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

Commit 0a250bc8 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "AIDL libAudioHal: Add effect AIDL conversion" am: ea92d2c8 am: 54119969 

Original change: https://android-review.googlesource.com/c/platform/frameworks/av/+/2411033



Change-Id: I266f03285f208d5d3ffb7ef7675fbd87937a1dcd
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 61edfb9d 54119969

media/audioaidlconversion/AidlConversionEffect.cpp

+1 −1
Original line number Diff line number Diff line
@@ -37,6 +37,7 @@ using ::aidl::android::hardware::audio::effect::Downmix; 
using ::aidl::android::hardware::audio::effect::DynamicsProcessing;

using ::aidl::android::hardware::audio::effect::Flags;

using ::aidl::android::hardware::audio::effect::Parameter;

using ::aidl::android::hardware::audio::effect::PresetReverb;

using ::aidl::android::media::audio::common::AudioDeviceDescription;



using ::android::BAD_VALUE;
@@ -347,6 +348,5 @@ ConversionResult<int32_t> aidl2legacy_DynamicsProcessing_ResolutionPreference_in 
    return static_cast<int32_t>(aidl);

}





}  // namespace android

}  // aidl

media/libaudiohal/impl/Android.bp

+10 −0
Original line number Diff line number Diff line
@@ -256,6 +256,16 @@ cc_library_shared { 
        "effectsAidlConversion/AidlConversionBassBoost.cpp",

        "effectsAidlConversion/AidlConversionDownmix.cpp",

        "effectsAidlConversion/AidlConversionDynamicsProcessing.cpp",

        "effectsAidlConversion/AidlConversionEnvReverb.cpp",

        "effectsAidlConversion/AidlConversionEq.cpp",

        "effectsAidlConversion/AidlConversionHapticGenerator.cpp",

        "effectsAidlConversion/AidlConversionLoudnessEnhancer.cpp",

        "effectsAidlConversion/AidlConversionNoiseSuppression.cpp",

        "effectsAidlConversion/AidlConversionPresetReverb.cpp",

        "effectsAidlConversion/AidlConversionSpatializer.cpp",

        "effectsAidlConversion/AidlConversionVendorExtension.cpp",

        "effectsAidlConversion/AidlConversionVirtualizer.cpp",

        "effectsAidlConversion/AidlConversionVisualizer.cpp",

        "EffectsFactoryHalAidl.cpp",

        "EffectsFactoryHalEntry.cpp",

        "StreamHalAidl.cpp",

media/libaudiohal/impl/EffectConversionHelperAidl.cpp

+55 −18
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
//#define LOG_NDEBUG 0



#include <error/expected_utils.h>

#include <media/AidlConversionCppNdk.h>

#include <media/AidlConversionNdk.h>

#include <media/AidlConversionEffect.h>
@@ -36,6 +37,8 @@ using ::aidl::android::hardware::audio::effect::CommandId; 
using ::aidl::android::hardware::audio::effect::Descriptor;

using ::aidl::android::hardware::audio::effect::Parameter;

using ::aidl::android::media::audio::common::AudioDeviceDescription;

using ::aidl::android::media::audio::common::AudioMode;

using ::aidl::android::media::audio::common::AudioSource;

using android::effect::utils::EffectParamReader;

using android::effect::utils::EffectParamWriter;
@@ -51,6 +54,7 @@ const std::map<uint32_t /* effect_command_e */, EffectConversionHelperAidl::Comm 
                {EFFECT_CMD_RESET, &EffectConversionHelperAidl::handleReset},

                {EFFECT_CMD_ENABLE, &EffectConversionHelperAidl::handleEnable},

                {EFFECT_CMD_DISABLE, &EffectConversionHelperAidl::handleDisable},

                {EFFECT_CMD_SET_AUDIO_SOURCE, &EffectConversionHelperAidl::handleSetAudioSource},

                {EFFECT_CMD_SET_DEVICE, &EffectConversionHelperAidl::handleSetDevice},

                {EFFECT_CMD_SET_INPUT_DEVICE, &EffectConversionHelperAidl::handleSetDevice},

                {EFFECT_CMD_SET_VOLUME, &EffectConversionHelperAidl::handleSetVolume},
@@ -101,7 +105,10 @@ status_t EffectConversionHelperAidl::handleSetParameter(uint32_t cmdSize, const 
        return BAD_VALUE;

    }



    return *(status_t*)pReplyData = setParameter(reader);

    status_t ret = setParameter(reader);

    EffectParamWriter writer(*(effect_param_t*)pReplyData);

    writer.setStatus(ret);

    return *(status_t*)pReplyData = ret;

}



