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