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

Commit 4f16bdc7 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 10368302 from a4a7a0b4 to udc-qpr1-release 

Change-Id: I8d0b4a0f2bb6540d3c5099f2fa5244f3359d7fc0
parents b82c62ca a4a7a0b4

media/libaudiohal/impl/DeviceHalAidl.cpp

+51 −11
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ 
#include <utils/Log.h>



#include "DeviceHalAidl.h"

#include "EffectHalAidl.h"

#include "StreamHalAidl.h"



using aidl::android::aidl_utils::statusTFromBinderStatus;
@@ -882,25 +883,64 @@ status_t DeviceHalAidl::getMicrophones( 
    return OK;

}



status_t DeviceHalAidl::addDeviceEffect(const struct audio_port_config *device __unused,

        sp<EffectHalInterface> effect) {

status_t DeviceHalAidl::addDeviceEffect(

        const struct audio_port_config *device, sp<EffectHalInterface> effect) {

    TIME_CHECK();

    if (!mModule) return NO_INIT;

    if (!effect) {

        return BAD_VALUE;

    }

    TIME_CHECK();

    if (!mModule) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    bool isInput = VALUE_OR_RETURN_STATUS(::aidl::android::portDirection(

                    device->role, device->type)) == ::aidl::android::AudioPortDirection::INPUT;

    auto requestedPortConfig = VALUE_OR_RETURN_STATUS(

            ::aidl::android::legacy2aidl_audio_port_config_AudioPortConfig(

                    *device, isInput, 0));

    if (requestedPortConfig.ext.getTag() != AudioPortExt::Tag::device) {

        ALOGE("%s: provided port config is not a device port config: %s",

                __func__, requestedPortConfig.toString().c_str());

        return BAD_VALUE;

    }

    AudioPortConfig devicePortConfig;

    bool created;

    RETURN_STATUS_IF_ERROR(findOrCreatePortConfig(

                    requestedPortConfig, {} /*destinationPortIds*/, &devicePortConfig, &created));

    Cleanups cleanups;

    if (created) {

        cleanups.emplace_front(this, &DeviceHalAidl::resetPortConfig, devicePortConfig.id);

    }

    auto aidlEffect = sp<effect::EffectHalAidl>::cast(effect);

    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mModule->addDeviceEffect(

                            devicePortConfig.id, aidlEffect->getIEffect())));

    cleanups.disarmAll();

    return OK;

}

