blob: 474c5be52176ed332c81d6c8dc40fbe23af49497 [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>
Shunkai Yao2b8fed42022-12-09 01:12:02 +000042#include <media/audiohal/AudioHalVersionInfo.h>
Mikhail Naganova0c91332016-09-19 10:01:12 -070043#include <media/audiohal/DeviceHalInterface.h>
44#include <media/audiohal/DevicesFactoryHalInterface.h>
45#include <media/audiohal/EffectsFactoryHalInterface.h>
Mikhail Naganov00260b52016-10-13 12:54:24 -070046#include <media/AudioParameter.h>
Andy Hungb68f5eb2019-12-03 16:49:17 -080047#include <media/MediaMetricsItem.h>
Mikhail Naganov913d06c2016-11-01 12:49:22 -070048#include <media/TypeConverter.h>
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -080049#include <mediautils/TimeCheck.h>
Andy Hung35fec5f2016-04-13 14:21:48 -070050#include <memunreachable/memunreachable.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070051#include <utils/String16.h>
52#include <utils/threads.h>
53
Steven Morelandf0c02ce2018-02-23 14:53:55 -080054#include <cutils/atomic.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070055#include <cutils/properties.h>
56
Dima Zavin64760242011-05-11 14:15:23 -070057#include <system/audio.h>
Vlad Popae8d99472022-06-30 16:02:48 +020058#include <audiomanager/IAudioManager.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070059
Mathias Agopian65ab4712010-07-14 17:59:35 -070060#include "AudioFlinger.h"
Andy Hung8946a282018-04-19 20:04:56 -070061#include "NBAIO_Tee.h"
Jiabin Huangebe64102021-09-07 20:01:07 +000062#include "PropertyUtils.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070063
Andy Hung6770c6f2015-04-07 13:43:36 -070064#include <media/AudioResamplerPublic.h>
65
Mikhail Naganov9fe94012016-10-14 14:57:40 -070066#include <system/audio_effects/effect_visualizer.h>
67#include <system/audio_effects/effect_ns.h>
68#include <system/audio_effects/effect_aec.h>
jiabineb3bda02020-06-30 14:07:03 -070069#include <system/audio_effects/effect_hapticgenerator.h>
Eric Laurentf690c462021-09-17 14:47:03 +020070#include <system/audio_effects/effect_spatializer.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070071
Glenn Kasten3b21c502011-12-15 09:52:39 -080072#include <audio_utils/primitives.h>
73
Eric Laurentfeb0db62011-07-22 09:04:31 -070074#include <powermanager/PowerManager.h>
Glenn Kasten190a46f2012-03-06 11:27:10 -080075
Glenn Kasten9e58b552013-01-18 15:09:48 -080076#include <media/IMediaLogService.h>
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -070077#include <media/AidlConversion.h>
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -080078#include <media/AudioValidator.h>
Glenn Kastenda6ef132013-01-10 12:31:01 -080079#include <media/nbaio/Pipe.h>
80#include <media/nbaio/PipeReader.h>
Wei Jia3f273d12015-11-24 09:06:49 -080081#include <mediautils/BatteryNotifier.h>
Andy Hunge9eb03e2020-04-04 14:08:23 -070082#include <mediautils/MemoryLeakTrackUtil.h>
Andy Hungc747c532022-03-07 21:41:14 -080083#include <mediautils/MethodStatistics.h>
Andy Hungab7ef302018-05-15 19:35:29 -070084#include <mediautils/ServiceUtilities.h>
Eric Laurent42896a02019-09-27 15:40:33 -070085#include <mediautils/TimeCheck.h>
Glenn Kasten4182c4e2013-07-15 14:45:07 -070086#include <private/android_filesystem_config.h>
Glenn Kastenda6ef132013-01-10 12:31:01 -080087
rago3bd1c872016-09-26 12:58:14 -070088//#define BUFLOG_NDEBUG 0
89#include <BufLog.h>
90
Nicolas Rouletfe1e1442017-01-30 12:02:03 -080091#include "TypedLogger.h"
92
Mathias Agopian65ab4712010-07-14 17:59:35 -070093// ----------------------------------------------------------------------------
Mathias Agopian65ab4712010-07-14 17:59:35 -070094
John Grossman1c345192012-03-27 14:00:17 -070095// Note: the following macro is used for extremely verbose logging message. In
96// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
97// 0; but one side effect of this is to turn all LOGV's as well. Some messages
98// are so verbose that we want to suppress them even when we have ALOG_ASSERT
99// turned on. Do not uncomment the #def below unless you really know what you
100// are doing and want to see all of the extremely verbose messages.
101//#define VERY_VERY_VERBOSE_LOGGING
102#ifdef VERY_VERY_VERBOSE_LOGGING
103#define ALOGVV ALOGV
104#else
105#define ALOGVV(a...) do { } while(0)
106#endif
Eric Laurentde070132010-07-13 04:45:46 -0700107
Mathias Agopian65ab4712010-07-14 17:59:35 -0700108namespace android {
109
Andy Hung03410c02022-01-27 08:24:31 -0800110using ::android::base::StringPrintf;
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700111using media::IEffectClient;
jiabine99d0882021-09-17 05:21:25 +0000112using media::audio::common::AudioMMapPolicyInfo;
113using media::audio::common::AudioMMapPolicyType;
Svet Ganov33761132021-05-13 22:51:08 +0000114using android::content::AttributionSourceState;
Shunkai Yao2b8fed42022-12-09 01:12:02 +0000115using android::detail::AudioHalVersionInfo;
116
117static const AudioHalVersionInfo kMaxAAudioPropertyDeviceHalVersion =
118 AudioHalVersionInfo(AudioHalVersionInfo::Type::HIDL, 7, 1);
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700119
Vlad Popae8d99472022-06-30 16:02:48 +0200120static constexpr char kDeadlockedString[] = "AudioFlinger may be deadlocked\n";
121static constexpr char kHardwareLockedString[] = "Hardware lock is taken\n";
122static constexpr char kClientLockedString[] = "Client lock is taken\n";
123static constexpr char kNoEffectsFactory[] = "Effects Factory is absent\n";
Mathias Agopian65ab4712010-07-14 17:59:35 -0700124
Vlad Popae8d99472022-06-30 16:02:48 +0200125static constexpr char kAudioServiceName[] = "audio";
Glenn Kasten58912562012-04-03 10:45:00 -0700126
John Grossman4ff14ba2012-02-08 16:37:41 -0800127nsecs_t AudioFlinger::mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs;
Eric Laurent7cafbb32011-11-22 18:50:29 -0800128
Eric Laurent81784c32012-11-19 14:55:58 -0800129uint32_t AudioFlinger::mScreenState;
Glenn Kasten3ed29202012-08-07 15:24:44 -0700130
Eric Laurent813e2a72013-08-31 12:59:48 -0700131// In order to avoid invalidating offloaded tracks each time a Visualizer is turned on and off
132// we define a minimum time during which a global effect is considered enabled.
133static const nsecs_t kMinGlobalEffectEnabletimeNs = seconds(7200);
134
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700135// Keep a strong reference to media.log service around forever.
136// The service is within our parent process so it can never die in a way that we could observe.
137// These two variables are const after initialization.
138static sp<IBinder> sMediaLogServiceAsBinder;
139static sp<IMediaLogService> sMediaLogService;
140
141static pthread_once_t sMediaLogOnce = PTHREAD_ONCE_INIT;
142
143static void sMediaLogInit()
144{
145 sMediaLogServiceAsBinder = defaultServiceManager()->getService(String16("media.log"));
146 if (sMediaLogServiceAsBinder != 0) {
147 sMediaLogService = interface_cast<IMediaLogService>(sMediaLogServiceAsBinder);
148 }
149}
150
jiabin57303cc2018-12-18 15:45:57 -0800151// Keep a strong reference to external vibrator service
152static sp<os::IExternalVibratorService> sExternalVibratorService;
153
154static sp<os::IExternalVibratorService> getExternalVibratorService() {
155 if (sExternalVibratorService == 0) {
Eric Laurent00abf0d2020-04-22 19:28:22 -0700156 sp<IBinder> binder = defaultServiceManager()->getService(
jiabin57303cc2018-12-18 15:45:57 -0800157 String16("external_vibrator_service"));
158 if (binder != 0) {
159 sExternalVibratorService =
160 interface_cast<os::IExternalVibratorService>(binder);
161 }
162 }
163 return sExternalVibratorService;
164}
165
Andy Hungc747c532022-03-07 21:41:14 -0800166// Creates association between Binder code to name for IAudioFlinger.
167#define IAUDIOFLINGER_BINDER_METHOD_MACRO_LIST \
168BINDER_METHOD_ENTRY(createTrack) \
169BINDER_METHOD_ENTRY(createRecord) \
170BINDER_METHOD_ENTRY(sampleRate) \
171BINDER_METHOD_ENTRY(format) \
172BINDER_METHOD_ENTRY(frameCount) \
173BINDER_METHOD_ENTRY(latency) \
174BINDER_METHOD_ENTRY(setMasterVolume) \
175BINDER_METHOD_ENTRY(setMasterMute) \
176BINDER_METHOD_ENTRY(masterVolume) \
177BINDER_METHOD_ENTRY(masterMute) \
178BINDER_METHOD_ENTRY(setStreamVolume) \
179BINDER_METHOD_ENTRY(setStreamMute) \
180BINDER_METHOD_ENTRY(streamVolume) \
181BINDER_METHOD_ENTRY(streamMute) \
182BINDER_METHOD_ENTRY(setMode) \
183BINDER_METHOD_ENTRY(setMicMute) \
184BINDER_METHOD_ENTRY(getMicMute) \
185BINDER_METHOD_ENTRY(setRecordSilenced) \
186BINDER_METHOD_ENTRY(setParameters) \
187BINDER_METHOD_ENTRY(getParameters) \
188BINDER_METHOD_ENTRY(registerClient) \
189BINDER_METHOD_ENTRY(getInputBufferSize) \
190BINDER_METHOD_ENTRY(openOutput) \
191BINDER_METHOD_ENTRY(openDuplicateOutput) \
192BINDER_METHOD_ENTRY(closeOutput) \
193BINDER_METHOD_ENTRY(suspendOutput) \
194BINDER_METHOD_ENTRY(restoreOutput) \
195BINDER_METHOD_ENTRY(openInput) \
196BINDER_METHOD_ENTRY(closeInput) \
197BINDER_METHOD_ENTRY(invalidateStream) \
198BINDER_METHOD_ENTRY(setVoiceVolume) \
199BINDER_METHOD_ENTRY(getRenderPosition) \
200BINDER_METHOD_ENTRY(getInputFramesLost) \
201BINDER_METHOD_ENTRY(newAudioUniqueId) \
202BINDER_METHOD_ENTRY(acquireAudioSessionId) \
203BINDER_METHOD_ENTRY(releaseAudioSessionId) \
204BINDER_METHOD_ENTRY(queryNumberEffects) \
205BINDER_METHOD_ENTRY(queryEffect) \
206BINDER_METHOD_ENTRY(getEffectDescriptor) \
207BINDER_METHOD_ENTRY(createEffect) \
208BINDER_METHOD_ENTRY(moveEffects) \
209BINDER_METHOD_ENTRY(loadHwModule) \
210BINDER_METHOD_ENTRY(getPrimaryOutputSamplingRate) \
211BINDER_METHOD_ENTRY(getPrimaryOutputFrameCount) \
212BINDER_METHOD_ENTRY(setLowRamDevice) \
213BINDER_METHOD_ENTRY(getAudioPort) \
214BINDER_METHOD_ENTRY(createAudioPatch) \
215BINDER_METHOD_ENTRY(releaseAudioPatch) \
216BINDER_METHOD_ENTRY(listAudioPatches) \
217BINDER_METHOD_ENTRY(setAudioPortConfig) \
218BINDER_METHOD_ENTRY(getAudioHwSyncForSession) \
219BINDER_METHOD_ENTRY(systemReady) \
220BINDER_METHOD_ENTRY(audioPolicyReady) \
221BINDER_METHOD_ENTRY(frameCountHAL) \
222BINDER_METHOD_ENTRY(getMicrophones) \
223BINDER_METHOD_ENTRY(setMasterBalance) \
224BINDER_METHOD_ENTRY(getMasterBalance) \
225BINDER_METHOD_ENTRY(setEffectSuspended) \
226BINDER_METHOD_ENTRY(setAudioHalPids) \
227BINDER_METHOD_ENTRY(setVibratorInfos) \
228BINDER_METHOD_ENTRY(updateSecondaryOutputs) \
229BINDER_METHOD_ENTRY(getMmapPolicyInfos) \
230BINDER_METHOD_ENTRY(getAAudioMixerBurstCount) \
231BINDER_METHOD_ENTRY(getAAudioHardwareBurstMinUsec) \
232BINDER_METHOD_ENTRY(setDeviceConnectedState) \
Eric Laurent076e7c72022-05-03 18:12:28 +0200233BINDER_METHOD_ENTRY(setRequestedLatencyMode) \
234BINDER_METHOD_ENTRY(getSupportedLatencyModes) \
Vlad Popa63f047e2022-11-05 14:09:19 +0100235BINDER_METHOD_ENTRY(registerSoundDoseCallback) \
Andy Hungc747c532022-03-07 21:41:14 -0800236
237// singleton for Binder Method Statistics for IAudioFlinger
238static auto& getIAudioFlingerStatistics() {
239 using Code = android::AudioFlingerServerAdapter::Delegate::TransactionCode;
240
241#pragma push_macro("BINDER_METHOD_ENTRY")
242#undef BINDER_METHOD_ENTRY
243#define BINDER_METHOD_ENTRY(ENTRY) \
244 {(Code)media::BnAudioFlingerService::TRANSACTION_##ENTRY, #ENTRY},
245
246 static mediautils::MethodStatistics<Code> methodStatistics{
247 IAUDIOFLINGER_BINDER_METHOD_MACRO_LIST
248 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
249 };
250#pragma pop_macro("BINDER_METHOD_ENTRY")
251
252 return methodStatistics;
253}
254
Mikhail Naganov88b30d22020-03-09 19:43:13 +0000255class DevicesFactoryHalCallbackImpl : public DevicesFactoryHalCallback {
256 public:
257 void onNewDevicesAvailable() override {
258 // Start a detached thread to execute notification in parallel.
259 // This is done to prevent mutual blocking of audio_flinger and
260 // audio_policy services during system initialization.
261 std::thread notifier([]() {
262 AudioSystem::onNewAudioModulesAvailable();
263 });
264 notifier.detach();
265 }
266};
267
Svet Ganov33761132021-05-13 22:51:08 +0000268// TODO b/182392769: use attribution source util
Eric Laurentec376dc2021-04-08 20:41:22 +0200269/* static */
Svet Ganov33761132021-05-13 22:51:08 +0000270AttributionSourceState AudioFlinger::checkAttributionSourcePackage(
271 const AttributionSourceState& attributionSource) {
Eric Laurentec376dc2021-04-08 20:41:22 +0200272 Vector<String16> packages;
Svet Ganov33761132021-05-13 22:51:08 +0000273 PermissionController{}.getPackagesForUid(attributionSource.uid, packages);
Eric Laurentec376dc2021-04-08 20:41:22 +0200274
Svet Ganov33761132021-05-13 22:51:08 +0000275 AttributionSourceState checkedAttributionSource = attributionSource;
276 if (!attributionSource.packageName.has_value()
277 || attributionSource.packageName.value().size() == 0) {
Eric Laurentec376dc2021-04-08 20:41:22 +0200278 if (!packages.isEmpty()) {
Svet Ganov33761132021-05-13 22:51:08 +0000279 checkedAttributionSource.packageName =
Eric Laurentec376dc2021-04-08 20:41:22 +0200280 std::move(legacy2aidl_String16_string(packages[0]).value());
281 }
282 } else {
283 String16 opPackageLegacy = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000284 aidl2legacy_string_view_String16(attributionSource.packageName.value_or("")));
Eric Laurentec376dc2021-04-08 20:41:22 +0200285 if (std::find_if(packages.begin(), packages.end(),
286 [&opPackageLegacy](const auto& package) {
287 return opPackageLegacy == package; }) == packages.end()) {
288 ALOGW("The package name(%s) provided does not correspond to the uid %d",
Svet Ganov33761132021-05-13 22:51:08 +0000289 attributionSource.packageName.value_or("").c_str(), attributionSource.uid);
Eric Laurentec376dc2021-04-08 20:41:22 +0200290 }
291 }
Svet Ganov33761132021-05-13 22:51:08 +0000292 return checkedAttributionSource;
Eric Laurentec376dc2021-04-08 20:41:22 +0200293}
294
Mathias Agopian65ab4712010-07-14 17:59:35 -0700295// ----------------------------------------------------------------------------
296
Mikhail Naganov913d06c2016-11-01 12:49:22 -0700297std::string formatToString(audio_format_t format) {
298 std::string result;
299 FormatConverter::toString(format, result);
300 return result;
Marco Nelissenb2208842014-02-07 14:00:50 -0800301}
302
Mathias Agopian65ab4712010-07-14 17:59:35 -0700303// ----------------------------------------------------------------------------
304
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800305void AudioFlinger::instantiate() {
306 sp<IServiceManager> sm(defaultServiceManager());
307 sm->addService(String16(IAudioFlinger::DEFAULT_SERVICE_NAME),
308 new AudioFlingerServerAdapter(new AudioFlinger()), false,
309 IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT);
310}
311
Mathias Agopian65ab4712010-07-14 17:59:35 -0700312AudioFlinger::AudioFlinger()
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800313 : mMediaLogNotifier(new AudioFlinger::MediaLogNotifier()),
John Grossman4ff14ba2012-02-08 16:37:41 -0800314 mPrimaryHardwareDev(NULL),
Glenn Kasten9ea65d02014-01-17 10:21:24 -0800315 mAudioHwDevs(NULL),
Glenn Kasten7d6c35b2012-07-02 12:45:10 -0700316 mHardwareStatus(AUDIO_HW_IDLE),
John Grossman4ff14ba2012-02-08 16:37:41 -0800317 mMasterVolume(1.0f),
John Grossman4ff14ba2012-02-08 16:37:41 -0800318 mMasterMute(false),
Glenn Kastend2e67e12016-04-11 08:26:37 -0700319 // mNextUniqueId(AUDIO_UNIQUE_ID_USE_MAX),
John Grossman4ff14ba2012-02-08 16:37:41 -0800320 mMode(AUDIO_MODE_INVALID),
Glenn Kasten4182c4e2013-07-15 14:45:07 -0700321 mBtNrecIsOff(false),
322 mIsLowRamDevice(true),
Eric Laurent813e2a72013-08-31 12:59:48 -0700323 mIsDeviceTypeKnown(false),
Andy Hung6f248bb2018-01-23 14:04:37 -0800324 mTotalMemory(0),
325 mClientSharedHeapSize(kMinimumClientSharedHeapSizeBytes),
Glenn Kasten4ea00a22014-06-02 08:29:22 -0700326 mGlobalEffectEnableTime(0),
Mikhail Naganovdea53042018-04-26 13:10:21 -0700327 mPatchPanel(this),
Vlad Popa5161f8a2022-10-10 16:17:20 +0200328 mPatchCommandThread(sp<PatchCommandThread>::make()),
329 mDeviceEffectManager(sp<DeviceEffectManager>::make(*this)),
Vlad Popab042ee62022-10-20 18:05:00 +0200330 mMelReporter(sp<MelReporter>::make(*this)),
Eric Laurent72e3f392015-05-20 14:43:50 -0700331 mSystemReady(false)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700332{
Eric Laurentf43be0c2021-03-25 10:45:53 +0100333 // Move the audio session unique ID generator start base as time passes to limit risk of
334 // generating the same ID again after an audioserver restart.
335 // This is important because clients will reuse previously allocated audio session IDs
336 // when reconnecting after an audioserver restart and newly allocated IDs may conflict with
337 // active clients.
338 // Moving the base by 1 for each elapsed second is a good compromise between avoiding overlap
339 // between allocation ranges and not reaching wrap around too soon.
340 timespec ts{};
341 clock_gettime(CLOCK_MONOTONIC, &ts);
342 // zero ID has a special meaning, so start allocation at least at AUDIO_UNIQUE_ID_USE_MAX
Eric Laurentf37f1982021-06-01 13:23:27 +0200343 uint32_t movingBase = (uint32_t)std::max((long)1, ts.tv_sec);
Glenn Kastend2e67e12016-04-11 08:26:37 -0700344 // unsigned instead of audio_unique_id_use_t, because ++ operator is unavailable for enum
345 for (unsigned use = AUDIO_UNIQUE_ID_USE_UNSPECIFIED; use < AUDIO_UNIQUE_ID_USE_MAX; use++) {
Eric Laurentf43be0c2021-03-25 10:45:53 +0100346 mNextUniqueIds[use] =
Eric Laurentf37f1982021-06-01 13:23:27 +0200347 ((use == AUDIO_UNIQUE_ID_USE_SESSION || use == AUDIO_UNIQUE_ID_USE_CLIENT) ?
348 movingBase : 1) * AUDIO_UNIQUE_ID_USE_MAX;
Glenn Kastend2e67e12016-04-11 08:26:37 -0700349 }
350
Eric Laurent94ca1142020-10-07 10:45:20 -0700351#if 1
352 // FIXME See bug 165702394 and bug 168511485
353 const bool doLog = false;
354#else
Glenn Kastenae0cff12016-02-24 13:57:49 -0800355 const bool doLog = property_get_bool("ro.test_harness", false);
Eric Laurent94ca1142020-10-07 10:45:20 -0700356#endif
Glenn Kasten9e58b552013-01-18 15:09:48 -0800357 if (doLog) {
Glenn Kastenb187de12014-12-30 08:18:15 -0800358 mLogMemoryDealer = new MemoryDealer(kLogMemorySize, "LogWriters",
359 MemoryHeapBase::READ_ONLY);
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700360 (void) pthread_once(&sMediaLogOnce, sMediaLogInit);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800361 }
Eric Laurent1c333e22014-05-20 10:48:17 -0700362
Wei Jia3f273d12015-11-24 09:06:49 -0800363 // reset battery stats.
364 // if the audio service has crashed, battery stats could be left
365 // in bad state, reset the state upon service start.
366 BatteryNotifier::getInstance().noteResetAudio();
367
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700368 mDevicesFactoryHal = DevicesFactoryHalInterface::create();
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700369 mEffectsFactoryHal = EffectsFactoryHalInterface::create();
370
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -0800371 mMediaLogNotifier->run("MediaLogNotifier");
Eric Laurent42896a02019-09-27 15:40:33 -0700372 std::vector<pid_t> halPids;
373 mDevicesFactoryHal->getHalPids(&halPids);
Andy Hung5c6d68a2022-03-09 21:54:59 -0800374 mediautils::TimeCheck::setAudioHalPids(halPids);
Andy Hungb68f5eb2019-12-03 16:49:17 -0800375
376 // Notify that we have started (also called when audioserver service restarts)
377 mediametrics::LogItem(mMetricsId)
378 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
379 .record();
Dima Zavin5a61d2f2011-04-19 19:04:32 -0700380}
381
382void AudioFlinger::onFirstRef()
383{
Eric Laurent93575202011-01-18 18:39:02 -0800384 Mutex::Autolock _l(mLock);
385
Dima Zavin799a70e2011-04-18 16:57:27 -0700386 /* TODO: move all this work into an Init() function */
John Grossman4ff14ba2012-02-08 16:37:41 -0800387 char val_str[PROPERTY_VALUE_MAX] = { 0 };
388 if (property_get("ro.audio.flinger_standbytime_ms", val_str, NULL) >= 0) {
389 uint32_t int_val;
390 if (1 == sscanf(val_str, "%u", &int_val)) {
391 mStandbyTimeInNsecs = milliseconds(int_val);
392 ALOGI("Using %u mSec as standby time.", int_val);
393 } else {
394 mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs;
395 ALOGI("Using default %u mSec as standby time.",
396 (uint32_t)(mStandbyTimeInNsecs / 1000000));
397 }
398 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700399
Eric Laurenta4c5a552012-03-29 10:12:40 -0700400 mMode = AUDIO_MODE_NORMAL;
Eric Laurentfc235202016-12-20 18:48:17 -0800401
Andy Hung6626a012021-01-12 13:38:00 -0800402 gAudioFlinger = this; // we are already refcounted, store into atomic pointer.
Mikhail Naganov88b30d22020-03-09 19:43:13 +0000403
404 mDevicesFactoryHalCallback = new DevicesFactoryHalCallbackImpl;
405 mDevicesFactoryHal->setCallbackOnce(mDevicesFactoryHalCallback);
jiabine504e7b2021-09-18 00:27:08 +0000406
Shunkai Yao2b8fed42022-12-09 01:12:02 +0000407 if (mDevicesFactoryHal->getHalVersion() <= kMaxAAudioPropertyDeviceHalVersion) {
jiabine504e7b2021-09-18 00:27:08 +0000408 mAAudioBurstsPerBuffer = getAAudioMixerBurstCountFromSystemProperty();
409 mAAudioHwBurstMinMicros = getAAudioHardwareBurstMinUsecFromSystemProperty();
410 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700411}
412
Eric Laurent42896a02019-09-27 15:40:33 -0700413status_t AudioFlinger::setAudioHalPids(const std::vector<pid_t>& pids) {
Andy Hung5c6d68a2022-03-09 21:54:59 -0800414 mediautils::TimeCheck::setAudioHalPids(pids);
Eric Laurent42896a02019-09-27 15:40:33 -0700415 return NO_ERROR;
416}
417
jiabin1319f5a2021-03-30 22:21:24 +0000418status_t AudioFlinger::setVibratorInfos(
419 const std::vector<media::AudioVibratorInfo>& vibratorInfos) {
420 Mutex::Autolock _l(mLock);
421 mAudioVibratorInfos = vibratorInfos;
422 return NO_ERROR;
423}
424
jiabinf042b9b2021-05-07 23:46:28 +0000425status_t AudioFlinger::updateSecondaryOutputs(
426 const TrackSecondaryOutputsMap& trackSecondaryOutputs) {
427 Mutex::Autolock _l(mLock);
428 for (const auto& [trackId, secondaryOutputs] : trackSecondaryOutputs) {
429 size_t i = 0;
430 for (; i < mPlaybackThreads.size(); ++i) {
431 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
432 Mutex::Autolock _tl(thread->mLock);
433 sp<PlaybackThread::Track> track = thread->getTrackById_l(trackId);
434 if (track != nullptr) {
435 ALOGD("%s trackId: %u", __func__, trackId);
436 updateSecondaryOutputsForTrack_l(track.get(), thread, secondaryOutputs);
437 break;
438 }
439 }
440 ALOGW_IF(i >= mPlaybackThreads.size(),
441 "%s cannot find track with id %u", __func__, trackId);
442 }
443 return NO_ERROR;
444}
445
Jiabin Huangebe64102021-09-07 20:01:07 +0000446status_t AudioFlinger::getMmapPolicyInfos(
jiabine99d0882021-09-17 05:21:25 +0000447 AudioMMapPolicyType policyType, std::vector<AudioMMapPolicyInfo> *policyInfos) {
jiabine504e7b2021-09-18 00:27:08 +0000448 Mutex::Autolock _l(mLock);
Jiabin Huangebe64102021-09-07 20:01:07 +0000449 if (const auto it = mPolicyInfos.find(policyType); it != mPolicyInfos.end()) {
450 *policyInfos = it->second;
451 return NO_ERROR;
452 }
Shunkai Yao2b8fed42022-12-09 01:12:02 +0000453 if (mDevicesFactoryHal->getHalVersion() > kMaxAAudioPropertyDeviceHalVersion) {
Jiabin Huangebe64102021-09-07 20:01:07 +0000454 AutoMutex lock(mHardwareLock);
455 for (size_t i = 0; i < mAudioHwDevs.size(); ++i) {
456 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
jiabine99d0882021-09-17 05:21:25 +0000457 std::vector<AudioMMapPolicyInfo> infos;
Jiabin Huangebe64102021-09-07 20:01:07 +0000458 status_t status = dev->getMmapPolicyInfos(policyType, &infos);
459 if (status != NO_ERROR) {
460 ALOGE("Failed to query mmap policy info of %d, error %d",
461 mAudioHwDevs.keyAt(i), status);
462 continue;
463 }
464 policyInfos->insert(policyInfos->end(), infos.begin(), infos.end());
465 }
466 mPolicyInfos[policyType] = *policyInfos;
467 } else {
468 getMmapPolicyInfosFromSystemProperty(policyType, policyInfos);
469 mPolicyInfos[policyType] = *policyInfos;
470 }
471 return NO_ERROR;
472}
473
jiabine504e7b2021-09-18 00:27:08 +0000474int32_t AudioFlinger::getAAudioMixerBurstCount() {
475 Mutex::Autolock _l(mLock);
476 return mAAudioBurstsPerBuffer;
477}
478
479int32_t AudioFlinger::getAAudioHardwareBurstMinUsec() {
480 Mutex::Autolock _l(mLock);
481 return mAAudioHwBurstMinMicros;
482}
483
Mikhail Naganov516d3982022-02-01 23:53:59 +0000484status_t AudioFlinger::setDeviceConnectedState(const struct audio_port_v7 *port, bool connected) {
485 status_t final_result = NO_INIT;
486 Mutex::Autolock _l(mLock);
487 AutoMutex lock(mHardwareLock);
488 mHardwareStatus = AUDIO_HW_SET_CONNECTED_STATE;
489 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
490 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
491 status_t result = dev->setConnectedState(port, connected);
492 // Same logic as with setParameter: it's a success if at least one
493 // HAL module accepts the update.
494 if (final_result != NO_ERROR) {
495 final_result = result;
496 }
497 }
498 mHardwareStatus = AUDIO_HW_IDLE;
499 return final_result;
500}
501
jiabin1319f5a2021-03-30 22:21:24 +0000502// getDefaultVibratorInfo_l must be called with AudioFlinger lock held.
Lais Andradebc3f37a2021-07-02 00:13:19 +0100503std::optional<media::AudioVibratorInfo> AudioFlinger::getDefaultVibratorInfo_l() {
jiabin1319f5a2021-03-30 22:21:24 +0000504 if (mAudioVibratorInfos.empty()) {
Lais Andradebc3f37a2021-07-02 00:13:19 +0100505 return {};
jiabin1319f5a2021-03-30 22:21:24 +0000506 }
Lais Andradebc3f37a2021-07-02 00:13:19 +0100507 return mAudioVibratorInfos.front();
jiabin1319f5a2021-03-30 22:21:24 +0000508}
509
Mathias Agopian65ab4712010-07-14 17:59:35 -0700510AudioFlinger::~AudioFlinger()
511{
512 while (!mRecordThreads.isEmpty()) {
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700513 // closeInput_nonvirtual() will remove specified entry from mRecordThreads
Glenn Kastend96c5722012-04-25 13:44:49 -0700514 closeInput_nonvirtual(mRecordThreads.keyAt(0));
Mathias Agopian65ab4712010-07-14 17:59:35 -0700515 }
516 while (!mPlaybackThreads.isEmpty()) {
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700517 // closeOutput_nonvirtual() will remove specified entry from mPlaybackThreads
Glenn Kastend96c5722012-04-25 13:44:49 -0700518 closeOutput_nonvirtual(mPlaybackThreads.keyAt(0));
Mathias Agopian65ab4712010-07-14 17:59:35 -0700519 }
Andy Hungb4946b62019-03-14 11:19:28 -0700520 while (!mMmapThreads.isEmpty()) {
521 const audio_io_handle_t io = mMmapThreads.keyAt(0);
522 if (mMmapThreads.valueAt(0)->isOutput()) {
523 closeOutput_nonvirtual(io); // removes entry from mMmapThreads
524 } else {
525 closeInput_nonvirtual(io); // removes entry from mMmapThreads
526 }
527 }
Dima Zavin799a70e2011-04-18 16:57:27 -0700528
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800529 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
530 // no mHardwareLock needed, as there are no other references to this
Eric Laurenta4c5a552012-03-29 10:12:40 -0700531 delete mAudioHwDevs.valueAt(i);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700532 }
Glenn Kasten481fb672013-09-30 14:39:28 -0700533
534 // Tell media.log service about any old writers that still need to be unregistered
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700535 if (sMediaLogService != 0) {
536 for (size_t count = mUnregisteredWriters.size(); count > 0; count--) {
537 sp<IMemory> iMemory(mUnregisteredWriters.top()->getIMemory());
538 mUnregisteredWriters.pop();
539 sMediaLogService->unregisterWriter(iMemory);
Glenn Kasten481fb672013-09-30 14:39:28 -0700540 }
541 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700542}
543
Eric Laurentfc235202016-12-20 18:48:17 -0800544//static
Eric Laurent6acd1d42017-01-04 14:23:29 -0800545__attribute__ ((visibility ("default")))
Eric Laurentfc235202016-12-20 18:48:17 -0800546status_t MmapStreamInterface::openMmapStream(MmapStreamInterface::stream_direction_t direction,
547 const audio_attributes_t *attr,
548 audio_config_base_t *config,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700549 const AudioClient& client,
Eric Laurentfc235202016-12-20 18:48:17 -0800550 audio_port_handle_t *deviceId,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800551 audio_session_t *sessionId,
Eric Laurentfc235202016-12-20 18:48:17 -0800552 const sp<MmapStreamCallback>& callback,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700553 sp<MmapStreamInterface>& interface,
554 audio_port_handle_t *handle)
Eric Laurentfc235202016-12-20 18:48:17 -0800555{
Andy Hung6626a012021-01-12 13:38:00 -0800556 // TODO: Use ServiceManager to get IAudioFlinger instead of by atomic pointer.
557 // This allows moving oboeservice (AAudio) to a separate process in the future.
558 sp<AudioFlinger> af = AudioFlinger::gAudioFlinger.load(); // either nullptr or singleton AF.
Eric Laurentfc235202016-12-20 18:48:17 -0800559 status_t ret = NO_INIT;
560 if (af != 0) {
561 ret = af->openMmapStream(
Phil Burk4e1af9f2018-01-03 15:54:35 -0800562 direction, attr, config, client, deviceId,
563 sessionId, callback, interface, handle);
Eric Laurentfc235202016-12-20 18:48:17 -0800564 }
565 return ret;
566}
567
Eric Laurent6acd1d42017-01-04 14:23:29 -0800568status_t AudioFlinger::openMmapStream(MmapStreamInterface::stream_direction_t direction,
569 const audio_attributes_t *attr,
570 audio_config_base_t *config,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700571 const AudioClient& client,
Eric Laurent6acd1d42017-01-04 14:23:29 -0800572 audio_port_handle_t *deviceId,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800573 audio_session_t *sessionId,
Eric Laurent6acd1d42017-01-04 14:23:29 -0800574 const sp<MmapStreamCallback>& callback,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700575 sp<MmapStreamInterface>& interface,
576 audio_port_handle_t *handle)
Eric Laurentfc235202016-12-20 18:48:17 -0800577{
578 status_t ret = initCheck();
579 if (ret != NO_ERROR) {
580 return ret;
581 }
Phil Burk4e1af9f2018-01-03 15:54:35 -0800582 audio_session_t actualSessionId = *sessionId;
583 if (actualSessionId == AUDIO_SESSION_ALLOCATE) {
584 actualSessionId = (audio_session_t) newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
585 }
Eric Laurent6acd1d42017-01-04 14:23:29 -0800586 audio_stream_type_t streamType = AUDIO_STREAM_DEFAULT;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700587 audio_io_handle_t io = AUDIO_IO_HANDLE_NONE;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800588 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
Eric Laurent42984412019-05-09 17:57:03 -0700589 audio_attributes_t localAttr = *attr;
Eric Laurent9ff3e532022-11-10 16:04:44 +0100590
591 // TODO b/182392553: refactor or make clearer
592 pid_t clientPid =
593 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(client.attributionSource.pid));
594 bool updatePid = (clientPid == (pid_t)-1);
595 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
596
597 AttributionSourceState adjAttributionSource = client.attributionSource;
598 if (!isAudioServerOrMediaServerOrSystemServerOrRootUid(callingUid)) {
599 uid_t clientUid =
600 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_uid_t(client.attributionSource.uid));
601 ALOGW_IF(clientUid != callingUid,
602 "%s uid %d tried to pass itself off as %d",
603 __FUNCTION__, callingUid, clientUid);
604 adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
605 updatePid = true;
606 }
607 if (updatePid) {
608 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
609 ALOGW_IF(clientPid != (pid_t)-1 && clientPid != callingPid,
610 "%s uid %d pid %d tried to pass itself off as pid %d",
611 __func__, callingUid, callingPid, clientPid);
612 adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
613 }
614 adjAttributionSource = AudioFlinger::checkAttributionSourcePackage(
615 adjAttributionSource);
616
Eric Laurent6acd1d42017-01-04 14:23:29 -0800617 if (direction == MmapStreamInterface::DIRECTION_OUTPUT) {
618 audio_config_t fullConfig = AUDIO_CONFIG_INITIALIZER;
619 fullConfig.sample_rate = config->sample_rate;
620 fullConfig.channel_mask = config->channel_mask;
621 fullConfig.format = config->format;
Kevin Rocard153f92d2018-12-18 18:33:28 -0800622 std::vector<audio_io_handle_t> secondaryOutputs;
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200623 bool isSpatialized;
Eric Laurent42984412019-05-09 17:57:03 -0700624 ret = AudioSystem::getOutputForAttr(&localAttr, &io,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800625 actualSessionId,
Eric Laurent9ff3e532022-11-10 16:04:44 +0100626 &streamType, adjAttributionSource,
Ricardo Correa57a37692020-03-23 17:27:25 -0700627 &fullConfig,
Glenn Kastend3bb6452016-12-05 18:14:37 -0800628 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ |
629 AUDIO_OUTPUT_FLAG_DIRECT),
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200630 deviceId, &portId, &secondaryOutputs, &isSpatialized);
jiabinf1c73972022-04-14 16:28:52 -0700631 if (ret != NO_ERROR) {
632 config->sample_rate = fullConfig.sample_rate;
633 config->channel_mask = fullConfig.channel_mask;
634 config->format = fullConfig.format;
635 }
Kevin Rocard153f92d2018-12-18 18:33:28 -0800636 ALOGW_IF(!secondaryOutputs.empty(),
637 "%s does not support secondary outputs, ignoring them", __func__);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800638 } else {
Eric Laurent42984412019-05-09 17:57:03 -0700639 ret = AudioSystem::getInputForAttr(&localAttr, &io,
Mikhail Naganov2996f672019-04-18 12:29:59 -0700640 RECORD_RIID_INVALID,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800641 actualSessionId,
Eric Laurent9ff3e532022-11-10 16:04:44 +0100642 adjAttributionSource,
Eric Laurent6acd1d42017-01-04 14:23:29 -0800643 config,
Eric Laurent2ac76942017-06-22 17:17:09 -0700644 AUDIO_INPUT_FLAG_MMAP_NOIRQ, deviceId, &portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800645 }
646 if (ret != NO_ERROR) {
647 return ret;
648 }
649
650 // at this stage, a MmapThread was created when openOutput() or openInput() was called by
651 // audio policy manager and we can retrieve it
652 sp<MmapThread> thread = mMmapThreads.valueFor(io);
653 if (thread != 0) {
654 interface = new MmapThreadHandle(thread);
Eric Laurent42984412019-05-09 17:57:03 -0700655 thread->configure(&localAttr, streamType, actualSessionId, callback, *deviceId, portId);
Eric Laurentcb4dae22017-07-01 19:39:32 -0700656 *handle = portId;
Phil Burk4e1af9f2018-01-03 15:54:35 -0800657 *sessionId = actualSessionId;
Eric Laurenta7a89e22020-01-08 18:39:20 -0800658 config->sample_rate = thread->sampleRate();
659 config->channel_mask = thread->channelMask();
660 config->format = thread->format();
Eric Laurent6acd1d42017-01-04 14:23:29 -0800661 } else {
Eric Laurentad2e7b92017-09-14 20:06:42 -0700662 if (direction == MmapStreamInterface::DIRECTION_OUTPUT) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700663 AudioSystem::releaseOutput(portId);
Eric Laurentad2e7b92017-09-14 20:06:42 -0700664 } else {
Eric Laurentfee19762018-01-29 18:44:13 -0800665 AudioSystem::releaseInput(portId);
Eric Laurentad2e7b92017-09-14 20:06:42 -0700666 }
Eric Laurent6acd1d42017-01-04 14:23:29 -0800667 ret = NO_INIT;
668 }
669
670 ALOGV("%s done status %d portId %d", __FUNCTION__, ret, portId);
671
Eric Laurentfc235202016-12-20 18:48:17 -0800672 return ret;
673}
674
jiabin57303cc2018-12-18 15:45:57 -0800675/* static */
Simon Bowden62823412022-10-17 14:52:26 +0000676os::HapticScale AudioFlinger::onExternalVibrationStart(
677 const sp<os::ExternalVibration>& externalVibration) {
jiabin57303cc2018-12-18 15:45:57 -0800678 sp<os::IExternalVibratorService> evs = getExternalVibratorService();
jiabin78dc9c82021-02-22 19:13:29 +0000679 if (evs != nullptr) {
jiabin57303cc2018-12-18 15:45:57 -0800680 int32_t ret;
681 binder::Status status = evs->onExternalVibrationStart(*externalVibration, &ret);
682 if (status.isOk()) {
jiabin78dc9c82021-02-22 19:13:29 +0000683 ALOGD("%s, start external vibration with intensity as %d", __func__, ret);
Simon Bowden62823412022-10-17 14:52:26 +0000684 return os::ExternalVibration::externalVibrationScaleToHapticScale(ret);
jiabin57303cc2018-12-18 15:45:57 -0800685 }
686 }
jiabin78dc9c82021-02-22 19:13:29 +0000687 ALOGD("%s, start external vibration with intensity as MUTE due to %s",
688 __func__,
689 evs == nullptr ? "external vibration service not found"
690 : "error when querying intensity");
Simon Bowden62823412022-10-17 14:52:26 +0000691 return os::HapticScale::MUTE;
jiabin57303cc2018-12-18 15:45:57 -0800692}
693
694/* static */
695void AudioFlinger::onExternalVibrationStop(const sp<os::ExternalVibration>& externalVibration) {
696 sp<os::IExternalVibratorService> evs = getExternalVibratorService();
697 if (evs != 0) {
jiabinc47acf22022-04-01 23:47:52 +0000698 ALOGD("%s, stopping external vibration", __func__);
jiabin57303cc2018-12-18 15:45:57 -0800699 evs->onExternalVibrationStop(*externalVibration);
700 }
701}
702
Eric Laurentb82e6b72019-11-22 17:25:04 -0800703status_t AudioFlinger::addEffectToHal(audio_port_handle_t deviceId,
704 audio_module_handle_t hwModuleId, sp<EffectHalInterface> effect) {
Eric Laurent00abf0d2020-04-22 19:28:22 -0700705 AutoMutex lock(mHardwareLock);
Eric Laurentb82e6b72019-11-22 17:25:04 -0800706 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueFor(hwModuleId);
707 if (audioHwDevice == nullptr) {
708 return NO_INIT;
709 }
710 return audioHwDevice->hwDevice()->addDeviceEffect(deviceId, effect);
711}
712
713status_t AudioFlinger::removeEffectFromHal(audio_port_handle_t deviceId,
714 audio_module_handle_t hwModuleId, sp<EffectHalInterface> effect) {
Eric Laurent00abf0d2020-04-22 19:28:22 -0700715 AutoMutex lock(mHardwareLock);
Eric Laurentb82e6b72019-11-22 17:25:04 -0800716 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueFor(hwModuleId);
717 if (audioHwDevice == nullptr) {
718 return NO_INIT;
719 }
720 return audioHwDevice->hwDevice()->removeDeviceEffect(deviceId, effect);
721}
722
Eric Laurenta4c5a552012-03-29 10:12:40 -0700723static const char * const audio_interfaces[] = {
724 AUDIO_HARDWARE_MODULE_ID_PRIMARY,
725 AUDIO_HARDWARE_MODULE_ID_A2DP,
726 AUDIO_HARDWARE_MODULE_ID_USB,
727};
Eric Laurenta4c5a552012-03-29 10:12:40 -0700728
Phil Burk062e67a2015-02-11 13:40:50 -0800729AudioHwDevice* AudioFlinger::findSuitableHwDev_l(
John Grossmanee578c02012-07-23 17:05:46 -0700730 audio_module_handle_t module,
jiabin43810402019-10-24 14:58:31 -0700731 audio_devices_t deviceType)
Dima Zavin799a70e2011-04-18 16:57:27 -0700732{
Eric Laurenta4c5a552012-03-29 10:12:40 -0700733 // if module is 0, the request comes from an old policy manager and we should load
734 // well known modules
Eric Laurent00abf0d2020-04-22 19:28:22 -0700735 AutoMutex lock(mHardwareLock);
Eric Laurenta4c5a552012-03-29 10:12:40 -0700736 if (module == 0) {
737 ALOGW("findSuitableHwDev_l() loading well know audio hw modules");
Mikhail Naganovbf493082017-04-17 17:37:12 -0700738 for (size_t i = 0; i < arraysize(audio_interfaces); i++) {
Eric Laurenta4c5a552012-03-29 10:12:40 -0700739 loadHwModule_l(audio_interfaces[i]);
740 }
Eric Laurentf1c04f92012-08-28 14:26:53 -0700741 // then try to find a module supporting the requested device.
742 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
743 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueAt(i);
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700744 sp<DeviceHalInterface> dev = audioHwDevice->hwDevice();
745 uint32_t supportedDevices;
746 if (dev->getSupportedDevices(&supportedDevices) == OK &&
jiabin43810402019-10-24 14:58:31 -0700747 (supportedDevices & deviceType) == deviceType) {
Eric Laurentf1c04f92012-08-28 14:26:53 -0700748 return audioHwDevice;
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700749 }
Eric Laurentf1c04f92012-08-28 14:26:53 -0700750 }
Eric Laurenta4c5a552012-03-29 10:12:40 -0700751 } else {
752 // check a match for the requested module handle
John Grossmanee578c02012-07-23 17:05:46 -0700753 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueFor(module);
754 if (audioHwDevice != NULL) {
755 return audioHwDevice;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700756 }
757 }
Eric Laurenta4c5a552012-03-29 10:12:40 -0700758
Dima Zavin799a70e2011-04-18 16:57:27 -0700759 return NULL;
760}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700761
Glenn Kasten0f11b512014-01-31 16:18:54 -0800762void AudioFlinger::dumpClients(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700763{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700764 String8 result;
765
Atneya Nair9ec58d52022-10-03 15:46:20 -0700766 result.append("Client Allocators:\n");
Mathias Agopian65ab4712010-07-14 17:59:35 -0700767 for (size_t i = 0; i < mClients.size(); ++i) {
Glenn Kasten77c11192012-01-25 14:27:41 -0800768 sp<Client> client = mClients.valueAt(i).promote();
769 if (client != 0) {
Atneya Nair9ec58d52022-10-03 15:46:20 -0700770 result.appendFormat("Client: %d\n", client->pid());
Atneya3c61d882021-09-20 14:52:15 -0400771 result.append(client->allocator().dump().c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700772 }
Atneya3c61d882021-09-20 14:52:15 -0400773 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700774
Eric Laurentd1b28d42013-09-18 18:47:13 -0700775 result.append("Notification Clients:\n");
Andy Hung5bdc5352019-12-23 14:36:31 -0800776 result.append(" pid uid name\n");
Eric Laurentd1b28d42013-09-18 18:47:13 -0700777 for (size_t i = 0; i < mNotificationClients.size(); ++i) {
Andy Hung5bdc5352019-12-23 14:36:31 -0800778 const pid_t pid = mNotificationClients[i]->getPid();
779 const uid_t uid = mNotificationClients[i]->getUid();
780 const mediautils::UidInfo::Info info = mUidInfo.getInfo(uid);
781 result.appendFormat("%6d %6u %s\n", pid, uid, info.package.c_str());
Eric Laurentd1b28d42013-09-18 18:47:13 -0700782 }
783
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700784 result.append("Global session refs:\n");
Andy Hung8b0bfd92019-12-23 13:11:11 -0800785 result.append(" session cnt pid uid name\n");
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700786 for (size_t i = 0; i < mAudioSessionRefs.size(); i++) {
787 AudioSessionRef *r = mAudioSessionRefs[i];
Andy Hung8b0bfd92019-12-23 13:11:11 -0800788 const mediautils::UidInfo::Info info = mUidInfo.getInfo(r->mUid);
789 result.appendFormat(" %7d %4d %7d %6u %s\n", r->mSessionid, r->mCnt, r->mPid,
790 r->mUid, info.package.c_str());
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700791 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700792 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700793}
794
795
Glenn Kasten0f11b512014-01-31 16:18:54 -0800796void AudioFlinger::dumpInternals(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700797{
798 const size_t SIZE = 256;
799 char buffer[SIZE];
800 String8 result;
Glenn Kastena4454b42012-01-04 11:02:33 -0800801 hardware_call_state hardwareStatus = mHardwareStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700802
John Grossman4ff14ba2012-02-08 16:37:41 -0800803 snprintf(buffer, SIZE, "Hardware status: %d\n"
804 "Standby Time mSec: %u\n",
805 hardwareStatus,
806 (uint32_t)(mStandbyTimeInNsecs / 1000000));
Mathias Agopian65ab4712010-07-14 17:59:35 -0700807 result.append(buffer);
808 write(fd, result.string(), result.size());
jiabinc47acf22022-04-01 23:47:52 +0000809
810 dprintf(fd, "Vibrator infos(size=%zu):\n", mAudioVibratorInfos.size());
811 for (const auto& vibratorInfo : mAudioVibratorInfos) {
812 dprintf(fd, " - %s\n", vibratorInfo.toString().c_str());
813 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700814}
815
Glenn Kasten0f11b512014-01-31 16:18:54 -0800816void AudioFlinger::dumpPermissionDenial(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700817{
818 const size_t SIZE = 256;
819 char buffer[SIZE];
820 String8 result;
821 snprintf(buffer, SIZE, "Permission Denial: "
822 "can't dump AudioFlinger from pid=%d, uid=%d\n",
823 IPCThreadState::self()->getCallingPid(),
824 IPCThreadState::self()->getCallingUid());
825 result.append(buffer);
826 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700827}
828
Eric Laurent81784c32012-11-19 14:55:58 -0800829bool AudioFlinger::dumpTryLock(Mutex& mutex)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700830{
Mikhail Naganov959e2d02019-03-28 11:08:19 -0700831 status_t err = mutex.timedLock(kDumpLockTimeoutNs);
832 return err == NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700833}
834
835status_t AudioFlinger::dump(int fd, const Vector<String16>& args)
836{
Glenn Kasten44deb052012-02-05 18:09:08 -0800837 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700838 dumpPermissionDenial(fd, args);
839 } else {
840 // get state of hardware lock
Eric Laurent81784c32012-11-19 14:55:58 -0800841 bool hardwareLocked = dumpTryLock(mHardwareLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700842 if (!hardwareLocked) {
843 String8 result(kHardwareLockedString);
844 write(fd, result.string(), result.size());
845 } else {
846 mHardwareLock.unlock();
847 }
848
Eric Tan7b651152018-07-13 10:17:19 -0700849 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700850
851 // failed to lock - AudioFlinger is probably deadlocked
852 if (!locked) {
853 String8 result(kDeadlockedString);
854 write(fd, result.string(), result.size());
855 }
856
Eric Laurent021cf962014-05-13 10:18:14 -0700857 bool clientLocked = dumpTryLock(mClientLock);
858 if (!clientLocked) {
859 String8 result(kClientLockedString);
860 write(fd, result.string(), result.size());
861 }
Marco Nelissend89eadd2014-10-07 13:28:44 -0700862
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700863 if (mEffectsFactoryHal != 0) {
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700864 mEffectsFactoryHal->dumpEffects(fd);
865 } else {
866 String8 result(kNoEffectsFactory);
867 write(fd, result.string(), result.size());
868 }
Marco Nelissend89eadd2014-10-07 13:28:44 -0700869
Mathias Agopian65ab4712010-07-14 17:59:35 -0700870 dumpClients(fd, args);
Eric Laurent021cf962014-05-13 10:18:14 -0700871 if (clientLocked) {
872 mClientLock.unlock();
873 }
874
Mathias Agopian65ab4712010-07-14 17:59:35 -0700875 dumpInternals(fd, args);
876
877 // dump playback threads
878 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
879 mPlaybackThreads.valueAt(i)->dump(fd, args);
880 }
881
882 // dump record threads
883 for (size_t i = 0; i < mRecordThreads.size(); i++) {
884 mRecordThreads.valueAt(i)->dump(fd, args);
885 }
886
Eric Laurent6acd1d42017-01-04 14:23:29 -0800887 // dump mmap threads
888 for (size_t i = 0; i < mMmapThreads.size(); i++) {
889 mMmapThreads.valueAt(i)->dump(fd, args);
890 }
891
Eric Laurentaaa44472014-09-12 17:41:50 -0700892 // dump orphan effect chains
893 if (mOrphanEffectChains.size() != 0) {
894 write(fd, " Orphan Effect Chains\n", strlen(" Orphan Effect Chains\n"));
895 for (size_t i = 0; i < mOrphanEffectChains.size(); i++) {
896 mOrphanEffectChains.valueAt(i)->dump(fd, args);
897 }
898 }
Dima Zavin799a70e2011-04-18 16:57:27 -0700899 // dump all hardware devs
900 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700901 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
Andy Hung61589a42021-06-16 09:37:53 -0700902 dev->dump(fd, args);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700903 }
Glenn Kastend06785b2012-09-30 12:29:28 -0700904
Mikhail Naganov201369b2018-05-16 16:52:32 -0700905 mPatchPanel.dump(fd);
906
Vlad Popa5161f8a2022-10-10 16:17:20 +0200907 mDeviceEffectManager->dump(fd);
Eric Laurentb82e6b72019-11-22 17:25:04 -0800908
Vlad Popab042ee62022-10-20 18:05:00 +0200909 std::string melOutput = mMelReporter->dump();
910 write(fd, melOutput.c_str(), melOutput.size());
911
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -0700912 // dump external setParameters
913 auto dumpLogger = [fd](SimpleLog& logger, const char* name) {
914 dprintf(fd, "\n%s setParameters:\n", name);
915 logger.dump(fd, " " /* prefix */);
916 };
917 dumpLogger(mRejectedSetParameterLog, "Rejected");
918 dumpLogger(mAppSetParameterLog, "App");
919 dumpLogger(mSystemSetParameterLog, "System");
920
Andy Hunga8115dc2018-08-24 15:51:59 -0700921 // dump historical threads in the last 10 seconds
922 const std::string threadLog = mThreadLog.dumpToString(
923 "Historical Thread Log ", 0 /* lines */,
924 audio_utils_get_real_time_ns() - 10 * 60 * NANOS_PER_SECOND);
925 write(fd, threadLog.c_str(), threadLog.size());
926
rago3bd1c872016-09-26 12:58:14 -0700927 BUFLOG_RESET;
928
Glenn Kastend65d73c2012-06-22 17:21:07 -0700929 if (locked) {
930 mLock.unlock();
931 }
Glenn Kasten9e58b552013-01-18 15:09:48 -0800932
Andy Hung8946a282018-04-19 20:04:56 -0700933#ifdef TEE_SINK
934 // NBAIO_Tee dump is safe to call outside of AF lock.
935 NBAIO_Tee::dumpAll(fd, "_DUMP");
936#endif
Glenn Kasten9e58b552013-01-18 15:09:48 -0800937 // append a copy of media.log here by forwarding fd to it, but don't attempt
938 // to lookup the service if it's not running, as it will block for a second
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700939 if (sMediaLogServiceAsBinder != 0) {
940 dprintf(fd, "\nmedia.log:\n");
941 Vector<String16> args;
942 sMediaLogServiceAsBinder->dump(fd, args);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800943 }
Andy Hung35fec5f2016-04-13 14:21:48 -0700944
945 // check for optional arguments
Andy Hung07b745e2016-05-23 16:21:07 -0700946 bool dumpMem = false;
Andy Hung35fec5f2016-04-13 14:21:48 -0700947 bool unreachableMemory = false;
948 for (const auto &arg : args) {
Andy Hung07b745e2016-05-23 16:21:07 -0700949 if (arg == String16("-m")) {
950 dumpMem = true;
951 } else if (arg == String16("--unreachable")) {
Andy Hung35fec5f2016-04-13 14:21:48 -0700952 unreachableMemory = true;
953 }
954 }
955
Andy Hung07b745e2016-05-23 16:21:07 -0700956 if (dumpMem) {
957 dprintf(fd, "\nDumping memory:\n");
958 std::string s = dumpMemoryAddresses(100 /* limit */);
959 write(fd, s.c_str(), s.size());
960 }
Andy Hung35fec5f2016-04-13 14:21:48 -0700961 if (unreachableMemory) {
962 dprintf(fd, "\nDumping unreachable memory:\n");
963 // TODO - should limit be an argument parameter?
Andy Hung07b745e2016-05-23 16:21:07 -0700964 std::string s = GetUnreachableMemoryString(true /* contents */, 100 /* limit */);
Andy Hung35fec5f2016-04-13 14:21:48 -0700965 write(fd, s.c_str(), s.size());
966 }
Andy Hungc747c532022-03-07 21:41:14 -0800967 {
968 std::string timeCheckStats = getIAudioFlingerStatistics().dump();
Andy Hung224f82f2022-03-22 00:00:49 -0700969 dprintf(fd, "\nIAudioFlinger binder call profile:\n");
Andy Hungc747c532022-03-07 21:41:14 -0800970 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
971
972 extern mediautils::MethodStatistics<int>& getIEffectStatistics();
973 timeCheckStats = getIEffectStatistics().dump();
Andy Hung224f82f2022-03-22 00:00:49 -0700974 dprintf(fd, "\nIEffect binder call profile:\n");
Andy Hungc747c532022-03-07 21:41:14 -0800975 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
Andy Hung224f82f2022-03-22 00:00:49 -0700976
977 // Automatically fetch HIDL statistics.
978 std::shared_ptr<std::vector<std::string>> hidlClassNames =
979 mediautils::getStatisticsClassesForModule(
980 METHOD_STATISTICS_MODULE_NAME_AUDIO_HIDL);
981 if (hidlClassNames) {
982 for (const auto& className : *hidlClassNames) {
983 auto stats = mediautils::getStatisticsForClass(className);
984 if (stats) {
985 timeCheckStats = stats->dump();
986 dprintf(fd, "\n%s binder call profile:\n", className.c_str());
987 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
988 }
989 }
990 }
991
992 timeCheckStats = mediautils::TimeCheck::toString();
993 dprintf(fd, "\nTimeCheck:\n");
994 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
995 dprintf(fd, "\n");
Andy Hungc747c532022-03-07 21:41:14 -0800996 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700997 }
998 return NO_ERROR;
999}
1000
Eric Laurent021cf962014-05-13 10:18:14 -07001001sp<AudioFlinger::Client> AudioFlinger::registerPid(pid_t pid)
Glenn Kasten98ec94c2012-01-25 14:28:29 -08001002{
Eric Laurent021cf962014-05-13 10:18:14 -07001003 Mutex::Autolock _cl(mClientLock);
Glenn Kasten98ec94c2012-01-25 14:28:29 -08001004 // If pid is already in the mClients wp<> map, then use that entry
1005 // (for which promote() is always != 0), otherwise create a new entry and Client.
1006 sp<Client> client = mClients.valueFor(pid).promote();
1007 if (client == 0) {
1008 client = new Client(this, pid);
1009 mClients.add(pid, client);
1010 }
1011
1012 return client;
1013}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001014
Glenn Kasten9e58b552013-01-18 15:09:48 -08001015sp<NBLog::Writer> AudioFlinger::newWriter_l(size_t size, const char *name)
1016{
Jiabin Huang60766082020-07-28 22:03:56 +00001017 // If there is no memory allocated for logs, return a no-op writer that does nothing.
1018 // Similarly if we can't contact the media.log service, also return a no-op writer.
Glenn Kasten04b96fc2017-04-10 14:58:47 -07001019 if (mLogMemoryDealer == 0 || sMediaLogService == 0) {
Glenn Kasten9e58b552013-01-18 15:09:48 -08001020 return new NBLog::Writer();
1021 }
Glenn Kasten481fb672013-09-30 14:39:28 -07001022 sp<IMemory> shared = mLogMemoryDealer->allocate(NBLog::Timeline::sharedSize(size));
1023 // If allocation fails, consult the vector of previously unregistered writers
1024 // and garbage-collect one or more them until an allocation succeeds
1025 if (shared == 0) {
1026 Mutex::Autolock _l(mUnregisteredWritersLock);
1027 for (size_t count = mUnregisteredWriters.size(); count > 0; count--) {
1028 {
1029 // Pick the oldest stale writer to garbage-collect
1030 sp<IMemory> iMemory(mUnregisteredWriters[0]->getIMemory());
1031 mUnregisteredWriters.removeAt(0);
Glenn Kasten04b96fc2017-04-10 14:58:47 -07001032 sMediaLogService->unregisterWriter(iMemory);
Glenn Kasten481fb672013-09-30 14:39:28 -07001033 // Now the media.log remote reference to IMemory is gone. When our last local
1034 // reference to IMemory also drops to zero at end of this block,
1035 // the IMemory destructor will deallocate the region from mLogMemoryDealer.
1036 }
1037 // Re-attempt the allocation
1038 shared = mLogMemoryDealer->allocate(NBLog::Timeline::sharedSize(size));
1039 if (shared != 0) {
1040 goto success;
1041 }
1042 }
1043 // Even after garbage-collecting all old writers, there is still not enough memory,
Jiabin Huang60766082020-07-28 22:03:56 +00001044 // so return a no-op writer
Glenn Kasten481fb672013-09-30 14:39:28 -07001045 return new NBLog::Writer();
1046 }
1047success:
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07001048 NBLog::Shared *sharedRawPtr = (NBLog::Shared *) shared->unsecurePointer();
Glenn Kasten535e1612016-12-05 12:19:36 -08001049 new((void *) sharedRawPtr) NBLog::Shared(); // placement new here, but the corresponding
1050 // explicit destructor not needed since it is POD
Glenn Kasten04b96fc2017-04-10 14:58:47 -07001051 sMediaLogService->registerWriter(shared, size, name);
Glenn Kasten535e1612016-12-05 12:19:36 -08001052 return new NBLog::Writer(shared, size);
Glenn Kasten9e58b552013-01-18 15:09:48 -08001053}
1054
1055void AudioFlinger::unregisterWriter(const sp<NBLog::Writer>& writer)
1056{
Glenn Kasten685ef092013-02-04 08:15:34 -08001057 if (writer == 0) {
1058 return;
1059 }
Glenn Kasten9e58b552013-01-18 15:09:48 -08001060 sp<IMemory> iMemory(writer->getIMemory());
1061 if (iMemory == 0) {
1062 return;
1063 }
Glenn Kasten481fb672013-09-30 14:39:28 -07001064 // Rather than removing the writer immediately, append it to a queue of old writers to
1065 // be garbage-collected later. This allows us to continue to view old logs for a while.
1066 Mutex::Autolock _l(mUnregisteredWritersLock);
1067 mUnregisteredWriters.push(writer);
Glenn Kasten9e58b552013-01-18 15:09:48 -08001068}
1069
Mathias Agopian65ab4712010-07-14 17:59:35 -07001070// IAudioFlinger interface
1071
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08001072status_t AudioFlinger::createTrack(const media::CreateTrackRequest& _input,
1073 media::CreateTrackResponse& _output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001074{
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001075 // Local version of VALUE_OR_RETURN, specific to this method's calling conventions.
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08001076 CreateTrackInput input = VALUE_OR_RETURN_STATUS(CreateTrackInput::fromAidl(_input));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001077 CreateTrackOutput output;
1078
Mathias Agopian65ab4712010-07-14 17:59:35 -07001079 sp<PlaybackThread::Track> track;
1080 sp<TrackHandle> trackHandle;
1081 sp<Client> client;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001082 status_t lStatus;
Eric Laurent21da6472017-11-09 16:29:26 -08001083 audio_stream_type_t streamType;
Eric Laurent77881cd2018-02-09 16:01:31 -08001084 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
Kevin Rocard153f92d2018-12-18 18:33:28 -08001085 std::vector<audio_io_handle_t> secondaryOutputs;
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001086 bool isSpatialized = false;;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001087
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001088 // TODO b/182392553: refactor or make clearer
1089 pid_t clientPid =
Svet Ganov33761132021-05-13 22:51:08 +00001090 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(input.clientInfo.attributionSource.pid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001091 bool updatePid = (clientPid == (pid_t)-1);
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07001092 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001093 uid_t clientUid =
Svet Ganov33761132021-05-13 22:51:08 +00001094 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_uid_t(input.clientInfo.attributionSource.uid));
Eric Laurent6c796322019-04-09 14:13:17 -07001095 audio_io_handle_t effectThreadId = AUDIO_IO_HANDLE_NONE;
1096 std::vector<int> effectIds;
Eric Laurent42984412019-05-09 17:57:03 -07001097 audio_attributes_t localAttr = input.attr;
Eric Laurent6c796322019-04-09 14:13:17 -07001098
Svet Ganov33761132021-05-13 22:51:08 +00001099 AttributionSourceState adjAttributionSource = input.clientInfo.attributionSource;
Eric Laurent9ff3e532022-11-10 16:04:44 +01001100 if (!isAudioServerOrMediaServerOrSystemServerOrRootUid(callingUid)) {
Eric Laurent21da6472017-11-09 16:29:26 -08001101 ALOGW_IF(clientUid != callingUid,
1102 "%s uid %d tried to pass itself off as %d",
1103 __FUNCTION__, callingUid, clientUid);
Svet Ganov33761132021-05-13 22:51:08 +00001104 adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
Eric Laurent21da6472017-11-09 16:29:26 -08001105 clientUid = callingUid;
1106 updatePid = true;
1107 }
Eric Laurent09f1ed22019-04-24 17:45:17 -07001108 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Eric Laurent21da6472017-11-09 16:29:26 -08001109 if (updatePid) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001110 ALOGW_IF(clientPid != (pid_t)-1 && clientPid != callingPid,
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07001111 "%s uid %d pid %d tried to pass itself off as pid %d",
Eric Laurent21da6472017-11-09 16:29:26 -08001112 __func__, callingUid, callingPid, clientPid);
1113 clientPid = callingPid;
Svet Ganov33761132021-05-13 22:51:08 +00001114 adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07001115 }
Eric Laurent9ff3e532022-11-10 16:04:44 +01001116 adjAttributionSource = AudioFlinger::checkAttributionSourcePackage(
1117 adjAttributionSource);
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07001118
Eric Laurent21da6472017-11-09 16:29:26 -08001119 audio_session_t sessionId = input.sessionId;
1120 if (sessionId == AUDIO_SESSION_ALLOCATE) {
1121 sessionId = (audio_session_t) newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
Eric Laurentf14db3c2017-12-08 14:20:36 -08001122 } else if (audio_unique_id_get_use(sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) {
1123 lStatus = BAD_VALUE;
1124 goto Exit;
Eric Laurent21da6472017-11-09 16:29:26 -08001125 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08001126
Eric Laurent21da6472017-11-09 16:29:26 -08001127 output.sessionId = sessionId;
1128 output.outputId = AUDIO_IO_HANDLE_NONE;
1129 output.selectedDeviceId = input.selectedDeviceId;
Eric Laurent42984412019-05-09 17:57:03 -07001130 lStatus = AudioSystem::getOutputForAttr(&localAttr, &output.outputId, sessionId, &streamType,
Svet Ganov33761132021-05-13 22:51:08 +00001131 adjAttributionSource, &input.config, input.flags,
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001132 &output.selectedDeviceId, &portId, &secondaryOutputs,
1133 &isSpatialized);
Eric Laurent21da6472017-11-09 16:29:26 -08001134
1135 if (lStatus != NO_ERROR || output.outputId == AUDIO_IO_HANDLE_NONE) {
1136 ALOGE("createTrack() getOutputForAttr() return error %d or invalid output handle", lStatus);
1137 goto Exit;
1138 }
Glenn Kasten263709e2012-01-06 08:40:01 -08001139 // client AudioTrack::set already implements AUDIO_STREAM_DEFAULT => AUDIO_STREAM_MUSIC,
1140 // but if someone uses binder directly they could bypass that and cause us to crash
1141 if (uint32_t(streamType) >= AUDIO_STREAM_CNT) {
Steve Block29357bc2012-01-06 19:20:56 +00001142 ALOGE("createTrack() invalid stream type %d", streamType);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001143 lStatus = BAD_VALUE;
1144 goto Exit;
1145 }
1146
Glenn Kasten53b5d092014-02-05 10:00:23 -08001147 // further channel mask checks are performed by createTrack_l() depending on the thread type
Eric Laurent21da6472017-11-09 16:29:26 -08001148 if (!audio_is_output_channel(input.config.channel_mask)) {
1149 ALOGE("createTrack() invalid channel mask %#x", input.config.channel_mask);
Glenn Kasten53b5d092014-02-05 10:00:23 -08001150 lStatus = BAD_VALUE;
1151 goto Exit;
1152 }
1153
Glenn Kastenc4b88a82014-04-30 16:54:30 -07001154 // further format checks are performed by createTrack_l() depending on the thread type
Eric Laurent21da6472017-11-09 16:29:26 -08001155 if (!audio_is_valid_format(input.config.format)) {
1156 ALOGE("createTrack() invalid format %#x", input.config.format);
Glenn Kasten663c2242013-09-24 11:52:37 -07001157 lStatus = BAD_VALUE;
1158 goto Exit;
1159 }
1160
Mathias Agopian65ab4712010-07-14 17:59:35 -07001161 {
1162 Mutex::Autolock _l(mLock);
Eric Laurent21da6472017-11-09 16:29:26 -08001163 PlaybackThread *thread = checkPlaybackThread_l(output.outputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001164 if (thread == NULL) {
Eric Laurent21da6472017-11-09 16:29:26 -08001165 ALOGE("no playback thread found for output handle %d", output.outputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001166 lStatus = BAD_VALUE;
1167 goto Exit;
1168 }
1169
Eric Laurent21da6472017-11-09 16:29:26 -08001170 client = registerPid(clientPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001171
Glenn Kastene848bd92014-03-13 15:00:32 -07001172 PlaybackThread *effectThread = NULL;
Eric Laurent21da6472017-11-09 16:29:26 -08001173 // check if an effect chain with the same session ID is present on another
1174 // output thread and move it here.
1175 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1176 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
1177 if (mPlaybackThreads.keyAt(i) != output.outputId) {
1178 uint32_t sessions = t->hasAudioSession(sessionId);
1179 if (sessions & ThreadBase::EFFECT_SESSION) {
1180 effectThread = t.get();
1181 break;
Eric Laurentde070132010-07-13 04:45:46 -07001182 }
1183 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001184 }
Eric Laurent21da6472017-11-09 16:29:26 -08001185 ALOGV("createTrack() sessionId: %d", sessionId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001186
Eric Laurent21da6472017-11-09 16:29:26 -08001187 output.sampleRate = input.config.sample_rate;
1188 output.frameCount = input.frameCount;
1189 output.notificationFrameCount = input.notificationFrameCount;
1190 output.flags = input.flags;
Andy Hunga2159aa2021-07-20 13:01:52 -07001191 output.streamType = streamType;
Eric Laurent21da6472017-11-09 16:29:26 -08001192
Eric Laurent42984412019-05-09 17:57:03 -07001193 track = thread->createTrack_l(client, streamType, localAttr, &output.sampleRate,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001194 input.config.format, input.config.channel_mask,
Eric Laurent21da6472017-11-09 16:29:26 -08001195 &output.frameCount, &output.notificationFrameCount,
1196 input.notificationsPerBuffer, input.speed,
1197 input.sharedBuffer, sessionId, &output.flags,
Svet Ganov33761132021-05-13 22:51:08 +00001198 callingPid, adjAttributionSource, input.clientInfo.clientTid,
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001199 &lStatus, portId, input.audioTrackCallback, isSpatialized);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08001200 LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (track == 0));
Glenn Kasten2fc14732013-08-05 14:58:14 -07001201 // we don't abort yet if lStatus != NO_ERROR; there is still work to be done regardless
Eric Laurent39e94f82010-07-28 01:32:47 -07001202
Eric Laurent21da6472017-11-09 16:29:26 -08001203 output.afFrameCount = thread->frameCount();
1204 output.afSampleRate = thread->sampleRate();
Robert Wu310037a2022-09-06 21:48:18 +00001205 output.afChannelMask = static_cast<audio_channel_mask_t>(thread->channelMask() |
1206 thread->hapticChannelMask());
1207 output.afFormat = thread->format();
Eric Laurent21da6472017-11-09 16:29:26 -08001208 output.afLatencyMs = thread->latency();
Eric Laurent973db022018-11-20 14:54:31 -08001209 output.portId = portId;
Eric Laurent21da6472017-11-09 16:29:26 -08001210
Kevin Rocard153f92d2018-12-18 18:33:28 -08001211 if (lStatus == NO_ERROR) {
1212 // Connect secondary outputs. Failure on a secondary output must not imped the primary
1213 // Any secondary output setup failure will lead to a desync between the AP and AF until
1214 // the track is destroyed.
jiabinf042b9b2021-05-07 23:46:28 +00001215 updateSecondaryOutputsForTrack_l(track.get(), thread, secondaryOutputs);
Kevin Rocard153f92d2018-12-18 18:33:28 -08001216 }
1217
Eric Laurent39e94f82010-07-28 01:32:47 -07001218 // move effect chain to this output thread if an effect on same session was waiting
1219 // for a track to be created
1220 if (lStatus == NO_ERROR && effectThread != NULL) {
Glenn Kasten2fc14732013-08-05 14:58:14 -07001221 // no risk of deadlock because AudioFlinger::mLock is held
Eric Laurent39e94f82010-07-28 01:32:47 -07001222 Mutex::Autolock _dl(thread->mLock);
1223 Mutex::Autolock _sl(effectThread->mLock);
Eric Laurent6c796322019-04-09 14:13:17 -07001224 if (moveEffectChain_l(sessionId, effectThread, thread) == NO_ERROR) {
1225 effectThreadId = thread->id();
1226 effectIds = thread->getEffectIds_l(sessionId);
1227 }
Eric Laurent39e94f82010-07-28 01:32:47 -07001228 }
Eric Laurenta011e352012-03-29 15:51:43 -07001229
1230 // Look for sync events awaiting for a session to be used.
Mark Salyzyn3ab368e2014-04-15 14:55:53 -07001231 for (size_t i = 0; i < mPendingSyncEvents.size(); i++) {
Eric Laurent21da6472017-11-09 16:29:26 -08001232 if (mPendingSyncEvents[i]->triggerSession() == sessionId) {
Eric Laurenta011e352012-03-29 15:51:43 -07001233 if (thread->isValidSyncEvent(mPendingSyncEvents[i])) {
Eric Laurent29864602012-05-08 18:57:51 -07001234 if (lStatus == NO_ERROR) {
Glenn Kastend23eedc2012-08-02 13:35:47 -07001235 (void) track->setSyncEvent(mPendingSyncEvents[i]);
Eric Laurent29864602012-05-08 18:57:51 -07001236 } else {
1237 mPendingSyncEvents[i]->cancel();
1238 }
Eric Laurenta011e352012-03-29 15:51:43 -07001239 mPendingSyncEvents.removeAt(i);
1240 i--;
1241 }
1242 }
1243 }
Andy Hung6eff0ff2021-07-30 19:01:48 -07001244 if ((output.flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) == AUDIO_OUTPUT_FLAG_HW_AV_SYNC) {
1245 setAudioHwSyncForSession_l(thread, sessionId);
1246 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001247 }
Glenn Kastene198c362013-08-13 09:13:36 -07001248
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07001249 if (lStatus != NO_ERROR) {
1250 // remove local strong reference to Client before deleting the Track so that the
Eric Laurent021cf962014-05-13 10:18:14 -07001251 // Client destructor is called by the TrackBase destructor with mClientLock held
Eric Laurentfe1a94e2014-05-26 16:03:08 -07001252 // Don't hold mClientLock when releasing the reference on the track as the
1253 // destructor will acquire it.
1254 {
1255 Mutex::Autolock _cl(mClientLock);
1256 client.clear();
1257 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001258 track.clear();
Glenn Kasten3ef14ef2014-03-13 15:08:51 -07001259 goto Exit;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001260 }
1261
Eric Laurent6c796322019-04-09 14:13:17 -07001262 // effectThreadId is not NONE if an effect chain corresponding to the track session
1263 // was found on another thread and must be moved on this thread
1264 if (effectThreadId != AUDIO_IO_HANDLE_NONE) {
1265 AudioSystem::moveEffectsToIo(effectIds, effectThreadId);
1266 }
1267
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08001268 output.audioTrack = new TrackHandle(track);
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001269 _output = VALUE_OR_FATAL(output.toAidl());
1270
Mathias Agopian65ab4712010-07-14 17:59:35 -07001271Exit:
Eric Laurent21da6472017-11-09 16:29:26 -08001272 if (lStatus != NO_ERROR && output.outputId != AUDIO_IO_HANDLE_NONE) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07001273 AudioSystem::releaseOutput(portId);
Eric Laurent21da6472017-11-09 16:29:26 -08001274 }
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08001275 return lStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001276}
1277
Glenn Kasten2c073da2016-02-26 09:14:08 -08001278uint32_t AudioFlinger::sampleRate(audio_io_handle_t ioHandle) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001279{
1280 Mutex::Autolock _l(mLock);
Glenn Kasten2c073da2016-02-26 09:14:08 -08001281 ThreadBase *thread = checkThread_l(ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001282 if (thread == NULL) {
Glenn Kasten2c073da2016-02-26 09:14:08 -08001283 ALOGW("sampleRate() unknown thread %d", ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001284 return 0;
1285 }
1286 return thread->sampleRate();
1287}
1288
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001289audio_format_t AudioFlinger::format(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001290{
1291 Mutex::Autolock _l(mLock);
1292 PlaybackThread *thread = checkPlaybackThread_l(output);
1293 if (thread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +00001294 ALOGW("format() unknown thread %d", output);
Glenn Kasten58f30212012-01-12 12:27:51 -08001295 return AUDIO_FORMAT_INVALID;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001296 }
1297 return thread->format();
1298}
1299
Glenn Kasten2c073da2016-02-26 09:14:08 -08001300size_t AudioFlinger::frameCount(audio_io_handle_t ioHandle) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001301{
1302 Mutex::Autolock _l(mLock);
Glenn Kasten2c073da2016-02-26 09:14:08 -08001303 ThreadBase *thread = checkThread_l(ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001304 if (thread == NULL) {
Glenn Kasten2c073da2016-02-26 09:14:08 -08001305 ALOGW("frameCount() unknown thread %d", ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001306 return 0;
1307 }
Glenn Kasten58912562012-04-03 10:45:00 -07001308 // FIXME currently returns the normal mixer's frame count to avoid confusing legacy callers;
1309 // should examine all callers and fix them to handle smaller counts
Mathias Agopian65ab4712010-07-14 17:59:35 -07001310 return thread->frameCount();
1311}
1312
Glenn Kasten4a8308b2016-04-18 14:10:01 -07001313size_t AudioFlinger::frameCountHAL(audio_io_handle_t ioHandle) const
1314{
1315 Mutex::Autolock _l(mLock);
1316 ThreadBase *thread = checkThread_l(ioHandle);
1317 if (thread == NULL) {
1318 ALOGW("frameCountHAL() unknown thread %d", ioHandle);
1319 return 0;
1320 }
1321 return thread->frameCountHAL();
1322}
1323
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001324uint32_t AudioFlinger::latency(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001325{
1326 Mutex::Autolock _l(mLock);
1327 PlaybackThread *thread = checkPlaybackThread_l(output);
1328 if (thread == NULL) {
Glenn Kastenc9b2e202013-02-26 11:32:32 -08001329 ALOGW("latency(): no playback thread found for output handle %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001330 return 0;
1331 }
1332 return thread->latency();
1333}
1334
1335status_t AudioFlinger::setMasterVolume(float value)
1336{
Eric Laurenta1884f92011-08-23 08:25:03 -07001337 status_t ret = initCheck();
1338 if (ret != NO_ERROR) {
1339 return ret;
1340 }
1341
Mathias Agopian65ab4712010-07-14 17:59:35 -07001342 // check calling permissions
1343 if (!settingsAllowed()) {
1344 return PERMISSION_DENIED;
1345 }
1346
Eric Laurenta4c5a552012-03-29 10:12:40 -07001347 Mutex::Autolock _l(mLock);
John Grossmanee578c02012-07-23 17:05:46 -07001348 mMasterVolume = value;
Eric Laurenta4c5a552012-03-29 10:12:40 -07001349
John Grossmanee578c02012-07-23 17:05:46 -07001350 // Set master volume in the HALs which support it.
Eric Laurent00abf0d2020-04-22 19:28:22 -07001351 {
John Grossmanee578c02012-07-23 17:05:46 -07001352 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07001353 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
1354 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
John Grossman4ff14ba2012-02-08 16:37:41 -08001355
Eric Laurent00abf0d2020-04-22 19:28:22 -07001356 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
1357 if (dev->canSetMasterVolume()) {
1358 dev->hwDevice()->setMasterVolume(value);
1359 }
1360 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent93575202011-01-18 18:39:02 -08001361 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001362 }
John Grossmanee578c02012-07-23 17:05:46 -07001363 // Now set the master volume in each playback thread. Playback threads
1364 // assigned to HALs which do not have master volume support will apply
1365 // master volume during the mix operation. Threads with HALs which do
1366 // support master volume will simply ignore the setting.
Eric Laurentf6870ae2015-05-08 10:50:03 -07001367 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1368 if (mPlaybackThreads.valueAt(i)->isDuplicating()) {
1369 continue;
1370 }
John Grossmanee578c02012-07-23 17:05:46 -07001371 mPlaybackThreads.valueAt(i)->setMasterVolume(value);
Eric Laurentf6870ae2015-05-08 10:50:03 -07001372 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001373
1374 return NO_ERROR;
1375}
1376
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001377status_t AudioFlinger::setMasterBalance(float balance)
1378{
1379 status_t ret = initCheck();
1380 if (ret != NO_ERROR) {
1381 return ret;
1382 }
1383
1384 // check calling permissions
1385 if (!settingsAllowed()) {
1386 return PERMISSION_DENIED;
1387 }
1388
1389 // check range
1390 if (isnan(balance) || fabs(balance) > 1.f) {
1391 return BAD_VALUE;
1392 }
1393
1394 Mutex::Autolock _l(mLock);
1395
1396 // short cut.
1397 if (mMasterBalance == balance) return NO_ERROR;
1398
1399 mMasterBalance = balance;
1400
1401 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1402 if (mPlaybackThreads.valueAt(i)->isDuplicating()) {
1403 continue;
1404 }
1405 mPlaybackThreads.valueAt(i)->setMasterBalance(balance);
1406 }
1407
1408 return NO_ERROR;
1409}
1410
Glenn Kastenf78aee72012-01-04 11:00:47 -08001411status_t AudioFlinger::setMode(audio_mode_t mode)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001412{
Eric Laurenta1884f92011-08-23 08:25:03 -07001413 status_t ret = initCheck();
1414 if (ret != NO_ERROR) {
1415 return ret;
1416 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001417
1418 // check calling permissions
1419 if (!settingsAllowed()) {
1420 return PERMISSION_DENIED;
1421 }
Glenn Kasten930f4ca2012-01-06 16:47:31 -08001422 if (uint32_t(mode) >= AUDIO_MODE_CNT) {
Steve Block5ff1dd52012-01-05 23:22:43 +00001423 ALOGW("Illegal value: setMode(%d)", mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001424 return BAD_VALUE;
1425 }
1426
1427 { // scope for the lock
1428 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07001429 if (mPrimaryHardwareDev == nullptr) {
1430 return INVALID_OPERATION;
1431 }
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001432 sp<DeviceHalInterface> dev = mPrimaryHardwareDev->hwDevice();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001433 mHardwareStatus = AUDIO_HW_SET_MODE;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001434 ret = dev->setMode(mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001435 mHardwareStatus = AUDIO_HW_IDLE;
1436 }
1437
1438 if (NO_ERROR == ret) {
1439 Mutex::Autolock _l(mLock);
1440 mMode = mode;
Glenn Kasten8d6a2442012-02-08 14:04:28 -08001441 for (size_t i = 0; i < mPlaybackThreads.size(); i++)
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001442 mPlaybackThreads.valueAt(i)->setMode(mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001443 }
1444
Joey Poomarin52989982020-03-05 17:40:49 +08001445 mediametrics::LogItem(mMetricsId)
1446 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETMODE)
1447 .set(AMEDIAMETRICS_PROP_AUDIOMODE, toString(mode))
1448 .record();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001449 return ret;
1450}
1451
1452status_t AudioFlinger::setMicMute(bool state)
1453{
Eric Laurenta1884f92011-08-23 08:25:03 -07001454 status_t ret = initCheck();
1455 if (ret != NO_ERROR) {
1456 return ret;
1457 }
1458
Mathias Agopian65ab4712010-07-14 17:59:35 -07001459 // check calling permissions
1460 if (!settingsAllowed()) {
1461 return PERMISSION_DENIED;
1462 }
1463
1464 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07001465 if (mPrimaryHardwareDev == nullptr) {
1466 return INVALID_OPERATION;
1467 }
Eric Laurent2325bf02020-04-08 19:38:13 -07001468 sp<DeviceHalInterface> primaryDev = mPrimaryHardwareDev->hwDevice();
1469 if (primaryDev == nullptr) {
1470 ALOGW("%s: no primary HAL device", __func__);
1471 return INVALID_OPERATION;
1472 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001473 mHardwareStatus = AUDIO_HW_SET_MIC_MUTE;
Eric Laurent2325bf02020-04-08 19:38:13 -07001474 ret = primaryDev->setMicMute(state);
Eric Laurent2f035f52014-09-14 12:11:52 -07001475 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001476 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
Eric Laurent2325bf02020-04-08 19:38:13 -07001477 if (dev != primaryDev) {
1478 (void)dev->setMicMute(state);
Eric Laurent2f035f52014-09-14 12:11:52 -07001479 }
1480 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001481 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent2325bf02020-04-08 19:38:13 -07001482 ALOGW_IF(ret != NO_ERROR, "%s: error %d setting state to HAL", __func__, ret);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001483 return ret;
1484}
1485
1486bool AudioFlinger::getMicMute() const
1487{
Eric Laurenta1884f92011-08-23 08:25:03 -07001488 status_t ret = initCheck();
1489 if (ret != NO_ERROR) {
1490 return false;
1491 }
Glenn Kasten2b213bc2012-02-02 14:05:20 -08001492 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07001493 if (mPrimaryHardwareDev == nullptr) {
1494 return false;
1495 }
Eric Laurent2325bf02020-04-08 19:38:13 -07001496 sp<DeviceHalInterface> primaryDev = mPrimaryHardwareDev->hwDevice();
1497 if (primaryDev == nullptr) {
1498 ALOGW("%s: no primary HAL device", __func__);
1499 return false;
Ricardo Garcia3e91b5d2015-02-19 10:54:52 -08001500 }
Eric Laurent2325bf02020-04-08 19:38:13 -07001501 bool state;
1502 mHardwareStatus = AUDIO_HW_GET_MIC_MUTE;
1503 ret = primaryDev->getMicMute(&state);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001504 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent2325bf02020-04-08 19:38:13 -07001505 ALOGE_IF(ret != NO_ERROR, "%s: error %d getting state from HAL", __func__, ret);
1506 return (ret == NO_ERROR) && state;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001507}
1508
Eric Laurent5ada82e2019-08-29 17:53:54 -07001509void AudioFlinger::setRecordSilenced(audio_port_handle_t portId, bool silenced)
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001510{
Eric Laurent5ada82e2019-08-29 17:53:54 -07001511 ALOGV("AudioFlinger::setRecordSilenced(portId:%d, silenced:%d)", portId, silenced);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001512
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001513 AutoMutex lock(mLock);
1514 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Eric Laurent5ada82e2019-08-29 17:53:54 -07001515 mRecordThreads[i]->setRecordSilenced(portId, silenced);
Eric Laurent331679c2018-04-16 17:03:16 -07001516 }
1517 for (size_t i = 0; i < mMmapThreads.size(); i++) {
Eric Laurent5ada82e2019-08-29 17:53:54 -07001518 mMmapThreads[i]->setRecordSilenced(portId, silenced);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001519 }
1520}
1521
Mathias Agopian65ab4712010-07-14 17:59:35 -07001522status_t AudioFlinger::setMasterMute(bool muted)
1523{
John Grossmand8f178d2012-07-20 14:51:35 -07001524 status_t ret = initCheck();
1525 if (ret != NO_ERROR) {
1526 return ret;
1527 }
1528
Mathias Agopian65ab4712010-07-14 17:59:35 -07001529 // check calling permissions
1530 if (!settingsAllowed()) {
1531 return PERMISSION_DENIED;
1532 }
1533
John Grossmanee578c02012-07-23 17:05:46 -07001534 Mutex::Autolock _l(mLock);
1535 mMasterMute = muted;
John Grossmand8f178d2012-07-20 14:51:35 -07001536
John Grossmanee578c02012-07-23 17:05:46 -07001537 // Set master mute in the HALs which support it.
Eric Laurent00abf0d2020-04-22 19:28:22 -07001538 {
John Grossmanee578c02012-07-23 17:05:46 -07001539 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07001540 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
1541 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
John Grossmand8f178d2012-07-20 14:51:35 -07001542
Eric Laurent00abf0d2020-04-22 19:28:22 -07001543 mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE;
1544 if (dev->canSetMasterMute()) {
1545 dev->hwDevice()->setMasterMute(muted);
1546 }
1547 mHardwareStatus = AUDIO_HW_IDLE;
John Grossmand8f178d2012-07-20 14:51:35 -07001548 }
John Grossmand8f178d2012-07-20 14:51:35 -07001549 }
1550
John Grossmanee578c02012-07-23 17:05:46 -07001551 // Now set the master mute in each playback thread. Playback threads
Glenn Kastena2f59b32020-08-03 16:37:24 -07001552 // assigned to HALs which do not have master mute support will apply master mute
1553 // during the mix operation. Threads with HALs which do support master mute
1554 // will simply ignore the setting.
Eric Laurent6acd1d42017-01-04 14:23:29 -08001555 Vector<VolumeInterface *> volumeInterfaces = getAllVolumeInterfaces_l();
1556 for (size_t i = 0; i < volumeInterfaces.size(); i++) {
1557 volumeInterfaces[i]->setMasterMute(muted);
Eric Laurentf6870ae2015-05-08 10:50:03 -07001558 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001559
1560 return NO_ERROR;
1561}
1562
1563float AudioFlinger::masterVolume() const
1564{
Glenn Kasten98067102011-12-13 11:47:54 -08001565 Mutex::Autolock _l(mLock);
1566 return masterVolume_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001567}
1568
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001569status_t AudioFlinger::getMasterBalance(float *balance) const
1570{
1571 Mutex::Autolock _l(mLock);
1572 *balance = getMasterBalance_l();
1573 return NO_ERROR; // if called through binder, may return a transactional error
1574}
1575
Mathias Agopian65ab4712010-07-14 17:59:35 -07001576bool AudioFlinger::masterMute() const
1577{
Glenn Kasten98067102011-12-13 11:47:54 -08001578 Mutex::Autolock _l(mLock);
1579 return masterMute_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001580}
1581
John Grossman4ff14ba2012-02-08 16:37:41 -08001582float AudioFlinger::masterVolume_l() const
1583{
John Grossman4ff14ba2012-02-08 16:37:41 -08001584 return mMasterVolume;
1585}
1586
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001587float AudioFlinger::getMasterBalance_l() const
1588{
1589 return mMasterBalance;
1590}
1591
John Grossmand8f178d2012-07-20 14:51:35 -07001592bool AudioFlinger::masterMute_l() const
1593{
John Grossmanee578c02012-07-23 17:05:46 -07001594 return mMasterMute;
John Grossmand8f178d2012-07-20 14:51:35 -07001595}
1596
Eric Laurent223fd5c2014-11-11 13:43:36 -08001597status_t AudioFlinger::checkStreamType(audio_stream_type_t stream) const
1598{
1599 if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08001600 ALOGW("checkStreamType() invalid stream %d", stream);
Eric Laurent223fd5c2014-11-11 13:43:36 -08001601 return BAD_VALUE;
1602 }
Andy Hung4ef19fa2018-05-15 19:35:29 -07001603 const uid_t callerUid = IPCThreadState::self()->getCallingUid();
1604 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT && !isAudioServerUid(callerUid)) {
1605 ALOGW("checkStreamType() uid %d cannot use internal stream type %d", callerUid, stream);
Eric Laurent223fd5c2014-11-11 13:43:36 -08001606 return PERMISSION_DENIED;
1607 }
1608
1609 return NO_ERROR;
1610}
1611
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001612status_t AudioFlinger::setStreamVolume(audio_stream_type_t stream, float value,
1613 audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001614{
1615 // check calling permissions
1616 if (!settingsAllowed()) {
1617 return PERMISSION_DENIED;
1618 }
1619
Eric Laurent223fd5c2014-11-11 13:43:36 -08001620 status_t status = checkStreamType(stream);
1621 if (status != NO_ERROR) {
1622 return status;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001623 }
Eric Laurent98e38192018-02-15 18:31:53 -08001624 if (output == AUDIO_IO_HANDLE_NONE) {
1625 return BAD_VALUE;
1626 }
François Gaffie9e1533c2019-04-11 16:07:36 +02001627 LOG_ALWAYS_FATAL_IF(stream == AUDIO_STREAM_PATCH && value != 1.0f,
1628 "AUDIO_STREAM_PATCH must have full scale volume");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001629
1630 AutoMutex lock(mLock);
Eric Laurent98e38192018-02-15 18:31:53 -08001631 VolumeInterface *volumeInterface = getVolumeInterface_l(output);
1632 if (volumeInterface == NULL) {
1633 return BAD_VALUE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001634 }
Eric Laurent98e38192018-02-15 18:31:53 -08001635 volumeInterface->setStreamVolume(stream, value);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001636
1637 return NO_ERROR;
1638}
1639
Eric Laurent076e7c72022-05-03 18:12:28 +02001640status_t AudioFlinger::setRequestedLatencyMode(
Eric Laurent68a40a82022-05-03 18:15:04 +02001641 audio_io_handle_t output, audio_latency_mode_t mode) {
Eric Laurent076e7c72022-05-03 18:12:28 +02001642 if (output == AUDIO_IO_HANDLE_NONE) {
1643 return BAD_VALUE;
1644 }
Eric Laurent68a40a82022-05-03 18:15:04 +02001645 AutoMutex lock(mLock);
1646 PlaybackThread *thread = checkPlaybackThread_l(output);
1647 if (thread == nullptr) {
1648 return BAD_VALUE;
1649 }
1650 return thread->setRequestedLatencyMode(mode);
Eric Laurent076e7c72022-05-03 18:12:28 +02001651}
1652
1653status_t AudioFlinger::getSupportedLatencyModes(audio_io_handle_t output,
Eric Laurent68a40a82022-05-03 18:15:04 +02001654 std::vector<audio_latency_mode_t>* modes) {
Eric Laurent076e7c72022-05-03 18:12:28 +02001655 if (output == AUDIO_IO_HANDLE_NONE) {
1656 return BAD_VALUE;
1657 }
Eric Laurent68a40a82022-05-03 18:15:04 +02001658 AutoMutex lock(mLock);
1659 PlaybackThread *thread = checkPlaybackThread_l(output);
1660 if (thread == nullptr) {
1661 return BAD_VALUE;
1662 }
1663 return thread->getSupportedLatencyModes(modes);
Eric Laurent076e7c72022-05-03 18:12:28 +02001664}
1665
Vlad Popa63f047e2022-11-05 14:09:19 +01001666status_t AudioFlinger::registerSoundDoseCallback(const sp<media::ISoundDoseCallback>& callback) {
1667 mMelReporter->registerSoundDoseCallback(callback);
1668 return NO_ERROR;
1669}
1670
Glenn Kastenfff6d712012-01-12 16:38:12 -08001671status_t AudioFlinger::setStreamMute(audio_stream_type_t stream, bool muted)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001672{
1673 // check calling permissions
1674 if (!settingsAllowed()) {
1675 return PERMISSION_DENIED;
1676 }
1677
Eric Laurent223fd5c2014-11-11 13:43:36 -08001678 status_t status = checkStreamType(stream);
1679 if (status != NO_ERROR) {
1680 return status;
1681 }
1682 ALOG_ASSERT(stream != AUDIO_STREAM_PATCH, "attempt to mute AUDIO_STREAM_PATCH");
1683
1684 if (uint32_t(stream) == AUDIO_STREAM_ENFORCED_AUDIBLE) {
Steve Block29357bc2012-01-06 19:20:56 +00001685 ALOGE("setStreamMute() invalid stream %d", stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001686 return BAD_VALUE;
1687 }
1688
Eric Laurent93575202011-01-18 18:39:02 -08001689 AutoMutex lock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001690 mStreamTypes[stream].mute = muted;
Eric Laurent6acd1d42017-01-04 14:23:29 -08001691 Vector<VolumeInterface *> volumeInterfaces = getAllVolumeInterfaces_l();
1692 for (size_t i = 0; i < volumeInterfaces.size(); i++) {
1693 volumeInterfaces[i]->setStreamMute(stream, muted);
1694 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001695
1696 return NO_ERROR;
1697}
1698
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001699float AudioFlinger::streamVolume(audio_stream_type_t stream, audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001700{
Eric Laurent223fd5c2014-11-11 13:43:36 -08001701 status_t status = checkStreamType(stream);
1702 if (status != NO_ERROR) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001703 return 0.0f;
1704 }
Eric Laurent98e38192018-02-15 18:31:53 -08001705 if (output == AUDIO_IO_HANDLE_NONE) {
1706 return 0.0f;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001707 }
1708
Eric Laurent98e38192018-02-15 18:31:53 -08001709 AutoMutex lock(mLock);
1710 VolumeInterface *volumeInterface = getVolumeInterface_l(output);
1711 if (volumeInterface == NULL) {
1712 return 0.0f;
1713 }
1714
1715 return volumeInterface->streamVolume(stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001716}
1717
Glenn Kastenfff6d712012-01-12 16:38:12 -08001718bool AudioFlinger::streamMute(audio_stream_type_t stream) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001719{
Eric Laurent223fd5c2014-11-11 13:43:36 -08001720 status_t status = checkStreamType(stream);
1721 if (status != NO_ERROR) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001722 return true;
1723 }
1724
Glenn Kasten6637baa2012-01-09 09:40:36 -08001725 AutoMutex lock(mLock);
1726 return streamMute_l(stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001727}
1728
Eric Laurent054d9d32015-04-24 08:48:48 -07001729
Andy Hungd9ef4b12020-11-11 15:13:18 -08001730void AudioFlinger::broadcastParametersToRecordThreads_l(const String8& keyValuePairs)
Eric Laurent054d9d32015-04-24 08:48:48 -07001731{
1732 for (size_t i = 0; i < mRecordThreads.size(); i++) {
1733 mRecordThreads.valueAt(i)->setParameters(keyValuePairs);
1734 }
1735}
1736
jiabinc52b1ff2019-10-31 17:20:42 -07001737void AudioFlinger::updateOutDevicesForRecordThreads_l(const DeviceDescriptorBaseVector& devices)
1738{
1739 for (size_t i = 0; i < mRecordThreads.size(); i++) {
1740 mRecordThreads.valueAt(i)->updateOutDevices(devices);
1741 }
1742}
1743
Mikhail Naganovb261ef52018-07-16 13:34:38 -07001744// forwardAudioHwSyncToDownstreamPatches_l() must be called with AudioFlinger::mLock held
1745void AudioFlinger::forwardParametersToDownstreamPatches_l(
1746 audio_io_handle_t upStream, const String8& keyValuePairs,
1747 std::function<bool(const sp<PlaybackThread>&)> useThread)
1748{
1749 std::vector<PatchPanel::SoftwarePatch> swPatches;
1750 if (mPatchPanel.getDownstreamSoftwarePatches(upStream, &swPatches) != OK) return;
1751 ALOGV_IF(!swPatches.empty(), "%s found %zu downstream patches for stream ID %d",
1752 __func__, swPatches.size(), upStream);
1753 for (const auto& swPatch : swPatches) {
1754 sp<PlaybackThread> downStream = checkPlaybackThread_l(swPatch.getPlaybackThreadHandle());
1755 if (downStream != NULL && (useThread == nullptr || useThread(downStream))) {
1756 downStream->setParameters(keyValuePairs);
1757 }
1758 }
1759}
1760
Eric Laurent74c38dc2020-12-23 18:19:44 +01001761// Update downstream patches for all playback threads attached to an MSD module
1762void AudioFlinger::updateDownStreamPatches_l(const struct audio_patch *patch,
1763 const std::set<audio_io_handle_t> streams)
1764{
1765 for (const audio_io_handle_t stream : streams) {
1766 PlaybackThread *playbackThread = checkPlaybackThread_l(stream);
1767 if (playbackThread == nullptr || !playbackThread->isMsdDevice()) {
1768 continue;
1769 }
1770 playbackThread->setDownStreamPatch(patch);
1771 playbackThread->sendIoConfigEvent(AUDIO_OUTPUT_CONFIG_CHANGED);
1772 }
1773}
1774
Eric Laurentf1047e82018-04-16 19:18:20 -07001775// Filter reserved keys from setParameters() before forwarding to audio HAL or acting upon.
1776// Some keys are used for audio routing and audio path configuration and should be reserved for use
1777// by audio policy and audio flinger for functional, privacy and security reasons.
1778void AudioFlinger::filterReservedParameters(String8& keyValuePairs, uid_t callingUid)
1779{
1780 static const String8 kReservedParameters[] = {
1781 String8(AudioParameter::keyRouting),
1782 String8(AudioParameter::keySamplingRate),
1783 String8(AudioParameter::keyFormat),
1784 String8(AudioParameter::keyChannels),
1785 String8(AudioParameter::keyFrameCount),
1786 String8(AudioParameter::keyInputSource),
1787 String8(AudioParameter::keyMonoOutput),
Mikhail Naganovf23fcf62019-07-08 15:28:43 -07001788 String8(AudioParameter::keyDeviceConnect),
1789 String8(AudioParameter::keyDeviceDisconnect),
Eric Laurentf1047e82018-04-16 19:18:20 -07001790 String8(AudioParameter::keyStreamSupportedFormats),
1791 String8(AudioParameter::keyStreamSupportedChannels),
1792 String8(AudioParameter::keyStreamSupportedSamplingRates),
1793 };
1794
Andy Hung4ef19fa2018-05-15 19:35:29 -07001795 if (isAudioServerUid(callingUid)) {
1796 return; // no need to filter if audioserver.
Eric Laurentf1047e82018-04-16 19:18:20 -07001797 }
1798
1799 AudioParameter param = AudioParameter(keyValuePairs);
1800 String8 value;
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001801 AudioParameter rejectedParam;
Eric Laurentf1047e82018-04-16 19:18:20 -07001802 for (auto& key : kReservedParameters) {
1803 if (param.get(key, value) == NO_ERROR) {
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001804 rejectedParam.add(key, value);
Eric Laurentf1047e82018-04-16 19:18:20 -07001805 param.remove(key);
1806 }
1807 }
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001808 logFilteredParameters(param.size() + rejectedParam.size(), keyValuePairs,
1809 rejectedParam.size(), rejectedParam.toString(), callingUid);
Eric Laurentf1047e82018-04-16 19:18:20 -07001810 keyValuePairs = param.toString();
1811}
1812
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001813void AudioFlinger::logFilteredParameters(size_t originalKVPSize, const String8& originalKVPs,
1814 size_t rejectedKVPSize, const String8& rejectedKVPs,
1815 uid_t callingUid) {
1816 auto prefix = String8::format("UID %5d", callingUid);
1817 auto suffix = String8::format("%zu KVP received: %s", originalKVPSize, originalKVPs.c_str());
1818 if (rejectedKVPSize != 0) {
1819 auto error = String8::format("%zu KVP rejected: %s", rejectedKVPSize, rejectedKVPs.c_str());
1820 ALOGW("%s: %s, %s, %s", __func__, prefix.c_str(), error.c_str(), suffix.c_str());
1821 mRejectedSetParameterLog.log("%s, %s, %s", prefix.c_str(), error.c_str(), suffix.c_str());
1822 } else {
1823 auto& logger = (isServiceUid(callingUid) ? mSystemSetParameterLog : mAppSetParameterLog);
1824 logger.log("%s, %s", prefix.c_str(), suffix.c_str());
1825 }
1826}
1827
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001828status_t AudioFlinger::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001829{
Eric Laurentf1047e82018-04-16 19:18:20 -07001830 ALOGV("setParameters(): io %d, keyvalue %s, calling pid %d calling uid %d",
1831 ioHandle, keyValuePairs.string(),
1832 IPCThreadState::self()->getCallingPid(), IPCThreadState::self()->getCallingUid());
Eric Laurent81784c32012-11-19 14:55:58 -08001833
Mathias Agopian65ab4712010-07-14 17:59:35 -07001834 // check calling permissions
1835 if (!settingsAllowed()) {
1836 return PERMISSION_DENIED;
1837 }
1838
Eric Laurentf1047e82018-04-16 19:18:20 -07001839 String8 filteredKeyValuePairs = keyValuePairs;
1840 filterReservedParameters(filteredKeyValuePairs, IPCThreadState::self()->getCallingUid());
1841
1842 ALOGV("%s: filtered keyvalue %s", __func__, filteredKeyValuePairs.string());
1843
Glenn Kasten142f5192014-03-25 17:44:59 -07001844 // AUDIO_IO_HANDLE_NONE means the parameters are global to the audio hardware interface
1845 if (ioHandle == AUDIO_IO_HANDLE_NONE) {
Eric Laurenta4c5a552012-03-29 10:12:40 -07001846 Mutex::Autolock _l(mLock);
Eric Laurentd21bcd22016-09-08 18:25:54 -07001847 // result will remain NO_INIT if no audio device is present
1848 status_t final_result = NO_INIT;
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001849 {
Eric Laurenta4c5a552012-03-29 10:12:40 -07001850 AutoMutex lock(mHardwareLock);
1851 mHardwareStatus = AUDIO_HW_SET_PARAMETER;
1852 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001853 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
Eric Laurentf1047e82018-04-16 19:18:20 -07001854 status_t result = dev->setParameters(filteredKeyValuePairs);
Eric Laurentd21bcd22016-09-08 18:25:54 -07001855 // return success if at least one audio device accepts the parameters as not all
1856 // HALs are requested to support all parameters. If no audio device supports the
1857 // requested parameters, the last error is reported.
1858 if (final_result != NO_ERROR) {
1859 final_result = result;
1860 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07001861 }
1862 mHardwareStatus = AUDIO_HW_IDLE;
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001863 }
Eric Laurent59bd0da2011-08-01 09:52:20 -07001864 // disable AEC and NS if the device is a BT SCO headset supporting those pre processings
Eric Laurentf1047e82018-04-16 19:18:20 -07001865 AudioParameter param = AudioParameter(filteredKeyValuePairs);
Eric Laurent59bd0da2011-08-01 09:52:20 -07001866 String8 value;
Mikhail Naganov00260b52016-10-13 12:54:24 -07001867 if (param.get(String8(AudioParameter::keyBtNrec), value) == NO_ERROR) {
1868 bool btNrecIsOff = (value == AudioParameter::valueOff);
Eric Laurentd8365c52017-07-16 15:27:05 -07001869 if (mBtNrecIsOff.exchange(btNrecIsOff) != btNrecIsOff) {
Eric Laurent59bd0da2011-08-01 09:52:20 -07001870 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Eric Laurentd8365c52017-07-16 15:27:05 -07001871 mRecordThreads.valueAt(i)->checkBtNrec();
Eric Laurent59bd0da2011-08-01 09:52:20 -07001872 }
Eric Laurent59bd0da2011-08-01 09:52:20 -07001873 }
1874 }
Glenn Kasten28ed2f92012-06-07 10:17:54 -07001875 String8 screenState;
1876 if (param.get(String8(AudioParameter::keyScreenState), screenState) == NO_ERROR) {
Mikhail Naganov00260b52016-10-13 12:54:24 -07001877 bool isOff = (screenState == AudioParameter::valueOff);
Eric Laurent81784c32012-11-19 14:55:58 -08001878 if (isOff != (AudioFlinger::mScreenState & 1)) {
1879 AudioFlinger::mScreenState = ((AudioFlinger::mScreenState & ~1) + 2) | isOff;
Glenn Kasten28ed2f92012-06-07 10:17:54 -07001880 }
1881 }
Dima Zavin799a70e2011-04-18 16:57:27 -07001882 return final_result;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001883 }
1884
1885 // hold a strong ref on thread in case closeOutput() or closeInput() is called
1886 // and the thread is exited once the lock is released
1887 sp<ThreadBase> thread;
1888 {
1889 Mutex::Autolock _l(mLock);
1890 thread = checkPlaybackThread_l(ioHandle);
Glenn Kastend5903ec2012-03-18 10:33:27 -07001891 if (thread == 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001892 thread = checkRecordThread_l(ioHandle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08001893 if (thread == 0) {
1894 thread = checkMmapThread_l(ioHandle);
1895 }
Glenn Kasten7fc9a6f2012-01-10 10:46:34 -08001896 } else if (thread == primaryPlaybackThread_l()) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001897 // indicate output device change to all input threads for pre processing
Eric Laurentf1047e82018-04-16 19:18:20 -07001898 AudioParameter param = AudioParameter(filteredKeyValuePairs);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001899 int value;
Eric Laurent89d94e72012-03-16 20:37:59 -07001900 if ((param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) &&
1901 (value != 0)) {
Andy Hungd9ef4b12020-11-11 15:13:18 -08001902 broadcastParametersToRecordThreads_l(filteredKeyValuePairs);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001903 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001904 }
1905 }
Glenn Kasten7378ca52012-01-20 13:44:40 -08001906 if (thread != 0) {
Mikhail Naganovb261ef52018-07-16 13:34:38 -07001907 status_t result = thread->setParameters(filteredKeyValuePairs);
1908 forwardParametersToDownstreamPatches_l(thread->id(), filteredKeyValuePairs);
1909 return result;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001910 }
1911 return BAD_VALUE;
1912}
1913
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001914String8 AudioFlinger::getParameters(audio_io_handle_t ioHandle, const String8& keys) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001915{
Glenn Kasten827e5f12012-11-02 10:00:06 -07001916 ALOGVV("getParameters() io %d, keys %s, calling pid %d",
1917 ioHandle, keys.string(), IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001918
Eric Laurenta4c5a552012-03-29 10:12:40 -07001919 Mutex::Autolock _l(mLock);
1920
Glenn Kasten142f5192014-03-25 17:44:59 -07001921 if (ioHandle == AUDIO_IO_HANDLE_NONE) {
Dima Zavinfce7a472011-04-19 22:30:36 -07001922 String8 out_s8;
1923
Eric Laurent00abf0d2020-04-22 19:28:22 -07001924 AutoMutex lock(mHardwareLock);
Dima Zavin799a70e2011-04-18 16:57:27 -07001925 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001926 String8 s;
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001927 mHardwareStatus = AUDIO_HW_GET_PARAMETER;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001928 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
Eric Laurent00abf0d2020-04-22 19:28:22 -07001929 status_t result = dev->getParameters(keys, &s);
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001930 mHardwareStatus = AUDIO_HW_IDLE;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001931 if (result == OK) out_s8 += s;
Dima Zavin799a70e2011-04-18 16:57:27 -07001932 }
Dima Zavinfce7a472011-04-19 22:30:36 -07001933 return out_s8;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001934 }
1935
Eric Laurent6acd1d42017-01-04 14:23:29 -08001936 ThreadBase *thread = (ThreadBase *)checkPlaybackThread_l(ioHandle);
1937 if (thread == NULL) {
1938 thread = (ThreadBase *)checkRecordThread_l(ioHandle);
1939 if (thread == NULL) {
1940 thread = (ThreadBase *)checkMmapThread_l(ioHandle);
1941 if (thread == NULL) {
Mikhail Naganovaa165e52017-07-12 10:39:16 -07001942 return String8("");
Eric Laurent6acd1d42017-01-04 14:23:29 -08001943 }
1944 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001945 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08001946 return thread->getParameters(keys);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001947}
1948
Glenn Kastendd8104c2012-07-02 12:42:44 -07001949size_t AudioFlinger::getInputBufferSize(uint32_t sampleRate, audio_format_t format,
1950 audio_channel_mask_t channelMask) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001951{
Eric Laurenta1884f92011-08-23 08:25:03 -07001952 status_t ret = initCheck();
1953 if (ret != NO_ERROR) {
1954 return 0;
1955 }
Eric Laurentcdf924a2016-02-04 15:57:56 -08001956 if ((sampleRate == 0) ||
Phil Burkfdb3c072016-02-09 10:47:02 -08001957 !audio_is_valid_format(format) || !audio_has_proportional_frames(format) ||
Eric Laurentcdf924a2016-02-04 15:57:56 -08001958 !audio_is_input_channel(channelMask)) {
Andy Hung6770c6f2015-04-07 13:43:36 -07001959 return 0;
1960 }
Eric Laurenta1884f92011-08-23 08:25:03 -07001961
Glenn Kasten2b213bc2012-02-02 14:05:20 -08001962 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07001963 if (mPrimaryHardwareDev == nullptr) {
1964 return 0;
1965 }
Glenn Kasten2b213bc2012-02-02 14:05:20 -08001966 mHardwareStatus = AUDIO_HW_GET_INPUT_BUFFER_SIZE;
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00001967
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001968 sp<DeviceHalInterface> dev = mPrimaryHardwareDev->hwDevice();
Judy Hsiaoabab5222019-11-09 18:14:58 +08001969 std::vector<audio_channel_mask_t> channelMasks = {channelMask};
1970 if (channelMask != AUDIO_CHANNEL_IN_MONO)
1971 channelMasks.push_back(AUDIO_CHANNEL_IN_MONO);
1972 if (channelMask != AUDIO_CHANNEL_IN_STEREO)
1973 channelMasks.push_back(AUDIO_CHANNEL_IN_STEREO);
1974
1975 std::vector<audio_format_t> formats = {format};
1976 if (format != AUDIO_FORMAT_PCM_16_BIT)
1977 formats.push_back(AUDIO_FORMAT_PCM_16_BIT);
1978
1979 std::vector<uint32_t> sampleRates = {sampleRate};
1980 static const uint32_t SR_44100 = 44100;
1981 static const uint32_t SR_48000 = 48000;
1982
1983 if (sampleRate != SR_48000)
1984 sampleRates.push_back(SR_48000);
1985 if (sampleRate != SR_44100)
1986 sampleRates.push_back(SR_44100);
1987
Glenn Kasten2b213bc2012-02-02 14:05:20 -08001988 mHardwareStatus = AUDIO_HW_IDLE;
Judy Hsiaoabab5222019-11-09 18:14:58 +08001989
Robin Lee9899ff72019-12-24 22:02:08 +01001990 // Change parameters of the configuration each iteration until we find a
1991 // configuration that the device will support.
1992 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
Judy Hsiaoabab5222019-11-09 18:14:58 +08001993 for (auto testChannelMask : channelMasks) {
1994 config.channel_mask = testChannelMask;
1995 for (auto testFormat : formats) {
1996 config.format = testFormat;
1997 for (auto testSampleRate : sampleRates) {
1998 config.sample_rate = testSampleRate;
Robin Lee9899ff72019-12-24 22:02:08 +01001999
Judy Hsiaoabab5222019-11-09 18:14:58 +08002000 size_t bytes = 0;
2001 status_t result = dev->getInputBufferSize(&config, &bytes);
2002 if (result != OK || bytes == 0) {
2003 continue;
2004 }
2005
2006 if (config.sample_rate != sampleRate || config.channel_mask != channelMask ||
2007 config.format != format) {
2008 uint32_t dstChannelCount = audio_channel_count_from_in_mask(channelMask);
2009 uint32_t srcChannelCount =
2010 audio_channel_count_from_in_mask(config.channel_mask);
2011 size_t srcFrames =
2012 bytes / audio_bytes_per_frame(srcChannelCount, config.format);
2013 size_t dstFrames = destinationFramesPossible(
2014 srcFrames, config.sample_rate, sampleRate);
2015 bytes = dstFrames * audio_bytes_per_frame(dstChannelCount, format);
2016 }
2017 return bytes;
2018 }
2019 }
Andy Hung6770c6f2015-04-07 13:43:36 -07002020 }
Judy Hsiaoabab5222019-11-09 18:14:58 +08002021
2022 ALOGW("getInputBufferSize failed with minimum buffer size sampleRate %u, "
2023 "format %#x, channelMask %#x",sampleRate, format, channelMask);
2024 return 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002025}
2026
Glenn Kasten5f972c02014-01-13 09:59:31 -08002027uint32_t AudioFlinger::getInputFramesLost(audio_io_handle_t ioHandle) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07002028{
Mathias Agopian65ab4712010-07-14 17:59:35 -07002029 Mutex::Autolock _l(mLock);
2030
2031 RecordThread *recordThread = checkRecordThread_l(ioHandle);
2032 if (recordThread != NULL) {
2033 return recordThread->getInputFramesLost();
2034 }
2035 return 0;
2036}
2037
2038status_t AudioFlinger::setVoiceVolume(float value)
2039{
Eric Laurenta1884f92011-08-23 08:25:03 -07002040 status_t ret = initCheck();
2041 if (ret != NO_ERROR) {
2042 return ret;
2043 }
2044
Mathias Agopian65ab4712010-07-14 17:59:35 -07002045 // check calling permissions
2046 if (!settingsAllowed()) {
2047 return PERMISSION_DENIED;
2048 }
2049
2050 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002051 if (mPrimaryHardwareDev == nullptr) {
2052 return INVALID_OPERATION;
2053 }
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002054 sp<DeviceHalInterface> dev = mPrimaryHardwareDev->hwDevice();
Glenn Kasten8abf44d2012-02-02 14:16:03 -08002055 mHardwareStatus = AUDIO_HW_SET_VOICE_VOLUME;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002056 ret = dev->setVoiceVolume(value);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002057 mHardwareStatus = AUDIO_HW_IDLE;
2058
Joey Poomarin52989982020-03-05 17:40:49 +08002059 mediametrics::LogItem(mMetricsId)
2060 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETVOICEVOLUME)
2061 .set(AMEDIAMETRICS_PROP_VOICEVOLUME, (double)value)
2062 .record();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002063 return ret;
2064}
2065
Kévin PETIT377b2ec2014-02-03 12:35:36 +00002066status_t AudioFlinger::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002067 audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07002068{
Mathias Agopian65ab4712010-07-14 17:59:35 -07002069 Mutex::Autolock _l(mLock);
2070
2071 PlaybackThread *playbackThread = checkPlaybackThread_l(output);
2072 if (playbackThread != NULL) {
2073 return playbackThread->getRenderPosition(halFrames, dspFrames);
2074 }
2075
2076 return BAD_VALUE;
2077}
2078
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002079void AudioFlinger::registerClient(const sp<media::IAudioFlingerClient>& client)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002080{
Mathias Agopian65ab4712010-07-14 17:59:35 -07002081 Mutex::Autolock _l(mLock);
Eric Laurent44622db2014-08-01 19:00:33 -07002082 if (client == 0) {
2083 return;
2084 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002085 pid_t pid = IPCThreadState::self()->getCallingPid();
Andy Hung5bdc5352019-12-23 14:36:31 -08002086 const uid_t uid = IPCThreadState::self()->getCallingUid();
Eric Laurent021cf962014-05-13 10:18:14 -07002087 {
2088 Mutex::Autolock _cl(mClientLock);
Eric Laurent021cf962014-05-13 10:18:14 -07002089 if (mNotificationClients.indexOfKey(pid) < 0) {
2090 sp<NotificationClient> notificationClient = new NotificationClient(this,
2091 client,
Andy Hung5bdc5352019-12-23 14:36:31 -08002092 pid,
2093 uid);
2094 ALOGV("registerClient() client %p, pid %d, uid %u",
2095 notificationClient.get(), pid, uid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002096
Eric Laurent021cf962014-05-13 10:18:14 -07002097 mNotificationClients.add(pid, notificationClient);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002098
Marco Nelissen06b46062014-11-14 07:58:25 -08002099 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurent021cf962014-05-13 10:18:14 -07002100 binder->linkToDeath(notificationClient);
Eric Laurent021cf962014-05-13 10:18:14 -07002101 }
2102 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002103
Eric Laurent021cf962014-05-13 10:18:14 -07002104 // mClientLock should not be held here because ThreadBase::sendIoConfigEvent() will lock the
Eric Laurentfe1a94e2014-05-26 16:03:08 -07002105 // ThreadBase mutex and the locking order is ThreadBase::mLock then AudioFlinger::mClientLock.
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002106 // the config change is always sent from playback or record threads to avoid deadlock
2107 // with AudioSystem::gLock
2108 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07002109 mPlaybackThreads.valueAt(i)->sendIoConfigEvent(AUDIO_OUTPUT_REGISTERED, pid);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002110 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002111
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002112 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07002113 mRecordThreads.valueAt(i)->sendIoConfigEvent(AUDIO_INPUT_REGISTERED, pid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002114 }
2115}
2116
2117void AudioFlinger::removeNotificationClient(pid_t pid)
2118{
Eric Laurent6c796322019-04-09 14:13:17 -07002119 std::vector< sp<AudioFlinger::EffectModule> > removedEffects;
Eric Laurent021cf962014-05-13 10:18:14 -07002120 {
Eric Laurent6c796322019-04-09 14:13:17 -07002121 Mutex::Autolock _l(mLock);
2122 {
2123 Mutex::Autolock _cl(mClientLock);
2124 mNotificationClients.removeItem(pid);
2125 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002126
Eric Laurent6c796322019-04-09 14:13:17 -07002127 ALOGV("%d died, releasing its sessions", pid);
2128 size_t num = mAudioSessionRefs.size();
2129 bool removed = false;
2130 for (size_t i = 0; i < num; ) {
2131 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
2132 ALOGV(" pid %d @ %zu", ref->mPid, i);
2133 if (ref->mPid == pid) {
2134 ALOGV(" removing entry for pid %d session %d", pid, ref->mSessionid);
2135 mAudioSessionRefs.removeAt(i);
2136 delete ref;
2137 removed = true;
2138 num--;
2139 } else {
2140 i++;
2141 }
2142 }
2143 if (removed) {
2144 removedEffects = purgeStaleEffects_l();
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002145 }
2146 }
Eric Laurent6c796322019-04-09 14:13:17 -07002147 for (auto& effect : removedEffects) {
2148 effect->updatePolicyState();
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002149 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002150}
2151
Mikhail Naganov88536df2021-07-26 17:30:29 -07002152void AudioFlinger::ioConfigChanged(audio_io_config_event_t event,
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002153 const sp<AudioIoDescriptor>& ioDesc,
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002154 pid_t pid) {
Andy Hungb75b6242021-07-29 16:46:14 +00002155 media::AudioIoConfigEvent eventAidl = VALUE_OR_FATAL(
2156 legacy2aidl_audio_io_config_event_t_AudioIoConfigEvent(event));
Mikhail Naganovde3fa182021-07-30 15:06:42 -07002157 media::AudioIoDescriptor descAidl = VALUE_OR_FATAL(
2158 legacy2aidl_AudioIoDescriptor_AudioIoDescriptor(ioDesc));
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002159
Eric Laurent021cf962014-05-13 10:18:14 -07002160 Mutex::Autolock _l(mClientLock);
2161 size_t size = mNotificationClients.size();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002162 for (size_t i = 0; i < size; i++) {
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002163 if ((pid == 0) || (mNotificationClients.keyAt(i) == pid)) {
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002164 mNotificationClients.valueAt(i)->audioFlingerClient()->ioConfigChanged(eventAidl,
2165 descAidl);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002166 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002167 }
2168}
2169
Eric Laurent076e7c72022-05-03 18:12:28 +02002170void AudioFlinger::onSupportedLatencyModesChanged(
2171 audio_io_handle_t output, const std::vector<audio_latency_mode_t>& modes) {
2172 int32_t outputAidl = VALUE_OR_FATAL(legacy2aidl_audio_io_handle_t_int32_t(output));
2173 std::vector<media::LatencyMode> modesAidl = VALUE_OR_FATAL(
2174 convertContainer<std::vector<media::LatencyMode>>(modes,
2175 legacy2aidl_audio_latency_mode_t_LatencyMode));
2176
2177 Mutex::Autolock _l(mClientLock);
2178 size_t size = mNotificationClients.size();
2179 for (size_t i = 0; i < size; i++) {
2180 mNotificationClients.valueAt(i)->audioFlingerClient()
2181 ->onSupportedLatencyModesChanged(outputAidl, modesAidl);
2182 }
2183}
2184
Eric Laurent021cf962014-05-13 10:18:14 -07002185// removeClient_l() must be called with AudioFlinger::mClientLock held
Mathias Agopian65ab4712010-07-14 17:59:35 -07002186void AudioFlinger::removeClient_l(pid_t pid)
2187{
Glenn Kasten827e5f12012-11-02 10:00:06 -07002188 ALOGV("removeClient_l() pid %d, calling pid %d", pid,
Glenn Kasten85ab62c2012-11-01 11:11:38 -07002189 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002190 mClients.removeItem(pid);
2191}
2192
Eric Laurent717e1282012-06-29 16:36:52 -07002193// getEffectThread_l() must be called with AudioFlinger::mLock held
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002194sp<AudioFlinger::ThreadBase> AudioFlinger::getEffectThread_l(audio_session_t sessionId,
2195 int effectId)
Eric Laurent717e1282012-06-29 16:36:52 -07002196{
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002197 sp<ThreadBase> thread;
Eric Laurent717e1282012-06-29 16:36:52 -07002198
2199 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002200 if (mPlaybackThreads.valueAt(i)->getEffect(sessionId, effectId) != 0) {
Eric Laurent717e1282012-06-29 16:36:52 -07002201 ALOG_ASSERT(thread == 0);
2202 thread = mPlaybackThreads.valueAt(i);
2203 }
2204 }
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002205 if (thread != nullptr) {
2206 return thread;
2207 }
2208 for (size_t i = 0; i < mRecordThreads.size(); i++) {
2209 if (mRecordThreads.valueAt(i)->getEffect(sessionId, effectId) != 0) {
2210 ALOG_ASSERT(thread == 0);
2211 thread = mRecordThreads.valueAt(i);
2212 }
2213 }
2214 if (thread != nullptr) {
2215 return thread;
2216 }
2217 for (size_t i = 0; i < mMmapThreads.size(); i++) {
2218 if (mMmapThreads.valueAt(i)->getEffect(sessionId, effectId) != 0) {
2219 ALOG_ASSERT(thread == 0);
2220 thread = mMmapThreads.valueAt(i);
2221 }
2222 }
Eric Laurent717e1282012-06-29 16:36:52 -07002223 return thread;
2224}
Mathias Agopian65ab4712010-07-14 17:59:35 -07002225
Mathias Agopian65ab4712010-07-14 17:59:35 -07002226
Mathias Agopian65ab4712010-07-14 17:59:35 -07002227
2228// ----------------------------------------------------------------------------
2229
2230AudioFlinger::Client::Client(const sp<AudioFlinger>& audioFlinger, pid_t pid)
2231 : RefBase(),
2232 mAudioFlinger(audioFlinger),
Atneya3c61d882021-09-20 14:52:15 -04002233 mPid(pid),
2234 mClientAllocator(AllocatorFactory::getClientAllocator()) {}
Mathias Agopian65ab4712010-07-14 17:59:35 -07002235
Eric Laurent021cf962014-05-13 10:18:14 -07002236// Client destructor must be called with AudioFlinger::mClientLock held
Mathias Agopian65ab4712010-07-14 17:59:35 -07002237AudioFlinger::Client::~Client()
2238{
2239 mAudioFlinger->removeClient_l(mPid);
2240}
2241
Atneya3c61d882021-09-20 14:52:15 -04002242AllocatorFactory::ClientAllocator& AudioFlinger::Client::allocator()
Mathias Agopian65ab4712010-07-14 17:59:35 -07002243{
Atneya3c61d882021-09-20 14:52:15 -04002244 return mClientAllocator;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002245}
2246
2247// ----------------------------------------------------------------------------
2248
2249AudioFlinger::NotificationClient::NotificationClient(const sp<AudioFlinger>& audioFlinger,
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -07002250 const sp<media::IAudioFlingerClient>& client,
Andy Hung5bdc5352019-12-23 14:36:31 -08002251 pid_t pid,
2252 uid_t uid)
2253 : mAudioFlinger(audioFlinger), mPid(pid), mUid(uid), mAudioFlingerClient(client)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002254{
2255}
2256
2257AudioFlinger::NotificationClient::~NotificationClient()
2258{
Mathias Agopian65ab4712010-07-14 17:59:35 -07002259}
2260
Glenn Kasten0f11b512014-01-31 16:18:54 -08002261void AudioFlinger::NotificationClient::binderDied(const wp<IBinder>& who __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002262{
2263 sp<NotificationClient> keep(this);
Glenn Kastena1117922012-01-26 10:53:32 -08002264 mAudioFlinger->removeNotificationClient(mPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002265}
2266
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08002267// ----------------------------------------------------------------------------
2268AudioFlinger::MediaLogNotifier::MediaLogNotifier()
2269 : mPendingRequests(false) {}
2270
2271
2272void AudioFlinger::MediaLogNotifier::requestMerge() {
2273 AutoMutex _l(mMutex);
2274 mPendingRequests = true;
2275 mCond.signal();
2276}
2277
2278bool AudioFlinger::MediaLogNotifier::threadLoop() {
Glenn Kasten04b96fc2017-04-10 14:58:47 -07002279 // Should already have been checked, but just in case
2280 if (sMediaLogService == 0) {
2281 return false;
2282 }
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08002283 // Wait until there are pending requests
2284 {
2285 AutoMutex _l(mMutex);
2286 mPendingRequests = false; // to ignore past requests
2287 while (!mPendingRequests) {
2288 mCond.wait(mMutex);
2289 // TODO may also need an exitPending check
2290 }
2291 mPendingRequests = false;
2292 }
2293 // Execute the actual MediaLogService binder call and ignore extra requests for a while
Glenn Kasten04b96fc2017-04-10 14:58:47 -07002294 sMediaLogService->requestMergeWakeup();
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08002295 usleep(kPostTriggerSleepPeriod);
2296 return true;
2297}
2298
2299void AudioFlinger::requestLogMerge() {
2300 mMediaLogNotifier->requestMerge();
2301}
Mathias Agopian65ab4712010-07-14 17:59:35 -07002302
2303// ----------------------------------------------------------------------------
2304
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08002305status_t AudioFlinger::createRecord(const media::CreateRecordRequest& _input,
2306 media::CreateRecordResponse& _output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002307{
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08002308 CreateRecordInput input = VALUE_OR_RETURN_STATUS(CreateRecordInput::fromAidl(_input));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08002309 CreateRecordOutput output;
2310
Mathias Agopian65ab4712010-07-14 17:59:35 -07002311 sp<RecordThread::RecordTrack> recordTrack;
2312 sp<RecordHandle> recordHandle;
2313 sp<Client> client;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002314 status_t lStatus;
Eric Laurentf14db3c2017-12-08 14:20:36 -08002315 audio_session_t sessionId = input.sessionId;
Eric Laurent77881cd2018-02-09 16:01:31 -08002316 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002317
Eric Laurentf14db3c2017-12-08 14:20:36 -08002318 output.cblk.clear();
2319 output.buffers.clear();
Eric Laurent896c9672017-12-08 14:08:45 -08002320 output.inputId = AUDIO_IO_HANDLE_NONE;
Glenn Kastend776ac62014-05-07 09:16:09 -07002321
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002322 // TODO b/182392553: refactor or clean up
Svet Ganov33761132021-05-13 22:51:08 +00002323 AttributionSourceState adjAttributionSource = input.clientInfo.attributionSource;
2324 bool updatePid = (adjAttributionSource.pid == -1);
Marco Nelissendcb346b2015-09-09 10:47:29 -07002325 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Svet Ganov33761132021-05-13 22:51:08 +00002326 const uid_t currentUid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(
2327 adjAttributionSource.uid));
Eric Laurent9ff3e532022-11-10 16:04:44 +01002328 if (!isAudioServerOrMediaServerOrSystemServerOrRootUid(callingUid)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002329 ALOGW_IF(currentUid != callingUid,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002330 "%s uid %d tried to pass itself off as %d",
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002331 __FUNCTION__, callingUid, currentUid);
Svet Ganov33761132021-05-13 22:51:08 +00002332 adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07002333 updatePid = true;
2334 }
Eric Laurent09f1ed22019-04-24 17:45:17 -07002335 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Svet Ganov33761132021-05-13 22:51:08 +00002336 const pid_t currentPid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(
2337 adjAttributionSource.pid));
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07002338 if (updatePid) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002339 ALOGW_IF(currentPid != (pid_t)-1 && currentPid != callingPid,
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07002340 "%s uid %d pid %d tried to pass itself off as pid %d",
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002341 __func__, callingUid, callingPid, currentPid);
Svet Ganov33761132021-05-13 22:51:08 +00002342 adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
Marco Nelissendcb346b2015-09-09 10:47:29 -07002343 }
Eric Laurent9ff3e532022-11-10 16:04:44 +01002344 adjAttributionSource = AudioFlinger::checkAttributionSourcePackage(
2345 adjAttributionSource);
Andy Hung6770c6f2015-04-07 13:43:36 -07002346 // we don't yet support anything other than linear PCM
Eric Laurentf14db3c2017-12-08 14:20:36 -08002347 if (!audio_is_valid_format(input.config.format) || !audio_is_linear_pcm(input.config.format)) {
2348 ALOGE("createRecord() invalid format %#x", input.config.format);
Glenn Kasten291bb6d2013-07-16 17:23:39 -07002349 lStatus = BAD_VALUE;
2350 goto Exit;
2351 }
2352
Glenn Kasten53b5d092014-02-05 10:00:23 -08002353 // further channel mask checks are performed by createRecordTrack_l()
Eric Laurentf14db3c2017-12-08 14:20:36 -08002354 if (!audio_is_input_channel(input.config.channel_mask)) {
2355 ALOGE("createRecord() invalid channel mask %#x", input.config.channel_mask);
Glenn Kasten53b5d092014-02-05 10:00:23 -08002356 lStatus = BAD_VALUE;
2357 goto Exit;
2358 }
2359
Eric Laurentf14db3c2017-12-08 14:20:36 -08002360 if (sessionId == AUDIO_SESSION_ALLOCATE) {
2361 sessionId = (audio_session_t) newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
2362 } else if (audio_unique_id_get_use(sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) {
2363 lStatus = BAD_VALUE;
2364 goto Exit;
2365 }
2366
2367 output.sessionId = sessionId;
Eric Laurentf14db3c2017-12-08 14:20:36 -08002368 output.selectedDeviceId = input.selectedDeviceId;
2369 output.flags = input.flags;
2370
Svet Ganov33761132021-05-13 22:51:08 +00002371 client = registerPid(VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(adjAttributionSource.pid)));
Eric Laurentf14db3c2017-12-08 14:20:36 -08002372
2373 // Not a conventional loop, but a retry loop for at most two iterations total.
2374 // Try first maybe with FAST flag then try again without FAST flag if that fails.
2375 // Exits loop via break on no error of got exit on error
2376 // The sp<> references will be dropped when re-entering scope.
2377 // The lack of indentation is deliberate, to reduce code churn and ease merges.
2378 for (;;) {
Eric Laurent896c9672017-12-08 14:08:45 -08002379 // release previously opened input if retrying.
2380 if (output.inputId != AUDIO_IO_HANDLE_NONE) {
2381 recordTrack.clear();
Eric Laurentfee19762018-01-29 18:44:13 -08002382 AudioSystem::releaseInput(portId);
Eric Laurent896c9672017-12-08 14:08:45 -08002383 output.inputId = AUDIO_IO_HANDLE_NONE;
Yung Ti Su5fac9c62018-05-15 15:07:43 +08002384 output.selectedDeviceId = input.selectedDeviceId;
Eric Laurent77881cd2018-02-09 16:01:31 -08002385 portId = AUDIO_PORT_HANDLE_NONE;
Eric Laurent896c9672017-12-08 14:08:45 -08002386 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08002387 lStatus = AudioSystem::getInputForAttr(&input.attr, &output.inputId,
Mikhail Naganov2996f672019-04-18 12:29:59 -07002388 input.riid,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002389 sessionId,
2390 // FIXME compare to AudioTrack
Svet Ganov33761132021-05-13 22:51:08 +00002391 adjAttributionSource,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002392 &input.config,
2393 output.flags, &output.selectedDeviceId, &portId);
jiabinc1de2df2019-05-07 14:26:40 -07002394 if (lStatus != NO_ERROR) {
2395 ALOGE("createRecord() getInputForAttr return error %d", lStatus);
2396 goto Exit;
2397 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08002398
Glenn Kasten05997e22014-03-13 15:08:33 -07002399 {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002400 Mutex::Autolock _l(mLock);
Eric Laurentf14db3c2017-12-08 14:20:36 -08002401 RecordThread *thread = checkRecordThread_l(output.inputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002402 if (thread == NULL) {
Eric Laurentd52a28c2020-08-21 17:10:39 -07002403 ALOGW("createRecord() checkRecordThread_l failed, input handle %d", output.inputId);
2404 lStatus = FAILED_TRANSACTION;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002405 goto Exit;
2406 }
2407
Eric Laurentf14db3c2017-12-08 14:20:36 -08002408 ALOGV("createRecord() lSessionId: %d input %d", sessionId, output.inputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002409
Eric Laurentf14db3c2017-12-08 14:20:36 -08002410 output.sampleRate = input.config.sample_rate;
2411 output.frameCount = input.frameCount;
2412 output.notificationFrameCount = input.notificationFrameCount;
Glenn Kasten570f6332014-03-13 15:01:06 -07002413
Kevin Rocard1f564ac2018-03-29 13:53:10 -07002414 recordTrack = thread->createRecordTrack_l(client, input.attr, &output.sampleRate,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002415 input.config.format, input.config.channel_mask,
2416 &output.frameCount, sessionId,
2417 &output.notificationFrameCount,
Svet Ganov33761132021-05-13 22:51:08 +00002418 callingPid, adjAttributionSource, &output.flags,
Eric Laurentf14db3c2017-12-08 14:20:36 -08002419 input.clientInfo.clientTid,
Eric Laurentec376dc2021-04-08 20:41:22 +02002420 &lStatus, portId, input.maxSharedAudioHistoryMs);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08002421 LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (recordTrack == 0));
Eric Laurent1b928682014-10-02 19:41:47 -07002422
Eric Laurentf14db3c2017-12-08 14:20:36 -08002423 // lStatus == BAD_TYPE means FAST flag was rejected: request a new input from
2424 // audio policy manager without FAST constraint
2425 if (lStatus == BAD_TYPE) {
Eric Laurentf14db3c2017-12-08 14:20:36 -08002426 continue;
Eric Laurent1b928682014-10-02 19:41:47 -07002427 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08002428
2429 if (lStatus != NO_ERROR) {
Eric Laurentf14db3c2017-12-08 14:20:36 -08002430 goto Exit;
2431 }
2432
jiabinb00edc32021-08-16 16:27:54 +00002433 if (recordTrack->isFastTrack()) {
2434 output.serverConfig = {
2435 thread->sampleRate(),
2436 thread->channelMask(),
2437 thread->format()
2438 };
2439 } else {
2440 output.serverConfig = {
2441 recordTrack->sampleRate(),
2442 recordTrack->channelMask(),
2443 recordTrack->format()
2444 };
2445 }
2446
Robert Wu310037a2022-09-06 21:48:18 +00002447 output.halConfig = {
2448 thread->sampleRate(),
2449 thread->channelMask(),
2450 thread->format()
2451 };
2452
Eric Laurentf14db3c2017-12-08 14:20:36 -08002453 // Check if one effect chain was awaiting for an AudioRecord to be created on this
2454 // session and move it to this thread.
2455 sp<EffectChain> chain = getOrphanEffectChain_l(sessionId);
2456 if (chain != 0) {
2457 Mutex::Autolock _l(thread->mLock);
2458 thread->addEffectChain_l(chain);
2459 }
2460 break;
2461 }
2462 // End of retry loop.
2463 // The lack of indentation is deliberate, to reduce code churn and ease merges.
Mathias Agopian65ab4712010-07-14 17:59:35 -07002464 }
Glenn Kastene198c362013-08-13 09:13:36 -07002465
Eric Laurentf14db3c2017-12-08 14:20:36 -08002466 output.cblk = recordTrack->getCblk();
2467 output.buffers = recordTrack->getBuffers();
Eric Laurent973db022018-11-20 14:54:31 -08002468 output.portId = portId;
Eric Laurentf14db3c2017-12-08 14:20:36 -08002469
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08002470 output.audioRecord = new RecordHandle(recordTrack);
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08002471 _output = VALUE_OR_FATAL(output.toAidl());
2472
Eric Laurentf14db3c2017-12-08 14:20:36 -08002473Exit:
Eric Laurent7c7f10b2011-06-17 21:29:58 -07002474 if (lStatus != NO_ERROR) {
Glenn Kasten85ab62c2012-11-01 11:11:38 -07002475 // remove local strong reference to Client before deleting the RecordTrack so that the
Eric Laurent021cf962014-05-13 10:18:14 -07002476 // Client destructor is called by the TrackBase destructor with mClientLock held
Eric Laurentfe1a94e2014-05-26 16:03:08 -07002477 // Don't hold mClientLock when releasing the reference on the track as the
2478 // destructor will acquire it.
2479 {
2480 Mutex::Autolock _cl(mClientLock);
2481 client.clear();
2482 }
Eric Laurent896c9672017-12-08 14:08:45 -08002483 recordTrack.clear();
2484 if (output.inputId != AUDIO_IO_HANDLE_NONE) {
Eric Laurentfee19762018-01-29 18:44:13 -08002485 AudioSystem::releaseInput(portId);
Eric Laurent896c9672017-12-08 14:08:45 -08002486 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002487 }
2488
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08002489 return lStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002490}
2491
Eric Laurentb8ba0a92011-08-07 16:32:26 -07002492
2493
Mathias Agopian65ab4712010-07-14 17:59:35 -07002494// ----------------------------------------------------------------------------
2495
Eric Laurenta4c5a552012-03-29 10:12:40 -07002496audio_module_handle_t AudioFlinger::loadHwModule(const char *name)
2497{
Eric Laurent44622db2014-08-01 19:00:33 -07002498 if (name == NULL) {
Glenn Kastena13cde92016-03-28 15:26:02 -07002499 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurent44622db2014-08-01 19:00:33 -07002500 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07002501 if (!settingsAllowed()) {
Glenn Kastena13cde92016-03-28 15:26:02 -07002502 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002503 }
2504 Mutex::Autolock _l(mLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002505 AutoMutex lock(mHardwareLock);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002506 return loadHwModule_l(name);
2507}
2508
Eric Laurent00abf0d2020-04-22 19:28:22 -07002509// loadHwModule_l() must be called with AudioFlinger::mLock and AudioFlinger::mHardwareLock held
Eric Laurenta4c5a552012-03-29 10:12:40 -07002510audio_module_handle_t AudioFlinger::loadHwModule_l(const char *name)
2511{
2512 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
2513 if (strncmp(mAudioHwDevs.valueAt(i)->moduleName(), name, strlen(name)) == 0) {
2514 ALOGW("loadHwModule() module %s already loaded", name);
2515 return mAudioHwDevs.keyAt(i);
2516 }
2517 }
2518
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002519 sp<DeviceHalInterface> dev;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002520
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002521 int rc = mDevicesFactoryHal->openDevice(name, &dev);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002522 if (rc) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002523 ALOGE("loadHwModule() error %d loading module %s", rc, name);
Glenn Kastena13cde92016-03-28 15:26:02 -07002524 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002525 }
2526
2527 mHardwareStatus = AUDIO_HW_INIT;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002528 rc = dev->initCheck();
Eric Laurenta4c5a552012-03-29 10:12:40 -07002529 mHardwareStatus = AUDIO_HW_IDLE;
2530 if (rc) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07002531 ALOGE("loadHwModule() init check error %d for module %s", rc, name);
Glenn Kastena13cde92016-03-28 15:26:02 -07002532 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002533 }
2534
John Grossmanee578c02012-07-23 17:05:46 -07002535 // Check and cache this HAL's level of support for master mute and master
2536 // volume. If this is the first HAL opened, and it supports the get
2537 // methods, use the initial values provided by the HAL as the current
2538 // master mute and volume settings.
2539
2540 AudioHwDevice::Flags flags = static_cast<AudioHwDevice::Flags>(0);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002541 if (0 == mAudioHwDevs.size()) {
2542 mHardwareStatus = AUDIO_HW_GET_MASTER_VOLUME;
2543 float mv;
2544 if (OK == dev->getMasterVolume(&mv)) {
2545 mMasterVolume = mv;
John Grossmanee578c02012-07-23 17:05:46 -07002546 }
2547
Eric Laurent00abf0d2020-04-22 19:28:22 -07002548 mHardwareStatus = AUDIO_HW_GET_MASTER_MUTE;
2549 bool mm;
2550 if (OK == dev->getMasterMute(&mm)) {
2551 mMasterMute = mm;
John Grossmanee578c02012-07-23 17:05:46 -07002552 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07002553 }
Eric Laurent00abf0d2020-04-22 19:28:22 -07002554
2555 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
2556 if (OK == dev->setMasterVolume(mMasterVolume)) {
2557 flags = static_cast<AudioHwDevice::Flags>(flags |
2558 AudioHwDevice::AHWD_CAN_SET_MASTER_VOLUME);
2559 }
2560
2561 mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE;
2562 if (OK == dev->setMasterMute(mMasterMute)) {
2563 flags = static_cast<AudioHwDevice::Flags>(flags |
2564 AudioHwDevice::AHWD_CAN_SET_MASTER_MUTE);
2565 }
2566
2567 mHardwareStatus = AUDIO_HW_IDLE;
2568
Mikhail Naganov97373b02018-07-23 13:27:24 -07002569 if (strcmp(name, AUDIO_HARDWARE_MODULE_ID_MSD) == 0) {
Mikhail Naganovadca70f2018-07-09 12:49:25 -07002570 // An MSD module is inserted before hardware modules in order to mix encoded streams.
2571 flags = static_cast<AudioHwDevice::Flags>(flags | AudioHwDevice::AHWD_IS_INSERT);
2572 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07002573
Glenn Kastena13cde92016-03-28 15:26:02 -07002574 audio_module_handle_t handle = (audio_module_handle_t) nextUniqueId(AUDIO_UNIQUE_ID_USE_MODULE);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002575 AudioHwDevice *audioDevice = new AudioHwDevice(handle, name, dev, flags);
2576 if (strcmp(name, AUDIO_HARDWARE_MODULE_ID_PRIMARY) == 0) {
2577 mPrimaryHardwareDev = audioDevice;
2578 mHardwareStatus = AUDIO_HW_SET_MODE;
2579 mPrimaryHardwareDev->hwDevice()->setMode(mMode);
2580 mHardwareStatus = AUDIO_HW_IDLE;
2581 }
2582
Shunkai Yao2b8fed42022-12-09 01:12:02 +00002583 if (mDevicesFactoryHal->getHalVersion() > kMaxAAudioPropertyDeviceHalVersion) {
jiabine504e7b2021-09-18 00:27:08 +00002584 if (int32_t mixerBursts = dev->getAAudioMixerBurstCount();
jiabina4ff38f2022-02-11 19:42:25 +00002585 mixerBursts > 0 && mixerBursts > mAAudioBurstsPerBuffer) {
jiabine504e7b2021-09-18 00:27:08 +00002586 mAAudioBurstsPerBuffer = mixerBursts;
2587 }
2588 if (int32_t hwBurstMinMicros = dev->getAAudioHardwareBurstMinUsec();
jiabina4ff38f2022-02-11 19:42:25 +00002589 hwBurstMinMicros > 0
2590 && (hwBurstMinMicros < mAAudioHwBurstMinMicros || mAAudioHwBurstMinMicros == 0)) {
jiabine504e7b2021-09-18 00:27:08 +00002591 mAAudioHwBurstMinMicros = hwBurstMinMicros;
2592 }
2593 }
2594
Eric Laurent00abf0d2020-04-22 19:28:22 -07002595 mAudioHwDevs.add(handle, audioDevice);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002596
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002597 ALOGI("loadHwModule() Loaded %s audio interface, handle %d", name, handle);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002598
2599 return handle;
2600
2601}
2602
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002603// ----------------------------------------------------------------------------
2604
Glenn Kasten3b16c762012-11-14 08:44:39 -08002605uint32_t AudioFlinger::getPrimaryOutputSamplingRate()
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002606{
2607 Mutex::Autolock _l(mLock);
Glenn Kastena7335632016-06-09 17:09:53 -07002608 PlaybackThread *thread = fastPlaybackThread_l();
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002609 return thread != NULL ? thread->sampleRate() : 0;
2610}
2611
Glenn Kastene33054e2012-11-14 12:54:39 -08002612size_t AudioFlinger::getPrimaryOutputFrameCount()
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002613{
2614 Mutex::Autolock _l(mLock);
Glenn Kastena7335632016-06-09 17:09:53 -07002615 PlaybackThread *thread = fastPlaybackThread_l();
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07002616 return thread != NULL ? thread->frameCountHAL() : 0;
2617}
2618
2619// ----------------------------------------------------------------------------
2620
Andy Hung6f248bb2018-01-23 14:04:37 -08002621status_t AudioFlinger::setLowRamDevice(bool isLowRamDevice, int64_t totalMemory)
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002622{
2623 uid_t uid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -07002624 if (!isAudioServerOrSystemServerUid(uid)) {
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002625 return PERMISSION_DENIED;
2626 }
2627 Mutex::Autolock _l(mLock);
2628 if (mIsDeviceTypeKnown) {
2629 return INVALID_OPERATION;
2630 }
2631 mIsLowRamDevice = isLowRamDevice;
Andy Hung6f248bb2018-01-23 14:04:37 -08002632 mTotalMemory = totalMemory;
2633 // mIsLowRamDevice and mTotalMemory are obtained through ActivityManager;
2634 // see ActivityManager.isLowRamDevice() and ActivityManager.getMemoryInfo().
2635 // mIsLowRamDevice generally represent devices with less than 1GB of memory,
2636 // though actual setting is determined through device configuration.
2637 constexpr int64_t GB = 1024 * 1024 * 1024;
2638 mClientSharedHeapSize =
2639 isLowRamDevice ? kMinimumClientSharedHeapSizeBytes
2640 : mTotalMemory < 2 * GB ? 4 * kMinimumClientSharedHeapSizeBytes
2641 : mTotalMemory < 3 * GB ? 8 * kMinimumClientSharedHeapSizeBytes
2642 : mTotalMemory < 4 * GB ? 16 * kMinimumClientSharedHeapSizeBytes
2643 : 32 * kMinimumClientSharedHeapSizeBytes;
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002644 mIsDeviceTypeKnown = true;
Andy Hung6f248bb2018-01-23 14:04:37 -08002645
2646 // TODO: Cache the client shared heap size in a persistent property.
2647 // It's possible that a native process or Java service or app accesses audioserver
2648 // after it is registered by system server, but before AudioService updates
2649 // the memory info. This would occur immediately after boot or an audioserver
2650 // crash and restore. Before update from AudioService, the client would get the
2651 // minimum heap size.
2652
2653 ALOGD("isLowRamDevice:%s totalMemory:%lld mClientSharedHeapSize:%zu",
2654 (isLowRamDevice ? "true" : "false"),
2655 (long long)mTotalMemory,
2656 mClientSharedHeapSize.load());
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002657 return NO_ERROR;
2658}
2659
Andy Hung6f248bb2018-01-23 14:04:37 -08002660size_t AudioFlinger::getClientSharedHeapSize() const
2661{
2662 size_t heapSizeInBytes = property_get_int32("ro.af.client_heap_size_kbyte", 0) * 1024;
2663 if (heapSizeInBytes != 0) { // read-only property overrides all.
2664 return heapSizeInBytes;
2665 }
2666 return mClientSharedHeapSize;
2667}
2668
Mikhail Naganovdea53042018-04-26 13:10:21 -07002669status_t AudioFlinger::setAudioPortConfig(const struct audio_port_config *config)
2670{
2671 ALOGV(__func__);
2672
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08002673 status_t status = AudioValidator::validateAudioPortConfig(*config);
2674 if (status != NO_ERROR) {
2675 return status;
2676 }
2677
Mikhail Naganovdea53042018-04-26 13:10:21 -07002678 audio_module_handle_t module;
2679 if (config->type == AUDIO_PORT_TYPE_DEVICE) {
2680 module = config->ext.device.hw_module;
2681 } else {
2682 module = config->ext.mix.hw_module;
2683 }
2684
2685 Mutex::Autolock _l(mLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002686 AutoMutex lock(mHardwareLock);
Mikhail Naganovdea53042018-04-26 13:10:21 -07002687 ssize_t index = mAudioHwDevs.indexOfKey(module);
2688 if (index < 0) {
2689 ALOGW("%s() bad hw module %d", __func__, module);
2690 return BAD_VALUE;
2691 }
2692
2693 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueAt(index);
2694 return audioHwDevice->hwDevice()->setAudioPortConfig(config);
2695}
2696
Eric Laurent93c3d412014-08-01 14:48:35 -07002697audio_hw_sync_t AudioFlinger::getAudioHwSyncForSession(audio_session_t sessionId)
2698{
2699 Mutex::Autolock _l(mLock);
Eric Laurentfa90e842014-10-17 18:12:31 -07002700
2701 ssize_t index = mHwAvSyncIds.indexOfKey(sessionId);
2702 if (index >= 0) {
2703 ALOGV("getAudioHwSyncForSession found ID %d for session %d",
2704 mHwAvSyncIds.valueAt(index), sessionId);
2705 return mHwAvSyncIds.valueAt(index);
2706 }
2707
Eric Laurent00abf0d2020-04-22 19:28:22 -07002708 sp<DeviceHalInterface> dev;
2709 {
2710 AutoMutex lock(mHardwareLock);
2711 if (mPrimaryHardwareDev == nullptr) {
2712 return AUDIO_HW_SYNC_INVALID;
2713 }
2714 dev = mPrimaryHardwareDev->hwDevice();
2715 }
2716 if (dev == nullptr) {
Eric Laurentfa90e842014-10-17 18:12:31 -07002717 return AUDIO_HW_SYNC_INVALID;
2718 }
Eric Laurentfa90e842014-10-17 18:12:31 -07002719
Ytai Ben-Tsvi48287b52021-12-01 15:07:11 -08002720 error::Result<audio_hw_sync_t> result = dev->getHwAvSync();
2721 if (!result.ok()) {
Eric Laurentfa90e842014-10-17 18:12:31 -07002722 ALOGW("getAudioHwSyncForSession error getting sync for session %d", sessionId);
2723 return AUDIO_HW_SYNC_INVALID;
2724 }
Ytai Ben-Tsvi48287b52021-12-01 15:07:11 -08002725 audio_hw_sync_t value = VALUE_OR_FATAL(result);
Eric Laurentfa90e842014-10-17 18:12:31 -07002726
2727 // allow only one session for a given HW A/V sync ID.
2728 for (size_t i = 0; i < mHwAvSyncIds.size(); i++) {
Ytai Ben-Tsvi48287b52021-12-01 15:07:11 -08002729 if (mHwAvSyncIds.valueAt(i) == value) {
Eric Laurentfa90e842014-10-17 18:12:31 -07002730 ALOGV("getAudioHwSyncForSession removing ID %d for session %d",
2731 value, mHwAvSyncIds.keyAt(i));
2732 mHwAvSyncIds.removeItemsAt(i);
Eric Laurent93c3d412014-08-01 14:48:35 -07002733 break;
2734 }
2735 }
Eric Laurentfa90e842014-10-17 18:12:31 -07002736
2737 mHwAvSyncIds.add(sessionId, value);
2738
2739 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2740 sp<PlaybackThread> thread = mPlaybackThreads.valueAt(i);
2741 uint32_t sessions = thread->hasAudioSession(sessionId);
Eric Laurent4c415062016-06-17 16:14:16 -07002742 if (sessions & ThreadBase::TRACK_SESSION) {
Eric Laurentfa90e842014-10-17 18:12:31 -07002743 AudioParameter param = AudioParameter();
Mikhail Naganov00260b52016-10-13 12:54:24 -07002744 param.addInt(String8(AudioParameter::keyStreamHwAvSync), value);
Mikhail Naganovb261ef52018-07-16 13:34:38 -07002745 String8 keyValuePairs = param.toString();
2746 thread->setParameters(keyValuePairs);
2747 forwardParametersToDownstreamPatches_l(thread->id(), keyValuePairs,
2748 [](const sp<PlaybackThread>& thread) { return thread->usesHwAvSync(); });
Eric Laurentfa90e842014-10-17 18:12:31 -07002749 break;
2750 }
2751 }
2752
2753 ALOGV("getAudioHwSyncForSession adding ID %d for session %d", value, sessionId);
2754 return (audio_hw_sync_t)value;
Eric Laurent93c3d412014-08-01 14:48:35 -07002755}
2756
Eric Laurent72e3f392015-05-20 14:43:50 -07002757status_t AudioFlinger::systemReady()
2758{
2759 Mutex::Autolock _l(mLock);
2760 ALOGI("%s", __FUNCTION__);
2761 if (mSystemReady) {
2762 ALOGW("%s called twice", __FUNCTION__);
2763 return NO_ERROR;
2764 }
2765 mSystemReady = true;
2766 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2767 ThreadBase *thread = (ThreadBase *)mPlaybackThreads.valueAt(i).get();
2768 thread->systemReady();
2769 }
2770 for (size_t i = 0; i < mRecordThreads.size(); i++) {
2771 ThreadBase *thread = (ThreadBase *)mRecordThreads.valueAt(i).get();
2772 thread->systemReady();
2773 }
Eric Laurentd66d7a12021-07-13 13:35:32 +02002774 for (size_t i = 0; i < mMmapThreads.size(); i++) {
2775 ThreadBase *thread = (ThreadBase *)mMmapThreads.valueAt(i).get();
2776 thread->systemReady();
2777 }
Vlad Popae8d99472022-06-30 16:02:48 +02002778
2779 // Java services are ready, so we can create a reference to AudioService
2780 getOrCreateAudioManager();
2781
Eric Laurent72e3f392015-05-20 14:43:50 -07002782 return NO_ERROR;
2783}
2784
Vlad Popae8d99472022-06-30 16:02:48 +02002785sp<IAudioManager> AudioFlinger::getOrCreateAudioManager()
2786{
2787 if (mAudioManager.load() == nullptr) {
2788 // use checkService() to avoid blocking
2789 sp<IBinder> binder =
2790 defaultServiceManager()->checkService(String16(kAudioServiceName));
2791 if (binder != nullptr) {
2792 mAudioManager = interface_cast<IAudioManager>(binder);
2793 } else {
2794 ALOGE("%s(): binding to audio service failed.", __func__);
2795 }
2796 }
2797 return mAudioManager.load();
2798}
2799
jiabin46a76fa2018-01-05 10:18:21 -08002800status_t AudioFlinger::getMicrophones(std::vector<media::MicrophoneInfo> *microphones)
2801{
jiabin9ff780e2018-03-19 18:19:52 -07002802 AutoMutex lock(mHardwareLock);
Eric Laurent00abf0d2020-04-22 19:28:22 -07002803 status_t status = INVALID_OPERATION;
2804
2805 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
2806 std::vector<media::MicrophoneInfo> mics;
2807 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
2808 mHardwareStatus = AUDIO_HW_GET_MICROPHONES;
2809 status_t devStatus = dev->hwDevice()->getMicrophones(&mics);
2810 mHardwareStatus = AUDIO_HW_IDLE;
2811 if (devStatus == NO_ERROR) {
2812 microphones->insert(microphones->begin(), mics.begin(), mics.end());
2813 // report success if at least one HW module supports the function.
2814 status = NO_ERROR;
2815 }
2816 }
2817
jiabin9ff780e2018-03-19 18:19:52 -07002818 return status;
jiabin46a76fa2018-01-05 10:18:21 -08002819}
2820
Eric Laurentfa90e842014-10-17 18:12:31 -07002821// setAudioHwSyncForSession_l() must be called with AudioFlinger::mLock held
2822void AudioFlinger::setAudioHwSyncForSession_l(PlaybackThread *thread, audio_session_t sessionId)
2823{
2824 ssize_t index = mHwAvSyncIds.indexOfKey(sessionId);
2825 if (index >= 0) {
2826 audio_hw_sync_t syncId = mHwAvSyncIds.valueAt(index);
2827 ALOGV("setAudioHwSyncForSession_l found ID %d for session %d", syncId, sessionId);
2828 AudioParameter param = AudioParameter();
Mikhail Naganov00260b52016-10-13 12:54:24 -07002829 param.addInt(String8(AudioParameter::keyStreamHwAvSync), syncId);
Mikhail Naganovb261ef52018-07-16 13:34:38 -07002830 String8 keyValuePairs = param.toString();
2831 thread->setParameters(keyValuePairs);
2832 forwardParametersToDownstreamPatches_l(thread->id(), keyValuePairs,
2833 [](const sp<PlaybackThread>& thread) { return thread->usesHwAvSync(); });
Eric Laurentfa90e842014-10-17 18:12:31 -07002834 }
2835}
2836
2837
Glenn Kasten4182c4e2013-07-15 14:45:07 -07002838// ----------------------------------------------------------------------------
2839
Eric Laurent83b88082014-06-20 18:31:16 -07002840
Eric Laurent6acd1d42017-01-04 14:23:29 -08002841sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t module,
jiabin43810402019-10-24 14:58:31 -07002842 audio_io_handle_t *output,
Eric Laurentf1f22e72021-07-13 14:04:14 +02002843 audio_config_t *halConfig,
2844 audio_config_base_t *mixerConfig __unused,
jiabin43810402019-10-24 14:58:31 -07002845 audio_devices_t deviceType,
2846 const String8& address,
2847 audio_output_flags_t flags)
Eric Laurent83b88082014-06-20 18:31:16 -07002848{
jiabin43810402019-10-24 14:58:31 -07002849 AudioHwDevice *outHwDev = findSuitableHwDev_l(module, deviceType);
Eric Laurent83b88082014-06-20 18:31:16 -07002850 if (outHwDev == NULL) {
Eric Laurente28c66d2022-01-21 13:40:41 +01002851 return nullptr;
Eric Laurent83b88082014-06-20 18:31:16 -07002852 }
2853
Eric Laurentcf2c0212014-07-25 16:20:43 -07002854 if (*output == AUDIO_IO_HANDLE_NONE) {
Glenn Kasteneeecb982016-02-26 10:44:04 -08002855 *output = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);
2856 } else {
2857 // Audio Policy does not currently request a specific output handle.
2858 // If this is ever needed, see openInput_l() for example code.
2859 ALOGE("openOutput_l requested output handle %d is not AUDIO_IO_HANDLE_NONE", *output);
Eric Laurente28c66d2022-01-21 13:40:41 +01002860 return nullptr;
Eric Laurentcf2c0212014-07-25 16:20:43 -07002861 }
Eric Laurent83b88082014-06-20 18:31:16 -07002862
Eric Laurente28c66d2022-01-21 13:40:41 +01002863#ifndef MULTICHANNEL_EFFECT_CHAIN
2864 if (flags & AUDIO_OUTPUT_FLAG_SPATIALIZER) {
2865 ALOGE("openOutput_l() cannot create spatializer thread "
2866 "without #define MULTICHANNEL_EFFECT_CHAIN");
2867 return nullptr;
2868 }
2869#endif
2870
Eric Laurent83b88082014-06-20 18:31:16 -07002871 mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;
2872
Eric Laurent83b88082014-06-20 18:31:16 -07002873 // FOR TESTING ONLY:
Andy Hung9a592762014-07-21 21:56:01 -07002874 // This if statement allows overriding the audio policy settings
2875 // and forcing a specific format or channel mask to the HAL/Sink device for testing.
2876 if (!(flags & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD | AUDIO_OUTPUT_FLAG_DIRECT))) {
2877 // Check only for Normal Mixing mode
2878 if (kEnableExtendedPrecision) {
2879 // Specify format (uncomment one below to choose)
Eric Laurentf1f22e72021-07-13 14:04:14 +02002880 //halConfig->format = AUDIO_FORMAT_PCM_FLOAT;
2881 //halConfig->format = AUDIO_FORMAT_PCM_24_BIT_PACKED;
2882 //halConfig->format = AUDIO_FORMAT_PCM_32_BIT;
2883 //halConfig->format = AUDIO_FORMAT_PCM_8_24_BIT;
2884 // ALOGV("openOutput_l() upgrading format to %#08x", halConfig->format);
Andy Hung9a592762014-07-21 21:56:01 -07002885 }
2886 if (kEnableExtendedChannels) {
2887 // Specify channel mask (uncomment one below to choose)
Eric Laurentf1f22e72021-07-13 14:04:14 +02002888 //halConfig->channel_mask = audio_channel_out_mask_from_count(4); // for USB 4ch
2889 //halConfig->channel_mask = audio_channel_mask_from_representation_and_bits(
Andy Hung9a592762014-07-21 21:56:01 -07002890 // AUDIO_CHANNEL_REPRESENTATION_INDEX, (1 << 4) - 1); // another 4ch example
2891 }
Eric Laurent83b88082014-06-20 18:31:16 -07002892 }
2893
Phil Burk062e67a2015-02-11 13:40:50 -08002894 AudioStreamOut *outputStream = NULL;
2895 status_t status = outHwDev->openOutputStream(
2896 &outputStream,
2897 *output,
jiabin43810402019-10-24 14:58:31 -07002898 deviceType,
Phil Burk062e67a2015-02-11 13:40:50 -08002899 flags,
Eric Laurentf1f22e72021-07-13 14:04:14 +02002900 halConfig,
Phil Burk062e67a2015-02-11 13:40:50 -08002901 address.string());
Eric Laurent83b88082014-06-20 18:31:16 -07002902
2903 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent83b88082014-06-20 18:31:16 -07002904
Phil Burk062e67a2015-02-11 13:40:50 -08002905 if (status == NO_ERROR) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08002906 if (flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) {
2907 sp<MmapPlaybackThread> thread =
jiabinc52b1ff2019-10-31 17:20:42 -07002908 new MmapPlaybackThread(this, *output, outHwDev, outputStream, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002909 mMmapThreads.add(*output, thread);
2910 ALOGV("openOutput_l() created mmap playback thread: ID %d thread %p",
2911 *output, thread.get());
2912 return thread;
Eric Laurent83b88082014-06-20 18:31:16 -07002913 } else {
Eric Laurent6acd1d42017-01-04 14:23:29 -08002914 sp<PlaybackThread> thread;
Eric Laurente28c66d2022-01-21 13:40:41 +01002915 if (flags & AUDIO_OUTPUT_FLAG_SPATIALIZER) {
Eric Laurentfa0f6742021-08-17 18:39:44 +02002916 thread = new SpatializerThread(this, outputStream, *output,
Eric Laurentb3f315a2021-07-13 15:09:05 +02002917 mSystemReady, mixerConfig);
Eric Laurente28c66d2022-01-21 13:40:41 +01002918 ALOGV("openOutput_l() created spatializer output: ID %d thread %p",
Eric Laurentb3f315a2021-07-13 15:09:05 +02002919 *output, thread.get());
2920 } else if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
Gareth Fennb18c1a32022-10-05 13:42:36 -07002921 thread = new OffloadThread(this, outputStream, *output,
2922 mSystemReady, halConfig->offload_info);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002923 ALOGV("openOutput_l() created offload output: ID %d thread %p",
2924 *output, thread.get());
2925 } else if ((flags & AUDIO_OUTPUT_FLAG_DIRECT)
Eric Laurentf1f22e72021-07-13 14:04:14 +02002926 || !isValidPcmSinkFormat(halConfig->format)
2927 || !isValidPcmSinkChannelMask(halConfig->channel_mask)) {
Gareth Fennb18c1a32022-10-05 13:42:36 -07002928 thread = new DirectOutputThread(this, outputStream, *output,
2929 mSystemReady, halConfig->offload_info);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002930 ALOGV("openOutput_l() created direct output: ID %d thread %p",
2931 *output, thread.get());
2932 } else {
jiabinc52b1ff2019-10-31 17:20:42 -07002933 thread = new MixerThread(this, outputStream, *output, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002934 ALOGV("openOutput_l() created mixer output: ID %d thread %p",
2935 *output, thread.get());
2936 }
2937 mPlaybackThreads.add(*output, thread);
Eric Laurent74c38dc2020-12-23 18:19:44 +01002938 struct audio_patch patch;
2939 mPatchPanel.notifyStreamOpened(outHwDev, *output, &patch);
2940 if (thread->isMsdDevice()) {
2941 thread->setDownStreamPatch(&patch);
2942 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08002943 return thread;
Eric Laurent83b88082014-06-20 18:31:16 -07002944 }
Eric Laurent83b88082014-06-20 18:31:16 -07002945 }
2946
Eric Laurente28c66d2022-01-21 13:40:41 +01002947 return nullptr;
Eric Laurent83b88082014-06-20 18:31:16 -07002948}
2949
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08002950status_t AudioFlinger::openOutput(const media::OpenOutputRequest& request,
2951 media::OpenOutputResponse* response)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002952{
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08002953 audio_module_handle_t module = VALUE_OR_RETURN_STATUS(
2954 aidl2legacy_int32_t_audio_module_handle_t(request.module));
Eric Laurentf1f22e72021-07-13 14:04:14 +02002955 audio_config_t halConfig = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -07002956 aidl2legacy_AudioConfig_audio_config_t(request.halConfig, false /*isInput*/));
Eric Laurentf1f22e72021-07-13 14:04:14 +02002957 audio_config_base_t mixerConfig = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -07002958 aidl2legacy_AudioConfigBase_audio_config_base_t(request.mixerConfig, false/*isInput*/));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08002959 sp<DeviceDescriptorBase> device = VALUE_OR_RETURN_STATUS(
2960 aidl2legacy_DeviceDescriptorBase(request.device));
2961 audio_output_flags_t flags = VALUE_OR_RETURN_STATUS(
Andy Hung973638a2020-12-08 20:47:45 -08002962 aidl2legacy_int32_t_audio_output_flags_t_mask(request.flags));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08002963
2964 audio_io_handle_t output;
2965 uint32_t latencyMs;
2966
jiabin43810402019-10-24 14:58:31 -07002967 ALOGI("openOutput() this %p, module %d Device %s, SamplingRate %d, Format %#08x, "
Glenn Kasten49f36ba2017-12-06 13:02:02 -08002968 "Channels %#x, flags %#x",
Eric Laurent6acd1d42017-01-04 14:23:29 -08002969 this, module,
jiabin43810402019-10-24 14:58:31 -07002970 device->toString().c_str(),
Eric Laurentf1f22e72021-07-13 14:04:14 +02002971 halConfig.sample_rate,
2972 halConfig.format,
2973 halConfig.channel_mask,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002974 flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002975
jiabin43810402019-10-24 14:58:31 -07002976 audio_devices_t deviceType = device->type();
2977 const String8 address = String8(device->address().c_str());
2978
2979 if (deviceType == AUDIO_DEVICE_NONE) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07002980 return BAD_VALUE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002981 }
Dima Zavin799a70e2011-04-18 16:57:27 -07002982
Mathias Agopian65ab4712010-07-14 17:59:35 -07002983 Mutex::Autolock _l(mLock);
2984
Eric Laurentf1f22e72021-07-13 14:04:14 +02002985 sp<ThreadBase> thread = openOutput_l(module, &output, &halConfig,
2986 &mixerConfig, deviceType, address, flags);
Eric Laurent83b88082014-06-20 18:31:16 -07002987 if (thread != 0) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08002988 if ((flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) == 0) {
2989 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08002990 latencyMs = playbackThread->latency();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002991
Eric Laurent6acd1d42017-01-04 14:23:29 -08002992 // notify client processes of the new output creation
2993 playbackThread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002994
Eric Laurent00abf0d2020-04-22 19:28:22 -07002995 // the first primary output opened designates the primary hw device if no HW module
2996 // named "primary" was already loaded.
2997 AutoMutex lock(mHardwareLock);
2998 if ((mPrimaryHardwareDev == nullptr) && (flags & AUDIO_OUTPUT_FLAG_PRIMARY)) {
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08002999 ALOGI("Using module %d as the primary audio interface", module);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003000 mPrimaryHardwareDev = playbackThread->getOutput()->audioHwDev;
Eric Laurenta4c5a552012-03-29 10:12:40 -07003001
Eric Laurent6acd1d42017-01-04 14:23:29 -08003002 mHardwareStatus = AUDIO_HW_SET_MODE;
3003 mPrimaryHardwareDev->hwDevice()->setMode(mMode);
3004 mHardwareStatus = AUDIO_HW_IDLE;
3005 }
3006 } else {
3007 MmapThread *mmapThread = (MmapThread *)thread.get();
3008 mmapThread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
Eric Laurenta4c5a552012-03-29 10:12:40 -07003009 }
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08003010 response->output = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
Mikhail Naganovde3fa182021-07-30 15:06:42 -07003011 response->config = VALUE_OR_RETURN_STATUS(
3012 legacy2aidl_audio_config_t_AudioConfig(halConfig, false /*isInput*/));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -08003013 response->latencyMs = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(latencyMs));
Andy Hung973638a2020-12-08 20:47:45 -08003014 response->flags = VALUE_OR_RETURN_STATUS(
3015 legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
Eric Laurentcf2c0212014-07-25 16:20:43 -07003016 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003017 }
3018
Eric Laurentcf2c0212014-07-25 16:20:43 -07003019 return NO_INIT;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003020}
3021
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003022audio_io_handle_t AudioFlinger::openDuplicateOutput(audio_io_handle_t output1,
3023 audio_io_handle_t output2)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003024{
3025 Mutex::Autolock _l(mLock);
3026 MixerThread *thread1 = checkMixerThread_l(output1);
3027 MixerThread *thread2 = checkMixerThread_l(output2);
3028
3029 if (thread1 == NULL || thread2 == NULL) {
Glenn Kasten85ab62c2012-11-01 11:11:38 -07003030 ALOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1,
3031 output2);
Glenn Kasten142f5192014-03-25 17:44:59 -07003032 return AUDIO_IO_HANDLE_NONE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003033 }
3034
Glenn Kasteneeecb982016-02-26 10:44:04 -08003035 audio_io_handle_t id = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);
Eric Laurent72e3f392015-05-20 14:43:50 -07003036 DuplicatingThread *thread = new DuplicatingThread(this, thread1, id, mSystemReady);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003037 thread->addOutputTrack(thread2);
3038 mPlaybackThreads.add(id, thread);
3039 // notify client processes of the new output creation
Eric Laurent73e26b62015-04-27 16:55:58 -07003040 thread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003041 return id;
3042}
3043
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003044status_t AudioFlinger::closeOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003045{
Glenn Kastend96c5722012-04-25 13:44:49 -07003046 return closeOutput_nonvirtual(output);
3047}
3048
3049status_t AudioFlinger::closeOutput_nonvirtual(audio_io_handle_t output)
3050{
Mathias Agopian65ab4712010-07-14 17:59:35 -07003051 // keep strong reference on the playback thread so that
3052 // it is not destroyed while exit() is executed
Eric Laurent6acd1d42017-01-04 14:23:29 -08003053 sp<PlaybackThread> playbackThread;
3054 sp<MmapPlaybackThread> mmapThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003055 {
3056 Mutex::Autolock _l(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003057 playbackThread = checkPlaybackThread_l(output);
3058 if (playbackThread != NULL) {
3059 ALOGV("closeOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003060
Andy Hungdc099c22018-09-18 13:46:39 -07003061 dumpToThreadLog_l(playbackThread);
Andy Hunga8115dc2018-08-24 15:51:59 -07003062
Eric Laurent6acd1d42017-01-04 14:23:29 -08003063 if (playbackThread->type() == ThreadBase::MIXER) {
3064 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3065 if (mPlaybackThreads.valueAt(i)->isDuplicating()) {
3066 DuplicatingThread *dupThread =
3067 (DuplicatingThread *)mPlaybackThreads.valueAt(i).get();
3068 dupThread->removeOutputTrack((MixerThread *)playbackThread.get());
3069 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003070 }
3071 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08003072
3073
Eric Laurent6acd1d42017-01-04 14:23:29 -08003074 mPlaybackThreads.removeItem(output);
3075 // save all effects to the default thread
3076 if (mPlaybackThreads.size()) {
3077 PlaybackThread *dstThread = checkPlaybackThread_l(mPlaybackThreads.keyAt(0));
3078 if (dstThread != NULL) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08003079 // audioflinger lock is held so order of thread lock acquisition doesn't matter
Eric Laurent6acd1d42017-01-04 14:23:29 -08003080 Mutex::Autolock _dl(dstThread->mLock);
3081 Mutex::Autolock _sl(playbackThread->mLock);
3082 Vector< sp<EffectChain> > effectChains = playbackThread->getEffectChains_l();
3083 for (size_t i = 0; i < effectChains.size(); i ++) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08003084 moveEffectChain_l(effectChains[i]->sessionId(), playbackThread.get(),
Eric Laurent6c796322019-04-09 14:13:17 -07003085 dstThread);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003086 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003087 }
3088 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003089 } else {
3090 mmapThread = (MmapPlaybackThread *)checkMmapThread_l(output);
3091 if (mmapThread == 0) {
3092 return BAD_VALUE;
3093 }
Andy Hungdc099c22018-09-18 13:46:39 -07003094 dumpToThreadLog_l(mmapThread);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003095 mMmapThreads.removeItem(output);
Phil Burk7f6b40d2017-02-09 13:18:38 -08003096 ALOGD("closing mmapThread %p", mmapThread.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003097 }
Mikhail Naganov88536df2021-07-26 17:30:29 -07003098 ioConfigChanged(AUDIO_OUTPUT_CLOSED, sp<AudioIoDescriptor>::make(output));
Mikhail Naganovadca70f2018-07-09 12:49:25 -07003099 mPatchPanel.notifyStreamClosed(output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003100 }
Glenn Kastenb28686f2012-01-06 08:39:38 -08003101 // The thread entity (active unit of execution) is no longer running here,
3102 // but the ThreadBase container still exists.
Mathias Agopian65ab4712010-07-14 17:59:35 -07003103
Eric Laurent6acd1d42017-01-04 14:23:29 -08003104 if (playbackThread != 0) {
3105 playbackThread->exit();
3106 if (!playbackThread->isDuplicating()) {
3107 closeOutputFinish(playbackThread);
3108 }
3109 } else if (mmapThread != 0) {
Phil Burk7f6b40d2017-02-09 13:18:38 -08003110 ALOGD("mmapThread exit()");
Eric Laurent6acd1d42017-01-04 14:23:29 -08003111 mmapThread->exit();
3112 AudioStreamOut *out = mmapThread->clearOutput();
3113 ALOG_ASSERT(out != NULL, "out shouldn't be NULL");
3114 // from now on thread->mOutput is NULL
3115 delete out;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003116 }
3117 return NO_ERROR;
3118}
3119
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -07003120void AudioFlinger::closeOutputFinish(const sp<PlaybackThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07003121{
3122 AudioStreamOut *out = thread->clearOutput();
3123 ALOG_ASSERT(out != NULL, "out shouldn't be NULL");
3124 // from now on thread->mOutput is NULL
Eric Laurent83b88082014-06-20 18:31:16 -07003125 delete out;
3126}
3127
Mikhail Naganov444ecc32018-05-01 17:40:05 -07003128void AudioFlinger::closeThreadInternal_l(const sp<PlaybackThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07003129{
3130 mPlaybackThreads.removeItem(thread->mId);
3131 thread->exit();
3132 closeOutputFinish(thread);
3133}
3134
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003135status_t AudioFlinger::suspendOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003136{
3137 Mutex::Autolock _l(mLock);
3138 PlaybackThread *thread = checkPlaybackThread_l(output);
3139
3140 if (thread == NULL) {
3141 return BAD_VALUE;
3142 }
3143
Steve Block3856b092011-10-20 11:56:00 +01003144 ALOGV("suspendOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003145 thread->suspend();
3146
3147 return NO_ERROR;
3148}
3149
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003150status_t AudioFlinger::restoreOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003151{
3152 Mutex::Autolock _l(mLock);
3153 PlaybackThread *thread = checkPlaybackThread_l(output);
3154
3155 if (thread == NULL) {
3156 return BAD_VALUE;
3157 }
3158
Steve Block3856b092011-10-20 11:56:00 +01003159 ALOGV("restoreOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003160
3161 thread->restore();
3162
3163 return NO_ERROR;
3164}
3165
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003166status_t AudioFlinger::openInput(const media::OpenInputRequest& request,
3167 media::OpenInputResponse* response)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003168{
Eric Laurent83b88082014-06-20 18:31:16 -07003169 Mutex::Autolock _l(mLock);
3170
Mikhail Naganov21a32ec2021-07-08 14:40:12 -07003171 AudioDeviceTypeAddr device = VALUE_OR_RETURN_STATUS(
3172 aidl2legacy_AudioDeviceTypeAddress(request.device));
3173 if (device.mType == AUDIO_DEVICE_NONE) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07003174 return BAD_VALUE;
Eric Laurent83b88082014-06-20 18:31:16 -07003175 }
3176
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003177 audio_io_handle_t input = VALUE_OR_RETURN_STATUS(
3178 aidl2legacy_int32_t_audio_io_handle_t(request.input));
3179 audio_config_t config = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -07003180 aidl2legacy_AudioConfig_audio_config_t(request.config, true /*isInput*/));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003181
Mikhail Naganovb4e037e2019-01-14 15:56:33 -08003182 sp<ThreadBase> thread = openInput_l(
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003183 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_module_handle_t(request.module)),
3184 &input,
3185 &config,
3186 device.mType,
3187 device.address().c_str(),
Mikhail Naganovddceecc2021-09-03 13:58:56 -07003188 VALUE_OR_RETURN_STATUS(aidl2legacy_AudioSource_audio_source_t(request.source)),
Andy Hung973638a2020-12-08 20:47:45 -08003189 VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_input_flags_t_mask(request.flags)),
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003190 AUDIO_DEVICE_NONE,
3191 String8{});
3192
3193 response->input = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(input));
Mikhail Naganovde3fa182021-07-30 15:06:42 -07003194 response->config = VALUE_OR_RETURN_STATUS(
3195 legacy2aidl_audio_config_t_AudioConfig(config, true /*isInput*/));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003196 response->device = request.device;
Eric Laurent83b88082014-06-20 18:31:16 -07003197
3198 if (thread != 0) {
Eric Laurent83b88082014-06-20 18:31:16 -07003199 // notify client processes of the new input creation
Eric Laurent73e26b62015-04-27 16:55:58 -07003200 thread->ioConfigChanged(AUDIO_INPUT_OPENED);
Eric Laurentcf2c0212014-07-25 16:20:43 -07003201 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003202 }
Eric Laurentcf2c0212014-07-25 16:20:43 -07003203 return NO_INIT;
Eric Laurent83b88082014-06-20 18:31:16 -07003204}
Dima Zavin799a70e2011-04-18 16:57:27 -07003205
Eric Laurent6acd1d42017-01-04 14:23:29 -08003206sp<AudioFlinger::ThreadBase> AudioFlinger::openInput_l(audio_module_handle_t module,
Eric Laurentcf2c0212014-07-25 16:20:43 -07003207 audio_io_handle_t *input,
3208 audio_config_t *config,
Glenn Kastene7d66712015-03-05 13:46:52 -08003209 audio_devices_t devices,
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003210 const char* address,
Eric Laurentcf2c0212014-07-25 16:20:43 -07003211 audio_source_t source,
Mikhail Naganovb4e037e2019-01-14 15:56:33 -08003212 audio_input_flags_t flags,
3213 audio_devices_t outputDevice,
3214 const String8& outputDeviceAddress)
Eric Laurent83b88082014-06-20 18:31:16 -07003215{
Glenn Kastene7d66712015-03-05 13:46:52 -08003216 AudioHwDevice *inHwDev = findSuitableHwDev_l(module, devices);
Glenn Kasten6e2ebe92013-08-13 09:14:51 -07003217 if (inHwDev == NULL) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07003218 *input = AUDIO_IO_HANDLE_NONE;
Dima Zavin799a70e2011-04-18 16:57:27 -07003219 return 0;
Glenn Kasten6e2ebe92013-08-13 09:14:51 -07003220 }
Dima Zavin799a70e2011-04-18 16:57:27 -07003221
Glenn Kasteneeecb982016-02-26 10:44:04 -08003222 // Audio Policy can request a specific handle for hardware hotword.
3223 // The goal here is not to re-open an already opened input.
3224 // It is to use a pre-assigned I/O handle.
Eric Laurentcf2c0212014-07-25 16:20:43 -07003225 if (*input == AUDIO_IO_HANDLE_NONE) {
Glenn Kasteneeecb982016-02-26 10:44:04 -08003226 *input = nextUniqueId(AUDIO_UNIQUE_ID_USE_INPUT);
3227 } else if (audio_unique_id_get_use(*input) != AUDIO_UNIQUE_ID_USE_INPUT) {
3228 ALOGE("openInput_l() requested input handle %d is invalid", *input);
3229 return 0;
3230 } else if (mRecordThreads.indexOfKey(*input) >= 0) {
3231 // This should not happen in a transient state with current design.
3232 ALOGE("openInput_l() requested input handle %d is already assigned", *input);
3233 return 0;
Eric Laurentcf2c0212014-07-25 16:20:43 -07003234 }
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07003235
Eric Laurentcf2c0212014-07-25 16:20:43 -07003236 audio_config_t halconfig = *config;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07003237 sp<DeviceHalInterface> inHwHal = inHwDev->hwDevice();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003238 sp<StreamInHalInterface> inStream;
3239 status_t status = inHwHal->openInputStream(
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003240 *input, devices, &halconfig, flags, address, source,
Mikhail Naganovb4e037e2019-01-14 15:56:33 -08003241 outputDevice, outputDeviceAddress, &inStream);
Glenn Kasten49f36ba2017-12-06 13:02:02 -08003242 ALOGV("openInput_l() openInputStream returned input %p, devices %#x, SamplingRate %d"
3243 ", Format %#x, Channels %#x, flags %#x, status %d addr %s",
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003244 inStream.get(),
Mikhail Naganovf558e022016-11-14 17:45:17 -08003245 devices,
Eric Laurentcf2c0212014-07-25 16:20:43 -07003246 halconfig.sample_rate,
3247 halconfig.format,
3248 halconfig.channel_mask,
Glenn Kastenec40d282014-07-15 15:31:26 -07003249 flags,
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003250 status, address);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003251
Glenn Kasten85ab62c2012-11-01 11:11:38 -07003252 // If the input could not be opened with the requested parameters and we can handle the
Andy Hung6770c6f2015-04-07 13:43:36 -07003253 // conversion internally, try to open again with the proposed parameters.
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07003254 if (status == BAD_VALUE &&
Andy Hung6770c6f2015-04-07 13:43:36 -07003255 audio_is_linear_pcm(config->format) &&
3256 audio_is_linear_pcm(halconfig.format) &&
3257 (halconfig.sample_rate <= AUDIO_RESAMPLER_DOWN_RATIO_MAX * config->sample_rate) &&
Andy Hung936845a2021-06-08 00:09:06 -07003258 (audio_channel_count_from_in_mask(halconfig.channel_mask) <= FCC_LIMIT) &&
3259 (audio_channel_count_from_in_mask(config->channel_mask) <= FCC_LIMIT)) {
Glenn Kasten85948432013-08-19 12:09:05 -07003260 // FIXME describe the change proposed by HAL (save old values so we can log them here)
Eric Laurentcf2c0212014-07-25 16:20:43 -07003261 ALOGV("openInput_l() reopening with proposed sampling rate and channel mask");
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003262 inStream.clear();
3263 status = inHwHal->openInputStream(
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003264 *input, devices, &halconfig, flags, address, source,
Mikhail Naganovb4e037e2019-01-14 15:56:33 -08003265 outputDevice, outputDeviceAddress, &inStream);
Glenn Kasten85948432013-08-19 12:09:05 -07003266 // FIXME log this new status; HAL should not propose any further changes
Mathias Agopian65ab4712010-07-14 17:59:35 -07003267 }
3268
Mikhail Naganov1dc98672016-08-18 17:50:29 -07003269 if (status == NO_ERROR && inStream != 0) {
Eric Laurent05067782016-06-01 18:27:28 -07003270 AudioStreamIn *inputStream = new AudioStreamIn(inHwDev, inStream, flags);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003271 if ((flags & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0) {
3272 sp<MmapCaptureThread> thread =
jiabinc52b1ff2019-10-31 17:20:42 -07003273 new MmapCaptureThread(this, *input, inHwDev, inputStream, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003274 mMmapThreads.add(*input, thread);
Glenn Kastend3bb6452016-12-05 18:14:37 -08003275 ALOGV("openInput_l() created mmap capture thread: ID %d thread %p", *input,
3276 thread.get());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003277 return thread;
3278 } else {
Eric Laurent6acd1d42017-01-04 14:23:29 -08003279 // Start record thread
3280 // RecordThread requires both input and output device indication to forward to audio
3281 // pre processing modules
jiabinc52b1ff2019-10-31 17:20:42 -07003282 sp<RecordThread> thread = new RecordThread(this, inputStream, *input, mSystemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003283 mRecordThreads.add(*input, thread);
3284 ALOGV("openInput_l() created record thread: ID %d thread %p", *input, thread.get());
3285 return thread;
3286 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003287 }
3288
Eric Laurentcf2c0212014-07-25 16:20:43 -07003289 *input = AUDIO_IO_HANDLE_NONE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003290 return 0;
3291}
3292
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003293status_t AudioFlinger::closeInput(audio_io_handle_t input)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003294{
Glenn Kastend96c5722012-04-25 13:44:49 -07003295 return closeInput_nonvirtual(input);
3296}
3297
3298status_t AudioFlinger::closeInput_nonvirtual(audio_io_handle_t input)
3299{
Mathias Agopian65ab4712010-07-14 17:59:35 -07003300 // keep strong reference on the record thread so that
3301 // it is not destroyed while exit() is executed
Eric Laurent6acd1d42017-01-04 14:23:29 -08003302 sp<RecordThread> recordThread;
3303 sp<MmapCaptureThread> mmapThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003304 {
3305 Mutex::Autolock _l(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003306 recordThread = checkRecordThread_l(input);
3307 if (recordThread != 0) {
3308 ALOGV("closeInput() %d", input);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003309
Andy Hungdc099c22018-09-18 13:46:39 -07003310 dumpToThreadLog_l(recordThread);
Andy Hung0264e7d2018-09-17 19:30:46 -07003311
Eric Laurent6acd1d42017-01-04 14:23:29 -08003312 // If we still have effect chains, it means that a client still holds a handle
3313 // on at least one effect. We must either move the chain to an existing thread with the
3314 // same session ID or put it aside in case a new record thread is opened for a
3315 // new capture on the same session
3316 sp<EffectChain> chain;
3317 {
3318 Mutex::Autolock _sl(recordThread->mLock);
3319 Vector< sp<EffectChain> > effectChains = recordThread->getEffectChains_l();
3320 // Note: maximum one chain per record thread
3321 if (effectChains.size() != 0) {
3322 chain = effectChains[0];
Eric Laurent1b928682014-10-02 19:41:47 -07003323 }
3324 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003325 if (chain != 0) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08003326 // first check if a record thread is already opened with a client on same session.
Eric Laurent6acd1d42017-01-04 14:23:29 -08003327 // This should only happen in case of overlap between one thread tear down and the
3328 // creation of its replacement
3329 size_t i;
3330 for (i = 0; i < mRecordThreads.size(); i++) {
3331 sp<RecordThread> t = mRecordThreads.valueAt(i);
3332 if (t == recordThread) {
3333 continue;
3334 }
3335 if (t->hasAudioSession(chain->sessionId()) != 0) {
3336 Mutex::Autolock _l(t->mLock);
3337 ALOGV("closeInput() found thread %d for effect session %d",
3338 t->id(), chain->sessionId());
3339 t->addEffectChain_l(chain);
3340 break;
3341 }
3342 }
Glenn Kastend3bb6452016-12-05 18:14:37 -08003343 // put the chain aside if we could not find a record thread with the same session id
Eric Laurent6acd1d42017-01-04 14:23:29 -08003344 if (i == mRecordThreads.size()) {
3345 putOrphanEffectChain_l(chain);
3346 }
Eric Laurentaaa44472014-09-12 17:41:50 -07003347 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003348 mRecordThreads.removeItem(input);
3349 } else {
3350 mmapThread = (MmapCaptureThread *)checkMmapThread_l(input);
3351 if (mmapThread == 0) {
3352 return BAD_VALUE;
3353 }
Andy Hungdc099c22018-09-18 13:46:39 -07003354 dumpToThreadLog_l(mmapThread);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003355 mMmapThreads.removeItem(input);
Eric Laurentaaa44472014-09-12 17:41:50 -07003356 }
Mikhail Naganov88536df2021-07-26 17:30:29 -07003357 ioConfigChanged(AUDIO_INPUT_CLOSED, sp<AudioIoDescriptor>::make(input));
Mathias Agopian65ab4712010-07-14 17:59:35 -07003358 }
Eric Laurent83b88082014-06-20 18:31:16 -07003359 // FIXME: calling thread->exit() without mLock held should not be needed anymore now that
3360 // we have a different lock for notification client
Eric Laurent6acd1d42017-01-04 14:23:29 -08003361 if (recordThread != 0) {
3362 closeInputFinish(recordThread);
3363 } else if (mmapThread != 0) {
3364 mmapThread->exit();
3365 AudioStreamIn *in = mmapThread->clearInput();
3366 ALOG_ASSERT(in != NULL, "in shouldn't be NULL");
3367 // from now on thread->mInput is NULL
3368 delete in;
3369 }
Eric Laurent83b88082014-06-20 18:31:16 -07003370 return NO_ERROR;
3371}
Mathias Agopian65ab4712010-07-14 17:59:35 -07003372
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -07003373void AudioFlinger::closeInputFinish(const sp<RecordThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07003374{
3375 thread->exit();
Eric Laurentb8ba0a92011-08-07 16:32:26 -07003376 AudioStreamIn *in = thread->clearInput();
Glenn Kasten5798d4e2012-03-08 12:18:35 -08003377 ALOG_ASSERT(in != NULL, "in shouldn't be NULL");
Eric Laurentb8ba0a92011-08-07 16:32:26 -07003378 // from now on thread->mInput is NULL
Dima Zavin799a70e2011-04-18 16:57:27 -07003379 delete in;
Eric Laurent83b88082014-06-20 18:31:16 -07003380}
Mathias Agopian65ab4712010-07-14 17:59:35 -07003381
Mikhail Naganov444ecc32018-05-01 17:40:05 -07003382void AudioFlinger::closeThreadInternal_l(const sp<RecordThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07003383{
3384 mRecordThreads.removeItem(thread->mId);
3385 closeInputFinish(thread);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003386}
3387
Glenn Kastend2304db2014-02-03 07:40:31 -08003388status_t AudioFlinger::invalidateStream(audio_stream_type_t stream)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003389{
3390 Mutex::Autolock _l(mLock);
Glenn Kastend2304db2014-02-03 07:40:31 -08003391 ALOGV("invalidateStream() stream %d", stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003392
3393 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3394 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
Eric Laurent22167852012-06-20 12:26:32 -07003395 thread->invalidateTracks(stream);
Eric Laurentde070132010-07-13 04:45:46 -07003396 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003397 for (size_t i = 0; i < mMmapThreads.size(); i++) {
3398 mMmapThreads[i]->invalidateTracks(stream);
3399 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003400 return NO_ERROR;
3401}
3402
3403
Glenn Kasteneeecb982016-02-26 10:44:04 -08003404audio_unique_id_t AudioFlinger::newAudioUniqueId(audio_unique_id_use_t use)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003405{
Glenn Kasten9d003132016-04-06 14:38:09 -07003406 // This is a binder API, so a malicious client could pass in a bad parameter.
3407 // Check for that before calling the internal API nextUniqueId().
3408 if ((unsigned) use >= (unsigned) AUDIO_UNIQUE_ID_USE_MAX) {
3409 ALOGE("newAudioUniqueId invalid use %d", use);
3410 return AUDIO_UNIQUE_ID_ALLOCATE;
3411 }
Glenn Kasteneeecb982016-02-26 10:44:04 -08003412 return nextUniqueId(use);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003413}
3414
Andy Hung8b0bfd92019-12-23 13:11:11 -08003415void AudioFlinger::acquireAudioSessionId(
3416 audio_session_t audioSession, pid_t pid, uid_t uid)
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003417{
3418 Mutex::Autolock _l(mLock);
Glenn Kastenbb001922012-02-03 11:10:26 -08003419 pid_t caller = IPCThreadState::self()->getCallingPid();
Marco Nelissend457c972014-02-11 08:47:07 -08003420 ALOGV("acquiring %d from %d, for %d", audioSession, caller, pid);
Andy Hung4ef19fa2018-05-15 19:35:29 -07003421 const uid_t callerUid = IPCThreadState::self()->getCallingUid();
Andy Hung8b0bfd92019-12-23 13:11:11 -08003422 if (pid != (pid_t)-1 && isAudioServerOrMediaServerUid(callerUid)) {
3423 caller = pid; // check must match releaseAudioSessionId()
3424 }
3425 if (uid == (uid_t)-1 || !isAudioServerOrMediaServerUid(callerUid)) {
3426 uid = callerUid;
Marco Nelissend457c972014-02-11 08:47:07 -08003427 }
Eric Laurentd1b28d42013-09-18 18:47:13 -07003428
Eric Laurent021cf962014-05-13 10:18:14 -07003429 {
3430 Mutex::Autolock _cl(mClientLock);
3431 // Ignore requests received from processes not known as notification client. The request
3432 // is likely proxied by mediaserver (e.g CameraService) and releaseAudioSessionId() can be
3433 // called from a different pid leaving a stale session reference. Also we don't know how
3434 // to clear this reference if the client process dies.
3435 if (mNotificationClients.indexOfKey(caller) < 0) {
3436 ALOGW("acquireAudioSessionId() unknown client %d for session %d", caller, audioSession);
3437 return;
3438 }
Eric Laurentd1b28d42013-09-18 18:47:13 -07003439 }
3440
Glenn Kasten8d6a2442012-02-08 14:04:28 -08003441 size_t num = mAudioSessionRefs.size();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08003442 for (size_t i = 0; i < num; i++) {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003443 AudioSessionRef *ref = mAudioSessionRefs.editItemAt(i);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08003444 if (ref->mSessionid == audioSession && ref->mPid == caller) {
3445 ref->mCnt++;
3446 ALOGV(" incremented refcount to %d", ref->mCnt);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003447 return;
3448 }
3449 }
Andy Hung8b0bfd92019-12-23 13:11:11 -08003450 mAudioSessionRefs.push(new AudioSessionRef(audioSession, caller, uid));
Glenn Kasten84afa3b2012-01-25 15:28:08 -08003451 ALOGV(" added new entry for %d", audioSession);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003452}
3453
Glenn Kastend848eb42016-03-08 13:42:11 -08003454void AudioFlinger::releaseAudioSessionId(audio_session_t audioSession, pid_t pid)
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003455{
Eric Laurent6c796322019-04-09 14:13:17 -07003456 std::vector< sp<EffectModule> > removedEffects;
3457 {
3458 Mutex::Autolock _l(mLock);
3459 pid_t caller = IPCThreadState::self()->getCallingPid();
3460 ALOGV("releasing %d from %d for %d", audioSession, caller, pid);
3461 const uid_t callerUid = IPCThreadState::self()->getCallingUid();
Andy Hung8b0bfd92019-12-23 13:11:11 -08003462 if (pid != (pid_t)-1 && isAudioServerOrMediaServerUid(callerUid)) {
3463 caller = pid; // check must match acquireAudioSessionId()
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003464 }
Eric Laurent6c796322019-04-09 14:13:17 -07003465 size_t num = mAudioSessionRefs.size();
3466 for (size_t i = 0; i < num; i++) {
3467 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
3468 if (ref->mSessionid == audioSession && ref->mPid == caller) {
3469 ref->mCnt--;
3470 ALOGV(" decremented refcount to %d", ref->mCnt);
3471 if (ref->mCnt == 0) {
3472 mAudioSessionRefs.removeAt(i);
3473 delete ref;
3474 std::vector< sp<EffectModule> > effects = purgeStaleEffects_l();
3475 removedEffects.insert(removedEffects.end(), effects.begin(), effects.end());
3476 }
3477 goto Exit;
3478 }
3479 }
3480 // If the caller is audioserver it is likely that the session being released was acquired
3481 // on behalf of a process not in notification clients and we ignore the warning.
3482 ALOGW_IF(!isAudioServerUid(callerUid),
3483 "session id %d not found for pid %d", audioSession, caller);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003484 }
Eric Laurent6c796322019-04-09 14:13:17 -07003485
3486Exit:
3487 for (auto& effect : removedEffects) {
3488 effect->updatePolicyState();
3489 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003490}
3491
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08003492bool AudioFlinger::isSessionAcquired_l(audio_session_t audioSession)
3493{
3494 size_t num = mAudioSessionRefs.size();
3495 for (size_t i = 0; i < num; i++) {
3496 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
3497 if (ref->mSessionid == audioSession) {
3498 return true;
3499 }
3500 }
3501 return false;
3502}
3503
Eric Laurent6c796322019-04-09 14:13:17 -07003504std::vector<sp<AudioFlinger::EffectModule>> AudioFlinger::purgeStaleEffects_l() {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003505
Steve Block3856b092011-10-20 11:56:00 +01003506 ALOGV("purging stale effects");
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003507
3508 Vector< sp<EffectChain> > chains;
Eric Laurent6c796322019-04-09 14:13:17 -07003509 std::vector< sp<EffectModule> > removedEffects;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003510
3511 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3512 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
Mateusz Kaplon2a6e1b02017-03-30 16:50:50 +02003513 Mutex::Autolock _l(t->mLock);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003514 for (size_t j = 0; j < t->mEffectChains.size(); j++) {
3515 sp<EffectChain> ec = t->mEffectChains[j];
Eric Laurent3f75a5b2019-11-12 15:55:51 -08003516 if (!audio_is_global_session(ec->sessionId())) {
Marco Nelissen0270b182011-08-12 14:14:39 -07003517 chains.push(ec);
3518 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003519 }
3520 }
Eric Laurent6c796322019-04-09 14:13:17 -07003521
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003522 for (size_t i = 0; i < mRecordThreads.size(); i++) {
3523 sp<RecordThread> t = mRecordThreads.valueAt(i);
Mateusz Kaplon2a6e1b02017-03-30 16:50:50 +02003524 Mutex::Autolock _l(t->mLock);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003525 for (size_t j = 0; j < t->mEffectChains.size(); j++) {
3526 sp<EffectChain> ec = t->mEffectChains[j];
3527 chains.push(ec);
3528 }
3529 }
3530
Eric Laurent6c796322019-04-09 14:13:17 -07003531 for (size_t i = 0; i < mMmapThreads.size(); i++) {
3532 sp<MmapThread> t = mMmapThreads.valueAt(i);
3533 Mutex::Autolock _l(t->mLock);
3534 for (size_t j = 0; j < t->mEffectChains.size(); j++) {
3535 sp<EffectChain> ec = t->mEffectChains[j];
3536 chains.push(ec);
3537 }
3538 }
3539
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003540 for (size_t i = 0; i < chains.size(); i++) {
3541 sp<EffectChain> ec = chains[i];
3542 int sessionid = ec->sessionId();
Eric Laurent6b446ce2019-12-13 10:56:31 -08003543 sp<ThreadBase> t = ec->thread().promote();
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003544 if (t == 0) {
3545 continue;
3546 }
3547 size_t numsessionrefs = mAudioSessionRefs.size();
3548 bool found = false;
3549 for (size_t k = 0; k < numsessionrefs; k++) {
3550 AudioSessionRef *ref = mAudioSessionRefs.itemAt(k);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08003551 if (ref->mSessionid == sessionid) {
Steve Block3856b092011-10-20 11:56:00 +01003552 ALOGV(" session %d still exists for %d with %d refs",
Glenn Kastene53b9ea2012-03-12 16:29:55 -07003553 sessionid, ref->mPid, ref->mCnt);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003554 found = true;
3555 break;
3556 }
3557 }
3558 if (!found) {
Glenn Kastene198c362013-08-13 09:13:36 -07003559 Mutex::Autolock _l(t->mLock);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003560 // remove all effects from the chain
3561 while (ec->mEffects.size()) {
3562 sp<EffectModule> effect = ec->mEffects[0];
3563 effect->unPin();
Mikhail Naganov424c4f52017-07-19 17:54:29 -07003564 t->removeEffect_l(effect, /*release*/ true);
Eric Laurenta5f44eb2012-06-25 11:38:29 -07003565 if (effect->purgeHandles()) {
Eric Laurent6b446ce2019-12-13 10:56:31 -08003566 effect->checkSuspendOnEffectEnabled(false, true /*threadLocked*/);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003567 }
Eric Laurent6c796322019-04-09 14:13:17 -07003568 removedEffects.push_back(effect);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003569 }
3570 }
3571 }
Eric Laurent6c796322019-04-09 14:13:17 -07003572 return removedEffects;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003573}
3574
Andy Hungdc099c22018-09-18 13:46:39 -07003575// dumpToThreadLog_l() must be called with AudioFlinger::mLock held
3576void AudioFlinger::dumpToThreadLog_l(const sp<ThreadBase> &thread)
3577{
Jaideep Sharma330845f2020-10-22 12:14:58 +05303578 constexpr int THREAD_DUMP_TIMEOUT_MS = 2;
3579 audio_utils::FdToString fdToString("- ", THREAD_DUMP_TIMEOUT_MS);
Andy Hungdc099c22018-09-18 13:46:39 -07003580 const int fd = fdToString.fd();
3581 if (fd >= 0) {
3582 thread->dump(fd, {} /* args */);
3583 mThreadLog.logs(-1 /* time */, fdToString.getStringAndClose());
3584 }
3585}
3586
Glenn Kasteneeecb982016-02-26 10:44:04 -08003587// checkThread_l() must be called with AudioFlinger::mLock held
3588AudioFlinger::ThreadBase *AudioFlinger::checkThread_l(audio_io_handle_t ioHandle) const
3589{
Eric Laurent6acd1d42017-01-04 14:23:29 -08003590 ThreadBase *thread = checkMmapThread_l(ioHandle);
3591 if (thread == 0) {
3592 switch (audio_unique_id_get_use(ioHandle)) {
3593 case AUDIO_UNIQUE_ID_USE_OUTPUT:
3594 thread = checkPlaybackThread_l(ioHandle);
3595 break;
3596 case AUDIO_UNIQUE_ID_USE_INPUT:
3597 thread = checkRecordThread_l(ioHandle);
3598 break;
3599 default:
3600 break;
3601 }
Glenn Kasteneeecb982016-02-26 10:44:04 -08003602 }
3603 return thread;
3604}
3605
Mathias Agopian65ab4712010-07-14 17:59:35 -07003606// checkPlaybackThread_l() must be called with AudioFlinger::mLock held
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003607AudioFlinger::PlaybackThread *AudioFlinger::checkPlaybackThread_l(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003608{
Glenn Kastena1117922012-01-26 10:53:32 -08003609 return mPlaybackThreads.valueFor(output).get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07003610}
3611
3612// checkMixerThread_l() must be called with AudioFlinger::mLock held
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003613AudioFlinger::MixerThread *AudioFlinger::checkMixerThread_l(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003614{
3615 PlaybackThread *thread = checkPlaybackThread_l(output);
Glenn Kastena1117922012-01-26 10:53:32 -08003616 return thread != NULL && thread->type() != ThreadBase::DIRECT ? (MixerThread *) thread : NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003617}
3618
3619// checkRecordThread_l() must be called with AudioFlinger::mLock held
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003620AudioFlinger::RecordThread *AudioFlinger::checkRecordThread_l(audio_io_handle_t input) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003621{
Glenn Kastena1117922012-01-26 10:53:32 -08003622 return mRecordThreads.valueFor(input).get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07003623}
3624
Eric Laurent6acd1d42017-01-04 14:23:29 -08003625// checkMmapThread_l() must be called with AudioFlinger::mLock held
3626AudioFlinger::MmapThread *AudioFlinger::checkMmapThread_l(audio_io_handle_t io) const
3627{
3628 return mMmapThreads.valueFor(io).get();
3629}
3630
3631
3632// checkPlaybackThread_l() must be called with AudioFlinger::mLock held
3633AudioFlinger::VolumeInterface *AudioFlinger::getVolumeInterface_l(audio_io_handle_t output) const
3634{
Eric Laurent7459b902017-04-19 18:10:41 -07003635 VolumeInterface *volumeInterface = mPlaybackThreads.valueFor(output).get();
Eric Laurent6acd1d42017-01-04 14:23:29 -08003636 if (volumeInterface == nullptr) {
3637 MmapThread *mmapThread = mMmapThreads.valueFor(output).get();
3638 if (mmapThread != nullptr) {
3639 if (mmapThread->isOutput()) {
Eric Laurent7459b902017-04-19 18:10:41 -07003640 MmapPlaybackThread *mmapPlaybackThread =
3641 static_cast<MmapPlaybackThread *>(mmapThread);
3642 volumeInterface = mmapPlaybackThread;
Eric Laurent6acd1d42017-01-04 14:23:29 -08003643 }
3644 }
3645 }
3646 return volumeInterface;
3647}
3648
3649Vector <AudioFlinger::VolumeInterface *> AudioFlinger::getAllVolumeInterfaces_l() const
3650{
3651 Vector <VolumeInterface *> volumeInterfaces;
3652 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Eric Laurent7459b902017-04-19 18:10:41 -07003653 volumeInterfaces.add(mPlaybackThreads.valueAt(i).get());
Eric Laurent6acd1d42017-01-04 14:23:29 -08003654 }
3655 for (size_t i = 0; i < mMmapThreads.size(); i++) {
3656 if (mMmapThreads.valueAt(i)->isOutput()) {
Eric Laurent7459b902017-04-19 18:10:41 -07003657 MmapPlaybackThread *mmapPlaybackThread =
3658 static_cast<MmapPlaybackThread *>(mMmapThreads.valueAt(i).get());
3659 volumeInterfaces.add(mmapPlaybackThread);
Eric Laurent6acd1d42017-01-04 14:23:29 -08003660 }
3661 }
3662 return volumeInterfaces;
3663}
3664
Glenn Kasteneeecb982016-02-26 10:44:04 -08003665audio_unique_id_t AudioFlinger::nextUniqueId(audio_unique_id_use_t use)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003666{
Glenn Kasten9d003132016-04-06 14:38:09 -07003667 // This is the internal API, so it is OK to assert on bad parameter.
Glenn Kasteneeecb982016-02-26 10:44:04 -08003668 LOG_ALWAYS_FATAL_IF((unsigned) use >= (unsigned) AUDIO_UNIQUE_ID_USE_MAX);
Glenn Kastend2e67e12016-04-11 08:26:37 -07003669 const int maxRetries = use == AUDIO_UNIQUE_ID_USE_SESSION ? 3 : 1;
3670 for (int retry = 0; retry < maxRetries; retry++) {
3671 // The cast allows wraparound from max positive to min negative instead of abort
3672 uint32_t base = (uint32_t) atomic_fetch_add_explicit(&mNextUniqueIds[use],
3673 (uint_fast32_t) AUDIO_UNIQUE_ID_USE_MAX, memory_order_acq_rel);
3674 ALOG_ASSERT(audio_unique_id_get_use(base) == AUDIO_UNIQUE_ID_USE_UNSPECIFIED);
3675 // allow wrap by skipping 0 and -1 for session ids
3676 if (!(base == 0 || base == (~0u & ~AUDIO_UNIQUE_ID_USE_MASK))) {
3677 ALOGW_IF(retry != 0, "unique ID overflow for use %d", use);
3678 return (audio_unique_id_t) (base | use);
3679 }
3680 }
3681 // We have no way of recovering from wraparound
3682 LOG_ALWAYS_FATAL("unique ID overflow for use %d", use);
3683 // TODO Use a floor after wraparound. This may need a mutex.
Mathias Agopian65ab4712010-07-14 17:59:35 -07003684}
3685
Glenn Kasten02fe1bf2012-02-24 15:42:17 -08003686AudioFlinger::PlaybackThread *AudioFlinger::primaryPlaybackThread_l() const
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003687{
Eric Laurent00abf0d2020-04-22 19:28:22 -07003688 AutoMutex lock(mHardwareLock);
3689 if (mPrimaryHardwareDev == nullptr) {
3690 return nullptr;
3691 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003692 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3693 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
Eric Laurentf6870ae2015-05-08 10:50:03 -07003694 if(thread->isDuplicating()) {
3695 continue;
3696 }
Eric Laurentb8ba0a92011-08-07 16:32:26 -07003697 AudioStreamOut *output = thread->getOutput();
John Grossmanee578c02012-07-23 17:05:46 -07003698 if (output != NULL && output->audioHwDev == mPrimaryHardwareDev) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003699 return thread;
3700 }
3701 }
Eric Laurent00abf0d2020-04-22 19:28:22 -07003702 return nullptr;
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003703}
3704
jiabinc52b1ff2019-10-31 17:20:42 -07003705DeviceTypeSet AudioFlinger::primaryOutputDevice_l() const
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003706{
3707 PlaybackThread *thread = primaryPlaybackThread_l();
3708
3709 if (thread == NULL) {
jiabinc52b1ff2019-10-31 17:20:42 -07003710 return DeviceTypeSet();
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003711 }
3712
jiabinc52b1ff2019-10-31 17:20:42 -07003713 return thread->outDeviceTypes();
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003714}
3715
Glenn Kastena7335632016-06-09 17:09:53 -07003716AudioFlinger::PlaybackThread *AudioFlinger::fastPlaybackThread_l() const
3717{
3718 size_t minFrameCount = 0;
3719 PlaybackThread *minThread = NULL;
3720 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3721 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
3722 if (!thread->isDuplicating()) {
3723 size_t frameCount = thread->frameCountHAL();
3724 if (frameCount != 0 && (minFrameCount == 0 || frameCount < minFrameCount ||
3725 (frameCount == minFrameCount && thread->hasFastMixer() &&
3726 /*minThread != NULL &&*/ !minThread->hasFastMixer()))) {
3727 minFrameCount = frameCount;
3728 minThread = thread;
3729 }
3730 }
3731 }
3732 return minThread;
3733}
3734
jiabineb3bda02020-06-30 14:07:03 -07003735AudioFlinger::ThreadBase *AudioFlinger::hapticPlaybackThread_l() const {
3736 for (size_t i = 0; i < mPlaybackThreads.size(); ++i) {
3737 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
3738 if (thread->hapticChannelMask() != AUDIO_CHANNEL_NONE) {
3739 return thread;
3740 }
3741 }
3742 return nullptr;
3743}
3744
jiabinf042b9b2021-05-07 23:46:28 +00003745void AudioFlinger::updateSecondaryOutputsForTrack_l(
3746 PlaybackThread::Track* track,
3747 PlaybackThread* thread,
3748 const std::vector<audio_io_handle_t> &secondaryOutputs) const {
3749 TeePatches teePatches;
3750 for (audio_io_handle_t secondaryOutput : secondaryOutputs) {
3751 PlaybackThread *secondaryThread = checkPlaybackThread_l(secondaryOutput);
3752 if (secondaryThread == nullptr) {
3753 ALOGE("no playback thread found for secondary output %d", thread->id());
3754 continue;
3755 }
3756
3757 size_t sourceFrameCount = thread->frameCount() * track->sampleRate()
3758 / thread->sampleRate();
3759 size_t sinkFrameCount = secondaryThread->frameCount() * track->sampleRate()
3760 / secondaryThread->sampleRate();
3761 // If the secondary output has just been opened, the first secondaryThread write
3762 // will not block as it will fill the empty startup buffer of the HAL,
3763 // so a second sink buffer needs to be ready for the immediate next blocking write.
3764 // Additionally, have a margin of one main thread buffer as the scheduling jitter
3765 // can reorder the writes (eg if thread A&B have the same write intervale,
3766 // the scheduler could schedule AB...BA)
3767 size_t frameCountToBeReady = 2 * sinkFrameCount + sourceFrameCount;
3768 // Total secondary output buffer must be at least as the read frames plus
3769 // the margin of a few buffers on both sides in case the
3770 // threads scheduling has some jitter.
3771 // That value should not impact latency as the secondary track is started before
3772 // its buffer is full, see frameCountToBeReady.
3773 size_t frameCount = frameCountToBeReady + 2 * (sourceFrameCount + sinkFrameCount);
3774 // The frameCount should also not be smaller than the secondary thread min frame
3775 // count
3776 size_t minFrameCount = AudioSystem::calculateMinFrameCount(
3777 [&] { Mutex::Autolock _l(secondaryThread->mLock);
3778 return secondaryThread->latency_l(); }(),
3779 secondaryThread->mNormalFrameCount,
3780 secondaryThread->mSampleRate,
3781 track->sampleRate(),
3782 track->getSpeed());
3783 frameCount = std::max(frameCount, minFrameCount);
3784
3785 using namespace std::chrono_literals;
3786 auto inChannelMask = audio_channel_mask_out_to_in(track->channelMask());
jiabin73e303c2022-09-15 17:49:50 +00003787 if (inChannelMask == AUDIO_CHANNEL_INVALID) {
3788 // The downstream PatchTrack has the proper output channel mask,
3789 // so if there is no input channel mask equivalent, we can just
3790 // use an index mask here to create the PatchRecord.
3791 inChannelMask = audio_channel_mask_out_to_in_index_mask(track->channelMask());
3792 }
jiabinf042b9b2021-05-07 23:46:28 +00003793 sp patchRecord = new RecordThread::PatchRecord(nullptr /* thread */,
3794 track->sampleRate(),
3795 inChannelMask,
3796 track->format(),
3797 frameCount,
3798 nullptr /* buffer */,
3799 (size_t)0 /* bufferSize */,
3800 AUDIO_INPUT_FLAG_DIRECT,
3801 0ns /* timeout */);
3802 status_t status = patchRecord->initCheck();
3803 if (status != NO_ERROR) {
3804 ALOGE("Secondary output patchRecord init failed: %d", status);
3805 continue;
3806 }
3807
3808 // TODO: We could check compatibility of the secondaryThread with the PatchTrack
3809 // for fast usage: thread has fast mixer, sample rate matches, etc.;
3810 // for now, we exclude fast tracks by removing the Fast flag.
3811 const audio_output_flags_t outputFlags =
3812 (audio_output_flags_t)(track->getOutputFlags() & ~AUDIO_OUTPUT_FLAG_FAST);
3813 sp patchTrack = new PlaybackThread::PatchTrack(secondaryThread,
3814 track->streamType(),
3815 track->sampleRate(),
3816 track->channelMask(),
3817 track->format(),
3818 frameCount,
3819 patchRecord->buffer(),
3820 patchRecord->bufferSize(),
3821 outputFlags,
3822 0ns /* timeout */,
3823 frameCountToBeReady);
3824 status = patchTrack->initCheck();
3825 if (status != NO_ERROR) {
3826 ALOGE("Secondary output patchTrack init failed: %d", status);
3827 continue;
3828 }
3829 teePatches.push_back({patchRecord, patchTrack});
3830 secondaryThread->addPatchTrack(patchTrack);
3831 // In case the downstream patchTrack on the secondaryThread temporarily outlives
3832 // our created track, ensure the corresponding patchRecord is still alive.
3833 patchTrack->setPeerProxy(patchRecord, true /* holdReference */);
3834 patchRecord->setPeerProxy(patchTrack, false /* holdReference */);
3835 }
3836 track->setTeePatches(std::move(teePatches));
3837}
3838
Eric Laurenta011e352012-03-29 15:51:43 -07003839sp<AudioFlinger::SyncEvent> AudioFlinger::createSyncEvent(AudioSystem::sync_event_t type,
Glenn Kastend848eb42016-03-08 13:42:11 -08003840 audio_session_t triggerSession,
3841 audio_session_t listenerSession,
Eric Laurenta011e352012-03-29 15:51:43 -07003842 sync_event_callback_t callBack,
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -07003843 const wp<RefBase>& cookie)
Eric Laurenta011e352012-03-29 15:51:43 -07003844{
3845 Mutex::Autolock _l(mLock);
3846
3847 sp<SyncEvent> event = new SyncEvent(type, triggerSession, listenerSession, callBack, cookie);
3848 status_t playStatus = NAME_NOT_FOUND;
3849 status_t recStatus = NAME_NOT_FOUND;
3850 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3851 playStatus = mPlaybackThreads.valueAt(i)->setSyncEvent(event);
3852 if (playStatus == NO_ERROR) {
3853 return event;
3854 }
3855 }
3856 for (size_t i = 0; i < mRecordThreads.size(); i++) {
3857 recStatus = mRecordThreads.valueAt(i)->setSyncEvent(event);
3858 if (recStatus == NO_ERROR) {
3859 return event;
3860 }
3861 }
3862 if (playStatus == NAME_NOT_FOUND || recStatus == NAME_NOT_FOUND) {
3863 mPendingSyncEvents.add(event);
3864 } else {
3865 ALOGV("createSyncEvent() invalid event %d", event->type());
3866 event.clear();
3867 }
3868 return event;
3869}
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003870
Mathias Agopian65ab4712010-07-14 17:59:35 -07003871// ----------------------------------------------------------------------------
3872// Effect management
3873// ----------------------------------------------------------------------------
3874
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07003875sp<EffectsFactoryHalInterface> AudioFlinger::getEffectsFactory() {
3876 return mEffectsFactoryHal;
3877}
Mathias Agopian65ab4712010-07-14 17:59:35 -07003878
Glenn Kastenf587ba52012-01-26 16:25:10 -08003879status_t AudioFlinger::queryNumberEffects(uint32_t *numEffects) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003880{
3881 Mutex::Autolock _l(mLock);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07003882 if (mEffectsFactoryHal.get()) {
3883 return mEffectsFactoryHal->queryNumberEffects(numEffects);
3884 } else {
3885 return -ENODEV;
3886 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003887}
3888
Glenn Kastenf587ba52012-01-26 16:25:10 -08003889status_t AudioFlinger::queryEffect(uint32_t index, effect_descriptor_t *descriptor) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003890{
3891 Mutex::Autolock _l(mLock);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07003892 if (mEffectsFactoryHal.get()) {
3893 return mEffectsFactoryHal->getDescriptor(index, descriptor);
3894 } else {
3895 return -ENODEV;
3896 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003897}
3898
Glenn Kasten5e92a782012-01-30 07:40:52 -08003899status_t AudioFlinger::getEffectDescriptor(const effect_uuid_t *pUuid,
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07003900 const effect_uuid_t *pTypeUuid,
3901 uint32_t preferredTypeFlag,
3902 effect_descriptor_t *descriptor) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003903{
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07003904 if (pUuid == NULL || pTypeUuid == NULL || descriptor == NULL) {
3905 return BAD_VALUE;
3906 }
3907
Mathias Agopian65ab4712010-07-14 17:59:35 -07003908 Mutex::Autolock _l(mLock);
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07003909
3910 if (!mEffectsFactoryHal.get()) {
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07003911 return -ENODEV;
3912 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003913
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07003914 status_t status = NO_ERROR;
3915 if (!EffectsFactoryHalInterface::isNullUuid(pUuid)) {
3916 // If uuid is specified, request effect descriptor from that.
3917 status = mEffectsFactoryHal->getDescriptor(pUuid, descriptor);
3918 } else if (!EffectsFactoryHalInterface::isNullUuid(pTypeUuid)) {
3919 // If uuid is not specified, look for an available implementation
3920 // of the required type instead.
3921
3922 // Use a temporary descriptor to avoid modifying |descriptor| in the failure case.
3923 effect_descriptor_t desc;
3924 desc.flags = 0; // prevent compiler warning
3925
3926 uint32_t numEffects = 0;
3927 status = mEffectsFactoryHal->queryNumberEffects(&numEffects);
3928 if (status < 0) {
3929 ALOGW("getEffectDescriptor() error %d from FactoryHal queryNumberEffects", status);
3930 return status;
3931 }
3932
3933 bool found = false;
3934 for (uint32_t i = 0; i < numEffects; i++) {
3935 status = mEffectsFactoryHal->getDescriptor(i, &desc);
3936 if (status < 0) {
3937 ALOGW("getEffectDescriptor() error %d from FactoryHal getDescriptor", status);
3938 continue;
3939 }
3940 if (memcmp(&desc.type, pTypeUuid, sizeof(effect_uuid_t)) == 0) {
3941 // If matching type found save effect descriptor.
3942 found = true;
3943 *descriptor = desc;
3944
3945 // If there's no preferred flag or this descriptor matches the preferred
3946 // flag, success! If this descriptor doesn't match the preferred
3947 // flag, continue enumeration in case a better matching version of this
3948 // effect type is available. Note that this means if no effect with a
3949 // correct flag is found, the descriptor returned will correspond to the
3950 // last effect that at least had a matching type uuid (if any).
3951 if (preferredTypeFlag == EFFECT_FLAG_TYPE_MASK ||
3952 (desc.flags & EFFECT_FLAG_TYPE_MASK) == preferredTypeFlag) {
3953 break;
3954 }
3955 }
3956 }
3957
3958 if (!found) {
3959 status = NAME_NOT_FOUND;
3960 ALOGW("getEffectDescriptor(): Effect not found by type.");
3961 }
3962 } else {
3963 status = BAD_VALUE;
3964 ALOGE("getEffectDescriptor(): Either uuid or type uuid must be non-null UUIDs.");
3965 }
3966 return status;
3967}
Mathias Agopian65ab4712010-07-14 17:59:35 -07003968
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08003969status_t AudioFlinger::createEffect(const media::CreateEffectRequest& request,
3970 media::CreateEffectResponse* response) {
3971 const sp<IEffectClient>& effectClient = request.client;
3972 const int32_t priority = request.priority;
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003973 const AudioDeviceTypeAddr device = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08003974 aidl2legacy_AudioDeviceTypeAddress(request.device));
Svet Ganov33761132021-05-13 22:51:08 +00003975 AttributionSourceState adjAttributionSource = request.attributionSource;
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003976 const audio_session_t sessionId = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08003977 aidl2legacy_int32_t_audio_session_t(request.sessionId));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08003978 audio_io_handle_t io = VALUE_OR_RETURN_STATUS(
3979 aidl2legacy_int32_t_audio_io_handle_t(request.output));
3980 const effect_descriptor_t descIn = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08003981 aidl2legacy_EffectDescriptor_effect_descriptor_t(request.desc));
3982 const bool probe = request.probe;
3983
Mathias Agopian65ab4712010-07-14 17:59:35 -07003984 sp<EffectHandle> handle;
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08003985 effect_descriptor_t descOut;
3986 int enabledOut = 0;
3987 int idOut = -1;
3988
3989 status_t lStatus = NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003990
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003991 // TODO b/182392553: refactor or make clearer
Eric Laurentb6436272016-12-07 19:24:50 -08003992 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Svet Ganov33761132021-05-13 22:51:08 +00003993 adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
3994 pid_t currentPid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(adjAttributionSource.pid));
Eric Laurent9ff3e532022-11-10 16:04:44 +01003995 if (currentPid == -1 || !isAudioServerOrMediaServerOrSystemServerOrRootUid(callingUid)) {
Eric Laurentb6436272016-12-07 19:24:50 -08003996 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003997 ALOGW_IF(currentPid != -1 && currentPid != callingPid,
Eric Laurentb6436272016-12-07 19:24:50 -08003998 "%s uid %d pid %d tried to pass itself off as pid %d",
Philip P. Moltmannbda45752020-07-17 16:41:18 -07003999 __func__, callingUid, callingPid, currentPid);
Svet Ganov33761132021-05-13 22:51:08 +00004000 adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -07004001 currentPid = callingPid;
Eric Laurentb6436272016-12-07 19:24:50 -08004002 }
Eric Laurent9ff3e532022-11-10 16:04:44 +01004003 adjAttributionSource = AudioFlinger::checkAttributionSourcePackage(adjAttributionSource);
Eric Laurentb6436272016-12-07 19:24:50 -08004004
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07004005 ALOGV("createEffect pid %d, effectClient %p, priority %d, sessionId %d, io %d, factory %p",
Svet Ganov33761132021-05-13 22:51:08 +00004006 adjAttributionSource.pid, effectClient.get(), priority, sessionId, io,
4007 mEffectsFactoryHal.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07004008
Mikhail Naganov1dc98672016-08-18 17:50:29 -07004009 if (mEffectsFactoryHal == 0) {
Andy Hung6096dcd2019-03-13 13:20:30 -07004010 ALOGE("%s: no effects factory hal", __func__);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07004011 lStatus = NO_INIT;
4012 goto Exit;
4013 }
4014
Andy Hung6096dcd2019-03-13 13:20:30 -07004015 // check audio settings permission for global effects
4016 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
4017 if (!settingsAllowed()) {
4018 ALOGE("%s: no permission for AUDIO_SESSION_OUTPUT_MIX", __func__);
4019 lStatus = PERMISSION_DENIED;
4020 goto Exit;
4021 }
4022 } else if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
Andy Hung6096dcd2019-03-13 13:20:30 -07004023 if (io == AUDIO_IO_HANDLE_NONE) {
4024 ALOGE("%s: APM must specify output when using AUDIO_SESSION_OUTPUT_STAGE", __func__);
4025 lStatus = BAD_VALUE;
4026 goto Exit;
4027 }
Eric Laurenta74058e2022-05-26 15:08:00 +00004028 PlaybackThread *thread = checkPlaybackThread_l(io);
4029 if (thread == nullptr) {
4030 ALOGE("%s: invalid output %d specified for AUDIO_SESSION_OUTPUT_STAGE", __func__, io);
4031 lStatus = BAD_VALUE;
4032 goto Exit;
4033 }
4034 if (!modifyDefaultAudioEffectsAllowed(adjAttributionSource)
4035 && !isAudioServerUid(callingUid)) {
4036 ALOGE("%s: effect on AUDIO_SESSION_OUTPUT_STAGE not granted for uid %d",
4037 __func__, callingUid);
4038 lStatus = PERMISSION_DENIED;
4039 goto Exit;
4040 }
Eric Laurent3f75a5b2019-11-12 15:55:51 -08004041 } else if (sessionId == AUDIO_SESSION_DEVICE) {
Svet Ganov33761132021-05-13 22:51:08 +00004042 if (!modifyDefaultAudioEffectsAllowed(adjAttributionSource)) {
Eric Laurent3f75a5b2019-11-12 15:55:51 -08004043 ALOGE("%s: device effect permission denied for uid %d", __func__, callingUid);
4044 lStatus = PERMISSION_DENIED;
4045 goto Exit;
4046 }
Eric Laurent94876032019-11-13 12:45:28 -08004047 if (io != AUDIO_IO_HANDLE_NONE) {
4048 ALOGE("%s: io handle should not be specified for device effect", __func__);
4049 lStatus = BAD_VALUE;
4050 goto Exit;
4051 }
Andy Hung6096dcd2019-03-13 13:20:30 -07004052 } else {
4053 // general sessionId.
4054
4055 if (audio_unique_id_get_use(sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) {
4056 ALOGE("%s: invalid sessionId %d", __func__, sessionId);
4057 lStatus = BAD_VALUE;
4058 goto Exit;
4059 }
4060
4061 // TODO: should we check if the callingUid (limited to pid) is in mAudioSessionRefs
4062 // to prevent creating an effect when one doesn't actually have track with that session?
4063 }
4064
Mathias Agopian65ab4712010-07-14 17:59:35 -07004065 {
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07004066 // Get the full effect descriptor from the uuid/type.
4067 // If the session is the output mix, prefer an auxiliary effect,
4068 // otherwise no preference.
4069 uint32_t preferredType = (sessionId == AUDIO_SESSION_OUTPUT_MIX ?
4070 EFFECT_FLAG_TYPE_AUXILIARY : EFFECT_FLAG_TYPE_MASK);
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004071 lStatus = getEffectDescriptor(&descIn.uuid, &descIn.type, preferredType, &descOut);
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -07004072 if (lStatus < 0) {
4073 ALOGW("createEffect() error %d from getEffectDescriptor", lStatus);
4074 goto Exit;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004075 }
4076
4077 // Do not allow auxiliary effects on a session different from 0 (output mix)
Dima Zavinfce7a472011-04-19 22:30:36 -07004078 if (sessionId != AUDIO_SESSION_OUTPUT_MIX &&
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004079 (descOut.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07004080 lStatus = INVALID_OPERATION;
4081 goto Exit;
4082 }
4083
Eric Laurent59255e42011-07-27 19:49:51 -07004084 // check recording permission for visualizer
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004085 if ((memcmp(&descOut.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) &&
Svet Ganov6e641372018-03-02 09:21:30 -08004086 // TODO: Do we need to start/stop op - i.e. is there recording being performed?
Svet Ganov33761132021-05-13 22:51:08 +00004087 !recordingAllowed(adjAttributionSource)) {
Eric Laurent59255e42011-07-27 19:49:51 -07004088 lStatus = PERMISSION_DENIED;
4089 goto Exit;
4090 }
4091
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004092 const bool hapticPlaybackRequired = EffectModule::isHapticGenerator(&descOut.type);
jiabineb3bda02020-06-30 14:07:03 -07004093 if (hapticPlaybackRequired
4094 && (sessionId == AUDIO_SESSION_DEVICE
4095 || sessionId == AUDIO_SESSION_OUTPUT_MIX
4096 || sessionId == AUDIO_SESSION_OUTPUT_STAGE)) {
4097 // haptic-generating effect is only valid when the session id is a general session id
4098 lStatus = INVALID_OPERATION;
4099 goto Exit;
4100 }
4101
Eric Laurentf690c462021-09-17 14:47:03 +02004102 // Only audio policy service can create a spatializer effect
4103 if ((memcmp(&descOut.type, FX_IID_SPATIALIZER, sizeof(effect_uuid_t)) == 0) &&
4104 (callingUid != AID_AUDIOSERVER || currentPid != getpid())) {
4105 ALOGW("%s: attempt to create a spatializer effect from uid/pid %d/%d",
4106 __func__, callingUid, currentPid);
4107 lStatus = PERMISSION_DENIED;
4108 goto Exit;
4109 }
4110
Glenn Kasten142f5192014-03-25 17:44:59 -07004111 if (io == AUDIO_IO_HANDLE_NONE && sessionId == AUDIO_SESSION_OUTPUT_MIX) {
Eric Laurenteb3c3372013-09-25 12:25:29 -07004112 // if the output returned by getOutputForEffect() is removed before we lock the
4113 // mutex below, the call to checkPlaybackThread_l(io) below will detect it
4114 // and we will exit safely
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004115 io = AudioSystem::getOutputForEffect(&descOut);
Eric Laurenteb3c3372013-09-25 12:25:29 -07004116 ALOGV("createEffect got output %d", io);
4117 }
4118
4119 Mutex::Autolock _l(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004120
Eric Laurentb82e6b72019-11-22 17:25:04 -08004121 if (sessionId == AUDIO_SESSION_DEVICE) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07004122 sp<Client> client = registerPid(currentPid);
Eric Laurent2fe0acd2020-03-13 14:30:46 -07004123 ALOGV("%s device type %#x address %s", __func__, device.mType, device.getAddress());
Vlad Popa5161f8a2022-10-10 16:17:20 +02004124 handle = mDeviceEffectManager->createEffect_l(
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004125 &descOut, device, client, effectClient, mPatchPanel.patches_l(),
Eric Laurentde8caf42021-08-11 17:19:25 +02004126 &enabledOut, &lStatus, probe, request.notifyFramesProcessed);
Eric Laurentb82e6b72019-11-22 17:25:04 -08004127 if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
4128 // remove local strong reference to Client with mClientLock held
4129 Mutex::Autolock _cl(mClientLock);
4130 client.clear();
4131 } else {
4132 // handle must be valid here, but check again to be safe.
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004133 if (handle.get() != nullptr) idOut = handle->id();
Eric Laurentb82e6b72019-11-22 17:25:04 -08004134 }
4135 goto Register;
4136 }
4137
Mathias Agopian65ab4712010-07-14 17:59:35 -07004138 // If output is not specified try to find a matching audio session ID in one of the
4139 // output threads.
Eric Laurent84e9a102010-09-23 16:10:16 -07004140 // If output is 0 here, sessionId is neither SESSION_OUTPUT_STAGE nor SESSION_OUTPUT_MIX
4141 // because of code checking output when entering the function.
Andy Hung444bb552019-03-14 17:06:39 -07004142 // Note: io is never AUDIO_IO_HANDLE_NONE when creating an effect on an input by APM.
4143 // An AudioEffect created from the Java API will have io as AUDIO_IO_HANDLE_NONE.
Glenn Kasten142f5192014-03-25 17:44:59 -07004144 if (io == AUDIO_IO_HANDLE_NONE) {
Eric Laurenteb3c3372013-09-25 12:25:29 -07004145 // look for the thread where the specified audio session is present
Andy Hunge778c422019-03-14 15:04:30 -07004146 io = findIoHandleBySessionId_l(sessionId, mPlaybackThreads);
4147 if (io == AUDIO_IO_HANDLE_NONE) {
4148 io = findIoHandleBySessionId_l(sessionId, mRecordThreads);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004149 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08004150 if (io == AUDIO_IO_HANDLE_NONE) {
Andy Hunge778c422019-03-14 15:04:30 -07004151 io = findIoHandleBySessionId_l(sessionId, mMmapThreads);
Eric Laurent6acd1d42017-01-04 14:23:29 -08004152 }
Andy Hung444bb552019-03-14 17:06:39 -07004153
4154 // If you wish to create a Record preprocessing AudioEffect in Java,
4155 // you MUST create an AudioRecord first and keep it alive so it is picked up above.
4156 // Otherwise it will fail when created on a Playback thread by legacy
4157 // handling below. Ditto with Mmap, the associated Mmap track must be created
4158 // before creating the AudioEffect or the io handle must be specified.
4159 //
4160 // Detect if the effect is created after an AudioRecord is destroyed.
4161 if (getOrphanEffectChain_l(sessionId).get() != nullptr) {
4162 ALOGE("%s: effect %s with no specified io handle is denied because the AudioRecord"
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004163 " for session %d no longer exists",
4164 __func__, descOut.name, sessionId);
Andy Hung444bb552019-03-14 17:06:39 -07004165 lStatus = PERMISSION_DENIED;
4166 goto Exit;
4167 }
4168
4169 // Legacy handling of creating an effect on an expired or made-up
4170 // session id. We think that it is a Playback effect.
4171 //
Eric Laurent84e9a102010-09-23 16:10:16 -07004172 // If no output thread contains the requested session ID, default to
4173 // first output. The effect chain will be moved to the correct output
4174 // thread when a track with the same session ID is created
Glenn Kasten142f5192014-03-25 17:44:59 -07004175 if (io == AUDIO_IO_HANDLE_NONE && mPlaybackThreads.size() > 0) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07004176 io = mPlaybackThreads.keyAt(0);
4177 }
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004178 ALOGV("createEffect() got io %d for effect %s", io, descOut.name);
Eric Laurentb3f315a2021-07-13 15:09:05 +02004179 } else if (checkPlaybackThread_l(io) != nullptr
4180 && sessionId != AUDIO_SESSION_OUTPUT_STAGE) {
Andy Hung1631f062019-03-12 19:39:03 -07004181 // allow only one effect chain per sessionId on mPlaybackThreads.
4182 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
4183 const audio_io_handle_t checkIo = mPlaybackThreads.keyAt(i);
jiabineb3bda02020-06-30 14:07:03 -07004184 if (io == checkIo) {
4185 if (hapticPlaybackRequired
4186 && mPlaybackThreads.valueAt(i)
4187 ->hapticChannelMask() == AUDIO_CHANNEL_NONE) {
4188 ALOGE("%s: haptic playback thread is required while the required playback "
4189 "thread(io=%d) doesn't support", __func__, (int)io);
4190 lStatus = BAD_VALUE;
4191 goto Exit;
4192 }
4193 continue;
4194 }
Andy Hung1631f062019-03-12 19:39:03 -07004195 const uint32_t sessionType =
4196 mPlaybackThreads.valueAt(i)->hasAudioSession(sessionId);
4197 if ((sessionType & ThreadBase::EFFECT_SESSION) != 0) {
4198 ALOGE("%s: effect %s io %d denied because session %d effect exists on io %d",
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004199 __func__, descOut.name, (int) io, (int) sessionId, (int) checkIo);
Andy Hung1631f062019-03-12 19:39:03 -07004200 android_errorWriteLog(0x534e4554, "123237974");
4201 lStatus = BAD_VALUE;
4202 goto Exit;
4203 }
4204 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07004205 }
4206 ThreadBase *thread = checkRecordThread_l(io);
4207 if (thread == NULL) {
4208 thread = checkPlaybackThread_l(io);
4209 if (thread == NULL) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08004210 thread = checkMmapThread_l(io);
4211 if (thread == NULL) {
4212 ALOGE("createEffect() unknown output thread");
4213 lStatus = BAD_VALUE;
4214 goto Exit;
4215 }
Eric Laurent84e9a102010-09-23 16:10:16 -07004216 }
Eric Laurentaaa44472014-09-12 17:41:50 -07004217 } else {
4218 // Check if one effect chain was awaiting for an effect to be created on this
4219 // session and used it instead of creating a new one.
Glenn Kastend848eb42016-03-08 13:42:11 -08004220 sp<EffectChain> chain = getOrphanEffectChain_l(sessionId);
Eric Laurentaaa44472014-09-12 17:41:50 -07004221 if (chain != 0) {
Eric Laurent1b928682014-10-02 19:41:47 -07004222 Mutex::Autolock _l(thread->mLock);
Eric Laurentaaa44472014-09-12 17:41:50 -07004223 thread->addEffectChain_l(chain);
4224 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004225 }
Eric Laurent84e9a102010-09-23 16:10:16 -07004226
Philip P. Moltmannbda45752020-07-17 16:41:18 -07004227 sp<Client> client = registerPid(currentPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004228
Marco Nelissen3a34bef2011-08-02 13:33:41 -07004229 // create effect on selected output thread
Eric Laurent3f75a5b2019-11-12 15:55:51 -08004230 bool pinned = !audio_is_global_session(sessionId) && isSessionAcquired_l(sessionId);
jiabineb3bda02020-06-30 14:07:03 -07004231 ThreadBase *oriThread = nullptr;
4232 if (hapticPlaybackRequired && thread->hapticChannelMask() == AUDIO_CHANNEL_NONE) {
4233 ThreadBase *hapticThread = hapticPlaybackThread_l();
4234 if (hapticThread == nullptr) {
4235 ALOGE("%s haptic thread not found while it is required", __func__);
4236 lStatus = INVALID_OPERATION;
4237 goto Exit;
4238 }
4239 if (hapticThread != thread) {
4240 // Force to use haptic thread for haptic-generating effect.
4241 oriThread = thread;
4242 thread = hapticThread;
4243 }
4244 }
Eric Laurentde070132010-07-13 04:45:46 -07004245 handle = thread->createEffect_l(client, effectClient, priority, sessionId,
Eric Laurentde8caf42021-08-11 17:19:25 +02004246 &descOut, &enabledOut, &lStatus, pinned, probe,
4247 request.notifyFramesProcessed);
haobo101735295ff7b0d2017-03-17 17:44:03 +08004248 if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
Eric Laurentfe1a94e2014-05-26 16:03:08 -07004249 // remove local strong reference to Client with mClientLock held
4250 Mutex::Autolock _cl(mClientLock);
4251 client.clear();
haobo101735295ff7b0d2017-03-17 17:44:03 +08004252 } else {
4253 // handle must be valid here, but check again to be safe.
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004254 if (handle.get() != nullptr) idOut = handle->id();
jiabineb3bda02020-06-30 14:07:03 -07004255 // Invalidate audio session when haptic playback is created.
4256 if (hapticPlaybackRequired && oriThread != nullptr) {
4257 // invalidateTracksForAudioSession will trigger locking the thread.
4258 oriThread->invalidateTracksForAudioSession(sessionId);
4259 }
Eric Laurentfe1a94e2014-05-26 16:03:08 -07004260 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004261 }
4262
Eric Laurentb82e6b72019-11-22 17:25:04 -08004263Register:
Eric Laurent2fe0acd2020-03-13 14:30:46 -07004264 if (!probe && (lStatus == NO_ERROR || lStatus == ALREADY_EXISTS)) {
Eric Laurent4f1d4e92022-02-01 14:37:16 +01004265 if (lStatus == ALREADY_EXISTS) {
4266 response->alreadyExists = true;
4267 lStatus = NO_ERROR;
4268 } else {
4269 response->alreadyExists = false;
4270 }
Eric Laurent6c796322019-04-09 14:13:17 -07004271 // Check CPU and memory usage
Eric Laurent41709552019-12-16 19:34:05 -08004272 sp<EffectBase> effect = handle->effect().promote();
Eric Laurent6c796322019-04-09 14:13:17 -07004273 if (effect != nullptr) {
4274 status_t rStatus = effect->updatePolicyState();
4275 if (rStatus != NO_ERROR) {
4276 lStatus = rStatus;
4277 }
4278 }
4279 } else {
haobo101735295ff7b0d2017-03-17 17:44:03 +08004280 handle.clear();
4281 }
4282
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004283 response->id = idOut;
4284 response->enabled = enabledOut != 0;
4285 response->effect = handle;
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -08004286 response->desc = VALUE_OR_RETURN_STATUS(
4287 legacy2aidl_effect_descriptor_t_EffectDescriptor(descOut));
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004288
Mathias Agopian65ab4712010-07-14 17:59:35 -07004289Exit:
Ytai Ben-Tsvice182942020-11-04 14:48:01 -08004290 return lStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004291}
4292
Glenn Kastend848eb42016-03-08 13:42:11 -08004293status_t AudioFlinger::moveEffects(audio_session_t sessionId, audio_io_handle_t srcOutput,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08004294 audio_io_handle_t dstOutput)
Eric Laurentde070132010-07-13 04:45:46 -07004295{
Steve Block3856b092011-10-20 11:56:00 +01004296 ALOGV("moveEffects() session %d, srcOutput %d, dstOutput %d",
Eric Laurent59255e42011-07-27 19:49:51 -07004297 sessionId, srcOutput, dstOutput);
Eric Laurentde070132010-07-13 04:45:46 -07004298 Mutex::Autolock _l(mLock);
4299 if (srcOutput == dstOutput) {
Steve Block5ff1dd52012-01-05 23:22:43 +00004300 ALOGW("moveEffects() same dst and src outputs %d", dstOutput);
Eric Laurentde070132010-07-13 04:45:46 -07004301 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004302 }
Eric Laurentde070132010-07-13 04:45:46 -07004303 PlaybackThread *srcThread = checkPlaybackThread_l(srcOutput);
4304 if (srcThread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +00004305 ALOGW("moveEffects() bad srcOutput %d", srcOutput);
Eric Laurentde070132010-07-13 04:45:46 -07004306 return BAD_VALUE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004307 }
Eric Laurentde070132010-07-13 04:45:46 -07004308 PlaybackThread *dstThread = checkPlaybackThread_l(dstOutput);
4309 if (dstThread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +00004310 ALOGW("moveEffects() bad dstOutput %d", dstOutput);
Eric Laurentde070132010-07-13 04:45:46 -07004311 return BAD_VALUE;
4312 }
4313
4314 Mutex::Autolock _dl(dstThread->mLock);
4315 Mutex::Autolock _sl(srcThread->mLock);
Eric Laurent6c796322019-04-09 14:13:17 -07004316 return moveEffectChain_l(sessionId, srcThread, dstThread);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004317}
4318
Eric Laurentb20cf7d2019-04-05 19:37:34 -07004319
4320void AudioFlinger::setEffectSuspended(int effectId,
4321 audio_session_t sessionId,
4322 bool suspended)
4323{
4324 Mutex::Autolock _l(mLock);
4325
4326 sp<ThreadBase> thread = getEffectThread_l(sessionId, effectId);
4327 if (thread == nullptr) {
4328 return;
4329 }
4330 Mutex::Autolock _sl(thread->mLock);
4331 sp<EffectModule> effect = thread->getEffect_l(sessionId, effectId);
4332 thread->setEffectSuspended_l(&effect->desc().type, suspended, sessionId);
4333}
4334
4335
Marco Nelissen3a34bef2011-08-02 13:33:41 -07004336// moveEffectChain_l must be called with both srcThread and dstThread mLocks held
Glenn Kastend848eb42016-03-08 13:42:11 -08004337status_t AudioFlinger::moveEffectChain_l(audio_session_t sessionId,
Eric Laurentde070132010-07-13 04:45:46 -07004338 AudioFlinger::PlaybackThread *srcThread,
Eric Laurent6c796322019-04-09 14:13:17 -07004339 AudioFlinger::PlaybackThread *dstThread)
Eric Laurentde070132010-07-13 04:45:46 -07004340{
Steve Block3856b092011-10-20 11:56:00 +01004341 ALOGV("moveEffectChain_l() session %d from thread %p to thread %p",
Eric Laurent59255e42011-07-27 19:49:51 -07004342 sessionId, srcThread, dstThread);
Eric Laurentde070132010-07-13 04:45:46 -07004343
Eric Laurent59255e42011-07-27 19:49:51 -07004344 sp<EffectChain> chain = srcThread->getEffectChain_l(sessionId);
Eric Laurentde070132010-07-13 04:45:46 -07004345 if (chain == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00004346 ALOGW("moveEffectChain_l() effect chain for session %d not on source thread %p",
Eric Laurent59255e42011-07-27 19:49:51 -07004347 sessionId, srcThread);
Eric Laurentde070132010-07-13 04:45:46 -07004348 return INVALID_OPERATION;
4349 }
4350
Eric Laurent4c415062016-06-17 16:14:16 -07004351 // Check whether the destination thread and all effects in the chain are compatible
4352 if (!chain->isCompatibleWithThread_l(dstThread)) {
Andy Hung9a592762014-07-21 21:56:01 -07004353 ALOGW("moveEffectChain_l() effect chain failed because"
Eric Laurent4c415062016-06-17 16:14:16 -07004354 " destination thread %p is not compatible with effects in the chain",
4355 dstThread);
Andy Hung9a592762014-07-21 21:56:01 -07004356 return INVALID_OPERATION;
4357 }
4358
Eric Laurent39e94f82010-07-28 01:32:47 -07004359 // remove chain first. This is useful only if reconfiguring effect chain on same output thread,
Eric Laurentde070132010-07-13 04:45:46 -07004360 // so that a new chain is created with correct parameters when first effect is added. This is
Eric Laurentec35a142011-10-05 17:42:25 -07004361 // otherwise unnecessary as removeEffect_l() will remove the chain when last effect is
Eric Laurentde070132010-07-13 04:45:46 -07004362 // removed.
Andy Hung180f49a2022-01-27 10:25:02 -08004363 // TODO(b/216875016): consider holding the effect chain locks for the duration of the move.
Eric Laurentde070132010-07-13 04:45:46 -07004364 srcThread->removeEffectChain_l(chain);
4365
4366 // transfer all effects one by one so that new effect chain is created on new thread with
4367 // correct buffer sizes and audio parameters and effect engines reconfigured accordingly
Eric Laurent39e94f82010-07-28 01:32:47 -07004368 sp<EffectChain> dstChain;
Eric Laurentde070132010-07-13 04:45:46 -07004369 sp<EffectModule> effect = chain->getEffectFromId_l(0);
Eric Laurent5baf2af2013-09-12 17:37:00 -07004370 Vector< sp<EffectModule> > removed;
4371 status_t status = NO_ERROR;
Andy Hung03410c02022-01-27 08:24:31 -08004372 std::string errorString;
Andy Hung180f49a2022-01-27 10:25:02 -08004373 while (effect != nullptr) {
Eric Laurentde070132010-07-13 04:45:46 -07004374 srcThread->removeEffect_l(effect);
Eric Laurent5baf2af2013-09-12 17:37:00 -07004375 removed.add(effect);
4376 status = dstThread->addEffect_l(effect);
4377 if (status != NO_ERROR) {
Andy Hung03410c02022-01-27 08:24:31 -08004378 errorString = StringPrintf(
4379 "cannot add effect %p to destination thread", effect.get());
Eric Laurent5baf2af2013-09-12 17:37:00 -07004380 break;
4381 }
Eric Laurent39e94f82010-07-28 01:32:47 -07004382 // if the move request is not received from audio policy manager, the effect must be
Andy Hung180f49a2022-01-27 10:25:02 -08004383 // re-registered with the new strategy and output.
4384
4385 // We obtain the dstChain once the effect is on the new thread.
4386 if (dstChain == nullptr) {
Andy Hungfda44002021-06-03 17:23:16 -07004387 dstChain = effect->getCallback()->chain().promote();
Andy Hung180f49a2022-01-27 10:25:02 -08004388 if (dstChain == nullptr) {
Andy Hung03410c02022-01-27 08:24:31 -08004389 errorString = StringPrintf("cannot get chain from effect %p", effect.get());
Eric Laurent5baf2af2013-09-12 17:37:00 -07004390 status = NO_INIT;
4391 break;
Eric Laurent39e94f82010-07-28 01:32:47 -07004392 }
Eric Laurent39e94f82010-07-28 01:32:47 -07004393 }
Eric Laurentde070132010-07-13 04:45:46 -07004394 effect = chain->getEffectFromId_l(0);
4395 }
4396
Andy Hung03410c02022-01-27 08:24:31 -08004397 size_t restored = 0;
Eric Laurent5baf2af2013-09-12 17:37:00 -07004398 if (status != NO_ERROR) {
Andy Hung180f49a2022-01-27 10:25:02 -08004399 dstChain.clear(); // dstChain is now from the srcThread (could be recreated).
Andy Hung03410c02022-01-27 08:24:31 -08004400 for (const auto& effect : removed) {
Andy Hung5c4dd0d2022-01-27 10:21:59 -08004401 dstThread->removeEffect_l(effect); // Note: Depending on error location, the last
4402 // effect may not have been placed on dstThread.
Andy Hung03410c02022-01-27 08:24:31 -08004403 if (srcThread->addEffect_l(effect) == NO_ERROR) {
4404 ++restored;
Andy Hung180f49a2022-01-27 10:25:02 -08004405 if (dstChain == nullptr) {
4406 dstChain = effect->getCallback()->chain().promote();
4407 }
Andy Hung03410c02022-01-27 08:24:31 -08004408 }
Eric Laurent5baf2af2013-09-12 17:37:00 -07004409 }
4410 }
4411
Andy Hung180f49a2022-01-27 10:25:02 -08004412 // After all the effects have been moved to new thread (or put back) we restart the effects
4413 // because removeEffect_l() has stopped the effect if it is currently active.
4414 size_t started = 0;
4415 if (dstChain != nullptr && !removed.empty()) {
4416 // If we do not take the dstChain lock, it is possible that processing is ongoing
4417 // while we are starting the effect. This can cause glitches with volume,
4418 // see b/202360137.
4419 dstChain->lock();
4420 for (const auto& effect : removed) {
4421 if (effect->state() == EffectModule::ACTIVE ||
4422 effect->state() == EffectModule::STOPPING) {
4423 ++started;
4424 effect->start();
4425 }
4426 }
4427 dstChain->unlock();
4428 }
4429
Andy Hung03410c02022-01-27 08:24:31 -08004430 if (status != NO_ERROR) {
4431 if (errorString.empty()) {
4432 errorString = StringPrintf("%s: failed status %d", __func__, status);
4433 }
4434 ALOGW("%s: %s unsuccessful move of session %d from srcThread %p to dstThread %p "
Andy Hung180f49a2022-01-27 10:25:02 -08004435 "(%zu effects removed from srcThread, %zu effects restored to srcThread, "
4436 "%zu effects started)",
Andy Hung03410c02022-01-27 08:24:31 -08004437 __func__, errorString.c_str(), sessionId, srcThread, dstThread,
Andy Hung180f49a2022-01-27 10:25:02 -08004438 removed.size(), restored, started);
Andy Hung03410c02022-01-27 08:24:31 -08004439 } else {
4440 ALOGD("%s: successful move of session %d from srcThread %p to dstThread %p "
Andy Hung180f49a2022-01-27 10:25:02 -08004441 "(%zu effects moved, %zu effects started)",
4442 __func__, sessionId, srcThread, dstThread, removed.size(), started);
Andy Hung03410c02022-01-27 08:24:31 -08004443 }
Eric Laurent5baf2af2013-09-12 17:37:00 -07004444 return status;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004445}
4446
Eric Laurent6c796322019-04-09 14:13:17 -07004447status_t AudioFlinger::moveAuxEffectToIo(int EffectId,
4448 const sp<PlaybackThread>& dstThread,
4449 sp<PlaybackThread> *srcThread)
4450{
4451 status_t status = NO_ERROR;
4452 Mutex::Autolock _l(mLock);
Eric Laurentb20cf7d2019-04-05 19:37:34 -07004453 sp<PlaybackThread> thread =
4454 static_cast<PlaybackThread *>(getEffectThread_l(AUDIO_SESSION_OUTPUT_MIX, EffectId).get());
Eric Laurent6c796322019-04-09 14:13:17 -07004455
4456 if (EffectId != 0 && thread != 0 && dstThread != thread.get()) {
4457 Mutex::Autolock _dl(dstThread->mLock);
4458 Mutex::Autolock _sl(thread->mLock);
4459 sp<EffectChain> srcChain = thread->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
4460 sp<EffectChain> dstChain;
4461 if (srcChain == 0) {
4462 return INVALID_OPERATION;
4463 }
4464
4465 sp<EffectModule> effect = srcChain->getEffectFromId_l(EffectId);
4466 if (effect == 0) {
4467 return INVALID_OPERATION;
4468 }
4469 thread->removeEffect_l(effect);
4470 status = dstThread->addEffect_l(effect);
4471 if (status != NO_ERROR) {
4472 thread->addEffect_l(effect);
4473 status = INVALID_OPERATION;
4474 goto Exit;
4475 }
4476
Andy Hungfda44002021-06-03 17:23:16 -07004477 dstChain = effect->getCallback()->chain().promote();
Eric Laurent6c796322019-04-09 14:13:17 -07004478 if (dstChain == 0) {
4479 thread->addEffect_l(effect);
4480 status = INVALID_OPERATION;
4481 }
4482
4483Exit:
4484 // removeEffect_l() has stopped the effect if it was active so it must be restarted
4485 if (effect->state() == EffectModule::ACTIVE ||
4486 effect->state() == EffectModule::STOPPING) {
4487 effect->start();
4488 }
4489 }
4490
4491 if (status == NO_ERROR && srcThread != nullptr) {
4492 *srcThread = thread;
4493 }
4494 return status;
4495}
4496
Eric Laurent5baf2af2013-09-12 17:37:00 -07004497bool AudioFlinger::isNonOffloadableGlobalEffectEnabled_l()
Eric Laurent813e2a72013-08-31 12:59:48 -07004498{
4499 if (mGlobalEffectEnableTime != 0 &&
4500 ((systemTime() - mGlobalEffectEnableTime) < kMinGlobalEffectEnabletimeNs)) {
4501 return true;
4502 }
4503
4504 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
4505 sp<EffectChain> ec =
4506 mPlaybackThreads.valueAt(i)->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
Eric Laurent5baf2af2013-09-12 17:37:00 -07004507 if (ec != 0 && ec->isNonOffloadableEnabled()) {
Eric Laurent813e2a72013-08-31 12:59:48 -07004508 return true;
4509 }
4510 }
4511 return false;
4512}
4513
Eric Laurent5baf2af2013-09-12 17:37:00 -07004514void AudioFlinger::onNonOffloadableGlobalEffectEnable()
Eric Laurent813e2a72013-08-31 12:59:48 -07004515{
4516 Mutex::Autolock _l(mLock);
4517
4518 mGlobalEffectEnableTime = systemTime();
4519
4520 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
4521 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
4522 if (t->mType == ThreadBase::OFFLOAD) {
4523 t->invalidateTracks(AUDIO_STREAM_MUSIC);
4524 }
4525 }
4526
4527}
4528
Eric Laurentaaa44472014-09-12 17:41:50 -07004529status_t AudioFlinger::putOrphanEffectChain_l(const sp<AudioFlinger::EffectChain>& chain)
4530{
Eric Laurentd8365c52017-07-16 15:27:05 -07004531 // clear possible suspended state before parking the chain so that it starts in default state
4532 // when attached to a new record thread
4533 chain->setEffectSuspended_l(FX_IID_AEC, false);
4534 chain->setEffectSuspended_l(FX_IID_NS, false);
4535
Glenn Kastend848eb42016-03-08 13:42:11 -08004536 audio_session_t session = chain->sessionId();
Eric Laurentaaa44472014-09-12 17:41:50 -07004537 ssize_t index = mOrphanEffectChains.indexOfKey(session);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07004538 ALOGV("putOrphanEffectChain_l session %d index %zd", session, index);
Eric Laurentaaa44472014-09-12 17:41:50 -07004539 if (index >= 0) {
4540 ALOGW("putOrphanEffectChain_l chain for session %d already present", session);
4541 return ALREADY_EXISTS;
4542 }
4543 mOrphanEffectChains.add(session, chain);
4544 return NO_ERROR;
4545}
4546
4547sp<AudioFlinger::EffectChain> AudioFlinger::getOrphanEffectChain_l(audio_session_t session)
4548{
4549 sp<EffectChain> chain;
4550 ssize_t index = mOrphanEffectChains.indexOfKey(session);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07004551 ALOGV("getOrphanEffectChain_l session %d index %zd", session, index);
Eric Laurentaaa44472014-09-12 17:41:50 -07004552 if (index >= 0) {
4553 chain = mOrphanEffectChains.valueAt(index);
4554 mOrphanEffectChains.removeItemsAt(index);
4555 }
4556 return chain;
4557}
4558
4559bool AudioFlinger::updateOrphanEffectChains(const sp<AudioFlinger::EffectModule>& effect)
4560{
4561 Mutex::Autolock _l(mLock);
Glenn Kastend848eb42016-03-08 13:42:11 -08004562 audio_session_t session = effect->sessionId();
Eric Laurentaaa44472014-09-12 17:41:50 -07004563 ssize_t index = mOrphanEffectChains.indexOfKey(session);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07004564 ALOGV("updateOrphanEffectChains session %d index %zd", session, index);
Eric Laurentaaa44472014-09-12 17:41:50 -07004565 if (index >= 0) {
4566 sp<EffectChain> chain = mOrphanEffectChains.valueAt(index);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08004567 if (chain->removeEffect_l(effect, true) == 0) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07004568 ALOGV("updateOrphanEffectChains removing effect chain at index %zd", index);
Eric Laurentaaa44472014-09-12 17:41:50 -07004569 mOrphanEffectChains.removeItemsAt(index);
4570 }
4571 return true;
4572 }
4573 return false;
4574}
4575
4576
Mathias Agopian65ab4712010-07-14 17:59:35 -07004577// ----------------------------------------------------------------------------
4578
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -07004579status_t AudioFlinger::onTransactWrapper(TransactionCode code,
4580 const Parcel& data,
4581 uint32_t flags,
4582 const std::function<status_t()>& delegate) {
4583 (void) data;
4584 (void) flags;
4585
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004586 // make sure transactions reserved to AudioPolicyManager do not come from other processes
4587 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004588 case TransactionCode::SET_STREAM_VOLUME:
4589 case TransactionCode::SET_STREAM_MUTE:
4590 case TransactionCode::OPEN_OUTPUT:
4591 case TransactionCode::OPEN_DUPLICATE_OUTPUT:
4592 case TransactionCode::CLOSE_OUTPUT:
4593 case TransactionCode::SUSPEND_OUTPUT:
4594 case TransactionCode::RESTORE_OUTPUT:
4595 case TransactionCode::OPEN_INPUT:
4596 case TransactionCode::CLOSE_INPUT:
4597 case TransactionCode::INVALIDATE_STREAM:
4598 case TransactionCode::SET_VOICE_VOLUME:
4599 case TransactionCode::MOVE_EFFECTS:
4600 case TransactionCode::SET_EFFECT_SUSPENDED:
4601 case TransactionCode::LOAD_HW_MODULE:
4602 case TransactionCode::GET_AUDIO_PORT:
4603 case TransactionCode::CREATE_AUDIO_PATCH:
4604 case TransactionCode::RELEASE_AUDIO_PATCH:
4605 case TransactionCode::LIST_AUDIO_PATCHES:
4606 case TransactionCode::SET_AUDIO_PORT_CONFIG:
4607 case TransactionCode::SET_RECORD_SILENCED:
Eric Laurentd66d7a12021-07-13 13:35:32 +02004608 case TransactionCode::AUDIO_POLICY_READY:
Mikhail Naganov516d3982022-02-01 23:53:59 +00004609 case TransactionCode::SET_DEVICE_CONNECTED_STATE:
Eric Laurent076e7c72022-05-03 18:12:28 +02004610 case TransactionCode::SET_REQUESTED_LATENCY_MODE:
4611 case TransactionCode::GET_SUPPORTED_LATENCY_MODES:
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004612 ALOGW("%s: transaction %d received from PID %d",
4613 __func__, code, IPCThreadState::self()->getCallingPid());
4614 // return status only for non void methods
4615 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004616 case TransactionCode::SET_RECORD_SILENCED:
4617 case TransactionCode::SET_EFFECT_SUSPENDED:
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004618 break;
4619 default:
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004620 return INVALID_OPERATION;
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004621 }
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -07004622 // Fail silently in these cases.
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004623 return OK;
4624 default:
4625 break;
4626 }
4627
4628 // make sure the following transactions come from system components
4629 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004630 case TransactionCode::SET_MASTER_VOLUME:
4631 case TransactionCode::SET_MASTER_MUTE:
Jean-Michel Trivie4f113b2020-11-16 11:50:33 -08004632 case TransactionCode::MASTER_MUTE:
Vlad Popa63f047e2022-11-05 14:09:19 +01004633 case TransactionCode::REGISTER_SOUND_DOSE_CALLBACK:
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004634 case TransactionCode::SET_MODE:
4635 case TransactionCode::SET_MIC_MUTE:
4636 case TransactionCode::SET_LOW_RAM_DEVICE:
4637 case TransactionCode::SYSTEM_READY:
jiabin1319f5a2021-03-30 22:21:24 +00004638 case TransactionCode::SET_AUDIO_HAL_PIDS:
jiabinf042b9b2021-05-07 23:46:28 +00004639 case TransactionCode::SET_VIBRATOR_INFOS:
4640 case TransactionCode::UPDATE_SECONDARY_OUTPUTS: {
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004641 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
4642 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
4643 __func__, code, IPCThreadState::self()->getCallingPid(),
4644 IPCThreadState::self()->getCallingUid());
Vlad Popa63f047e2022-11-05 14:09:19 +01004645 // return status only for non-void methods
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004646 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004647 case TransactionCode::SYSTEM_READY:
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004648 break;
4649 default:
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004650 return INVALID_OPERATION;
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004651 }
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -07004652 // Fail silently in these cases.
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004653 return OK;
4654 }
4655 } break;
4656 default:
4657 break;
4658 }
4659
4660 // List of relevant events that trigger log merging.
4661 // Log merging should activate during audio activity of any kind. This are considered the
4662 // most relevant events.
4663 // TODO should select more wisely the items from the list
4664 switch (code) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08004665 case TransactionCode::CREATE_TRACK:
4666 case TransactionCode::CREATE_RECORD:
4667 case TransactionCode::SET_MASTER_VOLUME:
4668 case TransactionCode::SET_MASTER_MUTE:
4669 case TransactionCode::SET_MIC_MUTE:
4670 case TransactionCode::SET_PARAMETERS:
4671 case TransactionCode::CREATE_EFFECT:
4672 case TransactionCode::SYSTEM_READY: {
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004673 requestLogMerge();
4674 break;
4675 }
4676 default:
4677 break;
4678 }
4679
Andy Hungc747c532022-03-07 21:41:14 -08004680 const std::string methodName = getIAudioFlingerStatistics().getMethodForCode(code);
4681 mediautils::TimeCheck check(
4682 std::string("IAudioFlinger::").append(methodName),
4683 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
4684 if (timeout) {
4685 mediametrics::LogItem(mMetricsId)
4686 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
4687 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
4688 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
4689 .record();
4690 } else {
4691 getIAudioFlingerStatistics().event(code, elapsedMs);
4692 }
Andy Hungf8ab0932022-06-13 19:49:43 -07004693 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
4694 mediautils::TimeCheck::kDefaultSecondChanceDuration,
4695 true /* crashOnTimeout */);
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -08004696
4697 // Make sure we connect to Audio Policy Service before calling into AudioFlinger:
4698 // - AudioFlinger can call into Audio Policy Service with its global mutex held
4699 // - If this is the first time Audio Policy Service is queried from inside audioserver process
4700 // this will trigger Audio Policy Manager initialization.
4701 // - Audio Policy Manager initialization calls into AudioFlinger which will try to lock
4702 // its global mutex and a deadlock will occur.
4703 if (IPCThreadState::self()->getCallingPid() != getpid()) {
4704 AudioSystem::get_audio_policy_service();
4705 }
4706
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -07004707 return delegate();
Mathias Agopian65ab4712010-07-14 17:59:35 -07004708}
4709
Glenn Kasten63238ef2015-03-02 15:50:29 -08004710} // namespace android