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

Commit 61ce9573 authored by Shunkai Yao's avatar Shunkai Yao
Browse files

[Effect AIDL] Add AGC1 conversion in framework 

Bug: 261129656
Test: atest EffectsFactoryHalInterfaceTest
Change-Id: I893e077140add3cbfdaf3b3d69165fae45213177
parent d5101e99

media/libaudiohal/impl/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -256,6 +256,7 @@ cc_library_shared { 
        "EffectBufferHalAidl.cpp",

        "EffectHalAidl.cpp",

        "effectsAidlConversion/AidlConversionAec.cpp",

        "effectsAidlConversion/AidlConversionAgc1.cpp",

        "effectsAidlConversion/AidlConversionAgc2.cpp",

        "effectsAidlConversion/AidlConversionBassBoost.cpp",

        "effectsAidlConversion/AidlConversionDownmix.cpp",

media/libaudiohal/impl/EffectHalAidl.cpp

+4 −0
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ 
#include <aidl/android/hardware/audio/effect/IEffect.h>



#include "effectsAidlConversion/AidlConversionAec.h"

#include "effectsAidlConversion/AidlConversionAgc1.h"

#include "effectsAidlConversion/AidlConversionAgc2.h"

#include "effectsAidlConversion/AidlConversionBassBoost.h"

#include "effectsAidlConversion/AidlConversionDownmix.h"
@@ -89,6 +90,9 @@ status_t EffectHalAidl::createAidlConversion( 
    if (typeUuid == kAcousticEchoCancelerTypeUUID) {

        mConversion =

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

    } else if (typeUuid == kAutomaticGainControl1TypeUUID) {

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

                                                                            desc);

    } else if (typeUuid == kAutomaticGainControl2TypeUUID) {

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

                                                                            desc);

media/libaudiohal/impl/effectsAidlConversion/AidlConversionAgc1.cpp

0 → 100644
+160 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2023 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <cstdint>

#include <cstring>

#include <optional>

#define LOG_TAG "AidlConversionAgc1"

//#define LOG_NDEBUG 0



#include <error/expected_utils.h>

#include <media/AidlConversionNdk.h>

#include <media/AidlConversionEffect.h>

#include <media/audiohal/AudioEffectUuid.h>

#include <system/audio_effects/effect_agc.h>



#include <utils/Log.h>



#include "AidlConversionAgc1.h"



namespace android {

namespace effect {



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

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

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

using ::aidl::android::getParameterSpecificField;

using ::android::status_t;

using utils::EffectParamReader;

using utils::EffectParamWriter;



status_t AidlConversionAgc1::setParameterLevel(EffectParamReader& param) {

    int16_t level;

    RETURN_STATUS_IF_ERROR(param.readFromValue(&level));

    Parameter aidlParam = MAKE_SPECIFIC_PARAMETER(AutomaticGainControlV1, automaticGainControlV1,

                                                  targetPeakLevelDbFs, level);

    return statusTFromBinderStatus(mEffect->setParameter(aidlParam));

}



status_t AidlConversionAgc1::setParameterGain(EffectParamReader& param) {

    int16_t gain;

    RETURN_STATUS_IF_ERROR(param.readFromValue(&gain));

    Parameter aidlParam = MAKE_SPECIFIC_PARAMETER(AutomaticGainControlV1, automaticGainControlV1,

                                                  maxCompressionGainDb, gain);

    return statusTFromBinderStatus(mEffect->setParameter(aidlParam));

}



status_t AidlConversionAgc1::setParameterLimiterEnable(EffectParamReader& param) {

    bool enable;

    RETURN_STATUS_IF_ERROR(param.readFromValue(&enable));

    Parameter aidlParam = MAKE_SPECIFIC_PARAMETER(AutomaticGainControlV1, automaticGainControlV1,

                                                  enableLimiter, enable);

    return statusTFromBinderStatus(mEffect->setParameter(aidlParam));

}



status_t AidlConversionAgc1::setParameter(EffectParamReader& param) {

    uint32_t type = 0;

    if (OK != param.readFromParameter(&type)) {

        ALOGE("%s invalid param %s", __func__, param.toString().c_str());

        return BAD_VALUE;

    }

    switch (type) {

        case AGC_PARAM_TARGET_LEVEL: {

            return setParameterLevel(param);

        }

        case AGC_PARAM_COMP_GAIN: {

            return setParameterGain(param);

        }

        case AGC_PARAM_LIMITER_ENA: {

            return setParameterLimiterEnable(param);

        }

        case AGC_PARAM_PROPERTIES: {

            RETURN_STATUS_IF_ERROR(setParameterLevel(param));

            RETURN_STATUS_IF_ERROR(setParameterGain(param));

            RETURN_STATUS_IF_ERROR(setParameterLimiterEnable(param));

            return OK;

        }

        default: {

            ALOGW("%s unknown param %s", __func__, param.toString().c_str());

            return BAD_VALUE;

        }

    }

}



status_t AidlConversionAgc1::getParameterLevel(EffectParamWriter& param) {

    Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(AutomaticGainControlV1, automaticGainControlV1Tag,

                                                  AutomaticGainControlV1::targetPeakLevelDbFs);

    Parameter aidlParam;

    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));

    int32_t level = VALUE_OR_RETURN_STATUS(

            GET_PARAMETER_SPECIFIC_FIELD(aidlParam, AutomaticGainControlV1, automaticGainControlV1,

                                         AutomaticGainControlV1::targetPeakLevelDbFs, int32_t));

    return param.writeToValue(&level);

}



status_t AidlConversionAgc1::getParameterGain(EffectParamWriter& param) {

    Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(AutomaticGainControlV1, automaticGainControlV1Tag,

                                                  AutomaticGainControlV1::maxCompressionGainDb);

    Parameter aidlParam;

    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));

    int32_t gain = VALUE_OR_RETURN_STATUS(

            GET_PARAMETER_SPECIFIC_FIELD(aidlParam, AutomaticGainControlV1, automaticGainControlV1,

                                         AutomaticGainControlV1::maxCompressionGainDb, int32_t));

    return param.writeToValue(&gain);

}



