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 41 namespace 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 59 template<typename TC, typename TI, typename TO> 60 AudioResamplerDyn<TC, TI, TO>::InBuffer::InBuffer() 61 : mState(NULL), mImpulse(NULL), mRingFull(NULL), mStateCount(0) 62 { 63 } 64 65 template<typename TC, typename TI, typename TO> 66 AudioResamplerDyn<TC, TI, TO>::InBuffer::~InBuffer() 67 { 68 init(); 69 } 70 71 template<typename TC, typename TI, typename TO> 72 void 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 82 template<typename TC, typename TI, typename TO> 83 void 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. 125 template<typename TC, typename TI, typename TO> 126 template<int CHANNELS> 127 void 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) 137 template<typename TC, typename TI, typename TO> 138 template<int CHANNELS> 139 void 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 152 template<typename TC, typename TI, typename TO> 153 void 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 161 template<typename TC, typename TI, typename TO> 162 void 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 175 template<typename TC, typename TI, typename TO> 176 AudioResamplerDyn<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 190 template<typename TC, typename TI, typename TO> 191 AudioResamplerDyn<TC, TI, TO>::~AudioResamplerDyn() 192 { 193 free(mCoefBuffer); 194 } 195 196 template<typename TC, typename TI, typename TO> 197 void AudioResamplerDyn<TC, TI, TO>::init() 198 { 199 mFilterSampleRate = 0; // always trigger new filter generation 200 mInBuffer.init(); 201 } 202 203 template<typename TC, typename TI, typename TO> 204 void 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 218 template<typename T> T max(T a, T b) {return a > b ? a : b;} 219 220 template<typename T> T absdiff(T a, T b) {return a > b ? a - b : b - a;} 221 222 template<typename TC, typename TI, typename TO> 223 void 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. 261 static int gcd(int n, int m) 262 { 263 if (m == 0) { 264 return n; 265 } 266 return gcd(m, n % m); 267 } 268 269 static 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 288 template<typename TC, typename TI, typename TO> 289 void 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 488 template<typename TC, typename TI, typename TO> 489 size_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 495 template<typename TC, typename TI, typename TO> 496 template<int CHANNELS, bool LOCKED, int STRIDE> 497 size_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 } 603 done: 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 615 resample_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 */ 628 template class AudioResamplerDyn<float, float, float>; 629 template class AudioResamplerDyn<int16_t, int16_t, int32_t>; 630 template class AudioResamplerDyn<int32_t, int16_t, int32_t>; 631 632 // ---------------------------------------------------------------------------- 633 } // namespace android 634
