Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 22:04:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge changes I118b2c04,I111b72aa,Ia5d29126

Browse Source 
* changes:
  audio: Add support for compressed offload
  audio: Improve debug logging in the AIDL version, fix bugs
  audio: Disable the C++ backend for android.hardware.audio.core
This commit is contained in:
Treehugger Robot
2022-08-25 02:24:01 +00:00
committed by Gerrit Code Review
parent 2412da0826 111e0ceab5
commit 660e9a4c48
10 changed files with 493 additions and 356 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
audio/aidl/Android.bp
View File

@@ -83,6 +83,10 @@ aidl_interface {
],
stability: "vintf",
backend: {
// The C++ backend is disabled transitively due to use of FMQ.
cpp: {
enabled: false,
},
java: {
platform_apis: true,
},

2
audio/aidl/android/hardware/audio/core/IModule.aidl
View File

@@ -282,6 +282,8 @@ interface IModule {
* @throws EX_ILLEGAL_ARGUMENT In the following cases:
* - If the port config can not be found by the ID.
* - If the port config is not of an output mix port.
* - If the offload info is not provided for an offload
* port configuration.
* @throws EX_ILLEGAL_STATE In the following cases:
* - If the port config already has a stream opened on it.
* - If the limit on the open stream count for the port has

2
audio/aidl/default/Android.bp
View File

@@ -13,6 +13,7 @@ cc_library_static {
shared_libs: [
"libbase",
"libbinder_ndk",
"libstagefright_foundation",
"android.media.audio.common.types-V1-ndk",
"android.hardware.audio.core-V1-ndk",
],
@@ -37,6 +38,7 @@ cc_binary {
shared_libs: [
"libbase",
"libbinder_ndk",
"libstagefright_foundation",
"android.media.audio.common.types-V1-ndk",
"android.hardware.audio.core-V1-ndk",
],

49
audio/aidl/default/Configuration.cpp
View File

@@ -20,6 +20,7 @@
#include <aidl/android/media/audio/common/AudioFormatType.h>
#include <aidl/android/media/audio/common/AudioIoFlags.h>
#include <aidl/android/media/audio/common/AudioOutputFlags.h>
#include <media/stagefright/foundation/MediaDefs.h>
#include "core-impl/Configuration.h"
@@ -42,16 +43,30 @@ using aidl::android::media::audio::common::PcmType;
namespace aidl::android::hardware::audio::core::internal {
static void fillProfile(AudioProfile* profile, const std::vector<int32_t>& channelLayouts,
const std::vector<int32_t>& sampleRates) {
for (auto layout : channelLayouts) {
profile->channelMasks.push_back(
AudioChannelLayout::make<AudioChannelLayout::layoutMask>(layout));
}
profile->sampleRates.insert(profile->sampleRates.end(), sampleRates.begin(), sampleRates.end());
}
static AudioProfile createProfile(PcmType pcmType, const std::vector<int32_t>& channelLayouts,
const std::vector<int32_t>& sampleRates) {
AudioProfile profile;
profile.format.type = AudioFormatType::PCM;
profile.format.pcm = pcmType;
for (auto layout : channelLayouts) {
profile.channelMasks.push_back(
AudioChannelLayout::make<AudioChannelLayout::layoutMask>(layout));
}
profile.sampleRates.insert(profile.sampleRates.end(), sampleRates.begin(), sampleRates.end());
fillProfile(&profile, channelLayouts, sampleRates);
return profile;
}
static AudioProfile createProfile(const std::string& encodingType,
const std::vector<int32_t>& channelLayouts,
const std::vector<int32_t>& sampleRates) {
AudioProfile profile;
profile.format.encoding = encodingType;
fillProfile(&profile, channelLayouts, sampleRates);
return profile;
}
@@ -125,6 +140,8 @@ static AudioRoute createRoute(const std::vector<int32_t>& sources, int32_t sink)
// * "primary output", PRIMARY, 1 max open, 1 max active stream
// - profile PCM 16-bit; MONO, STEREO; 44100, 48000
// - profile PCM 24-bit; MONO, STEREO; 44100, 48000
// * "compressed offload", DIRECT|COMPRESS_OFFLOAD|NON_BLOCKING, 1 max open, 1 max active stream
// - profile MP3; MONO, STEREO; 44100, 48000
// * "loopback output", stream count unlimited
// - profile PCM 24-bit; STEREO; 48000
// * "primary input", 2 max open, 2 max active streams
@@ -136,8 +153,8 @@ static AudioRoute createRoute(const std::vector<int32_t>& sources, int32_t sink)
// - profile PCM 24-bit; STEREO; 48000
//
// Routes:
// "primary out" -> "Null"
// "primary out" -> "USB Out"
// "primary out", "compressed offload" -> "Null"
// "primary out", "compressed offload" -> "USB Out"
// "loopback out" -> "Loopback Out"
// "Zero", "USB In" -> "primary input"
// "Loopback In" -> "loopback input"
@@ -183,6 +200,18 @@ Configuration& getNullPrimaryConfiguration() {
standardPcmAudioProfiles.end());
c.ports.push_back(primaryOutMix);
AudioPort compressedOffloadOutMix =
createPort(c.nextPortId++, "compressed offload",
1 << static_cast<int32_t>(AudioOutputFlags::DIRECT) |
1 << static_cast<int32_t>(AudioOutputFlags::COMPRESS_OFFLOAD) |
1 << static_cast<int32_t>(AudioOutputFlags::NON_BLOCKING),
false, createPortMixExt(1, 1));
compressedOffloadOutMix.profiles.push_back(
createProfile(::android::MEDIA_MIMETYPE_AUDIO_MPEG,
{AudioChannelLayout::LAYOUT_MONO, AudioChannelLayout::LAYOUT_STEREO},
{44100, 48000}));
c.ports.push_back(compressedOffloadOutMix);
AudioPort loopOutDevice = createPort(c.nextPortId++, "Loopback Out", 0, false,
createDeviceExt(AudioDeviceType::OUT_SUBMIX, 0));
loopOutDevice.profiles.push_back(
@@ -244,8 +273,10 @@ Configuration& getNullPrimaryConfiguration() {
c.ports.push_back(usbInDevice);
c.connectedProfiles[usbInDevice.id] = standardPcmAudioProfiles;
c.routes.push_back(createRoute({primaryOutMix.id}, nullOutDevice.id));
c.routes.push_back(createRoute({primaryOutMix.id}, usbOutDevice.id));
c.routes.push_back(
createRoute({primaryOutMix.id, compressedOffloadOutMix.id}, nullOutDevice.id));
c.routes.push_back(
createRoute({primaryOutMix.id, compressedOffloadOutMix.id}, usbOutDevice.id));
c.routes.push_back(createRoute({loopOutMix.id}, loopOutDevice.id));
c.routes.push_back(createRoute({zeroInDevice.id, usbInDevice.id}, primaryInMix.id));
c.routes.push_back(createRoute({loopInDevice.id}, loopInMix.id));

9
audio/aidl/default/Module.cpp
View File

@@ -405,6 +405,14 @@ ndk::ScopedAStatus Module::openOutputStream(int32_t in_portConfigId,
<< " does not correspond to an output mix port";
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
}
if (portConfigIt->flags.has_value() &&
((portConfigIt->flags.value().get<AudioIoFlags::Tag::output>() &
1 << static_cast<int32_t>(AudioOutputFlags::COMPRESS_OFFLOAD)) != 0) &&
!in_offloadInfo.has_value()) {
LOG(ERROR) << __func__ << ": port config id " << in_portConfigId
<< " has COMPRESS_OFFLOAD flag set, requires offload info";
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
}
if (mStreams.count(in_portConfigId) != 0) {
LOG(ERROR) << __func__ << ": port config id " << in_portConfigId
<< " already has a stream opened on it";
@@ -424,6 +432,7 @@ ndk::ScopedAStatus Module::openOutputStream(int32_t in_portConfigId,
}
ndk::ScopedAStatus Module::setAudioPatch(const AudioPatch& in_requested, AudioPatch* _aidl_return) {
LOG(DEBUG) << __func__ << ": requested patch " << in_requested.toString();
if (in_requested.sourcePortConfigIds.empty()) {
LOG(ERROR) << __func__ << ": requested patch has empty sources list";
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);

10
audio/aidl/default/main.cpp
View File

@@ -25,20 +25,22 @@ using aidl::android::hardware::audio::core::Config;
using aidl::android::hardware::audio::core::Module;
int main() {
// This is a debug implementation, always enable debug logging.
android::base::SetMinimumLogSeverity(::android::base::DEBUG);
ABinderProcess_setThreadPoolMaxThreadCount(16);
// make the default config service
// Make the default config service
auto config = ndk::SharedRefBase::make<Config>();
const std::string configName = std::string() + Config::descriptor + "/default";
binder_status_t status =
AServiceManager_addService(config->asBinder().get(), configName.c_str());
CHECK(status == STATUS_OK);
CHECK_EQ(STATUS_OK, status);
// make the default module
// Make the default module
auto moduleDefault = ndk::SharedRefBase::make<Module>();
const std::string moduleDefaultName = std::string() + Module::descriptor + "/default";
status = AServiceManager_addService(moduleDefault->asBinder().get(), moduleDefaultName.c_str());
CHECK(status == STATUS_OK);
CHECK_EQ(STATUS_OK, status);
ABinderProcess_joinThreadPool();
return EXIT_FAILURE; // should not reach

8
audio/aidl/vts/Android.bp
View File

@@ -18,12 +18,12 @@ cc_test {
"VtsHalAudioCoreTargetTest.cpp",
],
shared_libs: [
"libbinder",
"libbinder_ndk",
],
static_libs: [
"android.hardware.audio.common-V1-cpp",
"android.hardware.audio.core-V1-cpp",
"android.media.audio.common.types-V1-cpp",
"android.hardware.audio.common-V1-ndk",
"android.hardware.audio.core-V1-ndk",
"android.media.audio.common.types-V1-ndk",
],
test_suites: [
"general-tests",

145
audio/aidl/vts/ModuleConfig.cpp
View File

@@ -15,25 +15,50 @@
*/
#include <algorithm>
#include <chrono>
#include <android/media/audio/common/AudioIoFlags.h>
#include <android/media/audio/common/AudioOutputFlags.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 android::hardware::audio::core::IModule;
using android::media::audio::common::AudioChannelLayout;
using android::media::audio::common::AudioFormatDescription;
using android::media::audio::common::AudioFormatType;
using android::media::audio::common::AudioIoFlags;
using android::media::audio::common::AudioOutputFlags;
using android::media::audio::common::AudioPort;
using android::media::audio::common::AudioPortConfig;
using android::media::audio::common::AudioPortExt;
using android::media::audio::common::AudioProfile;
using android::media::audio::common::Int;
using aidl::android::hardware::audio::core::IModule;
using aidl::android::media::audio::common::AudioChannelLayout;
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::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 &&
(portConfig.flags.value().get<AudioIoFlags::Tag::output>() &
1 << static_cast<int>(AudioOutputFlags::COMPRESS_OFFLOAD)) != 0) {
AudioOffloadInfo offloadInfo;
offloadInfo.base.sampleRate = portConfig.sampleRate.value().value;
offloadInfo.base.channelMask = portConfig.channelMask.value();
offloadInfo.base.format = portConfig.format.value();
offloadInfo.bitRatePerSecond = 256; // Arbitrary value.
offloadInfo.durationUs = std::chrono::microseconds(1min).count(); // Arbitrary value.
offloadInfo.usage = AudioUsage::MEDIA;
offloadInfo.encapsulationMode = AudioEncapsulationMode::NONE;
return offloadInfo;
}
return {};
}
template <typename T>
auto findById(const std::vector<T>& v, int32_t id) {
@@ -251,23 +276,23 @@ std::string ModuleConfig::toString() const {
std::string result;
result.append("Ports: ");
result.append(android::internal::ToString(mPorts));
result.append("Initial configs: ");
result.append("\nInitial configs: ");
result.append(android::internal::ToString(mInitialConfigs));
result.append("Attached sink device ports: ");
result.append("\nAttached sink device ports: ");
result.append(android::internal::ToString(mAttachedSinkDevicePorts));
result.append("Attached source device ports: ");
result.append("\nAttached source device ports: ");
result.append(android::internal::ToString(mAttachedSourceDevicePorts));
result.append("External device ports: ");
result.append("\nExternal device ports: ");
result.append(android::internal::ToString(mExternalDevicePorts));
result.append("Routes: ");
result.append("\nRoutes: ");
result.append(android::internal::ToString(mRoutes));
return result;
}
static std::vector<AudioPortConfig> combineAudioConfigs(const AudioPort& port,
const AudioProfile& profile) {
std::vector<AudioPortConfig> configs;
configs.reserve(profile.channelMasks.size() * profile.sampleRates.size());
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{};
@@ -277,66 +302,32 @@ static std::vector<AudioPortConfig> combineAudioConfigs(const AudioPort& port,
config.sampleRate = sr;
config.channelMask = channelMask;
config.format = profile.format;
config.flags = port.flags;
config.ext = port.ext;
configs.push_back(config);
result->push_back(std::move(config));
}
}
return configs;
return newConfigCount;
}
std::vector<AudioPortConfig> ModuleConfig::generateInputAudioMixPortConfigs(
const std::vector<AudioPort>& ports, bool singleProfile) const {
static bool isDynamicProfile(const AudioProfile& profile) {
return (profile.format.type == AudioFormatType::DEFAULT && profile.format.encoding.empty()) ||
profile.sampleRates.empty() || profile.channelMasks.empty();
}
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 (getAttachedSourceDevicesPortsForMixPort(mixPort).empty()) {
continue; // no attached devices
if (getAttachedDevicesPortsForMixPort(isInput, mixPort).empty()) {
continue;
}
for (const auto& profile : mixPort.profiles) {
if (profile.format.type == AudioFormatType::DEFAULT || profile.sampleRates.empty() ||
profile.channelMasks.empty()) {
continue; // dynamic profile
}
auto configs = combineAudioConfigs(mixPort, profile);
for (auto& config : configs) {
config.flags = mixPort.flags;
result.push_back(config);
if (singleProfile) return result;
}
}
}
return result;
}
static std::tuple<AudioIoFlags, bool> generateOutFlags(const AudioPort& mixPort) {
static const AudioIoFlags offloadFlags = AudioIoFlags::make<AudioIoFlags::Tag::output>(
(1 << static_cast<int>(AudioOutputFlags::COMPRESS_OFFLOAD)) |
(1 << static_cast<int>(AudioOutputFlags::DIRECT)));
const bool isOffload = (mixPort.flags.get<AudioIoFlags::Tag::output>() &
(1 << static_cast<int>(AudioOutputFlags::COMPRESS_OFFLOAD))) != 0;
return {isOffload ? offloadFlags : mixPort.flags, isOffload};
}
std::vector<AudioPortConfig> ModuleConfig::generateOutputAudioMixPortConfigs(
const std::vector<AudioPort>& ports, bool singleProfile) const {
std::vector<AudioPortConfig> result;
for (const auto& mixPort : ports) {
if (getAttachedSinkDevicesPortsForMixPort(mixPort).empty()) {
continue; // no attached devices
}
auto [flags, isOffload] = generateOutFlags(mixPort);
(void)isOffload;
for (const auto& profile : mixPort.profiles) {
if (profile.format.type == AudioFormatType::DEFAULT) continue;
auto configs = combineAudioConfigs(mixPort, profile);
for (auto& config : configs) {
// Some combinations of flags declared in the config file require special
// treatment.
// if (isOffload) {
// config.offloadInfo.info(generateOffloadInfo(config.base));
// }
config.flags = flags;
result.push_back(config);
if (singleProfile) return result;
if (isDynamicProfile(profile)) continue;
combineAudioConfigs(mixPort, profile, &result);
if (singleProfile && !result.empty()) {
result.resize(1);
return result;
}
}
}
@@ -349,9 +340,11 @@ std::vector<AudioPortConfig> ModuleConfig::generateAudioDevicePortConfigs(
for (const auto& devicePort : ports) {
const size_t resultSizeBefore = result.size();
for (const auto& profile : devicePort.profiles) {
auto configs = combineAudioConfigs(devicePort, profile);
result.insert(result.end(), configs.begin(), configs.end());
if (singleProfile && !result.empty()) return result;
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),

121
audio/aidl/vts/ModuleConfig.h
View File

@@ -21,95 +21,94 @@
#include <utility>
#include <vector>
#include <android/hardware/audio/core/AudioRoute.h>
#include <android/hardware/audio/core/IModule.h>
#include <android/media/audio/common/AudioPort.h>
#include <binder/Status.h>
#include <aidl/android/hardware/audio/core/AudioRoute.h>
#include <aidl/android/hardware/audio/core/IModule.h>
#include <aidl/android/media/audio/common/AudioOffloadInfo.h>
#include <aidl/android/media/audio/common/AudioPort.h>
class ModuleConfig {
public:
using SrcSinkPair = std::pair<android::media::audio::common::AudioPortConfig,
android::media::audio::common::AudioPortConfig>;
using SrcSinkPair = std::pair<aidl::android::media::audio::common::AudioPortConfig,
aidl::android::media::audio::common::AudioPortConfig>;
using SrcSinkGroup =
std::pair<android::hardware::audio::core::AudioRoute, std::vector<SrcSinkPair>>;
std::pair<aidl::android::hardware::audio::core::AudioRoute, std::vector<SrcSinkPair>>;
explicit ModuleConfig(android::hardware::audio::core::IModule* module);
android::binder::Status getStatus() const { return mStatus; }
std::string getError() const { return mStatus.toString8().c_str(); }
static std::optional<aidl::android::media::audio::common::AudioOffloadInfo>
generateOffloadInfoIfNeeded(
const aidl::android::media::audio::common::AudioPortConfig& portConfig);
std::vector<android::media::audio::common::AudioPort> getAttachedDevicePorts() const;
std::vector<android::media::audio::common::AudioPort> getExternalDevicePorts() const;
std::vector<android::media::audio::common::AudioPort> getInputMixPorts() const;
std::vector<android::media::audio::common::AudioPort> getOutputMixPorts() const;
std::vector<android::media::audio::common::AudioPort> getMixPorts(bool isInput) const {
explicit ModuleConfig(aidl::android::hardware::audio::core::IModule* module);
const ndk::ScopedAStatus& getStatus() const { return mStatus; }
std::string getError() const { return mStatus.getMessage(); }
std::vector<aidl::android::media::audio::common::AudioPort> getAttachedDevicePorts() const;
std::vector<aidl::android::media::audio::common::AudioPort> getExternalDevicePorts() const;
std::vector<aidl::android::media::audio::common::AudioPort> getInputMixPorts() const;
std::vector<aidl::android::media::audio::common::AudioPort> getOutputMixPorts() const;
std::vector<aidl::android::media::audio::common::AudioPort> getMixPorts(bool isInput) const {
return isInput ? getInputMixPorts() : getOutputMixPorts();
}
std::vector<android::media::audio::common::AudioPort> getAttachedDevicesPortsForMixPort(
bool isInput, const android::media::audio::common::AudioPort& mixPort) const {
std::vector<aidl::android::media::audio::common::AudioPort> getAttachedDevicesPortsForMixPort(
bool isInput, const aidl::android::media::audio::common::AudioPort& mixPort) const {
return isInput ? getAttachedSourceDevicesPortsForMixPort(mixPort)
: getAttachedSinkDevicesPortsForMixPort(mixPort);
}
std::vector<android::media::audio::common::AudioPort> getAttachedSinkDevicesPortsForMixPort(
const android::media::audio::common::AudioPort& mixPort) const;
std::vector<android::media::audio::common::AudioPort> getAttachedSourceDevicesPortsForMixPort(
const android::media::audio::common::AudioPort& mixPort) const;
std::optional<android::media::audio::common::AudioPort> getSourceMixPortForAttachedDevice()
const;
std::vector<aidl::android::media::audio::common::AudioPort>
getAttachedSinkDevicesPortsForMixPort(
const aidl::android::media::audio::common::AudioPort& mixPort) const;
std::vector<aidl::android::media::audio::common::AudioPort>
getAttachedSourceDevicesPortsForMixPort(
const aidl::android::media::audio::common::AudioPort& mixPort) const;
std::optional<aidl::android::media::audio::common::AudioPort>
getSourceMixPortForAttachedDevice() const;
std::optional<SrcSinkPair> getNonRoutableSrcSinkPair(bool isInput) const;
std::optional<SrcSinkPair> getRoutableSrcSinkPair(bool isInput) const;
std::vector<SrcSinkGroup> getRoutableSrcSinkGroups(bool isInput) const;
std::vector<android::media::audio::common::AudioPortConfig>
std::vector<aidl::android::media::audio::common::AudioPortConfig>
getPortConfigsForAttachedDevicePorts() const {
return generateAudioDevicePortConfigs(getAttachedDevicePorts(), false);
}
std::vector<android::media::audio::common::AudioPortConfig> getPortConfigsForMixPorts() const {
auto inputs = generateInputAudioMixPortConfigs(getInputMixPorts(), false);
auto outputs = generateOutputAudioMixPortConfigs(getOutputMixPorts(), false);
std::vector<aidl::android::media::audio::common::AudioPortConfig> getPortConfigsForMixPorts()
const {
auto inputs = generateAudioMixPortConfigs(getInputMixPorts(), true, false);
auto outputs = generateAudioMixPortConfigs(getOutputMixPorts(), false, false);
inputs.insert(inputs.end(), outputs.begin(), outputs.end());
return inputs;
}
std::vector<android::media::audio::common::AudioPortConfig> getPortConfigsForMixPorts(
std::vector<aidl::android::media::audio::common::AudioPortConfig> getPortConfigsForMixPorts(
bool isInput) const {
return isInput ? generateInputAudioMixPortConfigs(getInputMixPorts(), false)
: generateOutputAudioMixPortConfigs(getOutputMixPorts(), false);
return generateAudioMixPortConfigs(getMixPorts(isInput), isInput, false);
}
std::vector<android::media::audio::common::AudioPortConfig> getPortConfigsForMixPorts(
bool isInput, const android::media::audio::common::AudioPort& port) const {
return isInput ? generateInputAudioMixPortConfigs({port}, false)
: generateOutputAudioMixPortConfigs({port}, false);
std::vector<aidl::android::media::audio::common::AudioPortConfig> getPortConfigsForMixPorts(
bool isInput, const aidl::android::media::audio::common::AudioPort& port) const {
return generateAudioMixPortConfigs({port}, isInput, false);
}
std::optional<android::media::audio::common::AudioPortConfig> getSingleConfigForMixPort(
std::optional<aidl::android::media::audio::common::AudioPortConfig> getSingleConfigForMixPort(
bool isInput) const {
const auto config = isInput ? generateInputAudioMixPortConfigs(getInputMixPorts(), true)
: generateOutputAudioMixPortConfigs(getOutputMixPorts(), true);
// TODO: Avoid returning configs for offload since they require an extra
// argument to openOutputStream.
const auto config = generateAudioMixPortConfigs(getMixPorts(isInput), isInput, true);
if (!config.empty()) {
return *config.begin();
} else {
return {};
}
return {};
}
std::optional<android::media::audio::common::AudioPortConfig> getSingleConfigForMixPort(
bool isInput, const android::media::audio::common::AudioPort& port) const {
const auto config = isInput ? generateInputAudioMixPortConfigs({port}, true)
: generateOutputAudioMixPortConfigs({port}, true);
std::optional<aidl::android::media::audio::common::AudioPortConfig> getSingleConfigForMixPort(
bool isInput, const aidl::android::media::audio::common::AudioPort& port) const {
const auto config = generateAudioMixPortConfigs({port}, isInput, true);
if (!config.empty()) {
return *config.begin();
} else {
return {};
}
return {};
}
std::vector<android::media::audio::common::AudioPortConfig> getPortConfigsForDevicePort(
const android::media::audio::common::AudioPort& port) const {
std::vector<aidl::android::media::audio::common::AudioPortConfig> getPortConfigsForDevicePort(
const aidl::android::media::audio::common::AudioPort& port) const {
return generateAudioDevicePortConfigs({port}, false);
}
android::media::audio::common::AudioPortConfig getSingleConfigForDevicePort(
const android::media::audio::common::AudioPort& port) const {
aidl::android::media::audio::common::AudioPortConfig getSingleConfigForDevicePort(
const aidl::android::media::audio::common::AudioPort& port) const {
const auto config = generateAudioDevicePortConfigs({port}, true);
return *config.begin();
}
@@ -117,26 +116,24 @@ class ModuleConfig {
std::string toString() const;
private:
std::vector<android::media::audio::common::AudioPortConfig> generateInputAudioMixPortConfigs(
const std::vector<android::media::audio::common::AudioPort>& ports,
bool singleProfile) const;
std::vector<android::media::audio::common::AudioPortConfig> generateOutputAudioMixPortConfigs(
const std::vector<android::media::audio::common::AudioPort>& ports,
std::vector<aidl::android::media::audio::common::AudioPortConfig> generateAudioMixPortConfigs(
const std::vector<aidl::android::media::audio::common::AudioPort>& ports, bool isInput,
bool singleProfile) const;
// Unlike MixPorts, the generator for DevicePorts always returns a non-empty
// vector for a non-empty input port list. If there are no profiles in the
// port, its initial configs are looked up, if there are none,
// then an empty config is used, assuming further negotiation via setAudioPortConfig.
std::vector<android::media::audio::common::AudioPortConfig> generateAudioDevicePortConfigs(
const std::vector<android::media::audio::common::AudioPort>& ports,
std::vector<aidl::android::media::audio::common::AudioPortConfig>
generateAudioDevicePortConfigs(
const std::vector<aidl::android::media::audio::common::AudioPort>& ports,
bool singleProfile) const;
android::binder::Status mStatus = android::binder::Status::ok();
std::vector<android::media::audio::common::AudioPort> mPorts;
std::vector<android::media::audio::common::AudioPortConfig> mInitialConfigs;
ndk::ScopedAStatus mStatus = ndk::ScopedAStatus::ok();
std::vector<aidl::android::media::audio::common::AudioPort> mPorts;
std::vector<aidl::android::media::audio::common::AudioPortConfig> mInitialConfigs;
std::set<int32_t> mAttachedSinkDevicePorts;
std::set<int32_t> mAttachedSourceDevicePorts;
std::set<int32_t> mExternalDevicePorts;
std::vector<android::hardware::audio::core::AudioRoute> mRoutes;
std::vector<aidl::android::hardware::audio::core::AudioRoute> mRoutes;
};

499
audio/aidl/vts/VtsHalAudioCoreTargetTest.cpp
View File

File diff suppressed because it is too large Load Diff