VolumeShaper: Initial implementation
The VolumeShaper is used to apply a volume
envelope to an AudioTrack or a MediaPlayer.
Test: CTS
Bug: 30920125
Bug: 31015569
Change-Id: I42e2f13bd6879299dc780e60d143c2d465483a44
diff --git a/include/media/VolumeShaper.h b/include/media/VolumeShaper.h
new file mode 100644
index 0000000..acb22ab
--- /dev/null
+++ b/include/media/VolumeShaper.h
@@ -0,0 +1,736 @@
+/*
+ * Copyright 2017 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.
+ */
+
+#ifndef ANDROID_VOLUME_SHAPER_H
+#define ANDROID_VOLUME_SHAPER_H
+
+#include <list>
+#include <math.h>
+#include <sstream>
+
+#include <binder/Parcel.h>
+#include <media/Interpolator.h>
+#include <utils/Mutex.h>
+#include <utils/RefBase.h>
+
+#pragma push_macro("LOG_TAG")
+#undef LOG_TAG
+#define LOG_TAG "VolumeShaper"
+
+// turn on VolumeShaper logging
+#if 0
+#define VS_LOG ALOGD
+#else
+#define VS_LOG(...)
+#endif
+
+namespace android {
+
+// The native VolumeShaper class mirrors the java VolumeShaper class;
+// in addition, the native class contains implementation for actual operation.
+//
+// VolumeShaper methods are not safe for multiple thread access.
+// Use VolumeHandler for thread-safe encapsulation of multiple VolumeShapers.
+//
+// Classes below written are to avoid naked pointers so there are no
+// explicit destructors required.
+
+class VolumeShaper {
+public:
+ using S = float;
+ using T = float;
+
+ static const int kSystemIdMax = 16;
+
+ // VolumeShaper::Status is equivalent to status_t if negative
+ // but if non-negative represents the id operated on.
+ // It must be expressible as an int32_t for binder purposes.
+ using Status = status_t;
+
+ class Configuration : public Interpolator<S, T>, public RefBase {
+ public:
+ /* VolumeShaper.Configuration derives from the Interpolator class and adds
+ * parameters relating to the volume shape.
+ */
+
+ // TODO document as per VolumeShaper.java flags.
+
+ // must match with VolumeShaper.java in frameworks/base
+ enum Type : int32_t {
+ TYPE_ID,
+ TYPE_SCALE,
+ };
+
+ // must match with VolumeShaper.java in frameworks/base
+ enum OptionFlag : int32_t {
+ OPTION_FLAG_NONE = 0,
+ OPTION_FLAG_VOLUME_IN_DBFS = (1 << 0),
+ OPTION_FLAG_CLOCK_TIME = (1 << 1),
+
+ OPTION_FLAG_ALL = (OPTION_FLAG_VOLUME_IN_DBFS | OPTION_FLAG_CLOCK_TIME),
+ };
+
+ // bring to derived class; must match with VolumeShaper.java in frameworks/base
+ using InterpolatorType = Interpolator<S, T>::InterpolatorType;
+
+ Configuration()
+ : Interpolator<S, T>()
+ , mType(TYPE_SCALE)
+ , mOptionFlags(OPTION_FLAG_NONE)
+ , mDurationMs(1000.)
+ , mId(-1) {
+ }
+
+ Type getType() const {
+ return mType;
+ }
+
+ status_t setType(Type type) {
+ switch (type) {
+ case TYPE_ID:
+ case TYPE_SCALE:
+ mType = type;
+ return NO_ERROR;
+ default:
+ ALOGE("invalid Type: %d", type);
+ return BAD_VALUE;
+ }
+ }
+
+ OptionFlag getOptionFlags() const {
+ return mOptionFlags;
+ }
+
+ status_t setOptionFlags(OptionFlag optionFlags) {
+ if ((optionFlags & ~OPTION_FLAG_ALL) != 0) {
+ ALOGE("optionFlags has invalid bits: %#x", optionFlags);
+ return BAD_VALUE;
+ }
+ mOptionFlags = optionFlags;
+ return NO_ERROR;
+ }
+
+ double getDurationMs() const {
+ return mDurationMs;
+ }
+
+ void setDurationMs(double durationMs) {
+ mDurationMs = durationMs;
+ }
+
+ int32_t getId() const {
+ return mId;
+ }
+
+ void setId(int32_t id) {
+ mId = id;
+ }
+
+ T adjustVolume(T volume) const {
+ if ((getOptionFlags() & OPTION_FLAG_VOLUME_IN_DBFS) != 0) {
+ const T out = powf(10.f, volume / 10.);
+ VS_LOG("in: %f out: %f", volume, out);
+ volume = out;
+ }
+ // clamp
+ if (volume < 0.f) {
+ volume = 0.f;
+ } else if (volume > 1.f) {
+ volume = 1.f;
+ }
+ return volume;
+ }
+
+ status_t checkCurve() {
+ if (mType == TYPE_ID) return NO_ERROR;
+ if (this->size() < 2) {
+ ALOGE("curve must have at least 2 points");
+ return BAD_VALUE;
+ }
+ if (first().first != 0.f || last().first != 1.f) {
+ ALOGE("curve must start at 0.f and end at 1.f");
+ return BAD_VALUE;
+ }
+ if ((getOptionFlags() & OPTION_FLAG_VOLUME_IN_DBFS) != 0) {
+ for (const auto &pt : *this) {
+ if (!(pt.second <= 0.f) /* handle nan */) {
+ ALOGE("positive volume dbFS");
+ return BAD_VALUE;
+ }
+ }
+ } else {
+ for (const auto &pt : *this) {
+ if (!(pt.second >= 0.f) || !(pt.second <= 1.f) /* handle nan */) {
+ ALOGE("volume < 0.f or > 1.f");
+ return BAD_VALUE;
+ }
+ }
+ }
+ return NO_ERROR;
+ }
+
+ void clampVolume() {
+ if ((mOptionFlags & OPTION_FLAG_VOLUME_IN_DBFS) != 0) {
+ for (auto it = this->begin(); it != this->end(); ++it) {
+ if (!(it->second <= 0.f) /* handle nan */) {
+ it->second = 0.f;
+ }
+ }
+ } else {
+ for (auto it = this->begin(); it != this->end(); ++it) {
+ if (!(it->second >= 0.f) /* handle nan */) {
+ it->second = 0.f;
+ } else if (!(it->second <= 1.f)) {
+ it->second = 1.f;
+ }
+ }
+ }
+ }
+
+ /* scaleToStartVolume() is used to set the start volume of a
+ * new VolumeShaper curve, when replacing one VolumeShaper
+ * with another using the "join" (volume match) option.
+ *
+ * It works best for monotonic volume ramps or ducks.
+ */
+ void scaleToStartVolume(T volume) {
+ if (this->size() < 2) {
+ return;
+ }
+ const T startVolume = first().second;
+ const T endVolume = last().second;
+ if (endVolume == startVolume) {
+ // match with linear ramp
+ const T offset = volume - startVolume;
+ for (auto it = this->begin(); it != this->end(); ++it) {
+ it->second = it->second + offset * (1.f - it->first);
+ }
+ } else {
+ const T scale = (volume - endVolume) / (startVolume - endVolume);
+ for (auto it = this->begin(); it != this->end(); ++it) {
+ it->second = scale * (it->second - endVolume) + endVolume;
+ }
+ }
+ clampVolume();
+ }
+
+ status_t writeToParcel(Parcel *parcel) const {
+ if (parcel == nullptr) return BAD_VALUE;
+ return parcel->writeInt32((int32_t)mType)
+ ?: parcel->writeInt32(mId)
+ ?: mType == TYPE_ID
+ ? NO_ERROR
+ : parcel->writeInt32((int32_t)mOptionFlags)
+ ?: parcel->writeDouble(mDurationMs)
+ ?: Interpolator<S, T>::writeToParcel(parcel);
+ }
+
+ status_t readFromParcel(const Parcel &parcel) {
+ int32_t type, optionFlags;
+ return parcel.readInt32(&type)
+ ?: setType((Type)type)
+ ?: parcel.readInt32(&mId)
+ ?: mType == TYPE_ID
+ ? NO_ERROR
+ : parcel.readInt32(&optionFlags)
+ ?: setOptionFlags((OptionFlag)optionFlags)
+ ?: parcel.readDouble(&mDurationMs)
+ ?: Interpolator<S, T>::readFromParcel(parcel)
+ ?: checkCurve();
+ }
+
+ std::string toString() const {
+ std::stringstream ss;
+ ss << "mType: " << mType << std::endl;
+ ss << "mId: " << mId << std::endl;
+ if (mType != TYPE_ID) {
+ ss << "mOptionFlags: " << mOptionFlags << std::endl;
+ ss << "mDurationMs: " << mDurationMs << std::endl;
+ ss << Interpolator<S, T>::toString().c_str();
+ }
+ return ss.str();
+ }
+
+ private:
+ Type mType;
+ int32_t mId;
+ OptionFlag mOptionFlags;
+ double mDurationMs;
+ }; // Configuration
+
+ // must match with VolumeShaper.java in frameworks/base
+ // TODO document per VolumeShaper.java flags.
+ class Operation : public RefBase {
+ public:
+ enum Flag : int32_t {
+ FLAG_NONE = 0,
+ FLAG_REVERSE = (1 << 0),
+ FLAG_TERMINATE = (1 << 1),
+ FLAG_JOIN = (1 << 2),
+ FLAG_DELAY = (1 << 3),
+
+ FLAG_ALL = (FLAG_REVERSE | FLAG_TERMINATE | FLAG_JOIN | FLAG_DELAY),
+ };
+
+ Operation()
+ : mFlags(FLAG_NONE)
+ , mReplaceId(-1) {
+ }
+
+ explicit Operation(Flag flags, int replaceId)
+ : mFlags(flags)
+ , mReplaceId(replaceId) {
+ }
+
+ int32_t getReplaceId() const {
+ return mReplaceId;
+ }
+
+ void setReplaceId(int32_t replaceId) {
+ mReplaceId = replaceId;
+ }
+
+ Flag getFlags() const {
+ return mFlags;
+ }
+
+ status_t setFlags(Flag flags) {
+ if ((flags & ~FLAG_ALL) != 0) {
+ ALOGE("flags has invalid bits: %#x", flags);
+ return BAD_VALUE;
+ }
+ mFlags = flags;
+ return NO_ERROR;
+ }
+
+ status_t writeToParcel(Parcel *parcel) const {
+ if (parcel == nullptr) return BAD_VALUE;
+ return parcel->writeInt32((int32_t)mFlags)
+ ?: parcel->writeInt32(mReplaceId);
+ }
+
+ status_t readFromParcel(const Parcel &parcel) {
+ int32_t flags;
+ return parcel.readInt32(&flags)
+ ?: parcel.readInt32(&mReplaceId)
+ ?: setFlags((Flag)flags);
+ }
+
+ std::string toString() const {
+ std::stringstream ss;
+ ss << "mFlags: " << mFlags << std::endl;
+ ss << "mReplaceId: " << mReplaceId << std::endl;
+ return ss.str();
+ }
+
+ private:
+ Flag mFlags;
+ int32_t mReplaceId;
+ }; // Operation
+
+ // must match with VolumeShaper.java in frameworks/base
+ class State : public RefBase {
+ public:
+ explicit State(T volume, S xOffset)
+ : mVolume(volume)
+ , mXOffset(xOffset) {
+ }
+
+ State()
+ : State(-1.f, -1.f) { }
+
+ T getVolume() const {
+ return mVolume;
+ }
+
+ void setVolume(T volume) {
+ mVolume = volume;
+ }
+
+ S getXOffset() const {
+ return mXOffset;
+ }
+
+ void setXOffset(S xOffset) {
+ mXOffset = xOffset;
+ }
+
+ status_t writeToParcel(Parcel *parcel) const {
+ if (parcel == nullptr) return BAD_VALUE;
+ return parcel->writeFloat(mVolume)
+ ?: parcel->writeFloat(mXOffset);
+ }
+
+ status_t readFromParcel(const Parcel &parcel) {
+ return parcel.readFloat(&mVolume)
+ ?: parcel.readFloat(&mXOffset);
+ }
+
+ std::string toString() const {
+ std::stringstream ss;
+ ss << "mVolume: " << mVolume << std::endl;
+ ss << "mXOffset: " << mXOffset << std::endl;
+ return ss.str();
+ }
+
+ private:
+ T mVolume;
+ S mXOffset;
+ }; // State
+
+ template <typename R>
+ class Translate {
+ public:
+ Translate()
+ : mOffset(0)
+ , mScale(1) {
+ }
+
+ R getOffset() const {
+ return mOffset;
+ }
+
+ void setOffset(R offset) {
+ mOffset = offset;
+ }
+
+ R getScale() const {
+ return mScale;
+ }
+
+ void setScale(R scale) {
+ mScale = scale;
+ }
+
+ R operator()(R in) const {
+ return mScale * (in - mOffset);
+ }
+
+ std::string toString() const {
+ std::stringstream ss;
+ ss << "mOffset: " << mOffset << std::endl;
+ ss << "mScale: " << mScale << std::endl;
+ return ss.str();
+ }
+
+ private:
+ R mOffset;
+ R mScale;
+ }; // Translate
+
+ static int64_t convertTimespecToUs(const struct timespec &tv)
+ {
+ return tv.tv_sec * 1000000ll + tv.tv_nsec / 1000;
+ }
+
+ // current monotonic time in microseconds.
+ static int64_t getNowUs()
+ {
+ struct timespec tv;
+ if (clock_gettime(CLOCK_MONOTONIC, &tv) != 0) {
+ return 0; // system is really sick, just return 0 for consistency.
+ }
+ return convertTimespecToUs(tv);
+ }
+
+ Translate<S> mXTranslate;
+ Translate<T> mYTranslate;
+ sp<VolumeShaper::Configuration> mConfiguration;
+ sp<VolumeShaper::Operation> mOperation;
+ int64_t mStartFrame;
+ T mLastVolume;
+ S mXOffset;
+
+ // TODO: Since we pass configuration and operation as shared pointers
+ // there is a potential risk that the caller may modify these after
+ // delivery. Currently, we don't require copies made here.
+ explicit VolumeShaper(
+ const sp<VolumeShaper::Configuration> &configuration,
+ const sp<VolumeShaper::Operation> &operation)
+ : mConfiguration(configuration) // we do not make a copy
+ , mOperation(operation) // ditto
+ , mStartFrame(-1)
+ , mLastVolume(T(1))
+ , mXOffset(0.f) {
+ if (configuration.get() != nullptr
+ && (getFlags() & VolumeShaper::Operation::FLAG_DELAY) == 0) {
+ mLastVolume = configuration->first().second;
+ }
+ }
+
+ void updatePosition(int64_t startFrame, double sampleRate) {
+ double scale = (mConfiguration->last().first - mConfiguration->first().first)
+ / (mConfiguration->getDurationMs() * 0.001 * sampleRate);
+ const double minScale = 1. / INT64_MAX;
+ scale = std::max(scale, minScale);
+ VS_LOG("update position: scale %lf frameCount:%lld, sampleRate:%lf",
+ scale, (long long) startFrame, sampleRate);
+ mXTranslate.setOffset(startFrame - mConfiguration->first().first / scale);
+ mXTranslate.setScale(scale);
+ VS_LOG("translate: %s", mXTranslate.toString().c_str());
+ }
+
+ // We allow a null operation here, though VolumeHandler always provides one.
+ VolumeShaper::Operation::Flag getFlags() const {
+ return mOperation == nullptr
+ ? VolumeShaper::Operation::FLAG_NONE :mOperation->getFlags();
+ }
+
+ sp<VolumeShaper::State> getState() const {
+ return new VolumeShaper::State(mLastVolume, mXOffset);
+ }
+
+ std::pair<T, bool> getVolume(int64_t trackFrameCount, double trackSampleRate) {
+ if (mConfiguration.get() == nullptr || mConfiguration->empty()) {
+ ALOGE("nonexistent VolumeShaper, removing");
+ mLastVolume = T(1);
+ mXOffset = 0.f;
+ return std::make_pair(T(1), true);
+ }
+ if ((getFlags() & VolumeShaper::Operation::FLAG_DELAY) != 0) {
+ VS_LOG("delayed VolumeShaper, ignoring");
+ mLastVolume = T(1);
+ mXOffset = 0.;
+ return std::make_pair(T(1), false);
+ }
+ const bool clockTime = (mConfiguration->getOptionFlags()
+ & VolumeShaper::Configuration::OPTION_FLAG_CLOCK_TIME) != 0;
+ const int64_t frameCount = clockTime ? getNowUs() : trackFrameCount;
+ const double sampleRate = clockTime ? 1000000 : trackSampleRate;
+
+ if (mStartFrame < 0) {
+ updatePosition(frameCount, sampleRate);
+ mStartFrame = frameCount;
+ }
+ VS_LOG("frameCount: %lld", (long long)frameCount);
+ S x = mXTranslate((T)frameCount);
+ VS_LOG("translation: %f", x);
+
+ // handle reversal of position
+ if (getFlags() & VolumeShaper::Operation::FLAG_REVERSE) {
+ x = 1.f - x;
+ VS_LOG("reversing to %f", x);
+ if (x < mConfiguration->first().first) {
+ mXOffset = 1.f;
+ const T volume = mConfiguration->adjustVolume(
+ mConfiguration->first().second); // persist last value
+ VS_LOG("persisting volume %f", volume);
+ mLastVolume = volume;
+ return std::make_pair(volume, false);
+ }
+ if (x > mConfiguration->last().first) {
+ mXOffset = 0.f;
+ mLastVolume = 1.f;
+ return std::make_pair(T(1), false); // too early
+ }
+ } else {
+ if (x < mConfiguration->first().first) {
+ mXOffset = 0.f;
+ mLastVolume = 1.f;
+ return std::make_pair(T(1), false); // too early
+ }
+ if (x > mConfiguration->last().first) {
+ mXOffset = 1.f;
+ const T volume = mConfiguration->adjustVolume(
+ mConfiguration->last().second); // persist last value
+ VS_LOG("persisting volume %f", volume);
+ mLastVolume = volume;
+ return std::make_pair(volume, false);
+ }
+ }
+ mXOffset = x;
+ // x contains the location on the volume curve to use.
+ const T unscaledVolume = mConfiguration->findY(x);
+ const T volumeChange = mYTranslate(unscaledVolume);
+ const T volume = mConfiguration->adjustVolume(volumeChange);
+ VS_LOG("volume: %f unscaled: %f", volume, unscaledVolume);
+ mLastVolume = volume;
+ return std::make_pair(volume, false);
+ }
+
+ std::string toString() const {
+ std::stringstream ss;
+ ss << "StartFrame: " << mStartFrame << std::endl;
+ ss << mXTranslate.toString().c_str();
+ ss << mYTranslate.toString().c_str();
+ if (mConfiguration.get() == nullptr) {
+ ss << "VolumeShaper::Configuration: nullptr" << std::endl;
+ } else {
+ ss << "VolumeShaper::Configuration:" << std::endl;
+ ss << mConfiguration->toString().c_str();
+ }
+ if (mOperation.get() == nullptr) {
+ ss << "VolumeShaper::Operation: nullptr" << std::endl;
+ } else {
+ ss << "VolumeShaper::Operation:" << std::endl;
+ ss << mOperation->toString().c_str();
+ }
+ return ss.str();
+ }
+}; // VolumeShaper
+
+// VolumeHandler combines the volume factors of multiple VolumeShapers and handles
+// multiple thread access by synchronizing all public methods.
+class VolumeHandler : public RefBase {
+public:
+ using S = float;
+ using T = float;
+
+ explicit VolumeHandler(uint32_t sampleRate)
+ : mSampleRate((double)sampleRate)
+ , mLastFrame(0) {
+ }
+
+ VolumeShaper::Status applyVolumeShaper(
+ const sp<VolumeShaper::Configuration> &configuration,
+ const sp<VolumeShaper::Operation> &operation) {
+ AutoMutex _l(mLock);
+ if (configuration == nullptr) {
+ ALOGE("null configuration");
+ return VolumeShaper::Status(BAD_VALUE);
+ }
+ if (operation == nullptr) {
+ ALOGE("null operation");
+ return VolumeShaper::Status(BAD_VALUE);
+ }
+ const int32_t id = configuration->getId();
+ if (id < 0) {
+ ALOGE("negative id: %d", id);
+ return VolumeShaper::Status(BAD_VALUE);
+ }
+ VS_LOG("applyVolumeShaper id: %d", id);
+
+ switch (configuration->getType()) {
+ case VolumeShaper::Configuration::TYPE_ID: {
+ VS_LOG("trying to find id: %d", id);
+ auto it = findId_l(id);
+ if (it == mVolumeShapers.end()) {
+ VS_LOG("couldn't find id: %d\n%s", id, this->toString().c_str());
+ return VolumeShaper::Status(INVALID_OPERATION);
+ }
+ if ((it->getFlags() & VolumeShaper::Operation::FLAG_TERMINATE) != 0) {
+ VS_LOG("terminate id: %d", id);
+ mVolumeShapers.erase(it);
+ break;
+ }
+ if ((it->getFlags() & VolumeShaper::Operation::FLAG_REVERSE) !=
+ (operation->getFlags() & VolumeShaper::Operation::FLAG_REVERSE)) {
+ const S x = it->mXTranslate((T)mLastFrame);
+ VS_LOG("translation: %f", x);
+ // reflect position
+ S target = 1.f - x;
+ if (target < it->mConfiguration->first().first) {
+ VS_LOG("clamp to start - begin immediately");
+ target = 0.;
+ }
+ VS_LOG("target: %f", target);
+ it->mXTranslate.setOffset(it->mXTranslate.getOffset()
+ + (x - target) / it->mXTranslate.getScale());
+ }
+ it->mOperation = operation; // replace the operation
+ } break;
+ case VolumeShaper::Configuration::TYPE_SCALE: {
+ const int replaceId = operation->getReplaceId();
+ if (replaceId >= 0) {
+ auto replaceIt = findId_l(replaceId);
+ if (replaceIt == mVolumeShapers.end()) {
+ ALOGW("cannot find replace id: %d", replaceId);
+ } else {
+ if ((replaceIt->getFlags() & VolumeShaper::Operation::FLAG_JOIN) != 0) {
+ // For join, we scale the start volume of the current configuration
+ // to match the last-used volume of the replacing VolumeShaper.
+ auto state = replaceIt->getState();
+ if (state->getXOffset() >= 0) { // valid
+ const T volume = state->getVolume();
+ ALOGD("join: scaling start volume to %f", volume);
+ configuration->scaleToStartVolume(volume);
+ }
+ }
+ (void)mVolumeShapers.erase(replaceIt);
+ }
+ }
+ // check if we have another of the same id.
+ auto oldIt = findId_l(id);
+ if (oldIt != mVolumeShapers.end()) {
+ ALOGW("duplicate id, removing old %d", id);
+ (void)mVolumeShapers.erase(oldIt);
+ }
+ // create new VolumeShaper
+ mVolumeShapers.emplace_back(configuration, operation);
+ } break;
+ }
+ return VolumeShaper::Status(id);
+ }
+
+ sp<VolumeShaper::State> getVolumeShaperState(int id) {
+ AutoMutex _l(mLock);
+ auto it = findId_l(id);
+ if (it == mVolumeShapers.end()) {
+ return nullptr;
+ }
+ return it->getState();
+ }
+
+ T getVolume(int64_t trackFrameCount) {
+ AutoMutex _l(mLock);
+ mLastFrame = trackFrameCount;
+ T volume(1);
+ for (auto it = mVolumeShapers.begin(); it != mVolumeShapers.end();) {
+ std::pair<T, bool> shaperVolume =
+ it->getVolume(trackFrameCount, mSampleRate);
+ volume *= shaperVolume.first;
+ if (shaperVolume.second) {
+ it = mVolumeShapers.erase(it);
+ continue;
+ }
+ ++it;
+ }
+ return volume;
+ }
+
+ std::string toString() const {
+ AutoMutex _l(mLock);
+ std::stringstream ss;
+ ss << "mSampleRate: " << mSampleRate << std::endl;
+ ss << "mLastFrame: " << mLastFrame << std::endl;
+ for (const auto &shaper : mVolumeShapers) {
+ ss << shaper.toString().c_str();
+ }
+ return ss.str();
+ }
+
+private:
+ std::list<VolumeShaper>::iterator findId_l(int32_t id) {
+ std::list<VolumeShaper>::iterator it = mVolumeShapers.begin();
+ for (; it != mVolumeShapers.end(); ++it) {
+ if (it->mConfiguration->getId() == id) {
+ break;
+ }
+ }
+ return it;
+ }
+
+ mutable Mutex mLock;
+ double mSampleRate; // in samples (frames) per second
+ int64_t mLastFrame; // logging purpose only
+ std::list<VolumeShaper> mVolumeShapers; // list provides stable iterators on erase
+}; // VolumeHandler
+
+} // namespace android
+
+#pragma pop_macro("LOG_TAG")
+
+#endif // ANDROID_VOLUME_SHAPER_H