1 /* 2 * Copyright (C) 2007 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 "AudioResampler" 18 //#define LOG_NDEBUG 0 19 20 #include <stdint.h> 21 #include <stdlib.h> 22 #include <sys/types.h> 23 #include <cutils/log.h> 24 #include <cutils/properties.h> 25 #include "AudioResampler.h" 26 #include "AudioResamplerSinc.h" 27 #include "AudioResamplerCubic.h" 28 29 namespace android { 30 31 #ifdef __ARM_ARCH_5E__ // optimized asm option 32 #define ASM_ARM_RESAMP1 // enable asm optimisation for ResamplerOrder1 33 #endif // __ARM_ARCH_5E__ 34 // ---------------------------------------------------------------------------- 35 36 class AudioResamplerOrder1 : public AudioResampler { 37 public: 38 AudioResamplerOrder1(int bitDepth, int inChannelCount, int32_t sampleRate) : 39 AudioResampler(bitDepth, inChannelCount, sampleRate), mX0L(0), mX0R(0) { 40 } 41 virtual void resample(int32_t* out, size_t outFrameCount, 42 AudioBufferProvider* provider); 43 private: 44 // number of bits used in interpolation multiply - 15 bits avoids overflow 45 static const int kNumInterpBits = 15; 46 47 // bits to shift the phase fraction down to avoid overflow 48 static const int kPreInterpShift = kNumPhaseBits - kNumInterpBits; 49 50 void init() {} 51 void resampleMono16(int32_t* out, size_t outFrameCount, 52 AudioBufferProvider* provider); 53 void resampleStereo16(int32_t* out, size_t outFrameCount, 54 AudioBufferProvider* provider); 55 #ifdef ASM_ARM_RESAMP1 // asm optimisation for ResamplerOrder1 56 void AsmMono16Loop(int16_t *in, int32_t* maxOutPt, int32_t maxInIdx, 57 size_t &outputIndex, int32_t* out, size_t &inputIndex, int32_t vl, int32_t vr, 58 uint32_t &phaseFraction, uint32_t phaseIncrement); 59 void AsmStereo16Loop(int16_t *in, int32_t* maxOutPt, int32_t maxInIdx, 60 size_t &outputIndex, int32_t* out, size_t &inputIndex, int32_t vl, int32_t vr, 61 uint32_t &phaseFraction, uint32_t phaseIncrement); 62 #endif // ASM_ARM_RESAMP1 63 64 static inline int32_t Interp(int32_t x0, int32_t x1, uint32_t f) { 65 return x0 + (((x1 - x0) * (int32_t)(f >> kPreInterpShift)) >> kNumInterpBits); 66 } 67 static inline void Advance(size_t* index, uint32_t* frac, uint32_t inc) { 68 *frac += inc; 69 *index += (size_t)(*frac >> kNumPhaseBits); 70 *frac &= kPhaseMask; 71 } 72 int mX0L; 73 int mX0R; 74 }; 75 76 // ---------------------------------------------------------------------------- 77 AudioResampler* AudioResampler::create(int bitDepth, int inChannelCount, 78 int32_t sampleRate, int quality) { 79 80 // can only create low quality resample now 81 AudioResampler* resampler; 82 83 char value[PROPERTY_VALUE_MAX]; 84 if (property_get("af.resampler.quality", value, 0)) { 85 quality = atoi(value); 86 LOGD("forcing AudioResampler quality to %d", quality); 87 } 88 89 if (quality == DEFAULT) 90 quality = LOW_QUALITY; 91 92 switch (quality) { 93 default: 94 case LOW_QUALITY: 95 LOGV("Create linear Resampler"); 96 resampler = new AudioResamplerOrder1(bitDepth, inChannelCount, sampleRate); 97 break; 98 case MED_QUALITY: 99 LOGV("Create cubic Resampler"); 100 resampler = new AudioResamplerCubic(bitDepth, inChannelCount, sampleRate); 101 break; 102 case HIGH_QUALITY: 103 LOGV("Create sinc Resampler"); 104 resampler = new AudioResamplerSinc(bitDepth, inChannelCount, sampleRate); 105 break; 106 } 107 108 // initialize resampler 109 resampler->init(); 110 return resampler; 111 } 112 113 AudioResampler::AudioResampler(int bitDepth, int inChannelCount, 114 int32_t sampleRate) : 115 mBitDepth(bitDepth), mChannelCount(inChannelCount), 116 mSampleRate(sampleRate), mInSampleRate(sampleRate), mInputIndex(0), 117 mPhaseFraction(0) { 118 // sanity check on format 119 if ((bitDepth != 16) ||(inChannelCount < 1) || (inChannelCount > 2)) { 120 LOGE("Unsupported sample format, %d bits, %d channels", bitDepth, 121 inChannelCount); 122 // LOG_ASSERT(0); 123 } 124 125 // initialize common members 126 mVolume[0] = mVolume[1] = 0; 127 mBuffer.frameCount = 0; 128 129 // save format for quick lookup 130 if (inChannelCount == 1) { 131 mFormat = MONO_16_BIT; 132 } else { 133 mFormat = STEREO_16_BIT; 134 } 135 } 136 137 AudioResampler::~AudioResampler() { 138 } 139 140 void AudioResampler::setSampleRate(int32_t inSampleRate) { 141 mInSampleRate = inSampleRate; 142 mPhaseIncrement = (uint32_t)((kPhaseMultiplier * inSampleRate) / mSampleRate); 143 } 144 145 void AudioResampler::setVolume(int16_t left, int16_t right) { 146 // TODO: Implement anti-zipper filter 147 mVolume[0] = left; 148 mVolume[1] = right; 149 } 150 151 // ---------------------------------------------------------------------------- 152 153 void AudioResamplerOrder1::resample(int32_t* out, size_t outFrameCount, 154 AudioBufferProvider* provider) { 155 156 // should never happen, but we overflow if it does 157 // LOG_ASSERT(outFrameCount < 32767); 158 159 // select the appropriate resampler 160 switch (mChannelCount) { 161 case 1: 162 resampleMono16(out, outFrameCount, provider); 163 break; 164 case 2: 165 resampleStereo16(out, outFrameCount, provider); 166 break; 167 } 168 } 169 170 void AudioResamplerOrder1::resampleStereo16(int32_t* out, size_t outFrameCount, 171 AudioBufferProvider* provider) { 172 173 int32_t vl = mVolume[0]; 174 int32_t vr = mVolume[1]; 175 176 size_t inputIndex = mInputIndex; 177 uint32_t phaseFraction = mPhaseFraction; 178 uint32_t phaseIncrement = mPhaseIncrement; 179 size_t outputIndex = 0; 180 size_t outputSampleCount = outFrameCount * 2; 181 size_t inFrameCount = (outFrameCount*mInSampleRate)/mSampleRate; 182 183 // LOGE("starting resample %d frames, inputIndex=%d, phaseFraction=%d, phaseIncrement=%d\n", 184 // outFrameCount, inputIndex, phaseFraction, phaseIncrement); 185 186 while (outputIndex < outputSampleCount) { 187 188 // buffer is empty, fetch a new one 189 while (mBuffer.frameCount == 0) { 190 mBuffer.frameCount = inFrameCount; 191 provider->getNextBuffer(&mBuffer); 192 if (mBuffer.raw == NULL) { 193 goto resampleStereo16_exit; 194 } 195 196 // LOGE("New buffer fetched: %d frames\n", mBuffer.frameCount); 197 if (mBuffer.frameCount > inputIndex) break; 198 199 inputIndex -= mBuffer.frameCount; 200 mX0L = mBuffer.i16[mBuffer.frameCount*2-2]; 201 mX0R = mBuffer.i16[mBuffer.frameCount*2-1]; 202 provider->releaseBuffer(&mBuffer); 203 // mBuffer.frameCount == 0 now so we reload a new buffer 204 } 205 206 int16_t *in = mBuffer.i16; 207 208 // handle boundary case 209 while (inputIndex == 0) { 210 // LOGE("boundary case\n"); 211 out[outputIndex++] += vl * Interp(mX0L, in[0], phaseFraction); 212 out[outputIndex++] += vr * Interp(mX0R, in[1], phaseFraction); 213 Advance(&inputIndex, &phaseFraction, phaseIncrement); 214 if (outputIndex == outputSampleCount) 215 break; 216 } 217 218 // process input samples 219 // LOGE("general case\n"); 220 221 #ifdef ASM_ARM_RESAMP1 // asm optimisation for ResamplerOrder1 222 if (inputIndex + 2 < mBuffer.frameCount) { 223 int32_t* maxOutPt; 224 int32_t maxInIdx; 225 226 maxOutPt = out + (outputSampleCount - 2); // 2 because 2 frames per loop 227 maxInIdx = mBuffer.frameCount - 2; 228 AsmStereo16Loop(in, maxOutPt, maxInIdx, outputIndex, out, inputIndex, vl, vr, 229 phaseFraction, phaseIncrement); 230 } 231 #endif // ASM_ARM_RESAMP1 232 233 while (outputIndex < outputSampleCount && inputIndex < mBuffer.frameCount) { 234 out[outputIndex++] += vl * Interp(in[inputIndex*2-2], 235 in[inputIndex*2], phaseFraction); 236 out[outputIndex++] += vr * Interp(in[inputIndex*2-1], 237 in[inputIndex*2+1], phaseFraction); 238 Advance(&inputIndex, &phaseFraction, phaseIncrement); 239 } 240 241 // LOGE("loop done - outputIndex=%d, inputIndex=%d\n", outputIndex, inputIndex); 242 243 // if done with buffer, save samples 244 if (inputIndex >= mBuffer.frameCount) { 245 inputIndex -= mBuffer.frameCount; 246 247 // LOGE("buffer done, new input index %d", inputIndex); 248 249 mX0L = mBuffer.i16[mBuffer.frameCount*2-2]; 250 mX0R = mBuffer.i16[mBuffer.frameCount*2-1]; 251 provider->releaseBuffer(&mBuffer); 252 253 // verify that the releaseBuffer resets the buffer frameCount 254 // LOG_ASSERT(mBuffer.frameCount == 0); 255 } 256 } 257 258 // LOGE("output buffer full - outputIndex=%d, inputIndex=%d\n", outputIndex, inputIndex); 259 260 resampleStereo16_exit: 261 // save state 262 mInputIndex = inputIndex; 263 mPhaseFraction = phaseFraction; 264 } 265 266 void AudioResamplerOrder1::resampleMono16(int32_t* out, size_t outFrameCount, 267 AudioBufferProvider* provider) { 268 269 int32_t vl = mVolume[0]; 270 int32_t vr = mVolume[1]; 271 272 size_t inputIndex = mInputIndex; 273 uint32_t phaseFraction = mPhaseFraction; 274 uint32_t phaseIncrement = mPhaseIncrement; 275 size_t outputIndex = 0; 276 size_t outputSampleCount = outFrameCount * 2; 277 size_t inFrameCount = (outFrameCount*mInSampleRate)/mSampleRate; 278 279 // LOGE("starting resample %d frames, inputIndex=%d, phaseFraction=%d, phaseIncrement=%d\n", 280 // outFrameCount, inputIndex, phaseFraction, phaseIncrement); 281 while (outputIndex < outputSampleCount) { 282 // buffer is empty, fetch a new one 283 while (mBuffer.frameCount == 0) { 284 mBuffer.frameCount = inFrameCount; 285 provider->getNextBuffer(&mBuffer); 286 if (mBuffer.raw == NULL) { 287 mInputIndex = inputIndex; 288 mPhaseFraction = phaseFraction; 289 goto resampleMono16_exit; 290 } 291 // LOGE("New buffer fetched: %d frames\n", mBuffer.frameCount); 292 if (mBuffer.frameCount > inputIndex) break; 293 294 inputIndex -= mBuffer.frameCount; 295 mX0L = mBuffer.i16[mBuffer.frameCount-1]; 296 provider->releaseBuffer(&mBuffer); 297 // mBuffer.frameCount == 0 now so we reload a new buffer 298 } 299 int16_t *in = mBuffer.i16; 300 301 // handle boundary case 302 while (inputIndex == 0) { 303 // LOGE("boundary case\n"); 304 int32_t sample = Interp(mX0L, in[0], phaseFraction); 305 out[outputIndex++] += vl * sample; 306 out[outputIndex++] += vr * sample; 307 Advance(&inputIndex, &phaseFraction, phaseIncrement); 308 if (outputIndex == outputSampleCount) 309 break; 310 } 311 312 // process input samples 313 // LOGE("general case\n"); 314 315 #ifdef ASM_ARM_RESAMP1 // asm optimisation for ResamplerOrder1 316 if (inputIndex + 2 < mBuffer.frameCount) { 317 int32_t* maxOutPt; 318 int32_t maxInIdx; 319 320 maxOutPt = out + (outputSampleCount - 2); 321 maxInIdx = (int32_t)mBuffer.frameCount - 2; 322 AsmMono16Loop(in, maxOutPt, maxInIdx, outputIndex, out, inputIndex, vl, vr, 323 phaseFraction, phaseIncrement); 324 } 325 #endif // ASM_ARM_RESAMP1 326 327 while (outputIndex < outputSampleCount && inputIndex < mBuffer.frameCount) { 328 int32_t sample = Interp(in[inputIndex-1], in[inputIndex], 329 phaseFraction); 330 out[outputIndex++] += vl * sample; 331 out[outputIndex++] += vr * sample; 332 Advance(&inputIndex, &phaseFraction, phaseIncrement); 333 } 334 335 336 // LOGE("loop done - outputIndex=%d, inputIndex=%d\n", outputIndex, inputIndex); 337 338 // if done with buffer, save samples 339 if (inputIndex >= mBuffer.frameCount) { 340 inputIndex -= mBuffer.frameCount; 341 342 // LOGE("buffer done, new input index %d", inputIndex); 343 344 mX0L = mBuffer.i16[mBuffer.frameCount-1]; 345 provider->releaseBuffer(&mBuffer); 346 347 // verify that the releaseBuffer resets the buffer frameCount 348 // LOG_ASSERT(mBuffer.frameCount == 0); 349 } 350 } 351 352 // LOGE("output buffer full - outputIndex=%d, inputIndex=%d\n", outputIndex, inputIndex); 353 354 resampleMono16_exit: 355 // save state 356 mInputIndex = inputIndex; 357 mPhaseFraction = phaseFraction; 358 } 359 360 #ifdef ASM_ARM_RESAMP1 // asm optimisation for ResamplerOrder1 361 362 /******************************************************************* 363 * 364 * AsmMono16Loop 365 * asm optimized monotonic loop version; one loop is 2 frames 366 * Input: 367 * in : pointer on input samples 368 * maxOutPt : pointer on first not filled 369 * maxInIdx : index on first not used 370 * outputIndex : pointer on current output index 371 * out : pointer on output buffer 372 * inputIndex : pointer on current input index 373 * vl, vr : left and right gain 374 * phaseFraction : pointer on current phase fraction 375 * phaseIncrement 376 * Ouput: 377 * outputIndex : 378 * out : updated buffer 379 * inputIndex : index of next to use 380 * phaseFraction : phase fraction for next interpolation 381 * 382 *******************************************************************/ 383 void AudioResamplerOrder1::AsmMono16Loop(int16_t *in, int32_t* maxOutPt, int32_t maxInIdx, 384 size_t &outputIndex, int32_t* out, size_t &inputIndex, int32_t vl, int32_t vr, 385 uint32_t &phaseFraction, uint32_t phaseIncrement) 386 { 387 #define MO_PARAM5 "36" // offset of parameter 5 (outputIndex) 388 389 asm( 390 "stmfd sp!, {r4, r5, r6, r7, r8, r9, r10, r11, lr}\n" 391 // get parameters 392 " ldr r6, [sp, #" MO_PARAM5 " + 20]\n" // &phaseFraction 393 " ldr r6, [r6]\n" // phaseFraction 394 " ldr r7, [sp, #" MO_PARAM5 " + 8]\n" // &inputIndex 395 " ldr r7, [r7]\n" // inputIndex 396 " ldr r8, [sp, #" MO_PARAM5 " + 4]\n" // out 397 " ldr r0, [sp, #" MO_PARAM5 " + 0]\n" // &outputIndex 398 " ldr r0, [r0]\n" // outputIndex 399 " add r8, r0, asl #2\n" // curOut 400 " ldr r9, [sp, #" MO_PARAM5 " + 24]\n" // phaseIncrement 401 " ldr r10, [sp, #" MO_PARAM5 " + 12]\n" // vl 402 " ldr r11, [sp, #" MO_PARAM5 " + 16]\n" // vr 403 404 // r0 pin, x0, Samp 405 406 // r1 in 407 // r2 maxOutPt 408 // r3 maxInIdx 409 410 // r4 x1, i1, i3, Out1 411 // r5 out0 412 413 // r6 frac 414 // r7 inputIndex 415 // r8 curOut 416 417 // r9 inc 418 // r10 vl 419 // r11 vr 420 421 // r12 422 // r13 sp 423 // r14 424 425 // the following loop works on 2 frames 426 427 ".Y4L01:\n" 428 " cmp r8, r2\n" // curOut - maxCurOut 429 " bcs .Y4L02\n" 430 431 #define MO_ONE_FRAME \ 432 " add r0, r1, r7, asl #1\n" /* in + inputIndex */\ 433 " ldrsh r4, [r0]\n" /* in[inputIndex] */\ 434 " ldr r5, [r8]\n" /* out[outputIndex] */\ 435 " ldrsh r0, [r0, #-2]\n" /* in[inputIndex-1] */\ 436 " bic r6, r6, #0xC0000000\n" /* phaseFraction & ... */\ 437 " sub r4, r4, r0\n" /* in[inputIndex] - in[inputIndex-1] */\ 438 " mov r4, r4, lsl #2\n" /* <<2 */\ 439 " smulwt r4, r4, r6\n" /* (x1-x0)*.. */\ 440 " add r6, r6, r9\n" /* phaseFraction + phaseIncrement */\ 441 " add r0, r0, r4\n" /* x0 - (..) */\ 442 " mla r5, r0, r10, r5\n" /* vl*interp + out[] */\ 443 " ldr r4, [r8, #4]\n" /* out[outputIndex+1] */\ 444 " str r5, [r8], #4\n" /* out[outputIndex++] = ... */\ 445 " mla r4, r0, r11, r4\n" /* vr*interp + out[] */\ 446 " add r7, r7, r6, lsr #30\n" /* inputIndex + phaseFraction>>30 */\ 447 " str r4, [r8], #4\n" /* out[outputIndex++] = ... */ 448 449 MO_ONE_FRAME // frame 1 450 MO_ONE_FRAME // frame 2 451 452 " cmp r7, r3\n" // inputIndex - maxInIdx 453 " bcc .Y4L01\n" 454 ".Y4L02:\n" 455 456 " bic r6, r6, #0xC0000000\n" // phaseFraction & ... 457 // save modified values 458 " ldr r0, [sp, #" MO_PARAM5 " + 20]\n" // &phaseFraction 459 " str r6, [r0]\n" // phaseFraction 460 " ldr r0, [sp, #" MO_PARAM5 " + 8]\n" // &inputIndex 461 " str r7, [r0]\n" // inputIndex 462 " ldr r0, [sp, #" MO_PARAM5 " + 4]\n" // out 463 " sub r8, r0\n" // curOut - out 464 " asr r8, #2\n" // new outputIndex 465 " ldr r0, [sp, #" MO_PARAM5 " + 0]\n" // &outputIndex 466 " str r8, [r0]\n" // save outputIndex 467 468 " ldmfd sp!, {r4, r5, r6, r7, r8, r9, r10, r11, pc}\n" 469 ); 470 } 471 472 /******************************************************************* 473 * 474 * AsmStereo16Loop 475 * asm optimized stereo loop version; one loop is 2 frames 476 * Input: 477 * in : pointer on input samples 478 * maxOutPt : pointer on first not filled 479 * maxInIdx : index on first not used 480 * outputIndex : pointer on current output index 481 * out : pointer on output buffer 482 * inputIndex : pointer on current input index 483 * vl, vr : left and right gain 484 * phaseFraction : pointer on current phase fraction 485 * phaseIncrement 486 * Ouput: 487 * outputIndex : 488 * out : updated buffer 489 * inputIndex : index of next to use 490 * phaseFraction : phase fraction for next interpolation 491 * 492 *******************************************************************/ 493 void AudioResamplerOrder1::AsmStereo16Loop(int16_t *in, int32_t* maxOutPt, int32_t maxInIdx, 494 size_t &outputIndex, int32_t* out, size_t &inputIndex, int32_t vl, int32_t vr, 495 uint32_t &phaseFraction, uint32_t phaseIncrement) 496 { 497 #define ST_PARAM5 "40" // offset of parameter 5 (outputIndex) 498 asm( 499 "stmfd sp!, {r4, r5, r6, r7, r8, r9, r10, r11, r12, lr}\n" 500 // get parameters 501 " ldr r6, [sp, #" ST_PARAM5 " + 20]\n" // &phaseFraction 502 " ldr r6, [r6]\n" // phaseFraction 503 " ldr r7, [sp, #" ST_PARAM5 " + 8]\n" // &inputIndex 504 " ldr r7, [r7]\n" // inputIndex 505 " ldr r8, [sp, #" ST_PARAM5 " + 4]\n" // out 506 " ldr r0, [sp, #" ST_PARAM5 " + 0]\n" // &outputIndex 507 " ldr r0, [r0]\n" // outputIndex 508 " add r8, r0, asl #2\n" // curOut 509 " ldr r9, [sp, #" ST_PARAM5 " + 24]\n" // phaseIncrement 510 " ldr r10, [sp, #" ST_PARAM5 " + 12]\n" // vl 511 " ldr r11, [sp, #" ST_PARAM5 " + 16]\n" // vr 512 513 // r0 pin, x0, Samp 514 515 // r1 in 516 // r2 maxOutPt 517 // r3 maxInIdx 518 519 // r4 x1, i1, i3, out1 520 // r5 out0 521 522 // r6 frac 523 // r7 inputIndex 524 // r8 curOut 525 526 // r9 inc 527 // r10 vl 528 // r11 vr 529 530 // r12 temporary 531 // r13 sp 532 // r14 533 534 ".Y5L01:\n" 535 " cmp r8, r2\n" // curOut - maxCurOut 536 " bcs .Y5L02\n" 537 538 #define ST_ONE_FRAME \ 539 " bic r6, r6, #0xC0000000\n" /* phaseFraction & ... */\ 540 \ 541 " add r0, r1, r7, asl #2\n" /* in + 2*inputIndex */\ 542 \ 543 " ldrsh r4, [r0]\n" /* in[2*inputIndex] */\ 544 " ldr r5, [r8]\n" /* out[outputIndex] */\ 545 " ldrsh r12, [r0, #-4]\n" /* in[2*inputIndex-2] */\ 546 " sub r4, r4, r12\n" /* in[2*InputIndex] - in[2*InputIndex-2] */\ 547 " mov r4, r4, lsl #2\n" /* <<2 */\ 548 " smulwt r4, r4, r6\n" /* (x1-x0)*.. */\ 549 " add r12, r12, r4\n" /* x0 - (..) */\ 550 " mla r5, r12, r10, r5\n" /* vl*interp + out[] */\ 551 " ldr r4, [r8, #4]\n" /* out[outputIndex+1] */\ 552 " str r5, [r8], #4\n" /* out[outputIndex++] = ... */\ 553 \ 554 " ldrsh r12, [r0, #+2]\n" /* in[2*inputIndex+1] */\ 555 " ldrsh r0, [r0, #-2]\n" /* in[2*inputIndex-1] */\ 556 " sub r12, r12, r0\n" /* in[2*InputIndex] - in[2*InputIndex-2] */\ 557 " mov r12, r12, lsl #2\n" /* <<2 */\ 558 " smulwt r12, r12, r6\n" /* (x1-x0)*.. */\ 559 " add r12, r0, r12\n" /* x0 - (..) */\ 560 " mla r4, r12, r11, r4\n" /* vr*interp + out[] */\ 561 " str r4, [r8], #4\n" /* out[outputIndex++] = ... */\ 562 \ 563 " add r6, r6, r9\n" /* phaseFraction + phaseIncrement */\ 564 " add r7, r7, r6, lsr #30\n" /* inputIndex + phaseFraction>>30 */ 565 566 ST_ONE_FRAME // frame 1 567 ST_ONE_FRAME // frame 1 568 569 " cmp r7, r3\n" // inputIndex - maxInIdx 570 " bcc .Y5L01\n" 571 ".Y5L02:\n" 572 573 " bic r6, r6, #0xC0000000\n" // phaseFraction & ... 574 // save modified values 575 " ldr r0, [sp, #" ST_PARAM5 " + 20]\n" // &phaseFraction 576 " str r6, [r0]\n" // phaseFraction 577 " ldr r0, [sp, #" ST_PARAM5 " + 8]\n" // &inputIndex 578 " str r7, [r0]\n" // inputIndex 579 " ldr r0, [sp, #" ST_PARAM5 " + 4]\n" // out 580 " sub r8, r0\n" // curOut - out 581 " asr r8, #2\n" // new outputIndex 582 " ldr r0, [sp, #" ST_PARAM5 " + 0]\n" // &outputIndex 583 " str r8, [r0]\n" // save outputIndex 584 585 " ldmfd sp!, {r4, r5, r6, r7, r8, r9, r10, r11, r12, pc}\n" 586 ); 587 } 588 589 #endif // ASM_ARM_RESAMP1 590 591 592 // ---------------------------------------------------------------------------- 593 } 594 ; // namespace android 595 596
