Merge "Re-enable LTO for libcodec2_hidl_client" into main
diff --git a/include/media/OWNERS b/include/media/OWNERS
new file mode 100644
index 0000000..b1cfd52
--- /dev/null
+++ b/include/media/OWNERS
@@ -0,0 +1,2 @@
+per-file DataSource.h,ExtractorUtils.h,MediaExtractorPluginApi.h,MediaExtractorPluginHelper.h,MediaPlayerInterface.h,MediaTrack.h=set noparent
+per-file DataSource.h,ExtractorUtils.h,MediaExtractorPluginApi.h,MediaExtractorPluginHelper.h,MediaPlayerInterface.h,MediaTrack.h=file:platform/frameworks/av:/media/janitors/media_solutions_OWNERS
diff --git a/media/audioserver/main_audioserver.cpp b/media/audioserver/main_audioserver.cpp
index 1e3bfe0..c7a1bfd 100644
--- a/media/audioserver/main_audioserver.cpp
+++ b/media/audioserver/main_audioserver.cpp
@@ -184,7 +184,7 @@
// attempting to call audio flinger on a null pointer could make the process crash
// and attract attentions.
std::vector<AudioMMapPolicyInfo> policyInfos;
- status_t status = af->getMmapPolicyInfos(
+ status_t status = sp<IAudioFlinger>::cast(af)->getMmapPolicyInfos(
AudioMMapPolicyType::DEFAULT, &policyInfos);
// Initialize aaudio service when querying mmap policy succeeds and
// any of the policy supports MMAP.
diff --git a/media/janitors/media_solutions_OWNERS b/media/janitors/media_solutions_OWNERS
index e0c87f7..17bc7dd 100644
--- a/media/janitors/media_solutions_OWNERS
+++ b/media/janitors/media_solutions_OWNERS
@@ -15,6 +15,7 @@
bachinger@google.com
christosts@google.com
ibaker@google.com
+jbibik@google.com
michaelkatz@google.com
rohks@google.com
tianyifeng@google.com
diff --git a/media/libaudioclient/IAudioFlinger.cpp b/media/libaudioclient/IAudioFlinger.cpp
index 7caaaaf..4bd12b8 100644
--- a/media/libaudioclient/IAudioFlinger.cpp
+++ b/media/libaudioclient/IAudioFlinger.cpp
@@ -646,7 +646,7 @@
return result.value_or(0);
}
-uint32_t AudioFlingerClientAdapter::getPrimaryOutputSamplingRate() {
+uint32_t AudioFlingerClientAdapter::getPrimaryOutputSamplingRate() const {
auto result = [&]() -> ConversionResult<uint32_t> {
int32_t aidlRet;
RETURN_IF_ERROR(statusTFromBinderStatus(
@@ -657,7 +657,7 @@
return result.value_or(0);
}
-size_t AudioFlingerClientAdapter::getPrimaryOutputFrameCount() {
+size_t AudioFlingerClientAdapter::getPrimaryOutputFrameCount() const {
auto result = [&]() -> ConversionResult<size_t> {
int64_t aidlRet;
RETURN_IF_ERROR(statusTFromBinderStatus(
@@ -672,7 +672,7 @@
return statusTFromBinderStatus(mDelegate->setLowRamDevice(isLowRamDevice, totalMemory));
}
-status_t AudioFlingerClientAdapter::getAudioPort(struct audio_port_v7* port) {
+status_t AudioFlingerClientAdapter::getAudioPort(struct audio_port_v7* port) const {
media::AudioPortFw portAidl = VALUE_OR_RETURN_STATUS(
legacy2aidl_audio_port_v7_AudioPortFw(*port));
media::AudioPortFw aidlRet;
@@ -705,7 +705,7 @@
}
status_t AudioFlingerClientAdapter::listAudioPatches(unsigned int* num_patches,
- struct audio_patch* patches) {
+ struct audio_patch* patches) const {
std::vector<media::AudioPatchFw> aidlRet;
int32_t maxPatches = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*num_patches));
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
@@ -753,7 +753,8 @@
}
status_t
-AudioFlingerClientAdapter::getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) {
+AudioFlingerClientAdapter::getMicrophones(
+ std::vector<media::MicrophoneInfoFw>* microphones) const {
std::vector<media::MicrophoneInfoFw> aidlRet;
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mDelegate->getMicrophones(&aidlRet)));
if (microphones != nullptr) {
@@ -788,7 +789,7 @@
return statusTFromBinderStatus(mDelegate->getMmapPolicyInfos(policyType, policyInfos));
}
-int32_t AudioFlingerClientAdapter::getAAudioMixerBurstCount() {
+int32_t AudioFlingerClientAdapter::getAAudioMixerBurstCount() const {
auto result = [&]() -> ConversionResult<int32_t> {
int32_t aidlRet;
RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->getAAudioMixerBurstCount(&aidlRet)));
@@ -798,7 +799,7 @@
return result.value_or(0);
}
-int32_t AudioFlingerClientAdapter::getAAudioHardwareBurstMinUsec() {
+int32_t AudioFlingerClientAdapter::getAAudioHardwareBurstMinUsec() const {
auto result = [&]() -> ConversionResult<int32_t> {
int32_t aidlRet;
RETURN_IF_ERROR(statusTFromBinderStatus(
@@ -829,7 +830,7 @@
}
status_t AudioFlingerClientAdapter::getSupportedLatencyModes(
- audio_io_handle_t output, std::vector<audio_latency_mode_t>* modes) {
+ audio_io_handle_t output, std::vector<audio_latency_mode_t>* modes) const {
if (modes == nullptr) {
return BAD_VALUE;
}
@@ -851,7 +852,7 @@
return statusTFromBinderStatus(mDelegate->setBluetoothVariableLatencyEnabled(enabled));
}
-status_t AudioFlingerClientAdapter::isBluetoothVariableLatencyEnabled(bool* enabled) {
+status_t AudioFlingerClientAdapter::isBluetoothVariableLatencyEnabled(bool* enabled) const {
if (enabled == nullptr) {
return BAD_VALUE;
}
@@ -862,7 +863,7 @@
return NO_ERROR;
}
-status_t AudioFlingerClientAdapter::supportsBluetoothVariableLatency(bool* support) {
+status_t AudioFlingerClientAdapter::supportsBluetoothVariableLatency(bool* support) const {
if (support == nullptr) {
return BAD_VALUE;
}
@@ -875,7 +876,7 @@
status_t AudioFlingerClientAdapter::getSoundDoseInterface(
const sp<media::ISoundDoseCallback> &callback,
- sp<media::ISoundDose>* soundDose) {
+ sp<media::ISoundDose>* soundDose) const {
return statusTFromBinderStatus(mDelegate->getSoundDoseInterface(callback, soundDose));
}
diff --git a/media/libaudioclient/include/media/IAudioFlinger.h b/media/libaudioclient/include/media/IAudioFlinger.h
index 2e2ef65..3c96862 100644
--- a/media/libaudioclient/include/media/IAudioFlinger.h
+++ b/media/libaudioclient/include/media/IAudioFlinger.h
@@ -303,8 +303,8 @@
// helpers for android.media.AudioManager.getProperty(), see description there for meaning
// FIXME move these APIs to AudioPolicy to permit a more accurate implementation
// that looks on primary device for a stream with fast flag, primary flag, or first one.
- virtual uint32_t getPrimaryOutputSamplingRate() = 0;
- virtual size_t getPrimaryOutputFrameCount() = 0;
+ virtual uint32_t getPrimaryOutputSamplingRate() const = 0;
+ virtual size_t getPrimaryOutputFrameCount() const = 0;
// Intended for AudioService to inform AudioFlinger of device's low RAM attribute,
// and should be called at most once. For a definition of what "low RAM" means, see
@@ -313,7 +313,7 @@
virtual status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) = 0;
/* Get attributes for a given audio port */
- virtual status_t getAudioPort(struct audio_port_v7 *port) = 0;
+ virtual status_t getAudioPort(struct audio_port_v7* port) const = 0;
/* Create an audio patch between several source and sink ports */
virtual status_t createAudioPatch(const struct audio_patch *patch,
@@ -324,7 +324,7 @@
/* List existing audio patches */
virtual status_t listAudioPatches(unsigned int *num_patches,
- struct audio_patch *patches) = 0;
+ struct audio_patch* patches) const = 0;
/* Set audio port configuration */
virtual status_t setAudioPortConfig(const struct audio_port_config *config) = 0;
@@ -341,7 +341,7 @@
virtual size_t frameCountHAL(audio_io_handle_t ioHandle) const = 0;
/* List available microphones and their characteristics */
- virtual status_t getMicrophones(std::vector<media::MicrophoneInfoFw> *microphones) = 0;
+ virtual status_t getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) const = 0;
virtual status_t setAudioHalPids(const std::vector<pid_t>& pids) = 0;
@@ -357,9 +357,9 @@
media::audio::common::AudioMMapPolicyType policyType,
std::vector<media::audio::common::AudioMMapPolicyInfo> *policyInfos) = 0;
- virtual int32_t getAAudioMixerBurstCount() = 0;
+ virtual int32_t getAAudioMixerBurstCount() const = 0;
- virtual int32_t getAAudioHardwareBurstMinUsec() = 0;
+ virtual int32_t getAAudioHardwareBurstMinUsec() const = 0;
virtual status_t setDeviceConnectedState(const struct audio_port_v7 *port,
media::DeviceConnectedState state) = 0;
@@ -370,18 +370,18 @@
audio_io_handle_t output, audio_latency_mode_t mode) = 0;
virtual status_t getSupportedLatencyModes(audio_io_handle_t output,
- std::vector<audio_latency_mode_t>* modes) = 0;
+ std::vector<audio_latency_mode_t>* modes) const = 0;
virtual status_t getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback,
- sp<media::ISoundDose>* soundDose) = 0;
+ sp<media::ISoundDose>* soundDose) const = 0;
virtual status_t invalidateTracks(const std::vector<audio_port_handle_t>& portIds) = 0;
virtual status_t setBluetoothVariableLatencyEnabled(bool enabled) = 0;
- virtual status_t isBluetoothVariableLatencyEnabled(bool* enabled) = 0;
+ virtual status_t isBluetoothVariableLatencyEnabled(bool* enabled) const = 0;
- virtual status_t supportsBluetoothVariableLatency(bool* support) = 0;
+ virtual status_t supportsBluetoothVariableLatency(bool* support) const = 0;
virtual status_t getAudioPolicyConfig(media::AudioPolicyConfig* output) = 0;
};
@@ -459,22 +459,22 @@
audio_session_t sessionId,
bool suspended) override;
audio_module_handle_t loadHwModule(const char* name) override;
- uint32_t getPrimaryOutputSamplingRate() override;
- size_t getPrimaryOutputFrameCount() override;
+ uint32_t getPrimaryOutputSamplingRate() const override;
+ size_t getPrimaryOutputFrameCount() const override;
status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) override;
- status_t getAudioPort(struct audio_port_v7* port) override;
+ status_t getAudioPort(struct audio_port_v7* port) const override;
status_t createAudioPatch(const struct audio_patch* patch,
audio_patch_handle_t* handle) override;
status_t releaseAudioPatch(audio_patch_handle_t handle) override;
status_t listAudioPatches(unsigned int* num_patches,
- struct audio_patch* patches) override;
+ struct audio_patch* patches) const override;
status_t setAudioPortConfig(const struct audio_port_config* config) override;
audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId) override;
status_t systemReady() override;
status_t audioPolicyReady() override;
size_t frameCountHAL(audio_io_handle_t ioHandle) const override;
- status_t getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) override;
+ status_t getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) const override;
status_t setAudioHalPids(const std::vector<pid_t>& pids) override;
status_t setVibratorInfos(const std::vector<media::AudioVibratorInfo>& vibratorInfos) override;
status_t updateSecondaryOutputs(
@@ -482,20 +482,20 @@
status_t getMmapPolicyInfos(
media::audio::common::AudioMMapPolicyType policyType,
std::vector<media::audio::common::AudioMMapPolicyInfo> *policyInfos) override;
- int32_t getAAudioMixerBurstCount() override;
- int32_t getAAudioHardwareBurstMinUsec() override;
+ int32_t getAAudioMixerBurstCount() const override;
+ int32_t getAAudioHardwareBurstMinUsec() const override;
status_t setDeviceConnectedState(const struct audio_port_v7 *port,
media::DeviceConnectedState state) override;
status_t setSimulateDeviceConnections(bool enabled) override;
status_t setRequestedLatencyMode(audio_io_handle_t output,
audio_latency_mode_t mode) override;
status_t getSupportedLatencyModes(
- audio_io_handle_t output, std::vector<audio_latency_mode_t>* modes) override;
+ audio_io_handle_t output, std::vector<audio_latency_mode_t>* modes) const override;
status_t setBluetoothVariableLatencyEnabled(bool enabled) override;
- status_t isBluetoothVariableLatencyEnabled(bool* enabled) override;
- status_t supportsBluetoothVariableLatency(bool* support) override;
+ status_t isBluetoothVariableLatencyEnabled(bool* enabled) const override;
+ status_t supportsBluetoothVariableLatency(bool* support) const override;
status_t getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback,
- sp<media::ISoundDose>* soundDose) override;
+ sp<media::ISoundDose>* soundDose) const override;
status_t invalidateTracks(const std::vector<audio_port_handle_t>& portIds) override;
status_t getAudioPolicyConfig(media::AudioPolicyConfig* output) override;
diff --git a/media/libaudiofoundation/DeviceDescriptorBase.cpp b/media/libaudiofoundation/DeviceDescriptorBase.cpp
index 2bb6afc..af70c39 100644
--- a/media/libaudiofoundation/DeviceDescriptorBase.cpp
+++ b/media/libaudiofoundation/DeviceDescriptorBase.cpp
@@ -125,6 +125,15 @@
dst->append(base::StringPrintf(
"%*sEncapsulation modes: %u, metadata types: %u\n", spaces, "",
mEncapsulationModes, mEncapsulationMetadataTypes));
+ if (!mEncodedFormats.empty()) {
+ std::string s;
+ for (const auto& format : mEncodedFormats) {
+ if (!s.empty()) s.append(", ");
+ s.append(audio_format_to_string(format));
+ }
+ dst->append(base::StringPrintf(
+ "%*sEncoded formats: %s\n", spaces, "", s.c_str()));
+ }
std::string portStr;
AudioPort::dump(&portStr, spaces, nullptr, verbose);
diff --git a/media/libaudiohal/impl/DeviceHalAidl.cpp b/media/libaudiohal/impl/DeviceHalAidl.cpp
index c7d7f69..99e3565 100644
--- a/media/libaudiohal/impl/DeviceHalAidl.cpp
+++ b/media/libaudiohal/impl/DeviceHalAidl.cpp
@@ -293,6 +293,9 @@
if (status_t status = filterAndUpdateScreenParameters(parameters); status != OK) {
ALOGW("%s: filtering or updating screen parameters failed: %d", __func__, status);
}
+ if (status_t status = filterAndUpdateTelephonyParameters(parameters); status != OK) {
+ ALOGW("%s: filtering or updating telephony parameters failed: %d", __func__, status);
+ }
return parseAndSetVendorParameters(mVendorExt, mModule, parameters);
}
@@ -1370,6 +1373,52 @@
return OK;
}
+status_t DeviceHalAidl::filterAndUpdateTelephonyParameters(AudioParameter ¶meters) {
+ TIME_CHECK();
+ 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;
+ }));
+ (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;
+ }));
+ if (mTelephony != nullptr && telConfig != ITelephony::TelecomConfig{}) {
+ ITelephony::TelecomConfig newTelConfig;
+ return statusTFromBinderStatus(
+ mTelephony->setTelecomConfig(telConfig, &newTelConfig));
+ }
+ return OK;
+}
+
status_t DeviceHalAidl::findOrCreatePatch(
const AudioPatch& requestedPatch, AudioPatch* patch, bool* created) {
std::set<int32_t> sourcePortConfigIds(requestedPatch.sourcePortConfigIds.begin(),
diff --git a/media/libaudiohal/impl/DeviceHalAidl.h b/media/libaudiohal/impl/DeviceHalAidl.h
index 6566de1..6b34bf4 100644
--- a/media/libaudiohal/impl/DeviceHalAidl.h
+++ b/media/libaudiohal/impl/DeviceHalAidl.h
@@ -224,6 +224,7 @@
status_t filterAndUpdateBtLeParameters(AudioParameter ¶meters);
status_t filterAndUpdateBtScoParameters(AudioParameter ¶meters);
status_t filterAndUpdateScreenParameters(AudioParameter ¶meters);
+ status_t filterAndUpdateTelephonyParameters(AudioParameter ¶meters);
status_t findOrCreatePatch(
const std::set<int32_t>& sourcePortConfigIds,
const std::set<int32_t>& sinkPortConfigIds,
diff --git a/media/libdatasource/OWNERS b/media/libdatasource/OWNERS
new file mode 100644
index 0000000..0e49ed8
--- /dev/null
+++ b/media/libdatasource/OWNERS
@@ -0,0 +1,6 @@
+# Bug component: 610698
+
+# Exclude /media/OWNERS but include top-level OWNERS
+set noparent
+include platform/frameworks/av:/OWNERS
+include platform/frameworks/av:/media/janitors/media_solutions_OWNERS
\ No newline at end of file
diff --git a/media/libmedia/OWNERS b/media/libmedia/OWNERS
new file mode 100644
index 0000000..e932382
--- /dev/null
+++ b/media/libmedia/OWNERS
@@ -0,0 +1,6 @@
+# Bug component: 610698
+
+# Exclude /media/OWNERS but include top-level OWNERS
+set noparent
+include platform/frameworks/av:/OWNERS
+include platform/frameworks/av:/media/janitors/media_solutions_OWNERS
diff --git a/media/libmediahelper/AudioParameter.cpp b/media/libmediahelper/AudioParameter.cpp
index 3832e90..c081629 100644
--- a/media/libmediahelper/AudioParameter.cpp
+++ b/media/libmediahelper/AudioParameter.cpp
@@ -43,6 +43,14 @@
const char * const AudioParameter::keyBtHfpEnable = AUDIO_PARAMETER_KEY_HFP_ENABLE;
const char * const AudioParameter::keyBtHfpSamplingRate = AUDIO_PARAMETER_KEY_HFP_SET_SAMPLING_RATE;
const char * const AudioParameter::keyBtHfpVolume = AUDIO_PARAMETER_KEY_HFP_VOLUME;
+const char * const AudioParameter::keyTtyMode = AUDIO_PARAMETER_KEY_TTY_MODE;
+const char * const AudioParameter::valueTtyModeOff = AUDIO_PARAMETER_VALUE_TTY_OFF;
+const char * const AudioParameter::valueTtyModeFull = AUDIO_PARAMETER_VALUE_TTY_FULL;
+const char * const AudioParameter::valueTtyModeHco = AUDIO_PARAMETER_VALUE_TTY_HCO;
+const char * const AudioParameter::valueTtyModeVco = AUDIO_PARAMETER_VALUE_TTY_VCO;
+const char * const AudioParameter::keyHacSetting = AUDIO_PARAMETER_KEY_HAC;
+const char * const AudioParameter::valueHacOff = AUDIO_PARAMETER_VALUE_HAC_OFF;
+const char * const AudioParameter::valueHacOn = AUDIO_PARAMETER_VALUE_HAC_ON;
const char * const AudioParameter::keyHwAvSync = AUDIO_PARAMETER_HW_AV_SYNC;
const char * const AudioParameter::keyPresentationId = AUDIO_PARAMETER_STREAM_PRESENTATION_ID;
const char * const AudioParameter::keyProgramId = AUDIO_PARAMETER_STREAM_PROGRAM_ID;
diff --git a/media/libmediahelper/include/media/AudioParameter.h b/media/libmediahelper/include/media/AudioParameter.h
index 3eee854..21d5117 100644
--- a/media/libmediahelper/include/media/AudioParameter.h
+++ b/media/libmediahelper/include/media/AudioParameter.h
@@ -69,6 +69,16 @@
static const char * const keyBtHfpSamplingRate;
static const char * const keyBtHfpVolume;
+ static const char * const keyTtyMode;
+ static const char * const valueTtyModeOff;
+ static const char * const valueTtyModeFull;
+ static const char * const valueTtyModeHco;
+ static const char * const valueTtyModeVco;
+
+ static const char * const keyHacSetting;
+ static const char * const valueHacOff;
+ static const char * const valueHacOn;
+
// keyHwAvSync: get HW synchronization source identifier from a device
// keyMonoOutput: Enable mono audio playback
// keyStreamHwAvSync: set HW synchronization source identifier on a stream
diff --git a/media/libmediaplayerservice/OWNERS b/media/libmediaplayerservice/OWNERS
new file mode 100644
index 0000000..e932382
--- /dev/null
+++ b/media/libmediaplayerservice/OWNERS
@@ -0,0 +1,6 @@
+# Bug component: 610698
+
+# Exclude /media/OWNERS but include top-level OWNERS
+set noparent
+include platform/frameworks/av:/OWNERS
+include platform/frameworks/av:/media/janitors/media_solutions_OWNERS
diff --git a/media/module/extractors/OWNERS b/media/module/extractors/OWNERS
new file mode 100644
index 0000000..8d39dcb
--- /dev/null
+++ b/media/module/extractors/OWNERS
@@ -0,0 +1,6 @@
+# Bug component: 817235
+
+# Exclude /media/OWNERS but include top-level OWNERS
+set noparent
+include platform/frameworks/av:/OWNERS
+include platform/frameworks/av:/media/janitors/media_solutions_OWNERS
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index 5929969..a9315f7 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -329,8 +329,6 @@
mClientSharedHeapSize(kMinimumClientSharedHeapSizeBytes),
mGlobalEffectEnableTime(0),
mPatchCommandThread(sp<PatchCommandThread>::make()),
- mDeviceEffectManager(sp<DeviceEffectManager>::make(*this)),
- mMelReporter(sp<MelReporter>::make(*this)),
mSystemReady(false),
mBluetoothLatencyModesEnabled(true)
{
@@ -404,7 +402,8 @@
mMode = AUDIO_MODE_NORMAL;
gAudioFlinger = this; // we are already refcounted, store into atomic pointer.
-
+ mDeviceEffectManager = sp<DeviceEffectManager>::make(
+ sp<IAfDeviceEffectManagerCallback>::fromExisting(this)),
mDevicesFactoryHalCallback = new DevicesFactoryHalCallbackImpl;
mDevicesFactoryHal->setCallbackOnce(mDevicesFactoryHalCallback);
@@ -412,6 +411,9 @@
mAAudioBurstsPerBuffer = getAAudioMixerBurstCountFromSystemProperty();
mAAudioHwBurstMinMicros = getAAudioHardwareBurstMinUsecFromSystemProperty();
}
+
+ mPatchPanel = IAfPatchPanel::create(sp<IAfPatchPanelCallback>::fromExisting(this));
+ mMelReporter = sp<MelReporter>::make(sp<IAfMelReporterCallback>::fromExisting(this));
}
status_t AudioFlinger::setAudioHalPids(const std::vector<pid_t>& pids) {
@@ -475,12 +477,12 @@
return NO_ERROR;
}
-int32_t AudioFlinger::getAAudioMixerBurstCount() {
+int32_t AudioFlinger::getAAudioMixerBurstCount() const {
Mutex::Autolock _l(mLock);
return mAAudioBurstsPerBuffer;
}
-int32_t AudioFlinger::getAAudioHardwareBurstMinUsec() {
+int32_t AudioFlinger::getAAudioHardwareBurstMinUsec() const {
Mutex::Autolock _l(mLock);
return mAAudioHwBurstMinMicros;
}
@@ -526,7 +528,7 @@
}
// getDefaultVibratorInfo_l must be called with AudioFlinger lock held.
-std::optional<media::AudioVibratorInfo> AudioFlinger::getDefaultVibratorInfo_l() {
+std::optional<media::AudioVibratorInfo> AudioFlinger::getDefaultVibratorInfo_l() const {
if (mAudioVibratorInfos.empty()) {
return {};
}
@@ -1035,7 +1037,7 @@
// (for which promote() is always != 0), otherwise create a new entry and Client.
sp<Client> client = mClients.valueFor(pid).promote();
if (client == 0) {
- client = new Client(this, pid);
+ client = sp<Client>::make(sp<IAfClientCallback>::fromExisting(this), pid);
mClients.add(pid, client);
}
@@ -1683,7 +1685,7 @@
}
status_t AudioFlinger::getSupportedLatencyModes(audio_io_handle_t output,
- std::vector<audio_latency_mode_t>* modes) {
+ std::vector<audio_latency_mode_t>* modes) const {
if (output == AUDIO_IO_HANDLE_NONE) {
return BAD_VALUE;
}
@@ -1710,7 +1712,7 @@
return status;
}
-status_t AudioFlinger::isBluetoothVariableLatencyEnabled(bool *enabled) {
+status_t AudioFlinger::isBluetoothVariableLatencyEnabled(bool* enabled) const {
if (enabled == nullptr) {
return BAD_VALUE;
}
@@ -1718,7 +1720,7 @@
return NO_ERROR;
}
-status_t AudioFlinger::supportsBluetoothVariableLatency(bool* support) {
+status_t AudioFlinger::supportsBluetoothVariableLatency(bool* support) const {
if (support == nullptr) {
return BAD_VALUE;
}
@@ -1734,7 +1736,7 @@
}
status_t AudioFlinger::getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback,
- sp<media::ISoundDose>* soundDose) {
+ sp<media::ISoundDose>* soundDose) const {
if (soundDose == nullptr) {
return BAD_VALUE;
}
@@ -2313,16 +2315,16 @@
// ----------------------------------------------------------------------------
-Client::Client(const sp<AudioFlinger>& audioFlinger, pid_t pid)
+Client::Client(const sp<IAfClientCallback>& afClientCallback, pid_t pid)
: RefBase(),
- mAudioFlinger(audioFlinger),
+ mAfClientCallback(afClientCallback),
mPid(pid),
mClientAllocator(AllocatorFactory::getClientAllocator()) {}
// Client destructor must be called with AudioFlinger::mClientLock held
Client::~Client()
{
- mAudioFlinger->removeClient_l(mPid);
+ mAfClientCallback->removeClient_l(mPid);
}
AllocatorFactory::ClientAllocator& Client::allocator()
@@ -2738,14 +2740,14 @@
// ----------------------------------------------------------------------------
-uint32_t AudioFlinger::getPrimaryOutputSamplingRate()
+uint32_t AudioFlinger::getPrimaryOutputSamplingRate() const
{
Mutex::Autolock _l(mLock);
IAfPlaybackThread* const thread = fastPlaybackThread_l();
return thread != NULL ? thread->sampleRate() : 0;
}
-size_t AudioFlinger::getPrimaryOutputFrameCount()
+size_t AudioFlinger::getPrimaryOutputFrameCount() const
{
Mutex::Autolock _l(mLock);
IAfPlaybackThread* const thread = fastPlaybackThread_l();
@@ -2933,7 +2935,7 @@
return mAudioManager.load();
}
-status_t AudioFlinger::getMicrophones(std::vector<media::MicrophoneInfoFw> *microphones)
+status_t AudioFlinger::getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) const
{
AutoMutex lock(mHardwareLock);
status_t status = INVALID_OPERATION;
@@ -4760,7 +4762,7 @@
return status;
}
-bool AudioFlinger::isNonOffloadableGlobalEffectEnabled_l()
+bool AudioFlinger::isNonOffloadableGlobalEffectEnabled_l() const
NO_THREAD_SAFETY_ANALYSIS // thread lock for getEffectChain_l.
{
if (mGlobalEffectEnableTime != 0 &&
diff --git a/services/audioflinger/AudioFlinger.h b/services/audioflinger/AudioFlinger.h
index e3910ea..737dffe 100644
--- a/services/audioflinger/AudioFlinger.h
+++ b/services/audioflinger/AudioFlinger.h
@@ -159,215 +159,321 @@
bool mute = false;
};
-class AudioFlinger : public AudioFlingerServerAdapter::Delegate
+class AudioFlinger
+ : public AudioFlingerServerAdapter::Delegate // IAudioFlinger client interface
+ , public IAfClientCallback
+ , public IAfDeviceEffectManagerCallback
+ , public IAfMelReporterCallback
+ , public IAfPatchPanelCallback
+ , public IAfThreadCallback
{
friend class sp<AudioFlinger>;
- // TODO(b/291319167) Create interface and remove friends.
- friend class Client; // removeClient_l();
- friend class DeviceEffectManager;
- friend class DeviceEffectManagerCallback;
- friend class MelReporter;
- friend class PatchPanel;
- // TODO(b/291012167) replace the Thread friends with an interface.
- friend class DirectOutputThread;
- friend class MixerThread;
- friend class MmapPlaybackThread;
- friend class MmapThread;
- friend class PlaybackThread;
- friend class RecordThread;
- friend class ThreadBase;
-
public:
static void instantiate() ANDROID_API;
static AttributionSourceState checkAttributionSourcePackage(
const AttributionSourceState& attributionSource);
- status_t dump(int fd, const Vector<String16>& args) override;
+private:
- // IAudioFlinger interface, in binder opcode order
+ // ---- begin IAudioFlinger interface
+
+ status_t dump(int fd, const Vector<String16>& args) final;
+
status_t createTrack(const media::CreateTrackRequest& input,
- media::CreateTrackResponse& output) override;
+ media::CreateTrackResponse& output) final;
status_t createRecord(const media::CreateRecordRequest& input,
- media::CreateRecordResponse& output) override;
+ media::CreateRecordResponse& output) final;
- virtual uint32_t sampleRate(audio_io_handle_t ioHandle) const;
- virtual audio_format_t format(audio_io_handle_t output) const;
- virtual size_t frameCount(audio_io_handle_t ioHandle) const;
- virtual size_t frameCountHAL(audio_io_handle_t ioHandle) const;
- virtual uint32_t latency(audio_io_handle_t output) const;
+ uint32_t sampleRate(audio_io_handle_t ioHandle) const final;
+ audio_format_t format(audio_io_handle_t output) const final;
+ size_t frameCount(audio_io_handle_t ioHandle) const final;
+ size_t frameCountHAL(audio_io_handle_t ioHandle) const final;
+ uint32_t latency(audio_io_handle_t output) const final;
- virtual status_t setMasterVolume(float value);
- virtual status_t setMasterMute(bool muted);
-
- virtual float masterVolume() const;
- virtual bool masterMute() const;
+ status_t setMasterVolume(float value) final;
+ status_t setMasterMute(bool muted) final;
+ float masterVolume() const final;
+ bool masterMute() const final;
// Balance value must be within -1.f (left only) to 1.f (right only) inclusive.
- status_t setMasterBalance(float balance) override;
- status_t getMasterBalance(float *balance) const override;
+ status_t setMasterBalance(float balance) final;
+ status_t getMasterBalance(float* balance) const final;
- virtual status_t setStreamVolume(audio_stream_type_t stream, float value,
- audio_io_handle_t output);
- virtual status_t setStreamMute(audio_stream_type_t stream, bool muted);
+ status_t setStreamVolume(audio_stream_type_t stream, float value,
+ audio_io_handle_t output) final;
+ status_t setStreamMute(audio_stream_type_t stream, bool muted) final;
- virtual float streamVolume(audio_stream_type_t stream,
- audio_io_handle_t output) const;
- virtual bool streamMute(audio_stream_type_t stream) const;
+ float streamVolume(audio_stream_type_t stream,
+ audio_io_handle_t output) const final;
+ bool streamMute(audio_stream_type_t stream) const final;
- virtual status_t setMode(audio_mode_t mode);
+ status_t setMode(audio_mode_t mode) final;
- virtual status_t setMicMute(bool state);
- virtual bool getMicMute() const;
+ status_t setMicMute(bool state) final;
+ bool getMicMute() const final;
- virtual void setRecordSilenced(audio_port_handle_t portId, bool silenced);
+ void setRecordSilenced(audio_port_handle_t portId, bool silenced) final;
- virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs);
- virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const;
+ status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs) final;
+ String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const final;
- virtual void registerClient(const sp<media::IAudioFlingerClient>& client);
+ void registerClient(const sp<media::IAudioFlingerClient>& client) final;
+ size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format,
+ audio_channel_mask_t channelMask) const final;
- virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format,
- audio_channel_mask_t channelMask) const;
+ status_t openOutput(const media::OpenOutputRequest& request,
+ media::OpenOutputResponse* response) final;
- virtual status_t openOutput(const media::OpenOutputRequest& request,
- media::OpenOutputResponse* response);
+ audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
+ audio_io_handle_t output2) final;
- virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
- audio_io_handle_t output2);
+ status_t closeOutput(audio_io_handle_t output) final;
- virtual status_t closeOutput(audio_io_handle_t output);
+ status_t suspendOutput(audio_io_handle_t output) final;
- virtual status_t suspendOutput(audio_io_handle_t output);
+ status_t restoreOutput(audio_io_handle_t output) final;
- virtual status_t restoreOutput(audio_io_handle_t output);
+ status_t openInput(const media::OpenInputRequest& request,
+ media::OpenInputResponse* response) final;
- virtual status_t openInput(const media::OpenInputRequest& request,
- media::OpenInputResponse* response);
+ status_t closeInput(audio_io_handle_t input) final;
- virtual status_t closeInput(audio_io_handle_t input);
+ status_t setVoiceVolume(float volume) final;
- virtual status_t setVoiceVolume(float volume);
+ status_t getRenderPosition(uint32_t* halFrames, uint32_t* dspFrames,
+ audio_io_handle_t output) const final;
- virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
- audio_io_handle_t output) const;
-
- virtual uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const;
+ uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const final;
// This is the binder API. For the internal API see nextUniqueId().
- virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use);
+ audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use) final;
- void acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid) override;
+ void acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid) final;
- virtual void releaseAudioSessionId(audio_session_t audioSession, pid_t pid);
+ void releaseAudioSessionId(audio_session_t audioSession, pid_t pid) final;
- virtual status_t queryNumberEffects(uint32_t *numEffects) const;
+ status_t queryNumberEffects(uint32_t* numEffects) const final;
- virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor) const;
+ status_t queryEffect(uint32_t index, effect_descriptor_t* descriptor) const final;
- virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid,
- const effect_uuid_t *pTypeUuid,
- uint32_t preferredTypeFlag,
- effect_descriptor_t *descriptor) const;
+ status_t getEffectDescriptor(const effect_uuid_t* pUuid,
+ const effect_uuid_t* pTypeUuid,
+ uint32_t preferredTypeFlag,
+ effect_descriptor_t* descriptor) const final;
- virtual status_t createEffect(const media::CreateEffectRequest& request,
- media::CreateEffectResponse* response);
+ status_t createEffect(const media::CreateEffectRequest& request,
+ media::CreateEffectResponse* response) final;
- virtual status_t moveEffects(audio_session_t sessionId, audio_io_handle_t srcOutput,
- audio_io_handle_t dstOutput);
+ status_t moveEffects(audio_session_t sessionId, audio_io_handle_t srcOutput,
+ audio_io_handle_t dstOutput) final;
- void setEffectSuspended(int effectId,
- audio_session_t sessionId,
- bool suspended) override;
+ void setEffectSuspended(int effectId,
+ audio_session_t sessionId,
+ bool suspended) final;
- virtual audio_module_handle_t loadHwModule(const char *name);
+ audio_module_handle_t loadHwModule(const char* name) final;
- virtual uint32_t getPrimaryOutputSamplingRate();
- virtual size_t getPrimaryOutputFrameCount();
+ uint32_t getPrimaryOutputSamplingRate() const final;
+ size_t getPrimaryOutputFrameCount() const final;
- virtual status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) override;
-
- /* List available audio ports and their attributes */
- virtual status_t listAudioPorts(unsigned int *num_ports,
- struct audio_port *ports);
+ status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) final;
/* Get attributes for a given audio port */
- virtual status_t getAudioPort(struct audio_port_v7 *port);
+ status_t getAudioPort(struct audio_port_v7* port) const final;
/* Create an audio patch between several source and sink ports */
- virtual status_t createAudioPatch(const struct audio_patch *patch,
- audio_patch_handle_t *handle);
+ status_t createAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t* handle) final;
/* Release an audio patch */
- virtual status_t releaseAudioPatch(audio_patch_handle_t handle);
+ status_t releaseAudioPatch(audio_patch_handle_t handle) final;
/* List existing audio patches */
- virtual status_t listAudioPatches(unsigned int *num_patches,
- struct audio_patch *patches);
+ status_t listAudioPatches(unsigned int* num_patches,
+ struct audio_patch* patches) const final;
/* Set audio port configuration */
- virtual status_t setAudioPortConfig(const struct audio_port_config *config);
+ status_t setAudioPortConfig(const struct audio_port_config* config) final;
/* Get the HW synchronization source used for an audio session */
- virtual audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId);
+ audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId) final;
/* Indicate JAVA services are ready (scheduling, power management ...) */
- virtual status_t systemReady();
- virtual status_t audioPolicyReady() { mAudioPolicyReady.store(true); return NO_ERROR; }
- bool isAudioPolicyReady() const { return mAudioPolicyReady.load(); }
+ status_t systemReady() final;
+ status_t audioPolicyReady() final { mAudioPolicyReady.store(true); return NO_ERROR; }
+ status_t getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) const final;
- virtual status_t getMicrophones(std::vector<media::MicrophoneInfoFw> *microphones);
+ status_t setAudioHalPids(const std::vector<pid_t>& pids) final;
- virtual status_t setAudioHalPids(const std::vector<pid_t>& pids);
+ status_t setVibratorInfos(const std::vector<media::AudioVibratorInfo>& vibratorInfos) final;
- virtual status_t setVibratorInfos(const std::vector<media::AudioVibratorInfo>& vibratorInfos);
+ status_t updateSecondaryOutputs(
+ const TrackSecondaryOutputsMap& trackSecondaryOutputs) final;
- virtual status_t updateSecondaryOutputs(
- const TrackSecondaryOutputsMap& trackSecondaryOutputs);
-
- virtual status_t getMmapPolicyInfos(
+ status_t getMmapPolicyInfos(
media::audio::common::AudioMMapPolicyType policyType,
- std::vector<media::audio::common::AudioMMapPolicyInfo> *policyInfos);
+ std::vector<media::audio::common::AudioMMapPolicyInfo>* policyInfos) final;
- virtual int32_t getAAudioMixerBurstCount();
+ int32_t getAAudioMixerBurstCount() const final;
- virtual int32_t getAAudioHardwareBurstMinUsec();
+ int32_t getAAudioHardwareBurstMinUsec() const final;
- virtual status_t setDeviceConnectedState(const struct audio_port_v7 *port,
- media::DeviceConnectedState state);
+ status_t setDeviceConnectedState(const struct audio_port_v7* port,
+ media::DeviceConnectedState state) final;
- virtual status_t setSimulateDeviceConnections(bool enabled);
+ status_t setSimulateDeviceConnections(bool enabled) final;
- virtual status_t setRequestedLatencyMode(
- audio_io_handle_t output, audio_latency_mode_t mode);
+ status_t setRequestedLatencyMode(
+ audio_io_handle_t output, audio_latency_mode_t mode) final;
- virtual status_t getSupportedLatencyModes(audio_io_handle_t output,
- std::vector<audio_latency_mode_t>* modes);
+ status_t getSupportedLatencyModes(audio_io_handle_t output,
+ std::vector<audio_latency_mode_t>* modes) const final;
- virtual status_t setBluetoothVariableLatencyEnabled(bool enabled);
+ status_t setBluetoothVariableLatencyEnabled(bool enabled) final;
- virtual status_t isBluetoothVariableLatencyEnabled(bool* enabled);
+ status_t isBluetoothVariableLatencyEnabled(bool* enabled) const final;
- virtual status_t supportsBluetoothVariableLatency(bool* support);
+ status_t supportsBluetoothVariableLatency(bool* support) const final;
- virtual status_t getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback,
- sp<media::ISoundDose>* soundDose);
+ status_t getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback,
+ sp<media::ISoundDose>* soundDose) const final;
- status_t invalidateTracks(const std::vector<audio_port_handle_t>& portIds) override;
+ status_t invalidateTracks(const std::vector<audio_port_handle_t>& portIds) final;
- virtual status_t getAudioPolicyConfig(media::AudioPolicyConfig* config);
+ status_t getAudioPolicyConfig(media::AudioPolicyConfig* config) final;
status_t onTransactWrapper(TransactionCode code, const Parcel& data, uint32_t flags,
- const std::function<status_t()>& delegate) override;
+ const std::function<status_t()>& delegate) final;
- // end of IAudioFlinger interface
+ // ---- end of IAudioFlinger interface
- sp<NBLog::Writer> newWriter_l(size_t size, const char *name);
- void unregisterWriter(const sp<NBLog::Writer>& writer);
+ // ---- begin IAfClientCallback interface
+
+ Mutex& clientMutex() const final { return mClientLock; }
+ void removeClient_l(pid_t pid) final;
+ void removeNotificationClient(pid_t pid) final;
+ status_t moveAuxEffectToIo(
+ int effectId,
+ const sp<IAfPlaybackThread>& dstThread,
+ sp<IAfPlaybackThread>* srcThread) final;
+
+ // ---- end of IAfClientCallback interface
+
+ // ---- begin IAfDeviceEffectManagerCallback interface
+
+ // also used by IAfThreadCallback
+ bool isAudioPolicyReady() const final { return mAudioPolicyReady.load(); }
+ // below also used by IAfMelReporterCallback, IAfPatchPanelCallback
+ const sp<PatchCommandThread>& getPatchCommandThread() final { return mPatchCommandThread; }
+ status_t addEffectToHal(
+ const struct audio_port_config* device, const sp<EffectHalInterface>& effect) final;
+ status_t removeEffectFromHal(
+ const struct audio_port_config* device, const sp<EffectHalInterface>& effect) final;
+
+ // ---- end of IAfDeviceEffectManagerCallback interface
+
+ // ---- begin IAfMelReporterCallback interface
+
+ // below also used by IAfThreadCallback
+ Mutex& mutex() const final { return mLock; }
+ sp<IAfThreadBase> checkOutputThread_l(audio_io_handle_t ioHandle) const final REQUIRES(mLock);
+
+ // ---- end of IAfMelReporterCallback interface
+
+ // ---- begin IAfPatchPanelCallback interface
+
+ void closeThreadInternal_l(const sp<IAfPlaybackThread>& thread) final;
+ void closeThreadInternal_l(const sp<IAfRecordThread>& thread) final;
+ // return thread associated with primary hardware device, or NULL
+ IAfPlaybackThread* primaryPlaybackThread_l() const final;
+ IAfPlaybackThread* checkPlaybackThread_l(audio_io_handle_t output) const final;
+ IAfRecordThread* checkRecordThread_l(audio_io_handle_t input) const final;
+ IAfMmapThread* checkMmapThread_l(audio_io_handle_t io) const final;
+ void lock() const final ACQUIRE(mLock) { mLock.lock(); }
+ void unlock() const final RELEASE(mLock) { mLock.unlock(); }
+ sp<IAfThreadBase> openInput_l(audio_module_handle_t module,
+ audio_io_handle_t* input,
+ audio_config_t* config,
+ audio_devices_t device,
+ const char* address,
+ audio_source_t source,
+ audio_input_flags_t flags,
+ audio_devices_t outputDevice,
+ const String8& outputDeviceAddress) final;
+ sp<IAfThreadBase> openOutput_l(audio_module_handle_t module,
+ audio_io_handle_t* output,
+ audio_config_t* halConfig,
+ audio_config_base_t* mixerConfig,
+ audio_devices_t deviceType,
+ const String8& address,
+ audio_output_flags_t flags) final;
+ const DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*>&
+ getAudioHwDevs_l() const final { return mAudioHwDevs; }
+ void updateDownStreamPatches_l(const struct audio_patch* patch,
+ const std::set<audio_io_handle_t>& streams) final;
+ void updateOutDevicesForRecordThreads_l(const DeviceDescriptorBaseVector& devices) final;
+
+ // ---- end of IAfPatchPanelCallback interface
+
+ // ----- begin IAfThreadCallback interface
+
+ bool isNonOffloadableGlobalEffectEnabled_l() const final;
+ bool btNrecIsOff() const final { return mBtNrecIsOff.load(); }
+ float masterVolume_l() const final;
+ bool masterMute_l() const final;
+ float getMasterBalance_l() const;
+ // no range check, AudioFlinger::mLock held
+ bool streamMute_l(audio_stream_type_t stream) const final { return mStreamTypes[stream].mute; }
+ audio_mode_t getMode() const final { return mMode; }
+ bool isLowRamDevice() const final { return mIsLowRamDevice; }
+
+ std::optional<media::AudioVibratorInfo> getDefaultVibratorInfo_l() const final;
+ const sp<IAfPatchPanel>& getPatchPanel() const final { return mPatchPanel; }
+ const sp<MelReporter>& getMelReporter() const final { return mMelReporter; }
+ const sp<EffectsFactoryHalInterface>& getEffectsFactoryHal() const final {
+ return mEffectsFactoryHal;
+ }
+ sp<IAudioManager> getOrCreateAudioManager() final;
+
+ // Called when the last effect handle on an effect instance is removed. If this
+ // effect belongs to an effect chain in mOrphanEffectChains, the chain is updated
+ // and removed from mOrphanEffectChains if it does not contain any effect.
+ // Return true if the effect was found in mOrphanEffectChains, false otherwise.
+ bool updateOrphanEffectChains(const sp<IAfEffectModule>& effect) final;
+
+ status_t moveEffectChain_l(audio_session_t sessionId,
+ IAfPlaybackThread* srcThread, IAfPlaybackThread* dstThread) final;
+
+ // This is a helper that is called during incoming binder calls.
+ // Requests media.log to start merging log buffers
+ void requestLogMerge() final;
+ sp<NBLog::Writer> newWriter_l(size_t size, const char *name) final;
+ void unregisterWriter(const sp<NBLog::Writer>& writer) final;
+
+ sp<audioflinger::SyncEvent> createSyncEvent(AudioSystem::sync_event_t type,
+ audio_session_t triggerSession,
+ audio_session_t listenerSession,
+ const audioflinger::SyncEventCallback& callBack,
+ const wp<IAfTrackBase>& cookie) final;
+
+ void ioConfigChanged(audio_io_config_event_t event,
+ const sp<AudioIoDescriptor>& ioDesc,
+ pid_t pid = 0) final;
+ void onNonOffloadableGlobalEffectEnable() final;
+ void onSupportedLatencyModesChanged(
+ audio_io_handle_t output, const std::vector<audio_latency_mode_t>& modes) final;
+
+ // ---- end of IAfThreadCallback interface
+
+ /* List available audio ports and their attributes */
+ status_t listAudioPorts(unsigned int* num_ports, struct audio_port* ports) const;
+
sp<EffectsFactoryHalInterface> getEffectsFactory();
+public:
status_t openMmapStream(MmapStreamInterface::stream_direction_t direction,
const audio_attributes_t *attr,
audio_config_base_t *config,
@@ -382,16 +488,6 @@
const sp<os::ExternalVibration>& externalVibration);
static void onExternalVibrationStop(const sp<os::ExternalVibration>& externalVibration);
- status_t addEffectToHal(
- const struct audio_port_config *device, const sp<EffectHalInterface>& effect);
- status_t removeEffectFromHal(
- const struct audio_port_config *device, const sp<EffectHalInterface>& effect);
-
- void updateDownStreamPatches_l(const struct audio_patch *patch,
- const std::set<audio_io_handle_t>& streams);
-
- std::optional<media::AudioVibratorInfo> getDefaultVibratorInfo_l();
-
private:
// FIXME The 400 is temporarily too high until a leak of writers in media.log is fixed.
static const size_t kLogMemorySize = 400 * 1024;
@@ -401,50 +497,15 @@
Vector< sp<NBLog::Writer> > mUnregisteredWriters;
Mutex mUnregisteredWritersLock;
-public:
- // Life cycle of gAudioFlinger and AudioFlinger:
- //
- // AudioFlinger is created once and survives until audioserver crashes
- // irrespective of sp<> and wp<> as it is refcounted by ServiceManager and we
- // don't issue a ServiceManager::tryUnregisterService().
- //
- // gAudioFlinger is an atomic pointer set on AudioFlinger::onFirstRef().
- // After this is set, it is safe to obtain a wp<> or sp<> from it as the
- // underlying object does not go away.
- //
- // Note: For most inner classes, it is acceptable to hold a reference to the outer
- // AudioFlinger instance as creation requires AudioFlinger to exist in the first place.
- //
- // An atomic here ensures underlying writes have completed before setting
- // the pointer. Access by memory_order_seq_cst.
- //
-
- static inline std::atomic<AudioFlinger *> gAudioFlinger = nullptr;
-
- sp<audioflinger::SyncEvent> createSyncEvent(AudioSystem::sync_event_t type,
- audio_session_t triggerSession,
- audio_session_t listenerSession,
- const audioflinger::SyncEventCallback& callBack,
- const wp<IAfTrackBase>& cookie);
-
- bool btNrecIsOff() const { return mBtNrecIsOff.load(); }
-
- void lock() ACQUIRE(mLock) { mLock.lock(); }
- void unlock() RELEASE(mLock) { mLock.unlock(); }
-
-private:
-
- audio_mode_t getMode() const { return mMode; }
-
AudioFlinger() ANDROID_API;
- virtual ~AudioFlinger();
+ ~AudioFlinger() override;
// call in any IAudioFlinger method that accesses mPrimaryHardwareDev
status_t initCheck() const { return mPrimaryHardwareDev == NULL ?
NO_INIT : NO_ERROR; }
// RefBase
- virtual void onFirstRef();
+ void onFirstRef() override;
AudioHwDevice* findSuitableHwDev_l(audio_module_handle_t module,
audio_devices_t deviceType);
@@ -454,6 +515,10 @@
// FCC_2 <= channels <= AudioMixer::MAX_NUM_CHANNELS.
static const bool kEnableExtendedChannels = true;
+public:
+ // Remove this when Oboeservice is updated to obtain handle directly.
+ static inline std::atomic<AudioFlinger*> gAudioFlinger = nullptr;
+
// Returns true if channel mask is permitted for the PCM sink in the MixerThread
static inline bool isValidPcmSinkChannelMask(audio_channel_mask_t channelMask) {
switch (audio_channel_mask_get_representation(channelMask)) {
@@ -512,7 +577,7 @@
// Internal dump utilities.
static const int kDumpLockTimeoutNs = 1 * NANOS_PER_SECOND;
-public:
+
// TODO(b/291319167) extract to afutils
static bool dumpTryLock(Mutex& mutex);
private:
@@ -578,10 +643,6 @@
const sp<MediaLogNotifier> mMediaLogNotifier;
- // This is a helper that is called during incoming binder calls.
- // Requests media.log to start merging log buffers
- void requestLogMerge();
-
// Find io handle by session id.
// Preference is given to an io handle with a matching effect chain to session id.
// If none found, AUDIO_IO_HANDLE_NONE is returned.
@@ -603,43 +664,15 @@
}
IAfThreadBase* checkThread_l(audio_io_handle_t ioHandle) const;
- sp<IAfThreadBase> checkOutputThread_l(audio_io_handle_t ioHandle) const REQUIRES(mLock);
- IAfPlaybackThread* checkPlaybackThread_l(audio_io_handle_t output) const;
IAfPlaybackThread* checkMixerThread_l(audio_io_handle_t output) const;
- IAfRecordThread* checkRecordThread_l(audio_io_handle_t input) const;
- IAfMmapThread* checkMmapThread_l(audio_io_handle_t io) const;
+
sp<VolumeInterface> getVolumeInterface_l(audio_io_handle_t output) const;
std::vector<sp<VolumeInterface>> getAllVolumeInterfaces_l() const;
- sp<IAfThreadBase> openInput_l(audio_module_handle_t module,
- audio_io_handle_t *input,
- audio_config_t *config,
- audio_devices_t device,
- const char* address,
- audio_source_t source,
- audio_input_flags_t flags,
- audio_devices_t outputDevice,
- const String8& outputDeviceAddress);
- sp<IAfThreadBase> openOutput_l(audio_module_handle_t module,
- audio_io_handle_t *output,
- audio_config_t *halConfig,
- audio_config_base_t *mixerConfig,
- audio_devices_t deviceType,
- const String8& address,
- audio_output_flags_t flags);
void closeOutputFinish(const sp<IAfPlaybackThread>& thread);
void closeInputFinish(const sp<IAfRecordThread>& thread);
- // no range check, AudioFlinger::mLock held
- bool streamMute_l(audio_stream_type_t stream) const
- { return mStreamTypes[stream].mute; }
- void ioConfigChanged(audio_io_config_event_t event,
- const sp<AudioIoDescriptor>& ioDesc,
- pid_t pid = 0);
- void onSupportedLatencyModesChanged(
- audio_io_handle_t output, const std::vector<audio_latency_mode_t>& modes);
-
// Allocate an audio_unique_id_t.
// Specific types are audio_io_handle_t, audio_session_t, effect ID (int),
// audio_module_handle_t, and audio_patch_handle_t.
@@ -651,21 +684,13 @@
// Thus it may fail by returning an ID of the wrong sign,
// or by returning a non-unique ID.
// This is the internal API. For the binder API see newAudioUniqueId().
- audio_unique_id_t nextUniqueId(audio_unique_id_use_t use);
+ // used by IAfDeviceEffectManagerCallback, IAfPatchPanelCallback, IAfThreadCallback
+ audio_unique_id_t nextUniqueId(audio_unique_id_use_t use) final;
status_t moveEffectChain_l(audio_session_t sessionId,
- IAfPlaybackThread* srcThread, IAfPlaybackThread* dstThread);
- status_t moveEffectChain_l(audio_session_t sessionId,
IAfRecordThread* srcThread, IAfRecordThread* dstThread);
-public:
- // TODO(b/291319167) cluster together
- status_t moveAuxEffectToIo(int EffectId,
- const sp<IAfPlaybackThread>& dstThread, sp<IAfPlaybackThread>* srcThread);
-private:
-
// return thread associated with primary hardware device, or NULL
- IAfPlaybackThread* primaryPlaybackThread_l() const;
DeviceTypeSet primaryOutputDevice_l() const;
// return the playback thread with smallest HAL buffer size, and prefer fast
@@ -680,14 +705,6 @@
IAfPlaybackThread* thread,
const std::vector<audio_io_handle_t>& secondaryOutputs) const;
-
- void removeClient_l(pid_t pid);
- void removeNotificationClient(pid_t pid);
-public:
- // TODO(b/291319167) cluster together
- bool isNonOffloadableGlobalEffectEnabled_l();
-private:
- void onNonOffloadableGlobalEffectEnable();
bool isSessionAcquired_l(audio_session_t audioSession);
// Store an effect chain to mOrphanEffectChains keyed vector.
@@ -701,21 +718,13 @@
// Get an effect chain for the specified session in mOrphanEffectChains and remove
// it if found. Returns 0 if not found (this is the most common case).
sp<IAfEffectChain> getOrphanEffectChain_l(audio_session_t session);
- // Called when the last effect handle on an effect instance is removed. If this
- // effect belongs to an effect chain in mOrphanEffectChains, the chain is updated
- // and removed from mOrphanEffectChains if it does not contain any effect.
- // Return true if the effect was found in mOrphanEffectChains, false otherwise.
-public:
-// TODO(b/291319167) suggest better grouping
- bool updateOrphanEffectChains(const sp<IAfEffectModule>& effect);
-private:
+
std::vector< sp<IAfEffectModule> > purgeStaleEffects_l();
std::vector< sp<IAfEffectModule> > purgeOrphanEffectChains_l();
bool updateOrphanEffectChains_l(const sp<IAfEffectModule>& effect);
void broadcastParametersToRecordThreads_l(const String8& keyValuePairs);
- void updateOutDevicesForRecordThreads_l(const DeviceDescriptorBaseVector& devices);
void forwardParametersToDownstreamPatches_l(
audio_io_handle_t upStream, const String8& keyValuePairs,
const std::function<bool(const sp<IAfPlaybackThread>&)>& useThread = nullptr);
@@ -730,16 +739,13 @@
int mCnt;
};
-public:
- // TODO(b/291319167) access by getter,
mutable Mutex mLock;
// protects mClients and mNotificationClients.
// must be locked after mLock and ThreadBase::mLock if both must be locked
// avoids acquiring AudioFlinger::mLock from inside thread loop.
- // TODO(b/291319167) access by getter,
- mutable Mutex mClientLock;
-private:
+ mutable Mutex mClientLock;
+
// protected by mClientLock
DefaultKeyedVector< pid_t, wp<Client> > mClients; // see ~Client()
@@ -809,9 +815,6 @@
// protected by mLock
Vector<AudioSessionRef*> mAudioSessionRefs;
- float masterVolume_l() const;
- float getMasterBalance_l() const;
- bool masterMute_l() const;
AudioHwDevice* loadHwModule_l(const char *name);
// sync events awaiting for a session to be created.
@@ -828,14 +831,11 @@
// Audio data transfer is directly handled by the client creating the MMAP stream
DefaultKeyedVector<audio_io_handle_t, sp<IAfMmapThread>> mMmapThreads;
-private:
sp<Client> registerPid(pid_t pid); // always returns non-0
// for use from destructor
status_t closeOutput_nonvirtual(audio_io_handle_t output);
- void closeThreadInternal_l(const sp<IAfPlaybackThread>& thread);
status_t closeInput_nonvirtual(audio_io_handle_t input);
- void closeThreadInternal_l(const sp<IAfRecordThread>& thread);
void setAudioHwSyncForSession_l(IAfPlaybackThread* thread, audio_session_t sessionId);
status_t checkStreamType(audio_stream_type_t stream) const;
@@ -845,15 +845,10 @@
size_t rejectedKVPSize, const String8& rejectedKVPs,
uid_t callingUid);
-public:
- sp<IAudioManager> getOrCreateAudioManager();
-
// These methods read variables atomically without mLock,
// though the variables are updated with mLock.
- bool isLowRamDevice() const { return mIsLowRamDevice; }
size_t getClientSharedHeapSize() const;
-private:
std::atomic<bool> mIsLowRamDevice;
bool mIsDeviceTypeKnown;
int64_t mTotalMemory;
@@ -862,17 +857,13 @@
nsecs_t mGlobalEffectEnableTime; // when a global effect was last enabled
- // protected by mLock
- const sp<IAfPatchPanel> mPatchPanel = IAfPatchPanel::create(this);
+ /* const */ sp<IAfPatchPanel> mPatchPanel;
-public:
- // TODO(b/291319167) access by getter.
sp<EffectsFactoryHalInterface> mEffectsFactoryHal;
-private:
const sp<PatchCommandThread> mPatchCommandThread;
- sp<DeviceEffectManager> mDeviceEffectManager;
- sp<MelReporter> mMelReporter;
+ /* const */ sp<DeviceEffectManager> mDeviceEffectManager; // set onFirstRef
+ /* const */ sp<MelReporter> mMelReporter; // set onFirstRef
bool mSystemReady;
std::atomic_bool mAudioPolicyReady{};
@@ -887,8 +878,10 @@
static inline constexpr const char *mMetricsId = AMEDIAMETRICS_KEY_AUDIO_FLINGER;
+public:
// Keep in sync with java definition in media/java/android/media/AudioRecord.java
static constexpr int32_t kMaxSharedAudioHistoryMs = 5000;
+private:
std::map<media::audio::common::AudioMMapPolicyType,
std::vector<media::audio::common::AudioMMapPolicyInfo>> mPolicyInfos;
diff --git a/services/audioflinger/Client.h b/services/audioflinger/Client.h
index 142d384..36d6ff7 100644
--- a/services/audioflinger/Client.h
+++ b/services/audioflinger/Client.h
@@ -19,23 +19,34 @@
// TODO(b/291318727) Move to nested namespace
namespace android {
-class AudioFlinger;
+class IAfPlaybackThread;
+
+class IAfClientCallback : public virtual RefBase {
+public:
+ virtual Mutex& clientMutex() const = 0;
+ virtual void removeClient_l(pid_t pid) = 0;
+ virtual void removeNotificationClient(pid_t pid) = 0;
+ virtual status_t moveAuxEffectToIo(
+ int effectId,
+ const sp<IAfPlaybackThread>& dstThread,
+ sp<IAfPlaybackThread>* srcThread) = 0;
+};
class Client : public RefBase {
public:
- Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
+ Client(const sp<IAfClientCallback>& audioFlinger, pid_t pid);
// TODO(b/289139675) make Client container.
// Client destructor must be called with AudioFlinger::mClientLock held
~Client() override;
AllocatorFactory::ClientAllocator& allocator();
pid_t pid() const { return mPid; }
- sp<AudioFlinger> audioFlinger() const { return mAudioFlinger; }
+ const auto& afClientCallback() const { return mAfClientCallback; }
private:
DISALLOW_COPY_AND_ASSIGN(Client);
- const sp<AudioFlinger> mAudioFlinger;
+ const sp<IAfClientCallback> mAfClientCallback;
const pid_t mPid;
AllocatorFactory::ClientAllocator mClientAllocator;
};
diff --git a/services/audioflinger/DeviceEffectManager.cpp b/services/audioflinger/DeviceEffectManager.cpp
index 0f645cd..d78e26f 100644
--- a/services/audioflinger/DeviceEffectManager.cpp
+++ b/services/audioflinger/DeviceEffectManager.cpp
@@ -34,22 +34,23 @@
using detail::AudioHalVersionInfo;
using media::IEffectClient;
-DeviceEffectManager::DeviceEffectManager(AudioFlinger& audioFlinger)
- : mAudioFlinger(audioFlinger),
+DeviceEffectManager::DeviceEffectManager(
+ const sp<IAfDeviceEffectManagerCallback>& afDeviceEffectManagerCallback)
+ : mAfDeviceEffectManagerCallback(afDeviceEffectManagerCallback),
mMyCallback(new DeviceEffectManagerCallback(*this)) {}
void DeviceEffectManager::onFirstRef() {
- mAudioFlinger.mPatchCommandThread->addListener(this);
+ mAfDeviceEffectManagerCallback->getPatchCommandThread()->addListener(this);
}
status_t DeviceEffectManager::addEffectToHal(const struct audio_port_config* device,
const sp<EffectHalInterface>& effect) {
- return mAudioFlinger.addEffectToHal(device, effect);
+ return mAfDeviceEffectManagerCallback->addEffectToHal(device, effect);
};
status_t DeviceEffectManager::removeEffectFromHal(const struct audio_port_config* device,
const sp<EffectHalInterface>& effect) {
- return mAudioFlinger.removeEffectFromHal(device, effect);
+ return mAfDeviceEffectManagerCallback->removeEffectFromHal(device, effect);
};
void DeviceEffectManager::onCreateAudioPatch(audio_patch_handle_t handle,
@@ -129,7 +130,8 @@
}
if (effect == nullptr) {
effect = IAfDeviceEffectProxy::create(device, mMyCallback,
- descriptor, mAudioFlinger.nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT),
+ descriptor,
+ mAfDeviceEffectManagerCallback->nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT),
notifyFramesProcessed);
effectsForDevice.push_back(effect);
}
@@ -266,11 +268,11 @@
}
bool DeviceEffectManagerCallback::isAudioPolicyReady() const {
- return mManager.audioFlinger().isAudioPolicyReady();
+ return mManager.afDeviceEffectManagerCallback()->isAudioPolicyReady();
}
int DeviceEffectManagerCallback::newEffectId() const {
- return mManager.audioFlinger().nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);
+ return mManager.afDeviceEffectManagerCallback()->nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);
}
} // namespace android
diff --git a/services/audioflinger/DeviceEffectManager.h b/services/audioflinger/DeviceEffectManager.h
index 54b88d0..3da5504 100644
--- a/services/audioflinger/DeviceEffectManager.h
+++ b/services/audioflinger/DeviceEffectManager.h
@@ -19,12 +19,24 @@
namespace android {
+class IAfDeviceEffectManagerCallback : public virtual RefBase {
+public:
+ virtual bool isAudioPolicyReady() const = 0;
+ virtual audio_unique_id_t nextUniqueId(audio_unique_id_use_t use) = 0;
+ virtual const sp<PatchCommandThread>& getPatchCommandThread() = 0;
+ virtual status_t addEffectToHal(
+ const struct audio_port_config* device, const sp<EffectHalInterface>& effect) = 0;
+ virtual status_t removeEffectFromHal(
+ const struct audio_port_config* device, const sp<EffectHalInterface>& effect) = 0;
+};
+
class DeviceEffectManagerCallback;
// DeviceEffectManager is concealed within AudioFlinger, their lifetimes are the same.
class DeviceEffectManager : public PatchCommandThread::PatchCommandListener {
public:
- explicit DeviceEffectManager(AudioFlinger& audioFlinger);
+ explicit DeviceEffectManager(
+ const sp<IAfDeviceEffectManagerCallback>& afDeviceEffectManagerCallback);
void onFirstRef() override;
@@ -47,7 +59,7 @@
status_t removeEffectFromHal(const struct audio_port_config *device,
const sp<EffectHalInterface>& effect);
- AudioFlinger& audioFlinger() const { return mAudioFlinger; }
+ const auto& afDeviceEffectManagerCallback() const { return mAfDeviceEffectManagerCallback; }
void dump(int fd);
@@ -64,7 +76,7 @@
status_t checkEffectCompatibility(const effect_descriptor_t *desc);
Mutex mLock;
- AudioFlinger &mAudioFlinger;
+ const sp<IAfDeviceEffectManagerCallback> mAfDeviceEffectManagerCallback;
const sp<DeviceEffectManagerCallback> mMyCallback;
std::map<AudioDeviceTypeAddr, std::vector<sp<IAfDeviceEffectProxy>>> mDeviceEffects;
};
diff --git a/services/audioflinger/Effects.cpp b/services/audioflinger/Effects.cpp
index 5780d5d..ce71703 100644
--- a/services/audioflinger/Effects.cpp
+++ b/services/audioflinger/Effects.cpp
@@ -1888,7 +1888,7 @@
}
mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
// Client destructor must run with AudioFlinger client mutex locked
- Mutex::Autolock _l2(mClient->audioFlinger()->mClientLock);
+ Mutex::Autolock _l2(mClient->afClientCallback()->clientMutex());
mClient.clear();
}
}
@@ -2118,30 +2118,22 @@
/* static */
sp<IAfEffectChain> IAfEffectChain::create(
- const wp<IAfThreadBase>& wThread,
+ const sp<IAfThreadBase>& thread,
audio_session_t sessionId)
{
- return sp<EffectChain>::make(wThread, sessionId);
+ return sp<EffectChain>::make(thread, sessionId);
}
-EffectChain::EffectChain(const wp<IAfThreadBase>& thread,
+EffectChain::EffectChain(const sp<IAfThreadBase>& thread,
audio_session_t sessionId)
: mSessionId(sessionId), mActiveTrackCnt(0), mTrackCnt(0), mTailBufferCount(0),
mVolumeCtrlIdx(-1), mLeftVolume(UINT_MAX), mRightVolume(UINT_MAX),
mNewLeftVolume(UINT_MAX), mNewRightVolume(UINT_MAX),
mEffectCallback(new EffectCallback(wp<EffectChain>(this), thread))
{
- const sp<IAfThreadBase> p = thread.promote();
- if (p == nullptr) {
- return;
- }
- mStrategy = p->getStrategyForStream(AUDIO_STREAM_MUSIC);
- mMaxTailBuffers = ((kProcessTailDurationMs * p->sampleRate()) / 1000) /
- p->frameCount();
-}
-
-EffectChain::~EffectChain()
-{
+ mStrategy = thread->getStrategyForStream(AUDIO_STREAM_MUSIC);
+ mMaxTailBuffers = ((kProcessTailDurationMs * thread->sampleRate()) / 1000) /
+ thread->frameCount();
}
// getEffectFromDesc_l() must be called with IAfThreadBase::mutex() held
@@ -2990,12 +2982,12 @@
bool EffectChain::EffectCallback::updateOrphanEffectChains(
const sp<IAfEffectBase>& effect) {
// in EffectChain context, an EffectBase is always from an EffectModule so static cast is safe
- return mAudioFlinger.updateOrphanEffectChains(effect->asEffectModule());
+ return mAfThreadCallback->updateOrphanEffectChains(effect->asEffectModule());
}
status_t EffectChain::EffectCallback::allocateHalBuffer(
size_t size, sp<EffectBufferHalInterface>* buffer) {
- return mAudioFlinger.mEffectsFactoryHal->allocateBuffer(size, buffer);
+ return mAfThreadCallback->getEffectsFactoryHal()->allocateBuffer(size, buffer);
}
status_t EffectChain::EffectCallback::addEffectToHal(
diff --git a/services/audioflinger/Effects.h b/services/audioflinger/Effects.h
index 365cd45..dfa199e 100644
--- a/services/audioflinger/Effects.h
+++ b/services/audioflinger/Effects.h
@@ -382,8 +382,7 @@
// it also provide it's own input buffer used by the track as accumulation buffer.
class EffectChain : public IAfEffectChain {
public:
- EffectChain(const wp<IAfThreadBase>& wThread, audio_session_t sessionId);
- ~EffectChain() override;
+ EffectChain(const sp<IAfThreadBase>& thread, audio_session_t sessionId);
void process_l() final;
@@ -516,16 +515,11 @@
// Note: ctors taking a weak pointer to their owner must not promote it
// during construction (but may keep a reference for later promotion).
EffectCallback(const wp<EffectChain>& owner,
- const wp<IAfThreadBase>& thread)
+ const sp<IAfThreadBase>& thread) // we take a sp<> but store a wp<>.
: mChain(owner)
- , mThread(thread)
- , mAudioFlinger(*AudioFlinger::gAudioFlinger) {
- const sp<IAfThreadBase> base = thread.promote();
- if (base != nullptr) {
- mThreadType = base->type();
- } else {
- mThreadType = IAfThreadBase::MIXER; // assure a consistent value.
- }
+ , mThread(thread) {
+ mThreadType = thread->type();
+ mAfThreadCallback = thread->afThreadCallback();
}
status_t createEffectHal(const effect_uuid_t *pEffectUuid,
@@ -566,7 +560,7 @@
wp<IAfEffectChain> chain() const final { return mChain; }
bool isAudioPolicyReady() const final {
- return mAudioFlinger.isAudioPolicyReady();
+ return mAfThreadCallback->isAudioPolicyReady();
}
wp<IAfThreadBase> thread() const { return mThread.load(); }
@@ -574,12 +568,13 @@
void setThread(const sp<IAfThreadBase>& thread) {
mThread = thread;
mThreadType = thread->type();
+ mAfThreadCallback = thread->afThreadCallback();
}
private:
const wp<IAfEffectChain> mChain;
mediautils::atomic_wp<IAfThreadBase> mThread;
- AudioFlinger &mAudioFlinger; // implementation detail: outer instance always exists.
+ sp<IAfThreadCallback> mAfThreadCallback;
IAfThreadBase::type_t mThreadType;
};
diff --git a/services/audioflinger/IAfEffect.h b/services/audioflinger/IAfEffect.h
index ece0081..9e3f7fd 100644
--- a/services/audioflinger/IAfEffect.h
+++ b/services/audioflinger/IAfEffect.h
@@ -192,7 +192,7 @@
// Most of these methods are accessed from AudioFlinger::Thread
public:
static sp<IAfEffectChain> create(
- const wp<IAfThreadBase>& wThread,
+ const sp<IAfThreadBase>& thread,
audio_session_t sessionId);
// special key used for an entry in mSuspendedEffects keyed vector
diff --git a/services/audioflinger/IAfPatchPanel.h b/services/audioflinger/IAfPatchPanel.h
index 29bd4ab..bc116a9 100644
--- a/services/audioflinger/IAfPatchPanel.h
+++ b/services/audioflinger/IAfPatchPanel.h
@@ -18,12 +18,14 @@
namespace android {
+class IAfMmapThread;
class IAfPatchPanel;
class IAfPatchRecord;
class IAfPatchTrack;
class IAfPlaybackThread;
class IAfRecordThread;
class IAfThreadBase;
+class PatchCommandThread;
class SoftwarePatch {
public:
@@ -51,9 +53,44 @@
const audio_io_handle_t mRecordThreadHandle;
};
+class IAfPatchPanelCallback : public virtual RefBase {
+public:
+ virtual void closeThreadInternal_l(const sp<IAfPlaybackThread>& thread) = 0;
+ virtual void closeThreadInternal_l(const sp<IAfRecordThread>& thread) = 0;
+ virtual IAfPlaybackThread* primaryPlaybackThread_l() const = 0;
+ virtual IAfPlaybackThread* checkPlaybackThread_l(audio_io_handle_t output) const = 0;
+ virtual IAfRecordThread* checkRecordThread_l(audio_io_handle_t input) const = 0;
+ virtual IAfMmapThread* checkMmapThread_l(audio_io_handle_t io) const = 0;
+ virtual sp<IAfThreadBase> openInput_l(audio_module_handle_t module,
+ audio_io_handle_t* input,
+ audio_config_t* config,
+ audio_devices_t device,
+ const char* address,
+ audio_source_t source,
+ audio_input_flags_t flags,
+ audio_devices_t outputDevice,
+ const String8& outputDeviceAddress) = 0;
+ virtual sp<IAfThreadBase> openOutput_l(audio_module_handle_t module,
+ audio_io_handle_t* output,
+ audio_config_t* halConfig,
+ audio_config_base_t* mixerConfig,
+ audio_devices_t deviceType,
+ const String8& address,
+ audio_output_flags_t flags) = 0;
+ virtual void lock() const = 0;
+ virtual void unlock() const = 0;
+ virtual const DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*>&
+ getAudioHwDevs_l() const = 0;
+ virtual audio_unique_id_t nextUniqueId(audio_unique_id_use_t use) = 0;
+ virtual const sp<PatchCommandThread>& getPatchCommandThread() = 0;
+ virtual void updateDownStreamPatches_l(
+ const struct audio_patch* patch, const std::set<audio_io_handle_t>& streams) = 0;
+ virtual void updateOutDevicesForRecordThreads_l(const DeviceDescriptorBaseVector& devices) = 0;
+};
+
class IAfPatchPanel : public virtual RefBase {
public:
- static sp<IAfPatchPanel> create(AudioFlinger* audioFlinger);
+ static sp<IAfPatchPanel> create(const sp<IAfPatchPanelCallback>& afPatchPanelCallback);
// Extraction of inner Endpoint and Patch classes would require interfaces
// (in the Endpoint case a templated interface) but that seems
diff --git a/services/audioflinger/IAfThread.h b/services/audioflinger/IAfThread.h
index ce4d62d..deb019f 100644
--- a/services/audioflinger/IAfThread.h
+++ b/services/audioflinger/IAfThread.h
@@ -26,6 +26,50 @@
class IAfMmapPlaybackThread;
class IAfPlaybackThread;
class IAfRecordThread;
+class MelReporter;
+
+// Note this is exposed through IAfThreadBase::afThreadCallback()
+// and hence may be used by the Effect / Track framework.
+class IAfThreadCallback : public virtual RefBase {
+public:
+ virtual Mutex& mutex() const = 0;
+ virtual bool isNonOffloadableGlobalEffectEnabled_l() const = 0; // Tracks
+ virtual audio_unique_id_t nextUniqueId(audio_unique_id_use_t use) = 0;
+ virtual bool btNrecIsOff() const = 0;
+ virtual float masterVolume_l() const = 0;
+ virtual bool masterMute_l() const = 0;
+ virtual float getMasterBalance_l() const = 0;
+ virtual bool streamMute_l(audio_stream_type_t stream) const = 0;
+ virtual audio_mode_t getMode() const = 0;
+ virtual bool isLowRamDevice() const = 0;
+ virtual bool isAudioPolicyReady() const = 0; // Effects
+ virtual std::optional<media::AudioVibratorInfo> getDefaultVibratorInfo_l() const = 0;
+ virtual const sp<IAfPatchPanel>& getPatchPanel() const = 0;
+ virtual const sp<MelReporter>& getMelReporter() const = 0;
+ virtual const sp<EffectsFactoryHalInterface>& getEffectsFactoryHal() const = 0;
+ virtual sp<IAudioManager> getOrCreateAudioManager() = 0; // Tracks
+
+ virtual bool updateOrphanEffectChains(const sp<IAfEffectModule>& effect) = 0;
+ virtual status_t moveEffectChain_l(audio_session_t sessionId,
+ IAfPlaybackThread* srcThread, IAfPlaybackThread* dstThread) = 0;
+
+ virtual void requestLogMerge() = 0;
+ virtual sp<NBLog::Writer> newWriter_l(size_t size, const char *name) = 0;
+ virtual void unregisterWriter(const sp<NBLog::Writer>& writer) = 0;
+
+ virtual sp<audioflinger::SyncEvent> createSyncEvent(AudioSystem::sync_event_t type,
+ audio_session_t triggerSession,
+ audio_session_t listenerSession,
+ const audioflinger::SyncEventCallback& callBack,
+ const wp<IAfTrackBase>& cookie) = 0;
+
+ virtual void ioConfigChanged(audio_io_config_event_t event,
+ const sp<AudioIoDescriptor>& ioDesc,
+ pid_t pid = 0) = 0;
+ virtual void onNonOffloadableGlobalEffectEnable() = 0;
+ virtual void onSupportedLatencyModesChanged(
+ audio_io_handle_t output, const std::vector<audio_latency_mode_t>& modes) = 0;
+};
class IAfThreadBase : public virtual RefBase {
public:
@@ -250,30 +294,31 @@
virtual sp<IAfDuplicatingThread> asIAfDuplicatingThread() { return nullptr; }
virtual sp<IAfPlaybackThread> asIAfPlaybackThread() { return nullptr; }
virtual sp<IAfRecordThread> asIAfRecordThread() { return nullptr; }
- virtual AudioFlinger* audioFlinger() const = 0;
+ virtual IAfThreadCallback* afThreadCallback() const = 0;
};
class IAfPlaybackThread : public virtual IAfThreadBase, public virtual VolumeInterface {
public:
static sp<IAfPlaybackThread> createBitPerfectThread(
- const sp<AudioFlinger>& audioflinger, AudioStreamOut* output, audio_io_handle_t id,
- bool systemReady);
+ const sp<IAfThreadCallback>& afThreadCallback, AudioStreamOut* output,
+ audio_io_handle_t id, bool systemReady);
static sp<IAfPlaybackThread> createDirectOutputThread(
- const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, audio_io_handle_t id,
- bool systemReady, const audio_offload_info_t& offloadInfo);
+ const sp<IAfThreadCallback>& afThreadCallback, AudioStreamOut* output,
+ audio_io_handle_t id, bool systemReady, const audio_offload_info_t& offloadInfo);
static sp<IAfPlaybackThread> createMixerThread(
- const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, audio_io_handle_t id,
- bool systemReady, type_t type = MIXER, audio_config_base_t* mixerConfig = nullptr);
+ const sp<IAfThreadCallback>& afThreadCallback, AudioStreamOut* output,
+ audio_io_handle_t id, bool systemReady, type_t type = MIXER,
+ audio_config_base_t* mixerConfig = nullptr);
static sp<IAfPlaybackThread> createOffloadThread(
- const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, audio_io_handle_t id,
- bool systemReady, const audio_offload_info_t& offloadInfo);
+ const sp<IAfThreadCallback>& afThreadCallback, AudioStreamOut* output,
+ audio_io_handle_t id, bool systemReady, const audio_offload_info_t& offloadInfo);
static sp<IAfPlaybackThread> createSpatializerThread(
- const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, audio_io_handle_t id,
- bool systemReady, audio_config_base_t* mixerConfig);
+ const sp<IAfThreadCallback>& afThreadCallback, AudioStreamOut* output,
+ audio_io_handle_t id, bool systemReady, audio_config_base_t* mixerConfig);
static constexpr int8_t kMaxTrackStopRetriesOffload = 2;
@@ -388,7 +433,7 @@
class IAfDuplicatingThread : public virtual IAfPlaybackThread {
public:
static sp<IAfDuplicatingThread> create(
- const sp<AudioFlinger>& audioFlinger, IAfPlaybackThread* mainThread,
+ const sp<IAfThreadCallback>& afThreadCallback, IAfPlaybackThread* mainThread,
audio_io_handle_t id, bool systemReady);
virtual void addOutputTrack(IAfPlaybackThread* thread) = 0;
@@ -399,8 +444,8 @@
class IAfRecordThread : public virtual IAfThreadBase {
public:
static sp<IAfRecordThread> create(
- const sp<AudioFlinger>& audioFlinger, AudioStreamIn* input, audio_io_handle_t id,
- bool systemReady);
+ const sp<IAfThreadCallback>& afThreadCallback, AudioStreamIn* input,
+ audio_io_handle_t id, bool systemReady);
virtual sp<IAfRecordTrack> createRecordTrack_l(
const sp<Client>& client,
@@ -499,8 +544,8 @@
class IAfMmapPlaybackThread : public virtual IAfMmapThread, public virtual VolumeInterface {
public:
static sp<IAfMmapPlaybackThread> create(
- const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, AudioHwDevice* hwDev,
- AudioStreamOut* output, bool systemReady);
+ const sp<IAfThreadCallback>& afThreadCallback, audio_io_handle_t id,
+ AudioHwDevice* hwDev, AudioStreamOut* output, bool systemReady);
virtual AudioStreamOut* clearOutput() = 0;
};
@@ -508,8 +553,8 @@
class IAfMmapCaptureThread : public virtual IAfMmapThread {
public:
static sp<IAfMmapCaptureThread> create(
- const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, AudioHwDevice* hwDev,
- AudioStreamIn* input, bool systemReady);
+ const sp<IAfThreadCallback>& afThreadCallback, audio_io_handle_t id,
+ AudioHwDevice* hwDev, AudioStreamIn* input, bool systemReady);
virtual AudioStreamIn* clearInput() = 0;
};
diff --git a/services/audioflinger/MelReporter.cpp b/services/audioflinger/MelReporter.cpp
index 0f739b0..35400e1 100644
--- a/services/audioflinger/MelReporter.cpp
+++ b/services/audioflinger/MelReporter.cpp
@@ -77,7 +77,7 @@
}
void MelReporter::onFirstRef() {
- mAudioFlinger.mPatchCommandThread->addListener(this);
+ mAfMelReporterCallback->getPatchCommandThread()->addListener(this);
}
bool MelReporter::shouldComputeMelForDeviceType(audio_devices_t device) {
@@ -111,7 +111,7 @@
return;
}
- std::lock_guard _laf(mAudioFlinger.mLock);
+ std::lock_guard _laf(mAfMelReporterCallback->mutex());
std::lock_guard _l(mLock);
auto activeMelPatchId = activePatchStreamHandle_l(streamHandle);
if (!activeMelPatchId) {
@@ -171,7 +171,7 @@
}
if (!newPatch.deviceHandles.empty()) {
- std::lock_guard _afl(mAudioFlinger.mLock);
+ std::lock_guard _afl(mAfMelReporterCallback->mutex());
std::lock_guard _l(mLock);
ALOGV("%s add patch handle %d to active devices", __func__, handle);
startMelComputationForActivePatch_l(newPatch);
@@ -183,7 +183,7 @@
void MelReporter::startMelComputationForActivePatch_l(const ActiveMelPatch& patch)
NO_THREAD_SAFETY_ANALYSIS // access of AudioFlinger::checkOutputThread_l
{
- auto outputThread = mAudioFlinger.checkOutputThread_l(patch.streamHandle);
+ auto outputThread = mAfMelReporterCallback->checkOutputThread_l(patch.streamHandle);
if (outputThread == nullptr) {
ALOGE("%s cannot find thread for stream handle %d", __func__, patch.streamHandle);
return;
@@ -226,7 +226,7 @@
mActiveMelPatches.erase(patchIt);
}
- std::lock_guard _afl(mAudioFlinger.mLock);
+ std::lock_guard _afl(mAfMelReporterCallback->mutex());
std::lock_guard _l(mLock);
stopMelComputationForPatch_l(melPatch);
}
@@ -258,7 +258,7 @@
return;
}
- auto outputThread = mAudioFlinger.checkOutputThread_l(patch.streamHandle);
+ auto outputThread = mAfMelReporterCallback->checkOutputThread_l(patch.streamHandle);
ALOGV("%s: stop MEL for stream id: %d", __func__, patch.streamHandle);
for (const auto& deviceId : patch.deviceHandles) {
diff --git a/services/audioflinger/MelReporter.h b/services/audioflinger/MelReporter.h
index f191c9c..0dbb5f8 100644
--- a/services/audioflinger/MelReporter.h
+++ b/services/audioflinger/MelReporter.h
@@ -25,14 +25,21 @@
constexpr static int kMaxTimestampDeltaInSec = 120;
+class IAfMelReporterCallback : public virtual RefBase {
+public:
+ virtual Mutex& mutex() const = 0;
+ virtual const sp<PatchCommandThread>& getPatchCommandThread() = 0;
+ virtual sp<IAfThreadBase> checkOutputThread_l(audio_io_handle_t ioHandle) const = 0;
+};
+
/**
* Class for listening to new patches and starting the MEL computation. MelReporter is
* concealed within AudioFlinger, their lifetimes are the same.
*/
class MelReporter : public PatchCommandThread::PatchCommandListener {
public:
- explicit MelReporter(AudioFlinger& audioFlinger)
- : mAudioFlinger(audioFlinger),
+ explicit MelReporter(const sp<IAfMelReporterCallback>& afMelReporterCallback)
+ : mAfMelReporterCallback(afMelReporterCallback),
mSoundDoseManager(sp<SoundDoseManager>::make()) {}
void onFirstRef() override;
@@ -103,7 +110,7 @@
bool useHalSoundDoseInterface_l() REQUIRES(mLock);
- AudioFlinger& mAudioFlinger; // does not own the object
+ const sp<IAfMelReporterCallback> mAfMelReporterCallback;
sp<SoundDoseManager> mSoundDoseManager;
diff --git a/services/audioflinger/PatchPanel.cpp b/services/audioflinger/PatchPanel.cpp
index bede225..3251345 100644
--- a/services/audioflinger/PatchPanel.cpp
+++ b/services/audioflinger/PatchPanel.cpp
@@ -50,14 +50,14 @@
/* List connected audio ports and their attributes */
status_t AudioFlinger::listAudioPorts(unsigned int *num_ports,
- struct audio_port *ports)
+ struct audio_port* ports) const
{
Mutex::Autolock _l(mLock);
return mPatchPanel->listAudioPorts(num_ports, ports);
}
/* Get supported attributes for a given audio port */
-status_t AudioFlinger::getAudioPort(struct audio_port_v7 *port) {
+status_t AudioFlinger::getAudioPort(struct audio_port_v7* port) const {
status_t status = AudioValidator::validateAudioPort(*port);
if (status != NO_ERROR) {
return status;
@@ -88,16 +88,16 @@
}
/* List connected audio ports and they attributes */
-status_t AudioFlinger::listAudioPatches(unsigned int *num_patches,
- struct audio_patch *patches)
+status_t AudioFlinger::listAudioPatches(
+ unsigned int* num_patches, struct audio_patch* patches) const
{
Mutex::Autolock _l(mLock);
return mPatchPanel->listAudioPatches(num_patches, patches);
}
/* static */
-sp<IAfPatchPanel> IAfPatchPanel::create(AudioFlinger* audioFlinger) {
- return sp<PatchPanel>::make(audioFlinger);
+sp<IAfPatchPanel> IAfPatchPanel::create(const sp<IAfPatchPanelCallback>& afPatchPanelCallback) {
+ return sp<PatchPanel>::make(afPatchPanelCallback);
}
status_t SoftwarePatch::getLatencyMs_l(double* latencyMs) const {
@@ -119,10 +119,10 @@
{
if (const auto recordThread = thread->asIAfRecordThread();
recordThread) {
- mAudioFlinger.closeThreadInternal_l(recordThread);
+ mAfPatchPanelCallback->closeThreadInternal_l(recordThread);
} else if (const auto playbackThread = thread->asIAfPlaybackThread();
playbackThread) {
- mAudioFlinger.closeThreadInternal_l(playbackThread);
+ mAfPatchPanelCallback->closeThreadInternal_l(playbackThread);
} else {
LOG_ALWAYS_FATAL("%s: Endpoints only accept IAfPlayback and IAfRecord threads, "
"invalid thread, id: %d type: %d",
@@ -281,8 +281,8 @@
status = INVALID_OPERATION;
goto exit;
}
- const sp<IAfThreadBase> thread =
- mAudioFlinger.checkPlaybackThread_l(patch->sources[1].ext.mix.handle);
+ const sp<IAfThreadBase> thread = mAfPatchPanelCallback->checkPlaybackThread_l(
+ patch->sources[1].ext.mix.handle);
if (thread == 0) {
ALOGW("%s() cannot get playback thread", __func__);
status = INVALID_OPERATION;
@@ -308,7 +308,7 @@
if (patch->sinks[0].config_mask & AUDIO_PORT_CONFIG_FLAGS) {
flags = patch->sinks[0].flags.output;
}
- const sp<IAfThreadBase> thread = mAudioFlinger.openOutput_l(
+ const sp<IAfThreadBase> thread = mAfPatchPanelCallback->openOutput_l(
patch->sinks[0].ext.device.hw_module,
&output,
&config,
@@ -316,7 +316,7 @@
outputDevice,
outputDeviceAddress,
flags);
- ALOGV("mAudioFlinger.openOutput_l() returned %p", thread.get());
+ ALOGV("mAfPatchPanelCallback->openOutput_l() returned %p", thread.get());
if (thread == 0) {
status = NO_MEMORY;
goto exit;
@@ -355,7 +355,7 @@
== AUDIO_STREAM_VOICE_CALL) {
source = AUDIO_SOURCE_VOICE_COMMUNICATION;
}
- const sp<IAfThreadBase> thread = mAudioFlinger.openInput_l(srcModule,
+ const sp<IAfThreadBase> thread = mAfPatchPanelCallback->openInput_l(srcModule,
&input,
&config,
device,
@@ -364,7 +364,7 @@
flags,
outputDevice,
outputDeviceAddress);
- ALOGV("mAudioFlinger.openInput_l() returned %p inChannelMask %08x",
+ ALOGV("mAfPatchPanelCallback->openInput_l() returned %p inChannelMask %08x",
thread.get(), config.channel_mask);
if (thread == 0) {
status = NO_MEMORY;
@@ -380,10 +380,11 @@
}
} else {
if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
- sp<IAfThreadBase> thread = mAudioFlinger.checkRecordThread_l(
+ sp<IAfThreadBase> thread = mAfPatchPanelCallback->checkRecordThread_l(
patch->sinks[0].ext.mix.handle);
if (thread == 0) {
- thread = mAudioFlinger.checkMmapThread_l(patch->sinks[0].ext.mix.handle);
+ thread = mAfPatchPanelCallback->checkMmapThread_l(
+ patch->sinks[0].ext.mix.handle);
if (thread == 0) {
ALOGW("%s() bad capture I/O handle %d",
__func__, patch->sinks[0].ext.mix.handle);
@@ -391,9 +392,9 @@
goto exit;
}
}
- mAudioFlinger.unlock();
+ mAfPatchPanelCallback->unlock();
status = thread->sendCreateAudioPatchConfigEvent(patch, &halHandle);
- mAudioFlinger.lock();
+ mAfPatchPanelCallback->lock();
if (status == NO_ERROR) {
newPatch.setThread(thread);
}
@@ -417,7 +418,7 @@
} break;
case AUDIO_PORT_TYPE_MIX: {
audio_module_handle_t srcModule = patch->sources[0].ext.mix.hw_module;
- ssize_t index = mAudioFlinger.mAudioHwDevs.indexOfKey(srcModule);
+ ssize_t index = mAfPatchPanelCallback->getAudioHwDevs_l().indexOfKey(srcModule);
if (index < 0) {
ALOGW("%s() bad src hw module %d", __func__, srcModule);
status = BAD_VALUE;
@@ -443,10 +444,11 @@
device->applyAudioPortConfig(&patch->sinks[i]);
devices.push_back(device);
}
- sp<IAfThreadBase> thread =
- mAudioFlinger.checkPlaybackThread_l(patch->sources[0].ext.mix.handle);
+ sp<IAfThreadBase> thread = mAfPatchPanelCallback->checkPlaybackThread_l(
+ patch->sources[0].ext.mix.handle);
if (thread == 0) {
- thread = mAudioFlinger.checkMmapThread_l(patch->sources[0].ext.mix.handle);
+ thread = mAfPatchPanelCallback->checkMmapThread_l(
+ patch->sources[0].ext.mix.handle);
if (thread == 0) {
ALOGW("%s() bad playback I/O handle %d",
__func__, patch->sources[0].ext.mix.handle);
@@ -454,13 +456,13 @@
goto exit;
}
}
- if (thread == mAudioFlinger.primaryPlaybackThread_l()) {
- mAudioFlinger.updateOutDevicesForRecordThreads_l(devices);
+ if (thread == mAfPatchPanelCallback->primaryPlaybackThread_l()) {
+ mAfPatchPanelCallback->updateOutDevicesForRecordThreads_l(devices);
}
- mAudioFlinger.unlock();
+ mAfPatchPanelCallback->unlock();
status = thread->sendCreateAudioPatchConfigEvent(patch, &halHandle);
- mAudioFlinger.lock();
+ mAfPatchPanelCallback->lock();
if (status == NO_ERROR) {
newPatch.setThread(thread);
}
@@ -485,12 +487,14 @@
exit:
ALOGV("%s() status %d", __func__, status);
if (status == NO_ERROR) {
- *handle = (audio_patch_handle_t) mAudioFlinger.nextUniqueId(AUDIO_UNIQUE_ID_USE_PATCH);
+ *handle = static_cast<audio_patch_handle_t>(
+ mAfPatchPanelCallback->nextUniqueId(AUDIO_UNIQUE_ID_USE_PATCH));
newPatch.mHalHandle = halHandle;
if (reuseExistingHalPatch) {
- mAudioFlinger.mPatchCommandThread->updateAudioPatch(oldhandle, *handle, newPatch);
+ mAfPatchPanelCallback->getPatchCommandThread()->updateAudioPatch(
+ oldhandle, *handle, newPatch);
} else {
- mAudioFlinger.mPatchCommandThread->createAudioPatch(*handle, newPatch);
+ mAfPatchPanelCallback->getPatchCommandThread()->createAudioPatch(*handle, newPatch);
}
if (insertedModule != AUDIO_MODULE_HANDLE_NONE) {
addSoftwarePatchToInsertedModules(insertedModule, *handle, &newPatch.mAudioPatch);
@@ -803,18 +807,18 @@
if (patch.sinks[0].type == AUDIO_PORT_TYPE_MIX) {
audio_io_handle_t ioHandle = patch.sinks[0].ext.mix.handle;
- sp<IAfThreadBase> thread = mAudioFlinger.checkRecordThread_l(ioHandle);
+ sp<IAfThreadBase> thread = mAfPatchPanelCallback->checkRecordThread_l(ioHandle);
if (thread == 0) {
- thread = mAudioFlinger.checkMmapThread_l(ioHandle);
+ thread = mAfPatchPanelCallback->checkMmapThread_l(ioHandle);
if (thread == 0) {
ALOGW("%s() bad capture I/O handle %d", __func__, ioHandle);
status = BAD_VALUE;
break;
}
}
- mAudioFlinger.unlock();
+ mAfPatchPanelCallback->unlock();
status = thread->sendReleaseAudioPatchConfigEvent(removedPatch.mHalHandle);
- mAudioFlinger.lock();
+ mAfPatchPanelCallback->lock();
} else {
status = hwDevice->releaseAudioPatch(removedPatch.mHalHandle);
}
@@ -826,18 +830,18 @@
break;
}
audio_io_handle_t ioHandle = src.ext.mix.handle;
- sp<IAfThreadBase> thread = mAudioFlinger.checkPlaybackThread_l(ioHandle);
+ sp<IAfThreadBase> thread = mAfPatchPanelCallback->checkPlaybackThread_l(ioHandle);
if (thread == 0) {
- thread = mAudioFlinger.checkMmapThread_l(ioHandle);
+ thread = mAfPatchPanelCallback->checkMmapThread_l(ioHandle);
if (thread == 0) {
ALOGW("%s() bad playback I/O handle %d", __func__, ioHandle);
status = BAD_VALUE;
break;
}
}
- mAudioFlinger.unlock();
+ mAfPatchPanelCallback->unlock();
status = thread->sendReleaseAudioPatchConfigEvent(removedPatch.mHalHandle);
- mAudioFlinger.lock();
+ mAfPatchPanelCallback->lock();
} break;
default:
status = BAD_VALUE;
@@ -851,7 +855,7 @@
mPatches.erase(handle);
removeSoftwarePatchFromInsertedModules(handle);
if (!reuseExistingHalPatch) {
- mAudioFlinger.mPatchCommandThread->releaseAudioPatch(handle);
+ mAfPatchPanelCallback->getPatchCommandThread()->releaseAudioPatch(handle);
}
}
@@ -916,12 +920,12 @@
AudioHwDevice* PatchPanel::findAudioHwDeviceByModule(audio_module_handle_t module)
{
if (module == AUDIO_MODULE_HANDLE_NONE) return nullptr;
- ssize_t index = mAudioFlinger.mAudioHwDevs.indexOfKey(module);
+ ssize_t index = mAfPatchPanelCallback->getAudioHwDevs_l().indexOfKey(module);
if (index < 0) {
ALOGW("%s() bad hw module %d", __func__, module);
return nullptr;
}
- return mAudioFlinger.mAudioHwDevs.valueAt(index);
+ return mAfPatchPanelCallback->getAudioHwDevs_l().valueAt(index);
}
sp<DeviceHalInterface> PatchPanel::findHwDeviceByModule(audio_module_handle_t module)
@@ -936,7 +940,7 @@
{
mInsertedModules[module].sw_patches.insert(handle);
if (!mInsertedModules[module].streams.empty()) {
- mAudioFlinger.updateDownStreamPatches_l(patch, mInsertedModules[module].streams);
+ mAfPatchPanelCallback->updateDownStreamPatches_l(patch, mInsertedModules[module].streams);
}
}
diff --git a/services/audioflinger/PatchPanel.h b/services/audioflinger/PatchPanel.h
index 6ef4d1a..a80a0e0 100644
--- a/services/audioflinger/PatchPanel.h
+++ b/services/audioflinger/PatchPanel.h
@@ -21,7 +21,8 @@
class PatchPanel : public IAfPatchPanel {
public:
- explicit PatchPanel(AudioFlinger* audioFlinger) : mAudioFlinger(*audioFlinger) {}
+ explicit PatchPanel(const sp<IAfPatchPanelCallback>& afPatchPanelCallback)
+ : mAfPatchPanelCallback(afPatchPanelCallback) {}
/* List connected audio ports and their attributes */
status_t listAudioPorts(unsigned int *num_ports,
@@ -102,7 +103,7 @@
newPatch.sources[0].ext.mix.handle == oldPatch.sources[0].ext.mix.handle);
}
- AudioFlinger &mAudioFlinger;
+ const sp<IAfPatchPanelCallback> mAfPatchPanelCallback;
std::map<audio_patch_handle_t, Patch> mPatches;
// This map allows going from a thread to "downstream" software patches
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 9e29ba3..1e1d925 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -544,11 +544,11 @@
}
}
-ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
+ThreadBase::ThreadBase(const sp<IAfThreadCallback>& afThreadCallback, audio_io_handle_t id,
type_t type, bool systemReady, bool isOut)
: Thread(false /*canCallJava*/),
mType(type),
- mAudioFlinger(audioFlinger),
+ mAfThreadCallback(afThreadCallback),
mThreadMetrics(std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_THREAD) + std::to_string(id),
isOut),
mIsOut(isOut),
@@ -1588,7 +1588,7 @@
ALOGV("createEffect_l() got effect %p on chain %p", effect.get(), chain.get());
if (effect == 0) {
- effectId = mAudioFlinger->nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);
+ effectId = mAfThreadCallback->nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);
// create a new effect module if none present in the chain
lStatus = chain->createEffect_l(effect, desc, effectId, sessionId, pinned);
if (lStatus != NO_ERROR) {
@@ -1599,14 +1599,14 @@
// FIXME: use vector of device and address when effect interface is ready.
effect->setDevices(outDeviceTypeAddrs());
effect->setInputDevice(inDeviceTypeAddr());
- effect->setMode(mAudioFlinger->getMode());
+ effect->setMode(mAfThreadCallback->getMode());
effect->setAudioSource(mAudioSource);
}
if (effect->isHapticGenerator()) {
// TODO(b/184194057): Use the vibrator information from the vibrator that will be used
// for the HapticGenerator.
const std::optional<media::AudioVibratorInfo> defaultVibratorInfo =
- std::move(mAudioFlinger->getDefaultVibratorInfo_l());
+ std::move(mAfThreadCallback->getDefaultVibratorInfo_l());
if (defaultVibratorInfo) {
// Only set the vibrator info when it is a valid one.
effect->setVibratorInfo(*defaultVibratorInfo);
@@ -1664,7 +1664,7 @@
sendCheckOutputStageEffectsEvent_l();
}
if (remove) {
- mAudioFlinger->updateOrphanEffectChains(effect);
+ mAfThreadCallback->updateOrphanEffectChains(effect);
if (handle->enabled()) {
effect->checkSuspendOnEffectEnabled(false, false /*threadLocked*/);
}
@@ -1682,7 +1682,7 @@
t->invalidateTracks(AUDIO_STREAM_MUSIC);
}
if (effect->sessionId() == AUDIO_SESSION_OUTPUT_MIX) {
- mAudioFlinger->onNonOffloadableGlobalEffectEnable();
+ mAfThreadCallback->onNonOffloadableGlobalEffectEnable();
}
}
}
@@ -1755,7 +1755,7 @@
effect->setDevices(outDeviceTypeAddrs());
effect->setInputDevice(inDeviceTypeAddr());
- effect->setMode(mAudioFlinger->getMode());
+ effect->setMode(mAfThreadCallback->getMode());
effect->setAudioSource(mAudioSource);
return NO_ERROR;
@@ -2007,7 +2007,7 @@
product_strategy_t ThreadBase::getStrategyForStream(audio_stream_type_t stream) const
{
- if (!mAudioFlinger->isAudioPolicyReady()) {
+ if (!mAfThreadCallback->isAudioPolicyReady()) {
return PRODUCT_STRATEGY_NONE;
}
return AudioSystem::getStrategyForStream(stream);
@@ -2032,13 +2032,13 @@
// Playback
// ----------------------------------------------------------------------------
-PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger,
+PlaybackThread::PlaybackThread(const sp<IAfThreadCallback>& afThreadCallback,
AudioStreamOut* output,
audio_io_handle_t id,
type_t type,
bool systemReady,
audio_config_base_t *mixerConfig)
- : ThreadBase(audioFlinger, id, type, systemReady, true /* isOut */),
+ : ThreadBase(afThreadCallback, id, type, systemReady, true /* isOut */),
mNormalFrameCount(0), mSinkBuffer(NULL),
mMixerBufferEnabled(AudioFlinger::kEnableExtendedPrecision || type == SPATIALIZER),
mMixerBuffer(NULL),
@@ -2075,7 +2075,7 @@
mIsTimestampAdvancing(kMinimumTimeBetweenTimestampChecksNs)
{
snprintf(mThreadName, kThreadNameLength, "AudioOut_%X", id);
- mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mThreadName);
+ mNBLogWriter = afThreadCallback->newWriter_l(kLogSize, mThreadName);
// Assumes constructor is called by AudioFlinger with it's mLock held, but
// it would be safer to explicitly pass initial masterVolume/masterMute as
@@ -2084,8 +2084,8 @@
// If the HAL we are using has support for master volume or master mute,
// then do not attenuate or mute during mixing (just leave the volume at 1.0
// and the mute set to false).
- mMasterVolume = audioFlinger->masterVolume_l();
- mMasterMute = audioFlinger->masterMute_l();
+ mMasterVolume = afThreadCallback->masterVolume_l();
+ mMasterMute = afThreadCallback->masterMute_l();
if (mOutput->audioHwDev) {
if (mOutput->audioHwDev->canSetMasterVolume()) {
mMasterVolume = 1.0;
@@ -2123,7 +2123,7 @@
for (int i = AUDIO_STREAM_MIN; i < AUDIO_STREAM_FOR_POLICY_CNT; ++i) {
const audio_stream_type_t stream{static_cast<audio_stream_type_t>(i)};
mStreamTypes[stream].volume = 0.0f;
- mStreamTypes[stream].mute = mAudioFlinger->streamMute_l(stream);
+ mStreamTypes[stream].mute = mAfThreadCallback->streamMute_l(stream);
}
// Audio patch and call assistant volume are always max
mStreamTypes[AUDIO_STREAM_PATCH].volume = 1.0f;
@@ -2134,7 +2134,7 @@
PlaybackThread::~PlaybackThread()
{
- mAudioFlinger->unregisterWriter(mNBLogWriter);
+ mAfThreadCallback->unregisterWriter(mNBLogWriter);
free(mSinkBuffer);
free(mMixerBuffer);
free(mEffectBuffer);
@@ -2820,8 +2820,8 @@
{
// TODO(b/184194780): Use the vibrator information from the vibrator that will be
// used to play this track.
- Mutex::Autolock _l(mAudioFlinger->mLock);
- vibratorInfo = std::move(mAudioFlinger->getDefaultVibratorInfo_l());
+ Mutex::Autolock _l(mAfThreadCallback->mutex());
+ vibratorInfo = std::move(mAfThreadCallback->getDefaultVibratorInfo_l());
}
mLock.lock();
track->setHapticIntensity(intensity);
@@ -2946,7 +2946,7 @@
desc = sp<AudioIoDescriptor>::make(mId);
break;
}
- mAudioFlinger->ioConfigChanged(event, desc, pid);
+ mAfThreadCallback->ioConfigChanged(event, desc, pid);
}
void PlaybackThread::onWriteReady()
@@ -3190,7 +3190,7 @@
// create a copy of mEffectChains as calling moveEffectChain_l() can reorder some effect chains
Vector<sp<IAfEffectChain>> effectChains = mEffectChains;
for (size_t i = 0; i < effectChains.size(); i ++) {
- mAudioFlinger->moveEffectChain_l(effectChains[i]->sessionId(),
+ mAfThreadCallback->moveEffectChain_l(effectChains[i]->sessionId(),
this/* srcThread */, this/* dstThread */);
}
@@ -3620,12 +3620,12 @@
}
size_t numSamples = mNormalFrameCount
* (audio_channel_count_from_out_mask(channelMask) + mHapticChannelCount);
- status_t result = mAudioFlinger->mEffectsFactoryHal->allocateBuffer(
+ status_t result = mAfThreadCallback->getEffectsFactoryHal()->allocateBuffer(
numSamples * sizeof(float),
&halInBuffer);
if (result != OK) return result;
- result = mAudioFlinger->mEffectsFactoryHal->mirrorBuffer(
+ result = mAfThreadCallback->getEffectsFactoryHal()->mirrorBuffer(
isSessionSpatialized ? mEffectBuffer : mPostSpatializerBuffer,
isSessionSpatialized ? mEffectBufferSize : mPostSpatializerBufferSize,
&halOutBuffer);
@@ -3640,10 +3640,10 @@
// - OUTPUT_STAGE session uses the mEffectBuffer as input buffer and
// mPostSpatializerBuffer as output buffer
// - DEVICE session uses the mPostSpatializerBuffer as input and output buffer.
- status_t result = mAudioFlinger->mEffectsFactoryHal->mirrorBuffer(
+ status_t result = mAfThreadCallback->getEffectsFactoryHal()->mirrorBuffer(
mEffectBuffer, mEffectBufferSize, &halInBuffer);
if (result != OK) return result;
- result = mAudioFlinger->mEffectsFactoryHal->mirrorBuffer(
+ result = mAfThreadCallback->getEffectsFactoryHal()->mirrorBuffer(
mPostSpatializerBuffer, mPostSpatializerBufferSize, &halOutBuffer);
if (result != OK) return result;
@@ -3652,7 +3652,7 @@
}
}
} else {
- status_t result = mAudioFlinger->mEffectsFactoryHal->mirrorBuffer(
+ status_t result = mAfThreadCallback->getEffectsFactoryHal()->mirrorBuffer(
mEffectBufferEnabled ? mEffectBuffer : mSinkBuffer,
mEffectBufferEnabled ? mEffectBufferSize : mSinkBufferSize,
&halInBuffer);
@@ -3668,7 +3668,8 @@
size_t numSamples = mNormalFrameCount
* (audio_channel_count_from_out_mask(mMixerChannelMask)
+ mHapticChannelCount);
- const status_t allocateStatus = mAudioFlinger->mEffectsFactoryHal->allocateBuffer(
+ const status_t allocateStatus =
+ mAfThreadCallback->getEffectsFactoryHal()->allocateBuffer(
numSamples * sizeof(float),
&halInBuffer);
if (allocateStatus != OK) return allocateStatus;
@@ -3860,7 +3861,7 @@
{
// Log merge requests are performed during AudioFlinger binder transactions, but
// that does not cover audio playback. It's requested here for that reason.
- mAudioFlinger->requestLogMerge();
+ mAfThreadCallback->requestLogMerge();
cpuStats.sample(myName);
@@ -3875,12 +3876,12 @@
if (isMsdDevice() && outDeviceTypes().count(AUDIO_DEVICE_OUT_BUS) != 0) {
// Here, we try for the AF lock, but do not block on it as the latency
// is more informational.
- if (mAudioFlinger->mLock.tryLock() == NO_ERROR) {
+ if (mAfThreadCallback->mutex().tryLock() == NO_ERROR) {
std::vector<SoftwarePatch> swPatches;
double latencyMs = 0.; // not required; initialized for clang-tidy
status_t status = INVALID_OPERATION;
audio_patch_handle_t downstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
- if (mAudioFlinger->mPatchPanel->getDownstreamSoftwarePatches(
+ if (mAfThreadCallback->getPatchPanel()->getDownstreamSoftwarePatches(
id(), &swPatches) == OK
&& swPatches.size() > 0) {
status = swPatches[0].getLatencyMs_l(&latencyMs);
@@ -3902,7 +3903,7 @@
}
mDownstreamLatencyStatMs.add(latencyMs);
}
- mAudioFlinger->mLock.unlock();
+ mAfThreadCallback->mutex().unlock();
}
} else {
if (lastDownstreamPatchHandle != AUDIO_PATCH_HANDLE_NONE) {
@@ -4263,7 +4264,7 @@
unlockEffectChains(effectChains);
if (!metadataUpdate.playbackMetadataUpdate.empty()) {
- mAudioFlinger->mMelReporter->updateMetadataForCsd(id(),
+ mAfThreadCallback->getMelReporter()->updateMetadataForCsd(id(),
metadataUpdate.playbackMetadataUpdate);
}
@@ -4855,14 +4856,14 @@
/* static */
sp<IAfPlaybackThread> IAfPlaybackThread::createMixerThread(
- const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
+ const sp<IAfThreadCallback>& afThreadCallback, AudioStreamOut* output,
audio_io_handle_t id, bool systemReady, type_t type, audio_config_base_t* mixerConfig) {
- return sp<MixerThread>::make(audioFlinger, output, id, systemReady, type, mixerConfig);
+ return sp<MixerThread>::make(afThreadCallback, output, id, systemReady, type, mixerConfig);
}
-MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
+MixerThread::MixerThread(const sp<IAfThreadCallback>& afThreadCallback, AudioStreamOut* output,
audio_io_handle_t id, bool systemReady, type_t type, audio_config_base_t *mixerConfig)
- : PlaybackThread(audioFlinger, output, id, type, systemReady, mixerConfig),
+ : PlaybackThread(afThreadCallback, output, id, type, systemReady, mixerConfig),
// mAudioMixer below
// mFastMixer below
mBluetoothLatencyModesEnabled(false),
@@ -4872,7 +4873,7 @@
// mPipeSink below
// mNormalSink below
{
- setMasterBalance(audioFlinger->getMasterBalance_l());
+ setMasterBalance(afThreadCallback->getMasterBalance_l());
ALOGV("MixerThread() id=%d type=%d", id, type);
ALOGV("mSampleRate=%u, mChannelMask=%#x, mChannelCount=%u, mFormat=%#x, mFrameSize=%zu, "
"mFrameCount=%zu, mNormalFrameCount=%zu",
@@ -4999,7 +5000,7 @@
state->mColdFutexAddr = &mFastMixerFutex;
state->mColdGen++;
state->mDumpState = &mFastMixerDumpState;
- mFastMixerNBLogWriter = audioFlinger->newWriter_l(kFastMixerLogSize, "FastMixer");
+ mFastMixerNBLogWriter = afThreadCallback->newWriter_l(kFastMixerLogSize, "FastMixer");
state->mNBLogWriter = mFastMixerNBLogWriter.get();
sq->end();
sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
@@ -5078,7 +5079,7 @@
}
#endif
}
- mAudioFlinger->unregisterWriter(mFastMixerNBLogWriter);
+ mAfThreadCallback->unregisterWriter(mFastMixerNBLogWriter);
delete mAudioMixer;
}
@@ -5135,7 +5136,7 @@
}
state->mCommand = FastMixerState::MIX_WRITE;
#ifdef FAST_THREAD_STATISTICS
- mFastMixerDumpState.increaseSamplingN(mAudioFlinger->isLowRamDevice() ?
+ mFastMixerDumpState.increaseSamplingN(mAfThreadCallback->isLowRamDevice() ?
FastThreadDumpState::kSamplingNforLowRamDevice : FastThreadDumpState::kSamplingN);
#endif
sq->end();
@@ -5563,7 +5564,7 @@
float vlf = float_from_gain(gain_minifloat_unpack_left(vlr));
float vrf = float_from_gain(gain_minifloat_unpack_right(vlr));
- track->processMuteEvent_l(mAudioFlinger->getOrCreateAudioManager(),
+ track->processMuteEvent_l(mAfThreadCallback->getOrCreateAudioManager(),
/*muteState=*/{masterVolume == 0.f,
mStreamTypes[track->streamType()].volume == 0.f,
mStreamTypes[track->streamType()].mute,
@@ -5746,7 +5747,7 @@
vrf = GAIN_FLOAT_UNITY;
}
- track->processMuteEvent_l(mAudioFlinger->getOrCreateAudioManager(),
+ track->processMuteEvent_l(mAfThreadCallback->getOrCreateAudioManager(),
/*muteState=*/{masterVolume == 0.f,
mStreamTypes[track->streamType()].volume == 0.f,
mStreamTypes[track->streamType()].mute,
@@ -6314,7 +6315,7 @@
}
void MixerThread::onHalLatencyModesChanged_l() {
- mAudioFlinger->onSupportedLatencyModesChanged(mId, mSupportedLatencyModes);
+ mAfThreadCallback->onSupportedLatencyModesChanged(mId, mSupportedLatencyModes);
}
void MixerThread::setHalLatencyMode_l() {
@@ -6411,20 +6412,20 @@
/* static */
sp<IAfPlaybackThread> IAfPlaybackThread::createDirectOutputThread(
- const sp<AudioFlinger>& audioFlinger,
+ const sp<IAfThreadCallback>& afThreadCallback,
AudioStreamOut* output, audio_io_handle_t id, bool systemReady,
const audio_offload_info_t& offloadInfo) {
return sp<DirectOutputThread>::make(
- audioFlinger, output, id, systemReady, offloadInfo);
+ afThreadCallback, output, id, systemReady, offloadInfo);
}
-DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger,
+DirectOutputThread::DirectOutputThread(const sp<IAfThreadCallback>& afThreadCallback,
AudioStreamOut* output, audio_io_handle_t id, ThreadBase::type_t type, bool systemReady,
const audio_offload_info_t& offloadInfo)
- : PlaybackThread(audioFlinger, output, id, type, systemReady)
+ : PlaybackThread(afThreadCallback, output, id, type, systemReady)
, mOffloadInfo(offloadInfo)
{
- setMasterBalance(audioFlinger->getMasterBalance_l());
+ setMasterBalance(afThreadCallback->getMasterBalance_l());
}
DirectOutputThread::~DirectOutputThread()
@@ -6488,14 +6489,14 @@
}
left *= v;
right *= v;
- if (mAudioFlinger->getMode() != AUDIO_MODE_IN_COMMUNICATION
+ if (mAfThreadCallback->getMode() != AUDIO_MODE_IN_COMMUNICATION
|| audio_channel_count_from_out_mask(mChannelMask) > 1) {
left *= mMasterBalanceLeft; // DirectOutputThread balance applied as track volume
right *= mMasterBalanceRight;
}
}
- track->processMuteEvent_l(mAudioFlinger->getOrCreateAudioManager(),
+ track->processMuteEvent_l(mAfThreadCallback->getOrCreateAudioManager(),
/*muteState=*/{mMasterMute,
mStreamTypes[track->streamType()].volume == 0.f,
mStreamTypes[track->streamType()].mute,
@@ -7079,16 +7080,16 @@
/* static */
sp<IAfPlaybackThread> IAfPlaybackThread::createOffloadThread(
- const sp<AudioFlinger>& audioFlinger,
+ const sp<IAfThreadCallback>& afThreadCallback,
AudioStreamOut* output, audio_io_handle_t id, bool systemReady,
const audio_offload_info_t& offloadInfo) {
- return sp<OffloadThread>::make(audioFlinger, output, id, systemReady, offloadInfo);
+ return sp<OffloadThread>::make(afThreadCallback, output, id, systemReady, offloadInfo);
}
-OffloadThread::OffloadThread(const sp<AudioFlinger>& audioFlinger,
+OffloadThread::OffloadThread(const sp<IAfThreadCallback>& afThreadCallback,
AudioStreamOut* output, audio_io_handle_t id, bool systemReady,
const audio_offload_info_t& offloadInfo)
- : DirectOutputThread(audioFlinger, output, id, OFFLOAD, systemReady, offloadInfo),
+ : DirectOutputThread(afThreadCallback, output, id, OFFLOAD, systemReady, offloadInfo),
mPausedWriteLength(0), mPausedBytesRemaining(0), mKeepWakeLock(true)
{
//FIXME: mStandby should be set to true by ThreadBase constructo
@@ -7411,14 +7412,14 @@
/* static */
sp<IAfDuplicatingThread> IAfDuplicatingThread::create(
- const sp<AudioFlinger>& audioFlinger,
+ const sp<IAfThreadCallback>& afThreadCallback,
IAfPlaybackThread* mainThread, audio_io_handle_t id, bool systemReady) {
- return sp<DuplicatingThread>::make(audioFlinger, mainThread, id, systemReady);
+ return sp<DuplicatingThread>::make(afThreadCallback, mainThread, id, systemReady);
}
-DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger,
+DuplicatingThread::DuplicatingThread(const sp<IAfThreadCallback>& afThreadCallback,
IAfPlaybackThread* mainThread, audio_io_handle_t id, bool systemReady)
- : MixerThread(audioFlinger, mainThread->getOutput(), id,
+ : MixerThread(afThreadCallback, mainThread->getOutput(), id,
systemReady, DUPLICATING),
mWaitTimeMs(UINT_MAX)
{
@@ -7655,20 +7656,20 @@
/* static */
sp<IAfPlaybackThread> IAfPlaybackThread::createSpatializerThread(
- const sp<AudioFlinger>& audioFlinger,
+ const sp<IAfThreadCallback>& afThreadCallback,
AudioStreamOut* output,
audio_io_handle_t id,
bool systemReady,
audio_config_base_t* mixerConfig) {
- return sp<SpatializerThread>::make(audioFlinger, output, id, systemReady, mixerConfig);
+ return sp<SpatializerThread>::make(afThreadCallback, output, id, systemReady, mixerConfig);
}
-SpatializerThread::SpatializerThread(const sp<AudioFlinger>& audioFlinger,
+SpatializerThread::SpatializerThread(const sp<IAfThreadCallback>& afThreadCallback,
AudioStreamOut* output,
audio_io_handle_t id,
bool systemReady,
audio_config_base_t *mixerConfig)
- : MixerThread(audioFlinger, output, id, systemReady, SPATIALIZER, mixerConfig)
+ : MixerThread(afThreadCallback, output, id, systemReady, SPATIALIZER, mixerConfig)
{
}
@@ -7759,7 +7760,7 @@
finalDownMixer.clear();
} else if (!hasDownMixer) {
std::vector<effect_descriptor_t> descriptors;
- status_t status = mAudioFlinger->mEffectsFactoryHal->getDescriptors(
+ status_t status = mAfThreadCallback->getEffectsFactoryHal()->getDescriptors(
EFFECT_UIID_DOWNMIX, &descriptors);
if (status != NO_ERROR) {
return;
@@ -7790,19 +7791,19 @@
// Record
// ----------------------------------------------------------------------------
-sp<IAfRecordThread> IAfRecordThread::create(const sp<AudioFlinger>& audioFlinger,
+sp<IAfRecordThread> IAfRecordThread::create(const sp<IAfThreadCallback>& afThreadCallback,
AudioStreamIn* input,
audio_io_handle_t id,
bool systemReady) {
- return sp<RecordThread>::make(audioFlinger, input, id, systemReady);
+ return sp<RecordThread>::make(afThreadCallback, input, id, systemReady);
}
-RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger,
+RecordThread::RecordThread(const sp<IAfThreadCallback>& afThreadCallback,
AudioStreamIn *input,
audio_io_handle_t id,
bool systemReady
) :
- ThreadBase(audioFlinger, id, RECORD, systemReady, false /* isOut */),
+ ThreadBase(afThreadCallback, id, RECORD, systemReady, false /* isOut */),
mInput(input),
mSource(mInput),
mActiveTracks(&this->mLocalLog),
@@ -7823,7 +7824,7 @@
, mBtNrecSuspended(false)
{
snprintf(mThreadName, kThreadNameLength, "AudioIn_%X", id);
- mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mThreadName);
+ mNBLogWriter = afThreadCallback->newWriter_l(kLogSize, mThreadName);
if (mInput->audioHwDev != nullptr) {
mIsMsdDevice = strcmp(
@@ -7931,7 +7932,8 @@
#ifdef TEE_SINK
// FIXME
#endif
- mFastCaptureNBLogWriter = audioFlinger->newWriter_l(kFastCaptureLogSize, "FastCapture");
+ mFastCaptureNBLogWriter =
+ afThreadCallback->newWriter_l(kFastCaptureLogSize, "FastCapture");
state->mNBLogWriter = mFastCaptureNBLogWriter.get();
sq->end();
sq->push(FastCaptureStateQueue::BLOCK_UNTIL_PUSHED);
@@ -7973,8 +7975,8 @@
mFastCapture->join();
mFastCapture.clear();
}
- mAudioFlinger->unregisterWriter(mFastCaptureNBLogWriter);
- mAudioFlinger->unregisterWriter(mNBLogWriter);
+ mAfThreadCallback->unregisterWriter(mFastCaptureNBLogWriter);
+ mAfThreadCallback->unregisterWriter(mNBLogWriter);
free(mRsmpInBuffer);
}
@@ -8202,7 +8204,7 @@
}
state->mCommand = FastCaptureState::READ_WRITE;
#if 0 // FIXME
- mFastCaptureDumpState.increaseSamplingN(mAudioFlinger->isLowRamDevice() ?
+ mFastCaptureDumpState.increaseSamplingN(mAfThreadCallback->isLowRamDevice() ?
FastThreadDumpState::kSamplingNforLowRamDevice :
FastThreadDumpState::kSamplingN);
#endif
@@ -8821,7 +8823,7 @@
recordTrack->clearSyncStartEvent();
} else if (event != AudioSystem::SYNC_EVENT_SAME) {
recordTrack->synchronizedRecordState().startRecording(
- mAudioFlinger->createSyncEvent(
+ mAfThreadCallback->createSyncEvent(
event, triggerSession,
recordTrack->sessionId(), syncStartEventCallback, recordTrack));
}
@@ -9313,7 +9315,7 @@
// disable AEC and NS if the device is a BT SCO headset supporting those
// pre processings
bool suspend = audio_is_bluetooth_sco_device(inDeviceType()) &&
- mAudioFlinger->btNrecIsOff();
+ mAfThreadCallback->btNrecIsOff();
if (mBtNrecSuspended.exchange(suspend) != suspend) {
for (size_t i = 0; i < mEffectChains.size(); i++) {
setEffectSuspended_l(FX_IID_AEC, suspend, mEffectChains[i]->sessionId());
@@ -9441,7 +9443,7 @@
desc = sp<AudioIoDescriptor>::make(mId);
break;
}
- mAudioFlinger->ioConfigChanged(event, desc, pid);
+ mAfThreadCallback->ioConfigChanged(event, desc, pid);
}
void RecordThread::readInputParameters_l()
@@ -9885,9 +9887,9 @@
MmapThread::MmapThread(
- const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
+ const sp<IAfThreadCallback>& afThreadCallback, audio_io_handle_t id,
AudioHwDevice *hwDev, const sp<StreamHalInterface>& stream, bool systemReady, bool isOut)
- : ThreadBase(audioFlinger, id, (isOut ? MMAP_PLAYBACK : MMAP_CAPTURE), systemReady, isOut),
+ : ThreadBase(afThreadCallback, id, (isOut ? MMAP_PLAYBACK : MMAP_CAPTURE), systemReady, isOut),
mSessionId(AUDIO_SESSION_NONE),
mPortId(AUDIO_PORT_HANDLE_NONE),
mHalStream(stream), mHalDevice(hwDev->hwDevice()), mAudioHwDev(hwDev),
@@ -10357,7 +10359,7 @@
desc = sp<AudioIoDescriptor>::make(mId);
break;
}
- mAudioFlinger->ioConfigChanged(event, desc, pid);
+ mAfThreadCallback->ioConfigChanged(event, desc, pid);
}
status_t MmapThread::createAudioPatch_l(const struct audio_patch* patch,
@@ -10643,27 +10645,27 @@
/* static */
sp<IAfMmapPlaybackThread> IAfMmapPlaybackThread::create(
- const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
+ const sp<IAfThreadCallback>& afThreadCallback, audio_io_handle_t id,
AudioHwDevice* hwDev, AudioStreamOut* output, bool systemReady) {
- return sp<MmapPlaybackThread>::make(audioFlinger, id, hwDev, output, systemReady);
+ return sp<MmapPlaybackThread>::make(afThreadCallback, id, hwDev, output, systemReady);
}
MmapPlaybackThread::MmapPlaybackThread(
- const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
+ const sp<IAfThreadCallback>& afThreadCallback, audio_io_handle_t id,
AudioHwDevice *hwDev, AudioStreamOut *output, bool systemReady)
- : MmapThread(audioFlinger, id, hwDev, output->stream, systemReady, true /* isOut */),
+ : MmapThread(afThreadCallback, id, hwDev, output->stream, systemReady, true /* isOut */),
mStreamType(AUDIO_STREAM_MUSIC),
mOutput(output)
{
snprintf(mThreadName, kThreadNameLength, "AudioMmapOut_%X", id);
mChannelCount = audio_channel_count_from_out_mask(mChannelMask);
- mMasterVolume = audioFlinger->masterVolume_l();
- mMasterMute = audioFlinger->masterMute_l();
+ mMasterVolume = afThreadCallback->masterVolume_l();
+ mMasterMute = afThreadCallback->masterMute_l();
for (int i = AUDIO_STREAM_MIN; i < AUDIO_STREAM_FOR_POLICY_CNT; ++i) {
const audio_stream_type_t stream{static_cast<audio_stream_type_t>(i)};
mStreamTypes[stream].volume = 0.0f;
- mStreamTypes[stream].mute = mAudioFlinger->streamMute_l(stream);
+ mStreamTypes[stream].mute = mAfThreadCallback->streamMute_l(stream);
}
// Audio patch and call assistant volume are always max
mStreamTypes[AUDIO_STREAM_PATCH].volume = 1.0f;
@@ -10821,7 +10823,7 @@
}
for (const sp<IAfMmapTrack>& track : mActiveTracks) {
track->setMetadataHasChanged();
- track->processMuteEvent_l(mAudioFlinger->getOrCreateAudioManager(),
+ track->processMuteEvent_l(mAfThreadCallback->getOrCreateAudioManager(),
/*muteState=*/{mMasterMute,
streamVolume_l() == 0.f,
streamMuted_l(),
@@ -10943,15 +10945,15 @@
/* static */
sp<IAfMmapCaptureThread> IAfMmapCaptureThread::create(
- const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
+ const sp<IAfThreadCallback>& afThreadCallback, audio_io_handle_t id,
AudioHwDevice* hwDev, AudioStreamIn* input, bool systemReady) {
- return sp<MmapCaptureThread>::make(audioFlinger, id, hwDev, input, systemReady);
+ return sp<MmapCaptureThread>::make(afThreadCallback, id, hwDev, input, systemReady);
}
MmapCaptureThread::MmapCaptureThread(
- const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
+ const sp<IAfThreadCallback>& afThreadCallback, audio_io_handle_t id,
AudioHwDevice *hwDev, AudioStreamIn *input, bool systemReady)
- : MmapThread(audioFlinger, id, hwDev, input->stream, systemReady, false /* isOut */),
+ : MmapThread(afThreadCallback, id, hwDev, input->stream, systemReady, false /* isOut */),
mInput(input)
{
snprintf(mThreadName, kThreadNameLength, "AudioMmapIn_%X", id);
@@ -11061,14 +11063,14 @@
/* static */
sp<IAfPlaybackThread> IAfPlaybackThread::createBitPerfectThread(
- const sp<AudioFlinger>& audioflinger,
+ const sp<IAfThreadCallback>& afThreadCallback,
AudioStreamOut* output, audio_io_handle_t id, bool systemReady) {
- return sp<BitPerfectThread>::make(audioflinger, output, id, systemReady);
+ return sp<BitPerfectThread>::make(afThreadCallback, output, id, systemReady);
}
-BitPerfectThread::BitPerfectThread(const sp<AudioFlinger> &audioflinger,
+BitPerfectThread::BitPerfectThread(const sp<IAfThreadCallback> &afThreadCallback,
AudioStreamOut *output, audio_io_handle_t id, bool systemReady)
- : MixerThread(audioflinger, output, id, systemReady, BIT_PERFECT) {}
+ : MixerThread(afThreadCallback, output, id, systemReady, BIT_PERFECT) {}
PlaybackThread::mixer_state BitPerfectThread::prepareTracks_l(
Vector<sp<IAfTrack>>* tracksToRemove) {
diff --git a/services/audioflinger/Threads.h b/services/audioflinger/Threads.h
index a8847d7..a628867 100644
--- a/services/audioflinger/Threads.h
+++ b/services/audioflinger/Threads.h
@@ -25,9 +25,9 @@
public:
static const char *threadTypeToString(type_t type);
- AudioFlinger* audioFlinger() const final { return mAudioFlinger.get(); }
+ IAfThreadCallback* afThreadCallback() const final { return mAfThreadCallback.get(); }
- ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
+ ThreadBase(const sp<IAfThreadCallback>& afThreadCallback, audio_io_handle_t id,
type_t type, bool systemReady, bool isOut);
~ThreadBase() override;
@@ -582,7 +582,7 @@
// Used by parameters, config events, addTrack_l, exit
Condition mWaitWorkCV;
- const sp<AudioFlinger> mAudioFlinger;
+ const sp<IAfThreadCallback> mAfThreadCallback;
ThreadMetrics mThreadMetrics;
const bool mIsOut;
@@ -804,7 +804,7 @@
// for initial conditions or large delays.
static const nsecs_t kMaxNextBufferDelayNs = 100000000;
- PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
+ PlaybackThread(const sp<IAfThreadCallback>& afThreadCallback, AudioStreamOut* output,
audio_io_handle_t id, type_t type, bool systemReady,
audio_config_base_t *mixerConfig = nullptr);
~PlaybackThread() override;
@@ -1434,7 +1434,7 @@
class MixerThread : public PlaybackThread,
public StreamOutHalInterfaceLatencyModeCallback {
public:
- MixerThread(const sp<AudioFlinger>& audioFlinger,
+ MixerThread(const sp<IAfThreadCallback>& afThreadCallback,
AudioStreamOut* output,
audio_io_handle_t id,
bool systemReady,
@@ -1564,10 +1564,10 @@
return sp<IAfDirectOutputThread>::fromExisting(this);
}
- DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
+ DirectOutputThread(const sp<IAfThreadCallback>& afThreadCallback, AudioStreamOut* output,
audio_io_handle_t id, bool systemReady,
const audio_offload_info_t& offloadInfo)
- : DirectOutputThread(audioFlinger, output, id, DIRECT, systemReady, offloadInfo) { }
+ : DirectOutputThread(afThreadCallback, output, id, DIRECT, systemReady, offloadInfo) { }
virtual ~DirectOutputThread();
@@ -1604,7 +1604,7 @@
audioflinger::MonotonicFrameCounter mMonotonicFrameCounter; // for VolumeShaper
bool mVolumeShaperActive = false;
- DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
+ DirectOutputThread(const sp<IAfThreadCallback>& afThreadCallback, AudioStreamOut* output,
audio_io_handle_t id, ThreadBase::type_t type, bool systemReady,
const audio_offload_info_t& offloadInfo);
void processVolume_l(IAfTrack *track, bool lastTrack);
@@ -1645,7 +1645,7 @@
class OffloadThread : public DirectOutputThread {
public:
- OffloadThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
+ OffloadThread(const sp<IAfThreadCallback>& afThreadCallback, AudioStreamOut* output,
audio_io_handle_t id, bool systemReady,
const audio_offload_info_t& offloadInfo);
virtual ~OffloadThread() {};
@@ -1703,7 +1703,8 @@
class DuplicatingThread : public MixerThread, public IAfDuplicatingThread {
public:
- DuplicatingThread(const sp<AudioFlinger>& audioFlinger, IAfPlaybackThread* mainThread,
+ DuplicatingThread(const sp<IAfThreadCallback>& afThreadCallback,
+ IAfPlaybackThread* mainThread,
audio_io_handle_t id, bool systemReady);
~DuplicatingThread() override;
@@ -1765,7 +1766,7 @@
class SpatializerThread : public MixerThread {
public:
- SpatializerThread(const sp<AudioFlinger>& audioFlinger,
+ SpatializerThread(const sp<IAfThreadCallback>& afThreadCallback,
AudioStreamOut* output,
audio_io_handle_t id,
bool systemReady,
@@ -1798,7 +1799,7 @@
return sp<IAfRecordThread>::fromExisting(this);
}
- RecordThread(const sp<AudioFlinger>& audioFlinger,
+ RecordThread(const sp<IAfThreadCallback>& afThreadCallback,
AudioStreamIn *input,
audio_io_handle_t id,
bool systemReady
@@ -2025,7 +2026,7 @@
class MmapThread : public ThreadBase, public virtual IAfMmapThread
{
public:
- MmapThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
+ MmapThread(const sp<IAfThreadCallback>& afThreadCallback, audio_io_handle_t id,
AudioHwDevice *hwDev, const sp<StreamHalInterface>& stream, bool systemReady,
bool isOut);
@@ -2150,7 +2151,7 @@
class MmapPlaybackThread : public MmapThread, public IAfMmapPlaybackThread,
public virtual VolumeInterface {
public:
- MmapPlaybackThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
+ MmapPlaybackThread(const sp<IAfThreadCallback>& afThreadCallback, audio_io_handle_t id,
AudioHwDevice *hwDev, AudioStreamOut *output, bool systemReady);
sp<IAfMmapPlaybackThread> asIAfMmapPlaybackThread() final {
@@ -2219,7 +2220,7 @@
class MmapCaptureThread : public MmapThread, public IAfMmapCaptureThread
{
public:
- MmapCaptureThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
+ MmapCaptureThread(const sp<IAfThreadCallback>& afThreadCallback, audio_io_handle_t id,
AudioHwDevice *hwDev, AudioStreamIn *input, bool systemReady);
sp<IAfMmapCaptureThread> asIAfMmapCaptureThread() final {
@@ -2249,7 +2250,7 @@
class BitPerfectThread : public MixerThread {
public:
- BitPerfectThread(const sp<AudioFlinger>& audioflinger, AudioStreamOut *output,
+ BitPerfectThread(const sp<IAfThreadCallback>& afThreadCallback, AudioStreamOut *output,
audio_io_handle_t id, bool systemReady);
protected:
diff --git a/services/audioflinger/Tracks.cpp b/services/audioflinger/Tracks.cpp
index 9169783..257f9e4 100644
--- a/services/audioflinger/Tracks.cpp
+++ b/services/audioflinger/Tracks.cpp
@@ -276,7 +276,7 @@
mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
if (mClient != 0) {
// Client destructor must run with AudioFlinger client mutex locked
- Mutex::Autolock _l(mClient->audioFlinger()->mClientLock);
+ Mutex::Autolock _l(mClient->afClientCallback()->clientMutex());
// If the client's reference count drops to zero, the associated destructor
// must run with AudioFlinger lock held. Thus the explicit clear() rather than
// relying on the automatic clear() at end of scope.
@@ -1164,10 +1164,10 @@
const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
if (isOffloaded()) {
- Mutex::Autolock _laf(thread->audioFlinger()->mLock);
+ Mutex::Autolock _laf(thread->afThreadCallback()->mutex());
Mutex::Autolock _lth(thread->mutex());
sp<IAfEffectChain> ec = thread->getEffectChain_l(mSessionId);
- if (thread->audioFlinger()->isNonOffloadableGlobalEffectEnabled_l() ||
+ if (thread->afThreadCallback()->isNonOffloadableGlobalEffectEnabled_l() ||
(ec != 0 && ec->isNonOffloadableEnabled())) {
invalidate();
return PERMISSION_DENIED;
@@ -1273,7 +1273,8 @@
}
if (status == NO_ERROR) {
// send format to AudioManager for playback activity monitoring
- const sp<IAudioManager> audioManager = thread->audioFlinger()->getOrCreateAudioManager();
+ const sp<IAudioManager> audioManager =
+ thread->afThreadCallback()->getOrCreateAudioManager();
if (audioManager && mPortId != AUDIO_PORT_HANDLE_NONE) {
std::unique_ptr<os::PersistableBundle> bundle =
std::make_unique<os::PersistableBundle>();
@@ -1678,7 +1679,7 @@
auto dstThread = thread->asIAfPlaybackThread();
// srcThread is initialized by call to moveAuxEffectToIo()
sp<IAfPlaybackThread> srcThread;
- sp<AudioFlinger> af = mClient->audioFlinger();
+ const auto& af = mClient->afClientCallback();
status_t status = af->moveAuxEffectToIo(EffectId, dstThread, &srcThread);
if (EffectId != 0 && status == NO_ERROR) {
diff --git a/services/audioflinger/timing/Android.bp b/services/audioflinger/timing/Android.bp
index ec6b85c..30ebca0 100644
--- a/services/audioflinger/timing/Android.bp
+++ b/services/audioflinger/timing/Android.bp
@@ -55,10 +55,4 @@
"-Wall",
"-Werror",
],
-
- // LTO causes unaligned __cfi_check in the library "libaudioflinger_timing.so"
- // http://b/289475610
- lto: {
- never: true,
- },
}
diff --git a/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp b/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
index 5f14ee4..95f8d14 100644
--- a/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
@@ -383,8 +383,8 @@
}
}
if (!allowToCreate) {
- ALOGV("%s: could not find HW module for device %s %04x address %s", __FUNCTION__,
- name, deviceType, address);
+ ALOGW("%s: could not find HW module for device %s (%s, %08x) address %s", __FUNCTION__,
+ name, audio_device_to_string(deviceType), deviceType, address);
return nullptr;
}
return createDevice(deviceType, address, name, encodedFormat);
@@ -398,8 +398,14 @@
std::string tagName = {};
sp<HwModule> hwModule = getModuleForDeviceType(type, encodedFormat, &tagName);
if (hwModule == 0) {
- ALOGE("%s: could not find HW module for device %04x address %s", __FUNCTION__, type,
- address);
+ if (encodedFormat == AUDIO_FORMAT_DEFAULT) {
+ ALOGE("%s: could not find HW module for device type '%s' (%08x)",
+ __FUNCTION__, audio_device_to_string(type), type);
+ } else {
+ ALOGE("%s: could not find HW module for device type '%s' (%08x), "
+ "encoded format '%s'", __FUNCTION__, audio_device_to_string(type), type,
+ audio_format_to_string(encodedFormat));
+ }
return nullptr;
}
diff --git a/services/camera/libcameraservice/CameraService.cpp b/services/camera/libcameraservice/CameraService.cpp
index 4757a42..6d3c7a5 100644
--- a/services/camera/libcameraservice/CameraService.cpp
+++ b/services/camera/libcameraservice/CameraService.cpp
@@ -2117,6 +2117,9 @@
if (err != OK) {
ALOGE("%s: Could not initialize client from HAL.", __FUNCTION__);
// Errors could be from the HAL module open call or from AppOpsManager
+ mServiceLock.unlock();
+ client->disconnect();
+ mServiceLock.lock();
switch(err) {
case BAD_VALUE:
return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,