Snap for 10566461 from bac5c56d7f55a6dbf0d4fc0e6b9a1afd63017130 to udc-qpr1-release (41c5d312) · Commits · e / os / android_frameworks_av

media/libaudiohal/impl/DeviceHalAidl.cpp

+49 −0

Original line number	Diff line number	Diff line
		@@ -293,6 +293,9 @@ status_t DeviceHalAidl::setParameters(const String8& kvPairs) {
		if (status_t status = filterAndUpdateScreenParameters(parameters); status != OK) {
		ALOGW("%s: filtering or updating screen parameters failed: %d", __func__, status);
		}
		if (status_t status = filterAndUpdateTelephonyParameters(parameters); status != OK) {
		ALOGW("%s: filtering or updating telephony parameters failed: %d", __func__, status);
		}
		return parseAndSetVendorParameters(mVendorExt, mModule, parameters);
		}

		@@ -1370,6 +1373,52 @@ status_t DeviceHalAidl::filterAndUpdateScreenParameters(AudioParameter &paramete
		return OK;
		}

		status_t DeviceHalAidl::filterAndUpdateTelephonyParameters(AudioParameter &parameters) {
		TIME_CHECK();
		using TtyMode = ITelephony::TelecomConfig::TtyMode;
		ITelephony::TelecomConfig telConfig;
		(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
		parameters, String8(AudioParameter::keyTtyMode),
		[&telConfig](const String8& mode) {
		if (mode == AudioParameter::valueTtyModeOff) {
		telConfig.ttyMode = TtyMode::OFF;
		return OK;
		} else if (mode == AudioParameter::valueTtyModeFull) {
		telConfig.ttyMode = TtyMode::FULL;
		return OK;
		} else if (mode == AudioParameter::valueTtyModeHco) {
		telConfig.ttyMode = TtyMode::HCO;
		return OK;
		} else if (mode == AudioParameter::valueTtyModeVco) {
		telConfig.ttyMode = TtyMode::VCO;
		return OK;
		}
		ALOGE("setParameters: parameter key \"%s\" has invalid value \"%s\"",
		AudioParameter::keyTtyMode, mode.c_str());
		return BAD_VALUE;
		}));
		(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
		parameters, String8(AudioParameter::keyHacSetting),
		[&telConfig](const String8& onOrOff) {
		if (onOrOff == AudioParameter::valueHacOn) {
		telConfig.isHacEnabled = Boolean{ .value = true };
		return OK;
		} else if (onOrOff == AudioParameter::valueHacOff) {
		telConfig.isHacEnabled = Boolean{ .value = false };
		return OK;
		}
		ALOGE("setParameters: parameter key \"%s\" has invalid value \"%s\"",
		AudioParameter::keyHacSetting, onOrOff.c_str());
		return BAD_VALUE;
		}));
		if (mTelephony != nullptr && telConfig != ITelephony::TelecomConfig{}) {
		ITelephony::TelecomConfig newTelConfig;
		return statusTFromBinderStatus(
		mTelephony->setTelecomConfig(telConfig, &newTelConfig));
		}
		return OK;
		}

		status_t DeviceHalAidl::findOrCreatePatch(
		const AudioPatch& requestedPatch, AudioPatch* patch, bool* created) {
		std::set<int32_t> sourcePortConfigIds(requestedPatch.sourcePortConfigIds.begin(),

media/libaudiohal/impl/DeviceHalAidl.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -224,6 +224,7 @@ class DeviceHalAidl : public DeviceHalInterface, public ConversionHelperAidl,
		status_t filterAndUpdateBtLeParameters(AudioParameter &parameters);
		status_t filterAndUpdateBtScoParameters(AudioParameter &parameters);
		status_t filterAndUpdateScreenParameters(AudioParameter &parameters);
		status_t filterAndUpdateTelephonyParameters(AudioParameter &parameters);
		status_t findOrCreatePatch(
		const std::set<int32_t>& sourcePortConfigIds,
		const std::set<int32_t>& sinkPortConfigIds,

media/libaudiohal/impl/EffectConversionHelperAidl.cpp

+8 −3

Original line number	Diff line number	Diff line
		@@ -209,12 +209,12 @@ status_t EffectConversionHelperAidl::handleSetConfig(uint32_t cmdSize, const voi
		mEffect->close();
		return status;
		}
		mCommon = common;
		} else if (mCommon != common) {
		ALOGI("%s at state %s, setParameter", __func__, android::internal::ToString(state).c_str());
		Parameter aidlParam = UNION_MAKE(Parameter, common, mCommon);
		Parameter aidlParam = UNION_MAKE(Parameter, common, common);
		RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->setParameter(aidlParam)));
		}
		mCommon = common;

		return static_cast<int32_t>(pReplyData) = OK;
		}
		@@ -352,9 +352,14 @@ status_t EffectConversionHelperAidl::handleSetOffload(uint32_t cmdSize, const vo
		if (mIsProxyEffect) {
		ALOGI("%s offload param offload %s ioHandle %d", __func__,
		offload->isOffload ? "true" : "false", offload->ioHandle);
		mCommon.ioHandle = offload->ioHandle;
		const auto& effectProxy = std::static_pointer_cast<EffectProxy>(mEffect);
		RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(effectProxy->setOffloadParam(offload)));
		if (mCommon.ioHandle != offload->ioHandle) {
		ALOGI("%s ioHandle update [%d to %d]", __func__, mCommon.ioHandle, offload->ioHandle);
		mCommon.ioHandle = offload->ioHandle;
		Parameter aidlParam = UNION_MAKE(Parameter, common, mCommon);
		RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->setParameter(aidlParam)));
		}
		// update FMQs if the effect instance already open
		if (State state; effectProxy->getState(&state).isOk() && state != State::INIT) {
		mStatusQ = effectProxy->getStatusMQ();

media/libaudiohal/impl/EffectProxy.cpp

+11 −6

Original line number	Diff line number	Diff line
		@@ -15,6 +15,7 @@
		*/

		#include <algorithm>
		#include <cstddef>
		#include <iterator>
		#include <memory>
		#define LOG_TAG "EffectProxy"
		@@ -90,12 +91,16 @@ ndk::ScopedAStatus EffectProxy::setOffloadParam(const effect_offload_param_t* of
		"noActiveEffctFound");
		}

		mActiveSubIdx = std::distance(mSubEffects.begin(), itor);
		ALOGV("%s: active %soffload sub-effect %zu descriptor: %s", __func__,
		const size_t newIndex = std::distance(mSubEffects.begin(), itor);
		mActiveSubIdx = newIndex;

		ALOGI("%s: active %soffload sub-effect %zu descriptor: %s", __func__,
		offload->isOffload ? "" : "non-", mActiveSubIdx,
		::android::audio::utils::toString(mSubEffects[mActiveSubIdx].descriptor.common.id.uuid)
		.c_str());
		return ndk::ScopedAStatus::ok();
		return runWithAllSubEffects([&](std::shared_ptr<IEffect>& effect) {
		return effect->setParameter(Parameter::make<Parameter::offload>(offload->isOffload));
		});
		}

		// EffectProxy go over sub-effects and call IEffect interfaces
		@@ -133,8 +138,8 @@ ndk::ScopedAStatus EffectProxy::close() {
		}

		ndk::ScopedAStatus EffectProxy::getDescriptor(Descriptor* desc) {
		desc->common = mDescriptorCommon;
		desc->capability = mSubEffects[mActiveSubIdx].descriptor.capability;
		*desc = mSubEffects[mActiveSubIdx].descriptor;
		desc->common.id.uuid = desc->common.id.proxy.value();
		return ndk::ScopedAStatus::ok();
		}

		@@ -168,7 +173,7 @@ Descriptor::Common EffectProxy::buildDescriptorCommon(
		// same as HIDL EffectProxy flags
		common.flags.type = Flags::Type::INSERT;
		common.flags.insert = Flags::Insert::LAST;
		common.flags.volume = Flags::Volume::CTRL;
		common.flags.volume = Flags::Volume::NONE;

		// set indication if any sub-effect indication was set
		common.flags.offloadIndication \|= desc.common.flags.offloadIndication;

media/libaudiohal/tests/EffectProxy_test.cpp

+21 −22

Original line number	Diff line number	Diff line
		@@ -53,7 +53,9 @@ class EffectProxyTest : public testing::Test {
		void SetUp() override {
		auto serviceName = android::getAidlHalInstanceNames(IFactory::descriptor);
		// only unit test with the first one in case more than one EffectFactory service exist
		ASSERT_NE(0ul, serviceName.size());
		if (0ul == serviceName.size()) {
		GTEST_SKIP() << "EffectFactory not available on device, skipping";
		}
		mFactory = IFactory::fromBinder(
		ndk::SpAIBinder(AServiceManager_waitForService(serviceName[0].c_str())));
		ASSERT_NE(nullptr, mFactory);
		@@ -157,6 +159,7 @@ TEST_F(EffectProxyTest, setOffloadParam) {
		effect_offload_param_t offloadParam{false, 0};
		EXPECT_TRUE(proxy->setOffloadParam(&offloadParam).isOk());
		offloadParam.isOffload = true;
		offloadParam.ioHandle++;
		EXPECT_TRUE(proxy->setOffloadParam(&offloadParam).isOk());
		EXPECT_TRUE(proxy->close().isOk());
		EXPECT_TRUE(proxy->destroy().isOk());
		@@ -189,21 +192,21 @@ TEST_F(EffectProxyTest, normalSequency) {
		Parameter::Common common = createParamCommon();
		IEffect::OpenEffectReturn ret;
		Parameter::VolumeStereo volumeStereo({.left = .1f, .right = -0.8f});
		Parameter param = Parameter::make<Parameter::volumeStereo>(volumeStereo);
		Parameter::Id id = Parameter::Id::make<Parameter::Id::commonTag>(Parameter::volumeStereo);
		Parameter expect = Parameter::make<Parameter::volumeStereo>(volumeStereo);
		const Parameter::Id id = Parameter::Id::make<Parameter::Id::commonTag>(Parameter::volumeStereo);
		State state;
		for (const auto& itor : proxyMap) {
		Parameter expect;
		Parameter getParam = Parameter::make<Parameter::offload>(true);
		auto& proxy = std::get<TupleIndex::HANDLE>(itor.second);
		effect_offload_param_t offloadParam{true, 0};
		EXPECT_TRUE(proxy->setOffloadParam(&offloadParam).isOk());

		EXPECT_TRUE(proxy->open(common, std::nullopt, &ret).isOk());

		EXPECT_TRUE(proxy->setParameter(param).isOk());
		EXPECT_TRUE(proxy->getParameter(id, &expect).isOk());
		EXPECT_EQ(expect, param) << " EXPECTED: " << expect.toString()
		<< "\nACTUAL: " << param.toString();
		EXPECT_TRUE(proxy->setParameter(expect).isOk());
		EXPECT_TRUE(proxy->getParameter(id, &getParam).isOk());
		EXPECT_EQ(expect, getParam)
		<< " EXPECTED: " << expect.toString() << "\nACTUAL: " << getParam.toString();

		EXPECT_TRUE(proxy->command(CommandId::START).isOk());
		EXPECT_TRUE(proxy->getState(&state).isOk());
		@@ -225,25 +228,25 @@ TEST_F(EffectProxyTest, changeActiveSubAndVerifyParameter) {
		Parameter::Common common = createParamCommon();
		IEffect::OpenEffectReturn ret;
		Parameter::VolumeStereo volumeStereo({.left = .5f, .right = .8f});
		Parameter param = Parameter::make<Parameter::volumeStereo>(volumeStereo);
		Parameter::Id id = Parameter::Id::make<Parameter::Id::commonTag>(Parameter::volumeStereo);
		Parameter expect = Parameter::make<Parameter::volumeStereo>(volumeStereo);
		const Parameter::Id id = Parameter::Id::make<Parameter::Id::commonTag>(Parameter::volumeStereo);
		for (const auto& itor : proxyMap) {
		Parameter expect;
		Parameter getParam = Parameter::make<Parameter::offload>(true);
		auto& proxy = std::get<TupleIndex::HANDLE>(itor.second);
		EXPECT_TRUE(proxy->open(common, std::nullopt, &ret).isOk());
		EXPECT_TRUE(proxy->setParameter(param).isOk());
		EXPECT_TRUE(proxy->getParameter(id, &expect).isOk());
		EXPECT_EQ(expect, param);
		EXPECT_TRUE(proxy->setParameter(expect).isOk());
		EXPECT_TRUE(proxy->getParameter(id, &getParam).isOk());
		EXPECT_EQ(expect, getParam);

		effect_offload_param_t offloadParam{false, 0};
		EXPECT_TRUE(proxy->setOffloadParam(&offloadParam).isOk());
		EXPECT_TRUE(proxy->getParameter(id, &expect).isOk());
		EXPECT_EQ(expect, param);
		EXPECT_TRUE(proxy->getParameter(id, &getParam).isOk());
		EXPECT_EQ(expect, getParam);

		offloadParam.isOffload = true;
		EXPECT_TRUE(proxy->setOffloadParam(&offloadParam).isOk());
		EXPECT_TRUE(proxy->getParameter(id, &expect).isOk());
		EXPECT_EQ(expect, param);
		EXPECT_TRUE(proxy->getParameter(id, &getParam).isOk());
		EXPECT_EQ(expect, getParam);

		EXPECT_TRUE(proxy->close().isOk());
		EXPECT_TRUE(proxy->destroy().isOk());
		@@ -271,13 +274,9 @@ TEST_F(EffectProxyTest, changeActiveSubAndVerifyState) {

		effect_offload_param_t offloadParam{false, 0};
		EXPECT_TRUE(proxy->setOffloadParam(&offloadParam).isOk());
		EXPECT_TRUE(proxy->getState(&state).isOk());
		EXPECT_EQ(State::PROCESSING, state);

		offloadParam.isOffload = true;
		EXPECT_TRUE(proxy->setOffloadParam(&offloadParam).isOk());
		EXPECT_TRUE(proxy->getState(&state).isOk());
		EXPECT_EQ(State::PROCESSING, state);

		EXPECT_TRUE(proxy->command(CommandId::STOP).isOk());
		EXPECT_TRUE(proxy->getState(&state).isOk());