| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "audio_utils_fifo" |
| |
| #include <errno.h> |
| #include <limits.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include <audio_utils/clock_nanosleep.h> |
| #include <audio_utils/fifo.h> |
| #include <audio_utils/futex.h> |
| #include <audio_utils/roundup.h> |
| #include <cutils/log.h> |
| #include <utils/Errors.h> |
| |
| audio_utils_fifo_base::audio_utils_fifo_base(uint32_t frameCount, |
| audio_utils_fifo_index& writerRear, audio_utils_fifo_index *throttleFront) |
| __attribute__((no_sanitize("integer"))) : |
| mFrameCount(frameCount), mFrameCountP2(roundup(frameCount)), |
| mFudgeFactor(mFrameCountP2 - mFrameCount), |
| // FIXME need an API to configure the sync types |
| mWriterRear(writerRear), mWriterRearSync(AUDIO_UTILS_FIFO_SYNC_SHARED), |
| mThrottleFront(throttleFront), mThrottleFrontSync(AUDIO_UTILS_FIFO_SYNC_SHARED), |
| mIsShutdown(false) |
| { |
| // actual upper bound on frameCount will depend on the frame size |
| LOG_ALWAYS_FATAL_IF(frameCount == 0 || frameCount > ((uint32_t) INT32_MAX)); |
| } |
| |
| audio_utils_fifo_base::~audio_utils_fifo_base() |
| { |
| } |
| |
| uint32_t audio_utils_fifo_base::sum(uint32_t index, uint32_t increment) const |
| __attribute__((no_sanitize("integer"))) |
| { |
| if (mFudgeFactor > 0) { |
| uint32_t mask = mFrameCountP2 - 1; |
| ALOG_ASSERT((index & mask) < mFrameCount); |
| ALOG_ASSERT(increment <= mFrameCountP2); |
| if ((index & mask) + increment >= mFrameCount) { |
| increment += mFudgeFactor; |
| } |
| index += increment; |
| ALOG_ASSERT((index & mask) < mFrameCount); |
| return index; |
| } else { |
| return index + increment; |
| } |
| } |
| |
| int32_t audio_utils_fifo_base::diff(uint32_t rear, uint32_t front, size_t *lost) const |
| __attribute__((no_sanitize("integer"))) |
| { |
| // TODO replace multiple returns by a single return point so this isn't needed |
| if (lost != NULL) { |
| *lost = 0; |
| } |
| if (mIsShutdown) { |
| return -EIO; |
| } |
| uint32_t diff = rear - front; |
| if (mFudgeFactor > 0) { |
| uint32_t mask = mFrameCountP2 - 1; |
| uint32_t rearOffset = rear & mask; |
| uint32_t frontOffset = front & mask; |
| if (rearOffset >= mFrameCount || frontOffset >= mFrameCount) { |
| ALOGE("%s frontOffset=%u rearOffset=%u mFrameCount=%u", |
| __func__, frontOffset, rearOffset, mFrameCount); |
| shutdown(); |
| return -EIO; |
| } |
| // genDiff is the difference between the generation count fields of rear and front, |
| // and is always a multiple of mFrameCountP2. |
| uint32_t genDiff = (rear & ~mask) - (front & ~mask); |
| // It's OK for writer to be one generation beyond reader, |
| // but reader has lost frames if writer is further than one generation beyond. |
| if (genDiff > mFrameCountP2) { |
| if (lost != NULL) { |
| // Calculate the number of lost frames as the raw difference, |
| // less the mFrameCount frames that are still valid and can be read on retry, |
| // less the wasted indices that don't count as true lost frames. |
| *lost = diff - mFrameCount - mFudgeFactor * (genDiff / mFrameCountP2); |
| } |
| return -EOVERFLOW; |
| } |
| // If writer is one generation beyond reader, skip over the wasted indices. |
| if (genDiff > 0) { |
| diff -= mFudgeFactor; |
| // Note is still possible for diff > mFrameCount. BCD 16 - BCD 1 shows the problem. |
| // genDiff is 16, fudge is 6, decimal diff is 15 = (22 - 1 - 6). |
| // So we need to check diff for overflow one more time. See "if" a few lines below. |
| } |
| } |
| // FIFO should not be overfull |
| if (diff > mFrameCount) { |
| if (lost != NULL) { |
| *lost = diff - mFrameCount; |
| } |
| return -EOVERFLOW; |
| } |
| return (int32_t) diff; |
| } |
| |
| void audio_utils_fifo_base::shutdown() const |
| { |
| ALOGE("%s", __func__); |
| mIsShutdown = true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| audio_utils_fifo::audio_utils_fifo(uint32_t frameCount, uint32_t frameSize, void *buffer, |
| audio_utils_fifo_index& writerRear, audio_utils_fifo_index *throttleFront) |
| __attribute__((no_sanitize("integer"))) : |
| audio_utils_fifo_base(frameCount, writerRear, throttleFront), |
| mFrameSize(frameSize), mBuffer(buffer) |
| { |
| // maximum value of frameCount * frameSize is INT32_MAX (2^31 - 1), not 2^31, because we need to |
| // be able to distinguish successful and error return values from read and write. |
| LOG_ALWAYS_FATAL_IF(frameCount == 0 || frameSize == 0 || buffer == NULL || |
| frameCount > ((uint32_t) INT32_MAX) / frameSize); |
| } |
| |
| audio_utils_fifo::audio_utils_fifo(uint32_t frameCount, uint32_t frameSize, void *buffer, |
| bool throttlesWriter) : |
| audio_utils_fifo(frameCount, frameSize, buffer, mSingleProcessSharedRear, |
| throttlesWriter ? &mSingleProcessSharedFront : NULL) |
| { |
| } |
| |
| audio_utils_fifo::~audio_utils_fifo() |
| { |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| audio_utils_fifo_provider::audio_utils_fifo_provider(audio_utils_fifo& fifo) : |
| mFifo(fifo), mObtained(0), mTotalReleased(0) |
| { |
| } |
| |
| audio_utils_fifo_provider::~audio_utils_fifo_provider() |
| { |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| audio_utils_fifo_writer::audio_utils_fifo_writer(audio_utils_fifo& fifo) : |
| audio_utils_fifo_provider(fifo), mLocalRear(0), |
| mArmLevel(fifo.mFrameCount), mTriggerLevel(0), |
| mIsArmed(true), // because initial fill level of zero is < mArmLevel |
| mEffectiveFrames(fifo.mFrameCount) |
| { |
| } |
| |
| audio_utils_fifo_writer::~audio_utils_fifo_writer() |
| { |
| } |
| |
| ssize_t audio_utils_fifo_writer::write(const void *buffer, size_t count, |
| const struct timespec *timeout) |
| __attribute__((no_sanitize("integer"))) |
| { |
| audio_utils_iovec iovec[2]; |
| ssize_t availToWrite = obtain(iovec, count, timeout); |
| if (availToWrite > 0) { |
| memcpy((char *) mFifo.mBuffer + iovec[0].mOffset * mFifo.mFrameSize, buffer, |
| iovec[0].mLength * mFifo.mFrameSize); |
| if (iovec[1].mLength > 0) { |
| memcpy((char *) mFifo.mBuffer + iovec[1].mOffset * mFifo.mFrameSize, |
| (char *) buffer + (iovec[0].mLength * mFifo.mFrameSize), |
| iovec[1].mLength * mFifo.mFrameSize); |
| } |
| release(availToWrite); |
| } |
| return availToWrite; |
| } |
| |
| // iovec == NULL is not part of the public API, but internally it means don't set mObtained |
| ssize_t audio_utils_fifo_writer::obtain(audio_utils_iovec iovec[2], size_t count, |
| const struct timespec *timeout) |
| __attribute__((no_sanitize("integer"))) |
| { |
| int err = 0; |
| size_t availToWrite; |
| if (mFifo.mThrottleFront != NULL) { |
| int retries = kRetries; |
| uint32_t front; |
| for (;;) { |
| front = mFifo.mThrottleFront->loadAcquire(); |
| // returns -EIO if mIsShutdown |
| int32_t filled = mFifo.diff(mLocalRear, front); |
| if (filled < 0) { |
| // on error, return an empty slice |
| err = filled; |
| availToWrite = 0; |
| break; |
| } |
| availToWrite = mEffectiveFrames > (uint32_t) filled ? |
| mEffectiveFrames - (uint32_t) filled : 0; |
| // TODO pull out "count == 0" |
| if (count == 0 || availToWrite > 0 || timeout == NULL || |
| (timeout->tv_sec == 0 && timeout->tv_nsec == 0)) { |
| break; |
| } |
| // TODO add comments |
| // TODO abstract out switch and replace by general sync object |
| // the high level code (synchronization, sleep, futex, iovec) should be completely |
| // separate from the low level code (indexes, available, masking). |
| int op = FUTEX_WAIT; |
| switch (mFifo.mThrottleFrontSync) { |
| case AUDIO_UTILS_FIFO_SYNC_SLEEP: |
| err = audio_utils_clock_nanosleep(CLOCK_MONOTONIC, 0 /*flags*/, timeout, |
| NULL /*remain*/); |
| if (err < 0) { |
| LOG_ALWAYS_FATAL_IF(errno != EINTR, "unexpected err=%d errno=%d", err, errno); |
| err = -errno; |
| } else { |
| err = -ETIMEDOUT; |
| } |
| break; |
| case AUDIO_UTILS_FIFO_SYNC_PRIVATE: |
| op = FUTEX_WAIT_PRIVATE; |
| // fall through |
| case AUDIO_UTILS_FIFO_SYNC_SHARED: |
| if (timeout->tv_sec == LONG_MAX) { |
| timeout = NULL; |
| } |
| err = mFifo.mThrottleFront->wait(op, front, timeout); |
| if (err < 0) { |
| switch (errno) { |
| case EWOULDBLOCK: |
| // Benign race condition with partner: mFifo.mThrottleFront->mIndex |
| // changed value between the earlier atomic_load_explicit() and sys_futex(). |
| // Try to load index again, but give up if we are unable to converge. |
| if (retries-- > 0) { |
| // bypass the "timeout = NULL;" below |
| continue; |
| } |
| // fall through |
| case EINTR: |
| case ETIMEDOUT: |
| err = -errno; |
| break; |
| default: |
| LOG_ALWAYS_FATAL("unexpected err=%d errno=%d", err, errno); |
| break; |
| } |
| } |
| break; |
| default: |
| LOG_ALWAYS_FATAL("mFifo.mThrottleFrontSync=%d", mFifo.mThrottleFrontSync); |
| break; |
| } |
| timeout = NULL; |
| } |
| } else { |
| if (mFifo.mIsShutdown) { |
| err = -EIO; |
| availToWrite = 0; |
| } else { |
| availToWrite = mEffectiveFrames; |
| } |
| } |
| if (availToWrite > count) { |
| availToWrite = count; |
| } |
| uint32_t rearOffset = mLocalRear & (mFifo.mFrameCountP2 - 1); |
| size_t part1 = mFifo.mFrameCount - rearOffset; |
| if (part1 > availToWrite) { |
| part1 = availToWrite; |
| } |
| size_t part2 = part1 > 0 ? availToWrite - part1 : 0; |
| // return slice |
| if (iovec != NULL) { |
| iovec[0].mOffset = rearOffset; |
| iovec[0].mLength = part1; |
| iovec[1].mOffset = 0; |
| iovec[1].mLength = part2; |
| mObtained = availToWrite; |
| } |
| return availToWrite > 0 ? availToWrite : err; |
| } |
| |
| void audio_utils_fifo_writer::release(size_t count) |
| __attribute__((no_sanitize("integer"))) |
| { |
| // no need to do an early check for mIsShutdown, because the extra code executed is harmless |
| if (count > 0) { |
| if (count > mObtained) { |
| ALOGE("%s(count=%zu) > mObtained=%u", __func__, count, mObtained); |
| mFifo.shutdown(); |
| return; |
| } |
| if (mFifo.mThrottleFront != NULL) { |
| uint32_t front = mFifo.mThrottleFront->loadAcquire(); |
| // returns -EIO if mIsShutdown |
| int32_t filled = mFifo.diff(mLocalRear, front); |
| mLocalRear = mFifo.sum(mLocalRear, count); |
| mFifo.mWriterRear.storeRelease(mLocalRear); |
| // TODO add comments |
| int op = FUTEX_WAKE; |
| switch (mFifo.mWriterRearSync) { |
| case AUDIO_UTILS_FIFO_SYNC_SLEEP: |
| break; |
| case AUDIO_UTILS_FIFO_SYNC_PRIVATE: |
| op = FUTEX_WAKE_PRIVATE; |
| // fall through |
| case AUDIO_UTILS_FIFO_SYNC_SHARED: |
| if (filled >= 0) { |
| if ((uint32_t) filled < mArmLevel) { |
| mIsArmed = true; |
| } |
| if (mIsArmed && filled + count > mTriggerLevel) { |
| int err = mFifo.mWriterRear.wake(op, INT32_MAX /*waiters*/); |
| // err is number of processes woken up |
| if (err < 0) { |
| LOG_ALWAYS_FATAL("%s: unexpected err=%d errno=%d", |
| __func__, err, errno); |
| } |
| mIsArmed = false; |
| } |
| } |
| break; |
| default: |
| LOG_ALWAYS_FATAL("mFifo.mWriterRearSync=%d", mFifo.mWriterRearSync); |
| break; |
| } |
| } else { |
| mLocalRear = mFifo.sum(mLocalRear, count); |
| mFifo.mWriterRear.storeRelease(mLocalRear); |
| } |
| mObtained -= count; |
| mTotalReleased += count; |
| } |
| } |
| |
| ssize_t audio_utils_fifo_writer::available() |
| { |
| // iovec == NULL is not part of the public API, but internally it means don't set mObtained |
| return obtain(NULL /*iovec*/, SIZE_MAX /*count*/, NULL /*timeout*/); |
| } |
| |
| void audio_utils_fifo_writer::resize(uint32_t frameCount) |
| { |
| // cap to range [0, mFifo.mFrameCount] |
| if (frameCount > mFifo.mFrameCount) { |
| frameCount = mFifo.mFrameCount; |
| } |
| // if we reduce the effective frame count, update hysteresis points to be within the new range |
| if (frameCount < mEffectiveFrames) { |
| if (mArmLevel > frameCount) { |
| mArmLevel = frameCount; |
| } |
| if (mTriggerLevel > frameCount) { |
| mTriggerLevel = frameCount; |
| } |
| } |
| mEffectiveFrames = frameCount; |
| } |
| |
| uint32_t audio_utils_fifo_writer::size() const |
| { |
| return mEffectiveFrames; |
| } |
| |
| void audio_utils_fifo_writer::setHysteresis(uint32_t lowLevelArm, uint32_t highLevelTrigger) |
| { |
| // cap to range [0, mEffectiveFrames] |
| if (lowLevelArm > mEffectiveFrames) { |
| lowLevelArm = mEffectiveFrames; |
| } |
| if (highLevelTrigger > mEffectiveFrames) { |
| highLevelTrigger = mEffectiveFrames; |
| } |
| // TODO this is overly conservative; it would be better to arm based on actual fill level |
| if (lowLevelArm > mArmLevel) { |
| mIsArmed = true; |
| } |
| mArmLevel = lowLevelArm; |
| mTriggerLevel = highLevelTrigger; |
| } |
| |
| void audio_utils_fifo_writer::getHysteresis(uint32_t *armLevel, uint32_t *triggerLevel) const |
| { |
| *armLevel = mArmLevel; |
| *triggerLevel = mTriggerLevel; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| audio_utils_fifo_reader::audio_utils_fifo_reader(audio_utils_fifo& fifo, bool throttlesWriter) : |
| audio_utils_fifo_provider(fifo), |
| |
| // If we throttle the writer, then initialize our front index to zero so that we see all data |
| // currently in the buffer. |
| // Otherwise, ignore everything currently in the buffer by initializing our front index to the |
| // current value of writer's rear. This avoids an immediate -EOVERFLOW (overrun) in the case |
| // where reader starts out more than one buffer behind writer. The initial catch-up does not |
| // contribute towards the totalLost, totalFlushed, or totalReleased counters. |
| mLocalFront(throttlesWriter ? 0 : mFifo.mWriterRear.loadConsume()), |
| |
| mThrottleFront(throttlesWriter ? mFifo.mThrottleFront : NULL), |
| mArmLevel(-1), mTriggerLevel(mFifo.mFrameCount), |
| mIsArmed(true), // because initial fill level of zero is > mArmLevel |
| mTotalLost(0), mTotalFlushed(0) |
| { |
| } |
| |
| audio_utils_fifo_reader::~audio_utils_fifo_reader() |
| { |
| // TODO Need a way to pass throttle capability to the another reader, should one reader exit. |
| } |
| |
| ssize_t audio_utils_fifo_reader::read(void *buffer, size_t count, const struct timespec *timeout, |
| size_t *lost) |
| __attribute__((no_sanitize("integer"))) |
| { |
| audio_utils_iovec iovec[2]; |
| ssize_t availToRead = obtain(iovec, count, timeout, lost); |
| if (availToRead > 0) { |
| memcpy(buffer, (char *) mFifo.mBuffer + iovec[0].mOffset * mFifo.mFrameSize, |
| iovec[0].mLength * mFifo.mFrameSize); |
| if (iovec[1].mLength > 0) { |
| memcpy((char *) buffer + (iovec[0].mLength * mFifo.mFrameSize), |
| (char *) mFifo.mBuffer + iovec[1].mOffset * mFifo.mFrameSize, |
| iovec[1].mLength * mFifo.mFrameSize); |
| } |
| release(availToRead); |
| } |
| return availToRead; |
| } |
| |
| ssize_t audio_utils_fifo_reader::obtain(audio_utils_iovec iovec[2], size_t count, |
| const struct timespec *timeout) |
| __attribute__((no_sanitize("integer"))) |
| { |
| return obtain(iovec, count, timeout, NULL /*lost*/); |
| } |
| |
| void audio_utils_fifo_reader::release(size_t count) |
| __attribute__((no_sanitize("integer"))) |
| { |
| // no need to do an early check for mIsShutdown, because the extra code executed is harmless |
| if (count > 0) { |
| if (count > mObtained) { |
| ALOGE("%s(count=%zu) > mObtained=%u", __func__, count, mObtained); |
| mFifo.shutdown(); |
| return; |
| } |
| if (mThrottleFront != NULL) { |
| uint32_t rear = mFifo.mWriterRear.loadAcquire(); |
| // returns -EIO if mIsShutdown |
| int32_t filled = mFifo.diff(rear, mLocalFront); |
| mLocalFront = mFifo.sum(mLocalFront, count); |
| mThrottleFront->storeRelease(mLocalFront); |
| // TODO add comments |
| int op = FUTEX_WAKE; |
| switch (mFifo.mThrottleFrontSync) { |
| case AUDIO_UTILS_FIFO_SYNC_SLEEP: |
| break; |
| case AUDIO_UTILS_FIFO_SYNC_PRIVATE: |
| op = FUTEX_WAKE_PRIVATE; |
| // fall through |
| case AUDIO_UTILS_FIFO_SYNC_SHARED: |
| if (filled >= 0) { |
| if (filled > mArmLevel) { |
| mIsArmed = true; |
| } |
| if (mIsArmed && filled - count < mTriggerLevel) { |
| int err = mThrottleFront->wake(op, 1 /*waiters*/); |
| // err is number of processes woken up |
| if (err < 0 || err > 1) { |
| LOG_ALWAYS_FATAL("%s: unexpected err=%d errno=%d", |
| __func__, err, errno); |
| } |
| mIsArmed = false; |
| } |
| } |
| break; |
| default: |
| LOG_ALWAYS_FATAL("mFifo.mThrottleFrontSync=%d", mFifo.mThrottleFrontSync); |
| break; |
| } |
| } else { |
| mLocalFront = mFifo.sum(mLocalFront, count); |
| } |
| mObtained -= count; |
| mTotalReleased += count; |
| } |
| } |
| |
| // iovec == NULL is not part of the public API, but internally it means don't set mObtained |
| ssize_t audio_utils_fifo_reader::obtain(audio_utils_iovec iovec[2], size_t count, |
| const struct timespec *timeout, size_t *lost) |
| __attribute__((no_sanitize("integer"))) |
| { |
| int err = 0; |
| int retries = kRetries; |
| uint32_t rear; |
| for (;;) { |
| rear = mFifo.mWriterRear.loadAcquire(); |
| // TODO pull out "count == 0" |
| if (count == 0 || rear != mLocalFront || timeout == NULL || |
| (timeout->tv_sec == 0 && timeout->tv_nsec == 0)) { |
| break; |
| } |
| // TODO add comments |
| int op = FUTEX_WAIT; |
| switch (mFifo.mWriterRearSync) { |
| case AUDIO_UTILS_FIFO_SYNC_SLEEP: |
| err = audio_utils_clock_nanosleep(CLOCK_MONOTONIC, 0 /*flags*/, timeout, |
| NULL /*remain*/); |
| if (err < 0) { |
| LOG_ALWAYS_FATAL_IF(errno != EINTR, "unexpected err=%d errno=%d", err, errno); |
| err = -errno; |
| } else { |
| err = -ETIMEDOUT; |
| } |
| break; |
| case AUDIO_UTILS_FIFO_SYNC_PRIVATE: |
| op = FUTEX_WAIT_PRIVATE; |
| // fall through |
| case AUDIO_UTILS_FIFO_SYNC_SHARED: |
| if (timeout->tv_sec == LONG_MAX) { |
| timeout = NULL; |
| } |
| err = mFifo.mWriterRear.wait(op, rear, timeout); |
| if (err < 0) { |
| switch (errno) { |
| case EWOULDBLOCK: |
| // Benign race condition with partner: mFifo.mWriterRear->mIndex |
| // changed value between the earlier atomic_load_explicit() and sys_futex(). |
| // Try to load index again, but give up if we are unable to converge. |
| if (retries-- > 0) { |
| // bypass the "timeout = NULL;" below |
| continue; |
| } |
| // fall through |
| case EINTR: |
| case ETIMEDOUT: |
| err = -errno; |
| break; |
| default: |
| LOG_ALWAYS_FATAL("unexpected err=%d errno=%d", err, errno); |
| break; |
| } |
| } |
| break; |
| default: |
| LOG_ALWAYS_FATAL("mFifo.mWriterRearSync=%d", mFifo.mWriterRearSync); |
| break; |
| } |
| timeout = NULL; |
| } |
| size_t ourLost; |
| if (lost == NULL) { |
| lost = &ourLost; |
| } |
| // returns -EIO if mIsShutdown |
| int32_t filled = mFifo.diff(rear, mLocalFront, lost); |
| mTotalLost += *lost; |
| mTotalReleased += *lost; |
| if (filled < 0) { |
| if (filled == -EOVERFLOW) { |
| // catch up with writer, but preserve the still valid frames in buffer |
| mLocalFront = rear - mFifo.mFrameCountP2; |
| } |
| // on error, return an empty slice |
| err = filled; |
| filled = 0; |
| } |
| size_t availToRead = (size_t) filled; |
| if (availToRead > count) { |
| availToRead = count; |
| } |
| uint32_t frontOffset = mLocalFront & (mFifo.mFrameCountP2 - 1); |
| size_t part1 = mFifo.mFrameCount - frontOffset; |
| if (part1 > availToRead) { |
| part1 = availToRead; |
| } |
| size_t part2 = part1 > 0 ? availToRead - part1 : 0; |
| // return slice |
| if (iovec != NULL) { |
| iovec[0].mOffset = frontOffset; |
| iovec[0].mLength = part1; |
| iovec[1].mOffset = 0; |
| iovec[1].mLength = part2; |
| mObtained = availToRead; |
| } |
| return availToRead > 0 ? availToRead : err; |
| } |
| |
| ssize_t audio_utils_fifo_reader::available() |
| { |
| return available(NULL /*lost*/); |
| } |
| |
| ssize_t audio_utils_fifo_reader::available(size_t *lost) |
| { |
| // iovec == NULL is not part of the public API, but internally it means don't set mObtained |
| return obtain(NULL /*iovec*/, SIZE_MAX /*count*/, NULL /*timeout*/, lost); |
| } |
| |
| ssize_t audio_utils_fifo_reader::flush(size_t *lost) |
| { |
| audio_utils_iovec iovec[2]; |
| ssize_t ret = obtain(iovec, SIZE_MAX /*count*/, NULL /*timeout*/, lost); |
| if (ret > 0) { |
| size_t flushed = (size_t) ret; |
| release(flushed); |
| mTotalFlushed += flushed; |
| ret = flushed; |
| } |
| return ret; |
| } |
| |
| void audio_utils_fifo_reader::setHysteresis(int32_t armLevel, uint32_t triggerLevel) |
| { |
| // cap to range [0, mFifo.mFrameCount] |
| if (armLevel < 0) { |
| armLevel = -1; |
| } else if ((uint32_t) armLevel > mFifo.mFrameCount) { |
| armLevel = mFifo.mFrameCount; |
| } |
| if (triggerLevel > mFifo.mFrameCount) { |
| triggerLevel = mFifo.mFrameCount; |
| } |
| // TODO this is overly conservative; it would be better to arm based on actual fill level |
| if (armLevel < mArmLevel) { |
| mIsArmed = true; |
| } |
| mArmLevel = armLevel; |
| mTriggerLevel = triggerLevel; |
| } |
| |
| void audio_utils_fifo_reader::getHysteresis(int32_t *armLevel, uint32_t *triggerLevel) const |
| { |
| *armLevel = mArmLevel; |
| *triggerLevel = mTriggerLevel; |
| } |