status_t EffectConversionHelperAidl::handleGetParameter(uint32_t cmdSize, const void* pCmdData,
@@ -111,10 +118,8 @@ status_t EffectConversionHelperAidl::handleGetParameter(uint32_t cmdSize, const 
    }



    const auto reader = EffectParamReader(*(effect_param_t*)pCmdData);

    if (!reader.validateCmdSize(cmdSize) ||

        *replySize < sizeof(effect_param_t) + reader.getParameterSize()) {

        ALOGE("%s illegal param %s, replySize %u", __func__, reader.toString().c_str(),

              *replySize);

    if (*replySize < sizeof(effect_param_t) + reader.getParameterSize()) {

        ALOGE("%s illegal param %s, replySize %u", __func__, reader.toString().c_str(), *replySize);

        return BAD_VALUE;

    }
@@ -123,7 +128,11 @@ status_t EffectConversionHelperAidl::handleGetParameter(uint32_t cmdSize, const 
    auto writer = EffectParamWriter(*(effect_param_t*)pReplyData);

    status_t ret = getParameter(writer);

    writer.finishValueWrite();

    writer.setStatus(ret);

    *replySize = writer.getTotalSize();

    if (ret != OK) {

        ALOGE("%s error ret %d, %s", __func__, ret, writer.toString().c_str());

    }

    return ret;

}
@@ -134,6 +143,7 @@ status_t EffectConversionHelperAidl::handleSetConfig(uint32_t cmdSize, const voi 
        return BAD_VALUE;

    }



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

    const auto& legacyConfig = static_cast<const effect_config_t*>(pCmdData);

    // already open, apply latest settings

    Parameter::Common common;
@@ -178,7 +188,7 @@ status_t EffectConversionHelperAidl::handleGetConfig(uint32_t cmdSize __unused, 
status_t EffectConversionHelperAidl::handleReset(uint32_t cmdSize __unused,

                                                 const void* pCmdData __unused, uint32_t* replySize,

                                                 void* pReplyData) {

    if (!replySize || *replySize != sizeof(effect_config_t) || !pReplyData) {

    if (!replySize || !pReplyData) {

        ALOGE("%s parameter invalid %p %p", __func__, replySize, pReplyData);

        return BAD_VALUE;

    }
@@ -187,9 +197,9 @@ status_t EffectConversionHelperAidl::handleReset(uint32_t cmdSize __unused, 
}



status_t EffectConversionHelperAidl::handleEnable(uint32_t cmdSize __unused,

                                                 const void* pCmdData __unused, uint32_t* replySize,

                                                 void* pReplyData) {

    if (!replySize || *replySize != sizeof(effect_config_t) || !pReplyData) {

                                                  const void* pCmdData __unused,

                                                  uint32_t* replySize, void* pReplyData) {

    if (!replySize || !pReplyData) {

        ALOGE("%s parameter invalid %p %p", __func__, replySize, pReplyData);

        return BAD_VALUE;

    }
@@ -200,7 +210,7 @@ status_t EffectConversionHelperAidl::handleEnable(uint32_t cmdSize __unused, 
status_t EffectConversionHelperAidl::handleDisable(uint32_t cmdSize __unused,

                                                   const void* pCmdData __unused,

                                                   uint32_t* replySize, void* pReplyData) {

    if (!replySize || *replySize != sizeof(effect_config_t) || !pReplyData) {

    if (!replySize || !pReplyData) {

        ALOGE("%s parameter invalid %p %p", __func__, replySize, pReplyData);

        return BAD_VALUE;

    }
@@ -208,10 +218,40 @@ status_t EffectConversionHelperAidl::handleDisable(uint32_t cmdSize __unused, 
    return statusTFromBinderStatus(mEffect->command(CommandId::STOP));

}



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

                                                          uint32_t* replySize, void* pReplyData) {

    if (cmdSize != sizeof(uint32_t) || !pCmdData || !replySize || !pReplyData) {

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

              pReplyData);

        return BAD_VALUE;

    }



    audio_source_t source = *(audio_source_t*)pCmdData;

    AudioSource aidlSource =

            VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_audio_source_t_AudioSource(source));

    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(

            mEffect->setParameter(Parameter::make<Parameter::source>(aidlSource))));

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

}



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

                                                        uint32_t* replySize, void* pReplyData) {

    if (cmdSize != sizeof(uint32_t) || !pCmdData || !replySize || !pReplyData) {

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

              pReplyData);

        return BAD_VALUE;

    }

    audio_mode_t mode = *(audio_mode_t *)pCmdData;

    AudioMode aidlMode =

            VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_audio_mode_t_AudioMode(mode));

    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(

            mEffect->setParameter(Parameter::make<Parameter::mode>(aidlMode))));

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

}



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

                                                     uint32_t* replySize, void* pReplyData) {

    if (cmdSize != sizeof(uint32_t) || !pCmdData || !replySize ||

        *replySize != sizeof(effect_config_t) || !pReplyData) {

    if (cmdSize != sizeof(uint32_t) || !pCmdData || !replySize || !pReplyData) {

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

              pReplyData);

        return BAD_VALUE;
@@ -223,11 +263,9 @@ 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, void* pReplyData) {

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

        *replySize != sizeof(effect_config_t) || !pReplyData) {

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

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

              pReplyData);

        return BAD_VALUE;
@@ -241,8 +279,7 @@ status_t EffectConversionHelperAidl::handleSetVolume(uint32_t cmdSize, const voi 


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

                                                      uint32_t* replySize, void* pReplyData) {

    if (cmdSize < sizeof(effect_offload_param_t) || !pCmdData || !replySize ||

        *replySize != sizeof(effect_config_t) || !pReplyData) {

    if (cmdSize < sizeof(effect_offload_param_t) || !pCmdData || !replySize || !pReplyData) {

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

              pReplyData);

        return BAD_VALUE;
@@ -254,7 +291,7 @@ status_t EffectConversionHelperAidl::handleSetOffload(uint32_t cmdSize, const vo 
status_t EffectConversionHelperAidl::handleFirstPriority(uint32_t cmdSize __unused,

                                                         const void* pCmdData __unused,

                                                         uint32_t* replySize, void* pReplyData) {

    if (!replySize || *replySize != sizeof(effect_config_t) || !pReplyData) {

    if (!replySize || !pReplyData) {

        ALOGE("%s parameter invalid %p %p", __func__, replySize, pReplyData);

        return BAD_VALUE;

    }

media/libaudiohal/impl/EffectConversionHelperAidl.h

+4 −0
Original line number Diff line number Diff line
@@ -82,6 +82,10 @@ class EffectConversionHelperAidl { 
                           void* pReplyData);

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

                         void* pReplyData);

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

                                  void* pReplyData);

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

                                void* pReplyData);

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

                             void* pReplyData);

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

media/libaudiohal/impl/EffectHalAidl.cpp

+45 −14
Original line number Diff line number Diff line
@@ -14,10 +14,11 @@ 
 * limitations under the License.

 */



#include <memory>

#define LOG_TAG "EffectHalAidl"

//#define LOG_NDEBUG 0



#include <memory>



#include <error/expected_utils.h>

#include <media/AidlConversionCppNdk.h>

#include <media/AidlConversionEffect.h>
@@ -25,19 +26,11 @@ 
#include <media/audiohal/AudioEffectUuid.h>

#include <media/EffectsFactoryApi.h>

#include <mediautils/TimeCheck.h>

#include <system/audio.h>

#include <utils/Log.h>



#include <system/audio_effects/effect_aec.h>

#include <system/audio_effects/effect_downmix.h>

#include <system/audio_effects/effect_dynamicsprocessing.h>

#include <system/audio_effects/effect_hapticgenerator.h>

#include <system/audio_effects/effect_ns.h>

#include <system/audio_effects/effect_spatializer.h>

#include <system/audio_effects/effect_visualizer.h>



#include "EffectHalAidl.h"



#include <system/audio.h>

#include <aidl/android/hardware/audio/effect/IEffect.h>



#include "effectsAidlConversion/AidlConversionAec.h"
@@ -45,6 +38,16 @@ 
#include "effectsAidlConversion/AidlConversionBassBoost.h"

#include "effectsAidlConversion/AidlConversionDownmix.h"

#include "effectsAidlConversion/AidlConversionDynamicsProcessing.h"

#include "effectsAidlConversion/AidlConversionEnvReverb.h"

#include "effectsAidlConversion/AidlConversionEq.h"

#include "effectsAidlConversion/AidlConversionHapticGenerator.h"

#include "effectsAidlConversion/AidlConversionLoudnessEnhancer.h"

#include "effectsAidlConversion/AidlConversionNoiseSuppression.h"

#include "effectsAidlConversion/AidlConversionPresetReverb.h"

#include "effectsAidlConversion/AidlConversionSpatializer.h"

#include "effectsAidlConversion/AidlConversionVendorExtension.h"

#include "effectsAidlConversion/AidlConversionVirtualizer.h"

#include "effectsAidlConversion/AidlConversionVisualizer.h"



using ::aidl::android::aidl_utils::statusTFromBinderStatus;

using ::aidl::android::hardware::audio::effect::CommandId;
@@ -81,10 +84,11 @@ status_t EffectHalAidl::createAidlConversion( 
        int32_t sessionId, int32_t ioId,

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

    const auto& typeUuid = desc.common.id.type;

    ALOGI("%s create UUID %s", __func__, typeUuid.toString().c_str());

    if (typeUuid == kAcousticEchoCancelerTypeUUID) {

        mConversion =

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

    } else if (typeUuid == kAutomaticGainControlTypeUUID) {

    } else if (typeUuid == kAutomaticGainControl2TypeUUID) {

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

                                                                            desc);

    } else if (typeUuid == kBassBoostTypeUUID) {
@@ -96,10 +100,37 @@ status_t EffectHalAidl::createAidlConversion( 
    } else if (typeUuid == kDynamicsProcessingTypeUUID) {

        mConversion =

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

    } else if (typeUuid == kEnvReverbTypeUUID) {

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

                                                                                 ioId, desc);

    } else if (typeUuid == kEqualizerTypeUUID) {

        mConversion =

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

    } else if (typeUuid == kHapticGeneratorTypeUUID) {

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

                effect, sessionId, ioId, desc);

    } else if (typeUuid == kLoudnessEnhancerTypeUUID) {

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

                effect, sessionId, ioId, desc);

    } else if (typeUuid == kNoiseSuppressionTypeUUID) {

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

                effect, sessionId, ioId, desc);

    } else if (typeUuid == kPresetReverbTypeUUID) {

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

                effect, sessionId, ioId, desc);

    } else if (typeUuid == kSpatializerTypeUUID) {

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

                effect, sessionId, ioId, desc);

    } else if (typeUuid == kVirtualizerTypeUUID) {

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

                effect, sessionId, ioId, desc);

    } else if (typeUuid == kVisualizerTypeUUID) {

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

                                                                                  ioId, desc);

    } else {

        ALOGE("%s effect not implemented yet, UUID type: %s", __func__,

              typeUuid.toString().c_str());

        return BAD_VALUE;

        // For unknown UUID, use vendor extension implementation

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

                effect, sessionId, ioId, desc);

    }

    return OK;

}