| /* |
| * Copyright (C) 2022 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 <algorithm> |
| #include <chrono> |
| |
| #include <Utils.h> |
| #include <aidl/android/media/audio/common/AudioInputFlags.h> |
| #include <aidl/android/media/audio/common/AudioIoFlags.h> |
| #include <aidl/android/media/audio/common/AudioOutputFlags.h> |
| |
| #include "ModuleConfig.h" |
| |
| using namespace android; |
| using namespace std::chrono_literals; |
| |
| using aidl::android::hardware::audio::common::isBitPositionFlagSet; |
| using aidl::android::hardware::audio::core::IModule; |
| using aidl::android::media::audio::common::AudioChannelLayout; |
| using aidl::android::media::audio::common::AudioDeviceDescription; |
| using aidl::android::media::audio::common::AudioDeviceType; |
| using aidl::android::media::audio::common::AudioEncapsulationMode; |
| using aidl::android::media::audio::common::AudioFormatDescription; |
| using aidl::android::media::audio::common::AudioFormatType; |
| using aidl::android::media::audio::common::AudioInputFlags; |
| using aidl::android::media::audio::common::AudioIoFlags; |
| using aidl::android::media::audio::common::AudioOffloadInfo; |
| using aidl::android::media::audio::common::AudioOutputFlags; |
| using aidl::android::media::audio::common::AudioPort; |
| using aidl::android::media::audio::common::AudioPortConfig; |
| using aidl::android::media::audio::common::AudioPortExt; |
| using aidl::android::media::audio::common::AudioProfile; |
| using aidl::android::media::audio::common::AudioUsage; |
| using aidl::android::media::audio::common::Int; |
| |
| // static |
| std::optional<AudioOffloadInfo> ModuleConfig::generateOffloadInfoIfNeeded( |
| const AudioPortConfig& portConfig) { |
| if (portConfig.flags.has_value() && |
| portConfig.flags.value().getTag() == AudioIoFlags::Tag::output && |
| isBitPositionFlagSet(portConfig.flags.value().get<AudioIoFlags::Tag::output>(), |
| AudioOutputFlags::COMPRESS_OFFLOAD)) { |
| AudioOffloadInfo offloadInfo; |
| offloadInfo.base.sampleRate = portConfig.sampleRate.value().value; |
| offloadInfo.base.channelMask = portConfig.channelMask.value(); |
| offloadInfo.base.format = portConfig.format.value(); |
| offloadInfo.bitRatePerSecond = 256000; // Arbitrary value. |
| offloadInfo.durationUs = std::chrono::microseconds(1min).count(); // Arbitrary value. |
| offloadInfo.usage = AudioUsage::MEDIA; |
| offloadInfo.encapsulationMode = AudioEncapsulationMode::NONE; |
| return offloadInfo; |
| } |
| return {}; |
| } |
| |
| std::vector<aidl::android::media::audio::common::AudioPort> |
| ModuleConfig::getAudioPortsForDeviceTypes(const std::vector<AudioDeviceType>& deviceTypes, |
| const std::string& connection) { |
| return getAudioPortsForDeviceTypes(mPorts, deviceTypes, connection); |
| } |
| |
| // static |
| std::vector<aidl::android::media::audio::common::AudioPort> ModuleConfig::getBuiltInMicPorts( |
| const std::vector<aidl::android::media::audio::common::AudioPort>& ports) { |
| return getAudioPortsForDeviceTypes( |
| ports, std::vector<AudioDeviceType>{AudioDeviceType::IN_MICROPHONE, |
| AudioDeviceType::IN_MICROPHONE_BACK}); |
| } |
| |
| std::vector<aidl::android::media::audio::common::AudioPort> |
| ModuleConfig::getAudioPortsForDeviceTypes( |
| const std::vector<aidl::android::media::audio::common::AudioPort>& ports, |
| const std::vector<AudioDeviceType>& deviceTypes, const std::string& connection) { |
| std::vector<AudioPort> result; |
| for (const auto& port : ports) { |
| if (port.ext.getTag() != AudioPortExt::Tag::device) continue; |
| const auto type = port.ext.get<AudioPortExt::Tag::device>().device.type; |
| if (type.connection == connection) { |
| for (auto deviceType : deviceTypes) { |
| if (type.type == deviceType) { |
| result.push_back(port); |
| } |
| } |
| } |
| } |
| return result; |
| } |
| |
| template <typename T> |
| auto findById(const std::vector<T>& v, int32_t id) { |
| return std::find_if(v.begin(), v.end(), [&](const auto& p) { return p.id == id; }); |
| } |
| |
| ModuleConfig::ModuleConfig(IModule* module) { |
| mStatus = module->getAudioPorts(&mPorts); |
| if (!mStatus.isOk()) return; |
| for (const auto& port : mPorts) { |
| if (port.ext.getTag() != AudioPortExt::Tag::device) continue; |
| const auto& devicePort = port.ext.get<AudioPortExt::Tag::device>(); |
| if (devicePort.device.type.connection.empty()) { |
| const bool isInput = port.flags.getTag() == AudioIoFlags::Tag::input; |
| // Permanently attached device. |
| if (isInput) { |
| mAttachedSourceDevicePorts.insert(port.id); |
| } else { |
| mAttachedSinkDevicePorts.insert(port.id); |
| } |
| } else if (devicePort.device.type.connection != AudioDeviceDescription::CONNECTION_VIRTUAL |
| // The "virtual" connection is used for remote submix which is a dynamic |
| // device but it can be connected and used w/o external hardware. |
| && port.profiles.empty()) { |
| mExternalDevicePorts.insert(port.id); |
| } |
| } |
| if (!mStatus.isOk()) return; |
| mStatus = module->getAudioRoutes(&mRoutes); |
| if (!mStatus.isOk()) return; |
| mStatus = module->getAudioPortConfigs(&mInitialConfigs); |
| } |
| |
| std::vector<AudioPort> ModuleConfig::getAttachedDevicePorts() const { |
| std::vector<AudioPort> result; |
| std::copy_if(mPorts.begin(), mPorts.end(), std::back_inserter(result), [&](const auto& port) { |
| return mAttachedSinkDevicePorts.count(port.id) != 0 || |
| mAttachedSourceDevicePorts.count(port.id) != 0; |
| }); |
| return result; |
| } |
| |
| std::vector<AudioPort> ModuleConfig::getConnectedExternalDevicePorts() const { |
| std::vector<AudioPort> result; |
| std::copy_if(mPorts.begin(), mPorts.end(), std::back_inserter(result), [&](const auto& port) { |
| return mConnectedExternalSinkDevicePorts.count(port.id) != 0 || |
| mConnectedExternalSourceDevicePorts.count(port.id) != 0; |
| }); |
| return result; |
| } |
| |
| std::set<int32_t> ModuleConfig::getConnectedSinkDevicePorts() const { |
| std::set<int32_t> result; |
| result.insert(mAttachedSinkDevicePorts.begin(), mAttachedSinkDevicePorts.end()); |
| result.insert(mConnectedExternalSinkDevicePorts.begin(), |
| mConnectedExternalSinkDevicePorts.end()); |
| return result; |
| } |
| |
| std::set<int32_t> ModuleConfig::getConnectedSourceDevicePorts() const { |
| std::set<int32_t> result; |
| result.insert(mAttachedSourceDevicePorts.begin(), mAttachedSourceDevicePorts.end()); |
| result.insert(mConnectedExternalSourceDevicePorts.begin(), |
| mConnectedExternalSourceDevicePorts.end()); |
| return result; |
| } |
| |
| std::vector<AudioPort> ModuleConfig::getExternalDevicePorts() const { |
| std::vector<AudioPort> result; |
| std::copy_if(mPorts.begin(), mPorts.end(), std::back_inserter(result), |
| [&](const auto& port) { return mExternalDevicePorts.count(port.id) != 0; }); |
| return result; |
| } |
| |
| std::vector<AudioPort> ModuleConfig::getInputMixPorts(bool connectedOnly) const { |
| std::vector<AudioPort> result; |
| std::copy_if(mPorts.begin(), mPorts.end(), std::back_inserter(result), [&](const auto& port) { |
| return port.ext.getTag() == AudioPortExt::Tag::mix && |
| port.flags.getTag() == AudioIoFlags::Tag::input && |
| (!connectedOnly || !getConnectedSourceDevicesPortsForMixPort(port).empty()); |
| }); |
| return result; |
| } |
| |
| std::vector<AudioPort> ModuleConfig::getOutputMixPorts(bool connectedOnly) const { |
| std::vector<AudioPort> result; |
| std::copy_if(mPorts.begin(), mPorts.end(), std::back_inserter(result), [&](const auto& port) { |
| return port.ext.getTag() == AudioPortExt::Tag::mix && |
| port.flags.getTag() == AudioIoFlags::Tag::output && |
| (!connectedOnly || !getConnectedSinkDevicesPortsForMixPort(port).empty()); |
| }); |
| return result; |
| } |
| |
| std::vector<AudioPort> ModuleConfig::getNonBlockingMixPorts(bool connectedOnly, |
| bool singlePort) const { |
| return findMixPorts(false /*isInput*/, connectedOnly, singlePort, [&](const AudioPort& port) { |
| return isBitPositionFlagSet(port.flags.get<AudioIoFlags::Tag::output>(), |
| AudioOutputFlags::NON_BLOCKING); |
| }); |
| } |
| |
| std::vector<AudioPort> ModuleConfig::getOffloadMixPorts(bool connectedOnly, bool singlePort) const { |
| return findMixPorts(false /*isInput*/, connectedOnly, singlePort, [&](const AudioPort& port) { |
| return isBitPositionFlagSet(port.flags.get<AudioIoFlags::Tag::output>(), |
| AudioOutputFlags::COMPRESS_OFFLOAD); |
| }); |
| } |
| |
| std::vector<AudioPort> ModuleConfig::getPrimaryMixPorts(bool connectedOnly, bool singlePort) const { |
| return findMixPorts(false /*isInput*/, connectedOnly, singlePort, [&](const AudioPort& port) { |
| return isBitPositionFlagSet(port.flags.get<AudioIoFlags::Tag::output>(), |
| AudioOutputFlags::PRIMARY); |
| }); |
| } |
| |
| std::vector<AudioPort> ModuleConfig::getMmapOutMixPorts(bool connectedOnly, bool singlePort) const { |
| return findMixPorts(false /*isInput*/, connectedOnly, singlePort, [&](const AudioPort& port) { |
| return isBitPositionFlagSet(port.flags.get<AudioIoFlags::Tag::output>(), |
| AudioOutputFlags::MMAP_NOIRQ); |
| }); |
| } |
| |
| std::vector<AudioPort> ModuleConfig::getMmapInMixPorts(bool connectedOnly, bool singlePort) const { |
| return findMixPorts(true /*isInput*/, connectedOnly, singlePort, [&](const AudioPort& port) { |
| return isBitPositionFlagSet(port.flags.get<AudioIoFlags::Tag::input>(), |
| AudioInputFlags::MMAP_NOIRQ); |
| }); |
| } |
| |
| std::vector<AudioPort> ModuleConfig::getConnectedDevicesPortsForMixPort( |
| bool isInput, const AudioPortConfig& mixPortConfig) const { |
| const auto mixPortIt = findById<AudioPort>(mPorts, mixPortConfig.portId); |
| if (mixPortIt != mPorts.end()) { |
| return getConnectedDevicesPortsForMixPort(isInput, *mixPortIt); |
| } |
| return {}; |
| } |
| |
| std::vector<AudioPort> ModuleConfig::getConnectedSinkDevicesPortsForMixPort( |
| const AudioPort& mixPort) const { |
| std::vector<AudioPort> result; |
| std::set<int32_t> connectedSinkDevicePorts = getConnectedSinkDevicePorts(); |
| for (const auto& route : mRoutes) { |
| if ((connectedSinkDevicePorts.count(route.sinkPortId) != 0) && |
| std::find(route.sourcePortIds.begin(), route.sourcePortIds.end(), mixPort.id) != |
| route.sourcePortIds.end()) { |
| const auto devicePortIt = findById<AudioPort>(mPorts, route.sinkPortId); |
| if (devicePortIt != mPorts.end()) result.push_back(*devicePortIt); |
| } |
| } |
| return result; |
| } |
| |
| std::vector<AudioPort> ModuleConfig::getConnectedSourceDevicesPortsForMixPort( |
| const AudioPort& mixPort) const { |
| std::vector<AudioPort> result; |
| std::set<int32_t> connectedSourceDevicePorts = getConnectedSourceDevicePorts(); |
| for (const auto& route : mRoutes) { |
| if (route.sinkPortId == mixPort.id) { |
| for (const auto srcId : route.sourcePortIds) { |
| if (connectedSourceDevicePorts.count(srcId) != 0) { |
| const auto devicePortIt = findById<AudioPort>(mPorts, srcId); |
| if (devicePortIt != mPorts.end()) result.push_back(*devicePortIt); |
| } |
| } |
| } |
| } |
| return result; |
| } |
| |
| std::optional<AudioPort> ModuleConfig::getSourceMixPortForConnectedDevice() const { |
| std::set<int32_t> connectedSinkDevicePorts = getConnectedSinkDevicePorts(); |
| for (const auto& route : mRoutes) { |
| if (connectedSinkDevicePorts.count(route.sinkPortId) != 0) { |
| const auto mixPortIt = findById<AudioPort>(mPorts, route.sourcePortIds[0]); |
| if (mixPortIt != mPorts.end()) return *mixPortIt; |
| } |
| } |
| return {}; |
| } |
| |
| std::optional<ModuleConfig::SrcSinkPair> ModuleConfig::getNonRoutableSrcSinkPair( |
| bool isInput) const { |
| const auto mixPorts = getMixPorts(isInput, false /*connectedOnly*/); |
| std::set<std::pair<int32_t, int32_t>> allowedRoutes; |
| for (const auto& route : mRoutes) { |
| for (const auto srcPortId : route.sourcePortIds) { |
| allowedRoutes.emplace(std::make_pair(srcPortId, route.sinkPortId)); |
| } |
| } |
| auto make_pair = [isInput](auto& device, auto& mix) { |
| return isInput ? std::make_pair(device, mix) : std::make_pair(mix, device); |
| }; |
| for (const auto portId : |
| isInput ? getConnectedSourceDevicePorts() : getConnectedSinkDevicePorts()) { |
| const auto devicePortIt = findById<AudioPort>(mPorts, portId); |
| if (devicePortIt == mPorts.end()) continue; |
| auto devicePortConfig = getSingleConfigForDevicePort(*devicePortIt); |
| for (const auto& mixPort : mixPorts) { |
| if (std::find(allowedRoutes.begin(), allowedRoutes.end(), |
| make_pair(portId, mixPort.id)) == allowedRoutes.end()) { |
| auto mixPortConfig = getSingleConfigForMixPort(isInput, mixPort); |
| if (mixPortConfig.has_value()) { |
| return make_pair(devicePortConfig, mixPortConfig.value()); |
| } |
| } |
| } |
| } |
| return {}; |
| } |
| |
| std::optional<ModuleConfig::SrcSinkPair> ModuleConfig::getRoutableSrcSinkPair(bool isInput) const { |
| if (isInput) { |
| std::set<int32_t> connectedSourceDevicePorts = getConnectedSourceDevicePorts(); |
| for (const auto& route : mRoutes) { |
| auto srcPortIdIt = std::find_if( |
| route.sourcePortIds.begin(), route.sourcePortIds.end(), |
| [&](const auto& portId) { return connectedSourceDevicePorts.count(portId); }); |
| if (srcPortIdIt == route.sourcePortIds.end()) continue; |
| const auto devicePortIt = findById<AudioPort>(mPorts, *srcPortIdIt); |
| const auto mixPortIt = findById<AudioPort>(mPorts, route.sinkPortId); |
| if (devicePortIt == mPorts.end() || mixPortIt == mPorts.end()) continue; |
| auto devicePortConfig = getSingleConfigForDevicePort(*devicePortIt); |
| auto mixPortConfig = getSingleConfigForMixPort(isInput, *mixPortIt); |
| if (!mixPortConfig.has_value()) continue; |
| return std::make_pair(devicePortConfig, mixPortConfig.value()); |
| } |
| } else { |
| std::set<int32_t> connectedSinkDevicePorts = getConnectedSinkDevicePorts(); |
| for (const auto& route : mRoutes) { |
| if (connectedSinkDevicePorts.count(route.sinkPortId) == 0) continue; |
| const auto mixPortIt = findById<AudioPort>(mPorts, route.sourcePortIds[0]); |
| const auto devicePortIt = findById<AudioPort>(mPorts, route.sinkPortId); |
| if (devicePortIt == mPorts.end() || mixPortIt == mPorts.end()) continue; |
| auto mixPortConfig = getSingleConfigForMixPort(isInput, *mixPortIt); |
| auto devicePortConfig = getSingleConfigForDevicePort(*devicePortIt); |
| if (!mixPortConfig.has_value()) continue; |
| return std::make_pair(mixPortConfig.value(), devicePortConfig); |
| } |
| } |
| return {}; |
| } |
| |
| std::vector<ModuleConfig::SrcSinkGroup> ModuleConfig::getRoutableSrcSinkGroups(bool isInput) const { |
| std::vector<SrcSinkGroup> result; |
| if (isInput) { |
| std::set<int32_t> connectedSourceDevicePorts = getConnectedSourceDevicePorts(); |
| for (const auto& route : mRoutes) { |
| std::vector<int32_t> srcPortIds; |
| std::copy_if(route.sourcePortIds.begin(), route.sourcePortIds.end(), |
| std::back_inserter(srcPortIds), [&](const auto& portId) { |
| return connectedSourceDevicePorts.count(portId); |
| }); |
| if (srcPortIds.empty()) continue; |
| const auto mixPortIt = findById<AudioPort>(mPorts, route.sinkPortId); |
| if (mixPortIt == mPorts.end()) continue; |
| auto mixPortConfig = getSingleConfigForMixPort(isInput, *mixPortIt); |
| if (!mixPortConfig.has_value()) continue; |
| std::vector<SrcSinkPair> pairs; |
| for (const auto srcPortId : srcPortIds) { |
| const auto devicePortIt = findById<AudioPort>(mPorts, srcPortId); |
| if (devicePortIt == mPorts.end()) continue; |
| // Using all configs for every source would be too much. |
| auto devicePortConfig = getSingleConfigForDevicePort(*devicePortIt); |
| pairs.emplace_back(devicePortConfig, mixPortConfig.value()); |
| } |
| if (!pairs.empty()) { |
| result.emplace_back(route, std::move(pairs)); |
| } |
| } |
| } else { |
| std::set<int32_t> connectedSinkDevicePorts = getConnectedSinkDevicePorts(); |
| for (const auto& route : mRoutes) { |
| if (connectedSinkDevicePorts.count(route.sinkPortId) == 0) continue; |
| const auto devicePortIt = findById<AudioPort>(mPorts, route.sinkPortId); |
| if (devicePortIt == mPorts.end()) continue; |
| auto devicePortConfig = getSingleConfigForDevicePort(*devicePortIt); |
| std::vector<SrcSinkPair> pairs; |
| for (const auto srcPortId : route.sourcePortIds) { |
| const auto mixPortIt = findById<AudioPort>(mPorts, srcPortId); |
| if (mixPortIt == mPorts.end()) continue; |
| // Using all configs for every source would be too much. |
| auto mixPortConfig = getSingleConfigForMixPort(isInput, *mixPortIt); |
| if (mixPortConfig.has_value()) { |
| pairs.emplace_back(mixPortConfig.value(), devicePortConfig); |
| } |
| } |
| if (!pairs.empty()) { |
| result.emplace_back(route, std::move(pairs)); |
| } |
| } |
| } |
| return result; |
| } |
| |
| std::string ModuleConfig::toString() const { |
| std::string result; |
| result.append("Ports: "); |
| result.append(android::internal::ToString(mPorts)); |
| result.append("\nInitial configs: "); |
| result.append(android::internal::ToString(mInitialConfigs)); |
| result.append("\nAttached sink device ports: "); |
| result.append(android::internal::ToString(mAttachedSinkDevicePorts)); |
| result.append("\nAttached source device ports: "); |
| result.append(android::internal::ToString(mAttachedSourceDevicePorts)); |
| result.append("\nExternal device ports: "); |
| result.append(android::internal::ToString(mExternalDevicePorts)); |
| result.append("\nConnected external device ports: "); |
| result.append(android::internal::ToString(getConnectedExternalDevicePorts())); |
| result.append("\nRoutes: "); |
| result.append(android::internal::ToString(mRoutes)); |
| return result; |
| } |
| |
| static size_t combineAudioConfigs(const AudioPort& port, const AudioProfile& profile, |
| std::vector<AudioPortConfig>* result) { |
| const size_t newConfigCount = profile.channelMasks.size() * profile.sampleRates.size(); |
| result->reserve(result->capacity() + newConfigCount); |
| for (auto channelMask : profile.channelMasks) { |
| for (auto sampleRate : profile.sampleRates) { |
| AudioPortConfig config{}; |
| config.portId = port.id; |
| Int sr; |
| sr.value = sampleRate; |
| config.sampleRate = sr; |
| config.channelMask = channelMask; |
| config.format = profile.format; |
| config.flags = port.flags; |
| config.ext = port.ext; |
| result->push_back(std::move(config)); |
| } |
| } |
| return newConfigCount; |
| } |
| |
| static bool isDynamicProfile(const AudioProfile& profile) { |
| return (profile.format.type == AudioFormatType::DEFAULT && profile.format.encoding.empty()) || |
| profile.sampleRates.empty() || profile.channelMasks.empty(); |
| } |
| |
| std::vector<AudioPort> ModuleConfig::findMixPorts( |
| bool isInput, bool connectedOnly, bool singlePort, |
| const std::function<bool(const AudioPort&)>& pred) const { |
| std::vector<AudioPort> result; |
| const auto mixPorts = getMixPorts(isInput, connectedOnly); |
| for (auto mixPortIt = mixPorts.begin(); mixPortIt != mixPorts.end();) { |
| mixPortIt = std::find_if(mixPortIt, mixPorts.end(), pred); |
| if (mixPortIt == mixPorts.end()) break; |
| result.push_back(*mixPortIt++); |
| if (singlePort) break; |
| } |
| return result; |
| } |
| |
| std::vector<AudioPortConfig> ModuleConfig::generateAudioMixPortConfigs( |
| const std::vector<AudioPort>& ports, bool isInput, bool singleProfile) const { |
| std::vector<AudioPortConfig> result; |
| for (const auto& mixPort : ports) { |
| if (getConnectedDevicesPortsForMixPort(isInput, mixPort).empty()) { |
| continue; |
| } |
| for (const auto& profile : mixPort.profiles) { |
| if (isDynamicProfile(profile)) continue; |
| combineAudioConfigs(mixPort, profile, &result); |
| if (singleProfile && !result.empty()) { |
| result.resize(1); |
| return result; |
| } |
| } |
| } |
| return result; |
| } |
| |
| std::vector<AudioPortConfig> ModuleConfig::generateAudioDevicePortConfigs( |
| const std::vector<AudioPort>& ports, bool singleProfile) const { |
| std::vector<AudioPortConfig> result; |
| for (const auto& devicePort : ports) { |
| const size_t resultSizeBefore = result.size(); |
| for (const auto& profile : devicePort.profiles) { |
| combineAudioConfigs(devicePort, profile, &result); |
| if (singleProfile && !result.empty()) { |
| result.resize(1); |
| return result; |
| } |
| } |
| if (resultSizeBefore == result.size()) { |
| std::copy_if(mInitialConfigs.begin(), mInitialConfigs.end(), std::back_inserter(result), |
| [&](const auto& config) { return config.portId == devicePort.id; }); |
| if (resultSizeBefore == result.size()) { |
| AudioPortConfig empty; |
| empty.portId = devicePort.id; |
| empty.ext = devicePort.ext; |
| result.push_back(empty); |
| } |
| } |
| if (singleProfile) return result; |
| } |
| return result; |
| } |
| |
| const ndk::ScopedAStatus& ModuleConfig::onExternalDeviceConnected(IModule* module, |
| const AudioPort& port) { |
| // Update ports and routes |
| mStatus = module->getAudioPorts(&mPorts); |
| if (!mStatus.isOk()) return mStatus; |
| mStatus = module->getAudioRoutes(&mRoutes); |
| if (!mStatus.isOk()) return mStatus; |
| |
| // Validate port is present in module |
| if (std::find(mPorts.begin(), mPorts.end(), port) == mPorts.end()) { |
| mStatus = ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); |
| return mStatus; |
| } |
| |
| if (port.flags.getTag() == aidl::android::media::audio::common::AudioIoFlags::Tag::input) { |
| mConnectedExternalSourceDevicePorts.insert(port.id); |
| } else { |
| mConnectedExternalSinkDevicePorts.insert(port.id); |
| } |
| return mStatus; |
| } |
| |
| const ndk::ScopedAStatus& ModuleConfig::onExternalDeviceDisconnected(IModule* module, |
| const AudioPort& port) { |
| // Update ports and routes |
| mStatus = module->getAudioPorts(&mPorts); |
| if (!mStatus.isOk()) return mStatus; |
| mStatus = module->getAudioRoutes(&mRoutes); |
| if (!mStatus.isOk()) return mStatus; |
| |
| if (port.flags.getTag() == aidl::android::media::audio::common::AudioIoFlags::Tag::input) { |
| mConnectedExternalSourceDevicePorts.erase(port.id); |
| } else { |
| mConnectedExternalSinkDevicePorts.erase(port.id); |
| } |
| return mStatus; |
| } |
| |
| bool ModuleConfig::isMmapSupported() const { |
| const std::vector<AudioPort> mmapOutMixPorts = |
| getMmapOutMixPorts(false /*connectedOnly*/, false /*singlePort*/); |
| const std::vector<AudioPort> mmapInMixPorts = |
| getMmapInMixPorts(false /*connectedOnly*/, false /*singlePort*/); |
| return !mmapOutMixPorts.empty() || !mmapInMixPorts.empty(); |
| } |
