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

Commit 03a2fbc6 authored by Mikhail Naganov's avatar Mikhail Naganov Committed by Gerrit Code Review
Browse files

Merge changes from topic "revert-2770886-AidlAudioHalModuleConfig-FQCMWOWMCH" into main 

* changes:
  Revert "audio: Parse module configurations from the APM XML files"
  Revert "audio: Populate MicrophoneInfo with vendor data"
  Revert "audio: Set connectedProfiles for non-attached device ports."
  Revert "audio: Use hardcoded r_submix configuration with XML"
parents 43543bda af75a679

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 −41
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;



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;

}



ConversionResult<AudioHalVolumeCurve> AudioPolicyConfigXmlConverter::convertVolumeCurveToAidl(

        const ap_xsd::Volume& xsdcVolumeCurve) {

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,24 +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";

            if (name != "r_submix") {

                mModuleConfigurations->emplace_back(

                        name, VALUE_OR_FATAL(convertModuleConfigToAidl(xsdcModule)));

            } else {

                // See the note on the 'getRSubmixConfiguration' function.

                mModuleConfigurations->emplace_back(name, nullptr);

            }

        }

    }

}



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

audio/aidl/default/Configuration.cpp

+8 −32
Original line number Diff line number Diff line
@@ -41,8 +41,8 @@ using aidl::android::media::audio::common::AudioPortExt; 
using aidl::android::media::audio::common::AudioPortMixExt;

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 {
@@ -135,22 +135,6 @@ static AudioRoute createRoute(const std::vector<AudioPort>& sources, const Audio 
    return route;

}



std::vector<AudioProfile> getStandard16And24BitPcmAudioProfiles() {

    auto createStdPcmAudioProfile = [](const PcmType& pcmType) {

        return AudioProfile{

                .format = AudioFormatDescription{.type = AudioFormatType::PCM, .pcm = pcmType},

                .channelMasks = {AudioChannelLayout::make<AudioChannelLayout::layoutMask>(

                                         AudioChannelLayout::LAYOUT_MONO),

                                 AudioChannelLayout::make<AudioChannelLayout::layoutMask>(

                                         AudioChannelLayout::LAYOUT_STEREO)},

                .sampleRates = {8000, 11025, 16000, 32000, 44100, 48000}};

    };

    return {

            createStdPcmAudioProfile(PcmType::INT_16_BIT),

            createStdPcmAudioProfile(PcmType::INT_24_BIT),

    };

}



// Primary (default) configuration:

//

// Device ports:
@@ -289,6 +273,13 @@ std::unique_ptr<Configuration> getPrimaryConfiguration() { 


        c.portConfigs.insert(c.portConfigs.end(), c.initialConfigs.begin(), c.initialConfigs.end());



        MicrophoneInfo mic;

        mic.id = "mic";

        mic.device = micInDevice.ext.get<AudioPortExt::Tag::device>().device;

        mic.group = 0;

        mic.indexInTheGroup = 0;

        c.microphones = std::vector<MicrophoneInfo>{mic};



        return c;

    }();

    return std::make_unique<Configuration>(configuration);
@@ -686,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

+29 −72
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"
@@ -43,7 +42,6 @@ using aidl::android::hardware::audio::common::SourceMetadata; 
using aidl::android::hardware::audio::core::sounddose::ISoundDose;

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

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

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

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

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

using aidl::android::media::audio::common::AudioInputFlags;
@@ -134,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:
@@ -185,11 +168,6 @@ std::ostream& operator<<(std::ostream& os, Module::Type t) { 
    return os;

}



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

    : mType(type), mConfig(std::move(config)) {

    populateConnectedProfiles();

}



void Module::cleanUpPatch(int32_t patchId) {

    erase_all_values(mPatches, std::set<int32_t>{patchId});

}
@@ -325,22 +303,6 @@ ndk::ScopedAStatus Module::findPortIdForNewStream(int32_t in_portConfigId, Audio 
    return ndk::ScopedAStatus::ok();

}



void Module::populateConnectedProfiles() {

    Configuration& config = getConfig();

    for (const AudioPort& port : config.ports) {

        if (port.ext.getTag() == AudioPortExt::device) {

            if (auto devicePort = port.ext.get<AudioPortExt::device>();

                !devicePort.device.type.connection.empty() && port.profiles.empty()) {

                if (auto connIt = config.connectedProfiles.find(port.id);

                    connIt == config.connectedProfiles.end()) {

                    config.connectedProfiles.emplace(

                            port.id, internal::getStandard16And24BitPcmAudioProfiles());

                }

            }

        }

    }

}



template <typename C>

std::set<int32_t> Module::portIdsFromPortConfigIds(C portConfigIds) {

    std::set<int32_t> result;
@@ -354,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) {
@@ -370,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());

    }
@@ -817,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,

                                             getMicrophoneInfos(), &stream));

                                             mConfig->microphones, &stream));

    StreamWrapper streamWrapper(stream);

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

        RETURN_STATUS_IF_ERROR(
@@ -1251,7 +1231,7 @@ ndk::ScopedAStatus Module::setMicMute(bool in_mute) { 
}



ndk::ScopedAStatus Module::getMicrophones(std::vector<MicrophoneInfo>* _aidl_return) {

    *_aidl_return = getMicrophoneInfos();

    *_aidl_return = getConfig().microphones;

    LOG(DEBUG) << __func__ << ": returning " << ::android::internal::ToString(*_aidl_return);

    return ndk::ScopedAStatus::ok();

}
@@ -1530,29 +1510,6 @@ ndk::ScopedAStatus Module::onMasterVolumeChanged(float volume __unused) { 
    return ndk::ScopedAStatus::ok();

}



std::vector<MicrophoneInfo> Module::getMicrophoneInfos() {

    std::vector<MicrophoneInfo> result;

    Configuration& config = getConfig();

    for (const AudioPort& port : config.ports) {

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

            const AudioDeviceType deviceType =

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

            if (deviceType == AudioDeviceType::IN_MICROPHONE ||

                deviceType == AudioDeviceType::IN_MICROPHONE_BACK) {

                // Placeholder values. Vendor implementations must populate MicrophoneInfo

                // accordingly based on their physical microphone parameters.

                result.push_back(MicrophoneInfo{

                        .id = port.name,

                        .device = port.ext.get<AudioPortExt::Tag::device>().device,

                        .group = 0,

                        .indexInTheGroup = 0,

                });

            }

        }

    }

    return result;

}



Module::BtProfileHandles Module::getBtProfileManagerHandles() {

    return std::make_tuple(std::weak_ptr<IBluetooth>(), std::weak_ptr<IBluetoothA2dp>(),

                           std::weak_ptr<IBluetoothLe>());