Merge changes I924d6fc8,Iee20a2b1,I4070aade,I55331da0 into main
* changes:
hwcryptohal: Service delegator fixes
hwcryptohal: Adding maps cleanup
hwcryptohal: Adding hwcrypto operations tests
hwcryptohal: Adding hwcrypto operations to hwcrypto service
diff --git a/audio/aidl/android/hardware/audio/core/StreamDescriptor.aidl b/audio/aidl/android/hardware/audio/core/StreamDescriptor.aidl
index cfe001e..9b7fea2 100644
--- a/audio/aidl/android/hardware/audio/core/StreamDescriptor.aidl
+++ b/audio/aidl/android/hardware/audio/core/StreamDescriptor.aidl
@@ -188,6 +188,14 @@
* In the 'DRAINING' state the producer is inactive, the consumer is
* finishing up on the buffer contents, emptying it up. As soon as it
* gets empty, the stream transfers itself into the next state.
+ *
+ * Note that "early notify" draining is a more complex procedure
+ * intended for transitioning between two clips. Both 'DRAINING' and
+ * 'DRAIN_PAUSED' states have "sub-states" not visible via the API. See
+ * the details in the 'stream-out-async-sm.gv' state machine
+ * description. In the HAL API V3 this behavior is enabled when the
+ * HAL exposes "aosp.clipTransitionSupport" property, and in the HAL
+ * API V4 it is the default behavior.
*/
DRAINING = 5,
/**
@@ -234,9 +242,15 @@
/**
* Used with output streams only, the HAL module indicates drain
* completion shortly before all audio data has been consumed in order
- * to give the client an opportunity to provide data for the next track
+ * to give the client an opportunity to provide data for the next clip
* for gapless playback. The exact amount of provided time is specific
* to the HAL implementation.
+ *
+ * In the HAL API V3, the HAL sends two 'onDrainReady' notifications:
+ * one to indicate readiness to receive next clip data, and another when
+ * the previous clip has finished playing. This behavior is enabled when
+ * the HAL exposes "aosp.clipTransitionSupport" property, and in the HAL
+ * API V4 it is the default behavior.
*/
DRAIN_EARLY_NOTIFY = 2,
}
diff --git a/audio/aidl/android/hardware/audio/core/stream-out-async-sm.gv b/audio/aidl/android/hardware/audio/core/stream-out-async-sm.gv
index e2da90d..bf75594 100644
--- a/audio/aidl/android/hardware/audio/core/stream-out-async-sm.gv
+++ b/audio/aidl/android/hardware/audio/core/stream-out-async-sm.gv
@@ -32,27 +32,78 @@
IDLE -> TRANSFERRING [label="burst"]; // producer -> active
IDLE -> ACTIVE [label="burst"]; // full write
ACTIVE -> PAUSED [label="pause"]; // consumer -> passive (not consuming)
- ACTIVE -> DRAINING [label="drain"]; // producer -> passive
+ ACTIVE -> DRAINING [label="drain(ALL)"]; // producer -> passive
+ ACTIVE -> DRAINING_en [label="drain(EARLY_NOTIFY)"]; // prepare for clip transition
ACTIVE -> TRANSFERRING [label="burst"]; // early unblocking
ACTIVE -> ACTIVE [label="burst"]; // full write
TRANSFERRING -> ACTIVE [label="←IStreamCallback.onTransferReady"];
TRANSFERRING -> TRANSFER_PAUSED [label="pause"]; // consumer -> passive (not consuming)
- TRANSFERRING -> DRAINING [label="drain"]; // producer -> passive
+ TRANSFERRING -> DRAINING [label="drain(ALL)"]; // producer -> passive
+ TRANSFERRING -> DRAINING_en [label="drain(EARLY_NOTIFY)"]; // prepare for clip transition
TRANSFER_PAUSED -> TRANSFERRING [label="start"]; // consumer -> active
- TRANSFER_PAUSED -> DRAIN_PAUSED [label="drain"]; // producer -> passive
+ TRANSFER_PAUSED -> DRAIN_PAUSED [label="drain(ALL)"]; // producer -> passive
TRANSFER_PAUSED -> IDLE [label="flush"]; // buffer is cleared
PAUSED -> PAUSED [label="burst"];
PAUSED -> ACTIVE [label="start"]; // consumer -> active
PAUSED -> IDLE [label="flush"]; // producer -> passive, buffer is cleared
DRAINING -> IDLE [label="←IStreamCallback.onDrainReady"];
- DRAINING -> DRAINING [label="←IStreamCallback.onDrainReady"]; // allowed for `DRAIN_EARLY_NOTIFY`
- DRAINING -> IDLE [label="<empty buffer>"]; // allowed for `DRAIN_EARLY_NOTIFY`
DRAINING -> TRANSFERRING [label="burst"]; // producer -> active
DRAINING -> ACTIVE [label="burst"]; // full write
DRAINING -> DRAIN_PAUSED [label="pause"]; // consumer -> passive (not consuming)
DRAIN_PAUSED -> DRAINING [label="start"]; // consumer -> active
DRAIN_PAUSED -> TRANSFER_PAUSED [label="burst"]; // producer -> active
DRAIN_PAUSED -> IDLE [label="flush"]; // buffer is cleared
+ // Note that the states in both clusters are combined with 'DRAINING' and 'DRAIN_PAUSED'
+ // state at the API level. The 'en' and 'en_sent' attributes only belong to the internal
+ // state of the stream and are not observable outside.
+ subgraph cluster_early_notify_entering {
+ // The stream is preparing for a transition between two clips. After
+ // receiving 'drain(EARLY_NOTIFY)' command, the stream continues playing
+ // the current clip, and at some point notifies the client that it is
+ // ready for the next clip data by issuing the first 'onDrainReady'
+ // callback.
+ label="EARLY_NOTIFY (entering)";
+ color=gray;
+ // Getting 'burst' or 'flush' command in these states resets the "clip
+ // transition" mode.
+ DRAINING_en;
+ DRAIN_PAUSED_en;
+ }
+ subgraph cluster_early_notify_notification_sent {
+ // After the stream has sent "onDrainReady", the client can now send
+ // 'burst' commands with the data of the next clip. These 'bursts' are
+ // always "early unblocking" because the previous clip is still playing
+ // thus the stream is unable to play any of the received data
+ // synchronously (in other words, it can not do a "full write"). To
+ // indicate readiness to accept the next burst the stream uses the usual
+ // 'onTransferReady' callback.
+ label="EARLY_NOTIFY (notification sent)";
+ color=gray;
+ // The state machine remains in these states until the current clip ends
+ // playing. When it ends, the stream sends 'onDrainReady' (note that
+ // it's the second 'onDrainReady' for the same 'drain(EARLY_NOTIFY)'),
+ // and transitions either to 'IDLE' if there is no data for the next
+ // clip, or to 'TRANSFERRING' otherwise. Note that it can not transition
+ // to 'ACTIVE' because that transition is associated with
+ // 'onTransferReady' callback.
+ DRAINING_en_sent;
+ DRAIN_PAUSED_en_sent;
+ }
+ DRAINING_en -> TRANSFERRING [label="burst"]; // producer -> active
+ DRAINING_en -> ACTIVE [label="burst"]; // full write
+ DRAINING_en -> DRAIN_PAUSED_en [label="pause"]; // consumer -> passive (not consuming)
+ DRAINING_en -> DRAINING_en_sent [label="←IStreamCallback.onDrainReady"];
+ DRAIN_PAUSED_en -> DRAINING_en [label="start"]; // consumer -> active
+ DRAIN_PAUSED_en -> TRANSFER_PAUSED [label="burst"]; // producer -> active
+ DRAIN_PAUSED_en -> IDLE [label="flush"]; // buffer is cleared
+ DRAINING_en_sent -> DRAINING_en_sent [label="burst"];
+ DRAINING_en_sent -> DRAINING_en_sent [label="←IStreamCallback.onTransferReady"];
+ DRAINING_en_sent -> DRAIN_PAUSED_en_sent [label="pause"]; // consumer -> passive (not consuming)
+ DRAINING_en_sent -> TRANSFERRING [label="←IStreamCallback.onDrainReady"];
+ DRAINING_en_sent -> IDLE [label="←IStreamCallback.onDrainReady"];
+ DRAIN_PAUSED_en_sent -> DRAINING_en_sent [label="start"]; // consumer -> active
+ DRAIN_PAUSED_en_sent -> DRAIN_PAUSED_en_sent [label="burst"]; // producer -> active
+ DRAIN_PAUSED_en_sent -> IDLE [label="flush"]; // buffer is cleared
ANY_STATE -> ERROR [label="←IStreamCallback.onError"];
ANY_STATE -> CLOSED [label="→IStream*.close"];
CLOSED -> F;
diff --git a/audio/aidl/default/Module.cpp b/audio/aidl/default/Module.cpp
index 077d80b..123a5ec 100644
--- a/audio/aidl/default/Module.cpp
+++ b/audio/aidl/default/Module.cpp
@@ -612,6 +612,15 @@
return ndk::ScopedAStatus::ok();
}
+binder_status_t Module::dump(int fd, const char** args, uint32_t numArgs) {
+ for (const auto& portConfig : getConfig().portConfigs) {
+ if (portConfig.ext.getTag() == AudioPortExt::Tag::mix) {
+ getStreams().dump(portConfig.id, fd, args, numArgs);
+ }
+ }
+ return STATUS_OK;
+}
+
ndk::ScopedAStatus Module::setModuleDebug(
const ::aidl::android::hardware::audio::core::ModuleDebug& in_debug) {
LOG(DEBUG) << __func__ << ": " << mType << ": old flags:" << mDebug.toString()
@@ -1546,6 +1555,7 @@
const std::string Module::VendorDebug::kForceTransientBurstName = "aosp.forceTransientBurst";
const std::string Module::VendorDebug::kForceSynchronousDrainName = "aosp.forceSynchronousDrain";
+const std::string Module::kClipTransitionSupportName = "aosp.clipTransitionSupport";
ndk::ScopedAStatus Module::getVendorParameters(const std::vector<std::string>& in_ids,
std::vector<VendorParameter>* _aidl_return) {
@@ -1560,6 +1570,10 @@
VendorParameter forceSynchronousDrain{.id = id};
forceSynchronousDrain.ext.setParcelable(Boolean{mVendorDebug.forceSynchronousDrain});
_aidl_return->push_back(std::move(forceSynchronousDrain));
+ } else if (id == kClipTransitionSupportName) {
+ VendorParameter clipTransitionSupport{.id = id};
+ clipTransitionSupport.ext.setParcelable(Boolean{true});
+ _aidl_return->push_back(std::move(clipTransitionSupport));
} else {
allParametersKnown = false;
LOG(VERBOSE) << __func__ << ": " << mType << ": unrecognized parameter \"" << id << "\"";
diff --git a/audio/aidl/default/Stream.cpp b/audio/aidl/default/Stream.cpp
index c6c1b5d..2800bed 100644
--- a/audio/aidl/default/Stream.cpp
+++ b/audio/aidl/default/Stream.cpp
@@ -252,9 +252,10 @@
mState == StreamDescriptor::State::ACTIVE ||
mState == StreamDescriptor::State::PAUSED ||
mState == StreamDescriptor::State::DRAINING) {
- if (hasMmapFlag(mContext->getFlags())) {
- populateReply(&reply, mIsConnected);
- } else if (!read(fmqByteCount, &reply)) {
+ if (bool success = hasMmapFlag(mContext->getFlags())
+ ? readMmap(&reply)
+ : read(fmqByteCount, &reply);
+ !success) {
mState = StreamDescriptor::State::ERROR;
}
if (mState == StreamDescriptor::State::IDLE ||
@@ -383,16 +384,38 @@
return !fatal;
}
+bool StreamInWorkerLogic::readMmap(StreamDescriptor::Reply* reply) {
+ void* buffer = nullptr;
+ size_t frameCount = 0;
+ size_t actualFrameCount = 0;
+ int32_t latency = mContext->getNominalLatencyMs();
+ // use default-initialized parameter values for mmap stream.
+ if (::android::status_t status =
+ mDriver->transfer(buffer, frameCount, &actualFrameCount, &latency);
+ status == ::android::OK) {
+ populateReply(reply, mIsConnected);
+ reply->latencyMs = latency;
+ return true;
+ } else {
+ LOG(ERROR) << __func__ << ": transfer failed: " << status;
+ return false;
+ }
+}
+
const std::string StreamOutWorkerLogic::kThreadName = "writer";
void StreamOutWorkerLogic::onBufferStateChange(size_t bufferFramesLeft) {
const StreamDescriptor::State state = mState;
- LOG(DEBUG) << __func__ << ": state: " << toString(state)
+ const DrainState drainState = mDrainState;
+ LOG(DEBUG) << __func__ << ": state: " << toString(state) << ", drainState: " << drainState
<< ", bufferFramesLeft: " << bufferFramesLeft;
- if (state == StreamDescriptor::State::TRANSFERRING) {
- mState = StreamDescriptor::State::ACTIVE;
+ if (state == StreamDescriptor::State::TRANSFERRING || drainState == DrainState::EN_SENT) {
+ if (state == StreamDescriptor::State::TRANSFERRING) {
+ mState = StreamDescriptor::State::ACTIVE;
+ }
std::shared_ptr<IStreamCallback> asyncCallback = mContext->getAsyncCallback();
if (asyncCallback != nullptr) {
+ LOG(VERBOSE) << __func__ << ": sending onTransferReady";
ndk::ScopedAStatus status = asyncCallback->onTransferReady();
if (!status.isOk()) {
LOG(ERROR) << __func__ << ": error from onTransferReady: " << status;
@@ -411,8 +434,10 @@
mState =
hasNextClip ? StreamDescriptor::State::TRANSFERRING : StreamDescriptor::State::IDLE;
mDrainState = DrainState::NONE;
- if (drainState == DrainState::ALL && asyncCallback != nullptr) {
+ if ((drainState == DrainState::ALL || drainState == DrainState::EN_SENT) &&
+ asyncCallback != nullptr) {
LOG(DEBUG) << __func__ << ": sending onDrainReady";
+ // For EN_SENT, this is the second onDrainReady which notifies about clip transition.
ndk::ScopedAStatus status = asyncCallback->onDrainReady();
if (!status.isOk()) {
LOG(ERROR) << __func__ << ": error from onDrainReady: " << status;
@@ -523,9 +548,10 @@
if (mState != StreamDescriptor::State::ERROR &&
mState != StreamDescriptor::State::TRANSFERRING &&
mState != StreamDescriptor::State::TRANSFER_PAUSED) {
- if (hasMmapFlag(mContext->getFlags())) {
- populateReply(&reply, mIsConnected);
- } else if (!write(fmqByteCount, &reply)) {
+ if (bool success = hasMmapFlag(mContext->getFlags())
+ ? writeMmap(&reply)
+ : write(fmqByteCount, &reply);
+ !success) {
mState = StreamDescriptor::State::ERROR;
}
std::shared_ptr<IStreamCallback> asyncCallback = mContext->getAsyncCallback();
@@ -539,13 +565,17 @@
mState = StreamDescriptor::State::TRANSFER_PAUSED;
}
} else if (mState == StreamDescriptor::State::IDLE ||
- mState == StreamDescriptor::State::DRAINING ||
- mState == StreamDescriptor::State::ACTIVE) {
+ mState == StreamDescriptor::State::ACTIVE ||
+ (mState == StreamDescriptor::State::DRAINING &&
+ mDrainState != DrainState::EN_SENT)) {
if (asyncCallback == nullptr || reply.fmqByteCount == fmqByteCount) {
mState = StreamDescriptor::State::ACTIVE;
} else {
switchToTransientState(StreamDescriptor::State::TRANSFERRING);
}
+ } else if (mState == StreamDescriptor::State::DRAINING &&
+ mDrainState == DrainState::EN_SENT) {
+ // keep mState
}
} else {
populateReplyWrongState(&reply, command);
@@ -700,6 +730,24 @@
return !fatal;
}
+bool StreamOutWorkerLogic::writeMmap(StreamDescriptor::Reply* reply) {
+ void* buffer = nullptr;
+ size_t frameCount = 0;
+ size_t actualFrameCount = 0;
+ int32_t latency = mContext->getNominalLatencyMs();
+ // use default-initialized parameter values for mmap stream.
+ if (::android::status_t status =
+ mDriver->transfer(buffer, frameCount, &actualFrameCount, &latency);
+ status == ::android::OK) {
+ populateReply(reply, mIsConnected);
+ reply->latencyMs = latency;
+ return true;
+ } else {
+ LOG(ERROR) << __func__ << ": transfer failed: " << status;
+ return false;
+ }
+}
+
StreamCommonImpl::~StreamCommonImpl() {
// It is responsibility of the class that implements 'DriverInterface' to call 'cleanupWorker'
// in the destructor. Note that 'cleanupWorker' can not be properly called from this destructor
diff --git a/audio/aidl/default/include/core-impl/Module.h b/audio/aidl/default/include/core-impl/Module.h
index 6a43102..0661015 100644
--- a/audio/aidl/default/include/core-impl/Module.h
+++ b/audio/aidl/default/include/core-impl/Module.h
@@ -61,6 +61,8 @@
// The vendor extension done via inheritance can override interface methods and augment
// a call to the base implementation.
+ binder_status_t dump(int fd, const char** args, uint32_t numArgs) override;
+
ndk::ScopedAStatus setModuleDebug(
const ::aidl::android::hardware::audio::core::ModuleDebug& in_debug) override;
ndk::ScopedAStatus getTelephony(std::shared_ptr<ITelephony>* _aidl_return) override;
@@ -159,6 +161,7 @@
// Multimap because both ports and configs can be used by multiple patches.
using Patches = std::multimap<int32_t, int32_t>;
+ static const std::string kClipTransitionSupportName;
const Type mType;
std::unique_ptr<Configuration> mConfig;
ModuleDebug mDebug;
diff --git a/audio/aidl/default/include/core-impl/Stream.h b/audio/aidl/default/include/core-impl/Stream.h
index f0139b4..376c684 100644
--- a/audio/aidl/default/include/core-impl/Stream.h
+++ b/audio/aidl/default/include/core-impl/Stream.h
@@ -307,6 +307,7 @@
private:
bool read(size_t clientSize, StreamDescriptor::Reply* reply);
+ bool readMmap(StreamDescriptor::Reply* reply);
};
using StreamInWorker = StreamWorkerImpl<StreamInWorkerLogic>;
@@ -325,6 +326,7 @@
private:
bool write(size_t clientSize, StreamDescriptor::Reply* reply);
+ bool writeMmap(StreamDescriptor::Reply* reply);
std::shared_ptr<IStreamOutEventCallback> mEventCallback;
@@ -651,6 +653,12 @@
return ndk::ScopedAStatus::ok();
}
+ void dump(int fd, const char** args, uint32_t numArgs) const {
+ auto s = ::ndk::ICInterface::asInterface(mStreamBinder.get());
+ if (s) s->dump(fd, args, numArgs);
+ return;
+ }
+
private:
std::weak_ptr<StreamCommonInterface> mStream;
ndk::SpAIBinder mStreamBinder;
@@ -692,6 +700,12 @@
}
return ndk::ScopedAStatus::ok();
}
+ void dump(int32_t portConfigId, int fd, const char** args, uint32_t numArgs) const {
+ if (auto it = mStreams.find(portConfigId); it != mStreams.end()) {
+ it->second.dump(fd, args, numArgs);
+ }
+ return;
+ }
private:
// Maps port ids and port config ids to streams. Multimap because a port
diff --git a/audio/aidl/default/include/core-impl/StreamOffloadStub.h b/audio/aidl/default/include/core-impl/StreamOffloadStub.h
index 67abe95..24e98c2 100644
--- a/audio/aidl/default/include/core-impl/StreamOffloadStub.h
+++ b/audio/aidl/default/include/core-impl/StreamOffloadStub.h
@@ -26,14 +26,16 @@
namespace aidl::android::hardware::audio::core {
struct DspSimulatorState {
+ static constexpr int64_t kSkipBufferNotifyFrames = -1;
+
const std::string formatEncoding;
const int sampleRate;
const int64_t earlyNotifyFrames;
- const int64_t bufferNotifyFrames;
DriverCallbackInterface* callback = nullptr; // set before starting DSP worker
std::mutex lock;
std::vector<int64_t> clipFramesLeft GUARDED_BY(lock);
- int64_t bufferFramesLeft GUARDED_BY(lock);
+ int64_t bufferFramesLeft GUARDED_BY(lock) = 0;
+ int64_t bufferNotifyFrames GUARDED_BY(lock) = kSkipBufferNotifyFrames;
};
class DspSimulatorLogic : public ::android::hardware::audio::common::StreamLogic {
@@ -68,6 +70,7 @@
private:
::android::status_t startWorkerIfNeeded();
+ const int64_t mBufferNotifyFrames;
DspSimulatorState mState;
DspSimulatorWorker mDspWorker;
bool mDspWorkerStarted = false;
diff --git a/audio/aidl/default/stub/StreamOffloadStub.cpp b/audio/aidl/default/stub/StreamOffloadStub.cpp
index 95cef35..155f76d 100644
--- a/audio/aidl/default/stub/StreamOffloadStub.cpp
+++ b/audio/aidl/default/stub/StreamOffloadStub.cpp
@@ -42,14 +42,13 @@
const int64_t clipFramesPlayed =
(::android::uptimeNanos() - timeBeginNs) * mSharedState.sampleRate / NANOS_PER_SECOND;
const int64_t bufferFramesConsumed = clipFramesPlayed / 2; // assume 1:2 compression ratio
- int64_t bufferFramesLeft = 0;
+ int64_t bufferFramesLeft = 0, bufferNotifyFrames = DspSimulatorState::kSkipBufferNotifyFrames;
{
std::lock_guard l(mSharedState.lock);
mSharedState.bufferFramesLeft =
mSharedState.bufferFramesLeft > bufferFramesConsumed
? mSharedState.bufferFramesLeft - bufferFramesConsumed
: 0;
- bufferFramesLeft = mSharedState.bufferFramesLeft;
int64_t framesPlayed = clipFramesPlayed;
while (framesPlayed > 0 && !mSharedState.clipFramesLeft.empty()) {
LOG(VERBOSE) << __func__ << ": clips: "
@@ -65,10 +64,21 @@
clipNotifies.emplace_back(0 /*clipFramesLeft*/, hasNextClip);
framesPlayed -= mSharedState.clipFramesLeft[0];
mSharedState.clipFramesLeft.erase(mSharedState.clipFramesLeft.begin());
+ if (!hasNextClip) {
+ // Since it's a simulation, the buffer consumption rate it not real,
+ // thus 'bufferFramesLeft' might still have something, need to erase it.
+ mSharedState.bufferFramesLeft = 0;
+ }
}
}
+ bufferFramesLeft = mSharedState.bufferFramesLeft;
+ bufferNotifyFrames = mSharedState.bufferNotifyFrames;
+ if (bufferFramesLeft <= bufferNotifyFrames) {
+ // Suppress further notifications.
+ mSharedState.bufferNotifyFrames = DspSimulatorState::kSkipBufferNotifyFrames;
+ }
}
- if (bufferFramesLeft <= mSharedState.bufferNotifyFrames) {
+ if (bufferFramesLeft <= bufferNotifyFrames) {
LOG(DEBUG) << __func__ << ": sending onBufferStateChange: " << bufferFramesLeft;
mSharedState.callback->onBufferStateChange(bufferFramesLeft);
}
@@ -82,9 +92,9 @@
DriverOffloadStubImpl::DriverOffloadStubImpl(const StreamContext& context)
: DriverStubImpl(context, 0 /*asyncSleepTimeUs*/),
+ mBufferNotifyFrames(static_cast<int64_t>(context.getBufferSizeInFrames()) / 2),
mState{context.getFormat().encoding, context.getSampleRate(),
- 250 /*earlyNotifyMs*/ * context.getSampleRate() / MILLIS_PER_SECOND,
- static_cast<int64_t>(context.getBufferSizeInFrames()) / 2},
+ 250 /*earlyNotifyMs*/ * context.getSampleRate() / MILLIS_PER_SECOND},
mDspWorker(mState) {
LOG_IF(FATAL, !mIsAsynchronous) << "The steam must be used in asynchronous mode";
}
@@ -111,6 +121,7 @@
mState.clipFramesLeft.resize(1);
}
}
+ mState.bufferNotifyFrames = DspSimulatorState::kSkipBufferNotifyFrames;
return ::android::OK;
}
@@ -121,6 +132,7 @@
std::lock_guard l(mState.lock);
mState.clipFramesLeft.clear();
mState.bufferFramesLeft = 0;
+ mState.bufferNotifyFrames = DspSimulatorState::kSkipBufferNotifyFrames;
}
return ::android::OK;
}
@@ -128,6 +140,10 @@
::android::status_t DriverOffloadStubImpl::pause() {
RETURN_STATUS_IF_ERROR(DriverStubImpl::pause());
mDspWorker.pause();
+ {
+ std::lock_guard l(mState.lock);
+ mState.bufferNotifyFrames = DspSimulatorState::kSkipBufferNotifyFrames;
+ }
return ::android::OK;
}
@@ -140,6 +156,7 @@
hasClips = !mState.clipFramesLeft.empty();
LOG(DEBUG) << __func__
<< ": clipFramesLeft: " << ::android::internal::ToString(mState.clipFramesLeft);
+ mState.bufferNotifyFrames = DspSimulatorState::kSkipBufferNotifyFrames;
}
if (hasClips) {
mDspWorker.resume();
@@ -184,6 +201,7 @@
{
std::lock_guard l(mState.lock);
mState.bufferFramesLeft = *actualFrameCount;
+ mState.bufferNotifyFrames = mBufferNotifyFrames;
}
mDspWorker.resume();
return ::android::OK;
diff --git a/audio/aidl/vts/VtsHalAECTargetTest.cpp b/audio/aidl/vts/VtsHalAECTargetTest.cpp
index c007f18..2fc126e 100644
--- a/audio/aidl/vts/VtsHalAECTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalAECTargetTest.cpp
@@ -140,12 +140,12 @@
TEST_P(AECParamTest, SetAndGetEchoDelay) {
addEchoDelayParam(mEchoDelay);
- SetAndGetParameters();
+ ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
TEST_P(AECParamTest, SetAndGetMobileMode) {
addMobileModeParam(mMobileMode);
- SetAndGetParameters();
+ ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kDescPair;
diff --git a/audio/aidl/vts/VtsHalAGC1TargetTest.cpp b/audio/aidl/vts/VtsHalAGC1TargetTest.cpp
index 72a2d5e..033cb9d 100644
--- a/audio/aidl/vts/VtsHalAGC1TargetTest.cpp
+++ b/audio/aidl/vts/VtsHalAGC1TargetTest.cpp
@@ -140,17 +140,17 @@
TEST_P(AGC1ParamTest, SetAndGetTargetPeakLevelParam) {
addTargetPeakLevelParam(mTargetPeakLevel);
- SetAndGetParameters();
+ ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
TEST_P(AGC1ParamTest, SetAndGetMaxCompressionGain) {
addMaxCompressionGainParam(mMaxCompressionGain);
- SetAndGetParameters();
+ ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
TEST_P(AGC1ParamTest, SetAndGetEnableLimiter) {
addEnableLimiterParam(mEnableLimiter);
- SetAndGetParameters();
+ ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kDescPair;
diff --git a/audio/aidl/vts/VtsHalAGC2TargetTest.cpp b/audio/aidl/vts/VtsHalAGC2TargetTest.cpp
index ccac8c5..9dec383 100644
--- a/audio/aidl/vts/VtsHalAGC2TargetTest.cpp
+++ b/audio/aidl/vts/VtsHalAGC2TargetTest.cpp
@@ -146,17 +146,17 @@
TEST_P(AGC2ParamTest, SetAndGetDigitalGainParam) {
addDigitalGainParam(mGain);
- SetAndGetParameters();
+ ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
TEST_P(AGC2ParamTest, SetAndGetSaturationMargin) {
addSaturationMarginParam(mMargin);
- SetAndGetParameters();
+ ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
TEST_P(AGC2ParamTest, SetAndGetLevelEstimator) {
addLevelEstimatorParam(mLevelEstimator);
- SetAndGetParameters();
+ ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kDescPair;
diff --git a/audio/aidl/vts/VtsHalAudioCoreConfigTargetTest.cpp b/audio/aidl/vts/VtsHalAudioCoreConfigTargetTest.cpp
index b1c5a1a..713af9a 100644
--- a/audio/aidl/vts/VtsHalAudioCoreConfigTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalAudioCoreConfigTargetTest.cpp
@@ -522,7 +522,8 @@
std::unordered_set<std::string> configurationNames;
for (const AudioHalCapConfiguration& configuration : domain.configurations) {
EXPECT_TRUE(configurationNames.insert(configuration.name).second);
- ValidateAudioHalConfigurationRule(configuration.rule, criteria);
+ ASSERT_NO_FATAL_FAILURE(
+ ValidateAudioHalConfigurationRule(configuration.rule, criteria));
}
auto domainParameters = domain.configurations[0].parameterSettings;
for (const auto& settingParameter : domainParameters) {
@@ -597,7 +598,8 @@
}
EXPECT_NO_FATAL_FAILURE(ValidateAudioHalCapCriterion(criterion.value()));
}
- ValidateAudioHalCapDomains(capCfg.domains.value(), capCfg.criteriaV2.value());
+ ASSERT_NO_FATAL_FAILURE(
+ ValidateAudioHalCapDomains(capCfg.domains.value(), capCfg.criteriaV2.value()));
}
/**
diff --git a/audio/aidl/vts/VtsHalAudioCoreModuleTargetTest.cpp b/audio/aidl/vts/VtsHalAudioCoreModuleTargetTest.cpp
index 21b7aff..806c93f 100644
--- a/audio/aidl/vts/VtsHalAudioCoreModuleTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalAudioCoreModuleTargetTest.cpp
@@ -1025,6 +1025,7 @@
auto [eventSeq, event] = mEventReceiver->waitForEvent(mLastEventSeq);
mLastEventSeq = eventSeq;
if (event != *expEvent) {
+ // TODO: Make available as an error so it can be displayed by GTest
LOG(ERROR) << __func__ << ": expected event " << toString(*expEvent) << ", got "
<< toString(event);
return {};
@@ -1327,7 +1328,8 @@
public:
// To avoid timing out the whole test suite in case no event is received
// from the HAL, use a local timeout for event waiting.
- static constexpr auto kEventTimeoutMs = std::chrono::milliseconds(1000);
+ // TODO: The timeout for 'onTransferReady' should depend on the buffer size.
+ static constexpr auto kEventTimeoutMs = std::chrono::milliseconds(3000);
StreamEventReceiver* getEventReceiver() { return this; }
std::tuple<int, Event> getLastEvent() const override {
@@ -4236,15 +4238,17 @@
enum {
NAMED_CMD_NAME,
NAMED_CMD_MIN_INTERFACE_VERSION,
+ NAMED_CMD_FEATURE_PROPERTY,
NAMED_CMD_DELAY_MS,
NAMED_CMD_STREAM_TYPE,
NAMED_CMD_CMDS,
NAMED_CMD_VALIDATE_POS_INCREASE
};
-enum class StreamTypeFilter { ANY, SYNC, ASYNC };
+enum class StreamTypeFilter { ANY, SYNC, ASYNC, OFFLOAD };
using NamedCommandSequence =
- std::tuple<std::string, int /*minInterfaceVersion*/, int /*cmdDelayMs*/, StreamTypeFilter,
- std::shared_ptr<StateSequence>, bool /*validatePositionIncrease*/>;
+ std::tuple<std::string, int /*minInterfaceVersion*/, std::string /*featureProperty*/,
+ int /*cmdDelayMs*/, StreamTypeFilter, std::shared_ptr<StateSequence>,
+ bool /*validatePositionIncrease*/>;
enum { PARAM_MODULE_NAME, PARAM_CMD_SEQ, PARAM_SETUP_SEQ };
using StreamIoTestParameters =
std::tuple<std::string /*moduleName*/, NamedCommandSequence, bool /*useSetupSequence2*/>;
@@ -4255,11 +4259,24 @@
void SetUp() override {
ASSERT_NO_FATAL_FAILURE(SetUpImpl(std::get<PARAM_MODULE_NAME>(GetParam())));
ASSERT_GE(aidlVersion, kAidlVersion1);
- if (const int minVersion =
- std::get<NAMED_CMD_MIN_INTERFACE_VERSION>(std::get<PARAM_CMD_SEQ>(GetParam()));
- aidlVersion < minVersion) {
+ const int minVersion =
+ std::get<NAMED_CMD_MIN_INTERFACE_VERSION>(std::get<PARAM_CMD_SEQ>(GetParam()));
+ if (aidlVersion < minVersion) {
GTEST_SKIP() << "Skip for audio HAL version lower than " << minVersion;
}
+ // When an associated feature property is defined, need to check that either that the HAL
+ // exposes this property, or it's of the version 'NAMED_CMD_MIN_INTERFACE_VERSION' + 1
+ // which must have this functionality implemented by default.
+ if (const std::string featureProperty =
+ std::get<NAMED_CMD_FEATURE_PROPERTY>(std::get<PARAM_CMD_SEQ>(GetParam()));
+ !featureProperty.empty() && aidlVersion < (minVersion + 1)) {
+ std::vector<VendorParameter> parameters;
+ ScopedAStatus result = module->getVendorParameters({featureProperty}, ¶meters);
+ if (!result.isOk() || parameters.size() != 1) {
+ GTEST_SKIP() << "Skip as audio HAL does not support feature \"" << featureProperty
+ << "\"";
+ }
+ }
ASSERT_NO_FATAL_FAILURE(SetUpModuleConfig());
}
@@ -4300,10 +4317,18 @@
isBitPositionFlagSet(portConfig.flags.value()
.template get<AudioIoFlags::Tag::output>(),
AudioOutputFlags::NON_BLOCKING);
+ const bool isOffload =
+ IOTraits<Stream>::is_input
+ ? false
+ : isBitPositionFlagSet(
+ portConfig.flags.value()
+ .template get<AudioIoFlags::Tag::output>(),
+ AudioOutputFlags::COMPRESS_OFFLOAD);
if (auto streamType =
std::get<NAMED_CMD_STREAM_TYPE>(std::get<PARAM_CMD_SEQ>(GetParam()));
(isNonBlocking && streamType == StreamTypeFilter::SYNC) ||
- (!isNonBlocking && streamType == StreamTypeFilter::ASYNC)) {
+ (!isNonBlocking && streamType == StreamTypeFilter::ASYNC) ||
+ (!isOffload && streamType == StreamTypeFilter::OFFLOAD)) {
continue;
}
WithDebugFlags delayTransientStates = WithDebugFlags::createNested(*debug);
@@ -4760,6 +4785,18 @@
// TODO: Add async test cases for input once it is implemented.
+// Allow optional routing via the TRANSFERRING state on bursts.
+StateDag::Node makeAsyncBurstCommands(StateDag* d, size_t burstCount, StateDag::Node last) {
+ using State = StreamDescriptor::State;
+ std::reference_wrapper<std::remove_reference_t<StateDag::Node>> prev = last;
+ for (size_t i = 0; i < burstCount; ++i) {
+ StateDag::Node active = d->makeNode(State::ACTIVE, kBurstCommand, prev);
+ active.children().push_back(d->makeNode(State::TRANSFERRING, kTransferReadyEvent, prev));
+ prev = active;
+ }
+ return prev;
+}
+
std::shared_ptr<StateSequence> makeBurstCommands(bool isSync, size_t burstCount,
bool standbyInputWhenDone) {
using State = StreamDescriptor::State;
@@ -4776,25 +4813,21 @@
d->makeNodes(State::ACTIVE, kBurstCommand, burstCount, last));
d->makeNode(State::STANDBY, kStartCommand, idle);
} else {
- StateDag::Node active2 = d->makeNode(State::ACTIVE, kBurstCommand, last);
- StateDag::Node active = d->makeNode(State::ACTIVE, kBurstCommand, active2);
+ StateDag::Node active = makeAsyncBurstCommands(d.get(), burstCount, last);
StateDag::Node idle = d->makeNode(State::IDLE, kBurstCommand, active);
- // Allow optional routing via the TRANSFERRING state on bursts.
- active2.children().push_back(d->makeNode(State::TRANSFERRING, kTransferReadyEvent, last));
- active.children().push_back(d->makeNode(State::TRANSFERRING, kTransferReadyEvent, active2));
idle.children().push_back(d->makeNode(State::TRANSFERRING, kTransferReadyEvent, active));
d->makeNode(State::STANDBY, kStartCommand, idle);
}
return std::make_shared<StateSequenceFollower>(std::move(d));
}
static const NamedCommandSequence kReadSeq =
- std::make_tuple(std::string("Read"), kAidlVersion1, 0, StreamTypeFilter::ANY,
+ std::make_tuple(std::string("Read"), kAidlVersion1, "", 0, StreamTypeFilter::ANY,
makeBurstCommands(true), true /*validatePositionIncrease*/);
static const NamedCommandSequence kWriteSyncSeq =
- std::make_tuple(std::string("Write"), kAidlVersion1, 0, StreamTypeFilter::SYNC,
+ std::make_tuple(std::string("Write"), kAidlVersion1, "", 0, StreamTypeFilter::SYNC,
makeBurstCommands(true), true /*validatePositionIncrease*/);
static const NamedCommandSequence kWriteAsyncSeq =
- std::make_tuple(std::string("Write"), kAidlVersion1, 0, StreamTypeFilter::ASYNC,
+ std::make_tuple(std::string("Write"), kAidlVersion1, "", 0, StreamTypeFilter::ASYNC,
makeBurstCommands(false), true /*validatePositionIncrease*/);
std::shared_ptr<StateSequence> makeAsyncDrainCommands(bool isInput) {
@@ -4824,10 +4857,10 @@
return std::make_shared<StateSequenceFollower>(std::move(d));
}
static const NamedCommandSequence kWriteDrainAsyncSeq = std::make_tuple(
- std::string("WriteDrain"), kAidlVersion1, kStreamTransientStateTransitionDelayMs,
+ std::string("WriteDrain"), kAidlVersion1, "", kStreamTransientStateTransitionDelayMs,
StreamTypeFilter::ASYNC, makeAsyncDrainCommands(false), false /*validatePositionIncrease*/);
static const NamedCommandSequence kDrainInSeq =
- std::make_tuple(std::string("Drain"), kAidlVersion1, 0, StreamTypeFilter::ANY,
+ std::make_tuple(std::string("Drain"), kAidlVersion1, "", 0, StreamTypeFilter::ANY,
makeAsyncDrainCommands(true), false /*validatePositionIncrease*/);
std::shared_ptr<StateSequence> makeDrainOutCommands(bool isSync) {
@@ -4849,10 +4882,10 @@
return std::make_shared<StateSequenceFollower>(std::move(d));
}
static const NamedCommandSequence kDrainOutSyncSeq =
- std::make_tuple(std::string("Drain"), kAidlVersion1, 0, StreamTypeFilter::SYNC,
+ std::make_tuple(std::string("Drain"), kAidlVersion1, "", 0, StreamTypeFilter::SYNC,
makeDrainOutCommands(true), false /*validatePositionIncrease*/);
static const NamedCommandSequence kDrainOutAsyncSeq =
- std::make_tuple(std::string("Drain"), kAidlVersion3, 0, StreamTypeFilter::ASYNC,
+ std::make_tuple(std::string("Drain"), kAidlVersion3, "", 0, StreamTypeFilter::ASYNC,
makeDrainOutCommands(false), false /*validatePositionIncrease*/);
std::shared_ptr<StateSequence> makeDrainEarlyOutCommands() {
@@ -4873,9 +4906,32 @@
return std::make_shared<StateSequenceFollower>(std::move(d));
}
static const NamedCommandSequence kDrainEarlyOutAsyncSeq =
- std::make_tuple(std::string("DrainEarly"), kAidlVersion3, 0, StreamTypeFilter::ASYNC,
+ std::make_tuple(std::string("DrainEarly"), kAidlVersion3, "", 0, StreamTypeFilter::ASYNC,
makeDrainEarlyOutCommands(), false /*validatePositionIncrease*/);
+// DRAINING_en ->(onDrainReady) DRAINING_en_sent ->(onDrainReady) IDLE | TRANSFERRING
+std::shared_ptr<StateSequence> makeDrainEarlyOffloadCommands() {
+ using State = StreamDescriptor::State;
+ auto d = std::make_unique<StateDag>();
+ StateDag::Node lastIdle = d->makeFinalNode(State::IDLE);
+ StateDag::Node lastTransferring = d->makeFinalNode(State::TRANSFERRING);
+ // The second onDrainReady event.
+ StateDag::Node continueDraining =
+ d->makeNode(State::DRAINING, kDrainReadyEvent, lastIdle, lastTransferring);
+ // The first onDrainReady event.
+ StateDag::Node draining = d->makeNode(State::DRAINING, kDrainReadyEvent, continueDraining);
+ StateDag::Node drain = d->makeNode(State::ACTIVE, kDrainOutEarlyCommand, draining);
+ StateDag::Node active = makeAsyncBurstCommands(d.get(), 10, drain);
+ StateDag::Node idle = d->makeNode(State::IDLE, kBurstCommand, active);
+ idle.children().push_back(d->makeNode(State::TRANSFERRING, kTransferReadyEvent, active));
+ d->makeNode(State::STANDBY, kStartCommand, idle);
+ return std::make_shared<StateSequenceFollower>(std::move(d));
+}
+static const NamedCommandSequence kDrainEarlyOffloadSeq =
+ std::make_tuple(std::string("DrainEarly"), kAidlVersion3, "aosp.clipTransitionSupport", 0,
+ StreamTypeFilter::OFFLOAD, makeDrainEarlyOffloadCommands(),
+ true /*validatePositionIncrease*/);
+
std::shared_ptr<StateSequence> makeDrainPauseOutCommands(bool isSync) {
using State = StreamDescriptor::State;
auto d = std::make_unique<StateDag>();
@@ -4896,11 +4952,11 @@
return std::make_shared<StateSequenceFollower>(std::move(d));
}
static const NamedCommandSequence kDrainPauseOutSyncSeq =
- std::make_tuple(std::string("DrainPause"), kAidlVersion1,
+ std::make_tuple(std::string("DrainPause"), kAidlVersion1, "",
kStreamTransientStateTransitionDelayMs, StreamTypeFilter::SYNC,
makeDrainPauseOutCommands(true), false /*validatePositionIncrease*/);
static const NamedCommandSequence kDrainPauseOutAsyncSeq =
- std::make_tuple(std::string("DrainPause"), kAidlVersion1,
+ std::make_tuple(std::string("DrainPause"), kAidlVersion1, "",
kStreamTransientStateTransitionDelayMs, StreamTypeFilter::ASYNC,
makeDrainPauseOutCommands(false), false /*validatePositionIncrease*/);
@@ -4919,7 +4975,7 @@
return std::make_shared<StateSequenceFollower>(std::move(d));
}
static const NamedCommandSequence kDrainEarlyPauseOutAsyncSeq =
- std::make_tuple(std::string("DrainEarlyPause"), kAidlVersion3,
+ std::make_tuple(std::string("DrainEarlyPause"), kAidlVersion3, "",
kStreamTransientStateTransitionDelayMs, StreamTypeFilter::ASYNC,
makeDrainEarlyPauseOutCommands(), false /*validatePositionIncrease*/);
@@ -4963,13 +5019,13 @@
return std::make_shared<StateSequenceFollower>(std::move(d));
}
static const NamedCommandSequence kStandbyInSeq =
- std::make_tuple(std::string("Standby"), kAidlVersion1, 0, StreamTypeFilter::ANY,
+ std::make_tuple(std::string("Standby"), kAidlVersion1, "", 0, StreamTypeFilter::ANY,
makeStandbyCommands(true, false), false /*validatePositionIncrease*/);
static const NamedCommandSequence kStandbyOutSyncSeq =
- std::make_tuple(std::string("Standby"), kAidlVersion1, 0, StreamTypeFilter::SYNC,
+ std::make_tuple(std::string("Standby"), kAidlVersion1, "", 0, StreamTypeFilter::SYNC,
makeStandbyCommands(false, true), false /*validatePositionIncrease*/);
static const NamedCommandSequence kStandbyOutAsyncSeq =
- std::make_tuple(std::string("Standby"), kAidlVersion1,
+ std::make_tuple(std::string("Standby"), kAidlVersion1, "",
kStreamTransientStateTransitionDelayMs, StreamTypeFilter::ASYNC,
makeStandbyCommands(false, false), false /*validatePositionIncrease*/);
@@ -5006,15 +5062,15 @@
return std::make_shared<StateSequenceFollower>(std::move(d));
}
static const NamedCommandSequence kPauseInSeq =
- std::make_tuple(std::string("Pause"), kAidlVersion1, 0, StreamTypeFilter::ANY,
+ std::make_tuple(std::string("Pause"), kAidlVersion1, "", 0, StreamTypeFilter::ANY,
makePauseCommands(true, false), false /*validatePositionIncrease*/);
static const NamedCommandSequence kPauseOutSyncSeq =
- std::make_tuple(std::string("Pause"), kAidlVersion1, 0, StreamTypeFilter::SYNC,
+ std::make_tuple(std::string("Pause"), kAidlVersion1, "", 0, StreamTypeFilter::SYNC,
makePauseCommands(false, true), false /*validatePositionIncrease*/);
static const NamedCommandSequence kPauseOutAsyncSeq =
- std::make_tuple(std::string("Pause"), kAidlVersion3, kStreamTransientStateTransitionDelayMs,
- StreamTypeFilter::ASYNC, makePauseCommands(false, false),
- false /*validatePositionIncrease*/);
+ std::make_tuple(std::string("Pause"), kAidlVersion3, "",
+ kStreamTransientStateTransitionDelayMs, StreamTypeFilter::ASYNC,
+ makePauseCommands(false, false), false /*validatePositionIncrease*/);
std::shared_ptr<StateSequence> makeFlushCommands(bool isInput, bool isSync) {
using State = StreamDescriptor::State;
@@ -5042,15 +5098,15 @@
return std::make_shared<StateSequenceFollower>(std::move(d));
}
static const NamedCommandSequence kFlushInSeq =
- std::make_tuple(std::string("Flush"), kAidlVersion1, 0, StreamTypeFilter::ANY,
+ std::make_tuple(std::string("Flush"), kAidlVersion1, "", 0, StreamTypeFilter::ANY,
makeFlushCommands(true, false), false /*validatePositionIncrease*/);
static const NamedCommandSequence kFlushOutSyncSeq =
- std::make_tuple(std::string("Flush"), kAidlVersion1, 0, StreamTypeFilter::SYNC,
+ std::make_tuple(std::string("Flush"), kAidlVersion1, "", 0, StreamTypeFilter::SYNC,
makeFlushCommands(false, true), false /*validatePositionIncrease*/);
static const NamedCommandSequence kFlushOutAsyncSeq =
- std::make_tuple(std::string("Flush"), kAidlVersion1, kStreamTransientStateTransitionDelayMs,
- StreamTypeFilter::ASYNC, makeFlushCommands(false, false),
- false /*validatePositionIncrease*/);
+ std::make_tuple(std::string("Flush"), kAidlVersion1, "",
+ kStreamTransientStateTransitionDelayMs, StreamTypeFilter::ASYNC,
+ makeFlushCommands(false, false), false /*validatePositionIncrease*/);
std::shared_ptr<StateSequence> makeDrainPauseFlushOutCommands(bool isSync) {
using State = StreamDescriptor::State;
@@ -5070,11 +5126,11 @@
return std::make_shared<StateSequenceFollower>(std::move(d));
}
static const NamedCommandSequence kDrainPauseFlushOutSyncSeq =
- std::make_tuple(std::string("DrainPauseFlush"), kAidlVersion1,
+ std::make_tuple(std::string("DrainPauseFlush"), kAidlVersion1, "",
kStreamTransientStateTransitionDelayMs, StreamTypeFilter::SYNC,
makeDrainPauseFlushOutCommands(true), false /*validatePositionIncrease*/);
static const NamedCommandSequence kDrainPauseFlushOutAsyncSeq =
- std::make_tuple(std::string("DrainPauseFlush"), kAidlVersion1,
+ std::make_tuple(std::string("DrainPauseFlush"), kAidlVersion1, "",
kStreamTransientStateTransitionDelayMs, StreamTypeFilter::ASYNC,
makeDrainPauseFlushOutCommands(false), false /*validatePositionIncrease*/);
@@ -5087,6 +5143,8 @@
return "Sync";
case StreamTypeFilter::ASYNC:
return "Async";
+ case StreamTypeFilter::OFFLOAD:
+ return "Offload";
}
return std::string("Unknown").append(std::to_string(static_cast<int32_t>(filter)));
}
@@ -5119,7 +5177,8 @@
kDrainPauseOutAsyncSeq, kDrainEarlyPauseOutAsyncSeq,
kStandbyOutSyncSeq, kStandbyOutAsyncSeq, kPauseOutSyncSeq,
kPauseOutAsyncSeq, kFlushOutSyncSeq, kFlushOutAsyncSeq,
- kDrainPauseFlushOutSyncSeq, kDrainPauseFlushOutAsyncSeq),
+ kDrainPauseFlushOutSyncSeq, kDrainPauseFlushOutAsyncSeq,
+ kDrainEarlyOffloadSeq),
testing::Values(false, true)),
GetStreamIoTestName);
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(AudioStreamIoOut);
diff --git a/audio/aidl/vts/VtsHalAudioEffectFactoryTargetTest.cpp b/audio/aidl/vts/VtsHalAudioEffectFactoryTargetTest.cpp
index a19aa56..5621285 100644
--- a/audio/aidl/vts/VtsHalAudioEffectFactoryTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalAudioEffectFactoryTargetTest.cpp
@@ -56,7 +56,7 @@
/// Effect factory testing.
class EffectFactoryTest : public testing::TestWithParam<std::string> {
public:
- void SetUp() override { connectAndGetFactory(); }
+ void SetUp() override { ASSERT_NO_FATAL_FAILURE(connectAndGetFactory()); }
void TearDown() override {
for (auto& effect : mEffects) {
@@ -253,7 +253,7 @@
creatAndDestroyDescs(descs);
restartAndGetFactory();
- connectAndGetFactory();
+ ASSERT_NO_FATAL_FAILURE(connectAndGetFactory());
creatAndDestroyDescs(descs);
}
@@ -265,7 +265,7 @@
std::vector<std::shared_ptr<IEffect>> effects = createWithDescs(descs);
restartAndGetFactory();
- connectAndGetFactory();
+ ASSERT_NO_FATAL_FAILURE(connectAndGetFactory());
destroyEffects(effects, EX_ILLEGAL_ARGUMENT);
}
diff --git a/audio/aidl/vts/VtsHalDownmixTargetTest.cpp b/audio/aidl/vts/VtsHalDownmixTargetTest.cpp
index 5c5be3a..720a040 100644
--- a/audio/aidl/vts/VtsHalDownmixTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalDownmixTargetTest.cpp
@@ -190,7 +190,7 @@
std::tie(mFactory, mDescriptor) = std::get<PARAM_INSTANCE_NAME>(GetParam());
}
- void SetUp() override { SetUpDownmix(); }
+ void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpDownmix()); }
void TearDown() override { TearDownDownmix(); }
@@ -216,7 +216,7 @@
void SetUp() override {
SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
- SetUpDownmix(mInputChannelLayout);
+ ASSERT_NO_FATAL_FAILURE(SetUpDownmix(mInputChannelLayout));
if (int32_t version;
mEffect->getInterfaceVersion(&version).isOk() && version < kMinDataTestHalVersion) {
GTEST_SKIP() << "Skipping the data test for version: " << version << "\n";
@@ -288,7 +288,7 @@
case AudioChannelLayout::CHANNEL_TOP_BACK_LEFT:
case AudioChannelLayout::CHANNEL_FRONT_WIDE_LEFT:
case AudioChannelLayout::CHANNEL_TOP_SIDE_LEFT:
- checkAtLeft(position);
+ ASSERT_NO_FATAL_FAILURE(checkAtLeft(position));
break;
case AudioChannelLayout::CHANNEL_FRONT_RIGHT:
@@ -300,7 +300,7 @@
case AudioChannelLayout::CHANNEL_FRONT_WIDE_RIGHT:
case AudioChannelLayout::CHANNEL_TOP_SIDE_RIGHT:
case AudioChannelLayout::CHANNEL_LOW_FREQUENCY_2:
- checkAtRight(position);
+ ASSERT_NO_FATAL_FAILURE(checkAtRight(position));
break;
case AudioChannelLayout::CHANNEL_FRONT_CENTER:
@@ -311,17 +311,17 @@
case AudioChannelLayout::CHANNEL_FRONT_RIGHT_OF_CENTER:
case AudioChannelLayout::CHANNEL_TOP_CENTER:
case AudioChannelLayout::CHANNEL_TOP_BACK_CENTER:
- checkAtCenter(position);
+ ASSERT_NO_FATAL_FAILURE(checkAtCenter(position));
break;
case AudioChannelLayout::CHANNEL_LOW_FREQUENCY:
// If CHANNEL_LOW_FREQUENCY_2 is supported
if (mInputChannelLayout & AudioChannelLayout::CHANNEL_LOW_FREQUENCY_2) {
// Validate that only Left channel has audio
- checkAtLeft(position);
+ ASSERT_NO_FATAL_FAILURE(checkAtLeft(position));
} else {
// Validate that both channels have audio
- checkAtCenter(position);
+ ASSERT_NO_FATAL_FAILURE(checkAtCenter(position));
}
break;
}
@@ -371,7 +371,7 @@
}
void SetUp() override {
- SetUpDownmix(mInputChannelLayout);
+ ASSERT_NO_FATAL_FAILURE(SetUpDownmix(mInputChannelLayout));
if (int32_t version;
mEffect->getInterfaceVersion(&version).isOk() && version < kMinDataTestHalVersion) {
GTEST_SKIP() << "Skipping the data test for version: " << version << "\n";
@@ -406,7 +406,7 @@
mInputChannelCount /*channelCount*/, kMaxDownmixSample);
ASSERT_NO_FATAL_FAILURE(
processAndWriteToOutput(mInputBuffer, mOutputBuffer, mEffect, &mOpenEffectReturn));
- validateOutput();
+ ASSERT_NO_FATAL_FAILURE(validateOutput());
}
INSTANTIATE_TEST_SUITE_P(
diff --git a/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp b/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp
index 2bb0a72..2ce7b51 100644
--- a/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp
+++ b/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp
@@ -39,6 +39,8 @@
using aidl::android::hardware::audio::effect::Parameter;
using android::hardware::audio::common::testing::detail::TestExecutionTracer;
+constexpr int32_t kMinDataTestHalVersion = 3;
+
/**
* Here we focus on specific parameter checking, general IEffect interfaces testing performed in
* VtsAudioEffectTargetTest.
@@ -139,6 +141,8 @@
void addLimiterConfig(const std::vector<DynamicsProcessing::LimiterConfig>& cfg);
void addInputGain(const std::vector<DynamicsProcessing::InputGain>& inputGain);
+ void checkHalVersion();
+
static constexpr float kPreferredProcessingDurationMs = 10.0f;
static constexpr int kBandCount = 5;
static constexpr int kSamplingFrequency = 44100;
@@ -548,6 +552,13 @@
mTags.push_back({DynamicsProcessing::inputGain, dp});
}
+void DynamicsProcessingTestHelper::checkHalVersion() {
+ if (int32_t version;
+ mEffect->getInterfaceVersion(&version).isOk() && version < kMinDataTestHalVersion) {
+ GTEST_SKIP() << "Skipping the data test for version: " << version << "\n";
+ }
+}
+
void fillLimiterConfig(std::vector<DynamicsProcessing::LimiterConfig>& limiterConfigList,
int channelIndex, bool enable, int linkGroup, float attackTime,
float releaseTime, float ratio, float threshold, float postGain) {
@@ -585,10 +596,10 @@
}
DynamicsProcessing::EqBandConfig creatEqBandConfig(int channel, int band, float cutOffFreqHz,
- float gainDb) {
+ float gainDb, bool enable) {
return DynamicsProcessing::EqBandConfig{.channel = channel,
.band = band,
- .enable = true,
+ .enable = enable,
.cutoffFrequencyHz = cutOffFreqHz,
.gainDb = gainDb};
}
@@ -624,7 +635,7 @@
fillEngineArchConfig(mCfg, GetParam());
};
- void SetUp() override { SetUpDynamicsProcessingEffect(); }
+ void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpDynamicsProcessingEffect()); }
void TearDown() override { TearDownDynamicsProcessingEffect(); }
@@ -676,7 +687,7 @@
: DynamicsProcessingTestHelper(std::get<INPUT_GAIN_INSTANCE_NAME>(GetParam())),
mInputGain(std::get<INPUT_GAIN_PARAM>(GetParam())) {};
- void SetUp() override { SetUpDynamicsProcessingEffect(); }
+ void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpDynamicsProcessingEffect()); }
void TearDown() override { TearDownDynamicsProcessingEffect(); }
@@ -715,7 +726,10 @@
mInput.resize(kFrameCount * mChannelCount);
}
- void SetUp() override { setUpDataTest({static_cast<int>(kInputFrequency)}, kSineFullScaleDb); }
+ void SetUp() override {
+ ASSERT_NO_FATAL_FAILURE(
+ setUpDataTest({static_cast<int>(kInputFrequency)}, kSineFullScaleDb));
+ }
void TearDown() override { TearDownDynamicsProcessingEffect(); }
@@ -793,7 +807,7 @@
fillLimiterConfig(mLimiterConfigList, GetParam());
}
- void SetUp() override { SetUpDynamicsProcessingEffect(); }
+ void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpDynamicsProcessingEffect()); }
void TearDown() override { TearDownDynamicsProcessingEffect(); }
@@ -843,7 +857,10 @@
mInput.resize(mBufferSize);
}
- void SetUp() override { setUpDataTest({static_cast<int>(kInputFrequency)}, kSineFullScaleDb); }
+ void SetUp() override {
+ ASSERT_NO_FATAL_FAILURE(
+ setUpDataTest({static_cast<int>(kInputFrequency)}, kSineFullScaleDb));
+ }
void TearDown() override { TearDownDynamicsProcessingEffect(); }
@@ -1011,7 +1028,7 @@
: DynamicsProcessingTestHelper(std::get<BAND_CHANNEL_TEST_INSTANCE_NAME>(GetParam())),
mCfg(std::get<BAND_CHANNEL_TEST_CHANNEL_CONFIG>(GetParam())) {}
- void SetUp() override { SetUpDynamicsProcessingEffect(); }
+ void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpDynamicsProcessingEffect()); }
void TearDown() override { TearDownDynamicsProcessingEffect(); }
@@ -1075,7 +1092,8 @@
int bandCount = cutOffFreqs.size();
for (int i = 0; i < bandCount; i++) {
cfgs.push_back(creatEqBandConfig(std::get<EQ_BAND_CHANNEL>(params), cutOffFreqs[i].first,
- cutOffFreqs[i].second, std::get<EQ_BAND_GAIN>(params)));
+ cutOffFreqs[i].second, std::get<EQ_BAND_GAIN>(params),
+ true));
}
}
@@ -1087,7 +1105,7 @@
fillEqBandConfig(mCfgs, GetParam());
}
- void SetUp() override { SetUpDynamicsProcessingEffect(); }
+ void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpDynamicsProcessingEffect()); }
void TearDown() override { TearDownDynamicsProcessingEffect(); }
@@ -1223,15 +1241,16 @@
}
void fillEqBandConfig(std::vector<DynamicsProcessing::EqBandConfig>& cfgs, int channelIndex,
- int bandIndex, int cutOffFreqHz, float gainDb) {
+ int bandIndex, int cutOffFreqHz, float gainDb, bool enable) {
cfgs.push_back(creatEqBandConfig(channelIndex, bandIndex, static_cast<float>(cutOffFreqHz),
- gainDb));
+ gainDb, enable));
}
- void validateOutput(const std::vector<float>& output, float gainDb, size_t bandIndex) {
+ void validateOutput(const std::vector<float>& output, float gainDb, size_t bandIndex,
+ bool enable) {
std::vector<float> outputMag(mBinOffsets.size());
EXPECT_NO_FATAL_FAILURE(getMagnitudeValue(output, outputMag));
- if (gainDb == 0) {
+ if (gainDb == 0 || !enable) {
EXPECT_NO_FATAL_FAILURE(checkInputAndOutputEquality(outputMag));
} else if (gainDb > 0) {
// For positive gain, current band's magnitude is greater than the other band's
@@ -1243,19 +1262,19 @@
}
}
- void analyseMultiBandOutput(float gainDb, bool isPreEq) {
+ void analyseMultiBandOutput(float gainDb, bool isPreEq, bool enable = true) {
std::vector<float> output(mInput.size());
roundToFreqCenteredToFftBin(mMultitoneTestFrequencies, mBinOffsets, kBinWidth);
// Set Equalizer values for two bands
for (size_t i = 0; i < kCutoffFreqHz.size(); i++) {
for (int channelIndex = 0; channelIndex < mChannelCount; channelIndex++) {
- fillEqBandConfig(mCfgs, channelIndex, i, kCutoffFreqHz[i], gainDb);
- fillEqBandConfig(mCfgs, channelIndex, i ^ 1, kCutoffFreqHz[i ^ 1], 0);
+ fillEqBandConfig(mCfgs, channelIndex, i, kCutoffFreqHz[i], gainDb, enable);
+ fillEqBandConfig(mCfgs, channelIndex, i ^ 1, kCutoffFreqHz[i ^ 1], 0, enable);
}
ASSERT_NO_FATAL_FAILURE(setEqParamAndProcess(output, isPreEq));
if (isAllParamsValid()) {
- ASSERT_NO_FATAL_FAILURE(validateOutput(output, gainDb, i));
+ ASSERT_NO_FATAL_FAILURE(validateOutput(output, gainDb, i, enable));
}
cleanUpEqConfig();
}
@@ -1291,6 +1310,16 @@
}
}
+TEST_P(DynamicsProcessingEqBandConfigDataTest, PreEqEnableDisable) {
+ ASSERT_NO_FATAL_FAILURE(analyseMultiBandOutput(10 /*gain dB*/, true /*pre-equalizer*/,
+ false /*disable equalizer*/));
+}
+
+TEST_P(DynamicsProcessingEqBandConfigDataTest, PostEqEnableDisable) {
+ ASSERT_NO_FATAL_FAILURE(analyseMultiBandOutput(10 /*gain dB*/, false /*post-equalizer*/,
+ false /*disable equalizer*/));
+}
+
INSTANTIATE_TEST_SUITE_P(DynamicsProcessingTest, DynamicsProcessingEqBandConfigDataTest,
testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),
@@ -1368,7 +1397,7 @@
fillMbcBandConfig(mCfgs, GetParam());
}
- void SetUp() override { SetUpDynamicsProcessingEffect(); }
+ void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpDynamicsProcessingEffect()); }
void TearDown() override { TearDownDynamicsProcessingEffect(); }
@@ -1541,6 +1570,51 @@
}
}
+TEST_P(DynamicsProcessingMbcBandConfigDataTest, IncreasingPreGain) {
+ /*
+ Depending on the pregain values, samples undergo either compression or expansion process.
+ At -6 dB input,
+ - Expansion is expected at -60 dB,
+ - Compression at 10, 34 and 60 dB
+ - No compression or expansion at -34, -10, -1 dB.
+ */
+ std::vector<float> preGainDbValues = {-60, -34, -10, -1, 10, 34, 60};
+ std::vector<float> output(mInput.size());
+ float thresholdDb = -7;
+ float noiseGateDb = -40;
+ std::vector<float> ratioValues = {1, 1.5, 2, 2.5, 3};
+ for (float ratio : ratioValues) {
+ for (float preGainDb : preGainDbValues) {
+ float expectedOutputDb;
+ float inputWithPreGain = mInputDb + preGainDb;
+ if (inputWithPreGain > thresholdDb) {
+ SCOPED_TRACE("Compressor ratio: " + std::to_string(ratio));
+ expectedOutputDb =
+ (inputWithPreGain - thresholdDb) / ratio + thresholdDb - preGainDb;
+ } else if (inputWithPreGain < noiseGateDb) {
+ SCOPED_TRACE("Expander ratio: " + std::to_string(ratio));
+ expectedOutputDb =
+ (inputWithPreGain - noiseGateDb) * ratio + noiseGateDb - preGainDb;
+ } else {
+ expectedOutputDb = mInputDb;
+ }
+ cleanUpMbcConfig();
+ for (int i = 0; i < mChannelCount; i++) {
+ fillMbcBandConfig(mCfgs, i, thresholdDb, ratio /*compressor ratio*/, noiseGateDb,
+ ratio /*expander ratio*/, 0 /*band index*/,
+ 2000 /*cutoffFrequency*/, preGainDb, kDefaultPostGainDb);
+ }
+ EXPECT_NO_FATAL_FAILURE(setMbcParamsAndProcess(output));
+ if (!isAllParamsValid()) {
+ continue;
+ }
+ float outputDb = calculateDb(output, kStartIndex);
+ EXPECT_NEAR(outputDb, expectedOutputDb, kToleranceDb)
+ << "PreGain: " << preGainDb << ", OutputDb: " << outputDb;
+ }
+ }
+}
+
INSTANTIATE_TEST_SUITE_P(DynamicsProcessingTest, DynamicsProcessingMbcBandConfigDataTest,
testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),
diff --git a/audio/aidl/vts/VtsHalEnvironmentalReverbTargetTest.cpp b/audio/aidl/vts/VtsHalEnvironmentalReverbTargetTest.cpp
index 0222923..9b1a3b3 100644
--- a/audio/aidl/vts/VtsHalEnvironmentalReverbTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalEnvironmentalReverbTargetTest.cpp
@@ -305,7 +305,7 @@
: EnvironmentalReverbHelper(std::get<DESCRIPTOR_INDEX>(GetParam())) {
std::tie(mTag, mParamValue) = std::get<TAG_VALUE_PAIR>(GetParam());
}
- void SetUp() override { SetUpReverb(); }
+ void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpReverb()); }
void TearDown() override { TearDownReverb(); }
EnvironmentalReverb::Tag mTag;
@@ -350,7 +350,7 @@
SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
ASSERT_NO_FATAL_FAILURE(
generateSineWave(kInputFrequency, mInput, 1.0, kSamplingFrequency, mChannelLayout));
- SetUpReverb();
+ ASSERT_NO_FATAL_FAILURE(SetUpReverb());
}
void TearDown() override {
SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
@@ -387,11 +387,11 @@
};
TEST_P(EnvironmentalReverbDataTest, IncreasingParamValue) {
- assertEnergyIncreasingWithParameter(false);
+ ASSERT_NO_FATAL_FAILURE(assertEnergyIncreasingWithParameter(false));
}
TEST_P(EnvironmentalReverbDataTest, WithBypassEnabled) {
- assertZeroEnergyWithBypass(true);
+ ASSERT_NO_FATAL_FAILURE(assertZeroEnergyWithBypass(true));
}
INSTANTIATE_TEST_SUITE_P(
@@ -420,7 +420,7 @@
}
void SetUp() override {
SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
- SetUpReverb();
+ ASSERT_NO_FATAL_FAILURE(SetUpReverb());
createEnvParam(EnvironmentalReverb::roomLevelMb, kMinRoomLevel);
ASSERT_NO_FATAL_FAILURE(
setAndVerifyParam(EX_NONE, mEnvParam, EnvironmentalReverb::roomLevelMb));
@@ -478,7 +478,7 @@
SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
ASSERT_NO_FATAL_FAILURE(
generateSineWave(kInputFrequency, mInput, 1.0, kSamplingFrequency, mChannelLayout));
- SetUpReverb();
+ ASSERT_NO_FATAL_FAILURE(SetUpReverb());
}
void TearDown() override {
SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
@@ -559,7 +559,7 @@
ASSERT_NO_FATAL_FAILURE(generateSineWave(kInputFrequency, mInput, 1.0,
kSamplingFrequency, mChannelLayout));
}
- SetUpReverb();
+ ASSERT_NO_FATAL_FAILURE(SetUpReverb());
}
void TearDown() override {
SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
diff --git a/audio/aidl/vts/VtsHalLoudnessEnhancerTargetTest.cpp b/audio/aidl/vts/VtsHalLoudnessEnhancerTargetTest.cpp
index ace0597..b1515bc 100644
--- a/audio/aidl/vts/VtsHalLoudnessEnhancerTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalLoudnessEnhancerTargetTest.cpp
@@ -133,7 +133,7 @@
std::tie(mFactory, mDescriptor) = std::get<PARAM_INSTANCE_NAME>(GetParam());
}
- void SetUp() override { SetUpLoudnessEnhancer(); }
+ void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpLoudnessEnhancer()); }
void TearDown() override { TearDownLoudnessEnhancer(); }
int mParamGainMb = 0;
};
@@ -164,7 +164,7 @@
void SetUp() override {
SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
- SetUpLoudnessEnhancer();
+ ASSERT_NO_FATAL_FAILURE(SetUpLoudnessEnhancer());
// Creating AidlMessageQueues
mStatusMQ = std::make_unique<EffectHelper::StatusMQ>(mOpenEffectReturn.statusMQ);
@@ -255,13 +255,13 @@
TEST_P(LoudnessEnhancerDataTest, IncreasingGains) {
static const std::vector<int> kIncreasingGains = {50, 100};
- assertSequentialGains(kIncreasingGains, true /*isIncreasing*/);
+ ASSERT_NO_FATAL_FAILURE(assertSequentialGains(kIncreasingGains, true /*isIncreasing*/));
}
TEST_P(LoudnessEnhancerDataTest, DecreasingGains) {
static const std::vector<int> kDecreasingGains = {-50, -100};
- assertSequentialGains(kDecreasingGains, false /*isIncreasing*/);
+ ASSERT_NO_FATAL_FAILURE(assertSequentialGains(kDecreasingGains, false /*isIncreasing*/));
}
TEST_P(LoudnessEnhancerDataTest, MinimumGain) {
diff --git a/audio/aidl/vts/VtsHalNSTargetTest.cpp b/audio/aidl/vts/VtsHalNSTargetTest.cpp
index c5a9bad..0618048 100644
--- a/audio/aidl/vts/VtsHalNSTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalNSTargetTest.cpp
@@ -141,12 +141,12 @@
TEST_P(NSParamTest, SetAndGetLevel) {
addLevelParam(mLevel);
- SetAndGetParameters();
+ ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
TEST_P(NSParamTest, SetAndGetType) {
addLevelParam(mLevel);
- SetAndGetParameters();
+ ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
INSTANTIATE_TEST_SUITE_P(
diff --git a/audio/aidl/vts/VtsHalPresetReverbTargetTest.cpp b/audio/aidl/vts/VtsHalPresetReverbTargetTest.cpp
index f127c81..3fbda96 100644
--- a/audio/aidl/vts/VtsHalPresetReverbTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalPresetReverbTargetTest.cpp
@@ -187,13 +187,13 @@
std::vector<PresetReverb::Presets> roomPresets = {PresetReverb::Presets::LARGEROOM,
PresetReverb::Presets::MEDIUMROOM,
PresetReverb::Presets::SMALLROOM};
- validateIncreasingEnergy(roomPresets);
+ ASSERT_NO_FATAL_FAILURE(validateIncreasingEnergy(roomPresets));
}
TEST_P(PresetReverbProcessTest, DecreasingHallSize) {
std::vector<PresetReverb::Presets> hallPresets = {PresetReverb::Presets::LARGEHALL,
PresetReverb::Presets::MEDIUMHALL};
- validateIncreasingEnergy(hallPresets);
+ ASSERT_NO_FATAL_FAILURE(validateIncreasingEnergy(hallPresets));
}
TEST_P(PresetReverbProcessTest, PresetPlate) {
diff --git a/audio/aidl/vts/VtsHalVisualizerTargetTest.cpp b/audio/aidl/vts/VtsHalVisualizerTargetTest.cpp
index f019e2a..586ed67 100644
--- a/audio/aidl/vts/VtsHalVisualizerTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalVisualizerTargetTest.cpp
@@ -183,7 +183,7 @@
generateInputBuffer(mInputBuffer, 0, true, mChannelCount, kMaxAudioSampleValue);
}
- void SetUp() override { SetUpVisualizer(); }
+ void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpVisualizer()); }
void TearDown() override { TearDownVisualizer(); }
@@ -252,7 +252,7 @@
std::get<PARAM_SCALING_MODE>(GetParam()),
std::get<PARAM_MEASUREMENT_MODE>(GetParam())) {}
- void SetUp() override { SetUpVisualizer(); }
+ void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpVisualizer()); }
void TearDown() override { TearDownVisualizer(); }
};