Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2015 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_NDEBUG 0 |
| 18 | #define LOG_TAG "audio_utils_fifo" |
| 19 | |
Glenn Kasten | 9052f3b | 2016-07-08 16:24:41 -0700 | [diff] [blame] | 20 | #include <errno.h> |
Glenn Kasten | 0ab1d86 | 2016-06-20 12:04:56 -0700 | [diff] [blame] | 21 | #include <limits.h> |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 22 | #include <stdlib.h> |
| 23 | #include <string.h> |
Glenn Kasten | 9052f3b | 2016-07-08 16:24:41 -0700 | [diff] [blame] | 24 | |
Glenn Kasten | be9f4d8 | 2016-12-01 08:30:21 -0800 | [diff] [blame] | 25 | #include <audio_utils/clock_nanosleep.h> |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 26 | #include <audio_utils/fifo.h> |
Glenn Kasten | be9f4d8 | 2016-12-01 08:30:21 -0800 | [diff] [blame] | 27 | #include <audio_utils/futex.h> |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 28 | #include <audio_utils/roundup.h> |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 29 | #include <cutils/log.h> |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 30 | #include <utils/Errors.h> |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 31 | |
Glenn Kasten | dc1ff1f | 2016-09-02 13:54:59 -0700 | [diff] [blame] | 32 | audio_utils_fifo_base::audio_utils_fifo_base(uint32_t frameCount, |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 33 | audio_utils_fifo_index& writerRear, audio_utils_fifo_index *throttleFront) |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 34 | __attribute__((no_sanitize("integer"))) : |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 35 | mFrameCount(frameCount), mFrameCountP2(roundup(frameCount)), |
Glenn Kasten | 09acf78 | 2016-06-17 10:28:05 -0700 | [diff] [blame] | 36 | mFudgeFactor(mFrameCountP2 - mFrameCount), |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 37 | // FIXME need an API to configure the sync types |
| 38 | mWriterRear(writerRear), mWriterRearSync(AUDIO_UTILS_FIFO_SYNC_SHARED), |
Glenn Kasten | 0b2947b | 2016-11-22 14:00:23 -0800 | [diff] [blame] | 39 | mThrottleFront(throttleFront), mThrottleFrontSync(AUDIO_UTILS_FIFO_SYNC_SHARED), |
| 40 | mIsShutdown(false) |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 41 | { |
Glenn Kasten | 09acf78 | 2016-06-17 10:28:05 -0700 | [diff] [blame] | 42 | // actual upper bound on frameCount will depend on the frame size |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 43 | LOG_ALWAYS_FATAL_IF(frameCount == 0 || frameCount > ((uint32_t) INT32_MAX)); |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 44 | } |
| 45 | |
Glenn Kasten | 09acf78 | 2016-06-17 10:28:05 -0700 | [diff] [blame] | 46 | audio_utils_fifo_base::~audio_utils_fifo_base() |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 47 | { |
| 48 | } |
| 49 | |
Glenn Kasten | 3f115ba | 2016-11-22 14:00:53 -0800 | [diff] [blame] | 50 | uint32_t audio_utils_fifo_base::sum(uint32_t index, uint32_t increment) const |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 51 | __attribute__((no_sanitize("integer"))) |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 52 | { |
Glenn Kasten | fc3d707 | 2017-03-06 14:58:33 -0800 | [diff] [blame] | 53 | if (mFudgeFactor > 0) { |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 54 | uint32_t mask = mFrameCountP2 - 1; |
| 55 | ALOG_ASSERT((index & mask) < mFrameCount); |
| 56 | ALOG_ASSERT(increment <= mFrameCountP2); |
| 57 | if ((index & mask) + increment >= mFrameCount) { |
| 58 | increment += mFudgeFactor; |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 59 | } |
| 60 | index += increment; |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 61 | ALOG_ASSERT((index & mask) < mFrameCount); |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 62 | return index; |
| 63 | } else { |
| 64 | return index + increment; |
| 65 | } |
| 66 | } |
| 67 | |
Glenn Kasten | 8c5518a | 2017-04-17 16:34:38 -0700 | [diff] [blame] | 68 | int32_t audio_utils_fifo_base::diff(uint32_t rear, uint32_t front, size_t *lost, bool flush) const |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 69 | __attribute__((no_sanitize("integer"))) |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 70 | { |
Glenn Kasten | 44001d4 | 2016-10-19 15:46:02 -0700 | [diff] [blame] | 71 | // TODO replace multiple returns by a single return point so this isn't needed |
| 72 | if (lost != NULL) { |
| 73 | *lost = 0; |
| 74 | } |
Glenn Kasten | 0b2947b | 2016-11-22 14:00:23 -0800 | [diff] [blame] | 75 | if (mIsShutdown) { |
| 76 | return -EIO; |
| 77 | } |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 78 | uint32_t diff = rear - front; |
Glenn Kasten | fc3d707 | 2017-03-06 14:58:33 -0800 | [diff] [blame] | 79 | if (mFudgeFactor > 0) { |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 80 | uint32_t mask = mFrameCountP2 - 1; |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 81 | uint32_t rearOffset = rear & mask; |
| 82 | uint32_t frontOffset = front & mask; |
| 83 | if (rearOffset >= mFrameCount || frontOffset >= mFrameCount) { |
Glenn Kasten | 0b2947b | 2016-11-22 14:00:23 -0800 | [diff] [blame] | 84 | ALOGE("%s frontOffset=%u rearOffset=%u mFrameCount=%u", |
| 85 | __func__, frontOffset, rearOffset, mFrameCount); |
| 86 | shutdown(); |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 87 | return -EIO; |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 88 | } |
Glenn Kasten | fc3d707 | 2017-03-06 14:58:33 -0800 | [diff] [blame] | 89 | // genDiff is the difference between the generation count fields of rear and front, |
| 90 | // and is always a multiple of mFrameCountP2. |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 91 | uint32_t genDiff = (rear & ~mask) - (front & ~mask); |
Glenn Kasten | fc3d707 | 2017-03-06 14:58:33 -0800 | [diff] [blame] | 92 | // It's OK for writer to be one generation beyond reader, |
| 93 | // but reader has lost frames if writer is further than one generation beyond. |
| 94 | if (genDiff > mFrameCountP2) { |
| 95 | if (lost != NULL) { |
| 96 | // Calculate the number of lost frames as the raw difference, |
| 97 | // less the mFrameCount frames that are still valid and can be read on retry, |
| 98 | // less the wasted indices that don't count as true lost frames. |
Glenn Kasten | 8c5518a | 2017-04-17 16:34:38 -0700 | [diff] [blame] | 99 | *lost = diff - (flush ? 0 : mFrameCount) - mFudgeFactor * (genDiff/mFrameCountP2); |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 100 | } |
Glenn Kasten | fc3d707 | 2017-03-06 14:58:33 -0800 | [diff] [blame] | 101 | return -EOVERFLOW; |
| 102 | } |
| 103 | // If writer is one generation beyond reader, skip over the wasted indices. |
| 104 | if (genDiff > 0) { |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 105 | diff -= mFudgeFactor; |
Glenn Kasten | fc3d707 | 2017-03-06 14:58:33 -0800 | [diff] [blame] | 106 | // Note is still possible for diff > mFrameCount. BCD 16 - BCD 1 shows the problem. |
| 107 | // genDiff is 16, fudge is 6, decimal diff is 15 = (22 - 1 - 6). |
| 108 | // So we need to check diff for overflow one more time. See "if" a few lines below. |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 109 | } |
| 110 | } |
| 111 | // FIFO should not be overfull |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 112 | if (diff > mFrameCount) { |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 113 | if (lost != NULL) { |
Glenn Kasten | 8c5518a | 2017-04-17 16:34:38 -0700 | [diff] [blame] | 114 | *lost = diff - (flush ? 0 : mFrameCount); |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 115 | } |
| 116 | return -EOVERFLOW; |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 117 | } |
| 118 | return (int32_t) diff; |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 119 | } |
| 120 | |
Glenn Kasten | 0b2947b | 2016-11-22 14:00:23 -0800 | [diff] [blame] | 121 | void audio_utils_fifo_base::shutdown() const |
| 122 | { |
| 123 | ALOGE("%s", __func__); |
| 124 | mIsShutdown = true; |
| 125 | } |
| 126 | |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 127 | //////////////////////////////////////////////////////////////////////////////// |
| 128 | |
Glenn Kasten | dc1ff1f | 2016-09-02 13:54:59 -0700 | [diff] [blame] | 129 | audio_utils_fifo::audio_utils_fifo(uint32_t frameCount, uint32_t frameSize, void *buffer, |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 130 | audio_utils_fifo_index& writerRear, audio_utils_fifo_index *throttleFront) |
Glenn Kasten | 09acf78 | 2016-06-17 10:28:05 -0700 | [diff] [blame] | 131 | __attribute__((no_sanitize("integer"))) : |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 132 | audio_utils_fifo_base(frameCount, writerRear, throttleFront), |
Glenn Kasten | dc1ff1f | 2016-09-02 13:54:59 -0700 | [diff] [blame] | 133 | mFrameSize(frameSize), mBuffer(buffer) |
Glenn Kasten | 09acf78 | 2016-06-17 10:28:05 -0700 | [diff] [blame] | 134 | { |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 135 | // maximum value of frameCount * frameSize is INT32_MAX (2^31 - 1), not 2^31, because we need to |
Glenn Kasten | 09acf78 | 2016-06-17 10:28:05 -0700 | [diff] [blame] | 136 | // be able to distinguish successful and error return values from read and write. |
Glenn Kasten | 0ab1d86 | 2016-06-20 12:04:56 -0700 | [diff] [blame] | 137 | LOG_ALWAYS_FATAL_IF(frameCount == 0 || frameSize == 0 || buffer == NULL || |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 138 | frameCount > ((uint32_t) INT32_MAX) / frameSize); |
Glenn Kasten | 09acf78 | 2016-06-17 10:28:05 -0700 | [diff] [blame] | 139 | } |
| 140 | |
Glenn Kasten | dc1ff1f | 2016-09-02 13:54:59 -0700 | [diff] [blame] | 141 | audio_utils_fifo::audio_utils_fifo(uint32_t frameCount, uint32_t frameSize, void *buffer, |
| 142 | bool throttlesWriter) : |
| 143 | audio_utils_fifo(frameCount, frameSize, buffer, mSingleProcessSharedRear, |
| 144 | throttlesWriter ? &mSingleProcessSharedFront : NULL) |
| 145 | { |
| 146 | } |
| 147 | |
Glenn Kasten | 09acf78 | 2016-06-17 10:28:05 -0700 | [diff] [blame] | 148 | audio_utils_fifo::~audio_utils_fifo() |
| 149 | { |
| 150 | } |
| 151 | |
| 152 | //////////////////////////////////////////////////////////////////////////////// |
| 153 | |
Glenn Kasten | 0f85039 | 2016-10-19 12:14:46 -0700 | [diff] [blame] | 154 | audio_utils_fifo_provider::audio_utils_fifo_provider(audio_utils_fifo& fifo) : |
| 155 | mFifo(fifo), mObtained(0), mTotalReleased(0) |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 156 | { |
| 157 | } |
| 158 | |
| 159 | audio_utils_fifo_provider::~audio_utils_fifo_provider() |
| 160 | { |
| 161 | } |
| 162 | |
| 163 | //////////////////////////////////////////////////////////////////////////////// |
| 164 | |
| 165 | audio_utils_fifo_writer::audio_utils_fifo_writer(audio_utils_fifo& fifo) : |
Glenn Kasten | 0f85039 | 2016-10-19 12:14:46 -0700 | [diff] [blame] | 166 | audio_utils_fifo_provider(fifo), mLocalRear(0), |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 167 | mArmLevel(fifo.mFrameCount), mTriggerLevel(0), |
| 168 | mIsArmed(true), // because initial fill level of zero is < mArmLevel |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 169 | mEffectiveFrames(fifo.mFrameCount) |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 170 | { |
| 171 | } |
| 172 | |
| 173 | audio_utils_fifo_writer::~audio_utils_fifo_writer() |
| 174 | { |
| 175 | } |
| 176 | |
Glenn Kasten | d9942f7 | 2016-10-16 14:51:15 -0700 | [diff] [blame] | 177 | ssize_t audio_utils_fifo_writer::write(const void *buffer, size_t count, |
| 178 | const struct timespec *timeout) |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 179 | __attribute__((no_sanitize("integer"))) |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 180 | { |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 181 | audio_utils_iovec iovec[2]; |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 182 | ssize_t availToWrite = obtain(iovec, count, timeout); |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 183 | if (availToWrite > 0) { |
Glenn Kasten | 169f3a2 | 2016-06-17 10:43:34 -0700 | [diff] [blame] | 184 | memcpy((char *) mFifo.mBuffer + iovec[0].mOffset * mFifo.mFrameSize, buffer, |
| 185 | iovec[0].mLength * mFifo.mFrameSize); |
| 186 | if (iovec[1].mLength > 0) { |
| 187 | memcpy((char *) mFifo.mBuffer + iovec[1].mOffset * mFifo.mFrameSize, |
| 188 | (char *) buffer + (iovec[0].mLength * mFifo.mFrameSize), |
| 189 | iovec[1].mLength * mFifo.mFrameSize); |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 190 | } |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 191 | release(availToWrite); |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 192 | } |
| 193 | return availToWrite; |
| 194 | } |
| 195 | |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 196 | // iovec == NULL is not part of the public API, but internally it means don't set mObtained |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 197 | ssize_t audio_utils_fifo_writer::obtain(audio_utils_iovec iovec[2], size_t count, |
Glenn Kasten | d9942f7 | 2016-10-16 14:51:15 -0700 | [diff] [blame] | 198 | const struct timespec *timeout) |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 199 | __attribute__((no_sanitize("integer"))) |
| 200 | { |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 201 | int err = 0; |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 202 | size_t availToWrite; |
| 203 | if (mFifo.mThrottleFront != NULL) { |
Glenn Kasten | f277a7c | 2016-10-14 08:51:20 -0700 | [diff] [blame] | 204 | int retries = kRetries; |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 205 | uint32_t front; |
| 206 | for (;;) { |
Glenn Kasten | 7cc8f54 | 2016-12-01 16:12:59 -0800 | [diff] [blame] | 207 | front = mFifo.mThrottleFront->loadAcquire(); |
Glenn Kasten | 0b2947b | 2016-11-22 14:00:23 -0800 | [diff] [blame] | 208 | // returns -EIO if mIsShutdown |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 209 | int32_t filled = mFifo.diff(mLocalRear, front); |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 210 | if (filled < 0) { |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 211 | // on error, return an empty slice |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 212 | err = filled; |
| 213 | availToWrite = 0; |
| 214 | break; |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 215 | } |
| 216 | availToWrite = mEffectiveFrames > (uint32_t) filled ? |
| 217 | mEffectiveFrames - (uint32_t) filled : 0; |
| 218 | // TODO pull out "count == 0" |
| 219 | if (count == 0 || availToWrite > 0 || timeout == NULL || |
| 220 | (timeout->tv_sec == 0 && timeout->tv_nsec == 0)) { |
| 221 | break; |
| 222 | } |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 223 | // TODO add comments |
| 224 | // TODO abstract out switch and replace by general sync object |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 225 | // the high level code (synchronization, sleep, futex, iovec) should be completely |
| 226 | // separate from the low level code (indexes, available, masking). |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 227 | int op = FUTEX_WAIT; |
| 228 | switch (mFifo.mThrottleFrontSync) { |
| 229 | case AUDIO_UTILS_FIFO_SYNC_SLEEP: |
Glenn Kasten | be9f4d8 | 2016-12-01 08:30:21 -0800 | [diff] [blame] | 230 | err = audio_utils_clock_nanosleep(CLOCK_MONOTONIC, 0 /*flags*/, timeout, |
| 231 | NULL /*remain*/); |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 232 | if (err < 0) { |
| 233 | LOG_ALWAYS_FATAL_IF(errno != EINTR, "unexpected err=%d errno=%d", err, errno); |
| 234 | err = -errno; |
| 235 | } else { |
| 236 | err = -ETIMEDOUT; |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 237 | } |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 238 | break; |
| 239 | case AUDIO_UTILS_FIFO_SYNC_PRIVATE: |
| 240 | op = FUTEX_WAIT_PRIVATE; |
| 241 | // fall through |
| 242 | case AUDIO_UTILS_FIFO_SYNC_SHARED: |
| 243 | if (timeout->tv_sec == LONG_MAX) { |
| 244 | timeout = NULL; |
| 245 | } |
Glenn Kasten | 7cc8f54 | 2016-12-01 16:12:59 -0800 | [diff] [blame] | 246 | err = mFifo.mThrottleFront->wait(op, front, timeout); |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 247 | if (err < 0) { |
| 248 | switch (errno) { |
Glenn Kasten | f277a7c | 2016-10-14 08:51:20 -0700 | [diff] [blame] | 249 | case EWOULDBLOCK: |
Glenn Kasten | 7cabff9 | 2016-10-19 11:13:55 -0700 | [diff] [blame] | 250 | // Benign race condition with partner: mFifo.mThrottleFront->mIndex |
| 251 | // changed value between the earlier atomic_load_explicit() and sys_futex(). |
| 252 | // Try to load index again, but give up if we are unable to converge. |
Glenn Kasten | f277a7c | 2016-10-14 08:51:20 -0700 | [diff] [blame] | 253 | if (retries-- > 0) { |
| 254 | // bypass the "timeout = NULL;" below |
| 255 | continue; |
| 256 | } |
| 257 | // fall through |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 258 | case EINTR: |
| 259 | case ETIMEDOUT: |
| 260 | err = -errno; |
| 261 | break; |
| 262 | default: |
| 263 | LOG_ALWAYS_FATAL("unexpected err=%d errno=%d", err, errno); |
| 264 | break; |
| 265 | } |
| 266 | } |
| 267 | break; |
| 268 | default: |
| 269 | LOG_ALWAYS_FATAL("mFifo.mThrottleFrontSync=%d", mFifo.mThrottleFrontSync); |
| 270 | break; |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 271 | } |
| 272 | timeout = NULL; |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 273 | } |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 274 | } else { |
Glenn Kasten | 0b2947b | 2016-11-22 14:00:23 -0800 | [diff] [blame] | 275 | if (mFifo.mIsShutdown) { |
| 276 | err = -EIO; |
| 277 | availToWrite = 0; |
| 278 | } else { |
| 279 | availToWrite = mEffectiveFrames; |
| 280 | } |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 281 | } |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 282 | if (availToWrite > count) { |
| 283 | availToWrite = count; |
| 284 | } |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 285 | uint32_t rearOffset = mLocalRear & (mFifo.mFrameCountP2 - 1); |
| 286 | size_t part1 = mFifo.mFrameCount - rearOffset; |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 287 | if (part1 > availToWrite) { |
| 288 | part1 = availToWrite; |
| 289 | } |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 290 | size_t part2 = part1 > 0 ? availToWrite - part1 : 0; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 291 | // return slice |
| 292 | if (iovec != NULL) { |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 293 | iovec[0].mOffset = rearOffset; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 294 | iovec[0].mLength = part1; |
| 295 | iovec[1].mOffset = 0; |
| 296 | iovec[1].mLength = part2; |
| 297 | mObtained = availToWrite; |
| 298 | } |
| 299 | return availToWrite > 0 ? availToWrite : err; |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 300 | } |
| 301 | |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 302 | void audio_utils_fifo_writer::release(size_t count) |
| 303 | __attribute__((no_sanitize("integer"))) |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 304 | { |
Glenn Kasten | 0b2947b | 2016-11-22 14:00:23 -0800 | [diff] [blame] | 305 | // no need to do an early check for mIsShutdown, because the extra code executed is harmless |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 306 | if (count > 0) { |
Glenn Kasten | 0b2947b | 2016-11-22 14:00:23 -0800 | [diff] [blame] | 307 | if (count > mObtained) { |
| 308 | ALOGE("%s(count=%zu) > mObtained=%u", __func__, count, mObtained); |
| 309 | mFifo.shutdown(); |
| 310 | return; |
| 311 | } |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 312 | if (mFifo.mThrottleFront != NULL) { |
Glenn Kasten | 7cc8f54 | 2016-12-01 16:12:59 -0800 | [diff] [blame] | 313 | uint32_t front = mFifo.mThrottleFront->loadAcquire(); |
Glenn Kasten | 0b2947b | 2016-11-22 14:00:23 -0800 | [diff] [blame] | 314 | // returns -EIO if mIsShutdown |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 315 | int32_t filled = mFifo.diff(mLocalRear, front); |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 316 | mLocalRear = mFifo.sum(mLocalRear, count); |
Glenn Kasten | 7cc8f54 | 2016-12-01 16:12:59 -0800 | [diff] [blame] | 317 | mFifo.mWriterRear.storeRelease(mLocalRear); |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 318 | // TODO add comments |
| 319 | int op = FUTEX_WAKE; |
| 320 | switch (mFifo.mWriterRearSync) { |
| 321 | case AUDIO_UTILS_FIFO_SYNC_SLEEP: |
| 322 | break; |
| 323 | case AUDIO_UTILS_FIFO_SYNC_PRIVATE: |
| 324 | op = FUTEX_WAKE_PRIVATE; |
| 325 | // fall through |
| 326 | case AUDIO_UTILS_FIFO_SYNC_SHARED: |
| 327 | if (filled >= 0) { |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 328 | if ((uint32_t) filled < mArmLevel) { |
| 329 | mIsArmed = true; |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 330 | } |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 331 | if (mIsArmed && filled + count > mTriggerLevel) { |
Glenn Kasten | 7cc8f54 | 2016-12-01 16:12:59 -0800 | [diff] [blame] | 332 | int err = mFifo.mWriterRear.wake(op, INT32_MAX /*waiters*/); |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 333 | // err is number of processes woken up |
| 334 | if (err < 0) { |
| 335 | LOG_ALWAYS_FATAL("%s: unexpected err=%d errno=%d", |
| 336 | __func__, err, errno); |
| 337 | } |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 338 | mIsArmed = false; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 339 | } |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 340 | } |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 341 | break; |
| 342 | default: |
| 343 | LOG_ALWAYS_FATAL("mFifo.mWriterRearSync=%d", mFifo.mWriterRearSync); |
| 344 | break; |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 345 | } |
| 346 | } else { |
| 347 | mLocalRear = mFifo.sum(mLocalRear, count); |
Glenn Kasten | 7cc8f54 | 2016-12-01 16:12:59 -0800 | [diff] [blame] | 348 | mFifo.mWriterRear.storeRelease(mLocalRear); |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 349 | } |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 350 | mObtained -= count; |
Glenn Kasten | 0f85039 | 2016-10-19 12:14:46 -0700 | [diff] [blame] | 351 | mTotalReleased += count; |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 352 | } |
| 353 | } |
| 354 | |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 355 | ssize_t audio_utils_fifo_writer::available() |
| 356 | { |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 357 | // iovec == NULL is not part of the public API, but internally it means don't set mObtained |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 358 | return obtain(NULL /*iovec*/, SIZE_MAX /*count*/, NULL /*timeout*/); |
| 359 | } |
| 360 | |
| 361 | void audio_utils_fifo_writer::resize(uint32_t frameCount) |
| 362 | { |
| 363 | // cap to range [0, mFifo.mFrameCount] |
| 364 | if (frameCount > mFifo.mFrameCount) { |
| 365 | frameCount = mFifo.mFrameCount; |
| 366 | } |
| 367 | // if we reduce the effective frame count, update hysteresis points to be within the new range |
| 368 | if (frameCount < mEffectiveFrames) { |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 369 | if (mArmLevel > frameCount) { |
| 370 | mArmLevel = frameCount; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 371 | } |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 372 | if (mTriggerLevel > frameCount) { |
| 373 | mTriggerLevel = frameCount; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 374 | } |
| 375 | } |
| 376 | mEffectiveFrames = frameCount; |
| 377 | } |
| 378 | |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 379 | uint32_t audio_utils_fifo_writer::size() const |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 380 | { |
| 381 | return mEffectiveFrames; |
| 382 | } |
| 383 | |
| 384 | void audio_utils_fifo_writer::setHysteresis(uint32_t lowLevelArm, uint32_t highLevelTrigger) |
| 385 | { |
| 386 | // cap to range [0, mEffectiveFrames] |
| 387 | if (lowLevelArm > mEffectiveFrames) { |
| 388 | lowLevelArm = mEffectiveFrames; |
| 389 | } |
| 390 | if (highLevelTrigger > mEffectiveFrames) { |
| 391 | highLevelTrigger = mEffectiveFrames; |
| 392 | } |
| 393 | // TODO this is overly conservative; it would be better to arm based on actual fill level |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 394 | if (lowLevelArm > mArmLevel) { |
| 395 | mIsArmed = true; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 396 | } |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 397 | mArmLevel = lowLevelArm; |
| 398 | mTriggerLevel = highLevelTrigger; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 399 | } |
| 400 | |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 401 | void audio_utils_fifo_writer::getHysteresis(uint32_t *armLevel, uint32_t *triggerLevel) const |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 402 | { |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 403 | *armLevel = mArmLevel; |
| 404 | *triggerLevel = mTriggerLevel; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 405 | } |
| 406 | |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 407 | //////////////////////////////////////////////////////////////////////////////// |
| 408 | |
Glenn Kasten | 8c5518a | 2017-04-17 16:34:38 -0700 | [diff] [blame] | 409 | audio_utils_fifo_reader::audio_utils_fifo_reader(audio_utils_fifo& fifo, bool throttlesWriter, |
| 410 | bool flush) : |
Glenn Kasten | 2f99531 | 2016-12-16 12:42:26 -0800 | [diff] [blame] | 411 | audio_utils_fifo_provider(fifo), |
| 412 | |
| 413 | // If we throttle the writer, then initialize our front index to zero so that we see all data |
| 414 | // currently in the buffer. |
| 415 | // Otherwise, ignore everything currently in the buffer by initializing our front index to the |
| 416 | // current value of writer's rear. This avoids an immediate -EOVERFLOW (overrun) in the case |
| 417 | // where reader starts out more than one buffer behind writer. The initial catch-up does not |
| 418 | // contribute towards the totalLost, totalFlushed, or totalReleased counters. |
| 419 | mLocalFront(throttlesWriter ? 0 : mFifo.mWriterRear.loadConsume()), |
| 420 | |
Glenn Kasten | dc1ff1f | 2016-09-02 13:54:59 -0700 | [diff] [blame] | 421 | mThrottleFront(throttlesWriter ? mFifo.mThrottleFront : NULL), |
Glenn Kasten | 8c5518a | 2017-04-17 16:34:38 -0700 | [diff] [blame] | 422 | mFlush(flush), |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 423 | mArmLevel(-1), mTriggerLevel(mFifo.mFrameCount), |
| 424 | mIsArmed(true), // because initial fill level of zero is > mArmLevel |
Glenn Kasten | 0f85039 | 2016-10-19 12:14:46 -0700 | [diff] [blame] | 425 | mTotalLost(0), mTotalFlushed(0) |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 426 | { |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 427 | } |
| 428 | |
| 429 | audio_utils_fifo_reader::~audio_utils_fifo_reader() |
| 430 | { |
Glenn Kasten | 0ab1d86 | 2016-06-20 12:04:56 -0700 | [diff] [blame] | 431 | // TODO Need a way to pass throttle capability to the another reader, should one reader exit. |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 432 | } |
| 433 | |
Glenn Kasten | d9942f7 | 2016-10-16 14:51:15 -0700 | [diff] [blame] | 434 | ssize_t audio_utils_fifo_reader::read(void *buffer, size_t count, const struct timespec *timeout, |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 435 | size_t *lost) |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 436 | __attribute__((no_sanitize("integer"))) |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 437 | { |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 438 | audio_utils_iovec iovec[2]; |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 439 | ssize_t availToRead = obtain(iovec, count, timeout, lost); |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 440 | if (availToRead > 0) { |
Glenn Kasten | 169f3a2 | 2016-06-17 10:43:34 -0700 | [diff] [blame] | 441 | memcpy(buffer, (char *) mFifo.mBuffer + iovec[0].mOffset * mFifo.mFrameSize, |
| 442 | iovec[0].mLength * mFifo.mFrameSize); |
| 443 | if (iovec[1].mLength > 0) { |
| 444 | memcpy((char *) buffer + (iovec[0].mLength * mFifo.mFrameSize), |
| 445 | (char *) mFifo.mBuffer + iovec[1].mOffset * mFifo.mFrameSize, |
| 446 | iovec[1].mLength * mFifo.mFrameSize); |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 447 | } |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 448 | release(availToRead); |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 449 | } |
| 450 | return availToRead; |
| 451 | } |
| 452 | |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 453 | ssize_t audio_utils_fifo_reader::obtain(audio_utils_iovec iovec[2], size_t count, |
Glenn Kasten | d9942f7 | 2016-10-16 14:51:15 -0700 | [diff] [blame] | 454 | const struct timespec *timeout) |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 455 | __attribute__((no_sanitize("integer"))) |
| 456 | { |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 457 | return obtain(iovec, count, timeout, NULL /*lost*/); |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 458 | } |
| 459 | |
| 460 | void audio_utils_fifo_reader::release(size_t count) |
| 461 | __attribute__((no_sanitize("integer"))) |
| 462 | { |
Glenn Kasten | 0b2947b | 2016-11-22 14:00:23 -0800 | [diff] [blame] | 463 | // no need to do an early check for mIsShutdown, because the extra code executed is harmless |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 464 | if (count > 0) { |
Glenn Kasten | 0b2947b | 2016-11-22 14:00:23 -0800 | [diff] [blame] | 465 | if (count > mObtained) { |
| 466 | ALOGE("%s(count=%zu) > mObtained=%u", __func__, count, mObtained); |
| 467 | mFifo.shutdown(); |
| 468 | return; |
| 469 | } |
Glenn Kasten | dc1ff1f | 2016-09-02 13:54:59 -0700 | [diff] [blame] | 470 | if (mThrottleFront != NULL) { |
Glenn Kasten | 7cc8f54 | 2016-12-01 16:12:59 -0800 | [diff] [blame] | 471 | uint32_t rear = mFifo.mWriterRear.loadAcquire(); |
Glenn Kasten | 0b2947b | 2016-11-22 14:00:23 -0800 | [diff] [blame] | 472 | // returns -EIO if mIsShutdown |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 473 | int32_t filled = mFifo.diff(rear, mLocalFront); |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 474 | mLocalFront = mFifo.sum(mLocalFront, count); |
Glenn Kasten | 7cc8f54 | 2016-12-01 16:12:59 -0800 | [diff] [blame] | 475 | mThrottleFront->storeRelease(mLocalFront); |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 476 | // TODO add comments |
| 477 | int op = FUTEX_WAKE; |
| 478 | switch (mFifo.mThrottleFrontSync) { |
| 479 | case AUDIO_UTILS_FIFO_SYNC_SLEEP: |
| 480 | break; |
| 481 | case AUDIO_UTILS_FIFO_SYNC_PRIVATE: |
| 482 | op = FUTEX_WAKE_PRIVATE; |
| 483 | // fall through |
| 484 | case AUDIO_UTILS_FIFO_SYNC_SHARED: |
| 485 | if (filled >= 0) { |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 486 | if (filled > mArmLevel) { |
| 487 | mIsArmed = true; |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 488 | } |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 489 | if (mIsArmed && filled - count < mTriggerLevel) { |
Glenn Kasten | 7cc8f54 | 2016-12-01 16:12:59 -0800 | [diff] [blame] | 490 | int err = mThrottleFront->wake(op, 1 /*waiters*/); |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 491 | // err is number of processes woken up |
| 492 | if (err < 0 || err > 1) { |
| 493 | LOG_ALWAYS_FATAL("%s: unexpected err=%d errno=%d", |
| 494 | __func__, err, errno); |
| 495 | } |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 496 | mIsArmed = false; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 497 | } |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 498 | } |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 499 | break; |
| 500 | default: |
| 501 | LOG_ALWAYS_FATAL("mFifo.mThrottleFrontSync=%d", mFifo.mThrottleFrontSync); |
| 502 | break; |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 503 | } |
| 504 | } else { |
| 505 | mLocalFront = mFifo.sum(mLocalFront, count); |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 506 | } |
| 507 | mObtained -= count; |
Glenn Kasten | 0f85039 | 2016-10-19 12:14:46 -0700 | [diff] [blame] | 508 | mTotalReleased += count; |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 509 | } |
| 510 | } |
| 511 | |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 512 | // iovec == NULL is not part of the public API, but internally it means don't set mObtained |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 513 | ssize_t audio_utils_fifo_reader::obtain(audio_utils_iovec iovec[2], size_t count, |
Glenn Kasten | d9942f7 | 2016-10-16 14:51:15 -0700 | [diff] [blame] | 514 | const struct timespec *timeout, size_t *lost) |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 515 | __attribute__((no_sanitize("integer"))) |
| 516 | { |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 517 | int err = 0; |
Glenn Kasten | f277a7c | 2016-10-14 08:51:20 -0700 | [diff] [blame] | 518 | int retries = kRetries; |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 519 | uint32_t rear; |
| 520 | for (;;) { |
Glenn Kasten | 7cc8f54 | 2016-12-01 16:12:59 -0800 | [diff] [blame] | 521 | rear = mFifo.mWriterRear.loadAcquire(); |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 522 | // TODO pull out "count == 0" |
| 523 | if (count == 0 || rear != mLocalFront || timeout == NULL || |
| 524 | (timeout->tv_sec == 0 && timeout->tv_nsec == 0)) { |
| 525 | break; |
| 526 | } |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 527 | // TODO add comments |
| 528 | int op = FUTEX_WAIT; |
| 529 | switch (mFifo.mWriterRearSync) { |
| 530 | case AUDIO_UTILS_FIFO_SYNC_SLEEP: |
Glenn Kasten | be9f4d8 | 2016-12-01 08:30:21 -0800 | [diff] [blame] | 531 | err = audio_utils_clock_nanosleep(CLOCK_MONOTONIC, 0 /*flags*/, timeout, |
| 532 | NULL /*remain*/); |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 533 | if (err < 0) { |
| 534 | LOG_ALWAYS_FATAL_IF(errno != EINTR, "unexpected err=%d errno=%d", err, errno); |
| 535 | err = -errno; |
| 536 | } else { |
| 537 | err = -ETIMEDOUT; |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 538 | } |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 539 | break; |
| 540 | case AUDIO_UTILS_FIFO_SYNC_PRIVATE: |
| 541 | op = FUTEX_WAIT_PRIVATE; |
| 542 | // fall through |
| 543 | case AUDIO_UTILS_FIFO_SYNC_SHARED: |
| 544 | if (timeout->tv_sec == LONG_MAX) { |
| 545 | timeout = NULL; |
| 546 | } |
Glenn Kasten | 7cc8f54 | 2016-12-01 16:12:59 -0800 | [diff] [blame] | 547 | err = mFifo.mWriterRear.wait(op, rear, timeout); |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 548 | if (err < 0) { |
| 549 | switch (errno) { |
Glenn Kasten | f277a7c | 2016-10-14 08:51:20 -0700 | [diff] [blame] | 550 | case EWOULDBLOCK: |
Glenn Kasten | 7cabff9 | 2016-10-19 11:13:55 -0700 | [diff] [blame] | 551 | // Benign race condition with partner: mFifo.mWriterRear->mIndex |
| 552 | // changed value between the earlier atomic_load_explicit() and sys_futex(). |
| 553 | // Try to load index again, but give up if we are unable to converge. |
Glenn Kasten | f277a7c | 2016-10-14 08:51:20 -0700 | [diff] [blame] | 554 | if (retries-- > 0) { |
| 555 | // bypass the "timeout = NULL;" below |
| 556 | continue; |
| 557 | } |
| 558 | // fall through |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 559 | case EINTR: |
| 560 | case ETIMEDOUT: |
| 561 | err = -errno; |
| 562 | break; |
| 563 | default: |
| 564 | LOG_ALWAYS_FATAL("unexpected err=%d errno=%d", err, errno); |
| 565 | break; |
| 566 | } |
| 567 | } |
| 568 | break; |
| 569 | default: |
| 570 | LOG_ALWAYS_FATAL("mFifo.mWriterRearSync=%d", mFifo.mWriterRearSync); |
| 571 | break; |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 572 | } |
| 573 | timeout = NULL; |
| 574 | } |
Glenn Kasten | 0f85039 | 2016-10-19 12:14:46 -0700 | [diff] [blame] | 575 | size_t ourLost; |
| 576 | if (lost == NULL) { |
| 577 | lost = &ourLost; |
| 578 | } |
Glenn Kasten | 0b2947b | 2016-11-22 14:00:23 -0800 | [diff] [blame] | 579 | // returns -EIO if mIsShutdown |
Glenn Kasten | 8c5518a | 2017-04-17 16:34:38 -0700 | [diff] [blame] | 580 | int32_t filled = mFifo.diff(rear, mLocalFront, lost, mFlush); |
Glenn Kasten | 0f85039 | 2016-10-19 12:14:46 -0700 | [diff] [blame] | 581 | mTotalLost += *lost; |
| 582 | mTotalReleased += *lost; |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 583 | if (filled < 0) { |
Glenn Kasten | 3ddacbb | 2016-06-20 14:41:03 -0700 | [diff] [blame] | 584 | if (filled == -EOVERFLOW) { |
Glenn Kasten | fc3d707 | 2017-03-06 14:58:33 -0800 | [diff] [blame] | 585 | // catch up with writer, but preserve the still valid frames in buffer |
Glenn Kasten | 8c5518a | 2017-04-17 16:34:38 -0700 | [diff] [blame] | 586 | mLocalFront = rear - (mFlush ? 0 : mFifo.mFrameCountP2 /*sic*/); |
Glenn Kasten | 6d7ad76 | 2016-06-15 17:05:54 -0700 | [diff] [blame] | 587 | } |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 588 | // on error, return an empty slice |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 589 | err = filled; |
| 590 | filled = 0; |
Glenn Kasten | 9b4fe47 | 2016-06-13 09:34:57 -0700 | [diff] [blame] | 591 | } |
| 592 | size_t availToRead = (size_t) filled; |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 593 | if (availToRead > count) { |
| 594 | availToRead = count; |
| 595 | } |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 596 | uint32_t frontOffset = mLocalFront & (mFifo.mFrameCountP2 - 1); |
| 597 | size_t part1 = mFifo.mFrameCount - frontOffset; |
Glenn Kasten | 9b4c805 | 2015-01-06 14:13:13 -0800 | [diff] [blame] | 598 | if (part1 > availToRead) { |
| 599 | part1 = availToRead; |
| 600 | } |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 601 | size_t part2 = part1 > 0 ? availToRead - part1 : 0; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 602 | // return slice |
| 603 | if (iovec != NULL) { |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 604 | iovec[0].mOffset = frontOffset; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 605 | iovec[0].mLength = part1; |
| 606 | iovec[1].mOffset = 0; |
| 607 | iovec[1].mLength = part2; |
| 608 | mObtained = availToRead; |
| 609 | } |
| 610 | return availToRead > 0 ? availToRead : err; |
| 611 | } |
| 612 | |
| 613 | ssize_t audio_utils_fifo_reader::available() |
| 614 | { |
| 615 | return available(NULL /*lost*/); |
| 616 | } |
| 617 | |
| 618 | ssize_t audio_utils_fifo_reader::available(size_t *lost) |
| 619 | { |
Glenn Kasten | 9ddeb2c | 2016-10-14 08:49:02 -0700 | [diff] [blame] | 620 | // iovec == NULL is not part of the public API, but internally it means don't set mObtained |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 621 | return obtain(NULL /*iovec*/, SIZE_MAX /*count*/, NULL /*timeout*/, lost); |
| 622 | } |
| 623 | |
Glenn Kasten | 0f85039 | 2016-10-19 12:14:46 -0700 | [diff] [blame] | 624 | ssize_t audio_utils_fifo_reader::flush(size_t *lost) |
| 625 | { |
| 626 | audio_utils_iovec iovec[2]; |
| 627 | ssize_t ret = obtain(iovec, SIZE_MAX /*count*/, NULL /*timeout*/, lost); |
| 628 | if (ret > 0) { |
| 629 | size_t flushed = (size_t) ret; |
| 630 | release(flushed); |
| 631 | mTotalFlushed += flushed; |
| 632 | ret = flushed; |
| 633 | } |
| 634 | return ret; |
| 635 | } |
| 636 | |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 637 | void audio_utils_fifo_reader::setHysteresis(int32_t armLevel, uint32_t triggerLevel) |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 638 | { |
| 639 | // cap to range [0, mFifo.mFrameCount] |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 640 | if (armLevel < 0) { |
| 641 | armLevel = -1; |
| 642 | } else if ((uint32_t) armLevel > mFifo.mFrameCount) { |
| 643 | armLevel = mFifo.mFrameCount; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 644 | } |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 645 | if (triggerLevel > mFifo.mFrameCount) { |
| 646 | triggerLevel = mFifo.mFrameCount; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 647 | } |
| 648 | // TODO this is overly conservative; it would be better to arm based on actual fill level |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 649 | if (armLevel < mArmLevel) { |
| 650 | mIsArmed = true; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 651 | } |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 652 | mArmLevel = armLevel; |
| 653 | mTriggerLevel = triggerLevel; |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 654 | } |
| 655 | |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 656 | void audio_utils_fifo_reader::getHysteresis(int32_t *armLevel, uint32_t *triggerLevel) const |
Glenn Kasten | c0924bc | 2016-10-02 13:00:19 -0700 | [diff] [blame] | 657 | { |
Glenn Kasten | b9652ab | 2016-11-18 13:34:01 -0800 | [diff] [blame] | 658 | *armLevel = mArmLevel; |
| 659 | *triggerLevel = mTriggerLevel; |
Glenn Kasten | 547a992 | 2016-06-15 13:07:31 -0700 | [diff] [blame] | 660 | } |