status_t DeviceHalAidl::removeDeviceEffect(const struct audio_port_config *device __unused,

                            sp<EffectHalInterface> effect) {

status_t DeviceHalAidl::removeDeviceEffect(

        const struct audio_port_config *device, sp<EffectHalInterface> effect) {

    TIME_CHECK();

    if (!mModule) return NO_INIT;

    if (!effect) {

        return BAD_VALUE;

    }

    TIME_CHECK();

    if (!mModule) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

    bool isInput = VALUE_OR_RETURN_STATUS(::aidl::android::portDirection(

                    device->role, device->type)) == ::aidl::android::AudioPortDirection::INPUT;

    auto requestedPortConfig = VALUE_OR_RETURN_STATUS(

            ::aidl::android::legacy2aidl_audio_port_config_AudioPortConfig(

                    *device, isInput, 0));

    if (requestedPortConfig.ext.getTag() != AudioPortExt::Tag::device) {

        ALOGE("%s: provided port config is not a device port config: %s",

                __func__, requestedPortConfig.toString().c_str());

        return BAD_VALUE;

    }

    auto existingPortConfigIt = findPortConfig(

            requestedPortConfig.ext.get<AudioPortExt::Tag::device>().device);

    if (existingPortConfigIt == mPortConfigs.end()) {

        ALOGE("%s: could not find a configured device port for the config %s",

                __func__, requestedPortConfig.toString().c_str());

        return BAD_VALUE;

    }

    auto aidlEffect = sp<effect::EffectHalAidl>::cast(effect);

    return statusTFromBinderStatus(mModule->removeDeviceEffect(

                    existingPortConfigIt->first, aidlEffect->getIEffect()));

}



status_t DeviceHalAidl::getMmapPolicyInfos(

media/libaudiohal/impl/EffectConversionHelperAidl.cpp

+39 −21
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 
 * limitations under the License.

 */



#include <csignal>

#include <cstddef>

#include <cstdint>

#include <cstring>
@@ -72,14 +73,13 @@ const std::map<uint32_t /* effect_command_e */, EffectConversionHelperAidl::Comm 


EffectConversionHelperAidl::EffectConversionHelperAidl(

        std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect> effect,

        int32_t sessionId, int32_t ioId, const Descriptor& desc)

        int32_t sessionId, int32_t ioId, const Descriptor& desc, bool isProxy)

    : mSessionId(sessionId),

      mIoId(ioId),

      mDesc(desc),

      mEffect(std::move(effect)),

      mIsInputStream(mDesc.common.flags.type == Flags::Type::PRE_PROC),

      mIsProxyEffect(mDesc.common.id.proxy.has_value() &&

                     mDesc.common.id.proxy.value() == mDesc.common.id.uuid) {

      mIsProxyEffect(isProxy) {

    mCommon.session = sessionId;

    mCommon.ioHandle = ioId;

    mCommon.input = mCommon.output = kDefaultAudioConfig;
@@ -195,11 +195,9 @@ status_t EffectConversionHelperAidl::handleSetConfig(uint32_t cmdSize, const voi 
                statusTFromBinderStatus(mEffect->open(common, std::nullopt, &openReturn)));



        if (mIsProxyEffect) {

            const auto& ret =

                    std::static_pointer_cast<EffectProxy>(mEffect)->getEffectReturnParam();

            mStatusQ = std::make_shared<StatusMQ>(ret->statusMQ);

            mInputQ = std::make_shared<DataMQ>(ret->inputDataMQ);

            mOutputQ = std::make_shared<DataMQ>(ret->outputDataMQ);

            mStatusQ = std::static_pointer_cast<EffectProxy>(mEffect)->getStatusMQ();

            mInputQ = std::static_pointer_cast<EffectProxy>(mEffect)->getInputMQ();

            mOutputQ = std::static_pointer_cast<EffectProxy>(mEffect)->getOutputMQ();

        } else {

            mStatusQ = std::make_shared<StatusMQ>(openReturn.statusMQ);

            mInputQ = std::make_shared<DataMQ>(openReturn.inputDataMQ);
@@ -207,6 +205,7 @@ status_t EffectConversionHelperAidl::handleSetConfig(uint32_t cmdSize, const voi 
        }



        if (status_t status = updateEventFlags(); status != OK) {

            ALOGV("%s closing at status %d", __func__, status);

            mEffect->close();

            return status;

        }
@@ -319,17 +318,25 @@ status_t EffectConversionHelperAidl::handleSetDevice(uint32_t cmdSize, const voi 
            mEffect->setParameter(Parameter::make<Parameter::deviceDescription>(aidlDevices))));

    return *static_cast<int32_t*>(pReplyData) = OK;

}



status_t EffectConversionHelperAidl::handleSetVolume(uint32_t cmdSize, const void* pCmdData,

                                                     uint32_t* replySize __unused,

                                                     void* pReplyData __unused) {

                                                     uint32_t* replySize, void* pReplyData) {

    if (cmdSize != 2 * sizeof(uint32_t) || !pCmdData) {

        ALOGE("%s parameter invalid %u %p", __func__, cmdSize, pCmdData);

        return BAD_VALUE;

    }

    Parameter::VolumeStereo volume = {.left = (float)(*(uint32_t*)pCmdData) / (1 << 24),

                                      .right = (float)(*(uint32_t*)pCmdData + 1) / (1 << 24)};



    constexpr uint32_t unityGain = 1 << 24;

    Parameter::VolumeStereo volume = {.left = (float)(*(uint32_t*)pCmdData) / unityGain,

                                      .right = (float)(*(uint32_t*)pCmdData + 1) / unityGain};

    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(

            mEffect->setParameter(Parameter::make<Parameter::volumeStereo>(volume))));



    // write unity gain back if volume was successfully set

    if (replySize && *replySize == 2 * sizeof(uint32_t) && pReplyData) {

        constexpr uint32_t vol_ret[2] = {unityGain, unityGain};

        memcpy(pReplyData, vol_ret, sizeof(vol_ret));

    }

    return OK;

}
@@ -346,14 +353,15 @@ status_t EffectConversionHelperAidl::handleSetOffload(uint32_t cmdSize, const vo 
        ALOGI("%s offload param offload %s ioHandle %d", __func__,

              offload->isOffload ? "true" : "false", offload->ioHandle);

        mCommon.ioHandle = offload->ioHandle;

        RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(

                std::static_pointer_cast<EffectProxy>(mEffect)->setOffloadParam(offload)));

        // update FMQs

        const auto& ret = std::static_pointer_cast<EffectProxy>(mEffect)->getEffectReturnParam();

        mStatusQ = std::make_shared<StatusMQ>(ret->statusMQ);

        mInputQ = std::make_shared<DataMQ>(ret->inputDataMQ);

        mOutputQ = std::make_shared<DataMQ>(ret->outputDataMQ);

        RETURN_STATUS_IF_ERROR(updateEventFlags());

        const auto& effectProxy = std::static_pointer_cast<EffectProxy>(mEffect);

        RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(effectProxy->setOffloadParam(offload)));

        // update FMQs if the effect instance already open

        if (State state; effectProxy->getState(&state).isOk() && state != State::INIT) {

            mStatusQ = effectProxy->getStatusMQ();

            mInputQ = effectProxy->getInputMQ();

            mOutputQ = effectProxy->getOutputMQ();

            updateEventFlags();

        }

    }

    return *static_cast<int32_t*>(pReplyData) = OK;

}
@@ -401,17 +409,27 @@ status_t EffectConversionHelperAidl::handleVisualizerMeasure(uint32_t cmdSize __ 
status_t EffectConversionHelperAidl::updateEventFlags() {

    status_t status = BAD_VALUE;

    EventFlag* efGroup = nullptr;

    if (mStatusQ->isValid()) {

    if (mStatusQ && mStatusQ->isValid()) {

        status = EventFlag::createEventFlag(mStatusQ->getEventFlagWord(), &efGroup);

        if (status != OK || !efGroup) {

            ALOGE("%s: create EventFlagGroup failed, ret %d, egGroup %p", __func__, status,

                  efGroup);

            status = (status == OK) ? BAD_VALUE : status;

        }

    } else if (isBypassing()) {

        // for effect with bypass (no processing) flag, it's okay to not have statusQ

        return OK;

    }



    mEfGroup.reset(efGroup, EventFlagDeleter());

    return status;

}



bool EffectConversionHelperAidl::isBypassing() const {

    return mEffect &&

           (mDesc.common.flags.bypass ||

            (mIsProxyEffect && std::static_pointer_cast<EffectProxy>(mEffect)->isBypassing()));

}



}  // namespace effect

}  // namespace android

