blob: bbdd89c1c60c3bf133e0b886aaf6330276c3be83 [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
Glenn Kasten153b9fe2013-07-15 11:23:36 -070022#include "Configuration.h"
Glenn Kastenda6ef132013-01-10 12:31:01 -080023#include <dirent.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070024#include <math.h>
25#include <signal.h>
26#include <sys/time.h>
27#include <sys/resource.h>
28
Gloria Wang9ee159b2011-02-24 14:51:45 -080029#include <binder/IPCThreadState.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070030#include <binder/IServiceManager.h>
31#include <utils/Log.h>
Glenn Kastend8e6fd32012-05-07 11:07:57 -070032#include <utils/Trace.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070033#include <binder/Parcel.h>
Mikhail Naganova0c91332016-09-19 10:01:12 -070034#include <media/audiohal/DeviceHalInterface.h>
35#include <media/audiohal/DevicesFactoryHalInterface.h>
36#include <media/audiohal/EffectsFactoryHalInterface.h>
Mikhail Naganov00260b52016-10-13 12:54:24 -070037#include <media/AudioParameter.h>
Mikhail Naganov913d06c2016-11-01 12:49:22 -070038#include <media/TypeConverter.h>
Andy Hung35fec5f2016-04-13 14:21:48 -070039#include <memunreachable/memunreachable.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070040#include <utils/String16.h>
41#include <utils/threads.h>
Eric Laurent38ccae22011-03-28 18:37:07 -070042#include <utils/Atomic.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070043
44#include <cutils/properties.h>
45
Dima Zavin64760242011-05-11 14:15:23 -070046#include <system/audio.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070047
Mathias Agopian65ab4712010-07-14 17:59:35 -070048#include "AudioFlinger.h"
Glenn Kasten44deb052012-02-05 18:09:08 -080049#include "ServiceUtilities.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070050
Andy Hung6770c6f2015-04-07 13:43:36 -070051#include <media/AudioResamplerPublic.h>
52
Mikhail Naganov9fe94012016-10-14 14:57:40 -070053#include <system/audio_effects/effect_visualizer.h>
54#include <system/audio_effects/effect_ns.h>
55#include <system/audio_effects/effect_aec.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070056
Glenn Kasten3b21c502011-12-15 09:52:39 -080057#include <audio_utils/primitives.h>
58
Eric Laurentfeb0db62011-07-22 09:04:31 -070059#include <powermanager/PowerManager.h>
Glenn Kasten190a46f2012-03-06 11:27:10 -080060
Glenn Kasten9e58b552013-01-18 15:09:48 -080061#include <media/IMediaLogService.h>
Andy Hung07b745e2016-05-23 16:21:07 -070062#include <media/MemoryLeakTrackUtil.h>
Glenn Kastenda6ef132013-01-10 12:31:01 -080063#include <media/nbaio/Pipe.h>
64#include <media/nbaio/PipeReader.h>
Glenn Kasten1ab85ec2013-05-31 09:18:43 -070065#include <media/AudioParameter.h>
Wei Jia3f273d12015-11-24 09:06:49 -080066#include <mediautils/BatteryNotifier.h>
Glenn Kasten4182c4e2013-07-15 14:45:07 -070067#include <private/android_filesystem_config.h>
Glenn Kastenda6ef132013-01-10 12:31:01 -080068
rago3bd1c872016-09-26 12:58:14 -070069//#define BUFLOG_NDEBUG 0
70#include <BufLog.h>
71
Nicolas Rouletfe1e1442017-01-30 12:02:03 -080072#include "TypedLogger.h"
73
Mathias Agopian65ab4712010-07-14 17:59:35 -070074// ----------------------------------------------------------------------------
Mathias Agopian65ab4712010-07-14 17:59:35 -070075
John Grossman1c345192012-03-27 14:00:17 -070076// Note: the following macro is used for extremely verbose logging message. In
77// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
78// 0; but one side effect of this is to turn all LOGV's as well. Some messages
79// are so verbose that we want to suppress them even when we have ALOG_ASSERT
80// turned on. Do not uncomment the #def below unless you really know what you
81// are doing and want to see all of the extremely verbose messages.
82//#define VERY_VERY_VERBOSE_LOGGING
83#ifdef VERY_VERY_VERBOSE_LOGGING
84#define ALOGVV ALOGV
85#else
86#define ALOGVV(a...) do { } while(0)
87#endif
Eric Laurentde070132010-07-13 04:45:46 -070088
Mathias Agopian65ab4712010-07-14 17:59:35 -070089namespace android {
90
Glenn Kastenec1d6b52011-12-12 09:04:45 -080091static const char kDeadlockedString[] = "AudioFlinger may be deadlocked\n";
92static const char kHardwareLockedString[] = "Hardware lock is taken\n";
Eric Laurent021cf962014-05-13 10:18:14 -070093static const char kClientLockedString[] = "Client lock is taken\n";
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -070094static const char kNoEffectsFactory[] = "Effects Factory is absent\n";
Mathias Agopian65ab4712010-07-14 17:59:35 -070095
Glenn Kasten58912562012-04-03 10:45:00 -070096
John Grossman4ff14ba2012-02-08 16:37:41 -080097nsecs_t AudioFlinger::mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs;
Eric Laurent7cafbb32011-11-22 18:50:29 -080098
Eric Laurent81784c32012-11-19 14:55:58 -080099uint32_t AudioFlinger::mScreenState;
Glenn Kasten3ed29202012-08-07 15:24:44 -0700100
Eric Laurentfc235202016-12-20 18:48:17 -0800101
Glenn Kasten46909e72013-02-26 09:20:22 -0800102#ifdef TEE_SINK
Glenn Kastenda6ef132013-01-10 12:31:01 -0800103bool AudioFlinger::mTeeSinkInputEnabled = false;
104bool AudioFlinger::mTeeSinkOutputEnabled = false;
105bool AudioFlinger::mTeeSinkTrackEnabled = false;
106
107size_t AudioFlinger::mTeeSinkInputFrames = kTeeSinkInputFramesDefault;
108size_t AudioFlinger::mTeeSinkOutputFrames = kTeeSinkOutputFramesDefault;
109size_t AudioFlinger::mTeeSinkTrackFrames = kTeeSinkTrackFramesDefault;
Glenn Kasten46909e72013-02-26 09:20:22 -0800110#endif
Glenn Kastenda6ef132013-01-10 12:31:01 -0800111
Eric Laurent813e2a72013-08-31 12:59:48 -0700112// In order to avoid invalidating offloaded tracks each time a Visualizer is turned on and off
113// we define a minimum time during which a global effect is considered enabled.
114static const nsecs_t kMinGlobalEffectEnabletimeNs = seconds(7200);
115
Eric Laurentfc235202016-12-20 18:48:17 -0800116Mutex gLock;
117wp<AudioFlinger> gAudioFlinger;
118
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700119// Keep a strong reference to media.log service around forever.
120// The service is within our parent process so it can never die in a way that we could observe.
121// These two variables are const after initialization.
122static sp<IBinder> sMediaLogServiceAsBinder;
123static sp<IMediaLogService> sMediaLogService;
124
125static pthread_once_t sMediaLogOnce = PTHREAD_ONCE_INIT;
126
127static void sMediaLogInit()
128{
129 sMediaLogServiceAsBinder = defaultServiceManager()->getService(String16("media.log"));
130 if (sMediaLogServiceAsBinder != 0) {
131 sMediaLogService = interface_cast<IMediaLogService>(sMediaLogServiceAsBinder);
132 }
133}
134
Mathias Agopian65ab4712010-07-14 17:59:35 -0700135// ----------------------------------------------------------------------------
136
Mikhail Naganov913d06c2016-11-01 12:49:22 -0700137std::string formatToString(audio_format_t format) {
138 std::string result;
139 FormatConverter::toString(format, result);
140 return result;
Marco Nelissenb2208842014-02-07 14:00:50 -0800141}
142
Mathias Agopian65ab4712010-07-14 17:59:35 -0700143// ----------------------------------------------------------------------------
144
145AudioFlinger::AudioFlinger()
146 : BnAudioFlinger(),
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -0800147 mMediaLogNotifier(new AudioFlinger::MediaLogNotifier()),
John Grossman4ff14ba2012-02-08 16:37:41 -0800148 mPrimaryHardwareDev(NULL),
Glenn Kasten9ea65d02014-01-17 10:21:24 -0800149 mAudioHwDevs(NULL),
Glenn Kasten7d6c35b2012-07-02 12:45:10 -0700150 mHardwareStatus(AUDIO_HW_IDLE),
John Grossman4ff14ba2012-02-08 16:37:41 -0800151 mMasterVolume(1.0f),
John Grossman4ff14ba2012-02-08 16:37:41 -0800152 mMasterMute(false),
Glenn Kastend2e67e12016-04-11 08:26:37 -0700153 // mNextUniqueId(AUDIO_UNIQUE_ID_USE_MAX),
John Grossman4ff14ba2012-02-08 16:37:41 -0800154 mMode(AUDIO_MODE_INVALID),
Glenn Kasten4182c4e2013-07-15 14:45:07 -0700155 mBtNrecIsOff(false),
156 mIsLowRamDevice(true),
Eric Laurent813e2a72013-08-31 12:59:48 -0700157 mIsDeviceTypeKnown(false),
Glenn Kasten4ea00a22014-06-02 08:29:22 -0700158 mGlobalEffectEnableTime(0),
Eric Laurent72e3f392015-05-20 14:43:50 -0700159 mSystemReady(false)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700160{
Glenn Kastend2e67e12016-04-11 08:26:37 -0700161 // unsigned instead of audio_unique_id_use_t, because ++ operator is unavailable for enum
162 for (unsigned use = AUDIO_UNIQUE_ID_USE_UNSPECIFIED; use < AUDIO_UNIQUE_ID_USE_MAX; use++) {
163 // zero ID has a special meaning, so unavailable
164 mNextUniqueIds[use] = AUDIO_UNIQUE_ID_USE_MAX;
165 }
166
Glenn Kasten949a9262013-04-16 12:35:20 -0700167 getpid_cached = getpid();
Glenn Kastenae0cff12016-02-24 13:57:49 -0800168 const bool doLog = property_get_bool("ro.test_harness", false);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800169 if (doLog) {
Glenn Kastenb187de12014-12-30 08:18:15 -0800170 mLogMemoryDealer = new MemoryDealer(kLogMemorySize, "LogWriters",
171 MemoryHeapBase::READ_ONLY);
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700172 (void) pthread_once(&sMediaLogOnce, sMediaLogInit);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800173 }
Eric Laurent1c333e22014-05-20 10:48:17 -0700174
Wei Jia3f273d12015-11-24 09:06:49 -0800175 // reset battery stats.
176 // if the audio service has crashed, battery stats could be left
177 // in bad state, reset the state upon service start.
178 BatteryNotifier::getInstance().noteResetAudio();
179
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700180 mDevicesFactoryHal = DevicesFactoryHalInterface::create();
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700181 mEffectsFactoryHal = EffectsFactoryHalInterface::create();
182
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -0800183 mMediaLogNotifier->run("MediaLogNotifier");
184
Glenn Kasten46909e72013-02-26 09:20:22 -0800185#ifdef TEE_SINK
Glenn Kasten9a003992016-02-23 15:24:34 -0800186 char value[PROPERTY_VALUE_MAX];
Glenn Kastenda6ef132013-01-10 12:31:01 -0800187 (void) property_get("ro.debuggable", value, "0");
188 int debuggable = atoi(value);
189 int teeEnabled = 0;
190 if (debuggable) {
191 (void) property_get("af.tee", value, "0");
192 teeEnabled = atoi(value);
193 }
Glenn Kastenf66b4222014-02-20 10:23:28 -0800194 // FIXME symbolic constants here
Glenn Kasten6e2ebe92013-08-13 09:14:51 -0700195 if (teeEnabled & 1) {
Glenn Kastenda6ef132013-01-10 12:31:01 -0800196 mTeeSinkInputEnabled = true;
Glenn Kasten6e2ebe92013-08-13 09:14:51 -0700197 }
198 if (teeEnabled & 2) {
Glenn Kastenda6ef132013-01-10 12:31:01 -0800199 mTeeSinkOutputEnabled = true;
Glenn Kasten6e2ebe92013-08-13 09:14:51 -0700200 }
201 if (teeEnabled & 4) {
Glenn Kastenda6ef132013-01-10 12:31:01 -0800202 mTeeSinkTrackEnabled = true;
Glenn Kasten6e2ebe92013-08-13 09:14:51 -0700203 }
Glenn Kasten46909e72013-02-26 09:20:22 -0800204#endif
Dima Zavin5a61d2f2011-04-19 19:04:32 -0700205}
206
207void AudioFlinger::onFirstRef()
208{
Eric Laurent93575202011-01-18 18:39:02 -0800209 Mutex::Autolock _l(mLock);
210
Dima Zavin799a70e2011-04-18 16:57:27 -0700211 /* TODO: move all this work into an Init() function */
John Grossman4ff14ba2012-02-08 16:37:41 -0800212 char val_str[PROPERTY_VALUE_MAX] = { 0 };
213 if (property_get("ro.audio.flinger_standbytime_ms", val_str, NULL) >= 0) {
214 uint32_t int_val;
215 if (1 == sscanf(val_str, "%u", &int_val)) {
216 mStandbyTimeInNsecs = milliseconds(int_val);
217 ALOGI("Using %u mSec as standby time.", int_val);
218 } else {
219 mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs;
220 ALOGI("Using default %u mSec as standby time.",
221 (uint32_t)(mStandbyTimeInNsecs / 1000000));
222 }
223 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700224
Eric Laurent1c333e22014-05-20 10:48:17 -0700225 mPatchPanel = new PatchPanel(this);
Andy Hungdeb03352016-08-29 14:40:14 -0700226
Eric Laurenta4c5a552012-03-29 10:12:40 -0700227 mMode = AUDIO_MODE_NORMAL;
Eric Laurentfc235202016-12-20 18:48:17 -0800228
229 gAudioFlinger = this;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700230}
231
232AudioFlinger::~AudioFlinger()
233{
234 while (!mRecordThreads.isEmpty()) {
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700235 // closeInput_nonvirtual() will remove specified entry from mRecordThreads
Glenn Kastend96c5722012-04-25 13:44:49 -0700236 closeInput_nonvirtual(mRecordThreads.keyAt(0));
Mathias Agopian65ab4712010-07-14 17:59:35 -0700237 }
238 while (!mPlaybackThreads.isEmpty()) {
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700239 // closeOutput_nonvirtual() will remove specified entry from mPlaybackThreads
Glenn Kastend96c5722012-04-25 13:44:49 -0700240 closeOutput_nonvirtual(mPlaybackThreads.keyAt(0));
Mathias Agopian65ab4712010-07-14 17:59:35 -0700241 }
Dima Zavin799a70e2011-04-18 16:57:27 -0700242
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800243 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
244 // no mHardwareLock needed, as there are no other references to this
Eric Laurenta4c5a552012-03-29 10:12:40 -0700245 delete mAudioHwDevs.valueAt(i);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700246 }
Glenn Kasten481fb672013-09-30 14:39:28 -0700247
248 // Tell media.log service about any old writers that still need to be unregistered
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700249 if (sMediaLogService != 0) {
250 for (size_t count = mUnregisteredWriters.size(); count > 0; count--) {
251 sp<IMemory> iMemory(mUnregisteredWriters.top()->getIMemory());
252 mUnregisteredWriters.pop();
253 sMediaLogService->unregisterWriter(iMemory);
Glenn Kasten481fb672013-09-30 14:39:28 -0700254 }
255 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700256}
257
Eric Laurentfc235202016-12-20 18:48:17 -0800258//static
Eric Laurent6acd1d42017-01-04 14:23:29 -0800259__attribute__ ((visibility ("default")))
Eric Laurentfc235202016-12-20 18:48:17 -0800260status_t MmapStreamInterface::openMmapStream(MmapStreamInterface::stream_direction_t direction,
261 const audio_attributes_t *attr,
262 audio_config_base_t *config,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700263 const AudioClient& client,
Eric Laurentfc235202016-12-20 18:48:17 -0800264 audio_port_handle_t *deviceId,
265 const sp<MmapStreamCallback>& callback,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700266 sp<MmapStreamInterface>& interface,
267 audio_port_handle_t *handle)
Eric Laurentfc235202016-12-20 18:48:17 -0800268{
269 sp<AudioFlinger> af;
270 {
271 Mutex::Autolock _l(gLock);
272 af = gAudioFlinger.promote();
273 }
274 status_t ret = NO_INIT;
275 if (af != 0) {
276 ret = af->openMmapStream(
Eric Laurentcb4dae22017-07-01 19:39:32 -0700277 direction, attr, config, client, deviceId, callback, interface, handle);
Eric Laurentfc235202016-12-20 18:48:17 -0800278 }
279 return ret;
280}
281
Eric Laurent6acd1d42017-01-04 14:23:29 -0800282status_t AudioFlinger::openMmapStream(MmapStreamInterface::stream_direction_t direction,
283 const audio_attributes_t *attr,
284 audio_config_base_t *config,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700285 const AudioClient& client,
Eric Laurent6acd1d42017-01-04 14:23:29 -0800286 audio_port_handle_t *deviceId,
287 const sp<MmapStreamCallback>& callback,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700288 sp<MmapStreamInterface>& interface,
289 audio_port_handle_t *handle)
Eric Laurentfc235202016-12-20 18:48:17 -0800290{
291 status_t ret = initCheck();
292 if (ret != NO_ERROR) {
293 return ret;
294 }
295
Eric Laurent6acd1d42017-01-04 14:23:29 -0800296 audio_session_t sessionId = (audio_session_t) newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
297 audio_stream_type_t streamType = AUDIO_STREAM_DEFAULT;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700298 audio_io_handle_t io = AUDIO_IO_HANDLE_NONE;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800299 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
300 if (direction == MmapStreamInterface::DIRECTION_OUTPUT) {
301 audio_config_t fullConfig = AUDIO_CONFIG_INITIALIZER;
302 fullConfig.sample_rate = config->sample_rate;
303 fullConfig.channel_mask = config->channel_mask;
304 fullConfig.format = config->format;
305 ret = AudioSystem::getOutputForAttr(attr, &io,
306 sessionId,
307 &streamType, client.clientUid,
308 &fullConfig,
Glenn Kastend3bb6452016-12-05 18:14:37 -0800309 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ |
310 AUDIO_OUTPUT_FLAG_DIRECT),
Eric Laurent2ac76942017-06-22 17:17:09 -0700311 deviceId, &portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800312 } else {
313 ret = AudioSystem::getInputForAttr(attr, &io,
314 sessionId,
315 client.clientPid,
316 client.clientUid,
317 config,
Eric Laurent2ac76942017-06-22 17:17:09 -0700318 AUDIO_INPUT_FLAG_MMAP_NOIRQ, deviceId, &portId);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800319 }
320 if (ret != NO_ERROR) {
321 return ret;
322 }
323
324 // at this stage, a MmapThread was created when openOutput() or openInput() was called by
325 // audio policy manager and we can retrieve it
326 sp<MmapThread> thread = mMmapThreads.valueFor(io);
327 if (thread != 0) {
328 interface = new MmapThreadHandle(thread);
Eric Laurent7aa0ccb2017-08-28 11:12:52 -0700329 thread->configure(attr, streamType, sessionId, callback, *deviceId, portId);
Eric Laurentcb4dae22017-07-01 19:39:32 -0700330 *handle = portId;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800331 } else {
Eric Laurentad2e7b92017-09-14 20:06:42 -0700332 if (direction == MmapStreamInterface::DIRECTION_OUTPUT) {
333 AudioSystem::releaseOutput(io, streamType, sessionId);
334 } else {
335 AudioSystem::releaseInput(io, sessionId);
336 }
Eric Laurent6acd1d42017-01-04 14:23:29 -0800337 ret = NO_INIT;
338 }
339
340 ALOGV("%s done status %d portId %d", __FUNCTION__, ret, portId);
341
Eric Laurentfc235202016-12-20 18:48:17 -0800342 return ret;
343}
344
Eric Laurenta4c5a552012-03-29 10:12:40 -0700345static const char * const audio_interfaces[] = {
346 AUDIO_HARDWARE_MODULE_ID_PRIMARY,
347 AUDIO_HARDWARE_MODULE_ID_A2DP,
348 AUDIO_HARDWARE_MODULE_ID_USB,
349};
Eric Laurenta4c5a552012-03-29 10:12:40 -0700350
Phil Burk062e67a2015-02-11 13:40:50 -0800351AudioHwDevice* AudioFlinger::findSuitableHwDev_l(
John Grossmanee578c02012-07-23 17:05:46 -0700352 audio_module_handle_t module,
353 audio_devices_t devices)
Dima Zavin799a70e2011-04-18 16:57:27 -0700354{
Eric Laurenta4c5a552012-03-29 10:12:40 -0700355 // if module is 0, the request comes from an old policy manager and we should load
356 // well known modules
357 if (module == 0) {
358 ALOGW("findSuitableHwDev_l() loading well know audio hw modules");
Mikhail Naganovbf493082017-04-17 17:37:12 -0700359 for (size_t i = 0; i < arraysize(audio_interfaces); i++) {
Eric Laurenta4c5a552012-03-29 10:12:40 -0700360 loadHwModule_l(audio_interfaces[i]);
361 }
Eric Laurentf1c04f92012-08-28 14:26:53 -0700362 // then try to find a module supporting the requested device.
363 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
364 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueAt(i);
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700365 sp<DeviceHalInterface> dev = audioHwDevice->hwDevice();
366 uint32_t supportedDevices;
367 if (dev->getSupportedDevices(&supportedDevices) == OK &&
368 (supportedDevices & devices) == devices) {
Eric Laurentf1c04f92012-08-28 14:26:53 -0700369 return audioHwDevice;
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700370 }
Eric Laurentf1c04f92012-08-28 14:26:53 -0700371 }
Eric Laurenta4c5a552012-03-29 10:12:40 -0700372 } else {
373 // check a match for the requested module handle
John Grossmanee578c02012-07-23 17:05:46 -0700374 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueFor(module);
375 if (audioHwDevice != NULL) {
376 return audioHwDevice;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700377 }
378 }
Eric Laurenta4c5a552012-03-29 10:12:40 -0700379
Dima Zavin799a70e2011-04-18 16:57:27 -0700380 return NULL;
381}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700382
Glenn Kasten0f11b512014-01-31 16:18:54 -0800383void AudioFlinger::dumpClients(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700384{
385 const size_t SIZE = 256;
386 char buffer[SIZE];
387 String8 result;
388
389 result.append("Clients:\n");
390 for (size_t i = 0; i < mClients.size(); ++i) {
Glenn Kasten77c11192012-01-25 14:27:41 -0800391 sp<Client> client = mClients.valueAt(i).promote();
392 if (client != 0) {
393 snprintf(buffer, SIZE, " pid: %d\n", client->pid());
394 result.append(buffer);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700395 }
396 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700397
Eric Laurentd1b28d42013-09-18 18:47:13 -0700398 result.append("Notification Clients:\n");
399 for (size_t i = 0; i < mNotificationClients.size(); ++i) {
400 snprintf(buffer, SIZE, " pid: %d\n", mNotificationClients.keyAt(i));
401 result.append(buffer);
402 }
403
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700404 result.append("Global session refs:\n");
Marco Nelissenb2208842014-02-07 14:00:50 -0800405 result.append(" session pid count\n");
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700406 for (size_t i = 0; i < mAudioSessionRefs.size(); i++) {
407 AudioSessionRef *r = mAudioSessionRefs[i];
Marco Nelissenb2208842014-02-07 14:00:50 -0800408 snprintf(buffer, SIZE, " %7d %5d %5d\n", r->mSessionid, r->mPid, r->mCnt);
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700409 result.append(buffer);
410 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700411 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700412}
413
414
Glenn Kasten0f11b512014-01-31 16:18:54 -0800415void AudioFlinger::dumpInternals(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700416{
417 const size_t SIZE = 256;
418 char buffer[SIZE];
419 String8 result;
Glenn Kastena4454b42012-01-04 11:02:33 -0800420 hardware_call_state hardwareStatus = mHardwareStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700421
John Grossman4ff14ba2012-02-08 16:37:41 -0800422 snprintf(buffer, SIZE, "Hardware status: %d\n"
423 "Standby Time mSec: %u\n",
424 hardwareStatus,
425 (uint32_t)(mStandbyTimeInNsecs / 1000000));
Mathias Agopian65ab4712010-07-14 17:59:35 -0700426 result.append(buffer);
427 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700428}
429
Glenn Kasten0f11b512014-01-31 16:18:54 -0800430void AudioFlinger::dumpPermissionDenial(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700431{
432 const size_t SIZE = 256;
433 char buffer[SIZE];
434 String8 result;
435 snprintf(buffer, SIZE, "Permission Denial: "
436 "can't dump AudioFlinger from pid=%d, uid=%d\n",
437 IPCThreadState::self()->getCallingPid(),
438 IPCThreadState::self()->getCallingUid());
439 result.append(buffer);
440 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700441}
442
Eric Laurent81784c32012-11-19 14:55:58 -0800443bool AudioFlinger::dumpTryLock(Mutex& mutex)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700444{
445 bool locked = false;
446 for (int i = 0; i < kDumpLockRetries; ++i) {
447 if (mutex.tryLock() == NO_ERROR) {
448 locked = true;
449 break;
450 }
Glenn Kasten7dede872011-12-13 11:04:14 -0800451 usleep(kDumpLockSleepUs);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700452 }
453 return locked;
454}
455
456status_t AudioFlinger::dump(int fd, const Vector<String16>& args)
457{
Glenn Kasten44deb052012-02-05 18:09:08 -0800458 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700459 dumpPermissionDenial(fd, args);
460 } else {
461 // get state of hardware lock
Eric Laurent81784c32012-11-19 14:55:58 -0800462 bool hardwareLocked = dumpTryLock(mHardwareLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700463 if (!hardwareLocked) {
464 String8 result(kHardwareLockedString);
465 write(fd, result.string(), result.size());
466 } else {
467 mHardwareLock.unlock();
468 }
469
Eric Laurent81784c32012-11-19 14:55:58 -0800470 bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700471
472 // failed to lock - AudioFlinger is probably deadlocked
473 if (!locked) {
474 String8 result(kDeadlockedString);
475 write(fd, result.string(), result.size());
476 }
477
Eric Laurent021cf962014-05-13 10:18:14 -0700478 bool clientLocked = dumpTryLock(mClientLock);
479 if (!clientLocked) {
480 String8 result(kClientLockedString);
481 write(fd, result.string(), result.size());
482 }
Marco Nelissend89eadd2014-10-07 13:28:44 -0700483
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700484 if (mEffectsFactoryHal != 0) {
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700485 mEffectsFactoryHal->dumpEffects(fd);
486 } else {
487 String8 result(kNoEffectsFactory);
488 write(fd, result.string(), result.size());
489 }
Marco Nelissend89eadd2014-10-07 13:28:44 -0700490
Mathias Agopian65ab4712010-07-14 17:59:35 -0700491 dumpClients(fd, args);
Eric Laurent021cf962014-05-13 10:18:14 -0700492 if (clientLocked) {
493 mClientLock.unlock();
494 }
495
Mathias Agopian65ab4712010-07-14 17:59:35 -0700496 dumpInternals(fd, args);
497
498 // dump playback threads
499 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
500 mPlaybackThreads.valueAt(i)->dump(fd, args);
501 }
502
503 // dump record threads
504 for (size_t i = 0; i < mRecordThreads.size(); i++) {
505 mRecordThreads.valueAt(i)->dump(fd, args);
506 }
507
Eric Laurent6acd1d42017-01-04 14:23:29 -0800508 // dump mmap threads
509 for (size_t i = 0; i < mMmapThreads.size(); i++) {
510 mMmapThreads.valueAt(i)->dump(fd, args);
511 }
512
Eric Laurentaaa44472014-09-12 17:41:50 -0700513 // dump orphan effect chains
514 if (mOrphanEffectChains.size() != 0) {
515 write(fd, " Orphan Effect Chains\n", strlen(" Orphan Effect Chains\n"));
516 for (size_t i = 0; i < mOrphanEffectChains.size(); i++) {
517 mOrphanEffectChains.valueAt(i)->dump(fd, args);
518 }
519 }
Dima Zavin799a70e2011-04-18 16:57:27 -0700520 // dump all hardware devs
521 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700522 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
523 dev->dump(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700524 }
Glenn Kastend06785b2012-09-30 12:29:28 -0700525
Glenn Kasten46909e72013-02-26 09:20:22 -0800526#ifdef TEE_SINK
Glenn Kastend06785b2012-09-30 12:29:28 -0700527 // dump the serially shared record tee sink
528 if (mRecordTeeSource != 0) {
Glenn Kasten5b2191a2016-08-19 11:44:47 -0700529 dumpTee(fd, mRecordTeeSource, AUDIO_IO_HANDLE_NONE, 'C');
Glenn Kastend06785b2012-09-30 12:29:28 -0700530 }
Glenn Kasten46909e72013-02-26 09:20:22 -0800531#endif
Glenn Kastend06785b2012-09-30 12:29:28 -0700532
rago3bd1c872016-09-26 12:58:14 -0700533 BUFLOG_RESET;
534
Glenn Kastend65d73c2012-06-22 17:21:07 -0700535 if (locked) {
536 mLock.unlock();
537 }
Glenn Kasten9e58b552013-01-18 15:09:48 -0800538
539 // append a copy of media.log here by forwarding fd to it, but don't attempt
540 // to lookup the service if it's not running, as it will block for a second
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700541 if (sMediaLogServiceAsBinder != 0) {
542 dprintf(fd, "\nmedia.log:\n");
543 Vector<String16> args;
544 sMediaLogServiceAsBinder->dump(fd, args);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800545 }
Andy Hung35fec5f2016-04-13 14:21:48 -0700546
547 // check for optional arguments
Andy Hung07b745e2016-05-23 16:21:07 -0700548 bool dumpMem = false;
Andy Hung35fec5f2016-04-13 14:21:48 -0700549 bool unreachableMemory = false;
550 for (const auto &arg : args) {
Andy Hung07b745e2016-05-23 16:21:07 -0700551 if (arg == String16("-m")) {
552 dumpMem = true;
553 } else if (arg == String16("--unreachable")) {
Andy Hung35fec5f2016-04-13 14:21:48 -0700554 unreachableMemory = true;
555 }
556 }
557
Andy Hung07b745e2016-05-23 16:21:07 -0700558 if (dumpMem) {
559 dprintf(fd, "\nDumping memory:\n");
560 std::string s = dumpMemoryAddresses(100 /* limit */);
561 write(fd, s.c_str(), s.size());
562 }
Andy Hung35fec5f2016-04-13 14:21:48 -0700563 if (unreachableMemory) {
564 dprintf(fd, "\nDumping unreachable memory:\n");
565 // TODO - should limit be an argument parameter?
Andy Hung07b745e2016-05-23 16:21:07 -0700566 std::string s = GetUnreachableMemoryString(true /* contents */, 100 /* limit */);
Andy Hung35fec5f2016-04-13 14:21:48 -0700567 write(fd, s.c_str(), s.size());
568 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700569 }
570 return NO_ERROR;
571}
572
Eric Laurent021cf962014-05-13 10:18:14 -0700573sp<AudioFlinger::Client> AudioFlinger::registerPid(pid_t pid)
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800574{
Eric Laurent021cf962014-05-13 10:18:14 -0700575 Mutex::Autolock _cl(mClientLock);
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800576 // If pid is already in the mClients wp<> map, then use that entry
577 // (for which promote() is always != 0), otherwise create a new entry and Client.
578 sp<Client> client = mClients.valueFor(pid).promote();
579 if (client == 0) {
580 client = new Client(this, pid);
581 mClients.add(pid, client);
582 }
583
584 return client;
585}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700586
Glenn Kasten9e58b552013-01-18 15:09:48 -0800587sp<NBLog::Writer> AudioFlinger::newWriter_l(size_t size, const char *name)
588{
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700589 // If there is no memory allocated for logs, return a dummy writer that does nothing.
590 // Similarly if we can't contact the media.log service, also return a dummy writer.
591 if (mLogMemoryDealer == 0 || sMediaLogService == 0) {
Glenn Kasten9e58b552013-01-18 15:09:48 -0800592 return new NBLog::Writer();
593 }
Glenn Kasten481fb672013-09-30 14:39:28 -0700594 sp<IMemory> shared = mLogMemoryDealer->allocate(NBLog::Timeline::sharedSize(size));
595 // If allocation fails, consult the vector of previously unregistered writers
596 // and garbage-collect one or more them until an allocation succeeds
597 if (shared == 0) {
598 Mutex::Autolock _l(mUnregisteredWritersLock);
599 for (size_t count = mUnregisteredWriters.size(); count > 0; count--) {
600 {
601 // Pick the oldest stale writer to garbage-collect
602 sp<IMemory> iMemory(mUnregisteredWriters[0]->getIMemory());
603 mUnregisteredWriters.removeAt(0);
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700604 sMediaLogService->unregisterWriter(iMemory);
Glenn Kasten481fb672013-09-30 14:39:28 -0700605 // Now the media.log remote reference to IMemory is gone. When our last local
606 // reference to IMemory also drops to zero at end of this block,
607 // the IMemory destructor will deallocate the region from mLogMemoryDealer.
608 }
609 // Re-attempt the allocation
610 shared = mLogMemoryDealer->allocate(NBLog::Timeline::sharedSize(size));
611 if (shared != 0) {
612 goto success;
613 }
614 }
615 // Even after garbage-collecting all old writers, there is still not enough memory,
616 // so return a dummy writer
617 return new NBLog::Writer();
618 }
619success:
Glenn Kasten535e1612016-12-05 12:19:36 -0800620 NBLog::Shared *sharedRawPtr = (NBLog::Shared *) shared->pointer();
621 new((void *) sharedRawPtr) NBLog::Shared(); // placement new here, but the corresponding
622 // explicit destructor not needed since it is POD
Glenn Kasten04b96fc2017-04-10 14:58:47 -0700623 sMediaLogService->registerWriter(shared, size, name);
Glenn Kasten535e1612016-12-05 12:19:36 -0800624 return new NBLog::Writer(shared, size);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800625}
626
627void AudioFlinger::unregisterWriter(const sp<NBLog::Writer>& writer)
628{
Glenn Kasten685ef092013-02-04 08:15:34 -0800629 if (writer == 0) {
630 return;
631 }
Glenn Kasten9e58b552013-01-18 15:09:48 -0800632 sp<IMemory> iMemory(writer->getIMemory());
633 if (iMemory == 0) {
634 return;
635 }
Glenn Kasten481fb672013-09-30 14:39:28 -0700636 // Rather than removing the writer immediately, append it to a queue of old writers to
637 // be garbage-collected later. This allows us to continue to view old logs for a while.
638 Mutex::Autolock _l(mUnregisteredWritersLock);
639 mUnregisteredWriters.push(writer);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800640}
641
Mathias Agopian65ab4712010-07-14 17:59:35 -0700642// IAudioFlinger interface
643
Eric Laurent21da6472017-11-09 16:29:26 -0800644sp<IAudioTrack> AudioFlinger::createTrack(const CreateTrackInput& input,
645 CreateTrackOutput& output,
646 status_t *status)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700647{
648 sp<PlaybackThread::Track> track;
649 sp<TrackHandle> trackHandle;
650 sp<Client> client;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700651 status_t lStatus;
Eric Laurent21da6472017-11-09 16:29:26 -0800652 audio_stream_type_t streamType;
653 audio_port_handle_t portId;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700654
Eric Laurent21da6472017-11-09 16:29:26 -0800655 bool updatePid = (input.clientInfo.clientPid == -1);
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -0700656 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Eric Laurent21da6472017-11-09 16:29:26 -0800657 uid_t clientUid = input.clientInfo.clientUid;
658 if (!isTrustedCallingUid(callingUid)) {
659 ALOGW_IF(clientUid != callingUid,
660 "%s uid %d tried to pass itself off as %d",
661 __FUNCTION__, callingUid, clientUid);
662 clientUid = callingUid;
663 updatePid = true;
664 }
665 pid_t clientPid = input.clientInfo.clientPid;
666 if (updatePid) {
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -0700667 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Eric Laurent21da6472017-11-09 16:29:26 -0800668 ALOGW_IF(clientPid != -1 && clientPid != callingPid,
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -0700669 "%s uid %d pid %d tried to pass itself off as pid %d",
Eric Laurent21da6472017-11-09 16:29:26 -0800670 __func__, callingUid, callingPid, clientPid);
671 clientPid = callingPid;
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -0700672 }
673
Eric Laurent21da6472017-11-09 16:29:26 -0800674 audio_session_t sessionId = input.sessionId;
675 if (sessionId == AUDIO_SESSION_ALLOCATE) {
676 sessionId = (audio_session_t) newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
Eric Laurentf14db3c2017-12-08 14:20:36 -0800677 } else if (audio_unique_id_get_use(sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) {
678 lStatus = BAD_VALUE;
679 goto Exit;
Eric Laurent21da6472017-11-09 16:29:26 -0800680 }
Eric Laurentf14db3c2017-12-08 14:20:36 -0800681
Eric Laurent21da6472017-11-09 16:29:26 -0800682 output.sessionId = sessionId;
683 output.outputId = AUDIO_IO_HANDLE_NONE;
684 output.selectedDeviceId = input.selectedDeviceId;
685
686 lStatus = AudioSystem::getOutputForAttr(&input.attr, &output.outputId, sessionId, &streamType,
687 clientUid, &input.config, input.flags,
688 &output.selectedDeviceId, &portId);
689
690 if (lStatus != NO_ERROR || output.outputId == AUDIO_IO_HANDLE_NONE) {
691 ALOGE("createTrack() getOutputForAttr() return error %d or invalid output handle", lStatus);
692 goto Exit;
693 }
Glenn Kasten263709e2012-01-06 08:40:01 -0800694 // client AudioTrack::set already implements AUDIO_STREAM_DEFAULT => AUDIO_STREAM_MUSIC,
695 // but if someone uses binder directly they could bypass that and cause us to crash
696 if (uint32_t(streamType) >= AUDIO_STREAM_CNT) {
Steve Block29357bc2012-01-06 19:20:56 +0000697 ALOGE("createTrack() invalid stream type %d", streamType);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700698 lStatus = BAD_VALUE;
699 goto Exit;
700 }
701
Glenn Kasten53b5d092014-02-05 10:00:23 -0800702 // further channel mask checks are performed by createTrack_l() depending on the thread type
Eric Laurent21da6472017-11-09 16:29:26 -0800703 if (!audio_is_output_channel(input.config.channel_mask)) {
704 ALOGE("createTrack() invalid channel mask %#x", input.config.channel_mask);
Glenn Kasten53b5d092014-02-05 10:00:23 -0800705 lStatus = BAD_VALUE;
706 goto Exit;
707 }
708
Glenn Kastenc4b88a82014-04-30 16:54:30 -0700709 // further format checks are performed by createTrack_l() depending on the thread type
Eric Laurent21da6472017-11-09 16:29:26 -0800710 if (!audio_is_valid_format(input.config.format)) {
711 ALOGE("createTrack() invalid format %#x", input.config.format);
Glenn Kasten663c2242013-09-24 11:52:37 -0700712 lStatus = BAD_VALUE;
713 goto Exit;
714 }
715
Mathias Agopian65ab4712010-07-14 17:59:35 -0700716 {
717 Mutex::Autolock _l(mLock);
Eric Laurent21da6472017-11-09 16:29:26 -0800718 PlaybackThread *thread = checkPlaybackThread_l(output.outputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700719 if (thread == NULL) {
Eric Laurent21da6472017-11-09 16:29:26 -0800720 ALOGE("no playback thread found for output handle %d", output.outputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700721 lStatus = BAD_VALUE;
722 goto Exit;
723 }
724
Eric Laurent21da6472017-11-09 16:29:26 -0800725 client = registerPid(clientPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700726
Glenn Kastene848bd92014-03-13 15:00:32 -0700727 PlaybackThread *effectThread = NULL;
Eric Laurent21da6472017-11-09 16:29:26 -0800728 // check if an effect chain with the same session ID is present on another
729 // output thread and move it here.
730 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
731 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
732 if (mPlaybackThreads.keyAt(i) != output.outputId) {
733 uint32_t sessions = t->hasAudioSession(sessionId);
734 if (sessions & ThreadBase::EFFECT_SESSION) {
735 effectThread = t.get();
736 break;
Eric Laurentde070132010-07-13 04:45:46 -0700737 }
738 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700739 }
Eric Laurent21da6472017-11-09 16:29:26 -0800740 ALOGV("createTrack() sessionId: %d", sessionId);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700741
Eric Laurent21da6472017-11-09 16:29:26 -0800742 output.sampleRate = input.config.sample_rate;
743 output.frameCount = input.frameCount;
744 output.notificationFrameCount = input.notificationFrameCount;
745 output.flags = input.flags;
746
747 track = thread->createTrack_l(client, streamType, &output.sampleRate, input.config.format,
748 input.config.channel_mask,
749 &output.frameCount, &output.notificationFrameCount,
750 input.notificationsPerBuffer, input.speed,
751 input.sharedBuffer, sessionId, &output.flags,
752 input.clientInfo.clientTid, clientUid, &lStatus, portId);
Haynes Mathew George03e9e832013-12-13 15:40:13 -0800753 LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (track == 0));
Glenn Kasten2fc14732013-08-05 14:58:14 -0700754 // we don't abort yet if lStatus != NO_ERROR; there is still work to be done regardless
Eric Laurent39e94f82010-07-28 01:32:47 -0700755
Eric Laurent21da6472017-11-09 16:29:26 -0800756 output.afFrameCount = thread->frameCount();
757 output.afSampleRate = thread->sampleRate();
758 output.afLatencyMs = thread->latency();
759
Eric Laurent39e94f82010-07-28 01:32:47 -0700760 // move effect chain to this output thread if an effect on same session was waiting
761 // for a track to be created
762 if (lStatus == NO_ERROR && effectThread != NULL) {
Glenn Kasten2fc14732013-08-05 14:58:14 -0700763 // no risk of deadlock because AudioFlinger::mLock is held
Eric Laurent39e94f82010-07-28 01:32:47 -0700764 Mutex::Autolock _dl(thread->mLock);
765 Mutex::Autolock _sl(effectThread->mLock);
Eric Laurent21da6472017-11-09 16:29:26 -0800766 moveEffectChain_l(sessionId, effectThread, thread, true);
Eric Laurent39e94f82010-07-28 01:32:47 -0700767 }
Eric Laurenta011e352012-03-29 15:51:43 -0700768
769 // Look for sync events awaiting for a session to be used.
Mark Salyzyn3ab368e2014-04-15 14:55:53 -0700770 for (size_t i = 0; i < mPendingSyncEvents.size(); i++) {
Eric Laurent21da6472017-11-09 16:29:26 -0800771 if (mPendingSyncEvents[i]->triggerSession() == sessionId) {
Eric Laurenta011e352012-03-29 15:51:43 -0700772 if (thread->isValidSyncEvent(mPendingSyncEvents[i])) {
Eric Laurent29864602012-05-08 18:57:51 -0700773 if (lStatus == NO_ERROR) {
Glenn Kastend23eedc2012-08-02 13:35:47 -0700774 (void) track->setSyncEvent(mPendingSyncEvents[i]);
Eric Laurent29864602012-05-08 18:57:51 -0700775 } else {
776 mPendingSyncEvents[i]->cancel();
777 }
Eric Laurenta011e352012-03-29 15:51:43 -0700778 mPendingSyncEvents.removeAt(i);
779 i--;
780 }
781 }
782 }
Glenn Kastene198c362013-08-13 09:13:36 -0700783
Eric Laurent21da6472017-11-09 16:29:26 -0800784 setAudioHwSyncForSession_l(thread, sessionId);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700785 }
Glenn Kastene198c362013-08-13 09:13:36 -0700786
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700787 if (lStatus != NO_ERROR) {
788 // remove local strong reference to Client before deleting the Track so that the
Eric Laurent021cf962014-05-13 10:18:14 -0700789 // Client destructor is called by the TrackBase destructor with mClientLock held
Eric Laurentfe1a94e2014-05-26 16:03:08 -0700790 // Don't hold mClientLock when releasing the reference on the track as the
791 // destructor will acquire it.
792 {
793 Mutex::Autolock _cl(mClientLock);
794 client.clear();
795 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700796 track.clear();
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700797 goto Exit;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700798 }
799
Glenn Kasten3ef14ef2014-03-13 15:08:51 -0700800 // return handle to client
801 trackHandle = new TrackHandle(track);
802
Mathias Agopian65ab4712010-07-14 17:59:35 -0700803Exit:
Eric Laurent21da6472017-11-09 16:29:26 -0800804 if (lStatus != NO_ERROR && output.outputId != AUDIO_IO_HANDLE_NONE) {
805 AudioSystem::releaseOutput(output.outputId, streamType, sessionId);
806 }
Glenn Kasten9156ef32013-08-06 15:39:08 -0700807 *status = lStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700808 return trackHandle;
809}
810
Glenn Kasten2c073da2016-02-26 09:14:08 -0800811uint32_t AudioFlinger::sampleRate(audio_io_handle_t ioHandle) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700812{
813 Mutex::Autolock _l(mLock);
Glenn Kasten2c073da2016-02-26 09:14:08 -0800814 ThreadBase *thread = checkThread_l(ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700815 if (thread == NULL) {
Glenn Kasten2c073da2016-02-26 09:14:08 -0800816 ALOGW("sampleRate() unknown thread %d", ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700817 return 0;
818 }
819 return thread->sampleRate();
820}
821
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800822audio_format_t AudioFlinger::format(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700823{
824 Mutex::Autolock _l(mLock);
825 PlaybackThread *thread = checkPlaybackThread_l(output);
826 if (thread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +0000827 ALOGW("format() unknown thread %d", output);
Glenn Kasten58f30212012-01-12 12:27:51 -0800828 return AUDIO_FORMAT_INVALID;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700829 }
830 return thread->format();
831}
832
Glenn Kasten2c073da2016-02-26 09:14:08 -0800833size_t AudioFlinger::frameCount(audio_io_handle_t ioHandle) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700834{
835 Mutex::Autolock _l(mLock);
Glenn Kasten2c073da2016-02-26 09:14:08 -0800836 ThreadBase *thread = checkThread_l(ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700837 if (thread == NULL) {
Glenn Kasten2c073da2016-02-26 09:14:08 -0800838 ALOGW("frameCount() unknown thread %d", ioHandle);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700839 return 0;
840 }
Glenn Kasten58912562012-04-03 10:45:00 -0700841 // FIXME currently returns the normal mixer's frame count to avoid confusing legacy callers;
842 // should examine all callers and fix them to handle smaller counts
Mathias Agopian65ab4712010-07-14 17:59:35 -0700843 return thread->frameCount();
844}
845
Glenn Kasten4a8308b2016-04-18 14:10:01 -0700846size_t AudioFlinger::frameCountHAL(audio_io_handle_t ioHandle) const
847{
848 Mutex::Autolock _l(mLock);
849 ThreadBase *thread = checkThread_l(ioHandle);
850 if (thread == NULL) {
851 ALOGW("frameCountHAL() unknown thread %d", ioHandle);
852 return 0;
853 }
854 return thread->frameCountHAL();
855}
856
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800857uint32_t AudioFlinger::latency(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700858{
859 Mutex::Autolock _l(mLock);
860 PlaybackThread *thread = checkPlaybackThread_l(output);
861 if (thread == NULL) {
Glenn Kastenc9b2e202013-02-26 11:32:32 -0800862 ALOGW("latency(): no playback thread found for output handle %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700863 return 0;
864 }
865 return thread->latency();
866}
867
868status_t AudioFlinger::setMasterVolume(float value)
869{
Eric Laurenta1884f92011-08-23 08:25:03 -0700870 status_t ret = initCheck();
871 if (ret != NO_ERROR) {
872 return ret;
873 }
874
Mathias Agopian65ab4712010-07-14 17:59:35 -0700875 // check calling permissions
876 if (!settingsAllowed()) {
877 return PERMISSION_DENIED;
878 }
879
Eric Laurenta4c5a552012-03-29 10:12:40 -0700880 Mutex::Autolock _l(mLock);
John Grossmanee578c02012-07-23 17:05:46 -0700881 mMasterVolume = value;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700882
John Grossmanee578c02012-07-23 17:05:46 -0700883 // Set master volume in the HALs which support it.
884 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
885 AutoMutex lock(mHardwareLock);
886 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
John Grossman4ff14ba2012-02-08 16:37:41 -0800887
John Grossmanee578c02012-07-23 17:05:46 -0700888 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
889 if (dev->canSetMasterVolume()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700890 dev->hwDevice()->setMasterVolume(value);
Eric Laurent93575202011-01-18 18:39:02 -0800891 }
John Grossmanee578c02012-07-23 17:05:46 -0700892 mHardwareStatus = AUDIO_HW_IDLE;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700893 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700894
John Grossmanee578c02012-07-23 17:05:46 -0700895 // Now set the master volume in each playback thread. Playback threads
896 // assigned to HALs which do not have master volume support will apply
897 // master volume during the mix operation. Threads with HALs which do
898 // support master volume will simply ignore the setting.
Eric Laurentf6870ae2015-05-08 10:50:03 -0700899 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
900 if (mPlaybackThreads.valueAt(i)->isDuplicating()) {
901 continue;
902 }
John Grossmanee578c02012-07-23 17:05:46 -0700903 mPlaybackThreads.valueAt(i)->setMasterVolume(value);
Eric Laurentf6870ae2015-05-08 10:50:03 -0700904 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700905
906 return NO_ERROR;
907}
908
Glenn Kastenf78aee72012-01-04 11:00:47 -0800909status_t AudioFlinger::setMode(audio_mode_t mode)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700910{
Eric Laurenta1884f92011-08-23 08:25:03 -0700911 status_t ret = initCheck();
912 if (ret != NO_ERROR) {
913 return ret;
914 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700915
916 // check calling permissions
917 if (!settingsAllowed()) {
918 return PERMISSION_DENIED;
919 }
Glenn Kasten930f4ca2012-01-06 16:47:31 -0800920 if (uint32_t(mode) >= AUDIO_MODE_CNT) {
Steve Block5ff1dd52012-01-05 23:22:43 +0000921 ALOGW("Illegal value: setMode(%d)", mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700922 return BAD_VALUE;
923 }
924
925 { // scope for the lock
926 AutoMutex lock(mHardwareLock);
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700927 sp<DeviceHalInterface> dev = mPrimaryHardwareDev->hwDevice();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700928 mHardwareStatus = AUDIO_HW_SET_MODE;
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700929 ret = dev->setMode(mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700930 mHardwareStatus = AUDIO_HW_IDLE;
931 }
932
933 if (NO_ERROR == ret) {
934 Mutex::Autolock _l(mLock);
935 mMode = mode;
Glenn Kasten8d6a2442012-02-08 14:04:28 -0800936 for (size_t i = 0; i < mPlaybackThreads.size(); i++)
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700937 mPlaybackThreads.valueAt(i)->setMode(mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700938 }
939
940 return ret;
941}
942
943status_t AudioFlinger::setMicMute(bool state)
944{
Eric Laurenta1884f92011-08-23 08:25:03 -0700945 status_t ret = initCheck();
946 if (ret != NO_ERROR) {
947 return ret;
948 }
949
Mathias Agopian65ab4712010-07-14 17:59:35 -0700950 // check calling permissions
951 if (!settingsAllowed()) {
952 return PERMISSION_DENIED;
953 }
954
955 AutoMutex lock(mHardwareLock);
956 mHardwareStatus = AUDIO_HW_SET_MIC_MUTE;
Eric Laurent2f035f52014-09-14 12:11:52 -0700957 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700958 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
959 status_t result = dev->setMicMute(state);
Eric Laurent2f035f52014-09-14 12:11:52 -0700960 if (result != NO_ERROR) {
961 ret = result;
962 }
963 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700964 mHardwareStatus = AUDIO_HW_IDLE;
965 return ret;
966}
967
968bool AudioFlinger::getMicMute() const
969{
Eric Laurenta1884f92011-08-23 08:25:03 -0700970 status_t ret = initCheck();
971 if (ret != NO_ERROR) {
972 return false;
973 }
Ricardo Garcia3e91b5d2015-02-19 10:54:52 -0800974 bool mute = true;
Dima Zavinfce7a472011-04-19 22:30:36 -0700975 bool state = AUDIO_MODE_INVALID;
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800976 AutoMutex lock(mHardwareLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700977 mHardwareStatus = AUDIO_HW_GET_MIC_MUTE;
Ricardo Garcia3e91b5d2015-02-19 10:54:52 -0800978 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700979 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
980 status_t result = dev->getMicMute(&state);
Ricardo Garcia3e91b5d2015-02-19 10:54:52 -0800981 if (result == NO_ERROR) {
982 mute = mute && state;
983 }
984 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700985 mHardwareStatus = AUDIO_HW_IDLE;
Ricardo Garcia3e91b5d2015-02-19 10:54:52 -0800986
987 return mute;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700988}
989
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800990void AudioFlinger::setRecordSilenced(uid_t uid, bool silenced)
991{
992 ALOGV("AudioFlinger::setRecordSilenced(uid:%d, silenced:%d)", uid, silenced);
993
994 // TODO: Notify MmapThreads
995
996 AutoMutex lock(mLock);
997 for (size_t i = 0; i < mRecordThreads.size(); i++) {
998 sp<RecordThread> thread = mRecordThreads.valueAt(i);
999 if (thread != 0) {
1000 thread->setRecordSilenced(uid, silenced);
1001 }
1002 }
1003}
1004
Mathias Agopian65ab4712010-07-14 17:59:35 -07001005status_t AudioFlinger::setMasterMute(bool muted)
1006{
John Grossmand8f178d2012-07-20 14:51:35 -07001007 status_t ret = initCheck();
1008 if (ret != NO_ERROR) {
1009 return ret;
1010 }
1011
Mathias Agopian65ab4712010-07-14 17:59:35 -07001012 // check calling permissions
1013 if (!settingsAllowed()) {
1014 return PERMISSION_DENIED;
1015 }
1016
John Grossmanee578c02012-07-23 17:05:46 -07001017 Mutex::Autolock _l(mLock);
1018 mMasterMute = muted;
John Grossmand8f178d2012-07-20 14:51:35 -07001019
John Grossmanee578c02012-07-23 17:05:46 -07001020 // Set master mute in the HALs which support it.
1021 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
1022 AutoMutex lock(mHardwareLock);
1023 AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
John Grossmand8f178d2012-07-20 14:51:35 -07001024
John Grossmanee578c02012-07-23 17:05:46 -07001025 mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE;
1026 if (dev->canSetMasterMute()) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001027 dev->hwDevice()->setMasterMute(muted);
John Grossmand8f178d2012-07-20 14:51:35 -07001028 }
John Grossmanee578c02012-07-23 17:05:46 -07001029 mHardwareStatus = AUDIO_HW_IDLE;
John Grossmand8f178d2012-07-20 14:51:35 -07001030 }
1031
John Grossmanee578c02012-07-23 17:05:46 -07001032 // Now set the master mute in each playback thread. Playback threads
1033 // assigned to HALs which do not have master mute support will apply master
1034 // mute during the mix operation. Threads with HALs which do support master
1035 // mute will simply ignore the setting.
Eric Laurent6acd1d42017-01-04 14:23:29 -08001036 Vector<VolumeInterface *> volumeInterfaces = getAllVolumeInterfaces_l();
1037 for (size_t i = 0; i < volumeInterfaces.size(); i++) {
1038 volumeInterfaces[i]->setMasterMute(muted);
Eric Laurentf6870ae2015-05-08 10:50:03 -07001039 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001040
1041 return NO_ERROR;
1042}
1043
1044float AudioFlinger::masterVolume() const
1045{
Glenn Kasten98067102011-12-13 11:47:54 -08001046 Mutex::Autolock _l(mLock);
1047 return masterVolume_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001048}
1049
1050bool AudioFlinger::masterMute() const
1051{
Glenn Kasten98067102011-12-13 11:47:54 -08001052 Mutex::Autolock _l(mLock);
1053 return masterMute_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001054}
1055
John Grossman4ff14ba2012-02-08 16:37:41 -08001056float AudioFlinger::masterVolume_l() const
1057{
John Grossman4ff14ba2012-02-08 16:37:41 -08001058 return mMasterVolume;
1059}
1060
John Grossmand8f178d2012-07-20 14:51:35 -07001061bool AudioFlinger::masterMute_l() const
1062{
John Grossmanee578c02012-07-23 17:05:46 -07001063 return mMasterMute;
John Grossmand8f178d2012-07-20 14:51:35 -07001064}
1065
Eric Laurent223fd5c2014-11-11 13:43:36 -08001066status_t AudioFlinger::checkStreamType(audio_stream_type_t stream) const
1067{
1068 if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08001069 ALOGW("checkStreamType() invalid stream %d", stream);
Eric Laurent223fd5c2014-11-11 13:43:36 -08001070 return BAD_VALUE;
1071 }
1072 pid_t caller = IPCThreadState::self()->getCallingPid();
1073 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT && caller != getpid_cached) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08001074 ALOGW("checkStreamType() pid %d cannot use internal stream type %d", caller, stream);
Eric Laurent223fd5c2014-11-11 13:43:36 -08001075 return PERMISSION_DENIED;
1076 }
1077
1078 return NO_ERROR;
1079}
1080
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001081status_t AudioFlinger::setStreamVolume(audio_stream_type_t stream, float value,
1082 audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001083{
1084 // check calling permissions
1085 if (!settingsAllowed()) {
1086 return PERMISSION_DENIED;
1087 }
1088
Eric Laurent223fd5c2014-11-11 13:43:36 -08001089 status_t status = checkStreamType(stream);
1090 if (status != NO_ERROR) {
1091 return status;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001092 }
Eric Laurent223fd5c2014-11-11 13:43:36 -08001093 ALOG_ASSERT(stream != AUDIO_STREAM_PATCH, "attempt to change AUDIO_STREAM_PATCH volume");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001094
1095 AutoMutex lock(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08001096 Vector<VolumeInterface *> volumeInterfaces;
Glenn Kasten142f5192014-03-25 17:44:59 -07001097 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08001098 VolumeInterface *volumeInterface = getVolumeInterface_l(output);
1099 if (volumeInterface == NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001100 return BAD_VALUE;
1101 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08001102 volumeInterfaces.add(volumeInterface);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001103 }
1104
1105 mStreamTypes[stream].volume = value;
1106
Eric Laurent6acd1d42017-01-04 14:23:29 -08001107 if (volumeInterfaces.size() == 0) {
1108 volumeInterfaces = getAllVolumeInterfaces_l();
1109 }
1110 for (size_t i = 0; i < volumeInterfaces.size(); i++) {
1111 volumeInterfaces[i]->setStreamVolume(stream, value);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001112 }
1113
1114 return NO_ERROR;
1115}
1116
Glenn Kastenfff6d712012-01-12 16:38:12 -08001117status_t AudioFlinger::setStreamMute(audio_stream_type_t stream, bool muted)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001118{
1119 // check calling permissions
1120 if (!settingsAllowed()) {
1121 return PERMISSION_DENIED;
1122 }
1123
Eric Laurent223fd5c2014-11-11 13:43:36 -08001124 status_t status = checkStreamType(stream);
1125 if (status != NO_ERROR) {
1126 return status;
1127 }
1128 ALOG_ASSERT(stream != AUDIO_STREAM_PATCH, "attempt to mute AUDIO_STREAM_PATCH");
1129
1130 if (uint32_t(stream) == AUDIO_STREAM_ENFORCED_AUDIBLE) {
Steve Block29357bc2012-01-06 19:20:56 +00001131 ALOGE("setStreamMute() invalid stream %d", stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001132 return BAD_VALUE;
1133 }
1134
Eric Laurent93575202011-01-18 18:39:02 -08001135 AutoMutex lock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001136 mStreamTypes[stream].mute = muted;
Eric Laurent6acd1d42017-01-04 14:23:29 -08001137 Vector<VolumeInterface *> volumeInterfaces = getAllVolumeInterfaces_l();
1138 for (size_t i = 0; i < volumeInterfaces.size(); i++) {
1139 volumeInterfaces[i]->setStreamMute(stream, muted);
1140 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001141
1142 return NO_ERROR;
1143}
1144
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001145float AudioFlinger::streamVolume(audio_stream_type_t stream, audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001146{
Eric Laurent223fd5c2014-11-11 13:43:36 -08001147 status_t status = checkStreamType(stream);
1148 if (status != NO_ERROR) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001149 return 0.0f;
1150 }
1151
1152 AutoMutex lock(mLock);
1153 float volume;
Glenn Kasten142f5192014-03-25 17:44:59 -07001154 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08001155 VolumeInterface *volumeInterface = getVolumeInterface_l(output);
1156 if (volumeInterface != NULL) {
1157 volume = volumeInterface->streamVolume(stream);
1158 } else {
1159 volume = 0.0f;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001160 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001161 } else {
Glenn Kasten6637baa2012-01-09 09:40:36 -08001162 volume = streamVolume_l(stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001163 }
1164
1165 return volume;
1166}
1167
Glenn Kastenfff6d712012-01-12 16:38:12 -08001168bool AudioFlinger::streamMute(audio_stream_type_t stream) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001169{
Eric Laurent223fd5c2014-11-11 13:43:36 -08001170 status_t status = checkStreamType(stream);
1171 if (status != NO_ERROR) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001172 return true;
1173 }
1174
Glenn Kasten6637baa2012-01-09 09:40:36 -08001175 AutoMutex lock(mLock);
1176 return streamMute_l(stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001177}
1178
Eric Laurent054d9d32015-04-24 08:48:48 -07001179
1180void AudioFlinger::broacastParametersToRecordThreads_l(const String8& keyValuePairs)
1181{
1182 for (size_t i = 0; i < mRecordThreads.size(); i++) {
1183 mRecordThreads.valueAt(i)->setParameters(keyValuePairs);
1184 }
1185}
1186
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001187status_t AudioFlinger::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001188{
Glenn Kasten827e5f12012-11-02 10:00:06 -07001189 ALOGV("setParameters(): io %d, keyvalue %s, calling pid %d",
1190 ioHandle, keyValuePairs.string(), IPCThreadState::self()->getCallingPid());
Eric Laurent81784c32012-11-19 14:55:58 -08001191
Mathias Agopian65ab4712010-07-14 17:59:35 -07001192 // check calling permissions
1193 if (!settingsAllowed()) {
1194 return PERMISSION_DENIED;
1195 }
1196
Glenn Kasten142f5192014-03-25 17:44:59 -07001197 // AUDIO_IO_HANDLE_NONE means the parameters are global to the audio hardware interface
1198 if (ioHandle == AUDIO_IO_HANDLE_NONE) {
Eric Laurenta4c5a552012-03-29 10:12:40 -07001199 Mutex::Autolock _l(mLock);
Eric Laurentd21bcd22016-09-08 18:25:54 -07001200 // result will remain NO_INIT if no audio device is present
1201 status_t final_result = NO_INIT;
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001202 {
Eric Laurenta4c5a552012-03-29 10:12:40 -07001203 AutoMutex lock(mHardwareLock);
1204 mHardwareStatus = AUDIO_HW_SET_PARAMETER;
1205 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001206 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
1207 status_t result = dev->setParameters(keyValuePairs);
Eric Laurentd21bcd22016-09-08 18:25:54 -07001208 // return success if at least one audio device accepts the parameters as not all
1209 // HALs are requested to support all parameters. If no audio device supports the
1210 // requested parameters, the last error is reported.
1211 if (final_result != NO_ERROR) {
1212 final_result = result;
1213 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07001214 }
1215 mHardwareStatus = AUDIO_HW_IDLE;
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001216 }
Eric Laurent59bd0da2011-08-01 09:52:20 -07001217 // disable AEC and NS if the device is a BT SCO headset supporting those pre processings
1218 AudioParameter param = AudioParameter(keyValuePairs);
1219 String8 value;
Mikhail Naganov00260b52016-10-13 12:54:24 -07001220 if (param.get(String8(AudioParameter::keyBtNrec), value) == NO_ERROR) {
1221 bool btNrecIsOff = (value == AudioParameter::valueOff);
Eric Laurentd8365c52017-07-16 15:27:05 -07001222 if (mBtNrecIsOff.exchange(btNrecIsOff) != btNrecIsOff) {
Eric Laurent59bd0da2011-08-01 09:52:20 -07001223 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Eric Laurentd8365c52017-07-16 15:27:05 -07001224 mRecordThreads.valueAt(i)->checkBtNrec();
Eric Laurent59bd0da2011-08-01 09:52:20 -07001225 }
Eric Laurent59bd0da2011-08-01 09:52:20 -07001226 }
1227 }
Glenn Kasten28ed2f92012-06-07 10:17:54 -07001228 String8 screenState;
1229 if (param.get(String8(AudioParameter::keyScreenState), screenState) == NO_ERROR) {
Mikhail Naganov00260b52016-10-13 12:54:24 -07001230 bool isOff = (screenState == AudioParameter::valueOff);
Eric Laurent81784c32012-11-19 14:55:58 -08001231 if (isOff != (AudioFlinger::mScreenState & 1)) {
1232 AudioFlinger::mScreenState = ((AudioFlinger::mScreenState & ~1) + 2) | isOff;
Glenn Kasten28ed2f92012-06-07 10:17:54 -07001233 }
1234 }
Dima Zavin799a70e2011-04-18 16:57:27 -07001235 return final_result;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001236 }
1237
1238 // hold a strong ref on thread in case closeOutput() or closeInput() is called
1239 // and the thread is exited once the lock is released
1240 sp<ThreadBase> thread;
1241 {
1242 Mutex::Autolock _l(mLock);
1243 thread = checkPlaybackThread_l(ioHandle);
Glenn Kastend5903ec2012-03-18 10:33:27 -07001244 if (thread == 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001245 thread = checkRecordThread_l(ioHandle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08001246 if (thread == 0) {
1247 thread = checkMmapThread_l(ioHandle);
1248 }
Glenn Kasten7fc9a6f2012-01-10 10:46:34 -08001249 } else if (thread == primaryPlaybackThread_l()) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001250 // indicate output device change to all input threads for pre processing
1251 AudioParameter param = AudioParameter(keyValuePairs);
1252 int value;
Eric Laurent89d94e72012-03-16 20:37:59 -07001253 if ((param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) &&
1254 (value != 0)) {
Eric Laurent054d9d32015-04-24 08:48:48 -07001255 broacastParametersToRecordThreads_l(keyValuePairs);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001256 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001257 }
1258 }
Glenn Kasten7378ca52012-01-20 13:44:40 -08001259 if (thread != 0) {
1260 return thread->setParameters(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001261 }
1262 return BAD_VALUE;
1263}
1264
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001265String8 AudioFlinger::getParameters(audio_io_handle_t ioHandle, const String8& keys) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001266{
Glenn Kasten827e5f12012-11-02 10:00:06 -07001267 ALOGVV("getParameters() io %d, keys %s, calling pid %d",
1268 ioHandle, keys.string(), IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001269
Eric Laurenta4c5a552012-03-29 10:12:40 -07001270 Mutex::Autolock _l(mLock);
1271
Glenn Kasten142f5192014-03-25 17:44:59 -07001272 if (ioHandle == AUDIO_IO_HANDLE_NONE) {
Dima Zavinfce7a472011-04-19 22:30:36 -07001273 String8 out_s8;
1274
Dima Zavin799a70e2011-04-18 16:57:27 -07001275 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001276 String8 s;
1277 status_t result;
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001278 {
1279 AutoMutex lock(mHardwareLock);
1280 mHardwareStatus = AUDIO_HW_GET_PARAMETER;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001281 sp<DeviceHalInterface> dev = mAudioHwDevs.valueAt(i)->hwDevice();
1282 result = dev->getParameters(keys, &s);
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001283 mHardwareStatus = AUDIO_HW_IDLE;
1284 }
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001285 if (result == OK) out_s8 += s;
Dima Zavin799a70e2011-04-18 16:57:27 -07001286 }
Dima Zavinfce7a472011-04-19 22:30:36 -07001287 return out_s8;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001288 }
1289
Eric Laurent6acd1d42017-01-04 14:23:29 -08001290 ThreadBase *thread = (ThreadBase *)checkPlaybackThread_l(ioHandle);
1291 if (thread == NULL) {
1292 thread = (ThreadBase *)checkRecordThread_l(ioHandle);
1293 if (thread == NULL) {
1294 thread = (ThreadBase *)checkMmapThread_l(ioHandle);
1295 if (thread == NULL) {
Mikhail Naganovaa165e52017-07-12 10:39:16 -07001296 return String8("");
Eric Laurent6acd1d42017-01-04 14:23:29 -08001297 }
1298 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001299 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08001300 return thread->getParameters(keys);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001301}
1302
Glenn Kastendd8104c2012-07-02 12:42:44 -07001303size_t AudioFlinger::getInputBufferSize(uint32_t sampleRate, audio_format_t format,
1304 audio_channel_mask_t channelMask) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001305{
Eric Laurenta1884f92011-08-23 08:25:03 -07001306 status_t ret = initCheck();
1307 if (ret != NO_ERROR) {
1308 return 0;
1309 }
Eric Laurentcdf924a2016-02-04 15:57:56 -08001310 if ((sampleRate == 0) ||
Phil Burkfdb3c072016-02-09 10:47:02 -08001311 !audio_is_valid_format(format) || !audio_has_proportional_frames(format) ||
Eric Laurentcdf924a2016-02-04 15:57:56 -08001312 !audio_is_input_channel(channelMask)) {
Andy Hung6770c6f2015-04-07 13:43:36 -07001313 return 0;
1314 }
Eric Laurenta1884f92011-08-23 08:25:03 -07001315
Glenn Kasten2b213bc2012-02-02 14:05:20 -08001316 AutoMutex lock(mHardwareLock);
1317 mHardwareStatus = AUDIO_HW_GET_INPUT_BUFFER_SIZE;
Andy Hung6770c6f2015-04-07 13:43:36 -07001318 audio_config_t config, proposed;
1319 memset(&proposed, 0, sizeof(proposed));
1320 proposed.sample_rate = sampleRate;
1321 proposed.channel_mask = channelMask;
1322 proposed.format = format;
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00001323
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001324 sp<DeviceHalInterface> dev = mPrimaryHardwareDev->hwDevice();
Andy Hung6770c6f2015-04-07 13:43:36 -07001325 size_t frames;
1326 for (;;) {
1327 // Note: config is currently a const parameter for get_input_buffer_size()
1328 // but we use a copy from proposed in case config changes from the call.
1329 config = proposed;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001330 status_t result = dev->getInputBufferSize(&config, &frames);
1331 if (result == OK && frames != 0) {
Andy Hung6770c6f2015-04-07 13:43:36 -07001332 break; // hal success, config is the result
1333 }
1334 // change one parameter of the configuration each iteration to a more "common" value
1335 // to see if the device will support it.
1336 if (proposed.format != AUDIO_FORMAT_PCM_16_BIT) {
1337 proposed.format = AUDIO_FORMAT_PCM_16_BIT;
1338 } else if (proposed.sample_rate != 44100) { // 44.1 is claimed as must in CDD as well as
1339 proposed.sample_rate = 44100; // legacy AudioRecord.java. TODO: Query hw?
1340 } else {
1341 ALOGW("getInputBufferSize failed with minimum buffer size sampleRate %u, "
1342 "format %#x, channelMask 0x%X",
1343 sampleRate, format, channelMask);
1344 break; // retries failed, break out of loop with frames == 0.
1345 }
1346 }
Glenn Kasten2b213bc2012-02-02 14:05:20 -08001347 mHardwareStatus = AUDIO_HW_IDLE;
Andy Hung6770c6f2015-04-07 13:43:36 -07001348 if (frames > 0 && config.sample_rate != sampleRate) {
1349 frames = destinationFramesPossible(frames, sampleRate, config.sample_rate);
1350 }
1351 return frames; // may be converted to bytes at the Java level.
Mathias Agopian65ab4712010-07-14 17:59:35 -07001352}
1353
Glenn Kasten5f972c02014-01-13 09:59:31 -08001354uint32_t AudioFlinger::getInputFramesLost(audio_io_handle_t ioHandle) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001355{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001356 Mutex::Autolock _l(mLock);
1357
1358 RecordThread *recordThread = checkRecordThread_l(ioHandle);
1359 if (recordThread != NULL) {
1360 return recordThread->getInputFramesLost();
1361 }
1362 return 0;
1363}
1364
1365status_t AudioFlinger::setVoiceVolume(float value)
1366{
Eric Laurenta1884f92011-08-23 08:25:03 -07001367 status_t ret = initCheck();
1368 if (ret != NO_ERROR) {
1369 return ret;
1370 }
1371
Mathias Agopian65ab4712010-07-14 17:59:35 -07001372 // check calling permissions
1373 if (!settingsAllowed()) {
1374 return PERMISSION_DENIED;
1375 }
1376
1377 AutoMutex lock(mHardwareLock);
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001378 sp<DeviceHalInterface> dev = mPrimaryHardwareDev->hwDevice();
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001379 mHardwareStatus = AUDIO_HW_SET_VOICE_VOLUME;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001380 ret = dev->setVoiceVolume(value);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001381 mHardwareStatus = AUDIO_HW_IDLE;
1382
1383 return ret;
1384}
1385
Kévin PETIT377b2ec2014-02-03 12:35:36 +00001386status_t AudioFlinger::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001387 audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001388{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001389 Mutex::Autolock _l(mLock);
1390
1391 PlaybackThread *playbackThread = checkPlaybackThread_l(output);
1392 if (playbackThread != NULL) {
1393 return playbackThread->getRenderPosition(halFrames, dspFrames);
1394 }
1395
1396 return BAD_VALUE;
1397}
1398
1399void AudioFlinger::registerClient(const sp<IAudioFlingerClient>& client)
1400{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001401 Mutex::Autolock _l(mLock);
Eric Laurent44622db2014-08-01 19:00:33 -07001402 if (client == 0) {
1403 return;
1404 }
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001405 pid_t pid = IPCThreadState::self()->getCallingPid();
Eric Laurent021cf962014-05-13 10:18:14 -07001406 {
1407 Mutex::Autolock _cl(mClientLock);
Eric Laurent021cf962014-05-13 10:18:14 -07001408 if (mNotificationClients.indexOfKey(pid) < 0) {
1409 sp<NotificationClient> notificationClient = new NotificationClient(this,
1410 client,
1411 pid);
1412 ALOGV("registerClient() client %p, pid %d", notificationClient.get(), pid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001413
Eric Laurent021cf962014-05-13 10:18:14 -07001414 mNotificationClients.add(pid, notificationClient);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001415
Marco Nelissen06b46062014-11-14 07:58:25 -08001416 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurent021cf962014-05-13 10:18:14 -07001417 binder->linkToDeath(notificationClient);
Eric Laurent021cf962014-05-13 10:18:14 -07001418 }
1419 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001420
Eric Laurent021cf962014-05-13 10:18:14 -07001421 // mClientLock should not be held here because ThreadBase::sendIoConfigEvent() will lock the
Eric Laurentfe1a94e2014-05-26 16:03:08 -07001422 // ThreadBase mutex and the locking order is ThreadBase::mLock then AudioFlinger::mClientLock.
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001423 // the config change is always sent from playback or record threads to avoid deadlock
1424 // with AudioSystem::gLock
1425 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07001426 mPlaybackThreads.valueAt(i)->sendIoConfigEvent(AUDIO_OUTPUT_REGISTERED, pid);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001427 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001428
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001429 for (size_t i = 0; i < mRecordThreads.size(); i++) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07001430 mRecordThreads.valueAt(i)->sendIoConfigEvent(AUDIO_INPUT_REGISTERED, pid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001431 }
1432}
1433
1434void AudioFlinger::removeNotificationClient(pid_t pid)
1435{
1436 Mutex::Autolock _l(mLock);
Eric Laurent021cf962014-05-13 10:18:14 -07001437 {
1438 Mutex::Autolock _cl(mClientLock);
1439 mNotificationClients.removeItem(pid);
1440 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001441
Steve Block3856b092011-10-20 11:56:00 +01001442 ALOGV("%d died, releasing its sessions", pid);
Glenn Kasten8d6a2442012-02-08 14:04:28 -08001443 size_t num = mAudioSessionRefs.size();
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001444 bool removed = false;
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08001445 for (size_t i = 0; i < num; ) {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001446 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001447 ALOGV(" pid %d @ %zu", ref->mPid, i);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08001448 if (ref->mPid == pid) {
1449 ALOGV(" removing entry for pid %d session %d", pid, ref->mSessionid);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001450 mAudioSessionRefs.removeAt(i);
1451 delete ref;
1452 removed = true;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001453 num--;
Glenn Kasten8d6a2442012-02-08 14:04:28 -08001454 } else {
1455 i++;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001456 }
1457 }
1458 if (removed) {
1459 purgeStaleEffects_l();
1460 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001461}
1462
Eric Laurent73e26b62015-04-27 16:55:58 -07001463void AudioFlinger::ioConfigChanged(audio_io_config_event event,
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001464 const sp<AudioIoDescriptor>& ioDesc,
1465 pid_t pid)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001466{
Eric Laurent021cf962014-05-13 10:18:14 -07001467 Mutex::Autolock _l(mClientLock);
1468 size_t size = mNotificationClients.size();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001469 for (size_t i = 0; i < size; i++) {
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001470 if ((pid == 0) || (mNotificationClients.keyAt(i) == pid)) {
1471 mNotificationClients.valueAt(i)->audioFlingerClient()->ioConfigChanged(event, ioDesc);
1472 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001473 }
1474}
1475
Eric Laurent021cf962014-05-13 10:18:14 -07001476// removeClient_l() must be called with AudioFlinger::mClientLock held
Mathias Agopian65ab4712010-07-14 17:59:35 -07001477void AudioFlinger::removeClient_l(pid_t pid)
1478{
Glenn Kasten827e5f12012-11-02 10:00:06 -07001479 ALOGV("removeClient_l() pid %d, calling pid %d", pid,
Glenn Kasten85ab62c2012-11-01 11:11:38 -07001480 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001481 mClients.removeItem(pid);
1482}
1483
Eric Laurent717e1282012-06-29 16:36:52 -07001484// getEffectThread_l() must be called with AudioFlinger::mLock held
Glenn Kastend848eb42016-03-08 13:42:11 -08001485sp<AudioFlinger::PlaybackThread> AudioFlinger::getEffectThread_l(audio_session_t sessionId,
1486 int EffectId)
Eric Laurent717e1282012-06-29 16:36:52 -07001487{
1488 sp<PlaybackThread> thread;
1489
1490 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1491 if (mPlaybackThreads.valueAt(i)->getEffect(sessionId, EffectId) != 0) {
1492 ALOG_ASSERT(thread == 0);
1493 thread = mPlaybackThreads.valueAt(i);
1494 }
1495 }
1496
1497 return thread;
1498}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001499
Mathias Agopian65ab4712010-07-14 17:59:35 -07001500
Mathias Agopian65ab4712010-07-14 17:59:35 -07001501
1502// ----------------------------------------------------------------------------
1503
1504AudioFlinger::Client::Client(const sp<AudioFlinger>& audioFlinger, pid_t pid)
1505 : RefBase(),
1506 mAudioFlinger(audioFlinger),
Glenn Kastend79072e2016-01-06 08:41:20 -08001507 mPid(pid)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001508{
Sumit Bhattacharyacd64e0e2016-02-11 01:37:20 +05301509 size_t heapSize = property_get_int32("ro.af.client_heap_size_kbyte", 0);
1510 heapSize *= 1024;
1511 if (!heapSize) {
1512 heapSize = kClientSharedHeapSizeBytes;
1513 // Increase heap size on non low ram devices to limit risk of reconnection failure for
1514 // invalidated tracks
1515 if (!audioFlinger->isLowRamDevice()) {
1516 heapSize *= kClientSharedHeapSizeMultiplier;
1517 }
Eric Laurentda73b6c2015-08-20 16:18:53 -07001518 }
1519 mMemoryDealer = new MemoryDealer(heapSize, "AudioFlinger::Client");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001520}
1521
Eric Laurent021cf962014-05-13 10:18:14 -07001522// Client destructor must be called with AudioFlinger::mClientLock held
Mathias Agopian65ab4712010-07-14 17:59:35 -07001523AudioFlinger::Client::~Client()
1524{
1525 mAudioFlinger->removeClient_l(mPid);
1526}
1527
Glenn Kasten435dbe62012-01-30 10:15:48 -08001528sp<MemoryDealer> AudioFlinger::Client::heap() const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001529{
1530 return mMemoryDealer;
1531}
1532
1533// ----------------------------------------------------------------------------
1534
1535AudioFlinger::NotificationClient::NotificationClient(const sp<AudioFlinger>& audioFlinger,
1536 const sp<IAudioFlingerClient>& client,
1537 pid_t pid)
Glenn Kasten84afa3b2012-01-25 15:28:08 -08001538 : mAudioFlinger(audioFlinger), mPid(pid), mAudioFlingerClient(client)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001539{
1540}
1541
1542AudioFlinger::NotificationClient::~NotificationClient()
1543{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001544}
1545
Glenn Kasten0f11b512014-01-31 16:18:54 -08001546void AudioFlinger::NotificationClient::binderDied(const wp<IBinder>& who __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001547{
1548 sp<NotificationClient> keep(this);
Glenn Kastena1117922012-01-26 10:53:32 -08001549 mAudioFlinger->removeNotificationClient(mPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001550}
1551
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08001552// ----------------------------------------------------------------------------
1553AudioFlinger::MediaLogNotifier::MediaLogNotifier()
1554 : mPendingRequests(false) {}
1555
1556
1557void AudioFlinger::MediaLogNotifier::requestMerge() {
1558 AutoMutex _l(mMutex);
1559 mPendingRequests = true;
1560 mCond.signal();
1561}
1562
1563bool AudioFlinger::MediaLogNotifier::threadLoop() {
Glenn Kasten04b96fc2017-04-10 14:58:47 -07001564 // Should already have been checked, but just in case
1565 if (sMediaLogService == 0) {
1566 return false;
1567 }
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08001568 // Wait until there are pending requests
1569 {
1570 AutoMutex _l(mMutex);
1571 mPendingRequests = false; // to ignore past requests
1572 while (!mPendingRequests) {
1573 mCond.wait(mMutex);
1574 // TODO may also need an exitPending check
1575 }
1576 mPendingRequests = false;
1577 }
1578 // Execute the actual MediaLogService binder call and ignore extra requests for a while
Glenn Kasten04b96fc2017-04-10 14:58:47 -07001579 sMediaLogService->requestMergeWakeup();
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -08001580 usleep(kPostTriggerSleepPeriod);
1581 return true;
1582}
1583
1584void AudioFlinger::requestLogMerge() {
1585 mMediaLogNotifier->requestMerge();
1586}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001587
1588// ----------------------------------------------------------------------------
1589
Eric Laurentf14db3c2017-12-08 14:20:36 -08001590sp<media::IAudioRecord> AudioFlinger::createRecord(const CreateRecordInput& input,
1591 CreateRecordOutput& output,
1592 status_t *status)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001593{
1594 sp<RecordThread::RecordTrack> recordTrack;
1595 sp<RecordHandle> recordHandle;
1596 sp<Client> client;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001597 status_t lStatus;
Eric Laurentf14db3c2017-12-08 14:20:36 -08001598 audio_session_t sessionId = input.sessionId;
1599 audio_port_handle_t portId;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001600
Eric Laurentf14db3c2017-12-08 14:20:36 -08001601 output.cblk.clear();
1602 output.buffers.clear();
Eric Laurent896c9672017-12-08 14:08:45 -08001603 output.inputId = AUDIO_IO_HANDLE_NONE;
Glenn Kastend776ac62014-05-07 09:16:09 -07001604
Eric Laurentf14db3c2017-12-08 14:20:36 -08001605 bool updatePid = (input.clientInfo.clientPid == -1);
Marco Nelissendcb346b2015-09-09 10:47:29 -07001606 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Eric Laurentf14db3c2017-12-08 14:20:36 -08001607 uid_t clientUid = input.clientInfo.clientUid;
Marco Nelissendcb346b2015-09-09 10:47:29 -07001608 if (!isTrustedCallingUid(callingUid)) {
Eric Laurentf14db3c2017-12-08 14:20:36 -08001609 ALOGW_IF(clientUid != callingUid,
1610 "%s uid %d tried to pass itself off as %d",
1611 __FUNCTION__, callingUid, clientUid);
Marco Nelissendcb346b2015-09-09 10:47:29 -07001612 clientUid = callingUid;
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07001613 updatePid = true;
1614 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08001615 pid_t clientPid = input.clientInfo.clientPid;
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07001616 if (updatePid) {
1617 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Eric Laurentf14db3c2017-12-08 14:20:36 -08001618 ALOGW_IF(clientPid != -1 && clientPid != callingPid,
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07001619 "%s uid %d pid %d tried to pass itself off as pid %d",
Eric Laurentf14db3c2017-12-08 14:20:36 -08001620 __func__, callingUid, callingPid, clientPid);
1621 clientPid = callingPid;
Marco Nelissendcb346b2015-09-09 10:47:29 -07001622 }
1623
Mathias Agopian65ab4712010-07-14 17:59:35 -07001624 // check calling permissions
Eric Laurentf14db3c2017-12-08 14:20:36 -08001625 if (!recordingAllowed(input.opPackageName, input.clientInfo.clientTid, clientUid)) {
1626 ALOGE("createRecord() permission denied: recording not allowed");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001627 lStatus = PERMISSION_DENIED;
1628 goto Exit;
1629 }
Andy Hung6770c6f2015-04-07 13:43:36 -07001630 // we don't yet support anything other than linear PCM
Eric Laurentf14db3c2017-12-08 14:20:36 -08001631 if (!audio_is_valid_format(input.config.format) || !audio_is_linear_pcm(input.config.format)) {
1632 ALOGE("createRecord() invalid format %#x", input.config.format);
Glenn Kasten291bb6d2013-07-16 17:23:39 -07001633 lStatus = BAD_VALUE;
1634 goto Exit;
1635 }
1636
Glenn Kasten53b5d092014-02-05 10:00:23 -08001637 // further channel mask checks are performed by createRecordTrack_l()
Eric Laurentf14db3c2017-12-08 14:20:36 -08001638 if (!audio_is_input_channel(input.config.channel_mask)) {
1639 ALOGE("createRecord() invalid channel mask %#x", input.config.channel_mask);
Glenn Kasten53b5d092014-02-05 10:00:23 -08001640 lStatus = BAD_VALUE;
1641 goto Exit;
1642 }
1643
Eric Laurentf14db3c2017-12-08 14:20:36 -08001644 if (sessionId == AUDIO_SESSION_ALLOCATE) {
1645 sessionId = (audio_session_t) newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
1646 } else if (audio_unique_id_get_use(sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) {
1647 lStatus = BAD_VALUE;
1648 goto Exit;
1649 }
1650
1651 output.sessionId = sessionId;
Eric Laurentf14db3c2017-12-08 14:20:36 -08001652 output.selectedDeviceId = input.selectedDeviceId;
1653 output.flags = input.flags;
1654
1655 client = registerPid(clientPid);
1656
1657 // Not a conventional loop, but a retry loop for at most two iterations total.
1658 // Try first maybe with FAST flag then try again without FAST flag if that fails.
1659 // Exits loop via break on no error of got exit on error
1660 // The sp<> references will be dropped when re-entering scope.
1661 // The lack of indentation is deliberate, to reduce code churn and ease merges.
1662 for (;;) {
Eric Laurent896c9672017-12-08 14:08:45 -08001663 // release previously opened input if retrying.
1664 if (output.inputId != AUDIO_IO_HANDLE_NONE) {
1665 recordTrack.clear();
1666 AudioSystem::releaseInput(output.inputId, sessionId);
1667 output.inputId = AUDIO_IO_HANDLE_NONE;
1668 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08001669 lStatus = AudioSystem::getInputForAttr(&input.attr, &output.inputId,
1670 sessionId,
1671 // FIXME compare to AudioTrack
1672 clientPid,
1673 clientUid,
1674 &input.config,
1675 output.flags, &output.selectedDeviceId, &portId);
1676
Glenn Kasten05997e22014-03-13 15:08:33 -07001677 {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001678 Mutex::Autolock _l(mLock);
Eric Laurentf14db3c2017-12-08 14:20:36 -08001679 RecordThread *thread = checkRecordThread_l(output.inputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001680 if (thread == NULL) {
Eric Laurentf14db3c2017-12-08 14:20:36 -08001681 ALOGE("createRecord() checkRecordThread_l failed");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001682 lStatus = BAD_VALUE;
1683 goto Exit;
1684 }
1685
Eric Laurentf14db3c2017-12-08 14:20:36 -08001686 ALOGV("createRecord() lSessionId: %d input %d", sessionId, output.inputId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001687
Eric Laurentf14db3c2017-12-08 14:20:36 -08001688 output.sampleRate = input.config.sample_rate;
1689 output.frameCount = input.frameCount;
1690 output.notificationFrameCount = input.notificationFrameCount;
Glenn Kasten570f6332014-03-13 15:01:06 -07001691
Eric Laurentf14db3c2017-12-08 14:20:36 -08001692 recordTrack = thread->createRecordTrack_l(client, &output.sampleRate,
1693 input.config.format, input.config.channel_mask,
1694 &output.frameCount, sessionId,
1695 &output.notificationFrameCount,
1696 clientUid, &output.flags,
1697 input.clientInfo.clientTid,
1698 &lStatus, portId);
Haynes Mathew George03e9e832013-12-13 15:40:13 -08001699 LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (recordTrack == 0));
Eric Laurent1b928682014-10-02 19:41:47 -07001700
Eric Laurentf14db3c2017-12-08 14:20:36 -08001701 // lStatus == BAD_TYPE means FAST flag was rejected: request a new input from
1702 // audio policy manager without FAST constraint
1703 if (lStatus == BAD_TYPE) {
Eric Laurentf14db3c2017-12-08 14:20:36 -08001704 continue;
Eric Laurent1b928682014-10-02 19:41:47 -07001705 }
Eric Laurentf14db3c2017-12-08 14:20:36 -08001706
1707 if (lStatus != NO_ERROR) {
Eric Laurentf14db3c2017-12-08 14:20:36 -08001708 goto Exit;
1709 }
1710
1711 // Check if one effect chain was awaiting for an AudioRecord to be created on this
1712 // session and move it to this thread.
1713 sp<EffectChain> chain = getOrphanEffectChain_l(sessionId);
1714 if (chain != 0) {
1715 Mutex::Autolock _l(thread->mLock);
1716 thread->addEffectChain_l(chain);
1717 }
1718 break;
1719 }
1720 // End of retry loop.
1721 // The lack of indentation is deliberate, to reduce code churn and ease merges.
Mathias Agopian65ab4712010-07-14 17:59:35 -07001722 }
Glenn Kastene198c362013-08-13 09:13:36 -07001723
Eric Laurentf14db3c2017-12-08 14:20:36 -08001724 output.cblk = recordTrack->getCblk();
1725 output.buffers = recordTrack->getBuffers();
1726
1727 // return handle to client
1728 recordHandle = new RecordHandle(recordTrack);
1729
1730Exit:
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001731 if (lStatus != NO_ERROR) {
Glenn Kasten85ab62c2012-11-01 11:11:38 -07001732 // remove local strong reference to Client before deleting the RecordTrack so that the
Eric Laurent021cf962014-05-13 10:18:14 -07001733 // Client destructor is called by the TrackBase destructor with mClientLock held
Eric Laurentfe1a94e2014-05-26 16:03:08 -07001734 // Don't hold mClientLock when releasing the reference on the track as the
1735 // destructor will acquire it.
1736 {
1737 Mutex::Autolock _cl(mClientLock);
1738 client.clear();
1739 }
Eric Laurent896c9672017-12-08 14:08:45 -08001740 recordTrack.clear();
1741 if (output.inputId != AUDIO_IO_HANDLE_NONE) {
1742 AudioSystem::releaseInput(output.inputId, sessionId);
1743 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001744 }
1745
Glenn Kasten9156ef32013-08-06 15:39:08 -07001746 *status = lStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001747 return recordHandle;
1748}
1749
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001750
1751
Mathias Agopian65ab4712010-07-14 17:59:35 -07001752// ----------------------------------------------------------------------------
1753
Eric Laurenta4c5a552012-03-29 10:12:40 -07001754audio_module_handle_t AudioFlinger::loadHwModule(const char *name)
1755{
Eric Laurent44622db2014-08-01 19:00:33 -07001756 if (name == NULL) {
Glenn Kastena13cde92016-03-28 15:26:02 -07001757 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurent44622db2014-08-01 19:00:33 -07001758 }
Eric Laurenta4c5a552012-03-29 10:12:40 -07001759 if (!settingsAllowed()) {
Glenn Kastena13cde92016-03-28 15:26:02 -07001760 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurenta4c5a552012-03-29 10:12:40 -07001761 }
1762 Mutex::Autolock _l(mLock);
1763 return loadHwModule_l(name);
1764}
1765
1766// loadHwModule_l() must be called with AudioFlinger::mLock held
1767audio_module_handle_t AudioFlinger::loadHwModule_l(const char *name)
1768{
1769 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
1770 if (strncmp(mAudioHwDevs.valueAt(i)->moduleName(), name, strlen(name)) == 0) {
1771 ALOGW("loadHwModule() module %s already loaded", name);
1772 return mAudioHwDevs.keyAt(i);
1773 }
1774 }
1775
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001776 sp<DeviceHalInterface> dev;
Eric Laurenta4c5a552012-03-29 10:12:40 -07001777
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001778 int rc = mDevicesFactoryHal->openDevice(name, &dev);
Eric Laurenta4c5a552012-03-29 10:12:40 -07001779 if (rc) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001780 ALOGE("loadHwModule() error %d loading module %s", rc, name);
Glenn Kastena13cde92016-03-28 15:26:02 -07001781 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurenta4c5a552012-03-29 10:12:40 -07001782 }
1783
1784 mHardwareStatus = AUDIO_HW_INIT;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001785 rc = dev->initCheck();
Eric Laurenta4c5a552012-03-29 10:12:40 -07001786 mHardwareStatus = AUDIO_HW_IDLE;
1787 if (rc) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07001788 ALOGE("loadHwModule() init check error %d for module %s", rc, name);
Glenn Kastena13cde92016-03-28 15:26:02 -07001789 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurenta4c5a552012-03-29 10:12:40 -07001790 }
1791
John Grossmanee578c02012-07-23 17:05:46 -07001792 // Check and cache this HAL's level of support for master mute and master
1793 // volume. If this is the first HAL opened, and it supports the get
1794 // methods, use the initial values provided by the HAL as the current
1795 // master mute and volume settings.
1796
1797 AudioHwDevice::Flags flags = static_cast<AudioHwDevice::Flags>(0);
1798 { // scope for auto-lock pattern
Eric Laurenta4c5a552012-03-29 10:12:40 -07001799 AutoMutex lock(mHardwareLock);
John Grossmanee578c02012-07-23 17:05:46 -07001800
1801 if (0 == mAudioHwDevs.size()) {
1802 mHardwareStatus = AUDIO_HW_GET_MASTER_VOLUME;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001803 float mv;
1804 if (OK == dev->getMasterVolume(&mv)) {
1805 mMasterVolume = mv;
John Grossmanee578c02012-07-23 17:05:46 -07001806 }
1807
1808 mHardwareStatus = AUDIO_HW_GET_MASTER_MUTE;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001809 bool mm;
1810 if (OK == dev->getMasterMute(&mm)) {
1811 mMasterMute = mm;
John Grossmanee578c02012-07-23 17:05:46 -07001812 }
1813 }
1814
Eric Laurenta4c5a552012-03-29 10:12:40 -07001815 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001816 if (OK == dev->setMasterVolume(mMasterVolume)) {
John Grossmanee578c02012-07-23 17:05:46 -07001817 flags = static_cast<AudioHwDevice::Flags>(flags |
1818 AudioHwDevice::AHWD_CAN_SET_MASTER_VOLUME);
1819 }
1820
1821 mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001822 if (OK == dev->setMasterMute(mMasterMute)) {
John Grossmanee578c02012-07-23 17:05:46 -07001823 flags = static_cast<AudioHwDevice::Flags>(flags |
1824 AudioHwDevice::AHWD_CAN_SET_MASTER_MUTE);
1825 }
1826
Eric Laurenta4c5a552012-03-29 10:12:40 -07001827 mHardwareStatus = AUDIO_HW_IDLE;
1828 }
1829
Glenn Kastena13cde92016-03-28 15:26:02 -07001830 audio_module_handle_t handle = (audio_module_handle_t) nextUniqueId(AUDIO_UNIQUE_ID_USE_MODULE);
Eric Laurent83b88082014-06-20 18:31:16 -07001831 mAudioHwDevs.add(handle, new AudioHwDevice(handle, name, dev, flags));
Eric Laurenta4c5a552012-03-29 10:12:40 -07001832
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001833 ALOGI("loadHwModule() Loaded %s audio interface, handle %d", name, handle);
Eric Laurenta4c5a552012-03-29 10:12:40 -07001834
1835 return handle;
1836
1837}
1838
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07001839// ----------------------------------------------------------------------------
1840
Glenn Kasten3b16c762012-11-14 08:44:39 -08001841uint32_t AudioFlinger::getPrimaryOutputSamplingRate()
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07001842{
1843 Mutex::Autolock _l(mLock);
Glenn Kastena7335632016-06-09 17:09:53 -07001844 PlaybackThread *thread = fastPlaybackThread_l();
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07001845 return thread != NULL ? thread->sampleRate() : 0;
1846}
1847
Glenn Kastene33054e2012-11-14 12:54:39 -08001848size_t AudioFlinger::getPrimaryOutputFrameCount()
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07001849{
1850 Mutex::Autolock _l(mLock);
Glenn Kastena7335632016-06-09 17:09:53 -07001851 PlaybackThread *thread = fastPlaybackThread_l();
Glenn Kastencc0f1cf2012-09-24 11:27:18 -07001852 return thread != NULL ? thread->frameCountHAL() : 0;
1853}
1854
1855// ----------------------------------------------------------------------------
1856
Glenn Kasten4182c4e2013-07-15 14:45:07 -07001857status_t AudioFlinger::setLowRamDevice(bool isLowRamDevice)
1858{
1859 uid_t uid = IPCThreadState::self()->getCallingUid();
1860 if (uid != AID_SYSTEM) {
1861 return PERMISSION_DENIED;
1862 }
1863 Mutex::Autolock _l(mLock);
1864 if (mIsDeviceTypeKnown) {
1865 return INVALID_OPERATION;
1866 }
1867 mIsLowRamDevice = isLowRamDevice;
1868 mIsDeviceTypeKnown = true;
1869 return NO_ERROR;
1870}
1871
Eric Laurent93c3d412014-08-01 14:48:35 -07001872audio_hw_sync_t AudioFlinger::getAudioHwSyncForSession(audio_session_t sessionId)
1873{
1874 Mutex::Autolock _l(mLock);
Eric Laurentfa90e842014-10-17 18:12:31 -07001875
1876 ssize_t index = mHwAvSyncIds.indexOfKey(sessionId);
1877 if (index >= 0) {
1878 ALOGV("getAudioHwSyncForSession found ID %d for session %d",
1879 mHwAvSyncIds.valueAt(index), sessionId);
1880 return mHwAvSyncIds.valueAt(index);
1881 }
1882
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001883 sp<DeviceHalInterface> dev = mPrimaryHardwareDev->hwDevice();
Eric Laurentfa90e842014-10-17 18:12:31 -07001884 if (dev == NULL) {
1885 return AUDIO_HW_SYNC_INVALID;
1886 }
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001887 String8 reply;
1888 AudioParameter param;
Mikhail Naganov00260b52016-10-13 12:54:24 -07001889 if (dev->getParameters(String8(AudioParameter::keyHwAvSync), &reply) == OK) {
Mikhail Naganove4f1f632016-08-31 11:35:10 -07001890 param = AudioParameter(reply);
1891 }
Eric Laurentfa90e842014-10-17 18:12:31 -07001892
1893 int value;
Mikhail Naganov00260b52016-10-13 12:54:24 -07001894 if (param.getInt(String8(AudioParameter::keyHwAvSync), value) != NO_ERROR) {
Eric Laurentfa90e842014-10-17 18:12:31 -07001895 ALOGW("getAudioHwSyncForSession error getting sync for session %d", sessionId);
1896 return AUDIO_HW_SYNC_INVALID;
1897 }
1898
1899 // allow only one session for a given HW A/V sync ID.
1900 for (size_t i = 0; i < mHwAvSyncIds.size(); i++) {
1901 if (mHwAvSyncIds.valueAt(i) == (audio_hw_sync_t)value) {
1902 ALOGV("getAudioHwSyncForSession removing ID %d for session %d",
1903 value, mHwAvSyncIds.keyAt(i));
1904 mHwAvSyncIds.removeItemsAt(i);
Eric Laurent93c3d412014-08-01 14:48:35 -07001905 break;
1906 }
1907 }
Eric Laurentfa90e842014-10-17 18:12:31 -07001908
1909 mHwAvSyncIds.add(sessionId, value);
1910
1911 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1912 sp<PlaybackThread> thread = mPlaybackThreads.valueAt(i);
1913 uint32_t sessions = thread->hasAudioSession(sessionId);
Eric Laurent4c415062016-06-17 16:14:16 -07001914 if (sessions & ThreadBase::TRACK_SESSION) {
Eric Laurentfa90e842014-10-17 18:12:31 -07001915 AudioParameter param = AudioParameter();
Mikhail Naganov00260b52016-10-13 12:54:24 -07001916 param.addInt(String8(AudioParameter::keyStreamHwAvSync), value);
Eric Laurentfa90e842014-10-17 18:12:31 -07001917 thread->setParameters(param.toString());
1918 break;
1919 }
1920 }
1921
1922 ALOGV("getAudioHwSyncForSession adding ID %d for session %d", value, sessionId);
1923 return (audio_hw_sync_t)value;
Eric Laurent93c3d412014-08-01 14:48:35 -07001924}
1925
Eric Laurent72e3f392015-05-20 14:43:50 -07001926status_t AudioFlinger::systemReady()
1927{
1928 Mutex::Autolock _l(mLock);
1929 ALOGI("%s", __FUNCTION__);
1930 if (mSystemReady) {
1931 ALOGW("%s called twice", __FUNCTION__);
1932 return NO_ERROR;
1933 }
1934 mSystemReady = true;
1935 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1936 ThreadBase *thread = (ThreadBase *)mPlaybackThreads.valueAt(i).get();
1937 thread->systemReady();
1938 }
1939 for (size_t i = 0; i < mRecordThreads.size(); i++) {
1940 ThreadBase *thread = (ThreadBase *)mRecordThreads.valueAt(i).get();
1941 thread->systemReady();
1942 }
1943 return NO_ERROR;
1944}
1945
Eric Laurentfa90e842014-10-17 18:12:31 -07001946// setAudioHwSyncForSession_l() must be called with AudioFlinger::mLock held
1947void AudioFlinger::setAudioHwSyncForSession_l(PlaybackThread *thread, audio_session_t sessionId)
1948{
1949 ssize_t index = mHwAvSyncIds.indexOfKey(sessionId);
1950 if (index >= 0) {
1951 audio_hw_sync_t syncId = mHwAvSyncIds.valueAt(index);
1952 ALOGV("setAudioHwSyncForSession_l found ID %d for session %d", syncId, sessionId);
1953 AudioParameter param = AudioParameter();
Mikhail Naganov00260b52016-10-13 12:54:24 -07001954 param.addInt(String8(AudioParameter::keyStreamHwAvSync), syncId);
Eric Laurentfa90e842014-10-17 18:12:31 -07001955 thread->setParameters(param.toString());
1956 }
1957}
1958
1959
Glenn Kasten4182c4e2013-07-15 14:45:07 -07001960// ----------------------------------------------------------------------------
1961
Eric Laurent83b88082014-06-20 18:31:16 -07001962
Eric Laurent6acd1d42017-01-04 14:23:29 -08001963sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t module,
Eric Laurentcf2c0212014-07-25 16:20:43 -07001964 audio_io_handle_t *output,
1965 audio_config_t *config,
1966 audio_devices_t devices,
1967 const String8& address,
Eric Laurent83b88082014-06-20 18:31:16 -07001968 audio_output_flags_t flags)
1969{
Eric Laurentcf2c0212014-07-25 16:20:43 -07001970 AudioHwDevice *outHwDev = findSuitableHwDev_l(module, devices);
Eric Laurent83b88082014-06-20 18:31:16 -07001971 if (outHwDev == NULL) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07001972 return 0;
Eric Laurent83b88082014-06-20 18:31:16 -07001973 }
1974
Eric Laurentcf2c0212014-07-25 16:20:43 -07001975 if (*output == AUDIO_IO_HANDLE_NONE) {
Glenn Kasteneeecb982016-02-26 10:44:04 -08001976 *output = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);
1977 } else {
1978 // Audio Policy does not currently request a specific output handle.
1979 // If this is ever needed, see openInput_l() for example code.
1980 ALOGE("openOutput_l requested output handle %d is not AUDIO_IO_HANDLE_NONE", *output);
1981 return 0;
Eric Laurentcf2c0212014-07-25 16:20:43 -07001982 }
Eric Laurent83b88082014-06-20 18:31:16 -07001983
1984 mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;
1985
Eric Laurent83b88082014-06-20 18:31:16 -07001986 // FOR TESTING ONLY:
Andy Hung9a592762014-07-21 21:56:01 -07001987 // This if statement allows overriding the audio policy settings
1988 // and forcing a specific format or channel mask to the HAL/Sink device for testing.
1989 if (!(flags & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD | AUDIO_OUTPUT_FLAG_DIRECT))) {
1990 // Check only for Normal Mixing mode
1991 if (kEnableExtendedPrecision) {
1992 // Specify format (uncomment one below to choose)
1993 //config->format = AUDIO_FORMAT_PCM_FLOAT;
1994 //config->format = AUDIO_FORMAT_PCM_24_BIT_PACKED;
1995 //config->format = AUDIO_FORMAT_PCM_32_BIT;
1996 //config->format = AUDIO_FORMAT_PCM_8_24_BIT;
Eric Laurentcf2c0212014-07-25 16:20:43 -07001997 // ALOGV("openOutput_l() upgrading format to %#08x", config->format);
Andy Hung9a592762014-07-21 21:56:01 -07001998 }
1999 if (kEnableExtendedChannels) {
2000 // Specify channel mask (uncomment one below to choose)
2001 //config->channel_mask = audio_channel_out_mask_from_count(4); // for USB 4ch
2002 //config->channel_mask = audio_channel_mask_from_representation_and_bits(
2003 // AUDIO_CHANNEL_REPRESENTATION_INDEX, (1 << 4) - 1); // another 4ch example
2004 }
Eric Laurent83b88082014-06-20 18:31:16 -07002005 }
2006
Phil Burk062e67a2015-02-11 13:40:50 -08002007 AudioStreamOut *outputStream = NULL;
2008 status_t status = outHwDev->openOutputStream(
2009 &outputStream,
2010 *output,
2011 devices,
2012 flags,
2013 config,
2014 address.string());
Eric Laurent83b88082014-06-20 18:31:16 -07002015
2016 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent83b88082014-06-20 18:31:16 -07002017
Phil Burk062e67a2015-02-11 13:40:50 -08002018 if (status == NO_ERROR) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08002019 if (flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) {
2020 sp<MmapPlaybackThread> thread =
2021 new MmapPlaybackThread(this, *output, outHwDev, outputStream,
2022 devices, AUDIO_DEVICE_NONE, mSystemReady);
2023 mMmapThreads.add(*output, thread);
2024 ALOGV("openOutput_l() created mmap playback thread: ID %d thread %p",
2025 *output, thread.get());
2026 return thread;
Eric Laurent83b88082014-06-20 18:31:16 -07002027 } else {
Eric Laurent6acd1d42017-01-04 14:23:29 -08002028 sp<PlaybackThread> thread;
2029 if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
2030 thread = new OffloadThread(this, outputStream, *output, devices, mSystemReady);
2031 ALOGV("openOutput_l() created offload output: ID %d thread %p",
2032 *output, thread.get());
2033 } else if ((flags & AUDIO_OUTPUT_FLAG_DIRECT)
2034 || !isValidPcmSinkFormat(config->format)
2035 || !isValidPcmSinkChannelMask(config->channel_mask)) {
2036 thread = new DirectOutputThread(this, outputStream, *output, devices, mSystemReady);
2037 ALOGV("openOutput_l() created direct output: ID %d thread %p",
2038 *output, thread.get());
2039 } else {
2040 thread = new MixerThread(this, outputStream, *output, devices, mSystemReady);
2041 ALOGV("openOutput_l() created mixer output: ID %d thread %p",
2042 *output, thread.get());
2043 }
2044 mPlaybackThreads.add(*output, thread);
2045 return thread;
Eric Laurent83b88082014-06-20 18:31:16 -07002046 }
Eric Laurent83b88082014-06-20 18:31:16 -07002047 }
2048
2049 return 0;
2050}
2051
Eric Laurentcf2c0212014-07-25 16:20:43 -07002052status_t AudioFlinger::openOutput(audio_module_handle_t module,
2053 audio_io_handle_t *output,
2054 audio_config_t *config,
2055 audio_devices_t *devices,
2056 const String8& address,
2057 uint32_t *latencyMs,
2058 audio_output_flags_t flags)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002059{
Glenn Kasten49f36ba2017-12-06 13:02:02 -08002060 ALOGI("openOutput() this %p, module %d Device %#x, SamplingRate %d, Format %#08x, "
2061 "Channels %#x, flags %#x",
Eric Laurent6acd1d42017-01-04 14:23:29 -08002062 this, module,
Eric Laurentcf2c0212014-07-25 16:20:43 -07002063 (devices != NULL) ? *devices : 0,
2064 config->sample_rate,
2065 config->format,
2066 config->channel_mask,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002067 flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002068
Yunlian Jiang32ba9862017-01-31 15:55:00 -08002069 if (devices == NULL || *devices == AUDIO_DEVICE_NONE) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07002070 return BAD_VALUE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002071 }
Dima Zavin799a70e2011-04-18 16:57:27 -07002072
Mathias Agopian65ab4712010-07-14 17:59:35 -07002073 Mutex::Autolock _l(mLock);
2074
Eric Laurent6acd1d42017-01-04 14:23:29 -08002075 sp<ThreadBase> thread = openOutput_l(module, output, config, *devices, address, flags);
Eric Laurent83b88082014-06-20 18:31:16 -07002076 if (thread != 0) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08002077 if ((flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) == 0) {
2078 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
2079 *latencyMs = playbackThread->latency();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002080
Eric Laurent6acd1d42017-01-04 14:23:29 -08002081 // notify client processes of the new output creation
2082 playbackThread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002083
Eric Laurent6acd1d42017-01-04 14:23:29 -08002084 // the first primary output opened designates the primary hw device
2085 if ((mPrimaryHardwareDev == NULL) && (flags & AUDIO_OUTPUT_FLAG_PRIMARY)) {
Glenn Kasten1bfe09a2017-02-21 13:05:56 -08002086 ALOGI("Using module %d as the primary audio interface", module);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002087 mPrimaryHardwareDev = playbackThread->getOutput()->audioHwDev;
Eric Laurenta4c5a552012-03-29 10:12:40 -07002088
Eric Laurent6acd1d42017-01-04 14:23:29 -08002089 AutoMutex lock(mHardwareLock);
2090 mHardwareStatus = AUDIO_HW_SET_MODE;
2091 mPrimaryHardwareDev->hwDevice()->setMode(mMode);
2092 mHardwareStatus = AUDIO_HW_IDLE;
2093 }
2094 } else {
2095 MmapThread *mmapThread = (MmapThread *)thread.get();
2096 mmapThread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002097 }
Eric Laurentcf2c0212014-07-25 16:20:43 -07002098 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002099 }
2100
Eric Laurentcf2c0212014-07-25 16:20:43 -07002101 return NO_INIT;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002102}
2103
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002104audio_io_handle_t AudioFlinger::openDuplicateOutput(audio_io_handle_t output1,
2105 audio_io_handle_t output2)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002106{
2107 Mutex::Autolock _l(mLock);
2108 MixerThread *thread1 = checkMixerThread_l(output1);
2109 MixerThread *thread2 = checkMixerThread_l(output2);
2110
2111 if (thread1 == NULL || thread2 == NULL) {
Glenn Kasten85ab62c2012-11-01 11:11:38 -07002112 ALOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1,
2113 output2);
Glenn Kasten142f5192014-03-25 17:44:59 -07002114 return AUDIO_IO_HANDLE_NONE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002115 }
2116
Glenn Kasteneeecb982016-02-26 10:44:04 -08002117 audio_io_handle_t id = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);
Eric Laurent72e3f392015-05-20 14:43:50 -07002118 DuplicatingThread *thread = new DuplicatingThread(this, thread1, id, mSystemReady);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002119 thread->addOutputTrack(thread2);
2120 mPlaybackThreads.add(id, thread);
2121 // notify client processes of the new output creation
Eric Laurent73e26b62015-04-27 16:55:58 -07002122 thread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002123 return id;
2124}
2125
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002126status_t AudioFlinger::closeOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002127{
Glenn Kastend96c5722012-04-25 13:44:49 -07002128 return closeOutput_nonvirtual(output);
2129}
2130
2131status_t AudioFlinger::closeOutput_nonvirtual(audio_io_handle_t output)
2132{
Mathias Agopian65ab4712010-07-14 17:59:35 -07002133 // keep strong reference on the playback thread so that
2134 // it is not destroyed while exit() is executed
Eric Laurent6acd1d42017-01-04 14:23:29 -08002135 sp<PlaybackThread> playbackThread;
2136 sp<MmapPlaybackThread> mmapThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002137 {
2138 Mutex::Autolock _l(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002139 playbackThread = checkPlaybackThread_l(output);
2140 if (playbackThread != NULL) {
2141 ALOGV("closeOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002142
Eric Laurent6acd1d42017-01-04 14:23:29 -08002143 if (playbackThread->type() == ThreadBase::MIXER) {
2144 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2145 if (mPlaybackThreads.valueAt(i)->isDuplicating()) {
2146 DuplicatingThread *dupThread =
2147 (DuplicatingThread *)mPlaybackThreads.valueAt(i).get();
2148 dupThread->removeOutputTrack((MixerThread *)playbackThread.get());
2149 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08002150 }
2151 }
Eric Laurentbfb1b832013-01-07 09:53:42 -08002152
2153
Eric Laurent6acd1d42017-01-04 14:23:29 -08002154 mPlaybackThreads.removeItem(output);
2155 // save all effects to the default thread
2156 if (mPlaybackThreads.size()) {
2157 PlaybackThread *dstThread = checkPlaybackThread_l(mPlaybackThreads.keyAt(0));
2158 if (dstThread != NULL) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08002159 // audioflinger lock is held so order of thread lock acquisition doesn't matter
Eric Laurent6acd1d42017-01-04 14:23:29 -08002160 Mutex::Autolock _dl(dstThread->mLock);
2161 Mutex::Autolock _sl(playbackThread->mLock);
2162 Vector< sp<EffectChain> > effectChains = playbackThread->getEffectChains_l();
2163 for (size_t i = 0; i < effectChains.size(); i ++) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08002164 moveEffectChain_l(effectChains[i]->sessionId(), playbackThread.get(),
2165 dstThread, true);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002166 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002167 }
2168 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08002169 } else {
2170 mmapThread = (MmapPlaybackThread *)checkMmapThread_l(output);
2171 if (mmapThread == 0) {
2172 return BAD_VALUE;
2173 }
2174 mMmapThreads.removeItem(output);
Phil Burk7f6b40d2017-02-09 13:18:38 -08002175 ALOGD("closing mmapThread %p", mmapThread.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002176 }
Eric Laurent73e26b62015-04-27 16:55:58 -07002177 const sp<AudioIoDescriptor> ioDesc = new AudioIoDescriptor();
2178 ioDesc->mIoHandle = output;
2179 ioConfigChanged(AUDIO_OUTPUT_CLOSED, ioDesc);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002180 }
Glenn Kastenb28686f2012-01-06 08:39:38 -08002181 // The thread entity (active unit of execution) is no longer running here,
2182 // but the ThreadBase container still exists.
Mathias Agopian65ab4712010-07-14 17:59:35 -07002183
Eric Laurent6acd1d42017-01-04 14:23:29 -08002184 if (playbackThread != 0) {
2185 playbackThread->exit();
2186 if (!playbackThread->isDuplicating()) {
2187 closeOutputFinish(playbackThread);
2188 }
2189 } else if (mmapThread != 0) {
Phil Burk7f6b40d2017-02-09 13:18:38 -08002190 ALOGD("mmapThread exit()");
Eric Laurent6acd1d42017-01-04 14:23:29 -08002191 mmapThread->exit();
2192 AudioStreamOut *out = mmapThread->clearOutput();
2193 ALOG_ASSERT(out != NULL, "out shouldn't be NULL");
2194 // from now on thread->mOutput is NULL
2195 delete out;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002196 }
2197 return NO_ERROR;
2198}
2199
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -07002200void AudioFlinger::closeOutputFinish(const sp<PlaybackThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07002201{
2202 AudioStreamOut *out = thread->clearOutput();
2203 ALOG_ASSERT(out != NULL, "out shouldn't be NULL");
2204 // from now on thread->mOutput is NULL
Eric Laurent83b88082014-06-20 18:31:16 -07002205 delete out;
2206}
2207
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -07002208void AudioFlinger::closeOutputInternal_l(const sp<PlaybackThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07002209{
2210 mPlaybackThreads.removeItem(thread->mId);
2211 thread->exit();
2212 closeOutputFinish(thread);
2213}
2214
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002215status_t AudioFlinger::suspendOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002216{
2217 Mutex::Autolock _l(mLock);
2218 PlaybackThread *thread = checkPlaybackThread_l(output);
2219
2220 if (thread == NULL) {
2221 return BAD_VALUE;
2222 }
2223
Steve Block3856b092011-10-20 11:56:00 +01002224 ALOGV("suspendOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002225 thread->suspend();
2226
2227 return NO_ERROR;
2228}
2229
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002230status_t AudioFlinger::restoreOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002231{
2232 Mutex::Autolock _l(mLock);
2233 PlaybackThread *thread = checkPlaybackThread_l(output);
2234
2235 if (thread == NULL) {
2236 return BAD_VALUE;
2237 }
2238
Steve Block3856b092011-10-20 11:56:00 +01002239 ALOGV("restoreOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002240
2241 thread->restore();
2242
2243 return NO_ERROR;
2244}
2245
Eric Laurentcf2c0212014-07-25 16:20:43 -07002246status_t AudioFlinger::openInput(audio_module_handle_t module,
2247 audio_io_handle_t *input,
2248 audio_config_t *config,
Glenn Kastene7d66712015-03-05 13:46:52 -08002249 audio_devices_t *devices,
Eric Laurentcf2c0212014-07-25 16:20:43 -07002250 const String8& address,
2251 audio_source_t source,
Glenn Kastenec40d282014-07-15 15:31:26 -07002252 audio_input_flags_t flags)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002253{
Eric Laurent83b88082014-06-20 18:31:16 -07002254 Mutex::Autolock _l(mLock);
2255
Glenn Kastene7d66712015-03-05 13:46:52 -08002256 if (*devices == AUDIO_DEVICE_NONE) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07002257 return BAD_VALUE;
Eric Laurent83b88082014-06-20 18:31:16 -07002258 }
2259
Eric Laurent6acd1d42017-01-04 14:23:29 -08002260 sp<ThreadBase> thread = openInput_l(module, input, config, *devices, address, source, flags);
Eric Laurent83b88082014-06-20 18:31:16 -07002261
2262 if (thread != 0) {
Eric Laurent83b88082014-06-20 18:31:16 -07002263 // notify client processes of the new input creation
Eric Laurent73e26b62015-04-27 16:55:58 -07002264 thread->ioConfigChanged(AUDIO_INPUT_OPENED);
Eric Laurentcf2c0212014-07-25 16:20:43 -07002265 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002266 }
Eric Laurentcf2c0212014-07-25 16:20:43 -07002267 return NO_INIT;
Eric Laurent83b88082014-06-20 18:31:16 -07002268}
Dima Zavin799a70e2011-04-18 16:57:27 -07002269
Eric Laurent6acd1d42017-01-04 14:23:29 -08002270sp<AudioFlinger::ThreadBase> AudioFlinger::openInput_l(audio_module_handle_t module,
Eric Laurentcf2c0212014-07-25 16:20:43 -07002271 audio_io_handle_t *input,
2272 audio_config_t *config,
Glenn Kastene7d66712015-03-05 13:46:52 -08002273 audio_devices_t devices,
Eric Laurentcf2c0212014-07-25 16:20:43 -07002274 const String8& address,
2275 audio_source_t source,
Eric Laurent83b88082014-06-20 18:31:16 -07002276 audio_input_flags_t flags)
2277{
Glenn Kastene7d66712015-03-05 13:46:52 -08002278 AudioHwDevice *inHwDev = findSuitableHwDev_l(module, devices);
Glenn Kasten6e2ebe92013-08-13 09:14:51 -07002279 if (inHwDev == NULL) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07002280 *input = AUDIO_IO_HANDLE_NONE;
Dima Zavin799a70e2011-04-18 16:57:27 -07002281 return 0;
Glenn Kasten6e2ebe92013-08-13 09:14:51 -07002282 }
Dima Zavin799a70e2011-04-18 16:57:27 -07002283
Glenn Kasteneeecb982016-02-26 10:44:04 -08002284 // Audio Policy can request a specific handle for hardware hotword.
2285 // The goal here is not to re-open an already opened input.
2286 // It is to use a pre-assigned I/O handle.
Eric Laurentcf2c0212014-07-25 16:20:43 -07002287 if (*input == AUDIO_IO_HANDLE_NONE) {
Glenn Kasteneeecb982016-02-26 10:44:04 -08002288 *input = nextUniqueId(AUDIO_UNIQUE_ID_USE_INPUT);
2289 } else if (audio_unique_id_get_use(*input) != AUDIO_UNIQUE_ID_USE_INPUT) {
2290 ALOGE("openInput_l() requested input handle %d is invalid", *input);
2291 return 0;
2292 } else if (mRecordThreads.indexOfKey(*input) >= 0) {
2293 // This should not happen in a transient state with current design.
2294 ALOGE("openInput_l() requested input handle %d is already assigned", *input);
2295 return 0;
Eric Laurentcf2c0212014-07-25 16:20:43 -07002296 }
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07002297
Eric Laurentcf2c0212014-07-25 16:20:43 -07002298 audio_config_t halconfig = *config;
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002299 sp<DeviceHalInterface> inHwHal = inHwDev->hwDevice();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002300 sp<StreamInHalInterface> inStream;
2301 status_t status = inHwHal->openInputStream(
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002302 *input, devices, &halconfig, flags, address.string(), source, &inStream);
Glenn Kasten49f36ba2017-12-06 13:02:02 -08002303 ALOGV("openInput_l() openInputStream returned input %p, devices %#x, SamplingRate %d"
2304 ", Format %#x, Channels %#x, flags %#x, status %d addr %s",
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002305 inStream.get(),
Mikhail Naganovf558e022016-11-14 17:45:17 -08002306 devices,
Eric Laurentcf2c0212014-07-25 16:20:43 -07002307 halconfig.sample_rate,
2308 halconfig.format,
2309 halconfig.channel_mask,
Glenn Kastenec40d282014-07-15 15:31:26 -07002310 flags,
Jean-Michel Trivifd4c1482014-08-06 16:02:28 -07002311 status, address.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002312
Glenn Kasten85ab62c2012-11-01 11:11:38 -07002313 // If the input could not be opened with the requested parameters and we can handle the
Andy Hung6770c6f2015-04-07 13:43:36 -07002314 // conversion internally, try to open again with the proposed parameters.
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07002315 if (status == BAD_VALUE &&
Andy Hung6770c6f2015-04-07 13:43:36 -07002316 audio_is_linear_pcm(config->format) &&
2317 audio_is_linear_pcm(halconfig.format) &&
2318 (halconfig.sample_rate <= AUDIO_RESAMPLER_DOWN_RATIO_MAX * config->sample_rate) &&
vivek mehta75346662016-05-04 18:45:46 -07002319 (audio_channel_count_from_in_mask(halconfig.channel_mask) <= FCC_8) &&
2320 (audio_channel_count_from_in_mask(config->channel_mask) <= FCC_8)) {
Glenn Kasten85948432013-08-19 12:09:05 -07002321 // FIXME describe the change proposed by HAL (save old values so we can log them here)
Eric Laurentcf2c0212014-07-25 16:20:43 -07002322 ALOGV("openInput_l() reopening with proposed sampling rate and channel mask");
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002323 inStream.clear();
2324 status = inHwHal->openInputStream(
Mikhail Naganove4f1f632016-08-31 11:35:10 -07002325 *input, devices, &halconfig, flags, address.string(), source, &inStream);
Glenn Kasten85948432013-08-19 12:09:05 -07002326 // FIXME log this new status; HAL should not propose any further changes
Mathias Agopian65ab4712010-07-14 17:59:35 -07002327 }
2328
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002329 if (status == NO_ERROR && inStream != 0) {
Eric Laurent05067782016-06-01 18:27:28 -07002330 AudioStreamIn *inputStream = new AudioStreamIn(inHwDev, inStream, flags);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002331 if ((flags & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0) {
2332 sp<MmapCaptureThread> thread =
2333 new MmapCaptureThread(this, *input,
2334 inHwDev, inputStream,
2335 primaryOutputDevice_l(), devices, mSystemReady);
2336 mMmapThreads.add(*input, thread);
Glenn Kastend3bb6452016-12-05 18:14:37 -08002337 ALOGV("openInput_l() created mmap capture thread: ID %d thread %p", *input,
2338 thread.get());
Eric Laurent6acd1d42017-01-04 14:23:29 -08002339 return thread;
2340 } else {
Glenn Kasten46909e72013-02-26 09:20:22 -08002341#ifdef TEE_SINK
Eric Laurent6acd1d42017-01-04 14:23:29 -08002342 // Try to re-use most recently used Pipe to archive a copy of input for dumpsys,
2343 // or (re-)create if current Pipe is idle and does not match the new format
2344 sp<NBAIO_Sink> teeSink;
2345 enum {
2346 TEE_SINK_NO, // don't copy input
2347 TEE_SINK_NEW, // copy input using a new pipe
2348 TEE_SINK_OLD, // copy input using an existing pipe
2349 } kind;
2350 NBAIO_Format format = Format_from_SR_C(halconfig.sample_rate,
2351 audio_channel_count_from_in_mask(halconfig.channel_mask), halconfig.format);
2352 if (!mTeeSinkInputEnabled) {
2353 kind = TEE_SINK_NO;
2354 } else if (!Format_isValid(format)) {
2355 kind = TEE_SINK_NO;
2356 } else if (mRecordTeeSink == 0) {
2357 kind = TEE_SINK_NEW;
2358 } else if (mRecordTeeSink->getStrongCount() != 1) {
2359 kind = TEE_SINK_NO;
2360 } else if (Format_isEqual(format, mRecordTeeSink->format())) {
2361 kind = TEE_SINK_OLD;
2362 } else {
2363 kind = TEE_SINK_NEW;
2364 }
2365 switch (kind) {
2366 case TEE_SINK_NEW: {
2367 Pipe *pipe = new Pipe(mTeeSinkInputFrames, format);
2368 size_t numCounterOffers = 0;
2369 const NBAIO_Format offers[1] = {format};
2370 ssize_t index = pipe->negotiate(offers, 1, NULL, numCounterOffers);
2371 ALOG_ASSERT(index == 0);
2372 PipeReader *pipeReader = new PipeReader(*pipe);
2373 numCounterOffers = 0;
2374 index = pipeReader->negotiate(offers, 1, NULL, numCounterOffers);
2375 ALOG_ASSERT(index == 0);
2376 mRecordTeeSink = pipe;
2377 mRecordTeeSource = pipeReader;
2378 teeSink = pipe;
2379 }
2380 break;
2381 case TEE_SINK_OLD:
2382 teeSink = mRecordTeeSink;
2383 break;
2384 case TEE_SINK_NO:
2385 default:
2386 break;
2387 }
Glenn Kasten46909e72013-02-26 09:20:22 -08002388#endif
Eric Laurent6acd1d42017-01-04 14:23:29 -08002389
2390 // Start record thread
2391 // RecordThread requires both input and output device indication to forward to audio
2392 // pre processing modules
2393 sp<RecordThread> thread = new RecordThread(this,
2394 inputStream,
2395 *input,
2396 primaryOutputDevice_l(),
2397 devices,
2398 mSystemReady
2399#ifdef TEE_SINK
2400 , teeSink
2401#endif
2402 );
2403 mRecordThreads.add(*input, thread);
2404 ALOGV("openInput_l() created record thread: ID %d thread %p", *input, thread.get());
2405 return thread;
2406 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002407 }
2408
Eric Laurentcf2c0212014-07-25 16:20:43 -07002409 *input = AUDIO_IO_HANDLE_NONE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002410 return 0;
2411}
2412
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002413status_t AudioFlinger::closeInput(audio_io_handle_t input)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002414{
Glenn Kastend96c5722012-04-25 13:44:49 -07002415 return closeInput_nonvirtual(input);
2416}
2417
2418status_t AudioFlinger::closeInput_nonvirtual(audio_io_handle_t input)
2419{
Mathias Agopian65ab4712010-07-14 17:59:35 -07002420 // keep strong reference on the record thread so that
2421 // it is not destroyed while exit() is executed
Eric Laurent6acd1d42017-01-04 14:23:29 -08002422 sp<RecordThread> recordThread;
2423 sp<MmapCaptureThread> mmapThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002424 {
2425 Mutex::Autolock _l(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002426 recordThread = checkRecordThread_l(input);
2427 if (recordThread != 0) {
2428 ALOGV("closeInput() %d", input);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002429
Eric Laurent6acd1d42017-01-04 14:23:29 -08002430 // If we still have effect chains, it means that a client still holds a handle
2431 // on at least one effect. We must either move the chain to an existing thread with the
2432 // same session ID or put it aside in case a new record thread is opened for a
2433 // new capture on the same session
2434 sp<EffectChain> chain;
2435 {
2436 Mutex::Autolock _sl(recordThread->mLock);
2437 Vector< sp<EffectChain> > effectChains = recordThread->getEffectChains_l();
2438 // Note: maximum one chain per record thread
2439 if (effectChains.size() != 0) {
2440 chain = effectChains[0];
Eric Laurent1b928682014-10-02 19:41:47 -07002441 }
2442 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08002443 if (chain != 0) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08002444 // first check if a record thread is already opened with a client on same session.
Eric Laurent6acd1d42017-01-04 14:23:29 -08002445 // This should only happen in case of overlap between one thread tear down and the
2446 // creation of its replacement
2447 size_t i;
2448 for (i = 0; i < mRecordThreads.size(); i++) {
2449 sp<RecordThread> t = mRecordThreads.valueAt(i);
2450 if (t == recordThread) {
2451 continue;
2452 }
2453 if (t->hasAudioSession(chain->sessionId()) != 0) {
2454 Mutex::Autolock _l(t->mLock);
2455 ALOGV("closeInput() found thread %d for effect session %d",
2456 t->id(), chain->sessionId());
2457 t->addEffectChain_l(chain);
2458 break;
2459 }
2460 }
Glenn Kastend3bb6452016-12-05 18:14:37 -08002461 // put the chain aside if we could not find a record thread with the same session id
Eric Laurent6acd1d42017-01-04 14:23:29 -08002462 if (i == mRecordThreads.size()) {
2463 putOrphanEffectChain_l(chain);
2464 }
Eric Laurentaaa44472014-09-12 17:41:50 -07002465 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08002466 mRecordThreads.removeItem(input);
2467 } else {
2468 mmapThread = (MmapCaptureThread *)checkMmapThread_l(input);
2469 if (mmapThread == 0) {
2470 return BAD_VALUE;
2471 }
2472 mMmapThreads.removeItem(input);
Eric Laurentaaa44472014-09-12 17:41:50 -07002473 }
Eric Laurent73e26b62015-04-27 16:55:58 -07002474 const sp<AudioIoDescriptor> ioDesc = new AudioIoDescriptor();
2475 ioDesc->mIoHandle = input;
2476 ioConfigChanged(AUDIO_INPUT_CLOSED, ioDesc);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002477 }
Eric Laurent83b88082014-06-20 18:31:16 -07002478 // FIXME: calling thread->exit() without mLock held should not be needed anymore now that
2479 // we have a different lock for notification client
Eric Laurent6acd1d42017-01-04 14:23:29 -08002480 if (recordThread != 0) {
2481 closeInputFinish(recordThread);
2482 } else if (mmapThread != 0) {
2483 mmapThread->exit();
2484 AudioStreamIn *in = mmapThread->clearInput();
2485 ALOG_ASSERT(in != NULL, "in shouldn't be NULL");
2486 // from now on thread->mInput is NULL
2487 delete in;
2488 }
Eric Laurent83b88082014-06-20 18:31:16 -07002489 return NO_ERROR;
2490}
Mathias Agopian65ab4712010-07-14 17:59:35 -07002491
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -07002492void AudioFlinger::closeInputFinish(const sp<RecordThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07002493{
2494 thread->exit();
Eric Laurentb8ba0a92011-08-07 16:32:26 -07002495 AudioStreamIn *in = thread->clearInput();
Glenn Kasten5798d4e2012-03-08 12:18:35 -08002496 ALOG_ASSERT(in != NULL, "in shouldn't be NULL");
Eric Laurentb8ba0a92011-08-07 16:32:26 -07002497 // from now on thread->mInput is NULL
Dima Zavin799a70e2011-04-18 16:57:27 -07002498 delete in;
Eric Laurent83b88082014-06-20 18:31:16 -07002499}
Mathias Agopian65ab4712010-07-14 17:59:35 -07002500
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -07002501void AudioFlinger::closeInputInternal_l(const sp<RecordThread>& thread)
Eric Laurent83b88082014-06-20 18:31:16 -07002502{
2503 mRecordThreads.removeItem(thread->mId);
2504 closeInputFinish(thread);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002505}
2506
Glenn Kastend2304db2014-02-03 07:40:31 -08002507status_t AudioFlinger::invalidateStream(audio_stream_type_t stream)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002508{
2509 Mutex::Autolock _l(mLock);
Glenn Kastend2304db2014-02-03 07:40:31 -08002510 ALOGV("invalidateStream() stream %d", stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002511
2512 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2513 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
Eric Laurent22167852012-06-20 12:26:32 -07002514 thread->invalidateTracks(stream);
Eric Laurentde070132010-07-13 04:45:46 -07002515 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08002516 for (size_t i = 0; i < mMmapThreads.size(); i++) {
2517 mMmapThreads[i]->invalidateTracks(stream);
2518 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002519 return NO_ERROR;
2520}
2521
2522
Glenn Kasteneeecb982016-02-26 10:44:04 -08002523audio_unique_id_t AudioFlinger::newAudioUniqueId(audio_unique_id_use_t use)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002524{
Glenn Kasten9d003132016-04-06 14:38:09 -07002525 // This is a binder API, so a malicious client could pass in a bad parameter.
2526 // Check for that before calling the internal API nextUniqueId().
2527 if ((unsigned) use >= (unsigned) AUDIO_UNIQUE_ID_USE_MAX) {
2528 ALOGE("newAudioUniqueId invalid use %d", use);
2529 return AUDIO_UNIQUE_ID_ALLOCATE;
2530 }
Glenn Kasteneeecb982016-02-26 10:44:04 -08002531 return nextUniqueId(use);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002532}
2533
Glenn Kastend848eb42016-03-08 13:42:11 -08002534void AudioFlinger::acquireAudioSessionId(audio_session_t audioSession, pid_t pid)
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002535{
2536 Mutex::Autolock _l(mLock);
Glenn Kastenbb001922012-02-03 11:10:26 -08002537 pid_t caller = IPCThreadState::self()->getCallingPid();
Marco Nelissend457c972014-02-11 08:47:07 -08002538 ALOGV("acquiring %d from %d, for %d", audioSession, caller, pid);
2539 if (pid != -1 && (caller == getpid_cached)) {
2540 caller = pid;
2541 }
Eric Laurentd1b28d42013-09-18 18:47:13 -07002542
Eric Laurent021cf962014-05-13 10:18:14 -07002543 {
2544 Mutex::Autolock _cl(mClientLock);
2545 // Ignore requests received from processes not known as notification client. The request
2546 // is likely proxied by mediaserver (e.g CameraService) and releaseAudioSessionId() can be
2547 // called from a different pid leaving a stale session reference. Also we don't know how
2548 // to clear this reference if the client process dies.
2549 if (mNotificationClients.indexOfKey(caller) < 0) {
2550 ALOGW("acquireAudioSessionId() unknown client %d for session %d", caller, audioSession);
2551 return;
2552 }
Eric Laurentd1b28d42013-09-18 18:47:13 -07002553 }
2554
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002555 size_t num = mAudioSessionRefs.size();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002556 for (size_t i = 0; i < num; i++) {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002557 AudioSessionRef *ref = mAudioSessionRefs.editItemAt(i);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08002558 if (ref->mSessionid == audioSession && ref->mPid == caller) {
2559 ref->mCnt++;
2560 ALOGV(" incremented refcount to %d", ref->mCnt);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002561 return;
2562 }
2563 }
Glenn Kasten84afa3b2012-01-25 15:28:08 -08002564 mAudioSessionRefs.push(new AudioSessionRef(audioSession, caller));
2565 ALOGV(" added new entry for %d", audioSession);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002566}
2567
Glenn Kastend848eb42016-03-08 13:42:11 -08002568void AudioFlinger::releaseAudioSessionId(audio_session_t audioSession, pid_t pid)
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002569{
2570 Mutex::Autolock _l(mLock);
Glenn Kastenbb001922012-02-03 11:10:26 -08002571 pid_t caller = IPCThreadState::self()->getCallingPid();
Marco Nelissend457c972014-02-11 08:47:07 -08002572 ALOGV("releasing %d from %d for %d", audioSession, caller, pid);
2573 if (pid != -1 && (caller == getpid_cached)) {
2574 caller = pid;
2575 }
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002576 size_t num = mAudioSessionRefs.size();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002577 for (size_t i = 0; i < num; i++) {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002578 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08002579 if (ref->mSessionid == audioSession && ref->mPid == caller) {
2580 ref->mCnt--;
2581 ALOGV(" decremented refcount to %d", ref->mCnt);
2582 if (ref->mCnt == 0) {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002583 mAudioSessionRefs.removeAt(i);
2584 delete ref;
2585 purgeStaleEffects_l();
2586 }
2587 return;
2588 }
2589 }
Eric Laurentd1b28d42013-09-18 18:47:13 -07002590 // If the caller is mediaserver it is likely that the session being released was acquired
2591 // on behalf of a process not in notification clients and we ignore the warning.
2592 ALOGW_IF(caller != getpid_cached, "session id %d not found for pid %d", audioSession, caller);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002593}
2594
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08002595bool AudioFlinger::isSessionAcquired_l(audio_session_t audioSession)
2596{
2597 size_t num = mAudioSessionRefs.size();
2598 for (size_t i = 0; i < num; i++) {
2599 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
2600 if (ref->mSessionid == audioSession) {
2601 return true;
2602 }
2603 }
2604 return false;
2605}
2606
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002607void AudioFlinger::purgeStaleEffects_l() {
2608
Steve Block3856b092011-10-20 11:56:00 +01002609 ALOGV("purging stale effects");
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002610
2611 Vector< sp<EffectChain> > chains;
2612
2613 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2614 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
Mateusz Kaplon2a6e1b02017-03-30 16:50:50 +02002615 Mutex::Autolock _l(t->mLock);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002616 for (size_t j = 0; j < t->mEffectChains.size(); j++) {
2617 sp<EffectChain> ec = t->mEffectChains[j];
Marco Nelissen0270b182011-08-12 14:14:39 -07002618 if (ec->sessionId() > AUDIO_SESSION_OUTPUT_MIX) {
2619 chains.push(ec);
2620 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002621 }
2622 }
2623 for (size_t i = 0; i < mRecordThreads.size(); i++) {
2624 sp<RecordThread> t = mRecordThreads.valueAt(i);
Mateusz Kaplon2a6e1b02017-03-30 16:50:50 +02002625 Mutex::Autolock _l(t->mLock);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002626 for (size_t j = 0; j < t->mEffectChains.size(); j++) {
2627 sp<EffectChain> ec = t->mEffectChains[j];
2628 chains.push(ec);
2629 }
2630 }
2631
2632 for (size_t i = 0; i < chains.size(); i++) {
2633 sp<EffectChain> ec = chains[i];
2634 int sessionid = ec->sessionId();
2635 sp<ThreadBase> t = ec->mThread.promote();
2636 if (t == 0) {
2637 continue;
2638 }
2639 size_t numsessionrefs = mAudioSessionRefs.size();
2640 bool found = false;
2641 for (size_t k = 0; k < numsessionrefs; k++) {
2642 AudioSessionRef *ref = mAudioSessionRefs.itemAt(k);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08002643 if (ref->mSessionid == sessionid) {
Steve Block3856b092011-10-20 11:56:00 +01002644 ALOGV(" session %d still exists for %d with %d refs",
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002645 sessionid, ref->mPid, ref->mCnt);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002646 found = true;
2647 break;
2648 }
2649 }
2650 if (!found) {
Glenn Kastene198c362013-08-13 09:13:36 -07002651 Mutex::Autolock _l(t->mLock);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002652 // remove all effects from the chain
2653 while (ec->mEffects.size()) {
2654 sp<EffectModule> effect = ec->mEffects[0];
2655 effect->unPin();
Mikhail Naganov424c4f52017-07-19 17:54:29 -07002656 t->removeEffect_l(effect, /*release*/ true);
Eric Laurenta5f44eb2012-06-25 11:38:29 -07002657 if (effect->purgeHandles()) {
2658 t->checkSuspendOnEffectEnabled_l(effect, false, effect->sessionId());
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002659 }
2660 AudioSystem::unregisterEffect(effect->id());
2661 }
2662 }
2663 }
2664 return;
2665}
2666
Glenn Kasteneeecb982016-02-26 10:44:04 -08002667// checkThread_l() must be called with AudioFlinger::mLock held
2668AudioFlinger::ThreadBase *AudioFlinger::checkThread_l(audio_io_handle_t ioHandle) const
2669{
Eric Laurent6acd1d42017-01-04 14:23:29 -08002670 ThreadBase *thread = checkMmapThread_l(ioHandle);
2671 if (thread == 0) {
2672 switch (audio_unique_id_get_use(ioHandle)) {
2673 case AUDIO_UNIQUE_ID_USE_OUTPUT:
2674 thread = checkPlaybackThread_l(ioHandle);
2675 break;
2676 case AUDIO_UNIQUE_ID_USE_INPUT:
2677 thread = checkRecordThread_l(ioHandle);
2678 break;
2679 default:
2680 break;
2681 }
Glenn Kasteneeecb982016-02-26 10:44:04 -08002682 }
2683 return thread;
2684}
2685
Mathias Agopian65ab4712010-07-14 17:59:35 -07002686// checkPlaybackThread_l() must be called with AudioFlinger::mLock held
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002687AudioFlinger::PlaybackThread *AudioFlinger::checkPlaybackThread_l(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07002688{
Glenn Kastena1117922012-01-26 10:53:32 -08002689 return mPlaybackThreads.valueFor(output).get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002690}
2691
2692// checkMixerThread_l() must be called with AudioFlinger::mLock held
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002693AudioFlinger::MixerThread *AudioFlinger::checkMixerThread_l(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07002694{
2695 PlaybackThread *thread = checkPlaybackThread_l(output);
Glenn Kastena1117922012-01-26 10:53:32 -08002696 return thread != NULL && thread->type() != ThreadBase::DIRECT ? (MixerThread *) thread : NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002697}
2698
2699// checkRecordThread_l() must be called with AudioFlinger::mLock held
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002700AudioFlinger::RecordThread *AudioFlinger::checkRecordThread_l(audio_io_handle_t input) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07002701{
Glenn Kastena1117922012-01-26 10:53:32 -08002702 return mRecordThreads.valueFor(input).get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002703}
2704
Eric Laurent6acd1d42017-01-04 14:23:29 -08002705// checkMmapThread_l() must be called with AudioFlinger::mLock held
2706AudioFlinger::MmapThread *AudioFlinger::checkMmapThread_l(audio_io_handle_t io) const
2707{
2708 return mMmapThreads.valueFor(io).get();
2709}
2710
2711
2712// checkPlaybackThread_l() must be called with AudioFlinger::mLock held
2713AudioFlinger::VolumeInterface *AudioFlinger::getVolumeInterface_l(audio_io_handle_t output) const
2714{
Eric Laurent7459b902017-04-19 18:10:41 -07002715 VolumeInterface *volumeInterface = mPlaybackThreads.valueFor(output).get();
Eric Laurent6acd1d42017-01-04 14:23:29 -08002716 if (volumeInterface == nullptr) {
2717 MmapThread *mmapThread = mMmapThreads.valueFor(output).get();
2718 if (mmapThread != nullptr) {
2719 if (mmapThread->isOutput()) {
Eric Laurent7459b902017-04-19 18:10:41 -07002720 MmapPlaybackThread *mmapPlaybackThread =
2721 static_cast<MmapPlaybackThread *>(mmapThread);
2722 volumeInterface = mmapPlaybackThread;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002723 }
2724 }
2725 }
2726 return volumeInterface;
2727}
2728
2729Vector <AudioFlinger::VolumeInterface *> AudioFlinger::getAllVolumeInterfaces_l() const
2730{
2731 Vector <VolumeInterface *> volumeInterfaces;
2732 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Eric Laurent7459b902017-04-19 18:10:41 -07002733 volumeInterfaces.add(mPlaybackThreads.valueAt(i).get());
Eric Laurent6acd1d42017-01-04 14:23:29 -08002734 }
2735 for (size_t i = 0; i < mMmapThreads.size(); i++) {
2736 if (mMmapThreads.valueAt(i)->isOutput()) {
Eric Laurent7459b902017-04-19 18:10:41 -07002737 MmapPlaybackThread *mmapPlaybackThread =
2738 static_cast<MmapPlaybackThread *>(mMmapThreads.valueAt(i).get());
2739 volumeInterfaces.add(mmapPlaybackThread);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002740 }
2741 }
2742 return volumeInterfaces;
2743}
2744
Glenn Kasteneeecb982016-02-26 10:44:04 -08002745audio_unique_id_t AudioFlinger::nextUniqueId(audio_unique_id_use_t use)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002746{
Glenn Kasten9d003132016-04-06 14:38:09 -07002747 // This is the internal API, so it is OK to assert on bad parameter.
Glenn Kasteneeecb982016-02-26 10:44:04 -08002748 LOG_ALWAYS_FATAL_IF((unsigned) use >= (unsigned) AUDIO_UNIQUE_ID_USE_MAX);
Glenn Kastend2e67e12016-04-11 08:26:37 -07002749 const int maxRetries = use == AUDIO_UNIQUE_ID_USE_SESSION ? 3 : 1;
2750 for (int retry = 0; retry < maxRetries; retry++) {
2751 // The cast allows wraparound from max positive to min negative instead of abort
2752 uint32_t base = (uint32_t) atomic_fetch_add_explicit(&mNextUniqueIds[use],
2753 (uint_fast32_t) AUDIO_UNIQUE_ID_USE_MAX, memory_order_acq_rel);
2754 ALOG_ASSERT(audio_unique_id_get_use(base) == AUDIO_UNIQUE_ID_USE_UNSPECIFIED);
2755 // allow wrap by skipping 0 and -1 for session ids
2756 if (!(base == 0 || base == (~0u & ~AUDIO_UNIQUE_ID_USE_MASK))) {
2757 ALOGW_IF(retry != 0, "unique ID overflow for use %d", use);
2758 return (audio_unique_id_t) (base | use);
2759 }
2760 }
2761 // We have no way of recovering from wraparound
2762 LOG_ALWAYS_FATAL("unique ID overflow for use %d", use);
2763 // TODO Use a floor after wraparound. This may need a mutex.
Mathias Agopian65ab4712010-07-14 17:59:35 -07002764}
2765
Glenn Kasten02fe1bf2012-02-24 15:42:17 -08002766AudioFlinger::PlaybackThread *AudioFlinger::primaryPlaybackThread_l() const
Eric Laurent7c7f10b2011-06-17 21:29:58 -07002767{
2768 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2769 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
Eric Laurentf6870ae2015-05-08 10:50:03 -07002770 if(thread->isDuplicating()) {
2771 continue;
2772 }
Eric Laurentb8ba0a92011-08-07 16:32:26 -07002773 AudioStreamOut *output = thread->getOutput();
John Grossmanee578c02012-07-23 17:05:46 -07002774 if (output != NULL && output->audioHwDev == mPrimaryHardwareDev) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07002775 return thread;
2776 }
2777 }
2778 return NULL;
2779}
2780
Glenn Kastenbb4350d2012-07-03 15:56:38 -07002781audio_devices_t AudioFlinger::primaryOutputDevice_l() const
Eric Laurent7c7f10b2011-06-17 21:29:58 -07002782{
2783 PlaybackThread *thread = primaryPlaybackThread_l();
2784
2785 if (thread == NULL) {
2786 return 0;
2787 }
2788
Eric Laurentf1c04f92012-08-28 14:26:53 -07002789 return thread->outDevice();
Eric Laurent7c7f10b2011-06-17 21:29:58 -07002790}
2791
Glenn Kastena7335632016-06-09 17:09:53 -07002792AudioFlinger::PlaybackThread *AudioFlinger::fastPlaybackThread_l() const
2793{
2794 size_t minFrameCount = 0;
2795 PlaybackThread *minThread = NULL;
2796 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2797 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
2798 if (!thread->isDuplicating()) {
2799 size_t frameCount = thread->frameCountHAL();
2800 if (frameCount != 0 && (minFrameCount == 0 || frameCount < minFrameCount ||
2801 (frameCount == minFrameCount && thread->hasFastMixer() &&
2802 /*minThread != NULL &&*/ !minThread->hasFastMixer()))) {
2803 minFrameCount = frameCount;
2804 minThread = thread;
2805 }
2806 }
2807 }
2808 return minThread;
2809}
2810
Eric Laurenta011e352012-03-29 15:51:43 -07002811sp<AudioFlinger::SyncEvent> AudioFlinger::createSyncEvent(AudioSystem::sync_event_t type,
Glenn Kastend848eb42016-03-08 13:42:11 -08002812 audio_session_t triggerSession,
2813 audio_session_t listenerSession,
Eric Laurenta011e352012-03-29 15:51:43 -07002814 sync_event_callback_t callBack,
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -07002815 const wp<RefBase>& cookie)
Eric Laurenta011e352012-03-29 15:51:43 -07002816{
2817 Mutex::Autolock _l(mLock);
2818
2819 sp<SyncEvent> event = new SyncEvent(type, triggerSession, listenerSession, callBack, cookie);
2820 status_t playStatus = NAME_NOT_FOUND;
2821 status_t recStatus = NAME_NOT_FOUND;
2822 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2823 playStatus = mPlaybackThreads.valueAt(i)->setSyncEvent(event);
2824 if (playStatus == NO_ERROR) {
2825 return event;
2826 }
2827 }
2828 for (size_t i = 0; i < mRecordThreads.size(); i++) {
2829 recStatus = mRecordThreads.valueAt(i)->setSyncEvent(event);
2830 if (recStatus == NO_ERROR) {
2831 return event;
2832 }
2833 }
2834 if (playStatus == NAME_NOT_FOUND || recStatus == NAME_NOT_FOUND) {
2835 mPendingSyncEvents.add(event);
2836 } else {
2837 ALOGV("createSyncEvent() invalid event %d", event->type());
2838 event.clear();
2839 }
2840 return event;
2841}
Eric Laurent7c7f10b2011-06-17 21:29:58 -07002842
Mathias Agopian65ab4712010-07-14 17:59:35 -07002843// ----------------------------------------------------------------------------
2844// Effect management
2845// ----------------------------------------------------------------------------
2846
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07002847sp<EffectsFactoryHalInterface> AudioFlinger::getEffectsFactory() {
2848 return mEffectsFactoryHal;
2849}
Mathias Agopian65ab4712010-07-14 17:59:35 -07002850
Glenn Kastenf587ba52012-01-26 16:25:10 -08002851status_t AudioFlinger::queryNumberEffects(uint32_t *numEffects) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07002852{
2853 Mutex::Autolock _l(mLock);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07002854 if (mEffectsFactoryHal.get()) {
2855 return mEffectsFactoryHal->queryNumberEffects(numEffects);
2856 } else {
2857 return -ENODEV;
2858 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002859}
2860
Glenn Kastenf587ba52012-01-26 16:25:10 -08002861status_t AudioFlinger::queryEffect(uint32_t index, effect_descriptor_t *descriptor) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07002862{
2863 Mutex::Autolock _l(mLock);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07002864 if (mEffectsFactoryHal.get()) {
2865 return mEffectsFactoryHal->getDescriptor(index, descriptor);
2866 } else {
2867 return -ENODEV;
2868 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002869}
2870
Glenn Kasten5e92a782012-01-30 07:40:52 -08002871status_t AudioFlinger::getEffectDescriptor(const effect_uuid_t *pUuid,
Glenn Kastenf587ba52012-01-26 16:25:10 -08002872 effect_descriptor_t *descriptor) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07002873{
2874 Mutex::Autolock _l(mLock);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07002875 if (mEffectsFactoryHal.get()) {
2876 return mEffectsFactoryHal->getDescriptor(pUuid, descriptor);
2877 } else {
2878 return -ENODEV;
2879 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002880}
2881
2882
Glenn Kasten8d6cc842012-02-03 11:06:53 -08002883sp<IEffect> AudioFlinger::createEffect(
Mathias Agopian65ab4712010-07-14 17:59:35 -07002884 effect_descriptor_t *pDesc,
2885 const sp<IEffectClient>& effectClient,
2886 int32_t priority,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002887 audio_io_handle_t io,
Glenn Kastend848eb42016-03-08 13:42:11 -08002888 audio_session_t sessionId,
Svet Ganovbe71aa22015-04-28 12:06:02 -07002889 const String16& opPackageName,
Eric Laurentb6436272016-12-07 19:24:50 -08002890 pid_t pid,
Mathias Agopian65ab4712010-07-14 17:59:35 -07002891 status_t *status,
2892 int *id,
2893 int *enabled)
2894{
2895 status_t lStatus = NO_ERROR;
2896 sp<EffectHandle> handle;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002897 effect_descriptor_t desc;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002898
Eric Laurentb6436272016-12-07 19:24:50 -08002899 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
2900 if (pid == -1 || !isTrustedCallingUid(callingUid)) {
2901 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
2902 ALOGW_IF(pid != -1 && pid != callingPid,
2903 "%s uid %d pid %d tried to pass itself off as pid %d",
2904 __func__, callingUid, callingPid, pid);
2905 pid = callingPid;
2906 }
2907
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07002908 ALOGV("createEffect pid %d, effectClient %p, priority %d, sessionId %d, io %d, factory %p",
2909 pid, effectClient.get(), priority, sessionId, io, mEffectsFactoryHal.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002910
2911 if (pDesc == NULL) {
2912 lStatus = BAD_VALUE;
2913 goto Exit;
2914 }
2915
Eric Laurent84e9a102010-09-23 16:10:16 -07002916 // check audio settings permission for global effects
Dima Zavinfce7a472011-04-19 22:30:36 -07002917 if (sessionId == AUDIO_SESSION_OUTPUT_MIX && !settingsAllowed()) {
Eric Laurent84e9a102010-09-23 16:10:16 -07002918 lStatus = PERMISSION_DENIED;
2919 goto Exit;
2920 }
2921
Dima Zavinfce7a472011-04-19 22:30:36 -07002922 // Session AUDIO_SESSION_OUTPUT_STAGE is reserved for output stage effects
Eric Laurent84e9a102010-09-23 16:10:16 -07002923 // that can only be created by audio policy manager (running in same process)
Glenn Kasten44deb052012-02-05 18:09:08 -08002924 if (sessionId == AUDIO_SESSION_OUTPUT_STAGE && getpid_cached != pid) {
Eric Laurent84e9a102010-09-23 16:10:16 -07002925 lStatus = PERMISSION_DENIED;
2926 goto Exit;
2927 }
2928
Mikhail Naganov1dc98672016-08-18 17:50:29 -07002929 if (mEffectsFactoryHal == 0) {
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07002930 lStatus = NO_INIT;
2931 goto Exit;
2932 }
2933
Mathias Agopian65ab4712010-07-14 17:59:35 -07002934 {
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07002935 if (!EffectsFactoryHalInterface::isNullUuid(&pDesc->uuid)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002936 // if uuid is specified, request effect descriptor
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07002937 lStatus = mEffectsFactoryHal->getDescriptor(&pDesc->uuid, &desc);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002938 if (lStatus < 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00002939 ALOGW("createEffect() error %d from EffectGetDescriptor", lStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002940 goto Exit;
2941 }
2942 } else {
2943 // if uuid is not specified, look for an available implementation
2944 // of the required type in effect factory
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07002945 if (EffectsFactoryHalInterface::isNullUuid(&pDesc->type)) {
Steve Block5ff1dd52012-01-05 23:22:43 +00002946 ALOGW("createEffect() no effect type");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002947 lStatus = BAD_VALUE;
2948 goto Exit;
2949 }
2950 uint32_t numEffects = 0;
2951 effect_descriptor_t d;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07002952 d.flags = 0; // prevent compiler warning
Mathias Agopian65ab4712010-07-14 17:59:35 -07002953 bool found = false;
2954
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07002955 lStatus = mEffectsFactoryHal->queryNumberEffects(&numEffects);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002956 if (lStatus < 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00002957 ALOGW("createEffect() error %d from EffectQueryNumberEffects", lStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002958 goto Exit;
2959 }
2960 for (uint32_t i = 0; i < numEffects; i++) {
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07002961 lStatus = mEffectsFactoryHal->getDescriptor(i, &desc);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002962 if (lStatus < 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00002963 ALOGW("createEffect() error %d from EffectQueryEffect", lStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002964 continue;
2965 }
2966 if (memcmp(&desc.type, &pDesc->type, sizeof(effect_uuid_t)) == 0) {
2967 // If matching type found save effect descriptor. If the session is
2968 // 0 and the effect is not auxiliary, continue enumeration in case
2969 // an auxiliary version of this effect type is available
2970 found = true;
Glenn Kastena189a682012-02-20 12:16:30 -08002971 d = desc;
Dima Zavinfce7a472011-04-19 22:30:36 -07002972 if (sessionId != AUDIO_SESSION_OUTPUT_MIX ||
Mathias Agopian65ab4712010-07-14 17:59:35 -07002973 (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
2974 break;
2975 }
2976 }
2977 }
2978 if (!found) {
2979 lStatus = BAD_VALUE;
Steve Block5ff1dd52012-01-05 23:22:43 +00002980 ALOGW("createEffect() effect not found");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002981 goto Exit;
2982 }
2983 // For same effect type, chose auxiliary version over insert version if
2984 // connect to output mix (Compliance to OpenSL ES)
Dima Zavinfce7a472011-04-19 22:30:36 -07002985 if (sessionId == AUDIO_SESSION_OUTPUT_MIX &&
Mathias Agopian65ab4712010-07-14 17:59:35 -07002986 (d.flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_AUXILIARY) {
Glenn Kastena189a682012-02-20 12:16:30 -08002987 desc = d;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002988 }
2989 }
2990
2991 // Do not allow auxiliary effects on a session different from 0 (output mix)
Dima Zavinfce7a472011-04-19 22:30:36 -07002992 if (sessionId != AUDIO_SESSION_OUTPUT_MIX &&
Mathias Agopian65ab4712010-07-14 17:59:35 -07002993 (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
2994 lStatus = INVALID_OPERATION;
2995 goto Exit;
2996 }
2997
Eric Laurent59255e42011-07-27 19:49:51 -07002998 // check recording permission for visualizer
2999 if ((memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) &&
Marco Nelissendcb346b2015-09-09 10:47:29 -07003000 !recordingAllowed(opPackageName, pid, IPCThreadState::self()->getCallingUid())) {
Eric Laurent59255e42011-07-27 19:49:51 -07003001 lStatus = PERMISSION_DENIED;
3002 goto Exit;
3003 }
3004
Mathias Agopian65ab4712010-07-14 17:59:35 -07003005 // return effect descriptor
Glenn Kastena189a682012-02-20 12:16:30 -08003006 *pDesc = desc;
Glenn Kasten142f5192014-03-25 17:44:59 -07003007 if (io == AUDIO_IO_HANDLE_NONE && sessionId == AUDIO_SESSION_OUTPUT_MIX) {
Eric Laurenteb3c3372013-09-25 12:25:29 -07003008 // if the output returned by getOutputForEffect() is removed before we lock the
3009 // mutex below, the call to checkPlaybackThread_l(io) below will detect it
3010 // and we will exit safely
3011 io = AudioSystem::getOutputForEffect(&desc);
3012 ALOGV("createEffect got output %d", io);
3013 }
3014
3015 Mutex::Autolock _l(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003016
3017 // If output is not specified try to find a matching audio session ID in one of the
3018 // output threads.
Eric Laurent84e9a102010-09-23 16:10:16 -07003019 // If output is 0 here, sessionId is neither SESSION_OUTPUT_STAGE nor SESSION_OUTPUT_MIX
3020 // because of code checking output when entering the function.
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003021 // Note: io is never 0 when creating an effect on an input
Glenn Kasten142f5192014-03-25 17:44:59 -07003022 if (io == AUDIO_IO_HANDLE_NONE) {
Eric Laurent5baf2af2013-09-12 17:37:00 -07003023 if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
3024 // output must be specified by AudioPolicyManager when using session
3025 // AUDIO_SESSION_OUTPUT_STAGE
3026 lStatus = BAD_VALUE;
3027 goto Exit;
3028 }
Eric Laurenteb3c3372013-09-25 12:25:29 -07003029 // look for the thread where the specified audio session is present
3030 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3031 if (mPlaybackThreads.valueAt(i)->hasAudioSession(sessionId) != 0) {
3032 io = mPlaybackThreads.keyAt(i);
3033 break;
3034 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003035 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003036 if (io == AUDIO_IO_HANDLE_NONE) {
Eric Laurenteb3c3372013-09-25 12:25:29 -07003037 for (size_t i = 0; i < mRecordThreads.size(); i++) {
3038 if (mRecordThreads.valueAt(i)->hasAudioSession(sessionId) != 0) {
3039 io = mRecordThreads.keyAt(i);
Glenn Kastene53b9ea2012-03-12 16:29:55 -07003040 break;
3041 }
3042 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003043 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08003044 if (io == AUDIO_IO_HANDLE_NONE) {
3045 for (size_t i = 0; i < mMmapThreads.size(); i++) {
3046 if (mMmapThreads.valueAt(i)->hasAudioSession(sessionId) != 0) {
3047 io = mMmapThreads.keyAt(i);
3048 break;
3049 }
3050 }
3051 }
Eric Laurent84e9a102010-09-23 16:10:16 -07003052 // If no output thread contains the requested session ID, default to
3053 // first output. The effect chain will be moved to the correct output
3054 // thread when a track with the same session ID is created
Glenn Kasten142f5192014-03-25 17:44:59 -07003055 if (io == AUDIO_IO_HANDLE_NONE && mPlaybackThreads.size() > 0) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003056 io = mPlaybackThreads.keyAt(0);
3057 }
Steve Block3856b092011-10-20 11:56:00 +01003058 ALOGV("createEffect() got io %d for effect %s", io, desc.name);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07003059 }
3060 ThreadBase *thread = checkRecordThread_l(io);
3061 if (thread == NULL) {
3062 thread = checkPlaybackThread_l(io);
3063 if (thread == NULL) {
Eric Laurent6acd1d42017-01-04 14:23:29 -08003064 thread = checkMmapThread_l(io);
3065 if (thread == NULL) {
3066 ALOGE("createEffect() unknown output thread");
3067 lStatus = BAD_VALUE;
3068 goto Exit;
3069 }
Eric Laurent84e9a102010-09-23 16:10:16 -07003070 }
Eric Laurentaaa44472014-09-12 17:41:50 -07003071 } else {
3072 // Check if one effect chain was awaiting for an effect to be created on this
3073 // session and used it instead of creating a new one.
Glenn Kastend848eb42016-03-08 13:42:11 -08003074 sp<EffectChain> chain = getOrphanEffectChain_l(sessionId);
Eric Laurentaaa44472014-09-12 17:41:50 -07003075 if (chain != 0) {
Eric Laurent1b928682014-10-02 19:41:47 -07003076 Mutex::Autolock _l(thread->mLock);
Eric Laurentaaa44472014-09-12 17:41:50 -07003077 thread->addEffectChain_l(chain);
3078 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003079 }
Eric Laurent84e9a102010-09-23 16:10:16 -07003080
Eric Laurent021cf962014-05-13 10:18:14 -07003081 sp<Client> client = registerPid(pid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003082
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003083 // create effect on selected output thread
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08003084 bool pinned = (sessionId > AUDIO_SESSION_OUTPUT_MIX) && isSessionAcquired_l(sessionId);
Eric Laurentde070132010-07-13 04:45:46 -07003085 handle = thread->createEffect_l(client, effectClient, priority, sessionId,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08003086 &desc, enabled, &lStatus, pinned);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003087 if (handle != 0 && id != NULL) {
3088 *id = handle->id();
3089 }
Eric Laurentfe1a94e2014-05-26 16:03:08 -07003090 if (handle == 0) {
3091 // remove local strong reference to Client with mClientLock held
3092 Mutex::Autolock _cl(mClientLock);
3093 client.clear();
3094 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003095 }
3096
3097Exit:
Glenn Kasten9156ef32013-08-06 15:39:08 -07003098 *status = lStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003099 return handle;
3100}
3101
Glenn Kastend848eb42016-03-08 13:42:11 -08003102status_t AudioFlinger::moveEffects(audio_session_t sessionId, audio_io_handle_t srcOutput,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003103 audio_io_handle_t dstOutput)
Eric Laurentde070132010-07-13 04:45:46 -07003104{
Steve Block3856b092011-10-20 11:56:00 +01003105 ALOGV("moveEffects() session %d, srcOutput %d, dstOutput %d",
Eric Laurent59255e42011-07-27 19:49:51 -07003106 sessionId, srcOutput, dstOutput);
Eric Laurentde070132010-07-13 04:45:46 -07003107 Mutex::Autolock _l(mLock);
3108 if (srcOutput == dstOutput) {
Steve Block5ff1dd52012-01-05 23:22:43 +00003109 ALOGW("moveEffects() same dst and src outputs %d", dstOutput);
Eric Laurentde070132010-07-13 04:45:46 -07003110 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003111 }
Eric Laurentde070132010-07-13 04:45:46 -07003112 PlaybackThread *srcThread = checkPlaybackThread_l(srcOutput);
3113 if (srcThread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +00003114 ALOGW("moveEffects() bad srcOutput %d", srcOutput);
Eric Laurentde070132010-07-13 04:45:46 -07003115 return BAD_VALUE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003116 }
Eric Laurentde070132010-07-13 04:45:46 -07003117 PlaybackThread *dstThread = checkPlaybackThread_l(dstOutput);
3118 if (dstThread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +00003119 ALOGW("moveEffects() bad dstOutput %d", dstOutput);
Eric Laurentde070132010-07-13 04:45:46 -07003120 return BAD_VALUE;
3121 }
3122
3123 Mutex::Autolock _dl(dstThread->mLock);
3124 Mutex::Autolock _sl(srcThread->mLock);
Eric Laurent5baf2af2013-09-12 17:37:00 -07003125 return moveEffectChain_l(sessionId, srcThread, dstThread, false);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003126}
3127
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003128// moveEffectChain_l must be called with both srcThread and dstThread mLocks held
Glenn Kastend848eb42016-03-08 13:42:11 -08003129status_t AudioFlinger::moveEffectChain_l(audio_session_t sessionId,
Eric Laurentde070132010-07-13 04:45:46 -07003130 AudioFlinger::PlaybackThread *srcThread,
Eric Laurent39e94f82010-07-28 01:32:47 -07003131 AudioFlinger::PlaybackThread *dstThread,
3132 bool reRegister)
Eric Laurentde070132010-07-13 04:45:46 -07003133{
Steve Block3856b092011-10-20 11:56:00 +01003134 ALOGV("moveEffectChain_l() session %d from thread %p to thread %p",
Eric Laurent59255e42011-07-27 19:49:51 -07003135 sessionId, srcThread, dstThread);
Eric Laurentde070132010-07-13 04:45:46 -07003136
Eric Laurent59255e42011-07-27 19:49:51 -07003137 sp<EffectChain> chain = srcThread->getEffectChain_l(sessionId);
Eric Laurentde070132010-07-13 04:45:46 -07003138 if (chain == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00003139 ALOGW("moveEffectChain_l() effect chain for session %d not on source thread %p",
Eric Laurent59255e42011-07-27 19:49:51 -07003140 sessionId, srcThread);
Eric Laurentde070132010-07-13 04:45:46 -07003141 return INVALID_OPERATION;
3142 }
3143
Eric Laurent4c415062016-06-17 16:14:16 -07003144 // Check whether the destination thread and all effects in the chain are compatible
3145 if (!chain->isCompatibleWithThread_l(dstThread)) {
Andy Hung9a592762014-07-21 21:56:01 -07003146 ALOGW("moveEffectChain_l() effect chain failed because"
Eric Laurent4c415062016-06-17 16:14:16 -07003147 " destination thread %p is not compatible with effects in the chain",
3148 dstThread);
Andy Hung9a592762014-07-21 21:56:01 -07003149 return INVALID_OPERATION;
3150 }
3151
Eric Laurent39e94f82010-07-28 01:32:47 -07003152 // remove chain first. This is useful only if reconfiguring effect chain on same output thread,
Eric Laurentde070132010-07-13 04:45:46 -07003153 // so that a new chain is created with correct parameters when first effect is added. This is
Eric Laurentec35a142011-10-05 17:42:25 -07003154 // otherwise unnecessary as removeEffect_l() will remove the chain when last effect is
Eric Laurentde070132010-07-13 04:45:46 -07003155 // removed.
3156 srcThread->removeEffectChain_l(chain);
3157
3158 // transfer all effects one by one so that new effect chain is created on new thread with
3159 // correct buffer sizes and audio parameters and effect engines reconfigured accordingly
Eric Laurent39e94f82010-07-28 01:32:47 -07003160 sp<EffectChain> dstChain;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07003161 uint32_t strategy = 0; // prevent compiler warning
Eric Laurentde070132010-07-13 04:45:46 -07003162 sp<EffectModule> effect = chain->getEffectFromId_l(0);
Eric Laurent5baf2af2013-09-12 17:37:00 -07003163 Vector< sp<EffectModule> > removed;
3164 status_t status = NO_ERROR;
Eric Laurentde070132010-07-13 04:45:46 -07003165 while (effect != 0) {
3166 srcThread->removeEffect_l(effect);
Eric Laurent5baf2af2013-09-12 17:37:00 -07003167 removed.add(effect);
3168 status = dstThread->addEffect_l(effect);
3169 if (status != NO_ERROR) {
3170 break;
3171 }
Eric Laurentec35a142011-10-05 17:42:25 -07003172 // removeEffect_l() has stopped the effect if it was active so it must be restarted
3173 if (effect->state() == EffectModule::ACTIVE ||
3174 effect->state() == EffectModule::STOPPING) {
3175 effect->start();
3176 }
Eric Laurent39e94f82010-07-28 01:32:47 -07003177 // if the move request is not received from audio policy manager, the effect must be
3178 // re-registered with the new strategy and output
3179 if (dstChain == 0) {
3180 dstChain = effect->chain().promote();
3181 if (dstChain == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00003182 ALOGW("moveEffectChain_l() cannot get chain from effect %p", effect.get());
Eric Laurent5baf2af2013-09-12 17:37:00 -07003183 status = NO_INIT;
3184 break;
Eric Laurent39e94f82010-07-28 01:32:47 -07003185 }
3186 strategy = dstChain->strategy();
3187 }
3188 if (reRegister) {
3189 AudioSystem::unregisterEffect(effect->id());
3190 AudioSystem::registerEffect(&effect->desc(),
Eric Laurent5baf2af2013-09-12 17:37:00 -07003191 dstThread->id(),
Eric Laurent39e94f82010-07-28 01:32:47 -07003192 strategy,
Eric Laurent59255e42011-07-27 19:49:51 -07003193 sessionId,
Eric Laurent39e94f82010-07-28 01:32:47 -07003194 effect->id());
Eric Laurentd72b7c02013-10-12 16:17:46 -07003195 AudioSystem::setEffectEnabled(effect->id(), effect->isEnabled());
Eric Laurent39e94f82010-07-28 01:32:47 -07003196 }
Eric Laurentde070132010-07-13 04:45:46 -07003197 effect = chain->getEffectFromId_l(0);
3198 }
3199
Eric Laurent5baf2af2013-09-12 17:37:00 -07003200 if (status != NO_ERROR) {
3201 for (size_t i = 0; i < removed.size(); i++) {
3202 srcThread->addEffect_l(removed[i]);
3203 if (dstChain != 0 && reRegister) {
3204 AudioSystem::unregisterEffect(removed[i]->id());
3205 AudioSystem::registerEffect(&removed[i]->desc(),
3206 srcThread->id(),
3207 strategy,
3208 sessionId,
3209 removed[i]->id());
Eric Laurentd72b7c02013-10-12 16:17:46 -07003210 AudioSystem::setEffectEnabled(effect->id(), effect->isEnabled());
Eric Laurent5baf2af2013-09-12 17:37:00 -07003211 }
3212 }
3213 }
3214
3215 return status;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003216}
3217
Eric Laurent5baf2af2013-09-12 17:37:00 -07003218bool AudioFlinger::isNonOffloadableGlobalEffectEnabled_l()
Eric Laurent813e2a72013-08-31 12:59:48 -07003219{
3220 if (mGlobalEffectEnableTime != 0 &&
3221 ((systemTime() - mGlobalEffectEnableTime) < kMinGlobalEffectEnabletimeNs)) {
3222 return true;
3223 }
3224
3225 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3226 sp<EffectChain> ec =
3227 mPlaybackThreads.valueAt(i)->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
Eric Laurent5baf2af2013-09-12 17:37:00 -07003228 if (ec != 0 && ec->isNonOffloadableEnabled()) {
Eric Laurent813e2a72013-08-31 12:59:48 -07003229 return true;
3230 }
3231 }
3232 return false;
3233}
3234
Eric Laurent5baf2af2013-09-12 17:37:00 -07003235void AudioFlinger::onNonOffloadableGlobalEffectEnable()
Eric Laurent813e2a72013-08-31 12:59:48 -07003236{
3237 Mutex::Autolock _l(mLock);
3238
3239 mGlobalEffectEnableTime = systemTime();
3240
3241 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
3242 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
3243 if (t->mType == ThreadBase::OFFLOAD) {
3244 t->invalidateTracks(AUDIO_STREAM_MUSIC);
3245 }
3246 }
3247
3248}
3249
Eric Laurentaaa44472014-09-12 17:41:50 -07003250status_t AudioFlinger::putOrphanEffectChain_l(const sp<AudioFlinger::EffectChain>& chain)
3251{
Eric Laurentd8365c52017-07-16 15:27:05 -07003252 // clear possible suspended state before parking the chain so that it starts in default state
3253 // when attached to a new record thread
3254 chain->setEffectSuspended_l(FX_IID_AEC, false);
3255 chain->setEffectSuspended_l(FX_IID_NS, false);
3256
Glenn Kastend848eb42016-03-08 13:42:11 -08003257 audio_session_t session = chain->sessionId();
Eric Laurentaaa44472014-09-12 17:41:50 -07003258 ssize_t index = mOrphanEffectChains.indexOfKey(session);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07003259 ALOGV("putOrphanEffectChain_l session %d index %zd", session, index);
Eric Laurentaaa44472014-09-12 17:41:50 -07003260 if (index >= 0) {
3261 ALOGW("putOrphanEffectChain_l chain for session %d already present", session);
3262 return ALREADY_EXISTS;
3263 }
3264 mOrphanEffectChains.add(session, chain);
3265 return NO_ERROR;
3266}
3267
3268sp<AudioFlinger::EffectChain> AudioFlinger::getOrphanEffectChain_l(audio_session_t session)
3269{
3270 sp<EffectChain> chain;
3271 ssize_t index = mOrphanEffectChains.indexOfKey(session);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07003272 ALOGV("getOrphanEffectChain_l session %d index %zd", session, index);
Eric Laurentaaa44472014-09-12 17:41:50 -07003273 if (index >= 0) {
3274 chain = mOrphanEffectChains.valueAt(index);
3275 mOrphanEffectChains.removeItemsAt(index);
3276 }
3277 return chain;
3278}
3279
3280bool AudioFlinger::updateOrphanEffectChains(const sp<AudioFlinger::EffectModule>& effect)
3281{
3282 Mutex::Autolock _l(mLock);
Glenn Kastend848eb42016-03-08 13:42:11 -08003283 audio_session_t session = effect->sessionId();
Eric Laurentaaa44472014-09-12 17:41:50 -07003284 ssize_t index = mOrphanEffectChains.indexOfKey(session);
Glenn Kastenc42e9b42016-03-21 11:35:03 -07003285 ALOGV("updateOrphanEffectChains session %d index %zd", session, index);
Eric Laurentaaa44472014-09-12 17:41:50 -07003286 if (index >= 0) {
3287 sp<EffectChain> chain = mOrphanEffectChains.valueAt(index);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -08003288 if (chain->removeEffect_l(effect, true) == 0) {
Glenn Kastenc42e9b42016-03-21 11:35:03 -07003289 ALOGV("updateOrphanEffectChains removing effect chain at index %zd", index);
Eric Laurentaaa44472014-09-12 17:41:50 -07003290 mOrphanEffectChains.removeItemsAt(index);
3291 }
3292 return true;
3293 }
3294 return false;
3295}
3296
3297
Glenn Kastenda6ef132013-01-10 12:31:01 -08003298struct Entry {
Glenn Kasten2f55e762015-03-05 16:05:08 -08003299#define TEE_MAX_FILENAME 32 // %Y%m%d%H%M%S_%d.wav = 4+2+2+2+2+2+1+1+4+1 = 21
3300 char mFileName[TEE_MAX_FILENAME];
Glenn Kastenda6ef132013-01-10 12:31:01 -08003301};
3302
3303int comparEntry(const void *p1, const void *p2)
3304{
Glenn Kasten2f55e762015-03-05 16:05:08 -08003305 return strcmp(((const Entry *) p1)->mFileName, ((const Entry *) p2)->mFileName);
Glenn Kastenda6ef132013-01-10 12:31:01 -08003306}
3307
Glenn Kasten46909e72013-02-26 09:20:22 -08003308#ifdef TEE_SINK
Glenn Kasten5b2191a2016-08-19 11:44:47 -07003309void AudioFlinger::dumpTee(int fd, const sp<NBAIO_Source>& source, audio_io_handle_t id, char suffix)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003310{
Eric Laurent81784c32012-11-19 14:55:58 -08003311 NBAIO_Source *teeSource = source.get();
3312 if (teeSource != NULL) {
Glenn Kastenda6ef132013-01-10 12:31:01 -08003313 // .wav rotation
3314 // There is a benign race condition if 2 threads call this simultaneously.
3315 // They would both traverse the directory, but the result would simply be
3316 // failures at unlink() which are ignored. It's also unlikely since
3317 // normally dumpsys is only done by bugreport or from the command line.
3318 char teePath[32+256];
Glenn Kasten9a003992016-02-23 15:24:34 -08003319 strcpy(teePath, "/data/misc/audioserver");
Glenn Kastenda6ef132013-01-10 12:31:01 -08003320 size_t teePathLen = strlen(teePath);
3321 DIR *dir = opendir(teePath);
3322 teePath[teePathLen++] = '/';
3323 if (dir != NULL) {
Glenn Kasten2f55e762015-03-05 16:05:08 -08003324#define TEE_MAX_SORT 20 // number of entries to sort
3325#define TEE_MAX_KEEP 10 // number of entries to keep
3326 struct Entry entries[TEE_MAX_SORT];
Glenn Kastenda6ef132013-01-10 12:31:01 -08003327 size_t entryCount = 0;
Glenn Kasten2f55e762015-03-05 16:05:08 -08003328 while (entryCount < TEE_MAX_SORT) {
Glenn Kastenda6ef132013-01-10 12:31:01 -08003329 struct dirent de;
3330 struct dirent *result = NULL;
3331 int rc = readdir_r(dir, &de, &result);
3332 if (rc != 0) {
3333 ALOGW("readdir_r failed %d", rc);
3334 break;
3335 }
3336 if (result == NULL) {
3337 break;
3338 }
3339 if (result != &de) {
3340 ALOGW("readdir_r returned unexpected result %p != %p", result, &de);
3341 break;
3342 }
3343 // ignore non .wav file entries
3344 size_t nameLen = strlen(de.d_name);
Glenn Kasten2f55e762015-03-05 16:05:08 -08003345 if (nameLen <= 4 || nameLen >= TEE_MAX_FILENAME ||
Glenn Kastenda6ef132013-01-10 12:31:01 -08003346 strcmp(&de.d_name[nameLen - 4], ".wav")) {
3347 continue;
3348 }
Glenn Kasten2f55e762015-03-05 16:05:08 -08003349 strcpy(entries[entryCount++].mFileName, de.d_name);
Glenn Kastenda6ef132013-01-10 12:31:01 -08003350 }
3351 (void) closedir(dir);
Glenn Kasten2f55e762015-03-05 16:05:08 -08003352 if (entryCount > TEE_MAX_KEEP) {
Glenn Kastenda6ef132013-01-10 12:31:01 -08003353 qsort(entries, entryCount, sizeof(Entry), comparEntry);
Glenn Kasten2f55e762015-03-05 16:05:08 -08003354 for (size_t i = 0; i < entryCount - TEE_MAX_KEEP; ++i) {
3355 strcpy(&teePath[teePathLen], entries[i].mFileName);
Glenn Kastenda6ef132013-01-10 12:31:01 -08003356 (void) unlink(teePath);
3357 }
3358 }
3359 } else {
3360 if (fd >= 0) {
Glenn Kastenfbd87e82016-07-18 15:45:56 -07003361 dprintf(fd, "unable to rotate tees in %.*s: %s\n", (int) teePathLen, teePath,
Glenn Kasten9a003992016-02-23 15:24:34 -08003362 strerror(errno));
Glenn Kastenda6ef132013-01-10 12:31:01 -08003363 }
3364 }
Eric Laurent81784c32012-11-19 14:55:58 -08003365 char teeTime[16];
3366 struct timeval tv;
3367 gettimeofday(&tv, NULL);
3368 struct tm tm;
3369 localtime_r(&tv.tv_sec, &tm);
Glenn Kastenda6ef132013-01-10 12:31:01 -08003370 strftime(teeTime, sizeof(teeTime), "%Y%m%d%H%M%S", &tm);
Glenn Kasten5b2191a2016-08-19 11:44:47 -07003371 snprintf(&teePath[teePathLen], sizeof(teePath) - teePathLen, "%s_%d_%c.wav", teeTime, id,
3372 suffix);
Glenn Kastenda6ef132013-01-10 12:31:01 -08003373 // if 2 dumpsys are done within 1 second, and rotation didn't work, then discard 2nd
3374 int teeFd = open(teePath, O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW, S_IRUSR | S_IWUSR);
Eric Laurent81784c32012-11-19 14:55:58 -08003375 if (teeFd >= 0) {
Glenn Kasten329f6512014-08-28 16:23:16 -07003376 // FIXME use libsndfile
Eric Laurent81784c32012-11-19 14:55:58 -08003377 char wavHeader[44];
3378 memcpy(wavHeader,
3379 "RIFF\0\0\0\0WAVEfmt \20\0\0\0\1\0\2\0\104\254\0\0\0\0\0\0\4\0\20\0data\0\0\0\0",
3380 sizeof(wavHeader));
3381 NBAIO_Format format = teeSource->format();
3382 unsigned channelCount = Format_channelCount(format);
Eric Laurent81784c32012-11-19 14:55:58 -08003383 uint32_t sampleRate = Format_sampleRate(format);
Glenn Kasten329f6512014-08-28 16:23:16 -07003384 size_t frameSize = Format_frameSize(format);
Eric Laurent81784c32012-11-19 14:55:58 -08003385 wavHeader[22] = channelCount; // number of channels
3386 wavHeader[24] = sampleRate; // sample rate
3387 wavHeader[25] = sampleRate >> 8;
Glenn Kasten329f6512014-08-28 16:23:16 -07003388 wavHeader[32] = frameSize; // block alignment
3389 wavHeader[33] = frameSize >> 8;
Eric Laurent81784c32012-11-19 14:55:58 -08003390 write(teeFd, wavHeader, sizeof(wavHeader));
3391 size_t total = 0;
3392 bool firstRead = true;
Glenn Kasten329f6512014-08-28 16:23:16 -07003393#define TEE_SINK_READ 1024 // frames per I/O operation
3394 void *buffer = malloc(TEE_SINK_READ * frameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08003395 for (;;) {
Eric Laurent81784c32012-11-19 14:55:58 -08003396 size_t count = TEE_SINK_READ;
Glenn Kastend79072e2016-01-06 08:41:20 -08003397 ssize_t actual = teeSource->read(buffer, count);
Eric Laurent81784c32012-11-19 14:55:58 -08003398 bool wasFirstRead = firstRead;
3399 firstRead = false;
3400 if (actual <= 0) {
3401 if (actual == (ssize_t) OVERRUN && wasFirstRead) {
3402 continue;
Eric Laurent59255e42011-07-27 19:49:51 -07003403 }
Eric Laurent81784c32012-11-19 14:55:58 -08003404 break;
Eric Laurent59255e42011-07-27 19:49:51 -07003405 }
Eric Laurent81784c32012-11-19 14:55:58 -08003406 ALOG_ASSERT(actual <= (ssize_t)count);
Glenn Kasten329f6512014-08-28 16:23:16 -07003407 write(teeFd, buffer, actual * frameSize);
Eric Laurent81784c32012-11-19 14:55:58 -08003408 total += actual;
Eric Laurent59255e42011-07-27 19:49:51 -07003409 }
Glenn Kasten329f6512014-08-28 16:23:16 -07003410 free(buffer);
Eric Laurent81784c32012-11-19 14:55:58 -08003411 lseek(teeFd, (off_t) 4, SEEK_SET);
Glenn Kasten329f6512014-08-28 16:23:16 -07003412 uint32_t temp = 44 + total * frameSize - 8;
3413 // FIXME not big-endian safe
Eric Laurent81784c32012-11-19 14:55:58 -08003414 write(teeFd, &temp, sizeof(temp));
3415 lseek(teeFd, (off_t) 40, SEEK_SET);
Glenn Kasten329f6512014-08-28 16:23:16 -07003416 temp = total * frameSize;
3417 // FIXME not big-endian safe
Eric Laurent81784c32012-11-19 14:55:58 -08003418 write(teeFd, &temp, sizeof(temp));
3419 close(teeFd);
Glenn Kastenda6ef132013-01-10 12:31:01 -08003420 if (fd >= 0) {
Elliott Hughes8b5f6422014-05-22 01:22:06 -07003421 dprintf(fd, "tee copied to %s\n", teePath);
Glenn Kastenda6ef132013-01-10 12:31:01 -08003422 }
Eric Laurent59255e42011-07-27 19:49:51 -07003423 } else {
Glenn Kastenda6ef132013-01-10 12:31:01 -08003424 if (fd >= 0) {
Elliott Hughes8b5f6422014-05-22 01:22:06 -07003425 dprintf(fd, "unable to create tee %s: %s\n", teePath, strerror(errno));
Glenn Kastenda6ef132013-01-10 12:31:01 -08003426 }
Eric Laurent59255e42011-07-27 19:49:51 -07003427 }
3428 }
3429}
Glenn Kasten46909e72013-02-26 09:20:22 -08003430#endif
Eric Laurent59255e42011-07-27 19:49:51 -07003431
Mathias Agopian65ab4712010-07-14 17:59:35 -07003432// ----------------------------------------------------------------------------
3433
3434status_t AudioFlinger::onTransact(
3435 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
3436{
3437 return BnAudioFlinger::onTransact(code, data, reply, flags);
3438}
3439
Glenn Kasten63238ef2015-03-02 15:50:29 -08003440} // namespace android