AudioResamplerDyn.cpp revision 068561c8e84569d51df2adbbb53b56fdfd09c06b 
1/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "AudioResamplerDyn"
18//#define LOG_NDEBUG 0
19
20#include <malloc.h>
21#include <string.h>
22#include <stdlib.h>
23#include <dlfcn.h>
24#include <math.h>
25
26#include <cutils/compiler.h>
27#include <cutils/properties.h>
28#include <utils/Debug.h>
29#include <utils/Log.h>
30#include <audio_utils/primitives.h>
31
32#include "AudioResamplerFirOps.h" // USE_NEON, USE_SSE and USE_INLINE_ASSEMBLY defined here
33#include "AudioResamplerFirProcess.h"
34#include "AudioResamplerFirProcessNeon.h"
35#include "AudioResamplerFirProcessSSE.h"
36#include "AudioResamplerFirGen.h" // requires math.h
37#include "AudioResamplerDyn.h"
38
39//#define DEBUG_RESAMPLER
40
41namespace android {
42
43/*
44 * InBuffer is a type agnostic input buffer.
45 *
46 * Layout of the state buffer for halfNumCoefs=8.
47 *
48 * [rrrrrrppppppppnnnnnnnnrrrrrrrrrrrrrrrrrrr.... rrrrrrr]
49 *  S            I                                R
50 *
51 * S = mState
52 * I = mImpulse
53 * R = mRingFull
54 * p = past samples, convoluted with the (p)ositive side of sinc()
55 * n = future samples, convoluted with the (n)egative side of sinc()
56 * r = extra space for implementing the ring buffer
57 */
58
59template<typename TC, typename TI, typename TO>
60AudioResamplerDyn<TC, TI, TO>::InBuffer::InBuffer()
61    : mState(NULL), mImpulse(NULL), mRingFull(NULL), mStateCount(0)
62{
63}
64
65template<typename TC, typename TI, typename TO>
66AudioResamplerDyn<TC, TI, TO>::InBuffer::~InBuffer()
67{
68    init();
69}
70
71template<typename TC, typename TI, typename TO>
72void AudioResamplerDyn<TC, TI, TO>::InBuffer::init()
73{
74    free(mState);
75    mState = NULL;
76    mImpulse = NULL;
77    mRingFull = NULL;
78    mStateCount = 0;
79}
80
81// resizes the state buffer to accommodate the appropriate filter length
82template<typename TC, typename TI, typename TO>
83void AudioResamplerDyn<TC, TI, TO>::InBuffer::resize(int CHANNELS, int halfNumCoefs)
84{
85    // calculate desired state size
86    size_t stateCount = halfNumCoefs * CHANNELS * 2 * kStateSizeMultipleOfFilterLength;
87
88    // check if buffer needs resizing
89    if (mState
90            && stateCount == mStateCount
91            && mRingFull-mState == (ssize_t) (mStateCount-halfNumCoefs*CHANNELS)) {
92        return;
93    }
94
95    // create new buffer
96    TI* state = NULL;
97    (void)posix_memalign(reinterpret_cast<void**>(&state), 32, stateCount*sizeof(*state));
98    memset(state, 0, stateCount*sizeof(*state));
99
100    // attempt to preserve state
101    if (mState) {
102        TI* srcLo = mImpulse - halfNumCoefs*CHANNELS;
103        TI* srcHi = mImpulse + halfNumCoefs*CHANNELS;
104        TI* dst = state;
105
106        if (srcLo < mState) {
107            dst += mState-srcLo;
108            srcLo = mState;
109        }
110        if (srcHi > mState + mStateCount) {
111            srcHi = mState + mStateCount;
112        }
113        memcpy(dst, srcLo, (srcHi - srcLo) * sizeof(*srcLo));
114        free(mState);
115    }
116
117    // set class member vars
118    mState = state;
119    mStateCount = stateCount;
120    mImpulse = state + halfNumCoefs*CHANNELS; // actually one sample greater than needed
121    mRingFull = state + mStateCount - halfNumCoefs*CHANNELS;
122}
123
124// copy in the input data into the head (impulse+halfNumCoefs) of the buffer.
125template<typename TC, typename TI, typename TO>
126template<int CHANNELS>
127void AudioResamplerDyn<TC, TI, TO>::InBuffer::readAgain(TI*& impulse, const int halfNumCoefs,
128        const TI* const in, const size_t inputIndex)
129{
130    TI* head = impulse + halfNumCoefs*CHANNELS;
131    for (size_t i=0 ; i<CHANNELS ; i++) {
132        head[i] = in[inputIndex*CHANNELS + i];
133    }
134}
135
136// advance the impulse pointer, and load in data into the head (impulse+halfNumCoefs)
137template<typename TC, typename TI, typename TO>
138template<int CHANNELS>
139void AudioResamplerDyn<TC, TI, TO>::InBuffer::readAdvance(TI*& impulse, const int halfNumCoefs,
140        const TI* const in, const size_t inputIndex)
141{
142    impulse += CHANNELS;
143
144    if (CC_UNLIKELY(impulse >= mRingFull)) {
145        const size_t shiftDown = mRingFull - mState - halfNumCoefs*CHANNELS;
146        memcpy(mState, mState+shiftDown, halfNumCoefs*CHANNELS*2*sizeof(TI));
147        impulse -= shiftDown;
148    }
149    readAgain<CHANNELS>(impulse, halfNumCoefs, in, inputIndex);
150}
151
152template<typename TC, typename TI, typename TO>
153void AudioResamplerDyn<TC, TI, TO>::InBuffer::reset()
154{
155    // clear resampler state
156    if (mState != nullptr) {
157        memset(mState, 0, mStateCount * sizeof(TI));
158    }
159}
160
161template<typename TC, typename TI, typename TO>
162void AudioResamplerDyn<TC, TI, TO>::Constants::set(
163        int L, int halfNumCoefs, int inSampleRate, int outSampleRate)
164{
165    int bits = 0;
166    int lscale = inSampleRate/outSampleRate < 2 ? L - 1 :
167            static_cast<int>(static_cast<uint64_t>(L)*inSampleRate/outSampleRate);
168    for (int i=lscale; i; ++bits, i>>=1)
169        ;
170    mL = L;
171    mShift = kNumPhaseBits - bits;
172    mHalfNumCoefs = halfNumCoefs;
173}
174
175template<typename TC, typename TI, typename TO>
176AudioResamplerDyn<TC, TI, TO>::AudioResamplerDyn(
177        int inChannelCount, int32_t sampleRate, src_quality quality)
178    : AudioResampler(inChannelCount, sampleRate, quality),
179      mResampleFunc(0), mFilterSampleRate(0), mFilterQuality(DEFAULT_QUALITY),
180    mCoefBuffer(NULL)
181{
182    mVolumeSimd[0] = mVolumeSimd[1] = 0;
183    // The AudioResampler base class assumes we are always ready for 1:1 resampling.
184    // We reset mInSampleRate to 0, so setSampleRate() will calculate filters for
185    // setSampleRate() for 1:1. (May be removed if precalculated filters are used.)
186    mInSampleRate = 0;
187    mConstants.set(128, 8, mSampleRate, mSampleRate); // TODO: set better
188}
189
190template<typename TC, typename TI, typename TO>
191AudioResamplerDyn<TC, TI, TO>::~AudioResamplerDyn()
192{
193    free(mCoefBuffer);
194}
195
196template<typename TC, typename TI, typename TO>
197void AudioResamplerDyn<TC, TI, TO>::init()
198{
199    mFilterSampleRate = 0; // always trigger new filter generation
200    mInBuffer.init();
201}
202
203template<typename TC, typename TI, typename TO>
204void AudioResamplerDyn<TC, TI, TO>::setVolume(float left, float right)
205{
206    AudioResampler::setVolume(left, right);
207    if (is_same<TO, float>::value || is_same<TO, double>::value) {
208        mVolumeSimd[0] = static_cast<TO>(left);
209        mVolumeSimd[1] = static_cast<TO>(right);
210    } else {  // integer requires scaling to U4_28 (rounding down)
211        // integer volumes are clamped to 0 to UNITY_GAIN so there
212        // are no issues with signed overflow.
213        mVolumeSimd[0] = u4_28_from_float(clampFloatVol(left));
214        mVolumeSimd[1] = u4_28_from_float(clampFloatVol(right));
215    }
216}
217
218template<typename T> T max(T a, T b) {return a > b ? a : b;}
219
220template<typename T> T absdiff(T a, T b) {return a > b ? a - b : b - a;}
221
222template<typename TC, typename TI, typename TO>
223void AudioResamplerDyn<TC, TI, TO>::createKaiserFir(Constants &c,
224        double stopBandAtten, int inSampleRate, int outSampleRate, double tbwCheat)
225{
226    TC* buf = NULL;
227    static const double atten = 0.9998;   // to avoid ripple overflow
228    double fcr;
229    double tbw = firKaiserTbw(c.mHalfNumCoefs, stopBandAtten);
230
231    (void)posix_memalign(reinterpret_cast<void**>(&buf), 32, (c.mL+1)*c.mHalfNumCoefs*sizeof(TC));
232    if (inSampleRate < outSampleRate) { // upsample
233        fcr = max(0.5*tbwCheat - tbw/2, tbw/2);
234    } else { // downsample
235        fcr = max(0.5*tbwCheat*outSampleRate/inSampleRate - tbw/2, tbw/2);
236    }
237    // create and set filter
238    firKaiserGen(buf, c.mL, c.mHalfNumCoefs, stopBandAtten, fcr, atten);
239    c.mFirCoefs = buf;
240    if (mCoefBuffer) {
241        free(mCoefBuffer);
242    }
243    mCoefBuffer = buf;
244#ifdef DEBUG_RESAMPLER
245    // print basic filter stats
246    printf("L:%d  hnc:%d  stopBandAtten:%lf  fcr:%lf  atten:%lf  tbw:%lf\n",
247            c.mL, c.mHalfNumCoefs, stopBandAtten, fcr, atten, tbw);
248    // test the filter and report results
249    double fp = (fcr - tbw/2)/c.mL;
250    double fs = (fcr + tbw/2)/c.mL;
251    double passMin, passMax, passRipple;
252    double stopMax, stopRipple;
253    testFir(buf, c.mL, c.mHalfNumCoefs, fp, fs, /*passSteps*/ 1000, /*stopSteps*/ 100000,
254            passMin, passMax, passRipple, stopMax, stopRipple);
255    printf("passband(%lf, %lf): %.8lf %.8lf %.8lf\n", 0., fp, passMin, passMax, passRipple);
256    printf("stopband(%lf, %lf): %.8lf %.3lf\n", fs, 0.5, stopMax, stopRipple);
257#endif
258}
259
260// recursive gcd. Using objdump, it appears the tail recursion is converted to a while loop.
261static int gcd(int n, int m)
262{
263    if (m == 0) {
264        return n;
265    }
266    return gcd(m, n % m);
267}
268
269static bool isClose(int32_t newSampleRate, int32_t prevSampleRate,
270        int32_t filterSampleRate, int32_t outSampleRate)
271{
272
273    // different upsampling ratios do not need a filter change.
274    if (filterSampleRate != 0
275            && filterSampleRate < outSampleRate
276            && newSampleRate < outSampleRate)
277        return true;
278
279    // check design criteria again if downsampling is detected.
280    int pdiff = absdiff(newSampleRate, prevSampleRate);
281    int adiff = absdiff(newSampleRate, filterSampleRate);
282
283    // allow up to 6% relative change increments.
284    // allow up to 12% absolute change increments (from filter design)
285    return pdiff < prevSampleRate>>4 && adiff < filterSampleRate>>3;
286}
287
288template<typename TC, typename TI, typename TO>
289void AudioResamplerDyn<TC, TI, TO>::setSampleRate(int32_t inSampleRate)
290{
291    if (mInSampleRate == inSampleRate) {
292        return;
293    }
294    int32_t oldSampleRate = mInSampleRate;
295    uint32_t oldPhaseWrapLimit = mConstants.mL << mConstants.mShift;
296    bool useS32 = false;
297
298    mInSampleRate = inSampleRate;
299
300    // TODO: Add precalculated Equiripple filters
301
302    if (mFilterQuality != getQuality() ||
303            !isClose(inSampleRate, oldSampleRate, mFilterSampleRate, mSampleRate)) {
304        mFilterSampleRate = inSampleRate;
305        mFilterQuality = getQuality();
306
307        // Begin Kaiser Filter computation
308        //
309        // The quantization floor for S16 is about 96db - 10*log_10(#length) + 3dB.
310        // Keep the stop band attenuation no greater than 84-85dB for 32 length S16 filters
311        //
312        // For s32 we keep the stop band attenuation at the same as 16b resolution, about
313        // 96-98dB
314        //
315
316        double stopBandAtten;
317        double tbwCheat = 1.; // how much we "cheat" into aliasing
318        int halfLength;
319        if (mFilterQuality == DYN_HIGH_QUALITY) {
320            // 32b coefficients, 64 length
321            useS32 = true;
322            stopBandAtten = 98.;
323            if (inSampleRate >= mSampleRate * 4) {
324                halfLength = 48;
325            } else if (inSampleRate >= mSampleRate * 2) {
326                halfLength = 40;
327            } else {
328                halfLength = 32;
329            }
330        } else if (mFilterQuality == DYN_LOW_QUALITY) {
331            // 16b coefficients, 16-32 length
332            useS32 = false;
333            stopBandAtten = 80.;
334            if (inSampleRate >= mSampleRate * 4) {
335                halfLength = 24;
336            } else if (inSampleRate >= mSampleRate * 2) {
337                halfLength = 16;
338            } else {
339                halfLength = 8;
340            }
341            if (inSampleRate <= mSampleRate) {
342                tbwCheat = 1.05;
343            } else {
344                tbwCheat = 1.03;
345            }
346        } else { // DYN_MED_QUALITY
347            // 16b coefficients, 32-64 length
348            // note: > 64 length filters with 16b coefs can have quantization noise problems
349            useS32 = false;
350            stopBandAtten = 84.;
351            if (inSampleRate >= mSampleRate * 4) {
352                halfLength = 32;
353            } else if (inSampleRate >= mSampleRate * 2) {
354                halfLength = 24;
355            } else {
356                halfLength = 16;
357            }
358            if (inSampleRate <= mSampleRate) {
359                tbwCheat = 1.03;
360            } else {
361                tbwCheat = 1.01;
362            }
363        }
364
365        // determine the number of polyphases in the filterbank.
366        // for 16b, it is desirable to have 2^(16/2) = 256 phases.
367        // https://ccrma.stanford.edu/~jos/resample/Relation_Interpolation_Error_Quantization.html
368        //
369        // We are a bit more lax on this.
370
371        int phases = mSampleRate / gcd(mSampleRate, inSampleRate);
372
373        // TODO: Once dynamic sample rate change is an option, the code below
374        // should be modified to execute only when dynamic sample rate change is enabled.
375        //
376        // as above, #phases less than 63 is too few phases for accurate linear interpolation.
377        // we increase the phases to compensate, but more phases means more memory per
378        // filter and more time to compute the filter.
379        //
380        // if we know that the filter will be used for dynamic sample rate changes,
381        // that would allow us skip this part for fixed sample rate resamplers.
382        //
383        while (phases<63) {
384            phases *= 2; // this code only needed to support dynamic rate changes
385        }
386
387        if (phases>=256) {  // too many phases, always interpolate
388            phases = 127;
389        }
390
391        // create the filter
392        mConstants.set(phases, halfLength, inSampleRate, mSampleRate);
393        createKaiserFir(mConstants, stopBandAtten,
394                inSampleRate, mSampleRate, tbwCheat);
395    } // End Kaiser filter
396
397    // update phase and state based on the new filter.
398    const Constants& c(mConstants);
399    mInBuffer.resize(mChannelCount, c.mHalfNumCoefs);
400    const uint32_t phaseWrapLimit = c.mL << c.mShift;
401    // try to preserve as much of the phase fraction as possible for on-the-fly changes
402    mPhaseFraction = static_cast<unsigned long long>(mPhaseFraction)
403            * phaseWrapLimit / oldPhaseWrapLimit;
404    mPhaseFraction %= phaseWrapLimit; // should not do anything, but just in case.
405    mPhaseIncrement = static_cast<uint32_t>(static_cast<uint64_t>(phaseWrapLimit)
406            * inSampleRate / mSampleRate);
407
408    // determine which resampler to use
409    // check if locked phase (works only if mPhaseIncrement has no "fractional phase bits")
410    int locked = (mPhaseIncrement << (sizeof(mPhaseIncrement)*8 - c.mShift)) == 0;
411    if (locked) {
412        mPhaseFraction = mPhaseFraction >> c.mShift << c.mShift; // remove fractional phase
413    }
414
415    // stride is the minimum number of filter coefficients processed per loop iteration.
416    // We currently only allow a stride of 16 to match with SIMD processing.
417    // This means that the filter length must be a multiple of 16,
418    // or half the filter length (mHalfNumCoefs) must be a multiple of 8.
419    //
420    // Note: A stride of 2 is achieved with non-SIMD processing.
421    int stride = ((c.mHalfNumCoefs & 7) == 0) ? 16 : 2;
422    LOG_ALWAYS_FATAL_IF(stride < 16, "Resampler stride must be 16 or more");
423    LOG_ALWAYS_FATAL_IF(mChannelCount < 1 || mChannelCount > 8,
424            "Resampler channels(%d) must be between 1 to 8", mChannelCount);
425    // stride 16 (falls back to stride 2 for machines that do not support NEON)
426    if (locked) {
427        switch (mChannelCount) {
428        case 1:
429            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<1, true, 16>;
430            break;
431        case 2:
432            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<2, true, 16>;
433            break;
434        case 3:
435            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<3, true, 16>;
436            break;
437        case 4:
438            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<4, true, 16>;
439            break;
440        case 5:
441            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<5, true, 16>;
442            break;
443        case 6:
444            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<6, true, 16>;
445            break;
446        case 7:
447            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<7, true, 16>;
448            break;
449        case 8:
450            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<8, true, 16>;
451            break;
452        }
453    } else {
454        switch (mChannelCount) {
455        case 1:
456            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<1, false, 16>;
457            break;
458        case 2:
459            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<2, false, 16>;
460            break;
461        case 3:
462            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<3, false, 16>;
463            break;
464        case 4:
465            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<4, false, 16>;
466            break;
467        case 5:
468            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<5, false, 16>;
469            break;
470        case 6:
471            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<6, false, 16>;
472            break;
473        case 7:
474            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<7, false, 16>;
475            break;
476        case 8:
477            mResampleFunc = &AudioResamplerDyn<TC, TI, TO>::resample<8, false, 16>;
478            break;
479        }
480    }
481#ifdef DEBUG_RESAMPLER
482    printf("channels:%d  %s  stride:%d  %s  coef:%d  shift:%d\n",
483            mChannelCount, locked ? "locked" : "interpolated",
484            stride, useS32 ? "S32" : "S16", 2*c.mHalfNumCoefs, c.mShift);
485#endif
486}
487
488template<typename TC, typename TI, typename TO>
489size_t AudioResamplerDyn<TC, TI, TO>::resample(int32_t* out, size_t outFrameCount,
490            AudioBufferProvider* provider)
491{
492    return (this->*mResampleFunc)(reinterpret_cast<TO*>(out), outFrameCount, provider);
493}
494
495template<typename TC, typename TI, typename TO>
496template<int CHANNELS, bool LOCKED, int STRIDE>
497size_t AudioResamplerDyn<TC, TI, TO>::resample(TO* out, size_t outFrameCount,
498        AudioBufferProvider* provider)
499{
500    // TODO Mono -> Mono is not supported. OUTPUT_CHANNELS reflects minimum of stereo out.
501    const int OUTPUT_CHANNELS = (CHANNELS < 2) ? 2 : CHANNELS;
502    const Constants& c(mConstants);
503    const TC* const coefs = mConstants.mFirCoefs;
504    TI* impulse = mInBuffer.getImpulse();
505    size_t inputIndex = 0;
506    uint32_t phaseFraction = mPhaseFraction;
507    const uint32_t phaseIncrement = mPhaseIncrement;
508    size_t outputIndex = 0;
509    size_t outputSampleCount = outFrameCount * OUTPUT_CHANNELS;
510    const uint32_t phaseWrapLimit = c.mL << c.mShift;
511    size_t inFrameCount = (phaseIncrement * (uint64_t)outFrameCount + phaseFraction)
512            / phaseWrapLimit;
513    // sanity check that inFrameCount is in signed 32 bit integer range.
514    ALOG_ASSERT(0 <= inFrameCount && inFrameCount < (1U << 31));
515
516    //ALOGV("inFrameCount:%d  outFrameCount:%d"
517    //        "  phaseIncrement:%u  phaseFraction:%u  phaseWrapLimit:%u",
518    //        inFrameCount, outFrameCount, phaseIncrement, phaseFraction, phaseWrapLimit);
519
520    // NOTE: be very careful when modifying the code here. register
521    // pressure is very high and a small change might cause the compiler
522    // to generate far less efficient code.
523    // Always sanity check the result with objdump or test-resample.
524
525    // the following logic is a bit convoluted to keep the main processing loop
526    // as tight as possible with register allocation.
527    while (outputIndex < outputSampleCount) {
528        //ALOGV("LOOP: inFrameCount:%d  outputIndex:%d  outFrameCount:%d"
529        //        "  phaseFraction:%u  phaseWrapLimit:%u",
530        //        inFrameCount, outputIndex, outFrameCount, phaseFraction, phaseWrapLimit);
531
532        // check inputIndex overflow
533        ALOG_ASSERT(inputIndex <= mBuffer.frameCount, "inputIndex%zu > frameCount%zu",
534                inputIndex, mBuffer.frameCount);
535        // Buffer is empty, fetch a new one if necessary (inFrameCount > 0).
536        // We may not fetch a new buffer if the existing data is sufficient.
537        while (mBuffer.frameCount == 0 && inFrameCount > 0) {
538            mBuffer.frameCount = inFrameCount;
539            provider->getNextBuffer(&mBuffer);
540            if (mBuffer.raw == NULL) {
541                // We are either at the end of playback or in an underrun situation.
542                // Reset buffer to prevent pop noise at the next buffer.
543                mInBuffer.reset();
544                goto resample_exit;
545            }
546            inFrameCount -= mBuffer.frameCount;
547            if (phaseFraction >= phaseWrapLimit) { // read in data
548                mInBuffer.template readAdvance<CHANNELS>(
549                        impulse, c.mHalfNumCoefs,
550                        reinterpret_cast<TI*>(mBuffer.raw), inputIndex);
551                inputIndex++;
552                phaseFraction -= phaseWrapLimit;
553                while (phaseFraction >= phaseWrapLimit) {
554                    if (inputIndex >= mBuffer.frameCount) {
555                        inputIndex = 0;
556                        provider->releaseBuffer(&mBuffer);
557                        break;
558                    }
559                    mInBuffer.template readAdvance<CHANNELS>(
560                            impulse, c.mHalfNumCoefs,
561                            reinterpret_cast<TI*>(mBuffer.raw), inputIndex);
562                    inputIndex++;
563                    phaseFraction -= phaseWrapLimit;
564                }
565            }
566        }
567        const TI* const in = reinterpret_cast<const TI*>(mBuffer.raw);
568        const size_t frameCount = mBuffer.frameCount;
569        const int coefShift = c.mShift;
570        const int halfNumCoefs = c.mHalfNumCoefs;
571        const TO* const volumeSimd = mVolumeSimd;
572
573        // main processing loop
574        while (CC_LIKELY(outputIndex < outputSampleCount)) {
575            // caution: fir() is inlined and may be large.
576            // output will be loaded with the appropriate values
577            //
578            // from the input samples in impulse[-halfNumCoefs+1]... impulse[halfNumCoefs]
579            // from the polyphase filter of (phaseFraction / phaseWrapLimit) in coefs.
580            //
581            //ALOGV("LOOP2: inFrameCount:%d  outputIndex:%d  outFrameCount:%d"
582            //        "  phaseFraction:%u  phaseWrapLimit:%u",
583            //        inFrameCount, outputIndex, outFrameCount, phaseFraction, phaseWrapLimit);
584            ALOG_ASSERT(phaseFraction < phaseWrapLimit);
585            fir<CHANNELS, LOCKED, STRIDE>(
586                    &out[outputIndex],
587                    phaseFraction, phaseWrapLimit,
588                    coefShift, halfNumCoefs, coefs,
589                    impulse, volumeSimd);
590
591            outputIndex += OUTPUT_CHANNELS;
592
593            phaseFraction += phaseIncrement;
594            while (phaseFraction >= phaseWrapLimit) {
595                if (inputIndex >= frameCount) {
596                    goto done;  // need a new buffer
597                }
598                mInBuffer.template readAdvance<CHANNELS>(impulse, halfNumCoefs, in, inputIndex);
599                inputIndex++;
600                phaseFraction -= phaseWrapLimit;
601            }
602        }
603done:
604        // We arrive here when we're finished or when the input buffer runs out.
605        // Regardless we need to release the input buffer if we've acquired it.
606        if (inputIndex > 0) {  // we've acquired a buffer (alternatively could check frameCount)
607            ALOG_ASSERT(inputIndex == frameCount, "inputIndex(%zu) != frameCount(%zu)",
608                    inputIndex, frameCount);  // must have been fully read.
609            inputIndex = 0;
610            provider->releaseBuffer(&mBuffer);
611            ALOG_ASSERT(mBuffer.frameCount == 0);
612        }
613    }
614
615resample_exit:
616    // inputIndex must be zero in all three cases:
617    // (1) the buffer never was been acquired; (2) the buffer was
618    // released at "done:"; or (3) getNextBuffer() failed.
619    ALOG_ASSERT(inputIndex == 0, "Releasing: inputindex:%zu frameCount:%zu  phaseFraction:%u",
620            inputIndex, mBuffer.frameCount, phaseFraction);
621    ALOG_ASSERT(mBuffer.frameCount == 0); // there must be no frames in the buffer
622    mInBuffer.setImpulse(impulse);
623    mPhaseFraction = phaseFraction;
624    return outputIndex / OUTPUT_CHANNELS;
625}
626
627/* instantiate templates used by AudioResampler::create */
628template class AudioResamplerDyn<float, float, float>;
629template class AudioResamplerDyn<int16_t, int16_t, int32_t>;
630template class AudioResamplerDyn<int32_t, int16_t, int32_t>;
631
632// ----------------------------------------------------------------------------
633} // namespace android
634