status_t AidlConversionAgc1::getParameterLimiterEnable(EffectParamWriter& param) {

    Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(AutomaticGainControlV1, automaticGainControlV1Tag,

                                                  AutomaticGainControlV1::enableLimiter);

    Parameter aidlParam;

    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));

    bool enable = VALUE_OR_RETURN_STATUS(

            GET_PARAMETER_SPECIFIC_FIELD(aidlParam, AutomaticGainControlV1, automaticGainControlV1,

                                         AutomaticGainControlV1::enableLimiter, bool));

    return param.writeToValue(&enable);

}



status_t AidlConversionAgc1::getParameter(EffectParamWriter& param) {

    uint32_t type = 0;

    if (OK != param.readFromParameter(&type)) {

        ALOGE("%s invalid param %s", __func__, param.toString().c_str());

        return BAD_VALUE;

    }

    switch (type) {

        case AGC_PARAM_TARGET_LEVEL: {

            return getParameterLevel(param);

        }

        case AGC_PARAM_COMP_GAIN: {

            return getParameterGain(param);

        }

        case AGC_PARAM_LIMITER_ENA: {

            return getParameterLimiterEnable(param);

        }

        case AGC_PARAM_PROPERTIES: {

            RETURN_STATUS_IF_ERROR(getParameterLevel(param));

            RETURN_STATUS_IF_ERROR(getParameterGain(param));

            RETURN_STATUS_IF_ERROR(getParameterLimiterEnable(param));

            return OK;

        }

        default: {

            ALOGW("%s unknown param %s", __func__, param.toString().c_str());

            return BAD_VALUE;

        }

    }

}



} // namespace effect

} // namespace android

media/libaudiohal/impl/effectsAidlConversion/AidlConversionAgc1.h

0 → 100644
+46 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2023 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#pragma once



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

#include "EffectConversionHelperAidl.h"



namespace android {

namespace effect {



class AidlConversionAgc1 : public EffectConversionHelperAidl {

  public:

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

                       int32_t sessionId, int32_t ioId,

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

        : EffectConversionHelperAidl(effect, sessionId, ioId, desc) {}

    ~AidlConversionAgc1() {}



  private:

    status_t setParameterLevel(utils::EffectParamReader& param);

    status_t setParameterGain(utils::EffectParamReader& param);

    status_t setParameterLimiterEnable(utils::EffectParamReader& param);

    status_t setParameter(utils::EffectParamReader& param) override;



    status_t getParameterLevel(utils::EffectParamWriter& param);

    status_t getParameterGain(utils::EffectParamWriter& param);

    status_t getParameterLimiterEnable(utils::EffectParamWriter& param);

    status_t getParameter(utils::EffectParamWriter& param) override;

};



}  // namespace effect

}  // namespace android

media/libaudiohal/include/media/audiohal/AudioEffectUuid.h

+6 −0
Original line number Diff line number Diff line
@@ -29,6 +29,12 @@ static const AudioUuid kAcousticEchoCancelerTypeUUID = {static_cast<int32_t>(0x7 
                                                        0x11e0,

                                                        0xbd61,

                                                        {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};

// ae3c653b-be18-4ab8-8938-418f0a7f06ac

static const AudioUuid kAutomaticGainControl1TypeUUID = {static_cast<int32_t>(0xae3c653b),

                                                         0xbe18,

                                                         0x4ab8,

                                                         0x8938,

                                                         {0x41, 0x8f, 0x0a, 0x7f, 0x06, 0xac}};

// 0xae3c653b-be18-4ab8-8938-418f0a7f06ac

static const AudioUuid kAutomaticGainControl2TypeUUID = {static_cast<int32_t>(0xae3c653b),

                                                         0xbe18,