Merge changes from topic "cherrypicker-L48700030005938629:N88900030094104124" into main
* changes:
libaudiohal: Modify logging in DeviceHalAidl/Hal2AidlMapper/StreamHalAidl
Send the Audio Usage down from AudioPolicyManager
Add SourceMetadata as a new parameter in openOutputStream
diff --git a/media/audioaidlconversion/AidlConversionNdk.cpp b/media/audioaidlconversion/AidlConversionNdk.cpp
index 9b14a5e..7ab616a 100644
--- a/media/audioaidlconversion/AidlConversionNdk.cpp
+++ b/media/audioaidlconversion/AidlConversionNdk.cpp
@@ -35,6 +35,7 @@
using hardware::audio::common::PlaybackTrackMetadata;
using hardware::audio::common::RecordTrackMetadata;
+using hardware::audio::common::SourceMetadata;
using ::android::BAD_VALUE;
using ::android::OK;
@@ -194,5 +195,16 @@
return aidl;
}
+// static
+ConversionResult<SourceMetadata>
+legacy2aidl_SourceMetadata(const std::vector<playback_track_metadata_v7_t>& legacy) {
+ SourceMetadata aidl;
+ aidl.tracks = VALUE_OR_RETURN(
+ convertContainer<std::vector<PlaybackTrackMetadata>>(
+ legacy,
+ legacy2aidl_playback_track_metadata_v7_PlaybackTrackMetadata));
+ return aidl;
+}
+
} // namespace android
} // aidl
diff --git a/media/audioaidlconversion/include/media/AidlConversionNdk.h b/media/audioaidlconversion/include/media/AidlConversionNdk.h
index 813a728..b5888b3 100644
--- a/media/audioaidlconversion/include/media/AidlConversionNdk.h
+++ b/media/audioaidlconversion/include/media/AidlConversionNdk.h
@@ -28,6 +28,7 @@
#include <aidl/android/hardware/audio/common/PlaybackTrackMetadata.h>
#include <aidl/android/hardware/audio/common/RecordTrackMetadata.h>
+#include <aidl/android/hardware/audio/common/SourceMetadata.h>
#include <aidl/android/media/audio/common/AudioConfig.h>
#include <media/AidlConversionUtil.h>
@@ -56,5 +57,8 @@
ConversionResult<hardware::audio::common::RecordTrackMetadata>
legacy2aidl_record_track_metadata_v7_RecordTrackMetadata(const record_track_metadata_v7& legacy);
+ConversionResult<hardware::audio::common::SourceMetadata>
+legacy2aidl_SourceMetadata(const std::vector<playback_track_metadata_v7_t>& legacy);
+
} // namespace android
} // namespace aidl
diff --git a/media/libaudioclient/aidl/android/media/OpenOutputRequest.aidl b/media/libaudioclient/aidl/android/media/OpenOutputRequest.aidl
index ddda8bb..73610a8 100644
--- a/media/libaudioclient/aidl/android/media/OpenOutputRequest.aidl
+++ b/media/libaudioclient/aidl/android/media/OpenOutputRequest.aidl
@@ -19,6 +19,7 @@
import android.media.AudioPortFw;
import android.media.audio.common.AudioConfig;
import android.media.audio.common.AudioConfigBase;
+import android.media.audio.common.AudioAttributes;
/**
* {@hide}
@@ -32,4 +33,5 @@
AudioPortFw device;
/** Bitmask, indexed by AudioOutputFlag. */
int flags;
+ AudioAttributes attributes;
}
diff --git a/media/libaudiohal/impl/AidlUtils.h b/media/libaudiohal/impl/AidlUtils.h
index 97a5bba..fcd7a01 100644
--- a/media/libaudiohal/impl/AidlUtils.h
+++ b/media/libaudiohal/impl/AidlUtils.h
@@ -25,6 +25,32 @@
namespace android {
+/*
+ * Helper macro to add instance name, function name in logs
+ * classes should provide getInstanceName and getClassName API to use these macros.
+ * print function names along with instance name.
+ *
+ * Usage:
+ * AUGMENT_LOG(I, "hello!");
+ * AUGMENT_LOG(W, "value: %d", value);
+ *
+ * AUGMENT_LOG_IF(D, value < 0, "negative");
+ * AUGMENT_LOG_IF(E, value < 0, "bad value: %d", value);
+ */
+
+#define AUGMENT_LOG(level, ...) \
+ ALOG##level("[%s] %s: " __android_second(0, __VA_ARGS__, ""), getInstanceName().c_str(), \
+ __func__ __android_rest(__VA_ARGS__))
+
+#define AUGMENT_LOG_IF(level, cond, ...) \
+ ALOG##level##_IF(cond, "[%s] %s: " __android_second(0, __VA_ARGS__, ""), \
+ getInstanceName().c_str(), __func__ __android_rest(__VA_ARGS__))
+// Used to register an entry into the function
+#define LOG_ENTRY() ALOGD("[%s] %s", getInstanceName().c_str(), __func__)
+
+// entry logging as verbose level
+#define LOG_ENTRY_V() ALOGV("[%s] %s", getInstanceName().c_str(), __func__)
+
class HalDeathHandler {
public:
static HalDeathHandler& getInstance();
diff --git a/media/libaudiohal/impl/ConversionHelperAidl.h b/media/libaudiohal/impl/ConversionHelperAidl.h
index 0fadd9c..2d19bee 100644
--- a/media/libaudiohal/impl/ConversionHelperAidl.h
+++ b/media/libaudiohal/impl/ConversionHelperAidl.h
@@ -49,13 +49,15 @@
class ConversionHelperAidl {
protected:
- ConversionHelperAidl(std::string_view className) : mClassName(className) {}
+ ConversionHelperAidl(std::string_view className, std::string_view instanceName)
+ : mClassName(className), mInstanceName(instanceName) {}
- const std::string& getClassName() const {
- return mClassName;
- }
+ const std::string& getClassName() const { return mClassName; }
+
+ const std::string& getInstanceName() const { return mInstanceName; }
const std::string mClassName;
+ const std::string mInstanceName;
};
// 'action' must accept a value of type 'T' and return 'status_t'.
diff --git a/media/libaudiohal/impl/DeviceHalAidl.cpp b/media/libaudiohal/impl/DeviceHalAidl.cpp
index 2f2f69f..f301a77 100644
--- a/media/libaudiohal/impl/DeviceHalAidl.cpp
+++ b/media/libaudiohal/impl/DeviceHalAidl.cpp
@@ -24,6 +24,7 @@
#include <aidl/android/hardware/audio/core/StreamDescriptor.h>
#include <error/expected_utils.h>
#include <media/AidlConversionCppNdk.h>
+#include <media/AidlConversionNdk.h>
#include <media/AidlConversionNdkCpp.h>
#include <media/AidlConversionUtil.h>
#include <mediautils/TimeCheck.h>
@@ -31,6 +32,7 @@
#include <Utils.h>
#include <utils/Log.h>
+#include "AidlUtils.h"
#include "DeviceHalAidl.h"
#include "EffectHalAidl.h"
#include "StreamHalAidl.h"
@@ -59,6 +61,8 @@
using aidl::android::hardware::audio::common::getFrameSizeInBytes;
using aidl::android::hardware::audio::common::isBitPositionFlagSet;
using aidl::android::hardware::audio::common::RecordTrackMetadata;
+using aidl::android::hardware::audio::common::PlaybackTrackMetadata;
+using aidl::android::hardware::audio::common::SourceMetadata;
using aidl::android::hardware::audio::core::sounddose::ISoundDose;
using aidl::android::hardware::audio::core::AudioPatch;
using aidl::android::hardware::audio::core::AudioRoute;
@@ -70,6 +74,18 @@
using aidl::android::hardware::audio::core::ModuleDebug;
using aidl::android::hardware::audio::core::VendorParameter;
+#define RETURN_IF_MODULE_NOT_INIT(retVal) \
+ if (mModule == nullptr) { \
+ AUGMENT_LOG(E, "module not initialized"); \
+ return retVal; \
+ }
+
+#define RETURN_IF_TELEPHONY_NOT_INIT(retVal) \
+ if (mTelephony == nullptr) { \
+ AUGMENT_LOG(E, "telephony not initialized"); \
+ return retVal; \
+ }
+
namespace android {
namespace {
@@ -102,15 +118,16 @@
DeviceHalAidl::DeviceHalAidl(const std::string& instance, const std::shared_ptr<IModule>& module,
const std::shared_ptr<IHalAdapterVendorExtension>& vext)
- : ConversionHelperAidl("DeviceHalAidl"),
- mInstance(instance), mModule(module), mVendorExt(vext),
- mTelephony(retrieveSubInterface<ITelephony>(module, &IModule::getTelephony)),
- mBluetooth(retrieveSubInterface<IBluetooth>(module, &IModule::getBluetooth)),
- mBluetoothA2dp(retrieveSubInterface<IBluetoothA2dp>(module, &IModule::getBluetoothA2dp)),
- mBluetoothLe(retrieveSubInterface<IBluetoothLe>(module, &IModule::getBluetoothLe)),
- mSoundDose(retrieveSubInterface<ISoundDose>(module, &IModule::getSoundDose)),
- mMapper(instance, module), mMapperAccessor(mMapper, mLock) {
-}
+ : ConversionHelperAidl("DeviceHalAidl", instance),
+ mModule(module),
+ mVendorExt(vext),
+ mTelephony(retrieveSubInterface<ITelephony>(module, &IModule::getTelephony)),
+ mBluetooth(retrieveSubInterface<IBluetooth>(module, &IModule::getBluetooth)),
+ mBluetoothA2dp(retrieveSubInterface<IBluetoothA2dp>(module, &IModule::getBluetoothA2dp)),
+ mBluetoothLe(retrieveSubInterface<IBluetoothLe>(module, &IModule::getBluetoothLe)),
+ mSoundDose(retrieveSubInterface<ISoundDose>(module, &IModule::getSoundDose)),
+ mMapper(instance, module),
+ mMapperAccessor(mMapper, mLock) {}
status_t DeviceHalAidl::getAudioPorts(std::vector<media::audio::common::AudioPort> *ports) {
std::lock_guard l(mLock);
@@ -123,11 +140,13 @@
}
status_t DeviceHalAidl::getSupportedModes(std::vector<media::audio::common::AudioMode> *modes) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
- if (mTelephony == nullptr) return INVALID_OPERATION;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
+ RETURN_IF_TELEPHONY_NOT_INIT(INVALID_OPERATION);
+
if (modes == nullptr) {
+ AUGMENT_LOG(E, "uninitialized modes");
return BAD_VALUE;
}
std::vector<AudioMode> aidlModes;
@@ -145,48 +164,53 @@
}
status_t DeviceHalAidl::initCheck() {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
std::lock_guard l(mLock);
return mMapper.initialize();
}
status_t DeviceHalAidl::setVoiceVolume(float volume) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ AUGMENT_LOG(D, "volume %f", volume);
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
- if (mTelephony == nullptr) return INVALID_OPERATION;
- ITelephony::TelecomConfig inConfig{ .voiceVolume = Float{volume} }, outConfig;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
+ RETURN_IF_TELEPHONY_NOT_INIT(INVALID_OPERATION);
+
+ ITelephony::TelecomConfig inConfig{.voiceVolume = Float{volume}}, outConfig;
RETURN_STATUS_IF_ERROR(
statusTFromBinderStatus(mTelephony->setTelecomConfig(inConfig, &outConfig)));
- ALOGW_IF(outConfig.voiceVolume.has_value() && volume != outConfig.voiceVolume.value().value,
- "%s: the resulting voice volume %f is not the same as requested %f",
- __func__, outConfig.voiceVolume.value().value, volume);
+ AUGMENT_LOG_IF(
+ W, outConfig.voiceVolume.has_value() && volume != outConfig.voiceVolume.value().value,
+ "the resulting voice volume %f is not the same as requested %f",
+ outConfig.voiceVolume.value().value, volume);
return OK;
}
status_t DeviceHalAidl::setMasterVolume(float volume) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ AUGMENT_LOG(D, "volume %f", volume);
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
return statusTFromBinderStatus(mModule->setMasterVolume(volume));
}
status_t DeviceHalAidl::getMasterVolume(float *volume) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (volume == nullptr) {
+ AUGMENT_LOG(E, "uninitialized volumes");
return BAD_VALUE;
}
return statusTFromBinderStatus(mModule->getMasterVolume(volume));
}
status_t DeviceHalAidl::setMode(audio_mode_t mode) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ AUGMENT_LOG(D, "mode %d", mode);
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
AudioMode audioMode = VALUE_OR_FATAL(::aidl::android::legacy2aidl_audio_mode_t_AudioMode(mode));
if (mTelephony != nullptr) {
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mTelephony->switchAudioMode(audioMode)));
@@ -195,90 +219,99 @@
}
status_t DeviceHalAidl::setMicMute(bool state) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ AUGMENT_LOG(D, "mute %d", state);
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
return statusTFromBinderStatus(mModule->setMicMute(state));
}
status_t DeviceHalAidl::getMicMute(bool *state) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (state == nullptr) {
+ AUGMENT_LOG(E, "uninitialized mute state");
return BAD_VALUE;
}
return statusTFromBinderStatus(mModule->getMicMute(state));
}
status_t DeviceHalAidl::setMasterMute(bool state) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ AUGMENT_LOG(D, "mute %d", state);
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
return statusTFromBinderStatus(mModule->setMasterMute(state));
}
status_t DeviceHalAidl::getMasterMute(bool *state) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (state == nullptr) {
+ AUGMENT_LOG(E, "uninitialized mute state");
return BAD_VALUE;
}
return statusTFromBinderStatus(mModule->getMasterMute(state));
}
status_t DeviceHalAidl::setParameters(const String8& kvPairs) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
AudioParameter parameters(kvPairs);
- ALOGD("%s: parameters: \"%s\"", __func__, parameters.toString().c_str());
+ AUGMENT_LOG(D, "parameters: \"%s\"", parameters.toString().c_str());
if (status_t status = filterAndUpdateBtA2dpParameters(parameters); status != OK) {
- ALOGW("%s: filtering or updating BT A2DP parameters failed: %d", __func__, status);
+ AUGMENT_LOG(W, "filterAndUpdateBtA2dpParameters failed: %d", status);
}
if (status_t status = filterAndUpdateBtHfpParameters(parameters); status != OK) {
- ALOGW("%s: filtering or updating BT HFP parameters failed: %d", __func__, status);
+ AUGMENT_LOG(W, "filterAndUpdateBtHfpParameters failed: %d", status);
}
if (status_t status = filterAndUpdateBtLeParameters(parameters); status != OK) {
- ALOGW("%s: filtering or updating BT LE parameters failed: %d", __func__, status);
+ AUGMENT_LOG(W, "filterAndUpdateBtLeParameters failed: %d", status);
}
if (status_t status = filterAndUpdateBtScoParameters(parameters); status != OK) {
- ALOGW("%s: filtering or updating BT SCO parameters failed: %d", __func__, status);
+ AUGMENT_LOG(W, "filterAndUpdateBtScoParameters failed: %d", status);
}
if (status_t status = filterAndUpdateScreenParameters(parameters); status != OK) {
- ALOGW("%s: filtering or updating screen parameters failed: %d", __func__, status);
+ AUGMENT_LOG(W, "filterAndUpdateScreenParameters failed: %d", status);
}
if (status_t status = filterAndUpdateTelephonyParameters(parameters); status != OK) {
- ALOGW("%s: filtering or updating telephony parameters failed: %d", __func__, status);
+ AUGMENT_LOG(W, "filterAndUpdateTelephonyParameters failed: %d", status);
}
return parseAndSetVendorParameters(mVendorExt, mModule, parameters);
}
status_t DeviceHalAidl::getParameters(const String8& keys, String8 *values) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ AUGMENT_LOG(D, "keys: \"%s\"", keys.c_str());
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (values == nullptr) {
+ AUGMENT_LOG(E, "invalid values");
return BAD_VALUE;
}
AudioParameter parameterKeys(keys), result;
if (status_t status = filterAndRetrieveBtA2dpParameters(parameterKeys, &result); status != OK) {
- ALOGW("%s: filtering or retrieving BT A2DP parameters failed: %d", __func__, status);
+ AUGMENT_LOG(W, "filterAndRetrieveBtA2dpParameters failed: %d", status);
}
if (status_t status = filterAndRetrieveBtLeParameters(parameterKeys, &result); status != OK) {
- ALOGW("%s: filtering or retrieving BT LE parameters failed: %d", __func__, status);
+ AUGMENT_LOG(W, "filterAndRetrieveBtLeParameters failed: %d", status);
}
*values = result.toString();
return parseAndGetVendorParameters(mVendorExt, mModule, parameterKeys, values);
}
status_t DeviceHalAidl::getInputBufferSize(struct audio_config* config, size_t* size) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (config == nullptr || size == nullptr) {
+ AUGMENT_LOG(E, "invalid config or size");
return BAD_VALUE;
}
constexpr bool isInput = true;
@@ -426,11 +459,13 @@
audio_io_handle_t handle, audio_devices_t devices,
audio_output_flags_t flags, struct audio_config* config,
const char* address,
- sp<StreamOutHalInterface>* outStream) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ sp<StreamOutHalInterface>* outStream,
+ const std::vector<playback_track_metadata_v7_t>& sourceMetadata) {
+ AUGMENT_LOG(D, "handle: %d devices %0x flags %0x", handle, devices, flags);
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (outStream == nullptr || config == nullptr) {
+ AUGMENT_LOG(E, "invalid outStream or config");
return BAD_VALUE;
}
constexpr bool isInput = false;
@@ -442,9 +477,12 @@
::aidl::android::legacy2aidl_audio_device_AudioDevice(devices, address));
int32_t aidlOutputFlags = VALUE_OR_RETURN_STATUS(
::aidl::android::legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
+ SourceMetadata aidlMetadata = VALUE_OR_RETURN_STATUS(
+ ::aidl::android::legacy2aidl_SourceMetadata(sourceMetadata));
AudioIoFlags aidlFlags = AudioIoFlags::make<AudioIoFlags::Tag::output>(aidlOutputFlags);
AudioPortConfig mixPortConfig;
AudioPatch aidlPatch;
+
Hal2AidlMapper::Cleanups cleanups(mMapperAccessor);
{
std::lock_guard l(mLock);
@@ -474,12 +512,13 @@
}
args.bufferSizeFrames = aidlConfig.frameCount;
args.eventCallback = eventCb;
+ args.sourceMetadata = aidlMetadata;
::aidl::android::hardware::audio::core::IModule::OpenOutputStreamReturn ret;
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mModule->openOutputStream(args, &ret)));
- StreamContextAidl context(ret.desc, isOffload);
+ StreamContextAidl context(ret.desc, isOffload, aidlHandle);
if (!context.isValid()) {
- ALOGE("%s: Failed to created a valid stream context from the descriptor: %s",
- __func__, ret.desc.toString().c_str());
+ AUGMENT_LOG(E, "Failed to created a valid stream context from the descriptor: %s",
+ ret.desc.toString().c_str());
return NO_INIT;
}
auto stream = sp<StreamOutHalAidl>::make(*config, std::move(context), aidlPatch.latenciesMs[0],
@@ -511,10 +550,11 @@
const char* address, audio_source_t source,
audio_devices_t outputDevice, const char* outputDeviceAddress,
sp<StreamInHalInterface>* inStream) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ AUGMENT_LOG(D, "handle: %d devices %0x flags %0x", handle, devices, flags);
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (inStream == nullptr || config == nullptr) {
+ AUGMENT_LOG(E, "invalid inStream or config");
return BAD_VALUE;
}
constexpr bool isInput = true;
@@ -554,10 +594,10 @@
args.bufferSizeFrames = aidlConfig.frameCount;
::aidl::android::hardware::audio::core::IModule::OpenInputStreamReturn ret;
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mModule->openInputStream(args, &ret)));
- StreamContextAidl context(ret.desc, false /*isAsynchronous*/);
+ StreamContextAidl context(ret.desc, false /*isAsynchronous*/, aidlHandle);
if (!context.isValid()) {
- ALOGE("%s: Failed to created a valid stream context from the descriptor: %s",
- __func__, ret.desc.toString().c_str());
+ AUGMENT_LOG(E, "Failed to created a valid stream context from the descriptor: %s",
+ ret.desc.toString().c_str());
return NO_INIT;
}
*inStream = sp<StreamInHalAidl>::make(*config, std::move(context), aidlPatch.latenciesMs[0],
@@ -571,7 +611,10 @@
}
status_t DeviceHalAidl::supportsAudioPatches(bool* supportsPatches) {
+ LOG_ENTRY_V();
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (supportsPatches == nullptr) {
+ AUGMENT_LOG(E, "uninitialized supportsPatches");
return BAD_VALUE;
}
*supportsPatches = true;
@@ -583,13 +626,20 @@
unsigned int num_sinks,
const struct audio_port_config* sinks,
audio_patch_handle_t* patch) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ AUGMENT_LOG(D, "sources: %d sinks %d", num_sources, num_sinks);
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
- if (num_sinks > AUDIO_PATCH_PORTS_MAX || num_sources > AUDIO_PATCH_PORTS_MAX ||
- sources == nullptr || sinks == nullptr || patch == nullptr) {
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
+ if (num_sinks > AUDIO_PATCH_PORTS_MAX || num_sources > AUDIO_PATCH_PORTS_MAX) {
+ AUGMENT_LOG(E, "invalid sources %d or sinks %d ", num_sources, num_sinks);
return BAD_VALUE;
}
+
+ if (sources == nullptr || sinks == nullptr || patch == nullptr) {
+ AUGMENT_LOG(E, "uninitialized sources %d or sinks %d or patches %d", (sources == nullptr),
+ (sinks == nullptr), (patch == nullptr));
+ return BAD_VALUE;
+ }
+
// When the patch handle (*patch) is AUDIO_PATCH_HANDLE_NONE, it means
// the framework wants to create a new patch. The handle has to be generated
// by the HAL. Since handles generated this way can only be unique within
@@ -651,9 +701,10 @@
}
status_t DeviceHalAidl::releaseAudioPatch(audio_patch_handle_t patch) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ AUGMENT_LOG(D, "patch: %d", patch);
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
static_assert(AUDIO_PATCH_HANDLE_NONE == 0);
if (patch == AUDIO_PATCH_HANDLE_NONE) {
return BAD_VALUE;
@@ -676,7 +727,10 @@
}
status_t DeviceHalAidl::getAudioPort(struct audio_port* port) {
+ LOG_ENTRY_V();
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (port == nullptr) {
+ AUGMENT_LOG(E, "port not initialized");
return BAD_VALUE;
}
audio_port_v7 portV7;
@@ -686,10 +740,12 @@
}
status_t DeviceHalAidl::getAudioPort(struct audio_port_v7 *port) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (port == nullptr) {
+ AUGMENT_LOG(E, "port not initialized");
return BAD_VALUE;
}
bool isInput = VALUE_OR_RETURN_STATUS(::aidl::android::portDirection(port->role, port->type)) ==
@@ -697,8 +753,7 @@
auto aidlPort = VALUE_OR_RETURN_STATUS(
::aidl::android::legacy2aidl_audio_port_v7_AudioPort(*port, isInput));
if (aidlPort.ext.getTag() != AudioPortExt::device) {
- ALOGE("%s: provided port is not a device port (module %s): %s",
- __func__, mInstance.c_str(), aidlPort.toString().c_str());
+ AUGMENT_LOG(E, "provided port is not a device port %s", aidlPort.toString().c_str());
return BAD_VALUE;
}
const auto& matchDevice = aidlPort.ext.get<AudioPortExt::device>().device;
@@ -717,11 +772,13 @@
status_t DeviceHalAidl::getAudioMixPort(const struct audio_port_v7 *devicePort,
struct audio_port_v7 *mixPort) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
- if (devicePort == nullptr || mixPort == nullptr ||
- devicePort->type != AUDIO_PORT_TYPE_DEVICE || mixPort->type != AUDIO_PORT_TYPE_MIX) {
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
+
+ if (devicePort == nullptr || mixPort == nullptr || devicePort->type != AUDIO_PORT_TYPE_DEVICE ||
+ mixPort->type != AUDIO_PORT_TYPE_MIX) {
+ AUGMENT_LOG(E, "invalid device or mix port");
return BAD_VALUE;
}
const int32_t aidlHandle = VALUE_OR_RETURN_STATUS(
@@ -739,10 +796,12 @@
}
status_t DeviceHalAidl::setAudioPortConfig(const struct audio_port_config* config) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (config == nullptr) {
+ AUGMENT_LOG(E, "config not initialized");
return BAD_VALUE;
}
bool isInput = VALUE_OR_RETURN_STATUS(::aidl::android::portDirection(
@@ -756,9 +815,10 @@
}
MicrophoneInfoProvider::Info const* DeviceHalAidl::getMicrophoneInfo() {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
+
TIME_CHECK();
- if (!mModule) return {};
+ RETURN_IF_MODULE_NOT_INIT({});
std::lock_guard l(mLock);
if (mMicrophones.status == Microphones::Status::UNKNOWN) {
TIME_CHECK();
@@ -770,7 +830,7 @@
} else if (status == INVALID_OPERATION) {
mMicrophones.status = Microphones::Status::NOT_SUPPORTED;
} else {
- ALOGE("%s: Unexpected status from 'IModule.getMicrophones': %d", __func__, status);
+ AUGMENT_LOG(E, "Unexpected status from HAL: %d", status);
return {};
}
}
@@ -782,10 +842,12 @@
status_t DeviceHalAidl::getMicrophones(
std::vector<audio_microphone_characteristic_t>* microphones) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (microphones == nullptr) {
+ AUGMENT_LOG(E, "microphones not initialized");
return BAD_VALUE;
}
auto staticInfo = getMicrophoneInfo();
@@ -804,10 +866,12 @@
status_t DeviceHalAidl::addDeviceEffect(
const struct audio_port_config *device, sp<EffectHalInterface> effect) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (device == nullptr || effect == nullptr) {
+ AUGMENT_LOG(E, "device or effect not initialized");
return BAD_VALUE;
}
bool isInput = VALUE_OR_RETURN_STATUS(::aidl::android::portDirection(
@@ -816,8 +880,8 @@
::aidl::android::legacy2aidl_audio_port_config_AudioPortConfig(
*device, isInput, 0));
if (requestedPortConfig.ext.getTag() != AudioPortExt::Tag::device) {
- ALOGE("%s: provided port config is not a device port config: %s",
- __func__, requestedPortConfig.toString().c_str());
+ AUGMENT_LOG(E, "provided port config is not a device port config: %s",
+ requestedPortConfig.toString().c_str());
return BAD_VALUE;
}
AudioPortConfig devicePortConfig;
@@ -835,10 +899,11 @@
}
status_t DeviceHalAidl::removeDeviceEffect(
const struct audio_port_config *device, sp<EffectHalInterface> effect) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (device == nullptr || effect == nullptr) {
+ AUGMENT_LOG(E, "device or effect not initialized");
return BAD_VALUE;
}
bool isInput = VALUE_OR_RETURN_STATUS(::aidl::android::portDirection(
@@ -847,8 +912,8 @@
::aidl::android::legacy2aidl_audio_port_config_AudioPortConfig(
*device, isInput, 0));
if (requestedPortConfig.ext.getTag() != AudioPortExt::Tag::device) {
- ALOGE("%s: provided port config is not a device port config: %s",
- __func__, requestedPortConfig.toString().c_str());
+ AUGMENT_LOG(E, "provided port config is not a device port config: %s",
+ requestedPortConfig.toString().c_str());
return BAD_VALUE;
}
AudioPortConfig devicePortConfig;
@@ -866,11 +931,13 @@
status_t DeviceHalAidl::getMmapPolicyInfos(
media::audio::common::AudioMMapPolicyType policyType,
std::vector<media::audio::common::AudioMMapPolicyInfo>* policyInfos) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
- AudioMMapPolicyType mmapPolicyType = VALUE_OR_RETURN_STATUS(
- cpp2ndk_AudioMMapPolicyType(policyType));
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
+
+ AudioMMapPolicyType mmapPolicyType =
+ VALUE_OR_RETURN_STATUS(cpp2ndk_AudioMMapPolicyType(policyType));
std::vector<AudioMMapPolicyInfo> mmapPolicyInfos;
@@ -886,9 +953,10 @@
}
int32_t DeviceHalAidl::getAAudioMixerBurstCount() {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
int32_t mixerBurstCount = 0;
if (mModule->getAAudioMixerBurstCount(&mixerBurstCount).isOk()) {
return mixerBurstCount;
@@ -897,9 +965,10 @@
}
int32_t DeviceHalAidl::getAAudioHardwareBurstMinUsec() {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
int32_t hardwareBurstMinUsec = 0;
if (mModule->getAAudioHardwareBurstMinUsec(&hardwareBurstMinUsec).isOk()) {
return hardwareBurstMinUsec;
@@ -908,9 +977,10 @@
}
error::Result<audio_hw_sync_t> DeviceHalAidl::getHwAvSync() {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
int32_t aidlHwAvSync;
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mModule->generateHwAvSyncId(&aidlHwAvSync)));
return VALUE_OR_RETURN_STATUS(
@@ -924,55 +994,59 @@
}
status_t DeviceHalAidl::supportsBluetoothVariableLatency(bool* supports) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
+
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (supports == nullptr) {
return BAD_VALUE;
}
return statusTFromBinderStatus(mModule->supportsVariableLatency(supports));
}
-status_t DeviceHalAidl::getSoundDoseInterface(const std::string& module,
- ::ndk::SpAIBinder* soundDoseBinder) {
+status_t DeviceHalAidl::getSoundDoseInterface([[maybe_unused]] const std::string& module,
+ ::ndk::SpAIBinder* soundDoseBinder) {
+ LOG_ENTRY_V();
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
+
if (soundDoseBinder == nullptr) {
return BAD_VALUE;
}
if (mSoundDose == nullptr) {
- ALOGE("%s failed to retrieve the sound dose interface for module %s",
- __func__, module.c_str());
+ AUGMENT_LOG(E, "failed to retrieve the sound dose interface");
return BAD_VALUE;
}
if (mSoundDose == nullptr) {
- ALOGE("%s failed to return the sound dose interface for module %s: not implemented",
- __func__,
- module.c_str());
+ AUGMENT_LOG(E, "failed to return the sound dose interface not implemented");
return NO_INIT;
}
*soundDoseBinder = mSoundDose->asBinder();
- ALOGI("%s using audio AIDL HAL sound dose interface", __func__);
+ AUGMENT_LOG(I, "using audio AIDL HAL sound dose interface");
return OK;
}
status_t DeviceHalAidl::prepareToDisconnectExternalDevice(const struct audio_port_v7* port) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY_V();
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (port == nullptr) {
+ AUGMENT_LOG(E, "port not initialized");
return BAD_VALUE;
}
- const bool isInput = VALUE_OR_RETURN_STATUS(
- ::aidl::android::portDirection(port->role, port->type)) ==
- ::aidl::android::AudioPortDirection::INPUT;
+ const bool isInput =
+ VALUE_OR_RETURN_STATUS(::aidl::android::portDirection(port->role, port->type)) ==
+ ::aidl::android::AudioPortDirection::INPUT;
AudioPort aidlPort = VALUE_OR_RETURN_STATUS(
::aidl::android::legacy2aidl_audio_port_v7_AudioPort(*port, isInput));
if (aidlPort.ext.getTag() != AudioPortExt::device) {
- ALOGE("%s: provided port is not a device port (module %s): %s",
- __func__, mInstance.c_str(), aidlPort.toString().c_str());
+ AUGMENT_LOG(E, "provided port is not a device port: %s", aidlPort.toString().c_str());
return BAD_VALUE;
}
+
+ AUGMENT_LOG(D, "device %s", aidlPort.toString().c_str());
+
status_t status = NO_ERROR;
{
std::lock_guard l(mLock);
@@ -993,10 +1067,11 @@
}
status_t DeviceHalAidl::setConnectedState(const struct audio_port_v7 *port, bool connected) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY_V();
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
if (port == nullptr) {
+ AUGMENT_LOG(E, "port not initialized");
return BAD_VALUE;
}
if (!connected) {
@@ -1015,17 +1090,18 @@
AudioPort aidlPort = VALUE_OR_RETURN_STATUS(
::aidl::android::legacy2aidl_audio_port_v7_AudioPort(*port, isInput));
if (aidlPort.ext.getTag() != AudioPortExt::device) {
- ALOGE("%s: provided port is not a device port (module %s): %s",
- __func__, mInstance.c_str(), aidlPort.toString().c_str());
+ AUGMENT_LOG(E, "provided port is not a device port: %s", aidlPort.toString().c_str());
return BAD_VALUE;
}
+ AUGMENT_LOG(D, "connected %d port: %s", connected, aidlPort.toString().c_str());
std::lock_guard l(mLock);
return mMapper.setDevicePortConnectedState(aidlPort, connected);
}
status_t DeviceHalAidl::setSimulateDeviceConnections(bool enabled) {
+ LOG_ENTRY_V();
TIME_CHECK();
- if (mModule == nullptr) return NO_INIT;
+ RETURN_IF_MODULE_NOT_INIT(NO_INIT);
{
std::lock_guard l(mLock);
mMapper.resetUnusedPatchesAndPortConfigs();
@@ -1034,9 +1110,9 @@
status_t status = statusTFromBinderStatus(mModule->setModuleDebug(debug));
// This is important to log as it affects HAL behavior.
if (status == OK) {
- ALOGI("%s: set enabled: %d", __func__, enabled);
+ AUGMENT_LOG(I, "set enabled: %d", enabled);
} else {
- ALOGW("%s: set enabled to %d failed: %d", __func__, enabled, status);
+ AUGMENT_LOG(W, "set enabled to %d failed: %d", enabled, status);
}
return status;
}
@@ -1051,7 +1127,7 @@
mBluetoothA2dp->supportsOffloadReconfiguration(&supports)));
result->addInt(key, supports ? 1 : 0);
} else {
- ALOGI("%s: no IBluetoothA2dp on %s", __func__, mInstance.c_str());
+ AUGMENT_LOG(I, "no IBluetoothA2dp");
result->addInt(key, 0);
}
}
@@ -1068,7 +1144,7 @@
mBluetoothLe->supportsOffloadReconfiguration(&supports)));
result->addInt(key, supports ? 1 : 0);
} else {
- ALOGI("%s: no mBluetoothLe on %s", __func__, mInstance.c_str());
+ AUGMENT_LOG(I, "no mBluetoothLe");
result->addInt(key, 0);
}
}
@@ -1079,29 +1155,29 @@
std::optional<bool> a2dpEnabled;
std::optional<std::vector<VendorParameter>> reconfigureOffload;
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
- parameters, String8(AudioParameter::keyBtA2dpSuspended),
- [&a2dpEnabled](const String8& trueOrFalse) {
- if (trueOrFalse == AudioParameter::valueTrue) {
- a2dpEnabled = false; // 'suspended' == true
- return OK;
- } else if (trueOrFalse == AudioParameter::valueFalse) {
- a2dpEnabled = true; // 'suspended' == false
- return OK;
- }
- ALOGE("setParameters: parameter key \"%s\" has invalid value \"%s\"",
- AudioParameter::keyBtA2dpSuspended, trueOrFalse.c_str());
- return BAD_VALUE;
- }));
+ parameters, String8(AudioParameter::keyBtA2dpSuspended),
+ [&a2dpEnabled, this](const String8& trueOrFalse) {
+ if (trueOrFalse == AudioParameter::valueTrue) {
+ a2dpEnabled = false; // 'suspended' == true
+ return OK;
+ } else if (trueOrFalse == AudioParameter::valueFalse) {
+ a2dpEnabled = true; // 'suspended' == false
+ return OK;
+ }
+ AUGMENT_LOG(E, "setParameters: parameter key \"%s\" has invalid value \"%s\"",
+ AudioParameter::keyBtA2dpSuspended, trueOrFalse.c_str());
+ return BAD_VALUE;
+ }));
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
- parameters, String8(AudioParameter::keyReconfigA2dp),
- [&](const String8& value) -> status_t {
- std::vector<VendorParameter> result;
- RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
- mVendorExt->parseBluetoothA2dpReconfigureOffload(
- std::string(value.c_str()), &result)));
- reconfigureOffload = std::move(result);
- return OK;
- }));
+ parameters, String8(AudioParameter::keyReconfigA2dp),
+ [&](const String8& value) -> status_t {
+ std::vector<VendorParameter> result;
+ RETURN_STATUS_IF_ERROR(
+ statusTFromBinderStatus(mVendorExt->parseBluetoothA2dpReconfigureOffload(
+ std::string(value.c_str()), &result)));
+ reconfigureOffload = std::move(result);
+ return OK;
+ }));
if (mBluetoothA2dp != nullptr && a2dpEnabled.has_value()) {
return statusTFromBinderStatus(mBluetoothA2dp->setEnabled(a2dpEnabled.value()));
}
@@ -1115,34 +1191,33 @@
status_t DeviceHalAidl::filterAndUpdateBtHfpParameters(AudioParameter ¶meters) {
IBluetooth::HfpConfig hfpConfig;
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
- parameters, String8(AudioParameter::keyBtHfpEnable),
- [&hfpConfig](const String8& trueOrFalse) {
- if (trueOrFalse == AudioParameter::valueTrue) {
- hfpConfig.isEnabled = Boolean{ .value = true };
- return OK;
- } else if (trueOrFalse == AudioParameter::valueFalse) {
- hfpConfig.isEnabled = Boolean{ .value = false };
- return OK;
- }
- ALOGE("setParameters: parameter key \"%s\" has invalid value \"%s\"",
- AudioParameter::keyBtHfpEnable, trueOrFalse.c_str());
- return BAD_VALUE;
- }));
+ parameters, String8(AudioParameter::keyBtHfpEnable),
+ [&hfpConfig, this](const String8& trueOrFalse) {
+ if (trueOrFalse == AudioParameter::valueTrue) {
+ hfpConfig.isEnabled = Boolean{.value = true};
+ return OK;
+ } else if (trueOrFalse == AudioParameter::valueFalse) {
+ hfpConfig.isEnabled = Boolean{.value = false};
+ return OK;
+ }
+ AUGMENT_LOG(E, "setParameters: parameter key \"%s\" has invalid value \"%s\"",
+ AudioParameter::keyBtHfpEnable, trueOrFalse.c_str());
+ return BAD_VALUE;
+ }));
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<int>(
- parameters, String8(AudioParameter::keyBtHfpSamplingRate),
- [&hfpConfig](int sampleRate) {
- return sampleRate > 0 ?
- hfpConfig.sampleRate = Int{ .value = sampleRate }, OK : BAD_VALUE;
- }));
+ parameters, String8(AudioParameter::keyBtHfpSamplingRate),
+ [&hfpConfig](int sampleRate) {
+ return sampleRate > 0 ? hfpConfig.sampleRate = Int{.value = sampleRate},
+ OK : BAD_VALUE;
+ }));
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<int>(
- parameters, String8(AudioParameter::keyBtHfpVolume),
- [&hfpConfig](int volume0to15) {
- if (volume0to15 >= 0 && volume0to15 <= 15) {
- hfpConfig.volume = Float{ .value = volume0to15 / 15.0f };
- return OK;
- }
- return BAD_VALUE;
- }));
+ parameters, String8(AudioParameter::keyBtHfpVolume), [&hfpConfig](int volume0to15) {
+ if (volume0to15 >= 0 && volume0to15 <= 15) {
+ hfpConfig.volume = Float{.value = volume0to15 / 15.0f};
+ return OK;
+ }
+ return BAD_VALUE;
+ }));
if (mBluetooth != nullptr && hfpConfig != IBluetooth::HfpConfig{}) {
IBluetooth::HfpConfig newHfpConfig;
return statusTFromBinderStatus(mBluetooth->setHfpConfig(hfpConfig, &newHfpConfig));
@@ -1154,39 +1229,39 @@
std::optional<bool> leEnabled;
std::optional<std::vector<VendorParameter>> reconfigureOffload;
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
- parameters, String8(AudioParameter::keyBtLeSuspended),
- [&leEnabled](const String8& trueOrFalse) {
- if (trueOrFalse == AudioParameter::valueTrue) {
- leEnabled = false; // 'suspended' == true
- return OK;
- } else if (trueOrFalse == AudioParameter::valueFalse) {
- leEnabled = true; // 'suspended' == false
- return OK;
- }
- ALOGE("setParameters: parameter key \"%s\" has invalid value \"%s\"",
- AudioParameter::keyBtLeSuspended, trueOrFalse.c_str());
- return BAD_VALUE;
- }));
+ parameters, String8(AudioParameter::keyBtLeSuspended),
+ [&leEnabled, this](const String8& trueOrFalse) {
+ if (trueOrFalse == AudioParameter::valueTrue) {
+ leEnabled = false; // 'suspended' == true
+ return OK;
+ } else if (trueOrFalse == AudioParameter::valueFalse) {
+ leEnabled = true; // 'suspended' == false
+ return OK;
+ }
+ AUGMENT_LOG(E, "setParameters: parameter key \"%s\" has invalid value \"%s\"",
+ AudioParameter::keyBtLeSuspended, trueOrFalse.c_str());
+ return BAD_VALUE;
+ }));
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
- parameters, String8(AudioParameter::keyReconfigLe),
- [&](const String8& value) -> status_t {
- if (mVendorExt != nullptr) {
- std::vector<VendorParameter> result;
- RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
- mVendorExt->parseBluetoothLeReconfigureOffload(
- std::string(value.c_str()), &result)));
- reconfigureOffload = std::move(result);
- } else {
- reconfigureOffload = std::vector<VendorParameter>();
- }
- return OK;
- }));
+ parameters, String8(AudioParameter::keyReconfigLe),
+ [&](const String8& value) -> status_t {
+ if (mVendorExt != nullptr) {
+ std::vector<VendorParameter> result;
+ RETURN_STATUS_IF_ERROR(
+ statusTFromBinderStatus(mVendorExt->parseBluetoothLeReconfigureOffload(
+ std::string(value.c_str()), &result)));
+ reconfigureOffload = std::move(result);
+ } else {
+ reconfigureOffload = std::vector<VendorParameter>();
+ }
+ return OK;
+ }));
if (mBluetoothLe != nullptr && leEnabled.has_value()) {
return statusTFromBinderStatus(mBluetoothLe->setEnabled(leEnabled.value()));
}
if (mBluetoothLe != nullptr && reconfigureOffload.has_value()) {
- return statusTFromBinderStatus(mBluetoothLe->reconfigureOffload(
- reconfigureOffload.value()));
+ return statusTFromBinderStatus(
+ mBluetoothLe->reconfigureOffload(reconfigureOffload.value()));
}
return OK;
}
@@ -1194,53 +1269,53 @@
status_t DeviceHalAidl::filterAndUpdateBtScoParameters(AudioParameter ¶meters) {
IBluetooth::ScoConfig scoConfig;
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
- parameters, String8(AudioParameter::keyBtSco),
- [&scoConfig](const String8& onOrOff) {
- if (onOrOff == AudioParameter::valueOn) {
- scoConfig.isEnabled = Boolean{ .value = true };
- return OK;
- } else if (onOrOff == AudioParameter::valueOff) {
- scoConfig.isEnabled = Boolean{ .value = false };
- return OK;
- }
- ALOGE("setParameters: parameter key \"%s\" has invalid value \"%s\"",
- AudioParameter::keyBtSco, onOrOff.c_str());
- return BAD_VALUE;
- }));
+ parameters, String8(AudioParameter::keyBtSco),
+ [&scoConfig, this](const String8& onOrOff) {
+ if (onOrOff == AudioParameter::valueOn) {
+ scoConfig.isEnabled = Boolean{.value = true};
+ return OK;
+ } else if (onOrOff == AudioParameter::valueOff) {
+ scoConfig.isEnabled = Boolean{.value = false};
+ return OK;
+ }
+ AUGMENT_LOG(E, "setParameters: parameter key \"%s\" has invalid value \"%s\"",
+ AudioParameter::keyBtSco, onOrOff.c_str());
+ return BAD_VALUE;
+ }));
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
- parameters, String8(AudioParameter::keyBtScoHeadsetName),
- [&scoConfig](const String8& name) {
- scoConfig.debugName = name;
- return OK;
- }));
+ parameters, String8(AudioParameter::keyBtScoHeadsetName),
+ [&scoConfig](const String8& name) {
+ scoConfig.debugName = name;
+ return OK;
+ }));
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
- parameters, String8(AudioParameter::keyBtNrec),
- [&scoConfig](const String8& onOrOff) {
- if (onOrOff == AudioParameter::valueOn) {
- scoConfig.isNrecEnabled = Boolean{ .value = true };
- return OK;
- } else if (onOrOff == AudioParameter::valueOff) {
- scoConfig.isNrecEnabled = Boolean{ .value = false };
- return OK;
- }
- ALOGE("setParameters: parameter key \"%s\" has invalid value \"%s\"",
- AudioParameter::keyBtNrec, onOrOff.c_str());
- return BAD_VALUE;
- }));
+ parameters, String8(AudioParameter::keyBtNrec),
+ [&scoConfig, this](const String8& onOrOff) {
+ if (onOrOff == AudioParameter::valueOn) {
+ scoConfig.isNrecEnabled = Boolean{.value = true};
+ return OK;
+ } else if (onOrOff == AudioParameter::valueOff) {
+ scoConfig.isNrecEnabled = Boolean{.value = false};
+ return OK;
+ }
+ AUGMENT_LOG(E, "setParameters: parameter key \"%s\" has invalid value \"%s\"",
+ AudioParameter::keyBtNrec, onOrOff.c_str());
+ return BAD_VALUE;
+ }));
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
- parameters, String8(AudioParameter::keyBtScoWb),
- [&scoConfig](const String8& onOrOff) {
- if (onOrOff == AudioParameter::valueOn) {
- scoConfig.mode = IBluetooth::ScoConfig::Mode::SCO_WB;
- return OK;
- } else if (onOrOff == AudioParameter::valueOff) {
- scoConfig.mode = IBluetooth::ScoConfig::Mode::SCO;
- return OK;
- }
- ALOGE("setParameters: parameter key \"%s\" has invalid value \"%s\"",
- AudioParameter::keyBtScoWb, onOrOff.c_str());
- return BAD_VALUE;
- }));
+ parameters, String8(AudioParameter::keyBtScoWb),
+ [&scoConfig, this](const String8& onOrOff) {
+ if (onOrOff == AudioParameter::valueOn) {
+ scoConfig.mode = IBluetooth::ScoConfig::Mode::SCO_WB;
+ return OK;
+ } else if (onOrOff == AudioParameter::valueOff) {
+ scoConfig.mode = IBluetooth::ScoConfig::Mode::SCO;
+ return OK;
+ }
+ AUGMENT_LOG(E, "setParameters: parameter key \"%s\" has invalid value \"%s\"",
+ AudioParameter::keyBtScoWb, onOrOff.c_str());
+ return BAD_VALUE;
+ }));
if (mBluetooth != nullptr && scoConfig != IBluetooth::ScoConfig{}) {
IBluetooth::ScoConfig newScoConfig;
return statusTFromBinderStatus(mBluetooth->setScoConfig(scoConfig, &newScoConfig));
@@ -1250,34 +1325,41 @@
status_t DeviceHalAidl::filterAndUpdateScreenParameters(AudioParameter ¶meters) {
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
- parameters, String8(AudioParameter::keyScreenState),
- [&](const String8& onOrOff) -> status_t {
- std::optional<bool> isTurnedOn;
- if (onOrOff == AudioParameter::valueOn) {
- isTurnedOn = true;
- } else if (onOrOff == AudioParameter::valueOff) {
- isTurnedOn = false;
- }
- if (!isTurnedOn.has_value()) {
- ALOGE("setParameters: parameter key \"%s\" has invalid value \"%s\"",
- AudioParameter::keyScreenState, onOrOff.c_str());
- return BAD_VALUE;
- }
- return statusTFromBinderStatus(
- mModule->updateScreenState(isTurnedOn.value()));
- }));
+ parameters, String8(AudioParameter::keyScreenState),
+ [&, this](const String8& onOrOff) -> status_t {
+ std::optional<bool> isTurnedOn;
+ if (onOrOff == AudioParameter::valueOn) {
+ isTurnedOn = true;
+ } else if (onOrOff == AudioParameter::valueOff) {
+ isTurnedOn = false;
+ }
+ if (!isTurnedOn.has_value()) {
+ AUGMENT_LOG(E, "setParameters: parameter key \"%s\" has invalid value \"%s\"",
+ AudioParameter::keyScreenState, onOrOff.c_str());
+ return BAD_VALUE;
+ }
+ return statusTFromBinderStatus(mModule->updateScreenState(isTurnedOn.value()));
+ }));
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<int>(
- parameters, String8(AudioParameter::keyScreenRotation),
- [&](int rotationDegrees) -> status_t {
+ parameters, String8(AudioParameter::keyScreenRotation),
+ [&, this](int rotationDegrees) -> status_t {
IModule::ScreenRotation rotation;
switch (rotationDegrees) {
- case 0: rotation = IModule::ScreenRotation::DEG_0; break;
- case 90: rotation = IModule::ScreenRotation::DEG_90; break;
- case 180: rotation = IModule::ScreenRotation::DEG_180; break;
- case 270: rotation = IModule::ScreenRotation::DEG_270; break;
+ case 0:
+ rotation = IModule::ScreenRotation::DEG_0;
+ break;
+ case 90:
+ rotation = IModule::ScreenRotation::DEG_90;
+ break;
+ case 180:
+ rotation = IModule::ScreenRotation::DEG_180;
+ break;
+ case 270:
+ rotation = IModule::ScreenRotation::DEG_270;
+ break;
default:
- ALOGE("setParameters: parameter key \"%s\" has invalid value %d",
- AudioParameter::keyScreenRotation, rotationDegrees);
+ AUGMENT_LOG(E, "setParameters: parameter key \"%s\" has invalid value %d",
+ AudioParameter::keyScreenRotation, rotationDegrees);
return BAD_VALUE;
}
return statusTFromBinderStatus(mModule->updateScreenRotation(rotation));
@@ -1289,43 +1371,42 @@
using TtyMode = ITelephony::TelecomConfig::TtyMode;
ITelephony::TelecomConfig telConfig;
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
- parameters, String8(AudioParameter::keyTtyMode),
- [&telConfig](const String8& mode) {
- if (mode == AudioParameter::valueTtyModeOff) {
- telConfig.ttyMode = TtyMode::OFF;
- return OK;
- } else if (mode == AudioParameter::valueTtyModeFull) {
- telConfig.ttyMode = TtyMode::FULL;
- return OK;
- } else if (mode == AudioParameter::valueTtyModeHco) {
- telConfig.ttyMode = TtyMode::HCO;
- return OK;
- } else if (mode == AudioParameter::valueTtyModeVco) {
- telConfig.ttyMode = TtyMode::VCO;
- return OK;
- }
- ALOGE("setParameters: parameter key \"%s\" has invalid value \"%s\"",
- AudioParameter::keyTtyMode, mode.c_str());
- return BAD_VALUE;
- }));
+ parameters, String8(AudioParameter::keyTtyMode),
+ [&telConfig, this](const String8& mode) {
+ if (mode == AudioParameter::valueTtyModeOff) {
+ telConfig.ttyMode = TtyMode::OFF;
+ return OK;
+ } else if (mode == AudioParameter::valueTtyModeFull) {
+ telConfig.ttyMode = TtyMode::FULL;
+ return OK;
+ } else if (mode == AudioParameter::valueTtyModeHco) {
+ telConfig.ttyMode = TtyMode::HCO;
+ return OK;
+ } else if (mode == AudioParameter::valueTtyModeVco) {
+ telConfig.ttyMode = TtyMode::VCO;
+ return OK;
+ }
+ AUGMENT_LOG(E, "setParameters: parameter key \"%s\" has invalid value \"%s\"",
+ AudioParameter::keyTtyMode, mode.c_str());
+ return BAD_VALUE;
+ }));
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<String8>(
- parameters, String8(AudioParameter::keyHacSetting),
- [&telConfig](const String8& onOrOff) {
- if (onOrOff == AudioParameter::valueHacOn) {
- telConfig.isHacEnabled = Boolean{ .value = true };
- return OK;
- } else if (onOrOff == AudioParameter::valueHacOff) {
- telConfig.isHacEnabled = Boolean{ .value = false };
- return OK;
- }
- ALOGE("setParameters: parameter key \"%s\" has invalid value \"%s\"",
- AudioParameter::keyHacSetting, onOrOff.c_str());
- return BAD_VALUE;
- }));
+ parameters, String8(AudioParameter::keyHacSetting),
+ [&telConfig, this](const String8& onOrOff) {
+ if (onOrOff == AudioParameter::valueHacOn) {
+ telConfig.isHacEnabled = Boolean{.value = true};
+ return OK;
+ } else if (onOrOff == AudioParameter::valueHacOff) {
+ telConfig.isHacEnabled = Boolean{.value = false};
+ return OK;
+ }
+ AUGMENT_LOG(E, "setParameters: parameter key \"%s\" has invalid value \"%s\"",
+ AudioParameter::keyHacSetting, onOrOff.c_str());
+ return BAD_VALUE;
+ }));
if (mTelephony != nullptr && telConfig != ITelephony::TelecomConfig{}) {
ITelephony::TelecomConfig newTelConfig;
- return statusTFromBinderStatus(
- mTelephony->setTelecomConfig(telConfig, &newTelConfig));
+ return statusTFromBinderStatus(mTelephony->setTelecomConfig(telConfig, &newTelConfig));
}
return OK;
}
diff --git a/media/libaudiohal/impl/DeviceHalAidl.h b/media/libaudiohal/impl/DeviceHalAidl.h
index 1778881..b41dbe0 100644
--- a/media/libaudiohal/impl/DeviceHalAidl.h
+++ b/media/libaudiohal/impl/DeviceHalAidl.h
@@ -119,7 +119,9 @@
// by releasing all references to the returned object.
status_t openOutputStream(audio_io_handle_t handle, audio_devices_t devices,
audio_output_flags_t flags, struct audio_config* config,
- const char* address, sp<StreamOutHalInterface>* outStream) override;
+ const char* address, sp<StreamOutHalInterface>* outStream,
+ const std::vector<playback_track_metadata_v7_t>&
+ sourceMetadata = {}) override;
// Creates and opens the audio hardware input stream. The stream is closed
// by releasing all references to the returned object.
@@ -233,7 +235,6 @@
// MicrophoneInfoProvider implementation
MicrophoneInfoProvider::Info const* getMicrophoneInfo() override;
- const std::string mInstance;
const std::shared_ptr<::aidl::android::hardware::audio::core::IModule> mModule;
const std::shared_ptr<::aidl::android::media::audio::IHalAdapterVendorExtension> mVendorExt;
const std::shared_ptr<::aidl::android::hardware::audio::core::ITelephony> mTelephony;
diff --git a/media/libaudiohal/impl/DeviceHalHidl.cpp b/media/libaudiohal/impl/DeviceHalHidl.cpp
index ea4258c..b48c7ed 100644
--- a/media/libaudiohal/impl/DeviceHalHidl.cpp
+++ b/media/libaudiohal/impl/DeviceHalHidl.cpp
@@ -259,7 +259,8 @@
audio_output_flags_t flags,
struct audio_config *config,
const char *address,
- sp<StreamOutHalInterface> *outStream) {
+ sp<StreamOutHalInterface> *outStream,
+ const std::vector<playback_track_metadata_v7_t>& sourceMetadata) {
TIME_CHECK();
if (mDevice == 0) return NO_INIT;
DeviceAddress hidlDevice;
@@ -273,6 +274,18 @@
return status;
}
+#if MAJOR_VERSION == 4
+ ::android::hardware::audio::CORE_TYPES_CPP_VERSION::SourceMetadata hidlMetadata;
+#else
+ ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION::SourceMetadata hidlMetadata;
+#endif
+
+ if (status_t status = CoreUtils::sourceMetadataFromHalV7(
+ sourceMetadata, true /*ignoreNonVendorTags*/, &hidlMetadata);
+ status != OK) {
+ return status;
+ }
+
#if !(MAJOR_VERSION == 7 && MINOR_VERSION == 1)
//TODO: b/193496180 use spatializer flag at audio HAL when available
if ((flags & AUDIO_OUTPUT_FLAG_SPATIALIZER) != 0) {
@@ -294,7 +307,7 @@
#endif
handle, hidlDevice, hidlConfig, hidlFlags,
#if MAJOR_VERSION >= 4
- {} /* metadata */,
+ hidlMetadata /* metadata */,
#endif
[&](Result r, const sp<::android::hardware::audio::CPP_VERSION::IStreamOut>& result,
const AudioConfig& suggestedConfig) {
diff --git a/media/libaudiohal/impl/DeviceHalHidl.h b/media/libaudiohal/impl/DeviceHalHidl.h
index 1362dab..5f3e08c 100644
--- a/media/libaudiohal/impl/DeviceHalHidl.h
+++ b/media/libaudiohal/impl/DeviceHalHidl.h
@@ -73,7 +73,9 @@
// by releasing all references to the returned object.
status_t openOutputStream(audio_io_handle_t handle, audio_devices_t devices,
audio_output_flags_t flags, struct audio_config* config,
- const char* address, sp<StreamOutHalInterface>* outStream) override;
+ const char* address, sp<StreamOutHalInterface>* outStream,
+ const std::vector<playback_track_metadata_v7_t>&
+ sourceMetadata = {}) override;
// Creates and opens the audio hardware input stream. The stream is closed
// by releasing all references to the returned object.
diff --git a/media/libaudiohal/impl/Hal2AidlMapper.cpp b/media/libaudiohal/impl/Hal2AidlMapper.cpp
index a01ac4b..f352849 100644
--- a/media/libaudiohal/impl/Hal2AidlMapper.cpp
+++ b/media/libaudiohal/impl/Hal2AidlMapper.cpp
@@ -25,6 +25,7 @@
#include <Utils.h>
#include <utils/Log.h>
+#include "AidlUtils.h"
#include "Hal2AidlMapper.h"
using aidl::android::aidl_utils::statusTFromBinderStatus;
@@ -99,8 +100,7 @@
} // namespace
Hal2AidlMapper::Hal2AidlMapper(const std::string& instance, const std::shared_ptr<IModule>& module)
- : mInstance(instance), mModule(module) {
-}
+ : ConversionHelperAidl("Hal2AidlMapper", instance), mModule(module) {}
void Hal2AidlMapper::addStream(
const sp<StreamHalInterface>& stream, int32_t mixPortConfigId, int32_t patchId) {
@@ -137,9 +137,9 @@
// 'sinks' will not be updated because 'setAudioPatch' only needs IDs. Here we log
// the source arguments, where only the audio configuration and device specifications
// are relevant.
- ALOGD("%s: patch ID: %d, [disregard IDs] sources: %s, sinks: %s",
- __func__, *patchId, ::android::internal::ToString(sources).c_str(),
- ::android::internal::ToString(sinks).c_str());
+ AUGMENT_LOG(D, "patch ID: %d, [disregard IDs] sources: %s, sinks: %s", *patchId,
+ ::android::internal::ToString(sources).c_str(),
+ ::android::internal::ToString(sinks).c_str());
auto fillPortConfigs = [&](
const std::vector<AudioPortConfig>& configs,
const std::set<int32_t>& destinationPortIds,
@@ -152,18 +152,20 @@
// See b/315528763. Despite that the framework knows the actual format of
// the mix port, it still uses the original format. Luckily, there is
// the I/O handle which can be used to find the mix port.
- ALOGI("fillPortConfigs: retrying to find a mix port config with default "
- "configuration");
+ AUGMENT_LOG(I,
+ "fillPortConfigs: retrying to find a mix port config with"
+ " default configuration");
if (auto it = findPortConfig(std::nullopt, s.flags,
s.ext.get<AudioPortExt::mix>().handle);
it != mPortConfigs.end()) {
portConfig = it->second;
} else {
- const std::string flags = s.flags.has_value() ?
- s.flags->toString() : "<unspecified>";
- ALOGE("fillPortConfigs: existing port config for flags %s, handle %d "
- "not found in module %s", flags.c_str(),
- s.ext.get<AudioPortExt::mix>().handle, mInstance.c_str());
+ const std::string flags =
+ s.flags.has_value() ? s.flags->toString() : "<unspecified>";
+ AUGMENT_LOG(E,
+ "fillPortConfigs: existing port config for flags %s, "
+ " handle %d not found",
+ flags.c_str(), s.ext.get<AudioPortExt::mix>().handle);
return BAD_VALUE;
}
} else {
@@ -171,8 +173,8 @@
}
}
LOG_ALWAYS_FATAL_IF(portConfig.id == 0,
- "fillPortConfigs: initial config: %s, port config: %s",
- s.toString().c_str(), portConfig.toString().c_str());
+ "fillPortConfigs: initial config: %s, port config: %s",
+ s.toString().c_str(), portConfig.toString().c_str());
ids->push_back(portConfig.id);
if (portIds != nullptr) {
portIds->insert(portConfig.portId);
@@ -218,8 +220,8 @@
if (!created) {
requestedPatch.id = patch.id;
if (patch != requestedPatch) {
- ALOGI("%s: Updating transient patch. Current: %s, new: %s",
- __func__, patch.toString().c_str(), requestedPatch.toString().c_str());
+ AUGMENT_LOG(I, "Updating transient patch. Current: %s, new: %s",
+ patch.toString().c_str(), requestedPatch.toString().c_str());
// Since matching may be done by mix port only, update the patch if the device port
// config has changed.
patch = requestedPatch;
@@ -252,7 +254,7 @@
int32_t id = result->id;
if (requestedPortConfig.id != 0 && requestedPortConfig.id != id) {
LOG_ALWAYS_FATAL("%s: requested port config id %d changed to %d", __func__,
- requestedPortConfig.id, id);
+ requestedPortConfig.id, id);
}
auto [_, inserted] = mPortConfigs.insert_or_assign(id, *result);
@@ -272,8 +274,8 @@
RETURN_STATUS_IF_ERROR(createOrUpdatePortConfig(suggestedOrAppliedPortConfig,
&appliedPortConfig, created));
if (appliedPortConfig.id == 0) {
- ALOGE("%s: module %s did not apply suggested config %s", __func__,
- mInstance.c_str(), suggestedOrAppliedPortConfig.toString().c_str());
+ AUGMENT_LOG(E, "did not apply suggested config %s",
+ suggestedOrAppliedPortConfig.toString().c_str());
return NO_INIT;
}
*result = appliedPortConfig;
@@ -289,7 +291,7 @@
if (mDisconnectedPortReplacement.first == portId) {
const auto& port = mDisconnectedPortReplacement.second;
mPorts.insert(std::make_pair(port.id, port));
- ALOGD("%s: disconnected port replacement: %s", __func__, port.toString().c_str());
+ AUGMENT_LOG(D, "disconnected port replacement: %s", port.toString().c_str());
mDisconnectedPortReplacement = std::pair<int32_t, AudioPort>();
}
updateDynamicMixPorts();
@@ -331,8 +333,7 @@
if (auto portConfigIt = findPortConfig(device); portConfigIt == mPortConfigs.end()) {
auto portsIt = findPort(device);
if (portsIt == mPorts.end()) {
- ALOGE("%s: device port for device %s is not found in the module %s",
- __func__, device.toString().c_str(), mInstance.c_str());
+ AUGMENT_LOG(E, "device port for device %s is not found", device.toString().c_str());
return BAD_VALUE;
}
AudioPortConfig requestedPortConfig;
@@ -385,15 +386,15 @@
matchFlags.set<AudioIoFlags::Tag::input>(matchFlags.get<AudioIoFlags::Tag::input>() &
~makeBitPositionFlagMask(*optionalInputFlagsIt++));
portsIt = findPort(config, matchFlags, destinationPortIds);
- ALOGI("%s: mix port for config %s, flags %s was not found in the module %s, "
- "retried with flags %s", __func__, config.toString().c_str(),
- flags.value().toString().c_str(), mInstance.c_str(),
- matchFlags.toString().c_str());
+ AUGMENT_LOG(I,
+ "mix port for config %s, flags %s was not found"
+ "retried with flags %s",
+ config.toString().c_str(), flags.value().toString().c_str(),
+ matchFlags.toString().c_str());
}
if (portsIt == mPorts.end()) {
- ALOGE("%s: mix port for config %s, flags %s is not found in the module %s",
- __func__, config.toString().c_str(), matchFlags.toString().c_str(),
- mInstance.c_str());
+ AUGMENT_LOG(E, "mix port for config %s, flags %s is not found",
+ config.toString().c_str(), matchFlags.toString().c_str());
return BAD_VALUE;
}
AudioPortConfig requestedPortConfig;
@@ -408,9 +409,10 @@
}
return createOrUpdatePortConfig(requestedPortConfig, portConfig, created);
} else if (portConfigIt == mPortConfigs.end() && !flags.has_value()) {
- ALOGW("%s: mix port config for %s, handle %d not found in the module %s, "
- "and was not created as flags are not specified",
- __func__, config.toString().c_str(), ioHandle, mInstance.c_str());
+ AUGMENT_LOG(W,
+ "mix port config for %s, handle %d not found "
+ "and was not created as flags are not specified",
+ config.toString().c_str(), ioHandle);
return BAD_VALUE;
} else {
AudioPortConfig requestedPortConfig = portConfigIt->second;
@@ -440,8 +442,8 @@
if (const auto& p = requestedPortConfig;
!p.sampleRate.has_value() || !p.channelMask.has_value() ||
!p.format.has_value()) {
- ALOGW("%s: provided mix port config is not fully specified: %s",
- __func__, p.toString().c_str());
+ AUGMENT_LOG(W, "provided mix port config is not fully specified: %s",
+ p.toString().c_str());
return BAD_VALUE;
}
AudioConfig config;
@@ -470,14 +472,13 @@
requestedPortConfig.ext.get<Tag::device>().device, configPtr, gainConfigPtr,
portConfig, created);
} else {
- ALOGD("%s: device port config does not have audio or gain config specified", __func__);
+ AUGMENT_LOG(D, "device port config does not have audio or gain config specified");
return findOrCreateDevicePortConfig(
requestedPortConfig.ext.get<Tag::device>().device, nullptr /*config*/,
nullptr /*gainConfig*/, portConfig, created);
}
}
- ALOGW("%s: unsupported audio port config: %s",
- __func__, requestedPortConfig.toString().c_str());
+ AUGMENT_LOG(W, "unsupported audio port config: %s", requestedPortConfig.toString().c_str());
return BAD_VALUE;
}
@@ -486,8 +487,7 @@
*portConfig = it->second;
return OK;
}
- ALOGE("%s: could not find a device port config for device %s",
- __func__, device.toString().c_str());
+ AUGMENT_LOG(E, "could not find a device port config for device %s", device.toString().c_str());
return BAD_VALUE;
}
@@ -593,9 +593,10 @@
}
optionalFlags |= makeBitPositionFlagMask(*optionalOutputFlagsIt++);
result = std::find_if(mPorts.begin(), mPorts.end(), matcher);
- ALOGI("%s: port for config %s, flags %s was not found in the module %s, "
- "retried with excluding optional flags %#x", __func__, config.toString().c_str(),
- flags.toString().c_str(), mInstance.c_str(), optionalFlags);
+ AUGMENT_LOG(I,
+ "port for config %s, flags %s was not found "
+ "retried with excluding optional flags %#x",
+ config.toString().c_str(), flags.toString().c_str(), optionalFlags);
}
}
return result;
@@ -629,7 +630,7 @@
status_t Hal2AidlMapper::getAudioMixPort(int32_t ioHandle, AudioPort* port) {
auto it = findPortConfig(std::nullopt /*config*/, std::nullopt /*flags*/, ioHandle);
if (it == mPortConfigs.end()) {
- ALOGE("%s, cannot find mix port config for handle %u", __func__, ioHandle);
+ AUGMENT_LOG(E, "cannot find mix port config for handle %u", ioHandle);
return BAD_VALUE;
}
return updateAudioPort(it->second.portId, port);
@@ -638,21 +639,18 @@
status_t Hal2AidlMapper::getAudioPortCached(
const ::aidl::android::media::audio::common::AudioDevice& device,
::aidl::android::media::audio::common::AudioPort* port) {
-
if (auto portsIt = findPort(device); portsIt != mPorts.end()) {
*port = portsIt->second;
return OK;
}
- ALOGE("%s: device port for device %s is not found in the module %s",
- __func__, device.toString().c_str(), mInstance.c_str());
+ AUGMENT_LOG(E, "device port for device %s is not found", device.toString().c_str());
return BAD_VALUE;
}
status_t Hal2AidlMapper::initialize() {
std::vector<AudioPort> ports;
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mModule->getAudioPorts(&ports)));
- ALOGW_IF(ports.empty(), "%s: module %s returned an empty list of audio ports",
- __func__, mInstance.c_str());
+ AUGMENT_LOG_IF(W, ports.empty(), "returned an empty list of audio ports");
mDefaultInputPortId = mDefaultOutputPortId = -1;
const int defaultDeviceFlag = 1 << AudioPortDeviceExt::FLAG_INDEX_DEFAULT_DEVICE;
for (auto it = ports.begin(); it != ports.end(); ) {
@@ -685,8 +683,9 @@
}
}
if (mRemoteSubmixIn.has_value() != mRemoteSubmixOut.has_value()) {
- ALOGE("%s: The configuration only has input or output remote submix device, must have both",
- __func__);
+ AUGMENT_LOG(E,
+ "The configuration only has input or output remote submix device, "
+ "must have both");
mRemoteSubmixIn.reset();
mRemoteSubmixOut.reset();
}
@@ -694,7 +693,7 @@
AudioPort connectedRSubmixIn = *mRemoteSubmixIn;
connectedRSubmixIn.ext.get<AudioPortExt::Tag::device>().device.address =
AUDIO_REMOTE_SUBMIX_DEVICE_ADDRESS;
- ALOGD("%s: connecting remote submix input", __func__);
+ AUGMENT_LOG(D, "connecting remote submix input");
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mModule->connectExternalDevice(
connectedRSubmixIn, &connectedRSubmixIn)));
// The template port for the remote submix input couldn't be "default" because it is not
@@ -711,7 +710,7 @@
AudioPort tempConnectedRSubmixOut = *mRemoteSubmixOut;
tempConnectedRSubmixOut.ext.get<AudioPortExt::Tag::device>().device.address =
AUDIO_REMOTE_SUBMIX_DEVICE_ADDRESS;
- ALOGD("%s: temporarily connecting and disconnecting remote submix output", __func__);
+ AUGMENT_LOG(D, "temporarily connecting and disconnecting remote submix output");
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mModule->connectExternalDevice(
tempConnectedRSubmixOut, &tempConnectedRSubmixOut)));
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mModule->disconnectExternalDevice(
@@ -720,8 +719,8 @@
ports.push_back(std::move(tempConnectedRSubmixOut));
}
- ALOGI("%s: module %s default port ids: input %d, output %d",
- __func__, mInstance.c_str(), mDefaultInputPortId, mDefaultOutputPortId);
+ AUGMENT_LOG(I, "default port ids: input %d, output %d", mDefaultInputPortId,
+ mDefaultOutputPortId);
std::transform(ports.begin(), ports.end(), std::inserter(mPorts, mPorts.end()),
[](const auto& p) { return std::make_pair(p.id, p); });
RETURN_STATUS_IF_ERROR(updateRoutes());
@@ -774,10 +773,10 @@
int32_t ioHandle, const AudioDevice& device, const AudioIoFlags& flags,
AudioSource source, Cleanups* cleanups, AudioConfig* config,
AudioPortConfig* mixPortConfig, AudioPatch* patch) {
- ALOGD("%p %s: handle %d, device %s, flags %s, source %s, config %s, mix port config %s",
- this, __func__, ioHandle, device.toString().c_str(),
- flags.toString().c_str(), toString(source).c_str(),
- config->toString().c_str(), mixPortConfig->toString().c_str());
+ AUGMENT_LOG(D, "handle %d, device %s, flags %s, source %s, config %s, mixport config %s",
+ ioHandle, device.toString().c_str(), flags.toString().c_str(),
+ toString(source).c_str(), config->toString().c_str(),
+ mixPortConfig->toString().c_str());
resetUnusedPatchesAndPortConfigs();
const AudioConfig initialConfig = *config;
// Find / create AudioPortConfigs for the device port and the mix port,
@@ -800,8 +799,8 @@
// module can't perform audio stream conversions.
AudioConfig deviceConfig = initialConfig;
if (setConfigFromPortConfig(&deviceConfig, devicePortConfig)->base != initialConfig.base) {
- ALOGD("%s: retrying with device port config: %s", __func__,
- devicePortConfig.toString().c_str());
+ AUGMENT_LOG(D, "retrying with device port config: %s",
+ devicePortConfig.toString().c_str());
status = prepareToOpenStreamHelper(ioHandle, devicePortConfig.portId,
devicePortConfig.id, flags, source, initialConfig, cleanups,
&deviceConfig, mixPortConfig, patch);
@@ -845,8 +844,8 @@
retryWithSuggestedConfig = true;
}
if (mixPortConfig->id == 0 && retryWithSuggestedConfig) {
- ALOGD("%s: retrying to find/create a mix port config using config %s", __func__,
- config->toString().c_str());
+ AUGMENT_LOG(D, "retrying to find/create a mix port config using config %s",
+ config->toString().c_str());
RETURN_STATUS_IF_ERROR(findOrCreateMixPortConfig(*config, flags, ioHandle, source,
std::set<int32_t>{devicePortId}, mixPortConfig, &created));
if (created) {
@@ -855,8 +854,8 @@
setConfigFromPortConfig(config, *mixPortConfig);
}
if (mixPortConfig->id == 0) {
- ALOGD("%p %s: returning suggested config for the stream: %s", this, __func__,
- config->toString().c_str());
+ AUGMENT_LOG(D, "returning suggested config for the stream: %s",
+ config->toString().c_str());
return OK;
}
if (isInput) {
@@ -894,9 +893,10 @@
// Note: does not reset port configs.
status_t Hal2AidlMapper::releaseAudioPatch(Patches::iterator it) {
const int32_t patchId = it->first;
+ AUGMENT_LOG(D, "patchId %d", patchId);
if (ndk::ScopedAStatus status = mModule->resetAudioPatch(patchId); !status.isOk()) {
- ALOGE("%s: error while resetting patch %d: %s",
- __func__, patchId, status.getDescription().c_str());
+ AUGMENT_LOG(E, "error while resetting patch %d: %s", patchId,
+ status.getDescription().c_str());
return statusTFromBinderStatus(status);
}
mPatches.erase(it);
@@ -915,7 +915,7 @@
if (auto it = mPatches.find(patchId); it != mPatches.end()) {
releaseAudioPatch(it);
} else {
- ALOGE("%s: patch id %d not found", __func__, patchId);
+ AUGMENT_LOG(E, "patch id %d not found", patchId);
result = BAD_VALUE;
}
}
@@ -925,16 +925,17 @@
void Hal2AidlMapper::resetPortConfig(int32_t portConfigId) {
if (auto it = mPortConfigs.find(portConfigId); it != mPortConfigs.end()) {
+ AUGMENT_LOG(D, "%s", it->second.toString().c_str());
if (ndk::ScopedAStatus status = mModule->resetAudioPortConfig(portConfigId);
!status.isOk()) {
- ALOGE("%s: error while resetting port config %d: %s",
- __func__, portConfigId, status.getDescription().c_str());
+ AUGMENT_LOG(E, "error while resetting port config %d: %s", portConfigId,
+ status.getDescription().c_str());
return;
}
mPortConfigs.erase(it);
return;
}
- ALOGE("%s: port config id %d not found", __func__, portConfigId);
+ AUGMENT_LOG(E, "port config id %d not found", portConfigId);
}
void Hal2AidlMapper::resetUnusedPatchesAndPortConfigs() {
@@ -979,6 +980,8 @@
}
status_t Hal2AidlMapper::setDevicePortConnectedState(const AudioPort& devicePort, bool connected) {
+ AUGMENT_LOG(D, "state %s, device %s", (connected ? "connected" : "disconnected"),
+ devicePort.toString().c_str());
resetUnusedPatchesAndPortConfigs();
if (connected) {
AudioDevice matchDevice = devicePort.ext.get<AudioPortExt::device>().device;
@@ -1009,8 +1012,7 @@
// port not found in every one of them.
return BAD_VALUE;
} else {
- ALOGD("%s: device port for device %s found in the module %s",
- __func__, matchDevice.toString().c_str(), mInstance.c_str());
+ AUGMENT_LOG(D, "device port for device %s found", matchDevice.toString().c_str());
}
templatePort = portsIt->second;
}
@@ -1021,10 +1023,9 @@
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mModule->connectExternalDevice(
connectedPort, &connectedPort)));
const auto [it, inserted] = mPorts.insert(std::make_pair(connectedPort.id, connectedPort));
- LOG_ALWAYS_FATAL_IF(!inserted,
- "%s: module %s, duplicate port ID received from HAL: %s, existing port: %s",
- __func__, mInstance.c_str(), connectedPort.toString().c_str(),
- it->second.toString().c_str());
+ LOG_ALWAYS_FATAL_IF(
+ !inserted, "%s duplicate port ID received from HAL: %s, existing port: %s",
+ __func__, connectedPort.toString().c_str(), it->second.toString().c_str());
mConnectedPorts.insert(connectedPort.id);
if (erasePortAfterConnectionIt != mPorts.end()) {
mPorts.erase(erasePortAfterConnectionIt);
@@ -1037,8 +1038,7 @@
// port not found in every one of them.
return BAD_VALUE;
} else {
- ALOGD("%s: device port for device %s found in the module %s",
- __func__, matchDevice.toString().c_str(), mInstance.c_str());
+ AUGMENT_LOG(D, "device port for device %s found", matchDevice.toString().c_str());
}
// Disconnection of remote submix out with address "0" is a special case. We need to replace
@@ -1094,8 +1094,8 @@
}
portIt->second = *port;
} else {
- ALOGW("%s, port(%d) returned successfully from the HAL but not it is not cached",
- __func__, portId);
+ AUGMENT_LOG(W, "port(%d) returned successfully from the HAL but not it is not cached",
+ portId);
}
}
return status;
@@ -1104,8 +1104,7 @@
status_t Hal2AidlMapper::updateRoutes() {
RETURN_STATUS_IF_ERROR(
statusTFromBinderStatus(mModule->getAudioRoutes(&mRoutes)));
- ALOGW_IF(mRoutes.empty(), "%s: module %s returned an empty list of audio routes",
- __func__, mInstance.c_str());
+ AUGMENT_LOG_IF(W, mRoutes.empty(), "returned an empty list of audio routes");
if (mRemoteSubmixIn.has_value()) {
// Remove mentions of the template remote submix input from routes.
int32_t rSubmixInId = mRemoteSubmixIn->id;
@@ -1146,7 +1145,7 @@
updateAudioPort(portId, &it->second);
} else {
// This must not happen
- ALOGE("%s, cannot find port for id=%d", __func__, portId);
+ AUGMENT_LOG(E, "cannot find port for id=%d", portId);
}
}
}
diff --git a/media/libaudiohal/impl/Hal2AidlMapper.h b/media/libaudiohal/impl/Hal2AidlMapper.h
index 710b43e..2548752 100644
--- a/media/libaudiohal/impl/Hal2AidlMapper.h
+++ b/media/libaudiohal/impl/Hal2AidlMapper.h
@@ -26,6 +26,7 @@
#include <media/AidlConversionUtil.h>
#include "Cleanups.h"
+#include "ConversionHelperAidl.h"
namespace android {
@@ -41,7 +42,7 @@
// but still consider some of the outputs to be valid (for example, in 'open{Input|Output}Stream'),
// 'Hal2AidlMapper' follows the Binder convention. It means that if a method returns an error,
// the outputs may not be initialized at all and should not be considered by the caller.
-class Hal2AidlMapper {
+class Hal2AidlMapper : public ConversionHelperAidl {
public:
using Cleanups = Cleanups<Hal2AidlMapper>;
@@ -135,7 +136,6 @@
enum PatchMatch { MATCH_SOURCES, MATCH_SINKS, MATCH_BOTH };
- const std::string mInstance;
const std::shared_ptr<::aidl::android::hardware::audio::core::IModule> mModule;
bool audioDeviceMatches(const ::aidl::android::media::audio::common::AudioDevice& device,
diff --git a/media/libaudiohal/impl/StreamHalAidl.cpp b/media/libaudiohal/impl/StreamHalAidl.cpp
index 7a80a6a..8a15e7a 100644
--- a/media/libaudiohal/impl/StreamHalAidl.cpp
+++ b/media/libaudiohal/impl/StreamHalAidl.cpp
@@ -31,6 +31,7 @@
#include <system/audio.h>
#include <utils/Log.h>
+#include "AidlUtils.h"
#include "DeviceHalAidl.h"
#include "EffectHalAidl.h"
#include "StreamHalAidl.h"
@@ -72,12 +73,12 @@
return streamCommon;
}
-StreamHalAidl::StreamHalAidl(
- std::string_view className, bool isInput, const audio_config& config,
- int32_t nominalLatency, StreamContextAidl&& context,
- const std::shared_ptr<IStreamCommon>& stream,
- const std::shared_ptr<IHalAdapterVendorExtension>& vext)
- : ConversionHelperAidl(className),
+StreamHalAidl::StreamHalAidl(std::string_view className, bool isInput, const audio_config& config,
+ int32_t nominalLatency, StreamContextAidl&& context,
+ const std::shared_ptr<IStreamCommon>& stream,
+ const std::shared_ptr<IHalAdapterVendorExtension>& vext)
+ : ConversionHelperAidl(className, std::string(isInput ? "in" : "out") + "|ioHandle:" +
+ std::to_string(context.getIoHandle())),
mIsInput(isInput),
mConfig(configToBase(config)),
mContext(std::move(context)),
@@ -88,7 +89,7 @@
mContext.getBufferDurationMs(mConfig.sample_rate))
* NANOS_PER_MILLISECOND)
{
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
{
std::lock_guard l(mLock);
mLastReply.latencyMs = nominalLatency;
@@ -103,15 +104,15 @@
}
StreamHalAidl::~StreamHalAidl() {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
if (mStream != nullptr) {
ndk::ScopedAStatus status = mStream->close();
- ALOGE_IF(!status.isOk(), "%s: status %s", __func__, status.getDescription().c_str());
+ AUGMENT_LOG_IF(E, !status.isOk(), "status %s", status.getDescription().c_str());
}
}
status_t StreamHalAidl::getBufferSize(size_t *size) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
if (size == nullptr) {
return BAD_VALUE;
}
@@ -120,11 +121,12 @@
return NO_INIT;
}
*size = mContext.getBufferSizeBytes();
+ AUGMENT_LOG(I, "size: %zu", *size);
return OK;
}
status_t StreamHalAidl::getAudioProperties(audio_config_base_t *configBase) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
if (configBase == nullptr) {
return BAD_VALUE;
}
@@ -134,10 +136,11 @@
}
status_t StreamHalAidl::setParameters(const String8& kvPairs) {
+ LOG_ENTRY_V();
TIME_CHECK();
if (!mStream) return NO_INIT;
AudioParameter parameters(kvPairs);
- ALOGD("%s: parameters: %s", __func__, parameters.toString().c_str());
+ AUGMENT_LOG(D, "parameters: %s", parameters.toString().c_str());
(void)VALUE_OR_RETURN_STATUS(filterOutAndProcessParameter<int>(
parameters, String8(AudioParameter::keyStreamHwAvSync),
@@ -148,6 +151,7 @@
}
status_t StreamHalAidl::getParameters(const String8& keys __unused, String8 *values) {
+ LOG_ENTRY_V();
TIME_CHECK();
if (!mStream) return NO_INIT;
if (values == nullptr) {
@@ -159,7 +163,7 @@
}
status_t StreamHalAidl::getFrameSize(size_t *size) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
if (size == nullptr) {
return BAD_VALUE;
}
@@ -171,7 +175,7 @@
}
status_t StreamHalAidl::addEffect(sp<EffectHalInterface> effect) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
if (!mStream) return NO_INIT;
if (effect == nullptr) {
@@ -182,7 +186,7 @@
}
status_t StreamHalAidl::removeEffect(sp<EffectHalInterface> effect) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
if (!mStream) return NO_INIT;
if (effect == nullptr) {
@@ -193,7 +197,7 @@
}
status_t StreamHalAidl::standby() {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
if (!mStream) return NO_INIT;
const auto state = getState();
@@ -206,8 +210,8 @@
if (reply.state != StreamDescriptor::State::PAUSED &&
reply.state != StreamDescriptor::State::DRAIN_PAUSED &&
reply.state != StreamDescriptor::State::TRANSFER_PAUSED) {
- ALOGE("%s: unexpected stream state: %s (expected PAUSED)",
- __func__, toString(reply.state).c_str());
+ AUGMENT_LOG(E, "unexpected stream state: %s (expected PAUSED)",
+ toString(reply.state).c_str());
return INVALID_OPERATION;
}
FALLTHROUGH_INTENDED;
@@ -217,8 +221,8 @@
if (mIsInput) return flush();
RETURN_STATUS_IF_ERROR(flush(&reply));
if (reply.state != StreamDescriptor::State::IDLE) {
- ALOGE("%s: unexpected stream state: %s (expected IDLE)",
- __func__, toString(reply.state).c_str());
+ AUGMENT_LOG(E, "unexpected stream state: %s (expected IDLE)",
+ toString(reply.state).c_str());
return INVALID_OPERATION;
}
FALLTHROUGH_INTENDED;
@@ -226,22 +230,22 @@
RETURN_STATUS_IF_ERROR(sendCommand(makeHalCommand<HalCommand::Tag::standby>(),
&reply, true /*safeFromNonWorkerThread*/));
if (reply.state != StreamDescriptor::State::STANDBY) {
- ALOGE("%s: unexpected stream state: %s (expected STANDBY)",
- __func__, toString(reply.state).c_str());
+ AUGMENT_LOG(E, "unexpected stream state: %s (expected STANDBY)",
+ toString(reply.state).c_str());
return INVALID_OPERATION;
}
FALLTHROUGH_INTENDED;
case StreamDescriptor::State::STANDBY:
return OK;
default:
- ALOGE("%s: not supported from %s stream state %s",
- __func__, mIsInput ? "input" : "output", toString(state).c_str());
+ AUGMENT_LOG(E, "not supported from %s stream state %s", mIsInput ? "input" : "output",
+ toString(state).c_str());
return INVALID_OPERATION;
}
}
status_t StreamHalAidl::dump(int fd, const Vector<String16>& args) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
if (!mStream) return NO_INIT;
status_t status = mStream->dump(fd, Args(args).args(), args.size());
@@ -250,7 +254,7 @@
}
status_t StreamHalAidl::start() {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
if (!mStream) return NO_INIT;
if (!mContext.isMmapped()) {
@@ -263,8 +267,8 @@
RETURN_STATUS_IF_ERROR(
sendCommand(makeHalCommand<HalCommand::Tag::start>(), &reply, true));
if (reply.state != StreamDescriptor::State::IDLE) {
- ALOGE("%s: unexpected stream state: %s (expected IDLE)",
- __func__, toString(reply.state).c_str());
+ AUGMENT_LOG(E, "unexpected stream state: %s (expected IDLE)",
+ toString(reply.state).c_str());
return INVALID_OPERATION;
}
FALLTHROUGH_INTENDED;
@@ -272,8 +276,8 @@
RETURN_STATUS_IF_ERROR(
sendCommand(makeHalCommand<HalCommand::Tag::burst>(0), &reply, true));
if (reply.state != StreamDescriptor::State::ACTIVE) {
- ALOGE("%s: unexpected stream state: %s (expected ACTIVE)",
- __func__, toString(reply.state).c_str());
+ AUGMENT_LOG(E, "unexpected stream state: %s (expected ACTIVE)",
+ toString(reply.state).c_str());
return INVALID_OPERATION;
}
FALLTHROUGH_INTENDED;
@@ -283,20 +287,20 @@
RETURN_STATUS_IF_ERROR(
sendCommand(makeHalCommand<HalCommand::Tag::start>(), &reply, true));
if (reply.state != StreamDescriptor::State::ACTIVE) {
- ALOGE("%s: unexpected stream state: %s (expected ACTIVE)",
- __func__, toString(reply.state).c_str());
+ AUGMENT_LOG(E, "unexpected stream state: %s (expected ACTIVE)",
+ toString(reply.state).c_str());
return INVALID_OPERATION;
}
return OK;
default:
- ALOGE("%s: not supported from %s stream state %s",
- __func__, mIsInput ? "input" : "output", toString(reply.state).c_str());
+ AUGMENT_LOG(E, "not supported from %s stream state %s", mIsInput ? "input" : "output",
+ toString(reply.state).c_str());
return INVALID_OPERATION;
}
}
status_t StreamHalAidl::stop() {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
if (!mStream) return NO_INIT;
if (!mContext.isMmapped()) {
@@ -313,28 +317,28 @@
return flush();
} else if (state != StreamDescriptor::State::IDLE &&
state != StreamDescriptor::State::STANDBY) {
- ALOGE("%s: not supported from %s stream state %s",
- __func__, mIsInput ? "input" : "output", toString(state).c_str());
+ AUGMENT_LOG(E, "not supported from %s stream state %s", mIsInput ? "input" : "output",
+ toString(state).c_str());
return INVALID_OPERATION;
}
return OK;
}
status_t StreamHalAidl::getLatency(uint32_t *latency) {
- ALOGV("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY_V();
if (!mStream) return NO_INIT;
StreamDescriptor::Reply reply;
RETURN_STATUS_IF_ERROR(updateCountersIfNeeded(&reply));
*latency = std::clamp(std::max<int32_t>(0, reply.latencyMs), 1, 3000);
- ALOGW_IF(reply.latencyMs != static_cast<int32_t>(*latency),
- "Suspicious latency value reported by HAL: %d, clamped to %u", reply.latencyMs,
- *latency);
+ AUGMENT_LOG_IF(W, reply.latencyMs != static_cast<int32_t>(*latency),
+ "Suspicious latency value reported by HAL: %d, clamped to %u", reply.latencyMs,
+ *latency);
return OK;
}
status_t StreamHalAidl::getObservablePosition(int64_t* frames, int64_t* timestamp,
StatePositions* statePositions) {
- ALOGV("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY_V();
if (!mStream) return NO_INIT;
StreamDescriptor::Reply reply;
RETURN_STATUS_IF_ERROR(updateCountersIfNeeded(&reply, statePositions));
@@ -344,7 +348,7 @@
}
status_t StreamHalAidl::getHardwarePosition(int64_t *frames, int64_t *timestamp) {
- ALOGV("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY_V();
if (!mStream) return NO_INIT;
StreamDescriptor::Reply reply;
RETURN_STATUS_IF_ERROR(updateCountersIfNeeded(&reply));
@@ -354,7 +358,7 @@
}
status_t StreamHalAidl::getXruns(int32_t *frames) {
- ALOGV("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY_V();
if (!mStream) return NO_INIT;
StreamDescriptor::Reply reply;
RETURN_STATUS_IF_ERROR(updateCountersIfNeeded(&reply));
@@ -363,7 +367,7 @@
}
status_t StreamHalAidl::transfer(void *buffer, size_t bytes, size_t *transferred) {
- ALOGV("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY_V();
// TIME_CHECK(); // TODO(b/243839867) reenable only when optimized.
if (!mStream || mContext.getDataMQ() == nullptr) return NO_INIT;
mWorkerTid.store(gettid(), std::memory_order_release);
@@ -375,8 +379,8 @@
StreamDescriptor::Reply reply;
RETURN_STATUS_IF_ERROR(sendCommand(makeHalCommand<HalCommand::Tag::start>(), &reply));
if (reply.state != StreamDescriptor::State::IDLE) {
- ALOGE("%s: failed to get the stream out of standby, actual state: %s",
- __func__, toString(reply.state).c_str());
+ AUGMENT_LOG(E, "failed to get the stream out of standby, actual state: %s",
+ toString(reply.state).c_str());
return INVALID_OPERATION;
}
}
@@ -390,7 +394,7 @@
StreamDescriptor::Command::make<StreamDescriptor::Command::Tag::burst>(bytes);
if (!mIsInput) {
if (!mContext.getDataMQ()->write(static_cast<const int8_t*>(buffer), bytes)) {
- ALOGE("%s: failed to write %zu bytes to data MQ", __func__, bytes);
+ AUGMENT_LOG(E, "failed to write %zu bytes to data MQ", bytes);
return NOT_ENOUGH_DATA;
}
}
@@ -403,7 +407,7 @@
__func__, *transferred, bytes);
if (auto toRead = mContext.getDataMQ()->availableToRead(&fmqError, &fmqErrorMsg);
toRead != 0 && !mContext.getDataMQ()->read(static_cast<int8_t*>(buffer), toRead)) {
- ALOGE("%s: failed to read %zu bytes to data MQ", __func__, toRead);
+ AUGMENT_LOG(E, "failed to read %zu bytes to data MQ", toRead);
return NOT_ENOUGH_DATA;
}
}
@@ -414,7 +418,7 @@
}
status_t StreamHalAidl::pause(StreamDescriptor::Reply* reply) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
if (!mStream) return NO_INIT;
@@ -423,14 +427,14 @@
makeHalCommand<HalCommand::Tag::pause>(), reply,
true /*safeFromNonWorkerThread*/); // The workers stops its I/O activity first.
} else {
- ALOGD("%s: already stream in one of the PAUSED kind of states, current state: %s", __func__,
- toString(state).c_str());
+ AUGMENT_LOG(D, "already stream in one of the PAUSED kind of states, current state: %s",
+ toString(state).c_str());
return OK;
}
}
status_t StreamHalAidl::resume(StreamDescriptor::Reply* reply) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
if (!mStream) return NO_INIT;
if (mIsInput) {
@@ -444,8 +448,8 @@
RETURN_STATUS_IF_ERROR(
sendCommand(makeHalCommand<HalCommand::Tag::burst>(0), innerReply));
if (innerReply->state != StreamDescriptor::State::ACTIVE) {
- ALOGE("%s: unexpected stream state: %s (expected ACTIVE)",
- __func__, toString(innerReply->state).c_str());
+ AUGMENT_LOG(E, "unexpected stream state: %s (expected ACTIVE)",
+ toString(innerReply->state).c_str());
return INVALID_OPERATION;
}
return OK;
@@ -456,18 +460,18 @@
} else if (state == StreamDescriptor::State::ACTIVE ||
state == StreamDescriptor::State::TRANSFERRING ||
state == StreamDescriptor::State::DRAINING) {
- ALOGD("%s: already in stream state: %s", __func__, toString(state).c_str());
+ AUGMENT_LOG(D, "already in stream state: %s", toString(state).c_str());
return OK;
} else {
- ALOGE("%s: unexpected stream state: %s (expected IDLE or one of *PAUSED states)",
- __func__, toString(state).c_str());
+ AUGMENT_LOG(E, "unexpected stream state: %s (expected IDLE or one of *PAUSED states)",
+ toString(state).c_str());
return INVALID_OPERATION;
}
}
}
status_t StreamHalAidl::drain(bool earlyNotify, StreamDescriptor::Reply* reply) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
if (!mStream) return NO_INIT;
return sendCommand(makeHalCommand<HalCommand::Tag::drain>(
@@ -478,7 +482,7 @@
}
status_t StreamHalAidl::flush(StreamDescriptor::Reply* reply) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
if (!mStream) return NO_INIT;
@@ -487,17 +491,17 @@
makeHalCommand<HalCommand::Tag::flush>(), reply,
true /*safeFromNonWorkerThread*/); // The workers stops its I/O activity first.
} else if (isInPlayOrRecordState(state)) {
- ALOGE("%s: found stream in non-flushable state: %s", __func__, toString(state).c_str());
+ AUGMENT_LOG(E, "found stream in non-flushable state: %s", toString(state).c_str());
return INVALID_OPERATION;
} else {
- ALOGD("%s: already stream in one of the flushable state: current state: %s", __func__,
- toString(state).c_str());
+ AUGMENT_LOG(D, "already stream in one of the flushable state: current state: %s",
+ toString(state).c_str());
return OK;
}
}
status_t StreamHalAidl::exit() {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
if (!mStream) return NO_INIT;
return statusTFromBinderStatus(mStream->prepareToClose());
@@ -510,7 +514,7 @@
sendCommand(makeHalCommand<HalCommand::Tag::getStatus>(),
nullptr, true /*safeFromNonWorkerThread */);
} else {
- ALOGW("%s: unexpected onTransferReady in the state %s", __func__, toString(state).c_str());
+ AUGMENT_LOG(W, "unexpected onTransferReady in the state %s", toString(state).c_str());
}
}
@@ -525,19 +529,19 @@
std::lock_guard l(mLock);
mStatePositions.framesAtFlushOrDrain = mLastReply.observable.frames;
} else {
- ALOGW("%s: unexpected onDrainReady in the state %s", __func__, toString(state).c_str());
+ AUGMENT_LOG(W, "unexpected onDrainReady in the state %s", toString(state).c_str());
}
}
void StreamHalAidl::onAsyncError() {
std::lock_guard l(mLock);
- ALOGW("%s: received in the state %s", __func__, toString(mLastReply.state).c_str());
+ AUGMENT_LOG(W, "received in the state %s", toString(mLastReply.state).c_str());
mLastReply.state = StreamDescriptor::State::ERROR;
}
status_t StreamHalAidl::createMmapBuffer(int32_t minSizeFrames __unused,
struct audio_mmap_buffer_info *info) {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
TIME_CHECK();
if (!mStream) return NO_INIT;
if (!mContext.isMmapped()) {
@@ -597,15 +601,14 @@
{
std::lock_guard l(mCommandReplyLock);
if (!mContext.getCommandMQ()->writeBlocking(&command, 1)) {
- ALOGE("%s: failed to write command %s to MQ", __func__, command.toString().c_str());
+ AUGMENT_LOG(E, "failed to write command %s to MQ", command.toString().c_str());
return NOT_ENOUGH_DATA;
}
if (reply == nullptr) {
reply = &localReply;
}
if (!mContext.getReplyMQ()->readBlocking(reply, 1)) {
- ALOGE("%s: failed to read from reply MQ, command %s",
- __func__, command.toString().c_str());
+ AUGMENT_LOG(E, "failed to read from reply MQ, command %s", command.toString().c_str());
return NOT_ENOUGH_DATA;
}
{
@@ -642,8 +645,8 @@
case STATUS_INVALID_OPERATION: return INVALID_OPERATION;
case STATUS_NOT_ENOUGH_DATA: return NOT_ENOUGH_DATA;
default:
- ALOGE("%s: unexpected status %d returned for command %s",
- __func__, reply->status, command.toString().c_str());
+ AUGMENT_LOG(E, "unexpected status %d returned for command %s", reply->status,
+ command.toString().c_str());
return INVALID_OPERATION;
}
}
@@ -708,10 +711,10 @@
if (!mStream) return NO_INIT;
AudioParameter parameters(kvPairs);
- ALOGD("%s: parameters: \"%s\"", __func__, parameters.toString().c_str());
+ AUGMENT_LOG(D, "parameters: \"%s\"", parameters.toString().c_str());
if (status_t status = filterAndUpdateOffloadMetadata(parameters); status != OK) {
- ALOGW("%s: filtering or updating offload metadata failed: %d", __func__, status);
+ AUGMENT_LOG(W, "filtering or updating offload metadata failed: %d", status);
}
return StreamHalAidl::setParameters(parameters.toString());
@@ -722,6 +725,7 @@
}
status_t StreamOutHalAidl::setVolume(float left, float right) {
+ AUGMENT_LOG(V, "left %f right %f", left, right);
TIME_CHECK();
if (!mStream) return NO_INIT;
size_t channelCount = audio_channel_count_from_out_mask(mConfig.channel_mask);
@@ -775,11 +779,11 @@
}
status_t StreamOutHalAidl::setCallback(wp<StreamOutHalInterfaceCallback> callback) {
- ALOGD("%p %s", this, __func__);
+ LOG_ENTRY();
TIME_CHECK();
if (!mStream) return NO_INIT;
if (!mContext.isAsynchronous()) {
- ALOGE("%s: the callback is intended for asynchronous streams only", __func__);
+ AUGMENT_LOG(E, "the callback is intended for asynchronous streams only");
return INVALID_OPERATION;
}
mClientCallback = callback;
@@ -818,7 +822,7 @@
if (!mStream) return NO_INIT;
if (const auto state = getState(); isInDrainedState(state)) {
- ALOGD("%p %s stream already in %s", this, __func__, toString(state).c_str());
+ AUGMENT_LOG(D, "stream already in %s state", toString(state).c_str());
if (mContext.isAsynchronous()) onDrainReady();
return OK;
}
@@ -851,7 +855,7 @@
}
status_t StreamOutHalAidl::presentationComplete() {
- ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
+ LOG_ENTRY();
return OK;
}
@@ -1042,10 +1046,10 @@
updateMetadata = true;
}
if (updateMetadata) {
- ALOGD("%s set offload metadata %s", __func__, mOffloadMetadata.toString().c_str());
+ AUGMENT_LOG(D, "set offload metadata %s", mOffloadMetadata.toString().c_str());
if (status_t status = statusTFromBinderStatus(
mStream->updateOffloadMetadata(mOffloadMetadata)); status != OK) {
- ALOGE("%s: updateOffloadMetadata failed %d", __func__, status);
+ AUGMENT_LOG(E, "updateOffloadMetadata failed %d", status);
return status;
}
}
@@ -1132,7 +1136,7 @@
// Note: info.portId is not filled because it's a bit of framework info.
result.push_back(std::move(info));
} else {
- ALOGE("%s: no static info for active microphone with id '%s'", __func__, d.id.c_str());
+ AUGMENT_LOG(E, "no static info for active microphone with id '%s'", d.id.c_str());
}
}
*microphones = std::move(result);
diff --git a/media/libaudiohal/impl/StreamHalAidl.h b/media/libaudiohal/impl/StreamHalAidl.h
index baf4ac0..a1cdac4 100644
--- a/media/libaudiohal/impl/StreamHalAidl.h
+++ b/media/libaudiohal/impl/StreamHalAidl.h
@@ -53,7 +53,7 @@
StreamContextAidl(
::aidl::android::hardware::audio::core::StreamDescriptor& descriptor,
- bool isAsynchronous)
+ bool isAsynchronous, int ioHandle)
: mFrameSizeBytes(descriptor.frameSizeBytes),
mCommandMQ(new CommandMQ(descriptor.command)),
mReplyMQ(new ReplyMQ(descriptor.reply)),
@@ -61,7 +61,8 @@
mDataMQ(maybeCreateDataMQ(descriptor)),
mIsAsynchronous(isAsynchronous),
mIsMmapped(isMmapped(descriptor)),
- mMmapBufferDescriptor(maybeGetMmapBuffer(descriptor)) {}
+ mMmapBufferDescriptor(maybeGetMmapBuffer(descriptor)),
+ mIoHandle(ioHandle) {}
StreamContextAidl(StreamContextAidl&& other) :
mFrameSizeBytes(other.mFrameSizeBytes),
mCommandMQ(std::move(other.mCommandMQ)),
@@ -70,7 +71,8 @@
mDataMQ(std::move(other.mDataMQ)),
mIsAsynchronous(other.mIsAsynchronous),
mIsMmapped(other.mIsMmapped),
- mMmapBufferDescriptor(std::move(other.mMmapBufferDescriptor)) {}
+ mMmapBufferDescriptor(std::move(other.mMmapBufferDescriptor)),
+ mIoHandle(other.mIoHandle) {}
StreamContextAidl& operator=(StreamContextAidl&& other) {
mFrameSizeBytes = other.mFrameSizeBytes;
mCommandMQ = std::move(other.mCommandMQ);
@@ -80,6 +82,7 @@
mIsAsynchronous = other.mIsAsynchronous;
mIsMmapped = other.mIsMmapped;
mMmapBufferDescriptor = std::move(other.mMmapBufferDescriptor);
+ mIoHandle = other.mIoHandle;
return *this;
}
bool isValid() const {
@@ -105,7 +108,9 @@
bool isAsynchronous() const { return mIsAsynchronous; }
bool isMmapped() const { return mIsMmapped; }
const MmapBufferDescriptor& getMmapBufferDescriptor() const { return mMmapBufferDescriptor; }
- size_t getMmapBurstSize() const { return mMmapBufferDescriptor.burstSizeFrames;}
+ size_t getMmapBurstSize() const { return mMmapBufferDescriptor.burstSizeFrames; }
+ int getIoHandle() const { return mIoHandle; }
+
private:
static std::unique_ptr<DataMQ> maybeCreateDataMQ(
const ::aidl::android::hardware::audio::core::StreamDescriptor& descriptor) {
@@ -137,6 +142,7 @@
bool mIsAsynchronous;
bool mIsMmapped;
MmapBufferDescriptor mMmapBufferDescriptor;
+ int mIoHandle;
};
class StreamHalAidl : public virtual StreamHalInterface, public ConversionHelperAidl {
diff --git a/media/libaudiohal/include/media/audiohal/DeviceHalInterface.h b/media/libaudiohal/include/media/audiohal/DeviceHalInterface.h
index 7f6c1fb..3f16526 100644
--- a/media/libaudiohal/include/media/audiohal/DeviceHalInterface.h
+++ b/media/libaudiohal/include/media/audiohal/DeviceHalInterface.h
@@ -90,7 +90,8 @@
audio_output_flags_t flags,
struct audio_config *config,
const char *address,
- sp<StreamOutHalInterface> *outStream) = 0;
+ sp<StreamOutHalInterface> *outStream,
+ const std::vector<playback_track_metadata_v7_t>& sourceMetadata = {}) = 0;
// Creates and opens the audio hardware input stream. The stream is closed
// by releasing all references to the returned object.
diff --git a/media/libaudiohal/tests/CoreAudioHalAidl_test.cpp b/media/libaudiohal/tests/CoreAudioHalAidl_test.cpp
index dbd1f60..0f5334f 100644
--- a/media/libaudiohal/tests/CoreAudioHalAidl_test.cpp
+++ b/media/libaudiohal/tests/CoreAudioHalAidl_test.cpp
@@ -988,9 +988,9 @@
mVendorExt = ndk::SharedRefBase::make<TestHalAdapterVendorExtension>();
struct audio_config config = AUDIO_CONFIG_INITIALIZER;
::aidl::android::hardware::audio::core::StreamDescriptor descriptor;
+ StreamContextAidl context(descriptor, false /*isAsynchronous*/, 0);
mStream = sp<StreamHalAidl>::make("test", false /*isInput*/, config, 0 /*nominalLatency*/,
- StreamContextAidl(descriptor, false /*isAsynchronous*/),
- mStreamCommon, mVendorExt);
+ std::move(context), mStreamCommon, mVendorExt);
}
void TearDown() override {
mStream.clear();
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index 3b71758..ca4c294 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -2923,7 +2923,8 @@
audio_config_base_t *mixerConfig,
audio_devices_t deviceType,
const String8& address,
- audio_output_flags_t flags)
+ audio_output_flags_t flags,
+ const audio_attributes_t attributes)
{
AudioHwDevice *outHwDev = findSuitableHwDev_l(module, deviceType);
if (outHwDev == NULL) {
@@ -2941,13 +2942,18 @@
mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;
AudioStreamOut *outputStream = NULL;
+
+ playback_track_metadata_v7_t trackMetadata;
+ trackMetadata.base.usage = attributes.usage;
+
status_t status = outHwDev->openOutputStream(
&outputStream,
*output,
deviceType,
flags,
halConfig,
- address.c_str());
+ address.c_str(),
+ {trackMetadata});
mHardwareStatus = AUDIO_HW_IDLE;
@@ -3016,6 +3022,8 @@
aidl2legacy_DeviceDescriptorBase(request.device));
audio_output_flags_t flags = VALUE_OR_RETURN_STATUS(
aidl2legacy_int32_t_audio_output_flags_t_mask(request.flags));
+ audio_attributes_t attributes = VALUE_OR_RETURN_STATUS(
+ aidl2legacy_AudioAttributes_audio_attributes_t(request.attributes));
audio_io_handle_t output;
@@ -3038,7 +3046,7 @@
audio_utils::lock_guard _l(mutex());
const sp<IAfThreadBase> thread = openOutput_l(module, &output, &halConfig,
- &mixerConfig, deviceType, address, flags);
+ &mixerConfig, deviceType, address, flags, attributes);
if (thread != 0) {
uint32_t latencyMs = 0;
if ((flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) == 0) {
diff --git a/services/audioflinger/AudioFlinger.h b/services/audioflinger/AudioFlinger.h
index f61fdce..f5ec5f8 100644
--- a/services/audioflinger/AudioFlinger.h
+++ b/services/audioflinger/AudioFlinger.h
@@ -332,7 +332,8 @@
audio_config_base_t* mixerConfig,
audio_devices_t deviceType,
const String8& address,
- audio_output_flags_t flags) final REQUIRES(mutex());
+ audio_output_flags_t flags,
+ audio_attributes_t attributes) final REQUIRES(mutex());
const DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*>&
getAudioHwDevs_l() const final REQUIRES(mutex(), hardwareMutex()) {
return mAudioHwDevs;
diff --git a/services/audioflinger/IAfPatchPanel.h b/services/audioflinger/IAfPatchPanel.h
index 6110e4c..37dce3a 100644
--- a/services/audioflinger/IAfPatchPanel.h
+++ b/services/audioflinger/IAfPatchPanel.h
@@ -82,7 +82,8 @@
audio_config_base_t* mixerConfig,
audio_devices_t deviceType,
const String8& address,
- audio_output_flags_t flags) REQUIRES(mutex()) = 0;
+ audio_output_flags_t flags,
+ audio_attributes_t attributes) REQUIRES(mutex()) = 0;
virtual audio_utils::mutex& mutex() const
RETURN_CAPABILITY(audio_utils::AudioFlinger_Mutex) = 0;
virtual const DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*>&
diff --git a/services/audioflinger/PatchPanel.cpp b/services/audioflinger/PatchPanel.cpp
index f57470f..35f17c1 100644
--- a/services/audioflinger/PatchPanel.cpp
+++ b/services/audioflinger/PatchPanel.cpp
@@ -260,6 +260,7 @@
if (patch->sinks[0].config_mask & AUDIO_PORT_CONFIG_FLAGS) {
flags = patch->sinks[0].flags.output;
}
+ audio_attributes_t attributes = AUDIO_ATTRIBUTES_INITIALIZER;
const sp<IAfThreadBase> thread = mAfPatchPanelCallback->openOutput_l(
patch->sinks[0].ext.device.hw_module,
&output,
@@ -267,7 +268,8 @@
&mixerConfig,
outputDevice,
outputDeviceAddress,
- flags);
+ flags,
+ attributes);
ALOGV("mAfPatchPanelCallback->openOutput_l() returned %p", thread.get());
if (thread == 0) {
status = NO_MEMORY;
diff --git a/services/audioflinger/datapath/AudioHwDevice.cpp b/services/audioflinger/datapath/AudioHwDevice.cpp
index 95e9ecc..5314e9e 100644
--- a/services/audioflinger/datapath/AudioHwDevice.cpp
+++ b/services/audioflinger/datapath/AudioHwDevice.cpp
@@ -43,7 +43,8 @@
audio_devices_t deviceType,
audio_output_flags_t flags,
struct audio_config *config,
- const char *address)
+ const char *address,
+ const std::vector<playback_track_metadata_v7_t>& sourceMetadata)
{
struct audio_config originalConfig = *config;
@@ -52,7 +53,7 @@
// Try to open the HAL first using the current format.
ALOGV("openOutputStream(), try sampleRate %d, format %#x, channelMask %#x", config->sample_rate,
config->format, config->channel_mask);
- status_t status = outputStream->open(handle, deviceType, config, address);
+ status_t status = outputStream->open(handle, deviceType, config, address, sourceMetadata);
if (status != NO_ERROR) {
delete outputStream;
@@ -72,7 +73,8 @@
if (wrapperNeeded) {
if (SPDIFEncoder::isFormatSupported(originalConfig.format)) {
outputStream = new SpdifStreamOut(this, flags, originalConfig.format);
- status = outputStream->open(handle, deviceType, &originalConfig, address);
+ status = outputStream->open(handle, deviceType, &originalConfig, address,
+ sourceMetadata);
if (status != NO_ERROR) {
ALOGE("ERROR - openOutputStream(), SPDIF open returned %d",
status);
diff --git a/services/audioflinger/datapath/AudioHwDevice.h b/services/audioflinger/datapath/AudioHwDevice.h
index 80c1473..e1a9018 100644
--- a/services/audioflinger/datapath/AudioHwDevice.h
+++ b/services/audioflinger/datapath/AudioHwDevice.h
@@ -87,7 +87,8 @@
audio_devices_t deviceType,
audio_output_flags_t flags,
struct audio_config *config,
- const char *address);
+ const char *address,
+ const std::vector<playback_track_metadata_v7_t>& sourceMetadata);
status_t openInputStream(
AudioStreamIn **ppStreamIn,
diff --git a/services/audioflinger/datapath/AudioStreamOut.cpp b/services/audioflinger/datapath/AudioStreamOut.cpp
index a686ff6..c65373e 100644
--- a/services/audioflinger/datapath/AudioStreamOut.cpp
+++ b/services/audioflinger/datapath/AudioStreamOut.cpp
@@ -93,7 +93,8 @@
audio_io_handle_t handle,
audio_devices_t deviceType,
struct audio_config *config,
- const char *address)
+ const char *address,
+ const std::vector<playback_track_metadata_v7_t>& sourceMetadata)
{
sp<StreamOutHalInterface> outStream;
@@ -107,7 +108,8 @@
customFlags,
config,
address,
- &outStream);
+ &outStream,
+ sourceMetadata);
ALOGV("AudioStreamOut::open(), HAL returned stream %p, sampleRate %d, format %#x,"
" channelMask %#x, status %d", outStream.get(), config->sample_rate, config->format,
config->channel_mask, status);
@@ -124,7 +126,8 @@
customFlags,
&customConfig,
address,
- &outStream);
+ &outStream,
+ sourceMetadata);
ALOGV("AudioStreamOut::open(), treat IEC61937 as PCM, status = %d", status);
}
diff --git a/services/audioflinger/datapath/AudioStreamOut.h b/services/audioflinger/datapath/AudioStreamOut.h
index 2c9fb3e..2bf94a1 100644
--- a/services/audioflinger/datapath/AudioStreamOut.h
+++ b/services/audioflinger/datapath/AudioStreamOut.h
@@ -47,7 +47,8 @@
audio_io_handle_t handle,
audio_devices_t deviceType,
struct audio_config *config,
- const char *address);
+ const char *address,
+ const std::vector<playback_track_metadata_v7_t>& sourceMetadata);
virtual ~AudioStreamOut();
diff --git a/services/audioflinger/datapath/SpdifStreamOut.cpp b/services/audioflinger/datapath/SpdifStreamOut.cpp
index 65a4eec..d3983b0 100644
--- a/services/audioflinger/datapath/SpdifStreamOut.cpp
+++ b/services/audioflinger/datapath/SpdifStreamOut.cpp
@@ -45,7 +45,8 @@
audio_io_handle_t handle,
audio_devices_t devices,
struct audio_config *config,
- const char *address)
+ const char *address,
+ const std::vector<playback_track_metadata_v7_t>& sourceMetadata)
{
struct audio_config customConfig = *config;
@@ -75,7 +76,8 @@
handle,
devices,
&customConfig,
- address);
+ address,
+ sourceMetadata);
ALOGI("SpdifStreamOut::open() status = %d", status);
diff --git a/services/audioflinger/datapath/SpdifStreamOut.h b/services/audioflinger/datapath/SpdifStreamOut.h
index c6d27ba..1cd8f65 100644
--- a/services/audioflinger/datapath/SpdifStreamOut.h
+++ b/services/audioflinger/datapath/SpdifStreamOut.h
@@ -43,7 +43,8 @@
audio_io_handle_t handle,
audio_devices_t devices,
struct audio_config *config,
- const char *address) override;
+ const char *address,
+ const std::vector<playback_track_metadata_v7_t>& sourceMetadata) override;
/**
* Write audio buffer to driver. Returns number of bytes written, or a
diff --git a/services/audiopolicy/AudioPolicyInterface.h b/services/audiopolicy/AudioPolicyInterface.h
index bfc3132..3dfda03 100644
--- a/services/audiopolicy/AudioPolicyInterface.h
+++ b/services/audiopolicy/AudioPolicyInterface.h
@@ -470,7 +470,8 @@
audio_config_base_t *mixerConfig,
const sp<DeviceDescriptorBase>& device,
uint32_t *latencyMs,
- audio_output_flags_t flags) = 0;
+ audio_output_flags_t flags,
+ audio_attributes_t audioAttributes) = 0;
// creates a special output that is duplicated to the two outputs passed as arguments.
// The duplication is performed by a special mixer thread in the AudioFlinger.
virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
diff --git a/services/audiopolicy/common/managerdefinitions/include/AudioOutputDescriptor.h b/services/audiopolicy/common/managerdefinitions/include/AudioOutputDescriptor.h
index 00958aa..ab2a350 100644
--- a/services/audiopolicy/common/managerdefinitions/include/AudioOutputDescriptor.h
+++ b/services/audiopolicy/common/managerdefinitions/include/AudioOutputDescriptor.h
@@ -412,7 +412,8 @@
const DeviceVector &devices,
audio_stream_type_t stream,
audio_output_flags_t flags,
- audio_io_handle_t *output);
+ audio_io_handle_t *output,
+ audio_attributes_t attributes);
// Called when a stream is about to be started
// Note: called before setClientActive(true);
diff --git a/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp b/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp
index acd0ff5..9286268 100644
--- a/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp
@@ -588,7 +588,8 @@
const DeviceVector &devices,
audio_stream_type_t stream,
audio_output_flags_t flags,
- audio_io_handle_t *output)
+ audio_io_handle_t *output,
+ audio_attributes_t attributes)
{
mDevices = devices;
sp<DeviceDescriptor> device = devices.getDeviceForOpening();
@@ -652,7 +653,8 @@
&lMixerConfig,
device,
&mLatency,
- mFlags);
+ mFlags,
+ attributes);
if (status == NO_ERROR) {
LOG_ALWAYS_FATAL_IF(*output == AUDIO_IO_HANDLE_NONE,
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
index b7201f2..5907aac 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
@@ -1258,7 +1258,7 @@
status = openDirectOutput(
*stream, session, config,
(audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_DIRECT),
- DeviceVector(policyMixDevice), &newOutput);
+ DeviceVector(policyMixDevice), &newOutput, *resultAttr);
if (status == NO_ERROR) {
policyDesc = mOutputs.valueFor(newOutput);
primaryMix->setOutput(policyDesc);
@@ -1479,7 +1479,8 @@
const audio_config_t *config,
audio_output_flags_t flags,
const DeviceVector &devices,
- audio_io_handle_t *output) {
+ audio_io_handle_t *output,
+ audio_attributes_t attributes) {
*output = AUDIO_IO_HANDLE_NONE;
@@ -1567,7 +1568,8 @@
releaseMsdOutputPatches(devices);
status_t status =
- outputDesc->open(config, nullptr /* mixerConfig */, devices, stream, flags, output);
+ outputDesc->open(config, nullptr /* mixerConfig */, devices, stream, flags, output,
+ attributes);
// only accept an output with the requested parameters
if (status != NO_ERROR ||
@@ -1668,7 +1670,9 @@
audio_config_t directConfig = *config;
directConfig.channel_mask = channelMask;
- status_t status = openDirectOutput(stream, session, &directConfig, *flags, devices, &output);
+
+ status_t status = openDirectOutput(stream, session, &directConfig, *flags, devices, &output,
+ *attr);
if (status != NAME_NOT_FOUND) {
return output;
}
@@ -6447,10 +6451,11 @@
sp<SwAudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(outProfile,
mpClientInterface);
audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
+ audio_attributes_t attributes = AUDIO_ATTRIBUTES_INITIALIZER;
status_t status = outputDesc->open(nullptr /* halConfig */, nullptr /* mixerConfig */,
DeviceVector(supportedDevice),
AUDIO_STREAM_DEFAULT,
- AUDIO_OUTPUT_FLAG_NONE, &output);
+ AUDIO_OUTPUT_FLAG_NONE, &output, attributes);
if (status != NO_ERROR) {
ALOGW("Cannot open output stream for devices %s on hw module %s",
supportedDevice->toString().c_str(), hwModule->getName());
@@ -8599,8 +8604,9 @@
}
sp<SwAudioOutputDescriptor> desc = new SwAudioOutputDescriptor(profile, mpClientInterface);
audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
+ audio_attributes_t attributes = AUDIO_ATTRIBUTES_INITIALIZER;
status_t status = desc->open(halConfig, mixerConfig, devices,
- AUDIO_STREAM_DEFAULT, flags, &output);
+ AUDIO_STREAM_DEFAULT, flags, &output, attributes);
if (status != NO_ERROR) {
ALOGE("%s failed to open output %d", __func__, status);
return nullptr;
@@ -8638,7 +8644,8 @@
config.offload_info.channel_mask = config.channel_mask;
config.offload_info.format = config.format;
- status = desc->open(&config, mixerConfig, devices, AUDIO_STREAM_DEFAULT, flags, &output);
+ status = desc->open(&config, mixerConfig, devices, AUDIO_STREAM_DEFAULT, flags, &output,
+ attributes);
if (status != NO_ERROR) {
return nullptr;
}
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.h b/services/audiopolicy/managerdefault/AudioPolicyManager.h
index c8cced6..5801846 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.h
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.h
@@ -1124,7 +1124,8 @@
const audio_config_t *config,
audio_output_flags_t flags,
const DeviceVector &devices,
- audio_io_handle_t *output);
+ audio_io_handle_t *output,
+ audio_attributes_t attributes);
/**
* @brief Queries if some kind of spatialization will be performed if the audio playback
diff --git a/services/audiopolicy/service/AudioPolicyClientImpl.cpp b/services/audiopolicy/service/AudioPolicyClientImpl.cpp
index 6de71a3..f1d7af8 100644
--- a/services/audiopolicy/service/AudioPolicyClientImpl.cpp
+++ b/services/audiopolicy/service/AudioPolicyClientImpl.cpp
@@ -56,7 +56,8 @@
audio_config_base_t *mixerConfig,
const sp<DeviceDescriptorBase>& device,
uint32_t *latencyMs,
- audio_output_flags_t flags)
+ audio_output_flags_t flags,
+ audio_attributes_t attributes)
{
sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
if (af == 0) {
@@ -74,6 +75,8 @@
legacy2aidl_audio_config_base_t_AudioConfigBase(*mixerConfig, false /*isInput*/));
request.device = VALUE_OR_RETURN_STATUS(legacy2aidl_DeviceDescriptorBase(device));
request.flags = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
+ request.attributes = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_attributes_t_AudioAttributes(attributes));
status_t status = af->openOutput(request, &response);
if (status == OK) {
diff --git a/services/audiopolicy/service/AudioPolicyService.h b/services/audiopolicy/service/AudioPolicyService.h
index 7aa80cf..da09e5f 100644
--- a/services/audiopolicy/service/AudioPolicyService.h
+++ b/services/audiopolicy/service/AudioPolicyService.h
@@ -778,7 +778,8 @@
audio_config_base_t *mixerConfig,
const sp<DeviceDescriptorBase>& device,
uint32_t *latencyMs,
- audio_output_flags_t flags);
+ audio_output_flags_t flags,
+ audio_attributes_t attributes);
// creates a special output that is duplicated to the two outputs passed as arguments. The duplication is performed by
// a special mixer thread in the AudioFlinger.
virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, audio_io_handle_t output2);
diff --git a/services/audiopolicy/tests/AudioPolicyManagerTestClient.h b/services/audiopolicy/tests/AudioPolicyManagerTestClient.h
index 072d9c0..6382c71 100644
--- a/services/audiopolicy/tests/AudioPolicyManagerTestClient.h
+++ b/services/audiopolicy/tests/AudioPolicyManagerTestClient.h
@@ -41,7 +41,8 @@
audio_config_base_t * /*mixerConfig*/,
const sp<DeviceDescriptorBase>& /*device*/,
uint32_t * /*latencyMs*/,
- audio_output_flags_t /*flags*/) override {
+ audio_output_flags_t /*flags*/,
+ audio_attributes_t /*attributes*/) override {
if (module >= mNextModuleHandle) {
ALOGE("%s: Module handle %d has not been allocated yet (next is %d)",
__func__, module, mNextModuleHandle);
diff --git a/services/audiopolicy/tests/AudioPolicyTestClient.h b/services/audiopolicy/tests/AudioPolicyTestClient.h
index e55e935..6aa347e 100644
--- a/services/audiopolicy/tests/AudioPolicyTestClient.h
+++ b/services/audiopolicy/tests/AudioPolicyTestClient.h
@@ -37,7 +37,8 @@
audio_config_base_t* /*mixerConfig*/,
const sp<DeviceDescriptorBase>& /*device*/,
uint32_t* /*latencyMs*/,
- audio_output_flags_t /*flags*/) override { return NO_INIT; }
+ audio_output_flags_t /*flags*/,
+ audio_attributes_t /*attributes*/) override { return NO_INIT; }
audio_io_handle_t openDuplicateOutput(audio_io_handle_t /*output1*/,
audio_io_handle_t /*output2*/) override {
return AUDIO_IO_HANDLE_NONE;
diff --git a/services/audiopolicy/tests/audiopolicymanager_tests.cpp b/services/audiopolicy/tests/audiopolicymanager_tests.cpp
index b93f7e2..3765a8f 100644
--- a/services/audiopolicy/tests/audiopolicymanager_tests.cpp
+++ b/services/audiopolicy/tests/audiopolicymanager_tests.cpp
@@ -2628,10 +2628,12 @@
audio_config_base_t * mixerConfig,
const sp<DeviceDescriptorBase>& device,
uint32_t * latencyMs,
- audio_output_flags_t flags) override {
+ audio_output_flags_t flags,
+ audio_attributes_t attributes) override {
return mSimulateFailure ? BAD_VALUE :
AudioPolicyManagerTestClient::openOutput(
- module, output, halConfig, mixerConfig, device, latencyMs, flags);
+ module, output, halConfig, mixerConfig, device, latencyMs, flags,
+ attributes);
}
status_t openInput(audio_module_handle_t module,