blob: 3e9400be20dbc110ccb0778f791a9f7334c20e8d [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
18
19#define LOG_TAG "AudioFlinger"
20//#define LOG_NDEBUG 0
21
jiabina392a552019-09-23 10:34:20 -070022// Define AUDIO_ARRAYS_STATIC_CHECK to check all audio arrays are correct
23#define AUDIO_ARRAYS_STATIC_CHECK 1
24
Glenn Kasten153b9fe2013-07-15 11:23:36 -070025#include "Configuration.h"
Glenn Kastenda6ef132013-01-10 12:31:01 -080026#include <dirent.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070027#include <math.h>
28#include <signal.h>
Eric Tan7b651152018-07-13 10:17:19 -070029#include <string>
Mathias Agopian65ab4712010-07-14 17:59:35 -070030#include <sys/time.h>
31#include <sys/resource.h>
Mikhail Naganov88b30d22020-03-09 19:43:13 +000032#include <thread>
Mathias Agopian65ab4712010-07-14 17:59:35 -070033
Andy Hung03410c02022-01-27 08:24:31 -080034#include <android-base/stringprintf.h>
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080035#include <android/media/IAudioPolicyService.h>
jiabin57303cc2018-12-18 15:45:57 -080036#include <android/os/IExternalVibratorService.h>
Gloria Wang9ee159b2011-02-24 14:51:45 -080037#include <binder/IPCThreadState.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070038#include <binder/IServiceManager.h>
39#include <utils/Log.h>
Glenn Kastend8e6fd32012-05-07 11:07:57 -070040#include <utils/Trace.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070041#include <binder/Parcel.h>
Mikhail Naganova0c91332016-09-19 10:01:12 -070042#include <media/audiohal/DeviceHalInterface.h>
43#include <media/audiohal/DevicesFactoryHalInterface.h>
44#include <media/audiohal/EffectsFactoryHalInterface.h>
Mikhail Naganov00260b52016-10-13 12:54:24 -070045#include <media/AudioParameter.h>
Andy Hungb68f5eb2019-12-03 16:49:17 -080046#include <media/MediaMetricsItem.h>
Mikhail Naganov913d06c2016-11-01 12:49:22 -070047#include <media/TypeConverter.h>
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -080048#include <mediautils/TimeCheck.h>
Andy Hung35fec5f2016-04-13 14:21:48 -070049#include <memunreachable/memunreachable.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070050#include <utils/String16.h>
51#include <utils/threads.h>
52
Steven Morelandf0c02ce2018-02-23 14:53:55 -080053#include <cutils/atomic.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070054#include <cutils/properties.h>
55
Dima Zavin64760242011-05-11 14:15:23 -070056#include <system/audio.h>
Vlad Popae8d99472022-06-30 16:02:48 +020057#include <audiomanager/IAudioManager.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070058
Mathias Agopian65ab4712010-07-14 17:59:35 -070059#include "AudioFlinger.h"
Andy Hung8946a282018-04-19 20:04:56 -070060#include "NBAIO_Tee.h"
Jiabin Huangebe64102021-09-07 20:01:07 +000061#include "PropertyUtils.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070062
Andy Hung6770c6f2015-04-07 13:43:36 -070063#include <media/AudioResamplerPublic.h>
64
Mikhail Naganov9fe94012016-10-14 14:57:40 -070065#include <system/audio_effects/effect_visualizer.h>
66#include <system/audio_effects/effect_ns.h>
67#include <system/audio_effects/effect_aec.h>
jiabineb3bda02020-06-30 14:07:03 -070068#include <system/audio_effects/effect_hapticgenerator.h>
Eric Laurentf690c462021-09-17 14:47:03 +020069#include <system/audio_effects/effect_spatializer.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070070
Glenn Kasten3b21c502011-12-15 09:52:39 -080071#include <audio_utils/primitives.h>
72
Eric Laurentfeb0db62011-07-22 09:04:31 -070073#include <powermanager/PowerManager.h>
Glenn Kasten190a46f2012-03-06 11:27:10 -080074
Glenn Kasten9e58b552013-01-18 15:09:48 -080075#include <media/IMediaLogService.h>
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -070076#include <media/AidlConversion.h>
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -080077#include <media/AudioValidator.h>
Glenn Kastenda6ef132013-01-10 12:31:01 -080078#include <media/nbaio/Pipe.h>
79#include <media/nbaio/PipeReader.h>
Wei Jia3f273d12015-11-24 09:06:49 -080080#include <mediautils/BatteryNotifier.h>
Andy Hunge9eb03e2020-04-04 14:08:23 -070081#include <mediautils/MemoryLeakTrackUtil.h>
Andy Hungc747c532022-03-07 21:41:14 -080082#include <mediautils/MethodStatistics.h>
Andy Hungab7ef302018-05-15 19:35:29 -070083#include <mediautils/ServiceUtilities.h>
Eric Laurent42896a02019-09-27 15:40:33 -070084#include <mediautils/TimeCheck.h>
Glenn Kasten4182c4e2013-07-15 14:45:07 -070085#include <private/android_filesystem_config.h>
Glenn Kastenda6ef132013-01-10 12:31:01 -080086
rago3bd1c872016-09-26 12:58:14 -070087//#define BUFLOG_NDEBUG 0
88#include <BufLog.h>
89
Nicolas Rouletfe1e1442017-01-30 12:02:03 -080090#include "TypedLogger.h"
91
Mathias Agopian65ab4712010-07-14 17:59:35 -070092// ----------------------------------------------------------------------------
Mathias Agopian65ab4712010-07-14 17:59:35 -070093
John Grossman1c345192012-03-27 14:00:17 -070094// Note: the following macro is used for extremely verbose logging message. In
95// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
96// 0; but one side effect of this is to turn all LOGV's as well. Some messages
97// are so verbose that we want to suppress them even when we have ALOG_ASSERT
98// turned on. Do not uncomment the #def below unless you really know what you
99// are doing and want to see all of the extremely verbose messages.
100//#define VERY_VERY_VERBOSE_LOGGING
101#ifdef VERY_VERY_VERBOSE_LOGGING
102#define ALOGVV ALOGV
103#else
104#define ALOGVV(a...) do { } while(0)
105#endif
Eric Laurentde070132010-07-13 04:45:46 -0700106
Mathias Agopian65ab4712010-07-14 17:59:35 -0700107namespace android {
108
jiabina4ff38f2022-02-11 19:42:25 +0000109#define MAX_AAUDIO_PROPERTY_DEVICE_HAL_VERSION 7.1
jiabine504e7b2021-09-18 00:27:08 +0000110
Andy Hung03410c02022-01-27 08:24:31 -0800111using ::android::base::StringPrintf;
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700112using media::IEffectClient;
jiabine99d0882021-09-17 05:21:25 +0000113using media::audio::common::AudioMMapPolicyInfo;
114using media::audio::common::AudioMMapPolicyType;
Svet Ganov33761132021-05-13 22:51:08 +0000115using android::content::AttributionSourceState;
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700116
Vlad Popae8d99472022-06-30 16:02:48 +0200117static constexpr char kDeadlockedString[] = "AudioFlinger may be deadlocked\n";
118static constexpr char kHardwareLockedString[] = "Hardware lock is taken\n";
119static constexpr char kClientLockedString[] = "Client lock is taken\n";
120static constexpr char kNoEffectsFactory[] = "Effects Factory is absent\n";
Mathias Agopian65ab4712010-07-14 17:59:35 -0700121
Vlad Popae8d99472022-06-30 16:02:48 +0200122static constexpr char kAudioServiceName[] = "audio";
Glenn Kasten58912562012-04-03 10:45:00 -0700123
John Grossman4ff14ba2012-02-08 16:37:41 -0800124nsecs_t AudioFlinger::mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs;
Eric Laurent7cafbb32011-11-22 18:50:29 -0800125
Eric Laurent81784c32012-11-19 14:55:58 -0800126uint32_t AudioFlinger::mScreenState;
Glenn Kasten3ed29202012-08-07 15:24:44 -0700127
Eric Laurent813e2a72013-08-31 12:59:48 -0700128// In order to avoid invalidating offloaded tracks each time a Visualizer is turned on and off
129// we define a minimum time during which a global effect is considered enabled.
130static const nsecs_t kMinGlobalEffectEnabletimeNs = seconds(7200);
131
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700132// Keep a strong reference to media.log service around forever.
133// The service is within our parent process so it can never die in a way that we could observe.
134// These two variables are const after initialization.
135static sp<IBinder> sMediaLogServiceAsBinder;
136static sp<IMediaLogService> sMediaLogService;
137
138static pthread_once_t sMediaLogOnce = PTHREAD_ONCE_INIT;
139
140static void sMediaLogInit()
141{
142 sMediaLogServiceAsBinder = defaultServiceManager()->getService(String16("media.log"));
143 if (sMediaLogServiceAsBinder != 0) {
144 sMediaLogService = interface_cast<IMediaLogService>(sMediaLogServiceAsBinder);
145 }
146}
147
jiabin57303cc2018-12-18 15:45:57 -0800148// Keep a strong reference to external vibrator service
149static sp<os::IExternalVibratorService> sExternalVibratorService;
150
151static sp<os::IExternalVibratorService> getExternalVibratorService() {
152 if (sExternalVibratorService == 0) {
Eric Laurent00abf0d2020-04-22 19:28:22 -0700153 sp<IBinder> binder = defaultServiceManager()->getService(
jiabin57303cc2018-12-18 15:45:57 -0800154 String16("external_vibrator_service"));
155 if (binder != 0) {
156 sExternalVibratorService =
157 interface_cast<os::IExternalVibratorService>(binder);
158 }
159 }
160 return sExternalVibratorService;
161}
162
Andy Hungc747c532022-03-07 21:41:14 -0800163// Creates association between Binder code to name for IAudioFlinger.
164#define IAUDIOFLINGER_BINDER_METHOD_MACRO_LIST \
165BINDER_METHOD_ENTRY(createTrack) \
166BINDER_METHOD_ENTRY(createRecord) \
167BINDER_METHOD_ENTRY(sampleRate) \
168BINDER_METHOD_ENTRY(format) \
169BINDER_METHOD_ENTRY(frameCount) \
170BINDER_METHOD_ENTRY(latency) \
171BINDER_METHOD_ENTRY(setMasterVolume) \
172BINDER_METHOD_ENTRY(setMasterMute) \
173BINDER_METHOD_ENTRY(masterVolume) \
174BINDER_METHOD_ENTRY(masterMute) \
175BINDER_METHOD_ENTRY(setStreamVolume) \
176BINDER_METHOD_ENTRY(setStreamMute) \
177BINDER_METHOD_ENTRY(streamVolume) \
178BINDER_METHOD_ENTRY(streamMute) \
179BINDER_METHOD_ENTRY(setMode) \
180BINDER_METHOD_ENTRY(setMicMute) \
181BINDER_METHOD_ENTRY(getMicMute) \
182BINDER_METHOD_ENTRY(setRecordSilenced) \
183BINDER_METHOD_ENTRY(setParameters) \
184BINDER_METHOD_ENTRY(getParameters) \
185BINDER_METHOD_ENTRY(registerClient) \
186BINDER_METHOD_ENTRY(getInputBufferSize) \
187BINDER_METHOD_ENTRY(openOutput) \
188BINDER_METHOD_ENTRY(openDuplicateOutput) \
189BINDER_METHOD_ENTRY(closeOutput) \
190BINDER_METHOD_ENTRY(suspendOutput) \
191BINDER_METHOD_ENTRY(restoreOutput) \
192BINDER_METHOD_ENTRY(openInput) \
193BINDER_METHOD_ENTRY(closeInput) \
194BINDER_METHOD_ENTRY(invalidateStream) \
195BINDER_METHOD_ENTRY(setVoiceVolume) \
196BINDER_METHOD_ENTRY(getRenderPosition) \
197BINDER_METHOD_ENTRY(getInputFramesLost) \
198BINDER_METHOD_ENTRY(newAudioUniqueId) \
199BINDER_METHOD_ENTRY(acquireAudioSessionId) \
200BINDER_METHOD_ENTRY(releaseAudioSessionId) \
201BINDER_METHOD_ENTRY(queryNumberEffects) \
202BINDER_METHOD_ENTRY(queryEffect) \
203BINDER_METHOD_ENTRY(getEffectDescriptor) \
204BINDER_METHOD_ENTRY(createEffect) \
205BINDER_METHOD_ENTRY(moveEffects) \
206BINDER_METHOD_ENTRY(loadHwModule) \
207BINDER_METHOD_ENTRY(getPrimaryOutputSamplingRate) \
208BINDER_METHOD_ENTRY(getPrimaryOutputFrameCount) \
209BINDER_METHOD_ENTRY(setLowRamDevice) \
210BINDER_METHOD_ENTRY(getAudioPort) \
211BINDER_METHOD_ENTRY(createAudioPatch) \
212BINDER_METHOD_ENTRY(releaseAudioPatch) \
213BINDER_METHOD_ENTRY(listAudioPatches) \
214BINDER_METHOD_ENTRY(setAudioPortConfig) \
215BINDER_METHOD_ENTRY(getAudioHwSyncForSession) \
216BINDER_METHOD_ENTRY(systemReady) \
217BINDER_METHOD_ENTRY(audioPolicyReady) \
218BINDER_METHOD_ENTRY(frameCountHAL) \
219BINDER_METHOD_ENTRY(getMicrophones) \
220BINDER_METHOD_ENTRY(setMasterBalance) \
221BINDER_METHOD_ENTRY(getMasterBalance) \
222BINDER_METHOD_ENTRY(setEffectSuspended) \
223BINDER_METHOD_ENTRY(setAudioHalPids) \
224BINDER_METHOD_ENTRY(setVibratorInfos) \
225BINDER_METHOD_ENTRY(updateSecondaryOutputs) \
226BINDER_METHOD_ENTRY(getMmapPolicyInfos) \
227BINDER_METHOD_ENTRY(getAAudioMixerBurstCount) \
228BINDER_METHOD_ENTRY(getAAudioHardwareBurstMinUsec) \
229BINDER_METHOD_ENTRY(setDeviceConnectedState) \
Eric Laurent076e7c72022-05-03 18:12:28 +0200230BINDER_METHOD_ENTRY(setRequestedLatencyMode) \
231BINDER_METHOD_ENTRY(getSupportedLatencyModes) \
232
Andy Hungc747c532022-03-07 21:41:14 -0800233
234// singleton for Binder Method Statistics for IAudioFlinger
235static auto& getIAudioFlingerStatistics() {
236 using Code = android::AudioFlingerServerAdapter::Delegate::TransactionCode;
237
238#pragma push_macro("BINDER_METHOD_ENTRY")
239#undef BINDER_METHOD_ENTRY
240#define BINDER_METHOD_ENTRY(ENTRY) \
241 {(Code)media::BnAudioFlingerService::TRANSACTION_##ENTRY, #ENTRY},
242
243 static mediautils::MethodStatistics<Code> methodStatistics{
244 IAUDIOFLINGER_BINDER_METHOD_MACRO_LIST
245 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
246 };
247#pragma pop_macro("BINDER_METHOD_ENTRY")
248
249 return methodStatistics;
250}
251
Mikhail Naganov88b30d22020-03-09 19:43:13 +0000252class DevicesFactoryHalCallbackImpl : public DevicesFactoryHalCallback {
253 public:
254 void onNewDevicesAvailable() override {
255 // Start a detached thread to execute notification in parallel.
256 // This is done to prevent mutual blocking of audio_flinger and
257 // audio_policy services during system initialization.
258 std::thread notifier([]() {
259 AudioSystem::onNewAudioModulesAvailable();
260 });
261 notifier.detach();
262 }
263};
264
Svet Ganov33761132021-05-13 22:51:08 +0000265// TODO b/182392769: use attribution source util
Eric Laurentec376dc2021-04-08 20:41:22 +0200266/* static */
Svet Ganov33761132021-05-13 22:51:08 +0000267AttributionSourceState AudioFlinger::checkAttributionSourcePackage(
268 const AttributionSourceState& attributionSource) {
Eric Laurentec376dc2021-04-08 20:41:22 +0200269 Vector<String16> packages;
Svet Ganov33761132021-05-13 22:51:08 +0000270 PermissionController{}.getPackagesForUid(attributionSource.uid, packages);
Eric Laurentec376dc2021-04-08 20:41:22 +0200271
Svet Ganov33761132021-05-13 22:51:08 +0000272 AttributionSourceState checkedAttributionSource = attributionSource;
273 if (!attributionSource.packageName.has_value()
274 || attributionSource.packageName.value().size() == 0) {
Eric Laurentec376dc2021-04-08 20:41:22 +0200275 if (!packages.isEmpty()) {
Svet Ganov33761132021-05-13 22:51:08 +0000276 checkedAttributionSource.packageName =
Eric Laurentec376dc2021-04-08 20:41:22 +0200277 std::move(legacy2aidl_String16_string(packages[0]).value());
278 }
279 } else {
280 String16 opPackageLegacy = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000281 aidl2legacy_string_view_String16(attributionSource.packageName.value_or("")));
Eric Laurentec376dc2021-04-08 20:41:22 +0200282 if (std::find_if(packages.begin(), packages.end(),
283 [&opPackageLegacy](const auto& package) {
284 return opPackageLegacy == package; }) == packages.end()) {
285 ALOGW("The package name(%s) provided does not correspond to the uid %d",
Svet Ganov33761132021-05-13 22:51:08 +0000286 attributionSource.packageName.value_or("").c_str(), attributionSource.uid);
287 checkedAttributionSource.packageName = std::optional<std::string>();
Eric Laurentec376dc2021-04-08 20:41:22 +0200288 }
289 }
Svet Ganov33761132021-05-13 22:51:08 +0000290 return checkedAttributionSource;
Eric Laurentec376dc2021-04-08 20:41:22 +0200291}
292
Mathias Agopian65ab4712010-07-14 17:59:35 -0700293// ----------------------------------------------------------------------------
294
Mikhail Naganov913d06c2016-11-01 12:49:22 -0700295std::string formatToString(audio_format_t format) {
296 std::string result;
297 FormatConverter::toString(format, result);
298 return result;
Marco Nelissenb2208842014-02-07 14:00:50 -0800299}
300
Mathias Agopian65ab4712010-07-14 17:59:35 -0700301// ----------------------------------------------------------------------------
302
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800303void AudioFlinger::instantiate() {
304 sp<IServiceManager> sm(defaultServiceManager());
305 sm->addService(String16(IAudioFlinger::DEFAULT_SERVICE_NAME),
306 new AudioFlingerServerAdapter(new AudioFlinger()), false,
307 IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT);
308}
309
Mathias Agopian65ab4712010-07-14 17:59:35 -0700310AudioFlinger::AudioFlinger()
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800311 : mMediaLogNotifier(new AudioFlinger::MediaLogNotifier()),
John Grossman4ff14ba2012-02-08 16:37:41 -0800312 mPrimaryHardwareDev(NULL),
Glenn Kasten9ea65d02014-01-17 10:21:24 -0800313 mAudioHwDevs(NULL),
Glenn Kasten7d6c35b2012-07-02 12:45:10 -0700314 mHardwareStatus(AUDIO_HW_IDLE),
John Grossman4ff14ba2012-02-08 16:37:41 -0800315 mMasterVolume(1.0f),
John Grossman4ff14ba2012-02-08 16:37:41 -0800316 mMasterMute(false),
Glenn Kastend2e67e12016-04-11 08:26:37 -0700317 // mNextUniqueId(AUDIO_UNIQUE_ID_USE_MAX),
John Grossman4ff14ba2012-02-08 16:37:41 -0800318 mMode(AUDIO_MODE_INVALID),
Glenn Kasten4182c4e2013-07-15 14:45:07 -0700319 mBtNrecIsOff(false),
320 mIsLowRamDevice(true),
Eric Laurent813e2a72013-08-31 12:59:48 -0700321 mIsDeviceTypeKnown(false),
Andy Hung6f248bb2018-01-23 14:04:37 -0800322 mTotalMemory(0),
323 mClientSharedHeapSize(kMinimumClientSharedHeapSizeBytes),
Glenn Kasten4ea00a22014-06-02 08:29:22 -0700324 mGlobalEffectEnableTime(0),
Mikhail Naganovdea53042018-04-26 13:10:21 -0700325 mPatchPanel(this),
Eric Laurentb82e6b72019-11-22 17:25:04 -0800326 mDeviceEffectManager(this),
Eric Laurent72e3f392015-05-20 14:43:50 -0700327 mSystemReady(false)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700328{
Eric Laurentf43be0c2021-03-25 10:45:53 +0100329 // Move the audio session unique ID generator start base as time passes to limit risk of
330 // generating the same ID again after an audioserver restart.
331 // This is important because clients will reuse previously allocated audio session IDs
332 // when reconnecting after an audioserver restart and newly allocated IDs may conflict with
333 // active clients.
334 // Moving the base by 1 for each elapsed second is a good compromise between avoiding overlap
335 // between allocation ranges and not reaching wrap around too soon.
336 timespec ts{};
337 clock_gettime(CLOCK_MONOTONIC, &ts);
338 // zero ID has a special meaning, so start allocation at least at AUDIO_UNIQUE_ID_USE_MAX
Eric Laurentf37f1982021-06-01 13:23:27 +0200339 uint32_t movingBase = (uint32_t)std::max((long)1, ts.tv_sec);
Glenn Kastend2e67e12016-04-11 08:26:37 -0700340 // unsigned instead of audio_unique_id_use_t, because ++ operator is unavailable for enum
341 for (unsigned use = AUDIO_UNIQUE_ID_USE_UNSPECIFIED; use < AUDIO_UNIQUE_ID_USE_MAX; use++) {
Eric Laurentf43be0c2021-03-25 10:45:53 +0100342 mNextUniqueIds[use] =
Eric Laurentf37f1982021-06-01 13:23:27 +0200343 ((use == AUDIO_UNIQUE_ID_USE_SESSION || use == AUDIO_UNIQUE_ID_USE_CLIENT) ?
344 movingBase : 1) * AUDIO_UNIQUE_ID_USE_MAX;
Glenn Kastend2e67e12016-04-11 08:26:37 -0700345 }
346
Eric Laurent94ca1142020-10-07 10:45:20 -0700347#if 1
348 // FIXME See bug 165702394 and bug 168511485
349 const bool doLog = false;
350#else
Glenn Kastenae0cff12016-02-24 13:57:49 -0800351 const bool doLog = property_get_bool("ro.test_harness", false);
Eric Laurent94ca1142020-10-07 10:45:20 -0700352#endif
Glenn Kasten9e58b552013-01-18 15:09:48 -0800353 if (doLog) {
Glenn Kastenb187de12014-12-30 08:18:15 -0800354 mLogMemoryDealer = new MemoryDealer(kLogMemorySize, "LogWriters",
355 MemoryHeapBase::READ_ONLY);
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700356 (void) pthread_once(&sMediaLogOnce, sMediaLogInit);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800357 }
Eric Laurent1c333e22014-05-20 10:48:17 -0700358
Wei Jia3f273d12015-11-24 09:06:49 -0800359 // reset battery stats.
360 // if the audio service has crashed, battery stats could be left
361 // in bad state, reset the state upon service start.
362 BatteryNotifier::getInstance().noteResetAudio();
363
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700364 mDevicesFactoryHal = DevicesFactoryHalInterface::create();
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700365 mEffectsFactoryHal = EffectsFactoryHalInterface::create();
366
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -0800367 mMediaLogNotifier->run("MediaLogNotifier");
Eric Laurent42896a02019-09-27 15:40:33 -0700368 std::vector<pid_t> halPids;
369 mDevicesFactoryHal->getHalPids(&halPids);
Andy Hung5c6d68a2022-03-09 21:54:59 -0800370 mediautils::TimeCheck::setAudioHalPids(halPids);
Andy Hungb68f5eb2019-12-03 16:49:17 -0800371
372 // Notify that we have started (also called when audioserver service restarts)
373 mediametrics::LogItem(mMetricsId)
374 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
375 .record();
Dima Zavin5a61d2f2011-04-19 19:04:32 -0700376}
377
378void AudioFlinger::onFirstRef()
379{
Eric Laurent93575202011-01-18 18:39:02 -0800380 Mutex::Autolock _l(mLock);
381
Dima Zavin799a70e2011-04-18 16:57:27 -0700382 /* TODO: move all this work into an Init() function */
John Grossman4ff14ba2012-02-08 16:37:41 -0800383 char val_str[PROPERTY_VALUE_MAX] = { 0 };
384 if (property_get("ro.audio.flinger_standbytime_ms", val_str, NULL) >= 0) {
385 uint32_t int_val;
386 if (1 == sscanf(val_str, "%u", &int_val)) {
387 mStandbyTimeInNsecs = milliseconds(int_val);
388 ALOGI("Using %u mSec as standby time.", int_val);
389 } else {
390 mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs;
391 ALOGI("Using default %u mSec as standby time.",
392 (uint32_t)(mStandbyTimeInNsecs / 1000000));
393 }
394 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700395
Eric Laurenta4c5a552012-03-29 10:12:40 -0700396 mMode = AUDIO_MODE_NORMAL;
Eric Laurentfc235202016-12-20 18:48:17 -0800397
Andy Hung6626a012021-01-12 13:38:00 -0800398 gAudioFlinger = this; // we are already refcounted, store into atomic pointer.
Mikhail Naganov88b30d22020-03-09 19:43:13 +0000399
400 mDevicesFactoryHalCallback = new DevicesFactoryHalCallbackImpl;
401 mDevicesFactoryHal->setCallbackOnce(mDevicesFactoryHalCallback);
jiabine504e7b2021-09-18 00:27:08 +0000402
403 if (mDevicesFactoryHal->getHalVersion() <= MAX_AAUDIO_PROPERTY_DEVICE_HAL_VERSION) {
404 mAAudioBurstsPerBuffer = getAAudioMixerBurstCountFromSystemProperty();
405 mAAudioHwBurstMinMicros = getAAudioHardwareBurstMinUsecFromSystemProperty();
406 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700407}
408
Eric Laurent42896a02019-09-27 15:40:33 -0700409status_t AudioFlinger::setAudioHalPids(const std::vector<pid_t>& pids) {
Andy Hung5c6d68a2022-03-09 21:54:59 -0800410 mediautils::TimeCheck::setAudioHalPids(pids);
Eric Laurent42896a02019-09-27 15:40:33 -0700411 return NO_ERROR;
412}
413
jiabin1319f5a2021-03-30 22:21:24 +0000414status_t AudioFlinger::setVibratorInfos(
415 const std::vector<media::AudioVibratorInfo>& vibratorInfos) {
416 Mutex::Autolock _l(mLock);
417 mAudioVibratorInfos = vibratorInfos;
418 return NO_ERROR;
419}
420
jiabinf042b9b2021-05-07 23:46:28 +0000421status_t AudioFlinger::updateSecondaryOutputs(
422 const TrackSecondaryOutputsMap& trackSecondaryOutputs) {
423 Mutex::Autolock _l(mLock);
424 for (const auto& [trackId, secondaryOutputs] : trackSecondaryOutputs) {
425 size_t i = 0;
426 for (; i < mPlaybackThreads.size(); ++i) {
427 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
428 Mutex::Autolock _tl(thread->mLock);
429 sp<PlaybackThread::Track> track = thread->getTrackById_l(trackId);
430 if (track != nullptr) {
431 ALOGD("%s trackId: %u", __func__, trackId);
432 updateSecondaryOutputsForTrack_l(track.get(), thread, secondaryOutputs);
433 break;
434 }
435 }
436 ALOGW_IF(i >= mPlaybackThreads.size(),
437 "%s cannot find track with id %u", __func__, trackId);
438 }
439 return NO_ERROR;
440}
441
Jiabin Huangebe64102021-09-07 20:01:07 +0000442status_t AudioFlinger::getMmapPolicyInfos(
jiabine99d0882021-09-17 05:21:25 +0000443 AudioMMapPolicyType policyType, std::vector<AudioMMapPolicyInfo> *policyInfos) {
jiabine504e7b2021-09-18 00:27:08 +0000444 Mutex::Autolock _l(mLock);
Jiabin Huangebe64102021-09-07 20:01:07 +0000445 if (const auto it = mPolicyInfos.find(policyType); it != mPolicyInfos.end()) {
446 *policyInfos = it->second;
447 return NO_ERROR;
448 }
jiabine504e7b2021-09-18 00:27:08 +0000449 if (mDevicesFactoryHal->getHalVersion() > MAX_AAUDIO_PROPERTY_DEVICE_HAL_VERSION) {
Jiabin Huangebe64102021-09-07 20:01:07 +0000450 AutoMutex lock(mHardwareLock);
451 for (size_t i = 0; i < mAudioHwDevs.size(); ++i) {
452 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
jiabine99d0882021-09-17 05:21:25 +0000453 std::vector<AudioMMapPolicyInfo> infos;
Jiabin Huangebe64102021-09-07 20:01:07 +0000454 status_t status = dev->getMmapPolicyInfos(policyType, &infos);
455 if (status != NO_ERROR) {
456 ALOGE("Failed to query mmap policy info of %d, error %d",
457 mAudioHwDevs.keyAt(i), status);
458 continue;
459 }
460 policyInfos->insert(policyInfos->end(), infos.begin(), infos.end());
461 }
462 mPolicyInfos[policyType] = *policyInfos;
463 } else {
464 getMmapPolicyInfosFromSystemProperty(policyType, policyInfos);
465 mPolicyInfos[policyType] = *policyInfos;
466 }
467 return NO_ERROR;
468}
469
jiabine504e7b2021-09-18 00:27:08 +0000470int32_t AudioFlinger::getAAudioMixerBurstCount() {
471 Mutex::Autolock _l(mLock);
472 return mAAudioBurstsPerBuffer;
473}
474
475int32_t AudioFlinger::getAAudioHardwareBurstMinUsec() {
476 Mutex::Autolock _l(mLock);
477 return mAAudioHwBurstMinMicros;
478}
479
Mikhail Naganov516d3982022-02-01 23:53:59 +0000480status_t AudioFlinger::setDeviceConnectedState(const struct audio_port_v7 *port, bool connected) {
481 status_t final_result = NO_INIT;
482 Mutex::Autolock _l(mLock);
483 AutoMutex lock(mHardwareLock);
484 mHardwareStatus = AUDIO_HW_SET_CONNECTED_STATE;
485 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
486 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
487 status_t result = dev->setConnectedState(port, connected);
488 // Same logic as with setParameter: it's a success if at least one
489 // HAL module accepts the update.
490 if (final_result != NO_ERROR) {
491 final_result = result;
492 }
493 }
494 mHardwareStatus = AUDIO_HW_IDLE;
495 return final_result;
496}
497
jiabin1319f5a2021-03-30 22:21:24 +0000498// getDefaultVibratorInfo_l must be called with AudioFlinger lock held.
Lais Andradebc3f37a2021-07-02 00:13:19 +0100499std::optional<media::AudioVibratorInfo> AudioFlinger::getDefaultVibratorInfo_l() {
jiabin1319f5a2021-03-30 22:21:24 +0000500 if (mAudioVibratorInfos.empty()) {
Lais Andradebc3f37a2021-07-02 00:13:19 +0100501 return {};
jiabin1319f5a2021-03-30 22:21:24 +0000502 }
Lais Andradebc3f37a2021-07-02 00:13:19 +0100503 return mAudioVibratorInfos.front();
jiabin1319f5a2021-03-30 22:21:24 +0000504}
505
Mathias Agopian65ab4712010-07-14 17:59:35 -0700506AudioFlinger::~AudioFlinger()
507{
508 while (!mRecordThreads.isEmpty()) {
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700509 // closeInput_nonvirtual() will remove specified entry from mRecordThreads
Glenn Kastend96c5722012-04-25 13:44:49 -0700510 closeInput_nonvirtual(mRecordThreads.keyAt(0));
Mathias Agopian65ab4712010-07-14 17:59:35 -0700511 }
512 while (!mPlaybackThreads.isEmpty()) {
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700513 // closeOutput_nonvirtual() will remove specified entry from mPlaybackThreads
Glenn Kastend96c5722012-04-25 13:44:49 -0700514 closeOutput_nonvirtual(mPlaybackThreads.keyAt(0));
Mathias Agopian65ab4712010-07-14 17:59:35 -0700515 }
Andy Hungb4946b62019-03-14 11:19:28 -0700516 while (!mMmapThreads.isEmpty()) {
517 const audio_io_handle_t io = mMmapThreads.keyAt(0);
518 if (mMmapThreads.valueAt(0)->isOutput()) {
519 closeOutput_nonvirtual(io); // removes entry from mMmapThreads
520 } else {
521 closeInput_nonvirtual(io); // removes entry from mMmapThreads
522 }
523 }
Dima Zavin799a70e2011-04-18 16:57:27 -0700524
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800525 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
526 // no mHardwareLock needed, as there are no other references to this
Eric Laurenta4c5a552012-03-29 10:12:40 -0700527 delete mAudioHwDevs.valueAt(i);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700528 }
Glenn Kasten481fb672013-09-30 14:39:28 -0700529
530 // Tell media.log service about any old writers that still need to be unregistered
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700531 if (sMediaLogService != 0) {
532 for (size_t count = mUnregisteredWriters.size(); count > 0; count--) {
533 sp<IMemory> iMemory(mUnregisteredWriters.top()->getIMemory());
534 mUnregisteredWriters.pop();
535 sMediaLogService->unregisterWriter(iMemory);
Glenn Kasten481fb672013-09-30 14:39:28 -0700536 }
537 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700538}
539
Eric Laurentfc235202016-12-20 18:48:17 -0800540//static
Eric Laurent6acd1d42017-01-04 14:23:29 -0800541__attribute__ ((visibility ("default")))
Eric Laurentfc235202016-12-20 18:48:17 -0800542status_t MmapStreamInterface::openMmapStream(MmapStreamInterface::stream_direction_t direction,
543 const audio_attributes_t *attr,
544 audio_config_base_t *config,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700545 const AudioClient& client,
Eric Laurentfc235202016-12-20 18:48:17 -0800546 audio_port_handle_t *deviceId,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800547 audio_session_t *sessionId,
Eric Laurentfc235202016-12-20 18:48:17 -0800548 const sp<MmapStreamCallback>& callback,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700549 sp<MmapStreamInterface>& interface,
550 audio_port_handle_t *handle)
Eric Laurentfc235202016-12-20 18:48:17 -0800551{
Andy Hung6626a012021-01-12 13:38:00 -0800552 // TODO: Use ServiceManager to get IAudioFlinger instead of by atomic pointer.
553 // This allows moving oboeservice (AAudio) to a separate process in the future.
554 sp<AudioFlinger> af = AudioFlinger::gAudioFlinger.load(); // either nullptr or singleton AF.
Eric Laurentfc235202016-12-20 18:48:17 -0800555 status_t ret = NO_INIT;
556 if (af != 0) {
557 ret = af->openMmapStream(
Phil Burk4e1af9f2018-01-03 15:54:35 -0800558 direction, attr, config, client, deviceId,
559 sessionId, callback, interface, handle);
Eric Laurentfc235202016-12-20 18:48:17 -0800560 }
561 return ret;
562}
563
Eric Laurent6acd1d42017-01-04 14:23:29 -0800564status_t AudioFlinger::openMmapStream(MmapStreamInterface::stream_direction_t direction,
565 const audio_attributes_t *attr,
566 audio_config_base_t *config,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700567 const AudioClient& client,
Eric Laurent6acd1d42017-01-04 14:23:29 -0800568 audio_port_handle_t *deviceId,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800569 audio_session_t *sessionId,
Eric Laurent6acd1d42017-01-04 14:23:29 -0800570 const sp<MmapStreamCallback>& callback,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700571 sp<MmapStreamInterface>& interface,
572 audio_port_handle_t *handle)
Eric Laurentfc235202016-12-20 18:48:17 -0800573{
574 status_t ret = initCheck();
575 if (ret != NO_ERROR) {
576 return ret;
577 }
Phil Burk4e1af9f2018-01-03 15:54:35 -0800578 audio_session_t actualSessionId = *sessionId;
579 if (actualSessionId == AUDIO_SESSION_ALLOCATE) {
580 actualSessionId = (audio_session_t) newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
581 }
Eric Laurent6acd1d42017-01-04 14:23:29 -0800582 audio_stream_type_t streamType = AUDIO_STREAM_DEFAULT;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700583 audio_io_handle_t io = AUDIO_IO_HANDLE_NONE;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800584 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
Eric Laurent42984412019-05-09 17:57:03 -0700585 audio_attributes_t localAttr = *attr;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800586 if (direction == MmapStreamInterface::DIRECTION_OUTPUT) {
587 audio_config_t fullConfig = AUDIO_CONFIG_INITIALIZER;
588 fullConfig.sample_rate = config->sample_rate;
589 fullConfig.channel_mask = config->channel_mask;
590 fullConfig.format = config->format;
Kevin Rocard153f92d2018-12-18 18:33:28 -0800591 std::vector<audio_io_handle_t> secondaryOutputs;
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200592 bool isSpatialized;
Eric Laurent42984412019-05-09 17:57:03 -0700593 ret = AudioSystem::getOutputForAttr(&localAttr, &io,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800594 actualSessionId,
Svet Ganov33761132021-05-13 22:51:08 +0000595 &streamType, client.attributionSource,
Ricardo Correa57a37692020-03-23 17:27:25 -0700596 &fullConfig,
Glenn Kastend3bb6452016-12-05 18:14:37 -0800597 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ |
598 AUDIO_OUTPUT_FLAG_DIRECT),
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200599 deviceId, &portId, &secondaryOutputs, &isSpatialized);
jiabinf1c73972022-04-14 16:28:52 -0700600 if (ret != NO_ERROR) {
601 config->sample_rate = fullConfig.sample_rate;
602 config->channel_mask = fullConfig.channel_mask;
603 config->format = fullConfig.format;
604 }
Kevin Rocard153f92d2018-12-18 18:33:28 -0800605 ALOGW_IF(!secondaryOutputs.empty(),
606 "%s does not support secondary outputs, ignoring them", __func__);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800607 } else {
Eric Laurent42984412019-05-09 17:57:03 -0700608 ret = AudioSystem::getInputForAttr(&localAttr, &io,
Mikhail Naganov2996f672019-04-18 12:29:59 -0700609 RECORD_RIID_INVALID,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800610 actualSessionId,
Svet Ganov33761132021-05-13 22:51:08 +0000611 client.attributionSource,
Eric Laurent6acd1d42017-01-04 14:23:29 -0800612 config,
Eric Laurent2ac76942017-06-22 17:17:09 -0700613 AUDIO_INPUT_FLAG_MMAP_NOIRQ, deviceId, &portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800614 }
615 if (ret != NO_ERROR) {
616 return ret;
617 }
618
619 // at this stage, a MmapThread was created when openOutput() or openInput() was called by
620 // audio policy manager and we can retrieve it
621 sp<MmapThread> thread = mMmapThreads.valueFor(io);
622 if (thread != 0) {
623 interface = new MmapThreadHandle(thread);
Eric Laurent42984412019-05-09 17:57:03 -0700624 thread->configure(&localAttr, streamType, actualSessionId, callback, *deviceId, portId);
Eric Laurentcb4dae22017-07-01 19:39:32 -0700625 *handle = portId;
Phil Burk4e1af9f2018-01-03 15:54:35 -0800626 *sessionId = actualSessionId;
Eric Laurenta7a89e22020-01-08 18:39:20 -0800627 config->sample_rate = thread->sampleRate();
628 config->channel_mask = thread->channelMask();
629 config->format = thread->format();
Eric Laurent6acd1d42017-01-04 14:23:29 -0800630 } else {
Eric Laurentad2e7b92017-09-14 20:06:42 -0700631 if (direction == MmapStreamInterface::DIRECTION_OUTPUT) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700632 AudioSystem::releaseOutput(portId);
Eric Laurentad2e7b92017-09-14 20:06:42 -0700633 } else {
Eric Laurentfee19762018-01-29 18:44:13 -0800634 AudioSystem::releaseInput(portId);
Eric Laurentad2e7b92017-09-14 20:06:42 -0700635 }
Eric Laurent6acd1d42017-01-04 14:23:29 -0800636 ret = NO_INIT;
637 }
638
639 ALOGV("%s done status %d portId %d", __FUNCTION__, ret, portId);
640
Eric Laurentfc235202016-12-20 18:48:17 -0800641 return ret;
642}
643
jiabin57303cc2018-12-18 15:45:57 -0800644/* static */
645int AudioFlinger::onExternalVibrationStart(const sp<os::ExternalVibration>& externalVibration) {
646 sp<os::IExternalVibratorService> evs = getExternalVibratorService();
jiabin78dc9c82021-02-22 19:13:29 +0000647 if (evs != nullptr) {
jiabin57303cc2018-12-18 15:45:57 -0800648 int32_t ret;
649 binder::Status status = evs->onExternalVibrationStart(*externalVibration, &ret);
650 if (status.isOk()) {
jiabin78dc9c82021-02-22 19:13:29 +0000651 ALOGD("%s, start external vibration with intensity as %d", __func__, ret);
jiabin57303cc2018-12-18 15:45:57 -0800652 return ret;
653 }
654 }
jiabin78dc9c82021-02-22 19:13:29 +0000655 ALOGD("%s, start external vibration with intensity as MUTE due to %s",
656 __func__,
657 evs == nullptr ? "external vibration service not found"
658 : "error when querying intensity");
jiabine70bc7f2020-06-30 22:07:55 -0700659 return static_cast<int>(os::HapticScale::MUTE);
jiabin57303cc2018-12-18 15:45:57 -0800660}
661
662/* static */
663void AudioFlinger::onExternalVibrationStop(const sp<os::ExternalVibration>& externalVibration) {
664 sp<os::IExternalVibratorService> evs = getExternalVibratorService();
665 if (evs != 0) {
jiabinc47acf22022-04-01 23:47:52 +0000666 ALOGD("%s, stopping external vibration", __func__);
jiabin57303cc2018-12-18 15:45:57 -0800667 evs->onExternalVibrationStop(*externalVibration);
668 }
669}
670
Eric Laurentb82e6b72019-11-22 17:25:04 -0800671status_t AudioFlinger::addEffectToHal(audio_port_handle_t deviceId,
672 audio_module_handle_t hwModuleId, sp<EffectHalInterface> effect) {
Eric Laurent00abf0d2020-04-22 19:28:22 -0700673 AutoMutex lock(mHardwareLock);
Eric Laurentb82e6b72019-11-22 17:25:04 -0800674 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueFor(hwModuleId);
675 if (audioHwDevice == nullptr) {
676 return NO_INIT;
677 }
678 return audioHwDevice->hwDevice()->addDeviceEffect(deviceId, effect);
679}
680
681status_t AudioFlinger::removeEffectFromHal(audio_port_handle_t deviceId,
682 audio_module_handle_t hwModuleId, sp<EffectHalInterface> effect) {
Eric Laurent00abf0d2020-04-22 19:28:22 -0700683 AutoMutex lock(mHardwareLock);
Eric Laurentb82e6b72019-11-22 17:25:04 -0800684 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueFor(hwModuleId);
685 if (audioHwDevice == nullptr) {
686 return NO_INIT;
687 }
688 return audioHwDevice->hwDevice()->removeDeviceEffect(deviceId, effect);
689}
690
Eric Laurenta4c5a552012-03-29 10:12:40 -0700691static const char * const audio_interfaces[] = {
692 AUDIO_HARDWARE_MODULE_ID_PRIMARY,
693 AUDIO_HARDWARE_MODULE_ID_A2DP,
694 AUDIO_HARDWARE_MODULE_ID_USB,
695};
Eric Laurenta4c5a552012-03-29 10:12:40 -0700696
Phil Burk062e67a2015-02-11 13:40:50 -0800697AudioHwDevice* AudioFlinger::findSuitableHwDev_l(
John Grossmanee578c02012-07-23 17:05:46 -0700698 audio_module_handle_t module,
jiabin43810402019-10-24 14:58:31 -0700699 audio_devices_t deviceType)
Dima Zavin799a70e2011-04-18 16:57:27 -0700700{
Eric Laurenta4c5a552012-03-29 10:12:40 -0700701 // if module is 0, the request comes from an old policy manager and we should load
702 // well known modules
Eric Laurent00abf0d2020-04-22 19:28:22 -0700703 AutoMutex lock(mHardwareLock);
Eric Laurenta4c5a552012-03-29 10:12:40 -0700704 if (module == 0) {
705 ALOGW("findSuitableHwDev_l() loading well know audio hw modules");
Mikhail Naganovbf493082017-04-17 17:37:12 -0700706 for (size_t i = 0; i < arraysize(audio_interfaces); i++) {
Eric Laurenta4c5a552012-03-29 10:12:40 -0700707 loadHwModule_l(audio_interfaces[i]);
708 }
Eric Laurentf1c04f92012-08-28 14:26:53 -0700709 // then try to find a module supporting the requested device.
710 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
711 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueAt(i);
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700712 sp<DeviceHalInterface> dev = audioHwDevice->hwDevice();
713 uint32_t supportedDevices;
714 if (dev->getSupportedDevices(&supportedDevices) == OK &&
jiabin43810402019-10-24 14:58:31 -0700715 (supportedDevices & deviceType) == deviceType) {
Eric Laurentf1c04f92012-08-28 14:26:53 -0700716 return audioHwDevice;
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700717 }
Eric Laurentf1c04f92012-08-28 14:26:53 -0700718 }
Eric Laurenta4c5a552012-03-29 10:12:40 -0700719 } else {
720 // check a match for the requested module handle
John Grossmanee578c02012-07-23 17:05:46 -0700721 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueFor(module);
722 if (audioHwDevice != NULL) {
723 return audioHwDevice;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700724 }
725 }
Eric Laurenta4c5a552012-03-29 10:12:40 -0700726
Dima Zavin799a70e2011-04-18 16:57:27 -0700727 return NULL;
728}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700729
Glenn Kasten0f11b512014-01-31 16:18:54 -0800730void AudioFlinger::dumpClients(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700731{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700732 String8 result;
733
734 result.append("Clients:\n");
Atneyafc18e632021-08-31 18:59:21 -0400735 result.append(" pid heap_size\n");
Mathias Agopian65ab4712010-07-14 17:59:35 -0700736 for (size_t i = 0; i < mClients.size(); ++i) {
Glenn Kasten77c11192012-01-25 14:27:41 -0800737 sp<Client> client = mClients.valueAt(i).promote();
738 if (client != 0) {
Atneya3c61d882021-09-20 14:52:15 -0400739 result.append("Client: %d\n", client->pid());
740 result.append(client->allocator().dump().c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700741 }
Atneya3c61d882021-09-20 14:52:15 -0400742 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700743
Eric Laurentd1b28d42013-09-18 18:47:13 -0700744 result.append("Notification Clients:\n");
Andy Hung5bdc5352019-12-23 14:36:31 -0800745 result.append(" pid uid name\n");
Eric Laurentd1b28d42013-09-18 18:47:13 -0700746 for (size_t i = 0; i < mNotificationClients.size(); ++i) {
Andy Hung5bdc5352019-12-23 14:36:31 -0800747 const pid_t pid = mNotificationClients[i]->getPid();
748 const uid_t uid = mNotificationClients[i]->getUid();
749 const mediautils::UidInfo::Info info = mUidInfo.getInfo(uid);
750 result.appendFormat("%6d %6u %s\n", pid, uid, info.package.c_str());
Eric Laurentd1b28d42013-09-18 18:47:13 -0700751 }
752
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700753 result.append("Global session refs:\n");
Andy Hung8b0bfd92019-12-23 13:11:11 -0800754 result.append(" session cnt pid uid name\n");
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700755 for (size_t i = 0; i < mAudioSessionRefs.size(); i++) {
756 AudioSessionRef *r = mAudioSessionRefs[i];
Andy Hung8b0bfd92019-12-23 13:11:11 -0800757 const mediautils::UidInfo::Info info = mUidInfo.getInfo(r->mUid);
758 result.appendFormat(" %7d %4d %7d %6u %s\n", r->mSessionid, r->mCnt, r->mPid,
759 r->mUid, info.package.c_str());
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700760 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700761 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700762}
763
764
Glenn Kasten0f11b512014-01-31 16:18:54 -0800765void AudioFlinger::dumpInternals(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700766{
767 const size_t SIZE = 256;
768 char buffer[SIZE];
769 String8 result;
Glenn Kastena4454b42012-01-04 11:02:33 -0800770 hardware_call_state hardwareStatus = mHardwareStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700771
John Grossman4ff14ba2012-02-08 16:37:41 -0800772 snprintf(buffer, SIZE, "Hardware status: %d\n"
773 "Standby Time mSec: %u\n",
774 hardwareStatus,
775 (uint32_t)(mStandbyTimeInNsecs / 1000000));
Mathias Agopian65ab4712010-07-14 17:59:35 -0700776 result.append(buffer);
777 write(fd, result.string(), result.size());
jiabinc47acf22022-04-01 23:47:52 +0000778
779 dprintf(fd, "Vibrator infos(size=%zu):\n", mAudioVibratorInfos.size());
780 for (const auto& vibratorInfo : mAudioVibratorInfos) {
781 dprintf(fd, " - %s\n", vibratorInfo.toString().c_str());
782 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700783}
784
Glenn Kasten0f11b512014-01-31 16:18:54 -0800785void AudioFlinger::dumpPermissionDenial(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700786{
787 const size_t SIZE = 256;
788 char buffer[SIZE];
789 String8 result;
790 snprintf(buffer, SIZE, "Permission Denial: "
791 "can't dump AudioFlinger from pid=%d, uid=%d\n",
792 IPCThreadState::self()->getCallingPid(),
793 IPCThreadState::self()->getCallingUid());
794 result.append(buffer);
795 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700796}
797
Eric Laurent81784c32012-11-19 14:55:58 -0800798bool AudioFlinger::dumpTryLock(Mutex& mutex)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700799{
Mikhail Naganov959e2d02019-03-28 11:08:19 -0700800 status_t err = mutex.timedLock(kDumpLockTimeoutNs);
801 return err == NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700802}
803
804status_t AudioFlinger::dump(int fd, const Vector<String16>& args)
805{
Glenn Kasten44deb052012-02-05 18:09:08 -0800806 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700807 dumpPermissionDenial(fd, args);
808 } else {
809 // get state of hardware lock
Eric Laurent81784c32012-11-19 14:55:58 -0800810 bool hardwareLocked = dumpTryLock(mHardwareLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700811 if (!hardwareLocked) {
812 String8 result(kHardwareLockedString);
813 write(fd, result.string(), result.size());
814 } else {
815 mHardwareLock.unlock();
816 }
817
Eric Tan7b651152018-07-13 10:17:19 -0700818 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700819
820 // failed to lock - AudioFlinger is probably deadlocked
821 if (!locked) {
822 String8 result(kDeadlockedString);
823 write(fd, result.string(), result.size());
824 }
825
Eric Laurent021cf962014-05-13 10:18:14 -0700826 bool clientLocked = dumpTryLock(mClientLock);
827 if (!clientLocked) {
828 String8 result(kClientLockedString);
829 write(fd, result.string(), result.size());
830 }
Marco Nelissend89eadd2014-10-07 13:28:44 -0700831
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700832 if (mEffectsFactoryHal != 0) {
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700833 mEffectsFactoryHal->dumpEffects(fd);
834 } else {
835 String8 result(kNoEffectsFactory);
836 write(fd, result.string(), result.size());
837 }
Marco Nelissend89eadd2014-10-07 13:28:44 -0700838
Mathias Agopian65ab4712010-07-14 17:59:35 -0700839 dumpClients(fd, args);
Eric Laurent021cf962014-05-13 10:18:14 -0700840 if (clientLocked) {
841 mClientLock.unlock();
842 }
843
Mathias Agopian65ab4712010-07-14 17:59:35 -0700844 dumpInternals(fd, args);
845
846 // dump playback threads
847 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
848 mPlaybackThreads.valueAt(i)->dump(fd, args);
849 }
850
851 // dump record threads
852 for (size_t i = 0; i < mRecordThreads.size(); i++) {
853 mRecordThreads.valueAt(i)->dump(fd, args);
854 }
855
Eric Laurent6acd1d42017-01-04 14:23:29 -0800856 // dump mmap threads
857 for (size_t i = 0; i < mMmapThreads.size(); i++) {
858 mMmapThreads.valueAt(i)->dump(fd, args);
859 }
860
Eric Laurentaaa44472014-09-12 17:41:50 -0700861 // dump orphan effect chains
862 if (mOrphanEffectChains.size() != 0) {
863 write(fd, " Orphan Effect Chains\n", strlen(" Orphan Effect Chains\n"));
864 for (size_t i = 0; i < mOrphanEffectChains.size(); i++) {
865 mOrphanEffectChains.valueAt(i)->dump(fd, args);
866 }
867 }
Dima Zavin799a70e2011-04-18 16:57:27 -0700868 // dump all hardware devs
869 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700870 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
Andy Hung61589a42021-06-16 09:37:53 -0700871 dev->dump(fd, args);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700872 }
Glenn Kastend06785b2012-09-30 12:29:28 -0700873
Mikhail Naganov201369b2018-05-16 16:52:32 -0700874 mPatchPanel.dump(fd);
875
Eric Laurentb82e6b72019-11-22 17:25:04 -0800876 mDeviceEffectManager.dump(fd);
877
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -0700878 // dump external setParameters
879 auto dumpLogger = [fd](SimpleLog& logger, const char* name) {
880 dprintf(fd, "\n%s setParameters:\n", name);
881 logger.dump(fd, " " /* prefix */);
882 };
883 dumpLogger(mRejectedSetParameterLog, "Rejected");
884 dumpLogger(mAppSetParameterLog, "App");
885 dumpLogger(mSystemSetParameterLog, "System");
886
Andy Hunga8115dc2018-08-24 15:51:59 -0700887 // dump historical threads in the last 10 seconds
888 const std::string threadLog = mThreadLog.dumpToString(
889 "Historical Thread Log ", 0 /* lines */,
890 audio_utils_get_real_time_ns() - 10 * 60 * NANOS_PER_SECOND);
891 write(fd, threadLog.c_str(), threadLog.size());
892
rago3bd1c872016-09-26 12:58:14 -0700893 BUFLOG_RESET;
894
Glenn Kastend65d73c2012-06-22 17:21:07 -0700895 if (locked) {
896 mLock.unlock();
897 }
Glenn Kasten9e58b552013-01-18 15:09:48 -0800898
Andy Hung8946a282018-04-19 20:04:56 -0700899#ifdef TEE_SINK
900 // NBAIO_Tee dump is safe to call outside of AF lock.
901 NBAIO_Tee::dumpAll(fd, "_DUMP");
902#endif
Glenn Kasten9e58b552013-01-18 15:09:48 -0800903 // append a copy of media.log here by forwarding fd to it, but don't attempt
904 // to lookup the service if it's not running, as it will block for a second
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700905 if (sMediaLogServiceAsBinder != 0) {
906 dprintf(fd, "\nmedia.log:\n");
907 Vector<String16> args;
908 sMediaLogServiceAsBinder->dump(fd, args);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800909 }
Andy Hung35fec5f2016-04-13 14:21:48 -0700910
911 // check for optional arguments
Andy Hung07b745e2016-05-23 16:21:07 -0700912 bool dumpMem = false;
Andy Hung35fec5f2016-04-13 14:21:48 -0700913 bool unreachableMemory = false;
914 for (const auto &arg : args) {
Andy Hung07b745e2016-05-23 16:21:07 -0700915 if (arg == String16("-m")) {
916 dumpMem = true;
917 } else if (arg == String16("--unreachable")) {
Andy Hung35fec5f2016-04-13 14:21:48 -0700918 unreachableMemory = true;
919 }
920 }
921
Andy Hung07b745e2016-05-23 16:21:07 -0700922 if (dumpMem) {
923 dprintf(fd, "\nDumping memory:\n");
924 std::string s = dumpMemoryAddresses(100 /* limit */);
925 write(fd, s.c_str(), s.size());
926 }
Andy Hung35fec5f2016-04-13 14:21:48 -0700927 if (unreachableMemory) {
928 dprintf(fd, "\nDumping unreachable memory:\n");
929 // TODO - should limit be an argument parameter?
Andy Hung07b745e2016-05-23 16:21:07 -0700930 std::string s = GetUnreachableMemoryString(true /* contents */, 100 /* limit */);
Andy Hung35fec5f2016-04-13 14:21:48 -0700931 write(fd, s.c_str(), s.size());
932 }
Andy Hungc747c532022-03-07 21:41:14 -0800933 {
934 std::string timeCheckStats = getIAudioFlingerStatistics().dump();
Andy Hung224f82f2022-03-22 00:00:49 -0700935 dprintf(fd, "\nIAudioFlinger binder call profile:\n");
Andy Hungc747c532022-03-07 21:41:14 -0800936 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
937
938 extern mediautils::MethodStatistics<int>& getIEffectStatistics();
939 timeCheckStats = getIEffectStatistics().dump();
Andy Hung224f82f2022-03-22 00:00:49 -0700940 dprintf(fd, "\nIEffect binder call profile:\n");
Andy Hungc747c532022-03-07 21:41:14 -0800941 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
Andy Hung224f82f2022-03-22 00:00:49 -0700942
943 // Automatically fetch HIDL statistics.
944 std::shared_ptr<std::vector<std::string>> hidlClassNames =
945 mediautils::getStatisticsClassesForModule(
946 METHOD_STATISTICS_MODULE_NAME_AUDIO_HIDL);
947 if (hidlClassNames) {
948 for (const auto& className : *hidlClassNames) {
949 auto stats = mediautils::getStatisticsForClass(className);
950 if (stats) {
951 timeCheckStats = stats->dump();
952 dprintf(fd, "\n%s binder call profile:\n", className.c_str());
953 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
954 }
955 }
956 }
957
958 timeCheckStats = mediautils::TimeCheck::toString();
959 dprintf(fd, "\nTimeCheck:\n");
960 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
961 dprintf(fd, "\n");
Andy Hungc747c532022-03-07 21:41:14 -0800962 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700963 }
964 return NO_ERROR;
965}
966
Eric Laurent021cf962014-05-13 10:18:14 -0700967sp<AudioFlinger::Client> AudioFlinger::registerPid(pid_t pid)
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800968{
Eric Laurent021cf962014-05-13 10:18:14 -0700969 Mutex::Autolock _cl(mClientLock);
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800970 // If pid is already in the mClients wp<> map, then use that entry
971 // (for which promote() is always != 0), otherwise create a new entry and Client.
972 sp<Client> client = mClients.valueFor(pid).promote();
973 if (client == 0) {
974 client = new Client(this, pid);
975 mClients.add(pid, client);
976 }
977
978 return client;
979}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700980
Glenn Kasten9e58b552013-01-18 15:09:48 -0800981sp<NBLog::Writer> AudioFlinger::newWriter_l(size_t size, const char *name)
982{
Jiabin Huang60766082020-07-28 22:03:56 +0000983 // If there is no memory allocated for logs, return a no-op writer that does nothing.
984 // Similarly if we can't contact the media.log service, also return a no-op writer.
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700985 if (mLogMemoryDealer == 0 || sMediaLogService == 0) {
Glenn Kasten9e58b552013-01-18 15:09:48 -0800986 return new NBLog::Writer();
987 }
Glenn Kasten481fb672013-09-30 14:39:28 -0700988 sp<IMemory> shared = mLogMemoryDealer->allocate(NBLog::Timeline::sharedSize(size));
989 // If allocation fails, consult the vector of previously unregistered writers
990 // and garbage-collect one or more them until an allocation succeeds
991 if (shared == 0) {
992 Mutex::Autolock _l(mUnregisteredWritersLock);
993 for (size_t count = mUnregisteredWriters.size(); count > 0; count--) {
994 {
995 // Pick the oldest stale writer to garbage-collect
996 sp<IMemory> iMemory(mUnregisteredWriters[0]->getIMemory());
997 mUnregisteredWriters.removeAt(0);
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700998 sMediaLogService->unregisterWriter(iMemory);
Glenn Kasten481fb672013-09-30 14:39:28 -0700999 // Now the media.log remote reference to IMemory is gone. When our last local
1000 // reference to IMemory also drops to zero at end of this block,
1001 // the IMemory destructor will deallocate the region from mLogMemoryDealer.
1002 }
1003 // Re-attempt the allocation
1004 shared = mLogMemoryDealer->allocate(NBLog::Timeline::sharedSize(size));
1005 if (shared != 0) {
1006 goto success;
1007 }
1008 }
1009 // Even after garbage-collecting all old writers, there is still not enough memory,
Jiabin Huang60766082020-07-28 22:03:56 +00001010 // so return a no-op writer
Glenn Kasten481fb672013-09-30 14:39:28 -07001011 return new NBLog::Writer();
1012 }
1013success:
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07001014 NBLog::Shared *sharedRawPtr = (NBLog::Shared *) shared->unsecurePointer();
Glenn Kasten535e1612016-12-05 12:19:36 -08001015 new((void *) sharedRawPtr) NBLog::Shared(); // placement new here, but the corresponding
1016 // explicit destructor not needed since it is POD
Glenn Kasten04b96fc2017-04-10 14:58:47 -07001017 sMediaLogService->registerWriter(shared, size, name);
Glenn Kasten535e1612016-12-05 12:19:36 -08001018 return new NBLog::Writer(shared, size);
Glenn Kasten9e58b552013-01-18 15:09:48 -08001019}
1020
1021void AudioFlinger::unregisterWriter(const sp<NBLog::Writer>& writer)
1022{
Glenn Kasten685ef092013-02-04 08:15:34 -08001023 if (writer == 0) {
1024 return;
1025 }
Glenn Kasten9e58b552013-01-18 15:09:48 -08001026 sp<IMemory> iMemory(writer->getIMemory());
1027 if (iMemory == 0) {
1028 return;
1029 }
Glenn Kasten481fb672013-09-30 14:39:28 -07001030 // Rather than removing the writer immediately, append it to a queue of old writers to
1031 // be garbage-collected later. This allows us to continue to view old logs for a while.
1032 Mutex::Autolock _l(mUnregisteredWritersLock);
1033 mUnregisteredWriters.push(writer);
Glenn Kasten9e58b552013-01-18 15:09:48 -08001034}
1035
Mathias Agopian65ab4712010-07-14 17:59:35 -07001036// IAudioFlinger interface
1037
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08001038status_t AudioFlinger::createTrack(const media::CreateTrackRequest& _input,
1039 media::CreateTrackResponse& _output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001040{
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001041 // Local version of VALUE_OR_RETURN, specific to this method's calling conventions.
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08001042 CreateTrackInput input = VALUE_OR_RETURN_STATUS(CreateTrackInput::fromAidl(_input));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001043 CreateTrackOutput output;
1044
Mathias Agopian65ab4712010-07-14 17:59:35 -07001045 sp<PlaybackThread::Track> track;
1046 sp<TrackHandle> trackHandle;
1047 sp<Client> client;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001048 status_t lStatus;
Eric Laurent21da6472017-11-09 16:29:26 -08001049 audio_stream_type_t streamType;
Eric Laurent77881cd2018-02-09 16:01:31 -08001050 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
Kevin Rocard153f92d2018-12-18 18:33:28 -08001051 std::vector<audio_io_handle_t> secondaryOutputs;
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001052 bool isSpatialized = false;;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001053
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001054 // TODO b/182392553: refactor or make clearer
1055 pid_t clientPid =
Svet Ganov33761132021-05-13 22:51:08 +00001056 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(input.clientInfo.attributionSource.pid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001057 bool updatePid = (clientPid == (pid_t)-1);
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07001058 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001059 uid_t clientUid =
Svet Ganov33761132021-05-13 22:51:08 +00001060 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_uid_t(input.clientInfo.attributionSource.uid));
Eric Laurent6c796322019-04-09 14:13:17 -07001061 audio_io_handle_t effectThreadId = AUDIO_IO_HANDLE_NONE;
1062 std::vector<int> effectIds;
Eric Laurent42984412019-05-09 17:57:03 -07001063 audio_attributes_t localAttr = input.attr;
Eric Laurent6c796322019-04-09 14:13:17 -07001064
Svet Ganov33761132021-05-13 22:51:08 +00001065 AttributionSourceState adjAttributionSource = input.clientInfo.attributionSource;
Andy Hung4ef19fa2018-05-15 19:35:29 -07001066 if (!isAudioServerOrMediaServerUid(callingUid)) {
Eric Laurent21da6472017-11-09 16:29:26 -08001067 ALOGW_IF(clientUid != callingUid,
1068 "%s uid %d tried to pass itself off as %d",
1069 __FUNCTION__, callingUid, clientUid);
Svet Ganov33761132021-05-13 22:51:08 +00001070 adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
Eric Laurent21da6472017-11-09 16:29:26 -08001071 clientUid = callingUid;
1072 updatePid = true;
1073 }
Eric Laurent09f1ed22019-04-24 17:45:17 -07001074 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Eric Laurent21da6472017-11-09 16:29:26 -08001075 if (updatePid) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001076 ALOGW_IF(clientPid != (pid_t)-1 && clientPid != callingPid,
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07001077 "%s uid %d pid %d tried to pass itself off as pid %d",
Eric Laurent21da6472017-11-09 16:29:26 -08001078 __func__, callingUid, callingPid, clientPid);
1079 clientPid = callingPid;
Svet Ganov33761132021-05-13 22:51:08 +00001080 adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07001081 }
1082
Eric Laurent21da6472017-11-09 16:29:26 -08001083 audio_session_t sessionId = input.sessionId;
1084 if (sessionId == AUDIO_SESSION_ALLOCATE) {
1085 sessionId = (audio_session_t) newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
Eric Laurentf14db3c2017-12-08 14:20:36 -08001086 } else if (audio_unique_id_get_use(sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) {
1087 lStatus = BAD_VALUE;
1088 goto Exit;
Eric Laurent21da6472017-11-09 16:29:26 -08001089 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08001090
Eric Laurent21da6472017-11-09 16:29:26 -08001091 output.sessionId = sessionId;
1092 output.outputId = AUDIO_IO_HANDLE_NONE;
1093 output.selectedDeviceId = input.selectedDeviceId;
Eric Laurent42984412019-05-09 17:57:03 -07001094 lStatus = AudioSystem::getOutputForAttr(&localAttr, &output.outputId, sessionId, &streamType,
Svet Ganov33761132021-05-13 22:51:08 +00001095 adjAttributionSource, &input.config, input.flags,
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001096 &output.selectedDeviceId, &portId, &secondaryOutputs,
1097 &isSpatialized);
Eric Laurent21da6472017-11-09 16:29:26 -08001098
1099 if (lStatus != NO_ERROR || output.outputId == AUDIO_IO_HANDLE_NONE) {
1100 ALOGE("createTrack() getOutputForAttr() return error %d or invalid output handle", lStatus);
1101 goto Exit;
1102 }
Glenn Kasten263709e2012-01-06 08:40:01 -08001103 // client AudioTrack::set already implements AUDIO_STREAM_DEFAULT => AUDIO_STREAM_MUSIC,
1104 // but if someone uses binder directly they could bypass that and cause us to crash
1105 if (uint32_t(streamType) >= AUDIO_STREAM_CNT) {
Steve Block29357bc2012-01-06 19:20:56 +00001106 ALOGE("createTrack() invalid stream type %d", streamType);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001107 lStatus = BAD_VALUE;
1108 goto Exit;
1109 }
1110
Glenn Kasten53b5d092014-02-05 10:00:23 -08001111 // further channel mask checks are performed by createTrack_l() depending on the thread type
Eric Laurent21da6472017-11-09 16:29:26 -08001112 if (!audio_is_output_channel(input.config.channel_mask)) {
1113 ALOGE("createTrack() invalid channel mask %#x", input.config.channel_mask);
Glenn Kasten53b5d092014-02-05 10:00:23 -08001114 lStatus = BAD_VALUE;
1115 goto Exit;
1116 }
1117
Glenn Kastenc4b88a82014-04-30 16:54:30 -07001118 // further format checks are performed by createTrack_l() depending on the thread type
Eric Laurent21da6472017-11-09 16:29:26 -08001119 if (!audio_is_valid_format(input.config.format)) {
1120 ALOGE("createTrack() invalid format %#x", input.config.format);
Glenn Kasten663c2242013-09-24 11:52:37 -07001121 lStatus = BAD_VALUE;
1122 goto Exit;
1123 }
1124
Mathias Agopian65ab4712010-07-14 17:59:35 -07001125 {
1126 Mutex::Autolock _l(mLock);
Eric Laurent21da6472017-11-09 16:29:26 -08001127 PlaybackThread *thread = checkPlaybackThread_l(output.outputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001128 if (thread == NULL) {
Eric Laurent21da6472017-11-09 16:29:26 -08001129 ALOGE("no playback thread found for output handle %d", output.outputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001130 lStatus = BAD_VALUE;
1131 goto Exit;
1132 }
1133
Eric Laurent21da6472017-11-09 16:29:26 -08001134 client = registerPid(clientPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001135
Glenn Kastene848bd92014-03-13 15:00:32 -07001136 PlaybackThread *effectThread = NULL;
Eric Laurent21da6472017-11-09 16:29:26 -08001137 // check if an effect chain with the same session ID is present on another
1138 // output thread and move it here.
1139 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1140 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
1141 if (mPlaybackThreads.keyAt(i) != output.outputId) {
1142 uint32_t sessions = t->hasAudioSession(sessionId);
1143 if (sessions & ThreadBase::EFFECT_SESSION) {
1144 effectThread = t.get();
1145 break;
Eric Laurentde070132010-07-13 04:45:46 -07001146 }
1147 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001148 }
Eric Laurent21da6472017-11-09 16:29:26 -08001149 ALOGV("createTrack() sessionId: %d", sessionId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001150
Eric Laurent21da6472017-11-09 16:29:26 -08001151 output.sampleRate = input.config.sample_rate;
1152 output.frameCount = input.frameCount;
1153 output.notificationFrameCount = input.notificationFrameCount;
1154 output.flags = input.flags;
Andy Hunga2159aa2021-07-20 13:01:52 -07001155 output.streamType = streamType;
Eric Laurent21da6472017-11-09 16:29:26 -08001156
Eric Laurent42984412019-05-09 17:57:03 -07001157 track = thread->createTrack_l(client, streamType, localAttr, &output.sampleRate,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001158 input.config.format, input.config.channel_mask,
Eric Laurent21da6472017-11-09 16:29:26 -08001159 &output.frameCount, &output.notificationFrameCount,
1160 input.notificationsPerBuffer, input.speed,
1161 input.sharedBuffer, sessionId, &output.flags,
Svet Ganov33761132021-05-13 22:51:08 +00001162 callingPid, adjAttributionSource, input.clientInfo.clientTid,
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001163 &lStatus, portId, input.audioTrackCallback, isSpatialized);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08001164 LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (track == 0));
Glenn Kasten2fc14732013-08-05 14:58:14 -07001165 // we don't abort yet if lStatus != NO_ERROR; there is still work to be done regardless
Eric Laurent39e94f82010-07-28 01:32:47 -07001166
Eric Laurent21da6472017-11-09 16:29:26 -08001167 output.afFrameCount = thread->frameCount();
1168 output.afSampleRate = thread->sampleRate();
1169 output.afLatencyMs = thread->latency();
Eric Laurent973db022018-11-20 14:54:31 -08001170 output.portId = portId;
Eric Laurent21da6472017-11-09 16:29:26 -08001171
Kevin Rocard153f92d2018-12-18 18:33:28 -08001172 if (lStatus == NO_ERROR) {
1173 // Connect secondary outputs. Failure on a secondary output must not imped the primary
1174 // Any secondary output setup failure will lead to a desync between the AP and AF until
1175 // the track is destroyed.
jiabinf042b9b2021-05-07 23:46:28 +00001176 updateSecondaryOutputsForTrack_l(track.get(), thread, secondaryOutputs);
Kevin Rocard153f92d2018-12-18 18:33:28 -08001177 }
1178
Eric Laurent39e94f82010-07-28 01:32:47 -07001179 // move effect chain to this output thread if an effect on same session was waiting
1180 // for a track to be created
1181 if (lStatus == NO_ERROR && effectThread != NULL) {
Glenn Kasten2fc14732013-08-05 14:58:14 -07001182 // no risk of deadlock because AudioFlinger::mLock is held
Eric Laurent39e94f82010-07-28 01:32:47 -07001183 Mutex::Autolock _dl(thread->mLock);
1184 Mutex::Autolock _sl(effectThread->mLock);
Eric Laurent6c796322019-04-09 14:13:17 -07001185 if (moveEffectChain_l(sessionId, effectThread, thread) == NO_ERROR) {
1186 effectThreadId = thread->id();
1187 effectIds = thread->getEffectIds_l(sessionId);
1188 }
Eric Laurent39e94f82010-07-28 01:32:47 -07001189 }
Eric Laurenta011e352012-03-29 15:51:43 -07001190
1191 // Look for sync events awaiting for a session to be used.
Mark Salyzyn3ab368e2014-04-15 14:55:53 -07001192 for (size_t i = 0; i < mPendingSyncEvents.size(); i++) {
Eric Laurent21da6472017-11-09 16:29:26 -08001193 if (mPendingSyncEvents[i]->triggerSession() == sessionId) {
Eric Laurenta011e352012-03-29 15:51:43 -07001194 if (thread->isValidSyncEvent(mPendingSyncEvents[i])) {
Eric Laurent29864602012-05-08 18:57:51 -07001195 if (lStatus == NO_ERROR) {
Glenn Kastend23eedc2012-08-02 13:35:47 -07001196 (void) track->setSyncEvent(mPendingSyncEvents[i]);
Eric Laurent29864602012-05-08 18:57:51 -07001197 } else {
1198 mPendingSyncEvents[i]->cancel();
1199 }
Eric Laurenta011e352012-03-29 15:51:43 -07001200 mPendingSyncEvents.removeAt(i);
1201 i--;
1202 }
1203 }
1204 }
Andy Hung6eff0ff2021-07-30 19:01:48 -07001205 if ((output.flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) == AUDIO_OUTPUT_FLAG_HW_AV_SYNC) {
1206 setAudioHwSyncForSession_l(thread, sessionId);
1207 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001208 }
Glenn Kastene198c362013-08-13 09:13:36 -07001209
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07001210 if (lStatus != NO_ERROR) {
1211 // remove local strong reference to Client before deleting the Track so that the
Eric Laurent021cf962014-05-13 10:18:14 -07001212 // Client destructor is called by the TrackBase destructor with mClientLock held
Eric Laurentfe1a94e2014-05-26 16:03:08 -07001213 // Don't hold mClientLock when releasing the reference on the track as the
1214 // destructor will acquire it.
1215 {
1216 Mutex::Autolock _cl(mClientLock);
1217 client.clear();
1218 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001219 track.clear();
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07001220 goto Exit;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001221 }
1222
Eric Laurent6c796322019-04-09 14:13:17 -07001223 // effectThreadId is not NONE if an effect chain corresponding to the track session
1224 // was found on another thread and must be moved on this thread
1225 if (effectThreadId != AUDIO_IO_HANDLE_NONE) {
1226 AudioSystem::moveEffectsToIo(effectIds, effectThreadId);
1227 }
1228
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08001229 output.audioTrack = new TrackHandle(track);
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001230 _output = VALUE_OR_FATAL(output.toAidl());
1231
Mathias Agopian65ab4712010-07-14 17:59:35 -07001232Exit:
Eric Laurent21da6472017-11-09 16:29:26 -08001233 if (lStatus != NO_ERROR && output.outputId != AUDIO_IO_HANDLE_NONE) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07001234 AudioSystem::releaseOutput(portId);
Eric Laurent21da6472017-11-09 16:29:26 -08001235 }
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08001236 return lStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001237}
1238
Glenn Kasten2c073da2016-02-26 09:14:08 -08001239uint32_t AudioFlinger::sampleRate(audio_io_handle_t ioHandle) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001240{
1241 Mutex::Autolock _l(mLock);
Glenn Kasten2c073da2016-02-26 09:14:08 -08001242 ThreadBase *thread = checkThread_l(ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001243 if (thread == NULL) {
Glenn Kasten2c073da2016-02-26 09:14:08 -08001244 ALOGW("sampleRate() unknown thread %d", ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001245 return 0;
1246 }
1247 return thread->sampleRate();
1248}
1249
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001250audio_format_t AudioFlinger::format(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001251{
1252 Mutex::Autolock _l(mLock);
1253 PlaybackThread *thread = checkPlaybackThread_l(output);
1254 if (thread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +00001255 ALOGW("format() unknown thread %d", output);
Glenn Kasten58f30212012-01-12 12:27:51 -08001256 return AUDIO_FORMAT_INVALID;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001257 }
1258 return thread->format();
1259}
1260
Glenn Kasten2c073da2016-02-26 09:14:08 -08001261size_t AudioFlinger::frameCount(audio_io_handle_t ioHandle) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001262{
1263 Mutex::Autolock _l(mLock);
Glenn Kasten2c073da2016-02-26 09:14:08 -08001264 ThreadBase *thread = checkThread_l(ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001265 if (thread == NULL) {
Glenn Kasten2c073da2016-02-26 09:14:08 -08001266 ALOGW("frameCount() unknown thread %d", ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001267 return 0;
1268 }
Glenn Kasten58912562012-04-03 10:45:00 -07001269 // FIXME currently returns the normal mixer's frame count to avoid confusing legacy callers;
1270 // should examine all callers and fix them to handle smaller counts
Mathias Agopian65ab4712010-07-14 17:59:35 -07001271 return thread->frameCount();
1272}
1273
Glenn Kasten4a8308b2016-04-18 14:10:01 -07001274size_t AudioFlinger::frameCountHAL(audio_io_handle_t ioHandle) const
1275{
1276 Mutex::Autolock _l(mLock);
1277 ThreadBase *thread = checkThread_l(ioHandle);
1278 if (thread == NULL) {
1279 ALOGW("frameCountHAL() unknown thread %d", ioHandle);
1280 return 0;
1281 }
1282 return thread->frameCountHAL();
1283}
1284
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001285uint32_t AudioFlinger::latency(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001286{
1287 Mutex::Autolock _l(mLock);
1288 PlaybackThread *thread = checkPlaybackThread_l(output);
1289 if (thread == NULL) {
Glenn Kastenc9b2e202013-02-26 11:32:32 -08001290 ALOGW("latency(): no playback thread found for output handle %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001291 return 0;
1292 }
1293 return thread->latency();
1294}
1295
1296status_t AudioFlinger::setMasterVolume(float value)
1297{
Eric Laurenta1884f92011-08-23 08:25:03 -07001298 status_t ret = initCheck();
1299 if (ret != NO_ERROR) {
1300 return ret;
1301 }
1302
Mathias Agopian65ab4712010-07-14 17:59:35 -07001303 // check calling permissions
1304 if (!settingsAllowed()) {
1305 return PERMISSION_DENIED;
1306 }
1307
Eric Laurenta4c5a552012-03-29 10:12:40 -07001308 Mutex::Autolock _l(mLock);
John Grossmanee578c02012-07-23 17:05:46 -07001309 mMasterVolume = value;
Eric Laurenta4c5a552012-03-29 10:12:40 -07001310
John Grossmanee578c02012-07-23 17:05:46 -07001311 // Set master volume in the HALs which support it.
Eric Laurent00abf0d2020-04-22 19:28:22 -07001312 {
John Grossmanee578c02012-07-23 17:05:46 -07001313 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07001314 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
1315 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
John Grossman4ff14ba2012-02-08 16:37:41 -08001316
Eric Laurent00abf0d2020-04-22 19:28:22 -07001317 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
1318 if (dev->canSetMasterVolume()) {
1319 dev->hwDevice()->setMasterVolume(value);
1320 }
1321 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent93575202011-01-18 18:39:02 -08001322 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001323 }
John Grossmanee578c02012-07-23 17:05:46 -07001324 // Now set the master volume in each playback thread. Playback threads
1325 // assigned to HALs which do not have master volume support will apply
1326 // master volume during the mix operation. Threads with HALs which do
1327 // support master volume will simply ignore the setting.
Eric Laurentf6870ae2015-05-08 10:50:03 -07001328 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1329 if (mPlaybackThreads.valueAt(i)->isDuplicating()) {
1330 continue;
1331 }
John Grossmanee578c02012-07-23 17:05:46 -07001332 mPlaybackThreads.valueAt(i)->setMasterVolume(value);
Eric Laurentf6870ae2015-05-08 10:50:03 -07001333 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001334
1335 return NO_ERROR;
1336}
1337
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001338status_t AudioFlinger::setMasterBalance(float balance)
1339{
1340 status_t ret = initCheck();
1341 if (ret != NO_ERROR) {
1342 return ret;
1343 }
1344
1345 // check calling permissions
1346 if (!settingsAllowed()) {
1347 return PERMISSION_DENIED;
1348 }
1349
1350 // check range
1351 if (isnan(balance) || fabs(balance) > 1.f) {
1352 return BAD_VALUE;
1353 }
1354
1355 Mutex::Autolock _l(mLock);
1356
1357 // short cut.
1358 if (mMasterBalance == balance) return NO_ERROR;
1359
1360 mMasterBalance = balance;
1361
1362 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1363 if (mPlaybackThreads.valueAt(i)->isDuplicating()) {
1364 continue;
1365 }
1366 mPlaybackThreads.valueAt(i)->setMasterBalance(balance);
1367 }
1368
1369 return NO_ERROR;
1370}
1371
Glenn Kastenf78aee72012-01-04 11:00:47 -08001372status_t AudioFlinger::setMode(audio_mode_t mode)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001373{
Eric Laurenta1884f92011-08-23 08:25:03 -07001374 status_t ret = initCheck();
1375 if (ret != NO_ERROR) {
1376 return ret;
1377 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001378
1379 // check calling permissions
1380 if (!settingsAllowed()) {
1381 return PERMISSION_DENIED;
1382 }
Glenn Kasten930f4ca2012-01-06 16:47:31 -08001383 if (uint32_t(mode) >= AUDIO_MODE_CNT) {
Steve Block5ff1dd52012-01-05 23:22:43 +00001384 ALOGW("Illegal value: setMode(%d)", mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001385 return BAD_VALUE;
1386 }
1387
1388 { // scope for the lock
1389 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07001390 if (mPrimaryHardwareDev == nullptr) {
1391 return INVALID_OPERATION;
1392 }
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001393 sp<DeviceHalInterface> dev = mPrimaryHardwareDev->hwDevice();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001394 mHardwareStatus = AUDIO_HW_SET_MODE;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001395 ret = dev->setMode(mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001396 mHardwareStatus = AUDIO_HW_IDLE;
1397 }
1398
1399 if (NO_ERROR == ret) {
1400 Mutex::Autolock _l(mLock);
1401 mMode = mode;
Glenn Kasten8d6a2442012-02-08 14:04:28 -08001402 for (size_t i = 0; i < mPlaybackThreads.size(); i++)
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001403 mPlaybackThreads.valueAt(i)->setMode(mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001404 }
1405
Joey Poomarin52989982020-03-05 17:40:49 +08001406 mediametrics::LogItem(mMetricsId)
1407 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETMODE)
1408 .set(AMEDIAMETRICS_PROP_AUDIOMODE, toString(mode))
1409 .record();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001410 return ret;
1411}
1412
1413status_t AudioFlinger::setMicMute(bool state)
1414{
Eric Laurenta1884f92011-08-23 08:25:03 -07001415 status_t ret = initCheck();
1416 if (ret != NO_ERROR) {
1417 return ret;
1418 }
1419
Mathias Agopian65ab4712010-07-14 17:59:35 -07001420 // check calling permissions
1421 if (!settingsAllowed()) {
1422 return PERMISSION_DENIED;
1423 }
1424
1425 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07001426 if (mPrimaryHardwareDev == nullptr) {
1427 return INVALID_OPERATION;
1428 }
Eric Laurent2325bf02020-04-08 19:38:13 -07001429 sp<DeviceHalInterface> primaryDev = mPrimaryHardwareDev->hwDevice();
1430 if (primaryDev == nullptr) {
1431 ALOGW("%s: no primary HAL device", __func__);
1432 return INVALID_OPERATION;
1433 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001434 mHardwareStatus = AUDIO_HW_SET_MIC_MUTE;
Eric Laurent2325bf02020-04-08 19:38:13 -07001435 ret = primaryDev->setMicMute(state);
Eric Laurent2f035f52014-09-14 12:11:52 -07001436 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001437 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
Eric Laurent2325bf02020-04-08 19:38:13 -07001438 if (dev != primaryDev) {
1439 (void)dev->setMicMute(state);
Eric Laurent2f035f52014-09-14 12:11:52 -07001440 }
1441 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001442 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent2325bf02020-04-08 19:38:13 -07001443 ALOGW_IF(ret != NO_ERROR, "%s: error %d setting state to HAL", __func__, ret);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001444 return ret;
1445}
1446
1447bool AudioFlinger::getMicMute() const
1448{
Eric Laurenta1884f92011-08-23 08:25:03 -07001449 status_t ret = initCheck();
1450 if (ret != NO_ERROR) {
1451 return false;
1452 }
Glenn Kasten2b213bc2012-02-02 14:05:20 -08001453 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07001454 if (mPrimaryHardwareDev == nullptr) {
1455 return false;
1456 }
Eric Laurent2325bf02020-04-08 19:38:13 -07001457 sp<DeviceHalInterface> primaryDev = mPrimaryHardwareDev->hwDevice();
1458 if (primaryDev == nullptr) {
1459 ALOGW("%s: no primary HAL device", __func__);
1460 return false;
Ricardo Garcia3e91b5d2015-02-19 10:54:52 -08001461 }
Eric Laurent2325bf02020-04-08 19:38:13 -07001462 bool state;
1463 mHardwareStatus = AUDIO_HW_GET_MIC_MUTE;
1464 ret = primaryDev->getMicMute(&state);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001465 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent2325bf02020-04-08 19:38:13 -07001466 ALOGE_IF(ret != NO_ERROR, "%s: error %d getting state from HAL", __func__, ret);
1467 return (ret == NO_ERROR) && state;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001468}
1469
Eric Laurent5ada82e2019-08-29 17:53:54 -07001470void AudioFlinger::setRecordSilenced(audio_port_handle_t portId, bool silenced)
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001471{
Eric Laurent5ada82e2019-08-29 17:53:54 -07001472 ALOGV("AudioFlinger::setRecordSilenced(portId:%d, silenced:%d)", portId, silenced);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001473
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001474 AutoMutex lock(mLock);
1475 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Eric Laurent5ada82e2019-08-29 17:53:54 -07001476 mRecordThreads[i]->setRecordSilenced(portId, silenced);
Eric Laurent331679c2018-04-16 17:03:16 -07001477 }
1478 for (size_t i = 0; i < mMmapThreads.size(); i++) {
Eric Laurent5ada82e2019-08-29 17:53:54 -07001479 mMmapThreads[i]->setRecordSilenced(portId, silenced);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001480 }
1481}
1482
Mathias Agopian65ab4712010-07-14 17:59:35 -07001483status_t AudioFlinger::setMasterMute(bool muted)
1484{
John Grossmand8f178d2012-07-20 14:51:35 -07001485 status_t ret = initCheck();
1486 if (ret != NO_ERROR) {
1487 return ret;
1488 }
1489
Mathias Agopian65ab4712010-07-14 17:59:35 -07001490 // check calling permissions
1491 if (!settingsAllowed()) {
1492 return PERMISSION_DENIED;
1493 }
1494
John Grossmanee578c02012-07-23 17:05:46 -07001495 Mutex::Autolock _l(mLock);
1496 mMasterMute = muted;
John Grossmand8f178d2012-07-20 14:51:35 -07001497
John Grossmanee578c02012-07-23 17:05:46 -07001498 // Set master mute in the HALs which support it.
Eric Laurent00abf0d2020-04-22 19:28:22 -07001499 {
John Grossmanee578c02012-07-23 17:05:46 -07001500 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07001501 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
1502 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
John Grossmand8f178d2012-07-20 14:51:35 -07001503
Eric Laurent00abf0d2020-04-22 19:28:22 -07001504 mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE;
1505 if (dev->canSetMasterMute()) {
1506 dev->hwDevice()->setMasterMute(muted);
1507 }
1508 mHardwareStatus = AUDIO_HW_IDLE;
John Grossmand8f178d2012-07-20 14:51:35 -07001509 }
John Grossmand8f178d2012-07-20 14:51:35 -07001510 }
1511
John Grossmanee578c02012-07-23 17:05:46 -07001512 // Now set the master mute in each playback thread. Playback threads
Glenn Kastena2f59b32020-08-03 16:37:24 -07001513 // assigned to HALs which do not have master mute support will apply master mute
1514 // during the mix operation. Threads with HALs which do support master mute
1515 // will simply ignore the setting.
Eric Laurent6acd1d42017-01-04 14:23:29 -08001516 Vector<VolumeInterface *> volumeInterfaces = getAllVolumeInterfaces_l();
1517 for (size_t i = 0; i < volumeInterfaces.size(); i++) {
1518 volumeInterfaces[i]->setMasterMute(muted);
Eric Laurentf6870ae2015-05-08 10:50:03 -07001519 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001520
1521 return NO_ERROR;
1522}
1523
1524float AudioFlinger::masterVolume() const
1525{
Glenn Kasten98067102011-12-13 11:47:54 -08001526 Mutex::Autolock _l(mLock);
1527 return masterVolume_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001528}
1529
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001530status_t AudioFlinger::getMasterBalance(float *balance) const
1531{
1532 Mutex::Autolock _l(mLock);
1533 *balance = getMasterBalance_l();
1534 return NO_ERROR; // if called through binder, may return a transactional error
1535}
1536
Mathias Agopian65ab4712010-07-14 17:59:35 -07001537bool AudioFlinger::masterMute() const
1538{
Glenn Kasten98067102011-12-13 11:47:54 -08001539 Mutex::Autolock _l(mLock);
1540 return masterMute_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001541}
1542
John Grossman4ff14ba2012-02-08 16:37:41 -08001543float AudioFlinger::masterVolume_l() const
1544{
John Grossman4ff14ba2012-02-08 16:37:41 -08001545 return mMasterVolume;
1546}
1547
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001548float AudioFlinger::getMasterBalance_l() const
1549{
1550 return mMasterBalance;
1551}
1552
John Grossmand8f178d2012-07-20 14:51:35 -07001553bool AudioFlinger::masterMute_l() const
1554{
John Grossmanee578c02012-07-23 17:05:46 -07001555 return mMasterMute;
John Grossmand8f178d2012-07-20 14:51:35 -07001556}
1557
Eric Laurent223fd5c2014-11-11 13:43:36 -08001558status_t AudioFlinger::checkStreamType(audio_stream_type_t stream) const
1559{
1560 if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08001561 ALOGW("checkStreamType() invalid stream %d", stream);
Eric Laurent223fd5c2014-11-11 13:43:36 -08001562 return BAD_VALUE;
1563 }
Andy Hung4ef19fa2018-05-15 19:35:29 -07001564 const uid_t callerUid = IPCThreadState::self()->getCallingUid();
1565 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT && !isAudioServerUid(callerUid)) {
1566 ALOGW("checkStreamType() uid %d cannot use internal stream type %d", callerUid, stream);
Eric Laurent223fd5c2014-11-11 13:43:36 -08001567 return PERMISSION_DENIED;
1568 }
1569
1570 return NO_ERROR;
1571}
1572
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001573status_t AudioFlinger::setStreamVolume(audio_stream_type_t stream, float value,
1574 audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001575{
1576 // check calling permissions
1577 if (!settingsAllowed()) {
1578 return PERMISSION_DENIED;
1579 }
1580
Eric Laurent223fd5c2014-11-11 13:43:36 -08001581 status_t status = checkStreamType(stream);
1582 if (status != NO_ERROR) {
1583 return status;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001584 }
Eric Laurent98e38192018-02-15 18:31:53 -08001585 if (output == AUDIO_IO_HANDLE_NONE) {
1586 return BAD_VALUE;
1587 }
François Gaffie9e1533c2019-04-11 16:07:36 +02001588 LOG_ALWAYS_FATAL_IF(stream == AUDIO_STREAM_PATCH && value != 1.0f,
1589 "AUDIO_STREAM_PATCH must have full scale volume");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001590
1591 AutoMutex lock(mLock);
Eric Laurent98e38192018-02-15 18:31:53 -08001592 VolumeInterface *volumeInterface = getVolumeInterface_l(output);
1593 if (volumeInterface == NULL) {
1594 return BAD_VALUE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001595 }
Eric Laurent98e38192018-02-15 18:31:53 -08001596 volumeInterface->setStreamVolume(stream, value);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001597
1598 return NO_ERROR;
1599}
1600
Eric Laurent076e7c72022-05-03 18:12:28 +02001601status_t AudioFlinger::setRequestedLatencyMode(
Eric Laurent68a40a82022-05-03 18:15:04 +02001602 audio_io_handle_t output, audio_latency_mode_t mode) {
Eric Laurent076e7c72022-05-03 18:12:28 +02001603 if (output == AUDIO_IO_HANDLE_NONE) {
1604 return BAD_VALUE;
1605 }
Eric Laurent68a40a82022-05-03 18:15:04 +02001606 AutoMutex lock(mLock);
1607 PlaybackThread *thread = checkPlaybackThread_l(output);
1608 if (thread == nullptr) {
1609 return BAD_VALUE;
1610 }
1611 return thread->setRequestedLatencyMode(mode);
Eric Laurent076e7c72022-05-03 18:12:28 +02001612}
1613
1614status_t AudioFlinger::getSupportedLatencyModes(audio_io_handle_t output,
Eric Laurent68a40a82022-05-03 18:15:04 +02001615 std::vector<audio_latency_mode_t>* modes) {
Eric Laurent076e7c72022-05-03 18:12:28 +02001616 if (output == AUDIO_IO_HANDLE_NONE) {
1617 return BAD_VALUE;
1618 }
Eric Laurent68a40a82022-05-03 18:15:04 +02001619 AutoMutex lock(mLock);
1620 PlaybackThread *thread = checkPlaybackThread_l(output);
1621 if (thread == nullptr) {
1622 return BAD_VALUE;
1623 }
1624 return thread->getSupportedLatencyModes(modes);
Eric Laurent076e7c72022-05-03 18:12:28 +02001625}
1626
Glenn Kastenfff6d712012-01-12 16:38:12 -08001627status_t AudioFlinger::setStreamMute(audio_stream_type_t stream, bool muted)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001628{
1629 // check calling permissions
1630 if (!settingsAllowed()) {
1631 return PERMISSION_DENIED;
1632 }
1633
Eric Laurent223fd5c2014-11-11 13:43:36 -08001634 status_t status = checkStreamType(stream);
1635 if (status != NO_ERROR) {
1636 return status;
1637 }
1638 ALOG_ASSERT(stream != AUDIO_STREAM_PATCH, "attempt to mute AUDIO_STREAM_PATCH");
1639
1640 if (uint32_t(stream) == AUDIO_STREAM_ENFORCED_AUDIBLE) {
Steve Block29357bc2012-01-06 19:20:56 +00001641 ALOGE("setStreamMute() invalid stream %d", stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001642 return BAD_VALUE;
1643 }
1644
Eric Laurent93575202011-01-18 18:39:02 -08001645 AutoMutex lock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001646 mStreamTypes[stream].mute = muted;
Eric Laurent6acd1d42017-01-04 14:23:29 -08001647 Vector<VolumeInterface *> volumeInterfaces = getAllVolumeInterfaces_l();
1648 for (size_t i = 0; i < volumeInterfaces.size(); i++) {
1649 volumeInterfaces[i]->setStreamMute(stream, muted);
1650 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001651
1652 return NO_ERROR;
1653}
1654
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001655float AudioFlinger::streamVolume(audio_stream_type_t stream, audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001656{
Eric Laurent223fd5c2014-11-11 13:43:36 -08001657 status_t status = checkStreamType(stream);
1658 if (status != NO_ERROR) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001659 return 0.0f;
1660 }
Eric Laurent98e38192018-02-15 18:31:53 -08001661 if (output == AUDIO_IO_HANDLE_NONE) {
1662 return 0.0f;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001663 }
1664
Eric Laurent98e38192018-02-15 18:31:53 -08001665 AutoMutex lock(mLock);
1666 VolumeInterface *volumeInterface = getVolumeInterface_l(output);
1667 if (volumeInterface == NULL) {
1668 return 0.0f;
1669 }
1670
1671 return volumeInterface->streamVolume(stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001672}
1673
Glenn Kastenfff6d712012-01-12 16:38:12 -08001674bool AudioFlinger::streamMute(audio_stream_type_t stream) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001675{
Eric Laurent223fd5c2014-11-11 13:43:36 -08001676 status_t status = checkStreamType(stream);
1677 if (status != NO_ERROR) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001678 return true;
1679 }
1680
Glenn Kasten6637baa2012-01-09 09:40:36 -08001681 AutoMutex lock(mLock);
1682 return streamMute_l(stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001683}
1684
Eric Laurent054d9d32015-04-24 08:48:48 -07001685
Andy Hungd9ef4b12020-11-11 15:13:18 -08001686void AudioFlinger::broadcastParametersToRecordThreads_l(const String8& keyValuePairs)
Eric Laurent054d9d32015-04-24 08:48:48 -07001687{
1688 for (size_t i = 0; i < mRecordThreads.size(); i++) {
1689 mRecordThreads.valueAt(i)->setParameters(keyValuePairs);
1690 }
1691}
1692
jiabinc52b1ff2019-10-31 17:20:42 -07001693void AudioFlinger::updateOutDevicesForRecordThreads_l(const DeviceDescriptorBaseVector& devices)
1694{
1695 for (size_t i = 0; i < mRecordThreads.size(); i++) {
1696 mRecordThreads.valueAt(i)->updateOutDevices(devices);
1697 }
1698}
1699
Mikhail Naganovb261ef52018-07-16 13:34:38 -07001700// forwardAudioHwSyncToDownstreamPatches_l() must be called with AudioFlinger::mLock held
1701void AudioFlinger::forwardParametersToDownstreamPatches_l(
1702 audio_io_handle_t upStream, const String8& keyValuePairs,
1703 std::function<bool(const sp<PlaybackThread>&)> useThread)
1704{
1705 std::vector<PatchPanel::SoftwarePatch> swPatches;
1706 if (mPatchPanel.getDownstreamSoftwarePatches(upStream, &swPatches) != OK) return;
1707 ALOGV_IF(!swPatches.empty(), "%s found %zu downstream patches for stream ID %d",
1708 __func__, swPatches.size(), upStream);
1709 for (const auto& swPatch : swPatches) {
1710 sp<PlaybackThread> downStream = checkPlaybackThread_l(swPatch.getPlaybackThreadHandle());
1711 if (downStream != NULL && (useThread == nullptr || useThread(downStream))) {
1712 downStream->setParameters(keyValuePairs);
1713 }
1714 }
1715}
1716
Eric Laurent74c38dc2020-12-23 18:19:44 +01001717// Update downstream patches for all playback threads attached to an MSD module
1718void AudioFlinger::updateDownStreamPatches_l(const struct audio_patch *patch,
1719 const std::set<audio_io_handle_t> streams)
1720{
1721 for (const audio_io_handle_t stream : streams) {
1722 PlaybackThread *playbackThread = checkPlaybackThread_l(stream);
1723 if (playbackThread == nullptr || !playbackThread->isMsdDevice()) {
1724 continue;
1725 }
1726 playbackThread->setDownStreamPatch(patch);
1727 playbackThread->sendIoConfigEvent(AUDIO_OUTPUT_CONFIG_CHANGED);
1728 }
1729}
1730
Eric Laurentf1047e82018-04-16 19:18:20 -07001731// Filter reserved keys from setParameters() before forwarding to audio HAL or acting upon.
1732// Some keys are used for audio routing and audio path configuration and should be reserved for use
1733// by audio policy and audio flinger for functional, privacy and security reasons.
1734void AudioFlinger::filterReservedParameters(String8& keyValuePairs, uid_t callingUid)
1735{
1736 static const String8 kReservedParameters[] = {
1737 String8(AudioParameter::keyRouting),
1738 String8(AudioParameter::keySamplingRate),
1739 String8(AudioParameter::keyFormat),
1740 String8(AudioParameter::keyChannels),
1741 String8(AudioParameter::keyFrameCount),
1742 String8(AudioParameter::keyInputSource),
1743 String8(AudioParameter::keyMonoOutput),
Mikhail Naganovf23fcf62019-07-08 15:28:43 -07001744 String8(AudioParameter::keyDeviceConnect),
1745 String8(AudioParameter::keyDeviceDisconnect),
Eric Laurentf1047e82018-04-16 19:18:20 -07001746 String8(AudioParameter::keyStreamSupportedFormats),
1747 String8(AudioParameter::keyStreamSupportedChannels),
1748 String8(AudioParameter::keyStreamSupportedSamplingRates),
1749 };
1750
Andy Hung4ef19fa2018-05-15 19:35:29 -07001751 if (isAudioServerUid(callingUid)) {
1752 return; // no need to filter if audioserver.
Eric Laurentf1047e82018-04-16 19:18:20 -07001753 }
1754
1755 AudioParameter param = AudioParameter(keyValuePairs);
1756 String8 value;
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001757 AudioParameter rejectedParam;
Eric Laurentf1047e82018-04-16 19:18:20 -07001758 for (auto& key : kReservedParameters) {
1759 if (param.get(key, value) == NO_ERROR) {
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001760 rejectedParam.add(key, value);
Eric Laurentf1047e82018-04-16 19:18:20 -07001761 param.remove(key);
1762 }
1763 }
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001764 logFilteredParameters(param.size() + rejectedParam.size(), keyValuePairs,
1765 rejectedParam.size(), rejectedParam.toString(), callingUid);
Eric Laurentf1047e82018-04-16 19:18:20 -07001766 keyValuePairs = param.toString();
1767}
1768
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001769void AudioFlinger::logFilteredParameters(size_t originalKVPSize, const String8& originalKVPs,
1770 size_t rejectedKVPSize, const String8& rejectedKVPs,
1771 uid_t callingUid) {
1772 auto prefix = String8::format("UID %5d", callingUid);
1773 auto suffix = String8::format("%zu KVP received: %s", originalKVPSize, originalKVPs.c_str());
1774 if (rejectedKVPSize != 0) {
1775 auto error = String8::format("%zu KVP rejected: %s", rejectedKVPSize, rejectedKVPs.c_str());
1776 ALOGW("%s: %s, %s, %s", __func__, prefix.c_str(), error.c_str(), suffix.c_str());
1777 mRejectedSetParameterLog.log("%s, %s, %s", prefix.c_str(), error.c_str(), suffix.c_str());
1778 } else {
1779 auto& logger = (isServiceUid(callingUid) ? mSystemSetParameterLog : mAppSetParameterLog);
1780 logger.log("%s, %s", prefix.c_str(), suffix.c_str());
1781 }
1782}
1783
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001784status_t AudioFlinger::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001785{
Eric Laurentf1047e82018-04-16 19:18:20 -07001786 ALOGV("setParameters(): io %d, keyvalue %s, calling pid %d calling uid %d",
1787 ioHandle, keyValuePairs.string(),
1788 IPCThreadState::self()->getCallingPid(), IPCThreadState::self()->getCallingUid());
Eric Laurent81784c32012-11-19 14:55:58 -08001789
Mathias Agopian65ab4712010-07-14 17:59:35 -07001790 // check calling permissions
1791 if (!settingsAllowed()) {
1792 return PERMISSION_DENIED;
1793 }
1794
Eric Laurentf1047e82018-04-16 19:18:20 -07001795 String8 filteredKeyValuePairs = keyValuePairs;
1796 filterReservedParameters(filteredKeyValuePairs, IPCThreadState::self()->getCallingUid());
1797
1798 ALOGV("%s: filtered keyvalue %s", __func__, filteredKeyValuePairs.string());
1799
Glenn Kasten142f5192014-03-25 17:44:59 -07001800 // AUDIO_IO_HANDLE_NONE means the parameters are global to the audio hardware interface
1801 if (ioHandle == AUDIO_IO_HANDLE_NONE) {
Eric Laurenta4c5a552012-03-29 10:12:40 -07001802 Mutex::Autolock _l(mLock);
Eric Laurentd21bcd22016-09-08 18:25:54 -07001803 // result will remain NO_INIT if no audio device is present
1804 status_t final_result = NO_INIT;
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001805 {
Eric Laurenta4c5a552012-03-29 10:12:40 -07001806 AutoMutex lock(mHardwareLock);
1807 mHardwareStatus = AUDIO_HW_SET_PARAMETER;
1808 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001809 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
Eric Laurentf1047e82018-04-16 19:18:20 -07001810 status_t result = dev->setParameters(filteredKeyValuePairs);
Eric Laurentd21bcd22016-09-08 18:25:54 -07001811 // return success if at least one audio device accepts the parameters as not all
1812 // HALs are requested to support all parameters. If no audio device supports the
1813 // requested parameters, the last error is reported.
1814 if (final_result != NO_ERROR) {
1815 final_result = result;
1816 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07001817 }
1818 mHardwareStatus = AUDIO_HW_IDLE;
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001819 }
Eric Laurent59bd0da2011-08-01 09:52:20 -07001820 // disable AEC and NS if the device is a BT SCO headset supporting those pre processings
Eric Laurentf1047e82018-04-16 19:18:20 -07001821 AudioParameter param = AudioParameter(filteredKeyValuePairs);
Eric Laurent59bd0da2011-08-01 09:52:20 -07001822 String8 value;
Mikhail Naganov00260b52016-10-13 12:54:24 -07001823 if (param.get(String8(AudioParameter::keyBtNrec), value) == NO_ERROR) {
1824 bool btNrecIsOff = (value == AudioParameter::valueOff);
Eric Laurentd8365c52017-07-16 15:27:05 -07001825 if (mBtNrecIsOff.exchange(btNrecIsOff) != btNrecIsOff) {
Eric Laurent59bd0da2011-08-01 09:52:20 -07001826 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Eric Laurentd8365c52017-07-16 15:27:05 -07001827 mRecordThreads.valueAt(i)->checkBtNrec();
Eric Laurent59bd0da2011-08-01 09:52:20 -07001828 }
Eric Laurent59bd0da2011-08-01 09:52:20 -07001829 }
1830 }
Glenn Kasten28ed2f92012-06-07 10:17:54 -07001831 String8 screenState;
1832 if (param.get(String8(AudioParameter::keyScreenState), screenState) == NO_ERROR) {
Mikhail Naganov00260b52016-10-13 12:54:24 -07001833 bool isOff = (screenState == AudioParameter::valueOff);
Eric Laurent81784c32012-11-19 14:55:58 -08001834 if (isOff != (AudioFlinger::mScreenState & 1)) {
1835 AudioFlinger::mScreenState = ((AudioFlinger::mScreenState & ~1) + 2) | isOff;
Glenn Kasten28ed2f92012-06-07 10:17:54 -07001836 }
1837 }
Dima Zavin799a70e2011-04-18 16:57:27 -07001838 return final_result;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001839 }
1840
1841 // hold a strong ref on thread in case closeOutput() or closeInput() is called
1842 // and the thread is exited once the lock is released
1843 sp<ThreadBase> thread;
1844 {
1845 Mutex::Autolock _l(mLock);
1846 thread = checkPlaybackThread_l(ioHandle);
Glenn Kastend5903ec2012-03-18 10:33:27 -07001847 if (thread == 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001848 thread = checkRecordThread_l(ioHandle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08001849 if (thread == 0) {
1850 thread = checkMmapThread_l(ioHandle);
1851 }
Glenn Kasten7fc9a6f2012-01-10 10:46:34 -08001852 } else if (thread == primaryPlaybackThread_l()) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001853 // indicate output device change to all input threads for pre processing
Eric Laurentf1047e82018-04-16 19:18:20 -07001854 AudioParameter param = AudioParameter(filteredKeyValuePairs);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001855 int value;
Eric Laurent89d94e72012-03-16 20:37:59 -07001856 if ((param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) &&
1857 (value != 0)) {
Andy Hungd9ef4b12020-11-11 15:13:18 -08001858 broadcastParametersToRecordThreads_l(filteredKeyValuePairs);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001859 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001860 }
1861 }
Glenn Kasten7378ca52012-01-20 13:44:40 -08001862 if (thread != 0) {
Mikhail Naganovb261ef52018-07-16 13:34:38 -07001863 status_t result = thread->setParameters(filteredKeyValuePairs);
1864 forwardParametersToDownstreamPatches_l(thread->id(), filteredKeyValuePairs);
1865 return result;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001866 }
1867 return BAD_VALUE;
1868}
1869
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001870String8 AudioFlinger::getParameters(audio_io_handle_t ioHandle, const String8& keys) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001871{
Glenn Kasten827e5f12012-11-02 10:00:06 -07001872 ALOGVV("getParameters() io %d, keys %s, calling pid %d",
1873 ioHandle, keys.string(), IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001874
Eric Laurenta4c5a552012-03-29 10:12:40 -07001875 Mutex::Autolock _l(mLock);
1876
Glenn Kasten142f5192014-03-25 17:44:59 -07001877 if (ioHandle == AUDIO_IO_HANDLE_NONE) {
Dima Zavinfce7a472011-04-19 22:30:36 -07001878 String8 out_s8;
1879
Eric Laurent00abf0d2020-04-22 19:28:22 -07001880 AutoMutex lock(mHardwareLock);
Dima Zavin799a70e2011-04-18 16:57:27 -07001881 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001882 String8 s;
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001883 mHardwareStatus = AUDIO_HW_GET_PARAMETER;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001884 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
Eric Laurent00abf0d2020-04-22 19:28:22 -07001885 status_t result = dev->getParameters(keys, &s);
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001886 mHardwareStatus = AUDIO_HW_IDLE;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001887 if (result == OK) out_s8 += s;
Dima Zavin799a70e2011-04-18 16:57:27 -07001888 }
Dima Zavinfce7a472011-04-19 22:30:36 -07001889 return out_s8;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001890 }
1891
Eric Laurent6acd1d42017-01-04 14:23:29 -08001892 ThreadBase *thread = (ThreadBase *)checkPlaybackThread_l(ioHandle);
1893 if (thread == NULL) {
1894 thread = (ThreadBase *)checkRecordThread_l(ioHandle);
1895 if (thread == NULL) {
1896 thread = (ThreadBase *)checkMmapThread_l(ioHandle);
1897 if (thread == NULL) {
Mikhail Naganovaa165e52017-07-12 10:39:16 -07001898 return String8("");
Eric Laurent6acd1d42017-01-04 14:23:29 -08001899 }
1900 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001901 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08001902 return thread->getParameters(keys);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001903}
1904
Glenn Kastendd8104c2012-07-02 12:42:44 -07001905size_t AudioFlinger::getInputBufferSize(uint32_t sampleRate, audio_format_t format,
1906 audio_channel_mask_t channelMask) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001907{
Eric Laurenta1884f92011-08-23 08:25:03 -07001908 status_t ret = initCheck();
1909 if (ret != NO_ERROR) {
1910 return 0;
1911 }
Eric Laurentcdf924a2016-02-04 15:57:56 -08001912 if ((sampleRate == 0) ||
Phil Burkfdb3c072016-02-09 10:47:02 -08001913 !audio_is_valid_format(format) || !audio_has_proportional_frames(format) ||
Eric Laurentcdf924a2016-02-04 15:57:56 -08001914 !audio_is_input_channel(channelMask)) {
Andy Hung6770c6f2015-04-07 13:43:36 -07001915 return 0;
1916 }
Eric Laurenta1884f92011-08-23 08:25:03 -07001917
Glenn Kasten2b213bc2012-02-02 14:05:20 -08001918 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07001919 if (mPrimaryHardwareDev == nullptr) {
1920 return 0;
1921 }
Glenn Kasten2b213bc2012-02-02 14:05:20 -08001922 mHardwareStatus = AUDIO_HW_GET_INPUT_BUFFER_SIZE;
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00001923
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001924 sp<DeviceHalInterface> dev = mPrimaryHardwareDev->hwDevice();
Judy Hsiaoabab5222019-11-09 18:14:58 +08001925 std::vector<audio_channel_mask_t> channelMasks = {channelMask};
1926 if (channelMask != AUDIO_CHANNEL_IN_MONO)
1927 channelMasks.push_back(AUDIO_CHANNEL_IN_MONO);
1928 if (channelMask != AUDIO_CHANNEL_IN_STEREO)
1929 channelMasks.push_back(AUDIO_CHANNEL_IN_STEREO);
1930
1931 std::vector<audio_format_t> formats = {format};
1932 if (format != AUDIO_FORMAT_PCM_16_BIT)
1933 formats.push_back(AUDIO_FORMAT_PCM_16_BIT);
1934
1935 std::vector<uint32_t> sampleRates = {sampleRate};
1936 static const uint32_t SR_44100 = 44100;
1937 static const uint32_t SR_48000 = 48000;
1938
1939 if (sampleRate != SR_48000)
1940 sampleRates.push_back(SR_48000);
1941 if (sampleRate != SR_44100)
1942 sampleRates.push_back(SR_44100);
1943
Glenn Kasten2b213bc2012-02-02 14:05:20 -08001944 mHardwareStatus = AUDIO_HW_IDLE;
Judy Hsiaoabab5222019-11-09 18:14:58 +08001945
Robin Lee9899ff72019-12-24 22:02:08 +01001946 // Change parameters of the configuration each iteration until we find a
1947 // configuration that the device will support.
1948 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
Judy Hsiaoabab5222019-11-09 18:14:58 +08001949 for (auto testChannelMask : channelMasks) {
1950 config.channel_mask = testChannelMask;
1951 for (auto testFormat : formats) {
1952 config.format = testFormat;
1953 for (auto testSampleRate : sampleRates) {
1954 config.sample_rate = testSampleRate;
Robin Lee9899ff72019-12-24 22:02:08 +01001955
Judy Hsiaoabab5222019-11-09 18:14:58 +08001956 size_t bytes = 0;
1957 status_t result = dev->getInputBufferSize(&config, &bytes);
1958 if (result != OK || bytes == 0) {
1959 continue;
1960 }
1961
1962 if (config.sample_rate != sampleRate || config.channel_mask != channelMask ||
1963 config.format != format) {
1964 uint32_t dstChannelCount = audio_channel_count_from_in_mask(channelMask);
1965 uint32_t srcChannelCount =
1966 audio_channel_count_from_in_mask(config.channel_mask);
1967 size_t srcFrames =
1968 bytes / audio_bytes_per_frame(srcChannelCount, config.format);
1969 size_t dstFrames = destinationFramesPossible(
1970 srcFrames, config.sample_rate, sampleRate);
1971 bytes = dstFrames * audio_bytes_per_frame(dstChannelCount, format);
1972 }
1973 return bytes;
1974 }
1975 }
Andy Hung6770c6f2015-04-07 13:43:36 -07001976 }
Judy Hsiaoabab5222019-11-09 18:14:58 +08001977
1978 ALOGW("getInputBufferSize failed with minimum buffer size sampleRate %u, "
1979 "format %#x, channelMask %#x",sampleRate, format, channelMask);
1980 return 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001981}
1982
Glenn Kasten5f972c02014-01-13 09:59:31 -08001983uint32_t AudioFlinger::getInputFramesLost(audio_io_handle_t ioHandle) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001984{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001985 Mutex::Autolock _l(mLock);
1986
1987 RecordThread *recordThread = checkRecordThread_l(ioHandle);
1988 if (recordThread != NULL) {
1989 return recordThread->getInputFramesLost();
1990 }
1991 return 0;
1992}
1993
1994status_t AudioFlinger::setVoiceVolume(float value)
1995{
Eric Laurenta1884f92011-08-23 08:25:03 -07001996 status_t ret = initCheck();
1997 if (ret != NO_ERROR) {
1998 return ret;
1999 }
2000
Mathias Agopian65ab4712010-07-14 17:59:35 -07002001 // check calling permissions
2002 if (!settingsAllowed()) {
2003 return PERMISSION_DENIED;
2004 }
2005
2006 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002007 if (mPrimaryHardwareDev == nullptr) {
2008 return INVALID_OPERATION;
2009 }
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002010 sp<DeviceHalInterface> dev = mPrimaryHardwareDev->hwDevice();
Glenn Kasten8abf44d2012-02-02 14:16:03 -08002011 mHardwareStatus = AUDIO_HW_SET_VOICE_VOLUME;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002012 ret = dev->setVoiceVolume(value);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002013 mHardwareStatus = AUDIO_HW_IDLE;
2014
Joey Poomarin52989982020-03-05 17:40:49 +08002015 mediametrics::LogItem(mMetricsId)
2016 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETVOICEVOLUME)
2017 .set(AMEDIAMETRICS_PROP_VOICEVOLUME, (double)value)
2018 .record();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002019 return ret;
2020}
2021
Kévin PETIT377b2ec2014-02-03 12:35:36 +00002022status_t AudioFlinger::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002023 audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07002024{
Mathias Agopian65ab4712010-07-14 17:59:35 -07002025 Mutex::Autolock _l(mLock);
2026
2027 PlaybackThread *playbackThread = checkPlaybackThread_l(output);
2028 if (playbackThread != NULL) {
2029 return playbackThread->getRenderPosition(halFrames, dspFrames);
2030 }
2031
2032 return BAD_VALUE;
2033}
2034
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002035void AudioFlinger::registerClient(const sp<media::IAudioFlingerClient>& client)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002036{
Mathias Agopian65ab4712010-07-14 17:59:35 -07002037 Mutex::Autolock _l(mLock);
Eric Laurent44622db2014-08-01 19:00:33 -07002038 if (client == 0) {
2039 return;
2040 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002041 pid_t pid = IPCThreadState::self()->getCallingPid();
Andy Hung5bdc5352019-12-23 14:36:31 -08002042 const uid_t uid = IPCThreadState::self()->getCallingUid();
Eric Laurent021cf962014-05-13 10:18:14 -07002043 {
2044 Mutex::Autolock _cl(mClientLock);
Eric Laurent021cf962014-05-13 10:18:14 -07002045 if (mNotificationClients.indexOfKey(pid) < 0) {
2046 sp<NotificationClient> notificationClient = new NotificationClient(this,
2047 client,
Andy Hung5bdc5352019-12-23 14:36:31 -08002048 pid,
2049 uid);
2050 ALOGV("registerClient() client %p, pid %d, uid %u",
2051 notificationClient.get(), pid, uid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002052
Eric Laurent021cf962014-05-13 10:18:14 -07002053 mNotificationClients.add(pid, notificationClient);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002054
Marco Nelissen06b46062014-11-14 07:58:25 -08002055 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurent021cf962014-05-13 10:18:14 -07002056 binder->linkToDeath(notificationClient);
Eric Laurent021cf962014-05-13 10:18:14 -07002057 }
2058 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002059
Eric Laurent021cf962014-05-13 10:18:14 -07002060 // mClientLock should not be held here because ThreadBase::sendIoConfigEvent() will lock the
Eric Laurentfe1a94e2014-05-26 16:03:08 -07002061 // ThreadBase mutex and the locking order is ThreadBase::mLock then AudioFlinger::mClientLock.
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002062 // the config change is always sent from playback or record threads to avoid deadlock
2063 // with AudioSystem::gLock
2064 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07002065 mPlaybackThreads.valueAt(i)->sendIoConfigEvent(AUDIO_OUTPUT_REGISTERED, pid);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002066 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002067
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002068 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07002069 mRecordThreads.valueAt(i)->sendIoConfigEvent(AUDIO_INPUT_REGISTERED, pid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002070 }
2071}
2072
2073void AudioFlinger::removeNotificationClient(pid_t pid)
2074{
Eric Laurent6c796322019-04-09 14:13:17 -07002075 std::vector< sp<AudioFlinger::EffectModule> > removedEffects;
Eric Laurent021cf962014-05-13 10:18:14 -07002076 {
Eric Laurent6c796322019-04-09 14:13:17 -07002077 Mutex::Autolock _l(mLock);
2078 {
2079 Mutex::Autolock _cl(mClientLock);
2080 mNotificationClients.removeItem(pid);
2081 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002082
Eric Laurent6c796322019-04-09 14:13:17 -07002083 ALOGV("%d died, releasing its sessions", pid);
2084 size_t num = mAudioSessionRefs.size();
2085 bool removed = false;
2086 for (size_t i = 0; i < num; ) {
2087 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
2088 ALOGV(" pid %d @ %zu", ref->mPid, i);
2089 if (ref->mPid == pid) {
2090 ALOGV(" removing entry for pid %d session %d", pid, ref->mSessionid);
2091 mAudioSessionRefs.removeAt(i);
2092 delete ref;
2093 removed = true;
2094 num--;
2095 } else {
2096 i++;
2097 }
2098 }
2099 if (removed) {
2100 removedEffects = purgeStaleEffects_l();
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002101 }
2102 }
Eric Laurent6c796322019-04-09 14:13:17 -07002103 for (auto& effect : removedEffects) {
2104 effect->updatePolicyState();
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002105 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002106}
2107
Mikhail Naganov88536df2021-07-26 17:30:29 -07002108void AudioFlinger::ioConfigChanged(audio_io_config_event_t event,
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002109 const sp<AudioIoDescriptor>& ioDesc,
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002110 pid_t pid) {
Andy Hungb75b6242021-07-29 16:46:14 +00002111 media::AudioIoConfigEvent eventAidl = VALUE_OR_FATAL(
2112 legacy2aidl_audio_io_config_event_t_AudioIoConfigEvent(event));
Mikhail Naganovde3fa182021-07-30 15:06:42 -07002113 media::AudioIoDescriptor descAidl = VALUE_OR_FATAL(
2114 legacy2aidl_AudioIoDescriptor_AudioIoDescriptor(ioDesc));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002115
Eric Laurent021cf962014-05-13 10:18:14 -07002116 Mutex::Autolock _l(mClientLock);
2117 size_t size = mNotificationClients.size();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002118 for (size_t i = 0; i < size; i++) {
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002119 if ((pid == 0) || (mNotificationClients.keyAt(i) == pid)) {
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002120 mNotificationClients.valueAt(i)->audioFlingerClient()->ioConfigChanged(eventAidl,
2121 descAidl);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002122 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002123 }
2124}
2125
Eric Laurent076e7c72022-05-03 18:12:28 +02002126void AudioFlinger::onSupportedLatencyModesChanged(
2127 audio_io_handle_t output, const std::vector<audio_latency_mode_t>& modes) {
2128 int32_t outputAidl = VALUE_OR_FATAL(legacy2aidl_audio_io_handle_t_int32_t(output));
2129 std::vector<media::LatencyMode> modesAidl = VALUE_OR_FATAL(
2130 convertContainer<std::vector<media::LatencyMode>>(modes,
2131 legacy2aidl_audio_latency_mode_t_LatencyMode));
2132
2133 Mutex::Autolock _l(mClientLock);
2134 size_t size = mNotificationClients.size();
2135 for (size_t i = 0; i < size; i++) {
2136 mNotificationClients.valueAt(i)->audioFlingerClient()
2137 ->onSupportedLatencyModesChanged(outputAidl, modesAidl);
2138 }
2139}
2140
Eric Laurent021cf962014-05-13 10:18:14 -07002141// removeClient_l() must be called with AudioFlinger::mClientLock held
Mathias Agopian65ab4712010-07-14 17:59:35 -07002142void AudioFlinger::removeClient_l(pid_t pid)
2143{
Glenn Kasten827e5f12012-11-02 10:00:06 -07002144 ALOGV("removeClient_l() pid %d, calling pid %d", pid,
Glenn Kasten85ab62c2012-11-01 11:11:38 -07002145 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002146 mClients.removeItem(pid);
2147}
2148
Eric Laurent717e1282012-06-29 16:36:52 -07002149// getEffectThread_l() must be called with AudioFlinger::mLock held
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002150sp<AudioFlinger::ThreadBase> AudioFlinger::getEffectThread_l(audio_session_t sessionId,
2151 int effectId)
Eric Laurent717e1282012-06-29 16:36:52 -07002152{
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002153 sp<ThreadBase> thread;
Eric Laurent717e1282012-06-29 16:36:52 -07002154
2155 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002156 if (mPlaybackThreads.valueAt(i)->getEffect(sessionId, effectId) != 0) {
Eric Laurent717e1282012-06-29 16:36:52 -07002157 ALOG_ASSERT(thread == 0);
2158 thread = mPlaybackThreads.valueAt(i);
2159 }
2160 }
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002161 if (thread != nullptr) {
2162 return thread;
2163 }
2164 for (size_t i = 0; i < mRecordThreads.size(); i++) {
2165 if (mRecordThreads.valueAt(i)->getEffect(sessionId, effectId) != 0) {
2166 ALOG_ASSERT(thread == 0);
2167 thread = mRecordThreads.valueAt(i);
2168 }
2169 }
2170 if (thread != nullptr) {
2171 return thread;
2172 }
2173 for (size_t i = 0; i < mMmapThreads.size(); i++) {
2174 if (mMmapThreads.valueAt(i)->getEffect(sessionId, effectId) != 0) {
2175 ALOG_ASSERT(thread == 0);
2176 thread = mMmapThreads.valueAt(i);
2177 }
2178 }
Eric Laurent717e1282012-06-29 16:36:52 -07002179 return thread;
2180}
Mathias Agopian65ab4712010-07-14 17:59:35 -07002181
Mathias Agopian65ab4712010-07-14 17:59:35 -07002182
Mathias Agopian65ab4712010-07-14 17:59:35 -07002183
2184// ----------------------------------------------------------------------------
2185
2186AudioFlinger::Client::Client(const sp<AudioFlinger>& audioFlinger, pid_t pid)
2187 : RefBase(),
2188 mAudioFlinger(audioFlinger),
Atneya3c61d882021-09-20 14:52:15 -04002189 mPid(pid),
2190 mClientAllocator(AllocatorFactory::getClientAllocator()) {}
Mathias Agopian65ab4712010-07-14 17:59:35 -07002191
Eric Laurent021cf962014-05-13 10:18:14 -07002192// Client destructor must be called with AudioFlinger::mClientLock held
Mathias Agopian65ab4712010-07-14 17:59:35 -07002193AudioFlinger::Client::~Client()
2194{
2195 mAudioFlinger->removeClient_l(mPid);
2196}
2197
Atneya3c61d882021-09-20 14:52:15 -04002198AllocatorFactory::ClientAllocator& AudioFlinger::Client::allocator()
Mathias Agopian65ab4712010-07-14 17:59:35 -07002199{
Atneya3c61d882021-09-20 14:52:15 -04002200 return mClientAllocator;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002201}
2202
2203// ----------------------------------------------------------------------------
2204
2205AudioFlinger::NotificationClient::NotificationClient(const sp<AudioFlinger>& audioFlinger,
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002206 const sp<media::IAudioFlingerClient>& client,
Andy Hung5bdc5352019-12-23 14:36:31 -08002207 pid_t pid,
2208 uid_t uid)
2209 : mAudioFlinger(audioFlinger), mPid(pid), mUid(uid), mAudioFlingerClient(client)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002210{
2211}
2212
2213AudioFlinger::NotificationClient::~NotificationClient()
2214{
Mathias Agopian65ab4712010-07-14 17:59:35 -07002215}
2216
Glenn Kasten0f11b512014-01-31 16:18:54 -08002217void AudioFlinger::NotificationClient::binderDied(const wp<IBinder>& who __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002218{
2219 sp<NotificationClient> keep(this);
Glenn Kastena1117922012-01-26 10:53:32 -08002220 mAudioFlinger->removeNotificationClient(mPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002221}
2222
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08002223// ----------------------------------------------------------------------------
2224AudioFlinger::MediaLogNotifier::MediaLogNotifier()
2225 : mPendingRequests(false) {}
2226
2227
2228void AudioFlinger::MediaLogNotifier::requestMerge() {
2229 AutoMutex _l(mMutex);
2230 mPendingRequests = true;
2231 mCond.signal();
2232}
2233
2234bool AudioFlinger::MediaLogNotifier::threadLoop() {
Glenn Kasten04b96fc2017-04-10 14:58:47 -07002235 // Should already have been checked, but just in case
2236 if (sMediaLogService == 0) {
2237 return false;
2238 }
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08002239 // Wait until there are pending requests
2240 {
2241 AutoMutex _l(mMutex);
2242 mPendingRequests = false; // to ignore past requests
2243 while (!mPendingRequests) {
2244 mCond.wait(mMutex);
2245 // TODO may also need an exitPending check
2246 }
2247 mPendingRequests = false;
2248 }
2249 // Execute the actual MediaLogService binder call and ignore extra requests for a while
Glenn Kasten04b96fc2017-04-10 14:58:47 -07002250 sMediaLogService->requestMergeWakeup();
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08002251 usleep(kPostTriggerSleepPeriod);
2252 return true;
2253}
2254
2255void AudioFlinger::requestLogMerge() {
2256 mMediaLogNotifier->requestMerge();
2257}
Mathias Agopian65ab4712010-07-14 17:59:35 -07002258
2259// ----------------------------------------------------------------------------
2260
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08002261status_t AudioFlinger::createRecord(const media::CreateRecordRequest& _input,
2262 media::CreateRecordResponse& _output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002263{
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08002264 CreateRecordInput input = VALUE_OR_RETURN_STATUS(CreateRecordInput::fromAidl(_input));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08002265 CreateRecordOutput output;
2266
Mathias Agopian65ab4712010-07-14 17:59:35 -07002267 sp<RecordThread::RecordTrack> recordTrack;
2268 sp<RecordHandle> recordHandle;
2269 sp<Client> client;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002270 status_t lStatus;
Eric Laurentf14db3c2017-12-08 14:20:36 -08002271 audio_session_t sessionId = input.sessionId;
Eric Laurent77881cd2018-02-09 16:01:31 -08002272 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002273
Eric Laurentf14db3c2017-12-08 14:20:36 -08002274 output.cblk.clear();
2275 output.buffers.clear();
Eric Laurent896c9672017-12-08 14:08:45 -08002276 output.inputId = AUDIO_IO_HANDLE_NONE;
Glenn Kastend776ac62014-05-07 09:16:09 -07002277
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002278 // TODO b/182392553: refactor or clean up
Svet Ganov33761132021-05-13 22:51:08 +00002279 AttributionSourceState adjAttributionSource = input.clientInfo.attributionSource;
2280 bool updatePid = (adjAttributionSource.pid == -1);
Marco Nelissendcb346b2015-09-09 10:47:29 -07002281 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Svet Ganov33761132021-05-13 22:51:08 +00002282 const uid_t currentUid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(
2283 adjAttributionSource.uid));
Andy Hung4ef19fa2018-05-15 19:35:29 -07002284 if (!isAudioServerOrMediaServerUid(callingUid)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002285 ALOGW_IF(currentUid != callingUid,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002286 "%s uid %d tried to pass itself off as %d",
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002287 __FUNCTION__, callingUid, currentUid);
Svet Ganov33761132021-05-13 22:51:08 +00002288 adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07002289 updatePid = true;
2290 }
Eric Laurent09f1ed22019-04-24 17:45:17 -07002291 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Svet Ganov33761132021-05-13 22:51:08 +00002292 const pid_t currentPid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(
2293 adjAttributionSource.pid));
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07002294 if (updatePid) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002295 ALOGW_IF(currentPid != (pid_t)-1 && currentPid != callingPid,
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07002296 "%s uid %d pid %d tried to pass itself off as pid %d",
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002297 __func__, callingUid, callingPid, currentPid);
Svet Ganov33761132021-05-13 22:51:08 +00002298 adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
Marco Nelissendcb346b2015-09-09 10:47:29 -07002299 }
2300
Andy Hung6770c6f2015-04-07 13:43:36 -07002301 // we don't yet support anything other than linear PCM
Eric Laurentf14db3c2017-12-08 14:20:36 -08002302 if (!audio_is_valid_format(input.config.format) || !audio_is_linear_pcm(input.config.format)) {
2303 ALOGE("createRecord() invalid format %#x", input.config.format);
Glenn Kasten291bb6d2013-07-16 17:23:39 -07002304 lStatus = BAD_VALUE;
2305 goto Exit;
2306 }
2307
Glenn Kasten53b5d092014-02-05 10:00:23 -08002308 // further channel mask checks are performed by createRecordTrack_l()
Eric Laurentf14db3c2017-12-08 14:20:36 -08002309 if (!audio_is_input_channel(input.config.channel_mask)) {
2310 ALOGE("createRecord() invalid channel mask %#x", input.config.channel_mask);
Glenn Kasten53b5d092014-02-05 10:00:23 -08002311 lStatus = BAD_VALUE;
2312 goto Exit;
2313 }
2314
Eric Laurentf14db3c2017-12-08 14:20:36 -08002315 if (sessionId == AUDIO_SESSION_ALLOCATE) {
2316 sessionId = (audio_session_t) newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
2317 } else if (audio_unique_id_get_use(sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) {
2318 lStatus = BAD_VALUE;
2319 goto Exit;
2320 }
2321
2322 output.sessionId = sessionId;
Eric Laurentf14db3c2017-12-08 14:20:36 -08002323 output.selectedDeviceId = input.selectedDeviceId;
2324 output.flags = input.flags;
2325
Svet Ganov33761132021-05-13 22:51:08 +00002326 client = registerPid(VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(adjAttributionSource.pid)));
Eric Laurentf14db3c2017-12-08 14:20:36 -08002327
2328 // Not a conventional loop, but a retry loop for at most two iterations total.
2329 // Try first maybe with FAST flag then try again without FAST flag if that fails.
2330 // Exits loop via break on no error of got exit on error
2331 // The sp<> references will be dropped when re-entering scope.
2332 // The lack of indentation is deliberate, to reduce code churn and ease merges.
2333 for (;;) {
Eric Laurent896c9672017-12-08 14:08:45 -08002334 // release previously opened input if retrying.
2335 if (output.inputId != AUDIO_IO_HANDLE_NONE) {
2336 recordTrack.clear();
Eric Laurentfee19762018-01-29 18:44:13 -08002337 AudioSystem::releaseInput(portId);
Eric Laurent896c9672017-12-08 14:08:45 -08002338 output.inputId = AUDIO_IO_HANDLE_NONE;
Yung Ti Su5fac9c62018-05-15 15:07:43 +08002339 output.selectedDeviceId = input.selectedDeviceId;
Eric Laurent77881cd2018-02-09 16:01:31 -08002340 portId = AUDIO_PORT_HANDLE_NONE;
Eric Laurent896c9672017-12-08 14:08:45 -08002341 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08002342 lStatus = AudioSystem::getInputForAttr(&input.attr, &output.inputId,
Mikhail Naganov2996f672019-04-18 12:29:59 -07002343 input.riid,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002344 sessionId,
2345 // FIXME compare to AudioTrack
Svet Ganov33761132021-05-13 22:51:08 +00002346 adjAttributionSource,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002347 &input.config,
2348 output.flags, &output.selectedDeviceId, &portId);
jiabinc1de2df2019-05-07 14:26:40 -07002349 if (lStatus != NO_ERROR) {
2350 ALOGE("createRecord() getInputForAttr return error %d", lStatus);
2351 goto Exit;
2352 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08002353
Glenn Kasten05997e22014-03-13 15:08:33 -07002354 {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002355 Mutex::Autolock _l(mLock);
Eric Laurentf14db3c2017-12-08 14:20:36 -08002356 RecordThread *thread = checkRecordThread_l(output.inputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002357 if (thread == NULL) {
Eric Laurentd52a28c2020-08-21 17:10:39 -07002358 ALOGW("createRecord() checkRecordThread_l failed, input handle %d", output.inputId);
2359 lStatus = FAILED_TRANSACTION;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002360 goto Exit;
2361 }
2362
Eric Laurentf14db3c2017-12-08 14:20:36 -08002363 ALOGV("createRecord() lSessionId: %d input %d", sessionId, output.inputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002364
Eric Laurentf14db3c2017-12-08 14:20:36 -08002365 output.sampleRate = input.config.sample_rate;
2366 output.frameCount = input.frameCount;
2367 output.notificationFrameCount = input.notificationFrameCount;
Glenn Kasten570f6332014-03-13 15:01:06 -07002368
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002369 recordTrack = thread->createRecordTrack_l(client, input.attr, &output.sampleRate,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002370 input.config.format, input.config.channel_mask,
2371 &output.frameCount, sessionId,
2372 &output.notificationFrameCount,
Svet Ganov33761132021-05-13 22:51:08 +00002373 callingPid, adjAttributionSource, &output.flags,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002374 input.clientInfo.clientTid,
Eric Laurentec376dc2021-04-08 20:41:22 +02002375 &lStatus, portId, input.maxSharedAudioHistoryMs);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08002376 LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (recordTrack == 0));
Eric Laurent1b928682014-10-02 19:41:47 -07002377
Eric Laurentf14db3c2017-12-08 14:20:36 -08002378 // lStatus == BAD_TYPE means FAST flag was rejected: request a new input from
2379 // audio policy manager without FAST constraint
2380 if (lStatus == BAD_TYPE) {
Eric Laurentf14db3c2017-12-08 14:20:36 -08002381 continue;
Eric Laurent1b928682014-10-02 19:41:47 -07002382 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08002383
2384 if (lStatus != NO_ERROR) {
Eric Laurentf14db3c2017-12-08 14:20:36 -08002385 goto Exit;
2386 }
2387
jiabinb00edc32021-08-16 16:27:54 +00002388 if (recordTrack->isFastTrack()) {
2389 output.serverConfig = {
2390 thread->sampleRate(),
2391 thread->channelMask(),
2392 thread->format()
2393 };
2394 } else {
2395 output.serverConfig = {
2396 recordTrack->sampleRate(),
2397 recordTrack->channelMask(),
2398 recordTrack->format()
2399 };
2400 }
2401
Eric Laurentf14db3c2017-12-08 14:20:36 -08002402 // Check if one effect chain was awaiting for an AudioRecord to be created on this
2403 // session and move it to this thread.
2404 sp<EffectChain> chain = getOrphanEffectChain_l(sessionId);
2405 if (chain != 0) {
2406 Mutex::Autolock _l(thread->mLock);
2407 thread->addEffectChain_l(chain);
2408 }
2409 break;
2410 }
2411 // End of retry loop.
2412 // The lack of indentation is deliberate, to reduce code churn and ease merges.
Mathias Agopian65ab4712010-07-14 17:59:35 -07002413 }
Glenn Kastene198c362013-08-13 09:13:36 -07002414
Eric Laurentf14db3c2017-12-08 14:20:36 -08002415 output.cblk = recordTrack->getCblk();
2416 output.buffers = recordTrack->getBuffers();
Eric Laurent973db022018-11-20 14:54:31 -08002417 output.portId = portId;
Eric Laurentf14db3c2017-12-08 14:20:36 -08002418
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08002419 output.audioRecord = new RecordHandle(recordTrack);
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08002420 _output = VALUE_OR_FATAL(output.toAidl());
2421
Eric Laurentf14db3c2017-12-08 14:20:36 -08002422Exit:
Eric Laurent7c7f10b2011-06-17 21:29:58 -07002423 if (lStatus != NO_ERROR) {
Glenn Kasten85ab62c2012-11-01 11:11:38 -07002424 // remove local strong reference to Client before deleting the RecordTrack so that the
Eric Laurent021cf962014-05-13 10:18:14 -07002425 // Client destructor is called by the TrackBase destructor with mClientLock held
Eric Laurentfe1a94e2014-05-26 16:03:08 -07002426 // Don't hold mClientLock when releasing the reference on the track as the
2427 // destructor will acquire it.
2428 {
2429 Mutex::Autolock _cl(mClientLock);
2430 client.clear();
2431 }
Eric Laurent896c9672017-12-08 14:08:45 -08002432 recordTrack.clear();
2433 if (output.inputId != AUDIO_IO_HANDLE_NONE) {
Eric Laurentfee19762018-01-29 18:44:13 -08002434 AudioSystem::releaseInput(portId);
Eric Laurent896c9672017-12-08 14:08:45 -08002435 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002436 }
2437
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08002438 return lStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002439}
2440
Eric Laurentb8ba0a92011-08-07 16:32:26 -07002441
2442
Mathias Agopian65ab4712010-07-14 17:59:35 -07002443// ----------------------------------------------------------------------------
2444
Eric Laurenta4c5a552012-03-29 10:12:40 -07002445audio_module_handle_t AudioFlinger::loadHwModule(const char *name)
2446{
Eric Laurent44622db2014-08-01 19:00:33 -07002447 if (name == NULL) {
Glenn Kastena13cde92016-03-28 15:26:02 -07002448 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurent44622db2014-08-01 19:00:33 -07002449 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07002450 if (!settingsAllowed()) {
Glenn Kastena13cde92016-03-28 15:26:02 -07002451 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002452 }
2453 Mutex::Autolock _l(mLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002454 AutoMutex lock(mHardwareLock);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002455 return loadHwModule_l(name);
2456}
2457
Eric Laurent00abf0d2020-04-22 19:28:22 -07002458// loadHwModule_l() must be called with AudioFlinger::mLock and AudioFlinger::mHardwareLock held
Eric Laurenta4c5a552012-03-29 10:12:40 -07002459audio_module_handle_t AudioFlinger::loadHwModule_l(const char *name)
2460{
2461 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
2462 if (strncmp(mAudioHwDevs.valueAt(i)->moduleName(), name, strlen(name)) == 0) {
2463 ALOGW("loadHwModule() module %s already loaded", name);
2464 return mAudioHwDevs.keyAt(i);
2465 }
2466 }
2467
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002468 sp<DeviceHalInterface> dev;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002469
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002470 int rc = mDevicesFactoryHal->openDevice(name, &dev);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002471 if (rc) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002472 ALOGE("loadHwModule() error %d loading module %s", rc, name);
Glenn Kastena13cde92016-03-28 15:26:02 -07002473 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002474 }
2475
2476 mHardwareStatus = AUDIO_HW_INIT;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002477 rc = dev->initCheck();
Eric Laurenta4c5a552012-03-29 10:12:40 -07002478 mHardwareStatus = AUDIO_HW_IDLE;
2479 if (rc) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002480 ALOGE("loadHwModule() init check error %d for module %s", rc, name);
Glenn Kastena13cde92016-03-28 15:26:02 -07002481 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002482 }
2483
John Grossmanee578c02012-07-23 17:05:46 -07002484 // Check and cache this HAL's level of support for master mute and master
2485 // volume. If this is the first HAL opened, and it supports the get
2486 // methods, use the initial values provided by the HAL as the current
2487 // master mute and volume settings.
2488
2489 AudioHwDevice::Flags flags = static_cast<AudioHwDevice::Flags>(0);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002490 if (0 == mAudioHwDevs.size()) {
2491 mHardwareStatus = AUDIO_HW_GET_MASTER_VOLUME;
2492 float mv;
2493 if (OK == dev->getMasterVolume(&mv)) {
2494 mMasterVolume = mv;
John Grossmanee578c02012-07-23 17:05:46 -07002495 }
2496
Eric Laurent00abf0d2020-04-22 19:28:22 -07002497 mHardwareStatus = AUDIO_HW_GET_MASTER_MUTE;
2498 bool mm;
2499 if (OK == dev->getMasterMute(&mm)) {
2500 mMasterMute = mm;
John Grossmanee578c02012-07-23 17:05:46 -07002501 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07002502 }
Eric Laurent00abf0d2020-04-22 19:28:22 -07002503
2504 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
2505 if (OK == dev->setMasterVolume(mMasterVolume)) {
2506 flags = static_cast<AudioHwDevice::Flags>(flags |
2507 AudioHwDevice::AHWD_CAN_SET_MASTER_VOLUME);
2508 }
2509
2510 mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE;
2511 if (OK == dev->setMasterMute(mMasterMute)) {
2512 flags = static_cast<AudioHwDevice::Flags>(flags |
2513 AudioHwDevice::AHWD_CAN_SET_MASTER_MUTE);
2514 }
2515
2516 mHardwareStatus = AUDIO_HW_IDLE;
2517
Mikhail Naganov97373b02018-07-23 13:27:24 -07002518 if (strcmp(name, AUDIO_HARDWARE_MODULE_ID_MSD) == 0) {
Mikhail Naganovadca70f2018-07-09 12:49:25 -07002519 // An MSD module is inserted before hardware modules in order to mix encoded streams.
2520 flags = static_cast<AudioHwDevice::Flags>(flags | AudioHwDevice::AHWD_IS_INSERT);
2521 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07002522
Glenn Kastena13cde92016-03-28 15:26:02 -07002523 audio_module_handle_t handle = (audio_module_handle_t) nextUniqueId(AUDIO_UNIQUE_ID_USE_MODULE);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002524 AudioHwDevice *audioDevice = new AudioHwDevice(handle, name, dev, flags);
2525 if (strcmp(name, AUDIO_HARDWARE_MODULE_ID_PRIMARY) == 0) {
2526 mPrimaryHardwareDev = audioDevice;
2527 mHardwareStatus = AUDIO_HW_SET_MODE;
2528 mPrimaryHardwareDev->hwDevice()->setMode(mMode);
2529 mHardwareStatus = AUDIO_HW_IDLE;
2530 }
2531
jiabine504e7b2021-09-18 00:27:08 +00002532 if (mDevicesFactoryHal->getHalVersion() > MAX_AAUDIO_PROPERTY_DEVICE_HAL_VERSION) {
2533 if (int32_t mixerBursts = dev->getAAudioMixerBurstCount();
jiabina4ff38f2022-02-11 19:42:25 +00002534 mixerBursts > 0 && mixerBursts > mAAudioBurstsPerBuffer) {
jiabine504e7b2021-09-18 00:27:08 +00002535 mAAudioBurstsPerBuffer = mixerBursts;
2536 }
2537 if (int32_t hwBurstMinMicros = dev->getAAudioHardwareBurstMinUsec();
jiabina4ff38f2022-02-11 19:42:25 +00002538 hwBurstMinMicros > 0
2539 && (hwBurstMinMicros < mAAudioHwBurstMinMicros || mAAudioHwBurstMinMicros == 0)) {
jiabine504e7b2021-09-18 00:27:08 +00002540 mAAudioHwBurstMinMicros = hwBurstMinMicros;
2541 }
2542 }
2543
Eric Laurent00abf0d2020-04-22 19:28:22 -07002544 mAudioHwDevs.add(handle, audioDevice);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002545
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002546 ALOGI("loadHwModule() Loaded %s audio interface, handle %d", name, handle);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002547
2548 return handle;
2549
2550}
2551
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002552// ----------------------------------------------------------------------------
2553
Glenn Kasten3b16c762012-11-14 08:44:39 -08002554uint32_t AudioFlinger::getPrimaryOutputSamplingRate()
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002555{
2556 Mutex::Autolock _l(mLock);
Glenn Kastena7335632016-06-09 17:09:53 -07002557 PlaybackThread *thread = fastPlaybackThread_l();
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002558 return thread != NULL ? thread->sampleRate() : 0;
2559}
2560
Glenn Kastene33054e2012-11-14 12:54:39 -08002561size_t AudioFlinger::getPrimaryOutputFrameCount()
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002562{
2563 Mutex::Autolock _l(mLock);
Glenn Kastena7335632016-06-09 17:09:53 -07002564 PlaybackThread *thread = fastPlaybackThread_l();
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002565 return thread != NULL ? thread->frameCountHAL() : 0;
2566}
2567
2568// ----------------------------------------------------------------------------
2569
Andy Hung6f248bb2018-01-23 14:04:37 -08002570status_t AudioFlinger::setLowRamDevice(bool isLowRamDevice, int64_t totalMemory)
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002571{
2572 uid_t uid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07002573 if (!isAudioServerOrSystemServerUid(uid)) {
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002574 return PERMISSION_DENIED;
2575 }
2576 Mutex::Autolock _l(mLock);
2577 if (mIsDeviceTypeKnown) {
2578 return INVALID_OPERATION;
2579 }
2580 mIsLowRamDevice = isLowRamDevice;
Andy Hung6f248bb2018-01-23 14:04:37 -08002581 mTotalMemory = totalMemory;
2582 // mIsLowRamDevice and mTotalMemory are obtained through ActivityManager;
2583 // see ActivityManager.isLowRamDevice() and ActivityManager.getMemoryInfo().
2584 // mIsLowRamDevice generally represent devices with less than 1GB of memory,
2585 // though actual setting is determined through device configuration.
2586 constexpr int64_t GB = 1024 * 1024 * 1024;
2587 mClientSharedHeapSize =
2588 isLowRamDevice ? kMinimumClientSharedHeapSizeBytes
2589 : mTotalMemory < 2 * GB ? 4 * kMinimumClientSharedHeapSizeBytes
2590 : mTotalMemory < 3 * GB ? 8 * kMinimumClientSharedHeapSizeBytes
2591 : mTotalMemory < 4 * GB ? 16 * kMinimumClientSharedHeapSizeBytes
2592 : 32 * kMinimumClientSharedHeapSizeBytes;
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002593 mIsDeviceTypeKnown = true;
Andy Hung6f248bb2018-01-23 14:04:37 -08002594
2595 // TODO: Cache the client shared heap size in a persistent property.
2596 // It's possible that a native process or Java service or app accesses audioserver
2597 // after it is registered by system server, but before AudioService updates
2598 // the memory info. This would occur immediately after boot or an audioserver
2599 // crash and restore. Before update from AudioService, the client would get the
2600 // minimum heap size.
2601
2602 ALOGD("isLowRamDevice:%s totalMemory:%lld mClientSharedHeapSize:%zu",
2603 (isLowRamDevice ? "true" : "false"),
2604 (long long)mTotalMemory,
2605 mClientSharedHeapSize.load());
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002606 return NO_ERROR;
2607}
2608
Andy Hung6f248bb2018-01-23 14:04:37 -08002609size_t AudioFlinger::getClientSharedHeapSize() const
2610{
2611 size_t heapSizeInBytes = property_get_int32("ro.af.client_heap_size_kbyte", 0) * 1024;
2612 if (heapSizeInBytes != 0) { // read-only property overrides all.
2613 return heapSizeInBytes;
2614 }
2615 return mClientSharedHeapSize;
2616}
2617
Mikhail Naganovdea53042018-04-26 13:10:21 -07002618status_t AudioFlinger::setAudioPortConfig(const struct audio_port_config *config)
2619{
2620 ALOGV(__func__);
2621
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08002622 status_t status = AudioValidator::validateAudioPortConfig(*config);
2623 if (status != NO_ERROR) {
2624 return status;
2625 }
2626
Mikhail Naganovdea53042018-04-26 13:10:21 -07002627 audio_module_handle_t module;
2628 if (config->type == AUDIO_PORT_TYPE_DEVICE) {
2629 module = config->ext.device.hw_module;
2630 } else {
2631 module = config->ext.mix.hw_module;
2632 }
2633
2634 Mutex::Autolock _l(mLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002635 AutoMutex lock(mHardwareLock);
Mikhail Naganovdea53042018-04-26 13:10:21 -07002636 ssize_t index = mAudioHwDevs.indexOfKey(module);
2637 if (index < 0) {
2638 ALOGW("%s() bad hw module %d", __func__, module);
2639 return BAD_VALUE;
2640 }
2641
2642 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueAt(index);
2643 return audioHwDevice->hwDevice()->setAudioPortConfig(config);
2644}
2645
Eric Laurent93c3d412014-08-01 14:48:35 -07002646audio_hw_sync_t AudioFlinger::getAudioHwSyncForSession(audio_session_t sessionId)
2647{
2648 Mutex::Autolock _l(mLock);
Eric Laurentfa90e842014-10-17 18:12:31 -07002649
2650 ssize_t index = mHwAvSyncIds.indexOfKey(sessionId);
2651 if (index >= 0) {
2652 ALOGV("getAudioHwSyncForSession found ID %d for session %d",
2653 mHwAvSyncIds.valueAt(index), sessionId);
2654 return mHwAvSyncIds.valueAt(index);
2655 }
2656
Eric Laurent00abf0d2020-04-22 19:28:22 -07002657 sp<DeviceHalInterface> dev;
2658 {
2659 AutoMutex lock(mHardwareLock);
2660 if (mPrimaryHardwareDev == nullptr) {
2661 return AUDIO_HW_SYNC_INVALID;
2662 }
2663 dev = mPrimaryHardwareDev->hwDevice();
2664 }
2665 if (dev == nullptr) {
Eric Laurentfa90e842014-10-17 18:12:31 -07002666 return AUDIO_HW_SYNC_INVALID;
2667 }
Eric Laurentfa90e842014-10-17 18:12:31 -07002668
Ytai Ben-Tsvi48287b52021-12-01 15:07:11 -08002669 error::Result<audio_hw_sync_t> result = dev->getHwAvSync();
2670 if (!result.ok()) {
Eric Laurentfa90e842014-10-17 18:12:31 -07002671 ALOGW("getAudioHwSyncForSession error getting sync for session %d", sessionId);
2672 return AUDIO_HW_SYNC_INVALID;
2673 }
Ytai Ben-Tsvi48287b52021-12-01 15:07:11 -08002674 audio_hw_sync_t value = VALUE_OR_FATAL(result);
Eric Laurentfa90e842014-10-17 18:12:31 -07002675
2676 // allow only one session for a given HW A/V sync ID.
2677 for (size_t i = 0; i < mHwAvSyncIds.size(); i++) {
Ytai Ben-Tsvi48287b52021-12-01 15:07:11 -08002678 if (mHwAvSyncIds.valueAt(i) == value) {
Eric Laurentfa90e842014-10-17 18:12:31 -07002679 ALOGV("getAudioHwSyncForSession removing ID %d for session %d",
2680 value, mHwAvSyncIds.keyAt(i));
2681 mHwAvSyncIds.removeItemsAt(i);
Eric Laurent93c3d412014-08-01 14:48:35 -07002682 break;
2683 }
2684 }
Eric Laurentfa90e842014-10-17 18:12:31 -07002685
2686 mHwAvSyncIds.add(sessionId, value);
2687
2688 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2689 sp<PlaybackThread> thread = mPlaybackThreads.valueAt(i);
2690 uint32_t sessions = thread->hasAudioSession(sessionId);
Eric Laurent4c415062016-06-17 16:14:16 -07002691 if (sessions & ThreadBase::TRACK_SESSION) {
Eric Laurentfa90e842014-10-17 18:12:31 -07002692 AudioParameter param = AudioParameter();
Mikhail Naganov00260b52016-10-13 12:54:24 -07002693 param.addInt(String8(AudioParameter::keyStreamHwAvSync), value);
Mikhail Naganovb261ef52018-07-16 13:34:38 -07002694 String8 keyValuePairs = param.toString();
2695 thread->setParameters(keyValuePairs);
2696 forwardParametersToDownstreamPatches_l(thread->id(), keyValuePairs,
2697 [](const sp<PlaybackThread>& thread) { return thread->usesHwAvSync(); });
Eric Laurentfa90e842014-10-17 18:12:31 -07002698 break;
2699 }
2700 }
2701
2702 ALOGV("getAudioHwSyncForSession adding ID %d for session %d", value, sessionId);
2703 return (audio_hw_sync_t)value;
Eric Laurent93c3d412014-08-01 14:48:35 -07002704}
2705
Eric Laurent72e3f392015-05-20 14:43:50 -07002706status_t AudioFlinger::systemReady()
2707{
2708 Mutex::Autolock _l(mLock);
2709 ALOGI("%s", __FUNCTION__);
2710 if (mSystemReady) {
2711 ALOGW("%s called twice", __FUNCTION__);
2712 return NO_ERROR;
2713 }
2714 mSystemReady = true;
2715 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2716 ThreadBase *thread = (ThreadBase *)mPlaybackThreads.valueAt(i).get();
2717 thread->systemReady();
2718 }
2719 for (size_t i = 0; i < mRecordThreads.size(); i++) {
2720 ThreadBase *thread = (ThreadBase *)mRecordThreads.valueAt(i).get();
2721 thread->systemReady();
2722 }
Eric Laurentd66d7a12021-07-13 13:35:32 +02002723 for (size_t i = 0; i < mMmapThreads.size(); i++) {
2724 ThreadBase *thread = (ThreadBase *)mMmapThreads.valueAt(i).get();
2725 thread->systemReady();
2726 }
Vlad Popae8d99472022-06-30 16:02:48 +02002727
2728 // Java services are ready, so we can create a reference to AudioService
2729 getOrCreateAudioManager();
2730
Eric Laurent72e3f392015-05-20 14:43:50 -07002731 return NO_ERROR;
2732}
2733
Vlad Popae8d99472022-06-30 16:02:48 +02002734sp<IAudioManager> AudioFlinger::getOrCreateAudioManager()
2735{
2736 if (mAudioManager.load() == nullptr) {
2737 // use checkService() to avoid blocking
2738 sp<IBinder> binder =
2739 defaultServiceManager()->checkService(String16(kAudioServiceName));
2740 if (binder != nullptr) {
2741 mAudioManager = interface_cast<IAudioManager>(binder);
2742 } else {
2743 ALOGE("%s(): binding to audio service failed.", __func__);
2744 }
2745 }
2746 return mAudioManager.load();
2747}
2748
jiabin46a76fa2018-01-05 10:18:21 -08002749status_t AudioFlinger::getMicrophones(std::vector<media::MicrophoneInfo> *microphones)
2750{
jiabin9ff780e2018-03-19 18:19:52 -07002751 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002752 status_t status = INVALID_OPERATION;
2753
2754 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
2755 std::vector<media::MicrophoneInfo> mics;
2756 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
2757 mHardwareStatus = AUDIO_HW_GET_MICROPHONES;
2758 status_t devStatus = dev->hwDevice()->getMicrophones(&mics);
2759 mHardwareStatus = AUDIO_HW_IDLE;
2760 if (devStatus == NO_ERROR) {
2761 microphones->insert(microphones->begin(), mics.begin(), mics.end());
2762 // report success if at least one HW module supports the function.
2763 status = NO_ERROR;
2764 }
2765 }
2766
jiabin9ff780e2018-03-19 18:19:52 -07002767 return status;
jiabin46a76fa2018-01-05 10:18:21 -08002768}
2769
Eric Laurentfa90e842014-10-17 18:12:31 -07002770// setAudioHwSyncForSession_l() must be called with AudioFlinger::mLock held
2771void AudioFlinger::setAudioHwSyncForSession_l(PlaybackThread *thread, audio_session_t sessionId)
2772{
2773 ssize_t index = mHwAvSyncIds.indexOfKey(sessionId);
2774 if (index >= 0) {
2775 audio_hw_sync_t syncId = mHwAvSyncIds.valueAt(index);
2776 ALOGV("setAudioHwSyncForSession_l found ID %d for session %d", syncId, sessionId);
2777 AudioParameter param = AudioParameter();
Mikhail Naganov00260b52016-10-13 12:54:24 -07002778 param.addInt(String8(AudioParameter::keyStreamHwAvSync), syncId);
Mikhail Naganovb261ef52018-07-16 13:34:38 -07002779 String8 keyValuePairs = param.toString();
2780 thread->setParameters(keyValuePairs);
2781 forwardParametersToDownstreamPatches_l(thread->id(), keyValuePairs,
2782 [](const sp<PlaybackThread>& thread) { return thread->usesHwAvSync(); });
Eric Laurentfa90e842014-10-17 18:12:31 -07002783 }
2784}
2785
2786
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002787// ----------------------------------------------------------------------------
2788
Eric Laurent83b88082014-06-20 18:31:16 -07002789
Eric Laurent6acd1d42017-01-04 14:23:29 -08002790sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t module,
jiabin43810402019-10-24 14:58:31 -07002791 audio_io_handle_t *output,
Eric Laurentf1f22e72021-07-13 14:04:14 +02002792 audio_config_t *halConfig,
2793 audio_config_base_t *mixerConfig __unused,
jiabin43810402019-10-24 14:58:31 -07002794 audio_devices_t deviceType,
2795 const String8& address,
2796 audio_output_flags_t flags)
Eric Laurent83b88082014-06-20 18:31:16 -07002797{
jiabin43810402019-10-24 14:58:31 -07002798 AudioHwDevice *outHwDev = findSuitableHwDev_l(module, deviceType);
Eric Laurent83b88082014-06-20 18:31:16 -07002799 if (outHwDev == NULL) {
Eric Laurente28c66d2022-01-21 13:40:41 +01002800 return nullptr;
Eric Laurent83b88082014-06-20 18:31:16 -07002801 }
2802
Eric Laurentcf2c0212014-07-25 16:20:43 -07002803 if (*output == AUDIO_IO_HANDLE_NONE) {
Glenn Kasteneeecb982016-02-26 10:44:04 -08002804 *output = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);
2805 } else {
2806 // Audio Policy does not currently request a specific output handle.
2807 // If this is ever needed, see openInput_l() for example code.
2808 ALOGE("openOutput_l requested output handle %d is not AUDIO_IO_HANDLE_NONE", *output);
Eric Laurente28c66d2022-01-21 13:40:41 +01002809 return nullptr;
Eric Laurentcf2c0212014-07-25 16:20:43 -07002810 }
Eric Laurent83b88082014-06-20 18:31:16 -07002811
Eric Laurente28c66d2022-01-21 13:40:41 +01002812#ifndef MULTICHANNEL_EFFECT_CHAIN
2813 if (flags & AUDIO_OUTPUT_FLAG_SPATIALIZER) {
2814 ALOGE("openOutput_l() cannot create spatializer thread "
2815 "without #define MULTICHANNEL_EFFECT_CHAIN");
2816 return nullptr;
2817 }
2818#endif
2819
Eric Laurent83b88082014-06-20 18:31:16 -07002820 mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;
2821
Eric Laurent83b88082014-06-20 18:31:16 -07002822 // FOR TESTING ONLY:
Andy Hung9a592762014-07-21 21:56:01 -07002823 // This if statement allows overriding the audio policy settings
2824 // and forcing a specific format or channel mask to the HAL/Sink device for testing.
2825 if (!(flags & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD | AUDIO_OUTPUT_FLAG_DIRECT))) {
2826 // Check only for Normal Mixing mode
2827 if (kEnableExtendedPrecision) {
2828 // Specify format (uncomment one below to choose)
Eric Laurentf1f22e72021-07-13 14:04:14 +02002829 //halConfig->format = AUDIO_FORMAT_PCM_FLOAT;
2830 //halConfig->format = AUDIO_FORMAT_PCM_24_BIT_PACKED;
2831 //halConfig->format = AUDIO_FORMAT_PCM_32_BIT;
2832 //halConfig->format = AUDIO_FORMAT_PCM_8_24_BIT;
2833 // ALOGV("openOutput_l() upgrading format to %#08x", halConfig->format);
Andy Hung9a592762014-07-21 21:56:01 -07002834 }
2835 if (kEnableExtendedChannels) {
2836 // Specify channel mask (uncomment one below to choose)
Eric Laurentf1f22e72021-07-13 14:04:14 +02002837 //halConfig->channel_mask = audio_channel_out_mask_from_count(4); // for USB 4ch
2838 //halConfig->channel_mask = audio_channel_mask_from_representation_and_bits(
Andy Hung9a592762014-07-21 21:56:01 -07002839 // AUDIO_CHANNEL_REPRESENTATION_INDEX, (1 << 4) - 1); // another 4ch example
2840 }
Eric Laurent83b88082014-06-20 18:31:16 -07002841 }
2842
Phil Burk062e67a2015-02-11 13:40:50 -08002843 AudioStreamOut *outputStream = NULL;
2844 status_t status = outHwDev->openOutputStream(
2845 &outputStream,
2846 *output,
jiabin43810402019-10-24 14:58:31 -07002847 deviceType,
Phil Burk062e67a2015-02-11 13:40:50 -08002848 flags,
Eric Laurentf1f22e72021-07-13 14:04:14 +02002849 halConfig,
Phil Burk062e67a2015-02-11 13:40:50 -08002850 address.string());
Eric Laurent83b88082014-06-20 18:31:16 -07002851
2852 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent83b88082014-06-20 18:31:16 -07002853
Phil Burk062e67a2015-02-11 13:40:50 -08002854 if (status == NO_ERROR) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08002855 if (flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) {
2856 sp<MmapPlaybackThread> thread =
jiabinc52b1ff2019-10-31 17:20:42 -07002857 new MmapPlaybackThread(this, *output, outHwDev, outputStream, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002858 mMmapThreads.add(*output, thread);
2859 ALOGV("openOutput_l() created mmap playback thread: ID %d thread %p",
2860 *output, thread.get());
2861 return thread;
Eric Laurent83b88082014-06-20 18:31:16 -07002862 } else {
Eric Laurent6acd1d42017-01-04 14:23:29 -08002863 sp<PlaybackThread> thread;
Eric Laurente28c66d2022-01-21 13:40:41 +01002864 if (flags & AUDIO_OUTPUT_FLAG_SPATIALIZER) {
Eric Laurentfa0f6742021-08-17 18:39:44 +02002865 thread = new SpatializerThread(this, outputStream, *output,
Eric Laurentb3f315a2021-07-13 15:09:05 +02002866 mSystemReady, mixerConfig);
Eric Laurente28c66d2022-01-21 13:40:41 +01002867 ALOGV("openOutput_l() created spatializer output: ID %d thread %p",
Eric Laurentb3f315a2021-07-13 15:09:05 +02002868 *output, thread.get());
2869 } else if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
jiabinc52b1ff2019-10-31 17:20:42 -07002870 thread = new OffloadThread(this, outputStream, *output, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002871 ALOGV("openOutput_l() created offload output: ID %d thread %p",
2872 *output, thread.get());
2873 } else if ((flags & AUDIO_OUTPUT_FLAG_DIRECT)
Eric Laurentf1f22e72021-07-13 14:04:14 +02002874 || !isValidPcmSinkFormat(halConfig->format)
2875 || !isValidPcmSinkChannelMask(halConfig->channel_mask)) {
jiabinc52b1ff2019-10-31 17:20:42 -07002876 thread = new DirectOutputThread(this, outputStream, *output, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002877 ALOGV("openOutput_l() created direct output: ID %d thread %p",
2878 *output, thread.get());
2879 } else {
jiabinc52b1ff2019-10-31 17:20:42 -07002880 thread = new MixerThread(this, outputStream, *output, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002881 ALOGV("openOutput_l() created mixer output: ID %d thread %p",
2882 *output, thread.get());
2883 }
2884 mPlaybackThreads.add(*output, thread);
Eric Laurent74c38dc2020-12-23 18:19:44 +01002885 struct audio_patch patch;
2886 mPatchPanel.notifyStreamOpened(outHwDev, *output, &patch);
2887 if (thread->isMsdDevice()) {
2888 thread->setDownStreamPatch(&patch);
2889 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08002890 return thread;
Eric Laurent83b88082014-06-20 18:31:16 -07002891 }
Eric Laurent83b88082014-06-20 18:31:16 -07002892 }
2893
Eric Laurente28c66d2022-01-21 13:40:41 +01002894 return nullptr;
Eric Laurent83b88082014-06-20 18:31:16 -07002895}
2896
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08002897status_t AudioFlinger::openOutput(const media::OpenOutputRequest& request,
2898 media::OpenOutputResponse* response)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002899{
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08002900 audio_module_handle_t module = VALUE_OR_RETURN_STATUS(
2901 aidl2legacy_int32_t_audio_module_handle_t(request.module));
Eric Laurentf1f22e72021-07-13 14:04:14 +02002902 audio_config_t halConfig = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -07002903 aidl2legacy_AudioConfig_audio_config_t(request.halConfig, false /*isInput*/));
Eric Laurentf1f22e72021-07-13 14:04:14 +02002904 audio_config_base_t mixerConfig = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -07002905 aidl2legacy_AudioConfigBase_audio_config_base_t(request.mixerConfig, false/*isInput*/));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08002906 sp<DeviceDescriptorBase> device = VALUE_OR_RETURN_STATUS(
2907 aidl2legacy_DeviceDescriptorBase(request.device));
2908 audio_output_flags_t flags = VALUE_OR_RETURN_STATUS(
Andy Hung973638a2020-12-08 20:47:45 -08002909 aidl2legacy_int32_t_audio_output_flags_t_mask(request.flags));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08002910
2911 audio_io_handle_t output;
2912 uint32_t latencyMs;
2913
jiabin43810402019-10-24 14:58:31 -07002914 ALOGI("openOutput() this %p, module %d Device %s, SamplingRate %d, Format %#08x, "
Glenn Kasten49f36ba2017-12-06 13:02:02 -08002915 "Channels %#x, flags %#x",
Eric Laurent6acd1d42017-01-04 14:23:29 -08002916 this, module,
jiabin43810402019-10-24 14:58:31 -07002917 device->toString().c_str(),
Eric Laurentf1f22e72021-07-13 14:04:14 +02002918 halConfig.sample_rate,
2919 halConfig.format,
2920 halConfig.channel_mask,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002921 flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002922
jiabin43810402019-10-24 14:58:31 -07002923 audio_devices_t deviceType = device->type();
2924 const String8 address = String8(device->address().c_str());
2925
2926 if (deviceType == AUDIO_DEVICE_NONE) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07002927 return BAD_VALUE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002928 }
Dima Zavin799a70e2011-04-18 16:57:27 -07002929
Mathias Agopian65ab4712010-07-14 17:59:35 -07002930 Mutex::Autolock _l(mLock);
2931
Eric Laurentf1f22e72021-07-13 14:04:14 +02002932 sp<ThreadBase> thread = openOutput_l(module, &output, &halConfig,
2933 &mixerConfig, deviceType, address, flags);
Eric Laurent83b88082014-06-20 18:31:16 -07002934 if (thread != 0) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08002935 if ((flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) == 0) {
2936 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08002937 latencyMs = playbackThread->latency();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002938
Eric Laurent6acd1d42017-01-04 14:23:29 -08002939 // notify client processes of the new output creation
2940 playbackThread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002941
Eric Laurent00abf0d2020-04-22 19:28:22 -07002942 // the first primary output opened designates the primary hw device if no HW module
2943 // named "primary" was already loaded.
2944 AutoMutex lock(mHardwareLock);
2945 if ((mPrimaryHardwareDev == nullptr) && (flags & AUDIO_OUTPUT_FLAG_PRIMARY)) {
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08002946 ALOGI("Using module %d as the primary audio interface", module);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002947 mPrimaryHardwareDev = playbackThread->getOutput()->audioHwDev;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002948
Eric Laurent6acd1d42017-01-04 14:23:29 -08002949 mHardwareStatus = AUDIO_HW_SET_MODE;
2950 mPrimaryHardwareDev->hwDevice()->setMode(mMode);
2951 mHardwareStatus = AUDIO_HW_IDLE;
2952 }
2953 } else {
2954 MmapThread *mmapThread = (MmapThread *)thread.get();
2955 mmapThread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002956 }
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08002957 response->output = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
Mikhail Naganovde3fa182021-07-30 15:06:42 -07002958 response->config = VALUE_OR_RETURN_STATUS(
2959 legacy2aidl_audio_config_t_AudioConfig(halConfig, false /*isInput*/));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08002960 response->latencyMs = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(latencyMs));
Andy Hung973638a2020-12-08 20:47:45 -08002961 response->flags = VALUE_OR_RETURN_STATUS(
2962 legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
Eric Laurentcf2c0212014-07-25 16:20:43 -07002963 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002964 }
2965
Eric Laurentcf2c0212014-07-25 16:20:43 -07002966 return NO_INIT;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002967}
2968
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002969audio_io_handle_t AudioFlinger::openDuplicateOutput(audio_io_handle_t output1,
2970 audio_io_handle_t output2)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002971{
2972 Mutex::Autolock _l(mLock);
2973 MixerThread *thread1 = checkMixerThread_l(output1);
2974 MixerThread *thread2 = checkMixerThread_l(output2);
2975
2976 if (thread1 == NULL || thread2 == NULL) {
Glenn Kasten85ab62c2012-11-01 11:11:38 -07002977 ALOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1,
2978 output2);
Glenn Kasten142f5192014-03-25 17:44:59 -07002979 return AUDIO_IO_HANDLE_NONE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002980 }
2981
Glenn Kasteneeecb982016-02-26 10:44:04 -08002982 audio_io_handle_t id = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);
Eric Laurent72e3f392015-05-20 14:43:50 -07002983 DuplicatingThread *thread = new DuplicatingThread(this, thread1, id, mSystemReady);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002984 thread->addOutputTrack(thread2);
2985 mPlaybackThreads.add(id, thread);
2986 // notify client processes of the new output creation
Eric Laurent73e26b62015-04-27 16:55:58 -07002987 thread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002988 return id;
2989}
2990
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002991status_t AudioFlinger::closeOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002992{
Glenn Kastend96c5722012-04-25 13:44:49 -07002993 return closeOutput_nonvirtual(output);
2994}
2995
2996status_t AudioFlinger::closeOutput_nonvirtual(audio_io_handle_t output)
2997{
Mathias Agopian65ab4712010-07-14 17:59:35 -07002998 // keep strong reference on the playback thread so that
2999 // it is not destroyed while exit() is executed
Eric Laurent6acd1d42017-01-04 14:23:29 -08003000 sp<PlaybackThread> playbackThread;
3001 sp<MmapPlaybackThread> mmapThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003002 {
3003 Mutex::Autolock _l(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003004 playbackThread = checkPlaybackThread_l(output);
3005 if (playbackThread != NULL) {
3006 ALOGV("closeOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003007
Andy Hungdc099c22018-09-18 13:46:39 -07003008 dumpToThreadLog_l(playbackThread);
Andy Hunga8115dc2018-08-24 15:51:59 -07003009
Eric Laurent6acd1d42017-01-04 14:23:29 -08003010 if (playbackThread->type() == ThreadBase::MIXER) {
3011 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3012 if (mPlaybackThreads.valueAt(i)->isDuplicating()) {
3013 DuplicatingThread *dupThread =
3014 (DuplicatingThread *)mPlaybackThreads.valueAt(i).get();
3015 dupThread->removeOutputTrack((MixerThread *)playbackThread.get());
3016 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003017 }
3018 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003019
3020
Eric Laurent6acd1d42017-01-04 14:23:29 -08003021 mPlaybackThreads.removeItem(output);
3022 // save all effects to the default thread
3023 if (mPlaybackThreads.size()) {
3024 PlaybackThread *dstThread = checkPlaybackThread_l(mPlaybackThreads.keyAt(0));
3025 if (dstThread != NULL) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08003026 // audioflinger lock is held so order of thread lock acquisition doesn't matter
Eric Laurent6acd1d42017-01-04 14:23:29 -08003027 Mutex::Autolock _dl(dstThread->mLock);
3028 Mutex::Autolock _sl(playbackThread->mLock);
3029 Vector< sp<EffectChain> > effectChains = playbackThread->getEffectChains_l();
3030 for (size_t i = 0; i < effectChains.size(); i ++) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08003031 moveEffectChain_l(effectChains[i]->sessionId(), playbackThread.get(),
Eric Laurent6c796322019-04-09 14:13:17 -07003032 dstThread);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003033 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003034 }
3035 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003036 } else {
3037 mmapThread = (MmapPlaybackThread *)checkMmapThread_l(output);
3038 if (mmapThread == 0) {
3039 return BAD_VALUE;
3040 }
Andy Hungdc099c22018-09-18 13:46:39 -07003041 dumpToThreadLog_l(mmapThread);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003042 mMmapThreads.removeItem(output);
Phil Burk7f6b40d2017-02-09 13:18:38 -08003043 ALOGD("closing mmapThread %p", mmapThread.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003044 }
Mikhail Naganov88536df2021-07-26 17:30:29 -07003045 ioConfigChanged(AUDIO_OUTPUT_CLOSED, sp<AudioIoDescriptor>::make(output));
Mikhail Naganovadca70f2018-07-09 12:49:25 -07003046 mPatchPanel.notifyStreamClosed(output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003047 }
Glenn Kastenb28686f2012-01-06 08:39:38 -08003048 // The thread entity (active unit of execution) is no longer running here,
3049 // but the ThreadBase container still exists.
Mathias Agopian65ab4712010-07-14 17:59:35 -07003050
Eric Laurent6acd1d42017-01-04 14:23:29 -08003051 if (playbackThread != 0) {
3052 playbackThread->exit();
3053 if (!playbackThread->isDuplicating()) {
3054 closeOutputFinish(playbackThread);
3055 }
3056 } else if (mmapThread != 0) {
Phil Burk7f6b40d2017-02-09 13:18:38 -08003057 ALOGD("mmapThread exit()");
Eric Laurent6acd1d42017-01-04 14:23:29 -08003058 mmapThread->exit();
3059 AudioStreamOut *out = mmapThread->clearOutput();
3060 ALOG_ASSERT(out != NULL, "out shouldn't be NULL");
3061 // from now on thread->mOutput is NULL
3062 delete out;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003063 }
3064 return NO_ERROR;
3065}
3066
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -07003067void AudioFlinger::closeOutputFinish(const sp<PlaybackThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07003068{
3069 AudioStreamOut *out = thread->clearOutput();
3070 ALOG_ASSERT(out != NULL, "out shouldn't be NULL");
3071 // from now on thread->mOutput is NULL
Eric Laurent83b88082014-06-20 18:31:16 -07003072 delete out;
3073}
3074
Mikhail Naganov444ecc32018-05-01 17:40:05 -07003075void AudioFlinger::closeThreadInternal_l(const sp<PlaybackThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07003076{
3077 mPlaybackThreads.removeItem(thread->mId);
3078 thread->exit();
3079 closeOutputFinish(thread);
3080}
3081
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003082status_t AudioFlinger::suspendOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003083{
3084 Mutex::Autolock _l(mLock);
3085 PlaybackThread *thread = checkPlaybackThread_l(output);
3086
3087 if (thread == NULL) {
3088 return BAD_VALUE;
3089 }
3090
Steve Block3856b092011-10-20 11:56:00 +01003091 ALOGV("suspendOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003092 thread->suspend();
3093
3094 return NO_ERROR;
3095}
3096
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003097status_t AudioFlinger::restoreOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003098{
3099 Mutex::Autolock _l(mLock);
3100 PlaybackThread *thread = checkPlaybackThread_l(output);
3101
3102 if (thread == NULL) {
3103 return BAD_VALUE;
3104 }
3105
Steve Block3856b092011-10-20 11:56:00 +01003106 ALOGV("restoreOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003107
3108 thread->restore();
3109
3110 return NO_ERROR;
3111}
3112
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003113status_t AudioFlinger::openInput(const media::OpenInputRequest& request,
3114 media::OpenInputResponse* response)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003115{
Eric Laurent83b88082014-06-20 18:31:16 -07003116 Mutex::Autolock _l(mLock);
3117
Mikhail Naganov21a32ec2021-07-08 14:40:12 -07003118 AudioDeviceTypeAddr device = VALUE_OR_RETURN_STATUS(
3119 aidl2legacy_AudioDeviceTypeAddress(request.device));
3120 if (device.mType == AUDIO_DEVICE_NONE) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07003121 return BAD_VALUE;
Eric Laurent83b88082014-06-20 18:31:16 -07003122 }
3123
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003124 audio_io_handle_t input = VALUE_OR_RETURN_STATUS(
3125 aidl2legacy_int32_t_audio_io_handle_t(request.input));
3126 audio_config_t config = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -07003127 aidl2legacy_AudioConfig_audio_config_t(request.config, true /*isInput*/));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003128
Mikhail Naganovb4e037e2019-01-14 15:56:33 -08003129 sp<ThreadBase> thread = openInput_l(
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003130 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_module_handle_t(request.module)),
3131 &input,
3132 &config,
3133 device.mType,
3134 device.address().c_str(),
Mikhail Naganovddceecc2021-09-03 13:58:56 -07003135 VALUE_OR_RETURN_STATUS(aidl2legacy_AudioSource_audio_source_t(request.source)),
Andy Hung973638a2020-12-08 20:47:45 -08003136 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_input_flags_t_mask(request.flags)),
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003137 AUDIO_DEVICE_NONE,
3138 String8{});
3139
3140 response->input = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(input));
Mikhail Naganovde3fa182021-07-30 15:06:42 -07003141 response->config = VALUE_OR_RETURN_STATUS(
3142 legacy2aidl_audio_config_t_AudioConfig(config, true /*isInput*/));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003143 response->device = request.device;
Eric Laurent83b88082014-06-20 18:31:16 -07003144
3145 if (thread != 0) {
Eric Laurent83b88082014-06-20 18:31:16 -07003146 // notify client processes of the new input creation
Eric Laurent73e26b62015-04-27 16:55:58 -07003147 thread->ioConfigChanged(AUDIO_INPUT_OPENED);
Eric Laurentcf2c0212014-07-25 16:20:43 -07003148 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003149 }
Eric Laurentcf2c0212014-07-25 16:20:43 -07003150 return NO_INIT;
Eric Laurent83b88082014-06-20 18:31:16 -07003151}
Dima Zavin799a70e2011-04-18 16:57:27 -07003152
Eric Laurent6acd1d42017-01-04 14:23:29 -08003153sp<AudioFlinger::ThreadBase> AudioFlinger::openInput_l(audio_module_handle_t module,
Eric Laurentcf2c0212014-07-25 16:20:43 -07003154 audio_io_handle_t *input,
3155 audio_config_t *config,
Glenn Kastene7d66712015-03-05 13:46:52 -08003156 audio_devices_t devices,
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003157 const char* address,
Eric Laurentcf2c0212014-07-25 16:20:43 -07003158 audio_source_t source,
Mikhail Naganovb4e037e2019-01-14 15:56:33 -08003159 audio_input_flags_t flags,
3160 audio_devices_t outputDevice,
3161 const String8& outputDeviceAddress)
Eric Laurent83b88082014-06-20 18:31:16 -07003162{
Glenn Kastene7d66712015-03-05 13:46:52 -08003163 AudioHwDevice *inHwDev = findSuitableHwDev_l(module, devices);
Glenn Kasten6e2ebe92013-08-13 09:14:51 -07003164 if (inHwDev == NULL) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07003165 *input = AUDIO_IO_HANDLE_NONE;
Dima Zavin799a70e2011-04-18 16:57:27 -07003166 return 0;
Glenn Kasten6e2ebe92013-08-13 09:14:51 -07003167 }
Dima Zavin799a70e2011-04-18 16:57:27 -07003168
Glenn Kasteneeecb982016-02-26 10:44:04 -08003169 // Audio Policy can request a specific handle for hardware hotword.
3170 // The goal here is not to re-open an already opened input.
3171 // It is to use a pre-assigned I/O handle.
Eric Laurentcf2c0212014-07-25 16:20:43 -07003172 if (*input == AUDIO_IO_HANDLE_NONE) {
Glenn Kasteneeecb982016-02-26 10:44:04 -08003173 *input = nextUniqueId(AUDIO_UNIQUE_ID_USE_INPUT);
3174 } else if (audio_unique_id_get_use(*input) != AUDIO_UNIQUE_ID_USE_INPUT) {
3175 ALOGE("openInput_l() requested input handle %d is invalid", *input);
3176 return 0;
3177 } else if (mRecordThreads.indexOfKey(*input) >= 0) {
3178 // This should not happen in a transient state with current design.
3179 ALOGE("openInput_l() requested input handle %d is already assigned", *input);
3180 return 0;
Eric Laurentcf2c0212014-07-25 16:20:43 -07003181 }
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07003182
Eric Laurentcf2c0212014-07-25 16:20:43 -07003183 audio_config_t halconfig = *config;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07003184 sp<DeviceHalInterface> inHwHal = inHwDev->hwDevice();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003185 sp<StreamInHalInterface> inStream;
3186 status_t status = inHwHal->openInputStream(
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003187 *input, devices, &halconfig, flags, address, source,
Mikhail Naganovb4e037e2019-01-14 15:56:33 -08003188 outputDevice, outputDeviceAddress, &inStream);
Glenn Kasten49f36ba2017-12-06 13:02:02 -08003189 ALOGV("openInput_l() openInputStream returned input %p, devices %#x, SamplingRate %d"
3190 ", Format %#x, Channels %#x, flags %#x, status %d addr %s",
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003191 inStream.get(),
Mikhail Naganovf558e022016-11-14 17:45:17 -08003192 devices,
Eric Laurentcf2c0212014-07-25 16:20:43 -07003193 halconfig.sample_rate,
3194 halconfig.format,
3195 halconfig.channel_mask,
Glenn Kastenec40d282014-07-15 15:31:26 -07003196 flags,
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003197 status, address);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003198
Glenn Kasten85ab62c2012-11-01 11:11:38 -07003199 // If the input could not be opened with the requested parameters and we can handle the
Andy Hung6770c6f2015-04-07 13:43:36 -07003200 // conversion internally, try to open again with the proposed parameters.
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07003201 if (status == BAD_VALUE &&
Andy Hung6770c6f2015-04-07 13:43:36 -07003202 audio_is_linear_pcm(config->format) &&
3203 audio_is_linear_pcm(halconfig.format) &&
3204 (halconfig.sample_rate <= AUDIO_RESAMPLER_DOWN_RATIO_MAX * config->sample_rate) &&
Andy Hung936845a2021-06-08 00:09:06 -07003205 (audio_channel_count_from_in_mask(halconfig.channel_mask) <= FCC_LIMIT) &&
3206 (audio_channel_count_from_in_mask(config->channel_mask) <= FCC_LIMIT)) {
Glenn Kasten85948432013-08-19 12:09:05 -07003207 // FIXME describe the change proposed by HAL (save old values so we can log them here)
Eric Laurentcf2c0212014-07-25 16:20:43 -07003208 ALOGV("openInput_l() reopening with proposed sampling rate and channel mask");
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003209 inStream.clear();
3210 status = inHwHal->openInputStream(
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003211 *input, devices, &halconfig, flags, address, source,
Mikhail Naganovb4e037e2019-01-14 15:56:33 -08003212 outputDevice, outputDeviceAddress, &inStream);
Glenn Kasten85948432013-08-19 12:09:05 -07003213 // FIXME log this new status; HAL should not propose any further changes
Mathias Agopian65ab4712010-07-14 17:59:35 -07003214 }
3215
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003216 if (status == NO_ERROR && inStream != 0) {
Eric Laurent05067782016-06-01 18:27:28 -07003217 AudioStreamIn *inputStream = new AudioStreamIn(inHwDev, inStream, flags);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003218 if ((flags & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0) {
3219 sp<MmapCaptureThread> thread =
jiabinc52b1ff2019-10-31 17:20:42 -07003220 new MmapCaptureThread(this, *input, inHwDev, inputStream, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003221 mMmapThreads.add(*input, thread);
Glenn Kastend3bb6452016-12-05 18:14:37 -08003222 ALOGV("openInput_l() created mmap capture thread: ID %d thread %p", *input,
3223 thread.get());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003224 return thread;
3225 } else {
Eric Laurent6acd1d42017-01-04 14:23:29 -08003226 // Start record thread
3227 // RecordThread requires both input and output device indication to forward to audio
3228 // pre processing modules
jiabinc52b1ff2019-10-31 17:20:42 -07003229 sp<RecordThread> thread = new RecordThread(this, inputStream, *input, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003230 mRecordThreads.add(*input, thread);
3231 ALOGV("openInput_l() created record thread: ID %d thread %p", *input, thread.get());
3232 return thread;
3233 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003234 }
3235
Eric Laurentcf2c0212014-07-25 16:20:43 -07003236 *input = AUDIO_IO_HANDLE_NONE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003237 return 0;
3238}
3239
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003240status_t AudioFlinger::closeInput(audio_io_handle_t input)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003241{
Glenn Kastend96c5722012-04-25 13:44:49 -07003242 return closeInput_nonvirtual(input);
3243}
3244
3245status_t AudioFlinger::closeInput_nonvirtual(audio_io_handle_t input)
3246{
Mathias Agopian65ab4712010-07-14 17:59:35 -07003247 // keep strong reference on the record thread so that
3248 // it is not destroyed while exit() is executed
Eric Laurent6acd1d42017-01-04 14:23:29 -08003249 sp<RecordThread> recordThread;
3250 sp<MmapCaptureThread> mmapThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003251 {
3252 Mutex::Autolock _l(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003253 recordThread = checkRecordThread_l(input);
3254 if (recordThread != 0) {
3255 ALOGV("closeInput() %d", input);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003256
Andy Hungdc099c22018-09-18 13:46:39 -07003257 dumpToThreadLog_l(recordThread);
Andy Hung0264e7d2018-09-17 19:30:46 -07003258
Eric Laurent6acd1d42017-01-04 14:23:29 -08003259 // If we still have effect chains, it means that a client still holds a handle
3260 // on at least one effect. We must either move the chain to an existing thread with the
3261 // same session ID or put it aside in case a new record thread is opened for a
3262 // new capture on the same session
3263 sp<EffectChain> chain;
3264 {
3265 Mutex::Autolock _sl(recordThread->mLock);
3266 Vector< sp<EffectChain> > effectChains = recordThread->getEffectChains_l();
3267 // Note: maximum one chain per record thread
3268 if (effectChains.size() != 0) {
3269 chain = effectChains[0];
Eric Laurent1b928682014-10-02 19:41:47 -07003270 }
3271 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003272 if (chain != 0) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08003273 // first check if a record thread is already opened with a client on same session.
Eric Laurent6acd1d42017-01-04 14:23:29 -08003274 // This should only happen in case of overlap between one thread tear down and the
3275 // creation of its replacement
3276 size_t i;
3277 for (i = 0; i < mRecordThreads.size(); i++) {
3278 sp<RecordThread> t = mRecordThreads.valueAt(i);
3279 if (t == recordThread) {
3280 continue;
3281 }
3282 if (t->hasAudioSession(chain->sessionId()) != 0) {
3283 Mutex::Autolock _l(t->mLock);
3284 ALOGV("closeInput() found thread %d for effect session %d",
3285 t->id(), chain->sessionId());
3286 t->addEffectChain_l(chain);
3287 break;
3288 }
3289 }
Glenn Kastend3bb6452016-12-05 18:14:37 -08003290 // put the chain aside if we could not find a record thread with the same session id
Eric Laurent6acd1d42017-01-04 14:23:29 -08003291 if (i == mRecordThreads.size()) {
3292 putOrphanEffectChain_l(chain);
3293 }
Eric Laurentaaa44472014-09-12 17:41:50 -07003294 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003295 mRecordThreads.removeItem(input);
3296 } else {
3297 mmapThread = (MmapCaptureThread *)checkMmapThread_l(input);
3298 if (mmapThread == 0) {
3299 return BAD_VALUE;
3300 }
Andy Hungdc099c22018-09-18 13:46:39 -07003301 dumpToThreadLog_l(mmapThread);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003302 mMmapThreads.removeItem(input);
Eric Laurentaaa44472014-09-12 17:41:50 -07003303 }
Mikhail Naganov88536df2021-07-26 17:30:29 -07003304 ioConfigChanged(AUDIO_INPUT_CLOSED, sp<AudioIoDescriptor>::make(input));
Mathias Agopian65ab4712010-07-14 17:59:35 -07003305 }
Eric Laurent83b88082014-06-20 18:31:16 -07003306 // FIXME: calling thread->exit() without mLock held should not be needed anymore now that
3307 // we have a different lock for notification client
Eric Laurent6acd1d42017-01-04 14:23:29 -08003308 if (recordThread != 0) {
3309 closeInputFinish(recordThread);
3310 } else if (mmapThread != 0) {
3311 mmapThread->exit();
3312 AudioStreamIn *in = mmapThread->clearInput();
3313 ALOG_ASSERT(in != NULL, "in shouldn't be NULL");
3314 // from now on thread->mInput is NULL
3315 delete in;
3316 }
Eric Laurent83b88082014-06-20 18:31:16 -07003317 return NO_ERROR;
3318}
Mathias Agopian65ab4712010-07-14 17:59:35 -07003319
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -07003320void AudioFlinger::closeInputFinish(const sp<RecordThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07003321{
3322 thread->exit();
Eric Laurentb8ba0a92011-08-07 16:32:26 -07003323 AudioStreamIn *in = thread->clearInput();
Glenn Kasten5798d4e2012-03-08 12:18:35 -08003324 ALOG_ASSERT(in != NULL, "in shouldn't be NULL");
Eric Laurentb8ba0a92011-08-07 16:32:26 -07003325 // from now on thread->mInput is NULL
Dima Zavin799a70e2011-04-18 16:57:27 -07003326 delete in;
Eric Laurent83b88082014-06-20 18:31:16 -07003327}
Mathias Agopian65ab4712010-07-14 17:59:35 -07003328
Mikhail Naganov444ecc32018-05-01 17:40:05 -07003329void AudioFlinger::closeThreadInternal_l(const sp<RecordThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07003330{
3331 mRecordThreads.removeItem(thread->mId);
3332 closeInputFinish(thread);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003333}
3334
Glenn Kastend2304db2014-02-03 07:40:31 -08003335status_t AudioFlinger::invalidateStream(audio_stream_type_t stream)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003336{
3337 Mutex::Autolock _l(mLock);
Glenn Kastend2304db2014-02-03 07:40:31 -08003338 ALOGV("invalidateStream() stream %d", stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003339
3340 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3341 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
Eric Laurent22167852012-06-20 12:26:32 -07003342 thread->invalidateTracks(stream);
Eric Laurentde070132010-07-13 04:45:46 -07003343 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003344 for (size_t i = 0; i < mMmapThreads.size(); i++) {
3345 mMmapThreads[i]->invalidateTracks(stream);
3346 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003347 return NO_ERROR;
3348}
3349
3350
Glenn Kasteneeecb982016-02-26 10:44:04 -08003351audio_unique_id_t AudioFlinger::newAudioUniqueId(audio_unique_id_use_t use)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003352{
Glenn Kasten9d003132016-04-06 14:38:09 -07003353 // This is a binder API, so a malicious client could pass in a bad parameter.
3354 // Check for that before calling the internal API nextUniqueId().
3355 if ((unsigned) use >= (unsigned) AUDIO_UNIQUE_ID_USE_MAX) {
3356 ALOGE("newAudioUniqueId invalid use %d", use);
3357 return AUDIO_UNIQUE_ID_ALLOCATE;
3358 }
Glenn Kasteneeecb982016-02-26 10:44:04 -08003359 return nextUniqueId(use);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003360}
3361
Andy Hung8b0bfd92019-12-23 13:11:11 -08003362void AudioFlinger::acquireAudioSessionId(
3363 audio_session_t audioSession, pid_t pid, uid_t uid)
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003364{
3365 Mutex::Autolock _l(mLock);
Glenn Kastenbb001922012-02-03 11:10:26 -08003366 pid_t caller = IPCThreadState::self()->getCallingPid();
Marco Nelissend457c972014-02-11 08:47:07 -08003367 ALOGV("acquiring %d from %d, for %d", audioSession, caller, pid);
Andy Hung4ef19fa2018-05-15 19:35:29 -07003368 const uid_t callerUid = IPCThreadState::self()->getCallingUid();
Andy Hung8b0bfd92019-12-23 13:11:11 -08003369 if (pid != (pid_t)-1 && isAudioServerOrMediaServerUid(callerUid)) {
3370 caller = pid; // check must match releaseAudioSessionId()
3371 }
3372 if (uid == (uid_t)-1 || !isAudioServerOrMediaServerUid(callerUid)) {
3373 uid = callerUid;
Marco Nelissend457c972014-02-11 08:47:07 -08003374 }
Eric Laurentd1b28d42013-09-18 18:47:13 -07003375
Eric Laurent021cf962014-05-13 10:18:14 -07003376 {
3377 Mutex::Autolock _cl(mClientLock);
3378 // Ignore requests received from processes not known as notification client. The request
3379 // is likely proxied by mediaserver (e.g CameraService) and releaseAudioSessionId() can be
3380 // called from a different pid leaving a stale session reference. Also we don't know how
3381 // to clear this reference if the client process dies.
3382 if (mNotificationClients.indexOfKey(caller) < 0) {
3383 ALOGW("acquireAudioSessionId() unknown client %d for session %d", caller, audioSession);
3384 return;
3385 }
Eric Laurentd1b28d42013-09-18 18:47:13 -07003386 }
3387
Glenn Kasten8d6a2442012-02-08 14:04:28 -08003388 size_t num = mAudioSessionRefs.size();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08003389 for (size_t i = 0; i < num; i++) {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003390 AudioSessionRef *ref = mAudioSessionRefs.editItemAt(i);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08003391 if (ref->mSessionid == audioSession && ref->mPid == caller) {
3392 ref->mCnt++;
3393 ALOGV(" incremented refcount to %d", ref->mCnt);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003394 return;
3395 }
3396 }
Andy Hung8b0bfd92019-12-23 13:11:11 -08003397 mAudioSessionRefs.push(new AudioSessionRef(audioSession, caller, uid));
Glenn Kasten84afa3b2012-01-25 15:28:08 -08003398 ALOGV(" added new entry for %d", audioSession);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003399}
3400
Glenn Kastend848eb42016-03-08 13:42:11 -08003401void AudioFlinger::releaseAudioSessionId(audio_session_t audioSession, pid_t pid)
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003402{
Eric Laurent6c796322019-04-09 14:13:17 -07003403 std::vector< sp<EffectModule> > removedEffects;
3404 {
3405 Mutex::Autolock _l(mLock);
3406 pid_t caller = IPCThreadState::self()->getCallingPid();
3407 ALOGV("releasing %d from %d for %d", audioSession, caller, pid);
3408 const uid_t callerUid = IPCThreadState::self()->getCallingUid();
Andy Hung8b0bfd92019-12-23 13:11:11 -08003409 if (pid != (pid_t)-1 && isAudioServerOrMediaServerUid(callerUid)) {
3410 caller = pid; // check must match acquireAudioSessionId()
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003411 }
Eric Laurent6c796322019-04-09 14:13:17 -07003412 size_t num = mAudioSessionRefs.size();
3413 for (size_t i = 0; i < num; i++) {
3414 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
3415 if (ref->mSessionid == audioSession && ref->mPid == caller) {
3416 ref->mCnt--;
3417 ALOGV(" decremented refcount to %d", ref->mCnt);
3418 if (ref->mCnt == 0) {
3419 mAudioSessionRefs.removeAt(i);
3420 delete ref;
3421 std::vector< sp<EffectModule> > effects = purgeStaleEffects_l();
3422 removedEffects.insert(removedEffects.end(), effects.begin(), effects.end());
3423 }
3424 goto Exit;
3425 }
3426 }
3427 // If the caller is audioserver it is likely that the session being released was acquired
3428 // on behalf of a process not in notification clients and we ignore the warning.
3429 ALOGW_IF(!isAudioServerUid(callerUid),
3430 "session id %d not found for pid %d", audioSession, caller);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003431 }
Eric Laurent6c796322019-04-09 14:13:17 -07003432
3433Exit:
3434 for (auto& effect : removedEffects) {
3435 effect->updatePolicyState();
3436 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003437}
3438
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08003439bool AudioFlinger::isSessionAcquired_l(audio_session_t audioSession)
3440{
3441 size_t num = mAudioSessionRefs.size();
3442 for (size_t i = 0; i < num; i++) {
3443 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
3444 if (ref->mSessionid == audioSession) {
3445 return true;
3446 }
3447 }
3448 return false;
3449}
3450
Eric Laurent6c796322019-04-09 14:13:17 -07003451std::vector<sp<AudioFlinger::EffectModule>> AudioFlinger::purgeStaleEffects_l() {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003452
Steve Block3856b092011-10-20 11:56:00 +01003453 ALOGV("purging stale effects");
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003454
3455 Vector< sp<EffectChain> > chains;
Eric Laurent6c796322019-04-09 14:13:17 -07003456 std::vector< sp<EffectModule> > removedEffects;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003457
3458 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3459 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
Mateusz Kaplon2a6e1b02017-03-30 16:50:50 +02003460 Mutex::Autolock _l(t->mLock);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003461 for (size_t j = 0; j < t->mEffectChains.size(); j++) {
3462 sp<EffectChain> ec = t->mEffectChains[j];
Eric Laurent3f75a5b2019-11-12 15:55:51 -08003463 if (!audio_is_global_session(ec->sessionId())) {
Marco Nelissen0270b182011-08-12 14:14:39 -07003464 chains.push(ec);
3465 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003466 }
3467 }
Eric Laurent6c796322019-04-09 14:13:17 -07003468
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003469 for (size_t i = 0; i < mRecordThreads.size(); i++) {
3470 sp<RecordThread> t = mRecordThreads.valueAt(i);
Mateusz Kaplon2a6e1b02017-03-30 16:50:50 +02003471 Mutex::Autolock _l(t->mLock);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003472 for (size_t j = 0; j < t->mEffectChains.size(); j++) {
3473 sp<EffectChain> ec = t->mEffectChains[j];
3474 chains.push(ec);
3475 }
3476 }
3477
Eric Laurent6c796322019-04-09 14:13:17 -07003478 for (size_t i = 0; i < mMmapThreads.size(); i++) {
3479 sp<MmapThread> t = mMmapThreads.valueAt(i);
3480 Mutex::Autolock _l(t->mLock);
3481 for (size_t j = 0; j < t->mEffectChains.size(); j++) {
3482 sp<EffectChain> ec = t->mEffectChains[j];
3483 chains.push(ec);
3484 }
3485 }
3486
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003487 for (size_t i = 0; i < chains.size(); i++) {
3488 sp<EffectChain> ec = chains[i];
3489 int sessionid = ec->sessionId();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003490 sp<ThreadBase> t = ec->thread().promote();
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003491 if (t == 0) {
3492 continue;
3493 }
3494 size_t numsessionrefs = mAudioSessionRefs.size();
3495 bool found = false;
3496 for (size_t k = 0; k < numsessionrefs; k++) {
3497 AudioSessionRef *ref = mAudioSessionRefs.itemAt(k);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08003498 if (ref->mSessionid == sessionid) {
Steve Block3856b092011-10-20 11:56:00 +01003499 ALOGV(" session %d still exists for %d with %d refs",
Glenn Kastene53b9ea2012-03-12 16:29:55 -07003500 sessionid, ref->mPid, ref->mCnt);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003501 found = true;
3502 break;
3503 }
3504 }
3505 if (!found) {
Glenn Kastene198c362013-08-13 09:13:36 -07003506 Mutex::Autolock _l(t->mLock);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003507 // remove all effects from the chain
3508 while (ec->mEffects.size()) {
3509 sp<EffectModule> effect = ec->mEffects[0];
3510 effect->unPin();
Mikhail Naganov424c4f52017-07-19 17:54:29 -07003511 t->removeEffect_l(effect, /*release*/ true);
Eric Laurenta5f44eb2012-06-25 11:38:29 -07003512 if (effect->purgeHandles()) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08003513 effect->checkSuspendOnEffectEnabled(false, true /*threadLocked*/);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003514 }
Eric Laurent6c796322019-04-09 14:13:17 -07003515 removedEffects.push_back(effect);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003516 }
3517 }
3518 }
Eric Laurent6c796322019-04-09 14:13:17 -07003519 return removedEffects;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003520}
3521
Andy Hungdc099c22018-09-18 13:46:39 -07003522// dumpToThreadLog_l() must be called with AudioFlinger::mLock held
3523void AudioFlinger::dumpToThreadLog_l(const sp<ThreadBase> &thread)
3524{
Jaideep Sharma330845f2020-10-22 12:14:58 +05303525 constexpr int THREAD_DUMP_TIMEOUT_MS = 2;
3526 audio_utils::FdToString fdToString("- ", THREAD_DUMP_TIMEOUT_MS);
Andy Hungdc099c22018-09-18 13:46:39 -07003527 const int fd = fdToString.fd();
3528 if (fd >= 0) {
3529 thread->dump(fd, {} /* args */);
3530 mThreadLog.logs(-1 /* time */, fdToString.getStringAndClose());
3531 }
3532}
3533
Glenn Kasteneeecb982016-02-26 10:44:04 -08003534// checkThread_l() must be called with AudioFlinger::mLock held
3535AudioFlinger::ThreadBase *AudioFlinger::checkThread_l(audio_io_handle_t ioHandle) const
3536{
Eric Laurent6acd1d42017-01-04 14:23:29 -08003537 ThreadBase *thread = checkMmapThread_l(ioHandle);
3538 if (thread == 0) {
3539 switch (audio_unique_id_get_use(ioHandle)) {
3540 case AUDIO_UNIQUE_ID_USE_OUTPUT:
3541 thread = checkPlaybackThread_l(ioHandle);
3542 break;
3543 case AUDIO_UNIQUE_ID_USE_INPUT:
3544 thread = checkRecordThread_l(ioHandle);
3545 break;
3546 default:
3547 break;
3548 }
Glenn Kasteneeecb982016-02-26 10:44:04 -08003549 }
3550 return thread;
3551}
3552
Mathias Agopian65ab4712010-07-14 17:59:35 -07003553// checkPlaybackThread_l() must be called with AudioFlinger::mLock held
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003554AudioFlinger::PlaybackThread *AudioFlinger::checkPlaybackThread_l(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003555{
Glenn Kastena1117922012-01-26 10:53:32 -08003556 return mPlaybackThreads.valueFor(output).get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07003557}
3558
3559// checkMixerThread_l() must be called with AudioFlinger::mLock held
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003560AudioFlinger::MixerThread *AudioFlinger::checkMixerThread_l(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003561{
3562 PlaybackThread *thread = checkPlaybackThread_l(output);
Glenn Kastena1117922012-01-26 10:53:32 -08003563 return thread != NULL && thread->type() != ThreadBase::DIRECT ? (MixerThread *) thread : NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003564}
3565
3566// checkRecordThread_l() must be called with AudioFlinger::mLock held
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003567AudioFlinger::RecordThread *AudioFlinger::checkRecordThread_l(audio_io_handle_t input) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003568{
Glenn Kastena1117922012-01-26 10:53:32 -08003569 return mRecordThreads.valueFor(input).get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07003570}
3571
Eric Laurent6acd1d42017-01-04 14:23:29 -08003572// checkMmapThread_l() must be called with AudioFlinger::mLock held
3573AudioFlinger::MmapThread *AudioFlinger::checkMmapThread_l(audio_io_handle_t io) const
3574{
3575 return mMmapThreads.valueFor(io).get();
3576}
3577
3578
3579// checkPlaybackThread_l() must be called with AudioFlinger::mLock held
3580AudioFlinger::VolumeInterface *AudioFlinger::getVolumeInterface_l(audio_io_handle_t output) const
3581{
Eric Laurent7459b902017-04-19 18:10:41 -07003582 VolumeInterface *volumeInterface = mPlaybackThreads.valueFor(output).get();
Eric Laurent6acd1d42017-01-04 14:23:29 -08003583 if (volumeInterface == nullptr) {
3584 MmapThread *mmapThread = mMmapThreads.valueFor(output).get();
3585 if (mmapThread != nullptr) {
3586 if (mmapThread->isOutput()) {
Eric Laurent7459b902017-04-19 18:10:41 -07003587 MmapPlaybackThread *mmapPlaybackThread =
3588 static_cast<MmapPlaybackThread *>(mmapThread);
3589 volumeInterface = mmapPlaybackThread;
Eric Laurent6acd1d42017-01-04 14:23:29 -08003590 }
3591 }
3592 }
3593 return volumeInterface;
3594}
3595
3596Vector <AudioFlinger::VolumeInterface *> AudioFlinger::getAllVolumeInterfaces_l() const
3597{
3598 Vector <VolumeInterface *> volumeInterfaces;
3599 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Eric Laurent7459b902017-04-19 18:10:41 -07003600 volumeInterfaces.add(mPlaybackThreads.valueAt(i).get());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003601 }
3602 for (size_t i = 0; i < mMmapThreads.size(); i++) {
3603 if (mMmapThreads.valueAt(i)->isOutput()) {
Eric Laurent7459b902017-04-19 18:10:41 -07003604 MmapPlaybackThread *mmapPlaybackThread =
3605 static_cast<MmapPlaybackThread *>(mMmapThreads.valueAt(i).get());
3606 volumeInterfaces.add(mmapPlaybackThread);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003607 }
3608 }
3609 return volumeInterfaces;
3610}
3611
Glenn Kasteneeecb982016-02-26 10:44:04 -08003612audio_unique_id_t AudioFlinger::nextUniqueId(audio_unique_id_use_t use)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003613{
Glenn Kasten9d003132016-04-06 14:38:09 -07003614 // This is the internal API, so it is OK to assert on bad parameter.
Glenn Kasteneeecb982016-02-26 10:44:04 -08003615 LOG_ALWAYS_FATAL_IF((unsigned) use >= (unsigned) AUDIO_UNIQUE_ID_USE_MAX);
Glenn Kastend2e67e12016-04-11 08:26:37 -07003616 const int maxRetries = use == AUDIO_UNIQUE_ID_USE_SESSION ? 3 : 1;
3617 for (int retry = 0; retry < maxRetries; retry++) {
3618 // The cast allows wraparound from max positive to min negative instead of abort
3619 uint32_t base = (uint32_t) atomic_fetch_add_explicit(&mNextUniqueIds[use],
3620 (uint_fast32_t) AUDIO_UNIQUE_ID_USE_MAX, memory_order_acq_rel);
3621 ALOG_ASSERT(audio_unique_id_get_use(base) == AUDIO_UNIQUE_ID_USE_UNSPECIFIED);
3622 // allow wrap by skipping 0 and -1 for session ids
3623 if (!(base == 0 || base == (~0u & ~AUDIO_UNIQUE_ID_USE_MASK))) {
3624 ALOGW_IF(retry != 0, "unique ID overflow for use %d", use);
3625 return (audio_unique_id_t) (base | use);
3626 }
3627 }
3628 // We have no way of recovering from wraparound
3629 LOG_ALWAYS_FATAL("unique ID overflow for use %d", use);
3630 // TODO Use a floor after wraparound. This may need a mutex.
Mathias Agopian65ab4712010-07-14 17:59:35 -07003631}
3632
Glenn Kasten02fe1bf2012-02-24 15:42:17 -08003633AudioFlinger::PlaybackThread *AudioFlinger::primaryPlaybackThread_l() const
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003634{
Eric Laurent00abf0d2020-04-22 19:28:22 -07003635 AutoMutex lock(mHardwareLock);
3636 if (mPrimaryHardwareDev == nullptr) {
3637 return nullptr;
3638 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003639 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3640 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
Eric Laurentf6870ae2015-05-08 10:50:03 -07003641 if(thread->isDuplicating()) {
3642 continue;
3643 }
Eric Laurentb8ba0a92011-08-07 16:32:26 -07003644 AudioStreamOut *output = thread->getOutput();
John Grossmanee578c02012-07-23 17:05:46 -07003645 if (output != NULL && output->audioHwDev == mPrimaryHardwareDev) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003646 return thread;
3647 }
3648 }
Eric Laurent00abf0d2020-04-22 19:28:22 -07003649 return nullptr;
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003650}
3651
jiabinc52b1ff2019-10-31 17:20:42 -07003652DeviceTypeSet AudioFlinger::primaryOutputDevice_l() const
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003653{
3654 PlaybackThread *thread = primaryPlaybackThread_l();
3655
3656 if (thread == NULL) {
jiabinc52b1ff2019-10-31 17:20:42 -07003657 return DeviceTypeSet();
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003658 }
3659
jiabinc52b1ff2019-10-31 17:20:42 -07003660 return thread->outDeviceTypes();
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003661}
3662
Glenn Kastena7335632016-06-09 17:09:53 -07003663AudioFlinger::PlaybackThread *AudioFlinger::fastPlaybackThread_l() const
3664{
3665 size_t minFrameCount = 0;
3666 PlaybackThread *minThread = NULL;
3667 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3668 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
3669 if (!thread->isDuplicating()) {
3670 size_t frameCount = thread->frameCountHAL();
3671 if (frameCount != 0 && (minFrameCount == 0 || frameCount < minFrameCount ||
3672 (frameCount == minFrameCount && thread->hasFastMixer() &&
3673 /*minThread != NULL &&*/ !minThread->hasFastMixer()))) {
3674 minFrameCount = frameCount;
3675 minThread = thread;
3676 }
3677 }
3678 }
3679 return minThread;
3680}
3681
jiabineb3bda02020-06-30 14:07:03 -07003682AudioFlinger::ThreadBase *AudioFlinger::hapticPlaybackThread_l() const {
3683 for (size_t i = 0; i < mPlaybackThreads.size(); ++i) {
3684 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
3685 if (thread->hapticChannelMask() != AUDIO_CHANNEL_NONE) {
3686 return thread;
3687 }
3688 }
3689 return nullptr;
3690}
3691
jiabinf042b9b2021-05-07 23:46:28 +00003692void AudioFlinger::updateSecondaryOutputsForTrack_l(
3693 PlaybackThread::Track* track,
3694 PlaybackThread* thread,
3695 const std::vector<audio_io_handle_t> &secondaryOutputs) const {
3696 TeePatches teePatches;
3697 for (audio_io_handle_t secondaryOutput : secondaryOutputs) {
3698 PlaybackThread *secondaryThread = checkPlaybackThread_l(secondaryOutput);
3699 if (secondaryThread == nullptr) {
3700 ALOGE("no playback thread found for secondary output %d", thread->id());
3701 continue;
3702 }
3703
3704 size_t sourceFrameCount = thread->frameCount() * track->sampleRate()
3705 / thread->sampleRate();
3706 size_t sinkFrameCount = secondaryThread->frameCount() * track->sampleRate()
3707 / secondaryThread->sampleRate();
3708 // If the secondary output has just been opened, the first secondaryThread write
3709 // will not block as it will fill the empty startup buffer of the HAL,
3710 // so a second sink buffer needs to be ready for the immediate next blocking write.
3711 // Additionally, have a margin of one main thread buffer as the scheduling jitter
3712 // can reorder the writes (eg if thread A&B have the same write intervale,
3713 // the scheduler could schedule AB...BA)
3714 size_t frameCountToBeReady = 2 * sinkFrameCount + sourceFrameCount;
3715 // Total secondary output buffer must be at least as the read frames plus
3716 // the margin of a few buffers on both sides in case the
3717 // threads scheduling has some jitter.
3718 // That value should not impact latency as the secondary track is started before
3719 // its buffer is full, see frameCountToBeReady.
3720 size_t frameCount = frameCountToBeReady + 2 * (sourceFrameCount + sinkFrameCount);
3721 // The frameCount should also not be smaller than the secondary thread min frame
3722 // count
3723 size_t minFrameCount = AudioSystem::calculateMinFrameCount(
3724 [&] { Mutex::Autolock _l(secondaryThread->mLock);
3725 return secondaryThread->latency_l(); }(),
3726 secondaryThread->mNormalFrameCount,
3727 secondaryThread->mSampleRate,
3728 track->sampleRate(),
3729 track->getSpeed());
3730 frameCount = std::max(frameCount, minFrameCount);
3731
3732 using namespace std::chrono_literals;
3733 auto inChannelMask = audio_channel_mask_out_to_in(track->channelMask());
jiabin73e303c2022-09-15 17:49:50 +00003734 if (inChannelMask == AUDIO_CHANNEL_INVALID) {
3735 // The downstream PatchTrack has the proper output channel mask,
3736 // so if there is no input channel mask equivalent, we can just
3737 // use an index mask here to create the PatchRecord.
3738 inChannelMask = audio_channel_mask_out_to_in_index_mask(track->channelMask());
3739 }
jiabinf042b9b2021-05-07 23:46:28 +00003740 sp patchRecord = new RecordThread::PatchRecord(nullptr /* thread */,
3741 track->sampleRate(),
3742 inChannelMask,
3743 track->format(),
3744 frameCount,
3745 nullptr /* buffer */,
3746 (size_t)0 /* bufferSize */,
3747 AUDIO_INPUT_FLAG_DIRECT,
3748 0ns /* timeout */);
3749 status_t status = patchRecord->initCheck();
3750 if (status != NO_ERROR) {
3751 ALOGE("Secondary output patchRecord init failed: %d", status);
3752 continue;
3753 }
3754
3755 // TODO: We could check compatibility of the secondaryThread with the PatchTrack
3756 // for fast usage: thread has fast mixer, sample rate matches, etc.;
3757 // for now, we exclude fast tracks by removing the Fast flag.
3758 const audio_output_flags_t outputFlags =
3759 (audio_output_flags_t)(track->getOutputFlags() & ~AUDIO_OUTPUT_FLAG_FAST);
3760 sp patchTrack = new PlaybackThread::PatchTrack(secondaryThread,
3761 track->streamType(),
3762 track->sampleRate(),
3763 track->channelMask(),
3764 track->format(),
3765 frameCount,
3766 patchRecord->buffer(),
3767 patchRecord->bufferSize(),
3768 outputFlags,
3769 0ns /* timeout */,
3770 frameCountToBeReady);
3771 status = patchTrack->initCheck();
3772 if (status != NO_ERROR) {
3773 ALOGE("Secondary output patchTrack init failed: %d", status);
3774 continue;
3775 }
3776 teePatches.push_back({patchRecord, patchTrack});
3777 secondaryThread->addPatchTrack(patchTrack);
3778 // In case the downstream patchTrack on the secondaryThread temporarily outlives
3779 // our created track, ensure the corresponding patchRecord is still alive.
3780 patchTrack->setPeerProxy(patchRecord, true /* holdReference */);
3781 patchRecord->setPeerProxy(patchTrack, false /* holdReference */);
3782 }
3783 track->setTeePatches(std::move(teePatches));
3784}
3785
Eric Laurenta011e352012-03-29 15:51:43 -07003786sp<AudioFlinger::SyncEvent> AudioFlinger::createSyncEvent(AudioSystem::sync_event_t type,
Glenn Kastend848eb42016-03-08 13:42:11 -08003787 audio_session_t triggerSession,
3788 audio_session_t listenerSession,
Eric Laurenta011e352012-03-29 15:51:43 -07003789 sync_event_callback_t callBack,
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -07003790 const wp<RefBase>& cookie)
Eric Laurenta011e352012-03-29 15:51:43 -07003791{
3792 Mutex::Autolock _l(mLock);
3793
3794 sp<SyncEvent> event = new SyncEvent(type, triggerSession, listenerSession, callBack, cookie);
3795 status_t playStatus = NAME_NOT_FOUND;
3796 status_t recStatus = NAME_NOT_FOUND;
3797 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3798 playStatus = mPlaybackThreads.valueAt(i)->setSyncEvent(event);
3799 if (playStatus == NO_ERROR) {
3800 return event;
3801 }
3802 }
3803 for (size_t i = 0; i < mRecordThreads.size(); i++) {
3804 recStatus = mRecordThreads.valueAt(i)->setSyncEvent(event);
3805 if (recStatus == NO_ERROR) {
3806 return event;
3807 }
3808 }
3809 if (playStatus == NAME_NOT_FOUND || recStatus == NAME_NOT_FOUND) {
3810 mPendingSyncEvents.add(event);
3811 } else {
3812 ALOGV("createSyncEvent() invalid event %d", event->type());
3813 event.clear();
3814 }
3815 return event;
3816}
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003817
Mathias Agopian65ab4712010-07-14 17:59:35 -07003818// ----------------------------------------------------------------------------
3819// Effect management
3820// ----------------------------------------------------------------------------
3821
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07003822sp<EffectsFactoryHalInterface> AudioFlinger::getEffectsFactory() {
3823 return mEffectsFactoryHal;
3824}
Mathias Agopian65ab4712010-07-14 17:59:35 -07003825
Glenn Kastenf587ba52012-01-26 16:25:10 -08003826status_t AudioFlinger::queryNumberEffects(uint32_t *numEffects) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003827{
3828 Mutex::Autolock _l(mLock);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07003829 if (mEffectsFactoryHal.get()) {
3830 return mEffectsFactoryHal->queryNumberEffects(numEffects);
3831 } else {
3832 return -ENODEV;
3833 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003834}
3835
Glenn Kastenf587ba52012-01-26 16:25:10 -08003836status_t AudioFlinger::queryEffect(uint32_t index, effect_descriptor_t *descriptor) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003837{
3838 Mutex::Autolock _l(mLock);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07003839 if (mEffectsFactoryHal.get()) {
3840 return mEffectsFactoryHal->getDescriptor(index, descriptor);
3841 } else {
3842 return -ENODEV;
3843 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003844}
3845
Glenn Kasten5e92a782012-01-30 07:40:52 -08003846status_t AudioFlinger::getEffectDescriptor(const effect_uuid_t *pUuid,
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07003847 const effect_uuid_t *pTypeUuid,
3848 uint32_t preferredTypeFlag,
3849 effect_descriptor_t *descriptor) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003850{
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07003851 if (pUuid == NULL || pTypeUuid == NULL || descriptor == NULL) {
3852 return BAD_VALUE;
3853 }
3854
Mathias Agopian65ab4712010-07-14 17:59:35 -07003855 Mutex::Autolock _l(mLock);
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07003856
3857 if (!mEffectsFactoryHal.get()) {
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07003858 return -ENODEV;
3859 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003860
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07003861 status_t status = NO_ERROR;
3862 if (!EffectsFactoryHalInterface::isNullUuid(pUuid)) {
3863 // If uuid is specified, request effect descriptor from that.
3864 status = mEffectsFactoryHal->getDescriptor(pUuid, descriptor);
3865 } else if (!EffectsFactoryHalInterface::isNullUuid(pTypeUuid)) {
3866 // If uuid is not specified, look for an available implementation
3867 // of the required type instead.
3868
3869 // Use a temporary descriptor to avoid modifying |descriptor| in the failure case.
3870 effect_descriptor_t desc;
3871 desc.flags = 0; // prevent compiler warning
3872
3873 uint32_t numEffects = 0;
3874 status = mEffectsFactoryHal->queryNumberEffects(&numEffects);
3875 if (status < 0) {
3876 ALOGW("getEffectDescriptor() error %d from FactoryHal queryNumberEffects", status);
3877 return status;
3878 }
3879
3880 bool found = false;
3881 for (uint32_t i = 0; i < numEffects; i++) {
3882 status = mEffectsFactoryHal->getDescriptor(i, &desc);
3883 if (status < 0) {
3884 ALOGW("getEffectDescriptor() error %d from FactoryHal getDescriptor", status);
3885 continue;
3886 }
3887 if (memcmp(&desc.type, pTypeUuid, sizeof(effect_uuid_t)) == 0) {
3888 // If matching type found save effect descriptor.
3889 found = true;
3890 *descriptor = desc;
3891
3892 // If there's no preferred flag or this descriptor matches the preferred
3893 // flag, success! If this descriptor doesn't match the preferred
3894 // flag, continue enumeration in case a better matching version of this
3895 // effect type is available. Note that this means if no effect with a
3896 // correct flag is found, the descriptor returned will correspond to the
3897 // last effect that at least had a matching type uuid (if any).
3898 if (preferredTypeFlag == EFFECT_FLAG_TYPE_MASK ||
3899 (desc.flags & EFFECT_FLAG_TYPE_MASK) == preferredTypeFlag) {
3900 break;
3901 }
3902 }
3903 }
3904
3905 if (!found) {
3906 status = NAME_NOT_FOUND;
3907 ALOGW("getEffectDescriptor(): Effect not found by type.");
3908 }
3909 } else {
3910 status = BAD_VALUE;
3911 ALOGE("getEffectDescriptor(): Either uuid or type uuid must be non-null UUIDs.");
3912 }
3913 return status;
3914}
Mathias Agopian65ab4712010-07-14 17:59:35 -07003915
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08003916status_t AudioFlinger::createEffect(const media::CreateEffectRequest& request,
3917 media::CreateEffectResponse* response) {
3918 const sp<IEffectClient>& effectClient = request.client;
3919 const int32_t priority = request.priority;
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003920 const AudioDeviceTypeAddr device = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08003921 aidl2legacy_AudioDeviceTypeAddress(request.device));
Svet Ganov33761132021-05-13 22:51:08 +00003922 AttributionSourceState adjAttributionSource = request.attributionSource;
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003923 const audio_session_t sessionId = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08003924 aidl2legacy_int32_t_audio_session_t(request.sessionId));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003925 audio_io_handle_t io = VALUE_OR_RETURN_STATUS(
3926 aidl2legacy_int32_t_audio_io_handle_t(request.output));
3927 const effect_descriptor_t descIn = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08003928 aidl2legacy_EffectDescriptor_effect_descriptor_t(request.desc));
3929 const bool probe = request.probe;
3930
Mathias Agopian65ab4712010-07-14 17:59:35 -07003931 sp<EffectHandle> handle;
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08003932 effect_descriptor_t descOut;
3933 int enabledOut = 0;
3934 int idOut = -1;
3935
3936 status_t lStatus = NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003937
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003938 // TODO b/182392553: refactor or make clearer
Eric Laurentb6436272016-12-07 19:24:50 -08003939 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Svet Ganov33761132021-05-13 22:51:08 +00003940 adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
3941 pid_t currentPid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(adjAttributionSource.pid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003942 if (currentPid == -1 || !isAudioServerOrMediaServerUid(callingUid)) {
Eric Laurentb6436272016-12-07 19:24:50 -08003943 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003944 ALOGW_IF(currentPid != -1 && currentPid != callingPid,
Eric Laurentb6436272016-12-07 19:24:50 -08003945 "%s uid %d pid %d tried to pass itself off as pid %d",
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003946 __func__, callingUid, callingPid, currentPid);
Svet Ganov33761132021-05-13 22:51:08 +00003947 adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003948 currentPid = callingPid;
Eric Laurentb6436272016-12-07 19:24:50 -08003949 }
3950
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07003951 ALOGV("createEffect pid %d, effectClient %p, priority %d, sessionId %d, io %d, factory %p",
Svet Ganov33761132021-05-13 22:51:08 +00003952 adjAttributionSource.pid, effectClient.get(), priority, sessionId, io,
3953 mEffectsFactoryHal.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003954
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003955 if (mEffectsFactoryHal == 0) {
Andy Hung6096dcd2019-03-13 13:20:30 -07003956 ALOGE("%s: no effects factory hal", __func__);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07003957 lStatus = NO_INIT;
3958 goto Exit;
3959 }
3960
Andy Hung6096dcd2019-03-13 13:20:30 -07003961 // check audio settings permission for global effects
3962 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
3963 if (!settingsAllowed()) {
3964 ALOGE("%s: no permission for AUDIO_SESSION_OUTPUT_MIX", __func__);
3965 lStatus = PERMISSION_DENIED;
3966 goto Exit;
3967 }
3968 } else if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
Andy Hung6096dcd2019-03-13 13:20:30 -07003969 if (io == AUDIO_IO_HANDLE_NONE) {
3970 ALOGE("%s: APM must specify output when using AUDIO_SESSION_OUTPUT_STAGE", __func__);
3971 lStatus = BAD_VALUE;
3972 goto Exit;
3973 }
Eric Laurenta74058e2022-05-26 15:08:00 +00003974 PlaybackThread *thread = checkPlaybackThread_l(io);
3975 if (thread == nullptr) {
3976 ALOGE("%s: invalid output %d specified for AUDIO_SESSION_OUTPUT_STAGE", __func__, io);
3977 lStatus = BAD_VALUE;
3978 goto Exit;
3979 }
3980 if (!modifyDefaultAudioEffectsAllowed(adjAttributionSource)
3981 && !isAudioServerUid(callingUid)) {
3982 ALOGE("%s: effect on AUDIO_SESSION_OUTPUT_STAGE not granted for uid %d",
3983 __func__, callingUid);
3984 lStatus = PERMISSION_DENIED;
3985 goto Exit;
3986 }
Eric Laurent3f75a5b2019-11-12 15:55:51 -08003987 } else if (sessionId == AUDIO_SESSION_DEVICE) {
Svet Ganov33761132021-05-13 22:51:08 +00003988 if (!modifyDefaultAudioEffectsAllowed(adjAttributionSource)) {
Eric Laurent3f75a5b2019-11-12 15:55:51 -08003989 ALOGE("%s: device effect permission denied for uid %d", __func__, callingUid);
3990 lStatus = PERMISSION_DENIED;
3991 goto Exit;
3992 }
Eric Laurent94876032019-11-13 12:45:28 -08003993 if (io != AUDIO_IO_HANDLE_NONE) {
3994 ALOGE("%s: io handle should not be specified for device effect", __func__);
3995 lStatus = BAD_VALUE;
3996 goto Exit;
3997 }
Andy Hung6096dcd2019-03-13 13:20:30 -07003998 } else {
3999 // general sessionId.
4000
4001 if (audio_unique_id_get_use(sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) {
4002 ALOGE("%s: invalid sessionId %d", __func__, sessionId);
4003 lStatus = BAD_VALUE;
4004 goto Exit;
4005 }
4006
4007 // TODO: should we check if the callingUid (limited to pid) is in mAudioSessionRefs
4008 // to prevent creating an effect when one doesn't actually have track with that session?
4009 }
4010
Mathias Agopian65ab4712010-07-14 17:59:35 -07004011 {
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07004012 // Get the full effect descriptor from the uuid/type.
4013 // If the session is the output mix, prefer an auxiliary effect,
4014 // otherwise no preference.
4015 uint32_t preferredType = (sessionId == AUDIO_SESSION_OUTPUT_MIX ?
4016 EFFECT_FLAG_TYPE_AUXILIARY : EFFECT_FLAG_TYPE_MASK);
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004017 lStatus = getEffectDescriptor(&descIn.uuid, &descIn.type, preferredType, &descOut);
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07004018 if (lStatus < 0) {
4019 ALOGW("createEffect() error %d from getEffectDescriptor", lStatus);
4020 goto Exit;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004021 }
4022
4023 // Do not allow auxiliary effects on a session different from 0 (output mix)
Dima Zavinfce7a472011-04-19 22:30:36 -07004024 if (sessionId != AUDIO_SESSION_OUTPUT_MIX &&
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004025 (descOut.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07004026 lStatus = INVALID_OPERATION;
4027 goto Exit;
4028 }
4029
Eric Laurent59255e42011-07-27 19:49:51 -07004030 // check recording permission for visualizer
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004031 if ((memcmp(&descOut.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) &&
Svet Ganov6e641372018-03-02 09:21:30 -08004032 // TODO: Do we need to start/stop op - i.e. is there recording being performed?
Svet Ganov33761132021-05-13 22:51:08 +00004033 !recordingAllowed(adjAttributionSource)) {
Eric Laurent59255e42011-07-27 19:49:51 -07004034 lStatus = PERMISSION_DENIED;
4035 goto Exit;
4036 }
4037
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004038 const bool hapticPlaybackRequired = EffectModule::isHapticGenerator(&descOut.type);
jiabineb3bda02020-06-30 14:07:03 -07004039 if (hapticPlaybackRequired
4040 && (sessionId == AUDIO_SESSION_DEVICE
4041 || sessionId == AUDIO_SESSION_OUTPUT_MIX
4042 || sessionId == AUDIO_SESSION_OUTPUT_STAGE)) {
4043 // haptic-generating effect is only valid when the session id is a general session id
4044 lStatus = INVALID_OPERATION;
4045 goto Exit;
4046 }
4047
Eric Laurentf690c462021-09-17 14:47:03 +02004048 // Only audio policy service can create a spatializer effect
4049 if ((memcmp(&descOut.type, FX_IID_SPATIALIZER, sizeof(effect_uuid_t)) == 0) &&
4050 (callingUid != AID_AUDIOSERVER || currentPid != getpid())) {
4051 ALOGW("%s: attempt to create a spatializer effect from uid/pid %d/%d",
4052 __func__, callingUid, currentPid);
4053 lStatus = PERMISSION_DENIED;
4054 goto Exit;
4055 }
4056
Glenn Kasten142f5192014-03-25 17:44:59 -07004057 if (io == AUDIO_IO_HANDLE_NONE && sessionId == AUDIO_SESSION_OUTPUT_MIX) {
Eric Laurenteb3c3372013-09-25 12:25:29 -07004058 // if the output returned by getOutputForEffect() is removed before we lock the
4059 // mutex below, the call to checkPlaybackThread_l(io) below will detect it
4060 // and we will exit safely
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004061 io = AudioSystem::getOutputForEffect(&descOut);
Eric Laurenteb3c3372013-09-25 12:25:29 -07004062 ALOGV("createEffect got output %d", io);
4063 }
4064
4065 Mutex::Autolock _l(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004066
Eric Laurentb82e6b72019-11-22 17:25:04 -08004067 if (sessionId == AUDIO_SESSION_DEVICE) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07004068 sp<Client> client = registerPid(currentPid);
Eric Laurent2fe0acd2020-03-13 14:30:46 -07004069 ALOGV("%s device type %#x address %s", __func__, device.mType, device.getAddress());
Eric Laurentb82e6b72019-11-22 17:25:04 -08004070 handle = mDeviceEffectManager.createEffect_l(
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004071 &descOut, device, client, effectClient, mPatchPanel.patches_l(),
Eric Laurentde8caf42021-08-11 17:19:25 +02004072 &enabledOut, &lStatus, probe, request.notifyFramesProcessed);
Eric Laurentb82e6b72019-11-22 17:25:04 -08004073 if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
4074 // remove local strong reference to Client with mClientLock held
4075 Mutex::Autolock _cl(mClientLock);
4076 client.clear();
4077 } else {
4078 // handle must be valid here, but check again to be safe.
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004079 if (handle.get() != nullptr) idOut = handle->id();
Eric Laurentb82e6b72019-11-22 17:25:04 -08004080 }
4081 goto Register;
4082 }
4083
Mathias Agopian65ab4712010-07-14 17:59:35 -07004084 // If output is not specified try to find a matching audio session ID in one of the
4085 // output threads.
Eric Laurent84e9a102010-09-23 16:10:16 -07004086 // If output is 0 here, sessionId is neither SESSION_OUTPUT_STAGE nor SESSION_OUTPUT_MIX
4087 // because of code checking output when entering the function.
Andy Hung444bb552019-03-14 17:06:39 -07004088 // Note: io is never AUDIO_IO_HANDLE_NONE when creating an effect on an input by APM.
4089 // An AudioEffect created from the Java API will have io as AUDIO_IO_HANDLE_NONE.
Glenn Kasten142f5192014-03-25 17:44:59 -07004090 if (io == AUDIO_IO_HANDLE_NONE) {
Eric Laurenteb3c3372013-09-25 12:25:29 -07004091 // look for the thread where the specified audio session is present
Andy Hunge778c422019-03-14 15:04:30 -07004092 io = findIoHandleBySessionId_l(sessionId, mPlaybackThreads);
4093 if (io == AUDIO_IO_HANDLE_NONE) {
4094 io = findIoHandleBySessionId_l(sessionId, mRecordThreads);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004095 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08004096 if (io == AUDIO_IO_HANDLE_NONE) {
Andy Hunge778c422019-03-14 15:04:30 -07004097 io = findIoHandleBySessionId_l(sessionId, mMmapThreads);
Eric Laurent6acd1d42017-01-04 14:23:29 -08004098 }
Andy Hung444bb552019-03-14 17:06:39 -07004099
4100 // If you wish to create a Record preprocessing AudioEffect in Java,
4101 // you MUST create an AudioRecord first and keep it alive so it is picked up above.
4102 // Otherwise it will fail when created on a Playback thread by legacy
4103 // handling below. Ditto with Mmap, the associated Mmap track must be created
4104 // before creating the AudioEffect or the io handle must be specified.
4105 //
4106 // Detect if the effect is created after an AudioRecord is destroyed.
4107 if (getOrphanEffectChain_l(sessionId).get() != nullptr) {
4108 ALOGE("%s: effect %s with no specified io handle is denied because the AudioRecord"
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004109 " for session %d no longer exists",
4110 __func__, descOut.name, sessionId);
Andy Hung444bb552019-03-14 17:06:39 -07004111 lStatus = PERMISSION_DENIED;
4112 goto Exit;
4113 }
4114
4115 // Legacy handling of creating an effect on an expired or made-up
4116 // session id. We think that it is a Playback effect.
4117 //
Eric Laurent84e9a102010-09-23 16:10:16 -07004118 // If no output thread contains the requested session ID, default to
4119 // first output. The effect chain will be moved to the correct output
4120 // thread when a track with the same session ID is created
Glenn Kasten142f5192014-03-25 17:44:59 -07004121 if (io == AUDIO_IO_HANDLE_NONE && mPlaybackThreads.size() > 0) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07004122 io = mPlaybackThreads.keyAt(0);
4123 }
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004124 ALOGV("createEffect() got io %d for effect %s", io, descOut.name);
Eric Laurentb3f315a2021-07-13 15:09:05 +02004125 } else if (checkPlaybackThread_l(io) != nullptr
4126 && sessionId != AUDIO_SESSION_OUTPUT_STAGE) {
Andy Hung1631f062019-03-12 19:39:03 -07004127 // allow only one effect chain per sessionId on mPlaybackThreads.
4128 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
4129 const audio_io_handle_t checkIo = mPlaybackThreads.keyAt(i);
jiabineb3bda02020-06-30 14:07:03 -07004130 if (io == checkIo) {
4131 if (hapticPlaybackRequired
4132 && mPlaybackThreads.valueAt(i)
4133 ->hapticChannelMask() == AUDIO_CHANNEL_NONE) {
4134 ALOGE("%s: haptic playback thread is required while the required playback "
4135 "thread(io=%d) doesn't support", __func__, (int)io);
4136 lStatus = BAD_VALUE;
4137 goto Exit;
4138 }
4139 continue;
4140 }
Andy Hung1631f062019-03-12 19:39:03 -07004141 const uint32_t sessionType =
4142 mPlaybackThreads.valueAt(i)->hasAudioSession(sessionId);
4143 if ((sessionType & ThreadBase::EFFECT_SESSION) != 0) {
4144 ALOGE("%s: effect %s io %d denied because session %d effect exists on io %d",
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004145 __func__, descOut.name, (int) io, (int) sessionId, (int) checkIo);
Andy Hung1631f062019-03-12 19:39:03 -07004146 android_errorWriteLog(0x534e4554, "123237974");
4147 lStatus = BAD_VALUE;
4148 goto Exit;
4149 }
4150 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07004151 }
4152 ThreadBase *thread = checkRecordThread_l(io);
4153 if (thread == NULL) {
4154 thread = checkPlaybackThread_l(io);
4155 if (thread == NULL) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08004156 thread = checkMmapThread_l(io);
4157 if (thread == NULL) {
4158 ALOGE("createEffect() unknown output thread");
4159 lStatus = BAD_VALUE;
4160 goto Exit;
4161 }
Eric Laurent84e9a102010-09-23 16:10:16 -07004162 }
Eric Laurentaaa44472014-09-12 17:41:50 -07004163 } else {
4164 // Check if one effect chain was awaiting for an effect to be created on this
4165 // session and used it instead of creating a new one.
Glenn Kastend848eb42016-03-08 13:42:11 -08004166 sp<EffectChain> chain = getOrphanEffectChain_l(sessionId);
Eric Laurentaaa44472014-09-12 17:41:50 -07004167 if (chain != 0) {
Eric Laurent1b928682014-10-02 19:41:47 -07004168 Mutex::Autolock _l(thread->mLock);
Eric Laurentaaa44472014-09-12 17:41:50 -07004169 thread->addEffectChain_l(chain);
4170 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004171 }
Eric Laurent84e9a102010-09-23 16:10:16 -07004172
Philip P. Moltmannbda45752020-07-17 16:41:18 -07004173 sp<Client> client = registerPid(currentPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004174
Marco Nelissen3a34bef2011-08-02 13:33:41 -07004175 // create effect on selected output thread
Eric Laurent3f75a5b2019-11-12 15:55:51 -08004176 bool pinned = !audio_is_global_session(sessionId) && isSessionAcquired_l(sessionId);
jiabineb3bda02020-06-30 14:07:03 -07004177 ThreadBase *oriThread = nullptr;
4178 if (hapticPlaybackRequired && thread->hapticChannelMask() == AUDIO_CHANNEL_NONE) {
4179 ThreadBase *hapticThread = hapticPlaybackThread_l();
4180 if (hapticThread == nullptr) {
4181 ALOGE("%s haptic thread not found while it is required", __func__);
4182 lStatus = INVALID_OPERATION;
4183 goto Exit;
4184 }
4185 if (hapticThread != thread) {
4186 // Force to use haptic thread for haptic-generating effect.
4187 oriThread = thread;
4188 thread = hapticThread;
4189 }
4190 }
Eric Laurentde070132010-07-13 04:45:46 -07004191 handle = thread->createEffect_l(client, effectClient, priority, sessionId,
Eric Laurentde8caf42021-08-11 17:19:25 +02004192 &descOut, &enabledOut, &lStatus, pinned, probe,
4193 request.notifyFramesProcessed);
haobo101735295ff7b0d2017-03-17 17:44:03 +08004194 if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
Eric Laurentfe1a94e2014-05-26 16:03:08 -07004195 // remove local strong reference to Client with mClientLock held
4196 Mutex::Autolock _cl(mClientLock);
4197 client.clear();
haobo101735295ff7b0d2017-03-17 17:44:03 +08004198 } else {
4199 // handle must be valid here, but check again to be safe.
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004200 if (handle.get() != nullptr) idOut = handle->id();
jiabineb3bda02020-06-30 14:07:03 -07004201 // Invalidate audio session when haptic playback is created.
4202 if (hapticPlaybackRequired && oriThread != nullptr) {
4203 // invalidateTracksForAudioSession will trigger locking the thread.
4204 oriThread->invalidateTracksForAudioSession(sessionId);
4205 }
Eric Laurentfe1a94e2014-05-26 16:03:08 -07004206 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004207 }
4208
Eric Laurentb82e6b72019-11-22 17:25:04 -08004209Register:
Eric Laurent2fe0acd2020-03-13 14:30:46 -07004210 if (!probe && (lStatus == NO_ERROR || lStatus == ALREADY_EXISTS)) {
Eric Laurent4f1d4e92022-02-01 14:37:16 +01004211 if (lStatus == ALREADY_EXISTS) {
4212 response->alreadyExists = true;
4213 lStatus = NO_ERROR;
4214 } else {
4215 response->alreadyExists = false;
4216 }
Eric Laurent6c796322019-04-09 14:13:17 -07004217 // Check CPU and memory usage
Eric Laurent41709552019-12-16 19:34:05 -08004218 sp<EffectBase> effect = handle->effect().promote();
Eric Laurent6c796322019-04-09 14:13:17 -07004219 if (effect != nullptr) {
4220 status_t rStatus = effect->updatePolicyState();
4221 if (rStatus != NO_ERROR) {
4222 lStatus = rStatus;
4223 }
4224 }
4225 } else {
haobo101735295ff7b0d2017-03-17 17:44:03 +08004226 handle.clear();
4227 }
4228
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004229 response->id = idOut;
4230 response->enabled = enabledOut != 0;
4231 response->effect = handle;
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08004232 response->desc = VALUE_OR_RETURN_STATUS(
4233 legacy2aidl_effect_descriptor_t_EffectDescriptor(descOut));
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004234
Mathias Agopian65ab4712010-07-14 17:59:35 -07004235Exit:
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004236 return lStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004237}
4238
Glenn Kastend848eb42016-03-08 13:42:11 -08004239status_t AudioFlinger::moveEffects(audio_session_t sessionId, audio_io_handle_t srcOutput,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08004240 audio_io_handle_t dstOutput)
Eric Laurentde070132010-07-13 04:45:46 -07004241{
Steve Block3856b092011-10-20 11:56:00 +01004242 ALOGV("moveEffects() session %d, srcOutput %d, dstOutput %d",
Eric Laurent59255e42011-07-27 19:49:51 -07004243 sessionId, srcOutput, dstOutput);
Eric Laurentde070132010-07-13 04:45:46 -07004244 Mutex::Autolock _l(mLock);
4245 if (srcOutput == dstOutput) {
Steve Block5ff1dd52012-01-05 23:22:43 +00004246 ALOGW("moveEffects() same dst and src outputs %d", dstOutput);
Eric Laurentde070132010-07-13 04:45:46 -07004247 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004248 }
Eric Laurentde070132010-07-13 04:45:46 -07004249 PlaybackThread *srcThread = checkPlaybackThread_l(srcOutput);
4250 if (srcThread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +00004251 ALOGW("moveEffects() bad srcOutput %d", srcOutput);
Eric Laurentde070132010-07-13 04:45:46 -07004252 return BAD_VALUE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004253 }
Eric Laurentde070132010-07-13 04:45:46 -07004254 PlaybackThread *dstThread = checkPlaybackThread_l(dstOutput);
4255 if (dstThread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +00004256 ALOGW("moveEffects() bad dstOutput %d", dstOutput);
Eric Laurentde070132010-07-13 04:45:46 -07004257 return BAD_VALUE;
4258 }
4259
4260 Mutex::Autolock _dl(dstThread->mLock);
4261 Mutex::Autolock _sl(srcThread->mLock);
Eric Laurent6c796322019-04-09 14:13:17 -07004262 return moveEffectChain_l(sessionId, srcThread, dstThread);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004263}
4264
Eric Laurentb20cf7d2019-04-05 19:37:34 -07004265
4266void AudioFlinger::setEffectSuspended(int effectId,
4267 audio_session_t sessionId,
4268 bool suspended)
4269{
4270 Mutex::Autolock _l(mLock);
4271
4272 sp<ThreadBase> thread = getEffectThread_l(sessionId, effectId);
4273 if (thread == nullptr) {
4274 return;
4275 }
4276 Mutex::Autolock _sl(thread->mLock);
4277 sp<EffectModule> effect = thread->getEffect_l(sessionId, effectId);
4278 thread->setEffectSuspended_l(&effect->desc().type, suspended, sessionId);
4279}
4280
4281
Marco Nelissen3a34bef2011-08-02 13:33:41 -07004282// moveEffectChain_l must be called with both srcThread and dstThread mLocks held
Glenn Kastend848eb42016-03-08 13:42:11 -08004283status_t AudioFlinger::moveEffectChain_l(audio_session_t sessionId,
Eric Laurentde070132010-07-13 04:45:46 -07004284 AudioFlinger::PlaybackThread *srcThread,
Eric Laurent6c796322019-04-09 14:13:17 -07004285 AudioFlinger::PlaybackThread *dstThread)
Eric Laurentde070132010-07-13 04:45:46 -07004286{
Steve Block3856b092011-10-20 11:56:00 +01004287 ALOGV("moveEffectChain_l() session %d from thread %p to thread %p",
Eric Laurent59255e42011-07-27 19:49:51 -07004288 sessionId, srcThread, dstThread);
Eric Laurentde070132010-07-13 04:45:46 -07004289
Eric Laurent59255e42011-07-27 19:49:51 -07004290 sp<EffectChain> chain = srcThread->getEffectChain_l(sessionId);
Eric Laurentde070132010-07-13 04:45:46 -07004291 if (chain == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00004292 ALOGW("moveEffectChain_l() effect chain for session %d not on source thread %p",
Eric Laurent59255e42011-07-27 19:49:51 -07004293 sessionId, srcThread);
Eric Laurentde070132010-07-13 04:45:46 -07004294 return INVALID_OPERATION;
4295 }
4296
Eric Laurent4c415062016-06-17 16:14:16 -07004297 // Check whether the destination thread and all effects in the chain are compatible
4298 if (!chain->isCompatibleWithThread_l(dstThread)) {
Andy Hung9a592762014-07-21 21:56:01 -07004299 ALOGW("moveEffectChain_l() effect chain failed because"
Eric Laurent4c415062016-06-17 16:14:16 -07004300 " destination thread %p is not compatible with effects in the chain",
4301 dstThread);
Andy Hung9a592762014-07-21 21:56:01 -07004302 return INVALID_OPERATION;
4303 }
4304
Eric Laurent39e94f82010-07-28 01:32:47 -07004305 // remove chain first. This is useful only if reconfiguring effect chain on same output thread,
Eric Laurentde070132010-07-13 04:45:46 -07004306 // so that a new chain is created with correct parameters when first effect is added. This is
Eric Laurentec35a142011-10-05 17:42:25 -07004307 // otherwise unnecessary as removeEffect_l() will remove the chain when last effect is
Eric Laurentde070132010-07-13 04:45:46 -07004308 // removed.
Andy Hung180f49a2022-01-27 10:25:02 -08004309 // TODO(b/216875016): consider holding the effect chain locks for the duration of the move.
Eric Laurentde070132010-07-13 04:45:46 -07004310 srcThread->removeEffectChain_l(chain);
4311
4312 // transfer all effects one by one so that new effect chain is created on new thread with
4313 // correct buffer sizes and audio parameters and effect engines reconfigured accordingly
Eric Laurent39e94f82010-07-28 01:32:47 -07004314 sp<EffectChain> dstChain;
Eric Laurentde070132010-07-13 04:45:46 -07004315 sp<EffectModule> effect = chain->getEffectFromId_l(0);
Eric Laurent5baf2af2013-09-12 17:37:00 -07004316 Vector< sp<EffectModule> > removed;
4317 status_t status = NO_ERROR;
Andy Hung03410c02022-01-27 08:24:31 -08004318 std::string errorString;
Andy Hung180f49a2022-01-27 10:25:02 -08004319 while (effect != nullptr) {
Eric Laurentde070132010-07-13 04:45:46 -07004320 srcThread->removeEffect_l(effect);
Eric Laurent5baf2af2013-09-12 17:37:00 -07004321 removed.add(effect);
4322 status = dstThread->addEffect_l(effect);
4323 if (status != NO_ERROR) {
Andy Hung03410c02022-01-27 08:24:31 -08004324 errorString = StringPrintf(
4325 "cannot add effect %p to destination thread", effect.get());
Eric Laurent5baf2af2013-09-12 17:37:00 -07004326 break;
4327 }
Eric Laurent39e94f82010-07-28 01:32:47 -07004328 // if the move request is not received from audio policy manager, the effect must be
Andy Hung180f49a2022-01-27 10:25:02 -08004329 // re-registered with the new strategy and output.
4330
4331 // We obtain the dstChain once the effect is on the new thread.
4332 if (dstChain == nullptr) {
Andy Hungfda44002021-06-03 17:23:16 -07004333 dstChain = effect->getCallback()->chain().promote();
Andy Hung180f49a2022-01-27 10:25:02 -08004334 if (dstChain == nullptr) {
Andy Hung03410c02022-01-27 08:24:31 -08004335 errorString = StringPrintf("cannot get chain from effect %p", effect.get());
Eric Laurent5baf2af2013-09-12 17:37:00 -07004336 status = NO_INIT;
4337 break;
Eric Laurent39e94f82010-07-28 01:32:47 -07004338 }
Eric Laurent39e94f82010-07-28 01:32:47 -07004339 }
Eric Laurentde070132010-07-13 04:45:46 -07004340 effect = chain->getEffectFromId_l(0);
4341 }
4342
Andy Hung03410c02022-01-27 08:24:31 -08004343 size_t restored = 0;
Eric Laurent5baf2af2013-09-12 17:37:00 -07004344 if (status != NO_ERROR) {
Andy Hung180f49a2022-01-27 10:25:02 -08004345 dstChain.clear(); // dstChain is now from the srcThread (could be recreated).
Andy Hung03410c02022-01-27 08:24:31 -08004346 for (const auto& effect : removed) {
Andy Hung5c4dd0d2022-01-27 10:21:59 -08004347 dstThread->removeEffect_l(effect); // Note: Depending on error location, the last
4348 // effect may not have been placed on dstThread.
Andy Hung03410c02022-01-27 08:24:31 -08004349 if (srcThread->addEffect_l(effect) == NO_ERROR) {
4350 ++restored;
Andy Hung180f49a2022-01-27 10:25:02 -08004351 if (dstChain == nullptr) {
4352 dstChain = effect->getCallback()->chain().promote();
4353 }
Andy Hung03410c02022-01-27 08:24:31 -08004354 }
Eric Laurent5baf2af2013-09-12 17:37:00 -07004355 }
4356 }
4357
Andy Hung180f49a2022-01-27 10:25:02 -08004358 // After all the effects have been moved to new thread (or put back) we restart the effects
4359 // because removeEffect_l() has stopped the effect if it is currently active.
4360 size_t started = 0;
4361 if (dstChain != nullptr && !removed.empty()) {
4362 // If we do not take the dstChain lock, it is possible that processing is ongoing
4363 // while we are starting the effect. This can cause glitches with volume,
4364 // see b/202360137.
4365 dstChain->lock();
4366 for (const auto& effect : removed) {
4367 if (effect->state() == EffectModule::ACTIVE ||
4368 effect->state() == EffectModule::STOPPING) {
4369 ++started;
4370 effect->start();
4371 }
4372 }
4373 dstChain->unlock();
4374 }
4375
Andy Hung03410c02022-01-27 08:24:31 -08004376 if (status != NO_ERROR) {
4377 if (errorString.empty()) {
4378 errorString = StringPrintf("%s: failed status %d", __func__, status);
4379 }
4380 ALOGW("%s: %s unsuccessful move of session %d from srcThread %p to dstThread %p "
Andy Hung180f49a2022-01-27 10:25:02 -08004381 "(%zu effects removed from srcThread, %zu effects restored to srcThread, "
4382 "%zu effects started)",
Andy Hung03410c02022-01-27 08:24:31 -08004383 __func__, errorString.c_str(), sessionId, srcThread, dstThread,
Andy Hung180f49a2022-01-27 10:25:02 -08004384 removed.size(), restored, started);
Andy Hung03410c02022-01-27 08:24:31 -08004385 } else {
4386 ALOGD("%s: successful move of session %d from srcThread %p to dstThread %p "
Andy Hung180f49a2022-01-27 10:25:02 -08004387 "(%zu effects moved, %zu effects started)",
4388 __func__, sessionId, srcThread, dstThread, removed.size(), started);
Andy Hung03410c02022-01-27 08:24:31 -08004389 }
Eric Laurent5baf2af2013-09-12 17:37:00 -07004390 return status;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004391}
4392
Eric Laurent6c796322019-04-09 14:13:17 -07004393status_t AudioFlinger::moveAuxEffectToIo(int EffectId,
4394 const sp<PlaybackThread>& dstThread,
4395 sp<PlaybackThread> *srcThread)
4396{
4397 status_t status = NO_ERROR;
4398 Mutex::Autolock _l(mLock);
Eric Laurentb20cf7d2019-04-05 19:37:34 -07004399 sp<PlaybackThread> thread =
4400 static_cast<PlaybackThread *>(getEffectThread_l(AUDIO_SESSION_OUTPUT_MIX, EffectId).get());
Eric Laurent6c796322019-04-09 14:13:17 -07004401
4402 if (EffectId != 0 && thread != 0 && dstThread != thread.get()) {
4403 Mutex::Autolock _dl(dstThread->mLock);
4404 Mutex::Autolock _sl(thread->mLock);
4405 sp<EffectChain> srcChain = thread->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
4406 sp<EffectChain> dstChain;
4407 if (srcChain == 0) {
4408 return INVALID_OPERATION;
4409 }
4410
4411 sp<EffectModule> effect = srcChain->getEffectFromId_l(EffectId);
4412 if (effect == 0) {
4413 return INVALID_OPERATION;
4414 }
4415 thread->removeEffect_l(effect);
4416 status = dstThread->addEffect_l(effect);
4417 if (status != NO_ERROR) {
4418 thread->addEffect_l(effect);
4419 status = INVALID_OPERATION;
4420 goto Exit;
4421 }
4422
Andy Hungfda44002021-06-03 17:23:16 -07004423 dstChain = effect->getCallback()->chain().promote();
Eric Laurent6c796322019-04-09 14:13:17 -07004424 if (dstChain == 0) {
4425 thread->addEffect_l(effect);
4426 status = INVALID_OPERATION;
4427 }
4428
4429Exit:
4430 // removeEffect_l() has stopped the effect if it was active so it must be restarted
4431 if (effect->state() == EffectModule::ACTIVE ||
4432 effect->state() == EffectModule::STOPPING) {
4433 effect->start();
4434 }
4435 }
4436
4437 if (status == NO_ERROR && srcThread != nullptr) {
4438 *srcThread = thread;
4439 }
4440 return status;
4441}
4442
Eric Laurent5baf2af2013-09-12 17:37:00 -07004443bool AudioFlinger::isNonOffloadableGlobalEffectEnabled_l()
Eric Laurent813e2a72013-08-31 12:59:48 -07004444{
4445 if (mGlobalEffectEnableTime != 0 &&
4446 ((systemTime() - mGlobalEffectEnableTime) < kMinGlobalEffectEnabletimeNs)) {
4447 return true;
4448 }
4449
4450 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
4451 sp<EffectChain> ec =
4452 mPlaybackThreads.valueAt(i)->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
Eric Laurent5baf2af2013-09-12 17:37:00 -07004453 if (ec != 0 && ec->isNonOffloadableEnabled()) {
Eric Laurent813e2a72013-08-31 12:59:48 -07004454 return true;
4455 }
4456 }
4457 return false;
4458}
4459
Eric Laurent5baf2af2013-09-12 17:37:00 -07004460void AudioFlinger::onNonOffloadableGlobalEffectEnable()
Eric Laurent813e2a72013-08-31 12:59:48 -07004461{
4462 Mutex::Autolock _l(mLock);
4463
4464 mGlobalEffectEnableTime = systemTime();
4465
4466 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
4467 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
4468 if (t->mType == ThreadBase::OFFLOAD) {
4469 t->invalidateTracks(AUDIO_STREAM_MUSIC);
4470 }
4471 }
4472
4473}
4474
Eric Laurentaaa44472014-09-12 17:41:50 -07004475status_t AudioFlinger::putOrphanEffectChain_l(const sp<AudioFlinger::EffectChain>& chain)
4476{
Eric Laurentd8365c52017-07-16 15:27:05 -07004477 // clear possible suspended state before parking the chain so that it starts in default state
4478 // when attached to a new record thread
4479 chain->setEffectSuspended_l(FX_IID_AEC, false);
4480 chain->setEffectSuspended_l(FX_IID_NS, false);
4481
Glenn Kastend848eb42016-03-08 13:42:11 -08004482 audio_session_t session = chain->sessionId();
Eric Laurentaaa44472014-09-12 17:41:50 -07004483 ssize_t index = mOrphanEffectChains.indexOfKey(session);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07004484 ALOGV("putOrphanEffectChain_l session %d index %zd", session, index);
Eric Laurentaaa44472014-09-12 17:41:50 -07004485 if (index >= 0) {
4486 ALOGW("putOrphanEffectChain_l chain for session %d already present", session);
4487 return ALREADY_EXISTS;
4488 }
4489 mOrphanEffectChains.add(session, chain);
4490 return NO_ERROR;
4491}
4492
4493sp<AudioFlinger::EffectChain> AudioFlinger::getOrphanEffectChain_l(audio_session_t session)
4494{
4495 sp<EffectChain> chain;
4496 ssize_t index = mOrphanEffectChains.indexOfKey(session);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07004497 ALOGV("getOrphanEffectChain_l session %d index %zd", session, index);
Eric Laurentaaa44472014-09-12 17:41:50 -07004498 if (index >= 0) {
4499 chain = mOrphanEffectChains.valueAt(index);
4500 mOrphanEffectChains.removeItemsAt(index);
4501 }
4502 return chain;
4503}
4504
4505bool AudioFlinger::updateOrphanEffectChains(const sp<AudioFlinger::EffectModule>& effect)
4506{
4507 Mutex::Autolock _l(mLock);
Glenn Kastend848eb42016-03-08 13:42:11 -08004508 audio_session_t session = effect->sessionId();
Eric Laurentaaa44472014-09-12 17:41:50 -07004509 ssize_t index = mOrphanEffectChains.indexOfKey(session);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07004510 ALOGV("updateOrphanEffectChains session %d index %zd", session, index);
Eric Laurentaaa44472014-09-12 17:41:50 -07004511 if (index >= 0) {
4512 sp<EffectChain> chain = mOrphanEffectChains.valueAt(index);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08004513 if (chain->removeEffect_l(effect, true) == 0) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07004514 ALOGV("updateOrphanEffectChains removing effect chain at index %zd", index);
Eric Laurentaaa44472014-09-12 17:41:50 -07004515 mOrphanEffectChains.removeItemsAt(index);
4516 }
4517 return true;
4518 }
4519 return false;
4520}
4521
4522
Mathias Agopian65ab4712010-07-14 17:59:35 -07004523// ----------------------------------------------------------------------------
4524
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -07004525status_t AudioFlinger::onTransactWrapper(TransactionCode code,
4526 const Parcel& data,
4527 uint32_t flags,
4528 const std::function<status_t()>& delegate) {
4529 (void) data;
4530 (void) flags;
4531
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004532 // make sure transactions reserved to AudioPolicyManager do not come from other processes
4533 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004534 case TransactionCode::SET_STREAM_VOLUME:
4535 case TransactionCode::SET_STREAM_MUTE:
4536 case TransactionCode::OPEN_OUTPUT:
4537 case TransactionCode::OPEN_DUPLICATE_OUTPUT:
4538 case TransactionCode::CLOSE_OUTPUT:
4539 case TransactionCode::SUSPEND_OUTPUT:
4540 case TransactionCode::RESTORE_OUTPUT:
4541 case TransactionCode::OPEN_INPUT:
4542 case TransactionCode::CLOSE_INPUT:
4543 case TransactionCode::INVALIDATE_STREAM:
4544 case TransactionCode::SET_VOICE_VOLUME:
4545 case TransactionCode::MOVE_EFFECTS:
4546 case TransactionCode::SET_EFFECT_SUSPENDED:
4547 case TransactionCode::LOAD_HW_MODULE:
4548 case TransactionCode::GET_AUDIO_PORT:
4549 case TransactionCode::CREATE_AUDIO_PATCH:
4550 case TransactionCode::RELEASE_AUDIO_PATCH:
4551 case TransactionCode::LIST_AUDIO_PATCHES:
4552 case TransactionCode::SET_AUDIO_PORT_CONFIG:
4553 case TransactionCode::SET_RECORD_SILENCED:
Eric Laurentd66d7a12021-07-13 13:35:32 +02004554 case TransactionCode::AUDIO_POLICY_READY:
Mikhail Naganov516d3982022-02-01 23:53:59 +00004555 case TransactionCode::SET_DEVICE_CONNECTED_STATE:
Eric Laurent076e7c72022-05-03 18:12:28 +02004556 case TransactionCode::SET_REQUESTED_LATENCY_MODE:
4557 case TransactionCode::GET_SUPPORTED_LATENCY_MODES:
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004558 ALOGW("%s: transaction %d received from PID %d",
4559 __func__, code, IPCThreadState::self()->getCallingPid());
4560 // return status only for non void methods
4561 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004562 case TransactionCode::SET_RECORD_SILENCED:
4563 case TransactionCode::SET_EFFECT_SUSPENDED:
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004564 break;
4565 default:
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004566 return INVALID_OPERATION;
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004567 }
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -07004568 // Fail silently in these cases.
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004569 return OK;
4570 default:
4571 break;
4572 }
4573
4574 // make sure the following transactions come from system components
4575 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004576 case TransactionCode::SET_MASTER_VOLUME:
4577 case TransactionCode::SET_MASTER_MUTE:
Jean-Michel Trivie4f113b2020-11-16 11:50:33 -08004578 case TransactionCode::MASTER_MUTE:
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004579 case TransactionCode::SET_MODE:
4580 case TransactionCode::SET_MIC_MUTE:
4581 case TransactionCode::SET_LOW_RAM_DEVICE:
4582 case TransactionCode::SYSTEM_READY:
jiabin1319f5a2021-03-30 22:21:24 +00004583 case TransactionCode::SET_AUDIO_HAL_PIDS:
jiabinf042b9b2021-05-07 23:46:28 +00004584 case TransactionCode::SET_VIBRATOR_INFOS:
4585 case TransactionCode::UPDATE_SECONDARY_OUTPUTS: {
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004586 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
4587 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
4588 __func__, code, IPCThreadState::self()->getCallingPid(),
4589 IPCThreadState::self()->getCallingUid());
4590 // return status only for non void methods
4591 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004592 case TransactionCode::SYSTEM_READY:
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004593 break;
4594 default:
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004595 return INVALID_OPERATION;
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004596 }
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -07004597 // Fail silently in these cases.
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004598 return OK;
4599 }
4600 } break;
4601 default:
4602 break;
4603 }
4604
4605 // List of relevant events that trigger log merging.
4606 // Log merging should activate during audio activity of any kind. This are considered the
4607 // most relevant events.
4608 // TODO should select more wisely the items from the list
4609 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004610 case TransactionCode::CREATE_TRACK:
4611 case TransactionCode::CREATE_RECORD:
4612 case TransactionCode::SET_MASTER_VOLUME:
4613 case TransactionCode::SET_MASTER_MUTE:
4614 case TransactionCode::SET_MIC_MUTE:
4615 case TransactionCode::SET_PARAMETERS:
4616 case TransactionCode::CREATE_EFFECT:
4617 case TransactionCode::SYSTEM_READY: {
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004618 requestLogMerge();
4619 break;
4620 }
4621 default:
4622 break;
4623 }
4624
Andy Hungc747c532022-03-07 21:41:14 -08004625 const std::string methodName = getIAudioFlingerStatistics().getMethodForCode(code);
4626 mediautils::TimeCheck check(
4627 std::string("IAudioFlinger::").append(methodName),
4628 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
4629 if (timeout) {
4630 mediametrics::LogItem(mMetricsId)
4631 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
4632 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
4633 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
4634 .record();
4635 } else {
4636 getIAudioFlingerStatistics().event(code, elapsedMs);
4637 }
Andy Hungf8ab0932022-06-13 19:49:43 -07004638 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
4639 mediautils::TimeCheck::kDefaultSecondChanceDuration,
4640 true /* crashOnTimeout */);
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004641
4642 // Make sure we connect to Audio Policy Service before calling into AudioFlinger:
4643 // - AudioFlinger can call into Audio Policy Service with its global mutex held
4644 // - If this is the first time Audio Policy Service is queried from inside audioserver process
4645 // this will trigger Audio Policy Manager initialization.
4646 // - Audio Policy Manager initialization calls into AudioFlinger which will try to lock
4647 // its global mutex and a deadlock will occur.
4648 if (IPCThreadState::self()->getCallingPid() != getpid()) {
4649 AudioSystem::get_audio_policy_service();
4650 }
4651
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -07004652 return delegate();
Mathias Agopian65ab4712010-07-14 17:59:35 -07004653}
4654
Glenn Kasten63238ef2015-03-02 15:50:29 -08004655} // namespace android