media/libaudiohal/impl/EffectConversionHelperAidl.h

+2 −1
Original line number Diff line number Diff line
@@ -41,6 +41,7 @@ class EffectConversionHelperAidl { 
    std::shared_ptr<DataMQ> getInputMQ() { return mInputQ; }

    std::shared_ptr<DataMQ> getOutputMQ() { return mOutputQ; }

    std::shared_ptr<android::hardware::EventFlag> getEventFlagGroup() { return mEfGroup; }

    bool isBypassing() const;



  protected:

    const int32_t mSessionId;
@@ -54,7 +55,7 @@ class EffectConversionHelperAidl { 
    EffectConversionHelperAidl(

            std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect> effect,

            int32_t sessionId, int32_t ioId,

            const ::aidl::android::hardware::audio::effect::Descriptor& desc);

            const ::aidl::android::hardware::audio::effect::Descriptor& desc, bool isProxy);



    status_t handleSetParameter(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,

                                void* pReplyData);

media/libaudiohal/impl/EffectHalAidl.cpp

+32 −26
Original line number Diff line number Diff line
@@ -74,9 +74,12 @@ EffectHalAidl::EffectHalAidl(const std::shared_ptr<IFactory>& factory, 
}



EffectHalAidl::~EffectHalAidl() {

    if (mEffect) {

        mIsProxyEffect ? std::static_pointer_cast<EffectProxy>(mEffect)->destroy()

                       : mFactory->destroyEffect(mEffect);

    if (mFactory && mEffect) {

        if (mIsProxyEffect) {

            std::static_pointer_cast<EffectProxy>(mEffect)->destroy();

        } else {

            mFactory->destroyEffect(mEffect);

        }

    }

}
@@ -88,64 +91,64 @@ status_t EffectHalAidl::createAidlConversion( 
    ALOGI("%s create UUID %s", __func__, typeUuid.toString().c_str());

    if (typeUuid ==

        ::aidl::android::hardware::audio::effect::getEffectTypeUuidAcousticEchoCanceler()) {

        mConversion =

                std::make_unique<android::effect::AidlConversionAec>(effect, sessionId, ioId, desc);

        mConversion = std::make_unique<android::effect::AidlConversionAec>(effect, sessionId, ioId,

                                                                           desc, mIsProxyEffect);

    } else if (typeUuid == ::aidl::android::hardware::audio::effect::

                                   getEffectTypeUuidAutomaticGainControlV1()) {

        mConversion = std::make_unique<android::effect::AidlConversionAgc1>(effect, sessionId, ioId,

                                                                            desc);

                                                                            desc, mIsProxyEffect);

    } else if (typeUuid == ::aidl::android::hardware::audio::effect::

                                   getEffectTypeUuidAutomaticGainControlV2()) {

        mConversion = std::make_unique<android::effect::AidlConversionAgc2>(effect, sessionId, ioId,

                                                                            desc);

                                                                            desc, mIsProxyEffect);

    } else if (typeUuid == ::aidl::android::hardware::audio::effect::getEffectTypeUuidBassBoost()) {

        mConversion = std::make_unique<android::effect::AidlConversionBassBoost>(effect, sessionId,

                                                                                 ioId, desc);

        mConversion = std::make_unique<android::effect::AidlConversionBassBoost>(

                effect, sessionId, ioId, desc, mIsProxyEffect);

    } else if (typeUuid == ::aidl::android::hardware::audio::effect::getEffectTypeUuidDownmix()) {

        mConversion = std::make_unique<android::effect::AidlConversionDownmix>(effect, sessionId,

                                                                               ioId, desc);

        mConversion = std::make_unique<android::effect::AidlConversionDownmix>(

                effect, sessionId, ioId, desc, mIsProxyEffect);

    } else if (typeUuid ==

               ::aidl::android::hardware::audio::effect::getEffectTypeUuidDynamicsProcessing()) {

        mConversion =

                std::make_unique<android::effect::AidlConversionDp>(effect, sessionId, ioId, desc);

        mConversion = std::make_unique<android::effect::AidlConversionDp>(effect, sessionId, ioId,

                                                                          desc, mIsProxyEffect);

    } else if (typeUuid == ::aidl::android::hardware::audio::effect::getEffectTypeUuidEnvReverb()) {

        mConversion = std::make_unique<android::effect::AidlConversionEnvReverb>(effect, sessionId,

                                                                                 ioId, desc);

        mConversion = std::make_unique<android::effect::AidlConversionEnvReverb>(

                effect, sessionId, ioId, desc, mIsProxyEffect);

    } else if (typeUuid == ::aidl::android::hardware::audio::effect::getEffectTypeUuidEqualizer()) {

        mConversion =

                std::make_unique<android::effect::AidlConversionEq>(effect, sessionId, ioId, desc);

        mConversion = std::make_unique<android::effect::AidlConversionEq>(effect, sessionId, ioId,

                                                                          desc, mIsProxyEffect);

    } else if (typeUuid ==

               ::aidl::android::hardware::audio::effect::getEffectTypeUuidHapticGenerator()) {

        mConversion = std::make_unique<android::effect::AidlConversionHapticGenerator>(

                effect, sessionId, ioId, desc);

                effect, sessionId, ioId, desc, mIsProxyEffect);

    } else if (typeUuid ==

               ::aidl::android::hardware::audio::effect::getEffectTypeUuidLoudnessEnhancer()) {

        mConversion = std::make_unique<android::effect::AidlConversionLoudnessEnhancer>(

                effect, sessionId, ioId, desc);

                effect, sessionId, ioId, desc, mIsProxyEffect);

    } else if (typeUuid ==

               ::aidl::android::hardware::audio::effect::getEffectTypeUuidNoiseSuppression()) {

        mConversion = std::make_unique<android::effect::AidlConversionNoiseSuppression>(

                effect, sessionId, ioId, desc);

                effect, sessionId, ioId, desc, mIsProxyEffect);

    } else if (typeUuid ==

               ::aidl::android::hardware::audio::effect::getEffectTypeUuidPresetReverb()) {

        mConversion = std::make_unique<android::effect::AidlConversionPresetReverb>(

                effect, sessionId, ioId, desc);

                effect, sessionId, ioId, desc, mIsProxyEffect);

    } else if (typeUuid ==

               ::aidl::android::hardware::audio::effect::getEffectTypeUuidSpatializer()) {

        mConversion = std::make_unique<android::effect::AidlConversionSpatializer>(

                effect, sessionId, ioId, desc);

                effect, sessionId, ioId, desc, mIsProxyEffect);

    } else if (typeUuid ==

               ::aidl::android::hardware::audio::effect::getEffectTypeUuidVirtualizer()) {

        mConversion = std::make_unique<android::effect::AidlConversionVirtualizer>(

                effect, sessionId, ioId, desc);

                effect, sessionId, ioId, desc, mIsProxyEffect);

    } else if (typeUuid ==

               ::aidl::android::hardware::audio::effect::getEffectTypeUuidVisualizer()) {

        mConversion = std::make_unique<android::effect::AidlConversionVisualizer>(effect, sessionId,

                                                                                  ioId, desc);

        mConversion = std::make_unique<android::effect::AidlConversionVisualizer>(

                effect, sessionId, ioId, desc, mIsProxyEffect);

    } else {

        // For unknown UUID, use vendor extension implementation

        mConversion = std::make_unique<android::effect::AidlConversionVendorExtension>(

                effect, sessionId, ioId, desc);

                effect, sessionId, ioId, desc, mIsProxyEffect);

    }

    return OK;

}
@@ -166,6 +169,9 @@ status_t EffectHalAidl::process() { 
    auto inputQ = mConversion->getInputMQ();

    auto outputQ = mConversion->getOutputMQ();

    auto efGroup = mConversion->getEventFlagGroup();

    if (mConversion->isBypassing()) {

        return OK;

    }

    if (!statusQ || !statusQ->isValid() || !inputQ || !inputQ->isValid() || !outputQ ||

        !outputQ->isValid() || !efGroup) {

        ALOGE("%s invalid FMQ [Status %d I %d O %d] efGroup %p", __func__,

media/libaudiohal/impl/EffectProxy.cpp

+133 −125

File changed.

Preview size limit exceeded, changes collapsed.