audio_utils/fifo.cpp

   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
  20 #include <errno.h>
  21 #include <limits.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include <audio_utils/clock_nanosleep.h>
  26 #include <audio_utils/fifo.h>
  27 #include <audio_utils/futex.h>
  28 #include <audio_utils/roundup.h>
  29 #include <cutils/log.h>
  30 #include <utils/Errors.h>
  31
  32 audio_utils_fifo_base::audio_utils_fifo_base(uint32_t frameCount,
  33         audio_utils_fifo_index& writerRear, audio_utils_fifo_index *throttleFront)
  34         __attribute__((no_sanitize("integer"))) :
  35     mFrameCount(frameCount), mFrameCountP2(roundup(frameCount)),
  36     mFudgeFactor(mFrameCountP2 - mFrameCount),
  37     // FIXME need an API to configure the sync types
  38     mWriterRear(writerRear), mWriterRearSync(AUDIO_UTILS_FIFO_SYNC_SHARED),
  39     mThrottleFront(throttleFront), mThrottleFrontSync(AUDIO_UTILS_FIFO_SYNC_SHARED),
  40     mIsShutdown(false)
  41 {
  42     // actual upper bound on frameCount will depend on the frame size
  43     LOG_ALWAYS_FATAL_IF(frameCount == 0 || frameCount > ((uint32_t) INT32_MAX));
  44 }
  45
  46 audio_utils_fifo_base::~audio_utils_fifo_base()
  47 {
  48 }
  49
  50 uint32_t audio_utils_fifo_base::sum(uint32_t index, uint32_t increment) const
  51         __attribute__((no_sanitize("integer")))
  52 {
  53     if (mFudgeFactor > 0) {
  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;
  59         }
  60         index += increment;
  61         ALOG_ASSERT((index & mask) < mFrameCount);
  62         return index;
  63     } else {
  64         return index + increment;
  65     }
  66 }
  67
  68 int32_t audio_utils_fifo_base::diff(uint32_t rear, uint32_t front, size_t *lost, bool flush) const
  69         __attribute__((no_sanitize("integer")))
  70 {
  71     // TODO replace multiple returns by a single return point so this isn't needed
  72     if (lost != NULL) {
  73         *lost = 0;
  74     }
  75     if (mIsShutdown) {
  76         return -EIO;
  77     }
  78     uint32_t diff = rear - front;
  79     if (mFudgeFactor > 0) {
  80         uint32_t mask = mFrameCountP2 - 1;
  81         uint32_t rearOffset = rear & mask;
  82         uint32_t frontOffset = front & mask;
  83         if (rearOffset >= mFrameCount || frontOffset >= mFrameCount) {
  84             ALOGE("%s frontOffset=%u rearOffset=%u mFrameCount=%u",
  85                     __func__, frontOffset, rearOffset, mFrameCount);
  86             shutdown();
  87             return -EIO;
  88         }
  89         // genDiff is the difference between the generation count fields of rear and front,
  90         // and is always a multiple of mFrameCountP2.
  91         uint32_t genDiff = (rear & ~mask) - (front & ~mask);
  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.
  99                 *lost = diff - (flush ? 0 : mFrameCount) - mFudgeFactor * (genDiff/mFrameCountP2);
 100             }
 101             return -EOVERFLOW;
 102         }
 103         // If writer is one generation beyond reader, skip over the wasted indices.
 104         if (genDiff > 0) {
 105             diff -= mFudgeFactor;
 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.
 109         }
 110     }
 111     // FIFO should not be overfull
 112     if (diff > mFrameCount) {
 113         if (lost != NULL) {
 114             *lost = diff - (flush ? 0 : mFrameCount);
 115         }
 116         return -EOVERFLOW;
 117     }
 118     return (int32_t) diff;
 119 }
 120
 121 void audio_utils_fifo_base::shutdown() const
 122 {
 123     ALOGE("%s", __func__);
 124     mIsShutdown = true;
 125 }
 126
 127 ////////////////////////////////////////////////////////////////////////////////
 128
 129 audio_utils_fifo::audio_utils_fifo(uint32_t frameCount, uint32_t frameSize, void *buffer,
 130         audio_utils_fifo_index& writerRear, audio_utils_fifo_index *throttleFront)
 131         __attribute__((no_sanitize("integer"))) :
 132     audio_utils_fifo_base(frameCount, writerRear, throttleFront),
 133     mFrameSize(frameSize), mBuffer(buffer)
 134 {
 135     // maximum value of frameCount * frameSize is INT32_MAX (2^31 - 1), not 2^31, because we need to
 136     // be able to distinguish successful and error return values from read and write.
 137     LOG_ALWAYS_FATAL_IF(frameCount == 0 || frameSize == 0 || buffer == NULL ||
 138             frameCount > ((uint32_t) INT32_MAX) / frameSize);
 139 }
 140
 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
 148 audio_utils_fifo::~audio_utils_fifo()
 149 {
 150 }
 151
 152 ////////////////////////////////////////////////////////////////////////////////
 153
 154 audio_utils_fifo_provider::audio_utils_fifo_provider(audio_utils_fifo& fifo) :
 155     mFifo(fifo), mObtained(0), mTotalReleased(0)
 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) :
 166     audio_utils_fifo_provider(fifo), mLocalRear(0),
 167     mArmLevel(fifo.mFrameCount), mTriggerLevel(0),
 168     mIsArmed(true), // because initial fill level of zero is < mArmLevel
 169     mEffectiveFrames(fifo.mFrameCount)
 170 {
 171 }
 172
 173 audio_utils_fifo_writer::~audio_utils_fifo_writer()
 174 {
 175 }
 176
 177 ssize_t audio_utils_fifo_writer::write(const void *buffer, size_t count,
 178         const struct timespec *timeout)
 179         __attribute__((no_sanitize("integer")))
 180 {
 181     audio_utils_iovec iovec[2];
 182     ssize_t availToWrite = obtain(iovec, count, timeout);
 183     if (availToWrite > 0) {
 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);
 190         }
 191         release(availToWrite);
 192     }
 193     return availToWrite;
 194 }
 195
 196 // iovec == NULL is not part of the public API, but internally it means don't set mObtained
 197 ssize_t audio_utils_fifo_writer::obtain(audio_utils_iovec iovec[2], size_t count,
 198         const struct timespec *timeout)
 199         __attribute__((no_sanitize("integer")))
 200 {
 201     int err = 0;
 202     size_t availToWrite;
 203     if (mFifo.mThrottleFront != NULL) {
 204         int retries = kRetries;
 205         uint32_t front;
 206         for (;;) {
 207             front = mFifo.mThrottleFront->loadAcquire();
 208             // returns -EIO if mIsShutdown
 209             int32_t filled = mFifo.diff(mLocalRear, front);
 210             if (filled < 0) {
 211                 // on error, return an empty slice
 212                 err = filled;
 213                 availToWrite = 0;
 214                 break;
 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             }
 223             // TODO add comments
 224             // TODO abstract out switch and replace by general sync object
 225             //      the high level code (synchronization, sleep, futex, iovec) should be completely
 226             //      separate from the low level code (indexes, available, masking).
 227             int op = FUTEX_WAIT;
 228             switch (mFifo.mThrottleFrontSync) {
 229             case AUDIO_UTILS_FIFO_SYNC_SLEEP:
 230                 err = audio_utils_clock_nanosleep(CLOCK_MONOTONIC, 0 /*flags*/, timeout,
 231                         NULL /*remain*/);
 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;
 237                 }
 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                 }
 246                 err = mFifo.mThrottleFront->wait(op, front, timeout);
 247                 if (err < 0) {
 248                     switch (errno) {
 249                     case EWOULDBLOCK:
 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.
 253                         if (retries-- > 0) {
 254                             // bypass the "timeout = NULL;" below
 255                             continue;
 256                         }
 257                         // fall through
 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;
 271             }
 272             timeout = NULL;
 273         }
 274     } else {
 275         if (mFifo.mIsShutdown) {
 276             err = -EIO;
 277             availToWrite = 0;
 278         } else {
 279             availToWrite = mEffectiveFrames;
 280         }
 281     }
 282     if (availToWrite > count) {
 283         availToWrite = count;
 284     }
 285     uint32_t rearOffset = mLocalRear & (mFifo.mFrameCountP2 - 1);
 286     size_t part1 = mFifo.mFrameCount - rearOffset;
 287     if (part1 > availToWrite) {
 288         part1 = availToWrite;
 289     }
 290     size_t part2 = part1 > 0 ? availToWrite - part1 : 0;
 291     // return slice
 292     if (iovec != NULL) {
 293         iovec[0].mOffset = rearOffset;
 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;
 300 }
 301
 302 void audio_utils_fifo_writer::release(size_t count)
 303         __attribute__((no_sanitize("integer")))
 304 {
 305     // no need to do an early check for mIsShutdown, because the extra code executed is harmless
 306     if (count > 0) {
 307         if (count > mObtained) {
 308             ALOGE("%s(count=%zu) > mObtained=%u", __func__, count, mObtained);
 309             mFifo.shutdown();
 310             return;
 311         }
 312         if (mFifo.mThrottleFront != NULL) {
 313             uint32_t front = mFifo.mThrottleFront->loadAcquire();
 314             // returns -EIO if mIsShutdown
 315             int32_t filled = mFifo.diff(mLocalRear, front);
 316             mLocalRear = mFifo.sum(mLocalRear, count);
 317             mFifo.mWriterRear.storeRelease(mLocalRear);
 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) {
 328                     if ((uint32_t) filled < mArmLevel) {
 329                         mIsArmed = true;
 330                     }
 331                     if (mIsArmed && filled + count > mTriggerLevel) {
 332                         int err = mFifo.mWriterRear.wake(op, INT32_MAX /*waiters*/);
 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                         }
 338                         mIsArmed = false;
 339                     }
 340                 }
 341                 break;
 342             default:
 343                 LOG_ALWAYS_FATAL("mFifo.mWriterRearSync=%d", mFifo.mWriterRearSync);
 344                 break;
 345             }
 346         } else {
 347             mLocalRear = mFifo.sum(mLocalRear, count);
 348             mFifo.mWriterRear.storeRelease(mLocalRear);
 349         }
 350         mObtained -= count;
 351         mTotalReleased += count;
 352     }
 353 }
 354
 355 ssize_t audio_utils_fifo_writer::available()
 356 {
 357     // iovec == NULL is not part of the public API, but internally it means don't set mObtained
 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) {
 369         if (mArmLevel > frameCount) {
 370             mArmLevel = frameCount;
 371         }
 372         if (mTriggerLevel > frameCount) {
 373             mTriggerLevel = frameCount;
 374         }
 375     }
 376     mEffectiveFrames = frameCount;
 377 }
 378
 379 uint32_t audio_utils_fifo_writer::size() const
 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
 394     if (lowLevelArm > mArmLevel) {
 395         mIsArmed = true;
 396     }
 397     mArmLevel = lowLevelArm;
 398     mTriggerLevel = highLevelTrigger;
 399 }
 400
 401 void audio_utils_fifo_writer::getHysteresis(uint32_t *armLevel, uint32_t *triggerLevel) const
 402 {
 403     *armLevel = mArmLevel;
 404     *triggerLevel = mTriggerLevel;
 405 }
 406
 407 ////////////////////////////////////////////////////////////////////////////////
 408
 409 audio_utils_fifo_reader::audio_utils_fifo_reader(audio_utils_fifo& fifo, bool throttlesWriter,
 410         bool flush) :
 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
 421     mThrottleFront(throttlesWriter ? mFifo.mThrottleFront : NULL),
 422     mFlush(flush),
 423     mArmLevel(-1), mTriggerLevel(mFifo.mFrameCount),
 424     mIsArmed(true), // because initial fill level of zero is > mArmLevel
 425     mTotalLost(0), mTotalFlushed(0)
 426 {
 427 }
 428
 429 audio_utils_fifo_reader::~audio_utils_fifo_reader()
 430 {
 431     // TODO Need a way to pass throttle capability to the another reader, should one reader exit.
 432 }
 433
 434 ssize_t audio_utils_fifo_reader::read(void *buffer, size_t count, const struct timespec *timeout,
 435         size_t *lost)
 436         __attribute__((no_sanitize("integer")))
 437 {
 438     audio_utils_iovec iovec[2];
 439     ssize_t availToRead = obtain(iovec, count, timeout, lost);
 440     if (availToRead > 0) {
 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);
 447         }
 448         release(availToRead);
 449     }
 450     return availToRead;
 451 }
 452
 453 ssize_t audio_utils_fifo_reader::obtain(audio_utils_iovec iovec[2], size_t count,
 454         const struct timespec *timeout)
 455         __attribute__((no_sanitize("integer")))
 456 {
 457     return obtain(iovec, count, timeout, NULL /*lost*/);
 458 }
 459
 460 void audio_utils_fifo_reader::release(size_t count)
 461         __attribute__((no_sanitize("integer")))
 462 {
 463     // no need to do an early check for mIsShutdown, because the extra code executed is harmless
 464     if (count > 0) {
 465         if (count > mObtained) {
 466             ALOGE("%s(count=%zu) > mObtained=%u", __func__, count, mObtained);
 467             mFifo.shutdown();
 468             return;
 469         }
 470         if (mThrottleFront != NULL) {
 471             uint32_t rear = mFifo.mWriterRear.loadAcquire();
 472             // returns -EIO if mIsShutdown
 473             int32_t filled = mFifo.diff(rear, mLocalFront);
 474             mLocalFront = mFifo.sum(mLocalFront, count);
 475             mThrottleFront->storeRelease(mLocalFront);
 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) {
 486                     if (filled > mArmLevel) {
 487                         mIsArmed = true;
 488                     }
 489                     if (mIsArmed && filled - count < mTriggerLevel) {
 490                         int err = mThrottleFront->wake(op, 1 /*waiters*/);
 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                         }
 496                         mIsArmed = false;
 497                     }
 498                 }
 499                 break;
 500             default:
 501                 LOG_ALWAYS_FATAL("mFifo.mThrottleFrontSync=%d", mFifo.mThrottleFrontSync);
 502                 break;
 503             }
 504         } else {
 505             mLocalFront = mFifo.sum(mLocalFront, count);
 506         }
 507         mObtained -= count;
 508         mTotalReleased += count;
 509     }
 510 }
 511
 512 // iovec == NULL is not part of the public API, but internally it means don't set mObtained
 513 ssize_t audio_utils_fifo_reader::obtain(audio_utils_iovec iovec[2], size_t count,
 514         const struct timespec *timeout, size_t *lost)
 515         __attribute__((no_sanitize("integer")))
 516 {
 517     int err = 0;
 518     int retries = kRetries;
 519     uint32_t rear;
 520     for (;;) {
 521         rear = mFifo.mWriterRear.loadAcquire();
 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         }
 527         // TODO add comments
 528         int op = FUTEX_WAIT;
 529         switch (mFifo.mWriterRearSync) {
 530         case AUDIO_UTILS_FIFO_SYNC_SLEEP:
 531             err = audio_utils_clock_nanosleep(CLOCK_MONOTONIC, 0 /*flags*/, timeout,
 532                     NULL /*remain*/);
 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;
 538             }
 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             }
 547             err = mFifo.mWriterRear.wait(op, rear, timeout);
 548             if (err < 0) {
 549                 switch (errno) {
 550                 case EWOULDBLOCK:
 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.
 554                     if (retries-- > 0) {
 555                         // bypass the "timeout = NULL;" below
 556                         continue;
 557                     }
 558                     // fall through
 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;
 572         }
 573         timeout = NULL;
 574     }
 575     size_t ourLost;
 576     if (lost == NULL) {
 577         lost = &ourLost;
 578     }
 579     // returns -EIO if mIsShutdown
 580     int32_t filled = mFifo.diff(rear, mLocalFront, lost, mFlush);
 581     mTotalLost += *lost;
 582     mTotalReleased += *lost;
 583     if (filled < 0) {
 584         if (filled == -EOVERFLOW) {
 585             // catch up with writer, but preserve the still valid frames in buffer
 586             mLocalFront = rear - (mFlush ? 0 : mFifo.mFrameCountP2 /*sic*/);
 587         }
 588         // on error, return an empty slice
 589         err = filled;
 590         filled = 0;
 591     }
 592     size_t availToRead = (size_t) filled;
 593     if (availToRead > count) {
 594         availToRead = count;
 595     }
 596     uint32_t frontOffset = mLocalFront & (mFifo.mFrameCountP2 - 1);
 597     size_t part1 = mFifo.mFrameCount - frontOffset;
 598     if (part1 > availToRead) {
 599         part1 = availToRead;
 600     }
 601     size_t part2 = part1 > 0 ? availToRead - part1 : 0;
 602     // return slice
 603     if (iovec != NULL) {
 604         iovec[0].mOffset = frontOffset;
 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 {
 620     // iovec == NULL is not part of the public API, but internally it means don't set mObtained
 621     return obtain(NULL /*iovec*/, SIZE_MAX /*count*/, NULL /*timeout*/, lost);
 622 }
 623
 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
 637 void audio_utils_fifo_reader::setHysteresis(int32_t armLevel, uint32_t triggerLevel)
 638 {
 639     // cap to range [0, mFifo.mFrameCount]
 640     if (armLevel < 0) {
 641         armLevel = -1;
 642     } else if ((uint32_t) armLevel > mFifo.mFrameCount) {
 643         armLevel = mFifo.mFrameCount;
 644     }
 645     if (triggerLevel > mFifo.mFrameCount) {
 646         triggerLevel = mFifo.mFrameCount;
 647     }
 648     // TODO this is overly conservative; it would be better to arm based on actual fill level
 649     if (armLevel < mArmLevel) {
 650         mIsArmed = true;
 651     }
 652     mArmLevel = armLevel;
 653     mTriggerLevel = triggerLevel;
 654 }
 655
 656 void audio_utils_fifo_reader::getHysteresis(int32_t *armLevel, uint32_t *triggerLevel) const
 657 {
 658     *armLevel = mArmLevel;
 659     *triggerLevel = mTriggerLevel;
 660 }