APM: update logic of populating profiles for dynamic mix port.
For AIDL HAL, use getAudioPort API to query the profiles for the dynamic
mix ports.
For HIDL HAL, if the HAL supports getAudioPort API, add the profiles of
the device port that contain attributes also reported by getParameters
API. The attributes reported by getParameters API but not in device port
will also be added to mix port.
The reason of using getAudioPort API instead of getParameters is that
getAudioPort API can return well structed audio profiles, which show the
correct relationship between audio format and sample rates, channel
masks.
Test: repo steps from the bug
Test: atest audiofoundation_containers_test
Test: atest audiopolicy_tests
Bug: 284033428
Change-Id: I6d3faf49470514c05fe57be755bb868d74d74dbb
diff --git a/media/libaudiohal/impl/DeviceHalAidl.cpp b/media/libaudiohal/impl/DeviceHalAidl.cpp
index 72fe32b..b7af103 100644
--- a/media/libaudiohal/impl/DeviceHalAidl.cpp
+++ b/media/libaudiohal/impl/DeviceHalAidl.cpp
@@ -836,6 +836,33 @@
return OK;
}
+status_t DeviceHalAidl::getAudioMixPort(const struct audio_port_v7 *devicePort,
+ struct audio_port_v7 *mixPort) {
+ ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ if (devicePort->type != AUDIO_PORT_TYPE_DEVICE) {
+ return BAD_VALUE;
+ }
+ if (mixPort->type != AUDIO_PORT_TYPE_MIX) {
+ return BAD_VALUE;
+ }
+ const int32_t aidlHandle = VALUE_OR_RETURN_STATUS(
+ ::aidl::android::legacy2aidl_audio_io_handle_t_int32_t(mixPort->ext.mix.handle));
+ auto it = findPortConfig(std::nullopt /*config*/, std::nullopt/*flags*/, aidlHandle);
+ if (it == mPortConfigs.end()) {
+ ALOGE("%s, cannot find mix port config for handle=%u", __func__, aidlHandle);
+ return BAD_VALUE;
+ }
+ AudioPort port;
+ if (status_t status = getAudioPort(it->second.portId, &port); status != NO_ERROR) {
+ return status;
+ }
+ const bool isInput = VALUE_OR_RETURN_STATUS(::aidl::android::portDirection(
+ mixPort->role, mixPort->type)) == ::aidl::android::AudioPortDirection::INPUT;
+ *mixPort = VALUE_OR_RETURN_STATUS(::aidl::android::aidl2legacy_AudioPort_audio_port_v7(
+ port, isInput));
+ return NO_ERROR;
+}
+
status_t DeviceHalAidl::setAudioPortConfig(const struct audio_port_config* config) {
ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
TIME_CHECK();
@@ -1702,7 +1729,9 @@
}
DeviceHalAidl::PortConfigs::iterator DeviceHalAidl::findPortConfig(
- const AudioConfig& config, const std::optional<AudioIoFlags>& flags, int32_t ioHandle) {
+ const std::optional<AudioConfig>& config,
+ const std::optional<AudioIoFlags>& flags,
+ int32_t ioHandle) {
using Tag = AudioPortExt::Tag;
return std::find_if(mPortConfigs.begin(), mPortConfigs.end(),
[&](const auto& pair) {
@@ -1713,7 +1742,8 @@
"%s: stored mix port config is not fully specified: %s",
__func__, p.toString().c_str());
return p.ext.getTag() == Tag::mix &&
- isConfigEqualToPortConfig(config, p) &&
+ (!config.has_value() ||
+ isConfigEqualToPortConfig(config.value(), p)) &&
(!flags.has_value() || p.flags.value() == flags.value()) &&
p.ext.template get<Tag::mix>().handle == ioHandle; });
}
@@ -1840,6 +1870,25 @@
return OK;
}
+status_t DeviceHalAidl::getAudioPort(int32_t portId, AudioPort* port) {
+ ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ TIME_CHECK();
+ if (!mModule) {
+ return NO_INIT;
+ }
+ const status_t status = statusTFromBinderStatus(mModule->getAudioPort(portId, port));
+ if (status == OK) {
+ auto portIt = mPorts.find(portId);
+ if (portIt != mPorts.end()) {
+ portIt->second = *port;
+ } else {
+ ALOGW("%s, port(%d) returned successfully from the HAL but not it is not cached",
+ __func__, portId);
+ }
+ }
+ return status;
+}
+
void DeviceHalAidl::clearCallbacks(void* cookie) {
std::lock_guard l(mLock);
mCallbacks.erase(cookie);
diff --git a/media/libaudiohal/impl/DeviceHalAidl.h b/media/libaudiohal/impl/DeviceHalAidl.h
index 6f45f1f..e1fe4d1 100644
--- a/media/libaudiohal/impl/DeviceHalAidl.h
+++ b/media/libaudiohal/impl/DeviceHalAidl.h
@@ -176,6 +176,9 @@
status_t setSimulateDeviceConnections(bool enabled) override;
+ status_t getAudioMixPort(const struct audio_port_v7* devicePort,
+ struct audio_port_v7* mixPort) override;
+
status_t dump(int __unused, const Vector<String16>& __unused) override;
private:
@@ -260,7 +263,7 @@
PortConfigs::iterator findPortConfig(
const ::aidl::android::media::audio::common::AudioDevice& device);
PortConfigs::iterator findPortConfig(
- const ::aidl::android::media::audio::common::AudioConfig& config,
+ const std::optional<::aidl::android::media::audio::common::AudioConfig>& config,
const std::optional<::aidl::android::media::audio::common::AudioIoFlags>& flags,
int32_t ioHandle);
bool isPortHeldByAStream(int32_t portId);
@@ -280,6 +283,7 @@
void resetUnusedPatchesAndPortConfigs();
void resetUnusedPortConfigs();
status_t updateRoutes();
+ status_t getAudioPort(int32_t portId, ::aidl::android::media::audio::common::AudioPort* port);
// CallbackBroker implementation
void clearCallbacks(void* cookie) override;
diff --git a/media/libaudiohal/impl/DeviceHalHidl.cpp b/media/libaudiohal/impl/DeviceHalHidl.cpp
index 0d71fd3..e8e1f46 100644
--- a/media/libaudiohal/impl/DeviceHalHidl.cpp
+++ b/media/libaudiohal/impl/DeviceHalHidl.cpp
@@ -304,7 +304,12 @@
}
HidlUtils::audioConfigToHal(suggestedConfig, config);
});
- return processReturn("openOutputStream", ret, retval);
+ const status_t status = processReturn("openOutputStream", ret, retval);
+ cleanupStreams();
+ if (status == NO_ERROR) {
+ mStreams.insert({handle, *outStream});
+ }
+ return status;
}
status_t DeviceHalHidl::openInputStream(
@@ -377,7 +382,12 @@
}
HidlUtils::audioConfigToHal(suggestedConfig, config);
});
- return processReturn("openInputStream", ret, retval);
+ const status_t status = processReturn("openInputStream", ret, retval);
+ cleanupStreams();
+ if (status == NO_ERROR) {
+ mStreams.insert({handle, *inStream});
+ }
+ return status;
}
status_t DeviceHalHidl::supportsAudioPatches(bool *supportsPatches) {
@@ -706,4 +716,126 @@
*supports = trueOrFalse == AudioParameter::valueTrue;
return NO_ERROR;
}
+
+namespace {
+
+status_t getParametersFromStream(
+ sp<StreamHalInterface> stream,
+ const char* parameters,
+ const char* extraParameters,
+ String8* reply) {
+ String8 request(parameters);
+ if (extraParameters != nullptr) {
+ request.append(";");
+ request.append(extraParameters);
+ }
+ status_t status = stream->getParameters(request, reply);
+ if (status != NO_ERROR) {
+ ALOGW("%s, failed to query %s, status=%d", __func__, parameters, status);
+ return status;
+ }
+ AudioParameter repliedParameters(*reply);
+ status = repliedParameters.get(String8(parameters), *reply);
+ if (status != NO_ERROR) {
+ ALOGW("%s: failed to retrieve %s, bailing out", __func__, parameters);
+ }
+ return status;
+}
+
+} // namespace
+
+status_t DeviceHalHidl::getAudioMixPort(const struct audio_port_v7 *devicePort,
+ struct audio_port_v7 *mixPort) {
+ // For HIDL HAL, querying mix port information is not supported. If the HAL supports
+ // `getAudioPort` API to query the device port attributes, use the structured audio profiles
+ // that have the same attributes reported by the `getParameters` API. Otherwise, only use
+ // the attributes reported by `getParameters` API.
+ struct audio_port_v7 temp = *devicePort;
+ AudioProfileAttributesMultimap attrsFromDevice;
+ status_t status = getAudioPort(&temp);
+ if (status == NO_ERROR) {
+ attrsFromDevice = createAudioProfilesAttrMap(temp.audio_profiles, 0 /*first*/,
+ temp.num_audio_profiles);
+ }
+ auto streamIt = mStreams.find(mixPort->ext.mix.handle);
+ if (streamIt == mStreams.end()) {
+ return BAD_VALUE;
+ }
+ auto stream = streamIt->second.promote();
+ if (stream == nullptr) {
+ return BAD_VALUE;
+ }
+
+ String8 formatsStr;
+ status = getParametersFromStream(
+ stream, AudioParameter::keyStreamSupportedFormats, nullptr /*extraParameters*/,
+ &formatsStr);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ FormatVector formats = formatsFromString(formatsStr.c_str());
+
+ mixPort->num_audio_profiles = 0;
+ for (audio_format_t format : formats) {
+ if (mixPort->num_audio_profiles >= AUDIO_PORT_MAX_AUDIO_PROFILES) {
+ ALOGW("%s, too many audio profiles", __func__);
+ break;
+ }
+ AudioParameter formatParameter;
+ formatParameter.addInt(String8(AudioParameter::keyFormat), format);
+
+ String8 samplingRatesStr;
+ status = getParametersFromStream(
+ stream, AudioParameter::keyStreamSupportedSamplingRates,
+ formatParameter.toString(), &samplingRatesStr);
+ if (status != NO_ERROR) {
+ // Failed to query supported sample rate for current format, may succeed with
+ // other formats.
+ ALOGW("Skip adding format=%#x, status=%d", format, status);
+ continue;
+ }
+ SampleRateSet sampleRatesFromStream = samplingRatesFromString(samplingRatesStr.c_str());
+ if (sampleRatesFromStream.empty()) {
+ ALOGW("Skip adding format=%#x as the returned sampling rates are empty", format);
+ continue;
+ }
+ String8 channelMasksStr;
+ status = getParametersFromStream(
+ stream, AudioParameter::keyStreamSupportedChannels,
+ formatParameter.toString(), &channelMasksStr);
+ if (status != NO_ERROR) {
+ // Failed to query supported channel masks for current format, may succeed with
+ // other formats.
+ ALOGW("Skip adding format=%#x, status=%d", format, status);
+ continue;
+ }
+ ChannelMaskSet channelMasksFromStream = channelMasksFromString(channelMasksStr.c_str());
+ if (channelMasksFromStream.empty()) {
+ ALOGW("Skip adding format=%#x as the returned channel masks are empty", format);
+ continue;
+ }
+
+ // For an audio format, all audio profiles from the device port with the same format will
+ // be added to mix port after filtering sample rates, channel masks according to the reply
+ // of getParameters API. If there is any sample rate or channel mask reported by
+ // getParameters API but not reported by the device, additional audio profiles will be
+ // added.
+ populateAudioProfiles(attrsFromDevice, format, channelMasksFromStream,
+ sampleRatesFromStream, mixPort->audio_profiles,
+ &mixPort->num_audio_profiles);
+ }
+
+ return NO_ERROR;
+}
+
+void DeviceHalHidl::cleanupStreams() {
+ for (auto it = mStreams.begin(); it != mStreams.end();) {
+ if (it->second.promote() == nullptr) {
+ it = mStreams.erase(it);
+ } else {
+ ++it;
+ }
+ }
+}
+
} // namespace android
diff --git a/media/libaudiohal/impl/DeviceHalHidl.h b/media/libaudiohal/impl/DeviceHalHidl.h
index 1a1db33..7a712df 100644
--- a/media/libaudiohal/impl/DeviceHalHidl.h
+++ b/media/libaudiohal/impl/DeviceHalHidl.h
@@ -21,6 +21,7 @@
#include PATH(android/hardware/audio/FILE_VERSION/IPrimaryDevice.h)
#include <media/audiohal/DeviceHalInterface.h>
#include <media/audiohal/EffectHalInterface.h>
+#include <media/audiohal/StreamHalInterface.h>
#include "CoreConversionHelperHidl.h"
@@ -145,6 +146,9 @@
status_t prepareToDisconnectExternalDevice(const struct audio_port_v7* port) override;
+ status_t getAudioMixPort(const struct audio_port_v7* devicePort,
+ struct audio_port_v7* mixPort) override;
+
private:
friend class DevicesFactoryHalHidl;
sp<::android::hardware::audio::CPP_VERSION::IDevice> mDevice;
@@ -154,12 +158,15 @@
class SoundDoseWrapper;
const std::unique_ptr<SoundDoseWrapper> mSoundDoseWrapper;
std::set<audio_port_handle_t> mDeviceDisconnectionNotified;
+ std::map<audio_io_handle_t, wp<StreamHalInterface>> mStreams;
// Can not be constructed directly by clients.
explicit DeviceHalHidl(const sp<::android::hardware::audio::CPP_VERSION::IDevice>& device);
explicit DeviceHalHidl(
const sp<::android::hardware::audio::CPP_VERSION::IPrimaryDevice>& device);
+ void cleanupStreams();
+
// The destructor automatically closes the device.
virtual ~DeviceHalHidl();