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