Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 849ba4cc authored by Shunkai Yao's avatar Shunkai Yao
Browse files

Update offload ioHandle to effects 

Bug: 271500140
Test: Enavble AIDL
Test: atest EffectProxyTest
Change-Id: I3705b3bfed33caf139dadbff9871be34b7ee906e
parent b2bcebca

media/libaudiohal/impl/EffectConversionHelperAidl.cpp

+8 −3
Original line number Diff line number Diff line
@@ -208,12 +208,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;

}
@@ -351,9 +351,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

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



#include <algorithm>

#include <cstddef>

#include <iterator>

#include <memory>

#define LOG_TAG "EffectProxy"
@@ -91,12 +92,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

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());