blob: aba93d0474a2ab411ffdbef0746f2893b9be5f68 [file] [log] [blame]
Eric Laurente552edb2014-03-10 17:42:56 -07001/*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -070017#define LOG_TAG "APM_AudioPolicyManager"
Eric Laurente552edb2014-03-10 17:42:56 -070018//#define LOG_NDEBUG 0
19
20//#define VERY_VERBOSE_LOGGING
21#ifdef VERY_VERBOSE_LOGGING
22#define ALOGVV ALOGV
23#else
24#define ALOGVV(a...) do { } while(0)
25#endif
26
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +090027#define AUDIO_POLICY_XML_CONFIG_FILE_PATH_MAX_LENGTH 128
28#define AUDIO_POLICY_XML_CONFIG_FILE_NAME "audio_policy_configuration.xml"
Petri Gynther150b9842018-04-17 18:46:10 -070029#define AUDIO_POLICY_A2DP_OFFLOAD_DISABLED_XML_CONFIG_FILE_NAME \
30 "audio_policy_configuration_a2dp_offload_disabled.xml"
François Gaffief4ad6e52015-11-19 16:59:57 +010031
Eric Laurentd4692962014-05-05 18:13:44 -070032#include <inttypes.h>
Eric Laurente552edb2014-03-10 17:42:56 -070033#include <math.h>
Eric Laurentd4692962014-05-05 18:13:44 -070034
François Gaffie2110e042015-03-24 08:41:51 +010035#include <AudioPolicyManagerInterface.h>
36#include <AudioPolicyEngineInstance.h>
Eric Laurente552edb2014-03-10 17:42:56 -070037#include <cutils/properties.h>
Eric Laurentd4692962014-05-05 18:13:44 -070038#include <utils/Log.h>
Eric Laurent3b73df72014-03-11 09:06:29 -070039#include <media/AudioParameter.h>
Eric Laurente83b55d2014-11-14 10:06:21 -080040#include <media/AudioPolicyHelper.h>
Eric Laurentdf3dc7e2014-07-27 18:39:40 -070041#include <soundtrigger/SoundTrigger.h>
Mikhail Naganovcbc8f612016-10-11 18:05:13 -070042#include <system/audio.h>
Mikhail Naganov9ee05402016-10-13 15:58:17 -070043#include <audio_policy_conf.h>
Eric Laurentd4692962014-05-05 18:13:44 -070044#include "AudioPolicyManager.h"
François Gaffied1ab2bd2015-12-02 18:20:06 +010045#ifndef USE_XML_AUDIO_POLICY_CONF
François Gaffie53615e22015-03-19 09:24:12 +010046#include <ConfigParsingUtils.h>
François Gaffied1ab2bd2015-12-02 18:20:06 +010047#include <StreamDescriptor.h>
François Gaffief4ad6e52015-11-19 16:59:57 +010048#endif
François Gaffied1ab2bd2015-12-02 18:20:06 +010049#include <Serializer.h>
François Gaffiea8ecc2c2015-11-09 16:10:40 +010050#include "TypeConverter.h"
François Gaffie53615e22015-03-19 09:24:12 +010051#include <policy.h>
Eric Laurente552edb2014-03-10 17:42:56 -070052
Eric Laurent3b73df72014-03-11 09:06:29 -070053namespace android {
Eric Laurente552edb2014-03-10 17:42:56 -070054
Eric Laurentdc462862016-07-19 12:29:53 -070055//FIXME: workaround for truncated touch sounds
56// to be removed when the problem is handled by system UI
57#define TOUCH_SOUND_FIXED_DELAY_MS 100
Jean-Michel Trivi719a9872017-08-05 13:51:35 -070058
59// Largest difference in dB on earpiece in call between the voice volume and another
60// media / notification / system volume.
61constexpr float IN_CALL_EARPIECE_HEADROOM_DB = 3.f;
62
Eric Laurente552edb2014-03-10 17:42:56 -070063// ----------------------------------------------------------------------------
64// AudioPolicyInterface implementation
65// ----------------------------------------------------------------------------
66
Eric Laurente0720872014-03-11 09:30:41 -070067status_t AudioPolicyManager::setDeviceConnectionState(audio_devices_t device,
Paul McLeane743a472015-01-28 11:07:31 -080068 audio_policy_dev_state_t state,
69 const char *device_address,
70 const char *device_name)
Eric Laurente552edb2014-03-10 17:42:56 -070071{
jiabina7b43792018-02-15 16:04:46 -080072 status_t status = setDeviceConnectionStateInt(device, state, device_address, device_name);
73 nextAudioPortGeneration();
74 return status;
Eric Laurentc73ca6e2014-12-12 14:34:22 -080075}
76
François Gaffie44481e72016-04-20 07:49:57 +020077void AudioPolicyManager::broadcastDeviceConnectionState(audio_devices_t device,
78 audio_policy_dev_state_t state,
79 const String8 &device_address)
80{
81 AudioParameter param(device_address);
82 const String8 key(state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE ?
Mikhail Naganov388360c2016-10-17 17:09:41 -070083 AudioParameter::keyStreamConnect : AudioParameter::keyStreamDisconnect);
François Gaffie44481e72016-04-20 07:49:57 +020084 param.addInt(key, device);
85 mpClientInterface->setParameters(AUDIO_IO_HANDLE_NONE, param.toString());
86}
87
Eric Laurentc73ca6e2014-12-12 14:34:22 -080088status_t AudioPolicyManager::setDeviceConnectionStateInt(audio_devices_t device,
Eric Laurenta1d525f2015-01-29 13:36:45 -080089 audio_policy_dev_state_t state,
Paul McLeane743a472015-01-28 11:07:31 -080090 const char *device_address,
91 const char *device_name)
Eric Laurentc73ca6e2014-12-12 14:34:22 -080092{
Paul McLeane743a472015-01-28 11:07:31 -080093 ALOGV("setDeviceConnectionStateInt() device: 0x%X, state %d, address %s name %s",
Mikhail Naganov7e22e942017-12-07 10:04:29 -080094 device, state, device_address, device_name);
Eric Laurente552edb2014-03-10 17:42:56 -070095
96 // connect/disconnect only 1 device at a time
97 if (!audio_is_output_device(device) && !audio_is_input_device(device)) return BAD_VALUE;
98
François Gaffie53615e22015-03-19 09:24:12 +010099 sp<DeviceDescriptor> devDesc =
100 mHwModules.getDeviceDescriptor(device, device_address, device_name);
Paul McLeane743a472015-01-28 11:07:31 -0800101
Eric Laurente552edb2014-03-10 17:42:56 -0700102 // handle output devices
103 if (audio_is_output_device(device)) {
Eric Laurentd4692962014-05-05 18:13:44 -0700104 SortedVector <audio_io_handle_t> outputs;
105
Eric Laurent3a4311c2014-03-17 12:00:47 -0700106 ssize_t index = mAvailableOutputDevices.indexOf(devDesc);
107
Eric Laurente552edb2014-03-10 17:42:56 -0700108 // save a copy of the opened output descriptors before any output is opened or closed
109 // by checkOutputsForDevice(). This will be needed by checkOutputForAllStrategies()
110 mPreviousOutputs = mOutputs;
Eric Laurente552edb2014-03-10 17:42:56 -0700111 switch (state)
112 {
113 // handle output device connection
Eric Laurent3ae5f312015-02-03 17:12:08 -0800114 case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700115 if (index >= 0) {
Eric Laurente552edb2014-03-10 17:42:56 -0700116 ALOGW("setDeviceConnectionState() device already connected: %x", device);
117 return INVALID_OPERATION;
118 }
119 ALOGV("setDeviceConnectionState() connecting device %x", device);
120
Eric Laurente552edb2014-03-10 17:42:56 -0700121 // register new device as available
Eric Laurent3a4311c2014-03-17 12:00:47 -0700122 index = mAvailableOutputDevices.add(devDesc);
123 if (index >= 0) {
François Gaffie53615e22015-03-19 09:24:12 +0100124 sp<HwModule> module = mHwModules.getModuleForDevice(device);
Eric Laurentcf817a22014-08-04 20:36:31 -0700125 if (module == 0) {
126 ALOGD("setDeviceConnectionState() could not find HW module for device %08x",
127 device);
128 mAvailableOutputDevices.remove(devDesc);
129 return INVALID_OPERATION;
130 }
Paul McLeane743a472015-01-28 11:07:31 -0800131 mAvailableOutputDevices[index]->attach(module);
Eric Laurent3a4311c2014-03-17 12:00:47 -0700132 } else {
133 return NO_MEMORY;
Eric Laurente552edb2014-03-10 17:42:56 -0700134 }
135
François Gaffie44481e72016-04-20 07:49:57 +0200136 // Before checking outputs, broadcast connect event to allow HAL to retrieve dynamic
137 // parameters on newly connected devices (instead of opening the outputs...)
138 broadcastDeviceConnectionState(device, state, devDesc->mAddress);
139
Eric Laurenta1d525f2015-01-29 13:36:45 -0800140 if (checkOutputsForDevice(devDesc, state, outputs, devDesc->mAddress) != NO_ERROR) {
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -0700141 mAvailableOutputDevices.remove(devDesc);
François Gaffie44481e72016-04-20 07:49:57 +0200142
143 broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
144 devDesc->mAddress);
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -0700145 return INVALID_OPERATION;
146 }
François Gaffie2110e042015-03-24 08:41:51 +0100147 // Propagate device availability to Engine
148 mEngine->setDeviceConnectionState(devDesc, state);
149
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -0700150 // outputs should never be empty here
151 ALOG_ASSERT(outputs.size() != 0, "setDeviceConnectionState():"
152 "checkOutputsForDevice() returned no outputs but status OK");
153 ALOGV("setDeviceConnectionState() checkOutputsForDevice() returned %zu outputs",
154 outputs.size());
Eric Laurent3ae5f312015-02-03 17:12:08 -0800155
Eric Laurent3ae5f312015-02-03 17:12:08 -0800156 } break;
Eric Laurente552edb2014-03-10 17:42:56 -0700157 // handle output device disconnection
Eric Laurent3b73df72014-03-11 09:06:29 -0700158 case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700159 if (index < 0) {
Eric Laurente552edb2014-03-10 17:42:56 -0700160 ALOGW("setDeviceConnectionState() device not connected: %x", device);
161 return INVALID_OPERATION;
162 }
163
Paul McLean5c477aa2014-08-20 16:47:57 -0700164 ALOGV("setDeviceConnectionState() disconnecting output device %x", device);
165
Paul McLeane743a472015-01-28 11:07:31 -0800166 // Send Disconnect to HALs
François Gaffie44481e72016-04-20 07:49:57 +0200167 broadcastDeviceConnectionState(device, state, devDesc->mAddress);
Paul McLean5c477aa2014-08-20 16:47:57 -0700168
Eric Laurente552edb2014-03-10 17:42:56 -0700169 // remove device from available output devices
Eric Laurent3a4311c2014-03-17 12:00:47 -0700170 mAvailableOutputDevices.remove(devDesc);
Eric Laurente552edb2014-03-10 17:42:56 -0700171
Eric Laurenta1d525f2015-01-29 13:36:45 -0800172 checkOutputsForDevice(devDesc, state, outputs, devDesc->mAddress);
François Gaffie2110e042015-03-24 08:41:51 +0100173
174 // Propagate device availability to Engine
175 mEngine->setDeviceConnectionState(devDesc, state);
Eric Laurente552edb2014-03-10 17:42:56 -0700176 } break;
177
178 default:
179 ALOGE("setDeviceConnectionState() invalid state: %x", state);
180 return BAD_VALUE;
181 }
182
Eric Laurent3a4311c2014-03-17 12:00:47 -0700183 // checkA2dpSuspend must run before checkOutputForAllStrategies so that A2DP
184 // output is suspended before any tracks are moved to it
Eric Laurente552edb2014-03-10 17:42:56 -0700185 checkA2dpSuspend();
186 checkOutputForAllStrategies();
187 // outputs must be closed after checkOutputForAllStrategies() is executed
188 if (!outputs.isEmpty()) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -0800189 for (audio_io_handle_t output : outputs) {
190 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
Eric Laurente552edb2014-03-10 17:42:56 -0700191 // close unused outputs after device disconnection or direct outputs that have been
192 // opened by checkOutputsForDevice() to query dynamic parameters
Eric Laurent3b73df72014-03-11 09:06:29 -0700193 if ((state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) ||
Eric Laurente552edb2014-03-10 17:42:56 -0700194 (((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) &&
195 (desc->mDirectOpenCount == 0))) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -0800196 closeOutput(output);
Eric Laurente552edb2014-03-10 17:42:56 -0700197 }
198 }
Eric Laurent3a4311c2014-03-17 12:00:47 -0700199 // check again after closing A2DP output to reset mA2dpSuspended if needed
200 checkA2dpSuspend();
Eric Laurente552edb2014-03-10 17:42:56 -0700201 }
202
203 updateDevicesAndOutputs();
Eric Laurent87ffa392015-05-22 10:32:38 -0700204 if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
Eric Laurentc2730ba2014-07-20 15:47:07 -0700205 audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
206 updateCallRouting(newDevice);
207 }
Eric Laurente552edb2014-03-10 17:42:56 -0700208 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -0700209 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
210 if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) || (desc != mPrimaryOutput)) {
211 audio_devices_t newDevice = getNewOutputDevice(desc, true /*fromCache*/);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700212 // do not force device change on duplicated output because if device is 0, it will
213 // also force a device 0 for the two outputs it is duplicated to which may override
214 // a valid device selection on those outputs.
Eric Laurentc75307b2015-03-17 15:29:32 -0700215 bool force = !desc->isDuplicated()
François Gaffie53615e22015-03-19 09:24:12 +0100216 && (!device_distinguishes_on_address(device)
Eric Laurentc2730ba2014-07-20 15:47:07 -0700217 // always force when disconnecting (a non-duplicated device)
218 || (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
Eric Laurentc75307b2015-03-17 15:29:32 -0700219 setOutputDevice(desc, newDevice, force, 0);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700220 }
Eric Laurente552edb2014-03-10 17:42:56 -0700221 }
222
Eric Laurentd60560a2015-04-10 11:31:20 -0700223 if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
224 cleanUpForDevice(devDesc);
225 }
226
Eric Laurent72aa32f2014-05-30 18:51:48 -0700227 mpClientInterface->onAudioPortListUpdate();
Eric Laurentb71e58b2014-05-29 16:08:11 -0700228 return NO_ERROR;
Eric Laurentd4692962014-05-05 18:13:44 -0700229 } // end if is output device
230
Eric Laurente552edb2014-03-10 17:42:56 -0700231 // handle input devices
232 if (audio_is_input_device(device)) {
Eric Laurentd4692962014-05-05 18:13:44 -0700233 SortedVector <audio_io_handle_t> inputs;
234
Eric Laurent3a4311c2014-03-17 12:00:47 -0700235 ssize_t index = mAvailableInputDevices.indexOf(devDesc);
Eric Laurente552edb2014-03-10 17:42:56 -0700236 switch (state)
237 {
238 // handle input device connection
Eric Laurent3b73df72014-03-11 09:06:29 -0700239 case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700240 if (index >= 0) {
Eric Laurente552edb2014-03-10 17:42:56 -0700241 ALOGW("setDeviceConnectionState() device already connected: %d", device);
242 return INVALID_OPERATION;
243 }
François Gaffie53615e22015-03-19 09:24:12 +0100244 sp<HwModule> module = mHwModules.getModuleForDevice(device);
Eric Laurent6a94d692014-05-20 11:18:06 -0700245 if (module == NULL) {
246 ALOGW("setDeviceConnectionState(): could not find HW module for device %08x",
247 device);
248 return INVALID_OPERATION;
249 }
François Gaffie44481e72016-04-20 07:49:57 +0200250
251 // Before checking intputs, broadcast connect event to allow HAL to retrieve dynamic
252 // parameters on newly connected devices (instead of opening the inputs...)
253 broadcastDeviceConnectionState(device, state, devDesc->mAddress);
254
Paul McLean9080a4c2015-06-18 08:24:02 -0700255 if (checkInputsForDevice(devDesc, state, inputs, devDesc->mAddress) != NO_ERROR) {
François Gaffie44481e72016-04-20 07:49:57 +0200256 broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
257 devDesc->mAddress);
Eric Laurentd4692962014-05-05 18:13:44 -0700258 return INVALID_OPERATION;
259 }
260
Eric Laurent3a4311c2014-03-17 12:00:47 -0700261 index = mAvailableInputDevices.add(devDesc);
262 if (index >= 0) {
Paul McLeane743a472015-01-28 11:07:31 -0800263 mAvailableInputDevices[index]->attach(module);
Eric Laurent3a4311c2014-03-17 12:00:47 -0700264 } else {
265 return NO_MEMORY;
266 }
Eric Laurent3ae5f312015-02-03 17:12:08 -0800267
François Gaffie2110e042015-03-24 08:41:51 +0100268 // Propagate device availability to Engine
269 mEngine->setDeviceConnectionState(devDesc, state);
Eric Laurentd4692962014-05-05 18:13:44 -0700270 } break;
Eric Laurente552edb2014-03-10 17:42:56 -0700271
272 // handle input device disconnection
Eric Laurent3b73df72014-03-11 09:06:29 -0700273 case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700274 if (index < 0) {
Eric Laurente552edb2014-03-10 17:42:56 -0700275 ALOGW("setDeviceConnectionState() device not connected: %d", device);
276 return INVALID_OPERATION;
277 }
Paul McLean5c477aa2014-08-20 16:47:57 -0700278
279 ALOGV("setDeviceConnectionState() disconnecting input device %x", device);
280
281 // Set Disconnect to HALs
François Gaffie44481e72016-04-20 07:49:57 +0200282 broadcastDeviceConnectionState(device, state, devDesc->mAddress);
Paul McLean5c477aa2014-08-20 16:47:57 -0700283
Paul McLean9080a4c2015-06-18 08:24:02 -0700284 checkInputsForDevice(devDesc, state, inputs, devDesc->mAddress);
Eric Laurent3a4311c2014-03-17 12:00:47 -0700285 mAvailableInputDevices.remove(devDesc);
Paul McLean5c477aa2014-08-20 16:47:57 -0700286
François Gaffie2110e042015-03-24 08:41:51 +0100287 // Propagate device availability to Engine
288 mEngine->setDeviceConnectionState(devDesc, state);
Eric Laurentd4692962014-05-05 18:13:44 -0700289 } break;
Eric Laurente552edb2014-03-10 17:42:56 -0700290
291 default:
292 ALOGE("setDeviceConnectionState() invalid state: %x", state);
293 return BAD_VALUE;
294 }
295
Eric Laurentd4692962014-05-05 18:13:44 -0700296 closeAllInputs();
Eric Laurent5f5fca52016-08-04 11:48:57 -0700297 // As the input device list can impact the output device selection, update
298 // getDeviceForStrategy() cache
299 updateDevicesAndOutputs();
Eric Laurente552edb2014-03-10 17:42:56 -0700300
Eric Laurent87ffa392015-05-22 10:32:38 -0700301 if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
Eric Laurentc2730ba2014-07-20 15:47:07 -0700302 audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
303 updateCallRouting(newDevice);
304 }
305
Eric Laurentd60560a2015-04-10 11:31:20 -0700306 if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
307 cleanUpForDevice(devDesc);
308 }
309
Eric Laurentb52c1522014-05-20 11:27:36 -0700310 mpClientInterface->onAudioPortListUpdate();
Eric Laurente552edb2014-03-10 17:42:56 -0700311 return NO_ERROR;
Eric Laurentd4692962014-05-05 18:13:44 -0700312 } // end if is input device
Eric Laurente552edb2014-03-10 17:42:56 -0700313
314 ALOGW("setDeviceConnectionState() invalid device: %x", device);
315 return BAD_VALUE;
316}
317
Eric Laurente0720872014-03-11 09:30:41 -0700318audio_policy_dev_state_t AudioPolicyManager::getDeviceConnectionState(audio_devices_t device,
François Gaffie53615e22015-03-19 09:24:12 +0100319 const char *device_address)
Eric Laurente552edb2014-03-10 17:42:56 -0700320{
Eric Laurent634b7142016-04-20 13:48:02 -0700321 sp<DeviceDescriptor> devDesc =
322 mHwModules.getDeviceDescriptor(device, device_address, "",
323 (strlen(device_address) != 0)/*matchAddress*/);
324
325 if (devDesc == 0) {
326 ALOGW("getDeviceConnectionState() undeclared device, type %08x, address: %s",
327 device, device_address);
328 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
329 }
François Gaffie53615e22015-03-19 09:24:12 +0100330
Eric Laurent3a4311c2014-03-17 12:00:47 -0700331 DeviceVector *deviceVector;
332
Eric Laurente552edb2014-03-10 17:42:56 -0700333 if (audio_is_output_device(device)) {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700334 deviceVector = &mAvailableOutputDevices;
Eric Laurente552edb2014-03-10 17:42:56 -0700335 } else if (audio_is_input_device(device)) {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700336 deviceVector = &mAvailableInputDevices;
337 } else {
338 ALOGW("getDeviceConnectionState() invalid device type %08x", device);
339 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
Eric Laurente552edb2014-03-10 17:42:56 -0700340 }
Eric Laurent634b7142016-04-20 13:48:02 -0700341
342 return (deviceVector->getDevice(device, String8(device_address)) != 0) ?
343 AUDIO_POLICY_DEVICE_STATE_AVAILABLE : AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
Eric Laurenta1d525f2015-01-29 13:36:45 -0800344}
345
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800346status_t AudioPolicyManager::handleDeviceConfigChange(audio_devices_t device,
347 const char *device_address,
348 const char *device_name)
349{
350 status_t status;
351
352 ALOGV("handleDeviceConfigChange(() device: 0x%X, address %s name %s",
353 device, device_address, device_name);
354
Pavlin Radoslavovc694ff42017-01-09 23:27:29 -0800355 // connect/disconnect only 1 device at a time
356 if (!audio_is_output_device(device) && !audio_is_input_device(device)) return BAD_VALUE;
357
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800358 // Check if the device is currently connected
359 sp<DeviceDescriptor> devDesc =
360 mHwModules.getDeviceDescriptor(device, device_address, device_name);
361 ssize_t index = mAvailableOutputDevices.indexOf(devDesc);
362 if (index < 0) {
363 // Nothing to do: device is not connected
364 return NO_ERROR;
365 }
366
367 // Toggle the device state: UNAVAILABLE -> AVAILABLE
368 // This will force reading again the device configuration
369 status = setDeviceConnectionState(device,
370 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
371 device_address, device_name);
372 if (status != NO_ERROR) {
373 ALOGW("handleDeviceConfigChange() error disabling connection state: %d",
374 status);
375 return status;
376 }
377
378 status = setDeviceConnectionState(device,
379 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
380 device_address, device_name);
381 if (status != NO_ERROR) {
382 ALOGW("handleDeviceConfigChange() error enabling connection state: %d",
383 status);
384 return status;
385 }
386
387 return NO_ERROR;
388}
389
Eric Laurentdc462862016-07-19 12:29:53 -0700390uint32_t AudioPolicyManager::updateCallRouting(audio_devices_t rxDevice, uint32_t delayMs)
Eric Laurentc2730ba2014-07-20 15:47:07 -0700391{
392 bool createTxPatch = false;
Eric Laurentdc462862016-07-19 12:29:53 -0700393 uint32_t muteWaitMs = 0;
Eric Laurentc2730ba2014-07-20 15:47:07 -0700394
Andy Hunga76c7de2016-12-13 19:14:31 -0800395 if(!hasPrimaryOutput() || mPrimaryOutput->device() == AUDIO_DEVICE_OUT_STUB) {
Eric Laurentdc462862016-07-19 12:29:53 -0700396 return muteWaitMs;
Eric Laurent87ffa392015-05-22 10:32:38 -0700397 }
Eric Laurentc73ca6e2014-12-12 14:34:22 -0800398 audio_devices_t txDevice = getDeviceAndMixForInputSource(AUDIO_SOURCE_VOICE_COMMUNICATION);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700399 ALOGV("updateCallRouting device rxDevice %08x txDevice %08x", rxDevice, txDevice);
400
401 // release existing RX patch if any
402 if (mCallRxPatch != 0) {
403 mpClientInterface->releaseAudioPatch(mCallRxPatch->mAfPatchHandle, 0);
404 mCallRxPatch.clear();
405 }
406 // release TX patch if any
407 if (mCallTxPatch != 0) {
408 mpClientInterface->releaseAudioPatch(mCallTxPatch->mAfPatchHandle, 0);
409 mCallTxPatch.clear();
410 }
411
412 // If the RX device is on the primary HW module, then use legacy routing method for voice calls
413 // via setOutputDevice() on primary output.
414 // Otherwise, create two audio patches for TX and RX path.
415 if (availablePrimaryOutputDevices() & rxDevice) {
Eric Laurentdc462862016-07-19 12:29:53 -0700416 muteWaitMs = setOutputDevice(mPrimaryOutput, rxDevice, true, delayMs);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700417 // If the TX device is also on the primary HW module, setOutputDevice() will take care
418 // of it due to legacy implementation. If not, create a patch.
419 if ((availablePrimaryInputDevices() & txDevice & ~AUDIO_DEVICE_BIT_IN)
420 == AUDIO_DEVICE_NONE) {
421 createTxPatch = true;
422 }
Eric Laurent8ae73122016-04-12 10:13:29 -0700423 } else { // create RX path audio patch
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800424 mCallRxPatch = createTelephonyPatch(true /*isRx*/, rxDevice, delayMs);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700425 createTxPatch = true;
426 }
Eric Laurent8ae73122016-04-12 10:13:29 -0700427 if (createTxPatch) { // create TX path audio patch
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800428 mCallTxPatch = createTelephonyPatch(false /*isRx*/, txDevice, delayMs);
429 }
Eric Laurent8ae73122016-04-12 10:13:29 -0700430
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800431 return muteWaitMs;
432}
Eric Laurentc2730ba2014-07-20 15:47:07 -0700433
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800434sp<AudioPatch> AudioPolicyManager::createTelephonyPatch(
435 bool isRx, audio_devices_t device, uint32_t delayMs) {
436 struct audio_patch patch;
437 patch.num_sources = 1;
438 patch.num_sinks = 1;
Eric Laurentc2730ba2014-07-20 15:47:07 -0700439
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800440 sp<DeviceDescriptor> txSourceDeviceDesc;
441 if (isRx) {
442 fillAudioPortConfigForDevice(mAvailableOutputDevices, device, &patch.sinks[0]);
443 fillAudioPortConfigForDevice(
444 mAvailableInputDevices, AUDIO_DEVICE_IN_TELEPHONY_RX, &patch.sources[0]);
445 } else {
446 txSourceDeviceDesc = fillAudioPortConfigForDevice(
447 mAvailableInputDevices, device, &patch.sources[0]);
448 fillAudioPortConfigForDevice(
449 mAvailableOutputDevices, AUDIO_DEVICE_OUT_TELEPHONY_TX, &patch.sinks[0]);
450 }
451
452 audio_devices_t outputDevice = isRx ? device : AUDIO_DEVICE_OUT_TELEPHONY_TX;
453 SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(outputDevice, mOutputs);
454 audio_io_handle_t output = selectOutput(outputs, AUDIO_OUTPUT_FLAG_NONE, AUDIO_FORMAT_INVALID);
455 // request to reuse existing output stream if one is already opened to reach the target device
456 if (output != AUDIO_IO_HANDLE_NONE) {
457 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
458 ALOG_ASSERT(!outputDesc->isDuplicated(),
459 "%s() %#x device output %d is duplicated", __func__, outputDevice, output);
460 outputDesc->toAudioPortConfig(&patch.sources[1]);
461 patch.sources[1].ext.mix.usecase.stream = AUDIO_STREAM_PATCH;
462 patch.num_sources = 2;
463 }
464
465 if (!isRx) {
Eric Laurentc0a889f2015-10-14 14:36:34 -0700466 // terminate active capture if on the same HW module as the call TX source device
467 // FIXME: would be better to refine to only inputs whose profile connects to the
468 // call TX device but this information is not in the audio patch and logic here must be
469 // symmetric to the one in startInput()
Mikhail Naganovcf84e592017-12-07 11:25:11 -0800470 for (const auto& activeDesc : mInputs.getActiveInputs()) {
Eric Laurentfb66dd92016-01-28 18:32:03 -0800471 if (activeDesc->hasSameHwModuleAs(txSourceDeviceDesc)) {
472 AudioSessionCollection activeSessions =
473 activeDesc->getAudioSessions(true /*activeOnly*/);
474 for (size_t j = 0; j < activeSessions.size(); j++) {
475 audio_session_t activeSession = activeSessions.keyAt(j);
476 stopInput(activeDesc->mIoHandle, activeSession);
477 releaseInput(activeDesc->mIoHandle, activeSession);
478 }
Eric Laurentc0a889f2015-10-14 14:36:34 -0700479 }
480 }
Eric Laurentc2730ba2014-07-20 15:47:07 -0700481 }
Eric Laurentdc462862016-07-19 12:29:53 -0700482
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800483 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
484 status_t status = mpClientInterface->createAudioPatch(&patch, &afPatchHandle, delayMs);
485 ALOGW_IF(status != NO_ERROR,
486 "%s() error %d creating %s audio patch", __func__, status, isRx ? "RX" : "TX");
487 sp<AudioPatch> audioPatch;
488 if (status == NO_ERROR) {
489 audioPatch = new AudioPatch(&patch, mUidCached);
490 audioPatch->mAfPatchHandle = afPatchHandle;
491 audioPatch->mUid = mUidCached;
492 }
493 return audioPatch;
494}
495
496sp<DeviceDescriptor> AudioPolicyManager::fillAudioPortConfigForDevice(
497 const DeviceVector& devices, audio_devices_t device, audio_port_config *config) {
498 DeviceVector deviceList = devices.getDevicesFromType(device);
499 ALOG_ASSERT(!deviceList.isEmpty(),
500 "%s() selected device type %#x is not in devices list", __func__, device);
501 sp<DeviceDescriptor> deviceDesc = deviceList.itemAt(0);
502 deviceDesc->toAudioPortConfig(config);
503 return deviceDesc;
Eric Laurentc2730ba2014-07-20 15:47:07 -0700504}
505
Eric Laurente0720872014-03-11 09:30:41 -0700506void AudioPolicyManager::setPhoneState(audio_mode_t state)
Eric Laurente552edb2014-03-10 17:42:56 -0700507{
508 ALOGV("setPhoneState() state %d", state);
François Gaffie2110e042015-03-24 08:41:51 +0100509 // store previous phone state for management of sonification strategy below
510 int oldState = mEngine->getPhoneState();
511
512 if (mEngine->setPhoneState(state) != NO_ERROR) {
513 ALOGW("setPhoneState() invalid or same state %d", state);
Eric Laurente552edb2014-03-10 17:42:56 -0700514 return;
515 }
François Gaffie2110e042015-03-24 08:41:51 +0100516 /// Opens: can these line be executed after the switch of volume curves???
Eric Laurente552edb2014-03-10 17:42:56 -0700517 // if leaving call state, handle special case of active streams
518 // pertaining to sonification strategy see handleIncallSonification()
Eric Laurent63dea1d2015-07-02 17:10:28 -0700519 if (isStateInCall(oldState)) {
Eric Laurente552edb2014-03-10 17:42:56 -0700520 ALOGV("setPhoneState() in call state management: new state is %d", state);
Eric Laurent794fde22016-03-11 09:50:45 -0800521 for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) {
Eric Laurent3b73df72014-03-11 09:06:29 -0700522 handleIncallSonification((audio_stream_type_t)stream, false, true);
Eric Laurente552edb2014-03-10 17:42:56 -0700523 }
Eric Laurent2cbe89a2014-12-19 11:49:08 -0800524
Eric Laurent63dea1d2015-07-02 17:10:28 -0700525 // force reevaluating accessibility routing when call stops
Eric Laurent2cbe89a2014-12-19 11:49:08 -0800526 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
Eric Laurente552edb2014-03-10 17:42:56 -0700527 }
528
François Gaffie2110e042015-03-24 08:41:51 +0100529 /**
530 * Switching to or from incall state or switching between telephony and VoIP lead to force
531 * routing command.
532 */
533 bool force = ((is_state_in_call(oldState) != is_state_in_call(state))
534 || (is_state_in_call(state) && (state != oldState)));
Eric Laurente552edb2014-03-10 17:42:56 -0700535
536 // check for device and output changes triggered by new phone state
Eric Laurente552edb2014-03-10 17:42:56 -0700537 checkA2dpSuspend();
538 checkOutputForAllStrategies();
539 updateDevicesAndOutputs();
540
Eric Laurente552edb2014-03-10 17:42:56 -0700541 int delayMs = 0;
542 if (isStateInCall(state)) {
543 nsecs_t sysTime = systemTime();
544 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -0700545 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Eric Laurente552edb2014-03-10 17:42:56 -0700546 // mute media and sonification strategies and delay device switch by the largest
547 // latency of any output where either strategy is active.
548 // This avoid sending the ring tone or music tail into the earpiece or headset.
François Gaffiead3183e2015-03-18 16:55:35 +0100549 if ((isStrategyActive(desc, STRATEGY_MEDIA,
550 SONIFICATION_HEADSET_MUSIC_DELAY,
551 sysTime) ||
552 isStrategyActive(desc, STRATEGY_SONIFICATION,
553 SONIFICATION_HEADSET_MUSIC_DELAY,
554 sysTime)) &&
Eric Laurentc75307b2015-03-17 15:29:32 -0700555 (delayMs < (int)desc->latency()*2)) {
556 delayMs = desc->latency()*2;
Eric Laurente552edb2014-03-10 17:42:56 -0700557 }
Eric Laurentc75307b2015-03-17 15:29:32 -0700558 setStrategyMute(STRATEGY_MEDIA, true, desc);
559 setStrategyMute(STRATEGY_MEDIA, false, desc, MUTE_TIME_MS,
Eric Laurente552edb2014-03-10 17:42:56 -0700560 getDeviceForStrategy(STRATEGY_MEDIA, true /*fromCache*/));
Eric Laurentc75307b2015-03-17 15:29:32 -0700561 setStrategyMute(STRATEGY_SONIFICATION, true, desc);
562 setStrategyMute(STRATEGY_SONIFICATION, false, desc, MUTE_TIME_MS,
Eric Laurente552edb2014-03-10 17:42:56 -0700563 getDeviceForStrategy(STRATEGY_SONIFICATION, true /*fromCache*/));
564 }
565 }
566
Eric Laurent87ffa392015-05-22 10:32:38 -0700567 if (hasPrimaryOutput()) {
568 // Note that despite the fact that getNewOutputDevice() is called on the primary output,
569 // the device returned is not necessarily reachable via this output
570 audio_devices_t rxDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
571 // force routing command to audio hardware when ending call
572 // even if no device change is needed
573 if (isStateInCall(oldState) && rxDevice == AUDIO_DEVICE_NONE) {
574 rxDevice = mPrimaryOutput->device();
575 }
Eric Laurente552edb2014-03-10 17:42:56 -0700576
Eric Laurent87ffa392015-05-22 10:32:38 -0700577 if (state == AUDIO_MODE_IN_CALL) {
578 updateCallRouting(rxDevice, delayMs);
579 } else if (oldState == AUDIO_MODE_IN_CALL) {
580 if (mCallRxPatch != 0) {
581 mpClientInterface->releaseAudioPatch(mCallRxPatch->mAfPatchHandle, 0);
582 mCallRxPatch.clear();
583 }
584 if (mCallTxPatch != 0) {
585 mpClientInterface->releaseAudioPatch(mCallTxPatch->mAfPatchHandle, 0);
586 mCallTxPatch.clear();
587 }
588 setOutputDevice(mPrimaryOutput, rxDevice, force, 0);
589 } else {
590 setOutputDevice(mPrimaryOutput, rxDevice, force, 0);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700591 }
Eric Laurentc2730ba2014-07-20 15:47:07 -0700592 }
Eric Laurente552edb2014-03-10 17:42:56 -0700593 // if entering in call state, handle special case of active streams
594 // pertaining to sonification strategy see handleIncallSonification()
595 if (isStateInCall(state)) {
596 ALOGV("setPhoneState() in call state management: new state is %d", state);
Eric Laurent794fde22016-03-11 09:50:45 -0800597 for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) {
Eric Laurent3b73df72014-03-11 09:06:29 -0700598 handleIncallSonification((audio_stream_type_t)stream, true, true);
Eric Laurente552edb2014-03-10 17:42:56 -0700599 }
Eric Laurent63dea1d2015-07-02 17:10:28 -0700600
601 // force reevaluating accessibility routing when call starts
602 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
Eric Laurente552edb2014-03-10 17:42:56 -0700603 }
604
605 // Flag that ringtone volume must be limited to music volume until we exit MODE_RINGTONE
Eric Laurent3b73df72014-03-11 09:06:29 -0700606 if (state == AUDIO_MODE_RINGTONE &&
607 isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY)) {
Eric Laurente552edb2014-03-10 17:42:56 -0700608 mLimitRingtoneVolume = true;
609 } else {
610 mLimitRingtoneVolume = false;
611 }
612}
613
Jean-Michel Trivi887a9ed2015-03-31 18:02:24 -0700614audio_mode_t AudioPolicyManager::getPhoneState() {
615 return mEngine->getPhoneState();
616}
617
Eric Laurente0720872014-03-11 09:30:41 -0700618void AudioPolicyManager::setForceUse(audio_policy_force_use_t usage,
Eric Laurent3b73df72014-03-11 09:06:29 -0700619 audio_policy_forced_cfg_t config)
Eric Laurente552edb2014-03-10 17:42:56 -0700620{
François Gaffie2110e042015-03-24 08:41:51 +0100621 ALOGV("setForceUse() usage %d, config %d, mPhoneState %d", usage, config, mEngine->getPhoneState());
Eric Laurent8dc87a62017-05-16 19:00:40 -0700622 if (config == mEngine->getForceUse(usage)) {
623 return;
624 }
Eric Laurente552edb2014-03-10 17:42:56 -0700625
François Gaffie2110e042015-03-24 08:41:51 +0100626 if (mEngine->setForceUse(usage, config) != NO_ERROR) {
627 ALOGW("setForceUse() could not set force cfg %d for usage %d", config, usage);
628 return;
Eric Laurente552edb2014-03-10 17:42:56 -0700629 }
François Gaffie2110e042015-03-24 08:41:51 +0100630 bool forceVolumeReeval = (usage == AUDIO_POLICY_FORCE_FOR_COMMUNICATION) ||
631 (usage == AUDIO_POLICY_FORCE_FOR_DOCK) ||
632 (usage == AUDIO_POLICY_FORCE_FOR_SYSTEM);
Eric Laurente552edb2014-03-10 17:42:56 -0700633
634 // check for device and output changes triggered by new force usage
635 checkA2dpSuspend();
636 checkOutputForAllStrategies();
637 updateDevicesAndOutputs();
Phil Burk09bc4612016-02-24 15:58:15 -0800638
Eric Laurentdc462862016-07-19 12:29:53 -0700639 //FIXME: workaround for truncated touch sounds
640 // to be removed when the problem is handled by system UI
641 uint32_t delayMs = 0;
642 uint32_t waitMs = 0;
643 if (usage == AUDIO_POLICY_FORCE_FOR_COMMUNICATION) {
644 delayMs = TOUCH_SOUND_FIXED_DELAY_MS;
645 }
Eric Laurent87ffa392015-05-22 10:32:38 -0700646 if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
Eric Laurentc2730ba2014-07-20 15:47:07 -0700647 audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, true /*fromCache*/);
Eric Laurentdc462862016-07-19 12:29:53 -0700648 waitMs = updateCallRouting(newDevice, delayMs);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700649 }
Eric Laurente552edb2014-03-10 17:42:56 -0700650 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -0700651 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
652 audio_devices_t newDevice = getNewOutputDevice(outputDesc, true /*fromCache*/);
653 if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) || (outputDesc != mPrimaryOutput)) {
Eric Laurentdc462862016-07-19 12:29:53 -0700654 waitMs = setOutputDevice(outputDesc, newDevice, (newDevice != AUDIO_DEVICE_NONE),
655 delayMs);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700656 }
Eric Laurente552edb2014-03-10 17:42:56 -0700657 if (forceVolumeReeval && (newDevice != AUDIO_DEVICE_NONE)) {
Eric Laurentdc462862016-07-19 12:29:53 -0700658 applyStreamVolumes(outputDesc, newDevice, waitMs, true);
Eric Laurente552edb2014-03-10 17:42:56 -0700659 }
660 }
661
Mikhail Naganovcf84e592017-12-07 11:25:11 -0800662 for (const auto& activeDesc : mInputs.getActiveInputs()) {
Eric Laurentfb66dd92016-01-28 18:32:03 -0800663 audio_devices_t newDevice = getNewInputDevice(activeDesc);
Eric Laurentc171c7c2015-09-25 12:21:06 -0700664 // Force new input selection if the new device can not be reached via current input
Eric Laurentfb66dd92016-01-28 18:32:03 -0800665 if (activeDesc->mProfile->getSupportedDevices().types() &
666 (newDevice & ~AUDIO_DEVICE_BIT_IN)) {
667 setInputDevice(activeDesc->mIoHandle, newDevice);
Eric Laurentc171c7c2015-09-25 12:21:06 -0700668 } else {
Eric Laurentfb66dd92016-01-28 18:32:03 -0800669 closeInput(activeDesc->mIoHandle);
Eric Laurentc171c7c2015-09-25 12:21:06 -0700670 }
Eric Laurente552edb2014-03-10 17:42:56 -0700671 }
Eric Laurente552edb2014-03-10 17:42:56 -0700672}
673
Eric Laurente0720872014-03-11 09:30:41 -0700674void AudioPolicyManager::setSystemProperty(const char* property, const char* value)
Eric Laurente552edb2014-03-10 17:42:56 -0700675{
676 ALOGV("setSystemProperty() property %s, value %s", property, value);
677}
678
679// Find a direct output profile compatible with the parameters passed, even if the input flags do
680// not explicitly request a direct output
Jean-Michel Trivi56ec4ff2015-01-23 16:45:18 -0800681sp<IOProfile> AudioPolicyManager::getProfileForDirectOutput(
Eric Laurente552edb2014-03-10 17:42:56 -0700682 audio_devices_t device,
683 uint32_t samplingRate,
684 audio_format_t format,
685 audio_channel_mask_t channelMask,
686 audio_output_flags_t flags)
687{
Eric Laurent861a6282015-05-18 15:40:16 -0700688 // only retain flags that will drive the direct output profile selection
689 // if explicitly requested
690 static const uint32_t kRelevantFlags =
Haynes Mathew George84c621e2017-04-25 11:41:50 -0700691 (AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD |
692 AUDIO_OUTPUT_FLAG_VOIP_RX);
Eric Laurent861a6282015-05-18 15:40:16 -0700693 flags =
694 (audio_output_flags_t)((flags & kRelevantFlags) | AUDIO_OUTPUT_FLAG_DIRECT);
695
696 sp<IOProfile> profile;
697
Mikhail Naganovd4120142017-12-06 15:49:22 -0800698 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -0800699 for (const auto& curProfile : hwModule->getOutputProfiles()) {
Eric Laurent861a6282015-05-18 15:40:16 -0700700 if (!curProfile->isCompatibleProfile(device, String8(""),
Andy Hungf129b032015-04-07 13:45:50 -0700701 samplingRate, NULL /*updatedSamplingRate*/,
702 format, NULL /*updatedFormat*/,
703 channelMask, NULL /*updatedChannelMask*/,
Eric Laurent861a6282015-05-18 15:40:16 -0700704 flags)) {
705 continue;
706 }
707 // reject profiles not corresponding to a device currently available
François Gaffiea8ecc2c2015-11-09 16:10:40 +0100708 if ((mAvailableOutputDevices.types() & curProfile->getSupportedDevicesType()) == 0) {
Eric Laurent861a6282015-05-18 15:40:16 -0700709 continue;
710 }
711 // if several profiles are compatible, give priority to one with offload capability
François Gaffiea8ecc2c2015-11-09 16:10:40 +0100712 if (profile != 0 && ((curProfile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0)) {
Eric Laurent861a6282015-05-18 15:40:16 -0700713 continue;
714 }
715 profile = curProfile;
François Gaffiea8ecc2c2015-11-09 16:10:40 +0100716 if ((profile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
Eric Laurent861a6282015-05-18 15:40:16 -0700717 break;
Eric Laurent3a4311c2014-03-17 12:00:47 -0700718 }
Eric Laurente552edb2014-03-10 17:42:56 -0700719 }
720 }
Eric Laurent861a6282015-05-18 15:40:16 -0700721 return profile;
Eric Laurente552edb2014-03-10 17:42:56 -0700722}
723
Eric Laurentf4e63452017-11-06 19:31:46 +0000724audio_io_handle_t AudioPolicyManager::getOutput(audio_stream_type_t stream)
Eric Laurente552edb2014-03-10 17:42:56 -0700725{
Eric Laurent3b73df72014-03-11 09:06:29 -0700726 routing_strategy strategy = getStrategy(stream);
Eric Laurente552edb2014-03-10 17:42:56 -0700727 audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
Andy Hungc9901522017-11-10 20:07:54 -0800728
729 // Note that related method getOutputForAttr() uses getOutputForDevice() not selectOutput().
730 // We use selectOutput() here since we don't have the desired AudioTrack sample rate,
731 // format, flags, etc. This may result in some discrepancy for functions that utilize
732 // getOutput() solely on audio_stream_type such as AudioSystem::getOutputFrameCount()
733 // and AudioSystem::getOutputSamplingRate().
734
Eric Laurentf4e63452017-11-06 19:31:46 +0000735 SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs);
736 audio_io_handle_t output = selectOutput(outputs, AUDIO_OUTPUT_FLAG_NONE, AUDIO_FORMAT_INVALID);
Eric Laurente552edb2014-03-10 17:42:56 -0700737
Eric Laurentf4e63452017-11-06 19:31:46 +0000738 ALOGV("getOutput() stream %d selected device %08x, output %d", stream, device, output);
739 return output;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700740}
741
Eric Laurente83b55d2014-11-14 10:06:21 -0800742status_t AudioPolicyManager::getOutputForAttr(const audio_attributes_t *attr,
743 audio_io_handle_t *output,
744 audio_session_t session,
745 audio_stream_type_t *stream,
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700746 uid_t uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800747 const audio_config_t *config,
Nadav Bar766fb022018-01-07 12:18:03 +0200748 audio_output_flags_t *flags,
Eric Laurent2ac76942017-06-22 17:17:09 -0700749 audio_port_handle_t *selectedDeviceId,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800750 audio_port_handle_t *portId)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700751{
Eric Laurente83b55d2014-11-14 10:06:21 -0800752 audio_attributes_t attributes;
753 if (attr != NULL) {
754 if (!isValidAttributes(attr)) {
755 ALOGE("getOutputForAttr() invalid attributes: usage=%d content=%d flags=0x%x tags=[%s]",
756 attr->usage, attr->content_type, attr->flags,
757 attr->tags);
758 return BAD_VALUE;
759 }
760 attributes = *attr;
761 } else {
762 if (*stream < AUDIO_STREAM_MIN || *stream >= AUDIO_STREAM_PUBLIC_CNT) {
763 ALOGE("getOutputForAttr(): invalid stream type");
764 return BAD_VALUE;
765 }
766 stream_type_to_audio_attributes(*stream, &attributes);
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700767 }
Eric Laurent20b9ef02016-12-05 11:03:16 -0800768
769 // TODO: check for existing client for this port ID
770 if (*portId == AUDIO_PORT_HANDLE_NONE) {
771 *portId = AudioPort::getNextUniqueId();
772 }
773
Eric Laurentc75307b2015-03-17 15:29:32 -0700774 sp<SwAudioOutputDescriptor> desc;
Jean-Michel Trivie8deced2016-02-11 12:50:39 -0800775 if (mPolicyMixes.getOutputForAttr(attributes, uid, desc) == NO_ERROR) {
François Gaffie036e1e92015-03-19 10:16:24 +0100776 ALOG_ASSERT(desc != 0, "Invalid desc returned by getOutputForAttr");
Eric Laurent20b9ef02016-12-05 11:03:16 -0800777 if (!audio_has_proportional_frames(config->format)) {
François Gaffie036e1e92015-03-19 10:16:24 +0100778 return BAD_VALUE;
Eric Laurent275e8e92014-11-30 15:14:47 -0800779 }
François Gaffie036e1e92015-03-19 10:16:24 +0100780 *stream = streamTypefromAttributesInt(&attributes);
781 *output = desc->mIoHandle;
782 ALOGV("getOutputForAttr() returns output %d", *output);
783 return NO_ERROR;
Eric Laurent275e8e92014-11-30 15:14:47 -0800784 }
785 if (attributes.usage == AUDIO_USAGE_VIRTUAL_SOURCE) {
786 ALOGW("getOutputForAttr() no policy mix found for usage AUDIO_USAGE_VIRTUAL_SOURCE");
787 return BAD_VALUE;
788 }
789
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700790 ALOGV("getOutputForAttr() usage=%d, content=%d, tag=%s flags=%08x"
791 " session %d selectedDeviceId %d",
792 attributes.usage, attributes.content_type, attributes.tags, attributes.flags,
Eric Laurent2ac76942017-06-22 17:17:09 -0700793 session, *selectedDeviceId);
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700794
795 *stream = streamTypefromAttributesInt(&attributes);
796
797 // Explicit routing?
798 sp<DeviceDescriptor> deviceDesc;
Eric Laurent2ac76942017-06-22 17:17:09 -0700799 if (*selectedDeviceId != AUDIO_PORT_HANDLE_NONE) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -0800800 deviceDesc = mAvailableOutputDevices.getDeviceFromId(*selectedDeviceId);
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700801 }
802 mOutputRoutes.addRoute(session, *stream, SessionRoute::SOURCE_TYPE_NA, deviceDesc, uid);
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700803
Eric Laurente83b55d2014-11-14 10:06:21 -0800804 routing_strategy strategy = (routing_strategy) getStrategyForAttr(&attributes);
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700805 audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
Eric Laurent93c3d412014-08-01 14:48:35 -0700806
Eric Laurente83b55d2014-11-14 10:06:21 -0800807 if ((attributes.flags & AUDIO_FLAG_HW_AV_SYNC) != 0) {
Nadav Bar766fb022018-01-07 12:18:03 +0200808 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_HW_AV_SYNC);
Eric Laurent93c3d412014-08-01 14:48:35 -0700809 }
810
Glenn Kasten49f36ba2017-12-06 13:02:02 -0800811 ALOGV("getOutputForAttr() device 0x%x, sampling rate %d, format %#x, channel mask %#x, "
812 "flags %#x",
Nadav Bar766fb022018-01-07 12:18:03 +0200813 device, config->sample_rate, config->format, config->channel_mask, *flags);
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700814
Phil Burk2d059932018-02-15 15:55:11 -0800815 *output = getOutputForDevice(device, session, *stream, *output, config, flags);
Eric Laurente83b55d2014-11-14 10:06:21 -0800816 if (*output == AUDIO_IO_HANDLE_NONE) {
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700817 mOutputRoutes.removeRoute(session);
Eric Laurente83b55d2014-11-14 10:06:21 -0800818 return INVALID_OPERATION;
819 }
Paul McLeanaa981192015-03-21 09:55:15 -0700820
Eric Laurent2ac76942017-06-22 17:17:09 -0700821 DeviceVector outputDevices = mAvailableOutputDevices.getDevicesFromType(device);
822 *selectedDeviceId = outputDevices.size() > 0 ? outputDevices.itemAt(0)->getId()
823 : AUDIO_PORT_HANDLE_NONE;
824
825 ALOGV(" getOutputForAttr() returns output %d selectedDeviceId %d", *output, *selectedDeviceId);
826
Eric Laurente83b55d2014-11-14 10:06:21 -0800827 return NO_ERROR;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700828}
829
830audio_io_handle_t AudioPolicyManager::getOutputForDevice(
831 audio_devices_t device,
Kevin Rocard169753c2017-03-06 14:18:23 -0800832 audio_session_t session,
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700833 audio_stream_type_t stream,
Phil Burk2d059932018-02-15 15:55:11 -0800834 audio_io_handle_t originalOutput,
Eric Laurentfe231122017-11-17 17:48:06 -0800835 const audio_config_t *config,
Nadav Bar766fb022018-01-07 12:18:03 +0200836 audio_output_flags_t *flags)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700837{
Phil Burk2d059932018-02-15 15:55:11 -0800838 audio_io_handle_t output = originalOutput;
Eric Laurentcf2c0212014-07-25 16:20:43 -0700839 status_t status;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700840
Eric Laurente552edb2014-03-10 17:42:56 -0700841 // open a direct output if required by specified parameters
842 //force direct flag if offload flag is set: offloading implies a direct output stream
843 // and all common behaviors are driven by checking only the direct flag
844 // this should normally be set appropriately in the policy configuration file
Nadav Bar766fb022018-01-07 12:18:03 +0200845 if ((*flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
846 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_DIRECT);
Eric Laurente552edb2014-03-10 17:42:56 -0700847 }
Nadav Bar766fb022018-01-07 12:18:03 +0200848 if ((*flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) {
849 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_DIRECT);
Eric Laurent93c3d412014-08-01 14:48:35 -0700850 }
Eric Laurente83b55d2014-11-14 10:06:21 -0800851 // only allow deep buffering for music stream type
852 if (stream != AUDIO_STREAM_MUSIC) {
Nadav Bar766fb022018-01-07 12:18:03 +0200853 *flags = (audio_output_flags_t)(*flags &~AUDIO_OUTPUT_FLAG_DEEP_BUFFER);
Ravi Kumar Alamanda439e4ed2015-04-03 12:13:21 -0700854 } else if (/* stream == AUDIO_STREAM_MUSIC && */
Nadav Bar766fb022018-01-07 12:18:03 +0200855 *flags == AUDIO_OUTPUT_FLAG_NONE &&
Ravi Kumar Alamanda439e4ed2015-04-03 12:13:21 -0700856 property_get_bool("audio.deep_buffer.media", false /* default_value */)) {
857 // use DEEP_BUFFER as default output for music stream type
Nadav Bar766fb022018-01-07 12:18:03 +0200858 *flags = (audio_output_flags_t)AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
Eric Laurente83b55d2014-11-14 10:06:21 -0800859 }
Ravi Kumar Alamandac36a8892015-04-24 16:35:49 -0700860 if (stream == AUDIO_STREAM_TTS) {
Nadav Bar766fb022018-01-07 12:18:03 +0200861 *flags = AUDIO_OUTPUT_FLAG_TTS;
Haynes Mathew George84c621e2017-04-25 11:41:50 -0700862 } else if (stream == AUDIO_STREAM_VOICE_CALL &&
Eric Laurentfe231122017-11-17 17:48:06 -0800863 audio_is_linear_pcm(config->format)) {
Nadav Bar766fb022018-01-07 12:18:03 +0200864 *flags = (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_VOIP_RX |
Haynes Mathew George84c621e2017-04-25 11:41:50 -0700865 AUDIO_OUTPUT_FLAG_DIRECT);
866 ALOGV("Set VoIP and Direct output flags for PCM format");
Nadav Bar766fb022018-01-07 12:18:03 +0200867 } else if (device == AUDIO_DEVICE_OUT_TELEPHONY_TX &&
868 stream == AUDIO_STREAM_MUSIC &&
869 audio_is_linear_pcm(config->format) &&
870 isInCall()) {
871 *flags = (audio_output_flags_t)AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
Ravi Kumar Alamandac36a8892015-04-24 16:35:49 -0700872 }
Eric Laurente552edb2014-03-10 17:42:56 -0700873
Nadav Bar766fb022018-01-07 12:18:03 +0200874
Eric Laurentb732cf52014-09-24 19:08:21 -0700875 sp<IOProfile> profile;
876
877 // skip direct output selection if the request can obviously be attached to a mixed output
Eric Laurentc2607842014-09-29 09:43:03 -0700878 // and not explicitly requested
Nadav Bar766fb022018-01-07 12:18:03 +0200879 if (((*flags & AUDIO_OUTPUT_FLAG_DIRECT) == 0) &&
Eric Laurentfe231122017-11-17 17:48:06 -0800880 audio_is_linear_pcm(config->format) && config->sample_rate <= SAMPLE_RATE_HZ_MAX &&
881 audio_channel_count_from_out_mask(config->channel_mask) <= 2) {
Eric Laurentb732cf52014-09-24 19:08:21 -0700882 goto non_direct_output;
883 }
884
Andy Hung2ddee192015-12-18 17:34:44 -0800885 // Do not allow offloading if one non offloadable effect is enabled or MasterMono is enabled.
886 // This prevents creating an offloaded track and tearing it down immediately after start
887 // when audioflinger detects there is an active non offloadable effect.
Eric Laurente552edb2014-03-10 17:42:56 -0700888 // FIXME: We should check the audio session here but we do not have it in this context.
889 // This may prevent offloading in rare situations where effects are left active by apps
890 // in the background.
Eric Laurentb732cf52014-09-24 19:08:21 -0700891
Nadav Bar766fb022018-01-07 12:18:03 +0200892 if (((*flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) ||
Andy Hung2ddee192015-12-18 17:34:44 -0800893 !(mEffects.isNonOffloadableEffectEnabled() || mMasterMono)) {
Eric Laurente552edb2014-03-10 17:42:56 -0700894 profile = getProfileForDirectOutput(device,
Eric Laurentfe231122017-11-17 17:48:06 -0800895 config->sample_rate,
896 config->format,
897 config->channel_mask,
Nadav Bar766fb022018-01-07 12:18:03 +0200898 (audio_output_flags_t)*flags);
Eric Laurente552edb2014-03-10 17:42:56 -0700899 }
900
Eric Laurent1c333e22014-05-20 10:48:17 -0700901 if (profile != 0) {
Phil Burk2d059932018-02-15 15:55:11 -0800902 // exclude MMAP streams
903 if ((*flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) == 0 || output != AUDIO_IO_HANDLE_NONE) {
904 for (size_t i = 0; i < mOutputs.size(); i++) {
905 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
906 if (!desc->isDuplicated() && (profile == desc->mProfile)) {
907 // reuse direct output if currently open by the same client
908 // and configured with same parameters
909 if ((config->sample_rate == desc->mSamplingRate) &&
910 audio_formats_match(config->format, desc->mFormat) &&
911 (config->channel_mask == desc->mChannelMask) &&
912 (session == desc->mDirectClientSession)) {
913 desc->mDirectOpenCount++;
914 ALOGI("getOutputForDevice() reusing direct output %d for session %d",
915 mOutputs.keyAt(i), session);
916 return mOutputs.keyAt(i);
917 }
Eric Laurente552edb2014-03-10 17:42:56 -0700918 }
919 }
920 }
Eric Laurent3974e3b2017-12-07 17:58:43 -0800921
922 if (!profile->canOpenNewIo()) {
923 goto non_direct_output;
Eric Laurente552edb2014-03-10 17:42:56 -0700924 }
Eric Laurent861a6282015-05-18 15:40:16 -0700925
Eric Laurent3974e3b2017-12-07 17:58:43 -0800926 sp<SwAudioOutputDescriptor> outputDesc =
927 new SwAudioOutputDescriptor(profile, mpClientInterface);
Eric Laurent53b810e2017-12-10 17:25:10 -0800928
929 DeviceVector outputDevices = mAvailableOutputDevices.getDevicesFromType(device);
930 String8 address = outputDevices.size() > 0 ? outputDevices.itemAt(0)->mAddress
931 : String8("");
932
Nadav Bar766fb022018-01-07 12:18:03 +0200933 status = outputDesc->open(config, device, address, stream, *flags, &output);
Eric Laurente552edb2014-03-10 17:42:56 -0700934
935 // only accept an output with the requested parameters
Eric Laurentcf2c0212014-07-25 16:20:43 -0700936 if (status != NO_ERROR ||
Eric Laurentfe231122017-11-17 17:48:06 -0800937 (config->sample_rate != 0 && config->sample_rate != outputDesc->mSamplingRate) ||
938 (config->format != AUDIO_FORMAT_DEFAULT &&
939 !audio_formats_match(config->format, outputDesc->mFormat)) ||
940 (config->channel_mask != 0 && config->channel_mask != outputDesc->mChannelMask)) {
941 ALOGV("getOutputForDevice() failed opening direct output: output %d sample rate %d %d,"
942 "format %d %d, channel mask %04x %04x", output, config->sample_rate,
943 outputDesc->mSamplingRate, config->format, outputDesc->mFormat,
944 config->channel_mask, outputDesc->mChannelMask);
Eric Laurentcf2c0212014-07-25 16:20:43 -0700945 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurentfe231122017-11-17 17:48:06 -0800946 outputDesc->close();
Eric Laurente552edb2014-03-10 17:42:56 -0700947 }
Eric Laurenta82797f2015-01-30 11:49:43 -0800948 // fall back to mixer output if possible when the direct output could not be open
Eric Laurentfe231122017-11-17 17:48:06 -0800949 if (audio_is_linear_pcm(config->format) &&
950 config->sample_rate <= SAMPLE_RATE_HZ_MAX) {
Eric Laurenta82797f2015-01-30 11:49:43 -0800951 goto non_direct_output;
952 }
Eric Laurentcf2c0212014-07-25 16:20:43 -0700953 return AUDIO_IO_HANDLE_NONE;
Eric Laurente552edb2014-03-10 17:42:56 -0700954 }
Eric Laurentcf2c0212014-07-25 16:20:43 -0700955 outputDesc->mRefCount[stream] = 0;
956 outputDesc->mStopTime[stream] = 0;
957 outputDesc->mDirectOpenCount = 1;
Kevin Rocard169753c2017-03-06 14:18:23 -0800958 outputDesc->mDirectClientSession = session;
959
Eric Laurente552edb2014-03-10 17:42:56 -0700960 addOutput(output, outputDesc);
Eric Laurente552edb2014-03-10 17:42:56 -0700961 mPreviousOutputs = mOutputs;
Eric Laurentf4e63452017-11-06 19:31:46 +0000962 ALOGV("getOutputForDevice() returns new direct output %d", output);
Eric Laurentb52c1522014-05-20 11:27:36 -0700963 mpClientInterface->onAudioPortListUpdate();
Eric Laurente552edb2014-03-10 17:42:56 -0700964 return output;
965 }
966
Eric Laurentb732cf52014-09-24 19:08:21 -0700967non_direct_output:
Eric Laurent14cbfca2016-03-17 09:42:16 -0700968
969 // A request for HW A/V sync cannot fallback to a mixed output because time
970 // stamps are embedded in audio data
Phil Burk2d059932018-02-15 15:55:11 -0800971 if ((*flags & (AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_MMAP_NOIRQ)) != 0) {
Eric Laurent14cbfca2016-03-17 09:42:16 -0700972 return AUDIO_IO_HANDLE_NONE;
973 }
974
Eric Laurente552edb2014-03-10 17:42:56 -0700975 // ignoring channel mask due to downmix capability in mixer
976
977 // open a non direct output
978
979 // for non direct outputs, only PCM is supported
Eric Laurentfe231122017-11-17 17:48:06 -0800980 if (audio_is_linear_pcm(config->format)) {
Eric Laurente552edb2014-03-10 17:42:56 -0700981 // get which output is suitable for the specified stream. The actual
982 // routing change will happen when startOutput() will be called
983 SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs);
984
Eric Laurent8838a382014-09-08 16:44:28 -0700985 // at this stage we should ignore the DIRECT flag as no direct output could be found earlier
Nadav Bar766fb022018-01-07 12:18:03 +0200986 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_DIRECT);
987 output = selectOutput(outputs, *flags, config->format);
Eric Laurente552edb2014-03-10 17:42:56 -0700988 }
Eric Laurentf4e63452017-11-06 19:31:46 +0000989 ALOGW_IF((output == 0), "getOutputForDevice() could not find output for stream %d, "
Glenn Kasten49f36ba2017-12-06 13:02:02 -0800990 "sampling rate %d, format %#x, channels %#x, flags %#x",
Nadav Bar766fb022018-01-07 12:18:03 +0200991 stream, config->sample_rate, config->format, config->channel_mask, *flags);
Eric Laurente552edb2014-03-10 17:42:56 -0700992
Eric Laurente552edb2014-03-10 17:42:56 -0700993 return output;
994}
995
Eric Laurente0720872014-03-11 09:30:41 -0700996audio_io_handle_t AudioPolicyManager::selectOutput(const SortedVector<audio_io_handle_t>& outputs,
Eric Laurent8838a382014-09-08 16:44:28 -0700997 audio_output_flags_t flags,
998 audio_format_t format)
Eric Laurente552edb2014-03-10 17:42:56 -0700999{
1000 // select one output among several that provide a path to a particular device or set of
1001 // devices (the list was previously build by getOutputsForDevice()).
1002 // The priority is as follows:
1003 // 1: the output with the highest number of requested policy flags
Eric Laurente6930022016-02-11 10:20:40 -08001004 // 2: the output with the bit depth the closest to the requested one
1005 // 3: the primary output
1006 // 4: the first output in the list
Eric Laurente552edb2014-03-10 17:42:56 -07001007
1008 if (outputs.size() == 0) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001009 return AUDIO_IO_HANDLE_NONE;
Eric Laurente552edb2014-03-10 17:42:56 -07001010 }
1011 if (outputs.size() == 1) {
1012 return outputs[0];
1013 }
1014
1015 int maxCommonFlags = 0;
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001016 audio_io_handle_t outputForFlags = AUDIO_IO_HANDLE_NONE;
1017 audio_io_handle_t outputForPrimary = AUDIO_IO_HANDLE_NONE;
1018 audio_io_handle_t outputForFormat = AUDIO_IO_HANDLE_NONE;
Eric Laurente6930022016-02-11 10:20:40 -08001019 audio_format_t bestFormat = AUDIO_FORMAT_INVALID;
1020 audio_format_t bestFormatForFlags = AUDIO_FORMAT_INVALID;
Eric Laurente552edb2014-03-10 17:42:56 -07001021
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001022 for (audio_io_handle_t output : outputs) {
1023 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
Eric Laurente552edb2014-03-10 17:42:56 -07001024 if (!outputDesc->isDuplicated()) {
Eric Laurent8838a382014-09-08 16:44:28 -07001025 // if a valid format is specified, skip output if not compatible
1026 if (format != AUDIO_FORMAT_INVALID) {
1027 if (outputDesc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
Eric Laurente6930022016-02-11 10:20:40 -08001028 if (!audio_formats_match(format, outputDesc->mFormat)) {
Eric Laurent8838a382014-09-08 16:44:28 -07001029 continue;
1030 }
1031 } else if (!audio_is_linear_pcm(format)) {
1032 continue;
1033 }
Eric Laurente6930022016-02-11 10:20:40 -08001034 if (AudioPort::isBetterFormatMatch(
1035 outputDesc->mFormat, bestFormat, format)) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001036 outputForFormat = output;
Eric Laurente6930022016-02-11 10:20:40 -08001037 bestFormat = outputDesc->mFormat;
1038 }
Eric Laurent8838a382014-09-08 16:44:28 -07001039 }
1040
François Gaffiea8ecc2c2015-11-09 16:10:40 +01001041 int commonFlags = popcount(outputDesc->mProfile->getFlags() & flags);
Eric Laurente6930022016-02-11 10:20:40 -08001042 if (commonFlags >= maxCommonFlags) {
1043 if (commonFlags == maxCommonFlags) {
Andy Hungc9901522017-11-10 20:07:54 -08001044 if (format != AUDIO_FORMAT_INVALID
1045 && AudioPort::isBetterFormatMatch(
1046 outputDesc->mFormat, bestFormatForFlags, format)) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001047 outputForFlags = output;
Eric Laurente6930022016-02-11 10:20:40 -08001048 bestFormatForFlags = outputDesc->mFormat;
1049 }
1050 } else {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001051 outputForFlags = output;
Eric Laurente6930022016-02-11 10:20:40 -08001052 maxCommonFlags = commonFlags;
1053 bestFormatForFlags = outputDesc->mFormat;
1054 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001055 ALOGV("selectOutput() commonFlags for output %d, %04x", output, commonFlags);
Eric Laurente552edb2014-03-10 17:42:56 -07001056 }
François Gaffiea8ecc2c2015-11-09 16:10:40 +01001057 if (outputDesc->mProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001058 outputForPrimary = output;
Eric Laurente552edb2014-03-10 17:42:56 -07001059 }
1060 }
1061 }
1062
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001063 if (outputForFlags != AUDIO_IO_HANDLE_NONE) {
Eric Laurente6930022016-02-11 10:20:40 -08001064 return outputForFlags;
Eric Laurente552edb2014-03-10 17:42:56 -07001065 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001066 if (outputForFormat != AUDIO_IO_HANDLE_NONE) {
Eric Laurente6930022016-02-11 10:20:40 -08001067 return outputForFormat;
1068 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001069 if (outputForPrimary != AUDIO_IO_HANDLE_NONE) {
Eric Laurente6930022016-02-11 10:20:40 -08001070 return outputForPrimary;
Eric Laurente552edb2014-03-10 17:42:56 -07001071 }
1072
1073 return outputs[0];
1074}
1075
Eric Laurente0720872014-03-11 09:30:41 -07001076status_t AudioPolicyManager::startOutput(audio_io_handle_t output,
Eric Laurent3b73df72014-03-11 09:06:29 -07001077 audio_stream_type_t stream,
Eric Laurente83b55d2014-11-14 10:06:21 -08001078 audio_session_t session)
Eric Laurente552edb2014-03-10 17:42:56 -07001079{
Paul McLeanaa981192015-03-21 09:55:15 -07001080 ALOGV("startOutput() output %d, stream %d, session %d",
1081 output, stream, session);
Eric Laurente552edb2014-03-10 17:42:56 -07001082 ssize_t index = mOutputs.indexOfKey(output);
1083 if (index < 0) {
1084 ALOGW("startOutput() unknown output %d", output);
1085 return BAD_VALUE;
1086 }
1087
Eric Laurentc75307b2015-03-17 15:29:32 -07001088 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(index);
1089
Eric Laurent733ce942017-12-07 12:18:25 -08001090 status_t status = outputDesc->start();
1091 if (status != NO_ERROR) {
1092 return status;
Eric Laurent3974e3b2017-12-07 17:58:43 -08001093 }
1094
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001095 // Routing?
1096 mOutputRoutes.incRouteActivity(session);
1097
Eric Laurentc75307b2015-03-17 15:29:32 -07001098 audio_devices_t newDevice;
Eric Laurentc40d9692016-04-13 19:14:13 -07001099 AudioMix *policyMix = NULL;
1100 const char *address = NULL;
Eric Laurentc75307b2015-03-17 15:29:32 -07001101 if (outputDesc->mPolicyMix != NULL) {
Eric Laurentc40d9692016-04-13 19:14:13 -07001102 policyMix = outputDesc->mPolicyMix;
1103 address = policyMix->mDeviceAddress.string();
1104 if ((policyMix->mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) {
1105 newDevice = policyMix->mDeviceType;
1106 } else {
1107 newDevice = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
1108 }
Eric Laurent493404d2015-04-21 15:07:36 -07001109 } else if (mOutputRoutes.hasRouteChanged(session)) {
1110 newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001111 checkStrategyRoute(getStrategy(stream), output);
Eric Laurentc75307b2015-03-17 15:29:32 -07001112 } else {
1113 newDevice = AUDIO_DEVICE_NONE;
1114 }
1115
1116 uint32_t delayMs = 0;
1117
Eric Laurent733ce942017-12-07 12:18:25 -08001118 status = startSource(outputDesc, stream, newDevice, address, &delayMs);
Eric Laurentc75307b2015-03-17 15:29:32 -07001119
1120 if (status != NO_ERROR) {
1121 mOutputRoutes.decRouteActivity(session);
Eric Laurent733ce942017-12-07 12:18:25 -08001122 outputDesc->stop();
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001123 return status;
Eric Laurentc75307b2015-03-17 15:29:32 -07001124 }
1125 // Automatically enable the remote submix input when output is started on a re routing mix
1126 // of type MIX_TYPE_RECORDERS
Eric Laurentc40d9692016-04-13 19:14:13 -07001127 if (audio_is_remote_submix_device(newDevice) && policyMix != NULL &&
1128 policyMix->mMixType == MIX_TYPE_RECORDERS) {
Eric Laurentc75307b2015-03-17 15:29:32 -07001129 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
1130 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
Eric Laurentc40d9692016-04-13 19:14:13 -07001131 address,
Eric Laurentc75307b2015-03-17 15:29:32 -07001132 "remote-submix");
1133 }
1134
1135 if (delayMs != 0) {
1136 usleep(delayMs * 1000);
1137 }
1138
1139 return status;
1140}
1141
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001142status_t AudioPolicyManager::startSource(const sp<AudioOutputDescriptor>& outputDesc,
Eric Laurentc75307b2015-03-17 15:29:32 -07001143 audio_stream_type_t stream,
1144 audio_devices_t device,
Eric Laurentc40d9692016-04-13 19:14:13 -07001145 const char *address,
Eric Laurentc75307b2015-03-17 15:29:32 -07001146 uint32_t *delayMs)
1147{
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001148 // cannot start playback of STREAM_TTS if any other output is being used
1149 uint32_t beaconMuteLatency = 0;
Eric Laurentc75307b2015-03-17 15:29:32 -07001150
1151 *delayMs = 0;
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001152 if (stream == AUDIO_STREAM_TTS) {
1153 ALOGV("\t found BEACON stream");
Eric Laurent9459fb02015-08-12 18:36:32 -07001154 if (!mTtsOutputAvailable && mOutputs.isAnyOutputActive(AUDIO_STREAM_TTS /*streamToIgnore*/)) {
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001155 return INVALID_OPERATION;
1156 } else {
1157 beaconMuteLatency = handleEventForBeacon(STARTING_BEACON);
1158 }
1159 } else {
1160 // some playback other than beacon starts
1161 beaconMuteLatency = handleEventForBeacon(STARTING_OUTPUT);
1162 }
1163
Eric Laurent77305a62016-07-25 16:39:22 -07001164 // force device change if the output is inactive and no audio patch is already present.
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001165 // check active before incrementing usage count
Eric Laurent77305a62016-07-25 16:39:22 -07001166 bool force = !outputDesc->isActive() &&
1167 (outputDesc->getPatchHandle() == AUDIO_PATCH_HANDLE_NONE);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001168
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001169 // requiresMuteCheck is false when we can bypass mute strategy.
1170 // It covers a common case when there is no materially active audio
1171 // and muting would result in unnecessary delay and dropped audio.
1172 const uint32_t outputLatencyMs = outputDesc->latency();
1173 bool requiresMuteCheck = outputDesc->isActive(outputLatencyMs * 2); // account for drain
1174
Eric Laurente552edb2014-03-10 17:42:56 -07001175 // increment usage count for this stream on the requested output:
1176 // NOTE that the usage count is the same for duplicated output and hardware output which is
1177 // necessary for a correct control of hardware output routing by startOutput() and stopOutput()
1178 outputDesc->changeRefCount(stream, 1);
1179
Eric Laurent36829f92017-04-07 19:04:42 -07001180 if (stream == AUDIO_STREAM_MUSIC) {
1181 selectOutputForMusicEffects();
1182 }
1183
Eric Laurent493404d2015-04-21 15:07:36 -07001184 if (outputDesc->mRefCount[stream] == 1 || device != AUDIO_DEVICE_NONE) {
Eric Laurent275e8e92014-11-30 15:14:47 -08001185 // starting an output being rerouted?
Eric Laurentc75307b2015-03-17 15:29:32 -07001186 if (device == AUDIO_DEVICE_NONE) {
1187 device = getNewOutputDevice(outputDesc, false /*fromCache*/);
Eric Laurent275e8e92014-11-30 15:14:47 -08001188 }
Eric Laurent36829f92017-04-07 19:04:42 -07001189
Eric Laurente552edb2014-03-10 17:42:56 -07001190 routing_strategy strategy = getStrategy(stream);
1191 bool shouldWait = (strategy == STRATEGY_SONIFICATION) ||
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001192 (strategy == STRATEGY_SONIFICATION_RESPECTFUL) ||
1193 (beaconMuteLatency > 0);
1194 uint32_t waitMs = beaconMuteLatency;
Eric Laurente552edb2014-03-10 17:42:56 -07001195 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurent1f2f2232014-06-02 12:01:23 -07001196 sp<AudioOutputDescriptor> desc = mOutputs.valueAt(i);
Eric Laurente552edb2014-03-10 17:42:56 -07001197 if (desc != outputDesc) {
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001198 // An output has a shared device if
1199 // - managed by the same hw module
1200 // - supports the currently selected device
1201 const bool sharedDevice = outputDesc->sharesHwModuleWith(desc)
1202 && (desc->supportedDevices() & device) != AUDIO_DEVICE_NONE;
1203
Eric Laurent77305a62016-07-25 16:39:22 -07001204 // force a device change if any other output is:
1205 // - managed by the same hw module
Jean-Michel Trivi4a5b4812018-02-08 17:22:32 +00001206 // - supports currently selected device
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001207 // - has a current device selection that differs from selected device.
Eric Laurent77305a62016-07-25 16:39:22 -07001208 // - has an active audio patch
Eric Laurente552edb2014-03-10 17:42:56 -07001209 // In this case, the audio HAL must receive the new device selection so that it can
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001210 // change the device currently selected by the other output.
1211 if (sharedDevice &&
Eric Laurent77305a62016-07-25 16:39:22 -07001212 desc->device() != device &&
Eric Laurent77305a62016-07-25 16:39:22 -07001213 desc->getPatchHandle() != AUDIO_PATCH_HANDLE_NONE) {
Eric Laurente552edb2014-03-10 17:42:56 -07001214 force = true;
1215 }
1216 // wait for audio on other active outputs to be presented when starting
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001217 // a notification so that audio focus effect can propagate, or that a mute/unmute
1218 // event occurred for beacon
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001219 const uint32_t latencyMs = desc->latency();
1220 const bool isActive = desc->isActive(latencyMs * 2); // account for drain
1221
1222 if (shouldWait && isActive && (waitMs < latencyMs)) {
1223 waitMs = latencyMs;
Eric Laurente552edb2014-03-10 17:42:56 -07001224 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001225
1226 // Require mute check if another output is on a shared device
1227 // and currently active to have proper drain and avoid pops.
1228 // Note restoring AudioTracks onto this output needs to invoke
1229 // a volume ramp if there is no mute.
1230 requiresMuteCheck |= sharedDevice && isActive;
Eric Laurente552edb2014-03-10 17:42:56 -07001231 }
1232 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001233
1234 const uint32_t muteWaitMs =
1235 setOutputDevice(outputDesc, device, force, 0, NULL, address, requiresMuteCheck);
Eric Laurente552edb2014-03-10 17:42:56 -07001236
1237 // handle special case for sonification while in call
1238 if (isInCall()) {
1239 handleIncallSonification(stream, true, false);
1240 }
1241
1242 // apply volume rules for current stream and device if necessary
1243 checkAndSetVolume(stream,
Shuhei Miyazaki6fe70332017-07-31 15:21:28 +09001244 mVolumeCurves->getVolumeIndex(stream, outputDesc->device()),
Eric Laurentc75307b2015-03-17 15:29:32 -07001245 outputDesc,
Shuhei Miyazaki6fe70332017-07-31 15:21:28 +09001246 outputDesc->device());
Eric Laurente552edb2014-03-10 17:42:56 -07001247
1248 // update the outputs if starting an output with a stream that can affect notification
1249 // routing
1250 handleNotificationRoutingForStream(stream);
Eric Laurentc722f302014-12-10 11:21:49 -08001251
Eric Laurent2cbe89a2014-12-19 11:49:08 -08001252 // force reevaluating accessibility routing when ringtone or alarm starts
1253 if (strategy == STRATEGY_SONIFICATION) {
1254 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
1255 }
Eric Laurentdc462862016-07-19 12:29:53 -07001256
1257 if (waitMs > muteWaitMs) {
1258 *delayMs = waitMs - muteWaitMs;
1259 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001260
1261 // FIXME: A device change (muteWaitMs > 0) likely introduces a volume change.
1262 // A volume change enacted by APM with 0 delay is not synchronous, as it goes
1263 // via AudioCommandThread to AudioFlinger. Hence it is possible that the volume
1264 // change occurs after the MixerThread starts and causes a stream volume
1265 // glitch.
1266 //
1267 // We do not introduce additional delay here.
Eric Laurente552edb2014-03-10 17:42:56 -07001268 }
Eric Laurentdc462862016-07-19 12:29:53 -07001269
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09001270 if (stream == AUDIO_STREAM_ENFORCED_AUDIBLE &&
1271 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
1272 setStrategyMute(STRATEGY_SONIFICATION, true, outputDesc);
1273 }
1274
Eric Laurente552edb2014-03-10 17:42:56 -07001275 return NO_ERROR;
1276}
1277
1278
Eric Laurente0720872014-03-11 09:30:41 -07001279status_t AudioPolicyManager::stopOutput(audio_io_handle_t output,
Eric Laurent3b73df72014-03-11 09:06:29 -07001280 audio_stream_type_t stream,
Eric Laurente83b55d2014-11-14 10:06:21 -08001281 audio_session_t session)
Eric Laurente552edb2014-03-10 17:42:56 -07001282{
1283 ALOGV("stopOutput() output %d, stream %d, session %d", output, stream, session);
1284 ssize_t index = mOutputs.indexOfKey(output);
1285 if (index < 0) {
1286 ALOGW("stopOutput() unknown output %d", output);
1287 return BAD_VALUE;
1288 }
1289
Eric Laurentc75307b2015-03-17 15:29:32 -07001290 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(index);
Eric Laurente552edb2014-03-10 17:42:56 -07001291
Eric Laurentc75307b2015-03-17 15:29:32 -07001292 if (outputDesc->mRefCount[stream] == 1) {
1293 // Automatically disable the remote submix input when output is stopped on a
1294 // re routing mix of type MIX_TYPE_RECORDERS
1295 if (audio_is_remote_submix_device(outputDesc->mDevice) &&
1296 outputDesc->mPolicyMix != NULL &&
1297 outputDesc->mPolicyMix->mMixType == MIX_TYPE_RECORDERS) {
1298 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
1299 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08001300 outputDesc->mPolicyMix->mDeviceAddress,
Eric Laurentc75307b2015-03-17 15:29:32 -07001301 "remote-submix");
1302 }
1303 }
1304
1305 // Routing?
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001306 bool forceDeviceUpdate = false;
Eric Laurentc75307b2015-03-17 15:29:32 -07001307 if (outputDesc->mRefCount[stream] > 0) {
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001308 int activityCount = mOutputRoutes.decRouteActivity(session);
1309 forceDeviceUpdate = (mOutputRoutes.hasRoute(session) && (activityCount == 0));
1310
1311 if (forceDeviceUpdate) {
1312 checkStrategyRoute(getStrategy(stream), AUDIO_IO_HANDLE_NONE);
1313 }
Eric Laurentc75307b2015-03-17 15:29:32 -07001314 }
1315
Eric Laurent3974e3b2017-12-07 17:58:43 -08001316 status_t status = stopSource(outputDesc, stream, forceDeviceUpdate);
1317
Eric Laurent733ce942017-12-07 12:18:25 -08001318 if (status == NO_ERROR ) {
1319 outputDesc->stop();
Eric Laurent3974e3b2017-12-07 17:58:43 -08001320 }
1321 return status;
Eric Laurentc75307b2015-03-17 15:29:32 -07001322}
1323
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001324status_t AudioPolicyManager::stopSource(const sp<AudioOutputDescriptor>& outputDesc,
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001325 audio_stream_type_t stream,
1326 bool forceDeviceUpdate)
Eric Laurentc75307b2015-03-17 15:29:32 -07001327{
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001328 // always handle stream stop, check which stream type is stopping
1329 handleEventForBeacon(stream == AUDIO_STREAM_TTS ? STOPPING_BEACON : STOPPING_OUTPUT);
1330
Eric Laurente552edb2014-03-10 17:42:56 -07001331 // handle special case for sonification while in call
1332 if (isInCall()) {
1333 handleIncallSonification(stream, false, false);
1334 }
1335
1336 if (outputDesc->mRefCount[stream] > 0) {
1337 // decrement usage count of this stream on the output
1338 outputDesc->changeRefCount(stream, -1);
Paul McLeanaa981192015-03-21 09:55:15 -07001339
Eric Laurente552edb2014-03-10 17:42:56 -07001340 // store time at which the stream was stopped - see isStreamActive()
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001341 if (outputDesc->mRefCount[stream] == 0 || forceDeviceUpdate) {
Eric Laurente552edb2014-03-10 17:42:56 -07001342 outputDesc->mStopTime[stream] = systemTime();
Eric Laurentc75307b2015-03-17 15:29:32 -07001343 audio_devices_t newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/);
Eric Laurente552edb2014-03-10 17:42:56 -07001344 // delay the device switch by twice the latency because stopOutput() is executed when
1345 // the track stop() command is received and at that time the audio track buffer can
1346 // still contain data that needs to be drained. The latency only covers the audio HAL
1347 // and kernel buffers. Also the latency does not always include additional delay in the
1348 // audio path (audio DSP, CODEC ...)
Eric Laurentc75307b2015-03-17 15:29:32 -07001349 setOutputDevice(outputDesc, newDevice, false, outputDesc->latency()*2);
Eric Laurente552edb2014-03-10 17:42:56 -07001350
1351 // force restoring the device selection on other active outputs if it differs from the
1352 // one being selected for this output
Eric Laurent57de36c2016-09-28 16:59:11 -07001353 uint32_t delayMs = outputDesc->latency()*2;
Eric Laurente552edb2014-03-10 17:42:56 -07001354 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurent1f2f2232014-06-02 12:01:23 -07001355 sp<AudioOutputDescriptor> desc = mOutputs.valueAt(i);
Eric Laurentc75307b2015-03-17 15:29:32 -07001356 if (desc != outputDesc &&
Eric Laurente552edb2014-03-10 17:42:56 -07001357 desc->isActive() &&
1358 outputDesc->sharesHwModuleWith(desc) &&
1359 (newDevice != desc->device())) {
Haynes Mathew George11c499a2016-08-26 12:08:25 -07001360 audio_devices_t newDevice2 = getNewOutputDevice(desc, false /*fromCache*/);
1361 bool force = desc->device() != newDevice2;
Eric Laurentc75307b2015-03-17 15:29:32 -07001362 setOutputDevice(desc,
Haynes Mathew George11c499a2016-08-26 12:08:25 -07001363 newDevice2,
1364 force,
Eric Laurent57de36c2016-09-28 16:59:11 -07001365 delayMs);
1366 // re-apply device specific volume if not done by setOutputDevice()
1367 if (!force) {
1368 applyStreamVolumes(desc, newDevice2, delayMs);
1369 }
Eric Laurente552edb2014-03-10 17:42:56 -07001370 }
1371 }
1372 // update the outputs if stopping one with a stream that can affect notification routing
1373 handleNotificationRoutingForStream(stream);
1374 }
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09001375
1376 if (stream == AUDIO_STREAM_ENFORCED_AUDIBLE &&
1377 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
1378 setStrategyMute(STRATEGY_SONIFICATION, false, outputDesc);
1379 }
1380
Eric Laurent36829f92017-04-07 19:04:42 -07001381 if (stream == AUDIO_STREAM_MUSIC) {
1382 selectOutputForMusicEffects();
1383 }
Eric Laurente552edb2014-03-10 17:42:56 -07001384 return NO_ERROR;
1385 } else {
Eric Laurentc75307b2015-03-17 15:29:32 -07001386 ALOGW("stopOutput() refcount is already 0");
Eric Laurente552edb2014-03-10 17:42:56 -07001387 return INVALID_OPERATION;
1388 }
1389}
1390
Eric Laurente83b55d2014-11-14 10:06:21 -08001391void AudioPolicyManager::releaseOutput(audio_io_handle_t output,
Eric Laurentcaf7f482014-11-25 17:50:47 -08001392 audio_stream_type_t stream __unused,
1393 audio_session_t session __unused)
Eric Laurente552edb2014-03-10 17:42:56 -07001394{
1395 ALOGV("releaseOutput() %d", output);
1396 ssize_t index = mOutputs.indexOfKey(output);
1397 if (index < 0) {
1398 ALOGW("releaseOutput() releasing unknown output %d", output);
1399 return;
1400 }
1401
Paul McLeanaa981192015-03-21 09:55:15 -07001402 // Routing
1403 mOutputRoutes.removeRoute(session);
1404
Eric Laurentc75307b2015-03-17 15:29:32 -07001405 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(index);
Eric Laurent3b73df72014-03-11 09:06:29 -07001406 if (desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
Eric Laurente552edb2014-03-10 17:42:56 -07001407 if (desc->mDirectOpenCount <= 0) {
1408 ALOGW("releaseOutput() invalid open count %d for output %d",
1409 desc->mDirectOpenCount, output);
1410 return;
1411 }
1412 if (--desc->mDirectOpenCount == 0) {
1413 closeOutput(output);
Eric Laurentb52c1522014-05-20 11:27:36 -07001414 mpClientInterface->onAudioPortListUpdate();
Eric Laurente552edb2014-03-10 17:42:56 -07001415 }
1416 }
1417}
1418
1419
Eric Laurentcaf7f482014-11-25 17:50:47 -08001420status_t AudioPolicyManager::getInputForAttr(const audio_attributes_t *attr,
1421 audio_io_handle_t *input,
1422 audio_session_t session,
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001423 uid_t uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001424 const audio_config_base_t *config,
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -08001425 audio_input_flags_t flags,
Eric Laurent2ac76942017-06-22 17:17:09 -07001426 audio_port_handle_t *selectedDeviceId,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001427 input_type_t *inputType,
1428 audio_port_handle_t *portId)
Eric Laurente552edb2014-03-10 17:42:56 -07001429{
Glenn Kasten49f36ba2017-12-06 13:02:02 -08001430 ALOGV("getInputForAttr() source %d, sampling rate %d, format %#x, channel mask %#x,"
Eric Laurentcaf7f482014-11-25 17:50:47 -08001431 "session %d, flags %#x",
Eric Laurent20b9ef02016-12-05 11:03:16 -08001432 attr->source, config->sample_rate, config->format, config->channel_mask, session, flags);
Eric Laurente552edb2014-03-10 17:42:56 -07001433
Eric Laurentad2e7b92017-09-14 20:06:42 -07001434 status_t status = NO_ERROR;
Eric Laurent275e8e92014-11-30 15:14:47 -08001435 // handle legacy remote submix case where the address was not always specified
1436 String8 address = String8("");
Eric Laurentc447ded2015-01-06 08:47:05 -08001437 audio_source_t halInputSource;
Eric Laurentad2e7b92017-09-14 20:06:42 -07001438 audio_source_t inputSource = attr->source;
Eric Laurentc722f302014-12-10 11:21:49 -08001439 AudioMix *policyMix = NULL;
Eric Laurentad2e7b92017-09-14 20:06:42 -07001440 DeviceVector inputDevices;
Eric Laurent20b9ef02016-12-05 11:03:16 -08001441
Eric Laurentfe231122017-11-17 17:48:06 -08001442 if (inputSource == AUDIO_SOURCE_DEFAULT) {
1443 inputSource = AUDIO_SOURCE_MIC;
1444 }
1445
Paul McLean466dc8e2015-04-17 13:15:36 -06001446 // Explicit routing?
1447 sp<DeviceDescriptor> deviceDesc;
Eric Laurent2ac76942017-06-22 17:17:09 -07001448 if (*selectedDeviceId != AUDIO_PORT_HANDLE_NONE) {
jiabinc0c831a2018-01-29 17:55:15 -08001449 deviceDesc = mAvailableInputDevices.getDeviceFromId(*selectedDeviceId);
Paul McLean466dc8e2015-04-17 13:15:36 -06001450 }
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001451 mInputRoutes.addRoute(session, SessionRoute::STREAM_TYPE_NA, inputSource, deviceDesc, uid);
Paul McLean466dc8e2015-04-17 13:15:36 -06001452
Eric Laurentad2e7b92017-09-14 20:06:42 -07001453 // special case for mmap capture: if an input IO handle is specified, we reuse this input if
1454 // possible
1455 if ((flags & AUDIO_INPUT_FLAG_MMAP_NOIRQ) == AUDIO_INPUT_FLAG_MMAP_NOIRQ &&
1456 *input != AUDIO_IO_HANDLE_NONE) {
1457 ssize_t index = mInputs.indexOfKey(*input);
1458 if (index < 0) {
1459 ALOGW("getInputForAttr() unknown MMAP input %d", *input);
1460 status = BAD_VALUE;
1461 goto error;
1462 }
1463 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index);
1464 sp<AudioSession> audioSession = inputDesc->getAudioSession(session);
1465 if (audioSession == 0) {
1466 ALOGW("getInputForAttr() unknown session %d on input %d", session, *input);
1467 status = BAD_VALUE;
1468 goto error;
1469 }
1470 // For MMAP mode, the first call to getInputForAttr() is made on behalf of audioflinger.
1471 // The second call is for the first active client and sets the UID. Any further call
Eric Laurent331679c2018-04-16 17:03:16 -07001472 // corresponds to a new client and is only permitted from the same UID.
1473 // If the first UID is silenced, allow a new UID connection and replace with new UID
Eric Laurentad2e7b92017-09-14 20:06:42 -07001474 if (audioSession->openCount() == 1) {
1475 audioSession->setUid(uid);
1476 } else if (audioSession->uid() != uid) {
Eric Laurent331679c2018-04-16 17:03:16 -07001477 if (!audioSession->isSilenced()) {
1478 ALOGW("getInputForAttr() bad uid %d for session %d uid %d",
1479 uid, session, audioSession->uid());
1480 status = INVALID_OPERATION;
1481 goto error;
1482 }
1483 audioSession->setUid(uid);
1484 audioSession->setSilenced(false);
Eric Laurentad2e7b92017-09-14 20:06:42 -07001485 }
1486 audioSession->changeOpenCount(1);
1487 *inputType = API_INPUT_LEGACY;
1488 if (*portId == AUDIO_PORT_HANDLE_NONE) {
1489 *portId = AudioPort::getNextUniqueId();
1490 }
1491 inputDevices = mAvailableInputDevices.getDevicesFromType(inputDesc->mDevice);
1492 *selectedDeviceId = inputDevices.size() > 0 ? inputDevices.itemAt(0)->getId()
1493 : AUDIO_PORT_HANDLE_NONE;
1494 ALOGI("%s reusing MMAP input %d for session %d", __FUNCTION__, *input, session);
1495
1496 return NO_ERROR;
1497 }
1498
1499 *input = AUDIO_IO_HANDLE_NONE;
1500 *inputType = API_INPUT_INVALID;
1501
Eric Laurentad2e7b92017-09-14 20:06:42 -07001502 halInputSource = inputSource;
1503
1504 // TODO: check for existing client for this port ID
1505 if (*portId == AUDIO_PORT_HANDLE_NONE) {
1506 *portId = AudioPort::getNextUniqueId();
1507 }
1508
1509 audio_devices_t device;
1510
Eric Laurentc447ded2015-01-06 08:47:05 -08001511 if (inputSource == AUDIO_SOURCE_REMOTE_SUBMIX &&
Eric Laurent275e8e92014-11-30 15:14:47 -08001512 strncmp(attr->tags, "addr=", strlen("addr=")) == 0) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07001513 status = mPolicyMixes.getInputMixForAttr(*attr, &policyMix);
1514 if (status != NO_ERROR) {
1515 goto error;
François Gaffie036e1e92015-03-19 10:16:24 +01001516 }
1517 *inputType = API_INPUT_MIX_EXT_POLICY_REROUTE;
Eric Laurent275e8e92014-11-30 15:14:47 -08001518 device = AUDIO_DEVICE_IN_REMOTE_SUBMIX;
1519 address = String8(attr->tags + strlen("addr="));
Eric Laurent275e8e92014-11-30 15:14:47 -08001520 } else {
Eric Laurentc447ded2015-01-06 08:47:05 -08001521 device = getDeviceAndMixForInputSource(inputSource, &policyMix);
Eric Laurent275e8e92014-11-30 15:14:47 -08001522 if (device == AUDIO_DEVICE_NONE) {
Eric Laurentc447ded2015-01-06 08:47:05 -08001523 ALOGW("getInputForAttr() could not find device for source %d", inputSource);
Eric Laurentad2e7b92017-09-14 20:06:42 -07001524 status = BAD_VALUE;
1525 goto error;
Eric Laurent275e8e92014-11-30 15:14:47 -08001526 }
Eric Laurentc722f302014-12-10 11:21:49 -08001527 if (policyMix != NULL) {
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08001528 address = policyMix->mDeviceAddress;
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -08001529 if (policyMix->mMixType == MIX_TYPE_RECORDERS) {
1530 // there is an external policy, but this input is attached to a mix of recorders,
1531 // meaning it receives audio injected into the framework, so the recorder doesn't
1532 // know about it and is therefore considered "legacy"
1533 *inputType = API_INPUT_LEGACY;
1534 } else {
1535 // recording a mix of players defined by an external policy, we're rerouting for
1536 // an external policy
1537 *inputType = API_INPUT_MIX_EXT_POLICY_REROUTE;
1538 }
Eric Laurentc722f302014-12-10 11:21:49 -08001539 } else if (audio_is_remote_submix_device(device)) {
1540 address = String8("0");
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -08001541 *inputType = API_INPUT_MIX_CAPTURE;
Eric Laurent82db2692015-08-07 13:59:42 -07001542 } else if (device == AUDIO_DEVICE_IN_TELEPHONY_RX) {
1543 *inputType = API_INPUT_TELEPHONY_RX;
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -08001544 } else {
1545 *inputType = API_INPUT_LEGACY;
Eric Laurentc722f302014-12-10 11:21:49 -08001546 }
Ravi Kumar Alamandab367f5b2015-08-25 08:21:37 -07001547
Eric Laurent599c7582015-12-07 18:05:55 -08001548 }
1549
1550 *input = getInputForDevice(device, address, session, uid, inputSource,
Eric Laurentfe231122017-11-17 17:48:06 -08001551 config, flags,
Eric Laurent599c7582015-12-07 18:05:55 -08001552 policyMix);
1553 if (*input == AUDIO_IO_HANDLE_NONE) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07001554 status = INVALID_OPERATION;
1555 goto error;
Eric Laurent599c7582015-12-07 18:05:55 -08001556 }
Eric Laurent20b9ef02016-12-05 11:03:16 -08001557
Eric Laurentad2e7b92017-09-14 20:06:42 -07001558 inputDevices = mAvailableInputDevices.getDevicesFromType(device);
Eric Laurent2ac76942017-06-22 17:17:09 -07001559 *selectedDeviceId = inputDevices.size() > 0 ? inputDevices.itemAt(0)->getId()
1560 : AUDIO_PORT_HANDLE_NONE;
1561
1562 ALOGV("getInputForAttr() returns input %d type %d selectedDeviceId %d",
1563 *input, *inputType, *selectedDeviceId);
1564
Eric Laurent599c7582015-12-07 18:05:55 -08001565 return NO_ERROR;
Eric Laurentad2e7b92017-09-14 20:06:42 -07001566
1567error:
1568 mInputRoutes.removeRoute(session);
1569 return status;
Eric Laurent599c7582015-12-07 18:05:55 -08001570}
1571
1572
1573audio_io_handle_t AudioPolicyManager::getInputForDevice(audio_devices_t device,
1574 String8 address,
1575 audio_session_t session,
1576 uid_t uid,
1577 audio_source_t inputSource,
Eric Laurentfe231122017-11-17 17:48:06 -08001578 const audio_config_base_t *config,
Eric Laurent599c7582015-12-07 18:05:55 -08001579 audio_input_flags_t flags,
1580 AudioMix *policyMix)
1581{
1582 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
1583 audio_source_t halInputSource = inputSource;
1584 bool isSoundTrigger = false;
1585
1586 if (inputSource == AUDIO_SOURCE_HOTWORD) {
1587 ssize_t index = mSoundTriggerSessions.indexOfKey(session);
1588 if (index >= 0) {
1589 input = mSoundTriggerSessions.valueFor(session);
1590 isSoundTrigger = true;
1591 flags = (audio_input_flags_t)(flags | AUDIO_INPUT_FLAG_HW_HOTWORD);
1592 ALOGV("SoundTrigger capture on session %d input %d", session, input);
1593 } else {
1594 halInputSource = AUDIO_SOURCE_VOICE_RECOGNITION;
Eric Laurent5dbe4712014-09-19 19:04:57 -07001595 }
Haynes Mathew George851d3ff2017-06-19 20:01:57 -07001596 } else if (inputSource == AUDIO_SOURCE_VOICE_COMMUNICATION &&
Eric Laurentfe231122017-11-17 17:48:06 -08001597 audio_is_linear_pcm(config->format)) {
Haynes Mathew George851d3ff2017-06-19 20:01:57 -07001598 flags = (audio_input_flags_t)(flags | AUDIO_INPUT_FLAG_VOIP_TX);
Eric Laurent5dbe4712014-09-19 19:04:57 -07001599 }
1600
Andy Hungf129b032015-04-07 13:45:50 -07001601 // find a compatible input profile (not necessarily identical in parameters)
1602 sp<IOProfile> profile;
Eric Laurentfe231122017-11-17 17:48:06 -08001603 // sampling rate and flags may be updated by getInputProfile
1604 uint32_t profileSamplingRate = (config->sample_rate == 0) ?
1605 SAMPLE_RATE_HZ_DEFAULT : config->sample_rate;
Glenn Kasten730b9262018-03-29 15:01:26 -07001606 audio_format_t profileFormat;
Eric Laurentfe231122017-11-17 17:48:06 -08001607 audio_channel_mask_t profileChannelMask = config->channel_mask;
Andy Hungf129b032015-04-07 13:45:50 -07001608 audio_input_flags_t profileFlags = flags;
1609 for (;;) {
Glenn Kasten730b9262018-03-29 15:01:26 -07001610 profileFormat = config->format; // reset each time through loop, in case it is updated
Eric Laurent275e8e92014-11-30 15:14:47 -08001611 profile = getInputProfile(device, address,
Andy Hungf129b032015-04-07 13:45:50 -07001612 profileSamplingRate, profileFormat, profileChannelMask,
1613 profileFlags);
1614 if (profile != 0) {
1615 break; // success
Eric Laurent05067782016-06-01 18:27:28 -07001616 } else if (profileFlags & AUDIO_INPUT_FLAG_RAW) {
1617 profileFlags = (audio_input_flags_t) (profileFlags & ~AUDIO_INPUT_FLAG_RAW); // retry
Andy Hungf129b032015-04-07 13:45:50 -07001618 } else if (profileFlags != AUDIO_INPUT_FLAG_NONE) {
1619 profileFlags = AUDIO_INPUT_FLAG_NONE; // retry
1620 } else { // fail
Glenn Kastenfaa10a62017-05-25 15:52:05 -07001621 ALOGW("getInputForDevice() could not find profile for device 0x%X, "
Eric Laurentfe231122017-11-17 17:48:06 -08001622 "sampling rate %u, format %#x, channel mask 0x%X, flags %#x",
1623 device, config->sample_rate, config->format, config->channel_mask, flags);
Eric Laurent599c7582015-12-07 18:05:55 -08001624 return input;
Eric Laurent5dbe4712014-09-19 19:04:57 -07001625 }
Eric Laurente552edb2014-03-10 17:42:56 -07001626 }
Glenn Kasten05ddca52016-02-11 08:17:12 -08001627 // Pick input sampling rate if not specified by client
Eric Laurentfe231122017-11-17 17:48:06 -08001628 uint32_t samplingRate = config->sample_rate;
Glenn Kasten05ddca52016-02-11 08:17:12 -08001629 if (samplingRate == 0) {
1630 samplingRate = profileSamplingRate;
1631 }
Eric Laurente552edb2014-03-10 17:42:56 -07001632
Eric Laurent322b4d22015-04-03 15:57:54 -07001633 if (profile->getModuleHandle() == 0) {
1634 ALOGE("getInputForAttr(): HW module %s not opened", profile->getModuleName());
Eric Laurent599c7582015-12-07 18:05:55 -08001635 return input;
Eric Laurentcf2c0212014-07-25 16:20:43 -07001636 }
1637
Eric Laurent599c7582015-12-07 18:05:55 -08001638 sp<AudioSession> audioSession = new AudioSession(session,
Eric Laurentfe231122017-11-17 17:48:06 -08001639 inputSource,
1640 config->format,
1641 samplingRate,
1642 config->channel_mask,
1643 flags,
1644 uid,
1645 isSoundTrigger,
1646 policyMix, mpClientInterface);
Eric Laurent599c7582015-12-07 18:05:55 -08001647
Eric Laurent74708e72017-04-07 17:13:42 -07001648// FIXME: disable concurrent capture until UI is ready
1649#if 0
Eric Laurent599c7582015-12-07 18:05:55 -08001650 // reuse an open input if possible
Eric Laurent555530a2017-02-07 18:17:24 -08001651 sp<AudioInputDescriptor> reusedInputDesc;
Eric Laurent599c7582015-12-07 18:05:55 -08001652 for (size_t i = 0; i < mInputs.size(); i++) {
1653 sp<AudioInputDescriptor> desc = mInputs.valueAt(i);
Eric Laurentfb66dd92016-01-28 18:32:03 -08001654 // reuse input if:
1655 // - it shares the same profile
1656 // AND
1657 // - it is not a reroute submix input
1658 // AND
1659 // - it is: not used for sound trigger
1660 // OR
1661 // used for sound trigger and all clients use the same session ID
1662 //
1663 if ((profile == desc->mProfile) &&
1664 (isSoundTrigger == desc->isSoundTrigger()) &&
1665 !is_virtual_input_device(device)) {
Eric Laurent599c7582015-12-07 18:05:55 -08001666
1667 sp<AudioSession> as = desc->getAudioSession(session);
1668 if (as != 0) {
1669 // do not allow unmatching properties on same session
1670 if (as->matches(audioSession)) {
1671 as->changeOpenCount(1);
1672 } else {
1673 ALOGW("getInputForDevice() record with different attributes"
1674 " exists for session %d", session);
Eric Laurent555530a2017-02-07 18:17:24 -08001675 continue;
Eric Laurent599c7582015-12-07 18:05:55 -08001676 }
Eric Laurentfb66dd92016-01-28 18:32:03 -08001677 } else if (isSoundTrigger) {
Eric Laurent555530a2017-02-07 18:17:24 -08001678 continue;
Eric Laurentfb66dd92016-01-28 18:32:03 -08001679 }
Eric Laurentbb948092017-01-23 18:33:30 -08001680
Eric Laurent555530a2017-02-07 18:17:24 -08001681 // Reuse the already opened input stream on this profile if:
1682 // - the new capture source is background OR
1683 // - the path requested configurations match OR
1684 // - the new source priority is less than the highest source priority on this input
1685 // If the input stream cannot be reused, close it before opening a new stream
1686 // on the same profile for the new client so that the requested path configuration
1687 // can be selected.
1688 if (!isConcurrentSource(inputSource) &&
Eric Laurentbb948092017-01-23 18:33:30 -08001689 ((desc->mSamplingRate != samplingRate ||
Eric Laurentfe231122017-11-17 17:48:06 -08001690 desc->mChannelMask != config->channel_mask ||
1691 !audio_formats_match(desc->mFormat, config->format)) &&
Eric Laurentfb66dd92016-01-28 18:32:03 -08001692 (source_priority(desc->getHighestPrioritySource(false /*activeOnly*/)) <
Eric Laurentbb948092017-01-23 18:33:30 -08001693 source_priority(inputSource)))) {
Eric Laurent555530a2017-02-07 18:17:24 -08001694 reusedInputDesc = desc;
1695 continue;
Eric Laurent599c7582015-12-07 18:05:55 -08001696 } else {
1697 desc->addAudioSession(session, audioSession);
Eric Laurentfb66dd92016-01-28 18:32:03 -08001698 ALOGV("%s: reusing input %d", __FUNCTION__, mInputs.keyAt(i));
1699 return mInputs.keyAt(i);
Eric Laurent599c7582015-12-07 18:05:55 -08001700 }
Eric Laurent599c7582015-12-07 18:05:55 -08001701 }
1702 }
Eric Laurent599c7582015-12-07 18:05:55 -08001703
Eric Laurent555530a2017-02-07 18:17:24 -08001704 if (reusedInputDesc != 0) {
1705 AudioSessionCollection sessions = reusedInputDesc->getAudioSessions(false /*activeOnly*/);
1706 for (size_t j = 0; j < sessions.size(); j++) {
1707 audio_session_t currentSession = sessions.keyAt(j);
1708 stopInput(reusedInputDesc->mIoHandle, currentSession);
1709 releaseInput(reusedInputDesc->mIoHandle, currentSession);
1710 }
1711 }
Eric Laurent74708e72017-04-07 17:13:42 -07001712#endif
Eric Laurent555530a2017-02-07 18:17:24 -08001713
Eric Laurent3974e3b2017-12-07 17:58:43 -08001714 if (!profile->canOpenNewIo()) {
1715 return AUDIO_IO_HANDLE_NONE;
1716 }
1717
Eric Laurentfe231122017-11-17 17:48:06 -08001718 sp<AudioInputDescriptor> inputDesc = new AudioInputDescriptor(profile, mpClientInterface);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001719
Eric Laurentfe231122017-11-17 17:48:06 -08001720 audio_config_t lConfig = AUDIO_CONFIG_INITIALIZER;
1721 lConfig.sample_rate = profileSamplingRate;
1722 lConfig.channel_mask = profileChannelMask;
1723 lConfig.format = profileFormat;
Eric Laurente3014102017-05-03 11:15:43 -07001724
Eric Laurent53b810e2017-12-10 17:25:10 -08001725 if (address == "") {
1726 DeviceVector inputDevices = mAvailableInputDevices.getDevicesFromType(device);
1727 // the inputs vector must be of size >= 1, but we don't want to crash here
1728 address = inputDevices.size() > 0 ? inputDevices.itemAt(0)->mAddress : String8("");
1729 }
1730
Eric Laurentfe231122017-11-17 17:48:06 -08001731 status_t status = inputDesc->open(&lConfig, device, address,
1732 halInputSource, profileFlags, &input);
Eric Laurentcf2c0212014-07-25 16:20:43 -07001733
1734 // only accept input with the exact requested set of parameters
Eric Laurent599c7582015-12-07 18:05:55 -08001735 if (status != NO_ERROR || input == AUDIO_IO_HANDLE_NONE ||
Eric Laurentfe231122017-11-17 17:48:06 -08001736 (profileSamplingRate != lConfig.sample_rate) ||
1737 !audio_formats_match(profileFormat, lConfig.format) ||
1738 (profileChannelMask != lConfig.channel_mask)) {
1739 ALOGW("getInputForAttr() failed opening input: sampling rate %d"
Glenn Kasten49f36ba2017-12-06 13:02:02 -08001740 ", format %#x, channel mask %#x",
Eric Laurentfe231122017-11-17 17:48:06 -08001741 profileSamplingRate, profileFormat, profileChannelMask);
Eric Laurent599c7582015-12-07 18:05:55 -08001742 if (input != AUDIO_IO_HANDLE_NONE) {
Eric Laurentfe231122017-11-17 17:48:06 -08001743 inputDesc->close();
Eric Laurentcf2c0212014-07-25 16:20:43 -07001744 }
Eric Laurent599c7582015-12-07 18:05:55 -08001745 return AUDIO_IO_HANDLE_NONE;
Eric Laurente552edb2014-03-10 17:42:56 -07001746 }
1747
Eric Laurentc722f302014-12-10 11:21:49 -08001748 inputDesc->mPolicyMix = policyMix;
Eric Laurent599c7582015-12-07 18:05:55 -08001749 inputDesc->addAudioSession(session, audioSession);
Glenn Kasten6a8ab052014-07-24 14:08:35 -07001750
Eric Laurent599c7582015-12-07 18:05:55 -08001751 addInput(input, inputDesc);
Eric Laurentb52c1522014-05-20 11:27:36 -07001752 mpClientInterface->onAudioPortListUpdate();
Paul McLean466dc8e2015-04-17 13:15:36 -06001753
Eric Laurent599c7582015-12-07 18:05:55 -08001754 return input;
Eric Laurente552edb2014-03-10 17:42:56 -07001755}
1756
Eric Laurentbb948092017-01-23 18:33:30 -08001757//static
1758bool AudioPolicyManager::isConcurrentSource(audio_source_t source)
1759{
1760 return (source == AUDIO_SOURCE_HOTWORD) ||
1761 (source == AUDIO_SOURCE_VOICE_RECOGNITION) ||
1762 (source == AUDIO_SOURCE_FM_TUNER);
1763}
1764
Eric Laurentfb66dd92016-01-28 18:32:03 -08001765bool AudioPolicyManager::isConcurentCaptureAllowed(const sp<AudioInputDescriptor>& inputDesc,
1766 const sp<AudioSession>& audioSession)
1767{
1768 // Do not allow capture if an active voice call is using a software patch and
1769 // the call TX source device is on the same HW module.
1770 // FIXME: would be better to refine to only inputs whose profile connects to the
1771 // call TX device but this information is not in the audio patch
1772 if (mCallTxPatch != 0 &&
1773 inputDesc->getModuleHandle() == mCallTxPatch->mPatch.sources[0].ext.device.hw_module) {
1774 return false;
1775 }
1776
1777 // starting concurrent capture is enabled if:
1778 // 1) capturing for re-routing
1779 // 2) capturing for HOTWORD source
1780 // 3) capturing for FM TUNER source
1781 // 3) All other active captures are either for re-routing or HOTWORD
1782
1783 if (is_virtual_input_device(inputDesc->mDevice) ||
Eric Laurentbb948092017-01-23 18:33:30 -08001784 isConcurrentSource(audioSession->inputSource())) {
Eric Laurentfb66dd92016-01-28 18:32:03 -08001785 return true;
1786 }
1787
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001788 for (const auto& activeInput : mInputs.getActiveInputs()) {
Eric Laurentbb948092017-01-23 18:33:30 -08001789 if (!isConcurrentSource(activeInput->inputSource(true)) &&
Eric Laurentfb66dd92016-01-28 18:32:03 -08001790 !is_virtual_input_device(activeInput->mDevice)) {
1791 return false;
1792 }
1793 }
1794
1795 return true;
1796}
1797
Chris Thornton2b864642017-06-27 21:26:07 -07001798// FIXME: remove when concurrent capture is ready. This is a hack to work around bug b/63083537.
1799bool AudioPolicyManager::soundTriggerSupportsConcurrentCapture() {
1800 if (!mHasComputedSoundTriggerSupportsConcurrentCapture) {
1801 bool soundTriggerSupportsConcurrentCapture = false;
1802 unsigned int numModules = 0;
1803 struct sound_trigger_module_descriptor* nModules = NULL;
1804
1805 status_t status = SoundTrigger::listModules(nModules, &numModules);
1806 if (status == NO_ERROR && numModules != 0) {
1807 nModules = (struct sound_trigger_module_descriptor*) calloc(
1808 numModules, sizeof(struct sound_trigger_module_descriptor));
1809 if (nModules == NULL) {
1810 // We failed to malloc the buffer, so just say no for now, and hope that we have more
1811 // ram the next time this function is called.
1812 ALOGE("Failed to allocate buffer for module descriptors");
1813 return false;
1814 }
1815
1816 status = SoundTrigger::listModules(nModules, &numModules);
1817 if (status == NO_ERROR) {
1818 soundTriggerSupportsConcurrentCapture = true;
1819 for (size_t i = 0; i < numModules; ++i) {
1820 soundTriggerSupportsConcurrentCapture &=
1821 nModules[i].properties.concurrent_capture;
1822 }
1823 }
1824 free(nModules);
1825 }
1826 mSoundTriggerSupportsConcurrentCapture = soundTriggerSupportsConcurrentCapture;
1827 mHasComputedSoundTriggerSupportsConcurrentCapture = true;
1828 }
1829 return mSoundTriggerSupportsConcurrentCapture;
1830}
1831
Eric Laurentfb66dd92016-01-28 18:32:03 -08001832
Eric Laurent4dc68062014-07-28 17:26:49 -07001833status_t AudioPolicyManager::startInput(audio_io_handle_t input,
Eric Laurentfb66dd92016-01-28 18:32:03 -08001834 audio_session_t session,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001835 bool silenced,
Eric Laurentfb66dd92016-01-28 18:32:03 -08001836 concurrency_type__mask_t *concurrency)
Eric Laurente552edb2014-03-10 17:42:56 -07001837{
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001838
1839 ALOGV("AudioPolicyManager::startInput(input:%d, session:%d, silenced:%d, concurrency:%d)",
1840 input, session, silenced, *concurrency);
1841
Eric Laurentfb66dd92016-01-28 18:32:03 -08001842 *concurrency = API_INPUT_CONCURRENCY_NONE;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001843
Eric Laurente552edb2014-03-10 17:42:56 -07001844 ssize_t index = mInputs.indexOfKey(input);
1845 if (index < 0) {
1846 ALOGW("startInput() unknown input %d", input);
1847 return BAD_VALUE;
1848 }
Eric Laurent1f2f2232014-06-02 12:01:23 -07001849 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index);
Eric Laurente552edb2014-03-10 17:42:56 -07001850
Eric Laurent599c7582015-12-07 18:05:55 -08001851 sp<AudioSession> audioSession = inputDesc->getAudioSession(session);
1852 if (audioSession == 0) {
Eric Laurent4dc68062014-07-28 17:26:49 -07001853 ALOGW("startInput() unknown session %d on input %d", session, input);
1854 return BAD_VALUE;
1855 }
1856
Eric Laurent74708e72017-04-07 17:13:42 -07001857// FIXME: disable concurrent capture until UI is ready
1858#if 0
Eric Laurentfb66dd92016-01-28 18:32:03 -08001859 if (!isConcurentCaptureAllowed(inputDesc, audioSession)) {
1860 ALOGW("startInput(%d) failed: other input already started", input);
1861 return INVALID_OPERATION;
1862 }
Glenn Kasten74a8e252014-07-24 14:09:55 -07001863
Eric Laurentfb66dd92016-01-28 18:32:03 -08001864 if (isInCall()) {
1865 *concurrency |= API_INPUT_CONCURRENCY_CALL;
1866 }
Eric Laurentf7c50102016-09-30 15:19:43 -07001867 if (mInputs.activeInputsCountOnDevices() != 0) {
Eric Laurentfb66dd92016-01-28 18:32:03 -08001868 *concurrency |= API_INPUT_CONCURRENCY_CAPTURE;
Eric Laurente552edb2014-03-10 17:42:56 -07001869 }
Eric Laurent74708e72017-04-07 17:13:42 -07001870#else
1871 if (!is_virtual_input_device(inputDesc->mDevice)) {
1872 if (mCallTxPatch != 0 &&
1873 inputDesc->getModuleHandle() == mCallTxPatch->mPatch.sources[0].ext.device.hw_module) {
1874 ALOGW("startInput(%d) failed: call in progress", input);
1875 return INVALID_OPERATION;
1876 }
1877
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001878 Vector<sp<AudioInputDescriptor>> activeInputs = mInputs.getActiveInputs();
Eric Laurent74708e72017-04-07 17:13:42 -07001879
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001880 // If a UID is idle and records silence and another not silenced recording starts
1881 // from another UID (idle or active) we stop the current idle UID recording in
1882 // favor of the new one - "There can be only one" TM
1883 if (!silenced) {
1884 for (const auto& activeDesc : activeInputs) {
1885 if ((audioSession->flags() & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0 &&
1886 activeDesc->getId() == inputDesc->getId()) {
1887 continue;
1888 }
1889
1890 AudioSessionCollection activeSessions = activeDesc->getAudioSessions(
1891 true /*activeOnly*/);
1892 sp<AudioSession> activeSession = activeSessions.valueAt(0);
1893 if (activeSession->isSilenced()) {
1894 audio_io_handle_t activeInput = activeDesc->mIoHandle;
1895 audio_session_t activeSessionId = activeSession->session();
1896 stopInput(activeInput, activeSessionId);
1897 releaseInput(activeInput, activeSessionId);
1898 ALOGV("startInput(%d) stopping silenced input %d", input, activeInput);
1899 activeInputs = mInputs.getActiveInputs();
1900 }
1901 }
1902 }
1903
1904 for (const auto& activeDesc : activeInputs) {
Eric Laurentcb4dae22017-07-01 19:39:32 -07001905 if ((audioSession->flags() & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0 &&
1906 activeDesc->getId() == inputDesc->getId()) {
1907 continue;
1908 }
1909
Eric Laurent74708e72017-04-07 17:13:42 -07001910 audio_source_t activeSource = activeDesc->inputSource(true);
1911 if (audioSession->inputSource() == AUDIO_SOURCE_HOTWORD) {
1912 if (activeSource == AUDIO_SOURCE_HOTWORD) {
1913 if (activeDesc->hasPreemptedSession(session)) {
1914 ALOGW("startInput(%d) failed for HOTWORD: "
1915 "other input %d already started for HOTWORD",
1916 input, activeDesc->mIoHandle);
1917 return INVALID_OPERATION;
1918 }
1919 } else {
1920 ALOGV("startInput(%d) failed for HOTWORD: other input %d already started",
1921 input, activeDesc->mIoHandle);
1922 return INVALID_OPERATION;
1923 }
1924 } else {
1925 if (activeSource != AUDIO_SOURCE_HOTWORD) {
1926 ALOGW("startInput(%d) failed: other input %d already started",
1927 input, activeDesc->mIoHandle);
1928 return INVALID_OPERATION;
1929 }
1930 }
1931 }
1932
Chris Thornton2b864642017-06-27 21:26:07 -07001933 // We only need to check if the sound trigger session supports concurrent capture if the
1934 // input is also a sound trigger input. Otherwise, we should preempt any hotword stream
1935 // that's running.
1936 const bool allowConcurrentWithSoundTrigger =
1937 inputDesc->isSoundTrigger() ? soundTriggerSupportsConcurrentCapture() : false;
1938
Eric Laurent74708e72017-04-07 17:13:42 -07001939 // if capture is allowed, preempt currently active HOTWORD captures
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001940 for (const auto& activeDesc : activeInputs) {
Chris Thornton2b864642017-06-27 21:26:07 -07001941 if (allowConcurrentWithSoundTrigger && activeDesc->isSoundTrigger()) {
1942 continue;
1943 }
1944
Eric Laurent74708e72017-04-07 17:13:42 -07001945 audio_source_t activeSource = activeDesc->inputSource(true);
1946 if (activeSource == AUDIO_SOURCE_HOTWORD) {
1947 AudioSessionCollection activeSessions =
1948 activeDesc->getAudioSessions(true /*activeOnly*/);
1949 audio_session_t activeSession = activeSessions.keyAt(0);
1950 audio_io_handle_t activeHandle = activeDesc->mIoHandle;
1951 SortedVector<audio_session_t> sessions = activeDesc->getPreemptedSessions();
1952 sessions.add(activeSession);
1953 inputDesc->setPreemptedSessions(sessions);
1954 stopInput(activeHandle, activeSession);
1955 releaseInput(activeHandle, activeSession);
1956 ALOGV("startInput(%d) for HOTWORD preempting HOTWORD input %d",
1957 input, activeDesc->mIoHandle);
1958 }
1959 }
1960 }
1961#endif
Eric Laurente552edb2014-03-10 17:42:56 -07001962
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001963 // Make sure we start with the correct silence state
1964 audioSession->setSilenced(silenced);
1965
Eric Laurent313d1e72016-01-29 09:56:57 -08001966 // increment activity count before calling getNewInputDevice() below as only active sessions
1967 // are considered for device selection
1968 audioSession->changeActiveCount(1);
1969
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001970 // Routing?
1971 mInputRoutes.incRouteActivity(session);
1972
Jean-Michel Trivieb6421d2016-03-17 12:32:52 -07001973 if (audioSession->activeCount() == 1 || mInputRoutes.hasRouteChanged(session)) {
Eric Laurent271a93e2016-09-29 14:47:06 -07001974 // indicate active capture to sound trigger service if starting capture from a mic on
1975 // primary HW module
Eric Laurentf7c50102016-09-30 15:19:43 -07001976 audio_devices_t device = getNewInputDevice(inputDesc);
Eric Laurent271a93e2016-09-29 14:47:06 -07001977 setInputDevice(input, device, true /* force */);
Eric Laurente552edb2014-03-10 17:42:56 -07001978
Eric Laurent733ce942017-12-07 12:18:25 -08001979 status_t status = inputDesc->start();
1980 if (status != NO_ERROR) {
1981 mInputRoutes.decRouteActivity(session);
1982 audioSession->changeActiveCount(-1);
1983 return status;
1984 }
Eric Laurent3974e3b2017-12-07 17:58:43 -08001985
Eric Laurent733ce942017-12-07 12:18:25 -08001986 if (inputDesc->getAudioSessionCount(true/*activeOnly*/) == 1) {
Jean-Michel Trivieb6421d2016-03-17 12:32:52 -07001987 // if input maps to a dynamic policy with an activity listener, notify of state change
1988 if ((inputDesc->mPolicyMix != NULL)
1989 && ((inputDesc->mPolicyMix->mCbFlags & AudioMix::kCbFlagNotifyActivity) != 0)) {
1990 mpClientInterface->onDynamicPolicyMixStateUpdate(inputDesc->mPolicyMix->mDeviceAddress,
1991 MIX_STATE_MIXING);
Eric Laurentc722f302014-12-10 11:21:49 -08001992 }
Jean-Michel Trivieb6421d2016-03-17 12:32:52 -07001993
Eric Laurentf7c50102016-09-30 15:19:43 -07001994 audio_devices_t primaryInputDevices = availablePrimaryInputDevices();
1995 if (((device & primaryInputDevices & ~AUDIO_DEVICE_BIT_IN) != 0) &&
Eric Laurent05b345e2016-11-18 12:36:27 -08001996 mInputs.activeInputsCountOnDevices(primaryInputDevices) == 1) {
Jean-Michel Trivieb6421d2016-03-17 12:32:52 -07001997 SoundTrigger::setCaptureState(true);
1998 }
1999
2000 // automatically enable the remote submix output when input is started if not
2001 // used by a policy mix of type MIX_TYPE_RECORDERS
2002 // For remote submix (a virtual device), we open only one input per capture request.
2003 if (audio_is_remote_submix_device(inputDesc->mDevice)) {
2004 String8 address = String8("");
2005 if (inputDesc->mPolicyMix == NULL) {
2006 address = String8("0");
2007 } else if (inputDesc->mPolicyMix->mMixType == MIX_TYPE_PLAYERS) {
2008 address = inputDesc->mPolicyMix->mDeviceAddress;
2009 }
2010 if (address != "") {
2011 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
2012 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2013 address, "remote-submix");
2014 }
Eric Laurentc722f302014-12-10 11:21:49 -08002015 }
Glenn Kasten74a8e252014-07-24 14:09:55 -07002016 }
Eric Laurente552edb2014-03-10 17:42:56 -07002017 }
2018
Eric Laurent599c7582015-12-07 18:05:55 -08002019 ALOGV("AudioPolicyManager::startInput() input source = %d", audioSession->inputSource());
Eric Laurente552edb2014-03-10 17:42:56 -07002020
Eric Laurente552edb2014-03-10 17:42:56 -07002021 return NO_ERROR;
2022}
2023
Eric Laurent4dc68062014-07-28 17:26:49 -07002024status_t AudioPolicyManager::stopInput(audio_io_handle_t input,
2025 audio_session_t session)
Eric Laurente552edb2014-03-10 17:42:56 -07002026{
2027 ALOGV("stopInput() input %d", input);
2028 ssize_t index = mInputs.indexOfKey(input);
2029 if (index < 0) {
2030 ALOGW("stopInput() unknown input %d", input);
2031 return BAD_VALUE;
2032 }
Eric Laurent1f2f2232014-06-02 12:01:23 -07002033 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index);
Eric Laurente552edb2014-03-10 17:42:56 -07002034
Eric Laurent599c7582015-12-07 18:05:55 -08002035 sp<AudioSession> audioSession = inputDesc->getAudioSession(session);
Eric Laurent4dc68062014-07-28 17:26:49 -07002036 if (index < 0) {
2037 ALOGW("stopInput() unknown session %d on input %d", session, input);
2038 return BAD_VALUE;
2039 }
2040
Eric Laurent599c7582015-12-07 18:05:55 -08002041 if (audioSession->activeCount() == 0) {
Eric Laurente552edb2014-03-10 17:42:56 -07002042 ALOGW("stopInput() input %d already stopped", input);
2043 return INVALID_OPERATION;
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002044 }
2045
Eric Laurent599c7582015-12-07 18:05:55 -08002046 audioSession->changeActiveCount(-1);
Paul McLean466dc8e2015-04-17 13:15:36 -06002047
2048 // Routing?
2049 mInputRoutes.decRouteActivity(session);
2050
Jean-Michel Trivieb6421d2016-03-17 12:32:52 -07002051 if (audioSession->activeCount() == 0) {
Eric Laurent733ce942017-12-07 12:18:25 -08002052 inputDesc->stop();
Jean-Michel Trivieb6421d2016-03-17 12:32:52 -07002053 if (inputDesc->isActive()) {
2054 setInputDevice(input, getNewInputDevice(inputDesc), false /* force */);
2055 } else {
2056 // if input maps to a dynamic policy with an activity listener, notify of state change
2057 if ((inputDesc->mPolicyMix != NULL)
2058 && ((inputDesc->mPolicyMix->mCbFlags & AudioMix::kCbFlagNotifyActivity) != 0)) {
2059 mpClientInterface->onDynamicPolicyMixStateUpdate(inputDesc->mPolicyMix->mDeviceAddress,
2060 MIX_STATE_IDLE);
Eric Laurent84332aa2016-01-28 22:19:18 +00002061 }
Jean-Michel Trivieb6421d2016-03-17 12:32:52 -07002062
2063 // automatically disable the remote submix output when input is stopped if not
2064 // used by a policy mix of type MIX_TYPE_RECORDERS
2065 if (audio_is_remote_submix_device(inputDesc->mDevice)) {
2066 String8 address = String8("");
2067 if (inputDesc->mPolicyMix == NULL) {
2068 address = String8("0");
2069 } else if (inputDesc->mPolicyMix->mMixType == MIX_TYPE_PLAYERS) {
2070 address = inputDesc->mPolicyMix->mDeviceAddress;
2071 }
2072 if (address != "") {
2073 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
2074 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
2075 address, "remote-submix");
2076 }
Eric Laurent84332aa2016-01-28 22:19:18 +00002077 }
Eric Laurent84332aa2016-01-28 22:19:18 +00002078
Eric Laurentf7c50102016-09-30 15:19:43 -07002079 audio_devices_t device = inputDesc->mDevice;
Eric Laurentfb66dd92016-01-28 18:32:03 -08002080 resetInputDevice(input);
Eric Laurent84332aa2016-01-28 22:19:18 +00002081
Eric Laurentf7c50102016-09-30 15:19:43 -07002082 // indicate inactive capture to sound trigger service if stopping capture from a mic on
2083 // primary HW module
2084 audio_devices_t primaryInputDevices = availablePrimaryInputDevices();
2085 if (((device & primaryInputDevices & ~AUDIO_DEVICE_BIT_IN) != 0) &&
2086 mInputs.activeInputsCountOnDevices(primaryInputDevices) == 0) {
Eric Laurentfb66dd92016-01-28 18:32:03 -08002087 SoundTrigger::setCaptureState(false);
2088 }
2089 inputDesc->clearPreemptedSessions();
Eric Laurent84332aa2016-01-28 22:19:18 +00002090 }
Eric Laurente552edb2014-03-10 17:42:56 -07002091 }
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002092 return NO_ERROR;
Eric Laurente552edb2014-03-10 17:42:56 -07002093}
2094
Eric Laurent4dc68062014-07-28 17:26:49 -07002095void AudioPolicyManager::releaseInput(audio_io_handle_t input,
2096 audio_session_t session)
Eric Laurente552edb2014-03-10 17:42:56 -07002097{
2098 ALOGV("releaseInput() %d", input);
2099 ssize_t index = mInputs.indexOfKey(input);
2100 if (index < 0) {
2101 ALOGW("releaseInput() releasing unknown input %d", input);
2102 return;
2103 }
Paul McLean466dc8e2015-04-17 13:15:36 -06002104
2105 // Routing
2106 mInputRoutes.removeRoute(session);
2107
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002108 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index);
2109 ALOG_ASSERT(inputDesc != 0);
Eric Laurent4dc68062014-07-28 17:26:49 -07002110
Eric Laurent599c7582015-12-07 18:05:55 -08002111 sp<AudioSession> audioSession = inputDesc->getAudioSession(session);
vivek mehta587b8df2017-01-31 14:58:44 -08002112 if (audioSession == 0) {
Eric Laurent4dc68062014-07-28 17:26:49 -07002113 ALOGW("releaseInput() unknown session %d on input %d", session, input);
2114 return;
2115 }
Eric Laurent599c7582015-12-07 18:05:55 -08002116
2117 if (audioSession->openCount() == 0) {
2118 ALOGW("releaseInput() invalid open count %d on session %d",
2119 audioSession->openCount(), session);
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002120 return;
2121 }
Eric Laurent599c7582015-12-07 18:05:55 -08002122
2123 if (audioSession->changeOpenCount(-1) == 0) {
2124 inputDesc->removeAudioSession(session);
2125 }
2126
Jean-Michel Trivi65bfe912015-12-04 15:56:47 -08002127 if (inputDesc->getOpenRefCount() > 0) {
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002128 ALOGV("releaseInput() exit > 0");
2129 return;
2130 }
2131
Eric Laurent05b90f82014-08-27 15:32:29 -07002132 closeInput(input);
Eric Laurentb52c1522014-05-20 11:27:36 -07002133 mpClientInterface->onAudioPortListUpdate();
Eric Laurente552edb2014-03-10 17:42:56 -07002134 ALOGV("releaseInput() exit");
2135}
2136
Eric Laurentd4692962014-05-05 18:13:44 -07002137void AudioPolicyManager::closeAllInputs() {
Eric Laurent05b90f82014-08-27 15:32:29 -07002138 bool patchRemoved = false;
2139
Mikhail Naganov7e22e942017-12-07 10:04:29 -08002140 for (size_t input_index = 0; input_index < mInputs.size(); input_index++) {
Eric Laurent05b90f82014-08-27 15:32:29 -07002141 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(input_index);
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002142 ssize_t patch_index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent05b90f82014-08-27 15:32:29 -07002143 if (patch_index >= 0) {
2144 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(patch_index);
Glenn Kastenfcddb0b2016-07-08 17:19:25 -07002145 (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
Eric Laurent05b90f82014-08-27 15:32:29 -07002146 mAudioPatches.removeItemsAt(patch_index);
2147 patchRemoved = true;
2148 }
Eric Laurentfe231122017-11-17 17:48:06 -08002149 inputDesc->close();
Eric Laurentd4692962014-05-05 18:13:44 -07002150 }
jiabin829a00b2018-04-04 16:28:32 -07002151 mInputRoutes.clear();
Eric Laurentd4692962014-05-05 18:13:44 -07002152 mInputs.clear();
Chris Thornton52785f32016-02-09 17:28:49 -08002153 SoundTrigger::setCaptureState(false);
Eric Laurent6a94d692014-05-20 11:18:06 -07002154 nextAudioPortGeneration();
Eric Laurent05b90f82014-08-27 15:32:29 -07002155
2156 if (patchRemoved) {
2157 mpClientInterface->onAudioPatchListUpdate();
2158 }
Eric Laurentd4692962014-05-05 18:13:44 -07002159}
2160
Eric Laurente0720872014-03-11 09:30:41 -07002161void AudioPolicyManager::initStreamVolume(audio_stream_type_t stream,
Eric Laurente552edb2014-03-10 17:42:56 -07002162 int indexMin,
2163 int indexMax)
2164{
2165 ALOGV("initStreamVolume() stream %d, min %d, max %d", stream , indexMin, indexMax);
François Gaffied1ab2bd2015-12-02 18:20:06 +01002166 mVolumeCurves->initStreamVolume(stream, indexMin, indexMax);
Eric Laurent28d09f02016-03-08 10:43:05 -08002167
2168 // initialize other private stream volumes which follow this one
Eric Laurent794fde22016-03-11 09:50:45 -08002169 for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) {
2170 if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
Eric Laurent28d09f02016-03-08 10:43:05 -08002171 continue;
2172 }
2173 mVolumeCurves->initStreamVolume((audio_stream_type_t)curStream, indexMin, indexMax);
Eric Laurent223fd5c2014-11-11 13:43:36 -08002174 }
Eric Laurente552edb2014-03-10 17:42:56 -07002175}
2176
Eric Laurente0720872014-03-11 09:30:41 -07002177status_t AudioPolicyManager::setStreamVolumeIndex(audio_stream_type_t stream,
François Gaffie53615e22015-03-19 09:24:12 +01002178 int index,
2179 audio_devices_t device)
Eric Laurente552edb2014-03-10 17:42:56 -07002180{
2181
Nadav Bar7c605f62017-12-25 00:01:52 +02002182 // VOICE_CALL stream has minVolumeIndex > 0 but can be muted directly by an
2183 // app that has MODIFY_PHONE_STATE permission.
2184 if (((index < mVolumeCurves->getVolumeIndexMin(stream)) &&
2185 !(stream == AUDIO_STREAM_VOICE_CALL && index == 0)) ||
François Gaffied1ab2bd2015-12-02 18:20:06 +01002186 (index > mVolumeCurves->getVolumeIndexMax(stream))) {
Eric Laurente552edb2014-03-10 17:42:56 -07002187 return BAD_VALUE;
2188 }
2189 if (!audio_is_output_device(device)) {
2190 return BAD_VALUE;
2191 }
2192
2193 // Force max volume if stream cannot be muted
François Gaffied1ab2bd2015-12-02 18:20:06 +01002194 if (!mVolumeCurves->canBeMuted(stream)) index = mVolumeCurves->getVolumeIndexMax(stream);
Eric Laurente552edb2014-03-10 17:42:56 -07002195
Eric Laurent1fd372e2016-04-06 14:23:53 -07002196 ALOGV("setStreamVolumeIndex() stream %d, device %08x, index %d",
Eric Laurente552edb2014-03-10 17:42:56 -07002197 stream, device, index);
2198
Eric Laurent28d09f02016-03-08 10:43:05 -08002199 // update other private stream volumes which follow this one
Eric Laurent794fde22016-03-11 09:50:45 -08002200 for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) {
2201 if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
Eric Laurent28d09f02016-03-08 10:43:05 -08002202 continue;
2203 }
2204 mVolumeCurves->addCurrentVolumeIndex((audio_stream_type_t)curStream, device, index);
2205 }
Eric Laurente552edb2014-03-10 17:42:56 -07002206
Eric Laurent1fd372e2016-04-06 14:23:53 -07002207 // update volume on all outputs and streams matching the following:
2208 // - The requested stream (or a stream matching for volume control) is active on the output
2209 // - The device (or devices) selected by the strategy corresponding to this stream includes
2210 // the requested device
2211 // - For non default requested device, currently selected device on the output is either the
2212 // requested device or one of the devices selected by the strategy
Eric Laurent5a2b6292016-04-14 18:05:57 -07002213 // - For default requested device (AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME), apply volume only if
2214 // no specific device volume value exists for currently selected device.
Eric Laurente552edb2014-03-10 17:42:56 -07002215 status_t status = NO_ERROR;
2216 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -07002217 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
2218 audio_devices_t curDevice = Volume::getDeviceForVolume(desc->device());
Eric Laurent794fde22016-03-11 09:50:45 -08002219 for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) {
2220 if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
Eric Laurent28d09f02016-03-08 10:43:05 -08002221 continue;
Eric Laurente552edb2014-03-10 17:42:56 -07002222 }
Eric Laurentd3926fe2016-04-15 18:10:07 -07002223 if (!(desc->isStreamActive((audio_stream_type_t)curStream) ||
2224 (isInCall() && (curStream == AUDIO_STREAM_VOICE_CALL)))) {
Eric Laurent1fd372e2016-04-06 14:23:53 -07002225 continue;
2226 }
Eric Laurent794fde22016-03-11 09:50:45 -08002227 routing_strategy curStrategy = getStrategy((audio_stream_type_t)curStream);
Jean-Michel Trivib7fdce62017-06-27 19:38:42 -07002228 audio_devices_t curStreamDevice = Volume::getDeviceForVolume(getDeviceForStrategy(
2229 curStrategy, false /*fromCache*/));
Eric Laurente76f29c2016-09-14 17:17:53 -07002230 if ((device != AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) &&
2231 ((curStreamDevice & device) == 0)) {
Eric Laurent1fd372e2016-04-06 14:23:53 -07002232 continue;
2233 }
Eric Laurente76f29c2016-09-14 17:17:53 -07002234 bool applyVolume;
Eric Laurent5a2b6292016-04-14 18:05:57 -07002235 if (device != AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
Eric Laurent1fd372e2016-04-06 14:23:53 -07002236 curStreamDevice |= device;
Eric Laurente76f29c2016-09-14 17:17:53 -07002237 applyVolume = (curDevice & curStreamDevice) != 0;
2238 } else {
2239 applyVolume = !mVolumeCurves->hasVolumeIndexForDevice(
Jean-Michel Trivib7fdce62017-06-27 19:38:42 -07002240 stream, curStreamDevice);
Eric Laurent1fd372e2016-04-06 14:23:53 -07002241 }
Eric Laurent28d09f02016-03-08 10:43:05 -08002242
Eric Laurente76f29c2016-09-14 17:17:53 -07002243 if (applyVolume) {
Eric Laurentdc462862016-07-19 12:29:53 -07002244 //FIXME: workaround for truncated touch sounds
2245 // delayed volume change for system stream to be removed when the problem is
2246 // handled by system UI
Eric Laurent28d09f02016-03-08 10:43:05 -08002247 status_t volStatus =
Eric Laurentdc462862016-07-19 12:29:53 -07002248 checkAndSetVolume((audio_stream_type_t)curStream, index, desc, curDevice,
2249 (stream == AUDIO_STREAM_SYSTEM) ? TOUCH_SOUND_FIXED_DELAY_MS : 0);
Eric Laurent28d09f02016-03-08 10:43:05 -08002250 if (volStatus != NO_ERROR) {
2251 status = volStatus;
2252 }
2253 }
Eric Laurent223fd5c2014-11-11 13:43:36 -08002254 }
Eric Laurente552edb2014-03-10 17:42:56 -07002255 }
2256 return status;
2257}
2258
Eric Laurente0720872014-03-11 09:30:41 -07002259status_t AudioPolicyManager::getStreamVolumeIndex(audio_stream_type_t stream,
Eric Laurente552edb2014-03-10 17:42:56 -07002260 int *index,
2261 audio_devices_t device)
2262{
2263 if (index == NULL) {
2264 return BAD_VALUE;
2265 }
2266 if (!audio_is_output_device(device)) {
2267 return BAD_VALUE;
2268 }
Eric Laurent5a2b6292016-04-14 18:05:57 -07002269 // if device is AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME, return volume for device corresponding to
Eric Laurente552edb2014-03-10 17:42:56 -07002270 // the strategy the stream belongs to.
Eric Laurent5a2b6292016-04-14 18:05:57 -07002271 if (device == AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
Eric Laurente552edb2014-03-10 17:42:56 -07002272 device = getDeviceForStrategy(getStrategy(stream), true /*fromCache*/);
2273 }
François Gaffiedfd74092015-03-19 12:10:59 +01002274 device = Volume::getDeviceForVolume(device);
Eric Laurente552edb2014-03-10 17:42:56 -07002275
François Gaffied1ab2bd2015-12-02 18:20:06 +01002276 *index = mVolumeCurves->getVolumeIndex(stream, device);
Eric Laurente552edb2014-03-10 17:42:56 -07002277 ALOGV("getStreamVolumeIndex() stream %d device %08x index %d", stream, device, *index);
2278 return NO_ERROR;
2279}
2280
Eric Laurent36829f92017-04-07 19:04:42 -07002281audio_io_handle_t AudioPolicyManager::selectOutputForMusicEffects()
Eric Laurente552edb2014-03-10 17:42:56 -07002282{
2283 // select one output among several suitable for global effects.
2284 // The priority is as follows:
2285 // 1: An offloaded output. If the effect ends up not being offloadable,
2286 // AudioFlinger will invalidate the track and the offloaded output
2287 // will be closed causing the effect to be moved to a PCM output.
2288 // 2: A deep buffer output
Eric Laurent36829f92017-04-07 19:04:42 -07002289 // 3: The primary output
2290 // 4: the first output in the list
Eric Laurente552edb2014-03-10 17:42:56 -07002291
Eric Laurent3b73df72014-03-11 09:06:29 -07002292 routing_strategy strategy = getStrategy(AUDIO_STREAM_MUSIC);
Eric Laurente552edb2014-03-10 17:42:56 -07002293 audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
Eric Laurent36829f92017-04-07 19:04:42 -07002294 SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs);
Eric Laurente552edb2014-03-10 17:42:56 -07002295
Eric Laurent36829f92017-04-07 19:04:42 -07002296 if (outputs.size() == 0) {
2297 return AUDIO_IO_HANDLE_NONE;
2298 }
Eric Laurente552edb2014-03-10 17:42:56 -07002299
Eric Laurent36829f92017-04-07 19:04:42 -07002300 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
2301 bool activeOnly = true;
2302
2303 while (output == AUDIO_IO_HANDLE_NONE) {
2304 audio_io_handle_t outputOffloaded = AUDIO_IO_HANDLE_NONE;
2305 audio_io_handle_t outputDeepBuffer = AUDIO_IO_HANDLE_NONE;
2306 audio_io_handle_t outputPrimary = AUDIO_IO_HANDLE_NONE;
2307
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002308 for (audio_io_handle_t output : outputs) {
2309 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
Eric Laurent36829f92017-04-07 19:04:42 -07002310 if (activeOnly && !desc->isStreamActive(AUDIO_STREAM_MUSIC)) {
2311 continue;
2312 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002313 ALOGV("selectOutputForMusicEffects activeOnly %d output %d flags 0x%08x",
2314 activeOnly, output, desc->mFlags);
Eric Laurent36829f92017-04-07 19:04:42 -07002315 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002316 outputOffloaded = output;
Eric Laurent36829f92017-04-07 19:04:42 -07002317 }
2318 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) != 0) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002319 outputDeepBuffer = output;
Eric Laurent36829f92017-04-07 19:04:42 -07002320 }
2321 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY) != 0) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002322 outputPrimary = output;
Eric Laurent36829f92017-04-07 19:04:42 -07002323 }
2324 }
2325 if (outputOffloaded != AUDIO_IO_HANDLE_NONE) {
2326 output = outputOffloaded;
2327 } else if (outputDeepBuffer != AUDIO_IO_HANDLE_NONE) {
2328 output = outputDeepBuffer;
2329 } else if (outputPrimary != AUDIO_IO_HANDLE_NONE) {
2330 output = outputPrimary;
2331 } else {
2332 output = outputs[0];
2333 }
2334 activeOnly = false;
2335 }
2336
2337 if (output != mMusicEffectOutput) {
2338 mpClientInterface->moveEffects(AUDIO_SESSION_OUTPUT_MIX, mMusicEffectOutput, output);
2339 mMusicEffectOutput = output;
2340 }
2341
2342 ALOGV("selectOutputForMusicEffects selected output %d", output);
Eric Laurente552edb2014-03-10 17:42:56 -07002343 return output;
2344}
2345
Eric Laurent36829f92017-04-07 19:04:42 -07002346audio_io_handle_t AudioPolicyManager::getOutputForEffect(const effect_descriptor_t *desc __unused)
2347{
2348 return selectOutputForMusicEffects();
2349}
2350
Eric Laurente0720872014-03-11 09:30:41 -07002351status_t AudioPolicyManager::registerEffect(const effect_descriptor_t *desc,
Eric Laurente552edb2014-03-10 17:42:56 -07002352 audio_io_handle_t io,
2353 uint32_t strategy,
2354 int session,
2355 int id)
2356{
2357 ssize_t index = mOutputs.indexOfKey(io);
2358 if (index < 0) {
2359 index = mInputs.indexOfKey(io);
2360 if (index < 0) {
2361 ALOGW("registerEffect() unknown io %d", io);
2362 return INVALID_OPERATION;
2363 }
2364 }
François Gaffie45ed3b02015-03-19 10:35:14 +01002365 return mEffects.registerEffect(desc, io, strategy, session, id);
Eric Laurente552edb2014-03-10 17:42:56 -07002366}
2367
Eric Laurentc75307b2015-03-17 15:29:32 -07002368bool AudioPolicyManager::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
2369{
Eric Laurent28d09f02016-03-08 10:43:05 -08002370 bool active = false;
Eric Laurent794fde22016-03-11 09:50:45 -08002371 for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT && !active; curStream++) {
2372 if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
Eric Laurent28d09f02016-03-08 10:43:05 -08002373 continue;
2374 }
2375 active = mOutputs.isStreamActive((audio_stream_type_t)curStream, inPastMs);
2376 }
Eric Laurent28d09f02016-03-08 10:43:05 -08002377 return active;
Eric Laurentc75307b2015-03-17 15:29:32 -07002378}
2379
2380bool AudioPolicyManager::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
2381{
2382 return mOutputs.isStreamActiveRemotely(stream, inPastMs);
2383}
2384
Eric Laurente0720872014-03-11 09:30:41 -07002385bool AudioPolicyManager::isSourceActive(audio_source_t source) const
Eric Laurente552edb2014-03-10 17:42:56 -07002386{
2387 for (size_t i = 0; i < mInputs.size(); i++) {
Eric Laurent1f2f2232014-06-02 12:01:23 -07002388 const sp<AudioInputDescriptor> inputDescriptor = mInputs.valueAt(i);
Eric Laurent599c7582015-12-07 18:05:55 -08002389 if (inputDescriptor->isSourceActive(source)) {
Eric Laurente552edb2014-03-10 17:42:56 -07002390 return true;
2391 }
2392 }
2393 return false;
2394}
2395
Eric Laurent275e8e92014-11-30 15:14:47 -08002396// Register a list of custom mixes with their attributes and format.
2397// When a mix is registered, corresponding input and output profiles are
2398// added to the remote submix hw module. The profile contains only the
2399// parameters (sampling rate, format...) specified by the mix.
2400// The corresponding input remote submix device is also connected.
2401//
2402// When a remote submix device is connected, the address is checked to select the
2403// appropriate profile and the corresponding input or output stream is opened.
2404//
2405// When capture starts, getInputForAttr() will:
2406// - 1 look for a mix matching the address passed in attribtutes tags if any
2407// - 2 if none found, getDeviceForInputSource() will:
2408// - 2.1 look for a mix matching the attributes source
2409// - 2.2 if none found, default to device selection by policy rules
2410// At this time, the corresponding output remote submix device is also connected
2411// and active playback use cases can be transferred to this mix if needed when reconnecting
2412// after AudioTracks are invalidated
2413//
2414// When playback starts, getOutputForAttr() will:
2415// - 1 look for a mix matching the address passed in attribtutes tags if any
2416// - 2 if none found, look for a mix matching the attributes usage
2417// - 3 if none found, default to device and output selection by policy rules.
2418
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002419status_t AudioPolicyManager::registerPolicyMixes(const Vector<AudioMix>& mixes)
Eric Laurent275e8e92014-11-30 15:14:47 -08002420{
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002421 ALOGV("registerPolicyMixes() %zu mix(es)", mixes.size());
2422 status_t res = NO_ERROR;
2423
2424 sp<HwModule> rSubmixModule;
2425 // examine each mix's route type
2426 for (size_t i = 0; i < mixes.size(); i++) {
2427 // we only support MIX_ROUTE_FLAG_LOOP_BACK or MIX_ROUTE_FLAG_RENDER, not the combination
2428 if ((mixes[i].mRouteFlags & MIX_ROUTE_FLAG_ALL) == MIX_ROUTE_FLAG_ALL) {
2429 res = INVALID_OPERATION;
Eric Laurent275e8e92014-11-30 15:14:47 -08002430 break;
2431 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002432 if ((mixes[i].mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) {
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002433 ALOGV("registerPolicyMixes() mix %zu of %zu is LOOP_BACK", i, mixes.size());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002434 if (rSubmixModule == 0) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08002435 rSubmixModule = mHwModules.getModuleFromName(
2436 AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX);
2437 if (rSubmixModule == 0) {
2438 ALOGE(" Unable to find audio module for submix, aborting mix %zu registration",
2439 i);
2440 res = INVALID_OPERATION;
2441 break;
2442 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002443 }
Eric Laurent275e8e92014-11-30 15:14:47 -08002444
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002445 String8 address = mixes[i].mDeviceAddress;
François Gaffie036e1e92015-03-19 10:16:24 +01002446
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002447 if (mPolicyMixes.registerMix(address, mixes[i], 0 /*output desc*/) != NO_ERROR) {
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07002448 ALOGE(" Error registering mix %zu for address %s", i, address.string());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002449 res = INVALID_OPERATION;
2450 break;
2451 }
2452 audio_config_t outputConfig = mixes[i].mFormat;
2453 audio_config_t inputConfig = mixes[i].mFormat;
2454 // NOTE: audio flinger mixer does not support mono output: configure remote submix HAL in
2455 // stereo and let audio flinger do the channel conversion if needed.
2456 outputConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
2457 inputConfig.channel_mask = AUDIO_CHANNEL_IN_STEREO;
2458 rSubmixModule->addOutputProfile(address, &outputConfig,
2459 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, address);
2460 rSubmixModule->addInputProfile(address, &inputConfig,
2461 AUDIO_DEVICE_IN_REMOTE_SUBMIX, address);
François Gaffie036e1e92015-03-19 10:16:24 +01002462
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002463 if (mixes[i].mMixType == MIX_TYPE_PLAYERS) {
2464 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
2465 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2466 address.string(), "remote-submix");
2467 } else {
2468 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
2469 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2470 address.string(), "remote-submix");
2471 }
2472 } else if ((mixes[i].mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) {
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002473 String8 address = mixes[i].mDeviceAddress;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002474 audio_devices_t device = mixes[i].mDeviceType;
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07002475 ALOGV(" registerPolicyMixes() mix %zu of %zu is RENDER, dev=0x%X addr=%s",
2476 i, mixes.size(), device, address.string());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002477
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07002478 bool foundOutput = false;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002479 for (size_t j = 0 ; j < mOutputs.size() ; j++) {
2480 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(j);
2481 sp<AudioPatch> patch = mAudioPatches.valueFor(desc->getPatchHandle());
2482 if ((patch != 0) && (patch->mPatch.num_sinks != 0)
2483 && (patch->mPatch.sinks[0].type == AUDIO_PORT_TYPE_DEVICE)
2484 && (patch->mPatch.sinks[0].ext.device.type == device)
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07002485 && (strncmp(patch->mPatch.sinks[0].ext.device.address, address.string(),
2486 AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0)) {
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002487 if (mPolicyMixes.registerMix(address, mixes[i], desc) != NO_ERROR) {
2488 res = INVALID_OPERATION;
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07002489 } else {
2490 foundOutput = true;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002491 }
2492 break;
2493 }
2494 }
2495
2496 if (res != NO_ERROR) {
2497 ALOGE(" Error registering mix %zu for device 0x%X addr %s",
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07002498 i, device, address.string());
2499 res = INVALID_OPERATION;
2500 break;
2501 } else if (!foundOutput) {
2502 ALOGE(" Output not found for mix %zu for device 0x%X addr %s",
2503 i, device, address.string());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002504 res = INVALID_OPERATION;
2505 break;
2506 }
Eric Laurentc722f302014-12-10 11:21:49 -08002507 }
Eric Laurent275e8e92014-11-30 15:14:47 -08002508 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002509 if (res != NO_ERROR) {
2510 unregisterPolicyMixes(mixes);
2511 }
2512 return res;
Eric Laurent275e8e92014-11-30 15:14:47 -08002513}
2514
2515status_t AudioPolicyManager::unregisterPolicyMixes(Vector<AudioMix> mixes)
2516{
Eric Laurent7b279bb2015-12-14 10:18:23 -08002517 ALOGV("unregisterPolicyMixes() num mixes %zu", mixes.size());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002518 status_t res = NO_ERROR;
2519 sp<HwModule> rSubmixModule;
2520 // examine each mix's route type
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002521 for (const auto& mix : mixes) {
2522 if ((mix.mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) {
François Gaffie036e1e92015-03-19 10:16:24 +01002523
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002524 if (rSubmixModule == 0) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08002525 rSubmixModule = mHwModules.getModuleFromName(
2526 AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX);
2527 if (rSubmixModule == 0) {
2528 res = INVALID_OPERATION;
2529 continue;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002530 }
2531 }
Eric Laurent275e8e92014-11-30 15:14:47 -08002532
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002533 String8 address = mix.mDeviceAddress;
Eric Laurent275e8e92014-11-30 15:14:47 -08002534
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002535 if (mPolicyMixes.unregisterMix(address) != NO_ERROR) {
2536 res = INVALID_OPERATION;
2537 continue;
2538 }
2539
2540 if (getDeviceConnectionState(AUDIO_DEVICE_IN_REMOTE_SUBMIX, address.string()) ==
2541 AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
2542 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
2543 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
2544 address.string(), "remote-submix");
2545 }
2546 if (getDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX, address.string()) ==
2547 AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
2548 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
2549 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
2550 address.string(), "remote-submix");
2551 }
2552 rSubmixModule->removeOutputProfile(address);
2553 rSubmixModule->removeInputProfile(address);
2554
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002555 } if ((mix.mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) {
2556 if (mPolicyMixes.unregisterMix(mix.mDeviceAddress) != NO_ERROR) {
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002557 res = INVALID_OPERATION;
2558 continue;
2559 }
Eric Laurent275e8e92014-11-30 15:14:47 -08002560 }
Eric Laurent275e8e92014-11-30 15:14:47 -08002561 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002562 return res;
Eric Laurent275e8e92014-11-30 15:14:47 -08002563}
2564
Eric Laurente552edb2014-03-10 17:42:56 -07002565
Eric Laurente0720872014-03-11 09:30:41 -07002566status_t AudioPolicyManager::dump(int fd)
Eric Laurente552edb2014-03-10 17:42:56 -07002567{
2568 const size_t SIZE = 256;
2569 char buffer[SIZE];
2570 String8 result;
2571
2572 snprintf(buffer, SIZE, "\nAudioPolicyManager Dump: %p\n", this);
2573 result.append(buffer);
2574
Eric Laurent87ffa392015-05-22 10:32:38 -07002575 snprintf(buffer, SIZE, " Primary Output: %d\n",
2576 hasPrimaryOutput() ? mPrimaryOutput->mIoHandle : AUDIO_IO_HANDLE_NONE);
Eric Laurente552edb2014-03-10 17:42:56 -07002577 result.append(buffer);
Mikhail Naganov0d6a0332016-04-19 17:12:38 -07002578 std::string stateLiteral;
2579 AudioModeConverter::toString(mEngine->getPhoneState(), stateLiteral);
2580 snprintf(buffer, SIZE, " Phone state: %s\n", stateLiteral.c_str());
Eric Laurente552edb2014-03-10 17:42:56 -07002581 result.append(buffer);
Eric Laurent3b73df72014-03-11 09:06:29 -07002582 snprintf(buffer, SIZE, " Force use for communications %d\n",
François Gaffie2110e042015-03-24 08:41:51 +01002583 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION));
Eric Laurente552edb2014-03-10 17:42:56 -07002584 result.append(buffer);
François Gaffie2110e042015-03-24 08:41:51 +01002585 snprintf(buffer, SIZE, " Force use for media %d\n", mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_MEDIA));
Eric Laurente552edb2014-03-10 17:42:56 -07002586 result.append(buffer);
François Gaffie2110e042015-03-24 08:41:51 +01002587 snprintf(buffer, SIZE, " Force use for record %d\n", mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_RECORD));
Eric Laurente552edb2014-03-10 17:42:56 -07002588 result.append(buffer);
François Gaffie2110e042015-03-24 08:41:51 +01002589 snprintf(buffer, SIZE, " Force use for dock %d\n", mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_DOCK));
Eric Laurente552edb2014-03-10 17:42:56 -07002590 result.append(buffer);
François Gaffie2110e042015-03-24 08:41:51 +01002591 snprintf(buffer, SIZE, " Force use for system %d\n", mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM));
Eric Laurente552edb2014-03-10 17:42:56 -07002592 result.append(buffer);
Jungshik Jang7b24ee32014-07-15 19:38:42 +09002593 snprintf(buffer, SIZE, " Force use for hdmi system audio %d\n",
François Gaffie2110e042015-03-24 08:41:51 +01002594 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO));
Jungshik Jang7b24ee32014-07-15 19:38:42 +09002595 result.append(buffer);
Phil Burk09bc4612016-02-24 15:58:15 -08002596 snprintf(buffer, SIZE, " Force use for encoded surround output %d\n",
2597 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND));
2598 result.append(buffer);
Eric Laurent9459fb02015-08-12 18:36:32 -07002599 snprintf(buffer, SIZE, " TTS output %s\n", mTtsOutputAvailable ? "available" : "not available");
2600 result.append(buffer);
Andy Hung2ddee192015-12-18 17:34:44 -08002601 snprintf(buffer, SIZE, " Master mono: %s\n", mMasterMono ? "on" : "off");
2602 result.append(buffer);
Eric Laurent9459fb02015-08-12 18:36:32 -07002603
François Gaffie2110e042015-03-24 08:41:51 +01002604 write(fd, result.string(), result.size());
Eric Laurente552edb2014-03-10 17:42:56 -07002605
François Gaffie112b0af2015-11-19 16:13:25 +01002606 mAvailableOutputDevices.dump(fd, String8("Available output"));
2607 mAvailableInputDevices.dump(fd, String8("Available input"));
Mikhail Naganovd4120142017-12-06 15:49:22 -08002608 mHwModulesAll.dump(fd);
François Gaffie53615e22015-03-19 09:24:12 +01002609 mOutputs.dump(fd);
2610 mInputs.dump(fd);
François Gaffied1ab2bd2015-12-02 18:20:06 +01002611 mVolumeCurves->dump(fd);
François Gaffie45ed3b02015-03-19 10:35:14 +01002612 mEffects.dump(fd);
François Gaffie53615e22015-03-19 09:24:12 +01002613 mAudioPatches.dump(fd);
Mikhail Naganov44344b02016-12-13 11:21:02 -08002614 mPolicyMixes.dump(fd);
Eric Laurente552edb2014-03-10 17:42:56 -07002615
2616 return NO_ERROR;
2617}
2618
2619// This function checks for the parameters which can be offloaded.
2620// This can be enhanced depending on the capability of the DSP and policy
2621// of the system.
Eric Laurente0720872014-03-11 09:30:41 -07002622bool AudioPolicyManager::isOffloadSupported(const audio_offload_info_t& offloadInfo)
Eric Laurente552edb2014-03-10 17:42:56 -07002623{
2624 ALOGV("isOffloadSupported: SR=%u, CM=0x%x, Format=0x%x, StreamType=%d,"
Eric Laurentd4692962014-05-05 18:13:44 -07002625 " BitRate=%u, duration=%" PRId64 " us, has_video=%d",
Eric Laurente552edb2014-03-10 17:42:56 -07002626 offloadInfo.sample_rate, offloadInfo.channel_mask,
2627 offloadInfo.format,
2628 offloadInfo.stream_type, offloadInfo.bit_rate, offloadInfo.duration_us,
2629 offloadInfo.has_video);
2630
Andy Hung2ddee192015-12-18 17:34:44 -08002631 if (mMasterMono) {
2632 return false; // no offloading if mono is set.
2633 }
2634
Eric Laurente552edb2014-03-10 17:42:56 -07002635 // Check if offload has been disabled
2636 char propValue[PROPERTY_VALUE_MAX];
2637 if (property_get("audio.offload.disable", propValue, "0")) {
2638 if (atoi(propValue) != 0) {
2639 ALOGV("offload disabled by audio.offload.disable=%s", propValue );
2640 return false;
2641 }
2642 }
2643
2644 // Check if stream type is music, then only allow offload as of now.
2645 if (offloadInfo.stream_type != AUDIO_STREAM_MUSIC)
2646 {
2647 ALOGV("isOffloadSupported: stream_type != MUSIC, returning false");
2648 return false;
2649 }
2650
2651 //TODO: enable audio offloading with video when ready
Andy Hung08945c42015-05-31 21:36:46 -07002652 const bool allowOffloadWithVideo =
2653 property_get_bool("audio.offload.video", false /* default_value */);
2654 if (offloadInfo.has_video && !allowOffloadWithVideo) {
Eric Laurente552edb2014-03-10 17:42:56 -07002655 ALOGV("isOffloadSupported: has_video == true, returning false");
2656 return false;
2657 }
2658
2659 //If duration is less than minimum value defined in property, return false
2660 if (property_get("audio.offload.min.duration.secs", propValue, NULL)) {
2661 if (offloadInfo.duration_us < (atoi(propValue) * 1000000 )) {
2662 ALOGV("Offload denied by duration < audio.offload.min.duration.secs(=%s)", propValue);
2663 return false;
2664 }
2665 } else if (offloadInfo.duration_us < OFFLOAD_DEFAULT_MIN_DURATION_SECS * 1000000) {
2666 ALOGV("Offload denied by duration < default min(=%u)", OFFLOAD_DEFAULT_MIN_DURATION_SECS);
2667 return false;
2668 }
2669
2670 // Do not allow offloading if one non offloadable effect is enabled. This prevents from
2671 // creating an offloaded track and tearing it down immediately after start when audioflinger
2672 // detects there is an active non offloadable effect.
2673 // FIXME: We should check the audio session here but we do not have it in this context.
2674 // This may prevent offloading in rare situations where effects are left active by apps
2675 // in the background.
François Gaffie45ed3b02015-03-19 10:35:14 +01002676 if (mEffects.isNonOffloadableEffectEnabled()) {
Eric Laurente552edb2014-03-10 17:42:56 -07002677 return false;
2678 }
2679
2680 // See if there is a profile to support this.
2681 // AUDIO_DEVICE_NONE
Eric Laurent1c333e22014-05-20 10:48:17 -07002682 sp<IOProfile> profile = getProfileForDirectOutput(AUDIO_DEVICE_NONE /*ignore device */,
Eric Laurente552edb2014-03-10 17:42:56 -07002683 offloadInfo.sample_rate,
2684 offloadInfo.format,
2685 offloadInfo.channel_mask,
2686 AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD);
Eric Laurent1c333e22014-05-20 10:48:17 -07002687 ALOGV("isOffloadSupported() profile %sfound", profile != 0 ? "" : "NOT ");
2688 return (profile != 0);
Eric Laurente552edb2014-03-10 17:42:56 -07002689}
2690
Eric Laurent6a94d692014-05-20 11:18:06 -07002691status_t AudioPolicyManager::listAudioPorts(audio_port_role_t role,
2692 audio_port_type_t type,
2693 unsigned int *num_ports,
2694 struct audio_port *ports,
2695 unsigned int *generation)
2696{
2697 if (num_ports == NULL || (*num_ports != 0 && ports == NULL) ||
2698 generation == NULL) {
2699 return BAD_VALUE;
2700 }
2701 ALOGV("listAudioPorts() role %d type %d num_ports %d ports %p", role, type, *num_ports, ports);
2702 if (ports == NULL) {
2703 *num_ports = 0;
2704 }
2705
2706 size_t portsWritten = 0;
2707 size_t portsMax = *num_ports;
2708 *num_ports = 0;
2709 if (type == AUDIO_PORT_TYPE_NONE || type == AUDIO_PORT_TYPE_DEVICE) {
Eric Laurent5a2b6292016-04-14 18:05:57 -07002710 // do not report devices with type AUDIO_DEVICE_IN_STUB or AUDIO_DEVICE_OUT_STUB
2711 // as they are used by stub HALs by convention
Eric Laurent6a94d692014-05-20 11:18:06 -07002712 if (role == AUDIO_PORT_ROLE_SINK || role == AUDIO_PORT_ROLE_NONE) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002713 for (const auto& dev : mAvailableOutputDevices) {
2714 if (dev->type() == AUDIO_DEVICE_OUT_STUB) {
Eric Laurent5a2b6292016-04-14 18:05:57 -07002715 continue;
2716 }
2717 if (portsWritten < portsMax) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002718 dev->toAudioPort(&ports[portsWritten++]);
Eric Laurent5a2b6292016-04-14 18:05:57 -07002719 }
2720 (*num_ports)++;
Eric Laurent6a94d692014-05-20 11:18:06 -07002721 }
Eric Laurent6a94d692014-05-20 11:18:06 -07002722 }
2723 if (role == AUDIO_PORT_ROLE_SOURCE || role == AUDIO_PORT_ROLE_NONE) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002724 for (const auto& dev : mAvailableInputDevices) {
2725 if (dev->type() == AUDIO_DEVICE_IN_STUB) {
Eric Laurent5a2b6292016-04-14 18:05:57 -07002726 continue;
2727 }
2728 if (portsWritten < portsMax) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002729 dev->toAudioPort(&ports[portsWritten++]);
Eric Laurent5a2b6292016-04-14 18:05:57 -07002730 }
2731 (*num_ports)++;
Eric Laurent6a94d692014-05-20 11:18:06 -07002732 }
Eric Laurent6a94d692014-05-20 11:18:06 -07002733 }
2734 }
2735 if (type == AUDIO_PORT_TYPE_NONE || type == AUDIO_PORT_TYPE_MIX) {
2736 if (role == AUDIO_PORT_ROLE_SINK || role == AUDIO_PORT_ROLE_NONE) {
2737 for (size_t i = 0; i < mInputs.size() && portsWritten < portsMax; i++) {
2738 mInputs[i]->toAudioPort(&ports[portsWritten++]);
2739 }
2740 *num_ports += mInputs.size();
2741 }
2742 if (role == AUDIO_PORT_ROLE_SOURCE || role == AUDIO_PORT_ROLE_NONE) {
Eric Laurent84c70242014-06-23 08:46:27 -07002743 size_t numOutputs = 0;
2744 for (size_t i = 0; i < mOutputs.size(); i++) {
2745 if (!mOutputs[i]->isDuplicated()) {
2746 numOutputs++;
2747 if (portsWritten < portsMax) {
2748 mOutputs[i]->toAudioPort(&ports[portsWritten++]);
2749 }
2750 }
Eric Laurent6a94d692014-05-20 11:18:06 -07002751 }
Eric Laurent84c70242014-06-23 08:46:27 -07002752 *num_ports += numOutputs;
Eric Laurent6a94d692014-05-20 11:18:06 -07002753 }
2754 }
2755 *generation = curAudioPortGeneration();
Mark Salyzynbeb9e302014-06-18 16:33:15 -07002756 ALOGV("listAudioPorts() got %zu ports needed %d", portsWritten, *num_ports);
Eric Laurent6a94d692014-05-20 11:18:06 -07002757 return NO_ERROR;
2758}
2759
2760status_t AudioPolicyManager::getAudioPort(struct audio_port *port __unused)
2761{
2762 return NO_ERROR;
2763}
2764
Eric Laurent6a94d692014-05-20 11:18:06 -07002765status_t AudioPolicyManager::createAudioPatch(const struct audio_patch *patch,
2766 audio_patch_handle_t *handle,
2767 uid_t uid)
2768{
2769 ALOGV("createAudioPatch()");
2770
2771 if (handle == NULL || patch == NULL) {
2772 return BAD_VALUE;
2773 }
2774 ALOGV("createAudioPatch() num sources %d num sinks %d", patch->num_sources, patch->num_sinks);
2775
Eric Laurent874c42872014-08-08 15:13:39 -07002776 if (patch->num_sources == 0 || patch->num_sources > AUDIO_PATCH_PORTS_MAX ||
2777 patch->num_sinks == 0 || patch->num_sinks > AUDIO_PATCH_PORTS_MAX) {
2778 return BAD_VALUE;
2779 }
2780 // only one source per audio patch supported for now
2781 if (patch->num_sources > 1) {
Eric Laurent6a94d692014-05-20 11:18:06 -07002782 return INVALID_OPERATION;
2783 }
Eric Laurent874c42872014-08-08 15:13:39 -07002784
2785 if (patch->sources[0].role != AUDIO_PORT_ROLE_SOURCE) {
Eric Laurent6a94d692014-05-20 11:18:06 -07002786 return INVALID_OPERATION;
2787 }
Eric Laurent874c42872014-08-08 15:13:39 -07002788 for (size_t i = 0; i < patch->num_sinks; i++) {
2789 if (patch->sinks[i].role != AUDIO_PORT_ROLE_SINK) {
2790 return INVALID_OPERATION;
2791 }
2792 }
Eric Laurent6a94d692014-05-20 11:18:06 -07002793
2794 sp<AudioPatch> patchDesc;
2795 ssize_t index = mAudioPatches.indexOfKey(*handle);
2796
Eric Laurent6a94d692014-05-20 11:18:06 -07002797 ALOGV("createAudioPatch source id %d role %d type %d", patch->sources[0].id,
2798 patch->sources[0].role,
2799 patch->sources[0].type);
Eric Laurent874c42872014-08-08 15:13:39 -07002800#if LOG_NDEBUG == 0
2801 for (size_t i = 0; i < patch->num_sinks; i++) {
Eric Laurent7b279bb2015-12-14 10:18:23 -08002802 ALOGV("createAudioPatch sink %zu: id %d role %d type %d", i, patch->sinks[i].id,
Eric Laurent874c42872014-08-08 15:13:39 -07002803 patch->sinks[i].role,
2804 patch->sinks[i].type);
2805 }
2806#endif
Eric Laurent6a94d692014-05-20 11:18:06 -07002807
2808 if (index >= 0) {
2809 patchDesc = mAudioPatches.valueAt(index);
2810 ALOGV("createAudioPatch() mUidCached %d patchDesc->mUid %d uid %d",
2811 mUidCached, patchDesc->mUid, uid);
2812 if (patchDesc->mUid != mUidCached && uid != patchDesc->mUid) {
2813 return INVALID_OPERATION;
2814 }
2815 } else {
Glenn Kastena13cde92016-03-28 15:26:02 -07002816 *handle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurent6a94d692014-05-20 11:18:06 -07002817 }
2818
2819 if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) {
Eric Laurentc75307b2015-03-17 15:29:32 -07002820 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07002821 if (outputDesc == NULL) {
2822 ALOGV("createAudioPatch() output not found for id %d", patch->sources[0].id);
2823 return BAD_VALUE;
2824 }
Eric Laurent84c70242014-06-23 08:46:27 -07002825 ALOG_ASSERT(!outputDesc->isDuplicated(),"duplicated output %d in source in ports",
2826 outputDesc->mIoHandle);
Eric Laurent6a94d692014-05-20 11:18:06 -07002827 if (patchDesc != 0) {
2828 if (patchDesc->mPatch.sources[0].id != patch->sources[0].id) {
2829 ALOGV("createAudioPatch() source id differs for patch current id %d new id %d",
2830 patchDesc->mPatch.sources[0].id, patch->sources[0].id);
2831 return BAD_VALUE;
2832 }
2833 }
Eric Laurent874c42872014-08-08 15:13:39 -07002834 DeviceVector devices;
2835 for (size_t i = 0; i < patch->num_sinks; i++) {
2836 // Only support mix to devices connection
2837 // TODO add support for mix to mix connection
2838 if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) {
2839 ALOGV("createAudioPatch() source mix but sink is not a device");
2840 return INVALID_OPERATION;
2841 }
2842 sp<DeviceDescriptor> devDesc =
2843 mAvailableOutputDevices.getDeviceFromId(patch->sinks[i].id);
2844 if (devDesc == 0) {
2845 ALOGV("createAudioPatch() out device not found for id %d", patch->sinks[i].id);
2846 return BAD_VALUE;
2847 }
Eric Laurent6a94d692014-05-20 11:18:06 -07002848
François Gaffie53615e22015-03-19 09:24:12 +01002849 if (!outputDesc->mProfile->isCompatibleProfile(devDesc->type(),
Eric Laurent275e8e92014-11-30 15:14:47 -08002850 devDesc->mAddress,
Eric Laurent874c42872014-08-08 15:13:39 -07002851 patch->sources[0].sample_rate,
François Gaffie53615e22015-03-19 09:24:12 +01002852 NULL, // updatedSamplingRate
2853 patch->sources[0].format,
Andy Hungf129b032015-04-07 13:45:50 -07002854 NULL, // updatedFormat
François Gaffie53615e22015-03-19 09:24:12 +01002855 patch->sources[0].channel_mask,
Andy Hungf129b032015-04-07 13:45:50 -07002856 NULL, // updatedChannelMask
François Gaffie53615e22015-03-19 09:24:12 +01002857 AUDIO_OUTPUT_FLAG_NONE /*FIXME*/)) {
Andy Hungf129b032015-04-07 13:45:50 -07002858 ALOGV("createAudioPatch() profile not supported for device %08x",
2859 devDesc->type());
Eric Laurent874c42872014-08-08 15:13:39 -07002860 return INVALID_OPERATION;
2861 }
2862 devices.add(devDesc);
2863 }
2864 if (devices.size() == 0) {
Eric Laurent6a94d692014-05-20 11:18:06 -07002865 return INVALID_OPERATION;
2866 }
Eric Laurent874c42872014-08-08 15:13:39 -07002867
Eric Laurent6a94d692014-05-20 11:18:06 -07002868 // TODO: reconfigure output format and channels here
2869 ALOGV("createAudioPatch() setting device %08x on output %d",
Eric Laurent874c42872014-08-08 15:13:39 -07002870 devices.types(), outputDesc->mIoHandle);
Eric Laurentc75307b2015-03-17 15:29:32 -07002871 setOutputDevice(outputDesc, devices.types(), true, 0, handle);
Eric Laurent6a94d692014-05-20 11:18:06 -07002872 index = mAudioPatches.indexOfKey(*handle);
2873 if (index >= 0) {
2874 if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) {
2875 ALOGW("createAudioPatch() setOutputDevice() did not reuse the patch provided");
2876 }
2877 patchDesc = mAudioPatches.valueAt(index);
2878 patchDesc->mUid = uid;
2879 ALOGV("createAudioPatch() success");
2880 } else {
2881 ALOGW("createAudioPatch() setOutputDevice() failed to create a patch");
2882 return INVALID_OPERATION;
2883 }
2884 } else if (patch->sources[0].type == AUDIO_PORT_TYPE_DEVICE) {
2885 if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
2886 // input device to input mix connection
Eric Laurent874c42872014-08-08 15:13:39 -07002887 // only one sink supported when connecting an input device to a mix
2888 if (patch->num_sinks > 1) {
2889 return INVALID_OPERATION;
2890 }
François Gaffie53615e22015-03-19 09:24:12 +01002891 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(patch->sinks[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07002892 if (inputDesc == NULL) {
2893 return BAD_VALUE;
2894 }
2895 if (patchDesc != 0) {
2896 if (patchDesc->mPatch.sinks[0].id != patch->sinks[0].id) {
2897 return BAD_VALUE;
2898 }
2899 }
2900 sp<DeviceDescriptor> devDesc =
2901 mAvailableInputDevices.getDeviceFromId(patch->sources[0].id);
2902 if (devDesc == 0) {
2903 return BAD_VALUE;
2904 }
2905
François Gaffie53615e22015-03-19 09:24:12 +01002906 if (!inputDesc->mProfile->isCompatibleProfile(devDesc->type(),
Eric Laurent275e8e92014-11-30 15:14:47 -08002907 devDesc->mAddress,
2908 patch->sinks[0].sample_rate,
2909 NULL, /*updatedSampleRate*/
2910 patch->sinks[0].format,
Andy Hungf129b032015-04-07 13:45:50 -07002911 NULL, /*updatedFormat*/
Eric Laurent275e8e92014-11-30 15:14:47 -08002912 patch->sinks[0].channel_mask,
Andy Hungf129b032015-04-07 13:45:50 -07002913 NULL, /*updatedChannelMask*/
Eric Laurent275e8e92014-11-30 15:14:47 -08002914 // FIXME for the parameter type,
2915 // and the NONE
2916 (audio_output_flags_t)
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002917 AUDIO_INPUT_FLAG_NONE)) {
Eric Laurent6a94d692014-05-20 11:18:06 -07002918 return INVALID_OPERATION;
2919 }
2920 // TODO: reconfigure output format and channels here
2921 ALOGV("createAudioPatch() setting device %08x on output %d",
François Gaffie53615e22015-03-19 09:24:12 +01002922 devDesc->type(), inputDesc->mIoHandle);
2923 setInputDevice(inputDesc->mIoHandle, devDesc->type(), true, handle);
Eric Laurent6a94d692014-05-20 11:18:06 -07002924 index = mAudioPatches.indexOfKey(*handle);
2925 if (index >= 0) {
2926 if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) {
2927 ALOGW("createAudioPatch() setInputDevice() did not reuse the patch provided");
2928 }
2929 patchDesc = mAudioPatches.valueAt(index);
2930 patchDesc->mUid = uid;
2931 ALOGV("createAudioPatch() success");
2932 } else {
2933 ALOGW("createAudioPatch() setInputDevice() failed to create a patch");
2934 return INVALID_OPERATION;
2935 }
2936 } else if (patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) {
2937 // device to device connection
2938 if (patchDesc != 0) {
Eric Laurent874c42872014-08-08 15:13:39 -07002939 if (patchDesc->mPatch.sources[0].id != patch->sources[0].id) {
Eric Laurent6a94d692014-05-20 11:18:06 -07002940 return BAD_VALUE;
2941 }
2942 }
Eric Laurent6a94d692014-05-20 11:18:06 -07002943 sp<DeviceDescriptor> srcDeviceDesc =
2944 mAvailableInputDevices.getDeviceFromId(patch->sources[0].id);
Eric Laurent58f8eb72014-09-12 16:19:41 -07002945 if (srcDeviceDesc == 0) {
2946 return BAD_VALUE;
2947 }
Eric Laurent874c42872014-08-08 15:13:39 -07002948
Eric Laurent6a94d692014-05-20 11:18:06 -07002949 //update source and sink with our own data as the data passed in the patch may
2950 // be incomplete.
2951 struct audio_patch newPatch = *patch;
2952 srcDeviceDesc->toAudioPortConfig(&newPatch.sources[0], &patch->sources[0]);
Eric Laurent6a94d692014-05-20 11:18:06 -07002953
Eric Laurent874c42872014-08-08 15:13:39 -07002954 for (size_t i = 0; i < patch->num_sinks; i++) {
2955 if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) {
2956 ALOGV("createAudioPatch() source device but one sink is not a device");
2957 return INVALID_OPERATION;
2958 }
2959
2960 sp<DeviceDescriptor> sinkDeviceDesc =
2961 mAvailableOutputDevices.getDeviceFromId(patch->sinks[i].id);
2962 if (sinkDeviceDesc == 0) {
2963 return BAD_VALUE;
2964 }
2965 sinkDeviceDesc->toAudioPortConfig(&newPatch.sinks[i], &patch->sinks[i]);
2966
Eric Laurent3bcf8592015-04-03 12:13:24 -07002967 // create a software bridge in PatchPanel if:
Scott Randolphf3172402018-01-23 17:06:53 -08002968 // - source and sink devices are on different HW modules OR
Eric Laurent3bcf8592015-04-03 12:13:24 -07002969 // - audio HAL version is < 3.0
Eric Laurentfb66dd92016-01-28 18:32:03 -08002970 if (!srcDeviceDesc->hasSameHwModuleAs(sinkDeviceDesc) ||
Mikhail Naganov9ee05402016-10-13 15:58:17 -07002971 (srcDeviceDesc->mModule->getHalVersionMajor() < 3)) {
Eric Laurent3bcf8592015-04-03 12:13:24 -07002972 // support only one sink device for now to simplify output selection logic
Eric Laurent874c42872014-08-08 15:13:39 -07002973 if (patch->num_sinks > 1) {
Eric Laurent83b88082014-06-20 18:31:16 -07002974 return INVALID_OPERATION;
2975 }
Eric Laurent874c42872014-08-08 15:13:39 -07002976 SortedVector<audio_io_handle_t> outputs =
François Gaffie53615e22015-03-19 09:24:12 +01002977 getOutputsForDevice(sinkDeviceDesc->type(), mOutputs);
Eric Laurent874c42872014-08-08 15:13:39 -07002978 // if the sink device is reachable via an opened output stream, request to go via
2979 // this output stream by adding a second source to the patch description
Eric Laurent8838a382014-09-08 16:44:28 -07002980 audio_io_handle_t output = selectOutput(outputs,
2981 AUDIO_OUTPUT_FLAG_NONE,
2982 AUDIO_FORMAT_INVALID);
Eric Laurent874c42872014-08-08 15:13:39 -07002983 if (output != AUDIO_IO_HANDLE_NONE) {
2984 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
2985 if (outputDesc->isDuplicated()) {
2986 return INVALID_OPERATION;
2987 }
2988 outputDesc->toAudioPortConfig(&newPatch.sources[1], &patch->sources[0]);
Eric Laurent3bcf8592015-04-03 12:13:24 -07002989 newPatch.sources[1].ext.mix.usecase.stream = AUDIO_STREAM_PATCH;
Eric Laurent874c42872014-08-08 15:13:39 -07002990 newPatch.num_sources = 2;
2991 }
Eric Laurent83b88082014-06-20 18:31:16 -07002992 }
Eric Laurent6a94d692014-05-20 11:18:06 -07002993 }
2994 // TODO: check from routing capabilities in config file and other conflicting patches
2995
2996 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
2997 if (index >= 0) {
2998 afPatchHandle = patchDesc->mAfPatchHandle;
2999 }
3000
3001 status_t status = mpClientInterface->createAudioPatch(&newPatch,
3002 &afPatchHandle,
3003 0);
3004 ALOGV("createAudioPatch() patch panel returned %d patchHandle %d",
3005 status, afPatchHandle);
3006 if (status == NO_ERROR) {
3007 if (index < 0) {
François Gaffie98cc1912015-03-18 17:52:40 +01003008 patchDesc = new AudioPatch(&newPatch, uid);
Eric Laurent6a94d692014-05-20 11:18:06 -07003009 addAudioPatch(patchDesc->mHandle, patchDesc);
3010 } else {
3011 patchDesc->mPatch = newPatch;
3012 }
3013 patchDesc->mAfPatchHandle = afPatchHandle;
3014 *handle = patchDesc->mHandle;
3015 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07003016 mpClientInterface->onAudioPatchListUpdate();
Eric Laurent6a94d692014-05-20 11:18:06 -07003017 } else {
3018 ALOGW("createAudioPatch() patch panel could not connect device patch, error %d",
3019 status);
3020 return INVALID_OPERATION;
3021 }
3022 } else {
3023 return BAD_VALUE;
3024 }
3025 } else {
3026 return BAD_VALUE;
3027 }
3028 return NO_ERROR;
3029}
3030
3031status_t AudioPolicyManager::releaseAudioPatch(audio_patch_handle_t handle,
3032 uid_t uid)
3033{
3034 ALOGV("releaseAudioPatch() patch %d", handle);
3035
3036 ssize_t index = mAudioPatches.indexOfKey(handle);
3037
3038 if (index < 0) {
3039 return BAD_VALUE;
3040 }
3041 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
3042 ALOGV("releaseAudioPatch() mUidCached %d patchDesc->mUid %d uid %d",
3043 mUidCached, patchDesc->mUid, uid);
3044 if (patchDesc->mUid != mUidCached && uid != patchDesc->mUid) {
3045 return INVALID_OPERATION;
3046 }
3047
3048 struct audio_patch *patch = &patchDesc->mPatch;
3049 patchDesc->mUid = mUidCached;
3050 if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) {
Eric Laurentc75307b2015-03-17 15:29:32 -07003051 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07003052 if (outputDesc == NULL) {
3053 ALOGV("releaseAudioPatch() output not found for id %d", patch->sources[0].id);
3054 return BAD_VALUE;
3055 }
3056
Eric Laurentc75307b2015-03-17 15:29:32 -07003057 setOutputDevice(outputDesc,
3058 getNewOutputDevice(outputDesc, true /*fromCache*/),
Eric Laurent6a94d692014-05-20 11:18:06 -07003059 true,
3060 0,
3061 NULL);
3062 } else if (patch->sources[0].type == AUDIO_PORT_TYPE_DEVICE) {
3063 if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
François Gaffie53615e22015-03-19 09:24:12 +01003064 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(patch->sinks[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07003065 if (inputDesc == NULL) {
3066 ALOGV("releaseAudioPatch() input not found for id %d", patch->sinks[0].id);
3067 return BAD_VALUE;
3068 }
3069 setInputDevice(inputDesc->mIoHandle,
Eric Laurentfb66dd92016-01-28 18:32:03 -08003070 getNewInputDevice(inputDesc),
Eric Laurent6a94d692014-05-20 11:18:06 -07003071 true,
3072 NULL);
3073 } else if (patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003074 status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
3075 ALOGV("releaseAudioPatch() patch panel returned %d patchHandle %d",
3076 status, patchDesc->mAfPatchHandle);
3077 removeAudioPatch(patchDesc->mHandle);
3078 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07003079 mpClientInterface->onAudioPatchListUpdate();
Eric Laurent6a94d692014-05-20 11:18:06 -07003080 } else {
3081 return BAD_VALUE;
3082 }
3083 } else {
3084 return BAD_VALUE;
3085 }
3086 return NO_ERROR;
3087}
3088
3089status_t AudioPolicyManager::listAudioPatches(unsigned int *num_patches,
3090 struct audio_patch *patches,
3091 unsigned int *generation)
3092{
François Gaffie53615e22015-03-19 09:24:12 +01003093 if (generation == NULL) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003094 return BAD_VALUE;
3095 }
Eric Laurent6a94d692014-05-20 11:18:06 -07003096 *generation = curAudioPortGeneration();
François Gaffie53615e22015-03-19 09:24:12 +01003097 return mAudioPatches.listAudioPatches(num_patches, patches);
Eric Laurent6a94d692014-05-20 11:18:06 -07003098}
3099
Eric Laurente1715a42014-05-20 11:30:42 -07003100status_t AudioPolicyManager::setAudioPortConfig(const struct audio_port_config *config)
Eric Laurent6a94d692014-05-20 11:18:06 -07003101{
Eric Laurente1715a42014-05-20 11:30:42 -07003102 ALOGV("setAudioPortConfig()");
3103
3104 if (config == NULL) {
3105 return BAD_VALUE;
3106 }
3107 ALOGV("setAudioPortConfig() on port handle %d", config->id);
3108 // Only support gain configuration for now
Eric Laurenta121f902014-06-03 13:32:54 -07003109 if (config->config_mask != AUDIO_PORT_CONFIG_GAIN) {
3110 return INVALID_OPERATION;
Eric Laurente1715a42014-05-20 11:30:42 -07003111 }
3112
Eric Laurenta121f902014-06-03 13:32:54 -07003113 sp<AudioPortConfig> audioPortConfig;
Eric Laurente1715a42014-05-20 11:30:42 -07003114 if (config->type == AUDIO_PORT_TYPE_MIX) {
3115 if (config->role == AUDIO_PORT_ROLE_SOURCE) {
Eric Laurentc75307b2015-03-17 15:29:32 -07003116 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(config->id);
Eric Laurente1715a42014-05-20 11:30:42 -07003117 if (outputDesc == NULL) {
3118 return BAD_VALUE;
3119 }
Eric Laurent84c70242014-06-23 08:46:27 -07003120 ALOG_ASSERT(!outputDesc->isDuplicated(),
3121 "setAudioPortConfig() called on duplicated output %d",
3122 outputDesc->mIoHandle);
Eric Laurenta121f902014-06-03 13:32:54 -07003123 audioPortConfig = outputDesc;
Eric Laurente1715a42014-05-20 11:30:42 -07003124 } else if (config->role == AUDIO_PORT_ROLE_SINK) {
François Gaffie53615e22015-03-19 09:24:12 +01003125 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(config->id);
Eric Laurente1715a42014-05-20 11:30:42 -07003126 if (inputDesc == NULL) {
3127 return BAD_VALUE;
3128 }
Eric Laurenta121f902014-06-03 13:32:54 -07003129 audioPortConfig = inputDesc;
Eric Laurente1715a42014-05-20 11:30:42 -07003130 } else {
3131 return BAD_VALUE;
3132 }
3133 } else if (config->type == AUDIO_PORT_TYPE_DEVICE) {
3134 sp<DeviceDescriptor> deviceDesc;
3135 if (config->role == AUDIO_PORT_ROLE_SOURCE) {
3136 deviceDesc = mAvailableInputDevices.getDeviceFromId(config->id);
3137 } else if (config->role == AUDIO_PORT_ROLE_SINK) {
3138 deviceDesc = mAvailableOutputDevices.getDeviceFromId(config->id);
3139 } else {
3140 return BAD_VALUE;
3141 }
3142 if (deviceDesc == NULL) {
3143 return BAD_VALUE;
3144 }
Eric Laurenta121f902014-06-03 13:32:54 -07003145 audioPortConfig = deviceDesc;
Eric Laurente1715a42014-05-20 11:30:42 -07003146 } else {
3147 return BAD_VALUE;
3148 }
3149
Eric Laurenta121f902014-06-03 13:32:54 -07003150 struct audio_port_config backupConfig;
3151 status_t status = audioPortConfig->applyAudioPortConfig(config, &backupConfig);
3152 if (status == NO_ERROR) {
3153 struct audio_port_config newConfig;
3154 audioPortConfig->toAudioPortConfig(&newConfig, config);
3155 status = mpClientInterface->setAudioPortConfig(&newConfig, 0);
Eric Laurente1715a42014-05-20 11:30:42 -07003156 }
Eric Laurenta121f902014-06-03 13:32:54 -07003157 if (status != NO_ERROR) {
3158 audioPortConfig->applyAudioPortConfig(&backupConfig);
Eric Laurente1715a42014-05-20 11:30:42 -07003159 }
Eric Laurente1715a42014-05-20 11:30:42 -07003160
3161 return status;
Eric Laurent6a94d692014-05-20 11:18:06 -07003162}
3163
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003164void AudioPolicyManager::releaseResourcesForUid(uid_t uid)
3165{
Eric Laurentd60560a2015-04-10 11:31:20 -07003166 clearAudioSources(uid);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003167 clearAudioPatches(uid);
3168 clearSessionRoutes(uid);
3169}
3170
Eric Laurent6a94d692014-05-20 11:18:06 -07003171void AudioPolicyManager::clearAudioPatches(uid_t uid)
3172{
Eric Laurent0add0fd2014-12-04 18:58:14 -08003173 for (ssize_t i = (ssize_t)mAudioPatches.size() - 1; i >= 0; i--) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003174 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(i);
3175 if (patchDesc->mUid == uid) {
Eric Laurent0add0fd2014-12-04 18:58:14 -08003176 releaseAudioPatch(mAudioPatches.keyAt(i), uid);
Eric Laurent6a94d692014-05-20 11:18:06 -07003177 }
3178 }
3179}
3180
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003181void AudioPolicyManager::checkStrategyRoute(routing_strategy strategy,
3182 audio_io_handle_t ouptutToSkip)
3183{
3184 audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
3185 SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs);
3186 for (size_t j = 0; j < mOutputs.size(); j++) {
3187 if (mOutputs.keyAt(j) == ouptutToSkip) {
3188 continue;
3189 }
3190 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(j);
3191 if (!isStrategyActive(outputDesc, (routing_strategy)strategy)) {
3192 continue;
3193 }
3194 // If the default device for this strategy is on another output mix,
3195 // invalidate all tracks in this strategy to force re connection.
3196 // Otherwise select new device on the output mix.
3197 if (outputs.indexOf(mOutputs.keyAt(j)) < 0) {
Eric Laurent794fde22016-03-11 09:50:45 -08003198 for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) {
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003199 if (getStrategy((audio_stream_type_t)stream) == strategy) {
3200 mpClientInterface->invalidateStream((audio_stream_type_t)stream);
3201 }
3202 }
3203 } else {
3204 audio_devices_t newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/);
3205 setOutputDevice(outputDesc, newDevice, false);
3206 }
3207 }
3208}
3209
3210void AudioPolicyManager::clearSessionRoutes(uid_t uid)
3211{
3212 // remove output routes associated with this uid
3213 SortedVector<routing_strategy> affectedStrategies;
3214 for (ssize_t i = (ssize_t)mOutputRoutes.size() - 1; i >= 0; i--) {
3215 sp<SessionRoute> route = mOutputRoutes.valueAt(i);
3216 if (route->mUid == uid) {
3217 mOutputRoutes.removeItemsAt(i);
3218 if (route->mDeviceDescriptor != 0) {
3219 affectedStrategies.add(getStrategy(route->mStreamType));
3220 }
3221 }
3222 }
3223 // reroute outputs if necessary
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003224 for (const auto& strategy : affectedStrategies) {
3225 checkStrategyRoute(strategy, AUDIO_IO_HANDLE_NONE);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003226 }
3227
3228 // remove input routes associated with this uid
3229 SortedVector<audio_source_t> affectedSources;
3230 for (ssize_t i = (ssize_t)mInputRoutes.size() - 1; i >= 0; i--) {
3231 sp<SessionRoute> route = mInputRoutes.valueAt(i);
3232 if (route->mUid == uid) {
3233 mInputRoutes.removeItemsAt(i);
3234 if (route->mDeviceDescriptor != 0) {
3235 affectedSources.add(route->mSource);
3236 }
3237 }
3238 }
3239 // reroute inputs if necessary
3240 SortedVector<audio_io_handle_t> inputsToClose;
3241 for (size_t i = 0; i < mInputs.size(); i++) {
3242 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(i);
Eric Laurent599c7582015-12-07 18:05:55 -08003243 if (affectedSources.indexOf(inputDesc->inputSource()) >= 0) {
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003244 inputsToClose.add(inputDesc->mIoHandle);
3245 }
3246 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003247 for (const auto& input : inputsToClose) {
3248 closeInput(input);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003249 }
3250}
3251
Eric Laurentd60560a2015-04-10 11:31:20 -07003252void AudioPolicyManager::clearAudioSources(uid_t uid)
3253{
3254 for (ssize_t i = (ssize_t)mAudioSources.size() - 1; i >= 0; i--) {
3255 sp<AudioSourceDescriptor> sourceDesc = mAudioSources.valueAt(i);
3256 if (sourceDesc->mUid == uid) {
3257 stopAudioSource(mAudioSources.keyAt(i));
3258 }
3259 }
3260}
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003261
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07003262status_t AudioPolicyManager::acquireSoundTriggerSession(audio_session_t *session,
3263 audio_io_handle_t *ioHandle,
3264 audio_devices_t *device)
3265{
Glenn Kastenf0c6d7d2016-02-26 10:44:04 -08003266 *session = (audio_session_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
3267 *ioHandle = (audio_io_handle_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_INPUT);
Eric Laurentc73ca6e2014-12-12 14:34:22 -08003268 *device = getDeviceAndMixForInputSource(AUDIO_SOURCE_HOTWORD);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07003269
François Gaffiedf372692015-03-19 10:43:27 +01003270 return mSoundTriggerSessions.acquireSession(*session, *ioHandle);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07003271}
3272
Eric Laurentd60560a2015-04-10 11:31:20 -07003273status_t AudioPolicyManager::startAudioSource(const struct audio_port_config *source,
3274 const audio_attributes_t *attributes,
Glenn Kasten559d4392016-03-29 13:42:57 -07003275 audio_patch_handle_t *handle,
Eric Laurentd60560a2015-04-10 11:31:20 -07003276 uid_t uid)
Eric Laurent554a2772015-04-10 11:29:24 -07003277{
Eric Laurentd60560a2015-04-10 11:31:20 -07003278 ALOGV("%s source %p attributes %p handle %p", __FUNCTION__, source, attributes, handle);
3279 if (source == NULL || attributes == NULL || handle == NULL) {
3280 return BAD_VALUE;
3281 }
3282
Glenn Kasten559d4392016-03-29 13:42:57 -07003283 *handle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurentd60560a2015-04-10 11:31:20 -07003284
3285 if (source->role != AUDIO_PORT_ROLE_SOURCE ||
3286 source->type != AUDIO_PORT_TYPE_DEVICE) {
3287 ALOGV("%s INVALID_OPERATION source->role %d source->type %d", __FUNCTION__, source->role, source->type);
3288 return INVALID_OPERATION;
3289 }
3290
3291 sp<DeviceDescriptor> srcDeviceDesc =
3292 mAvailableInputDevices.getDevice(source->ext.device.type,
3293 String8(source->ext.device.address));
3294 if (srcDeviceDesc == 0) {
3295 ALOGV("%s source->ext.device.type %08x not found", __FUNCTION__, source->ext.device.type);
3296 return BAD_VALUE;
3297 }
3298 sp<AudioSourceDescriptor> sourceDesc =
3299 new AudioSourceDescriptor(srcDeviceDesc, attributes, uid);
3300
3301 struct audio_patch dummyPatch;
3302 sp<AudioPatch> patchDesc = new AudioPatch(&dummyPatch, uid);
3303 sourceDesc->mPatchDesc = patchDesc;
3304
3305 status_t status = connectAudioSource(sourceDesc);
3306 if (status == NO_ERROR) {
3307 mAudioSources.add(sourceDesc->getHandle(), sourceDesc);
3308 *handle = sourceDesc->getHandle();
3309 }
3310 return status;
3311}
3312
3313status_t AudioPolicyManager::connectAudioSource(const sp<AudioSourceDescriptor>& sourceDesc)
3314{
3315 ALOGV("%s handle %d", __FUNCTION__, sourceDesc->getHandle());
3316
3317 // make sure we only have one patch per source.
3318 disconnectAudioSource(sourceDesc);
3319
3320 routing_strategy strategy = (routing_strategy) getStrategyForAttr(&sourceDesc->mAttributes);
Eric Laurent28d09f02016-03-08 10:43:05 -08003321 audio_stream_type_t stream = streamTypefromAttributesInt(&sourceDesc->mAttributes);
Eric Laurentd60560a2015-04-10 11:31:20 -07003322 sp<DeviceDescriptor> srcDeviceDesc = sourceDesc->mDevice;
3323
3324 audio_devices_t sinkDevice = getDeviceForStrategy(strategy, true);
3325 sp<DeviceDescriptor> sinkDeviceDesc =
3326 mAvailableOutputDevices.getDevice(sinkDevice, String8(""));
3327
3328 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
3329 struct audio_patch *patch = &sourceDesc->mPatchDesc->mPatch;
3330
3331 if (srcDeviceDesc->getAudioPort()->mModule->getHandle() ==
3332 sinkDeviceDesc->getAudioPort()->mModule->getHandle() &&
Mikhail Naganov9ee05402016-10-13 15:58:17 -07003333 srcDeviceDesc->getAudioPort()->mModule->getHalVersionMajor() >= 3 &&
Eric Laurentd60560a2015-04-10 11:31:20 -07003334 srcDeviceDesc->getAudioPort()->mGains.size() > 0) {
3335 ALOGV("%s AUDIO_DEVICE_API_VERSION_3_0", __FUNCTION__);
3336 // create patch between src device and output device
3337 // create Hwoutput and add to mHwOutputs
3338 } else {
3339 SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(sinkDevice, mOutputs);
3340 audio_io_handle_t output =
3341 selectOutput(outputs, AUDIO_OUTPUT_FLAG_NONE, AUDIO_FORMAT_INVALID);
3342 if (output == AUDIO_IO_HANDLE_NONE) {
3343 ALOGV("%s no output for device %08x", __FUNCTION__, sinkDevice);
3344 return INVALID_OPERATION;
3345 }
3346 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
3347 if (outputDesc->isDuplicated()) {
3348 ALOGV("%s output for device %08x is duplicated", __FUNCTION__, sinkDevice);
3349 return INVALID_OPERATION;
3350 }
Eric Laurent733ce942017-12-07 12:18:25 -08003351 status_t status = outputDesc->start();
3352 if (status != NO_ERROR) {
3353 return status;
3354 }
3355
Eric Laurentd60560a2015-04-10 11:31:20 -07003356 // create a special patch with no sink and two sources:
3357 // - the second source indicates to PatchPanel through which output mix this patch should
3358 // be connected as well as the stream type for volume control
3359 // - the sink is defined by whatever output device is currently selected for the output
3360 // though which this patch is routed.
3361 patch->num_sinks = 0;
3362 patch->num_sources = 2;
3363 srcDeviceDesc->toAudioPortConfig(&patch->sources[0], NULL);
3364 outputDesc->toAudioPortConfig(&patch->sources[1], NULL);
3365 patch->sources[1].ext.mix.usecase.stream = stream;
Eric Laurent733ce942017-12-07 12:18:25 -08003366 status = mpClientInterface->createAudioPatch(patch,
Eric Laurentd60560a2015-04-10 11:31:20 -07003367 &afPatchHandle,
3368 0);
3369 ALOGV("%s patch panel returned %d patchHandle %d", __FUNCTION__,
3370 status, afPatchHandle);
3371 if (status != NO_ERROR) {
3372 ALOGW("%s patch panel could not connect device patch, error %d",
3373 __FUNCTION__, status);
3374 return INVALID_OPERATION;
3375 }
3376 uint32_t delayMs = 0;
Eric Laurentc40d9692016-04-13 19:14:13 -07003377 status = startSource(outputDesc, stream, sinkDevice, NULL, &delayMs);
Eric Laurentd60560a2015-04-10 11:31:20 -07003378
3379 if (status != NO_ERROR) {
3380 mpClientInterface->releaseAudioPatch(sourceDesc->mPatchDesc->mAfPatchHandle, 0);
3381 return status;
3382 }
3383 sourceDesc->mSwOutput = outputDesc;
3384 if (delayMs != 0) {
3385 usleep(delayMs * 1000);
3386 }
3387 }
3388
3389 sourceDesc->mPatchDesc->mAfPatchHandle = afPatchHandle;
3390 addAudioPatch(sourceDesc->mPatchDesc->mHandle, sourceDesc->mPatchDesc);
3391
3392 return NO_ERROR;
Eric Laurent554a2772015-04-10 11:29:24 -07003393}
3394
Glenn Kasten559d4392016-03-29 13:42:57 -07003395status_t AudioPolicyManager::stopAudioSource(audio_patch_handle_t handle __unused)
Eric Laurent554a2772015-04-10 11:29:24 -07003396{
Eric Laurentd60560a2015-04-10 11:31:20 -07003397 sp<AudioSourceDescriptor> sourceDesc = mAudioSources.valueFor(handle);
3398 ALOGV("%s handle %d", __FUNCTION__, handle);
3399 if (sourceDesc == 0) {
3400 ALOGW("%s unknown source for handle %d", __FUNCTION__, handle);
3401 return BAD_VALUE;
3402 }
3403 status_t status = disconnectAudioSource(sourceDesc);
3404
3405 mAudioSources.removeItem(handle);
3406 return status;
3407}
3408
Andy Hung2ddee192015-12-18 17:34:44 -08003409status_t AudioPolicyManager::setMasterMono(bool mono)
3410{
3411 if (mMasterMono == mono) {
3412 return NO_ERROR;
3413 }
3414 mMasterMono = mono;
3415 // if enabling mono we close all offloaded devices, which will invalidate the
3416 // corresponding AudioTrack. The AudioTrack client/MediaPlayer is responsible
3417 // for recreating the new AudioTrack as non-offloaded PCM.
3418 //
3419 // If disabling mono, we leave all tracks as is: we don't know which clients
3420 // and tracks are able to be recreated as offloaded. The next "song" should
3421 // play back offloaded.
3422 if (mMasterMono) {
3423 Vector<audio_io_handle_t> offloaded;
3424 for (size_t i = 0; i < mOutputs.size(); ++i) {
3425 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
3426 if (desc->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
3427 offloaded.push(desc->mIoHandle);
3428 }
3429 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003430 for (const auto& handle : offloaded) {
3431 closeOutput(handle);
Andy Hung2ddee192015-12-18 17:34:44 -08003432 }
3433 }
3434 // update master mono for all remaining outputs
3435 for (size_t i = 0; i < mOutputs.size(); ++i) {
3436 updateMono(mOutputs.keyAt(i));
3437 }
3438 return NO_ERROR;
3439}
3440
3441status_t AudioPolicyManager::getMasterMono(bool *mono)
3442{
3443 *mono = mMasterMono;
3444 return NO_ERROR;
3445}
3446
Eric Laurentac9cef52017-06-09 15:46:26 -07003447float AudioPolicyManager::getStreamVolumeDB(
3448 audio_stream_type_t stream, int index, audio_devices_t device)
3449{
3450 return computeVolume(stream, index, device);
3451}
3452
Svet Ganovf4ddfef2018-01-16 07:37:58 -08003453void AudioPolicyManager::setRecordSilenced(uid_t uid, bool silenced)
3454{
3455 ALOGV("AudioPolicyManager:setRecordSilenced(uid:%d, silenced:%d)", uid, silenced);
3456
3457 Vector<sp<AudioInputDescriptor> > activeInputs = mInputs.getActiveInputs();
3458 for (size_t i = 0; i < activeInputs.size(); i++) {
3459 sp<AudioInputDescriptor> activeDesc = activeInputs[i];
3460 AudioSessionCollection activeSessions = activeDesc->getAudioSessions(true);
3461 for (size_t j = 0; j < activeSessions.size(); j++) {
3462 sp<AudioSession> activeSession = activeSessions.valueAt(j);
3463 if (activeSession->uid() == uid) {
3464 activeSession->setSilenced(silenced);
3465 }
3466 }
3467 }
3468}
3469
Eric Laurentd60560a2015-04-10 11:31:20 -07003470status_t AudioPolicyManager::disconnectAudioSource(const sp<AudioSourceDescriptor>& sourceDesc)
3471{
3472 ALOGV("%s handle %d", __FUNCTION__, sourceDesc->getHandle());
3473
3474 sp<AudioPatch> patchDesc = mAudioPatches.valueFor(sourceDesc->mPatchDesc->mHandle);
3475 if (patchDesc == 0) {
3476 ALOGW("%s source has no patch with handle %d", __FUNCTION__,
3477 sourceDesc->mPatchDesc->mHandle);
3478 return BAD_VALUE;
3479 }
3480 removeAudioPatch(sourceDesc->mPatchDesc->mHandle);
3481
Eric Laurent28d09f02016-03-08 10:43:05 -08003482 audio_stream_type_t stream = streamTypefromAttributesInt(&sourceDesc->mAttributes);
Eric Laurentd60560a2015-04-10 11:31:20 -07003483 sp<SwAudioOutputDescriptor> swOutputDesc = sourceDesc->mSwOutput.promote();
3484 if (swOutputDesc != 0) {
Eric Laurent733ce942017-12-07 12:18:25 -08003485 status_t status = stopSource(swOutputDesc, stream, false);
3486 if (status == NO_ERROR) {
3487 swOutputDesc->stop();
3488 }
Eric Laurentd60560a2015-04-10 11:31:20 -07003489 mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
3490 } else {
3491 sp<HwAudioOutputDescriptor> hwOutputDesc = sourceDesc->mHwOutput.promote();
3492 if (hwOutputDesc != 0) {
3493 // release patch between src device and output device
3494 // close Hwoutput and remove from mHwOutputs
3495 } else {
3496 ALOGW("%s source has neither SW nor HW output", __FUNCTION__);
3497 }
3498 }
3499 return NO_ERROR;
3500}
3501
3502sp<AudioSourceDescriptor> AudioPolicyManager::getSourceForStrategyOnOutput(
3503 audio_io_handle_t output, routing_strategy strategy)
3504{
3505 sp<AudioSourceDescriptor> source;
3506 for (size_t i = 0; i < mAudioSources.size(); i++) {
3507 sp<AudioSourceDescriptor> sourceDesc = mAudioSources.valueAt(i);
3508 routing_strategy sourceStrategy =
3509 (routing_strategy) getStrategyForAttr(&sourceDesc->mAttributes);
3510 sp<SwAudioOutputDescriptor> outputDesc = sourceDesc->mSwOutput.promote();
3511 if (sourceStrategy == strategy && outputDesc != 0 && outputDesc->mIoHandle == output) {
3512 source = sourceDesc;
3513 break;
3514 }
3515 }
3516 return source;
Eric Laurent554a2772015-04-10 11:29:24 -07003517}
3518
Eric Laurente552edb2014-03-10 17:42:56 -07003519// ----------------------------------------------------------------------------
Eric Laurente0720872014-03-11 09:30:41 -07003520// AudioPolicyManager
Eric Laurente552edb2014-03-10 17:42:56 -07003521// ----------------------------------------------------------------------------
Eric Laurent6a94d692014-05-20 11:18:06 -07003522uint32_t AudioPolicyManager::nextAudioPortGeneration()
3523{
Mikhail Naganov2773dd72017-12-08 10:12:11 -08003524 return mAudioPortGeneration++;
Eric Laurent6a94d692014-05-20 11:18:06 -07003525}
3526
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +09003527#ifdef USE_XML_AUDIO_POLICY_CONF
3528// Treblized audio policy xml config will be located in /odm/etc or /vendor/etc.
3529static const char *kConfigLocationList[] =
3530 {"/odm/etc", "/vendor/etc", "/system/etc"};
3531static const int kConfigLocationListSize =
3532 (sizeof(kConfigLocationList) / sizeof(kConfigLocationList[0]));
3533
3534static status_t deserializeAudioPolicyXmlConfig(AudioPolicyConfig &config) {
3535 char audioPolicyXmlConfigFile[AUDIO_POLICY_XML_CONFIG_FILE_PATH_MAX_LENGTH];
Petri Gynther150b9842018-04-17 18:46:10 -07003536 std::vector<const char*> fileNames;
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +09003537 status_t ret;
3538
Petri Gynther150b9842018-04-17 18:46:10 -07003539 if (property_get_bool("ro.bluetooth.a2dp_offload.supported", false) &&
3540 property_get_bool("persist.bluetooth.a2dp_offload.disabled", false)) {
3541 // A2DP offload supported but disabled: try to use special XML file
3542 fileNames.push_back(AUDIO_POLICY_A2DP_OFFLOAD_DISABLED_XML_CONFIG_FILE_NAME);
3543 }
3544 fileNames.push_back(AUDIO_POLICY_XML_CONFIG_FILE_NAME);
3545
3546 for (const char* fileName : fileNames) {
3547 for (int i = 0; i < kConfigLocationListSize; i++) {
3548 PolicySerializer serializer;
3549 snprintf(audioPolicyXmlConfigFile, sizeof(audioPolicyXmlConfigFile),
3550 "%s/%s", kConfigLocationList[i], fileName);
3551 ret = serializer.deserialize(audioPolicyXmlConfigFile, config);
3552 if (ret == NO_ERROR) {
3553 return ret;
3554 }
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +09003555 }
3556 }
3557 return ret;
3558}
3559#endif
3560
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003561AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface,
3562 bool /*forTesting*/)
Eric Laurente552edb2014-03-10 17:42:56 -07003563 :
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003564 mUidCached(getuid()),
3565 mpClientInterface(clientInterface),
Eric Laurente552edb2014-03-10 17:42:56 -07003566 mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f),
Eric Laurent3a4311c2014-03-17 12:00:47 -07003567 mA2dpSuspended(false),
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003568#ifdef USE_XML_AUDIO_POLICY_CONF
3569 mVolumeCurves(new VolumeCurvesCollection()),
3570 mConfig(mHwModulesAll, mAvailableOutputDevices, mAvailableInputDevices,
Mikhail Naganovbcbcb1b2017-12-13 13:03:35 -08003571 mDefaultOutputDevice, static_cast<VolumeCurvesCollection*>(mVolumeCurves.get())),
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003572#else
3573 mVolumeCurves(new StreamDescriptorCollection()),
3574 mConfig(mHwModulesAll, mAvailableOutputDevices, mAvailableInputDevices,
3575 mDefaultOutputDevice),
3576#endif
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07003577 mAudioPortGeneration(1),
3578 mBeaconMuteRefCount(0),
3579 mBeaconPlayingRefCount(0),
Eric Laurent9459fb02015-08-12 18:36:32 -07003580 mBeaconMuted(false),
Andy Hung2ddee192015-12-18 17:34:44 -08003581 mTtsOutputAvailable(false),
Eric Laurent36829f92017-04-07 19:04:42 -07003582 mMasterMono(false),
Chris Thornton2b864642017-06-27 21:26:07 -07003583 mMusicEffectOutput(AUDIO_IO_HANDLE_NONE),
3584 mHasComputedSoundTriggerSupportsConcurrentCapture(false)
Eric Laurente552edb2014-03-10 17:42:56 -07003585{
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003586}
François Gaffied1ab2bd2015-12-02 18:20:06 +01003587
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003588AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface)
3589 : AudioPolicyManager(clientInterface, false /*forTesting*/)
3590{
3591 loadConfig();
3592 initialize();
3593}
François Gaffied1ab2bd2015-12-02 18:20:06 +01003594
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003595void AudioPolicyManager::loadConfig() {
François Gaffied1ab2bd2015-12-02 18:20:06 +01003596#ifdef USE_XML_AUDIO_POLICY_CONF
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003597 if (deserializeAudioPolicyXmlConfig(getConfig()) != NO_ERROR) {
François Gaffied1ab2bd2015-12-02 18:20:06 +01003598#else
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003599 if ((ConfigParsingUtils::loadConfig(AUDIO_POLICY_VENDOR_CONFIG_FILE, getConfig()) != NO_ERROR)
3600 && (ConfigParsingUtils::loadConfig(AUDIO_POLICY_CONFIG_FILE, getConfig()) != NO_ERROR)) {
François Gaffied1ab2bd2015-12-02 18:20:06 +01003601#endif
3602 ALOGE("could not load audio policy configuration file, setting defaults");
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003603 getConfig().setDefault();
François Gaffied1ab2bd2015-12-02 18:20:06 +01003604 }
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003605}
3606
3607status_t AudioPolicyManager::initialize() {
3608 mVolumeCurves->initializeVolumeCurves(getConfig().isSpeakerDrcEnabled());
François Gaffied1ab2bd2015-12-02 18:20:06 +01003609
3610 // Once policy config has been parsed, retrieve an instance of the engine and initialize it.
François Gaffie2110e042015-03-24 08:41:51 +01003611 audio_policy::EngineInstance *engineInstance = audio_policy::EngineInstance::getInstance();
3612 if (!engineInstance) {
3613 ALOGE("%s: Could not get an instance of policy engine", __FUNCTION__);
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003614 return NO_INIT;
François Gaffie2110e042015-03-24 08:41:51 +01003615 }
3616 // Retrieve the Policy Manager Interface
3617 mEngine = engineInstance->queryInterface<AudioPolicyManagerInterface>();
3618 if (mEngine == NULL) {
3619 ALOGE("%s: Failed to get Policy Engine Interface", __FUNCTION__);
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003620 return NO_INIT;
François Gaffie2110e042015-03-24 08:41:51 +01003621 }
3622 mEngine->setObserver(this);
3623 status_t status = mEngine->initCheck();
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003624 if (status != NO_ERROR) {
3625 LOG_FATAL("Policy engine not initialized(err=%d)", status);
3626 return status;
3627 }
François Gaffie2110e042015-03-24 08:41:51 +01003628
Eric Laurent3a4311c2014-03-17 12:00:47 -07003629 // mAvailableOutputDevices and mAvailableInputDevices now contain all attached devices
Eric Laurente552edb2014-03-10 17:42:56 -07003630 // open all output streams needed to access attached devices
Eric Laurent3a4311c2014-03-17 12:00:47 -07003631 audio_devices_t outputDeviceTypes = mAvailableOutputDevices.types();
3632 audio_devices_t inputDeviceTypes = mAvailableInputDevices.types() & ~AUDIO_DEVICE_BIT_IN;
Mikhail Naganovd4120142017-12-06 15:49:22 -08003633 for (const auto& hwModule : mHwModulesAll) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08003634 hwModule->setHandle(mpClientInterface->loadHwModule(hwModule->getName()));
Mikhail Naganovd4120142017-12-06 15:49:22 -08003635 if (hwModule->getHandle() == AUDIO_MODULE_HANDLE_NONE) {
3636 ALOGW("could not open HW module %s", hwModule->getName());
Eric Laurente552edb2014-03-10 17:42:56 -07003637 continue;
3638 }
Mikhail Naganovd4120142017-12-06 15:49:22 -08003639 mHwModules.push_back(hwModule);
Eric Laurente552edb2014-03-10 17:42:56 -07003640 // open all output streams needed to access attached devices
3641 // except for direct output streams that are only opened when they are actually
3642 // required by an app.
Eric Laurent3a4311c2014-03-17 12:00:47 -07003643 // This also validates mAvailableOutputDevices list
Mikhail Naganova5e165d2017-12-07 17:08:02 -08003644 for (const auto& outProfile : hwModule->getOutputProfiles()) {
Eric Laurent3974e3b2017-12-07 17:58:43 -08003645 if (!outProfile->canOpenNewIo()) {
3646 ALOGE("Invalid Output profile max open count %u for profile %s",
3647 outProfile->maxOpenCount, outProfile->getTagName().c_str());
3648 continue;
3649 }
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003650 if (!outProfile->hasSupportedDevices()) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08003651 ALOGW("Output profile contains no device on module %s", hwModule->getName());
Eric Laurent3a4311c2014-03-17 12:00:47 -07003652 continue;
3653 }
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003654 if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_TTS) != 0) {
Eric Laurent9459fb02015-08-12 18:36:32 -07003655 mTtsOutputAvailable = true;
3656 }
Eric Laurent3a4311c2014-03-17 12:00:47 -07003657
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003658 if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_DIRECT) != 0) {
Eric Laurentd78f1532014-09-16 16:38:20 -07003659 continue;
3660 }
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003661 audio_devices_t profileType = outProfile->getSupportedDevicesType();
François Gaffie53615e22015-03-19 09:24:12 +01003662 if ((profileType & mDefaultOutputDevice->type()) != AUDIO_DEVICE_NONE) {
3663 profileType = mDefaultOutputDevice->type();
Eric Laurent83b88082014-06-20 18:31:16 -07003664 } else {
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003665 // chose first device present in profile's SupportedDevices also part of
Eric Laurentd78f1532014-09-16 16:38:20 -07003666 // outputDeviceTypes
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003667 profileType = outProfile->getSupportedDeviceForType(outputDeviceTypes);
Eric Laurente552edb2014-03-10 17:42:56 -07003668 }
Eric Laurentd78f1532014-09-16 16:38:20 -07003669 if ((profileType & outputDeviceTypes) == 0) {
3670 continue;
3671 }
Eric Laurentc75307b2015-03-17 15:29:32 -07003672 sp<SwAudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(outProfile,
3673 mpClientInterface);
Eric Laurentc40d9692016-04-13 19:14:13 -07003674 const DeviceVector &supportedDevices = outProfile->getSupportedDevices();
3675 const DeviceVector &devicesForType = supportedDevices.getDevicesFromType(profileType);
3676 String8 address = devicesForType.size() > 0 ? devicesForType.itemAt(0)->mAddress
3677 : String8("");
Eric Laurentd78f1532014-09-16 16:38:20 -07003678 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
Eric Laurentfe231122017-11-17 17:48:06 -08003679 status_t status = outputDesc->open(nullptr, profileType, address,
3680 AUDIO_STREAM_DEFAULT, AUDIO_OUTPUT_FLAG_NONE, &output);
Eric Laurentd78f1532014-09-16 16:38:20 -07003681
3682 if (status != NO_ERROR) {
3683 ALOGW("Cannot open output stream for device %08x on hw module %s",
3684 outputDesc->mDevice,
Mikhail Naganovd4120142017-12-06 15:49:22 -08003685 hwModule->getName());
Eric Laurentd78f1532014-09-16 16:38:20 -07003686 } else {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003687 for (const auto& dev : supportedDevices) {
3688 ssize_t index = mAvailableOutputDevices.indexOf(dev);
Eric Laurentd78f1532014-09-16 16:38:20 -07003689 // give a valid ID to an attached device once confirmed it is reachable
Paul McLeane743a472015-01-28 11:07:31 -08003690 if (index >= 0 && !mAvailableOutputDevices[index]->isAttached()) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08003691 mAvailableOutputDevices[index]->attach(hwModule);
Eric Laurentd78f1532014-09-16 16:38:20 -07003692 }
3693 }
3694 if (mPrimaryOutput == 0 &&
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003695 outProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
Eric Laurentc75307b2015-03-17 15:29:32 -07003696 mPrimaryOutput = outputDesc;
Eric Laurentd78f1532014-09-16 16:38:20 -07003697 }
3698 addOutput(output, outputDesc);
Eric Laurentc75307b2015-03-17 15:29:32 -07003699 setOutputDevice(outputDesc,
Eric Laurentfe231122017-11-17 17:48:06 -08003700 profileType,
Eric Laurentc40d9692016-04-13 19:14:13 -07003701 true,
3702 0,
3703 NULL,
Eric Laurentfe231122017-11-17 17:48:06 -08003704 address);
Eric Laurentd78f1532014-09-16 16:38:20 -07003705 }
Eric Laurente552edb2014-03-10 17:42:56 -07003706 }
Eric Laurent3a4311c2014-03-17 12:00:47 -07003707 // open input streams needed to access attached devices to validate
3708 // mAvailableInputDevices list
Mikhail Naganova5e165d2017-12-07 17:08:02 -08003709 for (const auto& inProfile : hwModule->getInputProfiles()) {
Eric Laurent3974e3b2017-12-07 17:58:43 -08003710 if (!inProfile->canOpenNewIo()) {
3711 ALOGE("Invalid Input profile max open count %u for profile %s",
3712 inProfile->maxOpenCount, inProfile->getTagName().c_str());
3713 continue;
3714 }
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003715 if (!inProfile->hasSupportedDevices()) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08003716 ALOGW("Input profile contains no device on module %s", hwModule->getName());
Eric Laurent3a4311c2014-03-17 12:00:47 -07003717 continue;
3718 }
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003719 // chose first device present in profile's SupportedDevices also part of
Eric Laurentd78f1532014-09-16 16:38:20 -07003720 // inputDeviceTypes
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003721 audio_devices_t profileType = inProfile->getSupportedDeviceForType(inputDeviceTypes);
3722
Eric Laurentd78f1532014-09-16 16:38:20 -07003723 if ((profileType & inputDeviceTypes) == 0) {
3724 continue;
3725 }
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08003726 sp<AudioInputDescriptor> inputDesc =
Eric Laurentfe231122017-11-17 17:48:06 -08003727 new AudioInputDescriptor(inProfile, mpClientInterface);
Eric Laurentd78f1532014-09-16 16:38:20 -07003728
Eric Laurent53b810e2017-12-10 17:25:10 -08003729 DeviceVector inputDevices = mAvailableInputDevices.getDevicesFromType(profileType);
3730 // the inputs vector must be of size >= 1, but we don't want to crash here
3731 String8 address = inputDevices.size() > 0 ? inputDevices.itemAt(0)->mAddress
3732 : String8("");
3733 ALOGV(" for input device 0x%x using address %s", profileType, address.string());
3734 ALOGE_IF(inputDevices.size() == 0, "Input device list is empty!");
3735
Eric Laurentd78f1532014-09-16 16:38:20 -07003736 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
Eric Laurentfe231122017-11-17 17:48:06 -08003737 status_t status = inputDesc->open(nullptr,
3738 profileType,
Eric Laurent53b810e2017-12-10 17:25:10 -08003739 address,
Eric Laurentfe231122017-11-17 17:48:06 -08003740 AUDIO_SOURCE_MIC,
3741 AUDIO_INPUT_FLAG_NONE,
3742 &input);
Eric Laurentd78f1532014-09-16 16:38:20 -07003743
3744 if (status == NO_ERROR) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003745 for (const auto& dev : inProfile->getSupportedDevices()) {
3746 ssize_t index = mAvailableInputDevices.indexOf(dev);
Eric Laurentd78f1532014-09-16 16:38:20 -07003747 // give a valid ID to an attached device once confirmed it is reachable
Eric Laurent45aabc32015-08-06 09:11:13 -07003748 if (index >= 0) {
3749 sp<DeviceDescriptor> devDesc = mAvailableInputDevices[index];
3750 if (!devDesc->isAttached()) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08003751 devDesc->attach(hwModule);
Eric Laurent83efe1c2017-07-09 16:51:08 -07003752 devDesc->importAudioPort(inProfile, true);
Eric Laurent45aabc32015-08-06 09:11:13 -07003753 }
Eric Laurentd78f1532014-09-16 16:38:20 -07003754 }
3755 }
Eric Laurentfe231122017-11-17 17:48:06 -08003756 inputDesc->close();
Eric Laurentd78f1532014-09-16 16:38:20 -07003757 } else {
3758 ALOGW("Cannot open input stream for device %08x on hw module %s",
Eric Laurentfe231122017-11-17 17:48:06 -08003759 profileType,
Mikhail Naganovd4120142017-12-06 15:49:22 -08003760 hwModule->getName());
Eric Laurentd78f1532014-09-16 16:38:20 -07003761 }
Eric Laurent3a4311c2014-03-17 12:00:47 -07003762 }
3763 }
3764 // make sure all attached devices have been allocated a unique ID
3765 for (size_t i = 0; i < mAvailableOutputDevices.size();) {
Paul McLeane743a472015-01-28 11:07:31 -08003766 if (!mAvailableOutputDevices[i]->isAttached()) {
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003767 ALOGW("Output device %08x unreachable", mAvailableOutputDevices[i]->type());
Eric Laurent3a4311c2014-03-17 12:00:47 -07003768 mAvailableOutputDevices.remove(mAvailableOutputDevices[i]);
3769 continue;
3770 }
François Gaffie2110e042015-03-24 08:41:51 +01003771 // The device is now validated and can be appended to the available devices of the engine
3772 mEngine->setDeviceConnectionState(mAvailableOutputDevices[i],
3773 AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
Eric Laurent3a4311c2014-03-17 12:00:47 -07003774 i++;
3775 }
3776 for (size_t i = 0; i < mAvailableInputDevices.size();) {
Paul McLeane743a472015-01-28 11:07:31 -08003777 if (!mAvailableInputDevices[i]->isAttached()) {
François Gaffie53615e22015-03-19 09:24:12 +01003778 ALOGW("Input device %08x unreachable", mAvailableInputDevices[i]->type());
Eric Laurent3a4311c2014-03-17 12:00:47 -07003779 mAvailableInputDevices.remove(mAvailableInputDevices[i]);
3780 continue;
3781 }
François Gaffie2110e042015-03-24 08:41:51 +01003782 // The device is now validated and can be appended to the available devices of the engine
3783 mEngine->setDeviceConnectionState(mAvailableInputDevices[i],
3784 AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
Eric Laurent3a4311c2014-03-17 12:00:47 -07003785 i++;
3786 }
3787 // make sure default device is reachable
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003788 if (mDefaultOutputDevice == 0 || mAvailableOutputDevices.indexOf(mDefaultOutputDevice) < 0) {
François Gaffie53615e22015-03-19 09:24:12 +01003789 ALOGE("Default device %08x is unreachable", mDefaultOutputDevice->type());
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003790 status = NO_INIT;
Eric Laurent3a4311c2014-03-17 12:00:47 -07003791 }
jiabin9ff780e2018-03-19 18:19:52 -07003792 // If microphones address is empty, set it according to device type
3793 for (size_t i = 0; i < mAvailableInputDevices.size(); i++) {
3794 if (mAvailableInputDevices[i]->mAddress.isEmpty()) {
3795 if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_BUILTIN_MIC) {
3796 mAvailableInputDevices[i]->mAddress = String8(AUDIO_BOTTOM_MICROPHONE_ADDRESS);
3797 } else if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_BACK_MIC) {
3798 mAvailableInputDevices[i]->mAddress = String8(AUDIO_BACK_MICROPHONE_ADDRESS);
3799 }
3800 }
3801 }
Eric Laurente552edb2014-03-10 17:42:56 -07003802
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003803 if (mPrimaryOutput == 0) {
3804 ALOGE("Failed to open primary output");
3805 status = NO_INIT;
3806 }
Eric Laurente552edb2014-03-10 17:42:56 -07003807
3808 updateDevicesAndOutputs();
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08003809 return status;
Eric Laurente552edb2014-03-10 17:42:56 -07003810}
3811
Eric Laurente0720872014-03-11 09:30:41 -07003812AudioPolicyManager::~AudioPolicyManager()
Eric Laurente552edb2014-03-10 17:42:56 -07003813{
Eric Laurente552edb2014-03-10 17:42:56 -07003814 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentfe231122017-11-17 17:48:06 -08003815 mOutputs.valueAt(i)->close();
Eric Laurente552edb2014-03-10 17:42:56 -07003816 }
3817 for (size_t i = 0; i < mInputs.size(); i++) {
Eric Laurentfe231122017-11-17 17:48:06 -08003818 mInputs.valueAt(i)->close();
Eric Laurente552edb2014-03-10 17:42:56 -07003819 }
Eric Laurent3a4311c2014-03-17 12:00:47 -07003820 mAvailableOutputDevices.clear();
3821 mAvailableInputDevices.clear();
Eric Laurent1f2f2232014-06-02 12:01:23 -07003822 mOutputs.clear();
3823 mInputs.clear();
3824 mHwModules.clear();
Mikhail Naganovd4120142017-12-06 15:49:22 -08003825 mHwModulesAll.clear();
Eric Laurente552edb2014-03-10 17:42:56 -07003826}
3827
Eric Laurente0720872014-03-11 09:30:41 -07003828status_t AudioPolicyManager::initCheck()
Eric Laurente552edb2014-03-10 17:42:56 -07003829{
Eric Laurent87ffa392015-05-22 10:32:38 -07003830 return hasPrimaryOutput() ? NO_ERROR : NO_INIT;
Eric Laurente552edb2014-03-10 17:42:56 -07003831}
3832
Eric Laurente552edb2014-03-10 17:42:56 -07003833// ---
3834
Eric Laurent98e38192018-02-15 18:31:53 -08003835void AudioPolicyManager::addOutput(audio_io_handle_t output,
3836 const sp<SwAudioOutputDescriptor>& outputDesc)
Eric Laurente552edb2014-03-10 17:42:56 -07003837{
Eric Laurent1c333e22014-05-20 10:48:17 -07003838 mOutputs.add(output, outputDesc);
Eric Laurent98e38192018-02-15 18:31:53 -08003839 applyStreamVolumes(outputDesc, AUDIO_DEVICE_NONE, 0 /* delayMs */, true /* force */);
Andy Hung2ddee192015-12-18 17:34:44 -08003840 updateMono(output); // update mono status when adding to output list
Eric Laurent36829f92017-04-07 19:04:42 -07003841 selectOutputForMusicEffects();
Eric Laurent6a94d692014-05-20 11:18:06 -07003842 nextAudioPortGeneration();
Eric Laurente552edb2014-03-10 17:42:56 -07003843}
3844
François Gaffie53615e22015-03-19 09:24:12 +01003845void AudioPolicyManager::removeOutput(audio_io_handle_t output)
3846{
3847 mOutputs.removeItem(output);
Eric Laurent36829f92017-04-07 19:04:42 -07003848 selectOutputForMusicEffects();
François Gaffie53615e22015-03-19 09:24:12 +01003849}
3850
Eric Laurent98e38192018-02-15 18:31:53 -08003851void AudioPolicyManager::addInput(audio_io_handle_t input,
3852 const sp<AudioInputDescriptor>& inputDesc)
Eric Laurentd4692962014-05-05 18:13:44 -07003853{
Eric Laurent1c333e22014-05-20 10:48:17 -07003854 mInputs.add(input, inputDesc);
Eric Laurent6a94d692014-05-20 11:18:06 -07003855 nextAudioPortGeneration();
Eric Laurentd4692962014-05-05 18:13:44 -07003856}
Eric Laurente552edb2014-03-10 17:42:56 -07003857
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003858void AudioPolicyManager::findIoHandlesByAddress(const sp<SwAudioOutputDescriptor>& desc /*in*/,
keunyoung3190e672014-12-30 13:00:52 -08003859 const audio_devices_t device /*in*/,
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003860 const String8& address /*in*/,
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07003861 SortedVector<audio_io_handle_t>& outputs /*out*/) {
keunyoung3190e672014-12-30 13:00:52 -08003862 sp<DeviceDescriptor> devDesc =
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003863 desc->mProfile->getSupportedDeviceByAddress(device, address);
keunyoung3190e672014-12-30 13:00:52 -08003864 if (devDesc != 0) {
3865 ALOGV("findIoHandlesByAddress(): adding opened output %d on same address %s",
3866 desc->mIoHandle, address.string());
3867 outputs.add(desc->mIoHandle);
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07003868 }
3869}
3870
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003871status_t AudioPolicyManager::checkOutputsForDevice(const sp<DeviceDescriptor>& devDesc,
François Gaffie53615e22015-03-19 09:24:12 +01003872 audio_policy_dev_state_t state,
3873 SortedVector<audio_io_handle_t>& outputs,
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003874 const String8& address)
Eric Laurente552edb2014-03-10 17:42:56 -07003875{
François Gaffie53615e22015-03-19 09:24:12 +01003876 audio_devices_t device = devDesc->type();
Eric Laurentc75307b2015-03-17 15:29:32 -07003877 sp<SwAudioOutputDescriptor> desc;
Eric Laurentcc750d32015-06-25 11:48:20 -07003878
3879 if (audio_device_is_digital(device)) {
3880 // erase all current sample rates, formats and channel masks
Eric Laurent20eb3a42016-01-26 18:39:17 -08003881 devDesc->clearAudioProfiles();
Eric Laurentcc750d32015-06-25 11:48:20 -07003882 }
Eric Laurente552edb2014-03-10 17:42:56 -07003883
Eric Laurent3b73df72014-03-11 09:06:29 -07003884 if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
Eric Laurente552edb2014-03-10 17:42:56 -07003885 // first list already open outputs that can be routed to this device
3886 for (size_t i = 0; i < mOutputs.size(); i++) {
3887 desc = mOutputs.valueAt(i);
Eric Laurentc75307b2015-03-17 15:29:32 -07003888 if (!desc->isDuplicated() && (desc->supportedDevices() & device)) {
François Gaffie53615e22015-03-19 09:24:12 +01003889 if (!device_distinguishes_on_address(device)) {
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07003890 ALOGV("checkOutputsForDevice(): adding opened output %d", mOutputs.keyAt(i));
3891 outputs.add(mOutputs.keyAt(i));
3892 } else {
3893 ALOGV(" checking address match due to device 0x%x", device);
keunyoung3190e672014-12-30 13:00:52 -08003894 findIoHandlesByAddress(desc, device, address, outputs);
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07003895 }
Eric Laurente552edb2014-03-10 17:42:56 -07003896 }
3897 }
3898 // then look for output profiles that can be routed to this device
Eric Laurent1c333e22014-05-20 10:48:17 -07003899 SortedVector< sp<IOProfile> > profiles;
Mikhail Naganov7e22e942017-12-07 10:04:29 -08003900 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08003901 for (size_t j = 0; j < hwModule->getOutputProfiles().size(); j++) {
3902 sp<IOProfile> profile = hwModule->getOutputProfiles()[j];
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003903 if (profile->supportDevice(device)) {
François Gaffie53615e22015-03-19 09:24:12 +01003904 if (!device_distinguishes_on_address(device) ||
François Gaffiea8ecc2c2015-11-09 16:10:40 +01003905 profile->supportDeviceAddress(address)) {
Eric Laurent275e8e92014-11-30 15:14:47 -08003906 profiles.add(profile);
Mikhail Naganovd4120142017-12-06 15:49:22 -08003907 ALOGV("checkOutputsForDevice(): adding profile %zu from module %s",
3908 j, hwModule->getName());
Eric Laurent275e8e92014-11-30 15:14:47 -08003909 }
Eric Laurente552edb2014-03-10 17:42:56 -07003910 }
3911 }
3912 }
3913
Eric Laurent7b279bb2015-12-14 10:18:23 -08003914 ALOGV(" found %zu profiles, %zu outputs", profiles.size(), outputs.size());
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07003915
Eric Laurente552edb2014-03-10 17:42:56 -07003916 if (profiles.isEmpty() && outputs.isEmpty()) {
3917 ALOGW("checkOutputsForDevice(): No output available for device %04x", device);
3918 return BAD_VALUE;
3919 }
3920
3921 // open outputs for matching profiles if needed. Direct outputs are also opened to
3922 // query for dynamic parameters and will be closed later by setDeviceConnectionState()
3923 for (ssize_t profile_index = 0; profile_index < (ssize_t)profiles.size(); profile_index++) {
Eric Laurent1c333e22014-05-20 10:48:17 -07003924 sp<IOProfile> profile = profiles[profile_index];
Eric Laurente552edb2014-03-10 17:42:56 -07003925
3926 // nothing to do if one output is already opened for this profile
3927 size_t j;
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07003928 for (j = 0; j < outputs.size(); j++) {
3929 desc = mOutputs.valueFor(outputs.itemAt(j));
Eric Laurente552edb2014-03-10 17:42:56 -07003930 if (!desc->isDuplicated() && desc->mProfile == profile) {
Jean-Michel Trivif17026d2014-08-10 14:30:48 -07003931 // matching profile: save the sample rates, format and channel masks supported
3932 // by the profile in our device descriptor
Paul McLean9080a4c2015-06-18 08:24:02 -07003933 if (audio_device_is_digital(device)) {
3934 devDesc->importAudioPort(profile);
3935 }
Eric Laurente552edb2014-03-10 17:42:56 -07003936 break;
3937 }
3938 }
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07003939 if (j != outputs.size()) {
Eric Laurente552edb2014-03-10 17:42:56 -07003940 continue;
3941 }
3942
Eric Laurent3974e3b2017-12-07 17:58:43 -08003943 if (!profile->canOpenNewIo()) {
3944 ALOGW("Max Output number %u already opened for this profile %s",
3945 profile->maxOpenCount, profile->getTagName().c_str());
3946 continue;
3947 }
3948
Eric Laurent83efe1c2017-07-09 16:51:08 -07003949 ALOGV("opening output for device %08x with params %s profile %p name %s",
3950 device, address.string(), profile.get(), profile->getName().string());
Eric Laurentc75307b2015-03-17 15:29:32 -07003951 desc = new SwAudioOutputDescriptor(profile, mpClientInterface);
Eric Laurentcf2c0212014-07-25 16:20:43 -07003952 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
Eric Laurentfe231122017-11-17 17:48:06 -08003953 status_t status = desc->open(nullptr, device, address,
3954 AUDIO_STREAM_DEFAULT, AUDIO_OUTPUT_FLAG_NONE, &output);
Eric Laurente552edb2014-03-10 17:42:56 -07003955
Eric Laurentfe231122017-11-17 17:48:06 -08003956 if (status == NO_ERROR) {
Eric Laurentd4692962014-05-05 18:13:44 -07003957 // Here is where the out_set_parameters() for card & device gets called
Eric Laurent3a4311c2014-03-17 12:00:47 -07003958 if (!address.isEmpty()) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07003959 char *param = audio_device_address_to_parameter(device, address);
3960 mpClientInterface->setParameters(output, String8(param));
3961 free(param);
Eric Laurente552edb2014-03-10 17:42:56 -07003962 }
Phil Burk00eeb322016-03-31 12:41:00 -07003963 updateAudioProfiles(device, output, profile->getAudioProfiles());
François Gaffie112b0af2015-11-19 16:13:25 +01003964 if (!profile->hasValidAudioProfile()) {
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07003965 ALOGW("checkOutputsForDevice() missing param");
Eric Laurentfe231122017-11-17 17:48:06 -08003966 desc->close();
Eric Laurentcf2c0212014-07-25 16:20:43 -07003967 output = AUDIO_IO_HANDLE_NONE;
François Gaffie112b0af2015-11-19 16:13:25 +01003968 } else if (profile->hasDynamicAudioProfile()) {
Eric Laurentfe231122017-11-17 17:48:06 -08003969 desc->close();
Phil Burk702b1052016-03-02 16:38:26 -08003970 output = AUDIO_IO_HANDLE_NONE;
Eric Laurentfe231122017-11-17 17:48:06 -08003971 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
3972 profile->pickAudioProfile(
3973 config.sample_rate, config.channel_mask, config.format);
Eric Laurentcf2c0212014-07-25 16:20:43 -07003974 config.offload_info.sample_rate = config.sample_rate;
3975 config.offload_info.channel_mask = config.channel_mask;
3976 config.offload_info.format = config.format;
Eric Laurentfe231122017-11-17 17:48:06 -08003977
3978 status_t status = desc->open(&config, device, address, AUDIO_STREAM_DEFAULT,
3979 AUDIO_OUTPUT_FLAG_NONE, &output);
3980 if (status != NO_ERROR) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07003981 output = AUDIO_IO_HANDLE_NONE;
3982 }
Eric Laurentd4692962014-05-05 18:13:44 -07003983 }
3984
Eric Laurentcf2c0212014-07-25 16:20:43 -07003985 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurente552edb2014-03-10 17:42:56 -07003986 addOutput(output, desc);
François Gaffie53615e22015-03-19 09:24:12 +01003987 if (device_distinguishes_on_address(device) && address != "0") {
François Gaffie036e1e92015-03-19 10:16:24 +01003988 sp<AudioPolicyMix> policyMix;
3989 if (mPolicyMixes.getAudioPolicyMix(address, policyMix) != NO_ERROR) {
Eric Laurent275e8e92014-11-30 15:14:47 -08003990 ALOGE("checkOutputsForDevice() cannot find policy for address %s",
3991 address.string());
3992 }
François Gaffie036e1e92015-03-19 10:16:24 +01003993 policyMix->setOutput(desc);
Jean-Michel Trividacc06f2015-04-08 18:16:39 -07003994 desc->mPolicyMix = policyMix->getMix();
François Gaffie036e1e92015-03-19 10:16:24 +01003995
Eric Laurent87ffa392015-05-22 10:32:38 -07003996 } else if (((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) == 0) &&
3997 hasPrimaryOutput()) {
Eric Laurentc722f302014-12-10 11:21:49 -08003998 // no duplicated output for direct outputs and
3999 // outputs used by dynamic policy mixes
Eric Laurentcf2c0212014-07-25 16:20:43 -07004000 audio_io_handle_t duplicatedOutput = AUDIO_IO_HANDLE_NONE;
Eric Laurente552edb2014-03-10 17:42:56 -07004001
Eric Laurentd4692962014-05-05 18:13:44 -07004002 //TODO: configure audio effect output stage here
4003
4004 // open a duplicating output thread for the new output and the primary output
Eric Laurent5babc4f2018-02-15 12:33:44 -08004005 sp<SwAudioOutputDescriptor> dupOutputDesc =
4006 new SwAudioOutputDescriptor(NULL, mpClientInterface);
4007 status_t status = dupOutputDesc->openDuplicating(mPrimaryOutput, desc,
4008 &duplicatedOutput);
4009 if (status == NO_ERROR) {
Eric Laurentd4692962014-05-05 18:13:44 -07004010 // add duplicated output descriptor
Eric Laurentd4692962014-05-05 18:13:44 -07004011 addOutput(duplicatedOutput, dupOutputDesc);
Eric Laurentd4692962014-05-05 18:13:44 -07004012 } else {
4013 ALOGW("checkOutputsForDevice() could not open dup output for %d and %d",
Eric Laurentc75307b2015-03-17 15:29:32 -07004014 mPrimaryOutput->mIoHandle, output);
Eric Laurentfe231122017-11-17 17:48:06 -08004015 desc->close();
François Gaffie53615e22015-03-19 09:24:12 +01004016 removeOutput(output);
Eric Laurent6a94d692014-05-20 11:18:06 -07004017 nextAudioPortGeneration();
Eric Laurentcf2c0212014-07-25 16:20:43 -07004018 output = AUDIO_IO_HANDLE_NONE;
Eric Laurentd4692962014-05-05 18:13:44 -07004019 }
Eric Laurente552edb2014-03-10 17:42:56 -07004020 }
4021 }
Eric Laurentcf2c0212014-07-25 16:20:43 -07004022 } else {
4023 output = AUDIO_IO_HANDLE_NONE;
Eric Laurente552edb2014-03-10 17:42:56 -07004024 }
Eric Laurentcf2c0212014-07-25 16:20:43 -07004025 if (output == AUDIO_IO_HANDLE_NONE) {
Eric Laurente552edb2014-03-10 17:42:56 -07004026 ALOGW("checkOutputsForDevice() could not open output for device %x", device);
Eric Laurente552edb2014-03-10 17:42:56 -07004027 profiles.removeAt(profile_index);
4028 profile_index--;
4029 } else {
4030 outputs.add(output);
Paul McLean9080a4c2015-06-18 08:24:02 -07004031 // Load digital format info only for digital devices
4032 if (audio_device_is_digital(device)) {
4033 devDesc->importAudioPort(profile);
4034 }
Jean-Michel Trivif17026d2014-08-10 14:30:48 -07004035
François Gaffie53615e22015-03-19 09:24:12 +01004036 if (device_distinguishes_on_address(device)) {
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004037 ALOGV("checkOutputsForDevice(): setOutputDevice(dev=0x%x, addr=%s)",
4038 device, address.string());
Eric Laurentc75307b2015-03-17 15:29:32 -07004039 setOutputDevice(desc, device, true/*force*/, 0/*delay*/,
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004040 NULL/*patch handle*/, address.string());
4041 }
Eric Laurente552edb2014-03-10 17:42:56 -07004042 ALOGV("checkOutputsForDevice(): adding output %d", output);
4043 }
4044 }
4045
4046 if (profiles.isEmpty()) {
4047 ALOGW("checkOutputsForDevice(): No output available for device %04x", device);
4048 return BAD_VALUE;
4049 }
Eric Laurentd4692962014-05-05 18:13:44 -07004050 } else { // Disconnect
Eric Laurente552edb2014-03-10 17:42:56 -07004051 // check if one opened output is not needed any more after disconnecting one device
4052 for (size_t i = 0; i < mOutputs.size(); i++) {
4053 desc = mOutputs.valueAt(i);
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004054 if (!desc->isDuplicated()) {
Eric Laurent275e8e92014-11-30 15:14:47 -08004055 // exact match on device
François Gaffie53615e22015-03-19 09:24:12 +01004056 if (device_distinguishes_on_address(device) &&
Eric Laurentc75307b2015-03-17 15:29:32 -07004057 (desc->supportedDevices() == device)) {
keunyoung3190e672014-12-30 13:00:52 -08004058 findIoHandlesByAddress(desc, device, address, outputs);
Eric Laurentc75307b2015-03-17 15:29:32 -07004059 } else if (!(desc->supportedDevices() & mAvailableOutputDevices.types())) {
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004060 ALOGV("checkOutputsForDevice(): disconnecting adding output %d",
4061 mOutputs.keyAt(i));
4062 outputs.add(mOutputs.keyAt(i));
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004063 }
Eric Laurente552edb2014-03-10 17:42:56 -07004064 }
4065 }
Eric Laurentd4692962014-05-05 18:13:44 -07004066 // Clear any profiles associated with the disconnected device.
Mikhail Naganov7e22e942017-12-07 10:04:29 -08004067 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08004068 for (size_t j = 0; j < hwModule->getOutputProfiles().size(); j++) {
4069 sp<IOProfile> profile = hwModule->getOutputProfiles()[j];
François Gaffiea8ecc2c2015-11-09 16:10:40 +01004070 if (profile->supportDevice(device)) {
Eric Laurentd4692962014-05-05 18:13:44 -07004071 ALOGV("checkOutputsForDevice(): "
Mikhail Naganovd4120142017-12-06 15:49:22 -08004072 "clearing direct output profile %zu on module %s",
4073 j, hwModule->getName());
François Gaffie112b0af2015-11-19 16:13:25 +01004074 profile->clearAudioProfiles();
Eric Laurente552edb2014-03-10 17:42:56 -07004075 }
4076 }
4077 }
4078 }
4079 return NO_ERROR;
4080}
4081
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07004082status_t AudioPolicyManager::checkInputsForDevice(const sp<DeviceDescriptor>& devDesc,
François Gaffie53615e22015-03-19 09:24:12 +01004083 audio_policy_dev_state_t state,
4084 SortedVector<audio_io_handle_t>& inputs,
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07004085 const String8& address)
Eric Laurentd4692962014-05-05 18:13:44 -07004086{
Paul McLean9080a4c2015-06-18 08:24:02 -07004087 audio_devices_t device = devDesc->type();
Eric Laurent1f2f2232014-06-02 12:01:23 -07004088 sp<AudioInputDescriptor> desc;
Eric Laurentcc750d32015-06-25 11:48:20 -07004089
4090 if (audio_device_is_digital(device)) {
4091 // erase all current sample rates, formats and channel masks
Eric Laurent20eb3a42016-01-26 18:39:17 -08004092 devDesc->clearAudioProfiles();
Eric Laurentcc750d32015-06-25 11:48:20 -07004093 }
4094
Eric Laurentd4692962014-05-05 18:13:44 -07004095 if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
4096 // first list already open inputs that can be routed to this device
4097 for (size_t input_index = 0; input_index < mInputs.size(); input_index++) {
4098 desc = mInputs.valueAt(input_index);
François Gaffiea8ecc2c2015-11-09 16:10:40 +01004099 if (desc->mProfile->supportDevice(device)) {
Eric Laurentd4692962014-05-05 18:13:44 -07004100 ALOGV("checkInputsForDevice(): adding opened input %d", mInputs.keyAt(input_index));
4101 inputs.add(mInputs.keyAt(input_index));
4102 }
4103 }
4104
4105 // then look for input profiles that can be routed to this device
Eric Laurent1c333e22014-05-20 10:48:17 -07004106 SortedVector< sp<IOProfile> > profiles;
Mikhail Naganov7e22e942017-12-07 10:04:29 -08004107 for (const auto& hwModule : mHwModules) {
Eric Laurentd4692962014-05-05 18:13:44 -07004108 for (size_t profile_index = 0;
Mikhail Naganova5e165d2017-12-07 17:08:02 -08004109 profile_index < hwModule->getInputProfiles().size();
Mikhail Naganov7e22e942017-12-07 10:04:29 -08004110 profile_index++) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08004111 sp<IOProfile> profile = hwModule->getInputProfiles()[profile_index];
Eric Laurent275e8e92014-11-30 15:14:47 -08004112
François Gaffiea8ecc2c2015-11-09 16:10:40 +01004113 if (profile->supportDevice(device)) {
François Gaffie53615e22015-03-19 09:24:12 +01004114 if (!device_distinguishes_on_address(device) ||
François Gaffiea8ecc2c2015-11-09 16:10:40 +01004115 profile->supportDeviceAddress(address)) {
Eric Laurent275e8e92014-11-30 15:14:47 -08004116 profiles.add(profile);
Mikhail Naganovd4120142017-12-06 15:49:22 -08004117 ALOGV("checkInputsForDevice(): adding profile %zu from module %s",
4118 profile_index, hwModule->getName());
Eric Laurent275e8e92014-11-30 15:14:47 -08004119 }
Eric Laurentd4692962014-05-05 18:13:44 -07004120 }
4121 }
4122 }
4123
4124 if (profiles.isEmpty() && inputs.isEmpty()) {
4125 ALOGW("checkInputsForDevice(): No input available for device 0x%X", device);
4126 return BAD_VALUE;
4127 }
4128
4129 // open inputs for matching profiles if needed. Direct inputs are also opened to
4130 // query for dynamic parameters and will be closed later by setDeviceConnectionState()
4131 for (ssize_t profile_index = 0; profile_index < (ssize_t)profiles.size(); profile_index++) {
4132
Eric Laurent1c333e22014-05-20 10:48:17 -07004133 sp<IOProfile> profile = profiles[profile_index];
Eric Laurent3974e3b2017-12-07 17:58:43 -08004134
Eric Laurentd4692962014-05-05 18:13:44 -07004135 // nothing to do if one input is already opened for this profile
4136 size_t input_index;
4137 for (input_index = 0; input_index < mInputs.size(); input_index++) {
4138 desc = mInputs.valueAt(input_index);
4139 if (desc->mProfile == profile) {
Paul McLean9080a4c2015-06-18 08:24:02 -07004140 if (audio_device_is_digital(device)) {
4141 devDesc->importAudioPort(profile);
4142 }
Eric Laurentd4692962014-05-05 18:13:44 -07004143 break;
4144 }
4145 }
4146 if (input_index != mInputs.size()) {
4147 continue;
4148 }
4149
Eric Laurent3974e3b2017-12-07 17:58:43 -08004150 if (!profile->canOpenNewIo()) {
4151 ALOGW("Max Input number %u already opened for this profile %s",
4152 profile->maxOpenCount, profile->getTagName().c_str());
4153 continue;
4154 }
4155
Eric Laurentfe231122017-11-17 17:48:06 -08004156 desc = new AudioInputDescriptor(profile, mpClientInterface);
Eric Laurentcf2c0212014-07-25 16:20:43 -07004157 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
Eric Laurentfe231122017-11-17 17:48:06 -08004158 status_t status = desc->open(nullptr,
4159 device,
4160 address,
4161 AUDIO_SOURCE_MIC,
4162 AUDIO_INPUT_FLAG_NONE,
4163 &input);
Eric Laurentd4692962014-05-05 18:13:44 -07004164
Eric Laurentcf2c0212014-07-25 16:20:43 -07004165 if (status == NO_ERROR) {
Eric Laurentd4692962014-05-05 18:13:44 -07004166 if (!address.isEmpty()) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07004167 char *param = audio_device_address_to_parameter(device, address);
4168 mpClientInterface->setParameters(input, String8(param));
4169 free(param);
Eric Laurentd4692962014-05-05 18:13:44 -07004170 }
Phil Burk00eeb322016-03-31 12:41:00 -07004171 updateAudioProfiles(device, input, profile->getAudioProfiles());
François Gaffie112b0af2015-11-19 16:13:25 +01004172 if (!profile->hasValidAudioProfile()) {
Eric Laurentd4692962014-05-05 18:13:44 -07004173 ALOGW("checkInputsForDevice() direct input missing param");
Eric Laurentfe231122017-11-17 17:48:06 -08004174 desc->close();
Eric Laurentcf2c0212014-07-25 16:20:43 -07004175 input = AUDIO_IO_HANDLE_NONE;
Eric Laurentd4692962014-05-05 18:13:44 -07004176 }
4177
4178 if (input != 0) {
4179 addInput(input, desc);
4180 }
4181 } // endif input != 0
4182
Eric Laurentcf2c0212014-07-25 16:20:43 -07004183 if (input == AUDIO_IO_HANDLE_NONE) {
Eric Laurentd4692962014-05-05 18:13:44 -07004184 ALOGW("checkInputsForDevice() could not open input for device 0x%X", device);
Eric Laurentd4692962014-05-05 18:13:44 -07004185 profiles.removeAt(profile_index);
4186 profile_index--;
4187 } else {
4188 inputs.add(input);
Paul McLean9080a4c2015-06-18 08:24:02 -07004189 if (audio_device_is_digital(device)) {
4190 devDesc->importAudioPort(profile);
4191 }
Eric Laurentd4692962014-05-05 18:13:44 -07004192 ALOGV("checkInputsForDevice(): adding input %d", input);
4193 }
4194 } // end scan profiles
4195
4196 if (profiles.isEmpty()) {
4197 ALOGW("checkInputsForDevice(): No input available for device 0x%X", device);
4198 return BAD_VALUE;
4199 }
4200 } else {
4201 // Disconnect
4202 // check if one opened input is not needed any more after disconnecting one device
4203 for (size_t input_index = 0; input_index < mInputs.size(); input_index++) {
4204 desc = mInputs.valueAt(input_index);
François Gaffiea8ecc2c2015-11-09 16:10:40 +01004205 if (!(desc->mProfile->supportDevice(mAvailableInputDevices.types()))) {
Eric Laurentd4692962014-05-05 18:13:44 -07004206 ALOGV("checkInputsForDevice(): disconnecting adding input %d",
4207 mInputs.keyAt(input_index));
4208 inputs.add(mInputs.keyAt(input_index));
4209 }
4210 }
4211 // Clear any profiles associated with the disconnected device.
Mikhail Naganovd4120142017-12-06 15:49:22 -08004212 for (const auto& hwModule : mHwModules) {
Eric Laurentd4692962014-05-05 18:13:44 -07004213 for (size_t profile_index = 0;
Mikhail Naganova5e165d2017-12-07 17:08:02 -08004214 profile_index < hwModule->getInputProfiles().size();
Eric Laurentd4692962014-05-05 18:13:44 -07004215 profile_index++) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08004216 sp<IOProfile> profile = hwModule->getInputProfiles()[profile_index];
François Gaffiea8ecc2c2015-11-09 16:10:40 +01004217 if (profile->supportDevice(device)) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08004218 ALOGV("checkInputsForDevice(): clearing direct input profile %zu on module %s",
4219 profile_index, hwModule->getName());
François Gaffie112b0af2015-11-19 16:13:25 +01004220 profile->clearAudioProfiles();
Eric Laurentd4692962014-05-05 18:13:44 -07004221 }
4222 }
4223 }
4224 } // end disconnect
4225
4226 return NO_ERROR;
4227}
4228
4229
Eric Laurente0720872014-03-11 09:30:41 -07004230void AudioPolicyManager::closeOutput(audio_io_handle_t output)
Eric Laurente552edb2014-03-10 17:42:56 -07004231{
4232 ALOGV("closeOutput(%d)", output);
4233
Eric Laurentc75307b2015-03-17 15:29:32 -07004234 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
Eric Laurente552edb2014-03-10 17:42:56 -07004235 if (outputDesc == NULL) {
4236 ALOGW("closeOutput() unknown output %d", output);
4237 return;
4238 }
François Gaffie036e1e92015-03-19 10:16:24 +01004239 mPolicyMixes.closeOutput(outputDesc);
Eric Laurent275e8e92014-11-30 15:14:47 -08004240
Eric Laurente552edb2014-03-10 17:42:56 -07004241 // look for duplicated outputs connected to the output being removed.
4242 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -07004243 sp<SwAudioOutputDescriptor> dupOutputDesc = mOutputs.valueAt(i);
Eric Laurente552edb2014-03-10 17:42:56 -07004244 if (dupOutputDesc->isDuplicated() &&
4245 (dupOutputDesc->mOutput1 == outputDesc ||
4246 dupOutputDesc->mOutput2 == outputDesc)) {
Eric Laurent733ce942017-12-07 12:18:25 -08004247 sp<SwAudioOutputDescriptor> outputDesc2;
Eric Laurente552edb2014-03-10 17:42:56 -07004248 if (dupOutputDesc->mOutput1 == outputDesc) {
4249 outputDesc2 = dupOutputDesc->mOutput2;
4250 } else {
4251 outputDesc2 = dupOutputDesc->mOutput1;
4252 }
4253 // As all active tracks on duplicated output will be deleted,
4254 // and as they were also referenced on the other output, the reference
4255 // count for their stream type must be adjusted accordingly on
4256 // the other output.
Eric Laurent733ce942017-12-07 12:18:25 -08004257 bool wasActive = outputDesc2->isActive();
Eric Laurent3b73df72014-03-11 09:06:29 -07004258 for (int j = 0; j < AUDIO_STREAM_CNT; j++) {
Eric Laurente552edb2014-03-10 17:42:56 -07004259 int refCount = dupOutputDesc->mRefCount[j];
Eric Laurent3b73df72014-03-11 09:06:29 -07004260 outputDesc2->changeRefCount((audio_stream_type_t)j,-refCount);
Eric Laurente552edb2014-03-10 17:42:56 -07004261 }
Eric Laurent733ce942017-12-07 12:18:25 -08004262 // stop() will be a no op if the output is still active but is needed in case all
4263 // active streams refcounts where cleared above
4264 if (wasActive) {
4265 outputDesc2->stop();
4266 }
Eric Laurente552edb2014-03-10 17:42:56 -07004267 audio_io_handle_t duplicatedOutput = mOutputs.keyAt(i);
4268 ALOGV("closeOutput() closing also duplicated output %d", duplicatedOutput);
4269
4270 mpClientInterface->closeOutput(duplicatedOutput);
François Gaffie53615e22015-03-19 09:24:12 +01004271 removeOutput(duplicatedOutput);
Eric Laurente552edb2014-03-10 17:42:56 -07004272 }
4273 }
4274
Eric Laurent05b90f82014-08-27 15:32:29 -07004275 nextAudioPortGeneration();
4276
Jean-Michel Triviff155c62016-02-26 12:07:16 -08004277 ssize_t index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
Eric Laurent05b90f82014-08-27 15:32:29 -07004278 if (index >= 0) {
4279 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
Glenn Kastenfcddb0b2016-07-08 17:19:25 -07004280 (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
Eric Laurent05b90f82014-08-27 15:32:29 -07004281 mAudioPatches.removeItemsAt(index);
4282 mpClientInterface->onAudioPatchListUpdate();
4283 }
4284
Eric Laurentfe231122017-11-17 17:48:06 -08004285 outputDesc->close();
Eric Laurente552edb2014-03-10 17:42:56 -07004286
François Gaffie53615e22015-03-19 09:24:12 +01004287 removeOutput(output);
Eric Laurente552edb2014-03-10 17:42:56 -07004288 mPreviousOutputs = mOutputs;
Eric Laurent05b90f82014-08-27 15:32:29 -07004289}
4290
4291void AudioPolicyManager::closeInput(audio_io_handle_t input)
4292{
4293 ALOGV("closeInput(%d)", input);
4294
4295 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
4296 if (inputDesc == NULL) {
4297 ALOGW("closeInput() unknown input %d", input);
4298 return;
4299 }
4300
Eric Laurent6a94d692014-05-20 11:18:06 -07004301 nextAudioPortGeneration();
Eric Laurent05b90f82014-08-27 15:32:29 -07004302
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08004303 ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent05b90f82014-08-27 15:32:29 -07004304 if (index >= 0) {
4305 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
Glenn Kastenfcddb0b2016-07-08 17:19:25 -07004306 (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
Eric Laurent05b90f82014-08-27 15:32:29 -07004307 mAudioPatches.removeItemsAt(index);
4308 mpClientInterface->onAudioPatchListUpdate();
4309 }
4310
Eric Laurentfe231122017-11-17 17:48:06 -08004311 inputDesc->close();
Eric Laurent05b90f82014-08-27 15:32:29 -07004312 mInputs.removeItem(input);
Eric Laurente552edb2014-03-10 17:42:56 -07004313}
4314
Eric Laurentc75307b2015-03-17 15:29:32 -07004315SortedVector<audio_io_handle_t> AudioPolicyManager::getOutputsForDevice(
4316 audio_devices_t device,
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07004317 const SwAudioOutputCollection& openOutputs)
Eric Laurente552edb2014-03-10 17:42:56 -07004318{
4319 SortedVector<audio_io_handle_t> outputs;
4320
4321 ALOGVV("getOutputsForDevice() device %04x", device);
4322 for (size_t i = 0; i < openOutputs.size(); i++) {
Eric Laurent37ddbb42016-08-10 16:19:14 -07004323 ALOGVV("output %zu isDuplicated=%d device=%04x",
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004324 i, openOutputs.valueAt(i)->isDuplicated(),
4325 openOutputs.valueAt(i)->supportedDevices());
Eric Laurente552edb2014-03-10 17:42:56 -07004326 if ((device & openOutputs.valueAt(i)->supportedDevices()) == device) {
4327 ALOGVV("getOutputsForDevice() found output %d", openOutputs.keyAt(i));
4328 outputs.add(openOutputs.keyAt(i));
4329 }
4330 }
4331 return outputs;
4332}
4333
Eric Laurente0720872014-03-11 09:30:41 -07004334bool AudioPolicyManager::vectorsEqual(SortedVector<audio_io_handle_t>& outputs1,
François Gaffie53615e22015-03-19 09:24:12 +01004335 SortedVector<audio_io_handle_t>& outputs2)
Eric Laurente552edb2014-03-10 17:42:56 -07004336{
4337 if (outputs1.size() != outputs2.size()) {
4338 return false;
4339 }
4340 for (size_t i = 0; i < outputs1.size(); i++) {
4341 if (outputs1[i] != outputs2[i]) {
4342 return false;
4343 }
4344 }
4345 return true;
4346}
4347
Eric Laurente0720872014-03-11 09:30:41 -07004348void AudioPolicyManager::checkOutputForStrategy(routing_strategy strategy)
Eric Laurente552edb2014-03-10 17:42:56 -07004349{
4350 audio_devices_t oldDevice = getDeviceForStrategy(strategy, true /*fromCache*/);
4351 audio_devices_t newDevice = getDeviceForStrategy(strategy, false /*fromCache*/);
4352 SortedVector<audio_io_handle_t> srcOutputs = getOutputsForDevice(oldDevice, mPreviousOutputs);
4353 SortedVector<audio_io_handle_t> dstOutputs = getOutputsForDevice(newDevice, mOutputs);
4354
Jean-Michel Trivife472e22014-12-16 14:23:13 -08004355 // also take into account external policy-related changes: add all outputs which are
4356 // associated with policies in the "before" and "after" output vectors
4357 ALOGVV("checkOutputForStrategy(): policy related outputs");
4358 for (size_t i = 0 ; i < mPreviousOutputs.size() ; i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -07004359 const sp<SwAudioOutputDescriptor> desc = mPreviousOutputs.valueAt(i);
Jean-Michel Trivife472e22014-12-16 14:23:13 -08004360 if (desc != 0 && desc->mPolicyMix != NULL) {
4361 srcOutputs.add(desc->mIoHandle);
4362 ALOGVV(" previous outputs: adding %d", desc->mIoHandle);
4363 }
4364 }
4365 for (size_t i = 0 ; i < mOutputs.size() ; i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -07004366 const sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Jean-Michel Trivife472e22014-12-16 14:23:13 -08004367 if (desc != 0 && desc->mPolicyMix != NULL) {
4368 dstOutputs.add(desc->mIoHandle);
4369 ALOGVV(" new outputs: adding %d", desc->mIoHandle);
4370 }
4371 }
4372
Eric Laurente552edb2014-03-10 17:42:56 -07004373 if (!vectorsEqual(srcOutputs,dstOutputs)) {
4374 ALOGV("checkOutputForStrategy() strategy %d, moving from output %d to output %d",
4375 strategy, srcOutputs[0], dstOutputs[0]);
4376 // mute strategy while moving tracks from one output to another
Mikhail Naganovcf84e592017-12-07 11:25:11 -08004377 for (audio_io_handle_t srcOut : srcOutputs) {
4378 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(srcOut);
François Gaffiead3183e2015-03-18 16:55:35 +01004379 if (isStrategyActive(desc, strategy)) {
Eric Laurentc75307b2015-03-17 15:29:32 -07004380 setStrategyMute(strategy, true, desc);
4381 setStrategyMute(strategy, false, desc, MUTE_TIME_MS, newDevice);
Eric Laurente552edb2014-03-10 17:42:56 -07004382 }
Eric Laurentd60560a2015-04-10 11:31:20 -07004383 sp<AudioSourceDescriptor> source =
Mikhail Naganovcf84e592017-12-07 11:25:11 -08004384 getSourceForStrategyOnOutput(srcOut, strategy);
Eric Laurentd60560a2015-04-10 11:31:20 -07004385 if (source != 0){
4386 connectAudioSource(source);
4387 }
Eric Laurente552edb2014-03-10 17:42:56 -07004388 }
4389
4390 // Move effects associated to this strategy from previous output to new output
4391 if (strategy == STRATEGY_MEDIA) {
Eric Laurent36829f92017-04-07 19:04:42 -07004392 selectOutputForMusicEffects();
Eric Laurente552edb2014-03-10 17:42:56 -07004393 }
4394 // Move tracks associated to this strategy from previous output to new output
Eric Laurent794fde22016-03-11 09:50:45 -08004395 for (int i = 0; i < AUDIO_STREAM_FOR_POLICY_CNT; i++) {
Eric Laurent3b73df72014-03-11 09:06:29 -07004396 if (getStrategy((audio_stream_type_t)i) == strategy) {
4397 mpClientInterface->invalidateStream((audio_stream_type_t)i);
Eric Laurente552edb2014-03-10 17:42:56 -07004398 }
4399 }
4400 }
4401}
4402
Eric Laurente0720872014-03-11 09:30:41 -07004403void AudioPolicyManager::checkOutputForAllStrategies()
Eric Laurente552edb2014-03-10 17:42:56 -07004404{
François Gaffie2110e042015-03-24 08:41:51 +01004405 if (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED)
Jon Eklund966095e2014-09-09 15:39:49 -05004406 checkOutputForStrategy(STRATEGY_ENFORCED_AUDIBLE);
Eric Laurente552edb2014-03-10 17:42:56 -07004407 checkOutputForStrategy(STRATEGY_PHONE);
François Gaffie2110e042015-03-24 08:41:51 +01004408 if (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) != AUDIO_POLICY_FORCE_SYSTEM_ENFORCED)
Jon Eklund966095e2014-09-09 15:39:49 -05004409 checkOutputForStrategy(STRATEGY_ENFORCED_AUDIBLE);
Eric Laurente552edb2014-03-10 17:42:56 -07004410 checkOutputForStrategy(STRATEGY_SONIFICATION);
4411 checkOutputForStrategy(STRATEGY_SONIFICATION_RESPECTFUL);
Eric Laurent223fd5c2014-11-11 13:43:36 -08004412 checkOutputForStrategy(STRATEGY_ACCESSIBILITY);
Eric Laurente552edb2014-03-10 17:42:56 -07004413 checkOutputForStrategy(STRATEGY_MEDIA);
4414 checkOutputForStrategy(STRATEGY_DTMF);
Eric Laurent223fd5c2014-11-11 13:43:36 -08004415 checkOutputForStrategy(STRATEGY_REROUTING);
Eric Laurente552edb2014-03-10 17:42:56 -07004416}
4417
Eric Laurente0720872014-03-11 09:30:41 -07004418void AudioPolicyManager::checkA2dpSuspend()
Eric Laurente552edb2014-03-10 17:42:56 -07004419{
François Gaffie53615e22015-03-19 09:24:12 +01004420 audio_io_handle_t a2dpOutput = mOutputs.getA2dpOutput();
Aniket Kumar Lataa8ee9962018-01-31 20:24:23 -08004421 if (a2dpOutput == 0 || mOutputs.isA2dpOffloadedOnPrimary()) {
Eric Laurent3a4311c2014-03-17 12:00:47 -07004422 mA2dpSuspended = false;
Eric Laurente552edb2014-03-10 17:42:56 -07004423 return;
4424 }
4425
Eric Laurent3a4311c2014-03-17 12:00:47 -07004426 bool isScoConnected =
Eric Laurentddbc6652014-11-13 15:13:44 -08004427 ((mAvailableInputDevices.types() & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET &
4428 ~AUDIO_DEVICE_BIT_IN) != 0) ||
4429 ((mAvailableOutputDevices.types() & AUDIO_DEVICE_OUT_ALL_SCO) != 0);
Eric Laurentf732e072016-08-03 19:30:28 -07004430
4431 // if suspended, restore A2DP output if:
4432 // ((SCO device is NOT connected) ||
4433 // ((forced usage communication is NOT SCO) && (forced usage for record is NOT SCO) &&
4434 // (phone state is NOT in call) && (phone state is NOT ringing)))
Eric Laurente552edb2014-03-10 17:42:56 -07004435 //
Eric Laurentf732e072016-08-03 19:30:28 -07004436 // if not suspended, suspend A2DP output if:
4437 // (SCO device is connected) &&
4438 // ((forced usage for communication is SCO) || (forced usage for record is SCO) ||
4439 // ((phone state is in call) || (phone state is ringing)))
Eric Laurente552edb2014-03-10 17:42:56 -07004440 //
4441 if (mA2dpSuspended) {
Eric Laurentf732e072016-08-03 19:30:28 -07004442 if (!isScoConnected ||
4443 ((mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION) !=
4444 AUDIO_POLICY_FORCE_BT_SCO) &&
4445 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_RECORD) !=
4446 AUDIO_POLICY_FORCE_BT_SCO) &&
4447 (mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) &&
François Gaffie2110e042015-03-24 08:41:51 +01004448 (mEngine->getPhoneState() != AUDIO_MODE_RINGTONE))) {
Eric Laurente552edb2014-03-10 17:42:56 -07004449
4450 mpClientInterface->restoreOutput(a2dpOutput);
4451 mA2dpSuspended = false;
4452 }
4453 } else {
Eric Laurentf732e072016-08-03 19:30:28 -07004454 if (isScoConnected &&
4455 ((mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION) ==
4456 AUDIO_POLICY_FORCE_BT_SCO) ||
4457 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_RECORD) ==
4458 AUDIO_POLICY_FORCE_BT_SCO) ||
4459 (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL) ||
François Gaffie2110e042015-03-24 08:41:51 +01004460 (mEngine->getPhoneState() == AUDIO_MODE_RINGTONE))) {
Eric Laurente552edb2014-03-10 17:42:56 -07004461
4462 mpClientInterface->suspendOutput(a2dpOutput);
4463 mA2dpSuspended = true;
4464 }
4465 }
4466}
4467
Eric Laurentc75307b2015-03-17 15:29:32 -07004468audio_devices_t AudioPolicyManager::getNewOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
4469 bool fromCache)
Eric Laurente552edb2014-03-10 17:42:56 -07004470{
4471 audio_devices_t device = AUDIO_DEVICE_NONE;
4472
Jean-Michel Triviff155c62016-02-26 12:07:16 -08004473 ssize_t index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07004474 if (index >= 0) {
4475 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
4476 if (patchDesc->mUid != mUidCached) {
4477 ALOGV("getNewOutputDevice() device %08x forced by patch %d",
Jean-Michel Triviff155c62016-02-26 12:07:16 -08004478 outputDesc->device(), outputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07004479 return outputDesc->device();
4480 }
4481 }
4482
Eric Laurente552edb2014-03-10 17:42:56 -07004483 // check the following by order of priority to request a routing change if necessary:
Jon Eklund966095e2014-09-09 15:39:49 -05004484 // 1: the strategy enforced audible is active and enforced on the output:
Eric Laurente552edb2014-03-10 17:42:56 -07004485 // use device for strategy enforced audible
4486 // 2: we are in call or the strategy phone is active on the output:
4487 // use device for strategy phone
Jean-Michel Trivi178683b2017-08-30 18:07:06 -07004488 // 3: the strategy sonification is active on the output:
Jean-Michel Trivi5de234b2015-07-21 11:42:02 -07004489 // use device for strategy sonification
Jean-Michel Trivi178683b2017-08-30 18:07:06 -07004490 // 4: the strategy for enforced audible is active but not enforced on the output:
4491 // use the device for strategy enforced audible
Eric Laurent28d09f02016-03-08 10:43:05 -08004492 // 5: the strategy accessibility is active on the output:
4493 // use device for strategy accessibility
Jean-Michel Trivi5de234b2015-07-21 11:42:02 -07004494 // 6: the strategy "respectful" sonification is active on the output:
4495 // use device for strategy "respectful" sonification
Eric Laurent223fd5c2014-11-11 13:43:36 -08004496 // 7: the strategy media is active on the output:
Eric Laurente552edb2014-03-10 17:42:56 -07004497 // use device for strategy media
Eric Laurent223fd5c2014-11-11 13:43:36 -08004498 // 8: the strategy DTMF is active on the output:
Eric Laurente552edb2014-03-10 17:42:56 -07004499 // use device for strategy DTMF
Eric Laurent223fd5c2014-11-11 13:43:36 -08004500 // 9: the strategy for beacon, a.k.a. "transmitted through speaker" is active on the output:
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07004501 // use device for strategy t-t-s
François Gaffiead3183e2015-03-18 16:55:35 +01004502 if (isStrategyActive(outputDesc, STRATEGY_ENFORCED_AUDIBLE) &&
François Gaffie2110e042015-03-24 08:41:51 +01004503 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
Eric Laurente552edb2014-03-10 17:42:56 -07004504 device = getDeviceForStrategy(STRATEGY_ENFORCED_AUDIBLE, fromCache);
4505 } else if (isInCall() ||
François Gaffiead3183e2015-03-18 16:55:35 +01004506 isStrategyActive(outputDesc, STRATEGY_PHONE)) {
Eric Laurente552edb2014-03-10 17:42:56 -07004507 device = getDeviceForStrategy(STRATEGY_PHONE, fromCache);
François Gaffiead3183e2015-03-18 16:55:35 +01004508 } else if (isStrategyActive(outputDesc, STRATEGY_SONIFICATION)) {
Eric Laurente552edb2014-03-10 17:42:56 -07004509 device = getDeviceForStrategy(STRATEGY_SONIFICATION, fromCache);
Jean-Michel Trivi178683b2017-08-30 18:07:06 -07004510 } else if (isStrategyActive(outputDesc, STRATEGY_ENFORCED_AUDIBLE)) {
4511 device = getDeviceForStrategy(STRATEGY_ENFORCED_AUDIBLE, fromCache);
Eric Laurent28d09f02016-03-08 10:43:05 -08004512 } else if (isStrategyActive(outputDesc, STRATEGY_ACCESSIBILITY)) {
4513 device = getDeviceForStrategy(STRATEGY_ACCESSIBILITY, fromCache);
François Gaffiead3183e2015-03-18 16:55:35 +01004514 } else if (isStrategyActive(outputDesc, STRATEGY_SONIFICATION_RESPECTFUL)) {
Eric Laurente552edb2014-03-10 17:42:56 -07004515 device = getDeviceForStrategy(STRATEGY_SONIFICATION_RESPECTFUL, fromCache);
François Gaffiead3183e2015-03-18 16:55:35 +01004516 } else if (isStrategyActive(outputDesc, STRATEGY_MEDIA)) {
Eric Laurente552edb2014-03-10 17:42:56 -07004517 device = getDeviceForStrategy(STRATEGY_MEDIA, fromCache);
François Gaffiead3183e2015-03-18 16:55:35 +01004518 } else if (isStrategyActive(outputDesc, STRATEGY_DTMF)) {
Eric Laurente552edb2014-03-10 17:42:56 -07004519 device = getDeviceForStrategy(STRATEGY_DTMF, fromCache);
François Gaffiead3183e2015-03-18 16:55:35 +01004520 } else if (isStrategyActive(outputDesc, STRATEGY_TRANSMITTED_THROUGH_SPEAKER)) {
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07004521 device = getDeviceForStrategy(STRATEGY_TRANSMITTED_THROUGH_SPEAKER, fromCache);
François Gaffiead3183e2015-03-18 16:55:35 +01004522 } else if (isStrategyActive(outputDesc, STRATEGY_REROUTING)) {
Eric Laurent223fd5c2014-11-11 13:43:36 -08004523 device = getDeviceForStrategy(STRATEGY_REROUTING, fromCache);
Eric Laurente552edb2014-03-10 17:42:56 -07004524 }
4525
Eric Laurent1c333e22014-05-20 10:48:17 -07004526 ALOGV("getNewOutputDevice() selected device %x", device);
4527 return device;
4528}
4529
Eric Laurentfb66dd92016-01-28 18:32:03 -08004530audio_devices_t AudioPolicyManager::getNewInputDevice(const sp<AudioInputDescriptor>& inputDesc)
Eric Laurent1c333e22014-05-20 10:48:17 -07004531{
Eric Laurentfb66dd92016-01-28 18:32:03 -08004532 audio_devices_t device = AUDIO_DEVICE_NONE;
Eric Laurent6a94d692014-05-20 11:18:06 -07004533
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08004534 ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07004535 if (index >= 0) {
4536 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
4537 if (patchDesc->mUid != mUidCached) {
4538 ALOGV("getNewInputDevice() device %08x forced by patch %d",
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08004539 inputDesc->mDevice, inputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07004540 return inputDesc->mDevice;
4541 }
4542 }
4543
Eric Laurentdc95a252018-04-12 12:46:56 -07004544 // If we are not in call and no client is active on this input, this methods returns
4545 // AUDIO_DEVICE_NONE, causing the patch on the input stream to be released.
Eric Laurentfb66dd92016-01-28 18:32:03 -08004546 audio_source_t source = inputDesc->getHighestPrioritySource(true /*activeOnly*/);
Eric Laurentdc95a252018-04-12 12:46:56 -07004547 if (source == AUDIO_SOURCE_DEFAULT && isInCall()) {
4548 source = AUDIO_SOURCE_VOICE_COMMUNICATION;
4549 }
4550 if (source != AUDIO_SOURCE_DEFAULT) {
Eric Laurentfb66dd92016-01-28 18:32:03 -08004551 device = getDeviceAndMixForInputSource(source);
4552 }
Eric Laurent1c333e22014-05-20 10:48:17 -07004553
Eric Laurente552edb2014-03-10 17:42:56 -07004554 return device;
4555}
4556
Eric Laurent794fde22016-03-11 09:50:45 -08004557bool AudioPolicyManager::streamsMatchForvolume(audio_stream_type_t stream1,
4558 audio_stream_type_t stream2) {
Jean-Michel Trivi99bb2f92016-11-23 15:52:07 -08004559 return (stream1 == stream2);
Eric Laurent28d09f02016-03-08 10:43:05 -08004560}
4561
Eric Laurente0720872014-03-11 09:30:41 -07004562uint32_t AudioPolicyManager::getStrategyForStream(audio_stream_type_t stream) {
Eric Laurente552edb2014-03-10 17:42:56 -07004563 return (uint32_t)getStrategy(stream);
4564}
4565
Eric Laurente0720872014-03-11 09:30:41 -07004566audio_devices_t AudioPolicyManager::getDevicesForStream(audio_stream_type_t stream) {
Eric Laurente552edb2014-03-10 17:42:56 -07004567 // By checking the range of stream before calling getStrategy, we avoid
4568 // getStrategy's behavior for invalid streams. getStrategy would do a ALOGE
4569 // and then return STRATEGY_MEDIA, but we want to return the empty set.
Eric Laurent223fd5c2014-11-11 13:43:36 -08004570 if (stream < (audio_stream_type_t) 0 || stream >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004571 return AUDIO_DEVICE_NONE;
4572 }
Eric Laurent28d09f02016-03-08 10:43:05 -08004573 audio_devices_t devices = AUDIO_DEVICE_NONE;
Eric Laurent794fde22016-03-11 09:50:45 -08004574 for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) {
4575 if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
Eric Laurent28d09f02016-03-08 10:43:05 -08004576 continue;
Eric Laurent6a94d692014-05-20 11:18:06 -07004577 }
Eric Laurent794fde22016-03-11 09:50:45 -08004578 routing_strategy curStrategy = getStrategy((audio_stream_type_t)curStream);
Eric Laurent28d09f02016-03-08 10:43:05 -08004579 audio_devices_t curDevices =
Eric Laurent447a87b2016-07-07 17:32:10 -07004580 getDeviceForStrategy((routing_strategy)curStrategy, false /*fromCache*/);
Mikhail Naganovcf84e592017-12-07 11:25:11 -08004581 for (audio_io_handle_t output : getOutputsForDevice(curDevices, mOutputs)) {
4582 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
Eric Laurent794fde22016-03-11 09:50:45 -08004583 if (outputDesc->isStreamActive((audio_stream_type_t)curStream)) {
Eric Laurent28d09f02016-03-08 10:43:05 -08004584 curDevices |= outputDesc->device();
4585 }
4586 }
4587 devices |= curDevices;
Eric Laurente552edb2014-03-10 17:42:56 -07004588 }
Jon Eklund11c9fb12014-06-23 14:47:03 -05004589
4590 /*Filter SPEAKER_SAFE out of results, as AudioService doesn't know about it
4591 and doesn't really need to.*/
4592 if (devices & AUDIO_DEVICE_OUT_SPEAKER_SAFE) {
4593 devices |= AUDIO_DEVICE_OUT_SPEAKER;
4594 devices &= ~AUDIO_DEVICE_OUT_SPEAKER_SAFE;
4595 }
Eric Laurente552edb2014-03-10 17:42:56 -07004596 return devices;
4597}
4598
François Gaffie2110e042015-03-24 08:41:51 +01004599routing_strategy AudioPolicyManager::getStrategy(audio_stream_type_t stream) const
4600{
Eric Laurent223fd5c2014-11-11 13:43:36 -08004601 ALOG_ASSERT(stream != AUDIO_STREAM_PATCH,"getStrategy() called for AUDIO_STREAM_PATCH");
François Gaffie2110e042015-03-24 08:41:51 +01004602 return mEngine->getStrategyForStream(stream);
Eric Laurente552edb2014-03-10 17:42:56 -07004603}
4604
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07004605uint32_t AudioPolicyManager::getStrategyForAttr(const audio_attributes_t *attr) {
4606 // flags to strategy mapping
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07004607 if ((attr->flags & AUDIO_FLAG_BEACON) == AUDIO_FLAG_BEACON) {
4608 return (uint32_t) STRATEGY_TRANSMITTED_THROUGH_SPEAKER;
4609 }
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07004610 if ((attr->flags & AUDIO_FLAG_AUDIBILITY_ENFORCED) == AUDIO_FLAG_AUDIBILITY_ENFORCED) {
4611 return (uint32_t) STRATEGY_ENFORCED_AUDIBLE;
4612 }
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07004613 // usage to strategy mapping
François Gaffie2110e042015-03-24 08:41:51 +01004614 return static_cast<uint32_t>(mEngine->getStrategyForUsage(attr->usage));
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07004615}
4616
Eric Laurente0720872014-03-11 09:30:41 -07004617void AudioPolicyManager::handleNotificationRoutingForStream(audio_stream_type_t stream) {
Eric Laurente552edb2014-03-10 17:42:56 -07004618 switch(stream) {
Eric Laurent3b73df72014-03-11 09:06:29 -07004619 case AUDIO_STREAM_MUSIC:
Eric Laurente552edb2014-03-10 17:42:56 -07004620 checkOutputForStrategy(STRATEGY_SONIFICATION_RESPECTFUL);
4621 updateDevicesAndOutputs();
4622 break;
4623 default:
4624 break;
4625 }
4626}
4627
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07004628uint32_t AudioPolicyManager::handleEventForBeacon(int event) {
Eric Laurent9459fb02015-08-12 18:36:32 -07004629
4630 // skip beacon mute management if a dedicated TTS output is available
4631 if (mTtsOutputAvailable) {
4632 return 0;
4633 }
4634
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07004635 switch(event) {
4636 case STARTING_OUTPUT:
4637 mBeaconMuteRefCount++;
4638 break;
4639 case STOPPING_OUTPUT:
4640 if (mBeaconMuteRefCount > 0) {
4641 mBeaconMuteRefCount--;
4642 }
4643 break;
4644 case STARTING_BEACON:
4645 mBeaconPlayingRefCount++;
4646 break;
4647 case STOPPING_BEACON:
4648 if (mBeaconPlayingRefCount > 0) {
4649 mBeaconPlayingRefCount--;
4650 }
4651 break;
4652 }
4653
4654 if (mBeaconMuteRefCount > 0) {
4655 // any playback causes beacon to be muted
4656 return setBeaconMute(true);
4657 } else {
4658 // no other playback: unmute when beacon starts playing, mute when it stops
4659 return setBeaconMute(mBeaconPlayingRefCount == 0);
4660 }
4661}
4662
4663uint32_t AudioPolicyManager::setBeaconMute(bool mute) {
4664 ALOGV("setBeaconMute(%d) mBeaconMuteRefCount=%d mBeaconPlayingRefCount=%d",
4665 mute, mBeaconMuteRefCount, mBeaconPlayingRefCount);
4666 // keep track of muted state to avoid repeating mute/unmute operations
4667 if (mBeaconMuted != mute) {
4668 // mute/unmute AUDIO_STREAM_TTS on all outputs
4669 ALOGV("\t muting %d", mute);
4670 uint32_t maxLatency = 0;
4671 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -07004672 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07004673 setStreamMute(AUDIO_STREAM_TTS, mute/*on*/,
Eric Laurentc75307b2015-03-17 15:29:32 -07004674 desc,
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07004675 0 /*delay*/, AUDIO_DEVICE_NONE);
4676 const uint32_t latency = desc->latency() * 2;
4677 if (latency > maxLatency) {
4678 maxLatency = latency;
4679 }
4680 }
4681 mBeaconMuted = mute;
4682 return maxLatency;
4683 }
4684 return 0;
4685}
4686
Eric Laurente0720872014-03-11 09:30:41 -07004687audio_devices_t AudioPolicyManager::getDeviceForStrategy(routing_strategy strategy,
François Gaffie53615e22015-03-19 09:24:12 +01004688 bool fromCache)
Eric Laurente552edb2014-03-10 17:42:56 -07004689{
Paul McLeanaa981192015-03-21 09:55:15 -07004690 // Routing
4691 // see if we have an explicit route
4692 // scan the whole RouteMap, for each entry, convert the stream type to a strategy
4693 // (getStrategy(stream)).
4694 // if the strategy from the stream type in the RouteMap is the same as the argument above,
Eric Laurentad2e7b92017-09-14 20:06:42 -07004695 // and activity count is non-zero and the device in the route descriptor is available
4696 // then select this device.
Paul McLeanaa981192015-03-21 09:55:15 -07004697 for (size_t routeIndex = 0; routeIndex < mOutputRoutes.size(); routeIndex++) {
4698 sp<SessionRoute> route = mOutputRoutes.valueAt(routeIndex);
Eric Laurent28d09f02016-03-08 10:43:05 -08004699 routing_strategy routeStrategy = getStrategy(route->mStreamType);
Eric Laurentad2e7b92017-09-14 20:06:42 -07004700 if ((routeStrategy == strategy) && route->isActive() &&
4701 (mAvailableOutputDevices.indexOf(route->mDeviceDescriptor) >= 0)) {
Paul McLeanaa981192015-03-21 09:55:15 -07004702 return route->mDeviceDescriptor->type();
4703 }
4704 }
4705
Eric Laurente552edb2014-03-10 17:42:56 -07004706 if (fromCache) {
4707 ALOGVV("getDeviceForStrategy() from cache strategy %d, device %x",
4708 strategy, mDeviceForStrategy[strategy]);
4709 return mDeviceForStrategy[strategy];
4710 }
François Gaffie2110e042015-03-24 08:41:51 +01004711 return mEngine->getDeviceForStrategy(strategy);
Eric Laurente552edb2014-03-10 17:42:56 -07004712}
4713
Eric Laurente0720872014-03-11 09:30:41 -07004714void AudioPolicyManager::updateDevicesAndOutputs()
Eric Laurente552edb2014-03-10 17:42:56 -07004715{
4716 for (int i = 0; i < NUM_STRATEGIES; i++) {
4717 mDeviceForStrategy[i] = getDeviceForStrategy((routing_strategy)i, false /*fromCache*/);
4718 }
4719 mPreviousOutputs = mOutputs;
4720}
4721
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07004722uint32_t AudioPolicyManager::checkDeviceMuteStrategies(const sp<AudioOutputDescriptor>& outputDesc,
Eric Laurente552edb2014-03-10 17:42:56 -07004723 audio_devices_t prevDevice,
4724 uint32_t delayMs)
4725{
4726 // mute/unmute strategies using an incompatible device combination
4727 // if muting, wait for the audio in pcm buffer to be drained before proceeding
4728 // if unmuting, unmute only after the specified delay
4729 if (outputDesc->isDuplicated()) {
4730 return 0;
4731 }
4732
4733 uint32_t muteWaitMs = 0;
4734 audio_devices_t device = outputDesc->device();
Eric Laurent3b73df72014-03-11 09:06:29 -07004735 bool shouldMute = outputDesc->isActive() && (popcount(device) >= 2);
Eric Laurente552edb2014-03-10 17:42:56 -07004736
4737 for (size_t i = 0; i < NUM_STRATEGIES; i++) {
4738 audio_devices_t curDevice = getDeviceForStrategy((routing_strategy)i, false /*fromCache*/);
Eric Laurentc75307b2015-03-17 15:29:32 -07004739 curDevice = curDevice & outputDesc->supportedDevices();
Eric Laurente552edb2014-03-10 17:42:56 -07004740 bool mute = shouldMute && (curDevice & device) && (curDevice != device);
4741 bool doMute = false;
4742
4743 if (mute && !outputDesc->mStrategyMutedByDevice[i]) {
4744 doMute = true;
4745 outputDesc->mStrategyMutedByDevice[i] = true;
4746 } else if (!mute && outputDesc->mStrategyMutedByDevice[i]){
4747 doMute = true;
4748 outputDesc->mStrategyMutedByDevice[i] = false;
4749 }
Eric Laurent99401132014-05-07 19:48:15 -07004750 if (doMute) {
Eric Laurente552edb2014-03-10 17:42:56 -07004751 for (size_t j = 0; j < mOutputs.size(); j++) {
Eric Laurent1f2f2232014-06-02 12:01:23 -07004752 sp<AudioOutputDescriptor> desc = mOutputs.valueAt(j);
Eric Laurente552edb2014-03-10 17:42:56 -07004753 // skip output if it does not share any device with current output
4754 if ((desc->supportedDevices() & outputDesc->supportedDevices())
4755 == AUDIO_DEVICE_NONE) {
4756 continue;
4757 }
Eric Laurent37ddbb42016-08-10 16:19:14 -07004758 ALOGVV("checkDeviceMuteStrategies() %s strategy %zu (curDevice %04x)",
Eric Laurentc75307b2015-03-17 15:29:32 -07004759 mute ? "muting" : "unmuting", i, curDevice);
4760 setStrategyMute((routing_strategy)i, mute, desc, mute ? 0 : delayMs);
François Gaffiead3183e2015-03-18 16:55:35 +01004761 if (isStrategyActive(desc, (routing_strategy)i)) {
Eric Laurent99401132014-05-07 19:48:15 -07004762 if (mute) {
4763 // FIXME: should not need to double latency if volume could be applied
4764 // immediately by the audioflinger mixer. We must account for the delay
4765 // between now and the next time the audioflinger thread for this output
4766 // will process a buffer (which corresponds to one buffer size,
4767 // usually 1/2 or 1/4 of the latency).
4768 if (muteWaitMs < desc->latency() * 2) {
4769 muteWaitMs = desc->latency() * 2;
Eric Laurente552edb2014-03-10 17:42:56 -07004770 }
4771 }
4772 }
4773 }
4774 }
4775 }
4776
Eric Laurent99401132014-05-07 19:48:15 -07004777 // temporary mute output if device selection changes to avoid volume bursts due to
4778 // different per device volumes
4779 if (outputDesc->isActive() && (device != prevDevice)) {
Eric Laurentdc462862016-07-19 12:29:53 -07004780 uint32_t tempMuteWaitMs = outputDesc->latency() * 2;
4781 // temporary mute duration is conservatively set to 4 times the reported latency
4782 uint32_t tempMuteDurationMs = outputDesc->latency() * 4;
4783 if (muteWaitMs < tempMuteWaitMs) {
4784 muteWaitMs = tempMuteWaitMs;
Eric Laurent99401132014-05-07 19:48:15 -07004785 }
Eric Laurentdc462862016-07-19 12:29:53 -07004786
Eric Laurent99401132014-05-07 19:48:15 -07004787 for (size_t i = 0; i < NUM_STRATEGIES; i++) {
François Gaffiead3183e2015-03-18 16:55:35 +01004788 if (isStrategyActive(outputDesc, (routing_strategy)i)) {
Eric Laurentdc462862016-07-19 12:29:53 -07004789 // make sure that we do not start the temporary mute period too early in case of
4790 // delayed device change
4791 setStrategyMute((routing_strategy)i, true, outputDesc, delayMs);
Eric Laurentc75307b2015-03-17 15:29:32 -07004792 setStrategyMute((routing_strategy)i, false, outputDesc,
Eric Laurentdc462862016-07-19 12:29:53 -07004793 delayMs + tempMuteDurationMs, device);
Eric Laurent99401132014-05-07 19:48:15 -07004794 }
4795 }
4796 }
4797
Eric Laurente552edb2014-03-10 17:42:56 -07004798 // wait for the PCM output buffers to empty before proceeding with the rest of the command
4799 if (muteWaitMs > delayMs) {
4800 muteWaitMs -= delayMs;
4801 usleep(muteWaitMs * 1000);
4802 return muteWaitMs;
4803 }
4804 return 0;
4805}
4806
Eric Laurentc75307b2015-03-17 15:29:32 -07004807uint32_t AudioPolicyManager::setOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
Eric Laurente552edb2014-03-10 17:42:56 -07004808 audio_devices_t device,
4809 bool force,
Eric Laurent6a94d692014-05-20 11:18:06 -07004810 int delayMs,
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004811 audio_patch_handle_t *patchHandle,
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00004812 const char *address,
4813 bool requiresMuteCheck)
Eric Laurente552edb2014-03-10 17:42:56 -07004814{
Eric Laurentc75307b2015-03-17 15:29:32 -07004815 ALOGV("setOutputDevice() device %04x delayMs %d", device, delayMs);
Eric Laurente552edb2014-03-10 17:42:56 -07004816 AudioParameter param;
4817 uint32_t muteWaitMs;
4818
4819 if (outputDesc->isDuplicated()) {
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00004820 muteWaitMs = setOutputDevice(outputDesc->subOutput1(), device, force, delayMs,
4821 nullptr /* patchHandle */, nullptr /* address */, requiresMuteCheck);
4822 muteWaitMs += setOutputDevice(outputDesc->subOutput2(), device, force, delayMs,
4823 nullptr /* patchHandle */, nullptr /* address */, requiresMuteCheck);
Eric Laurente552edb2014-03-10 17:42:56 -07004824 return muteWaitMs;
4825 }
4826 // no need to proceed if new device is not AUDIO_DEVICE_NONE and not supported by current
4827 // output profile
Eric Laurentc75307b2015-03-17 15:29:32 -07004828 if ((device != AUDIO_DEVICE_NONE) &&
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00004829 ((device & outputDesc->supportedDevices()) == AUDIO_DEVICE_NONE)) {
Eric Laurente552edb2014-03-10 17:42:56 -07004830 return 0;
4831 }
4832
4833 // filter devices according to output selected
Eric Laurentc75307b2015-03-17 15:29:32 -07004834 device = (audio_devices_t)(device & outputDesc->supportedDevices());
Eric Laurente552edb2014-03-10 17:42:56 -07004835
4836 audio_devices_t prevDevice = outputDesc->mDevice;
4837
Paul McLeanaa981192015-03-21 09:55:15 -07004838 ALOGV("setOutputDevice() prevDevice 0x%04x", prevDevice);
Eric Laurente552edb2014-03-10 17:42:56 -07004839
4840 if (device != AUDIO_DEVICE_NONE) {
4841 outputDesc->mDevice = device;
4842 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00004843
4844 // if the outputs are not materially active, there is no need to mute.
4845 if (requiresMuteCheck) {
4846 muteWaitMs = checkDeviceMuteStrategies(outputDesc, prevDevice, delayMs);
4847 } else {
4848 ALOGV("%s: suppressing checkDeviceMuteStrategies", __func__);
4849 muteWaitMs = 0;
4850 }
Eric Laurente552edb2014-03-10 17:42:56 -07004851
4852 // Do not change the routing if:
Eric Laurentb80a2a82014-10-27 16:07:59 -07004853 // the requested device is AUDIO_DEVICE_NONE
4854 // OR the requested device is the same as current device
4855 // AND force is not specified
4856 // AND the output is connected by a valid audio patch.
Eric Laurente552edb2014-03-10 17:42:56 -07004857 // Doing this check here allows the caller to call setOutputDevice() without conditions
Paul McLeanaa981192015-03-21 09:55:15 -07004858 if ((device == AUDIO_DEVICE_NONE || device == prevDevice) &&
4859 !force &&
Jean-Michel Triviff155c62016-02-26 12:07:16 -08004860 outputDesc->getPatchHandle() != 0) {
Eric Laurentc75307b2015-03-17 15:29:32 -07004861 ALOGV("setOutputDevice() setting same device 0x%04x or null device", device);
Eric Laurente552edb2014-03-10 17:42:56 -07004862 return muteWaitMs;
4863 }
4864
4865 ALOGV("setOutputDevice() changing device");
Eric Laurent1c333e22014-05-20 10:48:17 -07004866
Eric Laurente552edb2014-03-10 17:42:56 -07004867 // do the routing
Eric Laurent1c333e22014-05-20 10:48:17 -07004868 if (device == AUDIO_DEVICE_NONE) {
Eric Laurentc75307b2015-03-17 15:29:32 -07004869 resetOutputDevice(outputDesc, delayMs, NULL);
Eric Laurent1c333e22014-05-20 10:48:17 -07004870 } else {
Eric Laurentc40d9692016-04-13 19:14:13 -07004871 DeviceVector deviceList;
4872 if ((address == NULL) || (strlen(address) == 0)) {
4873 deviceList = mAvailableOutputDevices.getDevicesFromType(device);
4874 } else {
4875 deviceList = mAvailableOutputDevices.getDevicesFromTypeAddr(device, String8(address));
4876 }
4877
Eric Laurent1c333e22014-05-20 10:48:17 -07004878 if (!deviceList.isEmpty()) {
4879 struct audio_patch patch;
4880 outputDesc->toAudioPortConfig(&patch.sources[0]);
4881 patch.num_sources = 1;
4882 patch.num_sinks = 0;
4883 for (size_t i = 0; i < deviceList.size() && i < AUDIO_PATCH_PORTS_MAX; i++) {
4884 deviceList.itemAt(i)->toAudioPortConfig(&patch.sinks[i]);
Eric Laurent1c333e22014-05-20 10:48:17 -07004885 patch.num_sinks++;
4886 }
Eric Laurent6a94d692014-05-20 11:18:06 -07004887 ssize_t index;
4888 if (patchHandle && *patchHandle != AUDIO_PATCH_HANDLE_NONE) {
4889 index = mAudioPatches.indexOfKey(*patchHandle);
4890 } else {
Jean-Michel Triviff155c62016-02-26 12:07:16 -08004891 index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07004892 }
4893 sp< AudioPatch> patchDesc;
4894 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
4895 if (index >= 0) {
4896 patchDesc = mAudioPatches.valueAt(index);
4897 afPatchHandle = patchDesc->mAfPatchHandle;
4898 }
4899
Eric Laurent1c333e22014-05-20 10:48:17 -07004900 status_t status = mpClientInterface->createAudioPatch(&patch,
Eric Laurent6a94d692014-05-20 11:18:06 -07004901 &afPatchHandle,
4902 delayMs);
Eric Laurent1c333e22014-05-20 10:48:17 -07004903 ALOGV("setOutputDevice() createAudioPatch returned %d patchHandle %d"
4904 "num_sources %d num_sinks %d",
Eric Laurent6a94d692014-05-20 11:18:06 -07004905 status, afPatchHandle, patch.num_sources, patch.num_sinks);
Eric Laurent1c333e22014-05-20 10:48:17 -07004906 if (status == NO_ERROR) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004907 if (index < 0) {
François Gaffie98cc1912015-03-18 17:52:40 +01004908 patchDesc = new AudioPatch(&patch, mUidCached);
Eric Laurent6a94d692014-05-20 11:18:06 -07004909 addAudioPatch(patchDesc->mHandle, patchDesc);
4910 } else {
4911 patchDesc->mPatch = patch;
4912 }
4913 patchDesc->mAfPatchHandle = afPatchHandle;
Eric Laurent6a94d692014-05-20 11:18:06 -07004914 if (patchHandle) {
4915 *patchHandle = patchDesc->mHandle;
4916 }
Jean-Michel Triviff155c62016-02-26 12:07:16 -08004917 outputDesc->setPatchHandle(patchDesc->mHandle);
Eric Laurent6a94d692014-05-20 11:18:06 -07004918 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07004919 mpClientInterface->onAudioPatchListUpdate();
Eric Laurent1c333e22014-05-20 10:48:17 -07004920 }
4921 }
bryant_liuf5e7e792014-08-19 20:07:05 +08004922
4923 // inform all input as well
4924 for (size_t i = 0; i < mInputs.size(); i++) {
4925 const sp<AudioInputDescriptor> inputDescriptor = mInputs.valueAt(i);
François Gaffie53615e22015-03-19 09:24:12 +01004926 if (!is_virtual_input_device(inputDescriptor->mDevice)) {
bryant_liuf5e7e792014-08-19 20:07:05 +08004927 AudioParameter inputCmd = AudioParameter();
4928 ALOGV("%s: inform input %d of device:%d", __func__,
4929 inputDescriptor->mIoHandle, device);
4930 inputCmd.addInt(String8(AudioParameter::keyRouting),device);
4931 mpClientInterface->setParameters(inputDescriptor->mIoHandle,
4932 inputCmd.toString(),
4933 delayMs);
4934 }
4935 }
Eric Laurent1c333e22014-05-20 10:48:17 -07004936 }
Eric Laurente552edb2014-03-10 17:42:56 -07004937
4938 // update stream volumes according to new device
Eric Laurentc75307b2015-03-17 15:29:32 -07004939 applyStreamVolumes(outputDesc, device, delayMs);
Eric Laurente552edb2014-03-10 17:42:56 -07004940
4941 return muteWaitMs;
4942}
4943
Eric Laurentc75307b2015-03-17 15:29:32 -07004944status_t AudioPolicyManager::resetOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
Eric Laurent6a94d692014-05-20 11:18:06 -07004945 int delayMs,
4946 audio_patch_handle_t *patchHandle)
Eric Laurent1c333e22014-05-20 10:48:17 -07004947{
Eric Laurent6a94d692014-05-20 11:18:06 -07004948 ssize_t index;
4949 if (patchHandle) {
4950 index = mAudioPatches.indexOfKey(*patchHandle);
4951 } else {
Jean-Michel Triviff155c62016-02-26 12:07:16 -08004952 index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07004953 }
4954 if (index < 0) {
Eric Laurent1c333e22014-05-20 10:48:17 -07004955 return INVALID_OPERATION;
4956 }
Eric Laurent6a94d692014-05-20 11:18:06 -07004957 sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index);
4958 status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, delayMs);
Eric Laurent1c333e22014-05-20 10:48:17 -07004959 ALOGV("resetOutputDevice() releaseAudioPatch returned %d", status);
Glenn Kastena13cde92016-03-28 15:26:02 -07004960 outputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
Eric Laurent6a94d692014-05-20 11:18:06 -07004961 removeAudioPatch(patchDesc->mHandle);
4962 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07004963 mpClientInterface->onAudioPatchListUpdate();
Eric Laurent1c333e22014-05-20 10:48:17 -07004964 return status;
4965}
4966
4967status_t AudioPolicyManager::setInputDevice(audio_io_handle_t input,
4968 audio_devices_t device,
Eric Laurent6a94d692014-05-20 11:18:06 -07004969 bool force,
4970 audio_patch_handle_t *patchHandle)
Eric Laurent1c333e22014-05-20 10:48:17 -07004971{
4972 status_t status = NO_ERROR;
4973
Eric Laurent1f2f2232014-06-02 12:01:23 -07004974 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
Eric Laurent1c333e22014-05-20 10:48:17 -07004975 if ((device != AUDIO_DEVICE_NONE) && ((device != inputDesc->mDevice) || force)) {
4976 inputDesc->mDevice = device;
4977
4978 DeviceVector deviceList = mAvailableInputDevices.getDevicesFromType(device);
4979 if (!deviceList.isEmpty()) {
4980 struct audio_patch patch;
4981 inputDesc->toAudioPortConfig(&patch.sinks[0]);
Eric Laurentdaf92cc2014-07-22 15:36:10 -07004982 // AUDIO_SOURCE_HOTWORD is for internal use only:
4983 // handled as AUDIO_SOURCE_VOICE_RECOGNITION by the audio HAL
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07004984 if (patch.sinks[0].ext.mix.usecase.source == AUDIO_SOURCE_HOTWORD &&
Eric Laurent599c7582015-12-07 18:05:55 -08004985 !inputDesc->isSoundTrigger()) {
Eric Laurentdaf92cc2014-07-22 15:36:10 -07004986 patch.sinks[0].ext.mix.usecase.source = AUDIO_SOURCE_VOICE_RECOGNITION;
4987 }
Eric Laurent1c333e22014-05-20 10:48:17 -07004988 patch.num_sinks = 1;
4989 //only one input device for now
4990 deviceList.itemAt(0)->toAudioPortConfig(&patch.sources[0]);
Eric Laurent1c333e22014-05-20 10:48:17 -07004991 patch.num_sources = 1;
Eric Laurent6a94d692014-05-20 11:18:06 -07004992 ssize_t index;
4993 if (patchHandle && *patchHandle != AUDIO_PATCH_HANDLE_NONE) {
4994 index = mAudioPatches.indexOfKey(*patchHandle);
4995 } else {
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08004996 index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07004997 }
4998 sp< AudioPatch> patchDesc;
4999 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
5000 if (index >= 0) {
5001 patchDesc = mAudioPatches.valueAt(index);
5002 afPatchHandle = patchDesc->mAfPatchHandle;
5003 }
5004
Eric Laurent1c333e22014-05-20 10:48:17 -07005005 status_t status = mpClientInterface->createAudioPatch(&patch,
Eric Laurent6a94d692014-05-20 11:18:06 -07005006 &afPatchHandle,
Eric Laurent1c333e22014-05-20 10:48:17 -07005007 0);
5008 ALOGV("setInputDevice() createAudioPatch returned %d patchHandle %d",
Eric Laurent6a94d692014-05-20 11:18:06 -07005009 status, afPatchHandle);
Eric Laurent1c333e22014-05-20 10:48:17 -07005010 if (status == NO_ERROR) {
Eric Laurent6a94d692014-05-20 11:18:06 -07005011 if (index < 0) {
François Gaffie98cc1912015-03-18 17:52:40 +01005012 patchDesc = new AudioPatch(&patch, mUidCached);
Eric Laurent6a94d692014-05-20 11:18:06 -07005013 addAudioPatch(patchDesc->mHandle, patchDesc);
5014 } else {
5015 patchDesc->mPatch = patch;
5016 }
5017 patchDesc->mAfPatchHandle = afPatchHandle;
Eric Laurent6a94d692014-05-20 11:18:06 -07005018 if (patchHandle) {
5019 *patchHandle = patchDesc->mHandle;
5020 }
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08005021 inputDesc->setPatchHandle(patchDesc->mHandle);
Eric Laurent6a94d692014-05-20 11:18:06 -07005022 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07005023 mpClientInterface->onAudioPatchListUpdate();
Eric Laurent1c333e22014-05-20 10:48:17 -07005024 }
5025 }
5026 }
5027 return status;
5028}
5029
Eric Laurent6a94d692014-05-20 11:18:06 -07005030status_t AudioPolicyManager::resetInputDevice(audio_io_handle_t input,
5031 audio_patch_handle_t *patchHandle)
Eric Laurent1c333e22014-05-20 10:48:17 -07005032{
Eric Laurent1f2f2232014-06-02 12:01:23 -07005033 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
Eric Laurent6a94d692014-05-20 11:18:06 -07005034 ssize_t index;
5035 if (patchHandle) {
5036 index = mAudioPatches.indexOfKey(*patchHandle);
5037 } else {
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08005038 index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07005039 }
5040 if (index < 0) {
Eric Laurent1c333e22014-05-20 10:48:17 -07005041 return INVALID_OPERATION;
5042 }
Eric Laurent6a94d692014-05-20 11:18:06 -07005043 sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index);
5044 status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
Eric Laurent1c333e22014-05-20 10:48:17 -07005045 ALOGV("resetInputDevice() releaseAudioPatch returned %d", status);
Glenn Kastena13cde92016-03-28 15:26:02 -07005046 inputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
Eric Laurent6a94d692014-05-20 11:18:06 -07005047 removeAudioPatch(patchDesc->mHandle);
5048 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07005049 mpClientInterface->onAudioPatchListUpdate();
Eric Laurent1c333e22014-05-20 10:48:17 -07005050 return status;
5051}
5052
Jean-Michel Trivi56ec4ff2015-01-23 16:45:18 -08005053sp<IOProfile> AudioPolicyManager::getInputProfile(audio_devices_t device,
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07005054 const String8& address,
François Gaffie53615e22015-03-19 09:24:12 +01005055 uint32_t& samplingRate,
Andy Hungf129b032015-04-07 13:45:50 -07005056 audio_format_t& format,
5057 audio_channel_mask_t& channelMask,
François Gaffie53615e22015-03-19 09:24:12 +01005058 audio_input_flags_t flags)
Eric Laurente552edb2014-03-10 17:42:56 -07005059{
5060 // Choose an input profile based on the requested capture parameters: select the first available
5061 // profile supporting all requested parameters.
Andy Hungf129b032015-04-07 13:45:50 -07005062 //
5063 // TODO: perhaps isCompatibleProfile should return a "matching" score so we can return
5064 // the best matching profile, not the first one.
Eric Laurente552edb2014-03-10 17:42:56 -07005065
Glenn Kasten730b9262018-03-29 15:01:26 -07005066 sp<IOProfile> firstInexact;
5067 uint32_t updatedSamplingRate = 0;
5068 audio_format_t updatedFormat = AUDIO_FORMAT_INVALID;
5069 audio_channel_mask_t updatedChannelMask = AUDIO_CHANNEL_INVALID;
Mikhail Naganov7e22e942017-12-07 10:04:29 -08005070 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08005071 for (const auto& profile : hwModule->getInputProfiles()) {
Eric Laurentd4692962014-05-05 18:13:44 -07005072 // profile->log();
Glenn Kasten730b9262018-03-29 15:01:26 -07005073 //updatedFormat = format;
Eric Laurent275e8e92014-11-30 15:14:47 -08005074 if (profile->isCompatibleProfile(device, address, samplingRate,
Glenn Kasten730b9262018-03-29 15:01:26 -07005075 &samplingRate /*updatedSamplingRate*/,
Andy Hungf129b032015-04-07 13:45:50 -07005076 format,
Glenn Kasten730b9262018-03-29 15:01:26 -07005077 &format, /*updatedFormat*/
Andy Hungf129b032015-04-07 13:45:50 -07005078 channelMask,
Glenn Kasten730b9262018-03-29 15:01:26 -07005079 &channelMask /*updatedChannelMask*/,
5080 // FIXME ugly cast
5081 (audio_output_flags_t) flags,
5082 true /*exactMatchRequiredForInputFlags*/)) {
Eric Laurente552edb2014-03-10 17:42:56 -07005083 return profile;
5084 }
Glenn Kasten730b9262018-03-29 15:01:26 -07005085 if (firstInexact == nullptr && profile->isCompatibleProfile(device, address,
5086 samplingRate,
5087 &updatedSamplingRate,
5088 format,
5089 &updatedFormat,
5090 channelMask,
5091 &updatedChannelMask,
5092 // FIXME ugly cast
5093 (audio_output_flags_t) flags,
5094 false /*exactMatchRequiredForInputFlags*/)) {
5095 firstInexact = profile;
5096 }
5097
Eric Laurente552edb2014-03-10 17:42:56 -07005098 }
5099 }
Glenn Kasten730b9262018-03-29 15:01:26 -07005100 if (firstInexact != nullptr) {
5101 samplingRate = updatedSamplingRate;
5102 format = updatedFormat;
5103 channelMask = updatedChannelMask;
5104 return firstInexact;
5105 }
Eric Laurente552edb2014-03-10 17:42:56 -07005106 return NULL;
5107}
5108
Eric Laurentc73ca6e2014-12-12 14:34:22 -08005109
5110audio_devices_t AudioPolicyManager::getDeviceAndMixForInputSource(audio_source_t inputSource,
François Gaffie53615e22015-03-19 09:24:12 +01005111 AudioMix **policyMix)
Eric Laurente552edb2014-03-10 17:42:56 -07005112{
François Gaffie036e1e92015-03-19 10:16:24 +01005113 audio_devices_t availableDeviceTypes = mAvailableInputDevices.types() & ~AUDIO_DEVICE_BIT_IN;
5114 audio_devices_t selectedDeviceFromMix =
5115 mPolicyMixes.getDeviceAndMixForInputSource(inputSource, availableDeviceTypes, policyMix);
Eric Laurent275e8e92014-11-30 15:14:47 -08005116
François Gaffie036e1e92015-03-19 10:16:24 +01005117 if (selectedDeviceFromMix != AUDIO_DEVICE_NONE) {
5118 return selectedDeviceFromMix;
Eric Laurent275e8e92014-11-30 15:14:47 -08005119 }
Eric Laurentc73ca6e2014-12-12 14:34:22 -08005120 return getDeviceForInputSource(inputSource);
5121}
5122
5123audio_devices_t AudioPolicyManager::getDeviceForInputSource(audio_source_t inputSource)
5124{
Eric Laurentad2e7b92017-09-14 20:06:42 -07005125 // Routing
5126 // Scan the whole RouteMap to see if we have an explicit route:
5127 // if the input source in the RouteMap is the same as the argument above,
5128 // and activity count is non-zero and the device in the route descriptor is available
5129 // then select this device.
Paul McLean466dc8e2015-04-17 13:15:36 -06005130 for (size_t routeIndex = 0; routeIndex < mInputRoutes.size(); routeIndex++) {
5131 sp<SessionRoute> route = mInputRoutes.valueAt(routeIndex);
Eric Laurentad2e7b92017-09-14 20:06:42 -07005132 if ((inputSource == route->mSource) && route->isActive() &&
5133 (mAvailableInputDevices.indexOf(route->mDeviceDescriptor) >= 0)) {
Paul McLean466dc8e2015-04-17 13:15:36 -06005134 return route->mDeviceDescriptor->type();
5135 }
5136 }
5137
5138 return mEngine->getDeviceForInputSource(inputSource);
Eric Laurente552edb2014-03-10 17:42:56 -07005139}
5140
Eric Laurente0720872014-03-11 09:30:41 -07005141float AudioPolicyManager::computeVolume(audio_stream_type_t stream,
François Gaffied1ab2bd2015-12-02 18:20:06 +01005142 int index,
5143 audio_devices_t device)
Eric Laurente552edb2014-03-10 17:42:56 -07005144{
Jean-Michel Trivi00a20962016-05-25 19:11:01 -07005145 float volumeDB = mVolumeCurves->volIndexToDb(stream, Volume::getDeviceCategory(device), index);
Jean-Michel Trivi3d8b4a42016-09-14 18:37:46 -07005146
5147 // handle the case of accessibility active while a ringtone is playing: if the ringtone is much
5148 // louder than the accessibility prompt, the prompt cannot be heard, thus masking the touch
5149 // exploration of the dialer UI. In this situation, bring the accessibility volume closer to
5150 // the ringtone volume
5151 if ((stream == AUDIO_STREAM_ACCESSIBILITY)
5152 && (AUDIO_MODE_RINGTONE == mEngine->getPhoneState())
5153 && isStreamActive(AUDIO_STREAM_RING, 0)) {
5154 const float ringVolumeDB = computeVolume(AUDIO_STREAM_RING, index, device);
5155 return ringVolumeDB - 4 > volumeDB ? ringVolumeDB - 4 : volumeDB;
5156 }
5157
Jean-Michel Trivi719a9872017-08-05 13:51:35 -07005158 // in-call: always cap earpiece volume by voice volume + some low headroom
Eric Laurent7731b5a2018-04-06 15:47:22 -07005159 if ((stream != AUDIO_STREAM_VOICE_CALL) && (device & AUDIO_DEVICE_OUT_EARPIECE) &&
5160 (isInCall() || mOutputs.isStreamActiveLocally(AUDIO_STREAM_VOICE_CALL))) {
Jean-Michel Trivi719a9872017-08-05 13:51:35 -07005161 switch (stream) {
5162 case AUDIO_STREAM_SYSTEM:
5163 case AUDIO_STREAM_RING:
5164 case AUDIO_STREAM_MUSIC:
5165 case AUDIO_STREAM_ALARM:
5166 case AUDIO_STREAM_NOTIFICATION:
5167 case AUDIO_STREAM_ENFORCED_AUDIBLE:
5168 case AUDIO_STREAM_DTMF:
5169 case AUDIO_STREAM_ACCESSIBILITY: {
Eric Laurent7731b5a2018-04-06 15:47:22 -07005170 int voiceVolumeIndex =
5171 mVolumeCurves->getVolumeIndex(AUDIO_STREAM_VOICE_CALL, AUDIO_DEVICE_OUT_EARPIECE);
5172 const float maxVoiceVolDb =
5173 computeVolume(AUDIO_STREAM_VOICE_CALL, voiceVolumeIndex, AUDIO_DEVICE_OUT_EARPIECE)
5174 + IN_CALL_EARPIECE_HEADROOM_DB;
Jean-Michel Trivi719a9872017-08-05 13:51:35 -07005175 if (volumeDB > maxVoiceVolDb) {
5176 ALOGV("computeVolume() stream %d at vol=%f overriden by stream %d at vol=%f",
5177 stream, volumeDB, AUDIO_STREAM_VOICE_CALL, maxVoiceVolDb);
5178 volumeDB = maxVoiceVolDb;
5179 }
5180 } break;
5181 default:
5182 break;
5183 }
5184 }
5185
Eric Laurente552edb2014-03-10 17:42:56 -07005186 // if a headset is connected, apply the following rules to ring tones and notifications
5187 // to avoid sound level bursts in user's ears:
Eric Laurent6af1c1d2016-04-14 11:20:44 -07005188 // - always attenuate notifications volume by 6dB
5189 // - attenuate ring tones volume by 6dB unless music is not playing and
5190 // speaker is part of the select devices
Eric Laurente552edb2014-03-10 17:42:56 -07005191 // - if music is playing, always limit the volume to current music volume,
5192 // with a minimum threshold at -36dB so that notification is always perceived.
Eric Laurent3b73df72014-03-11 09:06:29 -07005193 const routing_strategy stream_strategy = getStrategy(stream);
Eric Laurente552edb2014-03-10 17:42:56 -07005194 if ((device & (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
5195 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
5196 AUDIO_DEVICE_OUT_WIRED_HEADSET |
Eric Laurent904d6322017-03-17 17:20:47 -07005197 AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
Jakub Pawlowski00f928c2018-03-22 13:20:03 -07005198 AUDIO_DEVICE_OUT_USB_HEADSET |
5199 AUDIO_DEVICE_OUT_HEARING_AID)) &&
Eric Laurente552edb2014-03-10 17:42:56 -07005200 ((stream_strategy == STRATEGY_SONIFICATION)
5201 || (stream_strategy == STRATEGY_SONIFICATION_RESPECTFUL)
Eric Laurent3b73df72014-03-11 09:06:29 -07005202 || (stream == AUDIO_STREAM_SYSTEM)
Eric Laurente552edb2014-03-10 17:42:56 -07005203 || ((stream_strategy == STRATEGY_ENFORCED_AUDIBLE) &&
François Gaffie2110e042015-03-24 08:41:51 +01005204 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_NONE))) &&
François Gaffied1ab2bd2015-12-02 18:20:06 +01005205 mVolumeCurves->canBeMuted(stream)) {
Eric Laurente552edb2014-03-10 17:42:56 -07005206 // when the phone is ringing we must consider that music could have been paused just before
5207 // by the music application and behave as if music was active if the last music track was
5208 // just stopped
Eric Laurent3b73df72014-03-11 09:06:29 -07005209 if (isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY) ||
Eric Laurente552edb2014-03-10 17:42:56 -07005210 mLimitRingtoneVolume) {
Jean-Michel Trivi00a20962016-05-25 19:11:01 -07005211 volumeDB += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
Eric Laurente552edb2014-03-10 17:42:56 -07005212 audio_devices_t musicDevice = getDeviceForStrategy(STRATEGY_MEDIA, true /*fromCache*/);
Eric Laurentffbc80f2015-03-18 18:30:19 -07005213 float musicVolDB = computeVolume(AUDIO_STREAM_MUSIC,
François Gaffied1ab2bd2015-12-02 18:20:06 +01005214 mVolumeCurves->getVolumeIndex(AUDIO_STREAM_MUSIC,
5215 musicDevice),
5216 musicDevice);
Eric Laurentffbc80f2015-03-18 18:30:19 -07005217 float minVolDB = (musicVolDB > SONIFICATION_HEADSET_VOLUME_MIN_DB) ?
5218 musicVolDB : SONIFICATION_HEADSET_VOLUME_MIN_DB;
Jean-Michel Trivi00a20962016-05-25 19:11:01 -07005219 if (volumeDB > minVolDB) {
5220 volumeDB = minVolDB;
Eric Laurentffbc80f2015-03-18 18:30:19 -07005221 ALOGV("computeVolume limiting volume to %f musicVol %f", minVolDB, musicVolDB);
Eric Laurente552edb2014-03-10 17:42:56 -07005222 }
Jean-Michel Trivi00a20962016-05-25 19:11:01 -07005223 if (device & (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
5224 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES)) {
5225 // on A2DP, also ensure notification volume is not too low compared to media when
5226 // intended to be played
5227 if ((volumeDB > -96.0f) &&
5228 (musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB > volumeDB)) {
5229 ALOGV("computeVolume increasing volume for stream=%d device=0x%X from %f to %f",
5230 stream, device,
5231 volumeDB, musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB);
5232 volumeDB = musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB;
5233 }
5234 }
Eric Laurent6af1c1d2016-04-14 11:20:44 -07005235 } else if ((Volume::getDeviceForVolume(device) != AUDIO_DEVICE_OUT_SPEAKER) ||
5236 stream_strategy != STRATEGY_SONIFICATION) {
Jean-Michel Trivi00a20962016-05-25 19:11:01 -07005237 volumeDB += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
Eric Laurente552edb2014-03-10 17:42:56 -07005238 }
5239 }
5240
Jean-Michel Trivi00a20962016-05-25 19:11:01 -07005241 return volumeDB;
Eric Laurente552edb2014-03-10 17:42:56 -07005242}
5243
Eric Laurente0720872014-03-11 09:30:41 -07005244status_t AudioPolicyManager::checkAndSetVolume(audio_stream_type_t stream,
Eric Laurentc75307b2015-03-17 15:29:32 -07005245 int index,
5246 const sp<AudioOutputDescriptor>& outputDesc,
5247 audio_devices_t device,
5248 int delayMs,
5249 bool force)
Eric Laurente552edb2014-03-10 17:42:56 -07005250{
Eric Laurente552edb2014-03-10 17:42:56 -07005251 // do not change actual stream volume if the stream is muted
Eric Laurentc75307b2015-03-17 15:29:32 -07005252 if (outputDesc->mMuteCount[stream] != 0) {
Eric Laurente552edb2014-03-10 17:42:56 -07005253 ALOGVV("checkAndSetVolume() stream %d muted count %d",
Eric Laurentc75307b2015-03-17 15:29:32 -07005254 stream, outputDesc->mMuteCount[stream]);
Eric Laurente552edb2014-03-10 17:42:56 -07005255 return NO_ERROR;
5256 }
François Gaffie2110e042015-03-24 08:41:51 +01005257 audio_policy_forced_cfg_t forceUseForComm =
5258 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION);
Eric Laurente552edb2014-03-10 17:42:56 -07005259 // do not change in call volume if bluetooth is connected and vice versa
François Gaffie2110e042015-03-24 08:41:51 +01005260 if ((stream == AUDIO_STREAM_VOICE_CALL && forceUseForComm == AUDIO_POLICY_FORCE_BT_SCO) ||
5261 (stream == AUDIO_STREAM_BLUETOOTH_SCO && forceUseForComm != AUDIO_POLICY_FORCE_BT_SCO)) {
Eric Laurente552edb2014-03-10 17:42:56 -07005262 ALOGV("checkAndSetVolume() cannot set stream %d volume with force use = %d for comm",
François Gaffie2110e042015-03-24 08:41:51 +01005263 stream, forceUseForComm);
Eric Laurente552edb2014-03-10 17:42:56 -07005264 return INVALID_OPERATION;
5265 }
5266
Eric Laurentc75307b2015-03-17 15:29:32 -07005267 if (device == AUDIO_DEVICE_NONE) {
5268 device = outputDesc->device();
5269 }
Eric Laurent275e8e92014-11-30 15:14:47 -08005270
Eric Laurentffbc80f2015-03-18 18:30:19 -07005271 float volumeDb = computeVolume(stream, index, device);
Eric Laurentc75307b2015-03-17 15:29:32 -07005272 if (outputDesc->isFixedVolume(device)) {
Eric Laurentffbc80f2015-03-18 18:30:19 -07005273 volumeDb = 0.0f;
Eric Laurent275e8e92014-11-30 15:14:47 -08005274 }
Eric Laurentc75307b2015-03-17 15:29:32 -07005275
Eric Laurentffbc80f2015-03-18 18:30:19 -07005276 outputDesc->setVolume(volumeDb, stream, device, delayMs, force);
Eric Laurente552edb2014-03-10 17:42:56 -07005277
Eric Laurent3b73df72014-03-11 09:06:29 -07005278 if (stream == AUDIO_STREAM_VOICE_CALL ||
5279 stream == AUDIO_STREAM_BLUETOOTH_SCO) {
Eric Laurente552edb2014-03-10 17:42:56 -07005280 float voiceVolume;
5281 // Force voice volume to max for bluetooth SCO as volume is managed by the headset
Eric Laurent3b73df72014-03-11 09:06:29 -07005282 if (stream == AUDIO_STREAM_VOICE_CALL) {
François Gaffied1ab2bd2015-12-02 18:20:06 +01005283 voiceVolume = (float)index/(float)mVolumeCurves->getVolumeIndexMax(stream);
Eric Laurente552edb2014-03-10 17:42:56 -07005284 } else {
5285 voiceVolume = 1.0;
5286 }
5287
Eric Laurent18fba842016-03-31 14:41:26 -07005288 if (voiceVolume != mLastVoiceVolume) {
Eric Laurente552edb2014-03-10 17:42:56 -07005289 mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
5290 mLastVoiceVolume = voiceVolume;
5291 }
5292 }
5293
5294 return NO_ERROR;
5295}
5296
Eric Laurentc75307b2015-03-17 15:29:32 -07005297void AudioPolicyManager::applyStreamVolumes(const sp<AudioOutputDescriptor>& outputDesc,
5298 audio_devices_t device,
5299 int delayMs,
5300 bool force)
Eric Laurente552edb2014-03-10 17:42:56 -07005301{
Eric Laurentc75307b2015-03-17 15:29:32 -07005302 ALOGVV("applyStreamVolumes() for device %08x", device);
Eric Laurente552edb2014-03-10 17:42:56 -07005303
Eric Laurent794fde22016-03-11 09:50:45 -08005304 for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) {
Eric Laurent3b73df72014-03-11 09:06:29 -07005305 checkAndSetVolume((audio_stream_type_t)stream,
François Gaffied1ab2bd2015-12-02 18:20:06 +01005306 mVolumeCurves->getVolumeIndex((audio_stream_type_t)stream, device),
Eric Laurentc75307b2015-03-17 15:29:32 -07005307 outputDesc,
Eric Laurente552edb2014-03-10 17:42:56 -07005308 device,
5309 delayMs,
5310 force);
5311 }
5312}
5313
Eric Laurente0720872014-03-11 09:30:41 -07005314void AudioPolicyManager::setStrategyMute(routing_strategy strategy,
Eric Laurentc75307b2015-03-17 15:29:32 -07005315 bool on,
5316 const sp<AudioOutputDescriptor>& outputDesc,
5317 int delayMs,
5318 audio_devices_t device)
Eric Laurente552edb2014-03-10 17:42:56 -07005319{
Eric Laurent72249d52015-06-08 11:12:15 -07005320 ALOGVV("setStrategyMute() strategy %d, mute %d, output ID %d",
5321 strategy, on, outputDesc->getId());
Eric Laurent794fde22016-03-11 09:50:45 -08005322 for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) {
Eric Laurent3b73df72014-03-11 09:06:29 -07005323 if (getStrategy((audio_stream_type_t)stream) == strategy) {
Eric Laurentc75307b2015-03-17 15:29:32 -07005324 setStreamMute((audio_stream_type_t)stream, on, outputDesc, delayMs, device);
Eric Laurente552edb2014-03-10 17:42:56 -07005325 }
5326 }
5327}
5328
Eric Laurente0720872014-03-11 09:30:41 -07005329void AudioPolicyManager::setStreamMute(audio_stream_type_t stream,
Eric Laurentc75307b2015-03-17 15:29:32 -07005330 bool on,
5331 const sp<AudioOutputDescriptor>& outputDesc,
5332 int delayMs,
5333 audio_devices_t device)
Eric Laurente552edb2014-03-10 17:42:56 -07005334{
Eric Laurente552edb2014-03-10 17:42:56 -07005335 if (device == AUDIO_DEVICE_NONE) {
5336 device = outputDesc->device();
5337 }
5338
Eric Laurentc75307b2015-03-17 15:29:32 -07005339 ALOGVV("setStreamMute() stream %d, mute %d, mMuteCount %d device %04x",
5340 stream, on, outputDesc->mMuteCount[stream], device);
Eric Laurente552edb2014-03-10 17:42:56 -07005341
5342 if (on) {
5343 if (outputDesc->mMuteCount[stream] == 0) {
François Gaffied1ab2bd2015-12-02 18:20:06 +01005344 if (mVolumeCurves->canBeMuted(stream) &&
Eric Laurent3b73df72014-03-11 09:06:29 -07005345 ((stream != AUDIO_STREAM_ENFORCED_AUDIBLE) ||
François Gaffie2110e042015-03-24 08:41:51 +01005346 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_NONE))) {
Eric Laurentc75307b2015-03-17 15:29:32 -07005347 checkAndSetVolume(stream, 0, outputDesc, device, delayMs);
Eric Laurente552edb2014-03-10 17:42:56 -07005348 }
5349 }
5350 // increment mMuteCount after calling checkAndSetVolume() so that volume change is not ignored
5351 outputDesc->mMuteCount[stream]++;
5352 } else {
5353 if (outputDesc->mMuteCount[stream] == 0) {
5354 ALOGV("setStreamMute() unmuting non muted stream!");
5355 return;
5356 }
5357 if (--outputDesc->mMuteCount[stream] == 0) {
5358 checkAndSetVolume(stream,
François Gaffied1ab2bd2015-12-02 18:20:06 +01005359 mVolumeCurves->getVolumeIndex(stream, device),
Eric Laurentc75307b2015-03-17 15:29:32 -07005360 outputDesc,
Eric Laurente552edb2014-03-10 17:42:56 -07005361 device,
5362 delayMs);
5363 }
5364 }
5365}
5366
Eric Laurente0720872014-03-11 09:30:41 -07005367void AudioPolicyManager::handleIncallSonification(audio_stream_type_t stream,
Eric Laurent3b73df72014-03-11 09:06:29 -07005368 bool starting, bool stateChange)
Eric Laurente552edb2014-03-10 17:42:56 -07005369{
Eric Laurent87ffa392015-05-22 10:32:38 -07005370 if(!hasPrimaryOutput()) {
5371 return;
5372 }
5373
Eric Laurente552edb2014-03-10 17:42:56 -07005374 // if the stream pertains to sonification strategy and we are in call we must
5375 // mute the stream if it is low visibility. If it is high visibility, we must play a tone
5376 // in the device used for phone strategy and play the tone if the selected device does not
5377 // interfere with the device used for phone strategy
5378 // if stateChange is true, we are called from setPhoneState() and we must mute or unmute as
5379 // many times as there are active tracks on the output
Eric Laurent3b73df72014-03-11 09:06:29 -07005380 const routing_strategy stream_strategy = getStrategy(stream);
Eric Laurente552edb2014-03-10 17:42:56 -07005381 if ((stream_strategy == STRATEGY_SONIFICATION) ||
5382 ((stream_strategy == STRATEGY_SONIFICATION_RESPECTFUL))) {
Eric Laurentc75307b2015-03-17 15:29:32 -07005383 sp<SwAudioOutputDescriptor> outputDesc = mPrimaryOutput;
Eric Laurente552edb2014-03-10 17:42:56 -07005384 ALOGV("handleIncallSonification() stream %d starting %d device %x stateChange %d",
5385 stream, starting, outputDesc->mDevice, stateChange);
5386 if (outputDesc->mRefCount[stream]) {
5387 int muteCount = 1;
5388 if (stateChange) {
5389 muteCount = outputDesc->mRefCount[stream];
5390 }
Eric Laurent3b73df72014-03-11 09:06:29 -07005391 if (audio_is_low_visibility(stream)) {
Eric Laurente552edb2014-03-10 17:42:56 -07005392 ALOGV("handleIncallSonification() low visibility, muteCount %d", muteCount);
5393 for (int i = 0; i < muteCount; i++) {
5394 setStreamMute(stream, starting, mPrimaryOutput);
5395 }
5396 } else {
5397 ALOGV("handleIncallSonification() high visibility");
5398 if (outputDesc->device() &
5399 getDeviceForStrategy(STRATEGY_PHONE, true /*fromCache*/)) {
5400 ALOGV("handleIncallSonification() high visibility muted, muteCount %d", muteCount);
5401 for (int i = 0; i < muteCount; i++) {
5402 setStreamMute(stream, starting, mPrimaryOutput);
5403 }
5404 }
5405 if (starting) {
Eric Laurent3b73df72014-03-11 09:06:29 -07005406 mpClientInterface->startTone(AUDIO_POLICY_TONE_IN_CALL_NOTIFICATION,
5407 AUDIO_STREAM_VOICE_CALL);
Eric Laurente552edb2014-03-10 17:42:56 -07005408 } else {
5409 mpClientInterface->stopTone();
5410 }
5411 }
5412 }
5413 }
5414}
5415
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07005416audio_stream_type_t AudioPolicyManager::streamTypefromAttributesInt(const audio_attributes_t *attr)
5417{
5418 // flags to stream type mapping
5419 if ((attr->flags & AUDIO_FLAG_AUDIBILITY_ENFORCED) == AUDIO_FLAG_AUDIBILITY_ENFORCED) {
5420 return AUDIO_STREAM_ENFORCED_AUDIBLE;
5421 }
5422 if ((attr->flags & AUDIO_FLAG_SCO) == AUDIO_FLAG_SCO) {
5423 return AUDIO_STREAM_BLUETOOTH_SCO;
5424 }
Jean-Michel Trivi79ad4382015-01-29 10:49:39 -08005425 if ((attr->flags & AUDIO_FLAG_BEACON) == AUDIO_FLAG_BEACON) {
5426 return AUDIO_STREAM_TTS;
5427 }
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07005428
5429 // usage to stream type mapping
5430 switch (attr->usage) {
5431 case AUDIO_USAGE_MEDIA:
5432 case AUDIO_USAGE_GAME:
Jean-Michel Trivi36867762016-12-29 12:03:28 -08005433 case AUDIO_USAGE_ASSISTANT:
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07005434 case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
5435 return AUDIO_STREAM_MUSIC;
Eric Laurent223fd5c2014-11-11 13:43:36 -08005436 case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
5437 return AUDIO_STREAM_ACCESSIBILITY;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07005438 case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
5439 return AUDIO_STREAM_SYSTEM;
5440 case AUDIO_USAGE_VOICE_COMMUNICATION:
5441 return AUDIO_STREAM_VOICE_CALL;
5442
5443 case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
5444 return AUDIO_STREAM_DTMF;
5445
5446 case AUDIO_USAGE_ALARM:
5447 return AUDIO_STREAM_ALARM;
5448 case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
5449 return AUDIO_STREAM_RING;
5450
5451 case AUDIO_USAGE_NOTIFICATION:
5452 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
5453 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
5454 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
5455 case AUDIO_USAGE_NOTIFICATION_EVENT:
5456 return AUDIO_STREAM_NOTIFICATION;
5457
5458 case AUDIO_USAGE_UNKNOWN:
5459 default:
5460 return AUDIO_STREAM_MUSIC;
5461 }
5462}
Eric Laurente83b55d2014-11-14 10:06:21 -08005463
François Gaffie53615e22015-03-19 09:24:12 +01005464bool AudioPolicyManager::isValidAttributes(const audio_attributes_t *paa)
5465{
Eric Laurente83b55d2014-11-14 10:06:21 -08005466 // has flags that map to a strategy?
5467 if ((paa->flags & (AUDIO_FLAG_AUDIBILITY_ENFORCED | AUDIO_FLAG_SCO | AUDIO_FLAG_BEACON)) != 0) {
5468 return true;
5469 }
5470
5471 // has known usage?
5472 switch (paa->usage) {
5473 case AUDIO_USAGE_UNKNOWN:
5474 case AUDIO_USAGE_MEDIA:
5475 case AUDIO_USAGE_VOICE_COMMUNICATION:
5476 case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
5477 case AUDIO_USAGE_ALARM:
5478 case AUDIO_USAGE_NOTIFICATION:
5479 case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
5480 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
5481 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
5482 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
5483 case AUDIO_USAGE_NOTIFICATION_EVENT:
5484 case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
5485 case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
5486 case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
5487 case AUDIO_USAGE_GAME:
Eric Laurent275e8e92014-11-30 15:14:47 -08005488 case AUDIO_USAGE_VIRTUAL_SOURCE:
Jean-Michel Trivi36867762016-12-29 12:03:28 -08005489 case AUDIO_USAGE_ASSISTANT:
Eric Laurente83b55d2014-11-14 10:06:21 -08005490 break;
5491 default:
5492 return false;
5493 }
5494 return true;
5495}
5496
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07005497bool AudioPolicyManager::isStrategyActive(const sp<AudioOutputDescriptor>& outputDesc,
François Gaffiead3183e2015-03-18 16:55:35 +01005498 routing_strategy strategy, uint32_t inPastMs,
5499 nsecs_t sysTime) const
5500{
5501 if ((sysTime == 0) && (inPastMs != 0)) {
5502 sysTime = systemTime();
5503 }
Eric Laurent794fde22016-03-11 09:50:45 -08005504 for (int i = 0; i < (int)AUDIO_STREAM_FOR_POLICY_CNT; i++) {
François Gaffiead3183e2015-03-18 16:55:35 +01005505 if (((getStrategy((audio_stream_type_t)i) == strategy) ||
5506 (NUM_STRATEGIES == strategy)) &&
5507 outputDesc->isStreamActive((audio_stream_type_t)i, inPastMs, sysTime)) {
5508 return true;
5509 }
5510 }
5511 return false;
5512}
5513
François Gaffie2110e042015-03-24 08:41:51 +01005514audio_policy_forced_cfg_t AudioPolicyManager::getForceUse(audio_policy_force_use_t usage)
5515{
5516 return mEngine->getForceUse(usage);
5517}
5518
5519bool AudioPolicyManager::isInCall()
5520{
5521 return isStateInCall(mEngine->getPhoneState());
5522}
5523
5524bool AudioPolicyManager::isStateInCall(int state)
5525{
5526 return is_state_in_call(state);
5527}
5528
Eric Laurentd60560a2015-04-10 11:31:20 -07005529void AudioPolicyManager::cleanUpForDevice(const sp<DeviceDescriptor>& deviceDesc)
5530{
5531 for (ssize_t i = (ssize_t)mAudioSources.size() - 1; i >= 0; i--) {
5532 sp<AudioSourceDescriptor> sourceDesc = mAudioSources.valueAt(i);
5533 if (sourceDesc->mDevice->equals(deviceDesc)) {
5534 ALOGV("%s releasing audio source %d", __FUNCTION__, sourceDesc->getHandle());
5535 stopAudioSource(sourceDesc->getHandle());
5536 }
5537 }
5538
5539 for (ssize_t i = (ssize_t)mAudioPatches.size() - 1; i >= 0; i--) {
5540 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(i);
5541 bool release = false;
5542 for (size_t j = 0; j < patchDesc->mPatch.num_sources && !release; j++) {
5543 const struct audio_port_config *source = &patchDesc->mPatch.sources[j];
5544 if (source->type == AUDIO_PORT_TYPE_DEVICE &&
5545 source->ext.device.type == deviceDesc->type()) {
5546 release = true;
5547 }
5548 }
5549 for (size_t j = 0; j < patchDesc->mPatch.num_sinks && !release; j++) {
5550 const struct audio_port_config *sink = &patchDesc->mPatch.sinks[j];
5551 if (sink->type == AUDIO_PORT_TYPE_DEVICE &&
5552 sink->ext.device.type == deviceDesc->type()) {
5553 release = true;
5554 }
5555 }
5556 if (release) {
5557 ALOGV("%s releasing patch %u", __FUNCTION__, patchDesc->mHandle);
5558 releaseAudioPatch(patchDesc->mHandle, patchDesc->mUid);
5559 }
5560 }
5561}
5562
Phil Burk09bc4612016-02-24 15:58:15 -08005563// Modify the list of surround sound formats supported.
Phil Burk0709b0a2016-03-31 12:54:57 -07005564void AudioPolicyManager::filterSurroundFormats(FormatVector *formatsPtr) {
5565 FormatVector &formats = *formatsPtr;
Phil Burk07ac1142016-03-25 13:39:29 -07005566 // TODO Set this based on Config properties.
5567 const bool alwaysForceAC3 = true;
Phil Burk09bc4612016-02-24 15:58:15 -08005568
5569 audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
5570 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
Phil Burk0709b0a2016-03-31 12:54:57 -07005571 ALOGD("%s: forced use = %d", __FUNCTION__, forceUse);
Phil Burk09bc4612016-02-24 15:58:15 -08005572
5573 // Analyze original support for various formats.
Phil Burk07ac1142016-03-25 13:39:29 -07005574 bool supportsAC3 = false;
5575 bool supportsOtherSurround = false;
Phil Burk09bc4612016-02-24 15:58:15 -08005576 bool supportsIEC61937 = false;
Mikhail Naganovcf84e592017-12-07 11:25:11 -08005577 for (ssize_t formatIndex = 0; formatIndex < (ssize_t)formats.size(); formatIndex++) {
Phil Burk09bc4612016-02-24 15:58:15 -08005578 audio_format_t format = formats[formatIndex];
Phil Burk09bc4612016-02-24 15:58:15 -08005579 switch (format) {
5580 case AUDIO_FORMAT_AC3:
Phil Burk07ac1142016-03-25 13:39:29 -07005581 supportsAC3 = true;
5582 break;
Phil Burk09bc4612016-02-24 15:58:15 -08005583 case AUDIO_FORMAT_E_AC3:
5584 case AUDIO_FORMAT_DTS:
5585 case AUDIO_FORMAT_DTS_HD:
jiabindd601152017-11-27 14:53:37 -08005586 // If ALWAYS, remove all other surround formats here since we will add them later.
5587 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS) {
5588 formats.removeAt(formatIndex);
5589 formatIndex--;
5590 }
Phil Burk07ac1142016-03-25 13:39:29 -07005591 supportsOtherSurround = true;
Phil Burk09bc4612016-02-24 15:58:15 -08005592 break;
5593 case AUDIO_FORMAT_IEC61937:
5594 supportsIEC61937 = true;
5595 break;
5596 default:
5597 break;
5598 }
5599 }
Phil Burk09bc4612016-02-24 15:58:15 -08005600
5601 // Modify formats based on surround preferences.
5602 // If NEVER, remove support for surround formats.
Phil Burk07ac1142016-03-25 13:39:29 -07005603 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) {
5604 if (supportsAC3 || supportsOtherSurround || supportsIEC61937) {
5605 // Remove surround sound related formats.
5606 for (size_t formatIndex = 0; formatIndex < formats.size(); ) {
5607 audio_format_t format = formats[formatIndex];
5608 switch(format) {
5609 case AUDIO_FORMAT_AC3:
5610 case AUDIO_FORMAT_E_AC3:
5611 case AUDIO_FORMAT_DTS:
5612 case AUDIO_FORMAT_DTS_HD:
5613 case AUDIO_FORMAT_IEC61937:
Phil Burk07ac1142016-03-25 13:39:29 -07005614 formats.removeAt(formatIndex);
5615 break;
5616 default:
5617 formatIndex++; // keep it
5618 break;
5619 }
Phil Burk09bc4612016-02-24 15:58:15 -08005620 }
Phil Burk07ac1142016-03-25 13:39:29 -07005621 supportsAC3 = false;
5622 supportsOtherSurround = false;
5623 supportsIEC61937 = false;
Phil Burk09bc4612016-02-24 15:58:15 -08005624 }
Phil Burk07ac1142016-03-25 13:39:29 -07005625 } else { // AUTO or ALWAYS
5626 // Most TVs support AC3 even if they do not report it in the EDID.
5627 if ((alwaysForceAC3 || (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS))
5628 && !supportsAC3) {
5629 formats.add(AUDIO_FORMAT_AC3);
5630 supportsAC3 = true;
5631 }
5632
5633 // If ALWAYS, add support for raw surround formats if all are missing.
5634 // This assumes that if any of these formats are reported by the HAL
5635 // then the report is valid and should not be modified.
jiabindd601152017-11-27 14:53:37 -08005636 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS) {
Phil Burk07ac1142016-03-25 13:39:29 -07005637 formats.add(AUDIO_FORMAT_E_AC3);
5638 formats.add(AUDIO_FORMAT_DTS);
5639 formats.add(AUDIO_FORMAT_DTS_HD);
5640 supportsOtherSurround = true;
5641 }
5642
5643 // Add support for IEC61937 if any raw surround supported.
5644 // The HAL could do this but add it here, just in case.
5645 if ((supportsAC3 || supportsOtherSurround) && !supportsIEC61937) {
5646 formats.add(AUDIO_FORMAT_IEC61937);
5647 supportsIEC61937 = true;
5648 }
Phil Burk09bc4612016-02-24 15:58:15 -08005649 }
Phil Burk0709b0a2016-03-31 12:54:57 -07005650}
5651
5652// Modify the list of channel masks supported.
5653void AudioPolicyManager::filterSurroundChannelMasks(ChannelsVector *channelMasksPtr) {
5654 ChannelsVector &channelMasks = *channelMasksPtr;
5655 audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
5656 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
5657
5658 // If NEVER, then remove support for channelMasks > stereo.
5659 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) {
5660 for (size_t maskIndex = 0; maskIndex < channelMasks.size(); ) {
5661 audio_channel_mask_t channelMask = channelMasks[maskIndex];
5662 if (channelMask & ~AUDIO_CHANNEL_OUT_STEREO) {
5663 ALOGI("%s: force NEVER, so remove channelMask 0x%08x", __FUNCTION__, channelMask);
5664 channelMasks.removeAt(maskIndex);
5665 } else {
5666 maskIndex++;
5667 }
5668 }
5669 // If ALWAYS, then make sure we at least support 5.1
5670 } else if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS) {
5671 bool supports5dot1 = false;
5672 // Are there any channel masks that can be considered "surround"?
Mikhail Naganovcf84e592017-12-07 11:25:11 -08005673 for (audio_channel_mask_t channelMask : channelMasks) {
Phil Burk0709b0a2016-03-31 12:54:57 -07005674 if ((channelMask & AUDIO_CHANNEL_OUT_5POINT1) == AUDIO_CHANNEL_OUT_5POINT1) {
5675 supports5dot1 = true;
5676 break;
5677 }
5678 }
5679 // If not then add 5.1 support.
5680 if (!supports5dot1) {
5681 channelMasks.add(AUDIO_CHANNEL_OUT_5POINT1);
5682 ALOGI("%s: force ALWAYS, so adding channelMask for 5.1 surround", __FUNCTION__);
5683 }
Phil Burk09bc4612016-02-24 15:58:15 -08005684 }
5685}
5686
Phil Burk00eeb322016-03-31 12:41:00 -07005687void AudioPolicyManager::updateAudioProfiles(audio_devices_t device,
5688 audio_io_handle_t ioHandle,
François Gaffie112b0af2015-11-19 16:13:25 +01005689 AudioProfileVector &profiles)
5690{
5691 String8 reply;
Phil Burk0709b0a2016-03-31 12:54:57 -07005692
François Gaffie112b0af2015-11-19 16:13:25 +01005693 // Format MUST be checked first to update the list of AudioProfile
5694 if (profiles.hasDynamicFormat()) {
Mikhail Naganov388360c2016-10-17 17:09:41 -07005695 reply = mpClientInterface->getParameters(
5696 ioHandle, String8(AudioParameter::keyStreamSupportedFormats));
Phil Burk0709b0a2016-03-31 12:54:57 -07005697 ALOGV("%s: supported formats %s", __FUNCTION__, reply.string());
Eric Laurent62e4bc52016-02-02 18:37:28 -08005698 AudioParameter repliedParameters(reply);
5699 if (repliedParameters.get(
Mikhail Naganov388360c2016-10-17 17:09:41 -07005700 String8(AudioParameter::keyStreamSupportedFormats), reply) != NO_ERROR) {
François Gaffie112b0af2015-11-19 16:13:25 +01005701 ALOGE("%s: failed to retrieve format, bailing out", __FUNCTION__);
5702 return;
5703 }
Phil Burk09bc4612016-02-24 15:58:15 -08005704 FormatVector formats = formatsFromString(reply.string());
Phil Burk00eeb322016-03-31 12:41:00 -07005705 if (device == AUDIO_DEVICE_OUT_HDMI) {
Phil Burk0709b0a2016-03-31 12:54:57 -07005706 filterSurroundFormats(&formats);
Phil Burk00eeb322016-03-31 12:41:00 -07005707 }
Phil Burk09bc4612016-02-24 15:58:15 -08005708 profiles.setFormats(formats);
François Gaffie112b0af2015-11-19 16:13:25 +01005709 }
François Gaffie112b0af2015-11-19 16:13:25 +01005710
Mikhail Naganovcf84e592017-12-07 11:25:11 -08005711 for (audio_format_t format : profiles.getSupportedFormats()) {
Eric Laurent20eb3a42016-01-26 18:39:17 -08005712 ChannelsVector channelMasks;
5713 SampleRateVector samplingRates;
François Gaffie112b0af2015-11-19 16:13:25 +01005714 AudioParameter requestedParameters;
Mikhail Naganov388360c2016-10-17 17:09:41 -07005715 requestedParameters.addInt(String8(AudioParameter::keyFormat), format);
François Gaffie112b0af2015-11-19 16:13:25 +01005716
5717 if (profiles.hasDynamicRateFor(format)) {
Mikhail Naganov388360c2016-10-17 17:09:41 -07005718 reply = mpClientInterface->getParameters(
5719 ioHandle,
5720 requestedParameters.toString() + ";" +
5721 AudioParameter::keyStreamSupportedSamplingRates);
François Gaffie112b0af2015-11-19 16:13:25 +01005722 ALOGV("%s: supported sampling rates %s", __FUNCTION__, reply.string());
Eric Laurent62e4bc52016-02-02 18:37:28 -08005723 AudioParameter repliedParameters(reply);
5724 if (repliedParameters.get(
Mikhail Naganov388360c2016-10-17 17:09:41 -07005725 String8(AudioParameter::keyStreamSupportedSamplingRates), reply) == NO_ERROR) {
Eric Laurent62e4bc52016-02-02 18:37:28 -08005726 samplingRates = samplingRatesFromString(reply.string());
François Gaffie112b0af2015-11-19 16:13:25 +01005727 }
5728 }
5729 if (profiles.hasDynamicChannelsFor(format)) {
5730 reply = mpClientInterface->getParameters(ioHandle,
5731 requestedParameters.toString() + ";" +
Mikhail Naganov388360c2016-10-17 17:09:41 -07005732 AudioParameter::keyStreamSupportedChannels);
François Gaffie112b0af2015-11-19 16:13:25 +01005733 ALOGV("%s: supported channel masks %s", __FUNCTION__, reply.string());
Eric Laurent62e4bc52016-02-02 18:37:28 -08005734 AudioParameter repliedParameters(reply);
5735 if (repliedParameters.get(
Mikhail Naganov388360c2016-10-17 17:09:41 -07005736 String8(AudioParameter::keyStreamSupportedChannels), reply) == NO_ERROR) {
Eric Laurent62e4bc52016-02-02 18:37:28 -08005737 channelMasks = channelMasksFromString(reply.string());
Phil Burk0709b0a2016-03-31 12:54:57 -07005738 if (device == AUDIO_DEVICE_OUT_HDMI) {
5739 filterSurroundChannelMasks(&channelMasks);
5740 }
François Gaffie112b0af2015-11-19 16:13:25 +01005741 }
5742 }
Eric Laurent20eb3a42016-01-26 18:39:17 -08005743 profiles.addProfileFromHal(new AudioProfile(format, channelMasks, samplingRates));
François Gaffie112b0af2015-11-19 16:13:25 +01005744 }
5745}
Eric Laurentd60560a2015-04-10 11:31:20 -07005746
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08005747} // namespace android