MonoPipe::MonoPipe(size_t reqFrames, const NBAIO_Format& format, bool writeCanBlock) : NBAIO_Sink(format), mUpdateSeq(0), mReqFrames(reqFrames), mMaxFrames(roundup(reqFrames)), mBuffer(malloc(mMaxFrames * Format_frameSize(format))), mFront(0), mRear(0), mWriteTsValid(false), // mWriteTs mSetpoint((reqFrames * 11) / 16), mWriteCanBlock(writeCanBlock), mIsShutdown(false), // mTimestampShared mTimestampMutator(&mTimestampShared), mTimestampObserver(&mTimestampShared) { uint64_t N, D; mNextRdPTS = AudioBufferProvider::kInvalidPTS; mSamplesToLocalTime.a_zero = 0; mSamplesToLocalTime.b_zero = 0; mSamplesToLocalTime.a_to_b_numer = 0; mSamplesToLocalTime.a_to_b_denom = 0; D = Format_sampleRate(format); (void) pthread_once(&cacheOnceControl, cacheOnceInit); if (!cacheValid) { // log has already been done return; } N = cacheN; LinearTransform::reduce(&N, &D); static const uint64_t kSignedHiBitsMask = ~(0x7FFFFFFFull); static const uint64_t kUnsignedHiBitsMask = ~(0xFFFFFFFFull); if ((N & kSignedHiBitsMask) || (D & kUnsignedHiBitsMask)) { ALOGE("Cannot reduce sample rate to local clock frequency ratio to fit" " in a 32/32 bit rational. (max reduction is 0x%016" PRIx64 "/0x%016" PRIx64 "). getNextWriteTimestamp calls will be non-functional", N, D); return; } mSamplesToLocalTime.a_to_b_numer = static_cast<int32_t>(N); mSamplesToLocalTime.a_to_b_denom = static_cast<uint32_t>(D); }
MonoPipe::MonoPipe(size_t reqFrames, NBAIO_Format format, bool writeCanBlock) : NBAIO_Sink(format), mUpdateSeq(0), mReqFrames(reqFrames), mMaxFrames(roundup(reqFrames)), mBuffer(malloc(mMaxFrames * Format_frameSize(format))), mFront(0), mRear(0), mWriteTsValid(false), // mWriteTs mSetpoint((reqFrames * 11) / 16), mWriteCanBlock(writeCanBlock), mIsShutdown(false) { CCHelper tmpHelper; status_t res; uint64_t N, D; mNextRdPTS = AudioBufferProvider::kInvalidPTS; mSamplesToLocalTime.a_zero = 0; mSamplesToLocalTime.b_zero = 0; mSamplesToLocalTime.a_to_b_numer = 0; mSamplesToLocalTime.a_to_b_denom = 0; D = Format_sampleRate(format); if (OK != (res = tmpHelper.getLocalFreq(&N))) { ALOGE("Failed to fetch local time frequency when constructing a" " MonoPipe (res = %d). getNextWriteTimestamp calls will be" " non-functional", res); return; } LinearTransform::reduce(&N, &D); static const uint64_t kSignedHiBitsMask = ~(0x7FFFFFFFull); static const uint64_t kUnsignedHiBitsMask = ~(0xFFFFFFFFull); if ((N & kSignedHiBitsMask) || (D & kUnsignedHiBitsMask)) { ALOGE("Cannot reduce sample rate to local clock frequency ratio to fit" " in a 32/32 bit rational. (max reduction is 0x%016llx/0x%016llx" "). getNextWriteTimestamp calls will be non-functional", N, D); return; } mSamplesToLocalTime.a_to_b_numer = static_cast<int32_t>(N); mSamplesToLocalTime.a_to_b_denom = static_cast<uint32_t>(D); }
ssize_t MonoPipe::write(const void *buffer, size_t count) { if (CC_UNLIKELY(!mNegotiated)) { return NEGOTIATE; } size_t totalFramesWritten = 0; while (count > 0) { // can't return a negative value, as we already checked for !mNegotiated size_t avail = availableToWrite(); size_t written = avail; if (CC_LIKELY(written > count)) { written = count; } size_t rear = mRear & (mMaxFrames - 1); size_t part1 = mMaxFrames - rear; if (part1 > written) { part1 = written; } if (CC_LIKELY(part1 > 0)) { memcpy((char *) mBuffer + (rear << mBitShift), buffer, part1 << mBitShift); if (CC_UNLIKELY(rear + part1 == mMaxFrames)) { size_t part2 = written - part1; if (CC_LIKELY(part2 > 0)) { memcpy(mBuffer, (char *) buffer + (part1 << mBitShift), part2 << mBitShift); } } android_atomic_release_store(written + mRear, &mRear); totalFramesWritten += written; } if (!mWriteCanBlock || mIsShutdown) { break; } count -= written; buffer = (char *) buffer + (written << mBitShift); // Simulate blocking I/O by sleeping at different rates, depending on a throttle. // The throttle tries to keep the mean pipe depth near the setpoint, with a slight jitter. uint32_t ns; if (written > 0) { size_t filled = (mMaxFrames - avail) + written; // FIXME cache these values to avoid re-computation if (filled <= mSetpoint / 2) { // pipe is (nearly) empty, fill quickly ns = written * ( 500000000 / Format_sampleRate(mFormat)); } else if (filled <= (mSetpoint * 3) / 4) { // pipe is below setpoint, fill at slightly faster rate ns = written * ( 750000000 / Format_sampleRate(mFormat)); } else if (filled <= (mSetpoint * 5) / 4) { // pipe is at setpoint, fill at nominal rate ns = written * (1000000000 / Format_sampleRate(mFormat)); } else if (filled <= (mSetpoint * 3) / 2) { // pipe is above setpoint, fill at slightly slower rate ns = written * (1150000000 / Format_sampleRate(mFormat)); } else if (filled <= (mSetpoint * 7) / 4) { // pipe is overflowing, fill slowly ns = written * (1350000000 / Format_sampleRate(mFormat)); } else { // pipe is severely overflowing ns = written * (1750000000 / Format_sampleRate(mFormat)); } } else { ns = count * (1350000000 / Format_sampleRate(mFormat)); } if (ns > 999999999) { ns = 999999999; } struct timespec nowTs; bool nowTsValid = !clock_gettime(CLOCK_MONOTONIC, &nowTs); // deduct the elapsed time since previous write() completed if (nowTsValid && mWriteTsValid) { time_t sec = nowTs.tv_sec - mWriteTs.tv_sec; long nsec = nowTs.tv_nsec - mWriteTs.tv_nsec; ALOGE_IF(sec < 0 || (sec == 0 && nsec < 0), "clock_gettime(CLOCK_MONOTONIC) failed: was %ld.%09ld but now %ld.%09ld", mWriteTs.tv_sec, mWriteTs.tv_nsec, nowTs.tv_sec, nowTs.tv_nsec); if (nsec < 0) { --sec; nsec += 1000000000; } if (sec == 0) { if ((long) ns > nsec) { ns -= nsec; } else { ns = 0; } } } if (ns > 0) { const struct timespec req = {0, ns}; nanosleep(&req, NULL); } // record the time that this write() completed if (nowTsValid) { mWriteTs = nowTs; if ((mWriteTs.tv_nsec += ns) >= 1000000000) { mWriteTs.tv_nsec -= 1000000000; ++mWriteTs.tv_sec; } } mWriteTsValid = nowTsValid; } mFramesWritten += totalFramesWritten; return totalFramesWritten; }
void FastCapture::onStateChange() { const FastCaptureState * const current = (const FastCaptureState *) mCurrent; const FastCaptureState * const previous = (const FastCaptureState *) mPrevious; FastCaptureDumpState * const dumpState = (FastCaptureDumpState *) mDumpState; const size_t frameCount = current->mFrameCount; bool eitherChanged = false; // check for change in input HAL configuration NBAIO_Format previousFormat = mFormat; if (current->mInputSourceGen != mInputSourceGen) { mInputSource = current->mInputSource; mInputSourceGen = current->mInputSourceGen; if (mInputSource == NULL) { mFormat = Format_Invalid; mSampleRate = 0; } else { mFormat = mInputSource->format(); mSampleRate = Format_sampleRate(mFormat); unsigned channelCount = Format_channelCount(mFormat); ALOG_ASSERT(channelCount >= 1 && channelCount <= FCC_8); } dumpState->mSampleRate = mSampleRate; eitherChanged = true; } // check for change in pipe if (current->mPipeSinkGen != mPipeSinkGen) { mPipeSink = current->mPipeSink; mPipeSinkGen = current->mPipeSinkGen; eitherChanged = true; } // input source and pipe sink must be compatible if (eitherChanged && mInputSource != NULL && mPipeSink != NULL) { ALOG_ASSERT(Format_isEqual(mFormat, mPipeSink->format())); } if ((!Format_isEqual(mFormat, previousFormat)) || (frameCount != previous->mFrameCount)) { // FIXME to avoid priority inversion, don't free here free(mReadBuffer); mReadBuffer = NULL; if (frameCount > 0 && mSampleRate > 0) { // FIXME new may block for unbounded time at internal mutex of the heap // implementation; it would be better to have normal capture thread allocate for // us to avoid blocking here and to prevent possible priority inversion size_t bufferSize = frameCount * Format_frameSize(mFormat); (void)posix_memalign(&mReadBuffer, 32, bufferSize); memset(mReadBuffer, 0, bufferSize); // if posix_memalign fails, will segv here. mPeriodNs = (frameCount * 1000000000LL) / mSampleRate; // 1.00 mUnderrunNs = (frameCount * 1750000000LL) / mSampleRate; // 1.75 mOverrunNs = (frameCount * 500000000LL) / mSampleRate; // 0.50 mForceNs = (frameCount * 950000000LL) / mSampleRate; // 0.95 mWarmupNsMin = (frameCount * 750000000LL) / mSampleRate; // 0.75 mWarmupNsMax = (frameCount * 1250000000LL) / mSampleRate; // 1.25 } else { mPeriodNs = 0; mUnderrunNs = 0; mOverrunNs = 0; mForceNs = 0; mWarmupNsMin = 0; mWarmupNsMax = LONG_MAX; } mReadBufferState = -1; dumpState->mFrameCount = frameCount; } }