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

Commit fb1d459f authored by Mikhail Naganov's avatar Mikhail Naganov Committed by Automerger Merge Worker
Browse files

Merge changes from topic "revert-2770886-AidlAudioHalModuleConfig-FQCMWOWMCH"... 

Merge changes from topic "revert-2770886-AidlAudioHalModuleConfig-FQCMWOWMCH" into main am: 03a2fbc6

Original change: https://android-review.googlesource.com/c/platform/hardware/interfaces/+/2786757



Change-Id: I2448c8275175486fc357937e5dab0d3a6c218617
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents ca9d26dc 03a2fbc6

audio/aidl/default/Android.bp

+0 −10
Original line number Diff line number Diff line
@@ -12,7 +12,6 @@ cc_defaults { 
    vendor: true,

    shared_libs: [

        "libalsautilsv2",

        "libaudio_aidl_conversion_common_ndk",

        "libaudioaidlcommon",

        "libaudioutils",

        "libbase",
@@ -20,8 +19,6 @@ cc_defaults { 
        "libcutils",

        "libfmq",

        "libnbaio_mono",

        "liblog",

        "libmedia_helper",

        "libstagefright_foundation",

        "libtinyalsav2",

        "libutils",
@@ -34,9 +31,6 @@ cc_defaults { 
        "libaudioaidl_headers",

        "libxsdc-utils",

    ],

    cflags: [

        "-DBACKEND_NDK",

    ],

}



cc_library {
@@ -84,7 +78,6 @@ cc_library { 
        "Stream.cpp",

        "StreamSwitcher.cpp",

        "Telephony.cpp",

        "XsdcConversion.cpp",

        "alsa/Mixer.cpp",

        "alsa/ModuleAlsa.cpp",

        "alsa/StreamAlsa.cpp",
@@ -179,7 +172,6 @@ cc_test { 
        "libbase",

        "libbinder_ndk",

        "libcutils",

        "libfmq",

        "libmedia_helper",

        "libstagefright_foundation",

        "libutils",
@@ -192,11 +184,9 @@ cc_test { 
    ],

    generated_sources: [

        "audio_policy_configuration_aidl_default",

        "audio_policy_engine_configuration_aidl_default",

    ],

    generated_headers: [

        "audio_policy_configuration_aidl_default",

        "audio_policy_engine_configuration_aidl_default",

    ],

    srcs: [

        "AudioPolicyConfigXmlConverter.cpp",

audio/aidl/default/AudioPolicyConfigXmlConverter.cpp

+36 −35
Original line number Diff line number Diff line
@@ -30,7 +30,6 @@ 


#include "core-impl/AidlConversionXsdc.h"

#include "core-impl/AudioPolicyConfigXmlConverter.h"

#include "core-impl/XsdcConversion.h"



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

using aidl::android::media::audio::common::AudioHalEngineConfig;
@@ -38,39 +37,60 @@ using aidl::android::media::audio::common::AudioHalVolumeCurve; 
using aidl::android::media::audio::common::AudioHalVolumeGroup;

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



namespace ap_xsd = android::audio::policy::configuration;

namespace xsd = android::audio::policy::configuration;



namespace aidl::android::hardware::audio::core::internal {



static const int kDefaultVolumeIndexMin = 0;

static const int kDefaultVolumeIndexMax = 100;

static const int KVolumeIndexDeferredToAudioService = -1;

/**

 * Valid curve points take the form "<index>,<attenuationMb>", where the index

 * must be in the range [0,100]. kInvalidCurvePointIndex is used to indicate

 * that a point was formatted incorrectly (e.g. if a vendor accidentally typed a

 * '.' instead of a ',' in their XML) -- using such a curve point will result in

 * failed VTS tests.

 */

static const int8_t kInvalidCurvePointIndex = -1;



ConversionResult<AudioHalVolumeCurve> AudioPolicyConfigXmlConverter::convertVolumeCurveToAidl(

        const ap_xsd::Volume& xsdcVolumeCurve) {

AudioHalVolumeCurve::CurvePoint AudioPolicyConfigXmlConverter::convertCurvePointToAidl(

        const std::string& xsdcCurvePoint) {

    AudioHalVolumeCurve::CurvePoint aidlCurvePoint{};

    if (sscanf(xsdcCurvePoint.c_str(), "%" SCNd8 ",%d", &aidlCurvePoint.index,

               &aidlCurvePoint.attenuationMb) != 2) {

        aidlCurvePoint.index = kInvalidCurvePointIndex;

    }

    return aidlCurvePoint;

}



AudioHalVolumeCurve AudioPolicyConfigXmlConverter::convertVolumeCurveToAidl(

        const xsd::Volume& xsdcVolumeCurve) {

    AudioHalVolumeCurve aidlVolumeCurve;

    aidlVolumeCurve.deviceCategory =

            static_cast<AudioHalVolumeCurve::DeviceCategory>(xsdcVolumeCurve.getDeviceCategory());

    if (xsdcVolumeCurve.hasRef()) {

        if (mVolumesReferenceMap.empty()) {

            mVolumesReferenceMap = generateReferenceMap<ap_xsd::Volumes, ap_xsd::Reference>(

            mVolumesReferenceMap = generateReferenceMap<xsd::Volumes, xsd::Reference>(

                    getXsdcConfig()->getVolumes());

        }

        aidlVolumeCurve.curvePoints = VALUE_OR_FATAL(

                (convertCollectionToAidl<std::string, AudioHalVolumeCurve::CurvePoint>(

        aidlVolumeCurve.curvePoints =

                convertCollectionToAidlUnchecked<std::string, AudioHalVolumeCurve::CurvePoint>(

                        mVolumesReferenceMap.at(xsdcVolumeCurve.getRef()).getPoint(),

                        &convertCurvePointToAidl)));

                        std::bind(&AudioPolicyConfigXmlConverter::convertCurvePointToAidl, this,

                                  std::placeholders::_1));

    } else {

        aidlVolumeCurve.curvePoints = VALUE_OR_FATAL(

                (convertCollectionToAidl<std::string, AudioHalVolumeCurve::CurvePoint>(

                        xsdcVolumeCurve.getPoint(), &convertCurvePointToAidl)));

        aidlVolumeCurve.curvePoints =

                convertCollectionToAidlUnchecked<std::string, AudioHalVolumeCurve::CurvePoint>(

                        xsdcVolumeCurve.getPoint(),

                        std::bind(&AudioPolicyConfigXmlConverter::convertCurvePointToAidl, this,

                                  std::placeholders::_1));

    }

    return aidlVolumeCurve;

}



void AudioPolicyConfigXmlConverter::mapStreamToVolumeCurve(const ap_xsd::Volume& xsdcVolumeCurve) {

void AudioPolicyConfigXmlConverter::mapStreamToVolumeCurve(const xsd::Volume& xsdcVolumeCurve) {

    mStreamToVolumeCurvesMap[xsdcVolumeCurve.getStream()].push_back(

            VALUE_OR_FATAL(convertVolumeCurveToAidl(xsdcVolumeCurve)));

            convertVolumeCurveToAidl(xsdcVolumeCurve));

}



const SurroundSoundConfig& AudioPolicyConfigXmlConverter::getSurroundSoundConfig() {
@@ -89,11 +109,6 @@ const SurroundSoundConfig& AudioPolicyConfigXmlConverter::getSurroundSoundConfig 
    return aidlSurroundSoundConfig;

}



std::unique_ptr<AudioPolicyConfigXmlConverter::ModuleConfigs>

AudioPolicyConfigXmlConverter::releaseModuleConfigs() {

    return std::move(mModuleConfigurations);

}



const AudioHalEngineConfig& AudioPolicyConfigXmlConverter::getAidlEngineConfig() {

    if (mAidlEngineConfig.volumeGroups.empty() && getXsdcConfig() &&

        getXsdcConfig()->hasVolumes()) {
@@ -145,8 +160,8 @@ const SurroundSoundConfig& AudioPolicyConfigXmlConverter::getDefaultSurroundSoun 


void AudioPolicyConfigXmlConverter::mapStreamsToVolumeCurves() {

    if (getXsdcConfig()->hasVolumes()) {

        for (const ap_xsd::Volumes& xsdcWrapperType : getXsdcConfig()->getVolumes()) {

            for (const ap_xsd::Volume& xsdcVolume : xsdcWrapperType.getVolume()) {

        for (const xsd::Volumes& xsdcWrapperType : getXsdcConfig()->getVolumes()) {

            for (const xsd::Volume& xsdcVolume : xsdcWrapperType.getVolume()) {

                mapStreamToVolumeCurve(xsdcVolume);

            }

        }
@@ -156,7 +171,7 @@ void AudioPolicyConfigXmlConverter::mapStreamsToVolumeCurves() { 
void AudioPolicyConfigXmlConverter::addVolumeGroupstoEngineConfig() {

    for (const auto& [xsdcStream, volumeCurves] : mStreamToVolumeCurvesMap) {

        AudioHalVolumeGroup volumeGroup;

        volumeGroup.name = ap_xsd::toString(xsdcStream);

        volumeGroup.name = xsd::toString(xsdcStream);

        if (static_cast<int>(xsdcStream) >= AUDIO_STREAM_PUBLIC_CNT) {

            volumeGroup.minIndex = kDefaultVolumeIndexMin;

            volumeGroup.maxIndex = kDefaultVolumeIndexMax;
@@ -175,18 +190,4 @@ void AudioPolicyConfigXmlConverter::parseVolumes() { 
        addVolumeGroupstoEngineConfig();

    }

}



void AudioPolicyConfigXmlConverter::init() {

    if (!getXsdcConfig()->hasModules()) return;

    for (const ap_xsd::Modules& xsdcModulesType : getXsdcConfig()->getModules()) {

        if (!xsdcModulesType.has_module()) continue;

        for (const ap_xsd::Modules::Module& xsdcModule : xsdcModulesType.get_module()) {

            // 'primary' in the XML schema used by HIDL is equivalent to 'default' module.

            const std::string name =

                    xsdcModule.getName() != "primary" ? xsdcModule.getName() : "default";

            mModuleConfigurations->emplace_back(

                    name, VALUE_OR_FATAL(convertModuleConfigToAidl(xsdcModule)));

        }

    }

}

}  // namespace aidl::android::hardware::audio::core::internal

audio/aidl/default/Configuration.cpp

+0 −16
Original line number Diff line number Diff line
@@ -43,7 +43,6 @@ using aidl::android::media::audio::common::AudioProfile; 
using aidl::android::media::audio::common::Int;

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

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

using Configuration = aidl::android::hardware::audio::core::Module::Configuration;



namespace aidl::android::hardware::audio::core::internal {
@@ -678,19 +677,4 @@ std::unique_ptr<Configuration> getBluetoothConfiguration() { 
    return std::make_unique<Configuration>(configuration);

}



std::unique_ptr<Module::Configuration> getConfiguration(Module::Type moduleType) {

    switch (moduleType) {

        case Module::Type::DEFAULT:

            return getPrimaryConfiguration();

        case Module::Type::R_SUBMIX:

            return getRSubmixConfiguration();

        case Module::Type::STUB:

            return getStubConfiguration();

        case Module::Type::USB:

            return getUsbConfiguration();

        case Module::Type::BLUETOOTH:

            return getBluetoothConfiguration();

    }

}



}  // namespace aidl::android::hardware::audio::core::internal

audio/aidl/default/EngineConfigXmlConverter.cpp

+114 −74

File changed.

Preview size limit exceeded, changes collapsed.

audio/aidl/default/Module.cpp

+28 −26
Original line number Diff line number Diff line
@@ -25,7 +25,6 @@ 
#include <android/binder_ibinder_platform.h>

#include <error/expected_utils.h>



#include "core-impl/Configuration.h"

#include "core-impl/Module.h"

#include "core-impl/ModuleBluetooth.h"

#include "core-impl/ModulePrimary.h"
@@ -133,36 +132,21 @@ bool findAudioProfile(const AudioPort& port, const AudioFormatDescription& forma 
}  // namespace



// static

std::shared_ptr<Module> Module::createInstance(Type type, std::unique_ptr<Configuration>&& config) {

std::shared_ptr<Module> Module::createInstance(Type type) {

    switch (type) {

        case Type::DEFAULT:

            return ndk::SharedRefBase::make<ModulePrimary>(std::move(config));

            return ndk::SharedRefBase::make<ModulePrimary>();

        case Type::R_SUBMIX:

            return ndk::SharedRefBase::make<ModuleRemoteSubmix>(std::move(config));

            return ndk::SharedRefBase::make<ModuleRemoteSubmix>();

        case Type::STUB:

            return ndk::SharedRefBase::make<ModuleStub>(std::move(config));

            return ndk::SharedRefBase::make<ModuleStub>();

        case Type::USB:

            return ndk::SharedRefBase::make<ModuleUsb>(std::move(config));

            return ndk::SharedRefBase::make<ModuleUsb>();

        case Type::BLUETOOTH:

            return ndk::SharedRefBase::make<ModuleBluetooth>(std::move(config));

            return ndk::SharedRefBase::make<ModuleBluetooth>();

    }

}



// static

std::optional<Module::Type> Module::typeFromString(const std::string& type) {

    if (type == "default")

        return Module::Type::DEFAULT;

    else if (type == "r_submix")

        return Module::Type::R_SUBMIX;

    else if (type == "stub")

        return Module::Type::STUB;

    else if (type == "usb")

        return Module::Type::USB;

    else if (type == "bluetooth")

        return Module::Type::BLUETOOTH;

    return {};

}



std::ostream& operator<<(std::ostream& os, Module::Type t) {

    switch (t) {

        case Module::Type::DEFAULT:
@@ -332,8 +316,26 @@ std::set<int32_t> Module::portIdsFromPortConfigIds(C portConfigIds) { 
    return result;

}



std::unique_ptr<Module::Configuration> Module::initializeConfig() {

    return internal::getConfiguration(getType());

std::unique_ptr<internal::Configuration> Module::initializeConfig() {

    std::unique_ptr<internal::Configuration> config;

    switch (getType()) {

        case Type::DEFAULT:

            config = std::move(internal::getPrimaryConfiguration());

            break;

        case Type::R_SUBMIX:

            config = std::move(internal::getRSubmixConfiguration());

            break;

        case Type::STUB:

            config = std::move(internal::getStubConfiguration());

            break;

        case Type::USB:

            config = std::move(internal::getUsbConfiguration());

            break;

        case Type::BLUETOOTH:

            config = std::move(internal::getBluetoothConfiguration());

            break;

    }

    return config;

}



std::vector<AudioRoute*> Module::getAudioRoutesForAudioPortImpl(int32_t portId) {
@@ -348,7 +350,7 @@ std::vector<AudioRoute*> Module::getAudioRoutesForAudioPortImpl(int32_t portId) 
    return result;

}



Module::Configuration& Module::getConfig() {

internal::Configuration& Module::getConfig() {

    if (!mConfig) {

        mConfig = std::move(initializeConfig());

    }
@@ -795,7 +797,7 @@ ndk::ScopedAStatus Module::openInputStream(const OpenInputStreamArguments& in_ar 
    context.fillDescriptor(&_aidl_return->desc);

    std::shared_ptr<StreamIn> stream;

    RETURN_STATUS_IF_ERROR(createInputStream(std::move(context), in_args.sinkMetadata,

                                             getConfig().microphones, &stream));

                                             mConfig->microphones, &stream));

    StreamWrapper streamWrapper(stream);

    if (auto patchIt = mPatches.find(in_args.portConfigId); patchIt != mPatches.end()) {

        RETURN_STATUS_IF_ERROR(