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

Commit f2b52d82 authored by Shunkai Yao's avatar Shunkai Yao Committed by Automerger Merge Worker
Browse files

Merge "[AIDL CTS] pass Virtualizer implementation cts" am: d8161222 am: 2d6140bd am: 0ff5f76c 

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



Change-Id: Ia921d524feb31c1a28b58e5e1bb82beb43feba56
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 2578090c 0ff5f76c

media/libaudiohal/impl/effectsAidlConversion/AidlConversionVirtualizer.cpp

+106 −10
Original line number Original line Diff line number Diff line
@@ -21,10 +21,12 @@ 
//#define LOG_NDEBUG 0

//#define LOG_NDEBUG 0





#include <error/expected_utils.h>

#include <error/expected_utils.h>

#include <media/AidlConversionCppNdk.h>

#include <media/AidlConversionNdk.h>

#include <media/AidlConversionNdk.h>

#include <media/AidlConversionEffect.h>

#include <media/AidlConversionEffect.h>

#include <media/audiohal/AudioEffectUuid.h>

#include <media/audiohal/AudioEffectUuid.h>

#include <system/audio_effects/effect_spatializer.h>

#include <system/audio_effects/aidl_effects_utils.h>

#include <system/audio_effects/effect_virtualizer.h>





#include <utils/Log.h>

#include <utils/Log.h>
@@ -34,34 +36,128 @@ namespace android { 
namespace effect {

namespace effect {





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

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

using ::aidl::android::getParameterSpecificField;

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

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

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

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

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

using ::android::status_t;

using ::android::status_t;

using utils::EffectParamReader;

using utils::EffectParamReader;

using utils::EffectParamWriter;

using utils::EffectParamWriter;





status_t AidlConversionVirtualizer::setParameter(EffectParamReader& param) {

status_t AidlConversionVirtualizer::setParameter(EffectParamReader& param) {

    uint32_t type = 0;

    uint32_t type = 0;

    uint16_t value = 0;

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

    if (!param.validateParamValueSize(sizeof(uint32_t), sizeof(uint16_t)) ||

        OK != param.readFromParameter(&type) || OK != param.readFromValue(&value)) {

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

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

        return BAD_VALUE;

        return BAD_VALUE;

    }

    }

    Parameter aidlParam;

    Parameter aidlParam;

    // TODO

    switch (type) {

        case VIRTUALIZER_PARAM_STRENGTH: {

            int16_t strength = 0;

            if (OK != param.readFromValue(&strength)) {

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

                return BAD_VALUE;

            }

            aidlParam = MAKE_SPECIFIC_PARAMETER(Virtualizer, virtualizer, strengthPm, strength);

            break;

        }

        case VIRTUALIZER_PARAM_FORCE_VIRTUALIZATION_MODE: {

            audio_devices_t deviceType;

            if (OK != param.readFromValue(&deviceType)) {

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

                return BAD_VALUE;

            }

            AudioDeviceDescription deviceDesc = VALUE_OR_RETURN_STATUS(

                    ::aidl::android::legacy2aidl_audio_devices_t_AudioDeviceDescription(

                            deviceType));

            aidlParam = MAKE_SPECIFIC_PARAMETER(Virtualizer, virtualizer, device, deviceDesc);

            break;

        }

        default: {

            // TODO: implement vendor extension parameters

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

            return BAD_VALUE;

        }

    }

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

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

}

}





status_t AidlConversionVirtualizer::getParameter(EffectParamWriter& param) {

status_t AidlConversionVirtualizer::getParameter(EffectParamWriter& param) {

    uint32_t type = 0, value = 0;

    uint32_t type = 0;

    if (!param.validateParamValueSize(sizeof(uint32_t), sizeof(uint32_t)) ||

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

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

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

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

        param.setStatus(BAD_VALUE);

        param.setStatus(BAD_VALUE);

        return BAD_VALUE;

        return BAD_VALUE;

    }

    }

    // TODO

    Parameter aidlParam;

    return param.writeToValue(&value);

    switch (type) {

        case VIRTUALIZER_PARAM_STRENGTH_SUPPORTED: {

            // an invalid range indicates not setting support for this parameter

            uint32_t support =

                    ::aidl::android::hardware::audio::effect::isRangeValid<Range::Tag::virtualizer>(

                            Virtualizer::strengthPm, mDesc.capability);

            return param.writeToValue(&support);

        }

        case VIRTUALIZER_PARAM_STRENGTH: {

            Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(Virtualizer, virtualizerTag,

                                                          Virtualizer::strengthPm);

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

            int16_t strength = VALUE_OR_RETURN_STATUS(GET_PARAMETER_SPECIFIC_FIELD(

                    aidlParam, Virtualizer, virtualizer, Virtualizer::strengthPm, int32_t));

            return param.writeToValue(&strength);

        }

        case VIRTUALIZER_PARAM_VIRTUAL_SPEAKER_ANGLES: {

            audio_channel_mask_t mask;

            audio_devices_t device;

            if (OK != param.readFromParameter(&mask) || OK != param.readFromParameter(&device)) {

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

                return BAD_VALUE;

            }

            Virtualizer::SpeakerAnglesPayload payload = {

                    .layout = VALUE_OR_RETURN_STATUS(

                            ::aidl::android::legacy2aidl_audio_channel_mask_t_AudioChannelLayout(

                                    mask, false)),

                    .device = VALUE_OR_RETURN_STATUS(

                            ::aidl::android::legacy2aidl_audio_devices_t_AudioDeviceDescription(

                                    device))};

            Virtualizer::Id vId = UNION_MAKE(Virtualizer::Id, speakerAnglesPayload, payload);

            Parameter::Id id = UNION_MAKE(Parameter::Id, virtualizerTag, vId);

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

            const auto& angles = VALUE_OR_RETURN_STATUS(GET_PARAMETER_SPECIFIC_FIELD(

                    aidlParam, Virtualizer, virtualizer, Virtualizer::speakerAngles,

                    std::vector<Virtualizer::ChannelAngle>));

            for (const auto& angle : angles) {

                const audio_channel_mask_t chMask = ::aidl::android::

                        aidl2legacy_AudioChannelLayout_layout_audio_channel_mask_t_bits(

                                angle.channel, false);

                ALOGW("%s aidl %d ch %d", __func__, angle.channel, chMask);

                if (OK != param.writeToValue(&chMask) ||

                    OK != param.writeToValue(&angle.azimuthDegree) ||

                    OK != param.writeToValue(&angle.elevationDegree)) {

                    ALOGW("%s can't write angles to param %s", __func__, param.toString().c_str());

                    return BAD_VALUE;

                }

            }

            return OK;

        }

        case VIRTUALIZER_PARAM_VIRTUALIZATION_MODE: {

            Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(Virtualizer, virtualizerTag,

                                                          Virtualizer::device);

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

            AudioDeviceDescription device = VALUE_OR_RETURN_STATUS(

                    GET_PARAMETER_SPECIFIC_FIELD(aidlParam, Virtualizer, virtualizer,

                                                 Virtualizer::device, AudioDeviceDescription));

            const audio_devices_t deviceType = VALUE_OR_RETURN_STATUS(

                    ::aidl::android::aidl2legacy_AudioDeviceDescription_audio_devices_t(device));

            return param.writeToValue(&deviceType);

        }

        default: {

            // TODO: implement vendor extension parameters

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

            return BAD_VALUE;

        }

    }

}

}





} // namespace effect

} // namespace effect