blob: e1b244b99d354f1c01c912fad978548c179faa63 [file] [log] [blame]
Glenn Kasten99e53b82012-01-19 08:59:58 -08001/*
Mathias Agopian65ab4712010-07-14 17:59:35 -07002**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
Mathias Agopian65ab4712010-07-14 17:59:35 -070018#define LOG_TAG "AudioFlinger"
19//#define LOG_NDEBUG 0
20
jiabina392a552019-09-23 10:34:20 -070021// Define AUDIO_ARRAYS_STATIC_CHECK to check all audio arrays are correct
22#define AUDIO_ARRAYS_STATIC_CHECK 1
23
Glenn Kasten153b9fe2013-07-15 11:23:36 -070024#include "Configuration.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070025#include "AudioFlinger.h"
Andy Hung9a57fc32023-07-19 18:02:19 -070026
27//#define BUFLOG_NDEBUG 0
28#include <afutils/BufLog.h>
29#include <afutils/DumpTryLock.h>
Ziyang Cheng4216c1a2023-11-02 00:17:15 +000030#include <afutils/NBAIO_Tee.h>
Andy Hung9a57fc32023-07-19 18:02:19 -070031#include <afutils/Permission.h>
Andy Hungdcd74052023-06-15 18:52:23 -070032#include <afutils/PropertyUtils.h>
Andy Hung9a57fc32023-07-19 18:02:19 -070033#include <afutils/TypedLogger.h>
Atneya Nair50ffdd12023-12-05 20:42:35 -080034#include <android-base/errors.h>
Andy Hung9a57fc32023-07-19 18:02:19 -070035#include <android-base/stringprintf.h>
36#include <android/media/IAudioPolicyService.h>
37#include <audiomanager/IAudioManager.h>
38#include <binder/IPCThreadState.h>
39#include <binder/IServiceManager.h>
40#include <binder/Parcel.h>
41#include <cutils/properties.h>
Atneya Nair5997a652024-06-14 17:24:45 -070042#include <com_android_media_audio.h>
Atneya Nair50ffdd12023-12-05 20:42:35 -080043#include <com_android_media_audioserver.h>
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -070044#include <media/AidlConversion.h>
Andy Hung9a57fc32023-07-19 18:02:19 -070045#include <media/AudioParameter.h>
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -080046#include <media/AudioValidator.h>
Andy Hung9a57fc32023-07-19 18:02:19 -070047#include <media/IMediaLogService.h>
Atneya Nair5997a652024-06-14 17:24:45 -070048#include <media/IPermissionProvider.h>
Andy Hung9a57fc32023-07-19 18:02:19 -070049#include <media/MediaMetricsItem.h>
Atneya Nair5997a652024-06-14 17:24:45 -070050#include <media/NativePermissionController.h>
Andy Hung9a57fc32023-07-19 18:02:19 -070051#include <media/TypeConverter.h>
Atneya Nair5997a652024-06-14 17:24:45 -070052#include <media/ValidatedAttributionSourceState.h>
Wei Jia3f273d12015-11-24 09:06:49 -080053#include <mediautils/BatteryNotifier.h>
Andy Hunge9eb03e2020-04-04 14:08:23 -070054#include <mediautils/MemoryLeakTrackUtil.h>
Andy Hungc747c532022-03-07 21:41:14 -080055#include <mediautils/MethodStatistics.h>
Andy Hungab7ef302018-05-15 19:35:29 -070056#include <mediautils/ServiceUtilities.h>
Eric Laurent42896a02019-09-27 15:40:33 -070057#include <mediautils/TimeCheck.h>
Andy Hung9a57fc32023-07-19 18:02:19 -070058#include <memunreachable/memunreachable.h>
59// required for effect matching
60#include <system/audio_effects/effect_aec.h>
61#include <system/audio_effects/effect_ns.h>
62#include <system/audio_effects/effect_spatializer.h>
63#include <system/audio_effects/effect_visualizer.h>
64#include <utils/Log.h>
Glenn Kastenda6ef132013-01-10 12:31:01 -080065
Andy Hung9a57fc32023-07-19 18:02:19 -070066// not needed with the includes above, added to prevent transitive include dependency.
67#include <chrono>
68#include <thread>
Nicolas Rouletfe1e1442017-01-30 12:02:03 -080069
Mathias Agopian65ab4712010-07-14 17:59:35 -070070// ----------------------------------------------------------------------------
Mathias Agopian65ab4712010-07-14 17:59:35 -070071
John Grossman1c345192012-03-27 14:00:17 -070072// Note: the following macro is used for extremely verbose logging message. In
73// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
74// 0; but one side effect of this is to turn all LOGV's as well. Some messages
75// are so verbose that we want to suppress them even when we have ALOG_ASSERT
76// turned on. Do not uncomment the #def below unless you really know what you
77// are doing and want to see all of the extremely verbose messages.
78//#define VERY_VERY_VERBOSE_LOGGING
79#ifdef VERY_VERY_VERBOSE_LOGGING
80#define ALOGVV ALOGV
81#else
82#define ALOGVV(a...) do { } while(0)
83#endif
Eric Laurentde070132010-07-13 04:45:46 -070084
Mathias Agopian65ab4712010-07-14 17:59:35 -070085namespace android {
86
Andy Hung03410c02022-01-27 08:24:31 -080087using ::android::base::StringPrintf;
Atneya Nair5997a652024-06-14 17:24:45 -070088using aidl_utils::statusTFromBinderStatus;
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -070089using media::IEffectClient;
jiabine99d0882021-09-17 05:21:25 +000090using media::audio::common::AudioMMapPolicyInfo;
91using media::audio::common::AudioMMapPolicyType;
Mikhail Naganovffd97712023-05-03 17:45:36 -070092using media::audio::common::AudioMode;
Svet Ganov33761132021-05-13 22:51:08 +000093using android::content::AttributionSourceState;
Shunkai Yao2b8fed42022-12-09 01:12:02 +000094using android::detail::AudioHalVersionInfo;
Atneya Nair5997a652024-06-14 17:24:45 -070095using com::android::media::permission::INativePermissionController;
96using com::android::media::permission::IPermissionProvider;
97using com::android::media::permission::NativePermissionController;
98using com::android::media::permission::ValidatedAttributionSourceState;
Shunkai Yao2b8fed42022-12-09 01:12:02 +000099
100static const AudioHalVersionInfo kMaxAAudioPropertyDeviceHalVersion =
101 AudioHalVersionInfo(AudioHalVersionInfo::Type::HIDL, 7, 1);
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700102
Vlad Popae8d99472022-06-30 16:02:48 +0200103static constexpr char kDeadlockedString[] = "AudioFlinger may be deadlocked\n";
104static constexpr char kHardwareLockedString[] = "Hardware lock is taken\n";
105static constexpr char kClientLockedString[] = "Client lock is taken\n";
106static constexpr char kNoEffectsFactory[] = "Effects Factory is absent\n";
Mathias Agopian65ab4712010-07-14 17:59:35 -0700107
Vlad Popae8d99472022-06-30 16:02:48 +0200108static constexpr char kAudioServiceName[] = "audio";
Glenn Kasten58912562012-04-03 10:45:00 -0700109
Eric Laurent813e2a72013-08-31 12:59:48 -0700110// In order to avoid invalidating offloaded tracks each time a Visualizer is turned on and off
111// we define a minimum time during which a global effect is considered enabled.
112static const nsecs_t kMinGlobalEffectEnabletimeNs = seconds(7200);
113
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700114// Keep a strong reference to media.log service around forever.
115// The service is within our parent process so it can never die in a way that we could observe.
116// These two variables are const after initialization.
117static sp<IBinder> sMediaLogServiceAsBinder;
118static sp<IMediaLogService> sMediaLogService;
119
120static pthread_once_t sMediaLogOnce = PTHREAD_ONCE_INIT;
121
122static void sMediaLogInit()
123{
124 sMediaLogServiceAsBinder = defaultServiceManager()->getService(String16("media.log"));
125 if (sMediaLogServiceAsBinder != 0) {
126 sMediaLogService = interface_cast<IMediaLogService>(sMediaLogServiceAsBinder);
127 }
128}
129
Atneya Nair5997a652024-06-14 17:24:45 -0700130static error::BinderResult<ValidatedAttributionSourceState>
131validateAttributionFromContextOrTrustedCaller(AttributionSourceState attr,
132 const IPermissionProvider& provider) {
133 const auto callingUid = IPCThreadState::self()->getCallingUid();
134 // We trust the following UIDs to appropriate validated identities above us
135 if (isAudioServerOrMediaServerOrSystemServerOrRootUid(callingUid)) {
136 // Legacy paths may not properly populate package name, so we attempt to handle.
137 if (!attr.packageName.has_value() || attr.packageName.value() == "") {
138 ALOGW("Trusted client %d provided attr with missing package name" , callingUid);
139 attr.packageName = VALUE_OR_RETURN(provider.getPackagesForUid(callingUid))[0];
140 }
141 // Behavior change: In the case of delegation, if pid is invalid,
142 // filling it in with the callingPid will cause a mismatch between the
143 // pid and the uid in the attribution, which is error-prone.
144 // Instead, assert that the pid from a trusted source is valid
145 if (attr.pid == -1) {
146 if (callingUid != static_cast<uid_t>(attr.uid)) {
147 return error::unexpectedExceptionCode(binder::Status::EX_ILLEGAL_ARGUMENT,
148 "validateAttribution: Invalid pid from delegating trusted source");
149 } else {
150 // Legacy handling for trusted clients which may not fill pid correctly
151 attr.pid = IPCThreadState::self()->getCallingPid();
152 }
153 }
154 return ValidatedAttributionSourceState::createFromTrustedSource(std::move(attr));
155 } else {
156 // Behavior change: Populate pid with callingPid unconditionally. Previously, we
157 // allowed caller provided pid, if uid matched calling context, but this is error-prone
158 // since it allows mismatching uid/pid
159 return ValidatedAttributionSourceState::createFromBinderContext(std::move(attr), provider);
160 }
161}
162
163#define VALUE_OR_RETURN_CONVERTED(exp) \
164 ({ \
165 auto _tmp = (exp); \
166 if (!_tmp.ok()) { \
167 ALOGE("Function: %s Line: %d Failed result (%s)", __FUNCTION__, __LINE__, \
168 errorToString(_tmp.error()).c_str()); \
169 return statusTFromBinderStatus(_tmp.error()); \
170 } \
171 std::move(_tmp.value()); \
172 })
173
174
175
Andy Hungc747c532022-03-07 21:41:14 -0800176// Creates association between Binder code to name for IAudioFlinger.
177#define IAUDIOFLINGER_BINDER_METHOD_MACRO_LIST \
178BINDER_METHOD_ENTRY(createTrack) \
179BINDER_METHOD_ENTRY(createRecord) \
180BINDER_METHOD_ENTRY(sampleRate) \
181BINDER_METHOD_ENTRY(format) \
182BINDER_METHOD_ENTRY(frameCount) \
183BINDER_METHOD_ENTRY(latency) \
184BINDER_METHOD_ENTRY(setMasterVolume) \
185BINDER_METHOD_ENTRY(setMasterMute) \
186BINDER_METHOD_ENTRY(masterVolume) \
187BINDER_METHOD_ENTRY(masterMute) \
188BINDER_METHOD_ENTRY(setStreamVolume) \
189BINDER_METHOD_ENTRY(setStreamMute) \
Andy Hung6b137d12024-08-27 22:35:17 +0000190BINDER_METHOD_ENTRY(setPortsVolume) \
Andy Hungc747c532022-03-07 21:41:14 -0800191BINDER_METHOD_ENTRY(setMode) \
192BINDER_METHOD_ENTRY(setMicMute) \
193BINDER_METHOD_ENTRY(getMicMute) \
194BINDER_METHOD_ENTRY(setRecordSilenced) \
195BINDER_METHOD_ENTRY(setParameters) \
196BINDER_METHOD_ENTRY(getParameters) \
197BINDER_METHOD_ENTRY(registerClient) \
198BINDER_METHOD_ENTRY(getInputBufferSize) \
199BINDER_METHOD_ENTRY(openOutput) \
200BINDER_METHOD_ENTRY(openDuplicateOutput) \
201BINDER_METHOD_ENTRY(closeOutput) \
202BINDER_METHOD_ENTRY(suspendOutput) \
203BINDER_METHOD_ENTRY(restoreOutput) \
204BINDER_METHOD_ENTRY(openInput) \
205BINDER_METHOD_ENTRY(closeInput) \
Andy Hungc747c532022-03-07 21:41:14 -0800206BINDER_METHOD_ENTRY(setVoiceVolume) \
207BINDER_METHOD_ENTRY(getRenderPosition) \
208BINDER_METHOD_ENTRY(getInputFramesLost) \
209BINDER_METHOD_ENTRY(newAudioUniqueId) \
210BINDER_METHOD_ENTRY(acquireAudioSessionId) \
211BINDER_METHOD_ENTRY(releaseAudioSessionId) \
212BINDER_METHOD_ENTRY(queryNumberEffects) \
213BINDER_METHOD_ENTRY(queryEffect) \
214BINDER_METHOD_ENTRY(getEffectDescriptor) \
215BINDER_METHOD_ENTRY(createEffect) \
216BINDER_METHOD_ENTRY(moveEffects) \
217BINDER_METHOD_ENTRY(loadHwModule) \
218BINDER_METHOD_ENTRY(getPrimaryOutputSamplingRate) \
219BINDER_METHOD_ENTRY(getPrimaryOutputFrameCount) \
220BINDER_METHOD_ENTRY(setLowRamDevice) \
221BINDER_METHOD_ENTRY(getAudioPort) \
222BINDER_METHOD_ENTRY(createAudioPatch) \
223BINDER_METHOD_ENTRY(releaseAudioPatch) \
224BINDER_METHOD_ENTRY(listAudioPatches) \
225BINDER_METHOD_ENTRY(setAudioPortConfig) \
226BINDER_METHOD_ENTRY(getAudioHwSyncForSession) \
227BINDER_METHOD_ENTRY(systemReady) \
228BINDER_METHOD_ENTRY(audioPolicyReady) \
229BINDER_METHOD_ENTRY(frameCountHAL) \
230BINDER_METHOD_ENTRY(getMicrophones) \
231BINDER_METHOD_ENTRY(setMasterBalance) \
232BINDER_METHOD_ENTRY(getMasterBalance) \
233BINDER_METHOD_ENTRY(setEffectSuspended) \
234BINDER_METHOD_ENTRY(setAudioHalPids) \
235BINDER_METHOD_ENTRY(setVibratorInfos) \
236BINDER_METHOD_ENTRY(updateSecondaryOutputs) \
237BINDER_METHOD_ENTRY(getMmapPolicyInfos) \
238BINDER_METHOD_ENTRY(getAAudioMixerBurstCount) \
239BINDER_METHOD_ENTRY(getAAudioHardwareBurstMinUsec) \
240BINDER_METHOD_ENTRY(setDeviceConnectedState) \
Mikhail Naganovb1ddbb02023-03-15 17:06:59 -0700241BINDER_METHOD_ENTRY(setSimulateDeviceConnections) \
Eric Laurent076e7c72022-05-03 18:12:28 +0200242BINDER_METHOD_ENTRY(setRequestedLatencyMode) \
243BINDER_METHOD_ENTRY(getSupportedLatencyModes) \
Eric Laurent50d72582022-12-20 20:20:23 +0100244BINDER_METHOD_ENTRY(setBluetoothVariableLatencyEnabled) \
245BINDER_METHOD_ENTRY(isBluetoothVariableLatencyEnabled) \
246BINDER_METHOD_ENTRY(supportsBluetoothVariableLatency) \
Vlad Popae3fd1c22022-11-07 21:03:18 +0100247BINDER_METHOD_ENTRY(getSoundDoseInterface) \
Mikhail Naganovffd97712023-05-03 17:45:36 -0700248BINDER_METHOD_ENTRY(getAudioPolicyConfig) \
jiabin12537fc2023-10-12 17:56:08 +0000249BINDER_METHOD_ENTRY(getAudioMixPort) \
Shraddha Basantwania6dadac2024-06-06 16:28:52 +0000250BINDER_METHOD_ENTRY(resetReferencesForTest) \
Andy Hungc747c532022-03-07 21:41:14 -0800251
252// singleton for Binder Method Statistics for IAudioFlinger
253static auto& getIAudioFlingerStatistics() {
254 using Code = android::AudioFlingerServerAdapter::Delegate::TransactionCode;
255
256#pragma push_macro("BINDER_METHOD_ENTRY")
257#undef BINDER_METHOD_ENTRY
258#define BINDER_METHOD_ENTRY(ENTRY) \
259 {(Code)media::BnAudioFlingerService::TRANSACTION_##ENTRY, #ENTRY},
260
261 static mediautils::MethodStatistics<Code> methodStatistics{
262 IAUDIOFLINGER_BINDER_METHOD_MACRO_LIST
263 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
264 };
265#pragma pop_macro("BINDER_METHOD_ENTRY")
266
267 return methodStatistics;
268}
269
Atneya Nair50ffdd12023-12-05 20:42:35 -0800270namespace base {
271template <typename T>
272struct OkOrFail<std::optional<T>> {
273 using opt_t = std::optional<T>;
274 OkOrFail() = delete;
275 OkOrFail(const opt_t&) = delete;
276
277 static bool IsOk(const opt_t& opt) { return opt.has_value(); }
278 static T Unwrap(opt_t&& opt) { return std::move(opt.value()); }
279 static std::string ErrorMessage(const opt_t&) { return "Empty optional"; }
280 static void Fail(opt_t&&) {}
281};
282}
283
Mikhail Naganov88b30d22020-03-09 19:43:13 +0000284class DevicesFactoryHalCallbackImpl : public DevicesFactoryHalCallback {
285 public:
286 void onNewDevicesAvailable() override {
287 // Start a detached thread to execute notification in parallel.
288 // This is done to prevent mutual blocking of audio_flinger and
289 // audio_policy services during system initialization.
290 std::thread notifier([]() {
291 AudioSystem::onNewAudioModulesAvailable();
292 });
293 notifier.detach();
294 }
295};
296
Mathias Agopian65ab4712010-07-14 17:59:35 -0700297// ----------------------------------------------------------------------------
298
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800299void AudioFlinger::instantiate() {
300 sp<IServiceManager> sm(defaultServiceManager());
301 sm->addService(String16(IAudioFlinger::DEFAULT_SERVICE_NAME),
302 new AudioFlingerServerAdapter(new AudioFlinger()), false,
303 IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT);
304}
305
Mathias Agopian65ab4712010-07-14 17:59:35 -0700306AudioFlinger::AudioFlinger()
Mathias Agopian65ab4712010-07-14 17:59:35 -0700307{
Eric Laurentf43be0c2021-03-25 10:45:53 +0100308 // Move the audio session unique ID generator start base as time passes to limit risk of
309 // generating the same ID again after an audioserver restart.
310 // This is important because clients will reuse previously allocated audio session IDs
311 // when reconnecting after an audioserver restart and newly allocated IDs may conflict with
312 // active clients.
313 // Moving the base by 1 for each elapsed second is a good compromise between avoiding overlap
314 // between allocation ranges and not reaching wrap around too soon.
315 timespec ts{};
316 clock_gettime(CLOCK_MONOTONIC, &ts);
317 // zero ID has a special meaning, so start allocation at least at AUDIO_UNIQUE_ID_USE_MAX
Eric Laurentf37f1982021-06-01 13:23:27 +0200318 uint32_t movingBase = (uint32_t)std::max((long)1, ts.tv_sec);
Glenn Kastend2e67e12016-04-11 08:26:37 -0700319 // unsigned instead of audio_unique_id_use_t, because ++ operator is unavailable for enum
320 for (unsigned use = AUDIO_UNIQUE_ID_USE_UNSPECIFIED; use < AUDIO_UNIQUE_ID_USE_MAX; use++) {
Eric Laurentf43be0c2021-03-25 10:45:53 +0100321 mNextUniqueIds[use] =
Eric Laurentf37f1982021-06-01 13:23:27 +0200322 ((use == AUDIO_UNIQUE_ID_USE_SESSION || use == AUDIO_UNIQUE_ID_USE_CLIENT) ?
323 movingBase : 1) * AUDIO_UNIQUE_ID_USE_MAX;
Glenn Kastend2e67e12016-04-11 08:26:37 -0700324 }
325
Eric Laurent94ca1142020-10-07 10:45:20 -0700326#if 1
327 // FIXME See bug 165702394 and bug 168511485
328 const bool doLog = false;
329#else
Glenn Kastenae0cff12016-02-24 13:57:49 -0800330 const bool doLog = property_get_bool("ro.test_harness", false);
Eric Laurent94ca1142020-10-07 10:45:20 -0700331#endif
Glenn Kasten9e58b552013-01-18 15:09:48 -0800332 if (doLog) {
Glenn Kastenb187de12014-12-30 08:18:15 -0800333 mLogMemoryDealer = new MemoryDealer(kLogMemorySize, "LogWriters",
334 MemoryHeapBase::READ_ONLY);
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700335 (void) pthread_once(&sMediaLogOnce, sMediaLogInit);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800336 }
Eric Laurent1c333e22014-05-20 10:48:17 -0700337
Wei Jia3f273d12015-11-24 09:06:49 -0800338 // reset battery stats.
339 // if the audio service has crashed, battery stats could be left
340 // in bad state, reset the state upon service start.
341 BatteryNotifier::getInstance().noteResetAudio();
342
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -0800343 mMediaLogNotifier->run("MediaLogNotifier");
Andy Hungb68f5eb2019-12-03 16:49:17 -0800344
345 // Notify that we have started (also called when audioserver service restarts)
346 mediametrics::LogItem(mMetricsId)
347 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
348 .record();
Dima Zavin5a61d2f2011-04-19 19:04:32 -0700349}
350
351void AudioFlinger::onFirstRef()
352{
Andy Hung954b9712023-08-28 18:36:53 -0700353 audio_utils::lock_guard _l(mutex());
Eric Laurent93575202011-01-18 18:39:02 -0800354
Eric Laurenta4c5a552012-03-29 10:12:40 -0700355 mMode = AUDIO_MODE_NORMAL;
Eric Laurentfc235202016-12-20 18:48:17 -0800356
Andy Hung6626a012021-01-12 13:38:00 -0800357 gAudioFlinger = this; // we are already refcounted, store into atomic pointer.
Andy Hung692f0452023-07-17 13:45:55 -0700358 mDeviceEffectManager = sp<DeviceEffectManager>::make(
359 sp<IAfDeviceEffectManagerCallback>::fromExisting(this)),
Mikhail Naganov88b30d22020-03-09 19:43:13 +0000360 mDevicesFactoryHalCallback = new DevicesFactoryHalCallbackImpl;
361 mDevicesFactoryHal->setCallbackOnce(mDevicesFactoryHalCallback);
jiabine504e7b2021-09-18 00:27:08 +0000362
Shunkai Yao2b8fed42022-12-09 01:12:02 +0000363 if (mDevicesFactoryHal->getHalVersion() <= kMaxAAudioPropertyDeviceHalVersion) {
jiabine504e7b2021-09-18 00:27:08 +0000364 mAAudioBurstsPerBuffer = getAAudioMixerBurstCountFromSystemProperty();
365 mAAudioHwBurstMinMicros = getAAudioHardwareBurstMinUsecFromSystemProperty();
366 }
Andy Hungb60a2c82023-07-17 14:02:52 -0700367
Andy Hung2dc61c42023-07-17 14:36:08 -0700368 mPatchPanel = IAfPatchPanel::create(sp<IAfPatchPanelCallback>::fromExisting(this));
Vlad Popa1c67ad62024-01-19 17:53:42 -0800369 mMelReporter = sp<MelReporter>::make(sp<IAfMelReporterCallback>::fromExisting(this),
370 mPatchPanel);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700371}
372
Eric Laurent42896a02019-09-27 15:40:33 -0700373status_t AudioFlinger::setAudioHalPids(const std::vector<pid_t>& pids) {
Andy Hung5c6d68a2022-03-09 21:54:59 -0800374 mediautils::TimeCheck::setAudioHalPids(pids);
Eric Laurent42896a02019-09-27 15:40:33 -0700375 return NO_ERROR;
376}
377
jiabin1319f5a2021-03-30 22:21:24 +0000378status_t AudioFlinger::setVibratorInfos(
379 const std::vector<media::AudioVibratorInfo>& vibratorInfos) {
Andy Hung954b9712023-08-28 18:36:53 -0700380 audio_utils::lock_guard _l(mutex());
jiabin1319f5a2021-03-30 22:21:24 +0000381 mAudioVibratorInfos = vibratorInfos;
382 return NO_ERROR;
383}
384
jiabinf042b9b2021-05-07 23:46:28 +0000385status_t AudioFlinger::updateSecondaryOutputs(
386 const TrackSecondaryOutputsMap& trackSecondaryOutputs) {
Andy Hung954b9712023-08-28 18:36:53 -0700387 audio_utils::lock_guard _l(mutex());
jiabinf042b9b2021-05-07 23:46:28 +0000388 for (const auto& [trackId, secondaryOutputs] : trackSecondaryOutputs) {
389 size_t i = 0;
390 for (; i < mPlaybackThreads.size(); ++i) {
Andy Hung87c693c2023-07-06 20:56:16 -0700391 IAfPlaybackThread* thread = mPlaybackThreads.valueAt(i).get();
Andy Hungc5007f82023-08-29 14:26:09 -0700392 audio_utils::lock_guard _tl(thread->mutex());
Andy Hungd29af632023-06-23 19:27:19 -0700393 sp<IAfTrack> track = thread->getTrackById_l(trackId);
jiabinf042b9b2021-05-07 23:46:28 +0000394 if (track != nullptr) {
395 ALOGD("%s trackId: %u", __func__, trackId);
396 updateSecondaryOutputsForTrack_l(track.get(), thread, secondaryOutputs);
397 break;
398 }
399 }
400 ALOGW_IF(i >= mPlaybackThreads.size(),
401 "%s cannot find track with id %u", __func__, trackId);
402 }
403 return NO_ERROR;
404}
405
Jiabin Huangebe64102021-09-07 20:01:07 +0000406status_t AudioFlinger::getMmapPolicyInfos(
jiabine99d0882021-09-17 05:21:25 +0000407 AudioMMapPolicyType policyType, std::vector<AudioMMapPolicyInfo> *policyInfos) {
Andy Hung954b9712023-08-28 18:36:53 -0700408 audio_utils::lock_guard _l(mutex());
Jiabin Huangebe64102021-09-07 20:01:07 +0000409 if (const auto it = mPolicyInfos.find(policyType); it != mPolicyInfos.end()) {
410 *policyInfos = it->second;
411 return NO_ERROR;
412 }
Shunkai Yao2b8fed42022-12-09 01:12:02 +0000413 if (mDevicesFactoryHal->getHalVersion() > kMaxAAudioPropertyDeviceHalVersion) {
Andy Hung954b9712023-08-28 18:36:53 -0700414 audio_utils::lock_guard lock(hardwareMutex());
Jiabin Huangebe64102021-09-07 20:01:07 +0000415 for (size_t i = 0; i < mAudioHwDevs.size(); ++i) {
416 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
jiabine99d0882021-09-17 05:21:25 +0000417 std::vector<AudioMMapPolicyInfo> infos;
Jiabin Huangebe64102021-09-07 20:01:07 +0000418 status_t status = dev->getMmapPolicyInfos(policyType, &infos);
419 if (status != NO_ERROR) {
420 ALOGE("Failed to query mmap policy info of %d, error %d",
421 mAudioHwDevs.keyAt(i), status);
422 continue;
423 }
424 policyInfos->insert(policyInfos->end(), infos.begin(), infos.end());
425 }
426 mPolicyInfos[policyType] = *policyInfos;
427 } else {
428 getMmapPolicyInfosFromSystemProperty(policyType, policyInfos);
429 mPolicyInfos[policyType] = *policyInfos;
430 }
431 return NO_ERROR;
432}
433
Andy Hungcdd80ef2023-07-17 11:37:26 -0700434int32_t AudioFlinger::getAAudioMixerBurstCount() const {
Andy Hung954b9712023-08-28 18:36:53 -0700435 audio_utils::lock_guard _l(mutex());
jiabine504e7b2021-09-18 00:27:08 +0000436 return mAAudioBurstsPerBuffer;
437}
438
Andy Hungcdd80ef2023-07-17 11:37:26 -0700439int32_t AudioFlinger::getAAudioHardwareBurstMinUsec() const {
Andy Hung954b9712023-08-28 18:36:53 -0700440 audio_utils::lock_guard _l(mutex());
jiabine504e7b2021-09-18 00:27:08 +0000441 return mAAudioHwBurstMinMicros;
442}
443
jiabinc0048632023-04-27 22:04:31 +0000444status_t AudioFlinger::setDeviceConnectedState(const struct audio_port_v7 *port,
445 media::DeviceConnectedState state) {
Mikhail Naganov516d3982022-02-01 23:53:59 +0000446 status_t final_result = NO_INIT;
Andy Hung954b9712023-08-28 18:36:53 -0700447 audio_utils::lock_guard _l(mutex());
448 audio_utils::lock_guard lock(hardwareMutex());
Mikhail Naganov516d3982022-02-01 23:53:59 +0000449 mHardwareStatus = AUDIO_HW_SET_CONNECTED_STATE;
450 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
451 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
jiabinc0048632023-04-27 22:04:31 +0000452 status_t result = state == media::DeviceConnectedState::PREPARE_TO_DISCONNECT
453 ? dev->prepareToDisconnectExternalDevice(port)
454 : dev->setConnectedState(port, state == media::DeviceConnectedState::CONNECTED);
Mikhail Naganov516d3982022-02-01 23:53:59 +0000455 // Same logic as with setParameter: it's a success if at least one
456 // HAL module accepts the update.
457 if (final_result != NO_ERROR) {
458 final_result = result;
459 }
460 }
461 mHardwareStatus = AUDIO_HW_IDLE;
462 return final_result;
463}
464
Mikhail Naganovb1ddbb02023-03-15 17:06:59 -0700465status_t AudioFlinger::setSimulateDeviceConnections(bool enabled) {
466 bool at_least_one_succeeded = false;
467 status_t last_error = INVALID_OPERATION;
Andy Hung954b9712023-08-28 18:36:53 -0700468 audio_utils::lock_guard _l(mutex());
469 audio_utils::lock_guard lock(hardwareMutex());
Mikhail Naganovb1ddbb02023-03-15 17:06:59 -0700470 mHardwareStatus = AUDIO_HW_SET_SIMULATE_CONNECTIONS;
471 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
472 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
473 status_t result = dev->setSimulateDeviceConnections(enabled);
474 if (result == OK) {
475 at_least_one_succeeded = true;
476 } else {
477 last_error = result;
478 }
479 }
480 mHardwareStatus = AUDIO_HW_IDLE;
481 return at_least_one_succeeded ? OK : last_error;
482}
483
jiabin1319f5a2021-03-30 22:21:24 +0000484// getDefaultVibratorInfo_l must be called with AudioFlinger lock held.
Andy Hung583043b2023-07-17 17:05:00 -0700485std::optional<media::AudioVibratorInfo> AudioFlinger::getDefaultVibratorInfo_l() const {
jiabin1319f5a2021-03-30 22:21:24 +0000486 if (mAudioVibratorInfos.empty()) {
Lais Andradebc3f37a2021-07-02 00:13:19 +0100487 return {};
jiabin1319f5a2021-03-30 22:21:24 +0000488 }
Lais Andradebc3f37a2021-07-02 00:13:19 +0100489 return mAudioVibratorInfos.front();
jiabin1319f5a2021-03-30 22:21:24 +0000490}
491
Mathias Agopian65ab4712010-07-14 17:59:35 -0700492AudioFlinger::~AudioFlinger()
493{
494 while (!mRecordThreads.isEmpty()) {
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700495 // closeInput_nonvirtual() will remove specified entry from mRecordThreads
Glenn Kastend96c5722012-04-25 13:44:49 -0700496 closeInput_nonvirtual(mRecordThreads.keyAt(0));
Mathias Agopian65ab4712010-07-14 17:59:35 -0700497 }
498 while (!mPlaybackThreads.isEmpty()) {
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700499 // closeOutput_nonvirtual() will remove specified entry from mPlaybackThreads
Glenn Kastend96c5722012-04-25 13:44:49 -0700500 closeOutput_nonvirtual(mPlaybackThreads.keyAt(0));
Mathias Agopian65ab4712010-07-14 17:59:35 -0700501 }
Andy Hungb4946b62019-03-14 11:19:28 -0700502 while (!mMmapThreads.isEmpty()) {
503 const audio_io_handle_t io = mMmapThreads.keyAt(0);
504 if (mMmapThreads.valueAt(0)->isOutput()) {
505 closeOutput_nonvirtual(io); // removes entry from mMmapThreads
506 } else {
507 closeInput_nonvirtual(io); // removes entry from mMmapThreads
508 }
509 }
Dima Zavin799a70e2011-04-18 16:57:27 -0700510
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800511 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Andy Hung954b9712023-08-28 18:36:53 -0700512 // no hardwareMutex() needed, as there are no other references to this
Eric Laurenta4c5a552012-03-29 10:12:40 -0700513 delete mAudioHwDevs.valueAt(i);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700514 }
Glenn Kasten481fb672013-09-30 14:39:28 -0700515
516 // Tell media.log service about any old writers that still need to be unregistered
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700517 if (sMediaLogService != 0) {
518 for (size_t count = mUnregisteredWriters.size(); count > 0; count--) {
519 sp<IMemory> iMemory(mUnregisteredWriters.top()->getIMemory());
520 mUnregisteredWriters.pop();
521 sMediaLogService->unregisterWriter(iMemory);
Glenn Kasten481fb672013-09-30 14:39:28 -0700522 }
523 }
Shraddha Basantwania6dadac2024-06-06 16:28:52 +0000524 mMediaLogNotifier->requestExit();
525 mPatchCommandThread->exit();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700526}
527
Eric Laurentfc235202016-12-20 18:48:17 -0800528//static
Eric Laurent6acd1d42017-01-04 14:23:29 -0800529__attribute__ ((visibility ("default")))
Eric Laurentfc235202016-12-20 18:48:17 -0800530status_t MmapStreamInterface::openMmapStream(MmapStreamInterface::stream_direction_t direction,
531 const audio_attributes_t *attr,
532 audio_config_base_t *config,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700533 const AudioClient& client,
Eric Laurentfc235202016-12-20 18:48:17 -0800534 audio_port_handle_t *deviceId,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800535 audio_session_t *sessionId,
Eric Laurentfc235202016-12-20 18:48:17 -0800536 const sp<MmapStreamCallback>& callback,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700537 sp<MmapStreamInterface>& interface,
538 audio_port_handle_t *handle)
Eric Laurentfc235202016-12-20 18:48:17 -0800539{
Andy Hung9a57fc32023-07-19 18:02:19 -0700540 // TODO(b/292281786): Use ServiceManager to get IAudioFlinger instead of by atomic pointer.
Andy Hung6626a012021-01-12 13:38:00 -0800541 // This allows moving oboeservice (AAudio) to a separate process in the future.
542 sp<AudioFlinger> af = AudioFlinger::gAudioFlinger.load(); // either nullptr or singleton AF.
Eric Laurentfc235202016-12-20 18:48:17 -0800543 status_t ret = NO_INIT;
544 if (af != 0) {
545 ret = af->openMmapStream(
Phil Burk4e1af9f2018-01-03 15:54:35 -0800546 direction, attr, config, client, deviceId,
547 sessionId, callback, interface, handle);
Eric Laurentfc235202016-12-20 18:48:17 -0800548 }
549 return ret;
550}
551
Eric Laurent6acd1d42017-01-04 14:23:29 -0800552status_t AudioFlinger::openMmapStream(MmapStreamInterface::stream_direction_t direction,
553 const audio_attributes_t *attr,
554 audio_config_base_t *config,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700555 const AudioClient& client,
Eric Laurent6acd1d42017-01-04 14:23:29 -0800556 audio_port_handle_t *deviceId,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800557 audio_session_t *sessionId,
Eric Laurent6acd1d42017-01-04 14:23:29 -0800558 const sp<MmapStreamCallback>& callback,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700559 sp<MmapStreamInterface>& interface,
560 audio_port_handle_t *handle)
Eric Laurentfc235202016-12-20 18:48:17 -0800561{
562 status_t ret = initCheck();
563 if (ret != NO_ERROR) {
564 return ret;
565 }
Phil Burk4e1af9f2018-01-03 15:54:35 -0800566 audio_session_t actualSessionId = *sessionId;
567 if (actualSessionId == AUDIO_SESSION_ALLOCATE) {
568 actualSessionId = (audio_session_t) newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
569 }
Eric Laurent6acd1d42017-01-04 14:23:29 -0800570 audio_stream_type_t streamType = AUDIO_STREAM_DEFAULT;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700571 audio_io_handle_t io = AUDIO_IO_HANDLE_NONE;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800572 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
Eric Laurent42984412019-05-09 17:57:03 -0700573 audio_attributes_t localAttr = *attr;
Eric Laurent9ff3e532022-11-10 16:04:44 +0100574
575 // TODO b/182392553: refactor or make clearer
Atneya Nair5997a652024-06-14 17:24:45 -0700576 AttributionSourceState adjAttributionSource;
577 if (!com::android::media::audio::audioserver_permissions()) {
578 pid_t clientPid =
579 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(client.attributionSource.pid));
580 bool updatePid = (clientPid == (pid_t)-1);
581 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Eric Laurent9ff3e532022-11-10 16:04:44 +0100582
Atneya Nair5997a652024-06-14 17:24:45 -0700583 adjAttributionSource = client.attributionSource;
584 if (!isAudioServerOrMediaServerOrSystemServerOrRootUid(callingUid)) {
585 uid_t clientUid =
586 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_uid_t(client.attributionSource.uid));
587 ALOGW_IF(clientUid != callingUid,
588 "%s uid %d tried to pass itself off as %d",
589 __FUNCTION__, callingUid, clientUid);
590 adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(
591 legacy2aidl_uid_t_int32_t(callingUid));
592 updatePid = true;
593 }
594 if (updatePid) {
595 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
596 ALOGW_IF(clientPid != (pid_t)-1 && clientPid != callingPid,
597 "%s uid %d pid %d tried to pass itself off as pid %d",
598 __func__, callingUid, callingPid, clientPid);
599 adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(
600 legacy2aidl_pid_t_int32_t(callingPid));
601 }
602 adjAttributionSource = afutils::checkAttributionSourcePackage(
Pechetty Sravani55532052024-06-14 03:30:13 +0000603 adjAttributionSource);
Atneya Nair5997a652024-06-14 17:24:45 -0700604 } else {
605 auto validatedAttrSource = VALUE_OR_RETURN_CONVERTED(
606 validateAttributionFromContextOrTrustedCaller(client.attributionSource,
607 getPermissionProvider()
608 ));
609 // TODO pass wrapped object around
610 adjAttributionSource = std::move(validatedAttrSource).unwrapInto();
611 }
Eric Laurent9ff3e532022-11-10 16:04:44 +0100612
Eric Laurent6acd1d42017-01-04 14:23:29 -0800613 if (direction == MmapStreamInterface::DIRECTION_OUTPUT) {
614 audio_config_t fullConfig = AUDIO_CONFIG_INITIALIZER;
615 fullConfig.sample_rate = config->sample_rate;
616 fullConfig.channel_mask = config->channel_mask;
617 fullConfig.format = config->format;
Kevin Rocard153f92d2018-12-18 18:33:28 -0800618 std::vector<audio_io_handle_t> secondaryOutputs;
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200619 bool isSpatialized;
jiabinc658e452022-10-21 20:52:21 +0000620 bool isBitPerfect;
Andy Hung6b137d12024-08-27 22:35:17 +0000621 float volume;
Eric Laurent42984412019-05-09 17:57:03 -0700622 ret = AudioSystem::getOutputForAttr(&localAttr, &io,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800623 actualSessionId,
Eric Laurent9ff3e532022-11-10 16:04:44 +0100624 &streamType, adjAttributionSource,
Ricardo Correa57a37692020-03-23 17:27:25 -0700625 &fullConfig,
Glenn Kastend3bb6452016-12-05 18:14:37 -0800626 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ |
627 AUDIO_OUTPUT_FLAG_DIRECT),
jiabinc658e452022-10-21 20:52:21 +0000628 deviceId, &portId, &secondaryOutputs, &isSpatialized,
Andy Hung6b137d12024-08-27 22:35:17 +0000629 &isBitPerfect,
630 &volume);
jiabinf1c73972022-04-14 16:28:52 -0700631 if (ret != NO_ERROR) {
632 config->sample_rate = fullConfig.sample_rate;
633 config->channel_mask = fullConfig.channel_mask;
634 config->format = fullConfig.format;
635 }
Kevin Rocard153f92d2018-12-18 18:33:28 -0800636 ALOGW_IF(!secondaryOutputs.empty(),
637 "%s does not support secondary outputs, ignoring them", __func__);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800638 } else {
Eric Laurent42984412019-05-09 17:57:03 -0700639 ret = AudioSystem::getInputForAttr(&localAttr, &io,
Mikhail Naganov2996f672019-04-18 12:29:59 -0700640 RECORD_RIID_INVALID,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800641 actualSessionId,
Eric Laurent9ff3e532022-11-10 16:04:44 +0100642 adjAttributionSource,
Eric Laurent6acd1d42017-01-04 14:23:29 -0800643 config,
Eric Laurent2ac76942017-06-22 17:17:09 -0700644 AUDIO_INPUT_FLAG_MMAP_NOIRQ, deviceId, &portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800645 }
646 if (ret != NO_ERROR) {
647 return ret;
648 }
649
Andy Hungc2cf7ec2023-08-30 18:19:00 -0700650 // use unique_lock as we may selectively unlock.
651 audio_utils::unique_lock l(mutex());
652
Eric Laurent6acd1d42017-01-04 14:23:29 -0800653 // at this stage, a MmapThread was created when openOutput() or openInput() was called by
654 // audio policy manager and we can retrieve it
Andy Hung7aa7d102023-07-07 15:58:48 -0700655 const sp<IAfMmapThread> thread = mMmapThreads.valueFor(io);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800656 if (thread != 0) {
Andy Hung7aa7d102023-07-07 15:58:48 -0700657 interface = IAfMmapThread::createMmapStreamInterfaceAdapter(thread);
Eric Laurent42984412019-05-09 17:57:03 -0700658 thread->configure(&localAttr, streamType, actualSessionId, callback, *deviceId, portId);
Eric Laurentcb4dae22017-07-01 19:39:32 -0700659 *handle = portId;
Phil Burk4e1af9f2018-01-03 15:54:35 -0800660 *sessionId = actualSessionId;
Eric Laurenta7a89e22020-01-08 18:39:20 -0800661 config->sample_rate = thread->sampleRate();
662 config->channel_mask = thread->channelMask();
663 config->format = thread->format();
Eric Laurent6acd1d42017-01-04 14:23:29 -0800664 } else {
Andy Hungc2cf7ec2023-08-30 18:19:00 -0700665 l.unlock();
Eric Laurentad2e7b92017-09-14 20:06:42 -0700666 if (direction == MmapStreamInterface::DIRECTION_OUTPUT) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700667 AudioSystem::releaseOutput(portId);
Eric Laurentad2e7b92017-09-14 20:06:42 -0700668 } else {
Eric Laurentfee19762018-01-29 18:44:13 -0800669 AudioSystem::releaseInput(portId);
Eric Laurentad2e7b92017-09-14 20:06:42 -0700670 }
Eric Laurent6acd1d42017-01-04 14:23:29 -0800671 ret = NO_INIT;
Andy Hungc2cf7ec2023-08-30 18:19:00 -0700672 // we don't reacquire the lock here as nothing left to do.
Eric Laurent6acd1d42017-01-04 14:23:29 -0800673 }
674
675 ALOGV("%s done status %d portId %d", __FUNCTION__, ret, portId);
676
Eric Laurentfc235202016-12-20 18:48:17 -0800677 return ret;
678}
679
Mikhail Naganovd2c7f852023-06-14 18:00:13 -0700680status_t AudioFlinger::addEffectToHal(
681 const struct audio_port_config *device, const sp<EffectHalInterface>& effect) {
Andy Hung954b9712023-08-28 18:36:53 -0700682 audio_utils::lock_guard lock(hardwareMutex());
Mikhail Naganovd2c7f852023-06-14 18:00:13 -0700683 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueFor(device->ext.device.hw_module);
Eric Laurentb82e6b72019-11-22 17:25:04 -0800684 if (audioHwDevice == nullptr) {
685 return NO_INIT;
686 }
Mikhail Naganovd2c7f852023-06-14 18:00:13 -0700687 return audioHwDevice->hwDevice()->addDeviceEffect(device, effect);
Eric Laurentb82e6b72019-11-22 17:25:04 -0800688}
689
Mikhail Naganovd2c7f852023-06-14 18:00:13 -0700690status_t AudioFlinger::removeEffectFromHal(
691 const struct audio_port_config *device, const sp<EffectHalInterface>& effect) {
Andy Hung954b9712023-08-28 18:36:53 -0700692 audio_utils::lock_guard lock(hardwareMutex());
Mikhail Naganovd2c7f852023-06-14 18:00:13 -0700693 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueFor(device->ext.device.hw_module);
Eric Laurentb82e6b72019-11-22 17:25:04 -0800694 if (audioHwDevice == nullptr) {
695 return NO_INIT;
696 }
Mikhail Naganovd2c7f852023-06-14 18:00:13 -0700697 return audioHwDevice->hwDevice()->removeDeviceEffect(device, effect);
Eric Laurentb82e6b72019-11-22 17:25:04 -0800698}
699
Eric Laurenta4c5a552012-03-29 10:12:40 -0700700static const char * const audio_interfaces[] = {
701 AUDIO_HARDWARE_MODULE_ID_PRIMARY,
702 AUDIO_HARDWARE_MODULE_ID_A2DP,
703 AUDIO_HARDWARE_MODULE_ID_USB,
704};
Eric Laurenta4c5a552012-03-29 10:12:40 -0700705
Phil Burk062e67a2015-02-11 13:40:50 -0800706AudioHwDevice* AudioFlinger::findSuitableHwDev_l(
John Grossmanee578c02012-07-23 17:05:46 -0700707 audio_module_handle_t module,
jiabin43810402019-10-24 14:58:31 -0700708 audio_devices_t deviceType)
Dima Zavin799a70e2011-04-18 16:57:27 -0700709{
Eric Laurenta4c5a552012-03-29 10:12:40 -0700710 // if module is 0, the request comes from an old policy manager and we should load
711 // well known modules
Andy Hung954b9712023-08-28 18:36:53 -0700712 audio_utils::lock_guard lock(hardwareMutex());
Eric Laurenta4c5a552012-03-29 10:12:40 -0700713 if (module == 0) {
714 ALOGW("findSuitableHwDev_l() loading well know audio hw modules");
Mikhail Naganovbf493082017-04-17 17:37:12 -0700715 for (size_t i = 0; i < arraysize(audio_interfaces); i++) {
Andy Hungc2cf7ec2023-08-30 18:19:00 -0700716 loadHwModule_ll(audio_interfaces[i]);
Eric Laurenta4c5a552012-03-29 10:12:40 -0700717 }
Eric Laurentf1c04f92012-08-28 14:26:53 -0700718 // then try to find a module supporting the requested device.
719 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
720 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueAt(i);
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700721 sp<DeviceHalInterface> dev = audioHwDevice->hwDevice();
722 uint32_t supportedDevices;
723 if (dev->getSupportedDevices(&supportedDevices) == OK &&
jiabin43810402019-10-24 14:58:31 -0700724 (supportedDevices & deviceType) == deviceType) {
Eric Laurentf1c04f92012-08-28 14:26:53 -0700725 return audioHwDevice;
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700726 }
Eric Laurentf1c04f92012-08-28 14:26:53 -0700727 }
Eric Laurenta4c5a552012-03-29 10:12:40 -0700728 } else {
729 // check a match for the requested module handle
John Grossmanee578c02012-07-23 17:05:46 -0700730 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueFor(module);
731 if (audioHwDevice != NULL) {
732 return audioHwDevice;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700733 }
734 }
Eric Laurenta4c5a552012-03-29 10:12:40 -0700735
Dima Zavin799a70e2011-04-18 16:57:27 -0700736 return NULL;
737}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700738
Andy Hungc2cf7ec2023-08-30 18:19:00 -0700739void AudioFlinger::dumpClients_ll(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700740{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700741 String8 result;
742
Atneya Nair9ec58d52022-10-03 15:46:20 -0700743 result.append("Client Allocators:\n");
Mathias Agopian65ab4712010-07-14 17:59:35 -0700744 for (size_t i = 0; i < mClients.size(); ++i) {
Glenn Kasten77c11192012-01-25 14:27:41 -0800745 sp<Client> client = mClients.valueAt(i).promote();
746 if (client != 0) {
Atneya Nair9ec58d52022-10-03 15:46:20 -0700747 result.appendFormat("Client: %d\n", client->pid());
Atneya3c61d882021-09-20 14:52:15 -0400748 result.append(client->allocator().dump().c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700749 }
Atneya3c61d882021-09-20 14:52:15 -0400750 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700751
Eric Laurentd1b28d42013-09-18 18:47:13 -0700752 result.append("Notification Clients:\n");
Andy Hung5bdc5352019-12-23 14:36:31 -0800753 result.append(" pid uid name\n");
Andy Hung05b0ffe2024-08-30 17:18:37 -0700754 for (const auto& [ _, client ] : mNotificationClients) {
755 const uid_t uid = client->getUid();
Andy Hungb26a1c82024-08-30 11:54:40 -0700756 const std::shared_ptr<const mediautils::UidInfo::Info> info =
757 mediautils::UidInfo::getInfo(uid);
Andy Hung05b0ffe2024-08-30 17:18:37 -0700758 result.appendFormat("%6d %6u %s\n",
759 client->getPid(), uid, info->package.c_str());
Eric Laurentd1b28d42013-09-18 18:47:13 -0700760 }
761
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700762 result.append("Global session refs:\n");
Andy Hung8b0bfd92019-12-23 13:11:11 -0800763 result.append(" session cnt pid uid name\n");
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700764 for (size_t i = 0; i < mAudioSessionRefs.size(); i++) {
765 AudioSessionRef *r = mAudioSessionRefs[i];
Andy Hungb26a1c82024-08-30 11:54:40 -0700766 const std::shared_ptr<const mediautils::UidInfo::Info> info =
767 mediautils::UidInfo::getInfo(r->mUid);
Andy Hung8b0bfd92019-12-23 13:11:11 -0800768 result.appendFormat(" %7d %4d %7d %6u %s\n", r->mSessionid, r->mCnt, r->mPid,
Andy Hungb26a1c82024-08-30 11:54:40 -0700769 r->mUid, info->package.c_str());
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700770 }
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000771 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700772}
773
774
Andy Hungc2cf7ec2023-08-30 18:19:00 -0700775void AudioFlinger::dumpInternals_l(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700776{
777 const size_t SIZE = 256;
778 char buffer[SIZE];
779 String8 result;
Glenn Kastena4454b42012-01-04 11:02:33 -0800780 hardware_call_state hardwareStatus = mHardwareStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700781
Andy Hung8fe87eb2023-07-20 21:31:38 -0700782 snprintf(buffer, SIZE, "Hardware status: %d\n", hardwareStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700783 result.append(buffer);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000784 write(fd, result.c_str(), result.size());
jiabinc47acf22022-04-01 23:47:52 +0000785
786 dprintf(fd, "Vibrator infos(size=%zu):\n", mAudioVibratorInfos.size());
787 for (const auto& vibratorInfo : mAudioVibratorInfos) {
788 dprintf(fd, " - %s\n", vibratorInfo.toString().c_str());
789 }
Eric Laurent90cea102023-05-15 15:08:27 +0200790 dprintf(fd, "Bluetooth latency modes are %senabled\n",
791 mBluetoothLatencyModesEnabled ? "" : "not ");
Mathias Agopian65ab4712010-07-14 17:59:35 -0700792}
793
Glenn Kasten0f11b512014-01-31 16:18:54 -0800794void AudioFlinger::dumpPermissionDenial(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700795{
796 const size_t SIZE = 256;
797 char buffer[SIZE];
798 String8 result;
799 snprintf(buffer, SIZE, "Permission Denial: "
800 "can't dump AudioFlinger from pid=%d, uid=%d\n",
801 IPCThreadState::self()->getCallingPid(),
802 IPCThreadState::self()->getCallingUid());
803 result.append(buffer);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000804 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700805}
806
Mathias Agopian65ab4712010-07-14 17:59:35 -0700807status_t AudioFlinger::dump(int fd, const Vector<String16>& args)
Andy Hung920f6572022-10-06 12:09:49 -0700808NO_THREAD_SAFETY_ANALYSIS // conditional try lock
Mathias Agopian65ab4712010-07-14 17:59:35 -0700809{
Glenn Kasten44deb052012-02-05 18:09:08 -0800810 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700811 dumpPermissionDenial(fd, args);
812 } else {
813 // get state of hardware lock
Andy Hung954b9712023-08-28 18:36:53 -0700814 const bool hardwareLocked = afutils::dumpTryLock(hardwareMutex());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700815 if (!hardwareLocked) {
816 String8 result(kHardwareLockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000817 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700818 } else {
Andy Hung954b9712023-08-28 18:36:53 -0700819 hardwareMutex().unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700820 }
821
Andy Hung954b9712023-08-28 18:36:53 -0700822 const bool locked = afutils::dumpTryLock(mutex());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700823
824 // failed to lock - AudioFlinger is probably deadlocked
825 if (!locked) {
826 String8 result(kDeadlockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000827 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700828 }
829
Andy Hung954b9712023-08-28 18:36:53 -0700830 const bool clientLocked = afutils::dumpTryLock(clientMutex());
Eric Laurent021cf962014-05-13 10:18:14 -0700831 if (!clientLocked) {
832 String8 result(kClientLockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000833 write(fd, result.c_str(), result.size());
Eric Laurent021cf962014-05-13 10:18:14 -0700834 }
Marco Nelissend89eadd2014-10-07 13:28:44 -0700835
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700836 if (mEffectsFactoryHal != 0) {
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700837 mEffectsFactoryHal->dumpEffects(fd);
838 } else {
839 String8 result(kNoEffectsFactory);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000840 write(fd, result.c_str(), result.size());
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700841 }
Marco Nelissend89eadd2014-10-07 13:28:44 -0700842
Andy Hungc2cf7ec2023-08-30 18:19:00 -0700843 dumpClients_ll(fd, args);
Eric Laurent021cf962014-05-13 10:18:14 -0700844 if (clientLocked) {
Andy Hung954b9712023-08-28 18:36:53 -0700845 clientMutex().unlock();
Eric Laurent021cf962014-05-13 10:18:14 -0700846 }
847
Andy Hungc2cf7ec2023-08-30 18:19:00 -0700848 dumpInternals_l(fd, args);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700849
850 // dump playback threads
851 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
852 mPlaybackThreads.valueAt(i)->dump(fd, args);
853 }
854
855 // dump record threads
856 for (size_t i = 0; i < mRecordThreads.size(); i++) {
857 mRecordThreads.valueAt(i)->dump(fd, args);
858 }
859
Eric Laurent6acd1d42017-01-04 14:23:29 -0800860 // dump mmap threads
861 for (size_t i = 0; i < mMmapThreads.size(); i++) {
862 mMmapThreads.valueAt(i)->dump(fd, args);
863 }
864
Eric Laurentaaa44472014-09-12 17:41:50 -0700865 // dump orphan effect chains
866 if (mOrphanEffectChains.size() != 0) {
867 write(fd, " Orphan Effect Chains\n", strlen(" Orphan Effect Chains\n"));
868 for (size_t i = 0; i < mOrphanEffectChains.size(); i++) {
869 mOrphanEffectChains.valueAt(i)->dump(fd, args);
870 }
871 }
Dima Zavin799a70e2011-04-18 16:57:27 -0700872 // dump all hardware devs
873 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700874 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
Andy Hung61589a42021-06-16 09:37:53 -0700875 dev->dump(fd, args);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700876 }
Glenn Kastend06785b2012-09-30 12:29:28 -0700877
Andy Hungb6692eb2023-07-13 16:52:46 -0700878 mPatchPanel->dump(fd);
Mikhail Naganov201369b2018-05-16 16:52:32 -0700879
Vlad Popa5161f8a2022-10-10 16:17:20 +0200880 mDeviceEffectManager->dump(fd);
Eric Laurentb82e6b72019-11-22 17:25:04 -0800881
Vlad Popab042ee62022-10-20 18:05:00 +0200882 std::string melOutput = mMelReporter->dump();
883 write(fd, melOutput.c_str(), melOutput.size());
884
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -0700885 // dump external setParameters
886 auto dumpLogger = [fd](SimpleLog& logger, const char* name) {
887 dprintf(fd, "\n%s setParameters:\n", name);
888 logger.dump(fd, " " /* prefix */);
889 };
890 dumpLogger(mRejectedSetParameterLog, "Rejected");
891 dumpLogger(mAppSetParameterLog, "App");
892 dumpLogger(mSystemSetParameterLog, "System");
893
Andy Hunga8115dc2018-08-24 15:51:59 -0700894 // dump historical threads in the last 10 seconds
895 const std::string threadLog = mThreadLog.dumpToString(
896 "Historical Thread Log ", 0 /* lines */,
897 audio_utils_get_real_time_ns() - 10 * 60 * NANOS_PER_SECOND);
898 write(fd, threadLog.c_str(), threadLog.size());
899
rago3bd1c872016-09-26 12:58:14 -0700900 BUFLOG_RESET;
901
Andy Hung88a7afe2024-08-12 20:00:46 -0700902 if (media::psh_utils::AudioPowerManager::enabled()) {
903 char value[PROPERTY_VALUE_MAX];
904 property_get("ro.build.display.id", value, "Unknown build");
905 std::string build(value);
906 build.append("\n");
907 write(fd, build.c_str(), build.size());
908 const std::string powerLog =
909 media::psh_utils::AudioPowerManager::getAudioPowerManager().toString();
910 write(fd, powerLog.c_str(), powerLog.size());
911 }
912
Glenn Kastend65d73c2012-06-22 17:21:07 -0700913 if (locked) {
Andy Hung954b9712023-08-28 18:36:53 -0700914 mutex().unlock();
Glenn Kastend65d73c2012-06-22 17:21:07 -0700915 }
Glenn Kasten9e58b552013-01-18 15:09:48 -0800916
Andy Hung8946a282018-04-19 20:04:56 -0700917#ifdef TEE_SINK
918 // NBAIO_Tee dump is safe to call outside of AF lock.
919 NBAIO_Tee::dumpAll(fd, "_DUMP");
920#endif
Glenn Kasten9e58b552013-01-18 15:09:48 -0800921 // append a copy of media.log here by forwarding fd to it, but don't attempt
922 // to lookup the service if it's not running, as it will block for a second
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700923 if (sMediaLogServiceAsBinder != 0) {
924 dprintf(fd, "\nmedia.log:\n");
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700925 sMediaLogServiceAsBinder->dump(fd, args);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800926 }
Andy Hung35fec5f2016-04-13 14:21:48 -0700927
928 // check for optional arguments
Andy Hung07b745e2016-05-23 16:21:07 -0700929 bool dumpMem = false;
Andy Hung35fec5f2016-04-13 14:21:48 -0700930 bool unreachableMemory = false;
931 for (const auto &arg : args) {
Andy Hung07b745e2016-05-23 16:21:07 -0700932 if (arg == String16("-m")) {
933 dumpMem = true;
934 } else if (arg == String16("--unreachable")) {
Andy Hung35fec5f2016-04-13 14:21:48 -0700935 unreachableMemory = true;
936 }
937 }
938
Andy Hung07b745e2016-05-23 16:21:07 -0700939 if (dumpMem) {
940 dprintf(fd, "\nDumping memory:\n");
941 std::string s = dumpMemoryAddresses(100 /* limit */);
942 write(fd, s.c_str(), s.size());
943 }
Andy Hung35fec5f2016-04-13 14:21:48 -0700944 if (unreachableMemory) {
945 dprintf(fd, "\nDumping unreachable memory:\n");
946 // TODO - should limit be an argument parameter?
Andy Hung07b745e2016-05-23 16:21:07 -0700947 std::string s = GetUnreachableMemoryString(true /* contents */, 100 /* limit */);
Andy Hung35fec5f2016-04-13 14:21:48 -0700948 write(fd, s.c_str(), s.size());
949 }
Andy Hungc747c532022-03-07 21:41:14 -0800950 {
951 std::string timeCheckStats = getIAudioFlingerStatistics().dump();
Andy Hung224f82f2022-03-22 00:00:49 -0700952 dprintf(fd, "\nIAudioFlinger binder call profile:\n");
Andy Hungc747c532022-03-07 21:41:14 -0800953 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
954
955 extern mediautils::MethodStatistics<int>& getIEffectStatistics();
956 timeCheckStats = getIEffectStatistics().dump();
Andy Hung224f82f2022-03-22 00:00:49 -0700957 dprintf(fd, "\nIEffect binder call profile:\n");
Andy Hungc747c532022-03-07 21:41:14 -0800958 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
Andy Hung224f82f2022-03-22 00:00:49 -0700959
Shunkai Yaod4532c82023-12-17 20:01:45 +0000960 // Automatically fetch HIDL or AIDL statistics.
961 const std::string_view halType = (mDevicesFactoryHal->getHalVersion().getType() ==
962 AudioHalVersionInfo::Type::HIDL)
963 ? METHOD_STATISTICS_MODULE_NAME_AUDIO_HIDL
964 : METHOD_STATISTICS_MODULE_NAME_AUDIO_AIDL;
965 const std::shared_ptr<std::vector<std::string>> halClassNames =
966 mediautils::getStatisticsClassesForModule(halType);
967 if (halClassNames) {
968 for (const auto& className : *halClassNames) {
Andy Hung224f82f2022-03-22 00:00:49 -0700969 auto stats = mediautils::getStatisticsForClass(className);
970 if (stats) {
971 timeCheckStats = stats->dump();
972 dprintf(fd, "\n%s binder call profile:\n", className.c_str());
973 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
974 }
975 }
976 }
977
978 timeCheckStats = mediautils::TimeCheck::toString();
979 dprintf(fd, "\nTimeCheck:\n");
980 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
981 dprintf(fd, "\n");
Andy Hungc747c532022-03-07 21:41:14 -0800982 }
Andy Hungfba891d2023-10-12 18:18:13 -0700983 // dump mutex stats
984 const auto mutexStats = audio_utils::mutex::all_stats_to_string();
985 write(fd, mutexStats.c_str(), mutexStats.size());
Andy Hungc6877d62023-10-17 18:43:12 -0700986
987 // dump held mutexes
988 const auto mutexThreadInfo = audio_utils::mutex::all_threads_to_string();
989 write(fd, mutexThreadInfo.c_str(), mutexThreadInfo.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700990 }
991 return NO_ERROR;
992}
993
Andy Hung59867e42023-06-27 17:05:02 -0700994sp<Client> AudioFlinger::registerPid(pid_t pid)
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800995{
Andy Hung954b9712023-08-28 18:36:53 -0700996 audio_utils::lock_guard _cl(clientMutex());
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800997 // If pid is already in the mClients wp<> map, then use that entry
998 // (for which promote() is always != 0), otherwise create a new entry and Client.
999 sp<Client> client = mClients.valueFor(pid).promote();
1000 if (client == 0) {
Andy Hung47c01172023-07-17 12:40:43 -07001001 client = sp<Client>::make(sp<IAfClientCallback>::fromExisting(this), pid);
Glenn Kasten98ec94c2012-01-25 14:28:29 -08001002 mClients.add(pid, client);
1003 }
1004
1005 return client;
1006}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001007
Glenn Kasten9e58b552013-01-18 15:09:48 -08001008sp<NBLog::Writer> AudioFlinger::newWriter_l(size_t size, const char *name)
1009{
Jiabin Huang60766082020-07-28 22:03:56 +00001010 // If there is no memory allocated for logs, return a no-op writer that does nothing.
1011 // Similarly if we can't contact the media.log service, also return a no-op writer.
Glenn Kasten04b96fc2017-04-10 14:58:47 -07001012 if (mLogMemoryDealer == 0 || sMediaLogService == 0) {
Glenn Kasten9e58b552013-01-18 15:09:48 -08001013 return new NBLog::Writer();
1014 }
Glenn Kasten481fb672013-09-30 14:39:28 -07001015 sp<IMemory> shared = mLogMemoryDealer->allocate(NBLog::Timeline::sharedSize(size));
1016 // If allocation fails, consult the vector of previously unregistered writers
1017 // and garbage-collect one or more them until an allocation succeeds
1018 if (shared == 0) {
Andy Hung954b9712023-08-28 18:36:53 -07001019 audio_utils::lock_guard _l(unregisteredWritersMutex());
Glenn Kasten481fb672013-09-30 14:39:28 -07001020 for (size_t count = mUnregisteredWriters.size(); count > 0; count--) {
1021 {
1022 // Pick the oldest stale writer to garbage-collect
1023 sp<IMemory> iMemory(mUnregisteredWriters[0]->getIMemory());
1024 mUnregisteredWriters.removeAt(0);
Glenn Kasten04b96fc2017-04-10 14:58:47 -07001025 sMediaLogService->unregisterWriter(iMemory);
Glenn Kasten481fb672013-09-30 14:39:28 -07001026 // Now the media.log remote reference to IMemory is gone. When our last local
1027 // reference to IMemory also drops to zero at end of this block,
1028 // the IMemory destructor will deallocate the region from mLogMemoryDealer.
1029 }
1030 // Re-attempt the allocation
1031 shared = mLogMemoryDealer->allocate(NBLog::Timeline::sharedSize(size));
1032 if (shared != 0) {
1033 goto success;
1034 }
1035 }
1036 // Even after garbage-collecting all old writers, there is still not enough memory,
Jiabin Huang60766082020-07-28 22:03:56 +00001037 // so return a no-op writer
Glenn Kasten481fb672013-09-30 14:39:28 -07001038 return new NBLog::Writer();
1039 }
1040success:
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07001041 NBLog::Shared *sharedRawPtr = (NBLog::Shared *) shared->unsecurePointer();
Glenn Kasten535e1612016-12-05 12:19:36 -08001042 new((void *) sharedRawPtr) NBLog::Shared(); // placement new here, but the corresponding
1043 // explicit destructor not needed since it is POD
Glenn Kasten04b96fc2017-04-10 14:58:47 -07001044 sMediaLogService->registerWriter(shared, size, name);
Glenn Kasten535e1612016-12-05 12:19:36 -08001045 return new NBLog::Writer(shared, size);
Glenn Kasten9e58b552013-01-18 15:09:48 -08001046}
1047
1048void AudioFlinger::unregisterWriter(const sp<NBLog::Writer>& writer)
1049{
Glenn Kasten685ef092013-02-04 08:15:34 -08001050 if (writer == 0) {
1051 return;
1052 }
Glenn Kasten9e58b552013-01-18 15:09:48 -08001053 sp<IMemory> iMemory(writer->getIMemory());
1054 if (iMemory == 0) {
1055 return;
1056 }
Glenn Kasten481fb672013-09-30 14:39:28 -07001057 // Rather than removing the writer immediately, append it to a queue of old writers to
1058 // be garbage-collected later. This allows us to continue to view old logs for a while.
Andy Hung954b9712023-08-28 18:36:53 -07001059 audio_utils::lock_guard _l(unregisteredWritersMutex());
Glenn Kasten481fb672013-09-30 14:39:28 -07001060 mUnregisteredWriters.push(writer);
Glenn Kasten9e58b552013-01-18 15:09:48 -08001061}
1062
Mathias Agopian65ab4712010-07-14 17:59:35 -07001063// IAudioFlinger interface
1064
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08001065status_t AudioFlinger::createTrack(const media::CreateTrackRequest& _input,
1066 media::CreateTrackResponse& _output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001067{
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001068 // Local version of VALUE_OR_RETURN, specific to this method's calling conventions.
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08001069 CreateTrackInput input = VALUE_OR_RETURN_STATUS(CreateTrackInput::fromAidl(_input));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001070 CreateTrackOutput output;
1071
Andy Hungd29af632023-06-23 19:27:19 -07001072 sp<IAfTrack> track;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001073 sp<Client> client;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001074 status_t lStatus;
Eric Laurent21da6472017-11-09 16:29:26 -08001075 audio_stream_type_t streamType;
Eric Laurent77881cd2018-02-09 16:01:31 -08001076 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
Kevin Rocard153f92d2018-12-18 18:33:28 -08001077 std::vector<audio_io_handle_t> secondaryOutputs;
jiabinc658e452022-10-21 20:52:21 +00001078 bool isSpatialized = false;
1079 bool isBitPerfect = false;
Andy Hung6b137d12024-08-27 22:35:17 +00001080 float volume;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001081
Eric Laurent6c796322019-04-09 14:13:17 -07001082 audio_io_handle_t effectThreadId = AUDIO_IO_HANDLE_NONE;
1083 std::vector<int> effectIds;
Eric Laurent42984412019-05-09 17:57:03 -07001084 audio_attributes_t localAttr = input.attr;
Eric Laurent6c796322019-04-09 14:13:17 -07001085
Atneya Nair5997a652024-06-14 17:24:45 -07001086 AttributionSourceState adjAttributionSource;
1087 pid_t callingPid = IPCThreadState::self()->getCallingPid();
1088 if (!com::android::media::audio::audioserver_permissions()) {
1089 adjAttributionSource = input.clientInfo.attributionSource;
1090 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
1091 uid_t clientUid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_uid_t(
1092 input.clientInfo.attributionSource.uid));
1093 pid_t clientPid =
1094 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(
1095 input.clientInfo.attributionSource.pid));
1096 bool updatePid = (clientPid == (pid_t)-1);
1097
1098 if (!isAudioServerOrMediaServerOrSystemServerOrRootUid(callingUid)) {
1099 ALOGW_IF(clientUid != callingUid,
1100 "%s uid %d tried to pass itself off as %d",
1101 __FUNCTION__, callingUid, clientUid);
1102 adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(
1103 legacy2aidl_uid_t_int32_t(callingUid));
1104 clientUid = callingUid;
1105 updatePid = true;
1106 }
1107 if (updatePid) {
1108 ALOGW_IF(clientPid != (pid_t)-1 && clientPid != callingPid,
1109 "%s uid %d pid %d tried to pass itself off as pid %d",
1110 __func__, callingUid, callingPid, clientPid);
1111 clientPid = callingPid;
1112 adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(
1113 legacy2aidl_pid_t_int32_t(callingPid));
1114 }
1115 adjAttributionSource = afutils::checkAttributionSourcePackage(
1116 adjAttributionSource);
1117
1118 } else {
1119 auto validatedAttrSource = VALUE_OR_RETURN_CONVERTED(
1120 validateAttributionFromContextOrTrustedCaller(input.clientInfo.attributionSource,
1121 getPermissionProvider()
1122 ));
1123 // TODO pass wrapped object around
1124 adjAttributionSource = std::move(validatedAttrSource).unwrapInto();
Eric Laurent21da6472017-11-09 16:29:26 -08001125 }
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07001126
Eric Laurent21da6472017-11-09 16:29:26 -08001127 audio_session_t sessionId = input.sessionId;
1128 if (sessionId == AUDIO_SESSION_ALLOCATE) {
1129 sessionId = (audio_session_t) newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
Eric Laurentf14db3c2017-12-08 14:20:36 -08001130 } else if (audio_unique_id_get_use(sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) {
1131 lStatus = BAD_VALUE;
1132 goto Exit;
Eric Laurent21da6472017-11-09 16:29:26 -08001133 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08001134
Eric Laurent21da6472017-11-09 16:29:26 -08001135 output.sessionId = sessionId;
1136 output.outputId = AUDIO_IO_HANDLE_NONE;
1137 output.selectedDeviceId = input.selectedDeviceId;
Eric Laurent42984412019-05-09 17:57:03 -07001138 lStatus = AudioSystem::getOutputForAttr(&localAttr, &output.outputId, sessionId, &streamType,
Svet Ganov33761132021-05-13 22:51:08 +00001139 adjAttributionSource, &input.config, input.flags,
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001140 &output.selectedDeviceId, &portId, &secondaryOutputs,
Andy Hung6b137d12024-08-27 22:35:17 +00001141 &isSpatialized, &isBitPerfect, &volume);
Eric Laurent21da6472017-11-09 16:29:26 -08001142
1143 if (lStatus != NO_ERROR || output.outputId == AUDIO_IO_HANDLE_NONE) {
1144 ALOGE("createTrack() getOutputForAttr() return error %d or invalid output handle", lStatus);
1145 goto Exit;
1146 }
Glenn Kasten263709e2012-01-06 08:40:01 -08001147 // client AudioTrack::set already implements AUDIO_STREAM_DEFAULT => AUDIO_STREAM_MUSIC,
1148 // but if someone uses binder directly they could bypass that and cause us to crash
1149 if (uint32_t(streamType) >= AUDIO_STREAM_CNT) {
Steve Block29357bc2012-01-06 19:20:56 +00001150 ALOGE("createTrack() invalid stream type %d", streamType);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001151 lStatus = BAD_VALUE;
1152 goto Exit;
1153 }
1154
Glenn Kasten53b5d092014-02-05 10:00:23 -08001155 // further channel mask checks are performed by createTrack_l() depending on the thread type
Eric Laurent21da6472017-11-09 16:29:26 -08001156 if (!audio_is_output_channel(input.config.channel_mask)) {
1157 ALOGE("createTrack() invalid channel mask %#x", input.config.channel_mask);
Glenn Kasten53b5d092014-02-05 10:00:23 -08001158 lStatus = BAD_VALUE;
1159 goto Exit;
1160 }
1161
Glenn Kastenc4b88a82014-04-30 16:54:30 -07001162 // further format checks are performed by createTrack_l() depending on the thread type
Eric Laurent21da6472017-11-09 16:29:26 -08001163 if (!audio_is_valid_format(input.config.format)) {
1164 ALOGE("createTrack() invalid format %#x", input.config.format);
Glenn Kasten663c2242013-09-24 11:52:37 -07001165 lStatus = BAD_VALUE;
1166 goto Exit;
1167 }
1168
Mathias Agopian65ab4712010-07-14 17:59:35 -07001169 {
Andy Hung954b9712023-08-28 18:36:53 -07001170 audio_utils::lock_guard _l(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07001171 IAfPlaybackThread* thread = checkPlaybackThread_l(output.outputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001172 if (thread == NULL) {
Eric Laurent21da6472017-11-09 16:29:26 -08001173 ALOGE("no playback thread found for output handle %d", output.outputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001174 lStatus = BAD_VALUE;
1175 goto Exit;
1176 }
1177
Atneya Nair5997a652024-06-14 17:24:45 -07001178 client = registerPid(adjAttributionSource.pid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001179
Andy Hung87c693c2023-07-06 20:56:16 -07001180 IAfPlaybackThread* effectThread = nullptr;
Shunkai Yao29d10572024-03-19 04:31:47 +00001181 sp<IAfEffectChain> effectChain = nullptr;
Eric Laurent21da6472017-11-09 16:29:26 -08001182 // check if an effect chain with the same session ID is present on another
1183 // output thread and move it here.
1184 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Andy Hung87c693c2023-07-06 20:56:16 -07001185 sp<IAfPlaybackThread> t = mPlaybackThreads.valueAt(i);
Eric Laurent21da6472017-11-09 16:29:26 -08001186 if (mPlaybackThreads.keyAt(i) != output.outputId) {
1187 uint32_t sessions = t->hasAudioSession(sessionId);
Andy Hung87c693c2023-07-06 20:56:16 -07001188 if (sessions & IAfThreadBase::EFFECT_SESSION) {
Eric Laurent21da6472017-11-09 16:29:26 -08001189 effectThread = t.get();
1190 break;
Eric Laurentde070132010-07-13 04:45:46 -07001191 }
1192 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001193 }
Shunkai Yao29d10572024-03-19 04:31:47 +00001194 // Check if an orphan effect chain exists for this session
1195 if (effectThread == nullptr) {
1196 effectChain = getOrphanEffectChain_l(sessionId);
1197 }
Andy Hung6b137d12024-08-27 22:35:17 +00001198 ALOGV("createTrack() sessionId: %d volume: %f", sessionId, volume);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001199
Eric Laurent21da6472017-11-09 16:29:26 -08001200 output.sampleRate = input.config.sample_rate;
1201 output.frameCount = input.frameCount;
1202 output.notificationFrameCount = input.notificationFrameCount;
1203 output.flags = input.flags;
Andy Hunga2159aa2021-07-20 13:01:52 -07001204 output.streamType = streamType;
Eric Laurent21da6472017-11-09 16:29:26 -08001205
Eric Laurent42984412019-05-09 17:57:03 -07001206 track = thread->createTrack_l(client, streamType, localAttr, &output.sampleRate,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001207 input.config.format, input.config.channel_mask,
Eric Laurent21da6472017-11-09 16:29:26 -08001208 &output.frameCount, &output.notificationFrameCount,
1209 input.notificationsPerBuffer, input.speed,
1210 input.sharedBuffer, sessionId, &output.flags,
Svet Ganov33761132021-05-13 22:51:08 +00001211 callingPid, adjAttributionSource, input.clientInfo.clientTid,
jiabinc658e452022-10-21 20:52:21 +00001212 &lStatus, portId, input.audioTrackCallback, isSpatialized,
Andy Hung6b137d12024-08-27 22:35:17 +00001213 isBitPerfect, &output.afTrackFlags, volume);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08001214 LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (track == 0));
Glenn Kasten2fc14732013-08-05 14:58:14 -07001215 // we don't abort yet if lStatus != NO_ERROR; there is still work to be done regardless
Eric Laurent39e94f82010-07-28 01:32:47 -07001216
Eric Laurent21da6472017-11-09 16:29:26 -08001217 output.afFrameCount = thread->frameCount();
1218 output.afSampleRate = thread->sampleRate();
Robert Wu310037a2022-09-06 21:48:18 +00001219 output.afChannelMask = static_cast<audio_channel_mask_t>(thread->channelMask() |
1220 thread->hapticChannelMask());
1221 output.afFormat = thread->format();
Eric Laurent21da6472017-11-09 16:29:26 -08001222 output.afLatencyMs = thread->latency();
Eric Laurent973db022018-11-20 14:54:31 -08001223 output.portId = portId;
Eric Laurent21da6472017-11-09 16:29:26 -08001224
Kevin Rocard153f92d2018-12-18 18:33:28 -08001225 if (lStatus == NO_ERROR) {
Andy Hung954b9712023-08-28 18:36:53 -07001226 // no risk of deadlock because AudioFlinger::mutex() is held
Andy Hungc5007f82023-08-29 14:26:09 -07001227 audio_utils::lock_guard _dl(thread->mutex());
Kevin Rocard153f92d2018-12-18 18:33:28 -08001228 // Connect secondary outputs. Failure on a secondary output must not imped the primary
1229 // Any secondary output setup failure will lead to a desync between the AP and AF until
1230 // the track is destroyed.
jiabinf042b9b2021-05-07 23:46:28 +00001231 updateSecondaryOutputsForTrack_l(track.get(), thread, secondaryOutputs);
jiabin87991352023-04-25 20:59:55 +00001232 // move effect chain to this output thread if an effect on same session was waiting
1233 // for a track to be created
1234 if (effectThread != nullptr) {
Andy Hung972bec12023-08-31 16:13:39 -07001235 // No thread safety analysis: double lock on a thread capability.
1236 audio_utils::lock_guard_no_thread_safety_analysis _sl(effectThread->mutex());
1237 if (moveEffectChain_ll(sessionId, effectThread, thread) == NO_ERROR) {
jiabin87991352023-04-25 20:59:55 +00001238 effectThreadId = thread->id();
1239 effectIds = thread->getEffectIds_l(sessionId);
1240 }
Eric Laurent6c796322019-04-09 14:13:17 -07001241 }
Shunkai Yao29d10572024-03-19 04:31:47 +00001242 if (effectChain != nullptr) {
1243 if (moveEffectChain_ll(sessionId, nullptr, thread, effectChain.get())
1244 == NO_ERROR) {
1245 effectThreadId = thread->id();
1246 effectIds = thread->getEffectIds_l(sessionId);
1247 }
1248 }
Eric Laurent39e94f82010-07-28 01:32:47 -07001249 }
Eric Laurenta011e352012-03-29 15:51:43 -07001250
1251 // Look for sync events awaiting for a session to be used.
Andy Hung068e08e2023-05-15 19:02:55 -07001252 for (auto it = mPendingSyncEvents.begin(); it != mPendingSyncEvents.end();) {
1253 if ((*it)->triggerSession() == sessionId) {
1254 if (thread->isValidSyncEvent(*it)) {
Eric Laurent29864602012-05-08 18:57:51 -07001255 if (lStatus == NO_ERROR) {
Andy Hung068e08e2023-05-15 19:02:55 -07001256 (void) track->setSyncEvent(*it);
Eric Laurent29864602012-05-08 18:57:51 -07001257 } else {
Andy Hung068e08e2023-05-15 19:02:55 -07001258 (*it)->cancel();
Eric Laurent29864602012-05-08 18:57:51 -07001259 }
Andy Hung068e08e2023-05-15 19:02:55 -07001260 it = mPendingSyncEvents.erase(it);
1261 continue;
Eric Laurenta011e352012-03-29 15:51:43 -07001262 }
1263 }
Andy Hung068e08e2023-05-15 19:02:55 -07001264 ++it;
Eric Laurenta011e352012-03-29 15:51:43 -07001265 }
Andy Hung6eff0ff2021-07-30 19:01:48 -07001266 if ((output.flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) == AUDIO_OUTPUT_FLAG_HW_AV_SYNC) {
1267 setAudioHwSyncForSession_l(thread, sessionId);
1268 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001269 }
Glenn Kastene198c362013-08-13 09:13:36 -07001270
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07001271 if (lStatus != NO_ERROR) {
1272 // remove local strong reference to Client before deleting the Track so that the
Andy Hung954b9712023-08-28 18:36:53 -07001273 // Client destructor is called by the TrackBase destructor with clientMutex() held
1274 // Don't hold clientMutex() when releasing the reference on the track as the
Eric Laurentfe1a94e2014-05-26 16:03:08 -07001275 // destructor will acquire it.
1276 {
Andy Hung954b9712023-08-28 18:36:53 -07001277 audio_utils::lock_guard _cl(clientMutex());
Eric Laurentfe1a94e2014-05-26 16:03:08 -07001278 client.clear();
1279 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001280 track.clear();
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07001281 goto Exit;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001282 }
1283
Eric Laurent6c796322019-04-09 14:13:17 -07001284 // effectThreadId is not NONE if an effect chain corresponding to the track session
1285 // was found on another thread and must be moved on this thread
1286 if (effectThreadId != AUDIO_IO_HANDLE_NONE) {
1287 AudioSystem::moveEffectsToIo(effectIds, effectThreadId);
1288 }
1289
Andy Hungd29af632023-06-23 19:27:19 -07001290 output.audioTrack = IAfTrack::createIAudioTrackAdapter(track);
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001291 _output = VALUE_OR_FATAL(output.toAidl());
1292
Mathias Agopian65ab4712010-07-14 17:59:35 -07001293Exit:
Eric Laurent21da6472017-11-09 16:29:26 -08001294 if (lStatus != NO_ERROR && output.outputId != AUDIO_IO_HANDLE_NONE) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07001295 AudioSystem::releaseOutput(portId);
Eric Laurent21da6472017-11-09 16:29:26 -08001296 }
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08001297 return lStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001298}
1299
Glenn Kasten2c073da2016-02-26 09:14:08 -08001300uint32_t AudioFlinger::sampleRate(audio_io_handle_t ioHandle) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001301{
Andy Hung954b9712023-08-28 18:36:53 -07001302 audio_utils::lock_guard _l(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07001303 IAfThreadBase* const thread = checkThread_l(ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001304 if (thread == NULL) {
Glenn Kasten2c073da2016-02-26 09:14:08 -08001305 ALOGW("sampleRate() unknown thread %d", ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001306 return 0;
1307 }
1308 return thread->sampleRate();
1309}
1310
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001311audio_format_t AudioFlinger::format(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001312{
Andy Hung954b9712023-08-28 18:36:53 -07001313 audio_utils::lock_guard _l(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07001314 IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001315 if (thread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +00001316 ALOGW("format() unknown thread %d", output);
Glenn Kasten58f30212012-01-12 12:27:51 -08001317 return AUDIO_FORMAT_INVALID;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001318 }
1319 return thread->format();
1320}
1321
Glenn Kasten2c073da2016-02-26 09:14:08 -08001322size_t AudioFlinger::frameCount(audio_io_handle_t ioHandle) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001323{
Andy Hung954b9712023-08-28 18:36:53 -07001324 audio_utils::lock_guard _l(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07001325 IAfThreadBase* const thread = checkThread_l(ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001326 if (thread == NULL) {
Glenn Kasten2c073da2016-02-26 09:14:08 -08001327 ALOGW("frameCount() unknown thread %d", ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001328 return 0;
1329 }
Glenn Kasten58912562012-04-03 10:45:00 -07001330 // FIXME currently returns the normal mixer's frame count to avoid confusing legacy callers;
1331 // should examine all callers and fix them to handle smaller counts
Mathias Agopian65ab4712010-07-14 17:59:35 -07001332 return thread->frameCount();
1333}
1334
Glenn Kasten4a8308b2016-04-18 14:10:01 -07001335size_t AudioFlinger::frameCountHAL(audio_io_handle_t ioHandle) const
1336{
Andy Hung954b9712023-08-28 18:36:53 -07001337 audio_utils::lock_guard _l(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07001338 IAfThreadBase* const thread = checkThread_l(ioHandle);
Glenn Kasten4a8308b2016-04-18 14:10:01 -07001339 if (thread == NULL) {
1340 ALOGW("frameCountHAL() unknown thread %d", ioHandle);
1341 return 0;
1342 }
1343 return thread->frameCountHAL();
1344}
1345
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001346uint32_t AudioFlinger::latency(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001347{
Andy Hung954b9712023-08-28 18:36:53 -07001348 audio_utils::lock_guard _l(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07001349 IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001350 if (thread == NULL) {
Glenn Kastenc9b2e202013-02-26 11:32:32 -08001351 ALOGW("latency(): no playback thread found for output handle %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001352 return 0;
1353 }
1354 return thread->latency();
1355}
1356
1357status_t AudioFlinger::setMasterVolume(float value)
1358{
Eric Laurenta1884f92011-08-23 08:25:03 -07001359 status_t ret = initCheck();
1360 if (ret != NO_ERROR) {
1361 return ret;
1362 }
1363
Mathias Agopian65ab4712010-07-14 17:59:35 -07001364 // check calling permissions
1365 if (!settingsAllowed()) {
1366 return PERMISSION_DENIED;
1367 }
1368
Andy Hung954b9712023-08-28 18:36:53 -07001369 audio_utils::lock_guard _l(mutex());
John Grossmanee578c02012-07-23 17:05:46 -07001370 mMasterVolume = value;
Eric Laurenta4c5a552012-03-29 10:12:40 -07001371
John Grossmanee578c02012-07-23 17:05:46 -07001372 // Set master volume in the HALs which support it.
Eric Laurent00abf0d2020-04-22 19:28:22 -07001373 {
Andy Hung954b9712023-08-28 18:36:53 -07001374 audio_utils::lock_guard lock(hardwareMutex());
Eric Laurent00abf0d2020-04-22 19:28:22 -07001375 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
1376 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
John Grossman4ff14ba2012-02-08 16:37:41 -08001377
Eric Laurent00abf0d2020-04-22 19:28:22 -07001378 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
1379 if (dev->canSetMasterVolume()) {
1380 dev->hwDevice()->setMasterVolume(value);
1381 }
1382 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent93575202011-01-18 18:39:02 -08001383 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001384 }
John Grossmanee578c02012-07-23 17:05:46 -07001385 // Now set the master volume in each playback thread. Playback threads
1386 // assigned to HALs which do not have master volume support will apply
1387 // master volume during the mix operation. Threads with HALs which do
1388 // support master volume will simply ignore the setting.
Eric Laurentf6870ae2015-05-08 10:50:03 -07001389 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1390 if (mPlaybackThreads.valueAt(i)->isDuplicating()) {
1391 continue;
1392 }
John Grossmanee578c02012-07-23 17:05:46 -07001393 mPlaybackThreads.valueAt(i)->setMasterVolume(value);
Eric Laurentf6870ae2015-05-08 10:50:03 -07001394 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001395
1396 return NO_ERROR;
1397}
1398
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001399status_t AudioFlinger::setMasterBalance(float balance)
1400{
1401 status_t ret = initCheck();
1402 if (ret != NO_ERROR) {
1403 return ret;
1404 }
1405
1406 // check calling permissions
1407 if (!settingsAllowed()) {
1408 return PERMISSION_DENIED;
1409 }
1410
1411 // check range
1412 if (isnan(balance) || fabs(balance) > 1.f) {
1413 return BAD_VALUE;
1414 }
1415
Andy Hung954b9712023-08-28 18:36:53 -07001416 audio_utils::lock_guard _l(mutex());
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001417
1418 // short cut.
1419 if (mMasterBalance == balance) return NO_ERROR;
1420
1421 mMasterBalance = balance;
1422
1423 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1424 if (mPlaybackThreads.valueAt(i)->isDuplicating()) {
1425 continue;
1426 }
1427 mPlaybackThreads.valueAt(i)->setMasterBalance(balance);
1428 }
1429
1430 return NO_ERROR;
1431}
1432
Glenn Kastenf78aee72012-01-04 11:00:47 -08001433status_t AudioFlinger::setMode(audio_mode_t mode)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001434{
Eric Laurenta1884f92011-08-23 08:25:03 -07001435 status_t ret = initCheck();
1436 if (ret != NO_ERROR) {
1437 return ret;
1438 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001439
1440 // check calling permissions
1441 if (!settingsAllowed()) {
1442 return PERMISSION_DENIED;
1443 }
Glenn Kasten930f4ca2012-01-06 16:47:31 -08001444 if (uint32_t(mode) >= AUDIO_MODE_CNT) {
Steve Block5ff1dd52012-01-05 23:22:43 +00001445 ALOGW("Illegal value: setMode(%d)", mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001446 return BAD_VALUE;
1447 }
1448
1449 { // scope for the lock
Andy Hung954b9712023-08-28 18:36:53 -07001450 audio_utils::lock_guard lock(hardwareMutex());
Eric Laurent00abf0d2020-04-22 19:28:22 -07001451 if (mPrimaryHardwareDev == nullptr) {
1452 return INVALID_OPERATION;
1453 }
Andy Hunge3748872023-08-30 19:05:16 -07001454 sp<DeviceHalInterface> dev = mPrimaryHardwareDev.load()->hwDevice();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001455 mHardwareStatus = AUDIO_HW_SET_MODE;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001456 ret = dev->setMode(mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001457 mHardwareStatus = AUDIO_HW_IDLE;
1458 }
1459
1460 if (NO_ERROR == ret) {
Andy Hung954b9712023-08-28 18:36:53 -07001461 audio_utils::lock_guard _l(mutex());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001462 mMode = mode;
Andy Hung920f6572022-10-06 12:09:49 -07001463 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001464 mPlaybackThreads.valueAt(i)->setMode(mode);
Andy Hung920f6572022-10-06 12:09:49 -07001465 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001466 }
1467
Joey Poomarin52989982020-03-05 17:40:49 +08001468 mediametrics::LogItem(mMetricsId)
1469 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETMODE)
1470 .set(AMEDIAMETRICS_PROP_AUDIOMODE, toString(mode))
1471 .record();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001472 return ret;
1473}
1474
1475status_t AudioFlinger::setMicMute(bool state)
1476{
Eric Laurenta1884f92011-08-23 08:25:03 -07001477 status_t ret = initCheck();
1478 if (ret != NO_ERROR) {
1479 return ret;
1480 }
1481
Mathias Agopian65ab4712010-07-14 17:59:35 -07001482 // check calling permissions
1483 if (!settingsAllowed()) {
1484 return PERMISSION_DENIED;
1485 }
1486
Andy Hung954b9712023-08-28 18:36:53 -07001487 audio_utils::lock_guard lock(hardwareMutex());
Eric Laurent00abf0d2020-04-22 19:28:22 -07001488 if (mPrimaryHardwareDev == nullptr) {
1489 return INVALID_OPERATION;
1490 }
Andy Hunge3748872023-08-30 19:05:16 -07001491 sp<DeviceHalInterface> primaryDev = mPrimaryHardwareDev.load()->hwDevice();
Eric Laurent2325bf02020-04-08 19:38:13 -07001492 if (primaryDev == nullptr) {
1493 ALOGW("%s: no primary HAL device", __func__);
1494 return INVALID_OPERATION;
1495 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001496 mHardwareStatus = AUDIO_HW_SET_MIC_MUTE;
Eric Laurent2325bf02020-04-08 19:38:13 -07001497 ret = primaryDev->setMicMute(state);
Eric Laurent2f035f52014-09-14 12:11:52 -07001498 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001499 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
Eric Laurent2325bf02020-04-08 19:38:13 -07001500 if (dev != primaryDev) {
1501 (void)dev->setMicMute(state);
Eric Laurent2f035f52014-09-14 12:11:52 -07001502 }
1503 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001504 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent2325bf02020-04-08 19:38:13 -07001505 ALOGW_IF(ret != NO_ERROR, "%s: error %d setting state to HAL", __func__, ret);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001506 return ret;
1507}
1508
1509bool AudioFlinger::getMicMute() const
1510{
Eric Laurenta1884f92011-08-23 08:25:03 -07001511 status_t ret = initCheck();
1512 if (ret != NO_ERROR) {
1513 return false;
1514 }
Andy Hung954b9712023-08-28 18:36:53 -07001515 audio_utils::lock_guard lock(hardwareMutex());
Eric Laurent00abf0d2020-04-22 19:28:22 -07001516 if (mPrimaryHardwareDev == nullptr) {
1517 return false;
1518 }
Andy Hunge3748872023-08-30 19:05:16 -07001519 sp<DeviceHalInterface> primaryDev = mPrimaryHardwareDev.load()->hwDevice();
Eric Laurent2325bf02020-04-08 19:38:13 -07001520 if (primaryDev == nullptr) {
1521 ALOGW("%s: no primary HAL device", __func__);
1522 return false;
Ricardo Garcia3e91b5d2015-02-19 10:54:52 -08001523 }
Eric Laurent2325bf02020-04-08 19:38:13 -07001524 bool state;
1525 mHardwareStatus = AUDIO_HW_GET_MIC_MUTE;
1526 ret = primaryDev->getMicMute(&state);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001527 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent2325bf02020-04-08 19:38:13 -07001528 ALOGE_IF(ret != NO_ERROR, "%s: error %d getting state from HAL", __func__, ret);
1529 return (ret == NO_ERROR) && state;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001530}
1531
Eric Laurent5ada82e2019-08-29 17:53:54 -07001532void AudioFlinger::setRecordSilenced(audio_port_handle_t portId, bool silenced)
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001533{
Eric Laurent5ada82e2019-08-29 17:53:54 -07001534 ALOGV("AudioFlinger::setRecordSilenced(portId:%d, silenced:%d)", portId, silenced);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001535
Andy Hung954b9712023-08-28 18:36:53 -07001536 audio_utils::lock_guard lock(mutex());
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001537 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Eric Laurent5ada82e2019-08-29 17:53:54 -07001538 mRecordThreads[i]->setRecordSilenced(portId, silenced);
Eric Laurent331679c2018-04-16 17:03:16 -07001539 }
1540 for (size_t i = 0; i < mMmapThreads.size(); i++) {
Eric Laurent5ada82e2019-08-29 17:53:54 -07001541 mMmapThreads[i]->setRecordSilenced(portId, silenced);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001542 }
1543}
1544
Mathias Agopian65ab4712010-07-14 17:59:35 -07001545status_t AudioFlinger::setMasterMute(bool muted)
1546{
John Grossmand8f178d2012-07-20 14:51:35 -07001547 status_t ret = initCheck();
1548 if (ret != NO_ERROR) {
1549 return ret;
1550 }
1551
Mathias Agopian65ab4712010-07-14 17:59:35 -07001552 // check calling permissions
1553 if (!settingsAllowed()) {
1554 return PERMISSION_DENIED;
1555 }
1556
Andy Hung954b9712023-08-28 18:36:53 -07001557 audio_utils::lock_guard _l(mutex());
John Grossmanee578c02012-07-23 17:05:46 -07001558 mMasterMute = muted;
John Grossmand8f178d2012-07-20 14:51:35 -07001559
John Grossmanee578c02012-07-23 17:05:46 -07001560 // Set master mute in the HALs which support it.
Eric Laurent00abf0d2020-04-22 19:28:22 -07001561 {
Andy Hung954b9712023-08-28 18:36:53 -07001562 audio_utils::lock_guard lock(hardwareMutex());
Eric Laurent00abf0d2020-04-22 19:28:22 -07001563 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
1564 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
John Grossmand8f178d2012-07-20 14:51:35 -07001565
Eric Laurent00abf0d2020-04-22 19:28:22 -07001566 mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE;
1567 if (dev->canSetMasterMute()) {
1568 dev->hwDevice()->setMasterMute(muted);
1569 }
1570 mHardwareStatus = AUDIO_HW_IDLE;
John Grossmand8f178d2012-07-20 14:51:35 -07001571 }
John Grossmand8f178d2012-07-20 14:51:35 -07001572 }
1573
John Grossmanee578c02012-07-23 17:05:46 -07001574 // Now set the master mute in each playback thread. Playback threads
Glenn Kastena2f59b32020-08-03 16:37:24 -07001575 // assigned to HALs which do not have master mute support will apply master mute
1576 // during the mix operation. Threads with HALs which do support master mute
1577 // will simply ignore the setting.
Andy Hung84074c62023-07-06 19:21:50 -07001578 std::vector<sp<VolumeInterface>> volumeInterfaces = getAllVolumeInterfaces_l();
Eric Laurent6acd1d42017-01-04 14:23:29 -08001579 for (size_t i = 0; i < volumeInterfaces.size(); i++) {
1580 volumeInterfaces[i]->setMasterMute(muted);
Eric Laurentf6870ae2015-05-08 10:50:03 -07001581 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001582
1583 return NO_ERROR;
1584}
1585
1586float AudioFlinger::masterVolume() const
1587{
Andy Hung954b9712023-08-28 18:36:53 -07001588 audio_utils::lock_guard _l(mutex());
Glenn Kasten98067102011-12-13 11:47:54 -08001589 return masterVolume_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001590}
1591
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001592status_t AudioFlinger::getMasterBalance(float *balance) const
1593{
Andy Hung954b9712023-08-28 18:36:53 -07001594 audio_utils::lock_guard _l(mutex());
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001595 *balance = getMasterBalance_l();
1596 return NO_ERROR; // if called through binder, may return a transactional error
1597}
1598
Mathias Agopian65ab4712010-07-14 17:59:35 -07001599bool AudioFlinger::masterMute() const
1600{
Andy Hung954b9712023-08-28 18:36:53 -07001601 audio_utils::lock_guard _l(mutex());
Glenn Kasten98067102011-12-13 11:47:54 -08001602 return masterMute_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001603}
1604
John Grossman4ff14ba2012-02-08 16:37:41 -08001605float AudioFlinger::masterVolume_l() const
1606{
John Grossman4ff14ba2012-02-08 16:37:41 -08001607 return mMasterVolume;
1608}
1609
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001610float AudioFlinger::getMasterBalance_l() const
1611{
1612 return mMasterBalance;
1613}
1614
John Grossmand8f178d2012-07-20 14:51:35 -07001615bool AudioFlinger::masterMute_l() const
1616{
John Grossmanee578c02012-07-23 17:05:46 -07001617 return mMasterMute;
John Grossmand8f178d2012-07-20 14:51:35 -07001618}
1619
Andy Hungc2cf7ec2023-08-30 18:19:00 -07001620/* static */
1621status_t AudioFlinger::checkStreamType(audio_stream_type_t stream)
Eric Laurent223fd5c2014-11-11 13:43:36 -08001622{
1623 if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08001624 ALOGW("checkStreamType() invalid stream %d", stream);
Eric Laurent223fd5c2014-11-11 13:43:36 -08001625 return BAD_VALUE;
1626 }
Andy Hung4ef19fa2018-05-15 19:35:29 -07001627 const uid_t callerUid = IPCThreadState::self()->getCallingUid();
1628 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT && !isAudioServerUid(callerUid)) {
1629 ALOGW("checkStreamType() uid %d cannot use internal stream type %d", callerUid, stream);
Eric Laurent223fd5c2014-11-11 13:43:36 -08001630 return PERMISSION_DENIED;
1631 }
1632
1633 return NO_ERROR;
1634}
1635
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001636status_t AudioFlinger::setStreamVolume(audio_stream_type_t stream, float value,
1637 audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001638{
1639 // check calling permissions
1640 if (!settingsAllowed()) {
1641 return PERMISSION_DENIED;
1642 }
1643
Eric Laurent223fd5c2014-11-11 13:43:36 -08001644 status_t status = checkStreamType(stream);
1645 if (status != NO_ERROR) {
1646 return status;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001647 }
Eric Laurent98e38192018-02-15 18:31:53 -08001648 if (output == AUDIO_IO_HANDLE_NONE) {
1649 return BAD_VALUE;
1650 }
François Gaffie9e1533c2019-04-11 16:07:36 +02001651 LOG_ALWAYS_FATAL_IF(stream == AUDIO_STREAM_PATCH && value != 1.0f,
1652 "AUDIO_STREAM_PATCH must have full scale volume");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001653
Andy Hung954b9712023-08-28 18:36:53 -07001654 audio_utils::lock_guard lock(mutex());
Andy Hung84074c62023-07-06 19:21:50 -07001655 sp<VolumeInterface> volumeInterface = getVolumeInterface_l(output);
Eric Laurent98e38192018-02-15 18:31:53 -08001656 if (volumeInterface == NULL) {
1657 return BAD_VALUE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001658 }
Eric Laurent98e38192018-02-15 18:31:53 -08001659 volumeInterface->setStreamVolume(stream, value);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001660
1661 return NO_ERROR;
1662}
1663
Andy Hung6b137d12024-08-27 22:35:17 +00001664status_t AudioFlinger::setPortsVolume(
1665 const std::vector<audio_port_handle_t>& ports, float volume, audio_io_handle_t output)
1666{
1667 for (const auto& port : ports) {
1668 if (port == AUDIO_PORT_HANDLE_NONE) {
1669 return BAD_VALUE;
1670 }
1671 }
1672 if (isnan(volume) || volume > 1.0f || volume < 0.0f) {
1673 return BAD_VALUE;
1674 }
1675 if (output == AUDIO_IO_HANDLE_NONE) {
1676 return BAD_VALUE;
1677 }
1678 audio_utils::lock_guard lock(mutex());
1679 IAfPlaybackThread *thread = checkPlaybackThread_l(output);
1680 if (thread != nullptr) {
1681 return thread->setPortsVolume(ports, volume);
1682 }
1683 const sp<IAfMmapThread> mmapThread = checkMmapThread_l(output);
1684 if (mmapThread != nullptr && mmapThread->isOutput()) {
1685 IAfMmapPlaybackThread *mmapPlaybackThread = mmapThread->asIAfMmapPlaybackThread().get();
1686 return mmapPlaybackThread->setPortsVolume(ports, volume);
1687 }
1688 return BAD_VALUE;
1689}
1690
Eric Laurent076e7c72022-05-03 18:12:28 +02001691status_t AudioFlinger::setRequestedLatencyMode(
Eric Laurent68a40a82022-05-03 18:15:04 +02001692 audio_io_handle_t output, audio_latency_mode_t mode) {
Eric Laurent076e7c72022-05-03 18:12:28 +02001693 if (output == AUDIO_IO_HANDLE_NONE) {
1694 return BAD_VALUE;
1695 }
Andy Hung954b9712023-08-28 18:36:53 -07001696 audio_utils::lock_guard lock(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07001697 IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
Eric Laurent68a40a82022-05-03 18:15:04 +02001698 if (thread == nullptr) {
1699 return BAD_VALUE;
1700 }
1701 return thread->setRequestedLatencyMode(mode);
Eric Laurent076e7c72022-05-03 18:12:28 +02001702}
1703
1704status_t AudioFlinger::getSupportedLatencyModes(audio_io_handle_t output,
Andy Hungcdd80ef2023-07-17 11:37:26 -07001705 std::vector<audio_latency_mode_t>* modes) const {
Eric Laurent076e7c72022-05-03 18:12:28 +02001706 if (output == AUDIO_IO_HANDLE_NONE) {
1707 return BAD_VALUE;
1708 }
Andy Hung954b9712023-08-28 18:36:53 -07001709 audio_utils::lock_guard lock(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07001710 IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
Eric Laurent68a40a82022-05-03 18:15:04 +02001711 if (thread == nullptr) {
1712 return BAD_VALUE;
1713 }
1714 return thread->getSupportedLatencyModes(modes);
Eric Laurent076e7c72022-05-03 18:12:28 +02001715}
1716
Eric Laurent50d72582022-12-20 20:20:23 +01001717status_t AudioFlinger::setBluetoothVariableLatencyEnabled(bool enabled) {
Andy Hung954b9712023-08-28 18:36:53 -07001718 audio_utils::lock_guard _l(mutex());
Eric Laurent52057642022-12-16 11:45:07 +01001719 status_t status = INVALID_OPERATION;
1720 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1721 // Success if at least one PlaybackThread supports Bluetooth latency modes
Eric Laurent50d72582022-12-20 20:20:23 +01001722 if (mPlaybackThreads.valueAt(i)->setBluetoothVariableLatencyEnabled(enabled) == NO_ERROR) {
Eric Laurent52057642022-12-16 11:45:07 +01001723 status = NO_ERROR;
1724 }
1725 }
1726 if (status == NO_ERROR) {
1727 mBluetoothLatencyModesEnabled.store(enabled);
1728 }
1729 return status;
1730}
1731
Andy Hungcdd80ef2023-07-17 11:37:26 -07001732status_t AudioFlinger::isBluetoothVariableLatencyEnabled(bool* enabled) const {
Eric Laurent50d72582022-12-20 20:20:23 +01001733 if (enabled == nullptr) {
1734 return BAD_VALUE;
1735 }
1736 *enabled = mBluetoothLatencyModesEnabled.load();
1737 return NO_ERROR;
1738}
1739
Andy Hungcdd80ef2023-07-17 11:37:26 -07001740status_t AudioFlinger::supportsBluetoothVariableLatency(bool* support) const {
Eric Laurent52057642022-12-16 11:45:07 +01001741 if (support == nullptr) {
1742 return BAD_VALUE;
1743 }
Andy Hungc2cf7ec2023-08-30 18:19:00 -07001744 audio_utils::lock_guard _l(hardwareMutex());
Eric Laurent52057642022-12-16 11:45:07 +01001745 *support = false;
1746 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Eric Laurent50d72582022-12-20 20:20:23 +01001747 if (mAudioHwDevs.valueAt(i)->supportsBluetoothVariableLatency()) {
Eric Laurent52057642022-12-16 11:45:07 +01001748 *support = true;
1749 break;
1750 }
1751 }
1752 return NO_ERROR;
1753}
1754
Vlad Popae3fd1c22022-11-07 21:03:18 +01001755status_t AudioFlinger::getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback,
Andy Hungcdd80ef2023-07-17 11:37:26 -07001756 sp<media::ISoundDose>* soundDose) const {
Vlad Popae3fd1c22022-11-07 21:03:18 +01001757 if (soundDose == nullptr) {
1758 return BAD_VALUE;
1759 }
1760
1761 *soundDose = mMelReporter->getSoundDoseInterface(callback);
Vlad Popa63f047e2022-11-05 14:09:19 +01001762 return NO_ERROR;
1763}
1764
Glenn Kastenfff6d712012-01-12 16:38:12 -08001765status_t AudioFlinger::setStreamMute(audio_stream_type_t stream, bool muted)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001766{
1767 // check calling permissions
1768 if (!settingsAllowed()) {
1769 return PERMISSION_DENIED;
1770 }
1771
Eric Laurent223fd5c2014-11-11 13:43:36 -08001772 status_t status = checkStreamType(stream);
1773 if (status != NO_ERROR) {
1774 return status;
1775 }
1776 ALOG_ASSERT(stream != AUDIO_STREAM_PATCH, "attempt to mute AUDIO_STREAM_PATCH");
1777
1778 if (uint32_t(stream) == AUDIO_STREAM_ENFORCED_AUDIBLE) {
Steve Block29357bc2012-01-06 19:20:56 +00001779 ALOGE("setStreamMute() invalid stream %d", stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001780 return BAD_VALUE;
1781 }
1782
Andy Hung954b9712023-08-28 18:36:53 -07001783 audio_utils::lock_guard lock(mutex());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001784 mStreamTypes[stream].mute = muted;
Andy Hung84074c62023-07-06 19:21:50 -07001785 std::vector<sp<VolumeInterface>> volumeInterfaces = getAllVolumeInterfaces_l();
Eric Laurent6acd1d42017-01-04 14:23:29 -08001786 for (size_t i = 0; i < volumeInterfaces.size(); i++) {
1787 volumeInterfaces[i]->setStreamMute(stream, muted);
1788 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001789
1790 return NO_ERROR;
1791}
1792
Andy Hungd9ef4b12020-11-11 15:13:18 -08001793void AudioFlinger::broadcastParametersToRecordThreads_l(const String8& keyValuePairs)
Eric Laurent054d9d32015-04-24 08:48:48 -07001794{
1795 for (size_t i = 0; i < mRecordThreads.size(); i++) {
1796 mRecordThreads.valueAt(i)->setParameters(keyValuePairs);
1797 }
1798}
1799
jiabinc52b1ff2019-10-31 17:20:42 -07001800void AudioFlinger::updateOutDevicesForRecordThreads_l(const DeviceDescriptorBaseVector& devices)
1801{
1802 for (size_t i = 0; i < mRecordThreads.size(); i++) {
1803 mRecordThreads.valueAt(i)->updateOutDevices(devices);
1804 }
1805}
1806
Andy Hung954b9712023-08-28 18:36:53 -07001807// forwardAudioHwSyncToDownstreamPatches_l() must be called with AudioFlinger::mutex() held
Mikhail Naganovb261ef52018-07-16 13:34:38 -07001808void AudioFlinger::forwardParametersToDownstreamPatches_l(
1809 audio_io_handle_t upStream, const String8& keyValuePairs,
Andy Hung87c693c2023-07-06 20:56:16 -07001810 const std::function<bool(const sp<IAfPlaybackThread>&)>& useThread)
Mikhail Naganovb261ef52018-07-16 13:34:38 -07001811{
Andy Hungb6692eb2023-07-13 16:52:46 -07001812 std::vector<SoftwarePatch> swPatches;
1813 if (mPatchPanel->getDownstreamSoftwarePatches(upStream, &swPatches) != OK) return;
Mikhail Naganovb261ef52018-07-16 13:34:38 -07001814 ALOGV_IF(!swPatches.empty(), "%s found %zu downstream patches for stream ID %d",
1815 __func__, swPatches.size(), upStream);
1816 for (const auto& swPatch : swPatches) {
Andy Hung87c693c2023-07-06 20:56:16 -07001817 const sp<IAfPlaybackThread> downStream =
1818 checkPlaybackThread_l(swPatch.getPlaybackThreadHandle());
Mikhail Naganovb261ef52018-07-16 13:34:38 -07001819 if (downStream != NULL && (useThread == nullptr || useThread(downStream))) {
1820 downStream->setParameters(keyValuePairs);
1821 }
1822 }
1823}
1824
Eric Laurent74c38dc2020-12-23 18:19:44 +01001825// Update downstream patches for all playback threads attached to an MSD module
1826void AudioFlinger::updateDownStreamPatches_l(const struct audio_patch *patch,
Andy Hung920f6572022-10-06 12:09:49 -07001827 const std::set<audio_io_handle_t>& streams)
Eric Laurent74c38dc2020-12-23 18:19:44 +01001828{
1829 for (const audio_io_handle_t stream : streams) {
Andy Hung87c693c2023-07-06 20:56:16 -07001830 IAfPlaybackThread* const playbackThread = checkPlaybackThread_l(stream);
Eric Laurent74c38dc2020-12-23 18:19:44 +01001831 if (playbackThread == nullptr || !playbackThread->isMsdDevice()) {
1832 continue;
1833 }
1834 playbackThread->setDownStreamPatch(patch);
1835 playbackThread->sendIoConfigEvent(AUDIO_OUTPUT_CONFIG_CHANGED);
1836 }
1837}
1838
Eric Laurentf1047e82018-04-16 19:18:20 -07001839// Filter reserved keys from setParameters() before forwarding to audio HAL or acting upon.
1840// Some keys are used for audio routing and audio path configuration and should be reserved for use
1841// by audio policy and audio flinger for functional, privacy and security reasons.
1842void AudioFlinger::filterReservedParameters(String8& keyValuePairs, uid_t callingUid)
1843{
1844 static const String8 kReservedParameters[] = {
1845 String8(AudioParameter::keyRouting),
1846 String8(AudioParameter::keySamplingRate),
1847 String8(AudioParameter::keyFormat),
1848 String8(AudioParameter::keyChannels),
1849 String8(AudioParameter::keyFrameCount),
1850 String8(AudioParameter::keyInputSource),
1851 String8(AudioParameter::keyMonoOutput),
Mikhail Naganovf23fcf62019-07-08 15:28:43 -07001852 String8(AudioParameter::keyDeviceConnect),
1853 String8(AudioParameter::keyDeviceDisconnect),
Eric Laurentf1047e82018-04-16 19:18:20 -07001854 String8(AudioParameter::keyStreamSupportedFormats),
1855 String8(AudioParameter::keyStreamSupportedChannels),
1856 String8(AudioParameter::keyStreamSupportedSamplingRates),
Andy Hungdda7aed2023-03-27 15:53:06 -07001857 String8(AudioParameter::keyClosing),
1858 String8(AudioParameter::keyExiting),
Eric Laurentf1047e82018-04-16 19:18:20 -07001859 };
1860
Andy Hung4ef19fa2018-05-15 19:35:29 -07001861 if (isAudioServerUid(callingUid)) {
1862 return; // no need to filter if audioserver.
Eric Laurentf1047e82018-04-16 19:18:20 -07001863 }
1864
1865 AudioParameter param = AudioParameter(keyValuePairs);
1866 String8 value;
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001867 AudioParameter rejectedParam;
Eric Laurentf1047e82018-04-16 19:18:20 -07001868 for (auto& key : kReservedParameters) {
1869 if (param.get(key, value) == NO_ERROR) {
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001870 rejectedParam.add(key, value);
Eric Laurentf1047e82018-04-16 19:18:20 -07001871 param.remove(key);
1872 }
1873 }
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001874 logFilteredParameters(param.size() + rejectedParam.size(), keyValuePairs,
1875 rejectedParam.size(), rejectedParam.toString(), callingUid);
Eric Laurentf1047e82018-04-16 19:18:20 -07001876 keyValuePairs = param.toString();
1877}
1878
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001879void AudioFlinger::logFilteredParameters(size_t originalKVPSize, const String8& originalKVPs,
1880 size_t rejectedKVPSize, const String8& rejectedKVPs,
1881 uid_t callingUid) {
1882 auto prefix = String8::format("UID %5d", callingUid);
1883 auto suffix = String8::format("%zu KVP received: %s", originalKVPSize, originalKVPs.c_str());
1884 if (rejectedKVPSize != 0) {
1885 auto error = String8::format("%zu KVP rejected: %s", rejectedKVPSize, rejectedKVPs.c_str());
1886 ALOGW("%s: %s, %s, %s", __func__, prefix.c_str(), error.c_str(), suffix.c_str());
1887 mRejectedSetParameterLog.log("%s, %s, %s", prefix.c_str(), error.c_str(), suffix.c_str());
1888 } else {
1889 auto& logger = (isServiceUid(callingUid) ? mSystemSetParameterLog : mAppSetParameterLog);
1890 logger.log("%s, %s", prefix.c_str(), suffix.c_str());
1891 }
1892}
1893
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001894status_t AudioFlinger::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001895{
Eric Laurentf1047e82018-04-16 19:18:20 -07001896 ALOGV("setParameters(): io %d, keyvalue %s, calling pid %d calling uid %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001897 ioHandle, keyValuePairs.c_str(),
Eric Laurentf1047e82018-04-16 19:18:20 -07001898 IPCThreadState::self()->getCallingPid(), IPCThreadState::self()->getCallingUid());
Eric Laurent81784c32012-11-19 14:55:58 -08001899
Mathias Agopian65ab4712010-07-14 17:59:35 -07001900 // check calling permissions
1901 if (!settingsAllowed()) {
1902 return PERMISSION_DENIED;
1903 }
1904
Eric Laurentf1047e82018-04-16 19:18:20 -07001905 String8 filteredKeyValuePairs = keyValuePairs;
1906 filterReservedParameters(filteredKeyValuePairs, IPCThreadState::self()->getCallingUid());
1907
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001908 ALOGV("%s: filtered keyvalue %s", __func__, filteredKeyValuePairs.c_str());
Eric Laurentf1047e82018-04-16 19:18:20 -07001909
Glenn Kasten142f5192014-03-25 17:44:59 -07001910 // AUDIO_IO_HANDLE_NONE means the parameters are global to the audio hardware interface
1911 if (ioHandle == AUDIO_IO_HANDLE_NONE) {
Andy Hung954b9712023-08-28 18:36:53 -07001912 audio_utils::lock_guard _l(mutex());
Eric Laurentd21bcd22016-09-08 18:25:54 -07001913 // result will remain NO_INIT if no audio device is present
1914 status_t final_result = NO_INIT;
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001915 {
Andy Hung954b9712023-08-28 18:36:53 -07001916 audio_utils::lock_guard lock(hardwareMutex());
Eric Laurenta4c5a552012-03-29 10:12:40 -07001917 mHardwareStatus = AUDIO_HW_SET_PARAMETER;
1918 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001919 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
Eric Laurentf1047e82018-04-16 19:18:20 -07001920 status_t result = dev->setParameters(filteredKeyValuePairs);
Eric Laurentd21bcd22016-09-08 18:25:54 -07001921 // return success if at least one audio device accepts the parameters as not all
1922 // HALs are requested to support all parameters. If no audio device supports the
1923 // requested parameters, the last error is reported.
1924 if (final_result != NO_ERROR) {
1925 final_result = result;
1926 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07001927 }
1928 mHardwareStatus = AUDIO_HW_IDLE;
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001929 }
Eric Laurent59bd0da2011-08-01 09:52:20 -07001930 // disable AEC and NS if the device is a BT SCO headset supporting those pre processings
Eric Laurentf1047e82018-04-16 19:18:20 -07001931 AudioParameter param = AudioParameter(filteredKeyValuePairs);
Eric Laurent59bd0da2011-08-01 09:52:20 -07001932 String8 value;
Mikhail Naganov00260b52016-10-13 12:54:24 -07001933 if (param.get(String8(AudioParameter::keyBtNrec), value) == NO_ERROR) {
1934 bool btNrecIsOff = (value == AudioParameter::valueOff);
Eric Laurentd8365c52017-07-16 15:27:05 -07001935 if (mBtNrecIsOff.exchange(btNrecIsOff) != btNrecIsOff) {
Eric Laurent59bd0da2011-08-01 09:52:20 -07001936 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Eric Laurentd8365c52017-07-16 15:27:05 -07001937 mRecordThreads.valueAt(i)->checkBtNrec();
Eric Laurent59bd0da2011-08-01 09:52:20 -07001938 }
Eric Laurent59bd0da2011-08-01 09:52:20 -07001939 }
1940 }
Glenn Kasten28ed2f92012-06-07 10:17:54 -07001941 String8 screenState;
1942 if (param.get(String8(AudioParameter::keyScreenState), screenState) == NO_ERROR) {
Mikhail Naganov00260b52016-10-13 12:54:24 -07001943 bool isOff = (screenState == AudioParameter::valueOff);
Andy Hung1d2d2aea2023-07-19 16:22:58 -07001944 if (isOff != (mScreenState & 1)) {
1945 mScreenState = ((mScreenState & ~1) + 2) | isOff;
Glenn Kasten28ed2f92012-06-07 10:17:54 -07001946 }
1947 }
Dima Zavin799a70e2011-04-18 16:57:27 -07001948 return final_result;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001949 }
1950
1951 // hold a strong ref on thread in case closeOutput() or closeInput() is called
1952 // and the thread is exited once the lock is released
Andy Hung87c693c2023-07-06 20:56:16 -07001953 sp<IAfThreadBase> thread;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001954 {
Andy Hung954b9712023-08-28 18:36:53 -07001955 audio_utils::lock_guard _l(mutex());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001956 thread = checkPlaybackThread_l(ioHandle);
Glenn Kastend5903ec2012-03-18 10:33:27 -07001957 if (thread == 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001958 thread = checkRecordThread_l(ioHandle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08001959 if (thread == 0) {
1960 thread = checkMmapThread_l(ioHandle);
1961 }
Glenn Kasten7fc9a6f2012-01-10 10:46:34 -08001962 } else if (thread == primaryPlaybackThread_l()) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001963 // indicate output device change to all input threads for pre processing
Eric Laurentf1047e82018-04-16 19:18:20 -07001964 AudioParameter param = AudioParameter(filteredKeyValuePairs);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001965 int value;
Eric Laurent89d94e72012-03-16 20:37:59 -07001966 if ((param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) &&
1967 (value != 0)) {
Andy Hungd9ef4b12020-11-11 15:13:18 -08001968 broadcastParametersToRecordThreads_l(filteredKeyValuePairs);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001969 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001970 }
1971 }
Glenn Kasten7378ca52012-01-20 13:44:40 -08001972 if (thread != 0) {
Mikhail Naganovb261ef52018-07-16 13:34:38 -07001973 status_t result = thread->setParameters(filteredKeyValuePairs);
Andy Hungc2cf7ec2023-08-30 18:19:00 -07001974 audio_utils::lock_guard _l(mutex());
Mikhail Naganovb261ef52018-07-16 13:34:38 -07001975 forwardParametersToDownstreamPatches_l(thread->id(), filteredKeyValuePairs);
1976 return result;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001977 }
1978 return BAD_VALUE;
1979}
1980
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001981String8 AudioFlinger::getParameters(audio_io_handle_t ioHandle, const String8& keys) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001982{
Glenn Kasten827e5f12012-11-02 10:00:06 -07001983 ALOGVV("getParameters() io %d, keys %s, calling pid %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001984 ioHandle, keys.c_str(), IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001985
Andy Hung954b9712023-08-28 18:36:53 -07001986 audio_utils::lock_guard _l(mutex());
Eric Laurenta4c5a552012-03-29 10:12:40 -07001987
Glenn Kasten142f5192014-03-25 17:44:59 -07001988 if (ioHandle == AUDIO_IO_HANDLE_NONE) {
Dima Zavinfce7a472011-04-19 22:30:36 -07001989 String8 out_s8;
1990
Andy Hung954b9712023-08-28 18:36:53 -07001991 audio_utils::lock_guard lock(hardwareMutex());
Dima Zavin799a70e2011-04-18 16:57:27 -07001992 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001993 String8 s;
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001994 mHardwareStatus = AUDIO_HW_GET_PARAMETER;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001995 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
Eric Laurent00abf0d2020-04-22 19:28:22 -07001996 status_t result = dev->getParameters(keys, &s);
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001997 mHardwareStatus = AUDIO_HW_IDLE;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001998 if (result == OK) out_s8 += s;
Dima Zavin799a70e2011-04-18 16:57:27 -07001999 }
Dima Zavinfce7a472011-04-19 22:30:36 -07002000 return out_s8;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002001 }
2002
Andy Hung87c693c2023-07-06 20:56:16 -07002003 IAfThreadBase* thread = checkPlaybackThread_l(ioHandle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002004 if (thread == NULL) {
Andy Hung87c693c2023-07-06 20:56:16 -07002005 thread = checkRecordThread_l(ioHandle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002006 if (thread == NULL) {
Andy Hung87c693c2023-07-06 20:56:16 -07002007 thread = checkMmapThread_l(ioHandle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002008 if (thread == NULL) {
Mikhail Naganovaa165e52017-07-12 10:39:16 -07002009 return String8("");
Eric Laurent6acd1d42017-01-04 14:23:29 -08002010 }
2011 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002012 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08002013 return thread->getParameters(keys);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002014}
2015
Glenn Kastendd8104c2012-07-02 12:42:44 -07002016size_t AudioFlinger::getInputBufferSize(uint32_t sampleRate, audio_format_t format,
2017 audio_channel_mask_t channelMask) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07002018{
Eric Laurenta1884f92011-08-23 08:25:03 -07002019 status_t ret = initCheck();
2020 if (ret != NO_ERROR) {
2021 return 0;
2022 }
Eric Laurentcdf924a2016-02-04 15:57:56 -08002023 if ((sampleRate == 0) ||
Dean Wheatley8d72b4b2023-11-16 06:43:58 +11002024 !audio_is_valid_format(format) ||
Eric Laurentcdf924a2016-02-04 15:57:56 -08002025 !audio_is_input_channel(channelMask)) {
Andy Hung6770c6f2015-04-07 13:43:36 -07002026 return 0;
2027 }
Eric Laurenta1884f92011-08-23 08:25:03 -07002028
Andy Hung954b9712023-08-28 18:36:53 -07002029 audio_utils::lock_guard lock(hardwareMutex());
Eric Laurent00abf0d2020-04-22 19:28:22 -07002030 if (mPrimaryHardwareDev == nullptr) {
2031 return 0;
2032 }
Oleg Lyovin7434b722024-03-05 18:08:01 +03002033 if (mInputBufferSizeOrderedDevs.empty()) {
2034 return 0;
2035 }
Glenn Kasten2b213bc2012-02-02 14:05:20 -08002036 mHardwareStatus = AUDIO_HW_GET_INPUT_BUFFER_SIZE;
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002037
Judy Hsiaoabab5222019-11-09 18:14:58 +08002038 std::vector<audio_channel_mask_t> channelMasks = {channelMask};
Andy Hung920f6572022-10-06 12:09:49 -07002039 if (channelMask != AUDIO_CHANNEL_IN_MONO) {
Judy Hsiaoabab5222019-11-09 18:14:58 +08002040 channelMasks.push_back(AUDIO_CHANNEL_IN_MONO);
Andy Hung920f6572022-10-06 12:09:49 -07002041 }
2042 if (channelMask != AUDIO_CHANNEL_IN_STEREO) {
Judy Hsiaoabab5222019-11-09 18:14:58 +08002043 channelMasks.push_back(AUDIO_CHANNEL_IN_STEREO);
Andy Hung920f6572022-10-06 12:09:49 -07002044 }
Judy Hsiaoabab5222019-11-09 18:14:58 +08002045
2046 std::vector<audio_format_t> formats = {format};
Andy Hung920f6572022-10-06 12:09:49 -07002047 if (format != AUDIO_FORMAT_PCM_16_BIT) {
Dean Wheatley8d72b4b2023-11-16 06:43:58 +11002048 // For compressed format, buffer size may be queried using PCM. Allow this for compatibility
2049 // in cases the primary hw dev does not support the format.
2050 // TODO: replace with a table of formats and nominal buffer sizes (based on nominal bitrate
2051 // and codec frame size).
Judy Hsiaoabab5222019-11-09 18:14:58 +08002052 formats.push_back(AUDIO_FORMAT_PCM_16_BIT);
Andy Hung920f6572022-10-06 12:09:49 -07002053 }
Judy Hsiaoabab5222019-11-09 18:14:58 +08002054
2055 std::vector<uint32_t> sampleRates = {sampleRate};
2056 static const uint32_t SR_44100 = 44100;
2057 static const uint32_t SR_48000 = 48000;
Andy Hung920f6572022-10-06 12:09:49 -07002058 if (sampleRate != SR_48000) {
Judy Hsiaoabab5222019-11-09 18:14:58 +08002059 sampleRates.push_back(SR_48000);
Andy Hung920f6572022-10-06 12:09:49 -07002060 }
2061 if (sampleRate != SR_44100) {
Judy Hsiaoabab5222019-11-09 18:14:58 +08002062 sampleRates.push_back(SR_44100);
Andy Hung920f6572022-10-06 12:09:49 -07002063 }
Judy Hsiaoabab5222019-11-09 18:14:58 +08002064
Glenn Kasten2b213bc2012-02-02 14:05:20 -08002065 mHardwareStatus = AUDIO_HW_IDLE;
Judy Hsiaoabab5222019-11-09 18:14:58 +08002066
Oleg Lyovin7434b722024-03-05 18:08:01 +03002067 auto getInputBufferSize = [](const sp<DeviceHalInterface>& dev, audio_config_t config,
2068 size_t* bytes) -> status_t {
2069 if (!dev) {
2070 return BAD_VALUE;
2071 }
2072 status_t result = dev->getInputBufferSize(&config, bytes);
2073 if (result == BAD_VALUE) {
2074 // Retry with the config suggested by the HAL.
2075 result = dev->getInputBufferSize(&config, bytes);
2076 }
2077 if (result != OK || *bytes == 0) {
2078 return BAD_VALUE;
2079 }
2080 return result;
2081 };
2082
Robin Lee9899ff72019-12-24 22:02:08 +01002083 // Change parameters of the configuration each iteration until we find a
Mikhail Naganovd5b643f2024-02-15 11:51:26 -08002084 // configuration that the device will support, or HAL suggests what it supports.
Robin Lee9899ff72019-12-24 22:02:08 +01002085 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
Judy Hsiaoabab5222019-11-09 18:14:58 +08002086 for (auto testChannelMask : channelMasks) {
2087 config.channel_mask = testChannelMask;
2088 for (auto testFormat : formats) {
2089 config.format = testFormat;
2090 for (auto testSampleRate : sampleRates) {
2091 config.sample_rate = testSampleRate;
Robin Lee9899ff72019-12-24 22:02:08 +01002092
Judy Hsiaoabab5222019-11-09 18:14:58 +08002093 size_t bytes = 0;
Oleg Lyovin7434b722024-03-05 18:08:01 +03002094 ret = BAD_VALUE;
2095 for (const AudioHwDevice* dev : mInputBufferSizeOrderedDevs) {
2096 ret = getInputBufferSize(dev->hwDevice(), config, &bytes);
2097 if (ret == OK) {
2098 break;
2099 }
Mikhail Naganovd5b643f2024-02-15 11:51:26 -08002100 }
Oleg Lyovin7434b722024-03-05 18:08:01 +03002101 if (ret == BAD_VALUE) continue;
2102
Judy Hsiaoabab5222019-11-09 18:14:58 +08002103 if (config.sample_rate != sampleRate || config.channel_mask != channelMask ||
2104 config.format != format) {
2105 uint32_t dstChannelCount = audio_channel_count_from_in_mask(channelMask);
2106 uint32_t srcChannelCount =
2107 audio_channel_count_from_in_mask(config.channel_mask);
2108 size_t srcFrames =
2109 bytes / audio_bytes_per_frame(srcChannelCount, config.format);
2110 size_t dstFrames = destinationFramesPossible(
2111 srcFrames, config.sample_rate, sampleRate);
2112 bytes = dstFrames * audio_bytes_per_frame(dstChannelCount, format);
2113 }
2114 return bytes;
2115 }
2116 }
Andy Hung6770c6f2015-04-07 13:43:36 -07002117 }
Judy Hsiaoabab5222019-11-09 18:14:58 +08002118
2119 ALOGW("getInputBufferSize failed with minimum buffer size sampleRate %u, "
2120 "format %#x, channelMask %#x",sampleRate, format, channelMask);
2121 return 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002122}
2123
Glenn Kasten5f972c02014-01-13 09:59:31 -08002124uint32_t AudioFlinger::getInputFramesLost(audio_io_handle_t ioHandle) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07002125{
Andy Hung954b9712023-08-28 18:36:53 -07002126 audio_utils::lock_guard _l(mutex());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002127
Andy Hung87c693c2023-07-06 20:56:16 -07002128 IAfRecordThread* const recordThread = checkRecordThread_l(ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002129 if (recordThread != NULL) {
2130 return recordThread->getInputFramesLost();
2131 }
2132 return 0;
2133}
2134
2135status_t AudioFlinger::setVoiceVolume(float value)
2136{
Eric Laurenta1884f92011-08-23 08:25:03 -07002137 status_t ret = initCheck();
2138 if (ret != NO_ERROR) {
2139 return ret;
2140 }
2141
Mathias Agopian65ab4712010-07-14 17:59:35 -07002142 // check calling permissions
2143 if (!settingsAllowed()) {
2144 return PERMISSION_DENIED;
2145 }
2146
Andy Hung954b9712023-08-28 18:36:53 -07002147 audio_utils::lock_guard lock(hardwareMutex());
Eric Laurent00abf0d2020-04-22 19:28:22 -07002148 if (mPrimaryHardwareDev == nullptr) {
2149 return INVALID_OPERATION;
2150 }
Andy Hunge3748872023-08-30 19:05:16 -07002151 sp<DeviceHalInterface> dev = mPrimaryHardwareDev.load()->hwDevice();
Glenn Kasten8abf44d2012-02-02 14:16:03 -08002152 mHardwareStatus = AUDIO_HW_SET_VOICE_VOLUME;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002153 ret = dev->setVoiceVolume(value);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002154 mHardwareStatus = AUDIO_HW_IDLE;
2155
Joey Poomarin52989982020-03-05 17:40:49 +08002156 mediametrics::LogItem(mMetricsId)
2157 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETVOICEVOLUME)
2158 .set(AMEDIAMETRICS_PROP_VOICEVOLUME, (double)value)
2159 .record();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002160 return ret;
2161}
2162
Kévin PETIT377b2ec2014-02-03 12:35:36 +00002163status_t AudioFlinger::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002164 audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07002165{
Andy Hung954b9712023-08-28 18:36:53 -07002166 audio_utils::lock_guard _l(mutex());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002167
Andy Hung87c693c2023-07-06 20:56:16 -07002168 IAfPlaybackThread* const playbackThread = checkPlaybackThread_l(output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002169 if (playbackThread != NULL) {
2170 return playbackThread->getRenderPosition(halFrames, dspFrames);
2171 }
2172
2173 return BAD_VALUE;
2174}
2175
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002176void AudioFlinger::registerClient(const sp<media::IAudioFlingerClient>& client)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002177{
Eric Laurent44622db2014-08-01 19:00:33 -07002178 if (client == 0) {
2179 return;
2180 }
Andy Hung05b0ffe2024-08-30 17:18:37 -07002181 const pid_t pid = IPCThreadState::self()->getCallingPid();
Andy Hung5bdc5352019-12-23 14:36:31 -08002182 const uid_t uid = IPCThreadState::self()->getCallingUid();
Andy Hung05b0ffe2024-08-30 17:18:37 -07002183
2184 audio_utils::lock_guard _l(mutex());
Eric Laurent021cf962014-05-13 10:18:14 -07002185 {
Andy Hung954b9712023-08-28 18:36:53 -07002186 audio_utils::lock_guard _cl(clientMutex());
Andy Hung05b0ffe2024-08-30 17:18:37 -07002187 if (mNotificationClients.count(pid) == 0) {
2188 auto notificationClient = sp<NotificationClient>::make(
2189 this, client, pid, uid);
Andy Hungbcd19ea2024-08-22 16:32:21 +00002190 ALOGV("registerClient() client %p, pid %d, uid %u",
2191 notificationClient.get(), pid, uid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002192
Andy Hung05b0ffe2024-08-30 17:18:37 -07002193 mNotificationClients[pid] = notificationClient;
Marco Nelissen06b46062014-11-14 07:58:25 -08002194 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurent021cf962014-05-13 10:18:14 -07002195 binder->linkToDeath(notificationClient);
Eric Laurent021cf962014-05-13 10:18:14 -07002196 }
2197 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002198
Andy Hung954b9712023-08-28 18:36:53 -07002199 // clientMutex() should not be held here because ThreadBase::sendIoConfigEvent()
2200 // will lock the ThreadBase::mutex() and the locking order is
2201 // ThreadBase::mutex() then AudioFlinger::clientMutex().
2202 // The config change is always sent from playback or record threads to avoid deadlock
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002203 // with AudioSystem::gLock
2204 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07002205 mPlaybackThreads.valueAt(i)->sendIoConfigEvent(AUDIO_OUTPUT_REGISTERED, pid);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002206 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002207
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002208 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07002209 mRecordThreads.valueAt(i)->sendIoConfigEvent(AUDIO_INPUT_REGISTERED, pid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002210 }
2211}
2212
2213void AudioFlinger::removeNotificationClient(pid_t pid)
2214{
Andy Hung6ac17eb2023-06-20 18:56:17 -07002215 std::vector<sp<IAfEffectModule>> removedEffects;
Eric Laurent021cf962014-05-13 10:18:14 -07002216 {
Andy Hung954b9712023-08-28 18:36:53 -07002217 audio_utils::lock_guard _l(mutex());
Eric Laurent6c796322019-04-09 14:13:17 -07002218 {
Andy Hung954b9712023-08-28 18:36:53 -07002219 audio_utils::lock_guard _cl(clientMutex());
Andy Hung05b0ffe2024-08-30 17:18:37 -07002220 mNotificationClients.erase(pid);
Eric Laurent6c796322019-04-09 14:13:17 -07002221 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002222
Eric Laurent6c796322019-04-09 14:13:17 -07002223 ALOGV("%d died, releasing its sessions", pid);
2224 size_t num = mAudioSessionRefs.size();
2225 bool removed = false;
2226 for (size_t i = 0; i < num; ) {
2227 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
2228 ALOGV(" pid %d @ %zu", ref->mPid, i);
2229 if (ref->mPid == pid) {
2230 ALOGV(" removing entry for pid %d session %d", pid, ref->mSessionid);
2231 mAudioSessionRefs.removeAt(i);
2232 delete ref;
2233 removed = true;
2234 num--;
2235 } else {
2236 i++;
2237 }
2238 }
2239 if (removed) {
2240 removedEffects = purgeStaleEffects_l();
François Gaffie1b4753e2023-02-06 10:36:33 +01002241 std::vector< sp<IAfEffectModule> > removedOrphanEffects = purgeOrphanEffectChains_l();
2242 removedEffects.insert(removedEffects.end(), removedOrphanEffects.begin(),
2243 removedOrphanEffects.end());
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002244 }
2245 }
Eric Laurent6c796322019-04-09 14:13:17 -07002246 for (auto& effect : removedEffects) {
2247 effect->updatePolicyState();
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002248 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002249}
2250
Andy Hungab65b182023-09-06 19:41:47 -07002251// Hold either AudioFlinger::mutex or ThreadBase::mutex
2252void AudioFlinger::ioConfigChanged_l(audio_io_config_event_t event,
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002253 const sp<AudioIoDescriptor>& ioDesc,
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002254 pid_t pid) {
Andy Hungb75b6242021-07-29 16:46:14 +00002255 media::AudioIoConfigEvent eventAidl = VALUE_OR_FATAL(
2256 legacy2aidl_audio_io_config_event_t_AudioIoConfigEvent(event));
Mikhail Naganovde3fa182021-07-30 15:06:42 -07002257 media::AudioIoDescriptor descAidl = VALUE_OR_FATAL(
2258 legacy2aidl_AudioIoDescriptor_AudioIoDescriptor(ioDesc));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002259
Andy Hung954b9712023-08-28 18:36:53 -07002260 audio_utils::lock_guard _l(clientMutex());
Andy Hung05b0ffe2024-08-30 17:18:37 -07002261 if (pid != 0) {
2262 if (auto it = mNotificationClients.find(pid); it != mNotificationClients.end()) {
2263 it->second->audioFlingerClient()->ioConfigChanged(eventAidl, descAidl);
2264 }
2265 } else {
2266 for (const auto& [ client_pid, client] : mNotificationClients) {
2267 client->audioFlingerClient()->ioConfigChanged(eventAidl, descAidl);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002268 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002269 }
2270}
2271
Eric Laurent076e7c72022-05-03 18:12:28 +02002272void AudioFlinger::onSupportedLatencyModesChanged(
2273 audio_io_handle_t output, const std::vector<audio_latency_mode_t>& modes) {
2274 int32_t outputAidl = VALUE_OR_FATAL(legacy2aidl_audio_io_handle_t_int32_t(output));
Mikhail Naganovf53e1822022-12-18 02:48:14 +00002275 std::vector<media::audio::common::AudioLatencyMode> modesAidl = VALUE_OR_FATAL(
2276 convertContainer<std::vector<media::audio::common::AudioLatencyMode>>(
2277 modes, legacy2aidl_audio_latency_mode_t_AudioLatencyMode));
Eric Laurent076e7c72022-05-03 18:12:28 +02002278
Andy Hung954b9712023-08-28 18:36:53 -07002279 audio_utils::lock_guard _l(clientMutex());
Eric Laurent076e7c72022-05-03 18:12:28 +02002280 size_t size = mNotificationClients.size();
Andy Hung05b0ffe2024-08-30 17:18:37 -07002281 for (const auto& [_, client] : mNotificationClients) {
2282 client->audioFlingerClient()->onSupportedLatencyModesChanged(outputAidl, modesAidl);
Eric Laurent076e7c72022-05-03 18:12:28 +02002283 }
2284}
2285
Mikhail Naganovbf203ce2024-05-23 16:27:59 -07002286void AudioFlinger::onHardError(std::set<audio_port_handle_t>& trackPortIds) {
2287 ALOGI("releasing tracks due to a hard error occurred on an I/O thread");
2288 for (const auto portId : trackPortIds) {
2289 AudioSystem::releaseOutput(portId);
2290 }
2291}
2292
Atneya Nair5997a652024-06-14 17:24:45 -07002293const IPermissionProvider& AudioFlinger::getPermissionProvider() {
2294 // This is inited as part of service construction, prior to binder registration,
2295 // so it should always be non-null.
2296 return mAudioPolicyServiceLocal.load()->getPermissionProvider();
2297}
2298
Andy Hung954b9712023-08-28 18:36:53 -07002299// removeClient_l() must be called with AudioFlinger::clientMutex() held
Mathias Agopian65ab4712010-07-14 17:59:35 -07002300void AudioFlinger::removeClient_l(pid_t pid)
2301{
Glenn Kasten827e5f12012-11-02 10:00:06 -07002302 ALOGV("removeClient_l() pid %d, calling pid %d", pid,
Glenn Kasten85ab62c2012-11-01 11:11:38 -07002303 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002304 mClients.removeItem(pid);
2305}
2306
Andy Hung954b9712023-08-28 18:36:53 -07002307// getEffectThread_l() must be called with AudioFlinger::mutex() held
Andy Hung87c693c2023-07-06 20:56:16 -07002308sp<IAfThreadBase> AudioFlinger::getEffectThread_l(audio_session_t sessionId,
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002309 int effectId)
Eric Laurent717e1282012-06-29 16:36:52 -07002310{
Andy Hung87c693c2023-07-06 20:56:16 -07002311 sp<IAfThreadBase> thread;
Eric Laurent717e1282012-06-29 16:36:52 -07002312
2313 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Shunkai Yao0bc64562024-02-14 03:01:33 +00002314 thread = mPlaybackThreads.valueAt(i);
2315 if (thread->getEffect(sessionId, effectId) != 0) {
2316 return thread;
Eric Laurent717e1282012-06-29 16:36:52 -07002317 }
2318 }
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002319 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Shunkai Yao0bc64562024-02-14 03:01:33 +00002320 thread = mRecordThreads.valueAt(i);
2321 if (thread->getEffect(sessionId, effectId) != 0) {
2322 return thread;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002323 }
2324 }
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002325 for (size_t i = 0; i < mMmapThreads.size(); i++) {
Shunkai Yao0bc64562024-02-14 03:01:33 +00002326 thread = mMmapThreads.valueAt(i);
2327 if (thread->getEffect(sessionId, effectId) != 0) {
2328 return thread;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002329 }
2330 }
Shunkai Yao0bc64562024-02-14 03:01:33 +00002331 return nullptr;
Eric Laurent717e1282012-06-29 16:36:52 -07002332}
Mathias Agopian65ab4712010-07-14 17:59:35 -07002333
Mathias Agopian65ab4712010-07-14 17:59:35 -07002334// ----------------------------------------------------------------------------
2335
2336AudioFlinger::NotificationClient::NotificationClient(const sp<AudioFlinger>& audioFlinger,
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002337 const sp<media::IAudioFlingerClient>& client,
Andy Hung5bdc5352019-12-23 14:36:31 -08002338 pid_t pid,
Andy Hungbcd19ea2024-08-22 16:32:21 +00002339 uid_t uid)
2340 : mAudioFlinger(audioFlinger), mPid(pid), mUid(uid), mAudioFlingerClient(client)
Andy Hung88a7afe2024-08-12 20:00:46 -07002341 , mClientToken(media::psh_utils::AudioPowerManager::enabled()
2342 ? media::psh_utils::createAudioClientToken(pid, uid)
2343 : nullptr)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002344{
2345}
2346
2347AudioFlinger::NotificationClient::~NotificationClient()
2348{
Mathias Agopian65ab4712010-07-14 17:59:35 -07002349}
2350
Glenn Kasten0f11b512014-01-31 16:18:54 -08002351void AudioFlinger::NotificationClient::binderDied(const wp<IBinder>& who __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002352{
Andy Hung05b0ffe2024-08-30 17:18:37 -07002353 const auto keep = sp<NotificationClient>::fromExisting(this);
Glenn Kastena1117922012-01-26 10:53:32 -08002354 mAudioFlinger->removeNotificationClient(mPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002355}
2356
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08002357// ----------------------------------------------------------------------------
2358AudioFlinger::MediaLogNotifier::MediaLogNotifier()
2359 : mPendingRequests(false) {}
2360
2361
2362void AudioFlinger::MediaLogNotifier::requestMerge() {
Andy Hung954b9712023-08-28 18:36:53 -07002363 audio_utils::lock_guard _l(mMutex);
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08002364 mPendingRequests = true;
Andy Hung954b9712023-08-28 18:36:53 -07002365 mCondition.notify_one();
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08002366}
2367
2368bool AudioFlinger::MediaLogNotifier::threadLoop() {
Glenn Kasten04b96fc2017-04-10 14:58:47 -07002369 // Should already have been checked, but just in case
2370 if (sMediaLogService == 0) {
2371 return false;
2372 }
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08002373 // Wait until there are pending requests
2374 {
Andy Hung954b9712023-08-28 18:36:53 -07002375 audio_utils::unique_lock _l(mMutex);
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08002376 mPendingRequests = false; // to ignore past requests
2377 while (!mPendingRequests) {
Andy Hung954b9712023-08-28 18:36:53 -07002378 mCondition.wait(_l);
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08002379 // TODO may also need an exitPending check
2380 }
2381 mPendingRequests = false;
2382 }
2383 // Execute the actual MediaLogService binder call and ignore extra requests for a while
Glenn Kasten04b96fc2017-04-10 14:58:47 -07002384 sMediaLogService->requestMergeWakeup();
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08002385 usleep(kPostTriggerSleepPeriod);
2386 return true;
2387}
2388
2389void AudioFlinger::requestLogMerge() {
2390 mMediaLogNotifier->requestMerge();
2391}
Mathias Agopian65ab4712010-07-14 17:59:35 -07002392
2393// ----------------------------------------------------------------------------
2394
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08002395status_t AudioFlinger::createRecord(const media::CreateRecordRequest& _input,
2396 media::CreateRecordResponse& _output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002397{
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08002398 CreateRecordInput input = VALUE_OR_RETURN_STATUS(CreateRecordInput::fromAidl(_input));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08002399 CreateRecordOutput output;
2400
Andy Hung8d31fd22023-06-26 19:20:57 -07002401 sp<IAfRecordTrack> recordTrack;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002402 sp<Client> client;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002403 status_t lStatus;
Eric Laurentf14db3c2017-12-08 14:20:36 -08002404 audio_session_t sessionId = input.sessionId;
Eric Laurent77881cd2018-02-09 16:01:31 -08002405 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002406
Eric Laurentf14db3c2017-12-08 14:20:36 -08002407 output.cblk.clear();
2408 output.buffers.clear();
Eric Laurent896c9672017-12-08 14:08:45 -08002409 output.inputId = AUDIO_IO_HANDLE_NONE;
Glenn Kastend776ac62014-05-07 09:16:09 -07002410
Atneya Nair5997a652024-06-14 17:24:45 -07002411 AttributionSourceState adjAttributionSource;
2412 pid_t callingPid = IPCThreadState::self()->getCallingPid();
2413 if (!com::android::media::audio::audioserver_permissions()) {
2414 adjAttributionSource = input.clientInfo.attributionSource;
2415 bool updatePid = (adjAttributionSource.pid == -1);
2416 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
2417 const uid_t currentUid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(
2418 adjAttributionSource.uid));
2419 if (!isAudioServerOrMediaServerOrSystemServerOrRootUid(callingUid)) {
2420 ALOGW_IF(currentUid != callingUid,
2421 "%s uid %d tried to pass itself off as %d",
2422 __FUNCTION__, callingUid, currentUid);
2423 adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(
2424 legacy2aidl_uid_t_int32_t(callingUid));
2425 updatePid = true;
2426 }
2427 const pid_t currentPid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(
2428 adjAttributionSource.pid));
2429 if (updatePid) {
2430 ALOGW_IF(currentPid != (pid_t)-1 && currentPid != callingPid,
2431 "%s uid %d pid %d tried to pass itself off as pid %d",
2432 __func__, callingUid, callingPid, currentPid);
2433 adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(
2434 legacy2aidl_pid_t_int32_t(callingPid));
2435 }
2436 adjAttributionSource = afutils::checkAttributionSourcePackage(
2437 adjAttributionSource);
2438 } else {
2439 auto validatedAttrSource = VALUE_OR_RETURN_CONVERTED(
2440 validateAttributionFromContextOrTrustedCaller(
2441 input.clientInfo.attributionSource,
2442 getPermissionProvider()
2443 ));
2444 // TODO pass wrapped object around
2445 adjAttributionSource = std::move(validatedAttrSource).unwrapInto();
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07002446 }
Atneya Nair5997a652024-06-14 17:24:45 -07002447
Dean Wheatleya404ff42023-10-20 13:25:02 +11002448 // further format checks are performed by createRecordTrack_l()
2449 if (!audio_is_valid_format(input.config.format)) {
Eric Laurentf14db3c2017-12-08 14:20:36 -08002450 ALOGE("createRecord() invalid format %#x", input.config.format);
Glenn Kasten291bb6d2013-07-16 17:23:39 -07002451 lStatus = BAD_VALUE;
2452 goto Exit;
2453 }
2454
Glenn Kasten53b5d092014-02-05 10:00:23 -08002455 // further channel mask checks are performed by createRecordTrack_l()
Eric Laurentf14db3c2017-12-08 14:20:36 -08002456 if (!audio_is_input_channel(input.config.channel_mask)) {
2457 ALOGE("createRecord() invalid channel mask %#x", input.config.channel_mask);
Glenn Kasten53b5d092014-02-05 10:00:23 -08002458 lStatus = BAD_VALUE;
2459 goto Exit;
2460 }
2461
Eric Laurentf14db3c2017-12-08 14:20:36 -08002462 if (sessionId == AUDIO_SESSION_ALLOCATE) {
2463 sessionId = (audio_session_t) newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
2464 } else if (audio_unique_id_get_use(sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) {
2465 lStatus = BAD_VALUE;
2466 goto Exit;
2467 }
2468
2469 output.sessionId = sessionId;
Eric Laurentf14db3c2017-12-08 14:20:36 -08002470 output.selectedDeviceId = input.selectedDeviceId;
2471 output.flags = input.flags;
2472
Svet Ganov33761132021-05-13 22:51:08 +00002473 client = registerPid(VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(adjAttributionSource.pid)));
Eric Laurentf14db3c2017-12-08 14:20:36 -08002474
2475 // Not a conventional loop, but a retry loop for at most two iterations total.
2476 // Try first maybe with FAST flag then try again without FAST flag if that fails.
2477 // Exits loop via break on no error of got exit on error
2478 // The sp<> references will be dropped when re-entering scope.
2479 // The lack of indentation is deliberate, to reduce code churn and ease merges.
2480 for (;;) {
Eric Laurent896c9672017-12-08 14:08:45 -08002481 // release previously opened input if retrying.
2482 if (output.inputId != AUDIO_IO_HANDLE_NONE) {
2483 recordTrack.clear();
Eric Laurentfee19762018-01-29 18:44:13 -08002484 AudioSystem::releaseInput(portId);
Eric Laurent896c9672017-12-08 14:08:45 -08002485 output.inputId = AUDIO_IO_HANDLE_NONE;
Yung Ti Su5fac9c62018-05-15 15:07:43 +08002486 output.selectedDeviceId = input.selectedDeviceId;
Eric Laurent77881cd2018-02-09 16:01:31 -08002487 portId = AUDIO_PORT_HANDLE_NONE;
Eric Laurent896c9672017-12-08 14:08:45 -08002488 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08002489 lStatus = AudioSystem::getInputForAttr(&input.attr, &output.inputId,
Mikhail Naganov2996f672019-04-18 12:29:59 -07002490 input.riid,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002491 sessionId,
2492 // FIXME compare to AudioTrack
Svet Ganov33761132021-05-13 22:51:08 +00002493 adjAttributionSource,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002494 &input.config,
2495 output.flags, &output.selectedDeviceId, &portId);
jiabinc1de2df2019-05-07 14:26:40 -07002496 if (lStatus != NO_ERROR) {
2497 ALOGE("createRecord() getInputForAttr return error %d", lStatus);
2498 goto Exit;
2499 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08002500
Glenn Kasten05997e22014-03-13 15:08:33 -07002501 {
Andy Hung954b9712023-08-28 18:36:53 -07002502 audio_utils::lock_guard _l(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07002503 IAfRecordThread* const thread = checkRecordThread_l(output.inputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002504 if (thread == NULL) {
Eric Laurentd52a28c2020-08-21 17:10:39 -07002505 ALOGW("createRecord() checkRecordThread_l failed, input handle %d", output.inputId);
2506 lStatus = FAILED_TRANSACTION;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002507 goto Exit;
2508 }
2509
Eric Laurentf14db3c2017-12-08 14:20:36 -08002510 ALOGV("createRecord() lSessionId: %d input %d", sessionId, output.inputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002511
Eric Laurentf14db3c2017-12-08 14:20:36 -08002512 output.sampleRate = input.config.sample_rate;
2513 output.frameCount = input.frameCount;
2514 output.notificationFrameCount = input.notificationFrameCount;
Glenn Kasten570f6332014-03-13 15:01:06 -07002515
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002516 recordTrack = thread->createRecordTrack_l(client, input.attr, &output.sampleRate,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002517 input.config.format, input.config.channel_mask,
2518 &output.frameCount, sessionId,
2519 &output.notificationFrameCount,
Svet Ganov33761132021-05-13 22:51:08 +00002520 callingPid, adjAttributionSource, &output.flags,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002521 input.clientInfo.clientTid,
Eric Laurentec376dc2021-04-08 20:41:22 +02002522 &lStatus, portId, input.maxSharedAudioHistoryMs);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08002523 LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (recordTrack == 0));
Eric Laurent1b928682014-10-02 19:41:47 -07002524
Eric Laurentf14db3c2017-12-08 14:20:36 -08002525 // lStatus == BAD_TYPE means FAST flag was rejected: request a new input from
2526 // audio policy manager without FAST constraint
2527 if (lStatus == BAD_TYPE) {
Eric Laurentf14db3c2017-12-08 14:20:36 -08002528 continue;
Eric Laurent1b928682014-10-02 19:41:47 -07002529 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08002530
2531 if (lStatus != NO_ERROR) {
Eric Laurentf14db3c2017-12-08 14:20:36 -08002532 goto Exit;
2533 }
2534
jiabinb00edc32021-08-16 16:27:54 +00002535 if (recordTrack->isFastTrack()) {
2536 output.serverConfig = {
2537 thread->sampleRate(),
2538 thread->channelMask(),
2539 thread->format()
2540 };
2541 } else {
2542 output.serverConfig = {
2543 recordTrack->sampleRate(),
2544 recordTrack->channelMask(),
2545 recordTrack->format()
2546 };
2547 }
2548
Robert Wu310037a2022-09-06 21:48:18 +00002549 output.halConfig = {
2550 thread->sampleRate(),
2551 thread->channelMask(),
2552 thread->format()
2553 };
2554
Eric Laurentf14db3c2017-12-08 14:20:36 -08002555 // Check if one effect chain was awaiting for an AudioRecord to be created on this
2556 // session and move it to this thread.
Andy Hung6ac17eb2023-06-20 18:56:17 -07002557 sp<IAfEffectChain> chain = getOrphanEffectChain_l(sessionId);
Eric Laurentf14db3c2017-12-08 14:20:36 -08002558 if (chain != 0) {
Andy Hungc5007f82023-08-29 14:26:09 -07002559 audio_utils::lock_guard _l2(thread->mutex());
Eric Laurentf14db3c2017-12-08 14:20:36 -08002560 thread->addEffectChain_l(chain);
2561 }
2562 break;
2563 }
2564 // End of retry loop.
2565 // The lack of indentation is deliberate, to reduce code churn and ease merges.
Mathias Agopian65ab4712010-07-14 17:59:35 -07002566 }
Glenn Kastene198c362013-08-13 09:13:36 -07002567
Eric Laurentf14db3c2017-12-08 14:20:36 -08002568 output.cblk = recordTrack->getCblk();
2569 output.buffers = recordTrack->getBuffers();
Eric Laurent973db022018-11-20 14:54:31 -08002570 output.portId = portId;
Eric Laurentf14db3c2017-12-08 14:20:36 -08002571
Andy Hungd29af632023-06-23 19:27:19 -07002572 output.audioRecord = IAfRecordTrack::createIAudioRecordAdapter(recordTrack);
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08002573 _output = VALUE_OR_FATAL(output.toAidl());
2574
Eric Laurentf14db3c2017-12-08 14:20:36 -08002575Exit:
Eric Laurent7c7f10b2011-06-17 21:29:58 -07002576 if (lStatus != NO_ERROR) {
Glenn Kasten85ab62c2012-11-01 11:11:38 -07002577 // remove local strong reference to Client before deleting the RecordTrack so that the
Andy Hung954b9712023-08-28 18:36:53 -07002578 // Client destructor is called by the TrackBase destructor with clientMutex() held
2579 // Don't hold clientMutex() when releasing the reference on the track as the
Eric Laurentfe1a94e2014-05-26 16:03:08 -07002580 // destructor will acquire it.
2581 {
Andy Hung954b9712023-08-28 18:36:53 -07002582 audio_utils::lock_guard _cl(clientMutex());
Eric Laurentfe1a94e2014-05-26 16:03:08 -07002583 client.clear();
2584 }
Eric Laurent896c9672017-12-08 14:08:45 -08002585 recordTrack.clear();
2586 if (output.inputId != AUDIO_IO_HANDLE_NONE) {
Eric Laurentfee19762018-01-29 18:44:13 -08002587 AudioSystem::releaseInput(portId);
Eric Laurent896c9672017-12-08 14:08:45 -08002588 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002589 }
2590
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08002591 return lStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002592}
2593
Eric Laurentb8ba0a92011-08-07 16:32:26 -07002594
2595
Mathias Agopian65ab4712010-07-14 17:59:35 -07002596// ----------------------------------------------------------------------------
2597
Mikhail Naganovffd97712023-05-03 17:45:36 -07002598status_t AudioFlinger::getAudioPolicyConfig(media::AudioPolicyConfig *config)
2599{
2600 if (config == nullptr) {
2601 return BAD_VALUE;
2602 }
Andy Hung954b9712023-08-28 18:36:53 -07002603 audio_utils::lock_guard _l(mutex());
2604 audio_utils::lock_guard lock(hardwareMutex());
Mikhail Naganovffd97712023-05-03 17:45:36 -07002605 RETURN_STATUS_IF_ERROR(
2606 mDevicesFactoryHal->getSurroundSoundConfig(&config->surroundSoundConfig));
2607 RETURN_STATUS_IF_ERROR(mDevicesFactoryHal->getEngineConfig(&config->engineConfig));
2608 std::vector<std::string> hwModuleNames;
2609 RETURN_STATUS_IF_ERROR(mDevicesFactoryHal->getDeviceNames(&hwModuleNames));
2610 std::set<AudioMode> allSupportedModes;
2611 for (const auto& name : hwModuleNames) {
Andy Hungc2cf7ec2023-08-30 18:19:00 -07002612 AudioHwDevice* module = loadHwModule_ll(name.c_str());
Mikhail Naganovffd97712023-05-03 17:45:36 -07002613 if (module == nullptr) continue;
2614 media::AudioHwModule aidlModule;
2615 if (module->hwDevice()->getAudioPorts(&aidlModule.ports) == OK &&
2616 module->hwDevice()->getAudioRoutes(&aidlModule.routes) == OK) {
2617 aidlModule.handle = module->handle();
2618 aidlModule.name = module->moduleName();
2619 config->modules.push_back(std::move(aidlModule));
2620 }
2621 std::vector<AudioMode> supportedModes;
2622 if (module->hwDevice()->getSupportedModes(&supportedModes) == OK) {
2623 allSupportedModes.insert(supportedModes.begin(), supportedModes.end());
2624 }
2625 }
2626 if (!allSupportedModes.empty()) {
2627 config->supportedModes.insert(config->supportedModes.end(),
2628 allSupportedModes.begin(), allSupportedModes.end());
2629 } else {
2630 ALOGW("%s: The HAL does not provide telephony functionality", __func__);
2631 config->supportedModes = { media::audio::common::AudioMode::NORMAL,
2632 media::audio::common::AudioMode::RINGTONE,
2633 media::audio::common::AudioMode::IN_CALL,
2634 media::audio::common::AudioMode::IN_COMMUNICATION };
2635 }
2636 return OK;
2637}
2638
Eric Laurenta4c5a552012-03-29 10:12:40 -07002639audio_module_handle_t AudioFlinger::loadHwModule(const char *name)
2640{
Eric Laurent44622db2014-08-01 19:00:33 -07002641 if (name == NULL) {
Glenn Kastena13cde92016-03-28 15:26:02 -07002642 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurent44622db2014-08-01 19:00:33 -07002643 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07002644 if (!settingsAllowed()) {
Glenn Kastena13cde92016-03-28 15:26:02 -07002645 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002646 }
Andy Hung954b9712023-08-28 18:36:53 -07002647 audio_utils::lock_guard _l(mutex());
2648 audio_utils::lock_guard lock(hardwareMutex());
Andy Hungc2cf7ec2023-08-30 18:19:00 -07002649 AudioHwDevice* module = loadHwModule_ll(name);
Mikhail Naganovffd97712023-05-03 17:45:36 -07002650 return module != nullptr ? module->handle() : AUDIO_MODULE_HANDLE_NONE;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002651}
2652
Andy Hung954b9712023-08-28 18:36:53 -07002653// loadHwModule_l() must be called with AudioFlinger::mutex()
2654// and AudioFlinger::hardwareMutex() held
Andy Hungc2cf7ec2023-08-30 18:19:00 -07002655AudioHwDevice* AudioFlinger::loadHwModule_ll(const char *name)
Eric Laurenta4c5a552012-03-29 10:12:40 -07002656{
2657 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
2658 if (strncmp(mAudioHwDevs.valueAt(i)->moduleName(), name, strlen(name)) == 0) {
2659 ALOGW("loadHwModule() module %s already loaded", name);
Mikhail Naganovffd97712023-05-03 17:45:36 -07002660 return mAudioHwDevs.valueAt(i);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002661 }
2662 }
2663
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002664 sp<DeviceHalInterface> dev;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002665
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002666 int rc = mDevicesFactoryHal->openDevice(name, &dev);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002667 if (rc) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002668 ALOGE("loadHwModule() error %d loading module %s", rc, name);
Mikhail Naganovffd97712023-05-03 17:45:36 -07002669 return nullptr;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002670 }
Vlad Popa03bd5bc2023-01-17 16:16:51 +01002671 if (!mMelReporter->activateHalSoundDoseComputation(name, dev)) {
Vlad Popa1d5f0d52022-12-18 12:21:26 +01002672 ALOGW("loadHwModule() sound dose reporting is not available");
2673 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07002674
2675 mHardwareStatus = AUDIO_HW_INIT;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002676 rc = dev->initCheck();
Eric Laurenta4c5a552012-03-29 10:12:40 -07002677 mHardwareStatus = AUDIO_HW_IDLE;
2678 if (rc) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002679 ALOGE("loadHwModule() init check error %d for module %s", rc, name);
Mikhail Naganovffd97712023-05-03 17:45:36 -07002680 return nullptr;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002681 }
2682
John Grossmanee578c02012-07-23 17:05:46 -07002683 // Check and cache this HAL's level of support for master mute and master
2684 // volume. If this is the first HAL opened, and it supports the get
2685 // methods, use the initial values provided by the HAL as the current
2686 // master mute and volume settings.
2687
2688 AudioHwDevice::Flags flags = static_cast<AudioHwDevice::Flags>(0);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002689 if (0 == mAudioHwDevs.size()) {
2690 mHardwareStatus = AUDIO_HW_GET_MASTER_VOLUME;
2691 float mv;
2692 if (OK == dev->getMasterVolume(&mv)) {
2693 mMasterVolume = mv;
John Grossmanee578c02012-07-23 17:05:46 -07002694 }
2695
Eric Laurent00abf0d2020-04-22 19:28:22 -07002696 mHardwareStatus = AUDIO_HW_GET_MASTER_MUTE;
2697 bool mm;
2698 if (OK == dev->getMasterMute(&mm)) {
2699 mMasterMute = mm;
Andy Hung0e26ec62024-02-20 16:32:57 -08002700 ALOGI_IF(mMasterMute, "%s: applying mute from HAL %s", __func__, name);
John Grossmanee578c02012-07-23 17:05:46 -07002701 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07002702 }
Eric Laurent00abf0d2020-04-22 19:28:22 -07002703
2704 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
2705 if (OK == dev->setMasterVolume(mMasterVolume)) {
2706 flags = static_cast<AudioHwDevice::Flags>(flags |
2707 AudioHwDevice::AHWD_CAN_SET_MASTER_VOLUME);
2708 }
2709
2710 mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE;
2711 if (OK == dev->setMasterMute(mMasterMute)) {
2712 flags = static_cast<AudioHwDevice::Flags>(flags |
2713 AudioHwDevice::AHWD_CAN_SET_MASTER_MUTE);
2714 }
2715
2716 mHardwareStatus = AUDIO_HW_IDLE;
2717
Mikhail Naganov97373b02018-07-23 13:27:24 -07002718 if (strcmp(name, AUDIO_HARDWARE_MODULE_ID_MSD) == 0) {
Mikhail Naganovadca70f2018-07-09 12:49:25 -07002719 // An MSD module is inserted before hardware modules in order to mix encoded streams.
2720 flags = static_cast<AudioHwDevice::Flags>(flags | AudioHwDevice::AHWD_IS_INSERT);
2721 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07002722
Eric Laurent52057642022-12-16 11:45:07 +01002723
2724 if (bool supports = false;
Eric Laurent50d72582022-12-20 20:20:23 +01002725 dev->supportsBluetoothVariableLatency(&supports) == NO_ERROR && supports) {
Eric Laurent52057642022-12-16 11:45:07 +01002726 flags = static_cast<AudioHwDevice::Flags>(flags |
2727 AudioHwDevice::AHWD_SUPPORTS_BT_LATENCY_MODES);
2728 }
2729
Glenn Kastena13cde92016-03-28 15:26:02 -07002730 audio_module_handle_t handle = (audio_module_handle_t) nextUniqueId(AUDIO_UNIQUE_ID_USE_MODULE);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002731 AudioHwDevice *audioDevice = new AudioHwDevice(handle, name, dev, flags);
2732 if (strcmp(name, AUDIO_HARDWARE_MODULE_ID_PRIMARY) == 0) {
2733 mPrimaryHardwareDev = audioDevice;
2734 mHardwareStatus = AUDIO_HW_SET_MODE;
Andy Hunge3748872023-08-30 19:05:16 -07002735 mPrimaryHardwareDev.load()->hwDevice()->setMode(mMode);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002736 mHardwareStatus = AUDIO_HW_IDLE;
2737 }
2738
Shunkai Yao2b8fed42022-12-09 01:12:02 +00002739 if (mDevicesFactoryHal->getHalVersion() > kMaxAAudioPropertyDeviceHalVersion) {
jiabine504e7b2021-09-18 00:27:08 +00002740 if (int32_t mixerBursts = dev->getAAudioMixerBurstCount();
jiabina4ff38f2022-02-11 19:42:25 +00002741 mixerBursts > 0 && mixerBursts > mAAudioBurstsPerBuffer) {
jiabine504e7b2021-09-18 00:27:08 +00002742 mAAudioBurstsPerBuffer = mixerBursts;
2743 }
2744 if (int32_t hwBurstMinMicros = dev->getAAudioHardwareBurstMinUsec();
jiabina4ff38f2022-02-11 19:42:25 +00002745 hwBurstMinMicros > 0
2746 && (hwBurstMinMicros < mAAudioHwBurstMinMicros || mAAudioHwBurstMinMicros == 0)) {
jiabine504e7b2021-09-18 00:27:08 +00002747 mAAudioHwBurstMinMicros = hwBurstMinMicros;
2748 }
2749 }
2750
Eric Laurent00abf0d2020-04-22 19:28:22 -07002751 mAudioHwDevs.add(handle, audioDevice);
Oleg Lyovin7434b722024-03-05 18:08:01 +03002752 if (strcmp(name, AUDIO_HARDWARE_MODULE_ID_STUB) != 0) {
2753 mInputBufferSizeOrderedDevs.insert(audioDevice);
2754 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07002755
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002756 ALOGI("loadHwModule() Loaded %s audio interface, handle %d", name, handle);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002757
Mikhail Naganovffd97712023-05-03 17:45:36 -07002758 return audioDevice;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002759}
2760
Oleg Lyovin7434b722024-03-05 18:08:01 +03002761// Sort AudioHwDevice to be traversed in the getInputBufferSize call in the following order:
2762// Primary, Usb, Bluetooth, A2DP, other modules, remote submix.
2763/* static */
2764bool AudioFlinger::inputBufferSizeDevsCmp(const AudioHwDevice* lhs, const AudioHwDevice* rhs) {
2765 static const std::map<std::string_view, int> kPriorities = {
2766 { AUDIO_HARDWARE_MODULE_ID_PRIMARY, 0 }, { AUDIO_HARDWARE_MODULE_ID_USB, 1 },
2767 { AUDIO_HARDWARE_MODULE_ID_BLUETOOTH, 2 }, { AUDIO_HARDWARE_MODULE_ID_A2DP, 3 },
2768 { AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX, std::numeric_limits<int>::max() }
2769 };
2770
2771 const std::string_view lhsName = lhs->moduleName();
2772 const std::string_view rhsName = rhs->moduleName();
2773
2774 auto lhsPriority = std::numeric_limits<int>::max() - 1;
2775 if (const auto lhsIt = kPriorities.find(lhsName); lhsIt != kPriorities.end()) {
2776 lhsPriority = lhsIt->second;
2777 }
2778 auto rhsPriority = std::numeric_limits<int>::max() - 1;
2779 if (const auto rhsIt = kPriorities.find(rhsName); rhsIt != kPriorities.end()) {
2780 rhsPriority = rhsIt->second;
2781 }
2782
2783 if (lhsPriority != rhsPriority) {
2784 return lhsPriority < rhsPriority;
2785 }
2786 return lhsName < rhsName;
2787}
2788
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002789// ----------------------------------------------------------------------------
2790
Andy Hungcdd80ef2023-07-17 11:37:26 -07002791uint32_t AudioFlinger::getPrimaryOutputSamplingRate() const
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002792{
Andy Hung954b9712023-08-28 18:36:53 -07002793 audio_utils::lock_guard _l(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07002794 IAfPlaybackThread* const thread = fastPlaybackThread_l();
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002795 return thread != NULL ? thread->sampleRate() : 0;
2796}
2797
Andy Hungcdd80ef2023-07-17 11:37:26 -07002798size_t AudioFlinger::getPrimaryOutputFrameCount() const
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002799{
Andy Hung954b9712023-08-28 18:36:53 -07002800 audio_utils::lock_guard _l(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07002801 IAfPlaybackThread* const thread = fastPlaybackThread_l();
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002802 return thread != NULL ? thread->frameCountHAL() : 0;
2803}
2804
2805// ----------------------------------------------------------------------------
2806
Andy Hung6f248bb2018-01-23 14:04:37 -08002807status_t AudioFlinger::setLowRamDevice(bool isLowRamDevice, int64_t totalMemory)
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002808{
2809 uid_t uid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07002810 if (!isAudioServerOrSystemServerUid(uid)) {
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002811 return PERMISSION_DENIED;
2812 }
Andy Hung954b9712023-08-28 18:36:53 -07002813 audio_utils::lock_guard _l(mutex());
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002814 if (mIsDeviceTypeKnown) {
2815 return INVALID_OPERATION;
2816 }
2817 mIsLowRamDevice = isLowRamDevice;
Andy Hung6f248bb2018-01-23 14:04:37 -08002818 mTotalMemory = totalMemory;
2819 // mIsLowRamDevice and mTotalMemory are obtained through ActivityManager;
2820 // see ActivityManager.isLowRamDevice() and ActivityManager.getMemoryInfo().
2821 // mIsLowRamDevice generally represent devices with less than 1GB of memory,
2822 // though actual setting is determined through device configuration.
2823 constexpr int64_t GB = 1024 * 1024 * 1024;
2824 mClientSharedHeapSize =
2825 isLowRamDevice ? kMinimumClientSharedHeapSizeBytes
2826 : mTotalMemory < 2 * GB ? 4 * kMinimumClientSharedHeapSizeBytes
2827 : mTotalMemory < 3 * GB ? 8 * kMinimumClientSharedHeapSizeBytes
2828 : mTotalMemory < 4 * GB ? 16 * kMinimumClientSharedHeapSizeBytes
2829 : 32 * kMinimumClientSharedHeapSizeBytes;
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002830 mIsDeviceTypeKnown = true;
Andy Hung6f248bb2018-01-23 14:04:37 -08002831
2832 // TODO: Cache the client shared heap size in a persistent property.
2833 // It's possible that a native process or Java service or app accesses audioserver
2834 // after it is registered by system server, but before AudioService updates
2835 // the memory info. This would occur immediately after boot or an audioserver
2836 // crash and restore. Before update from AudioService, the client would get the
2837 // minimum heap size.
2838
2839 ALOGD("isLowRamDevice:%s totalMemory:%lld mClientSharedHeapSize:%zu",
2840 (isLowRamDevice ? "true" : "false"),
2841 (long long)mTotalMemory,
2842 mClientSharedHeapSize.load());
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002843 return NO_ERROR;
2844}
2845
Andy Hung6f248bb2018-01-23 14:04:37 -08002846size_t AudioFlinger::getClientSharedHeapSize() const
2847{
2848 size_t heapSizeInBytes = property_get_int32("ro.af.client_heap_size_kbyte", 0) * 1024;
2849 if (heapSizeInBytes != 0) { // read-only property overrides all.
2850 return heapSizeInBytes;
2851 }
2852 return mClientSharedHeapSize;
2853}
2854
Mikhail Naganovdea53042018-04-26 13:10:21 -07002855status_t AudioFlinger::setAudioPortConfig(const struct audio_port_config *config)
2856{
2857 ALOGV(__func__);
2858
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08002859 status_t status = AudioValidator::validateAudioPortConfig(*config);
2860 if (status != NO_ERROR) {
2861 return status;
2862 }
2863
Mikhail Naganovdea53042018-04-26 13:10:21 -07002864 audio_module_handle_t module;
2865 if (config->type == AUDIO_PORT_TYPE_DEVICE) {
2866 module = config->ext.device.hw_module;
2867 } else {
2868 module = config->ext.mix.hw_module;
2869 }
2870
Andy Hung954b9712023-08-28 18:36:53 -07002871 audio_utils::lock_guard _l(mutex());
2872 audio_utils::lock_guard lock(hardwareMutex());
Mikhail Naganovdea53042018-04-26 13:10:21 -07002873 ssize_t index = mAudioHwDevs.indexOfKey(module);
2874 if (index < 0) {
2875 ALOGW("%s() bad hw module %d", __func__, module);
2876 return BAD_VALUE;
2877 }
2878
2879 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueAt(index);
2880 return audioHwDevice->hwDevice()->setAudioPortConfig(config);
2881}
2882
Eric Laurent93c3d412014-08-01 14:48:35 -07002883audio_hw_sync_t AudioFlinger::getAudioHwSyncForSession(audio_session_t sessionId)
2884{
Andy Hung954b9712023-08-28 18:36:53 -07002885 audio_utils::lock_guard _l(mutex());
Eric Laurentfa90e842014-10-17 18:12:31 -07002886
2887 ssize_t index = mHwAvSyncIds.indexOfKey(sessionId);
2888 if (index >= 0) {
2889 ALOGV("getAudioHwSyncForSession found ID %d for session %d",
2890 mHwAvSyncIds.valueAt(index), sessionId);
2891 return mHwAvSyncIds.valueAt(index);
2892 }
2893
Eric Laurent00abf0d2020-04-22 19:28:22 -07002894 sp<DeviceHalInterface> dev;
2895 {
Andy Hung954b9712023-08-28 18:36:53 -07002896 audio_utils::lock_guard lock(hardwareMutex());
Eric Laurent00abf0d2020-04-22 19:28:22 -07002897 if (mPrimaryHardwareDev == nullptr) {
2898 return AUDIO_HW_SYNC_INVALID;
2899 }
Andy Hunge3748872023-08-30 19:05:16 -07002900 dev = mPrimaryHardwareDev.load()->hwDevice();
Eric Laurent00abf0d2020-04-22 19:28:22 -07002901 }
2902 if (dev == nullptr) {
Eric Laurentfa90e842014-10-17 18:12:31 -07002903 return AUDIO_HW_SYNC_INVALID;
2904 }
Eric Laurentfa90e842014-10-17 18:12:31 -07002905
Ytai Ben-Tsvi48287b52021-12-01 15:07:11 -08002906 error::Result<audio_hw_sync_t> result = dev->getHwAvSync();
2907 if (!result.ok()) {
Eric Laurentfa90e842014-10-17 18:12:31 -07002908 ALOGW("getAudioHwSyncForSession error getting sync for session %d", sessionId);
2909 return AUDIO_HW_SYNC_INVALID;
2910 }
Ytai Ben-Tsvi48287b52021-12-01 15:07:11 -08002911 audio_hw_sync_t value = VALUE_OR_FATAL(result);
Eric Laurentfa90e842014-10-17 18:12:31 -07002912
2913 // allow only one session for a given HW A/V sync ID.
2914 for (size_t i = 0; i < mHwAvSyncIds.size(); i++) {
Ytai Ben-Tsvi48287b52021-12-01 15:07:11 -08002915 if (mHwAvSyncIds.valueAt(i) == value) {
Eric Laurentfa90e842014-10-17 18:12:31 -07002916 ALOGV("getAudioHwSyncForSession removing ID %d for session %d",
2917 value, mHwAvSyncIds.keyAt(i));
2918 mHwAvSyncIds.removeItemsAt(i);
Eric Laurent93c3d412014-08-01 14:48:35 -07002919 break;
2920 }
2921 }
Eric Laurentfa90e842014-10-17 18:12:31 -07002922
2923 mHwAvSyncIds.add(sessionId, value);
2924
2925 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Andy Hung87c693c2023-07-06 20:56:16 -07002926 const sp<IAfPlaybackThread> thread = mPlaybackThreads.valueAt(i);
Eric Laurentfa90e842014-10-17 18:12:31 -07002927 uint32_t sessions = thread->hasAudioSession(sessionId);
Andy Hung87c693c2023-07-06 20:56:16 -07002928 if (sessions & IAfThreadBase::TRACK_SESSION) {
Eric Laurentfa90e842014-10-17 18:12:31 -07002929 AudioParameter param = AudioParameter();
Mikhail Naganov00260b52016-10-13 12:54:24 -07002930 param.addInt(String8(AudioParameter::keyStreamHwAvSync), value);
Mikhail Naganovb261ef52018-07-16 13:34:38 -07002931 String8 keyValuePairs = param.toString();
2932 thread->setParameters(keyValuePairs);
2933 forwardParametersToDownstreamPatches_l(thread->id(), keyValuePairs,
Andy Hung87c693c2023-07-06 20:56:16 -07002934 [](const sp<IAfPlaybackThread>& thread) { return thread->usesHwAvSync(); });
Eric Laurentfa90e842014-10-17 18:12:31 -07002935 break;
2936 }
2937 }
2938
2939 ALOGV("getAudioHwSyncForSession adding ID %d for session %d", value, sessionId);
2940 return (audio_hw_sync_t)value;
Eric Laurent93c3d412014-08-01 14:48:35 -07002941}
2942
Eric Laurent72e3f392015-05-20 14:43:50 -07002943status_t AudioFlinger::systemReady()
2944{
Andy Hung954b9712023-08-28 18:36:53 -07002945 audio_utils::lock_guard _l(mutex());
Eric Laurent72e3f392015-05-20 14:43:50 -07002946 ALOGI("%s", __FUNCTION__);
2947 if (mSystemReady) {
2948 ALOGW("%s called twice", __FUNCTION__);
2949 return NO_ERROR;
2950 }
2951 mSystemReady = true;
2952 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Andy Hung87c693c2023-07-06 20:56:16 -07002953 IAfThreadBase* const thread = mPlaybackThreads.valueAt(i).get();
Eric Laurent72e3f392015-05-20 14:43:50 -07002954 thread->systemReady();
2955 }
2956 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Andy Hung87c693c2023-07-06 20:56:16 -07002957 IAfThreadBase* const thread = mRecordThreads.valueAt(i).get();
Eric Laurent72e3f392015-05-20 14:43:50 -07002958 thread->systemReady();
2959 }
Eric Laurentd66d7a12021-07-13 13:35:32 +02002960 for (size_t i = 0; i < mMmapThreads.size(); i++) {
Andy Hung87c693c2023-07-06 20:56:16 -07002961 IAfThreadBase* const thread = mMmapThreads.valueAt(i).get();
Eric Laurentd66d7a12021-07-13 13:35:32 +02002962 thread->systemReady();
2963 }
Vlad Popae8d99472022-06-30 16:02:48 +02002964
2965 // Java services are ready, so we can create a reference to AudioService
2966 getOrCreateAudioManager();
2967
Eric Laurent72e3f392015-05-20 14:43:50 -07002968 return NO_ERROR;
2969}
2970
Vlad Popae8d99472022-06-30 16:02:48 +02002971sp<IAudioManager> AudioFlinger::getOrCreateAudioManager()
2972{
2973 if (mAudioManager.load() == nullptr) {
2974 // use checkService() to avoid blocking
2975 sp<IBinder> binder =
2976 defaultServiceManager()->checkService(String16(kAudioServiceName));
2977 if (binder != nullptr) {
2978 mAudioManager = interface_cast<IAudioManager>(binder);
2979 } else {
2980 ALOGE("%s(): binding to audio service failed.", __func__);
2981 }
2982 }
2983 return mAudioManager.load();
2984}
2985
Andy Hungcdd80ef2023-07-17 11:37:26 -07002986status_t AudioFlinger::getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) const
jiabin46a76fa2018-01-05 10:18:21 -08002987{
Andy Hung954b9712023-08-28 18:36:53 -07002988 audio_utils::lock_guard lock(hardwareMutex());
Eric Laurent00abf0d2020-04-22 19:28:22 -07002989 status_t status = INVALID_OPERATION;
2990
2991 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Shunkai Yaoed624a72022-12-12 06:11:46 +00002992 std::vector<audio_microphone_characteristic_t> mics;
Eric Laurent00abf0d2020-04-22 19:28:22 -07002993 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
2994 mHardwareStatus = AUDIO_HW_GET_MICROPHONES;
2995 status_t devStatus = dev->hwDevice()->getMicrophones(&mics);
2996 mHardwareStatus = AUDIO_HW_IDLE;
2997 if (devStatus == NO_ERROR) {
Eric Laurent00abf0d2020-04-22 19:28:22 -07002998 // report success if at least one HW module supports the function.
Mikhail Naganovd5d9de72023-02-13 11:45:03 -08002999 std::transform(mics.begin(), mics.end(), std::back_inserter(*microphones), [](auto& mic)
3000 {
3001 auto microphone =
3002 legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfoFw(mic);
3003 return microphone.ok() ? microphone.value() : media::MicrophoneInfoFw{};
3004 });
Eric Laurent00abf0d2020-04-22 19:28:22 -07003005 status = NO_ERROR;
3006 }
3007 }
3008
jiabin9ff780e2018-03-19 18:19:52 -07003009 return status;
jiabin46a76fa2018-01-05 10:18:21 -08003010}
3011
Andy Hung954b9712023-08-28 18:36:53 -07003012// setAudioHwSyncForSession_l() must be called with AudioFlinger::mutex() held
Andy Hung87c693c2023-07-06 20:56:16 -07003013void AudioFlinger::setAudioHwSyncForSession_l(
3014 IAfPlaybackThread* const thread, audio_session_t sessionId)
Eric Laurentfa90e842014-10-17 18:12:31 -07003015{
3016 ssize_t index = mHwAvSyncIds.indexOfKey(sessionId);
3017 if (index >= 0) {
3018 audio_hw_sync_t syncId = mHwAvSyncIds.valueAt(index);
3019 ALOGV("setAudioHwSyncForSession_l found ID %d for session %d", syncId, sessionId);
3020 AudioParameter param = AudioParameter();
Mikhail Naganov00260b52016-10-13 12:54:24 -07003021 param.addInt(String8(AudioParameter::keyStreamHwAvSync), syncId);
Mikhail Naganovb261ef52018-07-16 13:34:38 -07003022 String8 keyValuePairs = param.toString();
3023 thread->setParameters(keyValuePairs);
3024 forwardParametersToDownstreamPatches_l(thread->id(), keyValuePairs,
Andy Hung87c693c2023-07-06 20:56:16 -07003025 [](const sp<IAfPlaybackThread>& thread) { return thread->usesHwAvSync(); });
Eric Laurentfa90e842014-10-17 18:12:31 -07003026 }
3027}
3028
3029
Glenn Kasten4182c4e2013-07-15 14:45:07 -07003030// ----------------------------------------------------------------------------
3031
Eric Laurent83b88082014-06-20 18:31:16 -07003032
Andy Hung87c693c2023-07-06 20:56:16 -07003033sp<IAfThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t module,
jiabin43810402019-10-24 14:58:31 -07003034 audio_io_handle_t *output,
Eric Laurentf1f22e72021-07-13 14:04:14 +02003035 audio_config_t *halConfig,
Andy Hung920f6572022-10-06 12:09:49 -07003036 audio_config_base_t *mixerConfig,
jiabin43810402019-10-24 14:58:31 -07003037 audio_devices_t deviceType,
3038 const String8& address,
Haofan Wangf6e304f2024-07-09 23:06:58 -07003039 audio_output_flags_t flags,
3040 const audio_attributes_t attributes)
Eric Laurent83b88082014-06-20 18:31:16 -07003041{
jiabin43810402019-10-24 14:58:31 -07003042 AudioHwDevice *outHwDev = findSuitableHwDev_l(module, deviceType);
Eric Laurent83b88082014-06-20 18:31:16 -07003043 if (outHwDev == NULL) {
Eric Laurente28c66d2022-01-21 13:40:41 +01003044 return nullptr;
Eric Laurent83b88082014-06-20 18:31:16 -07003045 }
3046
Eric Laurentcf2c0212014-07-25 16:20:43 -07003047 if (*output == AUDIO_IO_HANDLE_NONE) {
Glenn Kasteneeecb982016-02-26 10:44:04 -08003048 *output = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);
3049 } else {
3050 // Audio Policy does not currently request a specific output handle.
3051 // If this is ever needed, see openInput_l() for example code.
3052 ALOGE("openOutput_l requested output handle %d is not AUDIO_IO_HANDLE_NONE", *output);
Eric Laurente28c66d2022-01-21 13:40:41 +01003053 return nullptr;
Eric Laurentcf2c0212014-07-25 16:20:43 -07003054 }
Eric Laurent83b88082014-06-20 18:31:16 -07003055
3056 mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;
Phil Burk062e67a2015-02-11 13:40:50 -08003057 AudioStreamOut *outputStream = NULL;
Haofan Wangf6e304f2024-07-09 23:06:58 -07003058
3059 playback_track_metadata_v7_t trackMetadata;
3060 trackMetadata.base.usage = attributes.usage;
3061
Phil Burk062e67a2015-02-11 13:40:50 -08003062 status_t status = outHwDev->openOutputStream(
3063 &outputStream,
3064 *output,
jiabin43810402019-10-24 14:58:31 -07003065 deviceType,
Phil Burk062e67a2015-02-11 13:40:50 -08003066 flags,
Eric Laurentf1f22e72021-07-13 14:04:14 +02003067 halConfig,
Haofan Wangf6e304f2024-07-09 23:06:58 -07003068 address.c_str(),
3069 {trackMetadata});
Eric Laurent83b88082014-06-20 18:31:16 -07003070
3071 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent83b88082014-06-20 18:31:16 -07003072
Phil Burk062e67a2015-02-11 13:40:50 -08003073 if (status == NO_ERROR) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08003074 if (flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) {
Andy Hungee58e4a2023-07-07 13:47:37 -07003075 const sp<IAfMmapPlaybackThread> thread = IAfMmapPlaybackThread::create(
3076 this, *output, outHwDev, outputStream, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003077 mMmapThreads.add(*output, thread);
3078 ALOGV("openOutput_l() created mmap playback thread: ID %d thread %p",
3079 *output, thread.get());
3080 return thread;
Eric Laurent83b88082014-06-20 18:31:16 -07003081 } else {
Andy Hung87c693c2023-07-06 20:56:16 -07003082 sp<IAfPlaybackThread> thread;
jiabinc658e452022-10-21 20:52:21 +00003083 if (flags & AUDIO_OUTPUT_FLAG_BIT_PERFECT) {
Andy Hungee58e4a2023-07-07 13:47:37 -07003084 thread = IAfPlaybackThread::createBitPerfectThread(
3085 this, outputStream, *output, mSystemReady);
jiabinc658e452022-10-21 20:52:21 +00003086 ALOGV("%s() created bit-perfect output: ID %d thread %p",
3087 __func__, *output, thread.get());
3088 } else if (flags & AUDIO_OUTPUT_FLAG_SPATIALIZER) {
Andy Hungee58e4a2023-07-07 13:47:37 -07003089 thread = IAfPlaybackThread::createSpatializerThread(this, outputStream, *output,
Eric Laurentb3f315a2021-07-13 15:09:05 +02003090 mSystemReady, mixerConfig);
Eric Laurente28c66d2022-01-21 13:40:41 +01003091 ALOGV("openOutput_l() created spatializer output: ID %d thread %p",
Eric Laurentb3f315a2021-07-13 15:09:05 +02003092 *output, thread.get());
3093 } else if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
Andy Hungee58e4a2023-07-07 13:47:37 -07003094 thread = IAfPlaybackThread::createOffloadThread(this, outputStream, *output,
Gareth Fennb18c1a32022-10-05 13:42:36 -07003095 mSystemReady, halConfig->offload_info);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003096 ALOGV("openOutput_l() created offload output: ID %d thread %p",
3097 *output, thread.get());
3098 } else if ((flags & AUDIO_OUTPUT_FLAG_DIRECT)
Andy Hung81994d62023-07-20 21:44:14 -07003099 || !IAfThreadBase::isValidPcmSinkFormat(halConfig->format)
3100 || !IAfThreadBase::isValidPcmSinkChannelMask(halConfig->channel_mask)) {
Andy Hungee58e4a2023-07-07 13:47:37 -07003101 thread = IAfPlaybackThread::createDirectOutputThread(this, outputStream, *output,
Gareth Fennb18c1a32022-10-05 13:42:36 -07003102 mSystemReady, halConfig->offload_info);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003103 ALOGV("openOutput_l() created direct output: ID %d thread %p",
3104 *output, thread.get());
3105 } else {
Andy Hungee58e4a2023-07-07 13:47:37 -07003106 thread = IAfPlaybackThread::createMixerThread(
3107 this, outputStream, *output, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003108 ALOGV("openOutput_l() created mixer output: ID %d thread %p",
3109 *output, thread.get());
3110 }
3111 mPlaybackThreads.add(*output, thread);
Eric Laurent74c38dc2020-12-23 18:19:44 +01003112 struct audio_patch patch;
Andy Hungb6692eb2023-07-13 16:52:46 -07003113 mPatchPanel->notifyStreamOpened(outHwDev, *output, &patch);
Eric Laurent74c38dc2020-12-23 18:19:44 +01003114 if (thread->isMsdDevice()) {
3115 thread->setDownStreamPatch(&patch);
3116 }
Eric Laurent50d72582022-12-20 20:20:23 +01003117 thread->setBluetoothVariableLatencyEnabled(mBluetoothLatencyModesEnabled.load());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003118 return thread;
Eric Laurent83b88082014-06-20 18:31:16 -07003119 }
Eric Laurent83b88082014-06-20 18:31:16 -07003120 }
3121
Eric Laurente28c66d2022-01-21 13:40:41 +01003122 return nullptr;
Eric Laurent83b88082014-06-20 18:31:16 -07003123}
3124
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08003125status_t AudioFlinger::openOutput(const media::OpenOutputRequest& request,
3126 media::OpenOutputResponse* response)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003127{
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08003128 audio_module_handle_t module = VALUE_OR_RETURN_STATUS(
3129 aidl2legacy_int32_t_audio_module_handle_t(request.module));
Eric Laurentf1f22e72021-07-13 14:04:14 +02003130 audio_config_t halConfig = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -07003131 aidl2legacy_AudioConfig_audio_config_t(request.halConfig, false /*isInput*/));
Eric Laurentf1f22e72021-07-13 14:04:14 +02003132 audio_config_base_t mixerConfig = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -07003133 aidl2legacy_AudioConfigBase_audio_config_base_t(request.mixerConfig, false/*isInput*/));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08003134 sp<DeviceDescriptorBase> device = VALUE_OR_RETURN_STATUS(
3135 aidl2legacy_DeviceDescriptorBase(request.device));
3136 audio_output_flags_t flags = VALUE_OR_RETURN_STATUS(
Andy Hung973638a2020-12-08 20:47:45 -08003137 aidl2legacy_int32_t_audio_output_flags_t_mask(request.flags));
Haofan Wangf6e304f2024-07-09 23:06:58 -07003138 audio_attributes_t attributes = VALUE_OR_RETURN_STATUS(
3139 aidl2legacy_AudioAttributes_audio_attributes_t(request.attributes));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08003140
3141 audio_io_handle_t output;
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08003142
jiabin43810402019-10-24 14:58:31 -07003143 ALOGI("openOutput() this %p, module %d Device %s, SamplingRate %d, Format %#08x, "
Glenn Kasten49f36ba2017-12-06 13:02:02 -08003144 "Channels %#x, flags %#x",
Eric Laurent6acd1d42017-01-04 14:23:29 -08003145 this, module,
jiabin43810402019-10-24 14:58:31 -07003146 device->toString().c_str(),
Eric Laurentf1f22e72021-07-13 14:04:14 +02003147 halConfig.sample_rate,
3148 halConfig.format,
3149 halConfig.channel_mask,
Eric Laurenta4c5a552012-03-29 10:12:40 -07003150 flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003151
jiabin43810402019-10-24 14:58:31 -07003152 audio_devices_t deviceType = device->type();
3153 const String8 address = String8(device->address().c_str());
3154
3155 if (deviceType == AUDIO_DEVICE_NONE) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07003156 return BAD_VALUE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003157 }
Dima Zavin799a70e2011-04-18 16:57:27 -07003158
Andy Hung954b9712023-08-28 18:36:53 -07003159 audio_utils::lock_guard _l(mutex());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003160
Andy Hung87c693c2023-07-06 20:56:16 -07003161 const sp<IAfThreadBase> thread = openOutput_l(module, &output, &halConfig,
Haofan Wangf6e304f2024-07-09 23:06:58 -07003162 &mixerConfig, deviceType, address, flags, attributes);
Eric Laurent83b88082014-06-20 18:31:16 -07003163 if (thread != 0) {
Andy Hung920f6572022-10-06 12:09:49 -07003164 uint32_t latencyMs = 0;
Eric Laurent6acd1d42017-01-04 14:23:29 -08003165 if ((flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) == 0) {
Andy Hung87c693c2023-07-06 20:56:16 -07003166 const auto playbackThread = thread->asIAfPlaybackThread();
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08003167 latencyMs = playbackThread->latency();
Mathias Agopian65ab4712010-07-14 17:59:35 -07003168
Eric Laurent6acd1d42017-01-04 14:23:29 -08003169 // notify client processes of the new output creation
Andy Hungab65b182023-09-06 19:41:47 -07003170 playbackThread->ioConfigChanged_l(AUDIO_OUTPUT_OPENED);
Eric Laurenta4c5a552012-03-29 10:12:40 -07003171
Eric Laurent00abf0d2020-04-22 19:28:22 -07003172 // the first primary output opened designates the primary hw device if no HW module
3173 // named "primary" was already loaded.
Andy Hung954b9712023-08-28 18:36:53 -07003174 audio_utils::lock_guard lock(hardwareMutex());
Eric Laurent00abf0d2020-04-22 19:28:22 -07003175 if ((mPrimaryHardwareDev == nullptr) && (flags & AUDIO_OUTPUT_FLAG_PRIMARY)) {
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08003176 ALOGI("Using module %d as the primary audio interface", module);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003177 mPrimaryHardwareDev = playbackThread->getOutput()->audioHwDev;
Eric Laurenta4c5a552012-03-29 10:12:40 -07003178
Eric Laurent6acd1d42017-01-04 14:23:29 -08003179 mHardwareStatus = AUDIO_HW_SET_MODE;
Andy Hunge3748872023-08-30 19:05:16 -07003180 mPrimaryHardwareDev.load()->hwDevice()->setMode(mMode);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003181 mHardwareStatus = AUDIO_HW_IDLE;
3182 }
3183 } else {
Andy Hungab65b182023-09-06 19:41:47 -07003184 thread->ioConfigChanged_l(AUDIO_OUTPUT_OPENED);
Eric Laurenta4c5a552012-03-29 10:12:40 -07003185 }
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08003186 response->output = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
Mikhail Naganovde3fa182021-07-30 15:06:42 -07003187 response->config = VALUE_OR_RETURN_STATUS(
3188 legacy2aidl_audio_config_t_AudioConfig(halConfig, false /*isInput*/));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08003189 response->latencyMs = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(latencyMs));
Andy Hung973638a2020-12-08 20:47:45 -08003190 response->flags = VALUE_OR_RETURN_STATUS(
3191 legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
Eric Laurentcf2c0212014-07-25 16:20:43 -07003192 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003193 }
3194
Eric Laurentcf2c0212014-07-25 16:20:43 -07003195 return NO_INIT;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003196}
3197
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003198audio_io_handle_t AudioFlinger::openDuplicateOutput(audio_io_handle_t output1,
3199 audio_io_handle_t output2)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003200{
Andy Hung954b9712023-08-28 18:36:53 -07003201 audio_utils::lock_guard _l(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07003202 IAfPlaybackThread* const thread1 = checkMixerThread_l(output1);
3203 IAfPlaybackThread* const thread2 = checkMixerThread_l(output2);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003204
3205 if (thread1 == NULL || thread2 == NULL) {
Glenn Kasten85ab62c2012-11-01 11:11:38 -07003206 ALOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1,
3207 output2);
Glenn Kasten142f5192014-03-25 17:44:59 -07003208 return AUDIO_IO_HANDLE_NONE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003209 }
3210
Glenn Kasteneeecb982016-02-26 10:44:04 -08003211 audio_io_handle_t id = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);
Andy Hungee58e4a2023-07-07 13:47:37 -07003212 const sp<IAfDuplicatingThread> thread = IAfDuplicatingThread::create(
3213 this, thread1, id, mSystemReady);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003214 thread->addOutputTrack(thread2);
3215 mPlaybackThreads.add(id, thread);
3216 // notify client processes of the new output creation
Andy Hungab65b182023-09-06 19:41:47 -07003217 thread->ioConfigChanged_l(AUDIO_OUTPUT_OPENED);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003218 return id;
3219}
3220
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003221status_t AudioFlinger::closeOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003222{
Glenn Kastend96c5722012-04-25 13:44:49 -07003223 return closeOutput_nonvirtual(output);
3224}
3225
3226status_t AudioFlinger::closeOutput_nonvirtual(audio_io_handle_t output)
3227{
Mathias Agopian65ab4712010-07-14 17:59:35 -07003228 // keep strong reference on the playback thread so that
3229 // it is not destroyed while exit() is executed
Andy Hung87c693c2023-07-06 20:56:16 -07003230 sp<IAfPlaybackThread> playbackThread;
Andy Hung7aa7d102023-07-07 15:58:48 -07003231 sp<IAfMmapPlaybackThread> mmapThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003232 {
Andy Hung954b9712023-08-28 18:36:53 -07003233 audio_utils::lock_guard _l(mutex());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003234 playbackThread = checkPlaybackThread_l(output);
3235 if (playbackThread != NULL) {
3236 ALOGV("closeOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003237
Andy Hungdc099c22018-09-18 13:46:39 -07003238 dumpToThreadLog_l(playbackThread);
Andy Hunga8115dc2018-08-24 15:51:59 -07003239
Andy Hung87c693c2023-07-06 20:56:16 -07003240 if (playbackThread->type() == IAfThreadBase::MIXER) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08003241 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3242 if (mPlaybackThreads.valueAt(i)->isDuplicating()) {
Andy Hung87c693c2023-07-06 20:56:16 -07003243 IAfDuplicatingThread* const dupThread =
3244 mPlaybackThreads.valueAt(i)->asIAfDuplicatingThread().get();
3245 dupThread->removeOutputTrack(playbackThread.get());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003246 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003247 }
3248 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003249
3250
Eric Laurent6acd1d42017-01-04 14:23:29 -08003251 mPlaybackThreads.removeItem(output);
Shunkai Yao517fc2a2024-03-19 04:31:47 +00003252 // Save AUDIO_SESSION_OUTPUT_MIX effect to orphan chains
3253 // Output Mix Effect session is used to manage Music Effect by AudioPolicy Manager.
3254 // It exists across all playback threads.
3255 if (playbackThread->type() == IAfThreadBase::MIXER
3256 || playbackThread->type() == IAfThreadBase::OFFLOAD
3257 || playbackThread->type() == IAfThreadBase::SPATIALIZER) {
3258 sp<IAfEffectChain> mixChain;
3259 {
3260 audio_utils::scoped_lock sl(playbackThread->mutex());
3261 mixChain = playbackThread->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
3262 if (mixChain != nullptr) {
3263 ALOGW("%s() output %d moving mix session to orphans", __func__, output);
3264 playbackThread->removeEffectChain_l(mixChain);
3265 }
3266 }
3267 if (mixChain != nullptr) {
3268 putOrphanEffectChain_l(mixChain);
3269 }
3270 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003271 // save all effects to the default thread
3272 if (mPlaybackThreads.size()) {
Andy Hung87c693c2023-07-06 20:56:16 -07003273 IAfPlaybackThread* const dstThread =
3274 checkPlaybackThread_l(mPlaybackThreads.keyAt(0));
Eric Laurent6acd1d42017-01-04 14:23:29 -08003275 if (dstThread != NULL) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08003276 // audioflinger lock is held so order of thread lock acquisition doesn't matter
Andy Hunge0f5ec52023-08-30 11:26:06 -07003277 // Use scoped_lock to avoid deadlock order issues with duplicating threads.
3278 audio_utils::scoped_lock sl(dstThread->mutex(), playbackThread->mutex());
Andy Hung6ac17eb2023-06-20 18:56:17 -07003279 Vector<sp<IAfEffectChain>> effectChains = playbackThread->getEffectChains_l();
Eric Laurent6acd1d42017-01-04 14:23:29 -08003280 for (size_t i = 0; i < effectChains.size(); i ++) {
Andy Hung972bec12023-08-31 16:13:39 -07003281 moveEffectChain_ll(effectChains[i]->sessionId(), playbackThread.get(),
Eric Laurent6c796322019-04-09 14:13:17 -07003282 dstThread);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003283 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003284 }
3285 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003286 } else {
Andy Hung7aa7d102023-07-07 15:58:48 -07003287 const sp<IAfMmapThread> mt = checkMmapThread_l(output);
3288 mmapThread = mt ? mt->asIAfMmapPlaybackThread().get() : nullptr;
Eric Laurent6acd1d42017-01-04 14:23:29 -08003289 if (mmapThread == 0) {
3290 return BAD_VALUE;
3291 }
Andy Hungdc099c22018-09-18 13:46:39 -07003292 dumpToThreadLog_l(mmapThread);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003293 mMmapThreads.removeItem(output);
Phil Burk7f6b40d2017-02-09 13:18:38 -08003294 ALOGD("closing mmapThread %p", mmapThread.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003295 }
Andy Hungab65b182023-09-06 19:41:47 -07003296 ioConfigChanged_l(AUDIO_OUTPUT_CLOSED, sp<AudioIoDescriptor>::make(output));
Andy Hungb6692eb2023-07-13 16:52:46 -07003297 mPatchPanel->notifyStreamClosed(output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003298 }
Glenn Kastenb28686f2012-01-06 08:39:38 -08003299 // The thread entity (active unit of execution) is no longer running here,
Andy Hung87c693c2023-07-06 20:56:16 -07003300 // but the IAfThreadBase container still exists.
Mathias Agopian65ab4712010-07-14 17:59:35 -07003301
Eric Laurent6acd1d42017-01-04 14:23:29 -08003302 if (playbackThread != 0) {
3303 playbackThread->exit();
3304 if (!playbackThread->isDuplicating()) {
3305 closeOutputFinish(playbackThread);
3306 }
3307 } else if (mmapThread != 0) {
Phil Burk7f6b40d2017-02-09 13:18:38 -08003308 ALOGD("mmapThread exit()");
Eric Laurent6acd1d42017-01-04 14:23:29 -08003309 mmapThread->exit();
3310 AudioStreamOut *out = mmapThread->clearOutput();
3311 ALOG_ASSERT(out != NULL, "out shouldn't be NULL");
3312 // from now on thread->mOutput is NULL
3313 delete out;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003314 }
3315 return NO_ERROR;
3316}
3317
Andy Hungc2cf7ec2023-08-30 18:19:00 -07003318/* static */
Andy Hung87c693c2023-07-06 20:56:16 -07003319void AudioFlinger::closeOutputFinish(const sp<IAfPlaybackThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07003320{
3321 AudioStreamOut *out = thread->clearOutput();
3322 ALOG_ASSERT(out != NULL, "out shouldn't be NULL");
3323 // from now on thread->mOutput is NULL
Eric Laurent83b88082014-06-20 18:31:16 -07003324 delete out;
3325}
3326
Andy Hung87c693c2023-07-06 20:56:16 -07003327void AudioFlinger::closeThreadInternal_l(const sp<IAfPlaybackThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07003328{
Andy Hung87c693c2023-07-06 20:56:16 -07003329 mPlaybackThreads.removeItem(thread->id());
Eric Laurent83b88082014-06-20 18:31:16 -07003330 thread->exit();
3331 closeOutputFinish(thread);
3332}
3333
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003334status_t AudioFlinger::suspendOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003335{
Andy Hung954b9712023-08-28 18:36:53 -07003336 audio_utils::lock_guard _l(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07003337 IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003338
3339 if (thread == NULL) {
3340 return BAD_VALUE;
3341 }
3342
Steve Block3856b092011-10-20 11:56:00 +01003343 ALOGV("suspendOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003344 thread->suspend();
3345
3346 return NO_ERROR;
3347}
3348
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003349status_t AudioFlinger::restoreOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003350{
Andy Hung954b9712023-08-28 18:36:53 -07003351 audio_utils::lock_guard _l(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07003352 IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003353
3354 if (thread == NULL) {
3355 return BAD_VALUE;
3356 }
3357
Steve Block3856b092011-10-20 11:56:00 +01003358 ALOGV("restoreOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003359
3360 thread->restore();
3361
3362 return NO_ERROR;
3363}
3364
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003365status_t AudioFlinger::openInput(const media::OpenInputRequest& request,
3366 media::OpenInputResponse* response)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003367{
Andy Hung954b9712023-08-28 18:36:53 -07003368 audio_utils::lock_guard _l(mutex());
Eric Laurent83b88082014-06-20 18:31:16 -07003369
Mikhail Naganov21a32ec2021-07-08 14:40:12 -07003370 AudioDeviceTypeAddr device = VALUE_OR_RETURN_STATUS(
3371 aidl2legacy_AudioDeviceTypeAddress(request.device));
3372 if (device.mType == AUDIO_DEVICE_NONE) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07003373 return BAD_VALUE;
Eric Laurent83b88082014-06-20 18:31:16 -07003374 }
3375
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003376 audio_io_handle_t input = VALUE_OR_RETURN_STATUS(
3377 aidl2legacy_int32_t_audio_io_handle_t(request.input));
3378 audio_config_t config = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -07003379 aidl2legacy_AudioConfig_audio_config_t(request.config, true /*isInput*/));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003380
Andy Hung87c693c2023-07-06 20:56:16 -07003381 const sp<IAfThreadBase> thread = openInput_l(
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003382 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_module_handle_t(request.module)),
3383 &input,
3384 &config,
3385 device.mType,
3386 device.address().c_str(),
Mikhail Naganovddceecc2021-09-03 13:58:56 -07003387 VALUE_OR_RETURN_STATUS(aidl2legacy_AudioSource_audio_source_t(request.source)),
Andy Hung973638a2020-12-08 20:47:45 -08003388 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_input_flags_t_mask(request.flags)),
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003389 AUDIO_DEVICE_NONE,
3390 String8{});
3391
3392 response->input = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(input));
Mikhail Naganovde3fa182021-07-30 15:06:42 -07003393 response->config = VALUE_OR_RETURN_STATUS(
3394 legacy2aidl_audio_config_t_AudioConfig(config, true /*isInput*/));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003395 response->device = request.device;
Eric Laurent83b88082014-06-20 18:31:16 -07003396
3397 if (thread != 0) {
Eric Laurent83b88082014-06-20 18:31:16 -07003398 // notify client processes of the new input creation
Andy Hungab65b182023-09-06 19:41:47 -07003399 thread->ioConfigChanged_l(AUDIO_INPUT_OPENED);
Eric Laurentcf2c0212014-07-25 16:20:43 -07003400 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003401 }
Eric Laurentcf2c0212014-07-25 16:20:43 -07003402 return NO_INIT;
Eric Laurent83b88082014-06-20 18:31:16 -07003403}
Dima Zavin799a70e2011-04-18 16:57:27 -07003404
Andy Hung87c693c2023-07-06 20:56:16 -07003405sp<IAfThreadBase> AudioFlinger::openInput_l(audio_module_handle_t module,
Eric Laurentcf2c0212014-07-25 16:20:43 -07003406 audio_io_handle_t *input,
3407 audio_config_t *config,
Glenn Kastene7d66712015-03-05 13:46:52 -08003408 audio_devices_t devices,
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003409 const char* address,
Eric Laurentcf2c0212014-07-25 16:20:43 -07003410 audio_source_t source,
Mikhail Naganovb4e037e2019-01-14 15:56:33 -08003411 audio_input_flags_t flags,
3412 audio_devices_t outputDevice,
3413 const String8& outputDeviceAddress)
Eric Laurent83b88082014-06-20 18:31:16 -07003414{
Glenn Kastene7d66712015-03-05 13:46:52 -08003415 AudioHwDevice *inHwDev = findSuitableHwDev_l(module, devices);
Glenn Kasten6e2ebe92013-08-13 09:14:51 -07003416 if (inHwDev == NULL) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07003417 *input = AUDIO_IO_HANDLE_NONE;
Dima Zavin799a70e2011-04-18 16:57:27 -07003418 return 0;
Glenn Kasten6e2ebe92013-08-13 09:14:51 -07003419 }
Dima Zavin799a70e2011-04-18 16:57:27 -07003420
Glenn Kasteneeecb982016-02-26 10:44:04 -08003421 // Audio Policy can request a specific handle for hardware hotword.
3422 // The goal here is not to re-open an already opened input.
3423 // It is to use a pre-assigned I/O handle.
Eric Laurentcf2c0212014-07-25 16:20:43 -07003424 if (*input == AUDIO_IO_HANDLE_NONE) {
Glenn Kasteneeecb982016-02-26 10:44:04 -08003425 *input = nextUniqueId(AUDIO_UNIQUE_ID_USE_INPUT);
3426 } else if (audio_unique_id_get_use(*input) != AUDIO_UNIQUE_ID_USE_INPUT) {
3427 ALOGE("openInput_l() requested input handle %d is invalid", *input);
3428 return 0;
3429 } else if (mRecordThreads.indexOfKey(*input) >= 0) {
3430 // This should not happen in a transient state with current design.
3431 ALOGE("openInput_l() requested input handle %d is already assigned", *input);
3432 return 0;
Eric Laurentcf2c0212014-07-25 16:20:43 -07003433 }
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07003434
Dean Wheatley6c009512023-10-23 09:34:14 +11003435 AudioStreamIn *inputStream = nullptr;
3436 status_t status = inHwDev->openInputStream(
3437 &inputStream,
3438 *input,
Mikhail Naganovf558e022016-11-14 17:45:17 -08003439 devices,
Glenn Kastenec40d282014-07-15 15:31:26 -07003440 flags,
Dean Wheatley6c009512023-10-23 09:34:14 +11003441 config,
3442 address,
3443 source,
3444 outputDevice,
3445 outputDeviceAddress.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003446
Dean Wheatley6c009512023-10-23 09:34:14 +11003447 if (status == NO_ERROR) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08003448 if ((flags & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0) {
Andy Hung7aa7d102023-07-07 15:58:48 -07003449 const sp<IAfMmapCaptureThread> thread =
Andy Hungee58e4a2023-07-07 13:47:37 -07003450 IAfMmapCaptureThread::create(this, *input, inHwDev, inputStream, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003451 mMmapThreads.add(*input, thread);
Glenn Kastend3bb6452016-12-05 18:14:37 -08003452 ALOGV("openInput_l() created mmap capture thread: ID %d thread %p", *input,
3453 thread.get());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003454 return thread;
3455 } else {
Eric Laurent6acd1d42017-01-04 14:23:29 -08003456 // Start record thread
Andy Hung87c693c2023-07-06 20:56:16 -07003457 // IAfRecordThread requires both input and output device indication
3458 // to forward to audio pre processing modules
3459 const sp<IAfRecordThread> thread =
3460 IAfRecordThread::create(this, inputStream, *input, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003461 mRecordThreads.add(*input, thread);
3462 ALOGV("openInput_l() created record thread: ID %d thread %p", *input, thread.get());
3463 return thread;
3464 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003465 }
3466
Eric Laurentcf2c0212014-07-25 16:20:43 -07003467 *input = AUDIO_IO_HANDLE_NONE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003468 return 0;
3469}
3470
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003471status_t AudioFlinger::closeInput(audio_io_handle_t input)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003472{
Glenn Kastend96c5722012-04-25 13:44:49 -07003473 return closeInput_nonvirtual(input);
3474}
3475
3476status_t AudioFlinger::closeInput_nonvirtual(audio_io_handle_t input)
3477{
Mathias Agopian65ab4712010-07-14 17:59:35 -07003478 // keep strong reference on the record thread so that
3479 // it is not destroyed while exit() is executed
Andy Hung87c693c2023-07-06 20:56:16 -07003480 sp<IAfRecordThread> recordThread;
Andy Hung7aa7d102023-07-07 15:58:48 -07003481 sp<IAfMmapCaptureThread> mmapThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003482 {
Andy Hung954b9712023-08-28 18:36:53 -07003483 audio_utils::lock_guard _l(mutex());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003484 recordThread = checkRecordThread_l(input);
3485 if (recordThread != 0) {
3486 ALOGV("closeInput() %d", input);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003487
Andy Hungdc099c22018-09-18 13:46:39 -07003488 dumpToThreadLog_l(recordThread);
Andy Hung0264e7d2018-09-17 19:30:46 -07003489
Eric Laurent6acd1d42017-01-04 14:23:29 -08003490 // If we still have effect chains, it means that a client still holds a handle
3491 // on at least one effect. We must either move the chain to an existing thread with the
3492 // same session ID or put it aside in case a new record thread is opened for a
3493 // new capture on the same session
Andy Hung6ac17eb2023-06-20 18:56:17 -07003494 sp<IAfEffectChain> chain;
Eric Laurent6acd1d42017-01-04 14:23:29 -08003495 {
Andy Hungc5007f82023-08-29 14:26:09 -07003496 audio_utils::lock_guard _sl(recordThread->mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07003497 const Vector<sp<IAfEffectChain>> effectChains = recordThread->getEffectChains_l();
Eric Laurent6acd1d42017-01-04 14:23:29 -08003498 // Note: maximum one chain per record thread
3499 if (effectChains.size() != 0) {
3500 chain = effectChains[0];
Eric Laurent1b928682014-10-02 19:41:47 -07003501 }
3502 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003503 if (chain != 0) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08003504 // first check if a record thread is already opened with a client on same session.
Eric Laurent6acd1d42017-01-04 14:23:29 -08003505 // This should only happen in case of overlap between one thread tear down and the
3506 // creation of its replacement
3507 size_t i;
3508 for (i = 0; i < mRecordThreads.size(); i++) {
Andy Hung87c693c2023-07-06 20:56:16 -07003509 const sp<IAfRecordThread> t = mRecordThreads.valueAt(i);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003510 if (t == recordThread) {
3511 continue;
3512 }
3513 if (t->hasAudioSession(chain->sessionId()) != 0) {
Andy Hungc5007f82023-08-29 14:26:09 -07003514 audio_utils::lock_guard _l2(t->mutex());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003515 ALOGV("closeInput() found thread %d for effect session %d",
3516 t->id(), chain->sessionId());
3517 t->addEffectChain_l(chain);
3518 break;
3519 }
3520 }
Glenn Kastend3bb6452016-12-05 18:14:37 -08003521 // put the chain aside if we could not find a record thread with the same session id
Eric Laurent6acd1d42017-01-04 14:23:29 -08003522 if (i == mRecordThreads.size()) {
3523 putOrphanEffectChain_l(chain);
3524 }
Eric Laurentaaa44472014-09-12 17:41:50 -07003525 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003526 mRecordThreads.removeItem(input);
3527 } else {
Andy Hung7aa7d102023-07-07 15:58:48 -07003528 const sp<IAfMmapThread> mt = checkMmapThread_l(input);
3529 mmapThread = mt ? mt->asIAfMmapCaptureThread().get() : nullptr;
Eric Laurent6acd1d42017-01-04 14:23:29 -08003530 if (mmapThread == 0) {
3531 return BAD_VALUE;
3532 }
Andy Hungdc099c22018-09-18 13:46:39 -07003533 dumpToThreadLog_l(mmapThread);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003534 mMmapThreads.removeItem(input);
Eric Laurentaaa44472014-09-12 17:41:50 -07003535 }
Andy Hungab65b182023-09-06 19:41:47 -07003536 ioConfigChanged_l(AUDIO_INPUT_CLOSED, sp<AudioIoDescriptor>::make(input));
Mathias Agopian65ab4712010-07-14 17:59:35 -07003537 }
Andy Hung954b9712023-08-28 18:36:53 -07003538 // FIXME: calling thread->exit() without mutex() held should not be needed anymore now that
Eric Laurent83b88082014-06-20 18:31:16 -07003539 // we have a different lock for notification client
Eric Laurent6acd1d42017-01-04 14:23:29 -08003540 if (recordThread != 0) {
3541 closeInputFinish(recordThread);
3542 } else if (mmapThread != 0) {
3543 mmapThread->exit();
3544 AudioStreamIn *in = mmapThread->clearInput();
3545 ALOG_ASSERT(in != NULL, "in shouldn't be NULL");
3546 // from now on thread->mInput is NULL
3547 delete in;
3548 }
Eric Laurent83b88082014-06-20 18:31:16 -07003549 return NO_ERROR;
3550}
Mathias Agopian65ab4712010-07-14 17:59:35 -07003551
Andy Hung87c693c2023-07-06 20:56:16 -07003552void AudioFlinger::closeInputFinish(const sp<IAfRecordThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07003553{
3554 thread->exit();
Eric Laurentb8ba0a92011-08-07 16:32:26 -07003555 AudioStreamIn *in = thread->clearInput();
Glenn Kasten5798d4e2012-03-08 12:18:35 -08003556 ALOG_ASSERT(in != NULL, "in shouldn't be NULL");
Eric Laurentb8ba0a92011-08-07 16:32:26 -07003557 // from now on thread->mInput is NULL
Dima Zavin799a70e2011-04-18 16:57:27 -07003558 delete in;
Eric Laurent83b88082014-06-20 18:31:16 -07003559}
Mathias Agopian65ab4712010-07-14 17:59:35 -07003560
Andy Hung87c693c2023-07-06 20:56:16 -07003561void AudioFlinger::closeThreadInternal_l(const sp<IAfRecordThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07003562{
Andy Hung87c693c2023-07-06 20:56:16 -07003563 mRecordThreads.removeItem(thread->id());
Eric Laurent83b88082014-06-20 18:31:16 -07003564 closeInputFinish(thread);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003565}
3566
jiabinc44b3462022-12-08 12:52:31 -08003567status_t AudioFlinger::invalidateTracks(const std::vector<audio_port_handle_t> &portIds) {
Andy Hung954b9712023-08-28 18:36:53 -07003568 audio_utils::lock_guard _l(mutex());
jiabinc44b3462022-12-08 12:52:31 -08003569 ALOGV("%s", __func__);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003570
jiabinc44b3462022-12-08 12:52:31 -08003571 std::set<audio_port_handle_t> portIdSet(portIds.begin(), portIds.end());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003572 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Andy Hung87c693c2023-07-06 20:56:16 -07003573 IAfPlaybackThread* const thread = mPlaybackThreads.valueAt(i).get();
jiabinc44b3462022-12-08 12:52:31 -08003574 thread->invalidateTracks(portIdSet);
3575 if (portIdSet.empty()) {
3576 return NO_ERROR;
3577 }
Eric Laurentde070132010-07-13 04:45:46 -07003578 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003579 for (size_t i = 0; i < mMmapThreads.size(); i++) {
jiabinc44b3462022-12-08 12:52:31 -08003580 mMmapThreads[i]->invalidateTracks(portIdSet);
3581 if (portIdSet.empty()) {
3582 return NO_ERROR;
3583 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003584 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003585 return NO_ERROR;
3586}
3587
3588
Glenn Kasteneeecb982016-02-26 10:44:04 -08003589audio_unique_id_t AudioFlinger::newAudioUniqueId(audio_unique_id_use_t use)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003590{
Glenn Kasten9d003132016-04-06 14:38:09 -07003591 // This is a binder API, so a malicious client could pass in a bad parameter.
3592 // Check for that before calling the internal API nextUniqueId().
3593 if ((unsigned) use >= (unsigned) AUDIO_UNIQUE_ID_USE_MAX) {
3594 ALOGE("newAudioUniqueId invalid use %d", use);
3595 return AUDIO_UNIQUE_ID_ALLOCATE;
3596 }
Glenn Kasteneeecb982016-02-26 10:44:04 -08003597 return nextUniqueId(use);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003598}
3599
Andy Hung8b0bfd92019-12-23 13:11:11 -08003600void AudioFlinger::acquireAudioSessionId(
3601 audio_session_t audioSession, pid_t pid, uid_t uid)
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003602{
Andy Hung954b9712023-08-28 18:36:53 -07003603 audio_utils::lock_guard _l(mutex());
Glenn Kastenbb001922012-02-03 11:10:26 -08003604 pid_t caller = IPCThreadState::self()->getCallingPid();
Marco Nelissend457c972014-02-11 08:47:07 -08003605 ALOGV("acquiring %d from %d, for %d", audioSession, caller, pid);
Andy Hung4ef19fa2018-05-15 19:35:29 -07003606 const uid_t callerUid = IPCThreadState::self()->getCallingUid();
Andy Hung8b0bfd92019-12-23 13:11:11 -08003607 if (pid != (pid_t)-1 && isAudioServerOrMediaServerUid(callerUid)) {
3608 caller = pid; // check must match releaseAudioSessionId()
3609 }
3610 if (uid == (uid_t)-1 || !isAudioServerOrMediaServerUid(callerUid)) {
3611 uid = callerUid;
Marco Nelissend457c972014-02-11 08:47:07 -08003612 }
Eric Laurentd1b28d42013-09-18 18:47:13 -07003613
Eric Laurent021cf962014-05-13 10:18:14 -07003614 {
Andy Hung954b9712023-08-28 18:36:53 -07003615 audio_utils::lock_guard _cl(clientMutex());
Eric Laurent021cf962014-05-13 10:18:14 -07003616 // Ignore requests received from processes not known as notification client. The request
3617 // is likely proxied by mediaserver (e.g CameraService) and releaseAudioSessionId() can be
3618 // called from a different pid leaving a stale session reference. Also we don't know how
3619 // to clear this reference if the client process dies.
Andy Hung05b0ffe2024-08-30 17:18:37 -07003620 if (mNotificationClients.count(caller) == 0) {
Eric Laurent021cf962014-05-13 10:18:14 -07003621 ALOGW("acquireAudioSessionId() unknown client %d for session %d", caller, audioSession);
3622 return;
3623 }
Eric Laurentd1b28d42013-09-18 18:47:13 -07003624 }
3625
Glenn Kasten8d6a2442012-02-08 14:04:28 -08003626 size_t num = mAudioSessionRefs.size();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08003627 for (size_t i = 0; i < num; i++) {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003628 AudioSessionRef *ref = mAudioSessionRefs.editItemAt(i);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08003629 if (ref->mSessionid == audioSession && ref->mPid == caller) {
3630 ref->mCnt++;
3631 ALOGV(" incremented refcount to %d", ref->mCnt);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003632 return;
3633 }
3634 }
Andy Hung8b0bfd92019-12-23 13:11:11 -08003635 mAudioSessionRefs.push(new AudioSessionRef(audioSession, caller, uid));
Glenn Kasten84afa3b2012-01-25 15:28:08 -08003636 ALOGV(" added new entry for %d", audioSession);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003637}
3638
Glenn Kastend848eb42016-03-08 13:42:11 -08003639void AudioFlinger::releaseAudioSessionId(audio_session_t audioSession, pid_t pid)
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003640{
Andy Hung6ac17eb2023-06-20 18:56:17 -07003641 std::vector<sp<IAfEffectModule>> removedEffects;
Eric Laurent6c796322019-04-09 14:13:17 -07003642 {
Andy Hung954b9712023-08-28 18:36:53 -07003643 audio_utils::lock_guard _l(mutex());
Eric Laurent6c796322019-04-09 14:13:17 -07003644 pid_t caller = IPCThreadState::self()->getCallingPid();
3645 ALOGV("releasing %d from %d for %d", audioSession, caller, pid);
3646 const uid_t callerUid = IPCThreadState::self()->getCallingUid();
Andy Hung8b0bfd92019-12-23 13:11:11 -08003647 if (pid != (pid_t)-1 && isAudioServerOrMediaServerUid(callerUid)) {
3648 caller = pid; // check must match acquireAudioSessionId()
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003649 }
Eric Laurent6c796322019-04-09 14:13:17 -07003650 size_t num = mAudioSessionRefs.size();
3651 for (size_t i = 0; i < num; i++) {
3652 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
3653 if (ref->mSessionid == audioSession && ref->mPid == caller) {
3654 ref->mCnt--;
3655 ALOGV(" decremented refcount to %d", ref->mCnt);
3656 if (ref->mCnt == 0) {
3657 mAudioSessionRefs.removeAt(i);
3658 delete ref;
Andy Hung6ac17eb2023-06-20 18:56:17 -07003659 std::vector<sp<IAfEffectModule>> effects = purgeStaleEffects_l();
Eric Laurent6c796322019-04-09 14:13:17 -07003660 removedEffects.insert(removedEffects.end(), effects.begin(), effects.end());
3661 }
3662 goto Exit;
3663 }
3664 }
3665 // If the caller is audioserver it is likely that the session being released was acquired
3666 // on behalf of a process not in notification clients and we ignore the warning.
3667 ALOGW_IF(!isAudioServerUid(callerUid),
3668 "session id %d not found for pid %d", audioSession, caller);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003669 }
Eric Laurent6c796322019-04-09 14:13:17 -07003670
3671Exit:
3672 for (auto& effect : removedEffects) {
3673 effect->updatePolicyState();
3674 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003675}
3676
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08003677bool AudioFlinger::isSessionAcquired_l(audio_session_t audioSession)
3678{
3679 size_t num = mAudioSessionRefs.size();
3680 for (size_t i = 0; i < num; i++) {
3681 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
3682 if (ref->mSessionid == audioSession) {
3683 return true;
3684 }
3685 }
3686 return false;
3687}
3688
Andy Hung6ac17eb2023-06-20 18:56:17 -07003689std::vector<sp<IAfEffectModule>> AudioFlinger::purgeStaleEffects_l() {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003690
Steve Block3856b092011-10-20 11:56:00 +01003691 ALOGV("purging stale effects");
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003692
Andy Hung87c693c2023-07-06 20:56:16 -07003693 Vector<sp<IAfEffectChain>> chains;
Andy Hung6ac17eb2023-06-20 18:56:17 -07003694 std::vector< sp<IAfEffectModule> > removedEffects;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003695
3696 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Andy Hung87c693c2023-07-06 20:56:16 -07003697 sp<IAfPlaybackThread> t = mPlaybackThreads.valueAt(i);
Andy Hungc5007f82023-08-29 14:26:09 -07003698 audio_utils::lock_guard _l(t->mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07003699 const Vector<sp<IAfEffectChain>> threadChains = t->getEffectChains_l();
3700 for (size_t j = 0; j < threadChains.size(); j++) {
3701 sp<IAfEffectChain> ec = threadChains[j];
Eric Laurent3f75a5b2019-11-12 15:55:51 -08003702 if (!audio_is_global_session(ec->sessionId())) {
Marco Nelissen0270b182011-08-12 14:14:39 -07003703 chains.push(ec);
3704 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003705 }
3706 }
Eric Laurent6c796322019-04-09 14:13:17 -07003707
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003708 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Andy Hung87c693c2023-07-06 20:56:16 -07003709 sp<IAfRecordThread> t = mRecordThreads.valueAt(i);
Andy Hungc5007f82023-08-29 14:26:09 -07003710 audio_utils::lock_guard _l(t->mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07003711 const Vector<sp<IAfEffectChain>> threadChains = t->getEffectChains_l();
3712 for (size_t j = 0; j < threadChains.size(); j++) {
3713 sp<IAfEffectChain> ec = threadChains[j];
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003714 chains.push(ec);
3715 }
3716 }
3717
Eric Laurent6c796322019-04-09 14:13:17 -07003718 for (size_t i = 0; i < mMmapThreads.size(); i++) {
Andy Hung7aa7d102023-07-07 15:58:48 -07003719 const sp<IAfMmapThread> t = mMmapThreads.valueAt(i);
Andy Hungc5007f82023-08-29 14:26:09 -07003720 audio_utils::lock_guard _l(t->mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07003721 const Vector<sp<IAfEffectChain>> threadChains = t->getEffectChains_l();
3722 for (size_t j = 0; j < threadChains.size(); j++) {
3723 sp<IAfEffectChain> ec = threadChains[j];
Eric Laurent6c796322019-04-09 14:13:17 -07003724 chains.push(ec);
3725 }
3726 }
3727
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003728 for (size_t i = 0; i < chains.size(); i++) {
Andy Hung920f6572022-10-06 12:09:49 -07003729 // clang-tidy suggests const ref
Andy Hung6ac17eb2023-06-20 18:56:17 -07003730 sp<IAfEffectChain> ec = chains[i]; // NOLINT(performance-unnecessary-copy-initialization)
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003731 int sessionid = ec->sessionId();
Andy Hung99b1ba62023-07-14 11:00:08 -07003732 const auto t = ec->thread().promote();
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003733 if (t == 0) {
3734 continue;
3735 }
3736 size_t numsessionrefs = mAudioSessionRefs.size();
3737 bool found = false;
3738 for (size_t k = 0; k < numsessionrefs; k++) {
3739 AudioSessionRef *ref = mAudioSessionRefs.itemAt(k);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08003740 if (ref->mSessionid == sessionid) {
Steve Block3856b092011-10-20 11:56:00 +01003741 ALOGV(" session %d still exists for %d with %d refs",
Glenn Kastene53b9ea2012-03-12 16:29:55 -07003742 sessionid, ref->mPid, ref->mCnt);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003743 found = true;
3744 break;
3745 }
3746 }
3747 if (!found) {
Andy Hungc5007f82023-08-29 14:26:09 -07003748 audio_utils::lock_guard _l(t->mutex());
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003749 // remove all effects from the chain
Andy Hung6ac17eb2023-06-20 18:56:17 -07003750 while (ec->numberOfEffects()) {
3751 sp<IAfEffectModule> effect = ec->getEffectModule(0);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003752 effect->unPin();
Mikhail Naganov424c4f52017-07-19 17:54:29 -07003753 t->removeEffect_l(effect, /*release*/ true);
Eric Laurenta5f44eb2012-06-25 11:38:29 -07003754 if (effect->purgeHandles()) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08003755 effect->checkSuspendOnEffectEnabled(false, true /*threadLocked*/);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003756 }
Eric Laurent6c796322019-04-09 14:13:17 -07003757 removedEffects.push_back(effect);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003758 }
3759 }
3760 }
Eric Laurent6c796322019-04-09 14:13:17 -07003761 return removedEffects;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003762}
3763
François Gaffie1b4753e2023-02-06 10:36:33 +01003764std::vector< sp<IAfEffectModule> > AudioFlinger::purgeOrphanEffectChains_l()
3765{
3766 ALOGV("purging stale effects from orphan chains");
3767 std::vector< sp<IAfEffectModule> > removedEffects;
3768 for (size_t index = 0; index < mOrphanEffectChains.size(); index++) {
3769 sp<IAfEffectChain> chain = mOrphanEffectChains.valueAt(index);
3770 audio_session_t session = mOrphanEffectChains.keyAt(index);
3771 if (session == AUDIO_SESSION_OUTPUT_MIX || session == AUDIO_SESSION_DEVICE
3772 || session == AUDIO_SESSION_OUTPUT_STAGE) {
3773 continue;
3774 }
3775 size_t numSessionRefs = mAudioSessionRefs.size();
3776 bool found = false;
3777 for (size_t k = 0; k < numSessionRefs; k++) {
3778 AudioSessionRef *ref = mAudioSessionRefs.itemAt(k);
3779 if (ref->mSessionid == session) {
3780 ALOGV(" session %d still exists for %d with %d refs", session, ref->mPid,
3781 ref->mCnt);
3782 found = true;
3783 break;
3784 }
3785 }
3786 if (!found) {
3787 for (size_t i = 0; i < chain->numberOfEffects(); i++) {
3788 sp<IAfEffectModule> effect = chain->getEffectModule(i);
3789 removedEffects.push_back(effect);
3790 }
3791 }
3792 }
3793 for (auto& effect : removedEffects) {
3794 effect->unPin();
3795 updateOrphanEffectChains_l(effect);
3796 }
3797 return removedEffects;
3798}
3799
Andy Hung954b9712023-08-28 18:36:53 -07003800// dumpToThreadLog_l() must be called with AudioFlinger::mutex() held
Andy Hung87c693c2023-07-06 20:56:16 -07003801void AudioFlinger::dumpToThreadLog_l(const sp<IAfThreadBase> &thread)
Andy Hungdc099c22018-09-18 13:46:39 -07003802{
Jaideep Sharma330845f2020-10-22 12:14:58 +05303803 constexpr int THREAD_DUMP_TIMEOUT_MS = 2;
Atneya Nair50ffdd12023-12-05 20:42:35 -08003804 constexpr auto PREFIX = "- ";
3805 if (com::android::media::audioserver::fdtostring_timeout_fix()) {
3806 using ::android::audio_utils::FdToString;
3807
3808 auto writer = OR_RETURN(FdToString::createWriter(PREFIX));
3809 thread->dump(writer.borrowFdUnsafe(), {} /* args */);
3810 mThreadLog.logs(-1 /* time */, FdToString::closeWriterAndGetString(std::move(writer)));
3811 } else {
3812 audio_utils::FdToStringOldImpl fdToString("- ", THREAD_DUMP_TIMEOUT_MS);
3813 const int fd = fdToString.borrowFdUnsafe();
3814 if (fd >= 0) {
3815 thread->dump(fd, {} /* args */);
3816 mThreadLog.logs(-1 /* time */, fdToString.closeAndGetString());
3817 }
Andy Hungdc099c22018-09-18 13:46:39 -07003818 }
3819}
3820
Andy Hung954b9712023-08-28 18:36:53 -07003821// checkThread_l() must be called with AudioFlinger::mutex() held
Andy Hung87c693c2023-07-06 20:56:16 -07003822IAfThreadBase* AudioFlinger::checkThread_l(audio_io_handle_t ioHandle) const
Glenn Kasteneeecb982016-02-26 10:44:04 -08003823{
Andy Hung87c693c2023-07-06 20:56:16 -07003824 IAfThreadBase* thread = checkMmapThread_l(ioHandle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003825 if (thread == 0) {
3826 switch (audio_unique_id_get_use(ioHandle)) {
3827 case AUDIO_UNIQUE_ID_USE_OUTPUT:
3828 thread = checkPlaybackThread_l(ioHandle);
3829 break;
3830 case AUDIO_UNIQUE_ID_USE_INPUT:
3831 thread = checkRecordThread_l(ioHandle);
3832 break;
3833 default:
3834 break;
3835 }
Glenn Kasteneeecb982016-02-26 10:44:04 -08003836 }
3837 return thread;
3838}
3839
Andy Hung954b9712023-08-28 18:36:53 -07003840// checkOutputThread_l() must be called with AudioFlinger::mutex() held
Andy Hung87c693c2023-07-06 20:56:16 -07003841sp<IAfThreadBase> AudioFlinger::checkOutputThread_l(audio_io_handle_t ioHandle) const
Vlad Popa6fbbfbf2023-02-22 15:05:43 +01003842{
3843 if (audio_unique_id_get_use(ioHandle) != AUDIO_UNIQUE_ID_USE_OUTPUT) {
3844 return nullptr;
3845 }
3846
Andy Hung87c693c2023-07-06 20:56:16 -07003847 sp<IAfThreadBase> thread = mPlaybackThreads.valueFor(ioHandle);
Vlad Popa6fbbfbf2023-02-22 15:05:43 +01003848 if (thread == nullptr) {
3849 thread = mMmapThreads.valueFor(ioHandle);
3850 }
3851 return thread;
3852}
3853
Andy Hung954b9712023-08-28 18:36:53 -07003854// checkPlaybackThread_l() must be called with AudioFlinger::mutex() held
Andy Hung87c693c2023-07-06 20:56:16 -07003855IAfPlaybackThread* AudioFlinger::checkPlaybackThread_l(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003856{
Glenn Kastena1117922012-01-26 10:53:32 -08003857 return mPlaybackThreads.valueFor(output).get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07003858}
3859
Andy Hung954b9712023-08-28 18:36:53 -07003860// checkMixerThread_l() must be called with AudioFlinger::mutex() held
Andy Hung87c693c2023-07-06 20:56:16 -07003861IAfPlaybackThread* AudioFlinger::checkMixerThread_l(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003862{
Andy Hung87c693c2023-07-06 20:56:16 -07003863 IAfPlaybackThread * const thread = checkPlaybackThread_l(output);
3864 return thread != nullptr && thread->type() != IAfThreadBase::DIRECT ? thread : nullptr;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003865}
3866
Andy Hung954b9712023-08-28 18:36:53 -07003867// checkRecordThread_l() must be called with AudioFlinger::mutex() held
Andy Hung87c693c2023-07-06 20:56:16 -07003868IAfRecordThread* AudioFlinger::checkRecordThread_l(audio_io_handle_t input) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003869{
Glenn Kastena1117922012-01-26 10:53:32 -08003870 return mRecordThreads.valueFor(input).get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07003871}
3872
Andy Hung954b9712023-08-28 18:36:53 -07003873// checkMmapThread_l() must be called with AudioFlinger::mutex() held
Andy Hung7aa7d102023-07-07 15:58:48 -07003874IAfMmapThread* AudioFlinger::checkMmapThread_l(audio_io_handle_t io) const
Eric Laurent6acd1d42017-01-04 14:23:29 -08003875{
3876 return mMmapThreads.valueFor(io).get();
3877}
3878
3879
Andy Hung954b9712023-08-28 18:36:53 -07003880// checkPlaybackThread_l() must be called with AudioFlinger::mutex() held
Andy Hung6b137d12024-08-27 22:35:17 +00003881sp<VolumeInterface> AudioFlinger::getVolumeInterface_l(audio_io_handle_t output) const {
Andy Hung84074c62023-07-06 19:21:50 -07003882 sp<VolumeInterface> volumeInterface = mPlaybackThreads.valueFor(output).get();
Eric Laurent6acd1d42017-01-04 14:23:29 -08003883 if (volumeInterface == nullptr) {
Andy Hung7aa7d102023-07-07 15:58:48 -07003884 IAfMmapThread* const mmapThread = mMmapThreads.valueFor(output).get();
Eric Laurent6acd1d42017-01-04 14:23:29 -08003885 if (mmapThread != nullptr) {
3886 if (mmapThread->isOutput()) {
Andy Hung7aa7d102023-07-07 15:58:48 -07003887 IAfMmapPlaybackThread* const mmapPlaybackThread =
3888 mmapThread->asIAfMmapPlaybackThread().get();
Eric Laurent7459b902017-04-19 18:10:41 -07003889 volumeInterface = mmapPlaybackThread;
Eric Laurent6acd1d42017-01-04 14:23:29 -08003890 }
3891 }
3892 }
3893 return volumeInterface;
3894}
3895
Andy Hung84074c62023-07-06 19:21:50 -07003896std::vector<sp<VolumeInterface>> AudioFlinger::getAllVolumeInterfaces_l() const
Eric Laurent6acd1d42017-01-04 14:23:29 -08003897{
Andy Hung84074c62023-07-06 19:21:50 -07003898 std::vector<sp<VolumeInterface>> volumeInterfaces;
Eric Laurent6acd1d42017-01-04 14:23:29 -08003899 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Andy Hung84074c62023-07-06 19:21:50 -07003900 volumeInterfaces.push_back(mPlaybackThreads.valueAt(i).get());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003901 }
3902 for (size_t i = 0; i < mMmapThreads.size(); i++) {
3903 if (mMmapThreads.valueAt(i)->isOutput()) {
Andy Hung7aa7d102023-07-07 15:58:48 -07003904 IAfMmapPlaybackThread* const mmapPlaybackThread =
3905 mMmapThreads.valueAt(i)->asIAfMmapPlaybackThread().get();
Andy Hung84074c62023-07-06 19:21:50 -07003906 volumeInterfaces.push_back(mmapPlaybackThread);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003907 }
3908 }
3909 return volumeInterfaces;
3910}
3911
Glenn Kasteneeecb982016-02-26 10:44:04 -08003912audio_unique_id_t AudioFlinger::nextUniqueId(audio_unique_id_use_t use)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003913{
Glenn Kasten9d003132016-04-06 14:38:09 -07003914 // This is the internal API, so it is OK to assert on bad parameter.
Glenn Kasteneeecb982016-02-26 10:44:04 -08003915 LOG_ALWAYS_FATAL_IF((unsigned) use >= (unsigned) AUDIO_UNIQUE_ID_USE_MAX);
Glenn Kastend2e67e12016-04-11 08:26:37 -07003916 const int maxRetries = use == AUDIO_UNIQUE_ID_USE_SESSION ? 3 : 1;
3917 for (int retry = 0; retry < maxRetries; retry++) {
3918 // The cast allows wraparound from max positive to min negative instead of abort
3919 uint32_t base = (uint32_t) atomic_fetch_add_explicit(&mNextUniqueIds[use],
3920 (uint_fast32_t) AUDIO_UNIQUE_ID_USE_MAX, memory_order_acq_rel);
3921 ALOG_ASSERT(audio_unique_id_get_use(base) == AUDIO_UNIQUE_ID_USE_UNSPECIFIED);
3922 // allow wrap by skipping 0 and -1 for session ids
3923 if (!(base == 0 || base == (~0u & ~AUDIO_UNIQUE_ID_USE_MASK))) {
3924 ALOGW_IF(retry != 0, "unique ID overflow for use %d", use);
3925 return (audio_unique_id_t) (base | use);
3926 }
3927 }
3928 // We have no way of recovering from wraparound
3929 LOG_ALWAYS_FATAL("unique ID overflow for use %d", use);
3930 // TODO Use a floor after wraparound. This may need a mutex.
Mathias Agopian65ab4712010-07-14 17:59:35 -07003931}
3932
Andy Hung87c693c2023-07-06 20:56:16 -07003933IAfPlaybackThread* AudioFlinger::primaryPlaybackThread_l() const
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003934{
François Gaffie328a0a52024-06-25 11:48:09 +02003935 // The atomic ptr mPrimaryHardwareDev requires both the
3936 // AudioFlinger and the Hardware mutex for modification.
3937 // As we hold the AudioFlinger mutex, we access it
3938 // safely without the Hardware mutex, to avoid mutex order
3939 // inversion with Thread methods and the ThreadBase mutex.
Eric Laurent00abf0d2020-04-22 19:28:22 -07003940 if (mPrimaryHardwareDev == nullptr) {
3941 return nullptr;
3942 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003943 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Andy Hung87c693c2023-07-06 20:56:16 -07003944 IAfPlaybackThread* const thread = mPlaybackThreads.valueAt(i).get();
Eric Laurentf6870ae2015-05-08 10:50:03 -07003945 if(thread->isDuplicating()) {
3946 continue;
3947 }
Eric Laurentb8ba0a92011-08-07 16:32:26 -07003948 AudioStreamOut *output = thread->getOutput();
John Grossmanee578c02012-07-23 17:05:46 -07003949 if (output != NULL && output->audioHwDev == mPrimaryHardwareDev) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003950 return thread;
3951 }
3952 }
Eric Laurent00abf0d2020-04-22 19:28:22 -07003953 return nullptr;
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003954}
3955
jiabinc52b1ff2019-10-31 17:20:42 -07003956DeviceTypeSet AudioFlinger::primaryOutputDevice_l() const
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003957{
Andy Hung87c693c2023-07-06 20:56:16 -07003958 IAfPlaybackThread* const thread = primaryPlaybackThread_l();
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003959
3960 if (thread == NULL) {
Andy Hung920f6572022-10-06 12:09:49 -07003961 return {};
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003962 }
3963
Andy Hungab65b182023-09-06 19:41:47 -07003964 audio_utils::lock_guard l(thread->mutex());
3965 return thread->outDeviceTypes_l();
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003966}
3967
Andy Hung87c693c2023-07-06 20:56:16 -07003968IAfPlaybackThread* AudioFlinger::fastPlaybackThread_l() const
Glenn Kastena7335632016-06-09 17:09:53 -07003969{
3970 size_t minFrameCount = 0;
Andy Hung87c693c2023-07-06 20:56:16 -07003971 IAfPlaybackThread* minThread = nullptr;
Glenn Kastena7335632016-06-09 17:09:53 -07003972 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Andy Hung87c693c2023-07-06 20:56:16 -07003973 IAfPlaybackThread* const thread = mPlaybackThreads.valueAt(i).get();
Glenn Kastena7335632016-06-09 17:09:53 -07003974 if (!thread->isDuplicating()) {
3975 size_t frameCount = thread->frameCountHAL();
3976 if (frameCount != 0 && (minFrameCount == 0 || frameCount < minFrameCount ||
3977 (frameCount == minFrameCount && thread->hasFastMixer() &&
3978 /*minThread != NULL &&*/ !minThread->hasFastMixer()))) {
3979 minFrameCount = frameCount;
3980 minThread = thread;
3981 }
3982 }
3983 }
3984 return minThread;
3985}
3986
Andy Hung87c693c2023-07-06 20:56:16 -07003987IAfThreadBase* AudioFlinger::hapticPlaybackThread_l() const {
jiabineb3bda02020-06-30 14:07:03 -07003988 for (size_t i = 0; i < mPlaybackThreads.size(); ++i) {
Andy Hung87c693c2023-07-06 20:56:16 -07003989 IAfPlaybackThread* const thread = mPlaybackThreads.valueAt(i).get();
jiabineb3bda02020-06-30 14:07:03 -07003990 if (thread->hapticChannelMask() != AUDIO_CHANNEL_NONE) {
3991 return thread;
3992 }
3993 }
3994 return nullptr;
3995}
3996
jiabinf042b9b2021-05-07 23:46:28 +00003997void AudioFlinger::updateSecondaryOutputsForTrack_l(
Andy Hungd29af632023-06-23 19:27:19 -07003998 IAfTrack* track,
Andy Hung87c693c2023-07-06 20:56:16 -07003999 IAfPlaybackThread* thread,
jiabinf042b9b2021-05-07 23:46:28 +00004000 const std::vector<audio_io_handle_t> &secondaryOutputs) const {
4001 TeePatches teePatches;
4002 for (audio_io_handle_t secondaryOutput : secondaryOutputs) {
Andy Hung87c693c2023-07-06 20:56:16 -07004003 IAfPlaybackThread* const secondaryThread = checkPlaybackThread_l(secondaryOutput);
jiabinf042b9b2021-05-07 23:46:28 +00004004 if (secondaryThread == nullptr) {
4005 ALOGE("no playback thread found for secondary output %d", thread->id());
4006 continue;
4007 }
4008
4009 size_t sourceFrameCount = thread->frameCount() * track->sampleRate()
4010 / thread->sampleRate();
4011 size_t sinkFrameCount = secondaryThread->frameCount() * track->sampleRate()
4012 / secondaryThread->sampleRate();
4013 // If the secondary output has just been opened, the first secondaryThread write
4014 // will not block as it will fill the empty startup buffer of the HAL,
4015 // so a second sink buffer needs to be ready for the immediate next blocking write.
4016 // Additionally, have a margin of one main thread buffer as the scheduling jitter
4017 // can reorder the writes (eg if thread A&B have the same write intervale,
4018 // the scheduler could schedule AB...BA)
4019 size_t frameCountToBeReady = 2 * sinkFrameCount + sourceFrameCount;
4020 // Total secondary output buffer must be at least as the read frames plus
4021 // the margin of a few buffers on both sides in case the
4022 // threads scheduling has some jitter.
4023 // That value should not impact latency as the secondary track is started before
4024 // its buffer is full, see frameCountToBeReady.
4025 size_t frameCount = frameCountToBeReady + 2 * (sourceFrameCount + sinkFrameCount);
4026 // The frameCount should also not be smaller than the secondary thread min frame
4027 // count
4028 size_t minFrameCount = AudioSystem::calculateMinFrameCount(
Andy Hungc5007f82023-08-29 14:26:09 -07004029 [&] { audio_utils::lock_guard _l(secondaryThread->mutex());
jiabinf042b9b2021-05-07 23:46:28 +00004030 return secondaryThread->latency_l(); }(),
Andy Hung87c693c2023-07-06 20:56:16 -07004031 secondaryThread->frameCount(), // normal frame count
4032 secondaryThread->sampleRate(),
jiabinf042b9b2021-05-07 23:46:28 +00004033 track->sampleRate(),
4034 track->getSpeed());
4035 frameCount = std::max(frameCount, minFrameCount);
4036
4037 using namespace std::chrono_literals;
4038 auto inChannelMask = audio_channel_mask_out_to_in(track->channelMask());
jiabin73e303c2022-09-15 17:49:50 +00004039 if (inChannelMask == AUDIO_CHANNEL_INVALID) {
4040 // The downstream PatchTrack has the proper output channel mask,
4041 // so if there is no input channel mask equivalent, we can just
4042 // use an index mask here to create the PatchRecord.
4043 inChannelMask = audio_channel_mask_out_to_in_index_mask(track->channelMask());
4044 }
Andy Hung8d31fd22023-06-26 19:20:57 -07004045 sp<IAfPatchRecord> patchRecord = IAfPatchRecord::create(nullptr /* thread */,
jiabinf042b9b2021-05-07 23:46:28 +00004046 track->sampleRate(),
4047 inChannelMask,
4048 track->format(),
4049 frameCount,
4050 nullptr /* buffer */,
4051 (size_t)0 /* bufferSize */,
4052 AUDIO_INPUT_FLAG_DIRECT,
4053 0ns /* timeout */);
4054 status_t status = patchRecord->initCheck();
4055 if (status != NO_ERROR) {
4056 ALOGE("Secondary output patchRecord init failed: %d", status);
4057 continue;
4058 }
4059
4060 // TODO: We could check compatibility of the secondaryThread with the PatchTrack
4061 // for fast usage: thread has fast mixer, sample rate matches, etc.;
4062 // for now, we exclude fast tracks by removing the Fast flag.
Andy Hungb3fc6882024-08-19 19:03:55 -07004063 constexpr audio_output_flags_t kIncompatiblePatchTrackFlags =
4064 static_cast<audio_output_flags_t>(AUDIO_OUTPUT_FLAG_FAST
4065 | AUDIO_OUTPUT_FLAG_DIRECT | AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD);
4066
jiabinf042b9b2021-05-07 23:46:28 +00004067 const audio_output_flags_t outputFlags =
Andy Hungb3fc6882024-08-19 19:03:55 -07004068 (audio_output_flags_t)(track->getOutputFlags() & ~kIncompatiblePatchTrackFlags);
Andy Hung8d31fd22023-06-26 19:20:57 -07004069 sp<IAfPatchTrack> patchTrack = IAfPatchTrack::create(secondaryThread,
jiabinf042b9b2021-05-07 23:46:28 +00004070 track->streamType(),
4071 track->sampleRate(),
4072 track->channelMask(),
4073 track->format(),
4074 frameCount,
4075 patchRecord->buffer(),
4076 patchRecord->bufferSize(),
4077 outputFlags,
4078 0ns /* timeout */,
guonaichao3acc9b12024-06-07 09:27:21 +08004079 frameCountToBeReady,
Andy Hung6b137d12024-08-27 22:35:17 +00004080 track->getSpeed(),
Andy Hung9a4f5922024-08-27 18:21:19 -07004081 1.f /* volume */);
jiabinf042b9b2021-05-07 23:46:28 +00004082 status = patchTrack->initCheck();
4083 if (status != NO_ERROR) {
4084 ALOGE("Secondary output patchTrack init failed: %d", status);
4085 continue;
4086 }
4087 teePatches.push_back({patchRecord, patchTrack});
4088 secondaryThread->addPatchTrack(patchTrack);
4089 // In case the downstream patchTrack on the secondaryThread temporarily outlives
4090 // our created track, ensure the corresponding patchRecord is still alive.
4091 patchTrack->setPeerProxy(patchRecord, true /* holdReference */);
4092 patchRecord->setPeerProxy(patchTrack, false /* holdReference */);
4093 }
Andy Hung16ed0da2023-07-14 11:45:38 -07004094 track->setTeePatchesToUpdate_l(std::move(teePatches));
jiabinf042b9b2021-05-07 23:46:28 +00004095}
4096
Andy Hung068e08e2023-05-15 19:02:55 -07004097sp<audioflinger::SyncEvent> AudioFlinger::createSyncEvent(AudioSystem::sync_event_t type,
Glenn Kastend848eb42016-03-08 13:42:11 -08004098 audio_session_t triggerSession,
4099 audio_session_t listenerSession,
Andy Hunga9acac52023-05-22 18:13:40 -07004100 const audioflinger::SyncEventCallback& callBack,
Andy Hungd29af632023-06-23 19:27:19 -07004101 const wp<IAfTrackBase>& cookie)
Eric Laurenta011e352012-03-29 15:51:43 -07004102{
Andy Hung954b9712023-08-28 18:36:53 -07004103 audio_utils::lock_guard _l(mutex());
Eric Laurenta011e352012-03-29 15:51:43 -07004104
Andy Hung068e08e2023-05-15 19:02:55 -07004105 auto event = sp<audioflinger::SyncEvent>::make(
4106 type, triggerSession, listenerSession, callBack, cookie);
Eric Laurenta011e352012-03-29 15:51:43 -07004107 status_t playStatus = NAME_NOT_FOUND;
4108 status_t recStatus = NAME_NOT_FOUND;
4109 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
4110 playStatus = mPlaybackThreads.valueAt(i)->setSyncEvent(event);
4111 if (playStatus == NO_ERROR) {
4112 return event;
4113 }
4114 }
4115 for (size_t i = 0; i < mRecordThreads.size(); i++) {
4116 recStatus = mRecordThreads.valueAt(i)->setSyncEvent(event);
4117 if (recStatus == NO_ERROR) {
4118 return event;
4119 }
4120 }
4121 if (playStatus == NAME_NOT_FOUND || recStatus == NAME_NOT_FOUND) {
Andy Hung068e08e2023-05-15 19:02:55 -07004122 mPendingSyncEvents.emplace_back(event);
Eric Laurenta011e352012-03-29 15:51:43 -07004123 } else {
4124 ALOGV("createSyncEvent() invalid event %d", event->type());
4125 event.clear();
4126 }
4127 return event;
4128}
Eric Laurent7c7f10b2011-06-17 21:29:58 -07004129
Mathias Agopian65ab4712010-07-14 17:59:35 -07004130// ----------------------------------------------------------------------------
4131// Effect management
4132// ----------------------------------------------------------------------------
4133
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07004134sp<EffectsFactoryHalInterface> AudioFlinger::getEffectsFactory() {
4135 return mEffectsFactoryHal;
4136}
Mathias Agopian65ab4712010-07-14 17:59:35 -07004137
Glenn Kastenf587ba52012-01-26 16:25:10 -08004138status_t AudioFlinger::queryNumberEffects(uint32_t *numEffects) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07004139{
Andy Hung954b9712023-08-28 18:36:53 -07004140 audio_utils::lock_guard _l(mutex());
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07004141 if (mEffectsFactoryHal.get()) {
4142 return mEffectsFactoryHal->queryNumberEffects(numEffects);
4143 } else {
4144 return -ENODEV;
4145 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004146}
4147
Glenn Kastenf587ba52012-01-26 16:25:10 -08004148status_t AudioFlinger::queryEffect(uint32_t index, effect_descriptor_t *descriptor) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07004149{
Andy Hung954b9712023-08-28 18:36:53 -07004150 audio_utils::lock_guard _l(mutex());
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07004151 if (mEffectsFactoryHal.get()) {
4152 return mEffectsFactoryHal->getDescriptor(index, descriptor);
4153 } else {
4154 return -ENODEV;
4155 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004156}
4157
Glenn Kasten5e92a782012-01-30 07:40:52 -08004158status_t AudioFlinger::getEffectDescriptor(const effect_uuid_t *pUuid,
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07004159 const effect_uuid_t *pTypeUuid,
4160 uint32_t preferredTypeFlag,
4161 effect_descriptor_t *descriptor) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07004162{
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07004163 if (pUuid == NULL || pTypeUuid == NULL || descriptor == NULL) {
4164 return BAD_VALUE;
4165 }
4166
Andy Hung954b9712023-08-28 18:36:53 -07004167 audio_utils::lock_guard _l(mutex());
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07004168
4169 if (!mEffectsFactoryHal.get()) {
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07004170 return -ENODEV;
4171 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004172
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07004173 status_t status = NO_ERROR;
4174 if (!EffectsFactoryHalInterface::isNullUuid(pUuid)) {
4175 // If uuid is specified, request effect descriptor from that.
4176 status = mEffectsFactoryHal->getDescriptor(pUuid, descriptor);
4177 } else if (!EffectsFactoryHalInterface::isNullUuid(pTypeUuid)) {
4178 // If uuid is not specified, look for an available implementation
4179 // of the required type instead.
4180
4181 // Use a temporary descriptor to avoid modifying |descriptor| in the failure case.
4182 effect_descriptor_t desc;
4183 desc.flags = 0; // prevent compiler warning
4184
4185 uint32_t numEffects = 0;
4186 status = mEffectsFactoryHal->queryNumberEffects(&numEffects);
4187 if (status < 0) {
4188 ALOGW("getEffectDescriptor() error %d from FactoryHal queryNumberEffects", status);
4189 return status;
4190 }
4191
4192 bool found = false;
4193 for (uint32_t i = 0; i < numEffects; i++) {
4194 status = mEffectsFactoryHal->getDescriptor(i, &desc);
4195 if (status < 0) {
4196 ALOGW("getEffectDescriptor() error %d from FactoryHal getDescriptor", status);
4197 continue;
4198 }
4199 if (memcmp(&desc.type, pTypeUuid, sizeof(effect_uuid_t)) == 0) {
4200 // If matching type found save effect descriptor.
4201 found = true;
4202 *descriptor = desc;
4203
4204 // If there's no preferred flag or this descriptor matches the preferred
4205 // flag, success! If this descriptor doesn't match the preferred
4206 // flag, continue enumeration in case a better matching version of this
4207 // effect type is available. Note that this means if no effect with a
4208 // correct flag is found, the descriptor returned will correspond to the
4209 // last effect that at least had a matching type uuid (if any).
4210 if (preferredTypeFlag == EFFECT_FLAG_TYPE_MASK ||
4211 (desc.flags & EFFECT_FLAG_TYPE_MASK) == preferredTypeFlag) {
4212 break;
4213 }
4214 }
4215 }
4216
4217 if (!found) {
4218 status = NAME_NOT_FOUND;
4219 ALOGW("getEffectDescriptor(): Effect not found by type.");
4220 }
4221 } else {
4222 status = BAD_VALUE;
4223 ALOGE("getEffectDescriptor(): Either uuid or type uuid must be non-null UUIDs.");
4224 }
4225 return status;
4226}
Mathias Agopian65ab4712010-07-14 17:59:35 -07004227
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004228status_t AudioFlinger::createEffect(const media::CreateEffectRequest& request,
4229 media::CreateEffectResponse* response) {
4230 const sp<IEffectClient>& effectClient = request.client;
4231 const int32_t priority = request.priority;
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08004232 const AudioDeviceTypeAddr device = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004233 aidl2legacy_AudioDeviceTypeAddress(request.device));
Svet Ganov33761132021-05-13 22:51:08 +00004234 AttributionSourceState adjAttributionSource = request.attributionSource;
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08004235 const audio_session_t sessionId = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004236 aidl2legacy_int32_t_audio_session_t(request.sessionId));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08004237 audio_io_handle_t io = VALUE_OR_RETURN_STATUS(
4238 aidl2legacy_int32_t_audio_io_handle_t(request.output));
4239 const effect_descriptor_t descIn = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004240 aidl2legacy_EffectDescriptor_effect_descriptor_t(request.desc));
4241 const bool probe = request.probe;
4242
Andy Hung6ac17eb2023-06-20 18:56:17 -07004243 sp<IAfEffectHandle> handle;
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004244 effect_descriptor_t descOut;
4245 int enabledOut = 0;
4246 int idOut = -1;
4247
4248 status_t lStatus = NO_ERROR;
Atneya Nair5997a652024-06-14 17:24:45 -07004249 uid_t callingUid = IPCThreadState::self()->getCallingUid();
4250 pid_t currentPid;
4251 if (!com::android::media::audio::audioserver_permissions()) {
4252 adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
4253 currentPid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(adjAttributionSource.pid));
4254 if (currentPid == -1 || !isAudioServerOrMediaServerOrSystemServerOrRootUid(callingUid)) {
4255 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
4256 ALOGW_IF(currentPid != -1 && currentPid != callingPid,
4257 "%s uid %d pid %d tried to pass itself off as pid %d",
4258 __func__, callingUid, callingPid, currentPid);
4259 adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(
4260 legacy2aidl_pid_t_int32_t(callingPid));
4261 currentPid = callingPid;
4262 }
4263 adjAttributionSource = afutils::checkAttributionSourcePackage(adjAttributionSource);
4264 } else {
4265 auto validatedAttrSource = VALUE_OR_RETURN_CONVERTED(
4266 validateAttributionFromContextOrTrustedCaller(request.attributionSource,
4267 getPermissionProvider()
4268 ));
4269 // TODO pass wrapped object around
4270 adjAttributionSource = std::move(validatedAttrSource).unwrapInto();
4271 currentPid = adjAttributionSource.pid;
Pechetty Sravani55532052024-06-14 03:30:13 +00004272 }
Atneya Nair5997a652024-06-14 17:24:45 -07004273
Eric Laurentb6436272016-12-07 19:24:50 -08004274
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07004275 ALOGV("createEffect pid %d, effectClient %p, priority %d, sessionId %d, io %d, factory %p",
Svet Ganov33761132021-05-13 22:51:08 +00004276 adjAttributionSource.pid, effectClient.get(), priority, sessionId, io,
4277 mEffectsFactoryHal.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07004278
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004279 if (mEffectsFactoryHal == 0) {
Andy Hung6096dcd2019-03-13 13:20:30 -07004280 ALOGE("%s: no effects factory hal", __func__);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07004281 lStatus = NO_INIT;
4282 goto Exit;
4283 }
4284
Andy Hung6096dcd2019-03-13 13:20:30 -07004285 // check audio settings permission for global effects
4286 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
4287 if (!settingsAllowed()) {
4288 ALOGE("%s: no permission for AUDIO_SESSION_OUTPUT_MIX", __func__);
4289 lStatus = PERMISSION_DENIED;
4290 goto Exit;
4291 }
4292 } else if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
Andy Hung6096dcd2019-03-13 13:20:30 -07004293 if (io == AUDIO_IO_HANDLE_NONE) {
4294 ALOGE("%s: APM must specify output when using AUDIO_SESSION_OUTPUT_STAGE", __func__);
4295 lStatus = BAD_VALUE;
4296 goto Exit;
4297 }
Andy Hungc2cf7ec2023-08-30 18:19:00 -07004298 IAfPlaybackThread* thread;
4299 {
4300 audio_utils::lock_guard l(mutex());
4301 thread = checkPlaybackThread_l(io);
4302 }
Eric Laurenta74058e2022-05-26 15:08:00 +00004303 if (thread == nullptr) {
4304 ALOGE("%s: invalid output %d specified for AUDIO_SESSION_OUTPUT_STAGE", __func__, io);
4305 lStatus = BAD_VALUE;
4306 goto Exit;
4307 }
4308 if (!modifyDefaultAudioEffectsAllowed(adjAttributionSource)
4309 && !isAudioServerUid(callingUid)) {
4310 ALOGE("%s: effect on AUDIO_SESSION_OUTPUT_STAGE not granted for uid %d",
4311 __func__, callingUid);
4312 lStatus = PERMISSION_DENIED;
4313 goto Exit;
4314 }
Eric Laurent3f75a5b2019-11-12 15:55:51 -08004315 } else if (sessionId == AUDIO_SESSION_DEVICE) {
Svet Ganov33761132021-05-13 22:51:08 +00004316 if (!modifyDefaultAudioEffectsAllowed(adjAttributionSource)) {
Eric Laurent3f75a5b2019-11-12 15:55:51 -08004317 ALOGE("%s: device effect permission denied for uid %d", __func__, callingUid);
4318 lStatus = PERMISSION_DENIED;
4319 goto Exit;
4320 }
Eric Laurent94876032019-11-13 12:45:28 -08004321 if (io != AUDIO_IO_HANDLE_NONE) {
4322 ALOGE("%s: io handle should not be specified for device effect", __func__);
4323 lStatus = BAD_VALUE;
4324 goto Exit;
4325 }
Andy Hung6096dcd2019-03-13 13:20:30 -07004326 } else {
4327 // general sessionId.
4328
4329 if (audio_unique_id_get_use(sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) {
4330 ALOGE("%s: invalid sessionId %d", __func__, sessionId);
4331 lStatus = BAD_VALUE;
4332 goto Exit;
4333 }
4334
4335 // TODO: should we check if the callingUid (limited to pid) is in mAudioSessionRefs
4336 // to prevent creating an effect when one doesn't actually have track with that session?
4337 }
4338
Mathias Agopian65ab4712010-07-14 17:59:35 -07004339 {
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07004340 // Get the full effect descriptor from the uuid/type.
4341 // If the session is the output mix, prefer an auxiliary effect,
4342 // otherwise no preference.
4343 uint32_t preferredType = (sessionId == AUDIO_SESSION_OUTPUT_MIX ?
4344 EFFECT_FLAG_TYPE_AUXILIARY : EFFECT_FLAG_TYPE_MASK);
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004345 lStatus = getEffectDescriptor(&descIn.uuid, &descIn.type, preferredType, &descOut);
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07004346 if (lStatus < 0) {
4347 ALOGW("createEffect() error %d from getEffectDescriptor", lStatus);
4348 goto Exit;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004349 }
4350
4351 // Do not allow auxiliary effects on a session different from 0 (output mix)
Dima Zavinfce7a472011-04-19 22:30:36 -07004352 if (sessionId != AUDIO_SESSION_OUTPUT_MIX &&
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004353 (descOut.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07004354 lStatus = INVALID_OPERATION;
4355 goto Exit;
4356 }
4357
Eric Laurent59255e42011-07-27 19:49:51 -07004358 // check recording permission for visualizer
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004359 if ((memcmp(&descOut.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) &&
Svet Ganov6e641372018-03-02 09:21:30 -08004360 // TODO: Do we need to start/stop op - i.e. is there recording being performed?
Svet Ganov33761132021-05-13 22:51:08 +00004361 !recordingAllowed(adjAttributionSource)) {
Eric Laurent59255e42011-07-27 19:49:51 -07004362 lStatus = PERMISSION_DENIED;
4363 goto Exit;
4364 }
4365
Andy Hung6ac17eb2023-06-20 18:56:17 -07004366 const bool hapticPlaybackRequired = IAfEffectModule::isHapticGenerator(&descOut.type);
jiabineb3bda02020-06-30 14:07:03 -07004367 if (hapticPlaybackRequired
4368 && (sessionId == AUDIO_SESSION_DEVICE
4369 || sessionId == AUDIO_SESSION_OUTPUT_MIX
4370 || sessionId == AUDIO_SESSION_OUTPUT_STAGE)) {
4371 // haptic-generating effect is only valid when the session id is a general session id
4372 lStatus = INVALID_OPERATION;
4373 goto Exit;
4374 }
4375
Eric Laurentf690c462021-09-17 14:47:03 +02004376 // Only audio policy service can create a spatializer effect
Eric Laurent4eb45d02023-12-20 12:07:17 +01004377 if (IAfEffectModule::isSpatializer(&descOut.type) &&
Eric Laurentf690c462021-09-17 14:47:03 +02004378 (callingUid != AID_AUDIOSERVER || currentPid != getpid())) {
4379 ALOGW("%s: attempt to create a spatializer effect from uid/pid %d/%d",
4380 __func__, callingUid, currentPid);
4381 lStatus = PERMISSION_DENIED;
4382 goto Exit;
4383 }
4384
Glenn Kasten142f5192014-03-25 17:44:59 -07004385 if (io == AUDIO_IO_HANDLE_NONE && sessionId == AUDIO_SESSION_OUTPUT_MIX) {
Eric Laurenteb3c3372013-09-25 12:25:29 -07004386 // if the output returned by getOutputForEffect() is removed before we lock the
4387 // mutex below, the call to checkPlaybackThread_l(io) below will detect it
4388 // and we will exit safely
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004389 io = AudioSystem::getOutputForEffect(&descOut);
Eric Laurenteb3c3372013-09-25 12:25:29 -07004390 ALOGV("createEffect got output %d", io);
4391 }
4392
Andy Hung954b9712023-08-28 18:36:53 -07004393 audio_utils::lock_guard _l(mutex());
Mathias Agopian65ab4712010-07-14 17:59:35 -07004394
Eric Laurentb82e6b72019-11-22 17:25:04 -08004395 if (sessionId == AUDIO_SESSION_DEVICE) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07004396 sp<Client> client = registerPid(currentPid);
Eric Laurent2fe0acd2020-03-13 14:30:46 -07004397 ALOGV("%s device type %#x address %s", __func__, device.mType, device.getAddress());
Vlad Popa5161f8a2022-10-10 16:17:20 +02004398 handle = mDeviceEffectManager->createEffect_l(
Andy Hungb6692eb2023-07-13 16:52:46 -07004399 &descOut, device, client, effectClient, mPatchPanel->patches_l(),
Eric Laurentde8caf42021-08-11 17:19:25 +02004400 &enabledOut, &lStatus, probe, request.notifyFramesProcessed);
Eric Laurentb82e6b72019-11-22 17:25:04 -08004401 if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
Andy Hung954b9712023-08-28 18:36:53 -07004402 // remove local strong reference to Client with clientMutex() held
4403 audio_utils::lock_guard _cl(clientMutex());
Eric Laurentb82e6b72019-11-22 17:25:04 -08004404 client.clear();
4405 } else {
4406 // handle must be valid here, but check again to be safe.
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004407 if (handle.get() != nullptr) idOut = handle->id();
Eric Laurentb82e6b72019-11-22 17:25:04 -08004408 }
4409 goto Register;
4410 }
4411
Mathias Agopian65ab4712010-07-14 17:59:35 -07004412 // If output is not specified try to find a matching audio session ID in one of the
4413 // output threads.
Eric Laurent84e9a102010-09-23 16:10:16 -07004414 // If output is 0 here, sessionId is neither SESSION_OUTPUT_STAGE nor SESSION_OUTPUT_MIX
4415 // because of code checking output when entering the function.
Andy Hung444bb552019-03-14 17:06:39 -07004416 // Note: io is never AUDIO_IO_HANDLE_NONE when creating an effect on an input by APM.
4417 // An AudioEffect created from the Java API will have io as AUDIO_IO_HANDLE_NONE.
Glenn Kasten142f5192014-03-25 17:44:59 -07004418 if (io == AUDIO_IO_HANDLE_NONE) {
Eric Laurenteb3c3372013-09-25 12:25:29 -07004419 // look for the thread where the specified audio session is present
Andy Hunge778c422019-03-14 15:04:30 -07004420 io = findIoHandleBySessionId_l(sessionId, mPlaybackThreads);
4421 if (io == AUDIO_IO_HANDLE_NONE) {
4422 io = findIoHandleBySessionId_l(sessionId, mRecordThreads);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004423 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08004424 if (io == AUDIO_IO_HANDLE_NONE) {
Andy Hunge778c422019-03-14 15:04:30 -07004425 io = findIoHandleBySessionId_l(sessionId, mMmapThreads);
Eric Laurent6acd1d42017-01-04 14:23:29 -08004426 }
Andy Hung444bb552019-03-14 17:06:39 -07004427
4428 // If you wish to create a Record preprocessing AudioEffect in Java,
4429 // you MUST create an AudioRecord first and keep it alive so it is picked up above.
4430 // Otherwise it will fail when created on a Playback thread by legacy
4431 // handling below. Ditto with Mmap, the associated Mmap track must be created
4432 // before creating the AudioEffect or the io handle must be specified.
4433 //
4434 // Detect if the effect is created after an AudioRecord is destroyed.
Shunkai Yao29d10572024-03-19 04:31:47 +00004435 if (sessionId != AUDIO_SESSION_OUTPUT_MIX
4436 && ((descOut.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC)
4437 && getOrphanEffectChain_l(sessionId).get() != nullptr) {
Andy Hung444bb552019-03-14 17:06:39 -07004438 ALOGE("%s: effect %s with no specified io handle is denied because the AudioRecord"
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004439 " for session %d no longer exists",
4440 __func__, descOut.name, sessionId);
Andy Hung444bb552019-03-14 17:06:39 -07004441 lStatus = PERMISSION_DENIED;
4442 goto Exit;
4443 }
4444
4445 // Legacy handling of creating an effect on an expired or made-up
4446 // session id. We think that it is a Playback effect.
4447 //
Shunkai Yao29d10572024-03-19 04:31:47 +00004448 // If no output thread contains the requested session ID, park the effect to
4449 // the orphan chains. The effect chain will be moved to the correct output
4450 // thread when a track with the same session ID is created.
4451 if (io == AUDIO_IO_HANDLE_NONE) {
4452 if (probe) {
4453 // In probe mode, as no compatible thread found, exit with error.
4454 lStatus = BAD_VALUE;
4455 goto Exit;
4456 }
4457 ALOGV("%s() got io %d for effect %s", __func__, io, descOut.name);
4458 sp<Client> client = registerPid(currentPid);
4459 bool pinned = !audio_is_global_session(sessionId) && isSessionAcquired_l(sessionId);
4460 handle = createOrphanEffect_l(client, effectClient, priority, sessionId,
4461 &descOut, &enabledOut, &lStatus, pinned,
4462 request.notifyFramesProcessed);
4463 if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
4464 // remove local strong reference to Client with clientMutex() held
4465 audio_utils::lock_guard _cl(clientMutex());
4466 client.clear();
4467 }
4468 goto Register;
Eric Laurent7c7f10b2011-06-17 21:29:58 -07004469 }
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004470 ALOGV("createEffect() got io %d for effect %s", io, descOut.name);
Eric Laurentb3f315a2021-07-13 15:09:05 +02004471 } else if (checkPlaybackThread_l(io) != nullptr
4472 && sessionId != AUDIO_SESSION_OUTPUT_STAGE) {
Andy Hung1631f062019-03-12 19:39:03 -07004473 // allow only one effect chain per sessionId on mPlaybackThreads.
4474 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
4475 const audio_io_handle_t checkIo = mPlaybackThreads.keyAt(i);
jiabineb3bda02020-06-30 14:07:03 -07004476 if (io == checkIo) {
4477 if (hapticPlaybackRequired
4478 && mPlaybackThreads.valueAt(i)
4479 ->hapticChannelMask() == AUDIO_CHANNEL_NONE) {
4480 ALOGE("%s: haptic playback thread is required while the required playback "
4481 "thread(io=%d) doesn't support", __func__, (int)io);
4482 lStatus = BAD_VALUE;
4483 goto Exit;
4484 }
4485 continue;
4486 }
Andy Hung1631f062019-03-12 19:39:03 -07004487 const uint32_t sessionType =
4488 mPlaybackThreads.valueAt(i)->hasAudioSession(sessionId);
Andy Hung87c693c2023-07-06 20:56:16 -07004489 if ((sessionType & IAfThreadBase::EFFECT_SESSION) != 0) {
Andy Hung1631f062019-03-12 19:39:03 -07004490 ALOGE("%s: effect %s io %d denied because session %d effect exists on io %d",
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004491 __func__, descOut.name, (int) io, (int) sessionId, (int) checkIo);
Andy Hung1631f062019-03-12 19:39:03 -07004492 android_errorWriteLog(0x534e4554, "123237974");
4493 lStatus = BAD_VALUE;
4494 goto Exit;
4495 }
4496 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07004497 }
Andy Hung87c693c2023-07-06 20:56:16 -07004498 IAfThreadBase* thread = checkRecordThread_l(io);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07004499 if (thread == NULL) {
4500 thread = checkPlaybackThread_l(io);
4501 if (thread == NULL) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08004502 thread = checkMmapThread_l(io);
4503 if (thread == NULL) {
4504 ALOGE("createEffect() unknown output thread");
4505 lStatus = BAD_VALUE;
4506 goto Exit;
4507 }
Eric Laurent84e9a102010-09-23 16:10:16 -07004508 }
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004509 }
4510 if (thread->type() == IAfThreadBase::RECORD || sessionId == AUDIO_SESSION_OUTPUT_MIX) {
Eric Laurentaaa44472014-09-12 17:41:50 -07004511 // Check if one effect chain was awaiting for an effect to be created on this
4512 // session and used it instead of creating a new one.
Andy Hung6ac17eb2023-06-20 18:56:17 -07004513 sp<IAfEffectChain> chain = getOrphanEffectChain_l(sessionId);
Eric Laurentaaa44472014-09-12 17:41:50 -07004514 if (chain != 0) {
Andy Hungc5007f82023-08-29 14:26:09 -07004515 audio_utils::lock_guard _l2(thread->mutex());
Eric Laurentaaa44472014-09-12 17:41:50 -07004516 thread->addEffectChain_l(chain);
4517 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004518 }
Eric Laurent84e9a102010-09-23 16:10:16 -07004519
Philip P. Moltmannbda45752020-07-17 16:41:18 -07004520 sp<Client> client = registerPid(currentPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004521
Marco Nelissen3a34bef2011-08-02 13:33:41 -07004522 // create effect on selected output thread
Eric Laurent3f75a5b2019-11-12 15:55:51 -08004523 bool pinned = !audio_is_global_session(sessionId) && isSessionAcquired_l(sessionId);
Andy Hung87c693c2023-07-06 20:56:16 -07004524 IAfThreadBase* oriThread = nullptr;
jiabineb3bda02020-06-30 14:07:03 -07004525 if (hapticPlaybackRequired && thread->hapticChannelMask() == AUDIO_CHANNEL_NONE) {
Andy Hung87c693c2023-07-06 20:56:16 -07004526 IAfThreadBase* const hapticThread = hapticPlaybackThread_l();
jiabineb3bda02020-06-30 14:07:03 -07004527 if (hapticThread == nullptr) {
4528 ALOGE("%s haptic thread not found while it is required", __func__);
4529 lStatus = INVALID_OPERATION;
4530 goto Exit;
4531 }
4532 if (hapticThread != thread) {
4533 // Force to use haptic thread for haptic-generating effect.
4534 oriThread = thread;
4535 thread = hapticThread;
4536 }
4537 }
Eric Laurentde070132010-07-13 04:45:46 -07004538 handle = thread->createEffect_l(client, effectClient, priority, sessionId,
Eric Laurentde8caf42021-08-11 17:19:25 +02004539 &descOut, &enabledOut, &lStatus, pinned, probe,
4540 request.notifyFramesProcessed);
haobo101735295ff7b0d2017-03-17 17:44:03 +08004541 if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
Andy Hung954b9712023-08-28 18:36:53 -07004542 // remove local strong reference to Client with clientMutex() held
4543 audio_utils::lock_guard _cl(clientMutex());
Eric Laurentfe1a94e2014-05-26 16:03:08 -07004544 client.clear();
haobo101735295ff7b0d2017-03-17 17:44:03 +08004545 } else {
4546 // handle must be valid here, but check again to be safe.
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004547 if (handle.get() != nullptr) idOut = handle->id();
jiabineb3bda02020-06-30 14:07:03 -07004548 // Invalidate audio session when haptic playback is created.
4549 if (hapticPlaybackRequired && oriThread != nullptr) {
4550 // invalidateTracksForAudioSession will trigger locking the thread.
4551 oriThread->invalidateTracksForAudioSession(sessionId);
4552 }
Eric Laurentfe1a94e2014-05-26 16:03:08 -07004553 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004554 }
4555
Eric Laurentb82e6b72019-11-22 17:25:04 -08004556Register:
Eric Laurent2fe0acd2020-03-13 14:30:46 -07004557 if (!probe && (lStatus == NO_ERROR || lStatus == ALREADY_EXISTS)) {
Eric Laurent4f1d4e92022-02-01 14:37:16 +01004558 if (lStatus == ALREADY_EXISTS) {
4559 response->alreadyExists = true;
4560 lStatus = NO_ERROR;
4561 } else {
4562 response->alreadyExists = false;
4563 }
Eric Laurent6c796322019-04-09 14:13:17 -07004564 // Check CPU and memory usage
Andy Hung6ac17eb2023-06-20 18:56:17 -07004565 sp<IAfEffectBase> effect = handle->effect().promote();
Eric Laurent6c796322019-04-09 14:13:17 -07004566 if (effect != nullptr) {
4567 status_t rStatus = effect->updatePolicyState();
4568 if (rStatus != NO_ERROR) {
4569 lStatus = rStatus;
4570 }
4571 }
4572 } else {
haobo101735295ff7b0d2017-03-17 17:44:03 +08004573 handle.clear();
4574 }
4575
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004576 response->id = idOut;
4577 response->enabled = enabledOut != 0;
Shunkai Yao8ade2572023-07-28 00:55:00 +00004578 response->effect = handle.get() ? handle->asIEffect() : nullptr;
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08004579 response->desc = VALUE_OR_RETURN_STATUS(
4580 legacy2aidl_effect_descriptor_t_EffectDescriptor(descOut));
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004581
Mathias Agopian65ab4712010-07-14 17:59:35 -07004582Exit:
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004583 return lStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004584}
4585
Shunkai Yao29d10572024-03-19 04:31:47 +00004586sp<IAfEffectHandle> AudioFlinger::createOrphanEffect_l(
4587 const sp<Client>& client,
4588 const sp<IEffectClient>& effectClient,
4589 int32_t priority,
4590 audio_session_t sessionId,
4591 effect_descriptor_t *desc,
4592 int *enabled,
4593 status_t *status,
4594 bool pinned,
4595 bool notifyFramesProcessed)
4596{
4597 ALOGV("%s effectClient %p, priority %d, sessionId %d, factory %p",
4598 __func__, effectClient.get(), priority, sessionId, mEffectsFactoryHal.get());
4599
4600 // Check if an orphan effect chain exists for this session or create new chain for this session
4601 sp<IAfEffectModule> effect;
4602 sp<IAfEffectChain> chain = getOrphanEffectChain_l(sessionId);
4603 bool chainCreated = false;
4604 if (chain == nullptr) {
4605 chain = IAfEffectChain::create(/* ThreadBase= */ nullptr, sessionId, this);
4606 chainCreated = true;
4607 } else {
4608 effect = chain->getEffectFromDesc(desc);
4609 }
4610 bool effectCreated = false;
4611 if (effect == nullptr) {
4612 audio_unique_id_t effectId = nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);
4613 // create a new effect module if none present in the chain
4614 status_t llStatus =
4615 chain->createEffect(effect, desc, effectId, sessionId, pinned);
4616 if (llStatus != NO_ERROR) {
4617 *status = llStatus;
Shunkai Yao7eb61b82024-03-21 23:17:38 +00004618 // if the effect chain was not created here, put it back
4619 if (!chainCreated) {
4620 putOrphanEffectChain_l(chain);
4621 }
Shunkai Yao29d10572024-03-19 04:31:47 +00004622 return nullptr;
4623 }
4624 effect->setMode(getMode());
4625
4626 if (effect->isHapticGenerator()) {
4627 // TODO(b/184194057): Use the vibrator information from the vibrator that will be used
4628 // for the HapticGenerator.
4629 const std::optional<media::AudioVibratorInfo> defaultVibratorInfo =
Yi Kong3ac211f2024-08-12 07:31:44 +08004630 getDefaultVibratorInfo_l();
Shunkai Yao29d10572024-03-19 04:31:47 +00004631 if (defaultVibratorInfo) {
4632 // Only set the vibrator info when it is a valid one.
4633 audio_utils::lock_guard _cl(chain->mutex());
4634 effect->setVibratorInfo_l(*defaultVibratorInfo);
4635 }
4636 }
4637 effectCreated = true;
4638 }
4639 // create effect handle and connect it to effect module
4640 sp<IAfEffectHandle> handle =
4641 IAfEffectHandle::create(effect, client, effectClient, priority, notifyFramesProcessed);
4642 status_t lStatus = handle->initCheck();
4643 if (lStatus == OK) {
4644 lStatus = effect->addHandle(handle.get());
4645 }
Shunkai Yao7eb61b82024-03-21 23:17:38 +00004646 // in case of lStatus error, EffectHandle will still return and caller should do the clear
Shunkai Yao29d10572024-03-19 04:31:47 +00004647 if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
4648 if (effectCreated) {
4649 chain->removeEffect(effect);
4650 }
Shunkai Yao7eb61b82024-03-21 23:17:38 +00004651 // if the effect chain was not created here, put it back
4652 if (!chainCreated) {
4653 putOrphanEffectChain_l(chain);
4654 }
Shunkai Yao29d10572024-03-19 04:31:47 +00004655 } else {
4656 if (enabled != NULL) {
4657 *enabled = (int)effect->isEnabled();
4658 }
Shunkai Yao7eb61b82024-03-21 23:17:38 +00004659 putOrphanEffectChain_l(chain);
Shunkai Yao29d10572024-03-19 04:31:47 +00004660 }
4661 *status = lStatus;
4662 return handle;
4663}
4664
François Gaffie1b4753e2023-02-06 10:36:33 +01004665status_t AudioFlinger::moveEffects(audio_session_t sessionId, audio_io_handle_t srcIo,
4666 audio_io_handle_t dstIo)
4667NO_THREAD_SAFETY_ANALYSIS
Eric Laurentde070132010-07-13 04:45:46 -07004668{
François Gaffie1b4753e2023-02-06 10:36:33 +01004669 ALOGV("%s() session %d, srcIo %d, dstIo %d", __func__, sessionId, srcIo, dstIo);
Andy Hung954b9712023-08-28 18:36:53 -07004670 audio_utils::lock_guard _l(mutex());
François Gaffie1b4753e2023-02-06 10:36:33 +01004671 if (srcIo == dstIo) {
4672 ALOGW("%s() same dst and src outputs %d", __func__, dstIo);
Eric Laurentde070132010-07-13 04:45:46 -07004673 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004674 }
Andy Hung87c693c2023-07-06 20:56:16 -07004675 IAfRecordThread* const srcRecordThread = checkRecordThread_l(srcIo);
4676 IAfRecordThread* const dstRecordThread = checkRecordThread_l(dstIo);
François Gaffie1b4753e2023-02-06 10:36:33 +01004677 if (srcRecordThread != nullptr || dstRecordThread != nullptr) {
4678 if (srcRecordThread != nullptr) {
Andy Hung87c693c2023-07-06 20:56:16 -07004679 srcRecordThread->mutex().lock();
François Gaffie1b4753e2023-02-06 10:36:33 +01004680 }
4681 if (dstRecordThread != nullptr) {
Andy Hung87c693c2023-07-06 20:56:16 -07004682 dstRecordThread->mutex().lock();
François Gaffie1b4753e2023-02-06 10:36:33 +01004683 }
Andy Hung972bec12023-08-31 16:13:39 -07004684 status_t ret = moveEffectChain_ll(sessionId, srcRecordThread, dstRecordThread);
François Gaffie1b4753e2023-02-06 10:36:33 +01004685 if (srcRecordThread != nullptr) {
Andy Hung87c693c2023-07-06 20:56:16 -07004686 srcRecordThread->mutex().unlock();
François Gaffie1b4753e2023-02-06 10:36:33 +01004687 }
4688 if (dstRecordThread != nullptr) {
Andy Hung87c693c2023-07-06 20:56:16 -07004689 dstRecordThread->mutex().unlock();
François Gaffie1b4753e2023-02-06 10:36:33 +01004690 }
4691 return ret;
4692 }
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004693
4694 IAfPlaybackThread* dstThread = checkPlaybackThread_l(dstIo);
François Gaffie1b4753e2023-02-06 10:36:33 +01004695 if (dstThread == nullptr) {
4696 ALOGW("%s() bad dstIo %d", __func__, dstIo);
Eric Laurentde070132010-07-13 04:45:46 -07004697 return BAD_VALUE;
4698 }
4699
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004700 IAfPlaybackThread* srcThread = checkPlaybackThread_l(srcIo);
4701 sp<IAfEffectChain> orphanChain = getOrphanEffectChain_l(sessionId);
4702 if (srcThread == nullptr && orphanChain == nullptr && sessionId == AUDIO_SESSION_OUTPUT_MIX) {
4703 ALOGW("%s() AUDIO_SESSION_OUTPUT_MIX not found in orphans, checking other mix", __func__);
4704 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
4705 const sp<IAfPlaybackThread> pt = mPlaybackThreads.valueAt(i);
4706 const uint32_t sessionType = pt->hasAudioSession(AUDIO_SESSION_OUTPUT_MIX);
4707 if ((pt->type() == IAfThreadBase::MIXER || pt->type() == IAfThreadBase::OFFLOAD) &&
4708 ((sessionType & IAfThreadBase::EFFECT_SESSION) != 0)) {
4709 srcThread = pt.get();
Andy Hungae975472024-06-13 16:50:38 -07004710 if (srcThread == dstThread) {
4711 ALOGD("%s() same dst and src threads, ignoring move", __func__);
4712 return NO_ERROR;
4713 }
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004714 ALOGW("%s() found srcOutput %d hosting AUDIO_SESSION_OUTPUT_MIX", __func__,
4715 pt->id());
4716 break;
4717 }
4718 }
4719 }
4720 if (srcThread == nullptr && orphanChain == nullptr) {
4721 ALOGW("moveEffects() bad srcIo %d", srcIo);
4722 return BAD_VALUE;
4723 }
4724 // dstThread pointer validity has already been checked
4725 if (orphanChain != nullptr) {
4726 audio_utils::scoped_lock _ll(dstThread->mutex());
4727 return moveEffectChain_ll(sessionId, nullptr, dstThread, orphanChain.get());
4728 }
4729 // srcThread pointer validity has already been checked
Andy Hunge0f5ec52023-08-30 11:26:06 -07004730 audio_utils::scoped_lock _ll(dstThread->mutex(), srcThread->mutex());
Andy Hung972bec12023-08-31 16:13:39 -07004731 return moveEffectChain_ll(sessionId, srcThread, dstThread);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004732}
4733
Eric Laurentb20cf7d2019-04-05 19:37:34 -07004734
4735void AudioFlinger::setEffectSuspended(int effectId,
4736 audio_session_t sessionId,
4737 bool suspended)
4738{
Andy Hung954b9712023-08-28 18:36:53 -07004739 audio_utils::lock_guard _l(mutex());
Eric Laurentb20cf7d2019-04-05 19:37:34 -07004740
Andy Hung87c693c2023-07-06 20:56:16 -07004741 sp<IAfThreadBase> thread = getEffectThread_l(sessionId, effectId);
Eric Laurentb20cf7d2019-04-05 19:37:34 -07004742 if (thread == nullptr) {
Shunkai Yao8da94182024-02-14 02:49:47 +00004743 return;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07004744 }
Andy Hungc5007f82023-08-29 14:26:09 -07004745 audio_utils::lock_guard _sl(thread->mutex());
Shunkai Yao8da94182024-02-14 02:49:47 +00004746 if (const auto& effect = thread->getEffect_l(sessionId, effectId)) {
4747 thread->setEffectSuspended_l(&effect->desc().type, suspended, sessionId);
4748 }
Eric Laurentb20cf7d2019-04-05 19:37:34 -07004749}
4750
4751
Andy Hung972bec12023-08-31 16:13:39 -07004752// moveEffectChain_ll must be called with the AudioFlinger::mutex()
4753// and both srcThread and dstThread mutex()s held
4754status_t AudioFlinger::moveEffectChain_ll(audio_session_t sessionId,
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004755 IAfPlaybackThread* srcThread, IAfPlaybackThread* dstThread,
4756 IAfEffectChain* srcChain)
Eric Laurentde070132010-07-13 04:45:46 -07004757{
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004758 ALOGV("%s: session %d from thread %p to thread %p %s",
4759 __func__, sessionId, srcThread, dstThread,
4760 (srcChain != nullptr ? "from specific chain" : ""));
4761 ALOG_ASSERT((srcThread != nullptr) != (srcChain != nullptr),
4762 "no source provided for source chain");
Eric Laurentde070132010-07-13 04:45:46 -07004763
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004764 sp<IAfEffectChain> chain =
4765 srcChain != nullptr ? srcChain : srcThread->getEffectChain_l(sessionId);
Eric Laurentde070132010-07-13 04:45:46 -07004766 if (chain == 0) {
Andy Hung972bec12023-08-31 16:13:39 -07004767 ALOGW("%s: effect chain for session %d not on source thread %p",
4768 __func__, sessionId, srcThread);
Eric Laurentde070132010-07-13 04:45:46 -07004769 return INVALID_OPERATION;
4770 }
4771
Eric Laurent4c415062016-06-17 16:14:16 -07004772 // Check whether the destination thread and all effects in the chain are compatible
4773 if (!chain->isCompatibleWithThread_l(dstThread)) {
Andy Hung972bec12023-08-31 16:13:39 -07004774 ALOGW("%s: effect chain failed because"
Eric Laurent4c415062016-06-17 16:14:16 -07004775 " destination thread %p is not compatible with effects in the chain",
Andy Hung972bec12023-08-31 16:13:39 -07004776 __func__, dstThread);
Andy Hung9a592762014-07-21 21:56:01 -07004777 return INVALID_OPERATION;
4778 }
4779
Eric Laurent39e94f82010-07-28 01:32:47 -07004780 // remove chain first. This is useful only if reconfiguring effect chain on same output thread,
Eric Laurentde070132010-07-13 04:45:46 -07004781 // so that a new chain is created with correct parameters when first effect is added. This is
Eric Laurentec35a142011-10-05 17:42:25 -07004782 // otherwise unnecessary as removeEffect_l() will remove the chain when last effect is
Eric Laurentde070132010-07-13 04:45:46 -07004783 // removed.
Andy Hung180f49a2022-01-27 10:25:02 -08004784 // TODO(b/216875016): consider holding the effect chain locks for the duration of the move.
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004785 if (srcThread != nullptr) {
4786 srcThread->removeEffectChain_l(chain);
4787 }
Eric Laurentde070132010-07-13 04:45:46 -07004788 // transfer all effects one by one so that new effect chain is created on new thread with
4789 // correct buffer sizes and audio parameters and effect engines reconfigured accordingly
Andy Hung6ac17eb2023-06-20 18:56:17 -07004790 sp<IAfEffectChain> dstChain;
4791 Vector<sp<IAfEffectModule>> removed;
Eric Laurent5baf2af2013-09-12 17:37:00 -07004792 status_t status = NO_ERROR;
Andy Hung03410c02022-01-27 08:24:31 -08004793 std::string errorString;
Andy Hung920f6572022-10-06 12:09:49 -07004794 // process effects one by one.
Andy Hung6ac17eb2023-06-20 18:56:17 -07004795 for (sp<IAfEffectModule> effect = chain->getEffectFromId_l(0); effect != nullptr;
Andy Hung920f6572022-10-06 12:09:49 -07004796 effect = chain->getEffectFromId_l(0)) {
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004797 if (srcThread != nullptr) {
4798 srcThread->removeEffect_l(effect);
4799 } else {
Shunkai Yao29d10572024-03-19 04:31:47 +00004800 chain->removeEffect(effect);
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004801 }
Eric Laurent5baf2af2013-09-12 17:37:00 -07004802 removed.add(effect);
Andy Hung972bec12023-08-31 16:13:39 -07004803 status = dstThread->addEffect_ll(effect);
Eric Laurent5baf2af2013-09-12 17:37:00 -07004804 if (status != NO_ERROR) {
Andy Hung03410c02022-01-27 08:24:31 -08004805 errorString = StringPrintf(
4806 "cannot add effect %p to destination thread", effect.get());
Eric Laurent5baf2af2013-09-12 17:37:00 -07004807 break;
4808 }
Eric Laurent39e94f82010-07-28 01:32:47 -07004809 // if the move request is not received from audio policy manager, the effect must be
Andy Hung180f49a2022-01-27 10:25:02 -08004810 // re-registered with the new strategy and output.
4811
4812 // We obtain the dstChain once the effect is on the new thread.
4813 if (dstChain == nullptr) {
Andy Hungfda44002021-06-03 17:23:16 -07004814 dstChain = effect->getCallback()->chain().promote();
Andy Hung180f49a2022-01-27 10:25:02 -08004815 if (dstChain == nullptr) {
Andy Hung03410c02022-01-27 08:24:31 -08004816 errorString = StringPrintf("cannot get chain from effect %p", effect.get());
Eric Laurent5baf2af2013-09-12 17:37:00 -07004817 status = NO_INIT;
4818 break;
Eric Laurent39e94f82010-07-28 01:32:47 -07004819 }
Eric Laurent39e94f82010-07-28 01:32:47 -07004820 }
Eric Laurentde070132010-07-13 04:45:46 -07004821 }
4822
Andy Hung03410c02022-01-27 08:24:31 -08004823 size_t restored = 0;
Eric Laurent5baf2af2013-09-12 17:37:00 -07004824 if (status != NO_ERROR) {
Andy Hung180f49a2022-01-27 10:25:02 -08004825 dstChain.clear(); // dstChain is now from the srcThread (could be recreated).
Andy Hung03410c02022-01-27 08:24:31 -08004826 for (const auto& effect : removed) {
Andy Hung5c4dd0d2022-01-27 10:21:59 -08004827 dstThread->removeEffect_l(effect); // Note: Depending on error location, the last
4828 // effect may not have been placed on dstThread.
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004829 if (srcThread != nullptr && srcThread->addEffect_ll(effect) == NO_ERROR) {
Andy Hung03410c02022-01-27 08:24:31 -08004830 ++restored;
Andy Hung180f49a2022-01-27 10:25:02 -08004831 if (dstChain == nullptr) {
4832 dstChain = effect->getCallback()->chain().promote();
4833 }
Andy Hung03410c02022-01-27 08:24:31 -08004834 }
Eric Laurent5baf2af2013-09-12 17:37:00 -07004835 }
4836 }
4837
Andy Hung180f49a2022-01-27 10:25:02 -08004838 // After all the effects have been moved to new thread (or put back) we restart the effects
4839 // because removeEffect_l() has stopped the effect if it is currently active.
4840 size_t started = 0;
4841 if (dstChain != nullptr && !removed.empty()) {
4842 // If we do not take the dstChain lock, it is possible that processing is ongoing
4843 // while we are starting the effect. This can cause glitches with volume,
4844 // see b/202360137.
Andy Hungf65f5a72023-08-29 12:19:17 -07004845 dstChain->mutex().lock();
Andy Hung180f49a2022-01-27 10:25:02 -08004846 for (const auto& effect : removed) {
Andy Hung6ac17eb2023-06-20 18:56:17 -07004847 if (effect->state() == IAfEffectModule::ACTIVE ||
4848 effect->state() == IAfEffectModule::STOPPING) {
Andy Hung180f49a2022-01-27 10:25:02 -08004849 ++started;
Shunkai Yaod125e402024-01-20 03:19:06 +00004850 effect->start_l();
Andy Hung180f49a2022-01-27 10:25:02 -08004851 }
4852 }
Andy Hungf65f5a72023-08-29 12:19:17 -07004853 dstChain->mutex().unlock();
Andy Hung180f49a2022-01-27 10:25:02 -08004854 }
4855
Andy Hung03410c02022-01-27 08:24:31 -08004856 if (status != NO_ERROR) {
4857 if (errorString.empty()) {
4858 errorString = StringPrintf("%s: failed status %d", __func__, status);
4859 }
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004860 ALOGW("%s: %s unsuccessful move of session %d from %s %p to dstThread %p "
Andy Hung180f49a2022-01-27 10:25:02 -08004861 "(%zu effects removed from srcThread, %zu effects restored to srcThread, "
4862 "%zu effects started)",
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004863 __func__, errorString.c_str(), sessionId,
4864 (srcThread != nullptr ? "srcThread" : "srcChain"),
4865 (srcThread != nullptr ? (void*) srcThread : (void*) srcChain), dstThread,
Andy Hung180f49a2022-01-27 10:25:02 -08004866 removed.size(), restored, started);
Andy Hung03410c02022-01-27 08:24:31 -08004867 } else {
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004868 ALOGD("%s: successful move of session %d from %s %p to dstThread %p "
Andy Hung180f49a2022-01-27 10:25:02 -08004869 "(%zu effects moved, %zu effects started)",
Shunkai Yao517fc2a2024-03-19 04:31:47 +00004870 __func__, sessionId, (srcThread != nullptr ? "srcThread" : "srcChain"),
4871 (srcThread != nullptr ? (void*) srcThread : (void*) srcChain), dstThread,
4872 removed.size(), started);
Andy Hung03410c02022-01-27 08:24:31 -08004873 }
Eric Laurent5baf2af2013-09-12 17:37:00 -07004874 return status;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004875}
4876
François Gaffie1b4753e2023-02-06 10:36:33 +01004877
Andy Hung972bec12023-08-31 16:13:39 -07004878// moveEffectChain_ll must be called with both srcThread (if not null) and dstThread (if not null)
Andy Hung954b9712023-08-28 18:36:53 -07004879// mutex()s held
Andy Hung972bec12023-08-31 16:13:39 -07004880status_t AudioFlinger::moveEffectChain_ll(audio_session_t sessionId,
Andy Hung87c693c2023-07-06 20:56:16 -07004881 IAfRecordThread* srcThread, IAfRecordThread* dstThread)
François Gaffie1b4753e2023-02-06 10:36:33 +01004882{
4883 sp<IAfEffectChain> chain = nullptr;
4884 if (srcThread != 0) {
Andy Hung87c693c2023-07-06 20:56:16 -07004885 const Vector<sp<IAfEffectChain>> effectChains = srcThread->getEffectChains_l();
François Gaffie1b4753e2023-02-06 10:36:33 +01004886 for (size_t i = 0; i < effectChains.size(); i ++) {
4887 if (effectChains[i]->sessionId() == sessionId) {
4888 chain = effectChains[i];
4889 break;
4890 }
4891 }
4892 ALOGV_IF(effectChains.size() == 0, "%s: no effect chain on io=%d", __func__,
4893 srcThread->id());
4894 if (chain == nullptr) {
4895 ALOGE("%s wrong session id %d", __func__, sessionId);
4896 return BAD_VALUE;
4897 }
4898 ALOGV("%s: removing effect chain for session=%d io=%d", __func__, sessionId,
4899 srcThread->id());
4900 srcThread->removeEffectChain_l(chain);
4901 } else {
4902 chain = getOrphanEffectChain_l(sessionId);
4903 if (chain == nullptr) {
4904 ALOGE("%s: no orphan effect chain found for session=%d", __func__, sessionId);
4905 return BAD_VALUE;
4906 }
4907 }
4908 if (dstThread != 0) {
4909 ALOGV("%s: adding effect chain for session=%d on io=%d", __func__, sessionId,
4910 dstThread->id());
4911 dstThread->addEffectChain_l(chain);
4912 return NO_ERROR;
4913 }
4914 ALOGV("%s: parking to orphan effect chain for session=%d", __func__, sessionId);
4915 putOrphanEffectChain_l(chain);
4916 return NO_ERROR;
4917}
4918
Eric Laurent6c796322019-04-09 14:13:17 -07004919status_t AudioFlinger::moveAuxEffectToIo(int EffectId,
Andy Hung87c693c2023-07-06 20:56:16 -07004920 const sp<IAfPlaybackThread>& dstThread, sp<IAfPlaybackThread>* srcThread)
Eric Laurent6c796322019-04-09 14:13:17 -07004921{
4922 status_t status = NO_ERROR;
Andy Hung954b9712023-08-28 18:36:53 -07004923 audio_utils::lock_guard _l(mutex());
Andy Hung87c693c2023-07-06 20:56:16 -07004924 const sp<IAfThreadBase> threadBase = getEffectThread_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
4925 const sp<IAfPlaybackThread> thread = threadBase ? threadBase->asIAfPlaybackThread() : nullptr;
Eric Laurent6c796322019-04-09 14:13:17 -07004926
4927 if (EffectId != 0 && thread != 0 && dstThread != thread.get()) {
Andy Hunge0f5ec52023-08-30 11:26:06 -07004928 audio_utils::scoped_lock _ll(dstThread->mutex(), thread->mutex());
Andy Hung6ac17eb2023-06-20 18:56:17 -07004929 sp<IAfEffectChain> srcChain = thread->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
4930 sp<IAfEffectChain> dstChain;
Eric Laurent6c796322019-04-09 14:13:17 -07004931 if (srcChain == 0) {
4932 return INVALID_OPERATION;
4933 }
4934
Andy Hung6ac17eb2023-06-20 18:56:17 -07004935 sp<IAfEffectModule> effect = srcChain->getEffectFromId_l(EffectId);
Eric Laurent6c796322019-04-09 14:13:17 -07004936 if (effect == 0) {
4937 return INVALID_OPERATION;
4938 }
4939 thread->removeEffect_l(effect);
Andy Hung972bec12023-08-31 16:13:39 -07004940 status = dstThread->addEffect_ll(effect);
Eric Laurent6c796322019-04-09 14:13:17 -07004941 if (status != NO_ERROR) {
Andy Hung972bec12023-08-31 16:13:39 -07004942 thread->addEffect_ll(effect);
Eric Laurent6c796322019-04-09 14:13:17 -07004943 status = INVALID_OPERATION;
4944 goto Exit;
4945 }
4946
Andy Hungfda44002021-06-03 17:23:16 -07004947 dstChain = effect->getCallback()->chain().promote();
Eric Laurent6c796322019-04-09 14:13:17 -07004948 if (dstChain == 0) {
Andy Hung972bec12023-08-31 16:13:39 -07004949 thread->addEffect_ll(effect);
Eric Laurent6c796322019-04-09 14:13:17 -07004950 status = INVALID_OPERATION;
4951 }
4952
4953Exit:
4954 // removeEffect_l() has stopped the effect if it was active so it must be restarted
Andy Hung6ac17eb2023-06-20 18:56:17 -07004955 if (effect->state() == IAfEffectModule::ACTIVE ||
4956 effect->state() == IAfEffectModule::STOPPING) {
Shunkai Yaod125e402024-01-20 03:19:06 +00004957 effect->start_l();
Eric Laurent6c796322019-04-09 14:13:17 -07004958 }
4959 }
4960
4961 if (status == NO_ERROR && srcThread != nullptr) {
4962 *srcThread = thread;
4963 }
4964 return status;
4965}
4966
Andy Hung583043b2023-07-17 17:05:00 -07004967bool AudioFlinger::isNonOffloadableGlobalEffectEnabled_l() const
Eric Laurent813e2a72013-08-31 12:59:48 -07004968{
4969 if (mGlobalEffectEnableTime != 0 &&
4970 ((systemTime() - mGlobalEffectEnableTime) < kMinGlobalEffectEnabletimeNs)) {
4971 return true;
4972 }
4973
4974 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Andy Hungab65b182023-09-06 19:41:47 -07004975 const auto thread = mPlaybackThreads.valueAt(i);
4976 audio_utils::lock_guard l(thread->mutex());
4977 const sp<IAfEffectChain> ec = thread->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
Eric Laurent5baf2af2013-09-12 17:37:00 -07004978 if (ec != 0 && ec->isNonOffloadableEnabled()) {
Eric Laurent813e2a72013-08-31 12:59:48 -07004979 return true;
4980 }
4981 }
4982 return false;
4983}
4984
Eric Laurent5baf2af2013-09-12 17:37:00 -07004985void AudioFlinger::onNonOffloadableGlobalEffectEnable()
Eric Laurent813e2a72013-08-31 12:59:48 -07004986{
Andy Hung954b9712023-08-28 18:36:53 -07004987 audio_utils::lock_guard _l(mutex());
Eric Laurent813e2a72013-08-31 12:59:48 -07004988
4989 mGlobalEffectEnableTime = systemTime();
4990
4991 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Andy Hung87c693c2023-07-06 20:56:16 -07004992 const sp<IAfPlaybackThread> t = mPlaybackThreads.valueAt(i);
4993 if (t->type() == IAfThreadBase::OFFLOAD) {
Eric Laurent813e2a72013-08-31 12:59:48 -07004994 t->invalidateTracks(AUDIO_STREAM_MUSIC);
4995 }
4996 }
4997
4998}
4999
Andy Hung6ac17eb2023-06-20 18:56:17 -07005000status_t AudioFlinger::putOrphanEffectChain_l(const sp<IAfEffectChain>& chain)
Eric Laurentaaa44472014-09-12 17:41:50 -07005001{
Eric Laurentd8365c52017-07-16 15:27:05 -07005002 // clear possible suspended state before parking the chain so that it starts in default state
5003 // when attached to a new record thread
5004 chain->setEffectSuspended_l(FX_IID_AEC, false);
5005 chain->setEffectSuspended_l(FX_IID_NS, false);
5006
Glenn Kastend848eb42016-03-08 13:42:11 -08005007 audio_session_t session = chain->sessionId();
Eric Laurentaaa44472014-09-12 17:41:50 -07005008 ssize_t index = mOrphanEffectChains.indexOfKey(session);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07005009 ALOGV("putOrphanEffectChain_l session %d index %zd", session, index);
Eric Laurentaaa44472014-09-12 17:41:50 -07005010 if (index >= 0) {
5011 ALOGW("putOrphanEffectChain_l chain for session %d already present", session);
5012 return ALREADY_EXISTS;
5013 }
5014 mOrphanEffectChains.add(session, chain);
5015 return NO_ERROR;
5016}
5017
Andy Hung6ac17eb2023-06-20 18:56:17 -07005018sp<IAfEffectChain> AudioFlinger::getOrphanEffectChain_l(audio_session_t session)
Eric Laurentaaa44472014-09-12 17:41:50 -07005019{
Andy Hung6ac17eb2023-06-20 18:56:17 -07005020 sp<IAfEffectChain> chain;
Eric Laurentaaa44472014-09-12 17:41:50 -07005021 ssize_t index = mOrphanEffectChains.indexOfKey(session);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07005022 ALOGV("getOrphanEffectChain_l session %d index %zd", session, index);
Eric Laurentaaa44472014-09-12 17:41:50 -07005023 if (index >= 0) {
5024 chain = mOrphanEffectChains.valueAt(index);
5025 mOrphanEffectChains.removeItemsAt(index);
5026 }
5027 return chain;
5028}
5029
Andy Hung6ac17eb2023-06-20 18:56:17 -07005030bool AudioFlinger::updateOrphanEffectChains(const sp<IAfEffectModule>& effect)
Eric Laurentaaa44472014-09-12 17:41:50 -07005031{
Andy Hung954b9712023-08-28 18:36:53 -07005032 audio_utils::lock_guard _l(mutex());
François Gaffie1b4753e2023-02-06 10:36:33 +01005033 return updateOrphanEffectChains_l(effect);
5034}
5035
5036bool AudioFlinger::updateOrphanEffectChains_l(const sp<IAfEffectModule>& effect)
5037{
Glenn Kastend848eb42016-03-08 13:42:11 -08005038 audio_session_t session = effect->sessionId();
Eric Laurentaaa44472014-09-12 17:41:50 -07005039 ssize_t index = mOrphanEffectChains.indexOfKey(session);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07005040 ALOGV("updateOrphanEffectChains session %d index %zd", session, index);
Eric Laurentaaa44472014-09-12 17:41:50 -07005041 if (index >= 0) {
Andy Hung6ac17eb2023-06-20 18:56:17 -07005042 sp<IAfEffectChain> chain = mOrphanEffectChains.valueAt(index);
Shunkai Yao29d10572024-03-19 04:31:47 +00005043 if (chain->removeEffect(effect, true) == 0) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07005044 ALOGV("updateOrphanEffectChains removing effect chain at index %zd", index);
Eric Laurentaaa44472014-09-12 17:41:50 -07005045 mOrphanEffectChains.removeItemsAt(index);
5046 }
5047 return true;
5048 }
5049 return false;
5050}
5051
Andy Hung00b9aea2023-07-18 18:43:08 -07005052// ----------------------------------------------------------------------------
5053// from PatchPanel
5054
5055/* List connected audio ports and their attributes */
5056status_t AudioFlinger::listAudioPorts(unsigned int* num_ports,
5057 struct audio_port* ports) const
5058{
Andy Hung954b9712023-08-28 18:36:53 -07005059 audio_utils::lock_guard _l(mutex());
Andy Hung37006372023-08-31 15:24:24 -07005060 return mPatchPanel->listAudioPorts_l(num_ports, ports);
Andy Hung00b9aea2023-07-18 18:43:08 -07005061}
5062
5063/* Get supported attributes for a given audio port */
5064status_t AudioFlinger::getAudioPort(struct audio_port_v7* port) const {
5065 const status_t status = AudioValidator::validateAudioPort(*port);
5066 if (status != NO_ERROR) {
5067 return status;
5068 }
5069
Andy Hung954b9712023-08-28 18:36:53 -07005070 audio_utils::lock_guard _l(mutex());
Andy Hung37006372023-08-31 15:24:24 -07005071 return mPatchPanel->getAudioPort_l(port);
Andy Hung00b9aea2023-07-18 18:43:08 -07005072}
5073
5074/* Connect a patch between several source and sink ports */
5075status_t AudioFlinger::createAudioPatch(
5076 const struct audio_patch* patch, audio_patch_handle_t* handle)
5077{
5078 const status_t status = AudioValidator::validateAudioPatch(*patch);
5079 if (status != NO_ERROR) {
5080 return status;
5081 }
5082
Andy Hung954b9712023-08-28 18:36:53 -07005083 audio_utils::lock_guard _l(mutex());
Andy Hung37006372023-08-31 15:24:24 -07005084 return mPatchPanel->createAudioPatch_l(patch, handle);
Andy Hung00b9aea2023-07-18 18:43:08 -07005085}
5086
5087/* Disconnect a patch */
5088status_t AudioFlinger::releaseAudioPatch(audio_patch_handle_t handle)
5089{
Andy Hung954b9712023-08-28 18:36:53 -07005090 audio_utils::lock_guard _l(mutex());
Andy Hung37006372023-08-31 15:24:24 -07005091 return mPatchPanel->releaseAudioPatch_l(handle);
Andy Hung00b9aea2023-07-18 18:43:08 -07005092}
5093
5094/* List connected audio ports and they attributes */
5095status_t AudioFlinger::listAudioPatches(
5096 unsigned int* num_patches, struct audio_patch* patches) const
5097{
Andy Hung954b9712023-08-28 18:36:53 -07005098 audio_utils::lock_guard _l(mutex());
Andy Hung37006372023-08-31 15:24:24 -07005099 return mPatchPanel->listAudioPatches_l(num_patches, patches);
Andy Hung00b9aea2023-07-18 18:43:08 -07005100}
Eric Laurentaaa44472014-09-12 17:41:50 -07005101
jiabin12537fc2023-10-12 17:56:08 +00005102/**
5103 * Get the attributes of the mix port when connecting to the given device port.
5104 */
5105status_t AudioFlinger::getAudioMixPort(const struct audio_port_v7 *devicePort,
5106 struct audio_port_v7 *mixPort) const {
5107 if (status_t status = AudioValidator::validateAudioPort(*devicePort); status != NO_ERROR) {
5108 ALOGE("%s, invalid device port, status=%d", __func__, status);
5109 return status;
5110 }
5111 if (status_t status = AudioValidator::validateAudioPort(*mixPort); status != NO_ERROR) {
5112 ALOGE("%s, invalid mix port, status=%d", __func__, status);
5113 return status;
5114 }
5115
5116 audio_utils::lock_guard _l(mutex());
5117 return mPatchPanel->getAudioMixPort_l(devicePort, mixPort);
5118}
5119
jiabin220eea12024-05-17 17:55:20 +00005120status_t AudioFlinger::setTracksInternalMute(
5121 const std::vector<media::TrackInternalMuteInfo>& tracksInternalMute) {
5122 audio_utils::lock_guard _l(mutex());
5123 ALOGV("%s", __func__);
5124
5125 std::map<audio_port_handle_t, bool> tracksInternalMuteMap;
5126 for (const auto& trackInternalMute : tracksInternalMute) {
5127 audio_port_handle_t portId = VALUE_OR_RETURN_STATUS(
5128 aidl2legacy_int32_t_audio_port_handle_t(trackInternalMute.portId));
5129 tracksInternalMuteMap.emplace(portId, trackInternalMute.muted);
5130 }
5131 for (size_t i = 0; i < mPlaybackThreads.size() && !tracksInternalMuteMap.empty(); i++) {
5132 mPlaybackThreads.valueAt(i)->setTracksInternalMute(&tracksInternalMuteMap);
5133 }
5134 return NO_ERROR;
5135}
5136
Shraddha Basantwania6dadac2024-06-06 16:28:52 +00005137status_t AudioFlinger::resetReferencesForTest() {
5138 mDeviceEffectManager.clear();
5139 mPatchPanel.clear();
5140 mMelReporter->resetReferencesForTest();
5141 return NO_ERROR;
5142}
5143
Mathias Agopian65ab4712010-07-14 17:59:35 -07005144// ----------------------------------------------------------------------------
5145
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -07005146status_t AudioFlinger::onTransactWrapper(TransactionCode code,
Jing Mike537412f2023-03-12 11:01:47 +08005147 [[maybe_unused]] const Parcel& data,
5148 [[maybe_unused]] uint32_t flags,
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -07005149 const std::function<status_t()>& delegate) {
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005150 // make sure transactions reserved to AudioPolicyManager do not come from other processes
5151 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08005152 case TransactionCode::SET_STREAM_VOLUME:
5153 case TransactionCode::SET_STREAM_MUTE:
5154 case TransactionCode::OPEN_OUTPUT:
5155 case TransactionCode::OPEN_DUPLICATE_OUTPUT:
5156 case TransactionCode::CLOSE_OUTPUT:
5157 case TransactionCode::SUSPEND_OUTPUT:
5158 case TransactionCode::RESTORE_OUTPUT:
5159 case TransactionCode::OPEN_INPUT:
5160 case TransactionCode::CLOSE_INPUT:
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08005161 case TransactionCode::SET_VOICE_VOLUME:
5162 case TransactionCode::MOVE_EFFECTS:
5163 case TransactionCode::SET_EFFECT_SUSPENDED:
5164 case TransactionCode::LOAD_HW_MODULE:
5165 case TransactionCode::GET_AUDIO_PORT:
5166 case TransactionCode::CREATE_AUDIO_PATCH:
5167 case TransactionCode::RELEASE_AUDIO_PATCH:
5168 case TransactionCode::LIST_AUDIO_PATCHES:
5169 case TransactionCode::SET_AUDIO_PORT_CONFIG:
5170 case TransactionCode::SET_RECORD_SILENCED:
Eric Laurentd66d7a12021-07-13 13:35:32 +02005171 case TransactionCode::AUDIO_POLICY_READY:
Mikhail Naganov516d3982022-02-01 23:53:59 +00005172 case TransactionCode::SET_DEVICE_CONNECTED_STATE:
Eric Laurent076e7c72022-05-03 18:12:28 +02005173 case TransactionCode::SET_REQUESTED_LATENCY_MODE:
5174 case TransactionCode::GET_SUPPORTED_LATENCY_MODES:
jiabinc44b3462022-12-08 12:52:31 -08005175 case TransactionCode::INVALIDATE_TRACKS:
Mikhail Naganovffd97712023-05-03 17:45:36 -07005176 case TransactionCode::GET_AUDIO_POLICY_CONFIG:
jiabin12537fc2023-10-12 17:56:08 +00005177 case TransactionCode::GET_AUDIO_MIX_PORT:
jiabin220eea12024-05-17 17:55:20 +00005178 case TransactionCode::SET_TRACKS_INTERNAL_MUTE:
Shraddha Basantwania6dadac2024-06-06 16:28:52 +00005179 case TransactionCode::RESET_REFERENCES_FOR_TEST:
Andy Hung6b137d12024-08-27 22:35:17 +00005180 case TransactionCode::SET_PORTS_VOLUME:
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005181 ALOGW("%s: transaction %d received from PID %d",
Andy Hungf7786a42024-02-08 21:19:47 -08005182 __func__, static_cast<int>(code), IPCThreadState::self()->getCallingPid());
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005183 // return status only for non void methods
5184 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08005185 case TransactionCode::SET_RECORD_SILENCED:
5186 case TransactionCode::SET_EFFECT_SUSPENDED:
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005187 break;
5188 default:
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08005189 return INVALID_OPERATION;
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005190 }
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -07005191 // Fail silently in these cases.
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005192 return OK;
5193 default:
5194 break;
5195 }
5196
5197 // make sure the following transactions come from system components
5198 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08005199 case TransactionCode::SET_MASTER_VOLUME:
5200 case TransactionCode::SET_MASTER_MUTE:
Jean-Michel Trivie4f113b2020-11-16 11:50:33 -08005201 case TransactionCode::MASTER_MUTE:
Vlad Popae3fd1c22022-11-07 21:03:18 +01005202 case TransactionCode::GET_SOUND_DOSE_INTERFACE:
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08005203 case TransactionCode::SET_MODE:
5204 case TransactionCode::SET_MIC_MUTE:
5205 case TransactionCode::SET_LOW_RAM_DEVICE:
5206 case TransactionCode::SYSTEM_READY:
jiabin1319f5a2021-03-30 22:21:24 +00005207 case TransactionCode::SET_AUDIO_HAL_PIDS:
jiabinf042b9b2021-05-07 23:46:28 +00005208 case TransactionCode::SET_VIBRATOR_INFOS:
Eric Laurent52057642022-12-16 11:45:07 +01005209 case TransactionCode::UPDATE_SECONDARY_OUTPUTS:
Eric Laurent50d72582022-12-20 20:20:23 +01005210 case TransactionCode::SET_BLUETOOTH_VARIABLE_LATENCY_ENABLED:
5211 case TransactionCode::IS_BLUETOOTH_VARIABLE_LATENCY_ENABLED:
5212 case TransactionCode::SUPPORTS_BLUETOOTH_VARIABLE_LATENCY: {
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005213 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
5214 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
Andy Hungf7786a42024-02-08 21:19:47 -08005215 __func__, static_cast<int>(code),
5216 IPCThreadState::self()->getCallingPid(),
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005217 IPCThreadState::self()->getCallingUid());
Vlad Popa63f047e2022-11-05 14:09:19 +01005218 // return status only for non-void methods
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005219 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08005220 case TransactionCode::SYSTEM_READY:
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005221 break;
5222 default:
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08005223 return INVALID_OPERATION;
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005224 }
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -07005225 // Fail silently in these cases.
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005226 return OK;
5227 }
5228 } break;
5229 default:
5230 break;
5231 }
5232
5233 // List of relevant events that trigger log merging.
5234 // Log merging should activate during audio activity of any kind. This are considered the
5235 // most relevant events.
5236 // TODO should select more wisely the items from the list
5237 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08005238 case TransactionCode::CREATE_TRACK:
5239 case TransactionCode::CREATE_RECORD:
5240 case TransactionCode::SET_MASTER_VOLUME:
5241 case TransactionCode::SET_MASTER_MUTE:
5242 case TransactionCode::SET_MIC_MUTE:
5243 case TransactionCode::SET_PARAMETERS:
5244 case TransactionCode::CREATE_EFFECT:
5245 case TransactionCode::SYSTEM_READY: {
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005246 requestLogMerge();
5247 break;
5248 }
5249 default:
5250 break;
5251 }
5252
Andy Hungc747c532022-03-07 21:41:14 -08005253 const std::string methodName = getIAudioFlingerStatistics().getMethodForCode(code);
5254 mediautils::TimeCheck check(
5255 std::string("IAudioFlinger::").append(methodName),
5256 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
5257 if (timeout) {
5258 mediametrics::LogItem(mMetricsId)
5259 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
5260 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
5261 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
5262 .record();
5263 } else {
5264 getIAudioFlingerStatistics().event(code, elapsedMs);
5265 }
Andy Hung7cd77742024-08-06 15:17:16 -07005266 }, mediautils::TimeCheck::getDefaultTimeoutDuration(),
5267 mediautils::TimeCheck::getDefaultSecondChanceDuration(),
Atneya Nairc5b34362024-08-27 17:31:38 -07005268 !property_get_bool("audio.timecheck.disabled", false) /* crashOnTimeout */);
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08005269
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -07005270 return delegate();
Mathias Agopian65ab4712010-07-14 17:59:35 -07005271}
5272
Glenn Kasten63238ef2015-03-02 15:50:29 -08005273} // namespace android