blob: bd8c3d1cc56ae47d58a484b1dedccf37a09dabe5 [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"
Tomoharu Kasahara71c90912018-10-31 09:10:12 +090018
19// Need to keep the log statements even in production builds
20// to enable VERBOSE logging dynamically.
21// You can enable VERBOSE logging as follows:
22// adb shell setprop log.tag.APM_AudioPolicyManager V
23#define LOG_NDEBUG 0
Eric Laurente552edb2014-03-10 17:42:56 -070024
25//#define VERY_VERBOSE_LOGGING
26#ifdef VERY_VERBOSE_LOGGING
27#define ALOGVV ALOGV
28#else
29#define ALOGVV(a...) do { } while(0)
30#endif
31
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +090032#define AUDIO_POLICY_XML_CONFIG_FILE_PATH_MAX_LENGTH 128
33#define AUDIO_POLICY_XML_CONFIG_FILE_NAME "audio_policy_configuration.xml"
Petri Gyntherf497f292018-04-17 18:46:10 -070034#define AUDIO_POLICY_A2DP_OFFLOAD_DISABLED_XML_CONFIG_FILE_NAME \
35 "audio_policy_configuration_a2dp_offload_disabled.xml"
Cheney Nie5985452019-02-24 01:39:15 +080036#define AUDIO_POLICY_BLUETOOTH_LEGACY_HAL_XML_CONFIG_FILE_NAME \
37 "audio_policy_configuration_bluetooth_legacy_hal.xml"
François Gaffief4ad6e52015-11-19 16:59:57 +010038
Eric Laurent16c66dd2019-05-01 17:54:10 -070039#include <algorithm>
Eric Laurentd4692962014-05-05 18:13:44 -070040#include <inttypes.h>
Eric Laurente552edb2014-03-10 17:42:56 -070041#include <math.h>
Kevin Rocard153f92d2018-12-18 18:33:28 -080042#include <set>
Mikhail Naganovd5e18052018-11-30 14:55:45 -080043#include <unordered_set>
Mikhail Naganov15be9d22017-11-08 14:18:13 +110044#include <vector>
Eric Laurente552edb2014-03-10 17:42:56 -070045#include <cutils/properties.h>
Eric Laurentd4692962014-05-05 18:13:44 -070046#include <utils/Log.h>
Eric Laurent3b73df72014-03-11 09:06:29 -070047#include <media/AudioParameter.h>
Andy Hung4ef19fa2018-05-15 19:35:29 -070048#include <private/android_filesystem_config.h>
Mikhail Naganovcbc8f612016-10-11 18:05:13 -070049#include <system/audio.h>
Eric Laurentd4692962014-05-05 18:13:44 -070050#include "AudioPolicyManager.h"
François Gaffied1ab2bd2015-12-02 18:20:06 +010051#include <Serializer.h>
François Gaffiea8ecc2c2015-11-09 16:10:40 +010052#include "TypeConverter.h"
François Gaffie53615e22015-03-19 09:24:12 +010053#include <policy.h>
Eric Laurente552edb2014-03-10 17:42:56 -070054
Eric Laurent3b73df72014-03-11 09:06:29 -070055namespace android {
Eric Laurente552edb2014-03-10 17:42:56 -070056
Eric Laurentdc462862016-07-19 12:29:53 -070057//FIXME: workaround for truncated touch sounds
58// to be removed when the problem is handled by system UI
59#define TOUCH_SOUND_FIXED_DELAY_MS 100
Jean-Michel Trivi719a9872017-08-05 13:51:35 -070060
61// Largest difference in dB on earpiece in call between the voice volume and another
62// media / notification / system volume.
63constexpr float IN_CALL_EARPIECE_HEADROOM_DB = 3.f;
64
Mikhail Naganov15be9d22017-11-08 14:18:13 +110065// Compressed formats for MSD module, ordered from most preferred to least preferred.
66static const std::vector<audio_format_t> compressedFormatsOrder = {{
67 AUDIO_FORMAT_MAT_2_1, AUDIO_FORMAT_MAT_2_0, AUDIO_FORMAT_E_AC3,
68 AUDIO_FORMAT_AC3, AUDIO_FORMAT_PCM_16_BIT }};
69// Channel masks for MSD module, 3D > 2D > 1D ordering (most preferred to least preferred).
70static const std::vector<audio_channel_mask_t> surroundChannelMasksOrder = {{
71 AUDIO_CHANNEL_OUT_3POINT1POINT2, AUDIO_CHANNEL_OUT_3POINT0POINT2,
72 AUDIO_CHANNEL_OUT_2POINT1POINT2, AUDIO_CHANNEL_OUT_2POINT0POINT2,
73 AUDIO_CHANNEL_OUT_5POINT1, AUDIO_CHANNEL_OUT_STEREO }};
74
jiabin06e4bab2019-07-29 10:13:34 -070075template <typename T>
76bool operator== (const SortedVector<T> &left, const SortedVector<T> &right)
77{
78 if (left.size() != right.size()) {
79 return false;
80 }
81 for (size_t index = 0; index < right.size(); index++) {
82 if (left[index] != right[index]) {
83 return false;
84 }
85 }
86 return true;
87}
88
89template <typename T>
90bool operator!= (const SortedVector<T> &left, const SortedVector<T> &right)
91{
92 return !(left == right);
93}
94
Eric Laurente552edb2014-03-10 17:42:56 -070095// ----------------------------------------------------------------------------
96// AudioPolicyInterface implementation
97// ----------------------------------------------------------------------------
98
Eric Laurente0720872014-03-11 09:30:41 -070099status_t AudioPolicyManager::setDeviceConnectionState(audio_devices_t device,
Paul McLeane743a472015-01-28 11:07:31 -0800100 audio_policy_dev_state_t state,
101 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800102 const char *device_name,
103 audio_format_t encodedFormat)
Eric Laurente552edb2014-03-10 17:42:56 -0700104{
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800105 status_t status = setDeviceConnectionStateInt(device, state, device_address,
106 device_name, encodedFormat);
jiabina7b43792018-02-15 16:04:46 -0800107 nextAudioPortGeneration();
108 return status;
Eric Laurentc73ca6e2014-12-12 14:34:22 -0800109}
110
François Gaffie11d30102018-11-02 16:09:09 +0100111void AudioPolicyManager::broadcastDeviceConnectionState(const sp<DeviceDescriptor> &device,
112 audio_policy_dev_state_t state)
François Gaffie44481e72016-04-20 07:49:57 +0200113{
jiabince9f20e2019-09-12 16:29:15 -0700114 AudioParameter param(String8(device->address().c_str()));
François Gaffie44481e72016-04-20 07:49:57 +0200115 const String8 key(state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE ?
Mikhail Naganovf23fcf62019-07-08 15:28:43 -0700116 AudioParameter::keyDeviceConnect : AudioParameter::keyDeviceDisconnect);
François Gaffie11d30102018-11-02 16:09:09 +0100117 param.addInt(key, device->type());
François Gaffie44481e72016-04-20 07:49:57 +0200118 mpClientInterface->setParameters(AUDIO_IO_HANDLE_NONE, param.toString());
119}
120
François Gaffie11d30102018-11-02 16:09:09 +0100121status_t AudioPolicyManager::setDeviceConnectionStateInt(audio_devices_t deviceType,
Eric Laurenta1d525f2015-01-29 13:36:45 -0800122 audio_policy_dev_state_t state,
Paul McLeane743a472015-01-28 11:07:31 -0800123 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800124 const char *device_name,
125 audio_format_t encodedFormat)
Eric Laurentc73ca6e2014-12-12 14:34:22 -0800126{
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800127 ALOGV("setDeviceConnectionStateInt() device: 0x%X, state %d, address %s name %s format 0x%X",
128 deviceType, state, device_address, device_name, encodedFormat);
Eric Laurente552edb2014-03-10 17:42:56 -0700129
130 // connect/disconnect only 1 device at a time
François Gaffie11d30102018-11-02 16:09:09 +0100131 if (!audio_is_output_device(deviceType) && !audio_is_input_device(deviceType)) return BAD_VALUE;
Eric Laurente552edb2014-03-10 17:42:56 -0700132
François Gaffie11d30102018-11-02 16:09:09 +0100133 sp<DeviceDescriptor> device =
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800134 mHwModules.getDeviceDescriptor(deviceType, device_address, device_name, encodedFormat,
Francois Gaffie716e1432019-01-14 16:58:59 +0100135 state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
136 if (device == 0) {
137 return INVALID_OPERATION;
138 }
Paul McLeane743a472015-01-28 11:07:31 -0800139
Eric Laurente552edb2014-03-10 17:42:56 -0700140 // handle output devices
François Gaffie11d30102018-11-02 16:09:09 +0100141 if (audio_is_output_device(deviceType)) {
Eric Laurentd4692962014-05-05 18:13:44 -0700142 SortedVector <audio_io_handle_t> outputs;
143
François Gaffie11d30102018-11-02 16:09:09 +0100144 ssize_t index = mAvailableOutputDevices.indexOf(device);
Eric Laurent3a4311c2014-03-17 12:00:47 -0700145
Eric Laurente552edb2014-03-10 17:42:56 -0700146 // save a copy of the opened output descriptors before any output is opened or closed
147 // by checkOutputsForDevice(). This will be needed by checkOutputForAllStrategies()
148 mPreviousOutputs = mOutputs;
Eric Laurente552edb2014-03-10 17:42:56 -0700149 switch (state)
150 {
151 // handle output device connection
Eric Laurent3ae5f312015-02-03 17:12:08 -0800152 case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700153 if (index >= 0) {
François Gaffie11d30102018-11-02 16:09:09 +0100154 ALOGW("%s() device already connected: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700155 return INVALID_OPERATION;
156 }
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800157 ALOGV("%s() connecting device %s format %x",
158 __func__, device->toString().c_str(), encodedFormat);
Eric Laurente552edb2014-03-10 17:42:56 -0700159
Eric Laurente552edb2014-03-10 17:42:56 -0700160 // register new device as available
Francois Gaffie993f3902019-04-10 15:39:27 +0200161 if (mAvailableOutputDevices.add(device) < 0) {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700162 return NO_MEMORY;
Eric Laurente552edb2014-03-10 17:42:56 -0700163 }
164
François Gaffie44481e72016-04-20 07:49:57 +0200165 // Before checking outputs, broadcast connect event to allow HAL to retrieve dynamic
166 // parameters on newly connected devices (instead of opening the outputs...)
François Gaffie11d30102018-11-02 16:09:09 +0100167 broadcastDeviceConnectionState(device, state);
François Gaffie44481e72016-04-20 07:49:57 +0200168
François Gaffie11d30102018-11-02 16:09:09 +0100169 if (checkOutputsForDevice(device, state, outputs) != NO_ERROR) {
170 mAvailableOutputDevices.remove(device);
François Gaffie44481e72016-04-20 07:49:57 +0200171
Francois Gaffie716e1432019-01-14 16:58:59 +0100172 mHwModules.cleanUpForDevice(device);
173
François Gaffie11d30102018-11-02 16:09:09 +0100174 broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE);
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -0700175 return INVALID_OPERATION;
176 }
François Gaffie2110e042015-03-24 08:41:51 +0100177
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -0700178 // outputs should never be empty here
179 ALOG_ASSERT(outputs.size() != 0, "setDeviceConnectionState():"
180 "checkOutputsForDevice() returned no outputs but status OK");
François Gaffie11d30102018-11-02 16:09:09 +0100181 ALOGV("%s() checkOutputsForDevice() returned %zu outputs", __func__, outputs.size());
Eric Laurent3ae5f312015-02-03 17:12:08 -0800182
Eric Laurent3ae5f312015-02-03 17:12:08 -0800183 } break;
Eric Laurente552edb2014-03-10 17:42:56 -0700184 // handle output device disconnection
Eric Laurent3b73df72014-03-11 09:06:29 -0700185 case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700186 if (index < 0) {
François Gaffie11d30102018-11-02 16:09:09 +0100187 ALOGW("%s() device not connected: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700188 return INVALID_OPERATION;
189 }
190
François Gaffie11d30102018-11-02 16:09:09 +0100191 ALOGV("%s() disconnecting output device %s", __func__, device->toString().c_str());
Paul McLean5c477aa2014-08-20 16:47:57 -0700192
Paul McLeane743a472015-01-28 11:07:31 -0800193 // Send Disconnect to HALs
François Gaffie11d30102018-11-02 16:09:09 +0100194 broadcastDeviceConnectionState(device, state);
Paul McLean5c477aa2014-08-20 16:47:57 -0700195
Eric Laurente552edb2014-03-10 17:42:56 -0700196 // remove device from available output devices
François Gaffie11d30102018-11-02 16:09:09 +0100197 mAvailableOutputDevices.remove(device);
Eric Laurente552edb2014-03-10 17:42:56 -0700198
Francois Gaffieba2cf0f2018-12-12 16:40:25 +0100199 mOutputs.clearSessionRoutesForDevice(device);
200
François Gaffie11d30102018-11-02 16:09:09 +0100201 checkOutputsForDevice(device, state, outputs);
François Gaffie2110e042015-03-24 08:41:51 +0100202
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800203 // Reset active device codec
204 device->setEncodedFormat(AUDIO_FORMAT_DEFAULT);
205
Eric Laurente552edb2014-03-10 17:42:56 -0700206 } break;
207
208 default:
François Gaffie11d30102018-11-02 16:09:09 +0100209 ALOGE("%s() invalid state: %x", __func__, state);
Eric Laurente552edb2014-03-10 17:42:56 -0700210 return BAD_VALUE;
211 }
212
Eric Laurent736a1022019-03-27 18:28:46 -0700213 // Propagate device availability to Engine
214 setEngineDeviceConnectionState(device, state);
215
Eric Laurentae970022019-01-29 14:25:04 -0800216 // No need to evaluate playback routing when connecting a remote submix
217 // output device used by a dynamic policy of type recorder as no
218 // playback use case is affected.
219 bool doCheckForDeviceAndOutputChanges = true;
220 if (device->type() == AUDIO_DEVICE_OUT_REMOTE_SUBMIX
221 && strncmp(device_address, "0", AUDIO_DEVICE_MAX_ADDRESS_LEN) != 0) {
222 for (audio_io_handle_t output : outputs) {
223 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
Mikhail Naganovbfac5832019-03-05 16:55:28 -0800224 sp<AudioPolicyMix> policyMix = desc->mPolicyMix.promote();
225 if (policyMix != nullptr
226 && policyMix->mMixType == MIX_TYPE_RECORDERS
Eric Laurentae970022019-01-29 14:25:04 -0800227 && strncmp(device_address,
Mikhail Naganovbfac5832019-03-05 16:55:28 -0800228 policyMix->mDeviceAddress.string(),
Eric Laurentae970022019-01-29 14:25:04 -0800229 AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0) {
230 doCheckForDeviceAndOutputChanges = false;
231 break;
232 }
233 }
234 }
235
236 auto checkCloseOutputs = [&]() {
Mikhail Naganov37977152018-07-11 15:54:44 -0700237 // outputs must be closed after checkOutputForAllStrategies() is executed
238 if (!outputs.isEmpty()) {
239 for (audio_io_handle_t output : outputs) {
240 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
François Gaffie11d30102018-11-02 16:09:09 +0100241 // close unused outputs after device disconnection or direct outputs that have
242 // been opened by checkOutputsForDevice() to query dynamic parameters
Mikhail Naganov37977152018-07-11 15:54:44 -0700243 if ((state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) ||
244 (((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) &&
Eric Laurentae970022019-01-29 14:25:04 -0800245 (desc->mDirectOpenCount == 0))) {
Mikhail Naganov37977152018-07-11 15:54:44 -0700246 closeOutput(output);
247 }
Eric Laurente552edb2014-03-10 17:42:56 -0700248 }
Mikhail Naganov37977152018-07-11 15:54:44 -0700249 // check A2DP again after closing A2DP output to reset mA2dpSuspended if needed
250 return true;
Eric Laurente552edb2014-03-10 17:42:56 -0700251 }
Mikhail Naganov37977152018-07-11 15:54:44 -0700252 return false;
Eric Laurentae970022019-01-29 14:25:04 -0800253 };
254
255 if (doCheckForDeviceAndOutputChanges) {
256 checkForDeviceAndOutputChanges(checkCloseOutputs);
257 } else {
258 checkCloseOutputs();
259 }
Eric Laurente552edb2014-03-10 17:42:56 -0700260
Eric Laurent87ffa392015-05-22 10:32:38 -0700261 if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
François Gaffie11d30102018-11-02 16:09:09 +0100262 DeviceVector newDevices = getNewOutputDevices(mPrimaryOutput, false /*fromCache*/);
263 updateCallRouting(newDevices);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700264 }
François Gaffie11d30102018-11-02 16:09:09 +0100265 const DeviceVector msdOutDevices = getMsdAudioOutDevices();
Eric Laurente552edb2014-03-10 17:42:56 -0700266 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -0700267 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
268 if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) || (desc != mPrimaryOutput)) {
François Gaffie11d30102018-11-02 16:09:09 +0100269 DeviceVector newDevices = getNewOutputDevices(desc, true /*fromCache*/);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700270 // do not force device change on duplicated output because if device is 0, it will
271 // also force a device 0 for the two outputs it is duplicated to which may override
272 // a valid device selection on those outputs.
François Gaffie11d30102018-11-02 16:09:09 +0100273 bool force = (msdOutDevices.isEmpty() || msdOutDevices != desc->devices())
Mikhail Naganov15be9d22017-11-08 14:18:13 +1100274 && !desc->isDuplicated()
François Gaffie11d30102018-11-02 16:09:09 +0100275 && (!device_distinguishes_on_address(deviceType)
Eric Laurentc2730ba2014-07-20 15:47:07 -0700276 // always force when disconnecting (a non-duplicated device)
277 || (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
François Gaffie11d30102018-11-02 16:09:09 +0100278 setOutputDevices(desc, newDevices, force, 0);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700279 }
Eric Laurente552edb2014-03-10 17:42:56 -0700280 }
281
Eric Laurentd60560a2015-04-10 11:31:20 -0700282 if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
François Gaffie11d30102018-11-02 16:09:09 +0100283 cleanUpForDevice(device);
Eric Laurentd60560a2015-04-10 11:31:20 -0700284 }
285
Eric Laurent72aa32f2014-05-30 18:51:48 -0700286 mpClientInterface->onAudioPortListUpdate();
Eric Laurentb71e58b2014-05-29 16:08:11 -0700287 return NO_ERROR;
Eric Laurentd4692962014-05-05 18:13:44 -0700288 } // end if is output device
289
Eric Laurente552edb2014-03-10 17:42:56 -0700290 // handle input devices
François Gaffie11d30102018-11-02 16:09:09 +0100291 if (audio_is_input_device(deviceType)) {
François Gaffie11d30102018-11-02 16:09:09 +0100292 ssize_t index = mAvailableInputDevices.indexOf(device);
Eric Laurente552edb2014-03-10 17:42:56 -0700293 switch (state)
294 {
295 // handle input device connection
Eric Laurent3b73df72014-03-11 09:06:29 -0700296 case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700297 if (index >= 0) {
François Gaffie11d30102018-11-02 16:09:09 +0100298 ALOGW("%s() device already connected: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700299 return INVALID_OPERATION;
300 }
Eric Laurent0dd51852019-04-19 18:18:58 -0700301
302 if (mAvailableInputDevices.add(device) < 0) {
303 return NO_MEMORY;
304 }
305
François Gaffie44481e72016-04-20 07:49:57 +0200306 // Before checking intputs, broadcast connect event to allow HAL to retrieve dynamic
307 // parameters on newly connected devices (instead of opening the inputs...)
François Gaffie11d30102018-11-02 16:09:09 +0100308 broadcastDeviceConnectionState(device, state);
François Gaffie44481e72016-04-20 07:49:57 +0200309
Eric Laurent0dd51852019-04-19 18:18:58 -0700310 if (checkInputsForDevice(device, state) != NO_ERROR) {
311 mAvailableInputDevices.remove(device);
312
François Gaffie11d30102018-11-02 16:09:09 +0100313 broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE);
Francois Gaffie716e1432019-01-14 16:58:59 +0100314
315 mHwModules.cleanUpForDevice(device);
316
Eric Laurentd4692962014-05-05 18:13:44 -0700317 return INVALID_OPERATION;
318 }
319
Eric Laurentd4692962014-05-05 18:13:44 -0700320 } break;
Eric Laurente552edb2014-03-10 17:42:56 -0700321
322 // handle input device disconnection
Eric Laurent3b73df72014-03-11 09:06:29 -0700323 case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700324 if (index < 0) {
François Gaffie11d30102018-11-02 16:09:09 +0100325 ALOGW("%s() device not connected: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700326 return INVALID_OPERATION;
327 }
Paul McLean5c477aa2014-08-20 16:47:57 -0700328
François Gaffie11d30102018-11-02 16:09:09 +0100329 ALOGV("%s() disconnecting input device %s", __func__, device->toString().c_str());
Paul McLean5c477aa2014-08-20 16:47:57 -0700330
331 // Set Disconnect to HALs
François Gaffie11d30102018-11-02 16:09:09 +0100332 broadcastDeviceConnectionState(device, state);
Paul McLean5c477aa2014-08-20 16:47:57 -0700333
François Gaffie11d30102018-11-02 16:09:09 +0100334 mAvailableInputDevices.remove(device);
Eric Laurent0dd51852019-04-19 18:18:58 -0700335
336 checkInputsForDevice(device, state);
Eric Laurentd4692962014-05-05 18:13:44 -0700337 } break;
Eric Laurente552edb2014-03-10 17:42:56 -0700338
339 default:
François Gaffie11d30102018-11-02 16:09:09 +0100340 ALOGE("%s() invalid state: %x", __func__, state);
Eric Laurente552edb2014-03-10 17:42:56 -0700341 return BAD_VALUE;
342 }
343
Eric Laurent736a1022019-03-27 18:28:46 -0700344 // Propagate device availability to Engine
345 setEngineDeviceConnectionState(device, state);
346
Eric Laurent0dd51852019-04-19 18:18:58 -0700347 checkCloseInputs();
Eric Laurent5f5fca52016-08-04 11:48:57 -0700348 // As the input device list can impact the output device selection, update
349 // getDeviceForStrategy() cache
350 updateDevicesAndOutputs();
Eric Laurente552edb2014-03-10 17:42:56 -0700351
Eric Laurent87ffa392015-05-22 10:32:38 -0700352 if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
François Gaffie11d30102018-11-02 16:09:09 +0100353 DeviceVector newDevices = getNewOutputDevices(mPrimaryOutput, false /*fromCache*/);
354 updateCallRouting(newDevices);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700355 }
356
Eric Laurentd60560a2015-04-10 11:31:20 -0700357 if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
François Gaffie11d30102018-11-02 16:09:09 +0100358 cleanUpForDevice(device);
Eric Laurentd60560a2015-04-10 11:31:20 -0700359 }
360
Eric Laurentb52c1522014-05-20 11:27:36 -0700361 mpClientInterface->onAudioPortListUpdate();
Eric Laurente552edb2014-03-10 17:42:56 -0700362 return NO_ERROR;
Eric Laurentd4692962014-05-05 18:13:44 -0700363 } // end if is input device
Eric Laurente552edb2014-03-10 17:42:56 -0700364
François Gaffie11d30102018-11-02 16:09:09 +0100365 ALOGW("%s() invalid device: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700366 return BAD_VALUE;
367}
368
Eric Laurent736a1022019-03-27 18:28:46 -0700369void AudioPolicyManager::setEngineDeviceConnectionState(const sp<DeviceDescriptor> device,
370 audio_policy_dev_state_t state) {
371
372 // the Engine does not have to know about remote submix devices used by dynamic audio policies
373 if (audio_is_remote_submix_device(device->type()) && device->address() != "0") {
374 return;
375 }
376 mEngine->setDeviceConnectionState(device, state);
377}
378
379
Eric Laurente0720872014-03-11 09:30:41 -0700380audio_policy_dev_state_t AudioPolicyManager::getDeviceConnectionState(audio_devices_t device,
François Gaffie53615e22015-03-19 09:24:12 +0100381 const char *device_address)
Eric Laurente552edb2014-03-10 17:42:56 -0700382{
Eric Laurent634b7142016-04-20 13:48:02 -0700383 sp<DeviceDescriptor> devDesc =
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800384 mHwModules.getDeviceDescriptor(device, device_address, "", AUDIO_FORMAT_DEFAULT,
385 false /* allowToCreate */,
Eric Laurent634b7142016-04-20 13:48:02 -0700386 (strlen(device_address) != 0)/*matchAddress*/);
387
388 if (devDesc == 0) {
François Gaffie251c7f02018-11-07 10:41:08 +0100389 ALOGV("getDeviceConnectionState() undeclared device, type %08x, address: %s",
Eric Laurent634b7142016-04-20 13:48:02 -0700390 device, device_address);
391 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
392 }
François Gaffie53615e22015-03-19 09:24:12 +0100393
Eric Laurent3a4311c2014-03-17 12:00:47 -0700394 DeviceVector *deviceVector;
395
Eric Laurente552edb2014-03-10 17:42:56 -0700396 if (audio_is_output_device(device)) {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700397 deviceVector = &mAvailableOutputDevices;
Eric Laurente552edb2014-03-10 17:42:56 -0700398 } else if (audio_is_input_device(device)) {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700399 deviceVector = &mAvailableInputDevices;
400 } else {
François Gaffie11d30102018-11-02 16:09:09 +0100401 ALOGW("%s() invalid device type %08x", __func__, device);
Eric Laurent3a4311c2014-03-17 12:00:47 -0700402 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
Eric Laurente552edb2014-03-10 17:42:56 -0700403 }
Eric Laurent634b7142016-04-20 13:48:02 -0700404
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800405 return (deviceVector->getDevice(
406 device, String8(device_address), AUDIO_FORMAT_DEFAULT) != 0) ?
Eric Laurent634b7142016-04-20 13:48:02 -0700407 AUDIO_POLICY_DEVICE_STATE_AVAILABLE : AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
Eric Laurenta1d525f2015-01-29 13:36:45 -0800408}
409
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800410status_t AudioPolicyManager::handleDeviceConfigChange(audio_devices_t device,
411 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800412 const char *device_name,
413 audio_format_t encodedFormat)
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800414{
415 status_t status;
Aniket Kumar Lata3432e042018-04-06 14:22:15 -0700416 String8 reply;
417 AudioParameter param;
418 int isReconfigA2dpSupported = 0;
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800419
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800420 ALOGV("handleDeviceConfigChange(() device: 0x%X, address %s name %s encodedFormat: 0x%X",
421 device, device_address, device_name, encodedFormat);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800422
Pavlin Radoslavovc694ff42017-01-09 23:27:29 -0800423 // connect/disconnect only 1 device at a time
424 if (!audio_is_output_device(device) && !audio_is_input_device(device)) return BAD_VALUE;
425
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800426 // Check if the device is currently connected
jiabin9a3361e2019-10-01 09:38:30 -0700427 DeviceVector deviceList = mAvailableOutputDevices.getDevicesFromType(device);
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800428 if (deviceList.empty()) {
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800429 // Nothing to do: device is not connected
430 return NO_ERROR;
431 }
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800432 sp<DeviceDescriptor> devDesc = deviceList.itemAt(0);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800433
Aniket Kumar Lata3432e042018-04-06 14:22:15 -0700434 // For offloaded A2DP, Hw modules may have the capability to
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800435 // configure codecs.
436 // Handle two specific cases by sending a set parameter to
437 // configure A2DP codecs. No need to toggle device state.
438 // Case 1: A2DP active device switches from primary to primary
439 // module
440 // Case 2: A2DP device config changes on primary module.
jiabin9a3361e2019-10-01 09:38:30 -0700441 if (audio_is_a2dp_out_device(device)) {
442 sp<HwModule> module = mHwModules.getModuleForDeviceType(device, encodedFormat);
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800443 audio_module_handle_t primaryHandle = mPrimaryOutput->getModuleHandle();
444 if (availablePrimaryOutputDevices().contains(devDesc) &&
445 (module != 0 && module->getHandle() == primaryHandle)) {
446 reply = mpClientInterface->getParameters(
447 AUDIO_IO_HANDLE_NONE,
448 String8(AudioParameter::keyReconfigA2dpSupported));
449 AudioParameter repliedParameters(reply);
450 repliedParameters.getInt(
451 String8(AudioParameter::keyReconfigA2dpSupported), isReconfigA2dpSupported);
452 if (isReconfigA2dpSupported) {
453 const String8 key(AudioParameter::keyReconfigA2dp);
454 param.add(key, String8("true"));
455 mpClientInterface->setParameters(AUDIO_IO_HANDLE_NONE, param.toString());
456 devDesc->setEncodedFormat(encodedFormat);
457 return NO_ERROR;
458 }
Aniket Kumar Lata3432e042018-04-06 14:22:15 -0700459 }
460 }
461
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800462 // Toggle the device state: UNAVAILABLE -> AVAILABLE
463 // This will force reading again the device configuration
464 status = setDeviceConnectionState(device,
465 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800466 device_address, device_name,
467 devDesc->getEncodedFormat());
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800468 if (status != NO_ERROR) {
469 ALOGW("handleDeviceConfigChange() error disabling connection state: %d",
470 status);
471 return status;
472 }
473
474 status = setDeviceConnectionState(device,
475 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800476 device_address, device_name, encodedFormat);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800477 if (status != NO_ERROR) {
478 ALOGW("handleDeviceConfigChange() error enabling connection state: %d",
479 status);
480 return status;
481 }
482
483 return NO_ERROR;
484}
485
Arun Mirpuri11029ad2018-12-19 20:45:19 -0800486status_t AudioPolicyManager::getHwOffloadEncodingFormatsSupportedForA2DP(
487 std::vector<audio_format_t> *formats)
488{
489 ALOGV("getHwOffloadEncodingFormatsSupportedForA2DP()");
Arun Mirpuri11029ad2018-12-19 20:45:19 -0800490 status_t status = NO_ERROR;
Aniket Kumar Lata89e82232019-01-19 18:14:10 -0800491 std::unordered_set<audio_format_t> formatSet;
492 sp<HwModule> primaryModule =
493 mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_PRIMARY);
Aniket Kumar Latafedb5982019-07-03 11:20:36 -0700494 if (primaryModule == nullptr) {
495 ALOGE("%s() unable to get primary module", __func__);
496 return NO_INIT;
497 }
jiabin9a3361e2019-10-01 09:38:30 -0700498 DeviceVector declaredDevices = primaryModule->getDeclaredDevices().getDevicesFromTypes(
499 getAudioDeviceOutAllA2dpSet());
Aniket Kumar Lata89e82232019-01-19 18:14:10 -0800500 for (const auto& device : declaredDevices) {
501 formatSet.insert(device->encodedFormats().begin(), device->encodedFormats().end());
Arun Mirpuri11029ad2018-12-19 20:45:19 -0800502 }
Aniket Kumar Lata89e82232019-01-19 18:14:10 -0800503 formats->assign(formatSet.begin(), formatSet.end());
Arun Mirpuri11029ad2018-12-19 20:45:19 -0800504 return status;
505}
506
François Gaffie11d30102018-11-02 16:09:09 +0100507uint32_t AudioPolicyManager::updateCallRouting(const DeviceVector &rxDevices, uint32_t delayMs)
Eric Laurentc2730ba2014-07-20 15:47:07 -0700508{
509 bool createTxPatch = false;
François Gaffie9eb18552018-11-05 10:33:26 +0100510 bool createRxPatch = false;
Eric Laurentdc462862016-07-19 12:29:53 -0700511 uint32_t muteWaitMs = 0;
Eric Laurentc2730ba2014-07-20 15:47:07 -0700512
jiabin9a3361e2019-10-01 09:38:30 -0700513 if(!hasPrimaryOutput() ||
514 mPrimaryOutput->devices().onlyContainsDevicesWithType(AUDIO_DEVICE_OUT_STUB)) {
Eric Laurentdc462862016-07-19 12:29:53 -0700515 return muteWaitMs;
Eric Laurent87ffa392015-05-22 10:32:38 -0700516 }
François Gaffie11d30102018-11-02 16:09:09 +0100517 ALOG_ASSERT(!rxDevices.isEmpty(), "updateCallRouting() no selected output device");
518
Francois Gaffie716e1432019-01-14 16:58:59 +0100519 audio_attributes_t attr = { .source = AUDIO_SOURCE_VOICE_COMMUNICATION };
François Gaffiec005e562018-11-06 15:04:49 +0100520 auto txSourceDevice = mEngine->getInputDeviceForAttributes(attr);
François Gaffie9eb18552018-11-05 10:33:26 +0100521 ALOG_ASSERT(txSourceDevice != 0, "updateCallRouting() input selected device not available");
François Gaffiec005e562018-11-06 15:04:49 +0100522
523 ALOGV("updateCallRouting device rxDevice %s txDevice %s",
François Gaffie9eb18552018-11-05 10:33:26 +0100524 rxDevices.itemAt(0)->toString().c_str(), txSourceDevice->toString().c_str());
Eric Laurentc2730ba2014-07-20 15:47:07 -0700525
526 // release existing RX patch if any
527 if (mCallRxPatch != 0) {
528 mpClientInterface->releaseAudioPatch(mCallRxPatch->mAfPatchHandle, 0);
529 mCallRxPatch.clear();
530 }
531 // release TX patch if any
532 if (mCallTxPatch != 0) {
533 mpClientInterface->releaseAudioPatch(mCallTxPatch->mAfPatchHandle, 0);
534 mCallTxPatch.clear();
535 }
536
François Gaffie9eb18552018-11-05 10:33:26 +0100537 auto telephonyRxModule =
jiabin9a3361e2019-10-01 09:38:30 -0700538 mHwModules.getModuleForDeviceType(AUDIO_DEVICE_IN_TELEPHONY_RX, AUDIO_FORMAT_DEFAULT);
François Gaffie9eb18552018-11-05 10:33:26 +0100539 auto telephonyTxModule =
jiabin9a3361e2019-10-01 09:38:30 -0700540 mHwModules.getModuleForDeviceType(AUDIO_DEVICE_OUT_TELEPHONY_TX, AUDIO_FORMAT_DEFAULT);
François Gaffie9eb18552018-11-05 10:33:26 +0100541 // retrieve Rx Source and Tx Sink device descriptors
542 sp<DeviceDescriptor> rxSourceDevice =
543 mAvailableInputDevices.getDevice(AUDIO_DEVICE_IN_TELEPHONY_RX,
544 String8(),
545 AUDIO_FORMAT_DEFAULT);
546 sp<DeviceDescriptor> txSinkDevice =
547 mAvailableOutputDevices.getDevice(AUDIO_DEVICE_OUT_TELEPHONY_TX,
548 String8(),
549 AUDIO_FORMAT_DEFAULT);
550
551 // RX and TX Telephony device are declared by Primary Audio HAL
552 if (isPrimaryModule(telephonyRxModule) && isPrimaryModule(telephonyTxModule) &&
553 (telephonyRxModule->getHalVersionMajor() >= 3)) {
554 if (rxSourceDevice == 0 || txSinkDevice == 0) {
555 // RX / TX Telephony device(s) is(are) not currently available
556 ALOGE("updateCallRouting() no telephony Tx and/or RX device");
557 return muteWaitMs;
558 }
559 // do not create a patch (aka Sw Bridging) if Primary HW module has declared supporting a
560 // route between telephony RX to Sink device and Source device to telephony TX
561 const auto &primaryModule = telephonyRxModule;
562 createRxPatch = !primaryModule->supportsPatch(rxSourceDevice, rxDevices.itemAt(0));
563 createTxPatch = !primaryModule->supportsPatch(txSourceDevice, txSinkDevice);
564 } else {
565 // If the RX device is on the primary HW module, then use legacy routing method for
566 // voice calls via setOutputDevice() on primary output.
567 // Otherwise, create two audio patches for TX and RX path.
568 createRxPatch = !(availablePrimaryOutputDevices().contains(rxDevices.itemAt(0))) &&
569 (rxSourceDevice != 0);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700570 // If the TX device is also on the primary HW module, setOutputDevice() will take care
571 // of it due to legacy implementation. If not, create a patch.
François Gaffie9eb18552018-11-05 10:33:26 +0100572 createTxPatch = !(availablePrimaryModuleInputDevices().contains(txSourceDevice)) &&
573 (txSinkDevice != 0);
574 }
575 // Use legacy routing method for voice calls via setOutputDevice() on primary output.
576 // Otherwise, create two audio patches for TX and RX path.
577 if (!createRxPatch) {
578 muteWaitMs = setOutputDevices(mPrimaryOutput, rxDevices, true, delayMs);
Eric Laurent8ae73122016-04-12 10:13:29 -0700579 } else { // create RX path audio patch
François Gaffie11d30102018-11-02 16:09:09 +0100580 mCallRxPatch = createTelephonyPatch(true /*isRx*/, rxDevices.itemAt(0), delayMs);
juyuchen2224c5a2019-01-21 12:00:58 +0800581
582 // If the TX device is on the primary HW module but RX device is
583 // on other HW module, SinkMetaData of telephony input should handle it
584 // assuming the device uses audio HAL V5.0 and above
Eric Laurentc2730ba2014-07-20 15:47:07 -0700585 }
Eric Laurent8ae73122016-04-12 10:13:29 -0700586 if (createTxPatch) { // create TX path audio patch
François Gaffie9eb18552018-11-05 10:33:26 +0100587 mCallTxPatch = createTelephonyPatch(false /*isRx*/, txSourceDevice, delayMs);
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800588 }
Eric Laurent8ae73122016-04-12 10:13:29 -0700589
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800590 return muteWaitMs;
591}
Eric Laurentc2730ba2014-07-20 15:47:07 -0700592
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800593sp<AudioPatch> AudioPolicyManager::createTelephonyPatch(
François Gaffie11d30102018-11-02 16:09:09 +0100594 bool isRx, const sp<DeviceDescriptor> &device, uint32_t delayMs) {
Mikhail Naganovdc769682018-05-04 15:34:08 -0700595 PatchBuilder patchBuilder;
Eric Laurentc2730ba2014-07-20 15:47:07 -0700596
François Gaffie11d30102018-11-02 16:09:09 +0100597 if (device == nullptr) {
598 return nullptr;
599 }
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800600 if (isRx) {
François Gaffie11d30102018-11-02 16:09:09 +0100601 patchBuilder.addSink(device).
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800602 addSource(mAvailableInputDevices.getDevice(
603 AUDIO_DEVICE_IN_TELEPHONY_RX, String8(), AUDIO_FORMAT_DEFAULT));
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800604 } else {
François Gaffie11d30102018-11-02 16:09:09 +0100605 patchBuilder.addSource(device).
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800606 addSink(mAvailableOutputDevices.getDevice(
607 AUDIO_DEVICE_OUT_TELEPHONY_TX, String8(), AUDIO_FORMAT_DEFAULT));
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800608 }
609
François Gaffie11d30102018-11-02 16:09:09 +0100610 // @TODO: still ignoring the address, or not dealing platform with mutliple telephonydevices
611 const sp<DeviceDescriptor> outputDevice = isRx ?
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800612 device : mAvailableOutputDevices.getDevice(
613 AUDIO_DEVICE_OUT_TELEPHONY_TX, String8(), AUDIO_FORMAT_DEFAULT);
François Gaffie11d30102018-11-02 16:09:09 +0100614 SortedVector<audio_io_handle_t> outputs =
615 getOutputsForDevices(DeviceVector(outputDevice), mOutputs);
Eric Laurent16c66dd2019-05-01 17:54:10 -0700616 const audio_io_handle_t output = selectOutput(outputs);
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800617 // request to reuse existing output stream if one is already opened to reach the target device
618 if (output != AUDIO_IO_HANDLE_NONE) {
619 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
François Gaffie11d30102018-11-02 16:09:09 +0100620 ALOG_ASSERT(!outputDesc->isDuplicated(), "%s() %s device output %d is duplicated", __func__,
621 outputDevice->toString().c_str(), output);
Mikhail Naganovdc769682018-05-04 15:34:08 -0700622 patchBuilder.addSource(outputDesc, { .stream = AUDIO_STREAM_PATCH });
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800623 }
624
625 if (!isRx) {
Eric Laurentc0a889f2015-10-14 14:36:34 -0700626 // terminate active capture if on the same HW module as the call TX source device
627 // FIXME: would be better to refine to only inputs whose profile connects to the
628 // call TX device but this information is not in the audio patch and logic here must be
629 // symmetric to the one in startInput()
Mikhail Naganovcf84e592017-12-07 11:25:11 -0800630 for (const auto& activeDesc : mInputs.getActiveInputs()) {
François Gaffie11d30102018-11-02 16:09:09 +0100631 if (activeDesc->hasSameHwModuleAs(device)) {
Eric Laurent8f42ea12018-08-08 09:08:25 -0700632 closeActiveClients(activeDesc);
Eric Laurentc0a889f2015-10-14 14:36:34 -0700633 }
634 }
Eric Laurentc2730ba2014-07-20 15:47:07 -0700635 }
Eric Laurentdc462862016-07-19 12:29:53 -0700636
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800637 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
Mikhail Naganovdc769682018-05-04 15:34:08 -0700638 status_t status = mpClientInterface->createAudioPatch(
639 patchBuilder.patch(), &afPatchHandle, delayMs);
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800640 ALOGW_IF(status != NO_ERROR,
641 "%s() error %d creating %s audio patch", __func__, status, isRx ? "RX" : "TX");
642 sp<AudioPatch> audioPatch;
643 if (status == NO_ERROR) {
Mikhail Naganovdc769682018-05-04 15:34:08 -0700644 audioPatch = new AudioPatch(patchBuilder.patch(), mUidCached);
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800645 audioPatch->mAfPatchHandle = afPatchHandle;
646 audioPatch->mUid = mUidCached;
647 }
648 return audioPatch;
649}
650
Mikhail Naganov100f0122018-11-29 11:22:16 -0800651bool AudioPolicyManager::isDeviceOfModule(
652 const sp<DeviceDescriptor>& devDesc, const char *moduleId) const {
653 sp<HwModule> module = mHwModules.getModuleFromName(moduleId);
654 if (module != 0) {
655 return mAvailableOutputDevices.getDevicesFromHwModule(module->getHandle())
656 .indexOf(devDesc) != NAME_NOT_FOUND
657 || mAvailableInputDevices.getDevicesFromHwModule(module->getHandle())
658 .indexOf(devDesc) != NAME_NOT_FOUND;
659 }
660 return false;
661}
662
Eric Laurente0720872014-03-11 09:30:41 -0700663void AudioPolicyManager::setPhoneState(audio_mode_t state)
Eric Laurente552edb2014-03-10 17:42:56 -0700664{
665 ALOGV("setPhoneState() state %d", state);
François Gaffie2110e042015-03-24 08:41:51 +0100666 // store previous phone state for management of sonification strategy below
667 int oldState = mEngine->getPhoneState();
668
669 if (mEngine->setPhoneState(state) != NO_ERROR) {
670 ALOGW("setPhoneState() invalid or same state %d", state);
Eric Laurente552edb2014-03-10 17:42:56 -0700671 return;
672 }
François Gaffie2110e042015-03-24 08:41:51 +0100673 /// Opens: can these line be executed after the switch of volume curves???
Eric Laurent63dea1d2015-07-02 17:10:28 -0700674 if (isStateInCall(oldState)) {
Eric Laurente552edb2014-03-10 17:42:56 -0700675 ALOGV("setPhoneState() in call state management: new state is %d", state);
Eric Laurent63dea1d2015-07-02 17:10:28 -0700676 // force reevaluating accessibility routing when call stops
Eric Laurent2cbe89a2014-12-19 11:49:08 -0800677 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
Eric Laurente552edb2014-03-10 17:42:56 -0700678 }
679
François Gaffie2110e042015-03-24 08:41:51 +0100680 /**
681 * Switching to or from incall state or switching between telephony and VoIP lead to force
682 * routing command.
683 */
Eric Laurent74b71512019-11-06 17:21:57 -0800684 bool force = ((isStateInCall(oldState) != isStateInCall(state))
685 || (isStateInCall(state) && (state != oldState)));
Eric Laurente552edb2014-03-10 17:42:56 -0700686
687 // check for device and output changes triggered by new phone state
Mikhail Naganov37977152018-07-11 15:54:44 -0700688 checkForDeviceAndOutputChanges();
Eric Laurente552edb2014-03-10 17:42:56 -0700689
Eric Laurente552edb2014-03-10 17:42:56 -0700690 int delayMs = 0;
691 if (isStateInCall(state)) {
692 nsecs_t sysTime = systemTime();
François Gaffiec005e562018-11-06 15:04:49 +0100693 auto musicStrategy = streamToStrategy(AUDIO_STREAM_MUSIC);
694 auto sonificationStrategy = streamToStrategy(AUDIO_STREAM_ALARM);
Eric Laurente552edb2014-03-10 17:42:56 -0700695 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -0700696 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Eric Laurente552edb2014-03-10 17:42:56 -0700697 // mute media and sonification strategies and delay device switch by the largest
698 // latency of any output where either strategy is active.
699 // This avoid sending the ring tone or music tail into the earpiece or headset.
François Gaffiec005e562018-11-06 15:04:49 +0100700 if ((desc->isStrategyActive(musicStrategy, SONIFICATION_HEADSET_MUSIC_DELAY, sysTime) ||
701 desc->isStrategyActive(sonificationStrategy, SONIFICATION_HEADSET_MUSIC_DELAY,
702 sysTime)) &&
Eric Laurentc75307b2015-03-17 15:29:32 -0700703 (delayMs < (int)desc->latency()*2)) {
704 delayMs = desc->latency()*2;
Eric Laurente552edb2014-03-10 17:42:56 -0700705 }
François Gaffiec005e562018-11-06 15:04:49 +0100706 setStrategyMute(musicStrategy, true, desc);
707 setStrategyMute(musicStrategy, false, desc, MUTE_TIME_MS,
708 mEngine->getOutputDevicesForAttributes(attributes_initializer(AUDIO_USAGE_MEDIA),
709 nullptr, true /*fromCache*/).types());
710 setStrategyMute(sonificationStrategy, true, desc);
711 setStrategyMute(sonificationStrategy, false, desc, MUTE_TIME_MS,
712 mEngine->getOutputDevicesForAttributes(attributes_initializer(AUDIO_USAGE_ALARM),
713 nullptr, true /*fromCache*/).types());
Eric Laurente552edb2014-03-10 17:42:56 -0700714 }
715 }
716
Eric Laurent87ffa392015-05-22 10:32:38 -0700717 if (hasPrimaryOutput()) {
François Gaffie11d30102018-11-02 16:09:09 +0100718 // Note that despite the fact that getNewOutputDevices() is called on the primary output,
Eric Laurent87ffa392015-05-22 10:32:38 -0700719 // the device returned is not necessarily reachable via this output
François Gaffie11d30102018-11-02 16:09:09 +0100720 DeviceVector rxDevices = getNewOutputDevices(mPrimaryOutput, false /*fromCache*/);
Eric Laurent87ffa392015-05-22 10:32:38 -0700721 // force routing command to audio hardware when ending call
722 // even if no device change is needed
François Gaffie11d30102018-11-02 16:09:09 +0100723 if (isStateInCall(oldState) && rxDevices.isEmpty()) {
724 rxDevices = mPrimaryOutput->devices();
Eric Laurent87ffa392015-05-22 10:32:38 -0700725 }
Eric Laurente552edb2014-03-10 17:42:56 -0700726
Eric Laurent87ffa392015-05-22 10:32:38 -0700727 if (state == AUDIO_MODE_IN_CALL) {
François Gaffie11d30102018-11-02 16:09:09 +0100728 updateCallRouting(rxDevices, delayMs);
Eric Laurent87ffa392015-05-22 10:32:38 -0700729 } else if (oldState == AUDIO_MODE_IN_CALL) {
730 if (mCallRxPatch != 0) {
731 mpClientInterface->releaseAudioPatch(mCallRxPatch->mAfPatchHandle, 0);
732 mCallRxPatch.clear();
733 }
734 if (mCallTxPatch != 0) {
735 mpClientInterface->releaseAudioPatch(mCallTxPatch->mAfPatchHandle, 0);
736 mCallTxPatch.clear();
737 }
François Gaffie11d30102018-11-02 16:09:09 +0100738 setOutputDevices(mPrimaryOutput, rxDevices, force, 0);
Eric Laurent87ffa392015-05-22 10:32:38 -0700739 } else {
François Gaffie11d30102018-11-02 16:09:09 +0100740 setOutputDevices(mPrimaryOutput, rxDevices, force, 0);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700741 }
Eric Laurentc2730ba2014-07-20 15:47:07 -0700742 }
Eric Laurent2e2a8a92018-04-20 16:21:33 -0700743
744 // reevaluate routing on all outputs in case tracks have been started during the call
745 for (size_t i = 0; i < mOutputs.size(); i++) {
746 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
François Gaffie11d30102018-11-02 16:09:09 +0100747 DeviceVector newDevices = getNewOutputDevices(desc, true /*fromCache*/);
Eric Laurent2e2a8a92018-04-20 16:21:33 -0700748 if (state != AUDIO_MODE_IN_CALL || desc != mPrimaryOutput) {
François Gaffie11d30102018-11-02 16:09:09 +0100749 setOutputDevices(desc, newDevices, !newDevices.isEmpty(), 0 /*delayMs*/);
Eric Laurent2e2a8a92018-04-20 16:21:33 -0700750 }
751 }
752
Eric Laurente552edb2014-03-10 17:42:56 -0700753 if (isStateInCall(state)) {
754 ALOGV("setPhoneState() in call state management: new state is %d", state);
Eric Laurent63dea1d2015-07-02 17:10:28 -0700755 // force reevaluating accessibility routing when call starts
756 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
Eric Laurente552edb2014-03-10 17:42:56 -0700757 }
758
759 // Flag that ringtone volume must be limited to music volume until we exit MODE_RINGTONE
François Gaffiec005e562018-11-06 15:04:49 +0100760 mLimitRingtoneVolume = (state == AUDIO_MODE_RINGTONE &&
761 isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY));
Eric Laurente552edb2014-03-10 17:42:56 -0700762}
763
Jean-Michel Trivi887a9ed2015-03-31 18:02:24 -0700764audio_mode_t AudioPolicyManager::getPhoneState() {
765 return mEngine->getPhoneState();
766}
767
Eric Laurente0720872014-03-11 09:30:41 -0700768void AudioPolicyManager::setForceUse(audio_policy_force_use_t usage,
François Gaffie11d30102018-11-02 16:09:09 +0100769 audio_policy_forced_cfg_t config)
Eric Laurente552edb2014-03-10 17:42:56 -0700770{
François Gaffie2110e042015-03-24 08:41:51 +0100771 ALOGV("setForceUse() usage %d, config %d, mPhoneState %d", usage, config, mEngine->getPhoneState());
Eric Laurent8dc87a62017-05-16 19:00:40 -0700772 if (config == mEngine->getForceUse(usage)) {
773 return;
774 }
Eric Laurente552edb2014-03-10 17:42:56 -0700775
François Gaffie2110e042015-03-24 08:41:51 +0100776 if (mEngine->setForceUse(usage, config) != NO_ERROR) {
777 ALOGW("setForceUse() could not set force cfg %d for usage %d", config, usage);
778 return;
Eric Laurente552edb2014-03-10 17:42:56 -0700779 }
François Gaffie2110e042015-03-24 08:41:51 +0100780 bool forceVolumeReeval = (usage == AUDIO_POLICY_FORCE_FOR_COMMUNICATION) ||
781 (usage == AUDIO_POLICY_FORCE_FOR_DOCK) ||
782 (usage == AUDIO_POLICY_FORCE_FOR_SYSTEM);
Eric Laurente552edb2014-03-10 17:42:56 -0700783
784 // check for device and output changes triggered by new force usage
Mikhail Naganov37977152018-07-11 15:54:44 -0700785 checkForDeviceAndOutputChanges();
Phil Burk09bc4612016-02-24 15:58:15 -0800786
Eric Laurent22fcda22019-05-17 16:28:47 -0700787 // force client reconnection to reevaluate flag AUDIO_FLAG_AUDIBILITY_ENFORCED
788 if (usage == AUDIO_POLICY_FORCE_FOR_SYSTEM) {
789 mpClientInterface->invalidateStream(AUDIO_STREAM_SYSTEM);
790 mpClientInterface->invalidateStream(AUDIO_STREAM_ENFORCED_AUDIBLE);
791 }
792
Eric Laurentdc462862016-07-19 12:29:53 -0700793 //FIXME: workaround for truncated touch sounds
794 // to be removed when the problem is handled by system UI
795 uint32_t delayMs = 0;
Eric Laurentdc462862016-07-19 12:29:53 -0700796 if (usage == AUDIO_POLICY_FORCE_FOR_COMMUNICATION) {
797 delayMs = TOUCH_SOUND_FIXED_DELAY_MS;
798 }
Jean-Michel Trivi30857152019-11-01 11:04:15 -0700799
800 updateCallAndOutputRouting(forceVolumeReeval, delayMs);
Eric Laurente552edb2014-03-10 17:42:56 -0700801
Mikhail Naganovcf84e592017-12-07 11:25:11 -0800802 for (const auto& activeDesc : mInputs.getActiveInputs()) {
François Gaffie11d30102018-11-02 16:09:09 +0100803 auto newDevice = getNewInputDevice(activeDesc);
Eric Laurentc171c7c2015-09-25 12:21:06 -0700804 // Force new input selection if the new device can not be reached via current input
Francois Gaffie716e1432019-01-14 16:58:59 +0100805 if (activeDesc->mProfile->getSupportedDevices().contains(newDevice)) {
Eric Laurentfb66dd92016-01-28 18:32:03 -0800806 setInputDevice(activeDesc->mIoHandle, newDevice);
Eric Laurentc171c7c2015-09-25 12:21:06 -0700807 } else {
Eric Laurentfb66dd92016-01-28 18:32:03 -0800808 closeInput(activeDesc->mIoHandle);
Eric Laurentc171c7c2015-09-25 12:21:06 -0700809 }
Eric Laurente552edb2014-03-10 17:42:56 -0700810 }
Eric Laurente552edb2014-03-10 17:42:56 -0700811}
812
Eric Laurente0720872014-03-11 09:30:41 -0700813void AudioPolicyManager::setSystemProperty(const char* property, const char* value)
Eric Laurente552edb2014-03-10 17:42:56 -0700814{
815 ALOGV("setSystemProperty() property %s, value %s", property, value);
816}
817
Michael Chana94fbb22018-04-24 14:31:19 +1000818// Find an output profile compatible with the parameters passed. When "directOnly" is set, restrict
819// search to profiles for direct outputs.
820sp<IOProfile> AudioPolicyManager::getProfileForOutput(
François Gaffie11d30102018-11-02 16:09:09 +0100821 const DeviceVector& devices,
Michael Chana94fbb22018-04-24 14:31:19 +1000822 uint32_t samplingRate,
823 audio_format_t format,
824 audio_channel_mask_t channelMask,
825 audio_output_flags_t flags,
826 bool directOnly)
Eric Laurente552edb2014-03-10 17:42:56 -0700827{
Michael Chana94fbb22018-04-24 14:31:19 +1000828 if (directOnly) {
829 // only retain flags that will drive the direct output profile selection
830 // if explicitly requested
831 static const uint32_t kRelevantFlags =
832 (AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD |
Aniket Kumar Lataba810b82019-07-03 11:15:33 -0700833 AUDIO_OUTPUT_FLAG_VOIP_RX | AUDIO_OUTPUT_FLAG_MMAP_NOIRQ);
Michael Chana94fbb22018-04-24 14:31:19 +1000834 flags =
835 (audio_output_flags_t)((flags & kRelevantFlags) | AUDIO_OUTPUT_FLAG_DIRECT);
836 }
Eric Laurent861a6282015-05-18 15:40:16 -0700837
838 sp<IOProfile> profile;
839
Mikhail Naganovd4120142017-12-06 15:49:22 -0800840 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -0800841 for (const auto& curProfile : hwModule->getOutputProfiles()) {
François Gaffie11d30102018-11-02 16:09:09 +0100842 if (!curProfile->isCompatibleProfile(devices,
Andy Hungf129b032015-04-07 13:45:50 -0700843 samplingRate, NULL /*updatedSamplingRate*/,
844 format, NULL /*updatedFormat*/,
845 channelMask, NULL /*updatedChannelMask*/,
Eric Laurent861a6282015-05-18 15:40:16 -0700846 flags)) {
847 continue;
848 }
849 // reject profiles not corresponding to a device currently available
François Gaffie11d30102018-11-02 16:09:09 +0100850 if (!mAvailableOutputDevices.containsAtLeastOne(curProfile->getSupportedDevices())) {
Eric Laurent861a6282015-05-18 15:40:16 -0700851 continue;
852 }
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800853 // reject profiles if connected device does not support codec
jiabin9a3361e2019-10-01 09:38:30 -0700854 if (!curProfile->devicesSupportEncodedFormats(devices.types())) {
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800855 continue;
856 }
Michael Chana94fbb22018-04-24 14:31:19 +1000857 if (!directOnly) return curProfile;
858 // when searching for direct outputs, if several profiles are compatible, give priority
859 // to one with offload capability
François Gaffiea8ecc2c2015-11-09 16:10:40 +0100860 if (profile != 0 && ((curProfile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0)) {
Eric Laurent861a6282015-05-18 15:40:16 -0700861 continue;
862 }
863 profile = curProfile;
François Gaffiea8ecc2c2015-11-09 16:10:40 +0100864 if ((profile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
Eric Laurent861a6282015-05-18 15:40:16 -0700865 break;
Eric Laurent3a4311c2014-03-17 12:00:47 -0700866 }
Eric Laurente552edb2014-03-10 17:42:56 -0700867 }
868 }
Eric Laurent861a6282015-05-18 15:40:16 -0700869 return profile;
Eric Laurente552edb2014-03-10 17:42:56 -0700870}
871
Eric Laurentf4e63452017-11-06 19:31:46 +0000872audio_io_handle_t AudioPolicyManager::getOutput(audio_stream_type_t stream)
Eric Laurente552edb2014-03-10 17:42:56 -0700873{
François Gaffiec005e562018-11-06 15:04:49 +0100874 DeviceVector devices = mEngine->getOutputDevicesForStream(stream, false /*fromCache*/);
Andy Hungc9901522017-11-10 20:07:54 -0800875
876 // Note that related method getOutputForAttr() uses getOutputForDevice() not selectOutput().
877 // We use selectOutput() here since we don't have the desired AudioTrack sample rate,
878 // format, flags, etc. This may result in some discrepancy for functions that utilize
879 // getOutput() solely on audio_stream_type such as AudioSystem::getOutputFrameCount()
880 // and AudioSystem::getOutputSamplingRate().
881
François Gaffie11d30102018-11-02 16:09:09 +0100882 SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
Eric Laurent16c66dd2019-05-01 17:54:10 -0700883 const audio_io_handle_t output = selectOutput(outputs);
Eric Laurente552edb2014-03-10 17:42:56 -0700884
François Gaffie11d30102018-11-02 16:09:09 +0100885 ALOGV("getOutput() stream %d selected devices %s, output %d", stream,
886 devices.toString().c_str(), output);
Eric Laurentf4e63452017-11-06 19:31:46 +0000887 return output;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700888}
889
Hongwei Wangbb93dfb2018-10-23 13:54:22 -0700890status_t AudioPolicyManager::getAudioAttributes(audio_attributes_t *dstAttr,
891 const audio_attributes_t *srcAttr,
892 audio_stream_type_t srcStream)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700893{
Hongwei Wangbb93dfb2018-10-23 13:54:22 -0700894 if (srcAttr != NULL) {
895 if (!isValidAttributes(srcAttr)) {
896 ALOGE("%s invalid attributes: usage=%d content=%d flags=0x%x tags=[%s]",
897 __func__,
898 srcAttr->usage, srcAttr->content_type, srcAttr->flags,
899 srcAttr->tags);
900 return BAD_VALUE;
901 }
902 *dstAttr = *srcAttr;
903 } else {
904 if (srcStream < AUDIO_STREAM_MIN || srcStream >= AUDIO_STREAM_PUBLIC_CNT) {
905 ALOGE("%s: invalid stream type", __func__);
906 return BAD_VALUE;
907 }
François Gaffiec005e562018-11-06 15:04:49 +0100908 *dstAttr = mEngine->getAttributesForStreamType(srcStream);
Hongwei Wangbb93dfb2018-10-23 13:54:22 -0700909 }
Eric Laurent22fcda22019-05-17 16:28:47 -0700910
911 // Only honor audibility enforced when required. The client will be
912 // forced to reconnect if the forced usage changes.
913 if (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) != AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
914 dstAttr->flags &= ~AUDIO_FLAG_AUDIBILITY_ENFORCED;
915 }
916
Hongwei Wangbb93dfb2018-10-23 13:54:22 -0700917 return NO_ERROR;
918}
919
Kevin Rocard153f92d2018-12-18 18:33:28 -0800920status_t AudioPolicyManager::getOutputForAttrInt(
921 audio_attributes_t *resultAttr,
922 audio_io_handle_t *output,
923 audio_session_t session,
924 const audio_attributes_t *attr,
925 audio_stream_type_t *stream,
926 uid_t uid,
927 const audio_config_t *config,
928 audio_output_flags_t *flags,
929 audio_port_handle_t *selectedDeviceId,
930 bool *isRequestedDeviceForExclusiveUse,
Eric Laurent8a1095a2019-11-08 14:44:16 -0800931 std::vector<sp<SwAudioOutputDescriptor>> *secondaryDescs,
932 output_type_t *outputType)
Hongwei Wangbb93dfb2018-10-23 13:54:22 -0700933{
François Gaffiec005e562018-11-06 15:04:49 +0100934 DeviceVector outputDevices;
Francois Gaffie716e1432019-01-14 16:58:59 +0100935 const audio_port_handle_t requestedPortId = *selectedDeviceId;
François Gaffie11d30102018-11-02 16:09:09 +0100936 DeviceVector msdDevices = getMsdAudioOutDevices();
François Gaffiec005e562018-11-06 15:04:49 +0100937 const sp<DeviceDescriptor> requestedDevice =
938 mAvailableOutputDevices.getDeviceFromId(requestedPortId);
939
Eric Laurent8a1095a2019-11-08 14:44:16 -0800940 *outputType = API_OUTPUT_INVALID;
Hongwei Wangbb93dfb2018-10-23 13:54:22 -0700941 status_t status = getAudioAttributes(resultAttr, attr, *stream);
942 if (status != NO_ERROR) {
943 return status;
Eric Laurent8f42ea12018-08-08 09:08:25 -0700944 }
Kevin Rocardb99cc752019-03-21 20:52:24 -0700945 if (auto it = mAllowedCapturePolicies.find(uid); it != end(mAllowedCapturePolicies)) {
946 resultAttr->flags |= it->second;
947 }
François Gaffiec005e562018-11-06 15:04:49 +0100948 *stream = mEngine->getStreamTypeForAttributes(*resultAttr);
Eric Laurent8f42ea12018-08-08 09:08:25 -0700949
François Gaffiec005e562018-11-06 15:04:49 +0100950 ALOGV("%s() attributes=%s stream=%s session %d selectedDeviceId %d", __func__,
951 toString(*resultAttr).c_str(), toString(*stream).c_str(), session, requestedPortId);
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700952
Kevin Rocard153f92d2018-12-18 18:33:28 -0800953 // The primary output is the explicit routing (eg. setPreferredDevice) if specified,
954 // otherwise, fallback to the dynamic policies, if none match, query the engine.
955 // Secondary outputs are always found by dynamic policies as the engine do not support them
956 sp<SwAudioOutputDescriptor> policyDesc;
Kevin Rocard94114a22019-04-01 19:38:23 -0700957 status = mPolicyMixes.getOutputForAttr(*resultAttr, uid, *flags, policyDesc, secondaryDescs);
958 if (status != OK) {
959 return status;
Kevin Rocard153f92d2018-12-18 18:33:28 -0800960 }
Kevin Rocard94114a22019-04-01 19:38:23 -0700961
Kevin Rocard153f92d2018-12-18 18:33:28 -0800962 // Explicit routing is higher priority then any dynamic policy primary output
963 bool usePrimaryOutputFromPolicyMixes = requestedDevice == nullptr && policyDesc != nullptr;
964
965 // FIXME: in case of RENDER policy, the output capabilities should be checked
966 if ((usePrimaryOutputFromPolicyMixes || !secondaryDescs->empty())
Kevin Rocardc2afbdf2019-01-31 18:18:06 -0800967 && !audio_is_linear_pcm(config->format)) {
968 ALOGD("%s: rejecting request as dynamic audio policy only support pcm", __func__);
Kevin Rocard153f92d2018-12-18 18:33:28 -0800969 return BAD_VALUE;
970 }
971 if (usePrimaryOutputFromPolicyMixes) {
972 *output = policyDesc->mIoHandle;
Mikhail Naganovbfac5832019-03-05 16:55:28 -0800973 sp<AudioPolicyMix> mix = policyDesc->mPolicyMix.promote();
Jean-Michel Trivif41599b2020-01-07 14:22:08 -0800974 if (mix != nullptr) {
975 sp<DeviceDescriptor> deviceDesc =
976 mAvailableOutputDevices.getDevice(mix->mDeviceType,
977 mix->mDeviceAddress,
978 AUDIO_FORMAT_DEFAULT);
979 *selectedDeviceId = deviceDesc != 0 ? deviceDesc->getId() : AUDIO_PORT_HANDLE_NONE;
Eric Laurent8a1095a2019-11-08 14:44:16 -0800980
Jean-Michel Trivif41599b2020-01-07 14:22:08 -0800981 ALOGV("getOutputForAttr() returns output %d", *output);
982 if (resultAttr->usage == AUDIO_USAGE_VIRTUAL_SOURCE) {
983 *outputType = API_OUT_MIX_PLAYBACK;
984 } else {
985 *outputType = API_OUTPUT_LEGACY;
986 }
987 return NO_ERROR;
Eric Laurent8a1095a2019-11-08 14:44:16 -0800988 }
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700989 }
François Gaffiec005e562018-11-06 15:04:49 +0100990 // Virtual sources must always be dynamicaly or explicitly routed
991 if (resultAttr->usage == AUDIO_USAGE_VIRTUAL_SOURCE) {
992 ALOGW("getOutputForAttr() no policy mix found for usage AUDIO_USAGE_VIRTUAL_SOURCE");
993 return BAD_VALUE;
994 }
995 // explicit routing managed by getDeviceForStrategy in APM is now handled by engine
996 // in order to let the choice of the order to future vendor engine
997 outputDevices = mEngine->getOutputDevicesForAttributes(*resultAttr, requestedDevice, false);
Scott Randolph7b1fd232018-06-18 15:33:03 -0700998
Hongwei Wangbb93dfb2018-10-23 13:54:22 -0700999 if ((resultAttr->flags & AUDIO_FLAG_HW_AV_SYNC) != 0) {
Nadav Bar766fb022018-01-07 12:18:03 +02001000 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_HW_AV_SYNC);
Eric Laurent93c3d412014-08-01 14:48:35 -07001001 }
1002
Nadav Barb2f18162018-07-18 13:01:53 +03001003 // Set incall music only if device was explicitly set, and fallback to the device which is
1004 // chosen by the engine if not.
1005 // FIXME: provide a more generic approach which is not device specific and move this back
1006 // to getOutputForDevice.
Nadav Bar20919492018-11-20 10:20:51 +02001007 // TODO: Remove check of AUDIO_STREAM_MUSIC once migration is completed on the app side.
jiabin9a3361e2019-10-01 09:38:30 -07001008 if (outputDevices.onlyContainsDevicesWithType(AUDIO_DEVICE_OUT_TELEPHONY_TX) &&
François Gaffiec005e562018-11-06 15:04:49 +01001009 (*stream == AUDIO_STREAM_MUSIC || resultAttr->usage == AUDIO_USAGE_VOICE_COMMUNICATION) &&
Nadav Barb2f18162018-07-18 13:01:53 +03001010 audio_is_linear_pcm(config->format) &&
Eric Laurent74b71512019-11-06 17:21:57 -08001011 isCallAudioAccessible()) {
Francois Gaffie716e1432019-01-14 16:58:59 +01001012 if (requestedPortId != AUDIO_PORT_HANDLE_NONE) {
Nadav Barb2f18162018-07-18 13:01:53 +03001013 *flags = (audio_output_flags_t)AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
François Gaffief579db52018-11-13 11:25:16 +01001014 *isRequestedDeviceForExclusiveUse = true;
Nadav Barb2f18162018-07-18 13:01:53 +03001015 }
1016 }
1017
François Gaffiec005e562018-11-06 15:04:49 +01001018 ALOGV("%s() device %s, sampling rate %d, format %#x, channel mask %#x, flags %#x stream %s",
1019 __func__, outputDevices.toString().c_str(), config->sample_rate, config->format,
1020 config->channel_mask, *flags, toString(*stream).c_str());
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001021
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001022 *output = AUDIO_IO_HANDLE_NONE;
François Gaffie11d30102018-11-02 16:09:09 +01001023 if (!msdDevices.isEmpty()) {
1024 *output = getOutputForDevices(msdDevices, session, *stream, config, flags);
François Gaffiec005e562018-11-06 15:04:49 +01001025 sp<DeviceDescriptor> device = outputDevices.isEmpty() ? nullptr : outputDevices.itemAt(0);
1026 if (*output != AUDIO_IO_HANDLE_NONE && setMsdPatch(device) == NO_ERROR) {
1027 ALOGV("%s() Using MSD devices %s instead of devices %s",
1028 __func__, msdDevices.toString().c_str(), outputDevices.toString().c_str());
1029 outputDevices = msdDevices;
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001030 } else {
1031 *output = AUDIO_IO_HANDLE_NONE;
1032 }
1033 }
1034 if (*output == AUDIO_IO_HANDLE_NONE) {
jiabine375d412019-02-26 12:54:53 -08001035 *output = getOutputForDevices(outputDevices, session, *stream, config,
Eric Laurent42984412019-05-09 17:57:03 -07001036 flags, resultAttr->flags & AUDIO_FLAG_MUTE_HAPTIC);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001037 }
Eric Laurente83b55d2014-11-14 10:06:21 -08001038 if (*output == AUDIO_IO_HANDLE_NONE) {
1039 return INVALID_OPERATION;
1040 }
Paul McLeanaa981192015-03-21 09:55:15 -07001041
François Gaffiec005e562018-11-06 15:04:49 +01001042 *selectedDeviceId = getFirstDeviceId(outputDevices);
Eric Laurent2ac76942017-06-22 17:17:09 -07001043
Eric Laurent8a1095a2019-11-08 14:44:16 -08001044 if (outputDevices.onlyContainsDevicesWithType(AUDIO_DEVICE_OUT_TELEPHONY_TX)) {
1045 *outputType = API_OUTPUT_TELEPHONY_TX;
1046 } else {
1047 *outputType = API_OUTPUT_LEGACY;
1048 }
1049
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001050 ALOGV("%s returns output %d selectedDeviceId %d", __func__, *output, *selectedDeviceId);
1051
1052 return NO_ERROR;
1053}
1054
1055status_t AudioPolicyManager::getOutputForAttr(const audio_attributes_t *attr,
1056 audio_io_handle_t *output,
1057 audio_session_t session,
1058 audio_stream_type_t *stream,
1059 uid_t uid,
1060 const audio_config_t *config,
1061 audio_output_flags_t *flags,
1062 audio_port_handle_t *selectedDeviceId,
Kevin Rocard153f92d2018-12-18 18:33:28 -08001063 audio_port_handle_t *portId,
Eric Laurent8a1095a2019-11-08 14:44:16 -08001064 std::vector<audio_io_handle_t> *secondaryOutputs,
1065 output_type_t *outputType)
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001066{
1067 // The supplied portId must be AUDIO_PORT_HANDLE_NONE
1068 if (*portId != AUDIO_PORT_HANDLE_NONE) {
1069 return INVALID_OPERATION;
1070 }
Francois Gaffie716e1432019-01-14 16:58:59 +01001071 const audio_port_handle_t requestedPortId = *selectedDeviceId;
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001072 audio_attributes_t resultAttr;
François Gaffief579db52018-11-13 11:25:16 +01001073 bool isRequestedDeviceForExclusiveUse = false;
Kevin Rocard153f92d2018-12-18 18:33:28 -08001074 std::vector<sp<SwAudioOutputDescriptor>> secondaryOutputDescs;
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01001075 const sp<DeviceDescriptor> requestedDevice =
1076 mAvailableOutputDevices.getDeviceFromId(requestedPortId);
1077
1078 // Prevent from storing invalid requested device id in clients
1079 const audio_port_handle_t sanitizedRequestedPortId =
1080 requestedDevice != nullptr ? requestedPortId : AUDIO_PORT_HANDLE_NONE;
1081 *selectedDeviceId = sanitizedRequestedPortId;
1082
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001083 status_t status = getOutputForAttrInt(&resultAttr, output, session, attr, stream, uid,
Kevin Rocard153f92d2018-12-18 18:33:28 -08001084 config, flags, selectedDeviceId, &isRequestedDeviceForExclusiveUse,
Eric Laurent8a1095a2019-11-08 14:44:16 -08001085 &secondaryOutputDescs, outputType);
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001086 if (status != NO_ERROR) {
1087 return status;
1088 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08001089 std::vector<wp<SwAudioOutputDescriptor>> weakSecondaryOutputDescs;
1090 for (auto& secondaryDesc : secondaryOutputDescs) {
1091 secondaryOutputs->push_back(secondaryDesc->mIoHandle);
1092 weakSecondaryOutputDescs.push_back(secondaryDesc);
1093 }
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001094
Eric Laurent8fc147b2018-07-22 19:13:55 -07001095 audio_config_base_t clientConfig = {.sample_rate = config->sample_rate,
Nick Desaulniersa30e3202019-10-18 13:38:23 -07001096 .channel_mask = config->channel_mask,
Eric Laurent8fc147b2018-07-22 19:13:55 -07001097 .format = config->format,
Nick Desaulniersa30e3202019-10-18 13:38:23 -07001098 };
jiabin4ef93452019-09-10 14:29:54 -07001099 *portId = PolicyAudioPort::getNextUniqueId();
Eric Laurent8f42ea12018-08-08 09:08:25 -07001100
Eric Laurent8fc147b2018-07-22 19:13:55 -07001101 sp<TrackClientDescriptor> clientDesc =
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001102 new TrackClientDescriptor(*portId, uid, session, resultAttr, clientConfig,
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01001103 sanitizedRequestedPortId, *stream,
François Gaffiec005e562018-11-06 15:04:49 +01001104 mEngine->getProductStrategyForAttributes(resultAttr),
François Gaffieaaac0fd2018-11-22 17:56:39 +01001105 toVolumeSource(resultAttr),
Kevin Rocard153f92d2018-12-18 18:33:28 -08001106 *flags, isRequestedDeviceForExclusiveUse,
1107 std::move(weakSecondaryOutputDescs));
Eric Laurent8fc147b2018-07-22 19:13:55 -07001108 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(*output);
Andy Hung39efb7a2018-09-26 15:39:28 -07001109 outputDesc->addClient(clientDesc);
Eric Laurent8fc147b2018-07-22 19:13:55 -07001110
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01001111 ALOGV("%s() returns output %d requestedPortId %d selectedDeviceId %d for port ID %d", __func__,
1112 *output, requestedPortId, *selectedDeviceId, *portId);
Eric Laurent2ac76942017-06-22 17:17:09 -07001113
Eric Laurente83b55d2014-11-14 10:06:21 -08001114 return NO_ERROR;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001115}
1116
François Gaffie11d30102018-11-02 16:09:09 +01001117audio_io_handle_t AudioPolicyManager::getOutputForDevices(
1118 const DeviceVector &devices,
Kevin Rocard169753c2017-03-06 14:18:23 -08001119 audio_session_t session,
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001120 audio_stream_type_t stream,
Eric Laurentfe231122017-11-17 17:48:06 -08001121 const audio_config_t *config,
jiabine375d412019-02-26 12:54:53 -08001122 audio_output_flags_t *flags,
1123 bool forceMutingHaptic)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001124{
Andy Hungc88b0642018-04-27 15:42:35 -07001125 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
Eric Laurentcf2c0212014-07-25 16:20:43 -07001126 status_t status;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001127
jiabine375d412019-02-26 12:54:53 -08001128 // Discard haptic channel mask when forcing muting haptic channels.
1129 audio_channel_mask_t channelMask = forceMutingHaptic
1130 ? (config->channel_mask & ~AUDIO_CHANNEL_HAPTIC_ALL) : config->channel_mask;
1131
Eric Laurente552edb2014-03-10 17:42:56 -07001132 // open a direct output if required by specified parameters
1133 //force direct flag if offload flag is set: offloading implies a direct output stream
1134 // and all common behaviors are driven by checking only the direct flag
1135 // this should normally be set appropriately in the policy configuration file
Nadav Bar766fb022018-01-07 12:18:03 +02001136 if ((*flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
1137 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_DIRECT);
Eric Laurente552edb2014-03-10 17:42:56 -07001138 }
Nadav Bar766fb022018-01-07 12:18:03 +02001139 if ((*flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) {
1140 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_DIRECT);
Eric Laurent93c3d412014-08-01 14:48:35 -07001141 }
Eric Laurente83b55d2014-11-14 10:06:21 -08001142 // only allow deep buffering for music stream type
1143 if (stream != AUDIO_STREAM_MUSIC) {
Nadav Bar766fb022018-01-07 12:18:03 +02001144 *flags = (audio_output_flags_t)(*flags &~AUDIO_OUTPUT_FLAG_DEEP_BUFFER);
Ravi Kumar Alamanda439e4ed2015-04-03 12:13:21 -07001145 } else if (/* stream == AUDIO_STREAM_MUSIC && */
Nadav Bar766fb022018-01-07 12:18:03 +02001146 *flags == AUDIO_OUTPUT_FLAG_NONE &&
Ravi Kumar Alamanda439e4ed2015-04-03 12:13:21 -07001147 property_get_bool("audio.deep_buffer.media", false /* default_value */)) {
1148 // use DEEP_BUFFER as default output for music stream type
Nadav Bar766fb022018-01-07 12:18:03 +02001149 *flags = (audio_output_flags_t)AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
Eric Laurente83b55d2014-11-14 10:06:21 -08001150 }
Ravi Kumar Alamandac36a8892015-04-24 16:35:49 -07001151 if (stream == AUDIO_STREAM_TTS) {
Nadav Bar766fb022018-01-07 12:18:03 +02001152 *flags = AUDIO_OUTPUT_FLAG_TTS;
Haynes Mathew George84c621e2017-04-25 11:41:50 -07001153 } else if (stream == AUDIO_STREAM_VOICE_CALL &&
Nadav Bar20919492018-11-20 10:20:51 +02001154 audio_is_linear_pcm(config->format) &&
1155 (*flags & AUDIO_OUTPUT_FLAG_INCALL_MUSIC) == 0) {
Nadav Bar766fb022018-01-07 12:18:03 +02001156 *flags = (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_VOIP_RX |
Haynes Mathew George84c621e2017-04-25 11:41:50 -07001157 AUDIO_OUTPUT_FLAG_DIRECT);
1158 ALOGV("Set VoIP and Direct output flags for PCM format");
Ravi Kumar Alamandac36a8892015-04-24 16:35:49 -07001159 }
Eric Laurente552edb2014-03-10 17:42:56 -07001160
Nadav Bar766fb022018-01-07 12:18:03 +02001161
Eric Laurentb732cf52014-09-24 19:08:21 -07001162 sp<IOProfile> profile;
1163
1164 // skip direct output selection if the request can obviously be attached to a mixed output
Eric Laurentc2607842014-09-29 09:43:03 -07001165 // and not explicitly requested
Nadav Bar766fb022018-01-07 12:18:03 +02001166 if (((*flags & AUDIO_OUTPUT_FLAG_DIRECT) == 0) &&
Eric Laurentfe231122017-11-17 17:48:06 -08001167 audio_is_linear_pcm(config->format) && config->sample_rate <= SAMPLE_RATE_HZ_MAX &&
jiabine375d412019-02-26 12:54:53 -08001168 audio_channel_count_from_out_mask(channelMask) <= 2) {
Eric Laurentb732cf52014-09-24 19:08:21 -07001169 goto non_direct_output;
1170 }
1171
Andy Hung2ddee192015-12-18 17:34:44 -08001172 // Do not allow offloading if one non offloadable effect is enabled or MasterMono is enabled.
1173 // This prevents creating an offloaded track and tearing it down immediately after start
1174 // when audioflinger detects there is an active non offloadable effect.
Eric Laurente552edb2014-03-10 17:42:56 -07001175 // FIXME: We should check the audio session here but we do not have it in this context.
1176 // This may prevent offloading in rare situations where effects are left active by apps
1177 // in the background.
Eric Laurentb732cf52014-09-24 19:08:21 -07001178
Nadav Bar766fb022018-01-07 12:18:03 +02001179 if (((*flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) ||
Andy Hung2ddee192015-12-18 17:34:44 -08001180 !(mEffects.isNonOffloadableEffectEnabled() || mMasterMono)) {
François Gaffie11d30102018-11-02 16:09:09 +01001181 profile = getProfileForOutput(devices,
Michael Chana94fbb22018-04-24 14:31:19 +10001182 config->sample_rate,
1183 config->format,
jiabine375d412019-02-26 12:54:53 -08001184 channelMask,
Michael Chana94fbb22018-04-24 14:31:19 +10001185 (audio_output_flags_t)*flags,
1186 true /* directOnly */);
Eric Laurente552edb2014-03-10 17:42:56 -07001187 }
1188
Eric Laurent1c333e22014-05-20 10:48:17 -07001189 if (profile != 0) {
Andy Hungc88b0642018-04-27 15:42:35 -07001190 // exclusive outputs for MMAP and Offload are enforced by different session ids.
1191 for (size_t i = 0; i < mOutputs.size(); i++) {
1192 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
1193 if (!desc->isDuplicated() && (profile == desc->mProfile)) {
1194 // reuse direct output if currently open by the same client
1195 // and configured with same parameters
jiabin5740f082019-08-19 15:08:30 -07001196 if ((config->sample_rate == desc->getSamplingRate()) &&
1197 (config->format == desc->getFormat()) &&
1198 (channelMask == desc->getChannelMask()) &&
Andy Hungc88b0642018-04-27 15:42:35 -07001199 (session == desc->mDirectClientSession)) {
1200 desc->mDirectOpenCount++;
François Gaffie11d30102018-11-02 16:09:09 +01001201 ALOGI("%s reusing direct output %d for session %d", __func__,
Andy Hungc88b0642018-04-27 15:42:35 -07001202 mOutputs.keyAt(i), session);
1203 return mOutputs.keyAt(i);
Eric Laurente552edb2014-03-10 17:42:56 -07001204 }
1205 }
1206 }
Eric Laurent3974e3b2017-12-07 17:58:43 -08001207
1208 if (!profile->canOpenNewIo()) {
1209 goto non_direct_output;
Eric Laurente552edb2014-03-10 17:42:56 -07001210 }
Eric Laurent861a6282015-05-18 15:40:16 -07001211
Eric Laurent3974e3b2017-12-07 17:58:43 -08001212 sp<SwAudioOutputDescriptor> outputDesc =
1213 new SwAudioOutputDescriptor(profile, mpClientInterface);
Eric Laurent53b810e2017-12-10 17:25:10 -08001214
François Gaffie11d30102018-11-02 16:09:09 +01001215 String8 address = getFirstDeviceAddress(devices);
Eric Laurent53b810e2017-12-10 17:25:10 -08001216
Dean Wheatley3023b382018-08-09 07:42:40 +10001217 // MSD patch may be using the only output stream that can service this request. Release
1218 // MSD patch to prioritize this request over any active output on MSD.
1219 AudioPatchCollection msdPatches = getMsdPatches();
1220 for (size_t i = 0; i < msdPatches.size(); i++) {
1221 const auto& patch = msdPatches[i];
1222 for (size_t j = 0; j < patch->mPatch.num_sinks; ++j) {
1223 const struct audio_port_config *sink = &patch->mPatch.sinks[j];
1224 if (sink->type == AUDIO_PORT_TYPE_DEVICE &&
jiabin9a3361e2019-10-01 09:38:30 -07001225 devices.containsDeviceWithType(sink->ext.device.type) &&
Dean Wheatley3023b382018-08-09 07:42:40 +10001226 (address.isEmpty() || strncmp(sink->ext.device.address, address.string(),
1227 AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0)) {
1228 releaseAudioPatch(patch->mHandle, mUidCached);
1229 break;
1230 }
1231 }
1232 }
1233
François Gaffie11d30102018-11-02 16:09:09 +01001234 status = outputDesc->open(config, devices, stream, *flags, &output);
Eric Laurente552edb2014-03-10 17:42:56 -07001235
1236 // only accept an output with the requested parameters
Eric Laurentcf2c0212014-07-25 16:20:43 -07001237 if (status != NO_ERROR ||
jiabin5740f082019-08-19 15:08:30 -07001238 (config->sample_rate != 0 && config->sample_rate != outputDesc->getSamplingRate()) ||
1239 (config->format != AUDIO_FORMAT_DEFAULT && config->format != outputDesc->getFormat()) ||
1240 (channelMask != 0 && channelMask != outputDesc->getChannelMask())) {
François Gaffie11d30102018-11-02 16:09:09 +01001241 ALOGV("%s failed opening direct output: output %d sample rate %d %d,"
1242 "format %d %d, channel mask %04x %04x", __func__, output, config->sample_rate,
jiabin5740f082019-08-19 15:08:30 -07001243 outputDesc->getSamplingRate(), config->format, outputDesc->getFormat(),
1244 channelMask, outputDesc->getChannelMask());
Eric Laurentcf2c0212014-07-25 16:20:43 -07001245 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurentfe231122017-11-17 17:48:06 -08001246 outputDesc->close();
Eric Laurente552edb2014-03-10 17:42:56 -07001247 }
Eric Laurenta82797f2015-01-30 11:49:43 -08001248 // fall back to mixer output if possible when the direct output could not be open
Eric Laurentfe231122017-11-17 17:48:06 -08001249 if (audio_is_linear_pcm(config->format) &&
1250 config->sample_rate <= SAMPLE_RATE_HZ_MAX) {
Eric Laurenta82797f2015-01-30 11:49:43 -08001251 goto non_direct_output;
1252 }
Eric Laurentcf2c0212014-07-25 16:20:43 -07001253 return AUDIO_IO_HANDLE_NONE;
Eric Laurente552edb2014-03-10 17:42:56 -07001254 }
Eric Laurentcf2c0212014-07-25 16:20:43 -07001255 outputDesc->mDirectOpenCount = 1;
Kevin Rocard169753c2017-03-06 14:18:23 -08001256 outputDesc->mDirectClientSession = session;
1257
Eric Laurente552edb2014-03-10 17:42:56 -07001258 addOutput(output, outputDesc);
Eric Laurente552edb2014-03-10 17:42:56 -07001259 mPreviousOutputs = mOutputs;
François Gaffie11d30102018-11-02 16:09:09 +01001260 ALOGV("%s returns new direct output %d", __func__, output);
Eric Laurentb52c1522014-05-20 11:27:36 -07001261 mpClientInterface->onAudioPortListUpdate();
Eric Laurente552edb2014-03-10 17:42:56 -07001262 return output;
1263 }
1264
Eric Laurentb732cf52014-09-24 19:08:21 -07001265non_direct_output:
Eric Laurent14cbfca2016-03-17 09:42:16 -07001266
1267 // A request for HW A/V sync cannot fallback to a mixed output because time
1268 // stamps are embedded in audio data
Phil Burk2d059932018-02-15 15:55:11 -08001269 if ((*flags & (AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_MMAP_NOIRQ)) != 0) {
Eric Laurent14cbfca2016-03-17 09:42:16 -07001270 return AUDIO_IO_HANDLE_NONE;
1271 }
1272
Eric Laurente552edb2014-03-10 17:42:56 -07001273 // ignoring channel mask due to downmix capability in mixer
1274
1275 // open a non direct output
1276
1277 // for non direct outputs, only PCM is supported
Eric Laurentfe231122017-11-17 17:48:06 -08001278 if (audio_is_linear_pcm(config->format)) {
Eric Laurente552edb2014-03-10 17:42:56 -07001279 // get which output is suitable for the specified stream. The actual
1280 // routing change will happen when startOutput() will be called
François Gaffie11d30102018-11-02 16:09:09 +01001281 SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
Eric Laurente552edb2014-03-10 17:42:56 -07001282
Eric Laurent8838a382014-09-08 16:44:28 -07001283 // at this stage we should ignore the DIRECT flag as no direct output could be found earlier
Nadav Bar766fb022018-01-07 12:18:03 +02001284 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_DIRECT);
jiabine375d412019-02-26 12:54:53 -08001285 output = selectOutput(outputs, *flags, config->format, channelMask, config->sample_rate);
Eric Laurente552edb2014-03-10 17:42:56 -07001286 }
François Gaffie11d30102018-11-02 16:09:09 +01001287 ALOGW_IF((output == 0), "getOutputForDevices() could not find output for stream %d, "
Glenn Kasten49f36ba2017-12-06 13:02:02 -08001288 "sampling rate %d, format %#x, channels %#x, flags %#x",
jiabine375d412019-02-26 12:54:53 -08001289 stream, config->sample_rate, config->format, channelMask, *flags);
Eric Laurente552edb2014-03-10 17:42:56 -07001290
Eric Laurente552edb2014-03-10 17:42:56 -07001291 return output;
1292}
1293
Mikhail Naganovf02f3672018-11-09 12:44:16 -08001294sp<DeviceDescriptor> AudioPolicyManager::getMsdAudioInDevice() const {
François Gaffie11d30102018-11-02 16:09:09 +01001295 auto msdInDevices = mHwModules.getAvailableDevicesFromModuleName(AUDIO_HARDWARE_MODULE_ID_MSD,
1296 mAvailableInputDevices);
1297 return msdInDevices.isEmpty()? nullptr : msdInDevices.itemAt(0);
1298}
1299
1300DeviceVector AudioPolicyManager::getMsdAudioOutDevices() const {
1301 return mHwModules.getAvailableDevicesFromModuleName(AUDIO_HARDWARE_MODULE_ID_MSD,
1302 mAvailableOutputDevices);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001303}
1304
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001305const AudioPatchCollection AudioPolicyManager::getMsdPatches() const {
1306 AudioPatchCollection msdPatches;
Mikhail Naganov86112352018-10-04 09:02:49 -07001307 sp<HwModule> msdModule = mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD);
1308 if (msdModule != 0) {
1309 for (size_t i = 0; i < mAudioPatches.size(); ++i) {
1310 sp<AudioPatch> patch = mAudioPatches.valueAt(i);
1311 for (size_t j = 0; j < patch->mPatch.num_sources; ++j) {
1312 const struct audio_port_config *source = &patch->mPatch.sources[j];
1313 if (source->type == AUDIO_PORT_TYPE_DEVICE &&
1314 source->ext.device.hw_module == msdModule->getHandle()) {
1315 msdPatches.addAudioPatch(patch->mHandle, patch);
1316 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001317 }
1318 }
1319 }
1320 return msdPatches;
1321}
1322
François Gaffie11d30102018-11-02 16:09:09 +01001323status_t AudioPolicyManager::getBestMsdAudioProfileFor(const sp<DeviceDescriptor> &outputDevice,
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001324 bool hwAvSync, audio_port_config *sourceConfig, audio_port_config *sinkConfig) const
1325{
Mikhail Naganov7bd9b8d2018-11-15 02:09:03 +00001326 sp<HwModule> msdModule = mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001327 if (msdModule == nullptr) {
1328 ALOGE("%s() unable to get MSD module", __func__);
1329 return NO_INIT;
1330 }
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08001331 sp<HwModule> deviceModule = mHwModules.getModuleForDevice(outputDevice, AUDIO_FORMAT_DEFAULT);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001332 if (deviceModule == nullptr) {
François Gaffie11d30102018-11-02 16:09:09 +01001333 ALOGE("%s() unable to get module for %s", __func__, outputDevice->toString().c_str());
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001334 return NO_INIT;
1335 }
1336 const InputProfileCollection &inputProfiles = msdModule->getInputProfiles();
1337 if (inputProfiles.isEmpty()) {
1338 ALOGE("%s() no input profiles for MSD module", __func__);
1339 return NO_INIT;
1340 }
1341 const OutputProfileCollection &outputProfiles = deviceModule->getOutputProfiles();
1342 if (outputProfiles.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01001343 ALOGE("%s() no output profiles for device %s", __func__, outputDevice->toString().c_str());
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001344 return NO_INIT;
1345 }
1346 AudioProfileVector msdProfiles;
1347 // Each IOProfile represents a MixPort from audio_policy_configuration.xml
1348 for (const auto &inProfile : inputProfiles) {
1349 if (hwAvSync == ((inProfile->getFlags() & AUDIO_INPUT_FLAG_HW_AV_SYNC) != 0)) {
jiabin3e277cc2019-09-10 14:27:34 -07001350 appendAudioProfiles(msdProfiles, inProfile->getAudioProfiles());
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001351 }
1352 }
1353 AudioProfileVector deviceProfiles;
1354 for (const auto &outProfile : outputProfiles) {
1355 if (hwAvSync == ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0)) {
jiabin3e277cc2019-09-10 14:27:34 -07001356 appendAudioProfiles(deviceProfiles, outProfile->getAudioProfiles());
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001357 }
1358 }
1359 struct audio_config_base bestSinkConfig;
jiabin3e277cc2019-09-10 14:27:34 -07001360 status_t result = findBestMatchingOutputConfig(msdProfiles, deviceProfiles,
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001361 compressedFormatsOrder, surroundChannelMasksOrder, true /*preferHigherSamplingRates*/,
jiabin3e277cc2019-09-10 14:27:34 -07001362 bestSinkConfig);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001363 if (result != NO_ERROR) {
François Gaffie11d30102018-11-02 16:09:09 +01001364 ALOGD("%s() no matching profiles found for device: %s, hwAvSync: %d",
1365 __func__, outputDevice->toString().c_str(), hwAvSync);
Greg Kaiser83289652018-07-30 06:13:57 -07001366 return result;
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001367 }
1368 sinkConfig->sample_rate = bestSinkConfig.sample_rate;
1369 sinkConfig->channel_mask = bestSinkConfig.channel_mask;
1370 sinkConfig->format = bestSinkConfig.format;
1371 // For encoded streams force direct flag to prevent downstream mixing.
1372 sinkConfig->flags.output = static_cast<audio_output_flags_t>(
1373 sinkConfig->flags.output | AUDIO_OUTPUT_FLAG_DIRECT);
Dean Wheatley5c9f0832019-11-21 13:39:31 +11001374 if (audio_is_iec61937_compatible(sinkConfig->format)) {
1375 // For formats compatible with IEC61937 encapsulation, assume that
1376 // the record thread input from MSD is IEC61937 framed (for proportional buffer sizing).
1377 // Add the AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO flag so downstream HAL can distinguish between
1378 // raw and IEC61937 framed streams.
1379 sinkConfig->flags.output = static_cast<audio_output_flags_t>(
1380 sinkConfig->flags.output | AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO);
1381 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001382 sourceConfig->sample_rate = bestSinkConfig.sample_rate;
1383 // Specify exact channel mask to prevent guessing by bit count in PatchPanel.
1384 sourceConfig->channel_mask = audio_channel_mask_out_to_in(bestSinkConfig.channel_mask);
1385 sourceConfig->format = bestSinkConfig.format;
1386 // Copy input stream directly without any processing (e.g. resampling).
1387 sourceConfig->flags.input = static_cast<audio_input_flags_t>(
1388 sourceConfig->flags.input | AUDIO_INPUT_FLAG_DIRECT);
1389 if (hwAvSync) {
1390 sinkConfig->flags.output = static_cast<audio_output_flags_t>(
1391 sinkConfig->flags.output | AUDIO_OUTPUT_FLAG_HW_AV_SYNC);
1392 sourceConfig->flags.input = static_cast<audio_input_flags_t>(
1393 sourceConfig->flags.input | AUDIO_INPUT_FLAG_HW_AV_SYNC);
1394 }
1395 const unsigned int config_mask = AUDIO_PORT_CONFIG_SAMPLE_RATE |
1396 AUDIO_PORT_CONFIG_CHANNEL_MASK | AUDIO_PORT_CONFIG_FORMAT | AUDIO_PORT_CONFIG_FLAGS;
1397 sinkConfig->config_mask |= config_mask;
1398 sourceConfig->config_mask |= config_mask;
1399 return NO_ERROR;
1400}
1401
François Gaffie11d30102018-11-02 16:09:09 +01001402PatchBuilder AudioPolicyManager::buildMsdPatch(const sp<DeviceDescriptor> &outputDevice) const
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001403{
1404 PatchBuilder patchBuilder;
François Gaffie11d30102018-11-02 16:09:09 +01001405 patchBuilder.addSource(getMsdAudioInDevice()).addSink(outputDevice);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001406 audio_port_config sourceConfig = patchBuilder.patch()->sources[0];
1407 audio_port_config sinkConfig = patchBuilder.patch()->sinks[0];
1408 // TODO: Figure out whether MSD module has HW_AV_SYNC flag set in the AP config file.
1409 // For now, we just forcefully try with HwAvSync first.
1410 status_t res = getBestMsdAudioProfileFor(outputDevice, true /*hwAvSync*/,
1411 &sourceConfig, &sinkConfig) == NO_ERROR ? NO_ERROR :
1412 getBestMsdAudioProfileFor(
1413 outputDevice, false /*hwAvSync*/, &sourceConfig, &sinkConfig);
1414 if (res == NO_ERROR) {
1415 // Found a matching profile for encoded audio. Re-create PatchBuilder with this config.
1416 return (PatchBuilder()).addSource(sourceConfig).addSink(sinkConfig);
1417 }
1418 ALOGV("%s() no matching profile found. Fall through to default PCM patch"
1419 " supporting PCM format conversion.", __func__);
1420 return patchBuilder;
1421}
1422
François Gaffie11d30102018-11-02 16:09:09 +01001423status_t AudioPolicyManager::setMsdPatch(const sp<DeviceDescriptor> &outputDevice) {
1424 sp<DeviceDescriptor> device = outputDevice;
1425 if (device == nullptr) {
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001426 // Use media strategy for unspecified output device. This should only
1427 // occur on checkForDeviceAndOutputChanges(). Device connection events may
1428 // therefore invalidate explicit routing requests.
François Gaffiec005e562018-11-06 15:04:49 +01001429 DeviceVector devices = mEngine->getOutputDevicesForAttributes(
1430 attributes_initializer(AUDIO_USAGE_MEDIA), nullptr, false /*fromCache*/);
François Gaffie11d30102018-11-02 16:09:09 +01001431 LOG_ALWAYS_FATAL_IF(devices.isEmpty(), "no outpudevice to set Msd Patch");
1432 device = devices.itemAt(0);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001433 }
François Gaffie11d30102018-11-02 16:09:09 +01001434 ALOGV("%s() for device %s", __func__, device->toString().c_str());
1435 PatchBuilder patchBuilder = buildMsdPatch(device);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001436 const struct audio_patch* patch = patchBuilder.patch();
1437 const AudioPatchCollection msdPatches = getMsdPatches();
1438 if (!msdPatches.isEmpty()) {
1439 LOG_ALWAYS_FATAL_IF(msdPatches.size() > 1,
1440 "The current MSD prototype only supports one output patch");
1441 sp<AudioPatch> currentPatch = msdPatches.valueAt(0);
1442 if (audio_patches_are_equal(&currentPatch->mPatch, patch)) {
1443 return NO_ERROR;
1444 }
1445 releaseAudioPatch(currentPatch->mHandle, mUidCached);
1446 }
1447 status_t status = installPatch(__func__, -1 /*index*/, nullptr /*patchHandle*/,
1448 patch, 0 /*delayMs*/, mUidCached, nullptr /*patchDescPtr*/);
1449 ALOGE_IF(status != NO_ERROR, "%s() error %d creating MSD audio patch", __func__, status);
1450 ALOGI_IF(status == NO_ERROR, "%s() Patch created from MSD_IN to "
François Gaffie11d30102018-11-02 16:09:09 +01001451 "device:%s (format:%#x channels:%#x samplerate:%d)", __func__,
1452 device->toString().c_str(), patch->sources[0].format,
1453 patch->sources[0].channel_mask, patch->sources[0].sample_rate);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001454 return status;
1455}
1456
Eric Laurente0720872014-03-11 09:30:41 -07001457audio_io_handle_t AudioPolicyManager::selectOutput(const SortedVector<audio_io_handle_t>& outputs,
Eric Laurent8838a382014-09-08 16:44:28 -07001458 audio_output_flags_t flags,
jiabin40573322018-11-08 12:08:02 -08001459 audio_format_t format,
1460 audio_channel_mask_t channelMask,
1461 uint32_t samplingRate)
Eric Laurente552edb2014-03-10 17:42:56 -07001462{
Eric Laurent16c66dd2019-05-01 17:54:10 -07001463 LOG_ALWAYS_FATAL_IF(!(format == AUDIO_FORMAT_INVALID || audio_is_linear_pcm(format)),
1464 "%s called with format %#x", __func__, format);
1465
1466 // Flags disqualifying an output: the match must happen before calling selectOutput()
1467 static const audio_output_flags_t kExcludedFlags = (audio_output_flags_t)
1468 (AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_MMAP_NOIRQ | AUDIO_OUTPUT_FLAG_DIRECT);
1469
1470 // Flags expressing a functional request: must be honored in priority over
1471 // other criteria
1472 static const audio_output_flags_t kFunctionalFlags = (audio_output_flags_t)
1473 (AUDIO_OUTPUT_FLAG_VOIP_RX | AUDIO_OUTPUT_FLAG_INCALL_MUSIC |
1474 AUDIO_OUTPUT_FLAG_TTS | AUDIO_OUTPUT_FLAG_DIRECT_PCM);
1475 // Flags expressing a performance request: have lower priority than serving
1476 // requested sampling rate or channel mask
1477 static const audio_output_flags_t kPerformanceFlags = (audio_output_flags_t)
1478 (AUDIO_OUTPUT_FLAG_FAST | AUDIO_OUTPUT_FLAG_DEEP_BUFFER |
1479 AUDIO_OUTPUT_FLAG_RAW | AUDIO_OUTPUT_FLAG_SYNC);
1480
1481 const audio_output_flags_t functionalFlags =
1482 (audio_output_flags_t)(flags & kFunctionalFlags);
1483 const audio_output_flags_t performanceFlags =
1484 (audio_output_flags_t)(flags & kPerformanceFlags);
1485
1486 audio_io_handle_t bestOutput = (outputs.size() == 0) ? AUDIO_IO_HANDLE_NONE : outputs[0];
1487
Eric Laurente552edb2014-03-10 17:42:56 -07001488 // select one output among several that provide a path to a particular device or set of
François Gaffie11d30102018-11-02 16:09:09 +01001489 // devices (the list was previously build by getOutputsForDevices()).
Eric Laurente552edb2014-03-10 17:42:56 -07001490 // The priority is as follows:
jiabin40573322018-11-08 12:08:02 -08001491 // 1: the output supporting haptic playback when requesting haptic playback
Eric Laurent16c66dd2019-05-01 17:54:10 -07001492 // 2: the output with the highest number of requested functional flags
1493 // 3: the output supporting the exact channel mask
1494 // 4: the output with a higher channel count than requested
1495 // 5: the output with a higher sampling rate than requested
1496 // 6: the output with the highest number of requested performance flags
1497 // 7: the output with the bit depth the closest to the requested one
1498 // 8: the primary output
1499 // 9: the first output in the list
Eric Laurente552edb2014-03-10 17:42:56 -07001500
Eric Laurent16c66dd2019-05-01 17:54:10 -07001501 // matching criteria values in priority order for best matching output so far
1502 std::vector<uint32_t> bestMatchCriteria(8, 0);
Eric Laurente552edb2014-03-10 17:42:56 -07001503
Eric Laurent16c66dd2019-05-01 17:54:10 -07001504 const uint32_t channelCount = audio_channel_count_from_out_mask(channelMask);
1505 const uint32_t hapticChannelCount = audio_channel_count_from_out_mask(
1506 channelMask & AUDIO_CHANNEL_HAPTIC_ALL);
Eric Laurente78b6762018-12-19 16:29:01 -08001507
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001508 for (audio_io_handle_t output : outputs) {
1509 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
Eric Laurent16c66dd2019-05-01 17:54:10 -07001510 // matching criteria values in priority order for current output
1511 std::vector<uint32_t> currentMatchCriteria(8, 0);
jiabin40573322018-11-08 12:08:02 -08001512
Eric Laurent16c66dd2019-05-01 17:54:10 -07001513 if (outputDesc->isDuplicated()) {
1514 continue;
1515 }
1516 if ((kExcludedFlags & outputDesc->mFlags) != 0) {
1517 continue;
1518 }
Eric Laurent8838a382014-09-08 16:44:28 -07001519
Eric Laurent16c66dd2019-05-01 17:54:10 -07001520 // If haptic channel is specified, use the haptic output if present.
1521 // When using haptic output, same audio format and sample rate are required.
1522 const uint32_t outputHapticChannelCount = audio_channel_count_from_out_mask(
jiabin5740f082019-08-19 15:08:30 -07001523 outputDesc->getChannelMask() & AUDIO_CHANNEL_HAPTIC_ALL);
Eric Laurent16c66dd2019-05-01 17:54:10 -07001524 if ((hapticChannelCount == 0) != (outputHapticChannelCount == 0)) {
1525 continue;
1526 }
1527 if (outputHapticChannelCount >= hapticChannelCount
jiabin5740f082019-08-19 15:08:30 -07001528 && format == outputDesc->getFormat()
1529 && samplingRate == outputDesc->getSamplingRate()) {
Eric Laurent16c66dd2019-05-01 17:54:10 -07001530 currentMatchCriteria[0] = outputHapticChannelCount;
1531 }
1532
1533 // functional flags match
1534 currentMatchCriteria[1] = popcount(outputDesc->mFlags & functionalFlags);
1535
1536 // channel mask and channel count match
jiabin5740f082019-08-19 15:08:30 -07001537 uint32_t outputChannelCount = audio_channel_count_from_out_mask(
1538 outputDesc->getChannelMask());
Eric Laurent16c66dd2019-05-01 17:54:10 -07001539 if (channelMask != AUDIO_CHANNEL_NONE && channelCount > 2 &&
1540 channelCount <= outputChannelCount) {
1541 if ((audio_channel_mask_get_representation(channelMask) ==
jiabin5740f082019-08-19 15:08:30 -07001542 audio_channel_mask_get_representation(outputDesc->getChannelMask())) &&
1543 ((channelMask & outputDesc->getChannelMask()) == channelMask)) {
Eric Laurent16c66dd2019-05-01 17:54:10 -07001544 currentMatchCriteria[2] = outputChannelCount;
Eric Laurente552edb2014-03-10 17:42:56 -07001545 }
Eric Laurent16c66dd2019-05-01 17:54:10 -07001546 currentMatchCriteria[3] = outputChannelCount;
1547 }
1548
1549 // sampling rate match
1550 if (samplingRate > SAMPLE_RATE_HZ_DEFAULT &&
jiabin5740f082019-08-19 15:08:30 -07001551 samplingRate <= outputDesc->getSamplingRate()) {
1552 currentMatchCriteria[4] = outputDesc->getSamplingRate();
Eric Laurent16c66dd2019-05-01 17:54:10 -07001553 }
1554
1555 // performance flags match
1556 currentMatchCriteria[5] = popcount(outputDesc->mFlags & performanceFlags);
1557
1558 // format match
1559 if (format != AUDIO_FORMAT_INVALID) {
1560 currentMatchCriteria[6] =
jiabin4ef93452019-09-10 14:29:54 -07001561 PolicyAudioPort::kFormatDistanceMax -
1562 PolicyAudioPort::formatDistance(format, outputDesc->getFormat());
Eric Laurent16c66dd2019-05-01 17:54:10 -07001563 }
1564
1565 // primary output match
1566 currentMatchCriteria[7] = outputDesc->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY;
1567
1568 // compare match criteria by priority then value
1569 if (std::lexicographical_compare(bestMatchCriteria.begin(), bestMatchCriteria.end(),
1570 currentMatchCriteria.begin(), currentMatchCriteria.end())) {
1571 bestMatchCriteria = currentMatchCriteria;
1572 bestOutput = output;
1573
1574 std::stringstream result;
1575 std::copy(bestMatchCriteria.begin(), bestMatchCriteria.end(),
1576 std::ostream_iterator<int>(result, " "));
1577 ALOGV("%s new bestOutput %d criteria %s",
1578 __func__, bestOutput, result.str().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -07001579 }
1580 }
1581
Eric Laurent16c66dd2019-05-01 17:54:10 -07001582 return bestOutput;
Eric Laurente552edb2014-03-10 17:42:56 -07001583}
1584
Eric Laurent8fc147b2018-07-22 19:13:55 -07001585status_t AudioPolicyManager::startOutput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07001586{
Eric Laurent8fc147b2018-07-22 19:13:55 -07001587 ALOGV("%s portId %d", __FUNCTION__, portId);
1588
1589 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputForClient(portId);
1590 if (outputDesc == 0) {
1591 ALOGW("startOutput() no output for client %d", portId);
Eric Laurente552edb2014-03-10 17:42:56 -07001592 return BAD_VALUE;
1593 }
Andy Hung39efb7a2018-09-26 15:39:28 -07001594 sp<TrackClientDescriptor> client = outputDesc->getClient(portId);
Eric Laurente552edb2014-03-10 17:42:56 -07001595
Eric Laurent8fc147b2018-07-22 19:13:55 -07001596 ALOGV("startOutput() output %d, stream %d, session %d",
Eric Laurent97ac8712018-07-27 18:59:02 -07001597 outputDesc->mIoHandle, client->stream(), client->session());
Eric Laurentc75307b2015-03-17 15:29:32 -07001598
Eric Laurent733ce942017-12-07 12:18:25 -08001599 status_t status = outputDesc->start();
1600 if (status != NO_ERROR) {
1601 return status;
Eric Laurent3974e3b2017-12-07 17:58:43 -08001602 }
1603
Eric Laurent97ac8712018-07-27 18:59:02 -07001604 uint32_t delayMs;
1605 status = startSource(outputDesc, client, &delayMs);
Eric Laurentc75307b2015-03-17 15:29:32 -07001606
1607 if (status != NO_ERROR) {
Eric Laurent733ce942017-12-07 12:18:25 -08001608 outputDesc->stop();
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001609 return status;
Eric Laurentc75307b2015-03-17 15:29:32 -07001610 }
Eric Laurentc75307b2015-03-17 15:29:32 -07001611 if (delayMs != 0) {
1612 usleep(delayMs * 1000);
1613 }
1614
1615 return status;
1616}
1617
Eric Laurent97ac8712018-07-27 18:59:02 -07001618status_t AudioPolicyManager::startSource(const sp<SwAudioOutputDescriptor>& outputDesc,
1619 const sp<TrackClientDescriptor>& client,
1620 uint32_t *delayMs)
Eric Laurentc75307b2015-03-17 15:29:32 -07001621{
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001622 // cannot start playback of STREAM_TTS if any other output is being used
1623 uint32_t beaconMuteLatency = 0;
Eric Laurentc75307b2015-03-17 15:29:32 -07001624
1625 *delayMs = 0;
Eric Laurent97ac8712018-07-27 18:59:02 -07001626 audio_stream_type_t stream = client->stream();
François Gaffie1c878552018-11-22 16:53:21 +01001627 auto clientVolSrc = client->volumeSource();
François Gaffiec005e562018-11-06 15:04:49 +01001628 auto clientStrategy = client->strategy();
1629 auto clientAttr = client->attributes();
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001630 if (stream == AUDIO_STREAM_TTS) {
1631 ALOGV("\t found BEACON stream");
François Gaffie1c878552018-11-22 16:53:21 +01001632 if (!mTtsOutputAvailable && mOutputs.isAnyOutputActive(
Eric Laurent83d17c22019-04-02 17:10:01 -07001633 toVolumeSource(AUDIO_STREAM_TTS) /*sourceToIgnore*/)) {
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001634 return INVALID_OPERATION;
1635 } else {
1636 beaconMuteLatency = handleEventForBeacon(STARTING_BEACON);
1637 }
1638 } else {
1639 // some playback other than beacon starts
1640 beaconMuteLatency = handleEventForBeacon(STARTING_OUTPUT);
1641 }
1642
Eric Laurent77305a62016-07-25 16:39:22 -07001643 // force device change if the output is inactive and no audio patch is already present.
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001644 // check active before incrementing usage count
Eric Laurent77305a62016-07-25 16:39:22 -07001645 bool force = !outputDesc->isActive() &&
1646 (outputDesc->getPatchHandle() == AUDIO_PATCH_HANDLE_NONE);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001647
François Gaffie11d30102018-11-02 16:09:09 +01001648 DeviceVector devices;
Mikhail Naganovbfac5832019-03-05 16:55:28 -08001649 sp<AudioPolicyMix> policyMix = outputDesc->mPolicyMix.promote();
Eric Laurent97ac8712018-07-27 18:59:02 -07001650 const char *address = NULL;
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08001651 if (policyMix != nullptr) {
François Gaffie11d30102018-11-02 16:09:09 +01001652 audio_devices_t newDeviceType;
Eric Laurent97ac8712018-07-27 18:59:02 -07001653 address = policyMix->mDeviceAddress.string();
Kevin Rocard153f92d2018-12-18 18:33:28 -08001654 if ((policyMix->mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) {
François Gaffie11d30102018-11-02 16:09:09 +01001655 newDeviceType = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
Kevin Rocard153f92d2018-12-18 18:33:28 -08001656 } else {
1657 newDeviceType = policyMix->mDeviceType;
Eric Laurent97ac8712018-07-27 18:59:02 -07001658 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08001659 sp device = mAvailableOutputDevices.getDevice(newDeviceType, String8(address),
1660 AUDIO_FORMAT_DEFAULT);
1661 ALOG_ASSERT(device, "%s: no device found t=%u, a=%s", __func__, newDeviceType, address);
1662 devices.add(device);
Eric Laurent97ac8712018-07-27 18:59:02 -07001663 }
1664
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001665 // requiresMuteCheck is false when we can bypass mute strategy.
1666 // It covers a common case when there is no materially active audio
1667 // and muting would result in unnecessary delay and dropped audio.
1668 const uint32_t outputLatencyMs = outputDesc->latency();
1669 bool requiresMuteCheck = outputDesc->isActive(outputLatencyMs * 2); // account for drain
1670
Eric Laurente552edb2014-03-10 17:42:56 -07001671 // increment usage count for this stream on the requested output:
1672 // NOTE that the usage count is the same for duplicated output and hardware output which is
1673 // necessary for a correct control of hardware output routing by startOutput() and stopOutput()
Eric Laurent592dd7b2018-08-05 18:58:48 -07001674 outputDesc->setClientActive(client, true);
Eric Laurent97ac8712018-07-27 18:59:02 -07001675
1676 if (client->hasPreferredDevice(true)) {
François Gaffief96e5432019-04-09 17:13:56 +02001677 if (outputDesc->clientsList(true /*activeOnly*/).size() == 1 &&
1678 client->isPreferredDeviceForExclusiveUse()) {
1679 // Preferred device may be exclusive, use only if no other active clients on this output
1680 devices = DeviceVector(
1681 mAvailableOutputDevices.getDeviceFromId(client->preferredDeviceId()));
1682 } else {
1683 devices = getNewOutputDevices(outputDesc, false /*fromCache*/);
1684 }
François Gaffie11d30102018-11-02 16:09:09 +01001685 if (devices != outputDesc->devices()) {
François Gaffiec005e562018-11-06 15:04:49 +01001686 checkStrategyRoute(clientStrategy, outputDesc->mIoHandle);
Eric Laurent97ac8712018-07-27 18:59:02 -07001687 }
1688 }
Eric Laurente552edb2014-03-10 17:42:56 -07001689
François Gaffiec005e562018-11-06 15:04:49 +01001690 if (followsSameRouting(clientAttr, attributes_initializer(AUDIO_USAGE_MEDIA))) {
Eric Laurent36829f92017-04-07 19:04:42 -07001691 selectOutputForMusicEffects();
1692 }
1693
François Gaffie1c878552018-11-22 16:53:21 +01001694 if (outputDesc->getActivityCount(clientVolSrc) == 1 || !devices.isEmpty()) {
Eric Laurent275e8e92014-11-30 15:14:47 -08001695 // starting an output being rerouted?
François Gaffie11d30102018-11-02 16:09:09 +01001696 if (devices.isEmpty()) {
1697 devices = getNewOutputDevices(outputDesc, false /*fromCache*/);
Eric Laurent275e8e92014-11-30 15:14:47 -08001698 }
François Gaffiec005e562018-11-06 15:04:49 +01001699 bool shouldWait =
1700 (followsSameRouting(clientAttr, attributes_initializer(AUDIO_USAGE_ALARM)) ||
1701 followsSameRouting(clientAttr, attributes_initializer(AUDIO_USAGE_NOTIFICATION)) ||
1702 (beaconMuteLatency > 0));
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001703 uint32_t waitMs = beaconMuteLatency;
Eric Laurente552edb2014-03-10 17:42:56 -07001704 for (size_t i = 0; i < mOutputs.size(); i++) {
François Gaffie11d30102018-11-02 16:09:09 +01001705 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Eric Laurente552edb2014-03-10 17:42:56 -07001706 if (desc != outputDesc) {
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001707 // An output has a shared device if
1708 // - managed by the same hw module
1709 // - supports the currently selected device
1710 const bool sharedDevice = outputDesc->sharesHwModuleWith(desc)
François Gaffie11d30102018-11-02 16:09:09 +01001711 && (!desc->filterSupportedDevices(devices).isEmpty());
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001712
Eric Laurent77305a62016-07-25 16:39:22 -07001713 // force a device change if any other output is:
1714 // - managed by the same hw module
Jean-Michel Trivi4a5b4812018-02-08 17:22:32 +00001715 // - supports currently selected device
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001716 // - has a current device selection that differs from selected device.
Eric Laurent77305a62016-07-25 16:39:22 -07001717 // - has an active audio patch
Eric Laurente552edb2014-03-10 17:42:56 -07001718 // In this case, the audio HAL must receive the new device selection so that it can
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001719 // change the device currently selected by the other output.
1720 if (sharedDevice &&
François Gaffie11d30102018-11-02 16:09:09 +01001721 desc->devices() != devices &&
Eric Laurent77305a62016-07-25 16:39:22 -07001722 desc->getPatchHandle() != AUDIO_PATCH_HANDLE_NONE) {
Eric Laurente552edb2014-03-10 17:42:56 -07001723 force = true;
1724 }
1725 // wait for audio on other active outputs to be presented when starting
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001726 // a notification so that audio focus effect can propagate, or that a mute/unmute
1727 // event occurred for beacon
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001728 const uint32_t latencyMs = desc->latency();
1729 const bool isActive = desc->isActive(latencyMs * 2); // account for drain
1730
1731 if (shouldWait && isActive && (waitMs < latencyMs)) {
1732 waitMs = latencyMs;
Eric Laurente552edb2014-03-10 17:42:56 -07001733 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001734
1735 // Require mute check if another output is on a shared device
1736 // and currently active to have proper drain and avoid pops.
1737 // Note restoring AudioTracks onto this output needs to invoke
1738 // a volume ramp if there is no mute.
1739 requiresMuteCheck |= sharedDevice && isActive;
Eric Laurente552edb2014-03-10 17:42:56 -07001740 }
1741 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001742
1743 const uint32_t muteWaitMs =
François Gaffie11d30102018-11-02 16:09:09 +01001744 setOutputDevices(outputDesc, devices, force, 0, NULL, requiresMuteCheck);
Eric Laurente552edb2014-03-10 17:42:56 -07001745
Eric Laurente552edb2014-03-10 17:42:56 -07001746 // apply volume rules for current stream and device if necessary
François Gaffieaaac0fd2018-11-22 17:56:39 +01001747 auto &curves = getVolumeCurves(client->attributes());
1748 checkAndSetVolume(curves, client->volumeSource(),
1749 curves.getVolumeIndex(outputDesc->devices().types()),
Eric Laurentc75307b2015-03-17 15:29:32 -07001750 outputDesc,
François Gaffie11d30102018-11-02 16:09:09 +01001751 outputDesc->devices().types());
Eric Laurente552edb2014-03-10 17:42:56 -07001752
1753 // update the outputs if starting an output with a stream that can affect notification
1754 // routing
1755 handleNotificationRoutingForStream(stream);
Eric Laurentc722f302014-12-10 11:21:49 -08001756
Eric Laurent2cbe89a2014-12-19 11:49:08 -08001757 // force reevaluating accessibility routing when ringtone or alarm starts
François Gaffiec005e562018-11-06 15:04:49 +01001758 if (followsSameRouting(clientAttr, attributes_initializer(AUDIO_USAGE_ALARM))) {
Eric Laurent2cbe89a2014-12-19 11:49:08 -08001759 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
1760 }
Eric Laurentdc462862016-07-19 12:29:53 -07001761
1762 if (waitMs > muteWaitMs) {
1763 *delayMs = waitMs - muteWaitMs;
1764 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001765
1766 // FIXME: A device change (muteWaitMs > 0) likely introduces a volume change.
1767 // A volume change enacted by APM with 0 delay is not synchronous, as it goes
1768 // via AudioCommandThread to AudioFlinger. Hence it is possible that the volume
1769 // change occurs after the MixerThread starts and causes a stream volume
1770 // glitch.
1771 //
1772 // We do not introduce additional delay here.
Eric Laurente552edb2014-03-10 17:42:56 -07001773 }
Eric Laurentdc462862016-07-19 12:29:53 -07001774
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09001775 if (stream == AUDIO_STREAM_ENFORCED_AUDIBLE &&
jiabin9a3361e2019-10-01 09:38:30 -07001776 mEngine->getForceUse(
1777 AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
François Gaffiec005e562018-11-06 15:04:49 +01001778 setStrategyMute(streamToStrategy(AUDIO_STREAM_ALARM), true, outputDesc);
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09001779 }
1780
Eric Laurent97ac8712018-07-27 18:59:02 -07001781 // Automatically enable the remote submix input when output is started on a re routing mix
1782 // of type MIX_TYPE_RECORDERS
jiabin9a3361e2019-10-01 09:38:30 -07001783 if (isSingleDeviceType(devices.types(), &audio_is_remote_submix_device) &&
1784 policyMix != NULL && policyMix->mMixType == MIX_TYPE_RECORDERS) {
Eric Laurent97ac8712018-07-27 18:59:02 -07001785 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
1786 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
1787 address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08001788 "remote-submix",
1789 AUDIO_FORMAT_DEFAULT);
Eric Laurent97ac8712018-07-27 18:59:02 -07001790 }
1791
Eric Laurente552edb2014-03-10 17:42:56 -07001792 return NO_ERROR;
1793}
1794
Eric Laurent8fc147b2018-07-22 19:13:55 -07001795status_t AudioPolicyManager::stopOutput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07001796{
Eric Laurent8fc147b2018-07-22 19:13:55 -07001797 ALOGV("%s portId %d", __FUNCTION__, portId);
1798
1799 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputForClient(portId);
1800 if (outputDesc == 0) {
1801 ALOGW("stopOutput() no output for client %d", portId);
Eric Laurente552edb2014-03-10 17:42:56 -07001802 return BAD_VALUE;
1803 }
Andy Hung39efb7a2018-09-26 15:39:28 -07001804 sp<TrackClientDescriptor> client = outputDesc->getClient(portId);
Eric Laurente552edb2014-03-10 17:42:56 -07001805
Eric Laurent97ac8712018-07-27 18:59:02 -07001806 ALOGV("stopOutput() output %d, stream %d, session %d",
1807 outputDesc->mIoHandle, client->stream(), client->session());
Eric Laurente552edb2014-03-10 17:42:56 -07001808
Eric Laurent97ac8712018-07-27 18:59:02 -07001809 status_t status = stopSource(outputDesc, client);
Eric Laurent3974e3b2017-12-07 17:58:43 -08001810
Eric Laurent733ce942017-12-07 12:18:25 -08001811 if (status == NO_ERROR ) {
1812 outputDesc->stop();
Eric Laurent3974e3b2017-12-07 17:58:43 -08001813 }
1814 return status;
Eric Laurentc75307b2015-03-17 15:29:32 -07001815}
1816
Eric Laurent97ac8712018-07-27 18:59:02 -07001817status_t AudioPolicyManager::stopSource(const sp<SwAudioOutputDescriptor>& outputDesc,
1818 const sp<TrackClientDescriptor>& client)
Eric Laurentc75307b2015-03-17 15:29:32 -07001819{
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001820 // always handle stream stop, check which stream type is stopping
Eric Laurent97ac8712018-07-27 18:59:02 -07001821 audio_stream_type_t stream = client->stream();
François Gaffie1c878552018-11-22 16:53:21 +01001822 auto clientVolSrc = client->volumeSource();
Eric Laurent97ac8712018-07-27 18:59:02 -07001823
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001824 handleEventForBeacon(stream == AUDIO_STREAM_TTS ? STOPPING_BEACON : STOPPING_OUTPUT);
1825
François Gaffie1c878552018-11-22 16:53:21 +01001826 if (outputDesc->getActivityCount(clientVolSrc) > 0) {
1827 if (outputDesc->getActivityCount(clientVolSrc) == 1) {
Eric Laurent97ac8712018-07-27 18:59:02 -07001828 // Automatically disable the remote submix input when output is stopped on a
1829 // re routing mix of type MIX_TYPE_RECORDERS
Mikhail Naganovbfac5832019-03-05 16:55:28 -08001830 sp<AudioPolicyMix> policyMix = outputDesc->mPolicyMix.promote();
jiabin9a3361e2019-10-01 09:38:30 -07001831 if (isSingleDeviceType(
1832 outputDesc->devices().types(), &audio_is_remote_submix_device) &&
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08001833 policyMix != nullptr &&
Mikhail Naganovbfac5832019-03-05 16:55:28 -08001834 policyMix->mMixType == MIX_TYPE_RECORDERS) {
Eric Laurent97ac8712018-07-27 18:59:02 -07001835 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
1836 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
Mikhail Naganovbfac5832019-03-05 16:55:28 -08001837 policyMix->mDeviceAddress,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08001838 "remote-submix", AUDIO_FORMAT_DEFAULT);
Eric Laurent97ac8712018-07-27 18:59:02 -07001839 }
1840 }
1841 bool forceDeviceUpdate = false;
1842 if (client->hasPreferredDevice(true)) {
François Gaffiec005e562018-11-06 15:04:49 +01001843 checkStrategyRoute(client->strategy(), AUDIO_IO_HANDLE_NONE);
Eric Laurent97ac8712018-07-27 18:59:02 -07001844 forceDeviceUpdate = true;
1845 }
1846
Eric Laurente552edb2014-03-10 17:42:56 -07001847 // decrement usage count of this stream on the output
Eric Laurent592dd7b2018-08-05 18:58:48 -07001848 outputDesc->setClientActive(client, false);
Paul McLeanaa981192015-03-21 09:55:15 -07001849
Eric Laurente552edb2014-03-10 17:42:56 -07001850 // store time at which the stream was stopped - see isStreamActive()
François Gaffie1c878552018-11-22 16:53:21 +01001851 if (outputDesc->getActivityCount(clientVolSrc) == 0 || forceDeviceUpdate) {
François Gaffiec005e562018-11-06 15:04:49 +01001852 outputDesc->setStopTime(client, systemTime());
François Gaffie11d30102018-11-02 16:09:09 +01001853 DeviceVector newDevices = getNewOutputDevices(outputDesc, false /*fromCache*/);
Eric Laurente552edb2014-03-10 17:42:56 -07001854 // delay the device switch by twice the latency because stopOutput() is executed when
1855 // the track stop() command is received and at that time the audio track buffer can
1856 // still contain data that needs to be drained. The latency only covers the audio HAL
1857 // and kernel buffers. Also the latency does not always include additional delay in the
1858 // audio path (audio DSP, CODEC ...)
François Gaffie11d30102018-11-02 16:09:09 +01001859 setOutputDevices(outputDesc, newDevices, false, outputDesc->latency()*2);
Eric Laurente552edb2014-03-10 17:42:56 -07001860
1861 // force restoring the device selection on other active outputs if it differs from the
1862 // one being selected for this output
Eric Laurent57de36c2016-09-28 16:59:11 -07001863 uint32_t delayMs = outputDesc->latency()*2;
Eric Laurente552edb2014-03-10 17:42:56 -07001864 for (size_t i = 0; i < mOutputs.size(); i++) {
François Gaffie11d30102018-11-02 16:09:09 +01001865 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Eric Laurentc75307b2015-03-17 15:29:32 -07001866 if (desc != outputDesc &&
Eric Laurente552edb2014-03-10 17:42:56 -07001867 desc->isActive() &&
1868 outputDesc->sharesHwModuleWith(desc) &&
François Gaffie11d30102018-11-02 16:09:09 +01001869 (newDevices != desc->devices())) {
1870 DeviceVector newDevices2 = getNewOutputDevices(desc, false /*fromCache*/);
1871 bool force = desc->devices() != newDevices2;
Eric Laurentf3a5a602018-05-22 18:42:55 -07001872
François Gaffie11d30102018-11-02 16:09:09 +01001873 setOutputDevices(desc, newDevices2, force, delayMs);
1874
Eric Laurent57de36c2016-09-28 16:59:11 -07001875 // re-apply device specific volume if not done by setOutputDevice()
1876 if (!force) {
François Gaffie11d30102018-11-02 16:09:09 +01001877 applyStreamVolumes(desc, newDevices2.types(), delayMs);
Eric Laurent57de36c2016-09-28 16:59:11 -07001878 }
Eric Laurente552edb2014-03-10 17:42:56 -07001879 }
1880 }
1881 // update the outputs if stopping one with a stream that can affect notification routing
1882 handleNotificationRoutingForStream(stream);
1883 }
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09001884
1885 if (stream == AUDIO_STREAM_ENFORCED_AUDIBLE &&
1886 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -08001887 setStrategyMute(streamToStrategy(AUDIO_STREAM_ALARM), false, outputDesc);
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09001888 }
1889
François Gaffiec005e562018-11-06 15:04:49 +01001890 if (followsSameRouting(client->attributes(), attributes_initializer(AUDIO_USAGE_MEDIA))) {
Eric Laurent36829f92017-04-07 19:04:42 -07001891 selectOutputForMusicEffects();
1892 }
Eric Laurente552edb2014-03-10 17:42:56 -07001893 return NO_ERROR;
1894 } else {
Eric Laurentc75307b2015-03-17 15:29:32 -07001895 ALOGW("stopOutput() refcount is already 0");
Eric Laurente552edb2014-03-10 17:42:56 -07001896 return INVALID_OPERATION;
1897 }
1898}
1899
Eric Laurent8fc147b2018-07-22 19:13:55 -07001900void AudioPolicyManager::releaseOutput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07001901{
Eric Laurent8fc147b2018-07-22 19:13:55 -07001902 ALOGV("%s portId %d", __FUNCTION__, portId);
1903
1904 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputForClient(portId);
1905 if (outputDesc == 0) {
Andy Hung39efb7a2018-09-26 15:39:28 -07001906 // If an output descriptor is closed due to a device routing change,
1907 // then there are race conditions with releaseOutput from tracks
1908 // that may be destroyed (with no PlaybackThread) or a PlaybackThread
1909 // destroyed shortly thereafter.
1910 //
1911 // Here we just log a warning, instead of a fatal error.
Eric Laurent8fc147b2018-07-22 19:13:55 -07001912 ALOGW("releaseOutput() no output for client %d", portId);
Eric Laurente552edb2014-03-10 17:42:56 -07001913 return;
1914 }
Eric Laurent8fc147b2018-07-22 19:13:55 -07001915
1916 ALOGV("releaseOutput() %d", outputDesc->mIoHandle);
Eric Laurente552edb2014-03-10 17:42:56 -07001917
Eric Laurent8fc147b2018-07-22 19:13:55 -07001918 if (outputDesc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
1919 if (outputDesc->mDirectOpenCount <= 0) {
Eric Laurente552edb2014-03-10 17:42:56 -07001920 ALOGW("releaseOutput() invalid open count %d for output %d",
Eric Laurent8fc147b2018-07-22 19:13:55 -07001921 outputDesc->mDirectOpenCount, outputDesc->mIoHandle);
Eric Laurente552edb2014-03-10 17:42:56 -07001922 return;
1923 }
Eric Laurent8fc147b2018-07-22 19:13:55 -07001924 if (--outputDesc->mDirectOpenCount == 0) {
1925 closeOutput(outputDesc->mIoHandle);
Eric Laurentb52c1522014-05-20 11:27:36 -07001926 mpClientInterface->onAudioPortListUpdate();
Eric Laurente552edb2014-03-10 17:42:56 -07001927 }
1928 }
Andy Hung39efb7a2018-09-26 15:39:28 -07001929 // stopOutput() needs to be successfully called before releaseOutput()
1930 // otherwise there may be inaccurate stream reference counts.
1931 // This is checked in outputDesc->removeClient below.
1932 outputDesc->removeClient(portId);
Eric Laurente552edb2014-03-10 17:42:56 -07001933}
1934
Eric Laurentcaf7f482014-11-25 17:50:47 -08001935status_t AudioPolicyManager::getInputForAttr(const audio_attributes_t *attr,
1936 audio_io_handle_t *input,
Mikhail Naganov2996f672019-04-18 12:29:59 -07001937 audio_unique_id_t riid,
Eric Laurentcaf7f482014-11-25 17:50:47 -08001938 audio_session_t session,
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001939 uid_t uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001940 const audio_config_base_t *config,
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -08001941 audio_input_flags_t flags,
Eric Laurent2ac76942017-06-22 17:17:09 -07001942 audio_port_handle_t *selectedDeviceId,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001943 input_type_t *inputType,
1944 audio_port_handle_t *portId)
Eric Laurente552edb2014-03-10 17:42:56 -07001945{
François Gaffiec005e562018-11-06 15:04:49 +01001946 ALOGV("%s() source %d, sampling rate %d, format %#x, channel mask %#x, session %d, "
1947 "flags %#x attributes=%s", __func__, attr->source, config->sample_rate,
1948 config->format, config->channel_mask, session, flags, toString(*attr).c_str());
Eric Laurente552edb2014-03-10 17:42:56 -07001949
Eric Laurentad2e7b92017-09-14 20:06:42 -07001950 status_t status = NO_ERROR;
Eric Laurentc447ded2015-01-06 08:47:05 -08001951 audio_source_t halInputSource;
Francois Gaffie716e1432019-01-14 16:58:59 +01001952 audio_attributes_t attributes = *attr;
Mikhail Naganovbfac5832019-03-05 16:55:28 -08001953 sp<AudioPolicyMix> policyMix;
François Gaffie11d30102018-11-02 16:09:09 +01001954 sp<DeviceDescriptor> device;
Eric Laurent8fc147b2018-07-22 19:13:55 -07001955 sp<AudioInputDescriptor> inputDesc;
1956 sp<RecordClientDescriptor> clientDesc;
1957 audio_port_handle_t requestedDeviceId = *selectedDeviceId;
Eric Laurent8f42ea12018-08-08 09:08:25 -07001958 bool isSoundTrigger;
Eric Laurent8f42ea12018-08-08 09:08:25 -07001959
1960 // The supplied portId must be AUDIO_PORT_HANDLE_NONE
1961 if (*portId != AUDIO_PORT_HANDLE_NONE) {
1962 return INVALID_OPERATION;
1963 }
Eric Laurent20b9ef02016-12-05 11:03:16 -08001964
Francois Gaffie716e1432019-01-14 16:58:59 +01001965 if (attr->source == AUDIO_SOURCE_DEFAULT) {
1966 attributes.source = AUDIO_SOURCE_MIC;
Eric Laurentfe231122017-11-17 17:48:06 -08001967 }
1968
Paul McLean466dc8e2015-04-17 13:15:36 -06001969 // Explicit routing?
François Gaffie11d30102018-11-02 16:09:09 +01001970 sp<DeviceDescriptor> explicitRoutingDevice =
1971 mAvailableInputDevices.getDeviceFromId(*selectedDeviceId);
Paul McLean466dc8e2015-04-17 13:15:36 -06001972
Eric Laurentad2e7b92017-09-14 20:06:42 -07001973 // special case for mmap capture: if an input IO handle is specified, we reuse this input if
1974 // possible
1975 if ((flags & AUDIO_INPUT_FLAG_MMAP_NOIRQ) == AUDIO_INPUT_FLAG_MMAP_NOIRQ &&
1976 *input != AUDIO_IO_HANDLE_NONE) {
1977 ssize_t index = mInputs.indexOfKey(*input);
1978 if (index < 0) {
1979 ALOGW("getInputForAttr() unknown MMAP input %d", *input);
1980 status = BAD_VALUE;
1981 goto error;
1982 }
1983 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index);
Eric Laurent8f42ea12018-08-08 09:08:25 -07001984 RecordClientVector clients = inputDesc->getClientsForSession(session);
1985 if (clients.size() == 0) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07001986 ALOGW("getInputForAttr() unknown session %d on input %d", session, *input);
1987 status = BAD_VALUE;
1988 goto error;
1989 }
1990 // For MMAP mode, the first call to getInputForAttr() is made on behalf of audioflinger.
1991 // The second call is for the first active client and sets the UID. Any further call
Eric Laurent331679c2018-04-16 17:03:16 -07001992 // corresponds to a new client and is only permitted from the same UID.
1993 // If the first UID is silenced, allow a new UID connection and replace with new UID
Eric Laurent8f42ea12018-08-08 09:08:25 -07001994 if (clients.size() > 1) {
1995 for (const auto& client : clients) {
1996 // The client map is ordered by key values (portId) and portIds are allocated
1997 // incrementaly. So the first client in this list is the one opened by audio flinger
1998 // when the mmap stream is created and should be ignored as it does not correspond
1999 // to an actual client
2000 if (client == *clients.cbegin()) {
2001 continue;
2002 }
2003 if (uid != client->uid() && !client->isSilenced()) {
2004 ALOGW("getInputForAttr() bad uid %d for client %d uid %d",
2005 uid, client->portId(), client->uid());
2006 status = INVALID_OPERATION;
2007 goto error;
2008 }
Eric Laurent331679c2018-04-16 17:03:16 -07002009 }
Eric Laurentad2e7b92017-09-14 20:06:42 -07002010 }
Eric Laurentad2e7b92017-09-14 20:06:42 -07002011 *inputType = API_INPUT_LEGACY;
François Gaffie11d30102018-11-02 16:09:09 +01002012 device = inputDesc->getDevice();
Eric Laurentad2e7b92017-09-14 20:06:42 -07002013
Eric Laurent8f42ea12018-08-08 09:08:25 -07002014 ALOGI("%s reusing MMAP input %d for session %d", __FUNCTION__, *input, session);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002015 goto exit;
Eric Laurentad2e7b92017-09-14 20:06:42 -07002016 }
2017
2018 *input = AUDIO_IO_HANDLE_NONE;
2019 *inputType = API_INPUT_INVALID;
2020
Francois Gaffie716e1432019-01-14 16:58:59 +01002021 halInputSource = attributes.source;
Eric Laurentad2e7b92017-09-14 20:06:42 -07002022
Francois Gaffie716e1432019-01-14 16:58:59 +01002023 if (attributes.source == AUDIO_SOURCE_REMOTE_SUBMIX &&
2024 strncmp(attributes.tags, "addr=", strlen("addr=")) == 0) {
2025 status = mPolicyMixes.getInputMixForAttr(attributes, &policyMix);
Eric Laurentad2e7b92017-09-14 20:06:42 -07002026 if (status != NO_ERROR) {
jiabinc1de2df2019-05-07 14:26:40 -07002027 ALOGW("%s could not find input mix for attr %s",
2028 __func__, toString(attributes).c_str());
Eric Laurentad2e7b92017-09-14 20:06:42 -07002029 goto error;
François Gaffie036e1e92015-03-19 10:16:24 +01002030 }
jiabinc1de2df2019-05-07 14:26:40 -07002031 device = mAvailableInputDevices.getDevice(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
2032 String8(attr->tags + strlen("addr=")),
2033 AUDIO_FORMAT_DEFAULT);
2034 if (device == nullptr) {
Kevin Rocard04ed0462019-05-02 17:53:24 -07002035 ALOGW("%s could not find in Remote Submix device for source %d, tags %s",
jiabinc1de2df2019-05-07 14:26:40 -07002036 __func__, attributes.source, attributes.tags);
2037 status = BAD_VALUE;
2038 goto error;
2039 }
2040
Kevin Rocard25f9b052019-02-27 15:08:54 -08002041 if (is_mix_loopback_render(policyMix->mRouteFlags)) {
2042 *inputType = API_INPUT_MIX_PUBLIC_CAPTURE_PLAYBACK;
2043 } else {
2044 *inputType = API_INPUT_MIX_EXT_POLICY_REROUTE;
2045 }
Eric Laurent275e8e92014-11-30 15:14:47 -08002046 } else {
François Gaffie11d30102018-11-02 16:09:09 +01002047 if (explicitRoutingDevice != nullptr) {
2048 device = explicitRoutingDevice;
Eric Laurent97ac8712018-07-27 18:59:02 -07002049 } else {
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01002050 // Prevent from storing invalid requested device id in clients
2051 requestedDeviceId = AUDIO_PORT_HANDLE_NONE;
François Gaffiec005e562018-11-06 15:04:49 +01002052 device = mEngine->getInputDeviceForAttributes(attributes, &policyMix);
Eric Laurent97ac8712018-07-27 18:59:02 -07002053 }
François Gaffie11d30102018-11-02 16:09:09 +01002054 if (device == nullptr) {
Francois Gaffie716e1432019-01-14 16:58:59 +01002055 ALOGW("getInputForAttr() could not find device for source %d", attributes.source);
Eric Laurentad2e7b92017-09-14 20:06:42 -07002056 status = BAD_VALUE;
2057 goto error;
Eric Laurent275e8e92014-11-30 15:14:47 -08002058 }
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002059 if (policyMix) {
François Gaffie11d30102018-11-02 16:09:09 +01002060 ALOG_ASSERT(policyMix->mMixType == MIX_TYPE_RECORDERS, "Invalid Mix Type");
2061 // there is an external policy, but this input is attached to a mix of recorders,
2062 // meaning it receives audio injected into the framework, so the recorder doesn't
2063 // know about it and is therefore considered "legacy"
2064 *inputType = API_INPUT_LEGACY;
2065 } else if (audio_is_remote_submix_device(device->type())) {
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -08002066 *inputType = API_INPUT_MIX_CAPTURE;
François Gaffie11d30102018-11-02 16:09:09 +01002067 } else if (device->type() == AUDIO_DEVICE_IN_TELEPHONY_RX) {
Eric Laurent82db2692015-08-07 13:59:42 -07002068 *inputType = API_INPUT_TELEPHONY_RX;
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -08002069 } else {
2070 *inputType = API_INPUT_LEGACY;
Eric Laurentc722f302014-12-10 11:21:49 -08002071 }
Ravi Kumar Alamandab367f5b2015-08-25 08:21:37 -07002072
Eric Laurent599c7582015-12-07 18:05:55 -08002073 }
2074
François Gaffiec005e562018-11-06 15:04:49 +01002075 *input = getInputForDevice(device, session, attributes, config, flags, policyMix);
Eric Laurent599c7582015-12-07 18:05:55 -08002076 if (*input == AUDIO_IO_HANDLE_NONE) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07002077 status = INVALID_OPERATION;
2078 goto error;
Eric Laurent599c7582015-12-07 18:05:55 -08002079 }
Eric Laurent20b9ef02016-12-05 11:03:16 -08002080
Eric Laurent8f42ea12018-08-08 09:08:25 -07002081exit:
2082
François Gaffiec005e562018-11-06 15:04:49 +01002083 *selectedDeviceId = mAvailableInputDevices.contains(device) ?
2084 device->getId() : AUDIO_PORT_HANDLE_NONE;
Eric Laurent2ac76942017-06-22 17:17:09 -07002085
Francois Gaffie716e1432019-01-14 16:58:59 +01002086 isSoundTrigger = attributes.source == AUDIO_SOURCE_HOTWORD &&
Carter Hsud0cce2e2019-05-03 17:36:28 +08002087 mSoundTriggerSessions.indexOfKey(session) >= 0;
jiabin4ef93452019-09-10 14:29:54 -07002088 *portId = PolicyAudioPort::getNextUniqueId();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002089
Mikhail Naganov2996f672019-04-18 12:29:59 -07002090 clientDesc = new RecordClientDescriptor(*portId, riid, uid, session, attributes, *config,
Francois Gaffie716e1432019-01-14 16:58:59 +01002091 requestedDeviceId, attributes.source, flags,
2092 isSoundTrigger);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002093 inputDesc = mInputs.valueFor(*input);
Andy Hung39efb7a2018-09-26 15:39:28 -07002094 inputDesc->addClient(clientDesc);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002095
2096 ALOGV("getInputForAttr() returns input %d type %d selectedDeviceId %d for port ID %d",
2097 *input, *inputType, *selectedDeviceId, *portId);
Eric Laurent2ac76942017-06-22 17:17:09 -07002098
Eric Laurent599c7582015-12-07 18:05:55 -08002099 return NO_ERROR;
Eric Laurentad2e7b92017-09-14 20:06:42 -07002100
2101error:
Eric Laurentad2e7b92017-09-14 20:06:42 -07002102 return status;
Eric Laurent599c7582015-12-07 18:05:55 -08002103}
2104
2105
François Gaffie11d30102018-11-02 16:09:09 +01002106audio_io_handle_t AudioPolicyManager::getInputForDevice(const sp<DeviceDescriptor> &device,
Eric Laurent599c7582015-12-07 18:05:55 -08002107 audio_session_t session,
François Gaffiec005e562018-11-06 15:04:49 +01002108 const audio_attributes_t &attributes,
Eric Laurentfe231122017-11-17 17:48:06 -08002109 const audio_config_base_t *config,
Eric Laurent599c7582015-12-07 18:05:55 -08002110 audio_input_flags_t flags,
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002111 const sp<AudioPolicyMix> &policyMix)
Eric Laurent599c7582015-12-07 18:05:55 -08002112{
2113 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
François Gaffiec005e562018-11-06 15:04:49 +01002114 audio_source_t halInputSource = attributes.source;
Eric Laurent599c7582015-12-07 18:05:55 -08002115 bool isSoundTrigger = false;
2116
François Gaffiec005e562018-11-06 15:04:49 +01002117 if (attributes.source == AUDIO_SOURCE_HOTWORD) {
Eric Laurent599c7582015-12-07 18:05:55 -08002118 ssize_t index = mSoundTriggerSessions.indexOfKey(session);
2119 if (index >= 0) {
2120 input = mSoundTriggerSessions.valueFor(session);
2121 isSoundTrigger = true;
2122 flags = (audio_input_flags_t)(flags | AUDIO_INPUT_FLAG_HW_HOTWORD);
2123 ALOGV("SoundTrigger capture on session %d input %d", session, input);
2124 } else {
2125 halInputSource = AUDIO_SOURCE_VOICE_RECOGNITION;
Eric Laurent5dbe4712014-09-19 19:04:57 -07002126 }
François Gaffiec005e562018-11-06 15:04:49 +01002127 } else if (attributes.source == AUDIO_SOURCE_VOICE_COMMUNICATION &&
Eric Laurentfe231122017-11-17 17:48:06 -08002128 audio_is_linear_pcm(config->format)) {
Haynes Mathew George851d3ff2017-06-19 20:01:57 -07002129 flags = (audio_input_flags_t)(flags | AUDIO_INPUT_FLAG_VOIP_TX);
Eric Laurent5dbe4712014-09-19 19:04:57 -07002130 }
2131
Andy Hungf129b032015-04-07 13:45:50 -07002132 // find a compatible input profile (not necessarily identical in parameters)
2133 sp<IOProfile> profile;
Eric Laurentfe231122017-11-17 17:48:06 -08002134 // sampling rate and flags may be updated by getInputProfile
2135 uint32_t profileSamplingRate = (config->sample_rate == 0) ?
2136 SAMPLE_RATE_HZ_DEFAULT : config->sample_rate;
Glenn Kasten730b9262018-03-29 15:01:26 -07002137 audio_format_t profileFormat;
Eric Laurentfe231122017-11-17 17:48:06 -08002138 audio_channel_mask_t profileChannelMask = config->channel_mask;
Andy Hungf129b032015-04-07 13:45:50 -07002139 audio_input_flags_t profileFlags = flags;
2140 for (;;) {
Glenn Kasten730b9262018-03-29 15:01:26 -07002141 profileFormat = config->format; // reset each time through loop, in case it is updated
François Gaffie11d30102018-11-02 16:09:09 +01002142 profile = getInputProfile(device, profileSamplingRate, profileFormat, profileChannelMask,
Andy Hungf129b032015-04-07 13:45:50 -07002143 profileFlags);
2144 if (profile != 0) {
2145 break; // success
Eric Laurent05067782016-06-01 18:27:28 -07002146 } else if (profileFlags & AUDIO_INPUT_FLAG_RAW) {
2147 profileFlags = (audio_input_flags_t) (profileFlags & ~AUDIO_INPUT_FLAG_RAW); // retry
Andy Hungf129b032015-04-07 13:45:50 -07002148 } else if (profileFlags != AUDIO_INPUT_FLAG_NONE) {
2149 profileFlags = AUDIO_INPUT_FLAG_NONE; // retry
2150 } else { // fail
François Gaffie11d30102018-11-02 16:09:09 +01002151 ALOGW("%s could not find profile for device %s, sampling rate %u, format %#x, "
2152 "channel mask 0x%X, flags %#x", __func__, device->toString().c_str(),
2153 config->sample_rate, config->format, config->channel_mask, flags);
Eric Laurent599c7582015-12-07 18:05:55 -08002154 return input;
Eric Laurent5dbe4712014-09-19 19:04:57 -07002155 }
Eric Laurente552edb2014-03-10 17:42:56 -07002156 }
Glenn Kasten05ddca52016-02-11 08:17:12 -08002157 // Pick input sampling rate if not specified by client
Eric Laurentfe231122017-11-17 17:48:06 -08002158 uint32_t samplingRate = config->sample_rate;
Glenn Kasten05ddca52016-02-11 08:17:12 -08002159 if (samplingRate == 0) {
2160 samplingRate = profileSamplingRate;
2161 }
Eric Laurente552edb2014-03-10 17:42:56 -07002162
Eric Laurent322b4d22015-04-03 15:57:54 -07002163 if (profile->getModuleHandle() == 0) {
2164 ALOGE("getInputForAttr(): HW module %s not opened", profile->getModuleName());
Eric Laurent599c7582015-12-07 18:05:55 -08002165 return input;
Eric Laurentcf2c0212014-07-25 16:20:43 -07002166 }
2167
Eric Laurent3974e3b2017-12-07 17:58:43 -08002168 if (!profile->canOpenNewIo()) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08002169 for (size_t i = 0; i < mInputs.size(); ) {
2170 sp <AudioInputDescriptor> desc = mInputs.valueAt(i);
2171 if (desc->mProfile != profile) {
Carter Hsu9a645a92019-05-15 12:15:32 +08002172 i++;
Eric Laurent4eb58f12018-12-07 16:41:02 -08002173 continue;
2174 }
2175 // if sound trigger, reuse input if used by other sound trigger on same session
2176 // else
2177 // reuse input if active client app is not in IDLE state
2178 //
2179 RecordClientVector clients = desc->clientsList();
2180 bool doClose = false;
2181 for (const auto& client : clients) {
2182 if (isSoundTrigger != client->isSoundTrigger()) {
2183 continue;
2184 }
2185 if (client->isSoundTrigger()) {
2186 if (session == client->session()) {
2187 return desc->mIoHandle;
2188 }
2189 continue;
2190 }
2191 if (client->active() && client->appState() != APP_STATE_IDLE) {
2192 return desc->mIoHandle;
2193 }
2194 doClose = true;
2195 }
2196 if (doClose) {
2197 closeInput(desc->mIoHandle);
2198 } else {
2199 i++;
2200 }
2201 }
Eric Laurent3974e3b2017-12-07 17:58:43 -08002202 }
2203
Eric Laurentfe231122017-11-17 17:48:06 -08002204 sp<AudioInputDescriptor> inputDesc = new AudioInputDescriptor(profile, mpClientInterface);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07002205
Eric Laurentfe231122017-11-17 17:48:06 -08002206 audio_config_t lConfig = AUDIO_CONFIG_INITIALIZER;
2207 lConfig.sample_rate = profileSamplingRate;
2208 lConfig.channel_mask = profileChannelMask;
2209 lConfig.format = profileFormat;
Eric Laurente3014102017-05-03 11:15:43 -07002210
François Gaffie11d30102018-11-02 16:09:09 +01002211 status_t status = inputDesc->open(&lConfig, device, halInputSource, profileFlags, &input);
Eric Laurentcf2c0212014-07-25 16:20:43 -07002212
2213 // only accept input with the exact requested set of parameters
Eric Laurent599c7582015-12-07 18:05:55 -08002214 if (status != NO_ERROR || input == AUDIO_IO_HANDLE_NONE ||
Eric Laurentfe231122017-11-17 17:48:06 -08002215 (profileSamplingRate != lConfig.sample_rate) ||
2216 !audio_formats_match(profileFormat, lConfig.format) ||
2217 (profileChannelMask != lConfig.channel_mask)) {
2218 ALOGW("getInputForAttr() failed opening input: sampling rate %d"
Glenn Kasten49f36ba2017-12-06 13:02:02 -08002219 ", format %#x, channel mask %#x",
Eric Laurentfe231122017-11-17 17:48:06 -08002220 profileSamplingRate, profileFormat, profileChannelMask);
Eric Laurent599c7582015-12-07 18:05:55 -08002221 if (input != AUDIO_IO_HANDLE_NONE) {
Eric Laurentfe231122017-11-17 17:48:06 -08002222 inputDesc->close();
Eric Laurentcf2c0212014-07-25 16:20:43 -07002223 }
Eric Laurent599c7582015-12-07 18:05:55 -08002224 return AUDIO_IO_HANDLE_NONE;
Eric Laurente552edb2014-03-10 17:42:56 -07002225 }
2226
Eric Laurentc722f302014-12-10 11:21:49 -08002227 inputDesc->mPolicyMix = policyMix;
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002228
Eric Laurent599c7582015-12-07 18:05:55 -08002229 addInput(input, inputDesc);
Eric Laurentb52c1522014-05-20 11:27:36 -07002230 mpClientInterface->onAudioPortListUpdate();
Paul McLean466dc8e2015-04-17 13:15:36 -06002231
Eric Laurent599c7582015-12-07 18:05:55 -08002232 return input;
Eric Laurente552edb2014-03-10 17:42:56 -07002233}
2234
Eric Laurent4eb58f12018-12-07 16:41:02 -08002235status_t AudioPolicyManager::startInput(audio_port_handle_t portId)
Eric Laurentbb948092017-01-23 18:33:30 -08002236{
Eric Laurent8fc147b2018-07-22 19:13:55 -07002237 ALOGV("%s portId %d", __FUNCTION__, portId);
2238
2239 sp<AudioInputDescriptor> inputDesc = mInputs.getInputForClient(portId);
2240 if (inputDesc == 0) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002241 ALOGW("%s no input for client %d", __FUNCTION__, portId);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002242 return BAD_VALUE;
2243 }
Eric Laurent8fc147b2018-07-22 19:13:55 -07002244 audio_io_handle_t input = inputDesc->mIoHandle;
Andy Hung39efb7a2018-09-26 15:39:28 -07002245 sp<RecordClientDescriptor> client = inputDesc->getClient(portId);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002246 if (client->active()) {
2247 ALOGW("%s input %d client %d already started", __FUNCTION__, input, client->portId());
2248 return INVALID_OPERATION;
Eric Laurent4dc68062014-07-28 17:26:49 -07002249 }
2250
Eric Laurent8f42ea12018-08-08 09:08:25 -07002251 audio_session_t session = client->session();
2252
Eric Laurent4eb58f12018-12-07 16:41:02 -08002253 ALOGV("%s input:%d, session:%d)", __FUNCTION__, input, session);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002254
Eric Laurent4eb58f12018-12-07 16:41:02 -08002255 Vector<sp<AudioInputDescriptor>> activeInputs = mInputs.getActiveInputs();
Eric Laurent74708e72017-04-07 17:13:42 -07002256
Eric Laurent4eb58f12018-12-07 16:41:02 -08002257 status_t status = inputDesc->start();
2258 if (status != NO_ERROR) {
2259 return status;
Eric Laurent74708e72017-04-07 17:13:42 -07002260 }
Eric Laurente552edb2014-03-10 17:42:56 -07002261
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002262 // increment activity count before calling getNewInputDevice() below as only active sessions
Eric Laurent313d1e72016-01-29 09:56:57 -08002263 // are considered for device selection
Eric Laurent8f42ea12018-08-08 09:08:25 -07002264 inputDesc->setClientActive(client, true);
Eric Laurent313d1e72016-01-29 09:56:57 -08002265
Eric Laurent8f42ea12018-08-08 09:08:25 -07002266 // indicate active capture to sound trigger service if starting capture from a mic on
2267 // primary HW module
François Gaffie11d30102018-11-02 16:09:09 +01002268 sp<DeviceDescriptor> device = getNewInputDevice(inputDesc);
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002269 if (device != nullptr) {
2270 status = setInputDevice(input, device, true /* force */);
2271 } else {
2272 ALOGW("%s no new input device can be found for descriptor %d",
2273 __FUNCTION__, inputDesc->getId());
2274 status = BAD_VALUE;
2275 }
Eric Laurente552edb2014-03-10 17:42:56 -07002276
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002277 if (status == NO_ERROR && inputDesc->activeCount() == 1) {
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002278 sp<AudioPolicyMix> policyMix = inputDesc->mPolicyMix.promote();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002279 // if input maps to a dynamic policy with an activity listener, notify of state change
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002280 if ((policyMix != nullptr)
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002281 && ((policyMix->mCbFlags & AudioMix::kCbFlagNotifyActivity) != 0)) {
2282 mpClientInterface->onDynamicPolicyMixStateUpdate(policyMix->mDeviceAddress,
Eric Laurent8f42ea12018-08-08 09:08:25 -07002283 MIX_STATE_MIXING);
Eric Laurent733ce942017-12-07 12:18:25 -08002284 }
Eric Laurent3974e3b2017-12-07 17:58:43 -08002285
François Gaffie11d30102018-11-02 16:09:09 +01002286 DeviceVector primaryInputDevices = availablePrimaryModuleInputDevices();
2287 if (primaryInputDevices.contains(device) &&
Eric Laurent8f42ea12018-08-08 09:08:25 -07002288 mInputs.activeInputsCountOnDevices(primaryInputDevices) == 1) {
Ytai Ben-Tsvi74cd6b02019-10-25 10:06:40 -07002289 mpClientInterface->setSoundTriggerCaptureState(true);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002290 }
Jean-Michel Trivieb6421d2016-03-17 12:32:52 -07002291
Eric Laurent8f42ea12018-08-08 09:08:25 -07002292 // automatically enable the remote submix output when input is started if not
2293 // used by a policy mix of type MIX_TYPE_RECORDERS
2294 // For remote submix (a virtual device), we open only one input per capture request.
François Gaffie11d30102018-11-02 16:09:09 +01002295 if (audio_is_remote_submix_device(inputDesc->getDeviceType())) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002296 String8 address = String8("");
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002297 if (policyMix == nullptr) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002298 address = String8("0");
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002299 } else if (policyMix->mMixType == MIX_TYPE_PLAYERS) {
2300 address = policyMix->mDeviceAddress;
Jean-Michel Trivieb6421d2016-03-17 12:32:52 -07002301 }
Eric Laurent8f42ea12018-08-08 09:08:25 -07002302 if (address != "") {
2303 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
2304 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08002305 address, "remote-submix", AUDIO_FORMAT_DEFAULT);
Eric Laurentc722f302014-12-10 11:21:49 -08002306 }
Glenn Kasten74a8e252014-07-24 14:09:55 -07002307 }
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002308 } else if (status != NO_ERROR) {
2309 // Restore client activity state.
2310 inputDesc->setClientActive(client, false);
2311 inputDesc->stop();
Eric Laurente552edb2014-03-10 17:42:56 -07002312 }
2313
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002314 ALOGV("%s input %d source = %d status = %d exit",
2315 __FUNCTION__, input, client->source(), status);
Eric Laurente552edb2014-03-10 17:42:56 -07002316
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002317 return status;
Eric Laurente552edb2014-03-10 17:42:56 -07002318}
2319
Eric Laurent8fc147b2018-07-22 19:13:55 -07002320status_t AudioPolicyManager::stopInput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07002321{
Eric Laurent8fc147b2018-07-22 19:13:55 -07002322 ALOGV("%s portId %d", __FUNCTION__, portId);
2323
2324 sp<AudioInputDescriptor> inputDesc = mInputs.getInputForClient(portId);
2325 if (inputDesc == 0) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002326 ALOGW("%s no input for client %d", __FUNCTION__, portId);
Eric Laurente552edb2014-03-10 17:42:56 -07002327 return BAD_VALUE;
2328 }
Eric Laurent8fc147b2018-07-22 19:13:55 -07002329 audio_io_handle_t input = inputDesc->mIoHandle;
Andy Hung39efb7a2018-09-26 15:39:28 -07002330 sp<RecordClientDescriptor> client = inputDesc->getClient(portId);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002331 if (!client->active()) {
2332 ALOGW("%s input %d client %d already stopped", __FUNCTION__, input, client->portId());
Eric Laurente552edb2014-03-10 17:42:56 -07002333 return INVALID_OPERATION;
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002334 }
2335
Eric Laurent8f42ea12018-08-08 09:08:25 -07002336 inputDesc->setClientActive(client, false);
Paul McLean466dc8e2015-04-17 13:15:36 -06002337
Eric Laurent8f42ea12018-08-08 09:08:25 -07002338 inputDesc->stop();
2339 if (inputDesc->isActive()) {
2340 setInputDevice(input, getNewInputDevice(inputDesc), false /* force */);
2341 } else {
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002342 sp<AudioPolicyMix> policyMix = inputDesc->mPolicyMix.promote();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002343 // if input maps to a dynamic policy with an activity listener, notify of state change
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002344 if ((policyMix != nullptr)
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002345 && ((policyMix->mCbFlags & AudioMix::kCbFlagNotifyActivity) != 0)) {
2346 mpClientInterface->onDynamicPolicyMixStateUpdate(policyMix->mDeviceAddress,
Eric Laurent8f42ea12018-08-08 09:08:25 -07002347 MIX_STATE_IDLE);
Eric Laurent84332aa2016-01-28 22:19:18 +00002348 }
Eric Laurent8f42ea12018-08-08 09:08:25 -07002349
2350 // automatically disable the remote submix output when input is stopped if not
2351 // used by a policy mix of type MIX_TYPE_RECORDERS
François Gaffie11d30102018-11-02 16:09:09 +01002352 if (audio_is_remote_submix_device(inputDesc->getDeviceType())) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002353 String8 address = String8("");
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002354 if (policyMix == nullptr) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002355 address = String8("0");
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002356 } else if (policyMix->mMixType == MIX_TYPE_PLAYERS) {
2357 address = policyMix->mDeviceAddress;
Eric Laurent8f42ea12018-08-08 09:08:25 -07002358 }
2359 if (address != "") {
2360 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
2361 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08002362 address, "remote-submix", AUDIO_FORMAT_DEFAULT);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002363 }
2364 }
Eric Laurent8f42ea12018-08-08 09:08:25 -07002365 resetInputDevice(input);
2366
2367 // indicate inactive capture to sound trigger service if stopping capture from a mic on
2368 // primary HW module
François Gaffie11d30102018-11-02 16:09:09 +01002369 DeviceVector primaryInputDevices = availablePrimaryModuleInputDevices();
2370 if (primaryInputDevices.contains(inputDesc->getDevice()) &&
Eric Laurent8f42ea12018-08-08 09:08:25 -07002371 mInputs.activeInputsCountOnDevices(primaryInputDevices) == 0) {
Ytai Ben-Tsvi74cd6b02019-10-25 10:06:40 -07002372 mpClientInterface->setSoundTriggerCaptureState(false);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002373 }
2374 inputDesc->clearPreemptedSessions();
Eric Laurente552edb2014-03-10 17:42:56 -07002375 }
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002376 return NO_ERROR;
Eric Laurente552edb2014-03-10 17:42:56 -07002377}
2378
Eric Laurent8fc147b2018-07-22 19:13:55 -07002379void AudioPolicyManager::releaseInput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07002380{
Eric Laurent8fc147b2018-07-22 19:13:55 -07002381 ALOGV("%s portId %d", __FUNCTION__, portId);
2382
2383 sp<AudioInputDescriptor> inputDesc = mInputs.getInputForClient(portId);
2384 if (inputDesc == 0) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002385 ALOGW("%s no input for client %d", __FUNCTION__, portId);
Eric Laurente552edb2014-03-10 17:42:56 -07002386 return;
2387 }
Andy Hung39efb7a2018-09-26 15:39:28 -07002388 sp<RecordClientDescriptor> client = inputDesc->getClient(portId);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002389 audio_io_handle_t input = inputDesc->mIoHandle;
2390
Eric Laurent8f42ea12018-08-08 09:08:25 -07002391 ALOGV("%s %d", __FUNCTION__, input);
Paul McLean466dc8e2015-04-17 13:15:36 -06002392
Andy Hung39efb7a2018-09-26 15:39:28 -07002393 inputDesc->removeClient(portId);
Eric Laurent599c7582015-12-07 18:05:55 -08002394
Andy Hung39efb7a2018-09-26 15:39:28 -07002395 if (inputDesc->getClientCount() > 0) {
2396 ALOGV("%s(%d) %zu clients remaining", __func__, portId, inputDesc->getClientCount());
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002397 return;
2398 }
2399
Eric Laurent05b90f82014-08-27 15:32:29 -07002400 closeInput(input);
Eric Laurentb52c1522014-05-20 11:27:36 -07002401 mpClientInterface->onAudioPortListUpdate();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002402 ALOGV("%s exit", __FUNCTION__);
Eric Laurente552edb2014-03-10 17:42:56 -07002403}
2404
Eric Laurent8f42ea12018-08-08 09:08:25 -07002405void AudioPolicyManager::closeActiveClients(const sp<AudioInputDescriptor>& input)
Eric Laurent8fc147b2018-07-22 19:13:55 -07002406{
Eric Laurent8f42ea12018-08-08 09:08:25 -07002407 RecordClientVector clients = input->clientsList(true);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002408
2409 for (const auto& client : clients) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002410 closeClient(client->portId());
Eric Laurent8fc147b2018-07-22 19:13:55 -07002411 }
2412}
2413
Eric Laurent8f42ea12018-08-08 09:08:25 -07002414void AudioPolicyManager::closeClient(audio_port_handle_t portId)
2415{
2416 stopInput(portId);
2417 releaseInput(portId);
2418}
Eric Laurent8fc147b2018-07-22 19:13:55 -07002419
Eric Laurent0dd51852019-04-19 18:18:58 -07002420void AudioPolicyManager::checkCloseInputs() {
2421 // After connecting or disconnecting an input device, close input if:
2422 // - it has no client (was just opened to check profile) OR
2423 // - none of its supported devices are connected anymore OR
2424 // - one of its clients cannot be routed to one of its supported
2425 // devices anymore. Otherwise update device selection
2426 std::vector<audio_io_handle_t> inputsToClose;
2427 for (size_t i = 0; i < mInputs.size(); i++) {
2428 const sp<AudioInputDescriptor> input = mInputs.valueAt(i);
2429 if (input->clientsList().size() == 0
Eric Laurent7bd29392019-07-13 09:32:47 -07002430 || !mAvailableInputDevices.containsAtLeastOne(input->supportedDevices())
jiabin4ef93452019-09-10 14:29:54 -07002431 || (input->getPolicyAudioPort()->getFlags()
2432 & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0) {
Eric Laurent0dd51852019-04-19 18:18:58 -07002433 inputsToClose.push_back(mInputs.keyAt(i));
2434 } else {
2435 bool close = false;
2436 for (const auto& client : input->clientsList()) {
2437 sp<DeviceDescriptor> device =
2438 mEngine->getInputDeviceForAttributes(client->attributes());
2439 if (!input->supportedDevices().contains(device)) {
2440 close = true;
2441 break;
2442 }
2443 }
2444 if (close) {
2445 inputsToClose.push_back(mInputs.keyAt(i));
2446 } else {
2447 setInputDevice(input->mIoHandle, getNewInputDevice(input));
2448 }
2449 }
2450 }
2451
2452 for (const audio_io_handle_t handle : inputsToClose) {
2453 ALOGV("%s closing input %d", __func__, handle);
2454 closeInput(handle);
Eric Laurent05b90f82014-08-27 15:32:29 -07002455 }
Eric Laurentd4692962014-05-05 18:13:44 -07002456}
2457
François Gaffie251c7f02018-11-07 10:41:08 +01002458void AudioPolicyManager::initStreamVolume(audio_stream_type_t stream, int indexMin, int indexMax)
Eric Laurente552edb2014-03-10 17:42:56 -07002459{
2460 ALOGV("initStreamVolume() stream %d, min %d, max %d", stream , indexMin, indexMax);
Revathi Uddarajufe0fb8b2017-07-27 17:05:37 +08002461 if (indexMin < 0 || indexMax < 0) {
2462 ALOGE("%s for stream %d: invalid min %d or max %d", __func__, stream , indexMin, indexMax);
2463 return;
2464 }
Eric Laurentf5aa58d2019-02-22 18:20:11 -08002465 getVolumeCurves(stream).initVolume(indexMin, indexMax);
Eric Laurent28d09f02016-03-08 10:43:05 -08002466
2467 // initialize other private stream volumes which follow this one
Eric Laurent794fde22016-03-11 09:50:45 -08002468 for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) {
2469 if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
Eric Laurent28d09f02016-03-08 10:43:05 -08002470 continue;
2471 }
Eric Laurentf5aa58d2019-02-22 18:20:11 -08002472 getVolumeCurves((audio_stream_type_t)curStream).initVolume(indexMin, indexMax);
Eric Laurent223fd5c2014-11-11 13:43:36 -08002473 }
Eric Laurente552edb2014-03-10 17:42:56 -07002474}
2475
Eric Laurente0720872014-03-11 09:30:41 -07002476status_t AudioPolicyManager::setStreamVolumeIndex(audio_stream_type_t stream,
François Gaffie53615e22015-03-19 09:24:12 +01002477 int index,
2478 audio_devices_t device)
Eric Laurente552edb2014-03-10 17:42:56 -07002479{
François Gaffieaaac0fd2018-11-22 17:56:39 +01002480 auto attributes = mEngine->getAttributesForStreamType(stream);
François Gaffieaaac0fd2018-11-22 17:56:39 +01002481 ALOGV("%s: stream %s attributes=%s", __func__,
2482 toString(stream).c_str(), toString(attributes).c_str());
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002483 return setVolumeIndexForAttributes(attributes, index, device);
Eric Laurente552edb2014-03-10 17:42:56 -07002484}
2485
Eric Laurente0720872014-03-11 09:30:41 -07002486status_t AudioPolicyManager::getStreamVolumeIndex(audio_stream_type_t stream,
François Gaffieaaac0fd2018-11-22 17:56:39 +01002487 int *index,
2488 audio_devices_t device)
Eric Laurente552edb2014-03-10 17:42:56 -07002489{
François Gaffiec005e562018-11-06 15:04:49 +01002490 // if device is AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME, return volume for device selected for this
2491 // stream by the engine.
jiabin9a3361e2019-10-01 09:38:30 -07002492 DeviceTypeSet deviceTypes = {device};
Eric Laurent5a2b6292016-04-14 18:05:57 -07002493 if (device == AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
jiabin9a3361e2019-10-01 09:38:30 -07002494 deviceTypes = mEngine->getOutputDevicesForStream(
2495 stream, true /*fromCache*/).types();
Eric Laurente552edb2014-03-10 17:42:56 -07002496 }
jiabin9a3361e2019-10-01 09:38:30 -07002497 return getVolumeIndex(getVolumeCurves(stream), *index, deviceTypes);
Eric Laurente552edb2014-03-10 17:42:56 -07002498}
2499
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002500status_t AudioPolicyManager::setVolumeIndexForAttributes(const audio_attributes_t &attributes,
François Gaffiecfe17322018-11-07 13:41:29 +01002501 int index,
2502 audio_devices_t device)
2503{
2504 // Get Volume group matching the Audio Attributes
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002505 auto group = mEngine->getVolumeGroupForAttributes(attributes);
2506 if (group == VOLUME_GROUP_NONE) {
2507 ALOGD("%s: no group matching with %s", __FUNCTION__, toString(attributes).c_str());
François Gaffiecfe17322018-11-07 13:41:29 +01002508 return BAD_VALUE;
2509 }
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002510 ALOGV("%s: group %d matching with %s", __FUNCTION__, group, toString(attributes).c_str());
François Gaffiecfe17322018-11-07 13:41:29 +01002511 status_t status = NO_ERROR;
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002512 IVolumeCurves &curves = getVolumeCurves(attributes);
François Gaffieaaac0fd2018-11-22 17:56:39 +01002513 VolumeSource vs = toVolumeSource(group);
2514 product_strategy_t strategy = mEngine->getProductStrategyForAttributes(attributes);
2515
2516 status = setVolumeCurveIndex(index, device, curves);
2517 if (status != NO_ERROR) {
2518 ALOGE("%s failed to set curve index for group %d device 0x%X", __func__, group, device);
2519 return status;
2520 }
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002521
jiabin9a3361e2019-10-01 09:38:30 -07002522 DeviceTypeSet curSrcDevices;
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002523 auto curCurvAttrs = curves.getAttributes();
2524 if (!curCurvAttrs.empty() && curCurvAttrs.front() != defaultAttr) {
2525 auto attr = curCurvAttrs.front();
jiabin9a3361e2019-10-01 09:38:30 -07002526 curSrcDevices = mEngine->getOutputDevicesForAttributes(attr, nullptr, false).types();
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002527 } else if (!curves.getStreamTypes().empty()) {
2528 auto stream = curves.getStreamTypes().front();
jiabin9a3361e2019-10-01 09:38:30 -07002529 curSrcDevices = mEngine->getOutputDevicesForStream(stream, false).types();
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002530 } else {
2531 ALOGE("%s: Invalid src %d: no valid attributes nor stream",__func__, vs);
2532 return BAD_VALUE;
2533 }
jiabin9a3361e2019-10-01 09:38:30 -07002534 audio_devices_t curSrcDevice = Volume::getDeviceForVolume(curSrcDevices);
2535 resetDeviceTypes(curSrcDevices, curSrcDevice);
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002536
François Gaffiecfe17322018-11-07 13:41:29 +01002537 // update volume on all outputs and streams matching the following:
2538 // - The requested stream (or a stream matching for volume control) is active on the output
2539 // - The device (or devices) selected by the engine for this stream includes
2540 // the requested device
2541 // - For non default requested device, currently selected device on the output is either the
2542 // requested device or one of the devices selected by the engine for this stream
2543 // - For default requested device (AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME), apply volume only if
2544 // no specific device volume value exists for currently selected device.
François Gaffieaaac0fd2018-11-22 17:56:39 +01002545 for (size_t i = 0; i < mOutputs.size(); i++) {
2546 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
jiabin9a3361e2019-10-01 09:38:30 -07002547 DeviceTypeSet curDevices = desc->devices().types();
François Gaffieaaac0fd2018-11-22 17:56:39 +01002548
jiabin9a3361e2019-10-01 09:38:30 -07002549 if (curDevices.erase(AUDIO_DEVICE_OUT_SPEAKER_SAFE)) {
2550 curDevices.insert(AUDIO_DEVICE_OUT_SPEAKER);
Robert Lee5e66e792019-04-03 18:37:15 +08002551 }
2552
François Gaffieaaac0fd2018-11-22 17:56:39 +01002553 // Inter / intra volume group priority management: Loop on strategies arranged by priority
2554 // If a higher priority strategy is active, and the output is routed to a device with a
2555 // HW Gain management, do not change the volume
2556 bool applyVolume = false;
2557 if (desc->useHwGain()) {
François Gaffie9e1533c2019-04-11 16:07:36 +02002558 if (!(desc->isActive(toVolumeSource(group)) || isInCall())) {
François Gaffieaaac0fd2018-11-22 17:56:39 +01002559 continue;
2560 }
2561 for (const auto &productStrategy : mEngine->getOrderedProductStrategies()) {
2562 auto activeClients = desc->clientsList(true /*activeOnly*/, productStrategy,
2563 false /*preferredDevice*/);
2564 if (activeClients.empty()) {
2565 continue;
2566 }
2567 bool isPreempted = false;
2568 bool isHigherPriority = productStrategy < strategy;
2569 for (const auto &client : activeClients) {
2570 if (isHigherPriority && (client->volumeSource() != vs)) {
2571 ALOGV("%s: Strategy=%d (\nrequester:\n"
2572 " group %d, volumeGroup=%d attributes=%s)\n"
2573 " higher priority source active:\n"
2574 " volumeGroup=%d attributes=%s) \n"
2575 " on output %zu, bailing out", __func__, productStrategy,
2576 group, group, toString(attributes).c_str(),
2577 client->volumeSource(), toString(client->attributes()).c_str(), i);
2578 applyVolume = false;
2579 isPreempted = true;
2580 break;
2581 }
2582 // However, continue for loop to ensure no higher prio clients running on output
2583 if (client->volumeSource() == vs) {
2584 applyVolume = true;
2585 }
2586 }
2587 if (isPreempted || applyVolume) {
2588 break;
2589 }
2590 }
2591 if (!applyVolume) {
2592 continue; // next output
2593 }
jiabin9a3361e2019-10-01 09:38:30 -07002594 status_t volStatus = checkAndSetVolume(curves, vs, index, desc, curDevices,
François Gaffieaaac0fd2018-11-22 17:56:39 +01002595 (vs == toVolumeSource(AUDIO_STREAM_SYSTEM)?
2596 TOUCH_SOUND_FIXED_DELAY_MS : 0));
2597 if (volStatus != NO_ERROR) {
2598 status = volStatus;
2599 }
2600 continue;
2601 }
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002602 if (!(desc->isActive(vs) || isInCall())) {
2603 continue;
2604 }
jiabin9a3361e2019-10-01 09:38:30 -07002605 if (device != AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME &&
2606 curDevices.find(device) == curDevices.end()) {
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002607 continue;
2608 }
2609 if (device != AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
jiabin9a3361e2019-10-01 09:38:30 -07002610 curSrcDevices.insert(device);
2611 applyVolume = (curSrcDevices.find(
2612 Volume::getDeviceForVolume(curDevices)) != curSrcDevices.end());
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002613 } else {
2614 applyVolume = !curves.hasVolumeIndexForDevice(curSrcDevice);
2615 }
2616 if (applyVolume) {
2617 //FIXME: workaround for truncated touch sounds
2618 // delayed volume change for system stream to be removed when the problem is
2619 // handled by system UI
2620 status_t volStatus = checkAndSetVolume(
jiabin9a3361e2019-10-01 09:38:30 -07002621 curves, vs, index, desc, curDevices,
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002622 ((vs == toVolumeSource(AUDIO_STREAM_SYSTEM))?
2623 TOUCH_SOUND_FIXED_DELAY_MS : 0));
2624 if (volStatus != NO_ERROR) {
2625 status = volStatus;
François Gaffieaaac0fd2018-11-22 17:56:39 +01002626 }
2627 }
2628 }
François Gaffiecfe17322018-11-07 13:41:29 +01002629 mpClientInterface->onAudioVolumeGroupChanged(group, 0 /*flags*/);
2630 return status;
2631}
2632
François Gaffieaaac0fd2018-11-22 17:56:39 +01002633status_t AudioPolicyManager::setVolumeCurveIndex(int index,
François Gaffiecfe17322018-11-07 13:41:29 +01002634 audio_devices_t device,
2635 IVolumeCurves &volumeCurves)
2636{
2637 // VOICE_CALL stream has minVolumeIndex > 0 but can be muted directly by an
2638 // app that has MODIFY_PHONE_STATE permission.
François Gaffieaaac0fd2018-11-22 17:56:39 +01002639 bool hasVoice = hasVoiceStream(volumeCurves.getStreamTypes());
2640 if (((index < volumeCurves.getVolumeIndexMin()) && !(hasVoice && index == 0)) ||
François Gaffiecfe17322018-11-07 13:41:29 +01002641 (index > volumeCurves.getVolumeIndexMax())) {
2642 ALOGD("%s: wrong index %d min=%d max=%d", __FUNCTION__, index,
2643 volumeCurves.getVolumeIndexMin(), volumeCurves.getVolumeIndexMax());
2644 return BAD_VALUE;
2645 }
2646 if (!audio_is_output_device(device)) {
2647 return BAD_VALUE;
2648 }
2649
2650 // Force max volume if stream cannot be muted
2651 if (!volumeCurves.canBeMuted()) index = volumeCurves.getVolumeIndexMax();
2652
François Gaffieaaac0fd2018-11-22 17:56:39 +01002653 ALOGV("%s device %08x, index %d", __FUNCTION__ , device, index);
François Gaffiecfe17322018-11-07 13:41:29 +01002654 volumeCurves.addCurrentVolumeIndex(device, index);
2655 return NO_ERROR;
2656}
2657
2658status_t AudioPolicyManager::getVolumeIndexForAttributes(const audio_attributes_t &attr,
2659 int &index,
2660 audio_devices_t device)
2661{
2662 // if device is AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME, return volume for device selected for this
2663 // stream by the engine.
jiabin9a3361e2019-10-01 09:38:30 -07002664 DeviceTypeSet deviceTypes = {device};
François Gaffiecfe17322018-11-07 13:41:29 +01002665 if (device == AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
jiabin9a3361e2019-10-01 09:38:30 -07002666 DeviceTypeSet deviceTypes = mEngine->getOutputDevicesForAttributes(
2667 attr, nullptr, true /*fromCache*/).types();
François Gaffiecfe17322018-11-07 13:41:29 +01002668 }
jiabin9a3361e2019-10-01 09:38:30 -07002669 return getVolumeIndex(getVolumeCurves(attr), index, deviceTypes);
François Gaffiecfe17322018-11-07 13:41:29 +01002670}
2671
2672status_t AudioPolicyManager::getVolumeIndex(const IVolumeCurves &curves,
2673 int &index,
jiabin9a3361e2019-10-01 09:38:30 -07002674 const DeviceTypeSet& deviceTypes) const
François Gaffiecfe17322018-11-07 13:41:29 +01002675{
jiabin9a3361e2019-10-01 09:38:30 -07002676 if (isSingleDeviceType(deviceTypes, audio_is_output_device)) {
François Gaffiecfe17322018-11-07 13:41:29 +01002677 return BAD_VALUE;
2678 }
jiabin9a3361e2019-10-01 09:38:30 -07002679 index = curves.getVolumeIndex(deviceTypes);
2680 ALOGV("%s: device %s index %d", __FUNCTION__, dumpDeviceTypes(deviceTypes).c_str(), index);
François Gaffiecfe17322018-11-07 13:41:29 +01002681 return NO_ERROR;
2682}
2683
2684status_t AudioPolicyManager::getMinVolumeIndexForAttributes(const audio_attributes_t &attr,
2685 int &index)
2686{
2687 index = getVolumeCurves(attr).getVolumeIndexMin();
2688 return NO_ERROR;
2689}
2690
2691status_t AudioPolicyManager::getMaxVolumeIndexForAttributes(const audio_attributes_t &attr,
2692 int &index)
2693{
2694 index = getVolumeCurves(attr).getVolumeIndexMax();
2695 return NO_ERROR;
2696}
2697
Eric Laurent36829f92017-04-07 19:04:42 -07002698audio_io_handle_t AudioPolicyManager::selectOutputForMusicEffects()
Eric Laurente552edb2014-03-10 17:42:56 -07002699{
2700 // select one output among several suitable for global effects.
2701 // The priority is as follows:
2702 // 1: An offloaded output. If the effect ends up not being offloadable,
2703 // AudioFlinger will invalidate the track and the offloaded output
2704 // will be closed causing the effect to be moved to a PCM output.
2705 // 2: A deep buffer output
Eric Laurent36829f92017-04-07 19:04:42 -07002706 // 3: The primary output
2707 // 4: the first output in the list
Eric Laurente552edb2014-03-10 17:42:56 -07002708
François Gaffiec005e562018-11-06 15:04:49 +01002709 DeviceVector devices = mEngine->getOutputDevicesForAttributes(
2710 attributes_initializer(AUDIO_USAGE_MEDIA), nullptr, false /*fromCache*/);
François Gaffie11d30102018-11-02 16:09:09 +01002711 SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
Eric Laurente552edb2014-03-10 17:42:56 -07002712
Eric Laurent36829f92017-04-07 19:04:42 -07002713 if (outputs.size() == 0) {
2714 return AUDIO_IO_HANDLE_NONE;
2715 }
Eric Laurente552edb2014-03-10 17:42:56 -07002716
Eric Laurent36829f92017-04-07 19:04:42 -07002717 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
2718 bool activeOnly = true;
2719
2720 while (output == AUDIO_IO_HANDLE_NONE) {
2721 audio_io_handle_t outputOffloaded = AUDIO_IO_HANDLE_NONE;
2722 audio_io_handle_t outputDeepBuffer = AUDIO_IO_HANDLE_NONE;
2723 audio_io_handle_t outputPrimary = AUDIO_IO_HANDLE_NONE;
2724
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002725 for (audio_io_handle_t output : outputs) {
2726 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
Eric Laurent83d17c22019-04-02 17:10:01 -07002727 if (activeOnly && !desc->isActive(toVolumeSource(AUDIO_STREAM_MUSIC))) {
Eric Laurent36829f92017-04-07 19:04:42 -07002728 continue;
2729 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002730 ALOGV("selectOutputForMusicEffects activeOnly %d output %d flags 0x%08x",
2731 activeOnly, output, desc->mFlags);
Eric Laurent36829f92017-04-07 19:04:42 -07002732 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002733 outputOffloaded = output;
Eric Laurent36829f92017-04-07 19:04:42 -07002734 }
2735 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) != 0) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002736 outputDeepBuffer = output;
Eric Laurent36829f92017-04-07 19:04:42 -07002737 }
2738 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY) != 0) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002739 outputPrimary = output;
Eric Laurent36829f92017-04-07 19:04:42 -07002740 }
2741 }
2742 if (outputOffloaded != AUDIO_IO_HANDLE_NONE) {
2743 output = outputOffloaded;
2744 } else if (outputDeepBuffer != AUDIO_IO_HANDLE_NONE) {
2745 output = outputDeepBuffer;
2746 } else if (outputPrimary != AUDIO_IO_HANDLE_NONE) {
2747 output = outputPrimary;
2748 } else {
2749 output = outputs[0];
2750 }
2751 activeOnly = false;
2752 }
2753
2754 if (output != mMusicEffectOutput) {
Eric Laurent6c796322019-04-09 14:13:17 -07002755 mEffects.moveEffects(AUDIO_SESSION_OUTPUT_MIX, mMusicEffectOutput, output);
Eric Laurent36829f92017-04-07 19:04:42 -07002756 mpClientInterface->moveEffects(AUDIO_SESSION_OUTPUT_MIX, mMusicEffectOutput, output);
2757 mMusicEffectOutput = output;
2758 }
2759
2760 ALOGV("selectOutputForMusicEffects selected output %d", output);
Eric Laurente552edb2014-03-10 17:42:56 -07002761 return output;
2762}
2763
Eric Laurent36829f92017-04-07 19:04:42 -07002764audio_io_handle_t AudioPolicyManager::getOutputForEffect(const effect_descriptor_t *desc __unused)
2765{
2766 return selectOutputForMusicEffects();
2767}
2768
Eric Laurente0720872014-03-11 09:30:41 -07002769status_t AudioPolicyManager::registerEffect(const effect_descriptor_t *desc,
Eric Laurente552edb2014-03-10 17:42:56 -07002770 audio_io_handle_t io,
2771 uint32_t strategy,
2772 int session,
2773 int id)
2774{
Eric Laurentb82e6b72019-11-22 17:25:04 -08002775 if (session != AUDIO_SESSION_DEVICE) {
2776 ssize_t index = mOutputs.indexOfKey(io);
Eric Laurente552edb2014-03-10 17:42:56 -07002777 if (index < 0) {
Eric Laurentb82e6b72019-11-22 17:25:04 -08002778 index = mInputs.indexOfKey(io);
2779 if (index < 0) {
2780 ALOGW("registerEffect() unknown io %d", io);
2781 return INVALID_OPERATION;
2782 }
Eric Laurente552edb2014-03-10 17:42:56 -07002783 }
2784 }
François Gaffiec005e562018-11-06 15:04:49 +01002785 return mEffects.registerEffect(desc, io, session, id,
2786 (strategy == streamToStrategy(AUDIO_STREAM_MUSIC) ||
2787 strategy == PRODUCT_STRATEGY_NONE));
Eric Laurente552edb2014-03-10 17:42:56 -07002788}
2789
Eric Laurentc241b0d2018-11-28 09:08:49 -08002790status_t AudioPolicyManager::unregisterEffect(int id)
2791{
2792 if (mEffects.getEffect(id) == nullptr) {
2793 return INVALID_OPERATION;
2794 }
Eric Laurentc241b0d2018-11-28 09:08:49 -08002795 if (mEffects.isEffectEnabled(id)) {
2796 ALOGW("%s effect %d enabled", __FUNCTION__, id);
2797 setEffectEnabled(id, false);
2798 }
2799 return mEffects.unregisterEffect(id);
2800}
2801
2802status_t AudioPolicyManager::setEffectEnabled(int id, bool enabled)
2803{
2804 sp<EffectDescriptor> effect = mEffects.getEffect(id);
2805 if (effect == nullptr) {
2806 return INVALID_OPERATION;
2807 }
2808
2809 status_t status = mEffects.setEffectEnabled(id, enabled);
2810 if (status == NO_ERROR) {
2811 mInputs.trackEffectEnabled(effect, enabled);
2812 }
2813 return status;
2814}
2815
Eric Laurent6c796322019-04-09 14:13:17 -07002816
2817status_t AudioPolicyManager::moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io)
2818{
2819 mEffects.moveEffects(ids, io);
2820 return NO_ERROR;
2821}
2822
Eric Laurentc75307b2015-03-17 15:29:32 -07002823bool AudioPolicyManager::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
2824{
François Gaffieaaac0fd2018-11-22 17:56:39 +01002825 return mOutputs.isActive(toVolumeSource(stream), inPastMs);
Eric Laurentc75307b2015-03-17 15:29:32 -07002826}
2827
2828bool AudioPolicyManager::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
2829{
François Gaffieaaac0fd2018-11-22 17:56:39 +01002830 return mOutputs.isActiveRemotely(toVolumeSource(stream), inPastMs);
Eric Laurentc75307b2015-03-17 15:29:32 -07002831}
2832
Eric Laurente0720872014-03-11 09:30:41 -07002833bool AudioPolicyManager::isSourceActive(audio_source_t source) const
Eric Laurente552edb2014-03-10 17:42:56 -07002834{
2835 for (size_t i = 0; i < mInputs.size(); i++) {
Eric Laurent1f2f2232014-06-02 12:01:23 -07002836 const sp<AudioInputDescriptor> inputDescriptor = mInputs.valueAt(i);
Eric Laurent599c7582015-12-07 18:05:55 -08002837 if (inputDescriptor->isSourceActive(source)) {
Eric Laurente552edb2014-03-10 17:42:56 -07002838 return true;
2839 }
2840 }
2841 return false;
2842}
2843
Eric Laurent275e8e92014-11-30 15:14:47 -08002844// Register a list of custom mixes with their attributes and format.
2845// When a mix is registered, corresponding input and output profiles are
2846// added to the remote submix hw module. The profile contains only the
2847// parameters (sampling rate, format...) specified by the mix.
2848// The corresponding input remote submix device is also connected.
2849//
2850// When a remote submix device is connected, the address is checked to select the
2851// appropriate profile and the corresponding input or output stream is opened.
2852//
2853// When capture starts, getInputForAttr() will:
2854// - 1 look for a mix matching the address passed in attribtutes tags if any
2855// - 2 if none found, getDeviceForInputSource() will:
2856// - 2.1 look for a mix matching the attributes source
2857// - 2.2 if none found, default to device selection by policy rules
2858// At this time, the corresponding output remote submix device is also connected
2859// and active playback use cases can be transferred to this mix if needed when reconnecting
2860// after AudioTracks are invalidated
2861//
2862// When playback starts, getOutputForAttr() will:
2863// - 1 look for a mix matching the address passed in attribtutes tags if any
2864// - 2 if none found, look for a mix matching the attributes usage
2865// - 3 if none found, default to device and output selection by policy rules.
2866
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002867status_t AudioPolicyManager::registerPolicyMixes(const Vector<AudioMix>& mixes)
Eric Laurent275e8e92014-11-30 15:14:47 -08002868{
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002869 ALOGV("registerPolicyMixes() %zu mix(es)", mixes.size());
2870 status_t res = NO_ERROR;
2871
2872 sp<HwModule> rSubmixModule;
2873 // examine each mix's route type
2874 for (size_t i = 0; i < mixes.size(); i++) {
Eric Laurent97ac8712018-07-27 18:59:02 -07002875 AudioMix mix = mixes[i];
Kevin Rocard153f92d2018-12-18 18:33:28 -08002876 // Only capture of playback is allowed in LOOP_BACK & RENDER mode
2877 if (is_mix_loopback_render(mix.mRouteFlags) && mix.mMixType != MIX_TYPE_PLAYERS) {
2878 ALOGE("Unsupported Policy Mix %zu of %zu: "
2879 "Only capture of playback is allowed in LOOP_BACK & RENDER mode",
2880 i, mixes.size());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002881 res = INVALID_OPERATION;
Eric Laurent275e8e92014-11-30 15:14:47 -08002882 break;
2883 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08002884 // LOOP_BACK and LOOP_BACK | RENDER have the same remote submix backend and are handled
2885 // in the same way.
Eric Laurent97ac8712018-07-27 18:59:02 -07002886 if ((mix.mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08002887 ALOGV("registerPolicyMixes() mix %zu of %zu is LOOP_BACK %d", i, mixes.size(),
2888 mix.mRouteFlags);
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002889 if (rSubmixModule == 0) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08002890 rSubmixModule = mHwModules.getModuleFromName(
2891 AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX);
2892 if (rSubmixModule == 0) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08002893 ALOGE("Unable to find audio module for submix, aborting mix %zu registration",
Mikhail Naganovd4120142017-12-06 15:49:22 -08002894 i);
2895 res = INVALID_OPERATION;
2896 break;
2897 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002898 }
Eric Laurent275e8e92014-11-30 15:14:47 -08002899
Eric Laurent97ac8712018-07-27 18:59:02 -07002900 String8 address = mix.mDeviceAddress;
Jean-Michel Trivi67917272019-05-22 11:54:37 -07002901 audio_devices_t deviceTypeToMakeAvailable;
Eric Laurent97ac8712018-07-27 18:59:02 -07002902 if (mix.mMixType == MIX_TYPE_PLAYERS) {
Eric Laurent97ac8712018-07-27 18:59:02 -07002903 mix.mDeviceType = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
Jean-Michel Trivi67917272019-05-22 11:54:37 -07002904 deviceTypeToMakeAvailable = AUDIO_DEVICE_IN_REMOTE_SUBMIX;
2905 } else {
2906 mix.mDeviceType = AUDIO_DEVICE_IN_REMOTE_SUBMIX;
2907 deviceTypeToMakeAvailable = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
Eric Laurent97ac8712018-07-27 18:59:02 -07002908 }
François Gaffie036e1e92015-03-19 10:16:24 +01002909
Jean-Michel Trivi67917272019-05-22 11:54:37 -07002910 if (mPolicyMixes.registerMix(mix, 0 /*output desc*/) != NO_ERROR) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08002911 ALOGE("Error registering mix %zu for address %s", i, address.string());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002912 res = INVALID_OPERATION;
2913 break;
2914 }
Eric Laurent97ac8712018-07-27 18:59:02 -07002915 audio_config_t outputConfig = mix.mFormat;
2916 audio_config_t inputConfig = mix.mFormat;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002917 // NOTE: audio flinger mixer does not support mono output: configure remote submix HAL in
2918 // stereo and let audio flinger do the channel conversion if needed.
2919 outputConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
2920 inputConfig.channel_mask = AUDIO_CHANNEL_IN_STEREO;
jiabin5740f082019-08-19 15:08:30 -07002921 rSubmixModule->addOutputProfile(address.c_str(), &outputConfig,
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002922 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, address);
jiabin5740f082019-08-19 15:08:30 -07002923 rSubmixModule->addInputProfile(address.c_str(), &inputConfig,
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002924 AUDIO_DEVICE_IN_REMOTE_SUBMIX, address);
François Gaffie036e1e92015-03-19 10:16:24 +01002925
Jean-Michel Trivi67917272019-05-22 11:54:37 -07002926 if ((res = setDeviceConnectionStateInt(deviceTypeToMakeAvailable,
jiabinc1de2df2019-05-07 14:26:40 -07002927 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2928 address.string(), "remote-submix", AUDIO_FORMAT_DEFAULT)) != NO_ERROR) {
2929 ALOGE("Failed to set remote submix device available, type %u, address %s",
2930 mix.mDeviceType, address.string());
2931 break;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002932 }
Eric Laurent97ac8712018-07-27 18:59:02 -07002933 } else if ((mix.mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) {
2934 String8 address = mix.mDeviceAddress;
Eric Laurent2c80be02019-01-23 18:06:37 -08002935 audio_devices_t type = mix.mDeviceType;
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07002936 ALOGV(" registerPolicyMixes() mix %zu of %zu is RENDER, dev=0x%X addr=%s",
Eric Laurent2c80be02019-01-23 18:06:37 -08002937 i, mixes.size(), type, address.string());
2938
2939 sp<DeviceDescriptor> device = mHwModules.getDeviceDescriptor(
2940 mix.mDeviceType, mix.mDeviceAddress,
2941 String8(), AUDIO_FORMAT_DEFAULT);
2942 if (device == nullptr) {
2943 res = INVALID_OPERATION;
2944 break;
2945 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002946
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07002947 bool foundOutput = false;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002948 for (size_t j = 0 ; j < mOutputs.size() ; j++) {
2949 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(j);
Eric Laurent2c80be02019-01-23 18:06:37 -08002950
2951 if (desc->supportedDevices().contains(device)) {
Jean-Michel Trivi67917272019-05-22 11:54:37 -07002952 if (mPolicyMixes.registerMix(mix, desc) != NO_ERROR) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08002953 ALOGE("Could not register mix RENDER, dev=0x%X addr=%s", type,
2954 address.string());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002955 res = INVALID_OPERATION;
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07002956 } else {
2957 foundOutput = true;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002958 }
2959 break;
2960 }
2961 }
2962
2963 if (res != NO_ERROR) {
2964 ALOGE(" Error registering mix %zu for device 0x%X addr %s",
Eric Laurent2c80be02019-01-23 18:06:37 -08002965 i, type, address.string());
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07002966 res = INVALID_OPERATION;
2967 break;
2968 } else if (!foundOutput) {
2969 ALOGE(" Output not found for mix %zu for device 0x%X addr %s",
Eric Laurent2c80be02019-01-23 18:06:37 -08002970 i, type, address.string());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002971 res = INVALID_OPERATION;
2972 break;
2973 }
Eric Laurentc722f302014-12-10 11:21:49 -08002974 }
Eric Laurent275e8e92014-11-30 15:14:47 -08002975 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002976 if (res != NO_ERROR) {
2977 unregisterPolicyMixes(mixes);
2978 }
2979 return res;
Eric Laurent275e8e92014-11-30 15:14:47 -08002980}
2981
2982status_t AudioPolicyManager::unregisterPolicyMixes(Vector<AudioMix> mixes)
2983{
Eric Laurent7b279bb2015-12-14 10:18:23 -08002984 ALOGV("unregisterPolicyMixes() num mixes %zu", mixes.size());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002985 status_t res = NO_ERROR;
2986 sp<HwModule> rSubmixModule;
2987 // examine each mix's route type
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002988 for (const auto& mix : mixes) {
2989 if ((mix.mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) {
François Gaffie036e1e92015-03-19 10:16:24 +01002990
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002991 if (rSubmixModule == 0) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08002992 rSubmixModule = mHwModules.getModuleFromName(
2993 AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX);
2994 if (rSubmixModule == 0) {
2995 res = INVALID_OPERATION;
2996 continue;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08002997 }
2998 }
Eric Laurent275e8e92014-11-30 15:14:47 -08002999
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003000 String8 address = mix.mDeviceAddress;
Eric Laurent275e8e92014-11-30 15:14:47 -08003001
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003002 if (mPolicyMixes.unregisterMix(mix) != NO_ERROR) {
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003003 res = INVALID_OPERATION;
3004 continue;
3005 }
3006
Kevin Rocard04ed0462019-05-02 17:53:24 -07003007 for (auto device : {AUDIO_DEVICE_IN_REMOTE_SUBMIX, AUDIO_DEVICE_OUT_REMOTE_SUBMIX}) {
3008 if (getDeviceConnectionState(device, address.string()) ==
3009 AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
3010 res = setDeviceConnectionStateInt(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
3011 address.string(), "remote-submix",
3012 AUDIO_FORMAT_DEFAULT);
3013 if (res != OK) {
3014 ALOGE("Error making RemoteSubmix device unavailable for mix "
3015 "with type %d, address %s", device, address.string());
3016 }
3017 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003018 }
jiabin5740f082019-08-19 15:08:30 -07003019 rSubmixModule->removeOutputProfile(address.c_str());
3020 rSubmixModule->removeInputProfile(address.c_str());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003021
Kevin Rocard153f92d2018-12-18 18:33:28 -08003022 } else if ((mix.mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) {
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003023 if (mPolicyMixes.unregisterMix(mix) != NO_ERROR) {
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003024 res = INVALID_OPERATION;
3025 continue;
3026 }
Eric Laurent275e8e92014-11-30 15:14:47 -08003027 }
Eric Laurent275e8e92014-11-30 15:14:47 -08003028 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003029 return res;
Eric Laurent275e8e92014-11-30 15:14:47 -08003030}
3031
Mikhail Naganov100f0122018-11-29 11:22:16 -08003032void AudioPolicyManager::dumpManualSurroundFormats(String8 *dst) const
3033{
3034 size_t i = 0;
3035 constexpr size_t audioFormatPrefixLen = sizeof("AUDIO_FORMAT_");
3036 for (const auto& fmt : mManualSurroundFormats) {
3037 if (i++ != 0) dst->append(", ");
3038 std::string sfmt;
3039 FormatConverter::toString(fmt, sfmt);
3040 dst->append(sfmt.size() >= audioFormatPrefixLen ?
3041 sfmt.c_str() + audioFormatPrefixLen - 1 : sfmt.c_str());
3042 }
3043}
3044
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003045status_t AudioPolicyManager::setUidDeviceAffinities(uid_t uid,
3046 const Vector<AudioDeviceTypeAddr>& devices) {
3047 ALOGV("%s() uid=%d num devices %zu", __FUNCTION__, uid, devices.size());
3048 // uid/device affinity is only for output devices
3049 for (size_t i = 0; i < devices.size(); i++) {
3050 if (!audio_is_output_device(devices[i].mType)) {
3051 ALOGE("setUidDeviceAffinities() device=%08x is NOT an output device",
3052 devices[i].mType);
3053 return BAD_VALUE;
3054 }
3055 }
3056 status_t res = mPolicyMixes.setUidDeviceAffinities(uid, devices);
3057 if (res == NO_ERROR) {
3058 // reevaluate outputs for all given devices
3059 for (size_t i = 0; i < devices.size(); i++) {
3060 sp<DeviceDescriptor> devDesc = mHwModules.getDeviceDescriptor(
jiabin05b5edd2019-11-04 14:10:42 -08003061 devices[i].mType, devices[i].mAddress.c_str(), String8(),
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08003062 AUDIO_FORMAT_DEFAULT);
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003063 SortedVector<audio_io_handle_t> outputs;
3064 if (checkOutputsForDevice(devDesc, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
François Gaffie11d30102018-11-02 16:09:09 +01003065 outputs) != NO_ERROR) {
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003066 ALOGE("setUidDeviceAffinities() error in checkOutputsForDevice for device=%08x"
jiabin05b5edd2019-11-04 14:10:42 -08003067 " addr=%s", devices[i].mType, devices[i].mAddress.c_str());
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003068 return INVALID_OPERATION;
3069 }
3070 }
3071 }
3072 return res;
3073}
3074
3075status_t AudioPolicyManager::removeUidDeviceAffinities(uid_t uid) {
3076 ALOGV("%s() uid=%d", __FUNCTION__, uid);
Oscar Azucena4b2a8212019-04-26 23:48:59 -07003077 status_t res = mPolicyMixes.removeUidDeviceAffinities(uid);
3078 if (res != NO_ERROR) {
3079 ALOGE("%s() Could not remove all device affinities fo uid = %d",
3080 __FUNCTION__, uid);
3081 return INVALID_OPERATION;
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003082 }
3083
3084 return res;
3085}
3086
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003087status_t AudioPolicyManager::setPreferredDeviceForStrategy(product_strategy_t strategy,
3088 const AudioDeviceTypeAddr &device) {
3089 ALOGI("%s() strategy=%d device=%08x addr=%s", __FUNCTION__,
3090 strategy, device.mType, device.mAddress.c_str());
3091 // strategy preferred device is only for output devices
3092 if (!audio_is_output_device(device.mType)) {
3093 ALOGE("%s() device=%08x is NOT an output device", __FUNCTION__, device.mType);
3094 return BAD_VALUE;
3095 }
3096
3097 status_t status = mEngine->setPreferredDeviceForStrategy(strategy, device);
3098 if (status != NO_ERROR) {
3099 ALOGW("Engine could not set preferred device %08x %s for strategy %d",
3100 device.mType, device.mAddress.c_str(), strategy);
3101 return status;
3102 }
3103
3104 checkForDeviceAndOutputChanges();
3105 updateCallAndOutputRouting();
3106
3107 return NO_ERROR;
3108}
3109
3110void AudioPolicyManager::updateCallAndOutputRouting(bool forceVolumeReeval, uint32_t delayMs)
3111{
3112 uint32_t waitMs = 0;
3113 if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
3114 DeviceVector newDevices = getNewOutputDevices(mPrimaryOutput, true /*fromCache*/);
3115 waitMs = updateCallRouting(newDevices, delayMs);
3116 }
3117 for (size_t i = 0; i < mOutputs.size(); i++) {
3118 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
3119 DeviceVector newDevices = getNewOutputDevices(outputDesc, true /*fromCache*/);
3120 if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) || (outputDesc != mPrimaryOutput)) {
3121 // As done in setDeviceConnectionState, we could also fix default device issue by
3122 // preventing the force re-routing in case of default dev that distinguishes on address.
3123 // Let's give back to engine full device choice decision however.
3124 waitMs = setOutputDevices(outputDesc, newDevices, !newDevices.isEmpty(), delayMs);
3125 }
3126 if (forceVolumeReeval && !newDevices.isEmpty()) {
3127 applyStreamVolumes(outputDesc, newDevices.types(), waitMs, true);
3128 }
3129 }
3130}
3131
3132status_t AudioPolicyManager::removePreferredDeviceForStrategy(product_strategy_t strategy)
3133{
3134 ALOGI("%s() strategy=%d", __FUNCTION__, strategy);
3135
3136 status_t status = mEngine->removePreferredDeviceForStrategy(strategy);
3137 if (status != NO_ERROR) {
3138 ALOGW("Engine could not remove preferred device for strategy %d", strategy);
3139 return status;
3140 }
3141
3142 checkForDeviceAndOutputChanges();
3143 updateCallAndOutputRouting();
3144
3145 return NO_ERROR;
3146}
3147
3148status_t AudioPolicyManager::getPreferredDeviceForStrategy(product_strategy_t strategy,
3149 AudioDeviceTypeAddr &device) {
3150 return mEngine->getPreferredDeviceForStrategy(strategy, device);
3151}
3152
Oscar Azucena90e77632019-11-27 17:12:28 -08003153status_t AudioPolicyManager::setUserIdDeviceAffinities(int userId,
3154 const Vector<AudioDeviceTypeAddr>& devices) {
3155 ALOGI("%s() userId=%d num devices %zu", __FUNCTION__, userId, devices.size());
3156 // userId/device affinity is only for output devices
3157 for (size_t i = 0; i < devices.size(); i++) {
3158 if (!audio_is_output_device(devices[i].mType)) {
3159 ALOGE("%s() device=%08x is NOT an output device",
3160 __FUNCTION__,
3161 devices[i].mType);
3162 return BAD_VALUE;
3163 }
3164 }
3165
3166 status_t status = mPolicyMixes.setUserIdDeviceAffinities(userId, devices);
3167 if (status != NO_ERROR) {
3168 ALOGE("%s() could not set device affinity for userId %d",
3169 __FUNCTION__, userId);
3170 return status;
3171 }
3172
3173 // reevaluate outputs for all devices
3174 checkForDeviceAndOutputChanges();
3175 updateCallAndOutputRouting();
3176
3177 return NO_ERROR;
3178}
3179
3180status_t AudioPolicyManager::removeUserIdDeviceAffinities(int userId) {
3181 ALOGI("%s() userId=%d", __FUNCTION__, userId);
3182 status_t status = mPolicyMixes.removeUserIdDeviceAffinities(userId);
3183 if (status != NO_ERROR) {
3184 ALOGE("%s() Could not remove all device affinities fo userId = %d",
3185 __FUNCTION__, userId);
3186 return status;
3187 }
3188
3189 // reevaluate outputs for all devices
3190 checkForDeviceAndOutputChanges();
3191 updateCallAndOutputRouting();
3192
3193 return NO_ERROR;
3194}
3195
Andy Hungc29d82b2018-10-05 12:23:17 -07003196void AudioPolicyManager::dump(String8 *dst) const
Eric Laurente552edb2014-03-10 17:42:56 -07003197{
Andy Hungc29d82b2018-10-05 12:23:17 -07003198 dst->appendFormat("\nAudioPolicyManager Dump: %p\n", this);
3199 dst->appendFormat(" Primary Output: %d\n",
Eric Laurent87ffa392015-05-22 10:32:38 -07003200 hasPrimaryOutput() ? mPrimaryOutput->mIoHandle : AUDIO_IO_HANDLE_NONE);
Mikhail Naganov0d6a0332016-04-19 17:12:38 -07003201 std::string stateLiteral;
3202 AudioModeConverter::toString(mEngine->getPhoneState(), stateLiteral);
Andy Hungc29d82b2018-10-05 12:23:17 -07003203 dst->appendFormat(" Phone state: %s\n", stateLiteral.c_str());
Mikhail Naganov2e5167e12018-04-19 13:41:22 -07003204 const char* forceUses[AUDIO_POLICY_FORCE_USE_CNT] = {
3205 "communications", "media", "record", "dock", "system",
3206 "HDMI system audio", "encoded surround output", "vibrate ringing" };
3207 for (audio_policy_force_use_t i = AUDIO_POLICY_FORCE_FOR_COMMUNICATION;
3208 i < AUDIO_POLICY_FORCE_USE_CNT; i = (audio_policy_force_use_t)((int)i + 1)) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08003209 audio_policy_forced_cfg_t forceUseValue = mEngine->getForceUse(i);
3210 dst->appendFormat(" Force use for %s: %d", forceUses[i], forceUseValue);
3211 if (i == AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND &&
3212 forceUseValue == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
3213 dst->append(" (MANUAL: ");
3214 dumpManualSurroundFormats(dst);
3215 dst->append(")");
3216 }
3217 dst->append("\n");
Mikhail Naganov2e5167e12018-04-19 13:41:22 -07003218 }
Andy Hungc29d82b2018-10-05 12:23:17 -07003219 dst->appendFormat(" TTS output %savailable\n", mTtsOutputAvailable ? "" : "not ");
3220 dst->appendFormat(" Master mono: %s\n", mMasterMono ? "on" : "off");
3221 dst->appendFormat(" Config source: %s\n", mConfig.getSource().c_str()); // getConfig not const
3222 mAvailableOutputDevices.dump(dst, String8("Available output"));
3223 mAvailableInputDevices.dump(dst, String8("Available input"));
3224 mHwModulesAll.dump(dst);
3225 mOutputs.dump(dst);
3226 mInputs.dump(dst);
Andy Hungc29d82b2018-10-05 12:23:17 -07003227 mEffects.dump(dst);
3228 mAudioPatches.dump(dst);
3229 mPolicyMixes.dump(dst);
3230 mAudioSources.dump(dst);
François Gaffiec005e562018-11-06 15:04:49 +01003231
Kevin Rocardb99cc752019-03-21 20:52:24 -07003232 dst->appendFormat(" AllowedCapturePolicies:\n");
3233 for (auto& policy : mAllowedCapturePolicies) {
3234 dst->appendFormat(" - uid=%d flag_mask=%#x\n", policy.first, policy.second);
3235 }
3236
François Gaffiec005e562018-11-06 15:04:49 +01003237 dst->appendFormat("\nPolicy Engine dump:\n");
3238 mEngine->dump(dst);
Andy Hungc29d82b2018-10-05 12:23:17 -07003239}
3240
3241status_t AudioPolicyManager::dump(int fd)
3242{
3243 String8 result;
3244 dump(&result);
Andy Hungbb54e202018-10-05 11:42:02 -07003245 write(fd, result.string(), result.size());
Eric Laurente552edb2014-03-10 17:42:56 -07003246 return NO_ERROR;
3247}
3248
Kevin Rocardb99cc752019-03-21 20:52:24 -07003249status_t AudioPolicyManager::setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy)
3250{
3251 mAllowedCapturePolicies[uid] = capturePolicy;
3252 return NO_ERROR;
3253}
3254
Eric Laurente552edb2014-03-10 17:42:56 -07003255// This function checks for the parameters which can be offloaded.
3256// This can be enhanced depending on the capability of the DSP and policy
3257// of the system.
Eric Laurente0720872014-03-11 09:30:41 -07003258bool AudioPolicyManager::isOffloadSupported(const audio_offload_info_t& offloadInfo)
Eric Laurente552edb2014-03-10 17:42:56 -07003259{
3260 ALOGV("isOffloadSupported: SR=%u, CM=0x%x, Format=0x%x, StreamType=%d,"
Eric Laurentd4692962014-05-05 18:13:44 -07003261 " BitRate=%u, duration=%" PRId64 " us, has_video=%d",
Eric Laurente552edb2014-03-10 17:42:56 -07003262 offloadInfo.sample_rate, offloadInfo.channel_mask,
3263 offloadInfo.format,
3264 offloadInfo.stream_type, offloadInfo.bit_rate, offloadInfo.duration_us,
3265 offloadInfo.has_video);
3266
Andy Hung2ddee192015-12-18 17:34:44 -08003267 if (mMasterMono) {
3268 return false; // no offloading if mono is set.
3269 }
3270
Eric Laurente552edb2014-03-10 17:42:56 -07003271 // Check if offload has been disabled
Andy Hung0f6e6402018-09-06 11:20:45 -07003272 if (property_get_bool("audio.offload.disable", false /* default_value */)) {
3273 ALOGV("offload disabled by audio.offload.disable");
3274 return false;
Eric Laurente552edb2014-03-10 17:42:56 -07003275 }
3276
3277 // Check if stream type is music, then only allow offload as of now.
3278 if (offloadInfo.stream_type != AUDIO_STREAM_MUSIC)
3279 {
3280 ALOGV("isOffloadSupported: stream_type != MUSIC, returning false");
3281 return false;
3282 }
3283
3284 //TODO: enable audio offloading with video when ready
Andy Hung08945c42015-05-31 21:36:46 -07003285 const bool allowOffloadWithVideo =
3286 property_get_bool("audio.offload.video", false /* default_value */);
3287 if (offloadInfo.has_video && !allowOffloadWithVideo) {
Eric Laurente552edb2014-03-10 17:42:56 -07003288 ALOGV("isOffloadSupported: has_video == true, returning false");
3289 return false;
3290 }
3291
3292 //If duration is less than minimum value defined in property, return false
Andy Hung0f6e6402018-09-06 11:20:45 -07003293 const int min_duration_secs = property_get_int32(
3294 "audio.offload.min.duration.secs", -1 /* default_value */);
3295 if (min_duration_secs >= 0) {
3296 if (offloadInfo.duration_us < min_duration_secs * 1000000LL) {
3297 ALOGV("Offload denied by duration < audio.offload.min.duration.secs(=%d)",
3298 min_duration_secs);
Eric Laurente552edb2014-03-10 17:42:56 -07003299 return false;
3300 }
3301 } else if (offloadInfo.duration_us < OFFLOAD_DEFAULT_MIN_DURATION_SECS * 1000000) {
3302 ALOGV("Offload denied by duration < default min(=%u)", OFFLOAD_DEFAULT_MIN_DURATION_SECS);
3303 return false;
3304 }
3305
3306 // Do not allow offloading if one non offloadable effect is enabled. This prevents from
3307 // creating an offloaded track and tearing it down immediately after start when audioflinger
3308 // detects there is an active non offloadable effect.
3309 // FIXME: We should check the audio session here but we do not have it in this context.
3310 // This may prevent offloading in rare situations where effects are left active by apps
3311 // in the background.
François Gaffie45ed3b02015-03-19 10:35:14 +01003312 if (mEffects.isNonOffloadableEffectEnabled()) {
Eric Laurente552edb2014-03-10 17:42:56 -07003313 return false;
3314 }
3315
3316 // See if there is a profile to support this.
3317 // AUDIO_DEVICE_NONE
François Gaffie11d30102018-11-02 16:09:09 +01003318 sp<IOProfile> profile = getProfileForOutput(DeviceVector() /*ignore device */,
Eric Laurente552edb2014-03-10 17:42:56 -07003319 offloadInfo.sample_rate,
3320 offloadInfo.format,
3321 offloadInfo.channel_mask,
Michael Chana94fbb22018-04-24 14:31:19 +10003322 AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD,
3323 true /* directOnly */);
Eric Laurent1c333e22014-05-20 10:48:17 -07003324 ALOGV("isOffloadSupported() profile %sfound", profile != 0 ? "" : "NOT ");
3325 return (profile != 0);
Eric Laurente552edb2014-03-10 17:42:56 -07003326}
3327
Michael Chana94fbb22018-04-24 14:31:19 +10003328bool AudioPolicyManager::isDirectOutputSupported(const audio_config_base_t& config,
3329 const audio_attributes_t& attributes) {
3330 audio_output_flags_t output_flags = AUDIO_OUTPUT_FLAG_NONE;
François Gaffie58d4be52018-11-06 15:30:12 +01003331 audio_flags_to_audio_output_flags(attributes.flags, &output_flags);
François Gaffie11d30102018-11-02 16:09:09 +01003332 sp<IOProfile> profile = getProfileForOutput(DeviceVector() /*ignore device */,
Michael Chana94fbb22018-04-24 14:31:19 +10003333 config.sample_rate,
3334 config.format,
3335 config.channel_mask,
3336 output_flags,
3337 true /* directOnly */);
3338 ALOGV("%s() profile %sfound with name: %s, "
3339 "sample rate: %u, format: 0x%x, channel_mask: 0x%x, output flags: 0x%x",
3340 __FUNCTION__, profile != 0 ? "" : "NOT ",
jiabin5740f082019-08-19 15:08:30 -07003341 (profile != 0 ? profile->getTagName().c_str() : "null"),
Michael Chana94fbb22018-04-24 14:31:19 +10003342 config.sample_rate, config.format, config.channel_mask, output_flags);
3343 return (profile != 0);
3344}
3345
Eric Laurent6a94d692014-05-20 11:18:06 -07003346status_t AudioPolicyManager::listAudioPorts(audio_port_role_t role,
3347 audio_port_type_t type,
3348 unsigned int *num_ports,
3349 struct audio_port *ports,
3350 unsigned int *generation)
3351{
3352 if (num_ports == NULL || (*num_ports != 0 && ports == NULL) ||
3353 generation == NULL) {
3354 return BAD_VALUE;
3355 }
3356 ALOGV("listAudioPorts() role %d type %d num_ports %d ports %p", role, type, *num_ports, ports);
3357 if (ports == NULL) {
3358 *num_ports = 0;
3359 }
3360
3361 size_t portsWritten = 0;
3362 size_t portsMax = *num_ports;
3363 *num_ports = 0;
3364 if (type == AUDIO_PORT_TYPE_NONE || type == AUDIO_PORT_TYPE_DEVICE) {
Eric Laurent5a2b6292016-04-14 18:05:57 -07003365 // do not report devices with type AUDIO_DEVICE_IN_STUB or AUDIO_DEVICE_OUT_STUB
3366 // as they are used by stub HALs by convention
Eric Laurent6a94d692014-05-20 11:18:06 -07003367 if (role == AUDIO_PORT_ROLE_SINK || role == AUDIO_PORT_ROLE_NONE) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003368 for (const auto& dev : mAvailableOutputDevices) {
3369 if (dev->type() == AUDIO_DEVICE_OUT_STUB) {
Eric Laurent5a2b6292016-04-14 18:05:57 -07003370 continue;
3371 }
3372 if (portsWritten < portsMax) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003373 dev->toAudioPort(&ports[portsWritten++]);
Eric Laurent5a2b6292016-04-14 18:05:57 -07003374 }
3375 (*num_ports)++;
Eric Laurent6a94d692014-05-20 11:18:06 -07003376 }
Eric Laurent6a94d692014-05-20 11:18:06 -07003377 }
3378 if (role == AUDIO_PORT_ROLE_SOURCE || role == AUDIO_PORT_ROLE_NONE) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003379 for (const auto& dev : mAvailableInputDevices) {
3380 if (dev->type() == AUDIO_DEVICE_IN_STUB) {
Eric Laurent5a2b6292016-04-14 18:05:57 -07003381 continue;
3382 }
3383 if (portsWritten < portsMax) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003384 dev->toAudioPort(&ports[portsWritten++]);
Eric Laurent5a2b6292016-04-14 18:05:57 -07003385 }
3386 (*num_ports)++;
Eric Laurent6a94d692014-05-20 11:18:06 -07003387 }
Eric Laurent6a94d692014-05-20 11:18:06 -07003388 }
3389 }
3390 if (type == AUDIO_PORT_TYPE_NONE || type == AUDIO_PORT_TYPE_MIX) {
3391 if (role == AUDIO_PORT_ROLE_SINK || role == AUDIO_PORT_ROLE_NONE) {
3392 for (size_t i = 0; i < mInputs.size() && portsWritten < portsMax; i++) {
3393 mInputs[i]->toAudioPort(&ports[portsWritten++]);
3394 }
3395 *num_ports += mInputs.size();
3396 }
3397 if (role == AUDIO_PORT_ROLE_SOURCE || role == AUDIO_PORT_ROLE_NONE) {
Eric Laurent84c70242014-06-23 08:46:27 -07003398 size_t numOutputs = 0;
3399 for (size_t i = 0; i < mOutputs.size(); i++) {
3400 if (!mOutputs[i]->isDuplicated()) {
3401 numOutputs++;
3402 if (portsWritten < portsMax) {
3403 mOutputs[i]->toAudioPort(&ports[portsWritten++]);
3404 }
3405 }
Eric Laurent6a94d692014-05-20 11:18:06 -07003406 }
Eric Laurent84c70242014-06-23 08:46:27 -07003407 *num_ports += numOutputs;
Eric Laurent6a94d692014-05-20 11:18:06 -07003408 }
3409 }
3410 *generation = curAudioPortGeneration();
Mark Salyzynbeb9e302014-06-18 16:33:15 -07003411 ALOGV("listAudioPorts() got %zu ports needed %d", portsWritten, *num_ports);
Eric Laurent6a94d692014-05-20 11:18:06 -07003412 return NO_ERROR;
3413}
3414
Eric Laurent99fcae42018-05-17 16:59:18 -07003415status_t AudioPolicyManager::getAudioPort(struct audio_port *port)
Eric Laurent6a94d692014-05-20 11:18:06 -07003416{
Eric Laurent99fcae42018-05-17 16:59:18 -07003417 if (port == nullptr || port->id == AUDIO_PORT_HANDLE_NONE) {
3418 return BAD_VALUE;
3419 }
3420 sp<DeviceDescriptor> dev = mAvailableOutputDevices.getDeviceFromId(port->id);
3421 if (dev != 0) {
3422 dev->toAudioPort(port);
3423 return NO_ERROR;
3424 }
3425 dev = mAvailableInputDevices.getDeviceFromId(port->id);
3426 if (dev != 0) {
3427 dev->toAudioPort(port);
3428 return NO_ERROR;
3429 }
3430 sp<SwAudioOutputDescriptor> out = mOutputs.getOutputFromId(port->id);
3431 if (out != 0) {
3432 out->toAudioPort(port);
3433 return NO_ERROR;
3434 }
3435 sp<AudioInputDescriptor> in = mInputs.getInputFromId(port->id);
3436 if (in != 0) {
3437 in->toAudioPort(port);
3438 return NO_ERROR;
3439 }
3440 return BAD_VALUE;
Eric Laurent6a94d692014-05-20 11:18:06 -07003441}
3442
Eric Laurent6a94d692014-05-20 11:18:06 -07003443status_t AudioPolicyManager::createAudioPatch(const struct audio_patch *patch,
3444 audio_patch_handle_t *handle,
3445 uid_t uid)
3446{
3447 ALOGV("createAudioPatch()");
3448
3449 if (handle == NULL || patch == NULL) {
3450 return BAD_VALUE;
3451 }
3452 ALOGV("createAudioPatch() num sources %d num sinks %d", patch->num_sources, patch->num_sinks);
3453
Mikhail Naganovac9858b2018-06-15 13:12:37 -07003454 if (!audio_patch_is_valid(patch)) {
Eric Laurent874c42872014-08-08 15:13:39 -07003455 return BAD_VALUE;
3456 }
3457 // only one source per audio patch supported for now
3458 if (patch->num_sources > 1) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003459 return INVALID_OPERATION;
3460 }
Eric Laurent874c42872014-08-08 15:13:39 -07003461
3462 if (patch->sources[0].role != AUDIO_PORT_ROLE_SOURCE) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003463 return INVALID_OPERATION;
3464 }
Eric Laurent874c42872014-08-08 15:13:39 -07003465 for (size_t i = 0; i < patch->num_sinks; i++) {
3466 if (patch->sinks[i].role != AUDIO_PORT_ROLE_SINK) {
3467 return INVALID_OPERATION;
3468 }
3469 }
Eric Laurent6a94d692014-05-20 11:18:06 -07003470
3471 sp<AudioPatch> patchDesc;
3472 ssize_t index = mAudioPatches.indexOfKey(*handle);
3473
Eric Laurent6a94d692014-05-20 11:18:06 -07003474 ALOGV("createAudioPatch source id %d role %d type %d", patch->sources[0].id,
3475 patch->sources[0].role,
3476 patch->sources[0].type);
Eric Laurent874c42872014-08-08 15:13:39 -07003477#if LOG_NDEBUG == 0
3478 for (size_t i = 0; i < patch->num_sinks; i++) {
Eric Laurent7b279bb2015-12-14 10:18:23 -08003479 ALOGV("createAudioPatch sink %zu: id %d role %d type %d", i, patch->sinks[i].id,
Eric Laurent874c42872014-08-08 15:13:39 -07003480 patch->sinks[i].role,
3481 patch->sinks[i].type);
3482 }
3483#endif
Eric Laurent6a94d692014-05-20 11:18:06 -07003484
3485 if (index >= 0) {
3486 patchDesc = mAudioPatches.valueAt(index);
3487 ALOGV("createAudioPatch() mUidCached %d patchDesc->mUid %d uid %d",
3488 mUidCached, patchDesc->mUid, uid);
3489 if (patchDesc->mUid != mUidCached && uid != patchDesc->mUid) {
3490 return INVALID_OPERATION;
3491 }
3492 } else {
Glenn Kastena13cde92016-03-28 15:26:02 -07003493 *handle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurent6a94d692014-05-20 11:18:06 -07003494 }
3495
3496 if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) {
Eric Laurentc75307b2015-03-17 15:29:32 -07003497 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07003498 if (outputDesc == NULL) {
3499 ALOGV("createAudioPatch() output not found for id %d", patch->sources[0].id);
3500 return BAD_VALUE;
3501 }
Eric Laurent84c70242014-06-23 08:46:27 -07003502 ALOG_ASSERT(!outputDesc->isDuplicated(),"duplicated output %d in source in ports",
3503 outputDesc->mIoHandle);
Eric Laurent6a94d692014-05-20 11:18:06 -07003504 if (patchDesc != 0) {
3505 if (patchDesc->mPatch.sources[0].id != patch->sources[0].id) {
3506 ALOGV("createAudioPatch() source id differs for patch current id %d new id %d",
3507 patchDesc->mPatch.sources[0].id, patch->sources[0].id);
3508 return BAD_VALUE;
3509 }
3510 }
Eric Laurent874c42872014-08-08 15:13:39 -07003511 DeviceVector devices;
3512 for (size_t i = 0; i < patch->num_sinks; i++) {
3513 // Only support mix to devices connection
3514 // TODO add support for mix to mix connection
3515 if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) {
3516 ALOGV("createAudioPatch() source mix but sink is not a device");
3517 return INVALID_OPERATION;
3518 }
3519 sp<DeviceDescriptor> devDesc =
3520 mAvailableOutputDevices.getDeviceFromId(patch->sinks[i].id);
3521 if (devDesc == 0) {
3522 ALOGV("createAudioPatch() out device not found for id %d", patch->sinks[i].id);
3523 return BAD_VALUE;
3524 }
Eric Laurent6a94d692014-05-20 11:18:06 -07003525
François Gaffie11d30102018-11-02 16:09:09 +01003526 if (!outputDesc->mProfile->isCompatibleProfile(DeviceVector(devDesc),
Eric Laurent874c42872014-08-08 15:13:39 -07003527 patch->sources[0].sample_rate,
François Gaffie53615e22015-03-19 09:24:12 +01003528 NULL, // updatedSamplingRate
3529 patch->sources[0].format,
Andy Hungf129b032015-04-07 13:45:50 -07003530 NULL, // updatedFormat
François Gaffie53615e22015-03-19 09:24:12 +01003531 patch->sources[0].channel_mask,
Andy Hungf129b032015-04-07 13:45:50 -07003532 NULL, // updatedChannelMask
François Gaffie53615e22015-03-19 09:24:12 +01003533 AUDIO_OUTPUT_FLAG_NONE /*FIXME*/)) {
Andy Hungf129b032015-04-07 13:45:50 -07003534 ALOGV("createAudioPatch() profile not supported for device %08x",
3535 devDesc->type());
Eric Laurent874c42872014-08-08 15:13:39 -07003536 return INVALID_OPERATION;
3537 }
3538 devices.add(devDesc);
3539 }
3540 if (devices.size() == 0) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003541 return INVALID_OPERATION;
3542 }
Eric Laurent874c42872014-08-08 15:13:39 -07003543
Eric Laurent6a94d692014-05-20 11:18:06 -07003544 // TODO: reconfigure output format and channels here
jiabin9a3361e2019-10-01 09:38:30 -07003545 ALOGV("createAudioPatch() setting device %s on output %d",
3546 dumpDeviceTypes(devices.types()).c_str(), outputDesc->mIoHandle);
François Gaffie11d30102018-11-02 16:09:09 +01003547 setOutputDevices(outputDesc, devices, true, 0, handle);
Eric Laurent6a94d692014-05-20 11:18:06 -07003548 index = mAudioPatches.indexOfKey(*handle);
3549 if (index >= 0) {
3550 if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) {
3551 ALOGW("createAudioPatch() setOutputDevice() did not reuse the patch provided");
3552 }
3553 patchDesc = mAudioPatches.valueAt(index);
3554 patchDesc->mUid = uid;
3555 ALOGV("createAudioPatch() success");
3556 } else {
3557 ALOGW("createAudioPatch() setOutputDevice() failed to create a patch");
3558 return INVALID_OPERATION;
3559 }
3560 } else if (patch->sources[0].type == AUDIO_PORT_TYPE_DEVICE) {
3561 if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
3562 // input device to input mix connection
Eric Laurent874c42872014-08-08 15:13:39 -07003563 // only one sink supported when connecting an input device to a mix
3564 if (patch->num_sinks > 1) {
3565 return INVALID_OPERATION;
3566 }
François Gaffie53615e22015-03-19 09:24:12 +01003567 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(patch->sinks[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07003568 if (inputDesc == NULL) {
3569 return BAD_VALUE;
3570 }
3571 if (patchDesc != 0) {
3572 if (patchDesc->mPatch.sinks[0].id != patch->sinks[0].id) {
3573 return BAD_VALUE;
3574 }
3575 }
François Gaffie11d30102018-11-02 16:09:09 +01003576 sp<DeviceDescriptor> device =
Eric Laurent6a94d692014-05-20 11:18:06 -07003577 mAvailableInputDevices.getDeviceFromId(patch->sources[0].id);
François Gaffie11d30102018-11-02 16:09:09 +01003578 if (device == 0) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003579 return BAD_VALUE;
3580 }
3581
François Gaffie11d30102018-11-02 16:09:09 +01003582 if (!inputDesc->mProfile->isCompatibleProfile(DeviceVector(device),
Eric Laurent275e8e92014-11-30 15:14:47 -08003583 patch->sinks[0].sample_rate,
3584 NULL, /*updatedSampleRate*/
3585 patch->sinks[0].format,
Andy Hungf129b032015-04-07 13:45:50 -07003586 NULL, /*updatedFormat*/
Eric Laurent275e8e92014-11-30 15:14:47 -08003587 patch->sinks[0].channel_mask,
Andy Hungf129b032015-04-07 13:45:50 -07003588 NULL, /*updatedChannelMask*/
Eric Laurent275e8e92014-11-30 15:14:47 -08003589 // FIXME for the parameter type,
3590 // and the NONE
3591 (audio_output_flags_t)
Glenn Kasten6a8ab052014-07-24 14:08:35 -07003592 AUDIO_INPUT_FLAG_NONE)) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003593 return INVALID_OPERATION;
3594 }
3595 // TODO: reconfigure output format and channels here
François Gaffie11d30102018-11-02 16:09:09 +01003596 ALOGV("%s() setting device %s on output %d", __func__,
3597 device->toString().c_str(), inputDesc->mIoHandle);
3598 setInputDevice(inputDesc->mIoHandle, device, true, handle);
Eric Laurent6a94d692014-05-20 11:18:06 -07003599 index = mAudioPatches.indexOfKey(*handle);
3600 if (index >= 0) {
3601 if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) {
3602 ALOGW("createAudioPatch() setInputDevice() did not reuse the patch provided");
3603 }
3604 patchDesc = mAudioPatches.valueAt(index);
3605 patchDesc->mUid = uid;
3606 ALOGV("createAudioPatch() success");
3607 } else {
3608 ALOGW("createAudioPatch() setInputDevice() failed to create a patch");
3609 return INVALID_OPERATION;
3610 }
3611 } else if (patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) {
3612 // device to device connection
3613 if (patchDesc != 0) {
Eric Laurent874c42872014-08-08 15:13:39 -07003614 if (patchDesc->mPatch.sources[0].id != patch->sources[0].id) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003615 return BAD_VALUE;
3616 }
3617 }
François Gaffie11d30102018-11-02 16:09:09 +01003618 sp<DeviceDescriptor> srcDevice =
Eric Laurent6a94d692014-05-20 11:18:06 -07003619 mAvailableInputDevices.getDeviceFromId(patch->sources[0].id);
François Gaffie11d30102018-11-02 16:09:09 +01003620 if (srcDevice == 0) {
Eric Laurent58f8eb72014-09-12 16:19:41 -07003621 return BAD_VALUE;
3622 }
Eric Laurent874c42872014-08-08 15:13:39 -07003623
Eric Laurent6a94d692014-05-20 11:18:06 -07003624 //update source and sink with our own data as the data passed in the patch may
3625 // be incomplete.
3626 struct audio_patch newPatch = *patch;
François Gaffie11d30102018-11-02 16:09:09 +01003627 srcDevice->toAudioPortConfig(&newPatch.sources[0], &patch->sources[0]);
Eric Laurent6a94d692014-05-20 11:18:06 -07003628
Eric Laurent874c42872014-08-08 15:13:39 -07003629 for (size_t i = 0; i < patch->num_sinks; i++) {
3630 if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) {
3631 ALOGV("createAudioPatch() source device but one sink is not a device");
3632 return INVALID_OPERATION;
3633 }
3634
François Gaffie11d30102018-11-02 16:09:09 +01003635 sp<DeviceDescriptor> sinkDevice =
Eric Laurent874c42872014-08-08 15:13:39 -07003636 mAvailableOutputDevices.getDeviceFromId(patch->sinks[i].id);
François Gaffie11d30102018-11-02 16:09:09 +01003637 if (sinkDevice == 0) {
Eric Laurent874c42872014-08-08 15:13:39 -07003638 return BAD_VALUE;
3639 }
François Gaffie11d30102018-11-02 16:09:09 +01003640 sinkDevice->toAudioPortConfig(&newPatch.sinks[i], &patch->sinks[i]);
Eric Laurent874c42872014-08-08 15:13:39 -07003641
Eric Laurent3bcf8592015-04-03 12:13:24 -07003642 // create a software bridge in PatchPanel if:
Scott Randolphf3172402018-01-23 17:06:53 -08003643 // - source and sink devices are on different HW modules OR
Eric Laurent3bcf8592015-04-03 12:13:24 -07003644 // - audio HAL version is < 3.0
Francois Gaffie99896da2018-04-09 11:05:33 +02003645 // - audio HAL version is >= 3.0 but no route has been declared between devices
François Gaffie11d30102018-11-02 16:09:09 +01003646 if (!srcDevice->hasSameHwModuleAs(sinkDevice) ||
3647 (srcDevice->getModuleVersionMajor() < 3) ||
3648 !srcDevice->getModule()->supportsPatch(srcDevice, sinkDevice)) {
Eric Laurent3bcf8592015-04-03 12:13:24 -07003649 // support only one sink device for now to simplify output selection logic
Eric Laurent874c42872014-08-08 15:13:39 -07003650 if (patch->num_sinks > 1) {
Eric Laurent83b88082014-06-20 18:31:16 -07003651 return INVALID_OPERATION;
3652 }
Eric Laurent874c42872014-08-08 15:13:39 -07003653 SortedVector<audio_io_handle_t> outputs =
François Gaffie11d30102018-11-02 16:09:09 +01003654 getOutputsForDevices(DeviceVector(sinkDevice), mOutputs);
Eric Laurent874c42872014-08-08 15:13:39 -07003655 // if the sink device is reachable via an opened output stream, request to go via
3656 // this output stream by adding a second source to the patch description
Eric Laurent16c66dd2019-05-01 17:54:10 -07003657 const audio_io_handle_t output = selectOutput(outputs);
Eric Laurent874c42872014-08-08 15:13:39 -07003658 if (output != AUDIO_IO_HANDLE_NONE) {
3659 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
3660 if (outputDesc->isDuplicated()) {
3661 return INVALID_OPERATION;
3662 }
3663 outputDesc->toAudioPortConfig(&newPatch.sources[1], &patch->sources[0]);
Eric Laurent3bcf8592015-04-03 12:13:24 -07003664 newPatch.sources[1].ext.mix.usecase.stream = AUDIO_STREAM_PATCH;
Eric Laurent874c42872014-08-08 15:13:39 -07003665 newPatch.num_sources = 2;
3666 }
Eric Laurent83b88082014-06-20 18:31:16 -07003667 }
Eric Laurent6a94d692014-05-20 11:18:06 -07003668 }
3669 // TODO: check from routing capabilities in config file and other conflicting patches
3670
Mikhail Naganovdc769682018-05-04 15:34:08 -07003671 status_t status = installPatch(__func__, index, handle, &newPatch, 0, uid, &patchDesc);
3672 if (status != NO_ERROR) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003673 ALOGW("createAudioPatch() patch panel could not connect device patch, error %d",
3674 status);
3675 return INVALID_OPERATION;
3676 }
3677 } else {
3678 return BAD_VALUE;
3679 }
3680 } else {
3681 return BAD_VALUE;
3682 }
3683 return NO_ERROR;
3684}
3685
3686status_t AudioPolicyManager::releaseAudioPatch(audio_patch_handle_t handle,
3687 uid_t uid)
3688{
3689 ALOGV("releaseAudioPatch() patch %d", handle);
3690
3691 ssize_t index = mAudioPatches.indexOfKey(handle);
3692
3693 if (index < 0) {
3694 return BAD_VALUE;
3695 }
3696 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
3697 ALOGV("releaseAudioPatch() mUidCached %d patchDesc->mUid %d uid %d",
3698 mUidCached, patchDesc->mUid, uid);
3699 if (patchDesc->mUid != mUidCached && uid != patchDesc->mUid) {
3700 return INVALID_OPERATION;
3701 }
3702
3703 struct audio_patch *patch = &patchDesc->mPatch;
3704 patchDesc->mUid = mUidCached;
3705 if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) {
Eric Laurentc75307b2015-03-17 15:29:32 -07003706 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07003707 if (outputDesc == NULL) {
3708 ALOGV("releaseAudioPatch() output not found for id %d", patch->sources[0].id);
3709 return BAD_VALUE;
3710 }
3711
François Gaffie11d30102018-11-02 16:09:09 +01003712 setOutputDevices(outputDesc,
3713 getNewOutputDevices(outputDesc, true /*fromCache*/),
3714 true,
3715 0,
3716 NULL);
Eric Laurent6a94d692014-05-20 11:18:06 -07003717 } else if (patch->sources[0].type == AUDIO_PORT_TYPE_DEVICE) {
3718 if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
François Gaffie53615e22015-03-19 09:24:12 +01003719 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(patch->sinks[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07003720 if (inputDesc == NULL) {
3721 ALOGV("releaseAudioPatch() input not found for id %d", patch->sinks[0].id);
3722 return BAD_VALUE;
3723 }
3724 setInputDevice(inputDesc->mIoHandle,
Eric Laurentfb66dd92016-01-28 18:32:03 -08003725 getNewInputDevice(inputDesc),
Eric Laurent6a94d692014-05-20 11:18:06 -07003726 true,
3727 NULL);
3728 } else if (patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003729 status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
3730 ALOGV("releaseAudioPatch() patch panel returned %d patchHandle %d",
3731 status, patchDesc->mAfPatchHandle);
3732 removeAudioPatch(patchDesc->mHandle);
3733 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07003734 mpClientInterface->onAudioPatchListUpdate();
Eric Laurent6a94d692014-05-20 11:18:06 -07003735 } else {
3736 return BAD_VALUE;
3737 }
3738 } else {
3739 return BAD_VALUE;
3740 }
3741 return NO_ERROR;
3742}
3743
3744status_t AudioPolicyManager::listAudioPatches(unsigned int *num_patches,
3745 struct audio_patch *patches,
3746 unsigned int *generation)
3747{
François Gaffie53615e22015-03-19 09:24:12 +01003748 if (generation == NULL) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003749 return BAD_VALUE;
3750 }
Eric Laurent6a94d692014-05-20 11:18:06 -07003751 *generation = curAudioPortGeneration();
François Gaffie53615e22015-03-19 09:24:12 +01003752 return mAudioPatches.listAudioPatches(num_patches, patches);
Eric Laurent6a94d692014-05-20 11:18:06 -07003753}
3754
Eric Laurente1715a42014-05-20 11:30:42 -07003755status_t AudioPolicyManager::setAudioPortConfig(const struct audio_port_config *config)
Eric Laurent6a94d692014-05-20 11:18:06 -07003756{
Eric Laurente1715a42014-05-20 11:30:42 -07003757 ALOGV("setAudioPortConfig()");
3758
3759 if (config == NULL) {
3760 return BAD_VALUE;
3761 }
3762 ALOGV("setAudioPortConfig() on port handle %d", config->id);
3763 // Only support gain configuration for now
Eric Laurenta121f902014-06-03 13:32:54 -07003764 if (config->config_mask != AUDIO_PORT_CONFIG_GAIN) {
3765 return INVALID_OPERATION;
Eric Laurente1715a42014-05-20 11:30:42 -07003766 }
3767
Eric Laurenta121f902014-06-03 13:32:54 -07003768 sp<AudioPortConfig> audioPortConfig;
Eric Laurente1715a42014-05-20 11:30:42 -07003769 if (config->type == AUDIO_PORT_TYPE_MIX) {
3770 if (config->role == AUDIO_PORT_ROLE_SOURCE) {
Eric Laurentc75307b2015-03-17 15:29:32 -07003771 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(config->id);
Eric Laurente1715a42014-05-20 11:30:42 -07003772 if (outputDesc == NULL) {
3773 return BAD_VALUE;
3774 }
Eric Laurent84c70242014-06-23 08:46:27 -07003775 ALOG_ASSERT(!outputDesc->isDuplicated(),
3776 "setAudioPortConfig() called on duplicated output %d",
3777 outputDesc->mIoHandle);
Eric Laurenta121f902014-06-03 13:32:54 -07003778 audioPortConfig = outputDesc;
Eric Laurente1715a42014-05-20 11:30:42 -07003779 } else if (config->role == AUDIO_PORT_ROLE_SINK) {
François Gaffie53615e22015-03-19 09:24:12 +01003780 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(config->id);
Eric Laurente1715a42014-05-20 11:30:42 -07003781 if (inputDesc == NULL) {
3782 return BAD_VALUE;
3783 }
Eric Laurenta121f902014-06-03 13:32:54 -07003784 audioPortConfig = inputDesc;
Eric Laurente1715a42014-05-20 11:30:42 -07003785 } else {
3786 return BAD_VALUE;
3787 }
3788 } else if (config->type == AUDIO_PORT_TYPE_DEVICE) {
3789 sp<DeviceDescriptor> deviceDesc;
3790 if (config->role == AUDIO_PORT_ROLE_SOURCE) {
3791 deviceDesc = mAvailableInputDevices.getDeviceFromId(config->id);
3792 } else if (config->role == AUDIO_PORT_ROLE_SINK) {
3793 deviceDesc = mAvailableOutputDevices.getDeviceFromId(config->id);
3794 } else {
3795 return BAD_VALUE;
3796 }
3797 if (deviceDesc == NULL) {
3798 return BAD_VALUE;
3799 }
Eric Laurenta121f902014-06-03 13:32:54 -07003800 audioPortConfig = deviceDesc;
Eric Laurente1715a42014-05-20 11:30:42 -07003801 } else {
3802 return BAD_VALUE;
3803 }
3804
Mikhail Naganov7be71d22018-05-23 16:51:46 -07003805 struct audio_port_config backupConfig = {};
Eric Laurenta121f902014-06-03 13:32:54 -07003806 status_t status = audioPortConfig->applyAudioPortConfig(config, &backupConfig);
3807 if (status == NO_ERROR) {
Mikhail Naganov7be71d22018-05-23 16:51:46 -07003808 struct audio_port_config newConfig = {};
Eric Laurenta121f902014-06-03 13:32:54 -07003809 audioPortConfig->toAudioPortConfig(&newConfig, config);
3810 status = mpClientInterface->setAudioPortConfig(&newConfig, 0);
Eric Laurente1715a42014-05-20 11:30:42 -07003811 }
Eric Laurenta121f902014-06-03 13:32:54 -07003812 if (status != NO_ERROR) {
3813 audioPortConfig->applyAudioPortConfig(&backupConfig);
Eric Laurente1715a42014-05-20 11:30:42 -07003814 }
Eric Laurente1715a42014-05-20 11:30:42 -07003815
3816 return status;
Eric Laurent6a94d692014-05-20 11:18:06 -07003817}
3818
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003819void AudioPolicyManager::releaseResourcesForUid(uid_t uid)
3820{
Eric Laurentd60560a2015-04-10 11:31:20 -07003821 clearAudioSources(uid);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003822 clearAudioPatches(uid);
3823 clearSessionRoutes(uid);
3824}
3825
Eric Laurent6a94d692014-05-20 11:18:06 -07003826void AudioPolicyManager::clearAudioPatches(uid_t uid)
3827{
Eric Laurent0add0fd2014-12-04 18:58:14 -08003828 for (ssize_t i = (ssize_t)mAudioPatches.size() - 1; i >= 0; i--) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003829 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(i);
3830 if (patchDesc->mUid == uid) {
Eric Laurent0add0fd2014-12-04 18:58:14 -08003831 releaseAudioPatch(mAudioPatches.keyAt(i), uid);
Eric Laurent6a94d692014-05-20 11:18:06 -07003832 }
3833 }
3834}
3835
François Gaffiec005e562018-11-06 15:04:49 +01003836void AudioPolicyManager::checkStrategyRoute(product_strategy_t ps, audio_io_handle_t ouptutToSkip)
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003837{
François Gaffiec005e562018-11-06 15:04:49 +01003838 // Take the first attributes following the product strategy as it is used to retrieve the routed
3839 // device. All attributes wihin a strategy follows the same "routing strategy"
3840 auto attributes = mEngine->getAllAttributesForProductStrategy(ps).front();
3841 DeviceVector devices = mEngine->getOutputDevicesForAttributes(attributes, nullptr, false);
François Gaffie11d30102018-11-02 16:09:09 +01003842 SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003843 for (size_t j = 0; j < mOutputs.size(); j++) {
3844 if (mOutputs.keyAt(j) == ouptutToSkip) {
3845 continue;
3846 }
3847 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(j);
François Gaffiec005e562018-11-06 15:04:49 +01003848 if (!outputDesc->isStrategyActive(ps)) {
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003849 continue;
3850 }
3851 // If the default device for this strategy is on another output mix,
3852 // invalidate all tracks in this strategy to force re connection.
3853 // Otherwise select new device on the output mix.
3854 if (outputs.indexOf(mOutputs.keyAt(j)) < 0) {
François Gaffiec005e562018-11-06 15:04:49 +01003855 for (auto stream : mEngine->getStreamTypesForProductStrategy(ps)) {
3856 mpClientInterface->invalidateStream(stream);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003857 }
3858 } else {
François Gaffie11d30102018-11-02 16:09:09 +01003859 setOutputDevices(
3860 outputDesc, getNewOutputDevices(outputDesc, false /*fromCache*/), false);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003861 }
3862 }
3863}
3864
3865void AudioPolicyManager::clearSessionRoutes(uid_t uid)
3866{
3867 // remove output routes associated with this uid
François Gaffiec005e562018-11-06 15:04:49 +01003868 std::vector<product_strategy_t> affectedStrategies;
Eric Laurent97ac8712018-07-27 18:59:02 -07003869 for (size_t i = 0; i < mOutputs.size(); i++) {
3870 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
Andy Hung39efb7a2018-09-26 15:39:28 -07003871 for (const auto& client : outputDesc->getClientIterable()) {
3872 if (client->hasPreferredDevice() && client->uid() == uid) {
3873 client->setPreferredDeviceId(AUDIO_PORT_HANDLE_NONE);
François Gaffiec005e562018-11-06 15:04:49 +01003874 auto clientStrategy = client->strategy();
3875 if (std::find(begin(affectedStrategies), end(affectedStrategies), clientStrategy) !=
3876 end(affectedStrategies)) {
3877 continue;
3878 }
3879 affectedStrategies.push_back(client->strategy());
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003880 }
3881 }
3882 }
3883 // reroute outputs if necessary
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003884 for (const auto& strategy : affectedStrategies) {
3885 checkStrategyRoute(strategy, AUDIO_IO_HANDLE_NONE);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003886 }
3887
3888 // remove input routes associated with this uid
3889 SortedVector<audio_source_t> affectedSources;
Eric Laurent97ac8712018-07-27 18:59:02 -07003890 for (size_t i = 0; i < mInputs.size(); i++) {
3891 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(i);
Andy Hung39efb7a2018-09-26 15:39:28 -07003892 for (const auto& client : inputDesc->getClientIterable()) {
3893 if (client->hasPreferredDevice() && client->uid() == uid) {
3894 client->setPreferredDeviceId(AUDIO_PORT_HANDLE_NONE);
3895 affectedSources.add(client->source());
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003896 }
3897 }
3898 }
3899 // reroute inputs if necessary
3900 SortedVector<audio_io_handle_t> inputsToClose;
3901 for (size_t i = 0; i < mInputs.size(); i++) {
3902 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(i);
Eric Laurent4eb58f12018-12-07 16:41:02 -08003903 if (affectedSources.indexOf(inputDesc->source()) >= 0) {
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003904 inputsToClose.add(inputDesc->mIoHandle);
3905 }
3906 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003907 for (const auto& input : inputsToClose) {
3908 closeInput(input);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003909 }
3910}
3911
Eric Laurentd60560a2015-04-10 11:31:20 -07003912void AudioPolicyManager::clearAudioSources(uid_t uid)
3913{
3914 for (ssize_t i = (ssize_t)mAudioSources.size() - 1; i >= 0; i--) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07003915 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
3916 if (sourceDesc->uid() == uid) {
Eric Laurentd60560a2015-04-10 11:31:20 -07003917 stopAudioSource(mAudioSources.keyAt(i));
3918 }
3919 }
3920}
Eric Laurent8c7e6da2015-04-21 17:37:00 -07003921
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07003922status_t AudioPolicyManager::acquireSoundTriggerSession(audio_session_t *session,
3923 audio_io_handle_t *ioHandle,
3924 audio_devices_t *device)
3925{
Glenn Kastenf0c6d7d2016-02-26 10:44:04 -08003926 *session = (audio_session_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
3927 *ioHandle = (audio_io_handle_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_INPUT);
Francois Gaffie716e1432019-01-14 16:58:59 +01003928 audio_attributes_t attr = { .source = AUDIO_SOURCE_HOTWORD };
François Gaffiec005e562018-11-06 15:04:49 +01003929 *device = mEngine->getInputDeviceForAttributes(attr)->type();
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07003930
François Gaffiedf372692015-03-19 10:43:27 +01003931 return mSoundTriggerSessions.acquireSession(*session, *ioHandle);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07003932}
3933
Eric Laurentd60560a2015-04-10 11:31:20 -07003934status_t AudioPolicyManager::startAudioSource(const struct audio_port_config *source,
Eric Laurent3e6c7e12018-07-27 17:09:23 -07003935 const audio_attributes_t *attributes,
3936 audio_port_handle_t *portId,
3937 uid_t uid)
Eric Laurent554a2772015-04-10 11:29:24 -07003938{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07003939 ALOGV("%s", __FUNCTION__);
3940 *portId = AUDIO_PORT_HANDLE_NONE;
3941
3942 if (source == NULL || attributes == NULL || portId == NULL) {
3943 ALOGW("%s invalid argument: source %p attributes %p handle %p",
3944 __FUNCTION__, source, attributes, portId);
Eric Laurentd60560a2015-04-10 11:31:20 -07003945 return BAD_VALUE;
3946 }
3947
Eric Laurentd60560a2015-04-10 11:31:20 -07003948 if (source->role != AUDIO_PORT_ROLE_SOURCE ||
3949 source->type != AUDIO_PORT_TYPE_DEVICE) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07003950 ALOGW("%s INVALID_OPERATION source->role %d source->type %d",
3951 __FUNCTION__, source->role, source->type);
Eric Laurentd60560a2015-04-10 11:31:20 -07003952 return INVALID_OPERATION;
3953 }
3954
François Gaffie11d30102018-11-02 16:09:09 +01003955 sp<DeviceDescriptor> srcDevice =
Eric Laurentd60560a2015-04-10 11:31:20 -07003956 mAvailableInputDevices.getDevice(source->ext.device.type,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08003957 String8(source->ext.device.address),
3958 AUDIO_FORMAT_DEFAULT);
François Gaffie11d30102018-11-02 16:09:09 +01003959 if (srcDevice == 0) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07003960 ALOGW("%s source->ext.device.type %08x not found", __FUNCTION__, source->ext.device.type);
Eric Laurentd60560a2015-04-10 11:31:20 -07003961 return BAD_VALUE;
3962 }
Eric Laurent3e6c7e12018-07-27 17:09:23 -07003963
jiabin4ef93452019-09-10 14:29:54 -07003964 *portId = PolicyAudioPort::getNextUniqueId();
Eric Laurentd60560a2015-04-10 11:31:20 -07003965
Mikhail Naganov7be71d22018-05-23 16:51:46 -07003966 struct audio_patch dummyPatch = {};
Eric Laurentd60560a2015-04-10 11:31:20 -07003967 sp<AudioPatch> patchDesc = new AudioPatch(&dummyPatch, uid);
Eric Laurent3e6c7e12018-07-27 17:09:23 -07003968
François Gaffieaaac0fd2018-11-22 17:56:39 +01003969 sp<SourceClientDescriptor> sourceDesc =
3970 new SourceClientDescriptor(*portId, uid, *attributes, patchDesc, srcDevice,
3971 mEngine->getStreamTypeForAttributes(*attributes),
3972 mEngine->getProductStrategyForAttributes(*attributes),
3973 toVolumeSource(*attributes));
Eric Laurentd60560a2015-04-10 11:31:20 -07003974
3975 status_t status = connectAudioSource(sourceDesc);
3976 if (status == NO_ERROR) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07003977 mAudioSources.add(*portId, sourceDesc);
Eric Laurentd60560a2015-04-10 11:31:20 -07003978 }
3979 return status;
3980}
3981
Eric Laurent3e6c7e12018-07-27 17:09:23 -07003982status_t AudioPolicyManager::connectAudioSource(const sp<SourceClientDescriptor>& sourceDesc)
Eric Laurentd60560a2015-04-10 11:31:20 -07003983{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07003984 ALOGV("%s handle %d", __FUNCTION__, sourceDesc->portId());
Eric Laurentd60560a2015-04-10 11:31:20 -07003985
3986 // make sure we only have one patch per source.
3987 disconnectAudioSource(sourceDesc);
3988
Eric Laurent3e6c7e12018-07-27 17:09:23 -07003989 audio_attributes_t attributes = sourceDesc->attributes();
Eric Laurent3e6c7e12018-07-27 17:09:23 -07003990 audio_stream_type_t stream = sourceDesc->stream();
François Gaffie11d30102018-11-02 16:09:09 +01003991 sp<DeviceDescriptor> srcDevice = sourceDesc->srcDevice();
Eric Laurentd60560a2015-04-10 11:31:20 -07003992
François Gaffiec005e562018-11-06 15:04:49 +01003993 DeviceVector sinkDevices =
3994 mEngine->getOutputDevicesForAttributes(attributes, nullptr, true);
3995 ALOG_ASSERT(!sinkDevices.isEmpty(), "connectAudioSource(): no device found for attributes");
François Gaffie11d30102018-11-02 16:09:09 +01003996 sp<DeviceDescriptor> sinkDevice = sinkDevices.itemAt(0);
3997 ALOG_ASSERT(mAvailableOutputDevices.contains(sinkDevice), "%s: Device %s not available",
3998 __FUNCTION__, sinkDevice->toString().c_str());
Eric Laurentd60560a2015-04-10 11:31:20 -07003999
4000 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurentd60560a2015-04-10 11:31:20 -07004001
François Gaffie11d30102018-11-02 16:09:09 +01004002 if (srcDevice->hasSameHwModuleAs(sinkDevice) &&
4003 srcDevice->getModuleVersionMajor() >= 3 &&
4004 sinkDevice->getModule()->supportsPatch(srcDevice, sinkDevice) &&
jiabin5740f082019-08-19 15:08:30 -07004005 srcDevice->getAudioPort()->getGains().size() > 0) {
François Gaffie83d789d2018-05-29 13:29:19 +02004006 ALOGV("%s Device to Device route supported by >=3.0 HAL", __FUNCTION__);
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07004007 // TODO: may explicitly specify whether we should use HW or SW patch
François Gaffie83d789d2018-05-29 13:29:19 +02004008 // create patch between src device and output device
4009 // create Hwoutput and add to mHwOutputs
Eric Laurentd60560a2015-04-10 11:31:20 -07004010 } else {
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07004011 audio_attributes_t resultAttr;
4012 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
4013 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
4014 config.sample_rate = sourceDesc->config().sample_rate;
4015 config.channel_mask = sourceDesc->config().channel_mask;
4016 config.format = sourceDesc->config().format;
4017 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE;
4018 audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
François Gaffief579db52018-11-13 11:25:16 +01004019 bool isRequestedDeviceForExclusiveUse = false;
Kevin Rocard153f92d2018-12-18 18:33:28 -08004020 std::vector<sp<SwAudioOutputDescriptor>> secondaryOutputs;
Eric Laurent8a1095a2019-11-08 14:44:16 -08004021 output_type_t outputType;
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07004022 getOutputForAttrInt(&resultAttr, &output, AUDIO_SESSION_NONE,
François Gaffief579db52018-11-13 11:25:16 +01004023 &attributes, &stream, sourceDesc->uid(), &config, &flags,
Kevin Rocard153f92d2018-12-18 18:33:28 -08004024 &selectedDeviceId, &isRequestedDeviceForExclusiveUse,
Eric Laurent8a1095a2019-11-08 14:44:16 -08004025 &secondaryOutputs, &outputType);
Eric Laurentd60560a2015-04-10 11:31:20 -07004026 if (output == AUDIO_IO_HANDLE_NONE) {
jiabin9a3361e2019-10-01 09:38:30 -07004027 ALOGV("%s no output for device %s",
4028 __FUNCTION__, dumpDeviceTypes(sinkDevices.types()).c_str());
Eric Laurentd60560a2015-04-10 11:31:20 -07004029 return INVALID_OPERATION;
4030 }
4031 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
4032 if (outputDesc->isDuplicated()) {
jiabin9a3361e2019-10-01 09:38:30 -07004033 ALOGV("%s output for device %s is duplicated",
4034 __FUNCTION__, dumpDeviceTypes(sinkDevices.types()).c_str());
Eric Laurentd60560a2015-04-10 11:31:20 -07004035 return INVALID_OPERATION;
4036 }
Eric Laurent733ce942017-12-07 12:18:25 -08004037 status_t status = outputDesc->start();
4038 if (status != NO_ERROR) {
4039 return status;
4040 }
4041
Eric Laurentd60560a2015-04-10 11:31:20 -07004042 // create a special patch with no sink and two sources:
4043 // - the second source indicates to PatchPanel through which output mix this patch should
4044 // be connected as well as the stream type for volume control
4045 // - the sink is defined by whatever output device is currently selected for the output
4046 // though which this patch is routed.
Mikhail Naganovdc769682018-05-04 15:34:08 -07004047 PatchBuilder patchBuilder;
François Gaffie11d30102018-11-02 16:09:09 +01004048 patchBuilder.addSource(srcDevice).addSource(outputDesc, { .stream = stream });
Mikhail Naganovdc769682018-05-04 15:34:08 -07004049 status = mpClientInterface->createAudioPatch(patchBuilder.patch(),
Eric Laurentd60560a2015-04-10 11:31:20 -07004050 &afPatchHandle,
4051 0);
4052 ALOGV("%s patch panel returned %d patchHandle %d", __FUNCTION__,
4053 status, afPatchHandle);
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004054 sourceDesc->patchDesc()->mPatch = *patchBuilder.patch();
Eric Laurentd60560a2015-04-10 11:31:20 -07004055 if (status != NO_ERROR) {
4056 ALOGW("%s patch panel could not connect device patch, error %d",
4057 __FUNCTION__, status);
4058 return INVALID_OPERATION;
4059 }
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07004060
4061 if (outputDesc->getClient(sourceDesc->portId()) != nullptr) {
4062 ALOGW("%s source portId has already been attached to outputDesc", __func__);
4063 return INVALID_OPERATION;
4064 }
4065 outputDesc->addClient(sourceDesc);
4066
Eric Laurentd60560a2015-04-10 11:31:20 -07004067 uint32_t delayMs = 0;
Eric Laurent97ac8712018-07-27 18:59:02 -07004068 status = startSource(outputDesc, sourceDesc, &delayMs);
Eric Laurentd60560a2015-04-10 11:31:20 -07004069
4070 if (status != NO_ERROR) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004071 mpClientInterface->releaseAudioPatch(sourceDesc->patchDesc()->mAfPatchHandle, 0);
François Gaffie5592ee22019-05-22 08:00:05 +02004072 outputDesc->removeClient(sourceDesc->portId());
4073 outputDesc->stop();
Eric Laurentd60560a2015-04-10 11:31:20 -07004074 return status;
4075 }
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004076 sourceDesc->setSwOutput(outputDesc);
Eric Laurentd60560a2015-04-10 11:31:20 -07004077 if (delayMs != 0) {
4078 usleep(delayMs * 1000);
4079 }
4080 }
4081
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004082 sourceDesc->patchDesc()->mAfPatchHandle = afPatchHandle;
4083 addAudioPatch(sourceDesc->patchDesc()->mHandle, sourceDesc->patchDesc());
Eric Laurentd60560a2015-04-10 11:31:20 -07004084
4085 return NO_ERROR;
Eric Laurent554a2772015-04-10 11:29:24 -07004086}
4087
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004088status_t AudioPolicyManager::stopAudioSource(audio_port_handle_t portId)
Eric Laurent554a2772015-04-10 11:29:24 -07004089{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004090 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueFor(portId);
4091 ALOGV("%s port ID %d", __FUNCTION__, portId);
Eric Laurentd60560a2015-04-10 11:31:20 -07004092 if (sourceDesc == 0) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004093 ALOGW("%s unknown source for port ID %d", __FUNCTION__, portId);
Eric Laurentd60560a2015-04-10 11:31:20 -07004094 return BAD_VALUE;
4095 }
4096 status_t status = disconnectAudioSource(sourceDesc);
4097
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004098 mAudioSources.removeItem(portId);
Eric Laurentd60560a2015-04-10 11:31:20 -07004099 return status;
4100}
4101
Andy Hung2ddee192015-12-18 17:34:44 -08004102status_t AudioPolicyManager::setMasterMono(bool mono)
4103{
4104 if (mMasterMono == mono) {
4105 return NO_ERROR;
4106 }
4107 mMasterMono = mono;
4108 // if enabling mono we close all offloaded devices, which will invalidate the
4109 // corresponding AudioTrack. The AudioTrack client/MediaPlayer is responsible
4110 // for recreating the new AudioTrack as non-offloaded PCM.
4111 //
4112 // If disabling mono, we leave all tracks as is: we don't know which clients
4113 // and tracks are able to be recreated as offloaded. The next "song" should
4114 // play back offloaded.
4115 if (mMasterMono) {
4116 Vector<audio_io_handle_t> offloaded;
4117 for (size_t i = 0; i < mOutputs.size(); ++i) {
4118 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
4119 if (desc->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
4120 offloaded.push(desc->mIoHandle);
4121 }
4122 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08004123 for (const auto& handle : offloaded) {
4124 closeOutput(handle);
Andy Hung2ddee192015-12-18 17:34:44 -08004125 }
4126 }
4127 // update master mono for all remaining outputs
4128 for (size_t i = 0; i < mOutputs.size(); ++i) {
4129 updateMono(mOutputs.keyAt(i));
4130 }
4131 return NO_ERROR;
4132}
4133
4134status_t AudioPolicyManager::getMasterMono(bool *mono)
4135{
4136 *mono = mMasterMono;
4137 return NO_ERROR;
4138}
4139
Eric Laurentac9cef52017-06-09 15:46:26 -07004140float AudioPolicyManager::getStreamVolumeDB(
4141 audio_stream_type_t stream, int index, audio_devices_t device)
4142{
jiabin9a3361e2019-10-01 09:38:30 -07004143 return computeVolume(getVolumeCurves(stream), toVolumeSource(stream), index, {device});
Eric Laurentac9cef52017-06-09 15:46:26 -07004144}
4145
jiabin81772902018-04-02 17:52:27 -07004146status_t AudioPolicyManager::getSurroundFormats(unsigned int *numSurroundFormats,
4147 audio_format_t *surroundFormats,
4148 bool *surroundFormatsEnabled,
4149 bool reported)
4150{
4151 if (numSurroundFormats == NULL || (*numSurroundFormats != 0 &&
4152 (surroundFormats == NULL || surroundFormatsEnabled == NULL))) {
4153 return BAD_VALUE;
4154 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08004155 ALOGV("%s() numSurroundFormats %d surroundFormats %p surroundFormatsEnabled %p reported %d",
4156 __func__, *numSurroundFormats, surroundFormats, surroundFormatsEnabled, reported);
jiabin81772902018-04-02 17:52:27 -07004157
4158 size_t formatsWritten = 0;
4159 size_t formatsMax = *numSurroundFormats;
Mikhail Naganov100f0122018-11-29 11:22:16 -08004160 std::unordered_set<audio_format_t> formats; // Uses primary surround formats only
jiabin81772902018-04-02 17:52:27 -07004161 if (reported) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08004162 // Return formats from all device profiles that have already been resolved by
Mikhail Naganov2563f232018-09-27 14:48:01 -07004163 // checkOutputsForDevice().
Mikhail Naganov100f0122018-11-29 11:22:16 -08004164 for (size_t i = 0; i < mAvailableOutputDevices.size(); i++) {
4165 sp<DeviceDescriptor> device = mAvailableOutputDevices[i];
4166 FormatVector supportedFormats =
4167 device->getAudioPort()->getAudioProfiles().getSupportedFormats();
4168 for (size_t j = 0; j < supportedFormats.size(); j++) {
4169 if (mConfig.getSurroundFormats().count(supportedFormats[j]) != 0) {
4170 formats.insert(supportedFormats[j]);
4171 } else {
4172 for (const auto& pair : mConfig.getSurroundFormats()) {
4173 if (pair.second.count(supportedFormats[j]) != 0) {
4174 formats.insert(pair.first);
4175 break;
4176 }
4177 }
4178 }
4179 }
jiabin81772902018-04-02 17:52:27 -07004180 }
4181 } else {
Mikhail Naganov778bc1f2018-09-14 16:28:52 -07004182 for (const auto& pair : mConfig.getSurroundFormats()) {
4183 formats.insert(pair.first);
jiabin81772902018-04-02 17:52:27 -07004184 }
4185 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08004186 *numSurroundFormats = formats.size();
4187 audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
4188 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
Mikhail Naganov2563f232018-09-27 14:48:01 -07004189 for (const auto& format: formats) {
jiabin81772902018-04-02 17:52:27 -07004190 if (formatsWritten < formatsMax) {
Mikhail Naganov2563f232018-09-27 14:48:01 -07004191 surroundFormats[formatsWritten] = format;
Mikhail Naganov100f0122018-11-29 11:22:16 -08004192 bool formatEnabled = true;
4193 switch (forceUse) {
4194 case AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL:
4195 formatEnabled = mManualSurroundFormats.count(format) != 0;
4196 break;
4197 case AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER:
4198 formatEnabled = false;
4199 break;
4200 default: // AUTO or ALWAYS => true
4201 break;
jiabin81772902018-04-02 17:52:27 -07004202 }
4203 surroundFormatsEnabled[formatsWritten++] = formatEnabled;
4204 }
jiabin81772902018-04-02 17:52:27 -07004205 }
4206 return NO_ERROR;
4207}
4208
4209status_t AudioPolicyManager::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
4210{
Mikhail Naganov5dddbfd2018-09-11 14:15:05 -07004211 ALOGV("%s() format 0x%X enabled %d", __func__, audioFormat, enabled);
Mikhail Naganov778bc1f2018-09-14 16:28:52 -07004212 const auto& formatIter = mConfig.getSurroundFormats().find(audioFormat);
4213 if (formatIter == mConfig.getSurroundFormats().end()) {
Mikhail Naganov5dddbfd2018-09-11 14:15:05 -07004214 ALOGW("%s() format 0x%X is not a known surround format", __func__, audioFormat);
jiabin81772902018-04-02 17:52:27 -07004215 return BAD_VALUE;
4216 }
4217
Mikhail Naganov100f0122018-11-29 11:22:16 -08004218 if (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND) !=
4219 AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
Mikhail Naganov5dddbfd2018-09-11 14:15:05 -07004220 ALOGW("%s() not in manual mode for surround sound format selection", __func__);
jiabin81772902018-04-02 17:52:27 -07004221 return INVALID_OPERATION;
4222 }
4223
Mikhail Naganov100f0122018-11-29 11:22:16 -08004224 if ((mManualSurroundFormats.count(audioFormat) != 0) == enabled) {
jiabin81772902018-04-02 17:52:27 -07004225 return NO_ERROR;
4226 }
4227
Mikhail Naganov100f0122018-11-29 11:22:16 -08004228 std::unordered_set<audio_format_t> surroundFormatsBackup(mManualSurroundFormats);
jiabin81772902018-04-02 17:52:27 -07004229 if (enabled) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08004230 mManualSurroundFormats.insert(audioFormat);
Mikhail Naganov778bc1f2018-09-14 16:28:52 -07004231 for (const auto& subFormat : formatIter->second) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08004232 mManualSurroundFormats.insert(subFormat);
jiabin81772902018-04-02 17:52:27 -07004233 }
4234 } else {
Mikhail Naganov100f0122018-11-29 11:22:16 -08004235 mManualSurroundFormats.erase(audioFormat);
Mikhail Naganov778bc1f2018-09-14 16:28:52 -07004236 for (const auto& subFormat : formatIter->second) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08004237 mManualSurroundFormats.erase(subFormat);
jiabin81772902018-04-02 17:52:27 -07004238 }
4239 }
4240
4241 sp<SwAudioOutputDescriptor> outputDesc;
4242 bool profileUpdated = false;
jiabin9a3361e2019-10-01 09:38:30 -07004243 DeviceVector hdmiOutputDevices = mAvailableOutputDevices.getDevicesFromType(
4244 AUDIO_DEVICE_OUT_HDMI);
jiabin81772902018-04-02 17:52:27 -07004245 for (size_t i = 0; i < hdmiOutputDevices.size(); i++) {
4246 // Simulate reconnection to update enabled surround sound formats.
jiabince9f20e2019-09-12 16:29:15 -07004247 String8 address = String8(hdmiOutputDevices[i]->address().c_str());
jiabin5740f082019-08-19 15:08:30 -07004248 std::string name = hdmiOutputDevices[i]->getName();
jiabin81772902018-04-02 17:52:27 -07004249 status_t status = setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_HDMI,
4250 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
4251 address.c_str(),
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08004252 name.c_str(),
4253 AUDIO_FORMAT_DEFAULT);
jiabin81772902018-04-02 17:52:27 -07004254 if (status != NO_ERROR) {
4255 continue;
4256 }
4257 status = setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_HDMI,
4258 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
4259 address.c_str(),
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08004260 name.c_str(),
4261 AUDIO_FORMAT_DEFAULT);
jiabin81772902018-04-02 17:52:27 -07004262 profileUpdated |= (status == NO_ERROR);
4263 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08004264 // FIXME: Why doing this for input HDMI devices if we don't augment their reported formats?
jiabin9a3361e2019-10-01 09:38:30 -07004265 DeviceVector hdmiInputDevices = mAvailableInputDevices.getDevicesFromType(
jiabin81772902018-04-02 17:52:27 -07004266 AUDIO_DEVICE_IN_HDMI);
4267 for (size_t i = 0; i < hdmiInputDevices.size(); i++) {
4268 // Simulate reconnection to update enabled surround sound formats.
jiabince9f20e2019-09-12 16:29:15 -07004269 String8 address = String8(hdmiInputDevices[i]->address().c_str());
jiabin5740f082019-08-19 15:08:30 -07004270 std::string name = hdmiInputDevices[i]->getName();
jiabin81772902018-04-02 17:52:27 -07004271 status_t status = setDeviceConnectionStateInt(AUDIO_DEVICE_IN_HDMI,
4272 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
4273 address.c_str(),
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08004274 name.c_str(),
4275 AUDIO_FORMAT_DEFAULT);
jiabin81772902018-04-02 17:52:27 -07004276 if (status != NO_ERROR) {
4277 continue;
4278 }
4279 status = setDeviceConnectionStateInt(AUDIO_DEVICE_IN_HDMI,
4280 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
4281 address.c_str(),
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08004282 name.c_str(),
4283 AUDIO_FORMAT_DEFAULT);
jiabin81772902018-04-02 17:52:27 -07004284 profileUpdated |= (status == NO_ERROR);
4285 }
4286
jiabin81772902018-04-02 17:52:27 -07004287 if (!profileUpdated) {
Mikhail Naganov5dddbfd2018-09-11 14:15:05 -07004288 ALOGW("%s() no audio profiles updated, undoing surround formats change", __func__);
Mikhail Naganov100f0122018-11-29 11:22:16 -08004289 mManualSurroundFormats = std::move(surroundFormatsBackup);
jiabin81772902018-04-02 17:52:27 -07004290 }
4291
4292 return profileUpdated ? NO_ERROR : INVALID_OPERATION;
4293}
4294
Eric Laurent5ada82e2019-08-29 17:53:54 -07004295void AudioPolicyManager::setAppState(audio_port_handle_t portId, app_state_t state)
Svet Ganovf4ddfef2018-01-16 07:37:58 -08004296{
Eric Laurent5ada82e2019-08-29 17:53:54 -07004297 ALOGV("%s(portId:%d, state:%d)", __func__, portId, state);
Eric Laurenta9f86652018-11-28 17:23:11 -08004298 for (size_t i = 0; i < mInputs.size(); i++) {
Eric Laurent5ada82e2019-08-29 17:53:54 -07004299 mInputs.valueAt(i)->setAppState(portId, state);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08004300 }
4301}
4302
jiabin6012f912018-11-02 17:06:30 -07004303bool AudioPolicyManager::isHapticPlaybackSupported()
4304{
4305 for (const auto& hwModule : mHwModules) {
4306 const OutputProfileCollection &outputProfiles = hwModule->getOutputProfiles();
4307 for (const auto &outProfile : outputProfiles) {
4308 struct audio_port audioPort;
4309 outProfile->toAudioPort(&audioPort);
4310 for (size_t i = 0; i < audioPort.num_channel_masks; i++) {
4311 if (audioPort.channel_masks[i] & AUDIO_CHANNEL_HAPTIC_ALL) {
4312 return true;
4313 }
4314 }
4315 }
4316 }
4317 return false;
4318}
4319
Eric Laurent8340e672019-11-06 11:01:08 -08004320bool AudioPolicyManager::isCallScreenModeSupported()
4321{
4322 return getConfig().isCallScreenModeSupported();
4323}
4324
4325
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004326status_t AudioPolicyManager::disconnectAudioSource(const sp<SourceClientDescriptor>& sourceDesc)
Eric Laurentd60560a2015-04-10 11:31:20 -07004327{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004328 ALOGV("%s port Id %d", __FUNCTION__, sourceDesc->portId());
Eric Laurentd60560a2015-04-10 11:31:20 -07004329
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004330 sp<AudioPatch> patchDesc = mAudioPatches.valueFor(sourceDesc->patchDesc()->mHandle);
Eric Laurentd60560a2015-04-10 11:31:20 -07004331 if (patchDesc == 0) {
4332 ALOGW("%s source has no patch with handle %d", __FUNCTION__,
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004333 sourceDesc->patchDesc()->mHandle);
Eric Laurentd60560a2015-04-10 11:31:20 -07004334 return BAD_VALUE;
4335 }
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004336 removeAudioPatch(sourceDesc->patchDesc()->mHandle);
Eric Laurentd60560a2015-04-10 11:31:20 -07004337
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004338 sp<SwAudioOutputDescriptor> swOutputDesc = sourceDesc->swOutput().promote();
Eric Laurentd60560a2015-04-10 11:31:20 -07004339 if (swOutputDesc != 0) {
Eric Laurent97ac8712018-07-27 18:59:02 -07004340 status_t status = stopSource(swOutputDesc, sourceDesc);
Eric Laurent733ce942017-12-07 12:18:25 -08004341 if (status == NO_ERROR) {
4342 swOutputDesc->stop();
4343 }
François Gaffie5592ee22019-05-22 08:00:05 +02004344 swOutputDesc->removeClient(sourceDesc->portId());
Eric Laurentd60560a2015-04-10 11:31:20 -07004345 mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
4346 } else {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004347 sp<HwAudioOutputDescriptor> hwOutputDesc = sourceDesc->hwOutput().promote();
Eric Laurentd60560a2015-04-10 11:31:20 -07004348 if (hwOutputDesc != 0) {
4349 // release patch between src device and output device
4350 // close Hwoutput and remove from mHwOutputs
4351 } else {
4352 ALOGW("%s source has neither SW nor HW output", __FUNCTION__);
4353 }
4354 }
4355 return NO_ERROR;
4356}
4357
François Gaffiec005e562018-11-06 15:04:49 +01004358sp<SourceClientDescriptor> AudioPolicyManager::getSourceForAttributesOnOutput(
4359 audio_io_handle_t output, const audio_attributes_t &attr)
Eric Laurentd60560a2015-04-10 11:31:20 -07004360{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004361 sp<SourceClientDescriptor> source;
Eric Laurentd60560a2015-04-10 11:31:20 -07004362 for (size_t i = 0; i < mAudioSources.size(); i++) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004363 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004364 sp<SwAudioOutputDescriptor> outputDesc = sourceDesc->swOutput().promote();
François Gaffiec005e562018-11-06 15:04:49 +01004365 if (followsSameRouting(attr, sourceDesc->attributes()) &&
4366 outputDesc != 0 && outputDesc->mIoHandle == output) {
Eric Laurentd60560a2015-04-10 11:31:20 -07004367 source = sourceDesc;
4368 break;
4369 }
4370 }
4371 return source;
Eric Laurent554a2772015-04-10 11:29:24 -07004372}
4373
Eric Laurente552edb2014-03-10 17:42:56 -07004374// ----------------------------------------------------------------------------
Eric Laurente0720872014-03-11 09:30:41 -07004375// AudioPolicyManager
Eric Laurente552edb2014-03-10 17:42:56 -07004376// ----------------------------------------------------------------------------
Eric Laurent6a94d692014-05-20 11:18:06 -07004377uint32_t AudioPolicyManager::nextAudioPortGeneration()
4378{
Mikhail Naganov2773dd72017-12-08 10:12:11 -08004379 return mAudioPortGeneration++;
Eric Laurent6a94d692014-05-20 11:18:06 -07004380}
4381
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +09004382// Treblized audio policy xml config will be located in /odm/etc or /vendor/etc.
4383static const char *kConfigLocationList[] =
4384 {"/odm/etc", "/vendor/etc", "/system/etc"};
4385static const int kConfigLocationListSize =
4386 (sizeof(kConfigLocationList) / sizeof(kConfigLocationList[0]));
4387
4388static status_t deserializeAudioPolicyXmlConfig(AudioPolicyConfig &config) {
4389 char audioPolicyXmlConfigFile[AUDIO_POLICY_XML_CONFIG_FILE_PATH_MAX_LENGTH];
Petri Gyntherf497f292018-04-17 18:46:10 -07004390 std::vector<const char*> fileNames;
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +09004391 status_t ret;
4392
Cheney Ni00ce33d2018-11-01 06:30:37 +08004393 if (property_get_bool("ro.bluetooth.a2dp_offload.supported", false)) {
Cheney Nie5985452019-02-24 01:39:15 +08004394 if (property_get_bool("persist.bluetooth.bluetooth_audio_hal.disabled", false) &&
4395 property_get_bool("persist.bluetooth.a2dp_offload.disabled", false)) {
4396 // Both BluetoothAudio@2.0 and BluetoothA2dp@1.0 (Offlaod) are disabled, and uses
4397 // the legacy hardware module for A2DP and hearing aid.
4398 fileNames.push_back(AUDIO_POLICY_BLUETOOTH_LEGACY_HAL_XML_CONFIG_FILE_NAME);
4399 } else if (property_get_bool("persist.bluetooth.a2dp_offload.disabled", false)) {
4400 // A2DP offload supported but disabled: try to use special XML file
Cheney Ni6851adb2018-11-01 06:30:37 +08004401 fileNames.push_back(AUDIO_POLICY_A2DP_OFFLOAD_DISABLED_XML_CONFIG_FILE_NAME);
4402 }
Cheney Nie5985452019-02-24 01:39:15 +08004403 } else if (property_get_bool("persist.bluetooth.bluetooth_audio_hal.disabled", false)) {
4404 fileNames.push_back(AUDIO_POLICY_BLUETOOTH_LEGACY_HAL_XML_CONFIG_FILE_NAME);
Petri Gyntherf497f292018-04-17 18:46:10 -07004405 }
4406 fileNames.push_back(AUDIO_POLICY_XML_CONFIG_FILE_NAME);
4407
4408 for (const char* fileName : fileNames) {
4409 for (int i = 0; i < kConfigLocationListSize; i++) {
Petri Gyntherf497f292018-04-17 18:46:10 -07004410 snprintf(audioPolicyXmlConfigFile, sizeof(audioPolicyXmlConfigFile),
4411 "%s/%s", kConfigLocationList[i], fileName);
Mikhail Naganova289aea2018-09-17 15:26:23 -07004412 ret = deserializeAudioPolicyFile(audioPolicyXmlConfigFile, &config);
Petri Gyntherf497f292018-04-17 18:46:10 -07004413 if (ret == NO_ERROR) {
Mikhail Naganov2e5167e12018-04-19 13:41:22 -07004414 config.setSource(audioPolicyXmlConfigFile);
Petri Gyntherf497f292018-04-17 18:46:10 -07004415 return ret;
4416 }
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +09004417 }
4418 }
4419 return ret;
4420}
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +09004421
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08004422AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface,
4423 bool /*forTesting*/)
Eric Laurente552edb2014-03-10 17:42:56 -07004424 :
Andy Hung4ef19fa2018-05-15 19:35:29 -07004425 mUidCached(AID_AUDIOSERVER), // no need to call getuid(), there's only one of us running.
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08004426 mpClientInterface(clientInterface),
Eric Laurente552edb2014-03-10 17:42:56 -07004427 mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f),
Eric Laurent3a4311c2014-03-17 12:00:47 -07004428 mA2dpSuspended(false),
Eric Laurentf5aa58d2019-02-22 18:20:11 -08004429 mConfig(mHwModulesAll, mAvailableOutputDevices, mAvailableInputDevices, mDefaultOutputDevice),
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07004430 mAudioPortGeneration(1),
4431 mBeaconMuteRefCount(0),
4432 mBeaconPlayingRefCount(0),
Eric Laurent9459fb02015-08-12 18:36:32 -07004433 mBeaconMuted(false),
Andy Hung2ddee192015-12-18 17:34:44 -08004434 mTtsOutputAvailable(false),
Eric Laurent36829f92017-04-07 19:04:42 -07004435 mMasterMono(false),
Eric Laurent4eb58f12018-12-07 16:41:02 -08004436 mMusicEffectOutput(AUDIO_IO_HANDLE_NONE)
Eric Laurente552edb2014-03-10 17:42:56 -07004437{
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08004438}
François Gaffied1ab2bd2015-12-02 18:20:06 +01004439
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08004440AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface)
4441 : AudioPolicyManager(clientInterface, false /*forTesting*/)
4442{
4443 loadConfig();
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08004444}
François Gaffied1ab2bd2015-12-02 18:20:06 +01004445
Kevin Rocarddfa1e8a2018-10-26 16:42:07 -07004446void AudioPolicyManager::loadConfig() {
4447 if (deserializeAudioPolicyXmlConfig(getConfig()) != NO_ERROR) {
François Gaffied1ab2bd2015-12-02 18:20:06 +01004448 ALOGE("could not load audio policy configuration file, setting defaults");
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08004449 getConfig().setDefault();
François Gaffied1ab2bd2015-12-02 18:20:06 +01004450 }
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08004451}
4452
4453status_t AudioPolicyManager::initialize() {
Mikhail Naganov47835552019-05-14 10:32:51 -07004454 {
4455 auto engLib = EngineLibrary::load(
4456 "libaudiopolicyengine" + getConfig().getEngineLibraryNameSuffix() + ".so");
4457 if (!engLib) {
4458 ALOGE("%s: Failed to load the engine library", __FUNCTION__);
4459 return NO_INIT;
4460 }
4461 mEngine = engLib->createEngine();
4462 if (mEngine == nullptr) {
4463 ALOGE("%s: Failed to instantiate the APM engine", __FUNCTION__);
4464 return NO_INIT;
4465 }
François Gaffie2110e042015-03-24 08:41:51 +01004466 }
4467 mEngine->setObserver(this);
4468 status_t status = mEngine->initCheck();
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08004469 if (status != NO_ERROR) {
4470 LOG_FATAL("Policy engine not initialized(err=%d)", status);
4471 return status;
4472 }
François Gaffie2110e042015-03-24 08:41:51 +01004473
Eric Laurent3a4311c2014-03-17 12:00:47 -07004474 // mAvailableOutputDevices and mAvailableInputDevices now contain all attached devices
Eric Laurente552edb2014-03-10 17:42:56 -07004475 // open all output streams needed to access attached devices
Mikhail Naganovd4120142017-12-06 15:49:22 -08004476 for (const auto& hwModule : mHwModulesAll) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08004477 hwModule->setHandle(mpClientInterface->loadHwModule(hwModule->getName()));
Mikhail Naganovd4120142017-12-06 15:49:22 -08004478 if (hwModule->getHandle() == AUDIO_MODULE_HANDLE_NONE) {
4479 ALOGW("could not open HW module %s", hwModule->getName());
Eric Laurente552edb2014-03-10 17:42:56 -07004480 continue;
4481 }
Mikhail Naganovd4120142017-12-06 15:49:22 -08004482 mHwModules.push_back(hwModule);
Eric Laurente552edb2014-03-10 17:42:56 -07004483 // open all output streams needed to access attached devices
4484 // except for direct output streams that are only opened when they are actually
4485 // required by an app.
Eric Laurent3a4311c2014-03-17 12:00:47 -07004486 // This also validates mAvailableOutputDevices list
Mikhail Naganova5e165d2017-12-07 17:08:02 -08004487 for (const auto& outProfile : hwModule->getOutputProfiles()) {
Eric Laurent3974e3b2017-12-07 17:58:43 -08004488 if (!outProfile->canOpenNewIo()) {
4489 ALOGE("Invalid Output profile max open count %u for profile %s",
4490 outProfile->maxOpenCount, outProfile->getTagName().c_str());
4491 continue;
4492 }
François Gaffiea8ecc2c2015-11-09 16:10:40 +01004493 if (!outProfile->hasSupportedDevices()) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08004494 ALOGW("Output profile contains no device on module %s", hwModule->getName());
Eric Laurent3a4311c2014-03-17 12:00:47 -07004495 continue;
4496 }
François Gaffiea8ecc2c2015-11-09 16:10:40 +01004497 if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_TTS) != 0) {
Eric Laurent9459fb02015-08-12 18:36:32 -07004498 mTtsOutputAvailable = true;
4499 }
Eric Laurent3a4311c2014-03-17 12:00:47 -07004500
François Gaffiea8ecc2c2015-11-09 16:10:40 +01004501 if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_DIRECT) != 0) {
Eric Laurentd78f1532014-09-16 16:38:20 -07004502 continue;
4503 }
François Gaffie11d30102018-11-02 16:09:09 +01004504 const DeviceVector &supportedDevices = outProfile->getSupportedDevices();
4505 DeviceVector availProfileDevices = supportedDevices.filter(mAvailableOutputDevices);
4506 sp<DeviceDescriptor> supportedDevice = 0;
4507 if (supportedDevices.contains(mDefaultOutputDevice)) {
4508 supportedDevice = mDefaultOutputDevice;
Eric Laurent83b88082014-06-20 18:31:16 -07004509 } else {
François Gaffie11d30102018-11-02 16:09:09 +01004510 // choose first device present in profile's SupportedDevices also part of
4511 // mAvailableOutputDevices.
4512 if (availProfileDevices.isEmpty()) {
4513 continue;
4514 }
4515 supportedDevice = availProfileDevices.itemAt(0);
Eric Laurente552edb2014-03-10 17:42:56 -07004516 }
François Gaffie11d30102018-11-02 16:09:09 +01004517 if (!mAvailableOutputDevices.contains(supportedDevice)) {
Eric Laurentd78f1532014-09-16 16:38:20 -07004518 continue;
4519 }
Eric Laurentc75307b2015-03-17 15:29:32 -07004520 sp<SwAudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(outProfile,
4521 mpClientInterface);
Eric Laurentd78f1532014-09-16 16:38:20 -07004522 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
François Gaffie11d30102018-11-02 16:09:09 +01004523 status_t status = outputDesc->open(nullptr, DeviceVector(supportedDevice),
4524 AUDIO_STREAM_DEFAULT,
4525 AUDIO_OUTPUT_FLAG_NONE, &output);
Eric Laurentd78f1532014-09-16 16:38:20 -07004526 if (status != NO_ERROR) {
François Gaffie11d30102018-11-02 16:09:09 +01004527 ALOGW("Cannot open output stream for devices %s on hw module %s",
4528 supportedDevice->toString().c_str(), hwModule->getName());
4529 continue;
Eric Laurentd78f1532014-09-16 16:38:20 -07004530 }
François Gaffie11d30102018-11-02 16:09:09 +01004531 for (const auto &device : availProfileDevices) {
4532 // give a valid ID to an attached device once confirmed it is reachable
4533 if (!device->isAttached()) {
4534 device->attach(hwModule);
4535 }
4536 }
4537 if (mPrimaryOutput == 0 &&
4538 outProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
4539 mPrimaryOutput = outputDesc;
4540 }
4541 addOutput(output, outputDesc);
4542 setOutputDevices(outputDesc,
4543 DeviceVector(supportedDevice),
4544 true,
4545 0,
4546 NULL);
Eric Laurente552edb2014-03-10 17:42:56 -07004547 }
Eric Laurent3a4311c2014-03-17 12:00:47 -07004548 // open input streams needed to access attached devices to validate
4549 // mAvailableInputDevices list
Mikhail Naganova5e165d2017-12-07 17:08:02 -08004550 for (const auto& inProfile : hwModule->getInputProfiles()) {
Eric Laurent3974e3b2017-12-07 17:58:43 -08004551 if (!inProfile->canOpenNewIo()) {
4552 ALOGE("Invalid Input profile max open count %u for profile %s",
4553 inProfile->maxOpenCount, inProfile->getTagName().c_str());
4554 continue;
4555 }
François Gaffiea8ecc2c2015-11-09 16:10:40 +01004556 if (!inProfile->hasSupportedDevices()) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08004557 ALOGW("Input profile contains no device on module %s", hwModule->getName());
Eric Laurent3a4311c2014-03-17 12:00:47 -07004558 continue;
4559 }
François Gaffiea8ecc2c2015-11-09 16:10:40 +01004560 // chose first device present in profile's SupportedDevices also part of
François Gaffie11d30102018-11-02 16:09:09 +01004561 // available input devices
4562 const DeviceVector &supportedDevices = inProfile->getSupportedDevices();
4563 DeviceVector availProfileDevices = supportedDevices.filter(mAvailableInputDevices);
4564 if (availProfileDevices.isEmpty()) {
4565 ALOGE("%s: Input device list is empty!", __FUNCTION__);
Eric Laurentd78f1532014-09-16 16:38:20 -07004566 continue;
4567 }
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08004568 sp<AudioInputDescriptor> inputDesc =
Eric Laurentfe231122017-11-17 17:48:06 -08004569 new AudioInputDescriptor(inProfile, mpClientInterface);
Eric Laurentd78f1532014-09-16 16:38:20 -07004570
Eric Laurentd78f1532014-09-16 16:38:20 -07004571 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
Eric Laurentfe231122017-11-17 17:48:06 -08004572 status_t status = inputDesc->open(nullptr,
François Gaffie11d30102018-11-02 16:09:09 +01004573 availProfileDevices.itemAt(0),
Eric Laurentfe231122017-11-17 17:48:06 -08004574 AUDIO_SOURCE_MIC,
4575 AUDIO_INPUT_FLAG_NONE,
4576 &input);
François Gaffie11d30102018-11-02 16:09:09 +01004577 if (status != NO_ERROR) {
4578 ALOGW("Cannot open input stream for device %s on hw module %s",
4579 availProfileDevices.toString().c_str(),
Mikhail Naganovd4120142017-12-06 15:49:22 -08004580 hwModule->getName());
François Gaffie11d30102018-11-02 16:09:09 +01004581 continue;
Eric Laurentd78f1532014-09-16 16:38:20 -07004582 }
François Gaffie11d30102018-11-02 16:09:09 +01004583 for (const auto &device : availProfileDevices) {
4584 // give a valid ID to an attached device once confirmed it is reachable
4585 if (!device->isAttached()) {
4586 device->attach(hwModule);
jiabin4ef93452019-09-10 14:29:54 -07004587 device->importAudioPortAndPickAudioProfile(inProfile, true);
François Gaffie11d30102018-11-02 16:09:09 +01004588 }
4589 }
4590 inputDesc->close();
Eric Laurent3a4311c2014-03-17 12:00:47 -07004591 }
4592 }
4593 // make sure all attached devices have been allocated a unique ID
François Gaffie11d30102018-11-02 16:09:09 +01004594 auto checkAndSetAvailable = [this](auto& devices) {
Eric Laurent7f0f4312019-01-18 10:47:14 -08004595 for (size_t i = 0; i < devices.size();) {
4596 const auto &device = devices[i];
François Gaffie11d30102018-11-02 16:09:09 +01004597 if (!device->isAttached()) {
4598 ALOGW("device %s is unreachable", device->toString().c_str());
4599 devices.remove(device);
4600 continue;
4601 }
4602 // Device is now validated and can be appended to the available devices of the engine
Eric Laurent736a1022019-03-27 18:28:46 -07004603 setEngineDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
Eric Laurent7f0f4312019-01-18 10:47:14 -08004604 i++;
Eric Laurent3a4311c2014-03-17 12:00:47 -07004605 }
François Gaffie11d30102018-11-02 16:09:09 +01004606 };
4607 checkAndSetAvailable(mAvailableOutputDevices);
4608 checkAndSetAvailable(mAvailableInputDevices);
4609
Eric Laurent3a4311c2014-03-17 12:00:47 -07004610 // make sure default device is reachable
François Gaffie11d30102018-11-02 16:09:09 +01004611 if (mDefaultOutputDevice == 0 || !mAvailableOutputDevices.contains(mDefaultOutputDevice)) {
4612 ALOGE_IF(mDefaultOutputDevice != 0, "Default device %s is unreachable",
4613 mDefaultOutputDevice->toString().c_str());
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08004614 status = NO_INIT;
Eric Laurent3a4311c2014-03-17 12:00:47 -07004615 }
jiabin9ff780e2018-03-19 18:19:52 -07004616 // If microphones address is empty, set it according to device type
Eric Laurent736a1022019-03-27 18:28:46 -07004617 for (size_t i = 0; i < mAvailableInputDevices.size(); i++) {
jiabince9f20e2019-09-12 16:29:15 -07004618 if (mAvailableInputDevices[i]->address().empty()) {
jiabin9ff780e2018-03-19 18:19:52 -07004619 if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_BUILTIN_MIC) {
jiabince9f20e2019-09-12 16:29:15 -07004620 mAvailableInputDevices[i]->setAddress(AUDIO_BOTTOM_MICROPHONE_ADDRESS);
jiabin9ff780e2018-03-19 18:19:52 -07004621 } else if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_BACK_MIC) {
jiabince9f20e2019-09-12 16:29:15 -07004622 mAvailableInputDevices[i]->setAddress(AUDIO_BACK_MICROPHONE_ADDRESS);
jiabin9ff780e2018-03-19 18:19:52 -07004623 }
4624 }
4625 }
Eric Laurente552edb2014-03-10 17:42:56 -07004626
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08004627 if (mPrimaryOutput == 0) {
4628 ALOGE("Failed to open primary output");
4629 status = NO_INIT;
4630 }
Eric Laurente552edb2014-03-10 17:42:56 -07004631
Tomoharu Kasahara71c90912018-10-31 09:10:12 +09004632 // Silence ALOGV statements
4633 property_set("log.tag." LOG_TAG, "D");
4634
Eric Laurente552edb2014-03-10 17:42:56 -07004635 updateDevicesAndOutputs();
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08004636 return status;
Eric Laurente552edb2014-03-10 17:42:56 -07004637}
4638
Eric Laurente0720872014-03-11 09:30:41 -07004639AudioPolicyManager::~AudioPolicyManager()
Eric Laurente552edb2014-03-10 17:42:56 -07004640{
Eric Laurente552edb2014-03-10 17:42:56 -07004641 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentfe231122017-11-17 17:48:06 -08004642 mOutputs.valueAt(i)->close();
Eric Laurente552edb2014-03-10 17:42:56 -07004643 }
4644 for (size_t i = 0; i < mInputs.size(); i++) {
Eric Laurentfe231122017-11-17 17:48:06 -08004645 mInputs.valueAt(i)->close();
Eric Laurente552edb2014-03-10 17:42:56 -07004646 }
Eric Laurent3a4311c2014-03-17 12:00:47 -07004647 mAvailableOutputDevices.clear();
4648 mAvailableInputDevices.clear();
Eric Laurent1f2f2232014-06-02 12:01:23 -07004649 mOutputs.clear();
4650 mInputs.clear();
4651 mHwModules.clear();
Mikhail Naganovd4120142017-12-06 15:49:22 -08004652 mHwModulesAll.clear();
Mikhail Naganov100f0122018-11-29 11:22:16 -08004653 mManualSurroundFormats.clear();
Eric Laurente552edb2014-03-10 17:42:56 -07004654}
4655
Eric Laurente0720872014-03-11 09:30:41 -07004656status_t AudioPolicyManager::initCheck()
Eric Laurente552edb2014-03-10 17:42:56 -07004657{
Eric Laurent87ffa392015-05-22 10:32:38 -07004658 return hasPrimaryOutput() ? NO_ERROR : NO_INIT;
Eric Laurente552edb2014-03-10 17:42:56 -07004659}
4660
Eric Laurente552edb2014-03-10 17:42:56 -07004661// ---
4662
Eric Laurent98e38192018-02-15 18:31:53 -08004663void AudioPolicyManager::addOutput(audio_io_handle_t output,
4664 const sp<SwAudioOutputDescriptor>& outputDesc)
Eric Laurente552edb2014-03-10 17:42:56 -07004665{
Eric Laurent1c333e22014-05-20 10:48:17 -07004666 mOutputs.add(output, outputDesc);
jiabin9a3361e2019-10-01 09:38:30 -07004667 applyStreamVolumes(outputDesc, DeviceTypeSet(), 0 /* delayMs */, true /* force */);
Andy Hung2ddee192015-12-18 17:34:44 -08004668 updateMono(output); // update mono status when adding to output list
Eric Laurent36829f92017-04-07 19:04:42 -07004669 selectOutputForMusicEffects();
Eric Laurent6a94d692014-05-20 11:18:06 -07004670 nextAudioPortGeneration();
Eric Laurente552edb2014-03-10 17:42:56 -07004671}
4672
François Gaffie53615e22015-03-19 09:24:12 +01004673void AudioPolicyManager::removeOutput(audio_io_handle_t output)
4674{
4675 mOutputs.removeItem(output);
Eric Laurent36829f92017-04-07 19:04:42 -07004676 selectOutputForMusicEffects();
François Gaffie53615e22015-03-19 09:24:12 +01004677}
4678
Eric Laurent98e38192018-02-15 18:31:53 -08004679void AudioPolicyManager::addInput(audio_io_handle_t input,
4680 const sp<AudioInputDescriptor>& inputDesc)
Eric Laurentd4692962014-05-05 18:13:44 -07004681{
Eric Laurent1c333e22014-05-20 10:48:17 -07004682 mInputs.add(input, inputDesc);
Eric Laurent6a94d692014-05-20 11:18:06 -07004683 nextAudioPortGeneration();
Eric Laurentd4692962014-05-05 18:13:44 -07004684}
Eric Laurente552edb2014-03-10 17:42:56 -07004685
François Gaffie11d30102018-11-02 16:09:09 +01004686status_t AudioPolicyManager::checkOutputsForDevice(const sp<DeviceDescriptor>& device,
François Gaffie53615e22015-03-19 09:24:12 +01004687 audio_policy_dev_state_t state,
François Gaffie11d30102018-11-02 16:09:09 +01004688 SortedVector<audio_io_handle_t>& outputs)
Eric Laurente552edb2014-03-10 17:42:56 -07004689{
François Gaffie11d30102018-11-02 16:09:09 +01004690 audio_devices_t deviceType = device->type();
jiabince9f20e2019-09-12 16:29:15 -07004691 const String8 &address = String8(device->address().c_str());
Eric Laurentc75307b2015-03-17 15:29:32 -07004692 sp<SwAudioOutputDescriptor> desc;
Eric Laurentcc750d32015-06-25 11:48:20 -07004693
François Gaffie11d30102018-11-02 16:09:09 +01004694 if (audio_device_is_digital(deviceType)) {
Eric Laurentcc750d32015-06-25 11:48:20 -07004695 // erase all current sample rates, formats and channel masks
François Gaffie11d30102018-11-02 16:09:09 +01004696 device->clearAudioProfiles();
Eric Laurentcc750d32015-06-25 11:48:20 -07004697 }
Eric Laurente552edb2014-03-10 17:42:56 -07004698
Eric Laurent3b73df72014-03-11 09:06:29 -07004699 if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
Eric Laurente552edb2014-03-10 17:42:56 -07004700 // first list already open outputs that can be routed to this device
4701 for (size_t i = 0; i < mOutputs.size(); i++) {
4702 desc = mOutputs.valueAt(i);
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08004703 if (!desc->isDuplicated() && desc->supportsDevice(device)
jiabin9a3361e2019-10-01 09:38:30 -07004704 && desc->devicesSupportEncodedFormats({deviceType})) {
François Gaffie11d30102018-11-02 16:09:09 +01004705 ALOGV("checkOutputsForDevice(): adding opened output %d on device %s",
4706 mOutputs.keyAt(i), device->toString().c_str());
4707 outputs.add(mOutputs.keyAt(i));
Eric Laurente552edb2014-03-10 17:42:56 -07004708 }
4709 }
4710 // then look for output profiles that can be routed to this device
Eric Laurent1c333e22014-05-20 10:48:17 -07004711 SortedVector< sp<IOProfile> > profiles;
Mikhail Naganov7e22e942017-12-07 10:04:29 -08004712 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08004713 for (size_t j = 0; j < hwModule->getOutputProfiles().size(); j++) {
4714 sp<IOProfile> profile = hwModule->getOutputProfiles()[j];
François Gaffie11d30102018-11-02 16:09:09 +01004715 if (profile->supportsDevice(device)) {
4716 profiles.add(profile);
4717 ALOGV("checkOutputsForDevice(): adding profile %zu from module %s",
4718 j, hwModule->getName());
Eric Laurente552edb2014-03-10 17:42:56 -07004719 }
4720 }
4721 }
4722
Eric Laurent7b279bb2015-12-14 10:18:23 -08004723 ALOGV(" found %zu profiles, %zu outputs", profiles.size(), outputs.size());
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004724
Eric Laurente552edb2014-03-10 17:42:56 -07004725 if (profiles.isEmpty() && outputs.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01004726 ALOGW("checkOutputsForDevice(): No output available for device %04x", deviceType);
Eric Laurente552edb2014-03-10 17:42:56 -07004727 return BAD_VALUE;
4728 }
4729
4730 // open outputs for matching profiles if needed. Direct outputs are also opened to
4731 // query for dynamic parameters and will be closed later by setDeviceConnectionState()
4732 for (ssize_t profile_index = 0; profile_index < (ssize_t)profiles.size(); profile_index++) {
Eric Laurent1c333e22014-05-20 10:48:17 -07004733 sp<IOProfile> profile = profiles[profile_index];
Eric Laurente552edb2014-03-10 17:42:56 -07004734
4735 // nothing to do if one output is already opened for this profile
4736 size_t j;
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004737 for (j = 0; j < outputs.size(); j++) {
4738 desc = mOutputs.valueFor(outputs.itemAt(j));
Eric Laurente552edb2014-03-10 17:42:56 -07004739 if (!desc->isDuplicated() && desc->mProfile == profile) {
Jean-Michel Trivif17026d2014-08-10 14:30:48 -07004740 // matching profile: save the sample rates, format and channel masks supported
4741 // by the profile in our device descriptor
François Gaffie11d30102018-11-02 16:09:09 +01004742 if (audio_device_is_digital(deviceType)) {
jiabin4ef93452019-09-10 14:29:54 -07004743 device->importAudioPortAndPickAudioProfile(profile);
Paul McLean9080a4c2015-06-18 08:24:02 -07004744 }
Eric Laurente552edb2014-03-10 17:42:56 -07004745 break;
4746 }
4747 }
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004748 if (j != outputs.size()) {
Eric Laurente552edb2014-03-10 17:42:56 -07004749 continue;
4750 }
4751
Eric Laurent3974e3b2017-12-07 17:58:43 -08004752 if (!profile->canOpenNewIo()) {
4753 ALOGW("Max Output number %u already opened for this profile %s",
4754 profile->maxOpenCount, profile->getTagName().c_str());
4755 continue;
4756 }
4757
Eric Laurent83efe1c2017-07-09 16:51:08 -07004758 ALOGV("opening output for device %08x with params %s profile %p name %s",
jiabin5740f082019-08-19 15:08:30 -07004759 deviceType, address.string(), profile.get(), profile->getName().c_str());
Eric Laurentc75307b2015-03-17 15:29:32 -07004760 desc = new SwAudioOutputDescriptor(profile, mpClientInterface);
Eric Laurentcf2c0212014-07-25 16:20:43 -07004761 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
François Gaffie11d30102018-11-02 16:09:09 +01004762 status_t status = desc->open(nullptr, DeviceVector(device),
Eric Laurentfe231122017-11-17 17:48:06 -08004763 AUDIO_STREAM_DEFAULT, AUDIO_OUTPUT_FLAG_NONE, &output);
Eric Laurente552edb2014-03-10 17:42:56 -07004764
Eric Laurentfe231122017-11-17 17:48:06 -08004765 if (status == NO_ERROR) {
Eric Laurentd4692962014-05-05 18:13:44 -07004766 // Here is where the out_set_parameters() for card & device gets called
Eric Laurent3a4311c2014-03-17 12:00:47 -07004767 if (!address.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01004768 char *param = audio_device_address_to_parameter(deviceType, address);
Eric Laurentcf2c0212014-07-25 16:20:43 -07004769 mpClientInterface->setParameters(output, String8(param));
4770 free(param);
Eric Laurente552edb2014-03-10 17:42:56 -07004771 }
François Gaffie11d30102018-11-02 16:09:09 +01004772 updateAudioProfiles(device, output, profile->getAudioProfiles());
François Gaffie112b0af2015-11-19 16:13:25 +01004773 if (!profile->hasValidAudioProfile()) {
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004774 ALOGW("checkOutputsForDevice() missing param");
Eric Laurentfe231122017-11-17 17:48:06 -08004775 desc->close();
Eric Laurentcf2c0212014-07-25 16:20:43 -07004776 output = AUDIO_IO_HANDLE_NONE;
François Gaffie112b0af2015-11-19 16:13:25 +01004777 } else if (profile->hasDynamicAudioProfile()) {
Eric Laurentfe231122017-11-17 17:48:06 -08004778 desc->close();
Phil Burk702b1052016-03-02 16:38:26 -08004779 output = AUDIO_IO_HANDLE_NONE;
Eric Laurentfe231122017-11-17 17:48:06 -08004780 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
4781 profile->pickAudioProfile(
4782 config.sample_rate, config.channel_mask, config.format);
Eric Laurentcf2c0212014-07-25 16:20:43 -07004783 config.offload_info.sample_rate = config.sample_rate;
4784 config.offload_info.channel_mask = config.channel_mask;
4785 config.offload_info.format = config.format;
Eric Laurentfe231122017-11-17 17:48:06 -08004786
François Gaffie11d30102018-11-02 16:09:09 +01004787 status_t status = desc->open(&config, DeviceVector(device),
4788 AUDIO_STREAM_DEFAULT,
Eric Laurentfe231122017-11-17 17:48:06 -08004789 AUDIO_OUTPUT_FLAG_NONE, &output);
4790 if (status != NO_ERROR) {
Eric Laurentcf2c0212014-07-25 16:20:43 -07004791 output = AUDIO_IO_HANDLE_NONE;
4792 }
Eric Laurentd4692962014-05-05 18:13:44 -07004793 }
4794
Eric Laurentcf2c0212014-07-25 16:20:43 -07004795 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurente552edb2014-03-10 17:42:56 -07004796 addOutput(output, desc);
François Gaffie11d30102018-11-02 16:09:09 +01004797 if (device_distinguishes_on_address(deviceType) && address != "0") {
François Gaffie036e1e92015-03-19 10:16:24 +01004798 sp<AudioPolicyMix> policyMix;
Jean-Michel Trivi67917272019-05-22 11:54:37 -07004799 if (mPolicyMixes.getAudioPolicyMix(deviceType, address, policyMix)
4800 == NO_ERROR) {
François Gaffieb141c522018-03-12 11:47:40 +01004801 policyMix->setOutput(desc);
Mikhail Naganovbfac5832019-03-05 16:55:28 -08004802 desc->mPolicyMix = policyMix;
François Gaffieb141c522018-03-12 11:47:40 +01004803 } else {
4804 ALOGW("checkOutputsForDevice() cannot find policy for address %s",
Eric Laurent275e8e92014-11-30 15:14:47 -08004805 address.string());
4806 }
François Gaffie036e1e92015-03-19 10:16:24 +01004807
Eric Laurent87ffa392015-05-22 10:32:38 -07004808 } else if (((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) == 0) &&
4809 hasPrimaryOutput()) {
Eric Laurentc722f302014-12-10 11:21:49 -08004810 // no duplicated output for direct outputs and
4811 // outputs used by dynamic policy mixes
Eric Laurentcf2c0212014-07-25 16:20:43 -07004812 audio_io_handle_t duplicatedOutput = AUDIO_IO_HANDLE_NONE;
Eric Laurente552edb2014-03-10 17:42:56 -07004813
Eric Laurentd4692962014-05-05 18:13:44 -07004814 //TODO: configure audio effect output stage here
4815
4816 // open a duplicating output thread for the new output and the primary output
Eric Laurent5babc4f2018-02-15 12:33:44 -08004817 sp<SwAudioOutputDescriptor> dupOutputDesc =
4818 new SwAudioOutputDescriptor(NULL, mpClientInterface);
4819 status_t status = dupOutputDesc->openDuplicating(mPrimaryOutput, desc,
4820 &duplicatedOutput);
4821 if (status == NO_ERROR) {
Eric Laurentd4692962014-05-05 18:13:44 -07004822 // add duplicated output descriptor
Eric Laurentd4692962014-05-05 18:13:44 -07004823 addOutput(duplicatedOutput, dupOutputDesc);
Eric Laurentd4692962014-05-05 18:13:44 -07004824 } else {
4825 ALOGW("checkOutputsForDevice() could not open dup output for %d and %d",
Eric Laurentc75307b2015-03-17 15:29:32 -07004826 mPrimaryOutput->mIoHandle, output);
Eric Laurentfe231122017-11-17 17:48:06 -08004827 desc->close();
François Gaffie53615e22015-03-19 09:24:12 +01004828 removeOutput(output);
Eric Laurent6a94d692014-05-20 11:18:06 -07004829 nextAudioPortGeneration();
Eric Laurentcf2c0212014-07-25 16:20:43 -07004830 output = AUDIO_IO_HANDLE_NONE;
Eric Laurentd4692962014-05-05 18:13:44 -07004831 }
Eric Laurente552edb2014-03-10 17:42:56 -07004832 }
4833 }
Eric Laurentcf2c0212014-07-25 16:20:43 -07004834 } else {
4835 output = AUDIO_IO_HANDLE_NONE;
Eric Laurente552edb2014-03-10 17:42:56 -07004836 }
Eric Laurentcf2c0212014-07-25 16:20:43 -07004837 if (output == AUDIO_IO_HANDLE_NONE) {
François Gaffie11d30102018-11-02 16:09:09 +01004838 ALOGW("checkOutputsForDevice() could not open output for device %x", deviceType);
Eric Laurente552edb2014-03-10 17:42:56 -07004839 profiles.removeAt(profile_index);
4840 profile_index--;
4841 } else {
4842 outputs.add(output);
Paul McLean9080a4c2015-06-18 08:24:02 -07004843 // Load digital format info only for digital devices
François Gaffie11d30102018-11-02 16:09:09 +01004844 if (audio_device_is_digital(deviceType)) {
jiabin4ef93452019-09-10 14:29:54 -07004845 device->importAudioPortAndPickAudioProfile(profile);
Paul McLean9080a4c2015-06-18 08:24:02 -07004846 }
Jean-Michel Trivif17026d2014-08-10 14:30:48 -07004847
François Gaffie11d30102018-11-02 16:09:09 +01004848 if (device_distinguishes_on_address(deviceType)) {
4849 ALOGV("checkOutputsForDevice(): setOutputDevices %s",
4850 device->toString().c_str());
4851 setOutputDevices(desc, DeviceVector(device), true/*force*/, 0/*delay*/,
4852 NULL/*patch handle*/);
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004853 }
Eric Laurente552edb2014-03-10 17:42:56 -07004854 ALOGV("checkOutputsForDevice(): adding output %d", output);
4855 }
4856 }
4857
4858 if (profiles.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01004859 ALOGW("checkOutputsForDevice(): No output available for device %04x", deviceType);
Eric Laurente552edb2014-03-10 17:42:56 -07004860 return BAD_VALUE;
4861 }
Eric Laurentd4692962014-05-05 18:13:44 -07004862 } else { // Disconnect
Eric Laurente552edb2014-03-10 17:42:56 -07004863 // check if one opened output is not needed any more after disconnecting one device
4864 for (size_t i = 0; i < mOutputs.size(); i++) {
4865 desc = mOutputs.valueAt(i);
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004866 if (!desc->isDuplicated()) {
Eric Laurent275e8e92014-11-30 15:14:47 -08004867 // exact match on device
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08004868 if (device_distinguishes_on_address(deviceType) && desc->supportsDevice(device)
jiabin9a3361e2019-10-01 09:38:30 -07004869 && desc->devicesSupportEncodedFormats({deviceType})) {
François Gaffie11d30102018-11-02 16:09:09 +01004870 outputs.add(mOutputs.keyAt(i));
Francois Gaffie716e1432019-01-14 16:58:59 +01004871 } else if (!mAvailableOutputDevices.containsAtLeastOne(desc->supportedDevices())) {
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004872 ALOGV("checkOutputsForDevice(): disconnecting adding output %d",
4873 mOutputs.keyAt(i));
4874 outputs.add(mOutputs.keyAt(i));
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07004875 }
Eric Laurente552edb2014-03-10 17:42:56 -07004876 }
4877 }
Eric Laurentd4692962014-05-05 18:13:44 -07004878 // Clear any profiles associated with the disconnected device.
Mikhail Naganov7e22e942017-12-07 10:04:29 -08004879 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08004880 for (size_t j = 0; j < hwModule->getOutputProfiles().size(); j++) {
4881 sp<IOProfile> profile = hwModule->getOutputProfiles()[j];
François Gaffie11d30102018-11-02 16:09:09 +01004882 if (profile->supportsDevice(device)) {
Eric Laurentd4692962014-05-05 18:13:44 -07004883 ALOGV("checkOutputsForDevice(): "
Mikhail Naganovd4120142017-12-06 15:49:22 -08004884 "clearing direct output profile %zu on module %s",
4885 j, hwModule->getName());
François Gaffie112b0af2015-11-19 16:13:25 +01004886 profile->clearAudioProfiles();
Eric Laurente552edb2014-03-10 17:42:56 -07004887 }
4888 }
4889 }
4890 }
4891 return NO_ERROR;
4892}
4893
François Gaffie11d30102018-11-02 16:09:09 +01004894status_t AudioPolicyManager::checkInputsForDevice(const sp<DeviceDescriptor>& device,
Eric Laurent0dd51852019-04-19 18:18:58 -07004895 audio_policy_dev_state_t state)
Eric Laurentd4692962014-05-05 18:13:44 -07004896{
Eric Laurent1f2f2232014-06-02 12:01:23 -07004897 sp<AudioInputDescriptor> desc;
Eric Laurentcc750d32015-06-25 11:48:20 -07004898
François Gaffie11d30102018-11-02 16:09:09 +01004899 if (audio_device_is_digital(device->type())) {
Eric Laurentcc750d32015-06-25 11:48:20 -07004900 // erase all current sample rates, formats and channel masks
François Gaffie11d30102018-11-02 16:09:09 +01004901 device->clearAudioProfiles();
Eric Laurentcc750d32015-06-25 11:48:20 -07004902 }
4903
Eric Laurentd4692962014-05-05 18:13:44 -07004904 if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
Eric Laurent0dd51852019-04-19 18:18:58 -07004905 // look for input profiles that can be routed to this device
Eric Laurent1c333e22014-05-20 10:48:17 -07004906 SortedVector< sp<IOProfile> > profiles;
Mikhail Naganov7e22e942017-12-07 10:04:29 -08004907 for (const auto& hwModule : mHwModules) {
Eric Laurentd4692962014-05-05 18:13:44 -07004908 for (size_t profile_index = 0;
Mikhail Naganova5e165d2017-12-07 17:08:02 -08004909 profile_index < hwModule->getInputProfiles().size();
Mikhail Naganov7e22e942017-12-07 10:04:29 -08004910 profile_index++) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08004911 sp<IOProfile> profile = hwModule->getInputProfiles()[profile_index];
Eric Laurent275e8e92014-11-30 15:14:47 -08004912
François Gaffie11d30102018-11-02 16:09:09 +01004913 if (profile->supportsDevice(device)) {
4914 profiles.add(profile);
4915 ALOGV("checkInputsForDevice(): adding profile %zu from module %s",
4916 profile_index, hwModule->getName());
Eric Laurentd4692962014-05-05 18:13:44 -07004917 }
4918 }
4919 }
4920
Eric Laurent0dd51852019-04-19 18:18:58 -07004921 if (profiles.isEmpty()) {
4922 ALOGW("%s: No input profile available for device %s",
4923 __func__, device->toString().c_str());
Eric Laurentd4692962014-05-05 18:13:44 -07004924 return BAD_VALUE;
4925 }
4926
4927 // open inputs for matching profiles if needed. Direct inputs are also opened to
4928 // query for dynamic parameters and will be closed later by setDeviceConnectionState()
4929 for (ssize_t profile_index = 0; profile_index < (ssize_t)profiles.size(); profile_index++) {
4930
Eric Laurent1c333e22014-05-20 10:48:17 -07004931 sp<IOProfile> profile = profiles[profile_index];
Eric Laurent3974e3b2017-12-07 17:58:43 -08004932
Eric Laurentd4692962014-05-05 18:13:44 -07004933 // nothing to do if one input is already opened for this profile
4934 size_t input_index;
4935 for (input_index = 0; input_index < mInputs.size(); input_index++) {
4936 desc = mInputs.valueAt(input_index);
4937 if (desc->mProfile == profile) {
François Gaffie11d30102018-11-02 16:09:09 +01004938 if (audio_device_is_digital(device->type())) {
jiabin4ef93452019-09-10 14:29:54 -07004939 device->importAudioPortAndPickAudioProfile(profile);
Paul McLean9080a4c2015-06-18 08:24:02 -07004940 }
Eric Laurentd4692962014-05-05 18:13:44 -07004941 break;
4942 }
4943 }
4944 if (input_index != mInputs.size()) {
4945 continue;
4946 }
4947
Eric Laurent3974e3b2017-12-07 17:58:43 -08004948 if (!profile->canOpenNewIo()) {
4949 ALOGW("Max Input number %u already opened for this profile %s",
4950 profile->maxOpenCount, profile->getTagName().c_str());
4951 continue;
4952 }
4953
Eric Laurentfe231122017-11-17 17:48:06 -08004954 desc = new AudioInputDescriptor(profile, mpClientInterface);
Eric Laurentcf2c0212014-07-25 16:20:43 -07004955 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
Eric Laurentfe231122017-11-17 17:48:06 -08004956 status_t status = desc->open(nullptr,
4957 device,
Eric Laurentfe231122017-11-17 17:48:06 -08004958 AUDIO_SOURCE_MIC,
4959 AUDIO_INPUT_FLAG_NONE,
4960 &input);
Eric Laurentd4692962014-05-05 18:13:44 -07004961
Eric Laurentcf2c0212014-07-25 16:20:43 -07004962 if (status == NO_ERROR) {
jiabince9f20e2019-09-12 16:29:15 -07004963 const String8& address = String8(device->address().c_str());
Eric Laurentd4692962014-05-05 18:13:44 -07004964 if (!address.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01004965 char *param = audio_device_address_to_parameter(device->type(), address);
Eric Laurentcf2c0212014-07-25 16:20:43 -07004966 mpClientInterface->setParameters(input, String8(param));
4967 free(param);
Eric Laurentd4692962014-05-05 18:13:44 -07004968 }
François Gaffie11d30102018-11-02 16:09:09 +01004969 updateAudioProfiles(device, input, profile->getAudioProfiles());
François Gaffie112b0af2015-11-19 16:13:25 +01004970 if (!profile->hasValidAudioProfile()) {
Eric Laurentd4692962014-05-05 18:13:44 -07004971 ALOGW("checkInputsForDevice() direct input missing param");
Eric Laurentfe231122017-11-17 17:48:06 -08004972 desc->close();
Eric Laurentcf2c0212014-07-25 16:20:43 -07004973 input = AUDIO_IO_HANDLE_NONE;
Eric Laurentd4692962014-05-05 18:13:44 -07004974 }
4975
Eric Laurent0dd51852019-04-19 18:18:58 -07004976 if (input != AUDIO_IO_HANDLE_NONE) {
Eric Laurentd4692962014-05-05 18:13:44 -07004977 addInput(input, desc);
4978 }
4979 } // endif input != 0
4980
Eric Laurentcf2c0212014-07-25 16:20:43 -07004981 if (input == AUDIO_IO_HANDLE_NONE) {
François Gaffie11d30102018-11-02 16:09:09 +01004982 ALOGW("%s could not open input for device %s", __func__,
4983 device->toString().c_str());
Eric Laurentd4692962014-05-05 18:13:44 -07004984 profiles.removeAt(profile_index);
4985 profile_index--;
4986 } else {
François Gaffie11d30102018-11-02 16:09:09 +01004987 if (audio_device_is_digital(device->type())) {
jiabin4ef93452019-09-10 14:29:54 -07004988 device->importAudioPortAndPickAudioProfile(profile);
Paul McLean9080a4c2015-06-18 08:24:02 -07004989 }
Eric Laurentd4692962014-05-05 18:13:44 -07004990 ALOGV("checkInputsForDevice(): adding input %d", input);
4991 }
4992 } // end scan profiles
4993
4994 if (profiles.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01004995 ALOGW("%s: No input available for device %s", __func__, device->toString().c_str());
Eric Laurentd4692962014-05-05 18:13:44 -07004996 return BAD_VALUE;
4997 }
4998 } else {
4999 // Disconnect
Eric Laurentd4692962014-05-05 18:13:44 -07005000 // Clear any profiles associated with the disconnected device.
Mikhail Naganovd4120142017-12-06 15:49:22 -08005001 for (const auto& hwModule : mHwModules) {
Eric Laurentd4692962014-05-05 18:13:44 -07005002 for (size_t profile_index = 0;
Mikhail Naganova5e165d2017-12-07 17:08:02 -08005003 profile_index < hwModule->getInputProfiles().size();
Eric Laurentd4692962014-05-05 18:13:44 -07005004 profile_index++) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08005005 sp<IOProfile> profile = hwModule->getInputProfiles()[profile_index];
Francois Gaffie716e1432019-01-14 16:58:59 +01005006 if (profile->supportsDevice(device)) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08005007 ALOGV("checkInputsForDevice(): clearing direct input profile %zu on module %s",
5008 profile_index, hwModule->getName());
François Gaffie112b0af2015-11-19 16:13:25 +01005009 profile->clearAudioProfiles();
Eric Laurentd4692962014-05-05 18:13:44 -07005010 }
5011 }
5012 }
5013 } // end disconnect
5014
5015 return NO_ERROR;
5016}
5017
5018
Eric Laurente0720872014-03-11 09:30:41 -07005019void AudioPolicyManager::closeOutput(audio_io_handle_t output)
Eric Laurente552edb2014-03-10 17:42:56 -07005020{
5021 ALOGV("closeOutput(%d)", output);
5022
François Gaffie1c878552018-11-22 16:53:21 +01005023 sp<SwAudioOutputDescriptor> closingOutput = mOutputs.valueFor(output);
5024 if (closingOutput == NULL) {
Eric Laurente552edb2014-03-10 17:42:56 -07005025 ALOGW("closeOutput() unknown output %d", output);
5026 return;
5027 }
Mikhail Naganov32ebca32019-03-22 15:42:52 -07005028 const bool closingOutputWasActive = closingOutput->isActive();
François Gaffie1c878552018-11-22 16:53:21 +01005029 mPolicyMixes.closeOutput(closingOutput);
Eric Laurent275e8e92014-11-30 15:14:47 -08005030
Eric Laurente552edb2014-03-10 17:42:56 -07005031 // look for duplicated outputs connected to the output being removed.
5032 for (size_t i = 0; i < mOutputs.size(); i++) {
François Gaffie1c878552018-11-22 16:53:21 +01005033 sp<SwAudioOutputDescriptor> dupOutput = mOutputs.valueAt(i);
5034 if (dupOutput->isDuplicated() &&
5035 (dupOutput->mOutput1 == closingOutput || dupOutput->mOutput2 == closingOutput)) {
5036 sp<SwAudioOutputDescriptor> remainingOutput =
5037 dupOutput->mOutput1 == closingOutput ? dupOutput->mOutput2 : dupOutput->mOutput1;
Eric Laurente552edb2014-03-10 17:42:56 -07005038 // As all active tracks on duplicated output will be deleted,
5039 // and as they were also referenced on the other output, the reference
5040 // count for their stream type must be adjusted accordingly on
5041 // the other output.
François Gaffie1c878552018-11-22 16:53:21 +01005042 const bool wasActive = remainingOutput->isActive();
5043 // Note: no-op on the closing output where all clients has already been set inactive
5044 dupOutput->setAllClientsInactive();
Eric Laurent733ce942017-12-07 12:18:25 -08005045 // stop() will be a no op if the output is still active but is needed in case all
5046 // active streams refcounts where cleared above
5047 if (wasActive) {
François Gaffie1c878552018-11-22 16:53:21 +01005048 remainingOutput->stop();
Eric Laurent733ce942017-12-07 12:18:25 -08005049 }
Eric Laurente552edb2014-03-10 17:42:56 -07005050 audio_io_handle_t duplicatedOutput = mOutputs.keyAt(i);
5051 ALOGV("closeOutput() closing also duplicated output %d", duplicatedOutput);
5052
5053 mpClientInterface->closeOutput(duplicatedOutput);
François Gaffie53615e22015-03-19 09:24:12 +01005054 removeOutput(duplicatedOutput);
Eric Laurente552edb2014-03-10 17:42:56 -07005055 }
5056 }
5057
Eric Laurent05b90f82014-08-27 15:32:29 -07005058 nextAudioPortGeneration();
5059
François Gaffie1c878552018-11-22 16:53:21 +01005060 ssize_t index = mAudioPatches.indexOfKey(closingOutput->getPatchHandle());
Eric Laurent05b90f82014-08-27 15:32:29 -07005061 if (index >= 0) {
5062 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
Glenn Kastenfcddb0b2016-07-08 17:19:25 -07005063 (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
Eric Laurent05b90f82014-08-27 15:32:29 -07005064 mAudioPatches.removeItemsAt(index);
5065 mpClientInterface->onAudioPatchListUpdate();
5066 }
5067
Mikhail Naganov32ebca32019-03-22 15:42:52 -07005068 if (closingOutputWasActive) {
5069 closingOutput->stop();
5070 }
François Gaffie1c878552018-11-22 16:53:21 +01005071 closingOutput->close();
Eric Laurente552edb2014-03-10 17:42:56 -07005072
François Gaffie53615e22015-03-19 09:24:12 +01005073 removeOutput(output);
Eric Laurente552edb2014-03-10 17:42:56 -07005074 mPreviousOutputs = mOutputs;
Dean Wheatley3023b382018-08-09 07:42:40 +10005075
5076 // MSD patches may have been released to support a non-MSD direct output. Reset MSD patch if
5077 // no direct outputs are open.
François Gaffie11d30102018-11-02 16:09:09 +01005078 if (!getMsdAudioOutDevices().isEmpty()) {
Dean Wheatley3023b382018-08-09 07:42:40 +10005079 bool directOutputOpen = false;
5080 for (size_t i = 0; i < mOutputs.size(); i++) {
5081 if (mOutputs[i]->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
5082 directOutputOpen = true;
5083 break;
5084 }
5085 }
5086 if (!directOutputOpen) {
5087 ALOGV("no direct outputs open, reset MSD patch");
5088 setMsdPatch();
5089 }
5090 }
Eric Laurent05b90f82014-08-27 15:32:29 -07005091}
5092
5093void AudioPolicyManager::closeInput(audio_io_handle_t input)
5094{
5095 ALOGV("closeInput(%d)", input);
5096
5097 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
5098 if (inputDesc == NULL) {
5099 ALOGW("closeInput() unknown input %d", input);
5100 return;
5101 }
5102
Eric Laurent6a94d692014-05-20 11:18:06 -07005103 nextAudioPortGeneration();
Eric Laurent05b90f82014-08-27 15:32:29 -07005104
François Gaffie11d30102018-11-02 16:09:09 +01005105 sp<DeviceDescriptor> device = inputDesc->getDevice();
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08005106 ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent05b90f82014-08-27 15:32:29 -07005107 if (index >= 0) {
5108 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
Glenn Kastenfcddb0b2016-07-08 17:19:25 -07005109 (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
Eric Laurent05b90f82014-08-27 15:32:29 -07005110 mAudioPatches.removeItemsAt(index);
5111 mpClientInterface->onAudioPatchListUpdate();
5112 }
5113
Eric Laurentfe231122017-11-17 17:48:06 -08005114 inputDesc->close();
Eric Laurent05b90f82014-08-27 15:32:29 -07005115 mInputs.removeItem(input);
Haynes Mathew George1d539d92018-03-16 11:40:49 -07005116
François Gaffie11d30102018-11-02 16:09:09 +01005117 DeviceVector primaryInputDevices = availablePrimaryModuleInputDevices();
5118 if (primaryInputDevices.contains(device) &&
Haynes Mathew George1d539d92018-03-16 11:40:49 -07005119 mInputs.activeInputsCountOnDevices(primaryInputDevices) == 0) {
Ytai Ben-Tsvi74cd6b02019-10-25 10:06:40 -07005120 mpClientInterface->setSoundTriggerCaptureState(false);
Haynes Mathew George1d539d92018-03-16 11:40:49 -07005121 }
Eric Laurente552edb2014-03-10 17:42:56 -07005122}
5123
François Gaffie11d30102018-11-02 16:09:09 +01005124SortedVector<audio_io_handle_t> AudioPolicyManager::getOutputsForDevices(
5125 const DeviceVector &devices,
5126 const SwAudioOutputCollection& openOutputs)
Eric Laurente552edb2014-03-10 17:42:56 -07005127{
5128 SortedVector<audio_io_handle_t> outputs;
5129
François Gaffie11d30102018-11-02 16:09:09 +01005130 ALOGVV("%s() devices %s", __func__, devices.toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -07005131 for (size_t i = 0; i < openOutputs.size(); i++) {
François Gaffie11d30102018-11-02 16:09:09 +01005132 ALOGVV("output %zu isDuplicated=%d device=%s",
Eric Laurent8c7e6da2015-04-21 17:37:00 -07005133 i, openOutputs.valueAt(i)->isDuplicated(),
François Gaffie11d30102018-11-02 16:09:09 +01005134 openOutputs.valueAt(i)->supportedDevices().toString().c_str());
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005135 if (openOutputs.valueAt(i)->supportsAllDevices(devices)
jiabin9a3361e2019-10-01 09:38:30 -07005136 && openOutputs.valueAt(i)->devicesSupportEncodedFormats(devices.types())) {
François Gaffie11d30102018-11-02 16:09:09 +01005137 ALOGVV("%s() found output %d", __func__, openOutputs.keyAt(i));
Eric Laurente552edb2014-03-10 17:42:56 -07005138 outputs.add(openOutputs.keyAt(i));
5139 }
5140 }
5141 return outputs;
5142}
5143
Mikhail Naganov37977152018-07-11 15:54:44 -07005144void AudioPolicyManager::checkForDeviceAndOutputChanges(std::function<bool()> onOutputsChecked)
5145{
5146 // checkA2dpSuspend must run before checkOutputForAllStrategies so that A2DP
5147 // output is suspended before any tracks are moved to it
5148 checkA2dpSuspend();
5149 checkOutputForAllStrategies();
Kevin Rocard153f92d2018-12-18 18:33:28 -08005150 checkSecondaryOutputs();
Mikhail Naganov15be9d22017-11-08 14:18:13 +11005151 if (onOutputsChecked != nullptr && onOutputsChecked()) checkA2dpSuspend();
Mikhail Naganov37977152018-07-11 15:54:44 -07005152 updateDevicesAndOutputs();
Mikhail Naganov7bd9b8d2018-11-15 02:09:03 +00005153 if (mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD) != 0) {
Mikhail Naganov15be9d22017-11-08 14:18:13 +11005154 setMsdPatch();
5155 }
Mikhail Naganov37977152018-07-11 15:54:44 -07005156}
5157
François Gaffiec005e562018-11-06 15:04:49 +01005158bool AudioPolicyManager::followsSameRouting(const audio_attributes_t &lAttr,
5159 const audio_attributes_t &rAttr) const
Eric Laurente552edb2014-03-10 17:42:56 -07005160{
François Gaffiec005e562018-11-06 15:04:49 +01005161 return mEngine->getProductStrategyForAttributes(lAttr) ==
5162 mEngine->getProductStrategyForAttributes(rAttr);
5163}
5164
5165void AudioPolicyManager::checkOutputForAttributes(const audio_attributes_t &attr)
5166{
5167 auto psId = mEngine->getProductStrategyForAttributes(attr);
5168
5169 DeviceVector oldDevices = mEngine->getOutputDevicesForAttributes(attr, 0, true /*fromCache*/);
5170 DeviceVector newDevices = mEngine->getOutputDevicesForAttributes(attr, 0, false /*fromCache*/);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07005171
François Gaffie11d30102018-11-02 16:09:09 +01005172 SortedVector<audio_io_handle_t> srcOutputs = getOutputsForDevices(oldDevices, mPreviousOutputs);
5173 SortedVector<audio_io_handle_t> dstOutputs = getOutputsForDevices(newDevices, mOutputs);
Eric Laurente552edb2014-03-10 17:42:56 -07005174
Jean-Michel Trivife472e22014-12-16 14:23:13 -08005175 // also take into account external policy-related changes: add all outputs which are
5176 // associated with policies in the "before" and "after" output vectors
François Gaffiec005e562018-11-06 15:04:49 +01005177 ALOGVV("%s(): policy related outputs", __func__);
Eric Laurentaa02db82019-09-05 17:31:49 -07005178 bool hasDynamicPolicy = false;
Jean-Michel Trivife472e22014-12-16 14:23:13 -08005179 for (size_t i = 0 ; i < mPreviousOutputs.size() ; i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -07005180 const sp<SwAudioOutputDescriptor> desc = mPreviousOutputs.valueAt(i);
Jean-Michel Trivife472e22014-12-16 14:23:13 -08005181 if (desc != 0 && desc->mPolicyMix != NULL) {
5182 srcOutputs.add(desc->mIoHandle);
Eric Laurentaa02db82019-09-05 17:31:49 -07005183 hasDynamicPolicy = true;
Jean-Michel Trivife472e22014-12-16 14:23:13 -08005184 ALOGVV(" previous outputs: adding %d", desc->mIoHandle);
5185 }
5186 }
5187 for (size_t i = 0 ; i < mOutputs.size() ; i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -07005188 const sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Jean-Michel Trivife472e22014-12-16 14:23:13 -08005189 if (desc != 0 && desc->mPolicyMix != NULL) {
5190 dstOutputs.add(desc->mIoHandle);
Eric Laurentaa02db82019-09-05 17:31:49 -07005191 hasDynamicPolicy = true;
Jean-Michel Trivife472e22014-12-16 14:23:13 -08005192 ALOGVV(" new outputs: adding %d", desc->mIoHandle);
5193 }
5194 }
5195
François Gaffiec005e562018-11-06 15:04:49 +01005196 if (srcOutputs != dstOutputs) {
Eric Laurentac3a6902018-05-11 16:39:10 -07005197 // get maximum latency of all source outputs to determine the minimum mute time guaranteeing
5198 // audio from invalidated tracks will be rendered when unmuting
5199 uint32_t maxLatency = 0;
Eric Laurentaa02db82019-09-05 17:31:49 -07005200 bool invalidate = hasDynamicPolicy;
Eric Laurentac3a6902018-05-11 16:39:10 -07005201 for (audio_io_handle_t srcOut : srcOutputs) {
5202 sp<SwAudioOutputDescriptor> desc = mPreviousOutputs.valueFor(srcOut);
Eric Laurentaa02db82019-09-05 17:31:49 -07005203 if (desc == nullptr) continue;
5204
5205 if (desc->isStrategyActive(psId) && maxLatency < desc->latency()) {
Eric Laurentac3a6902018-05-11 16:39:10 -07005206 maxLatency = desc->latency();
5207 }
Eric Laurentaa02db82019-09-05 17:31:49 -07005208
5209 if (invalidate) continue;
5210
5211 for (auto client : desc->clientsList(false /*activeOnly*/)) {
Eric Laurent78aade82019-09-13 18:55:08 -07005212 if (desc->isDuplicated() || !desc->mProfile->isDirectOutput()) {
Eric Laurentaa02db82019-09-05 17:31:49 -07005213 // a client on a non direct outputs has necessarily a linear PCM format
5214 // so we can call selectOutput() safely
5215 const audio_io_handle_t newOutput = selectOutput(dstOutputs,
5216 client->flags(),
5217 client->config().format,
5218 client->config().channel_mask,
5219 client->config().sample_rate);
5220 if (newOutput != srcOut) {
5221 invalidate = true;
5222 break;
5223 }
5224 } else {
5225 sp<IOProfile> profile = getProfileForOutput(newDevices,
5226 client->config().sample_rate,
5227 client->config().format,
5228 client->config().channel_mask,
5229 client->flags(),
5230 true /* directOnly */);
5231 if (profile != desc->mProfile) {
5232 invalidate = true;
5233 break;
5234 }
5235 }
5236 }
Eric Laurentac3a6902018-05-11 16:39:10 -07005237 }
Eric Laurentaa02db82019-09-05 17:31:49 -07005238
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005239 ALOGV_IF(!(srcOutputs.isEmpty() || dstOutputs.isEmpty()),
François Gaffiec005e562018-11-06 15:04:49 +01005240 "%s: strategy %d, moving from output %s to output %s", __func__, psId,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005241 std::to_string(srcOutputs[0]).c_str(),
5242 std::to_string(dstOutputs[0]).c_str());
Eric Laurente552edb2014-03-10 17:42:56 -07005243 // mute strategy while moving tracks from one output to another
Mikhail Naganovcf84e592017-12-07 11:25:11 -08005244 for (audio_io_handle_t srcOut : srcOutputs) {
Eric Laurentac3a6902018-05-11 16:39:10 -07005245 sp<SwAudioOutputDescriptor> desc = mPreviousOutputs.valueFor(srcOut);
Eric Laurentaa02db82019-09-05 17:31:49 -07005246 if (desc == nullptr) continue;
5247
5248 if (desc->isStrategyActive(psId)) {
François Gaffiec005e562018-11-06 15:04:49 +01005249 setStrategyMute(psId, true, desc);
5250 setStrategyMute(psId, false, desc, maxLatency * LATENCY_MUTE_FACTOR,
François Gaffie11d30102018-11-02 16:09:09 +01005251 newDevices.types());
Eric Laurente552edb2014-03-10 17:42:56 -07005252 }
François Gaffiec005e562018-11-06 15:04:49 +01005253 sp<SourceClientDescriptor> source = getSourceForAttributesOnOutput(srcOut, attr);
Eric Laurentd60560a2015-04-10 11:31:20 -07005254 if (source != 0){
5255 connectAudioSource(source);
5256 }
Eric Laurente552edb2014-03-10 17:42:56 -07005257 }
5258
François Gaffiec005e562018-11-06 15:04:49 +01005259 // Move effects associated to this stream from previous output to new output
5260 if (followsSameRouting(attr, attributes_initializer(AUDIO_USAGE_MEDIA))) {
Eric Laurent36829f92017-04-07 19:04:42 -07005261 selectOutputForMusicEffects();
Eric Laurente552edb2014-03-10 17:42:56 -07005262 }
François Gaffiec005e562018-11-06 15:04:49 +01005263 // Move tracks associated to this stream (and linked) from previous output to new output
Eric Laurentaa02db82019-09-05 17:31:49 -07005264 if (invalidate) {
5265 for (auto stream : mEngine->getStreamTypesForProductStrategy(psId)) {
5266 mpClientInterface->invalidateStream(stream);
5267 }
Eric Laurente552edb2014-03-10 17:42:56 -07005268 }
5269 }
5270}
5271
Eric Laurente0720872014-03-11 09:30:41 -07005272void AudioPolicyManager::checkOutputForAllStrategies()
Eric Laurente552edb2014-03-10 17:42:56 -07005273{
François Gaffiec005e562018-11-06 15:04:49 +01005274 for (const auto &strategy : mEngine->getOrderedProductStrategies()) {
5275 auto attributes = mEngine->getAllAttributesForProductStrategy(strategy).front();
5276 checkOutputForAttributes(attributes);
5277 }
Eric Laurente552edb2014-03-10 17:42:56 -07005278}
5279
Kevin Rocard153f92d2018-12-18 18:33:28 -08005280void AudioPolicyManager::checkSecondaryOutputs() {
5281 std::set<audio_stream_type_t> streamsToInvalidate;
5282 for (size_t i = 0; i < mOutputs.size(); i++) {
5283 const sp<SwAudioOutputDescriptor>& outputDescriptor = mOutputs[i];
5284 for (const sp<TrackClientDescriptor>& client : outputDescriptor->getClientIterable()) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08005285 sp<SwAudioOutputDescriptor> desc;
5286 std::vector<sp<SwAudioOutputDescriptor>> secondaryDescs;
Kevin Rocard94114a22019-04-01 19:38:23 -07005287 status_t status = mPolicyMixes.getOutputForAttr(client->attributes(), client->uid(),
5288 client->flags(), desc, &secondaryDescs);
5289 if (status != OK ||
5290 !std::equal(client->getSecondaryOutputs().begin(),
Kevin Rocard153f92d2018-12-18 18:33:28 -08005291 client->getSecondaryOutputs().end(),
5292 secondaryDescs.begin(), secondaryDescs.end())) {
5293 streamsToInvalidate.insert(client->stream());
5294 }
5295 }
5296 }
5297 for (audio_stream_type_t stream : streamsToInvalidate) {
5298 ALOGD("%s Invalidate stream %d due to secondary output change", __func__, stream);
5299 mpClientInterface->invalidateStream(stream);
5300 }
5301}
5302
Eric Laurente0720872014-03-11 09:30:41 -07005303void AudioPolicyManager::checkA2dpSuspend()
Eric Laurente552edb2014-03-10 17:42:56 -07005304{
François Gaffie53615e22015-03-19 09:24:12 +01005305 audio_io_handle_t a2dpOutput = mOutputs.getA2dpOutput();
Aniket Kumar Lataa8ee9962018-01-31 20:24:23 -08005306 if (a2dpOutput == 0 || mOutputs.isA2dpOffloadedOnPrimary()) {
Eric Laurent3a4311c2014-03-17 12:00:47 -07005307 mA2dpSuspended = false;
Eric Laurente552edb2014-03-10 17:42:56 -07005308 return;
5309 }
5310
Eric Laurent3a4311c2014-03-17 12:00:47 -07005311 bool isScoConnected =
jiabin9a3361e2019-10-01 09:38:30 -07005312 (mAvailableInputDevices.types().count(AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) != 0 ||
5313 !Intersection(mAvailableOutputDevices.types(), getAudioDeviceOutAllScoSet()).empty());
Eric Laurentf732e072016-08-03 19:30:28 -07005314
5315 // if suspended, restore A2DP output if:
5316 // ((SCO device is NOT connected) ||
5317 // ((forced usage communication is NOT SCO) && (forced usage for record is NOT SCO) &&
5318 // (phone state is NOT in call) && (phone state is NOT ringing)))
Eric Laurente552edb2014-03-10 17:42:56 -07005319 //
Eric Laurentf732e072016-08-03 19:30:28 -07005320 // if not suspended, suspend A2DP output if:
5321 // (SCO device is connected) &&
5322 // ((forced usage for communication is SCO) || (forced usage for record is SCO) ||
5323 // ((phone state is in call) || (phone state is ringing)))
Eric Laurente552edb2014-03-10 17:42:56 -07005324 //
5325 if (mA2dpSuspended) {
Eric Laurentf732e072016-08-03 19:30:28 -07005326 if (!isScoConnected ||
5327 ((mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION) !=
5328 AUDIO_POLICY_FORCE_BT_SCO) &&
5329 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_RECORD) !=
5330 AUDIO_POLICY_FORCE_BT_SCO) &&
5331 (mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) &&
François Gaffie2110e042015-03-24 08:41:51 +01005332 (mEngine->getPhoneState() != AUDIO_MODE_RINGTONE))) {
Eric Laurente552edb2014-03-10 17:42:56 -07005333
5334 mpClientInterface->restoreOutput(a2dpOutput);
5335 mA2dpSuspended = false;
5336 }
5337 } else {
Eric Laurentf732e072016-08-03 19:30:28 -07005338 if (isScoConnected &&
5339 ((mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION) ==
5340 AUDIO_POLICY_FORCE_BT_SCO) ||
5341 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_RECORD) ==
5342 AUDIO_POLICY_FORCE_BT_SCO) ||
5343 (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL) ||
François Gaffie2110e042015-03-24 08:41:51 +01005344 (mEngine->getPhoneState() == AUDIO_MODE_RINGTONE))) {
Eric Laurente552edb2014-03-10 17:42:56 -07005345
5346 mpClientInterface->suspendOutput(a2dpOutput);
5347 mA2dpSuspended = true;
5348 }
5349 }
5350}
5351
François Gaffie11d30102018-11-02 16:09:09 +01005352DeviceVector AudioPolicyManager::getNewOutputDevices(const sp<SwAudioOutputDescriptor>& outputDesc,
5353 bool fromCache)
Eric Laurente552edb2014-03-10 17:42:56 -07005354{
François Gaffie11d30102018-11-02 16:09:09 +01005355 DeviceVector devices;
5356
Jean-Michel Triviff155c62016-02-26 12:07:16 -08005357 ssize_t index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07005358 if (index >= 0) {
5359 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
5360 if (patchDesc->mUid != mUidCached) {
François Gaffie11d30102018-11-02 16:09:09 +01005361 ALOGV("%s device %s forced by patch %d", __func__,
5362 outputDesc->devices().toString().c_str(), outputDesc->getPatchHandle());
5363 return outputDesc->devices();
Eric Laurent6a94d692014-05-20 11:18:06 -07005364 }
5365 }
5366
Eric Laurent97ac8712018-07-27 18:59:02 -07005367 // Honor explicit routing requests only if no client using default routing is active on this
5368 // input: a specific app can not force routing for other apps by setting a preferred device.
5369 bool active; // unused
François Gaffie11d30102018-11-02 16:09:09 +01005370 sp<DeviceDescriptor> device =
François Gaffiec005e562018-11-06 15:04:49 +01005371 findPreferredDevice(outputDesc, PRODUCT_STRATEGY_NONE, active, mAvailableOutputDevices);
François Gaffie11d30102018-11-02 16:09:09 +01005372 if (device != nullptr) {
5373 return DeviceVector(device);
Eric Laurentf3a5a602018-05-22 18:42:55 -07005374 }
5375
François Gaffiea807ef92018-11-05 10:44:33 +01005376 // Legacy Engine cannot take care of bus devices and mix, so we need to handle the conflict
5377 // of setForceUse / Default Bus device here
5378 device = mPolicyMixes.getDeviceAndMixForOutput(outputDesc, mAvailableOutputDevices);
5379 if (device != nullptr) {
5380 return DeviceVector(device);
5381 }
5382
François Gaffiec005e562018-11-06 15:04:49 +01005383 for (const auto &productStrategy : mEngine->getOrderedProductStrategies()) {
5384 StreamTypeVector streams = mEngine->getStreamTypesForProductStrategy(productStrategy);
5385 auto attr = mEngine->getAllAttributesForProductStrategy(productStrategy).front();
Eric Laurent484e9272018-06-07 17:29:23 -07005386
François Gaffiec005e562018-11-06 15:04:49 +01005387 if ((hasVoiceStream(streams) &&
Henrik Backlund019c1732019-09-30 14:48:38 +02005388 (isInCall() || mOutputs.isStrategyActiveOnSameModule(productStrategy, outputDesc)) &&
5389 !isStreamActive(AUDIO_STREAM_ENFORCED_AUDIBLE, 0)) ||
Eric Laurentf23a7712019-02-28 17:15:40 -08005390 ((hasStream(streams, AUDIO_STREAM_ALARM) || hasStream(streams, AUDIO_STREAM_ENFORCED_AUDIBLE)) &&
François Gaffiec005e562018-11-06 15:04:49 +01005391 mOutputs.isStrategyActiveOnSameModule(productStrategy, outputDesc)) ||
5392 outputDesc->isStrategyActive(productStrategy)) {
5393 // Retrieval of devices for voice DL is done on primary output profile, cannot
5394 // check the route (would force modifying configuration file for this profile)
5395 devices = mEngine->getOutputDevicesForAttributes(attr, nullptr, fromCache);
5396 break;
5397 }
Eric Laurente552edb2014-03-10 17:42:56 -07005398 }
François Gaffiec005e562018-11-06 15:04:49 +01005399 ALOGV("%s selected devices %s", __func__, devices.toString().c_str());
François Gaffie11d30102018-11-02 16:09:09 +01005400 return devices;
Eric Laurent1c333e22014-05-20 10:48:17 -07005401}
5402
François Gaffie11d30102018-11-02 16:09:09 +01005403sp<DeviceDescriptor> AudioPolicyManager::getNewInputDevice(
5404 const sp<AudioInputDescriptor>& inputDesc)
Eric Laurent1c333e22014-05-20 10:48:17 -07005405{
François Gaffie11d30102018-11-02 16:09:09 +01005406 sp<DeviceDescriptor> device;
Eric Laurent6a94d692014-05-20 11:18:06 -07005407
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08005408 ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07005409 if (index >= 0) {
5410 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
5411 if (patchDesc->mUid != mUidCached) {
François Gaffie11d30102018-11-02 16:09:09 +01005412 ALOGV("getNewInputDevice() device %s forced by patch %d",
5413 inputDesc->getDevice()->toString().c_str(), inputDesc->getPatchHandle());
5414 return inputDesc->getDevice();
Eric Laurent6a94d692014-05-20 11:18:06 -07005415 }
5416 }
5417
Eric Laurent97ac8712018-07-27 18:59:02 -07005418 // Honor explicit routing requests only if no client using default routing is active on this
5419 // input: a specific app can not force routing for other apps by setting a preferred device.
5420 bool active;
François Gaffie11d30102018-11-02 16:09:09 +01005421 device = findPreferredDevice(inputDesc, AUDIO_SOURCE_DEFAULT, active, mAvailableInputDevices);
5422 if (device != nullptr) {
5423 return device;
Eric Laurent97ac8712018-07-27 18:59:02 -07005424 }
5425
Eric Laurentdc95a252018-04-12 12:46:56 -07005426 // If we are not in call and no client is active on this input, this methods returns
Andy Hungf024a9e2019-01-30 16:01:02 -08005427 // a null sp<>, causing the patch on the input stream to be released.
Francois Gaffie716e1432019-01-14 16:58:59 +01005428 audio_attributes_t attributes = inputDesc->getHighestPriorityAttributes();
5429 if (attributes.source == AUDIO_SOURCE_DEFAULT && isInCall()) {
5430 attributes.source = AUDIO_SOURCE_VOICE_COMMUNICATION;
Eric Laurentdc95a252018-04-12 12:46:56 -07005431 }
Francois Gaffie716e1432019-01-14 16:58:59 +01005432 if (attributes.source != AUDIO_SOURCE_DEFAULT) {
François Gaffiec005e562018-11-06 15:04:49 +01005433 device = mEngine->getInputDeviceForAttributes(attributes);
Eric Laurentfb66dd92016-01-28 18:32:03 -08005434 }
Eric Laurent1c333e22014-05-20 10:48:17 -07005435
Eric Laurente552edb2014-03-10 17:42:56 -07005436 return device;
5437}
5438
Eric Laurent794fde22016-03-11 09:50:45 -08005439bool AudioPolicyManager::streamsMatchForvolume(audio_stream_type_t stream1,
5440 audio_stream_type_t stream2) {
Jean-Michel Trivi99bb2f92016-11-23 15:52:07 -08005441 return (stream1 == stream2);
Eric Laurent28d09f02016-03-08 10:43:05 -08005442}
5443
Eric Laurente0720872014-03-11 09:30:41 -07005444audio_devices_t AudioPolicyManager::getDevicesForStream(audio_stream_type_t stream) {
Eric Laurente552edb2014-03-10 17:42:56 -07005445 // By checking the range of stream before calling getStrategy, we avoid
François Gaffiec005e562018-11-06 15:04:49 +01005446 // getOutputDevicesForStream's behavior for invalid streams.
5447 // engine's getOutputDevicesForStream would fallback on its default behavior (most probably
5448 // device for music stream), but we want to return the empty set.
5449 if (stream < AUDIO_STREAM_MIN || stream >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent6a94d692014-05-20 11:18:06 -07005450 return AUDIO_DEVICE_NONE;
5451 }
François Gaffie11d30102018-11-02 16:09:09 +01005452 DeviceVector activeDevices;
5453 DeviceVector devices;
François Gaffiec005e562018-11-06 15:04:49 +01005454 for (audio_stream_type_t curStream = AUDIO_STREAM_MIN; curStream < AUDIO_STREAM_PUBLIC_CNT;
5455 curStream = (audio_stream_type_t) (curStream + 1)) {
5456 if (!streamsMatchForvolume(stream, curStream)) {
Eric Laurent28d09f02016-03-08 10:43:05 -08005457 continue;
Eric Laurent6a94d692014-05-20 11:18:06 -07005458 }
François Gaffiec005e562018-11-06 15:04:49 +01005459 DeviceVector curDevices = mEngine->getOutputDevicesForStream(curStream, false/*fromCache*/);
François Gaffie11d30102018-11-02 16:09:09 +01005460 devices.merge(curDevices);
5461 for (audio_io_handle_t output : getOutputsForDevices(curDevices, mOutputs)) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08005462 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
Eric Laurent83d17c22019-04-02 17:10:01 -07005463 if (outputDesc->isActive(toVolumeSource(curStream))) {
François Gaffie11d30102018-11-02 16:09:09 +01005464 activeDevices.merge(outputDesc->devices());
Eric Laurent28d09f02016-03-08 10:43:05 -08005465 }
5466 }
Eric Laurente552edb2014-03-10 17:42:56 -07005467 }
Jon Eklund11c9fb12014-06-23 14:47:03 -05005468
Eric Laurentb0688d62018-08-14 15:49:18 -07005469 // Favor devices selected on active streams if any to report correct device in case of
5470 // explicit device selection
François Gaffie11d30102018-11-02 16:09:09 +01005471 if (!activeDevices.isEmpty()) {
Eric Laurentb0688d62018-08-14 15:49:18 -07005472 devices = activeDevices;
5473 }
Jon Eklund11c9fb12014-06-23 14:47:03 -05005474 /*Filter SPEAKER_SAFE out of results, as AudioService doesn't know about it
5475 and doesn't really need to.*/
jiabin9a3361e2019-10-01 09:38:30 -07005476 DeviceVector speakerSafeDevices = devices.getDevicesFromType(AUDIO_DEVICE_OUT_SPEAKER_SAFE);
François Gaffie11d30102018-11-02 16:09:09 +01005477 if (!speakerSafeDevices.isEmpty()) {
jiabin9a3361e2019-10-01 09:38:30 -07005478 devices.merge(mAvailableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_SPEAKER));
François Gaffie11d30102018-11-02 16:09:09 +01005479 devices.remove(speakerSafeDevices);
Jon Eklund11c9fb12014-06-23 14:47:03 -05005480 }
jiabin9a3361e2019-10-01 09:38:30 -07005481 // FIXME: use DeviceTypeSet when Java layer is ready for it.
5482 return deviceTypesToBitMask(devices.types());
Eric Laurente552edb2014-03-10 17:42:56 -07005483}
5484
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08005485status_t AudioPolicyManager::getDevicesForAttributes(
5486 const audio_attributes_t &attr, AudioDeviceTypeAddrVector *devices) {
5487 if (devices == nullptr) {
5488 return BAD_VALUE;
5489 }
5490 // check dynamic policies but only for primary descriptors (secondary not used for audible
5491 // audio routing, only used for duplication for playback capture)
5492 sp<SwAudioOutputDescriptor> policyDesc;
5493 status_t status = mPolicyMixes.getOutputForAttr(attr, 0 /*uid unknown here*/,
5494 AUDIO_OUTPUT_FLAG_NONE, policyDesc, nullptr);
5495 if (status != OK) {
5496 return status;
5497 }
5498 if (policyDesc != nullptr) {
5499 sp<AudioPolicyMix> mix = policyDesc->mPolicyMix.promote();
5500 if (mix != nullptr) {
5501 AudioDeviceTypeAddr device(mix->mDeviceType, mix->mDeviceAddress.c_str());
5502 devices->push_back(device);
5503 return NO_ERROR;
5504 }
5505 }
5506
5507 DeviceVector curDevices = mEngine->getOutputDevicesForAttributes(attr, nullptr, false);
5508 for (const auto& device : curDevices) {
5509 devices->push_back(device->getDeviceTypeAddr());
5510 }
5511 return NO_ERROR;
5512}
5513
Eric Laurente0720872014-03-11 09:30:41 -07005514void AudioPolicyManager::handleNotificationRoutingForStream(audio_stream_type_t stream) {
Eric Laurente552edb2014-03-10 17:42:56 -07005515 switch(stream) {
Eric Laurent3b73df72014-03-11 09:06:29 -07005516 case AUDIO_STREAM_MUSIC:
François Gaffiec005e562018-11-06 15:04:49 +01005517 checkOutputForAttributes(attributes_initializer(AUDIO_USAGE_NOTIFICATION));
Eric Laurente552edb2014-03-10 17:42:56 -07005518 updateDevicesAndOutputs();
5519 break;
5520 default:
5521 break;
5522 }
5523}
5524
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07005525uint32_t AudioPolicyManager::handleEventForBeacon(int event) {
Eric Laurent9459fb02015-08-12 18:36:32 -07005526
5527 // skip beacon mute management if a dedicated TTS output is available
5528 if (mTtsOutputAvailable) {
5529 return 0;
5530 }
5531
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07005532 switch(event) {
5533 case STARTING_OUTPUT:
5534 mBeaconMuteRefCount++;
5535 break;
5536 case STOPPING_OUTPUT:
5537 if (mBeaconMuteRefCount > 0) {
5538 mBeaconMuteRefCount--;
5539 }
5540 break;
5541 case STARTING_BEACON:
5542 mBeaconPlayingRefCount++;
5543 break;
5544 case STOPPING_BEACON:
5545 if (mBeaconPlayingRefCount > 0) {
5546 mBeaconPlayingRefCount--;
5547 }
5548 break;
5549 }
5550
5551 if (mBeaconMuteRefCount > 0) {
5552 // any playback causes beacon to be muted
5553 return setBeaconMute(true);
5554 } else {
5555 // no other playback: unmute when beacon starts playing, mute when it stops
5556 return setBeaconMute(mBeaconPlayingRefCount == 0);
5557 }
5558}
5559
5560uint32_t AudioPolicyManager::setBeaconMute(bool mute) {
5561 ALOGV("setBeaconMute(%d) mBeaconMuteRefCount=%d mBeaconPlayingRefCount=%d",
5562 mute, mBeaconMuteRefCount, mBeaconPlayingRefCount);
5563 // keep track of muted state to avoid repeating mute/unmute operations
5564 if (mBeaconMuted != mute) {
5565 // mute/unmute AUDIO_STREAM_TTS on all outputs
5566 ALOGV("\t muting %d", mute);
5567 uint32_t maxLatency = 0;
François Gaffieaaac0fd2018-11-22 17:56:39 +01005568 auto ttsVolumeSource = toVolumeSource(AUDIO_STREAM_TTS);
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07005569 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -07005570 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
jiabin9a3361e2019-10-01 09:38:30 -07005571 setVolumeSourceMute(ttsVolumeSource, mute/*on*/, desc, 0 /*delay*/, DeviceTypeSet());
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07005572 const uint32_t latency = desc->latency() * 2;
5573 if (latency > maxLatency) {
5574 maxLatency = latency;
5575 }
5576 }
5577 mBeaconMuted = mute;
5578 return maxLatency;
5579 }
5580 return 0;
5581}
5582
Eric Laurente0720872014-03-11 09:30:41 -07005583void AudioPolicyManager::updateDevicesAndOutputs()
Eric Laurente552edb2014-03-10 17:42:56 -07005584{
François Gaffiec005e562018-11-06 15:04:49 +01005585 mEngine->updateDeviceSelectionCache();
Eric Laurente552edb2014-03-10 17:42:56 -07005586 mPreviousOutputs = mOutputs;
5587}
5588
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07005589uint32_t AudioPolicyManager::checkDeviceMuteStrategies(const sp<AudioOutputDescriptor>& outputDesc,
François Gaffiec005e562018-11-06 15:04:49 +01005590 const DeviceVector &prevDevices,
Eric Laurente552edb2014-03-10 17:42:56 -07005591 uint32_t delayMs)
5592{
5593 // mute/unmute strategies using an incompatible device combination
5594 // if muting, wait for the audio in pcm buffer to be drained before proceeding
5595 // if unmuting, unmute only after the specified delay
5596 if (outputDesc->isDuplicated()) {
5597 return 0;
5598 }
5599
5600 uint32_t muteWaitMs = 0;
François Gaffiec005e562018-11-06 15:04:49 +01005601 DeviceVector devices = outputDesc->devices();
5602 bool shouldMute = outputDesc->isActive() && (devices.size() >= 2);
Eric Laurente552edb2014-03-10 17:42:56 -07005603
François Gaffiec005e562018-11-06 15:04:49 +01005604 auto productStrategies = mEngine->getOrderedProductStrategies();
5605 for (const auto &productStrategy : productStrategies) {
5606 auto attributes = mEngine->getAllAttributesForProductStrategy(productStrategy).front();
5607 DeviceVector curDevices =
5608 mEngine->getOutputDevicesForAttributes(attributes, nullptr, false/*fromCache*/);
5609 curDevices = curDevices.filter(outputDesc->supportedDevices());
5610 bool mute = shouldMute && curDevices.containsAtLeastOne(devices) && curDevices != devices;
Eric Laurente552edb2014-03-10 17:42:56 -07005611 bool doMute = false;
5612
François Gaffiec005e562018-11-06 15:04:49 +01005613 if (mute && !outputDesc->isStrategyMutedByDevice(productStrategy)) {
Eric Laurente552edb2014-03-10 17:42:56 -07005614 doMute = true;
François Gaffiec005e562018-11-06 15:04:49 +01005615 outputDesc->setStrategyMutedByDevice(productStrategy, true);
5616 } else if (!mute && outputDesc->isStrategyMutedByDevice(productStrategy)) {
Eric Laurente552edb2014-03-10 17:42:56 -07005617 doMute = true;
François Gaffiec005e562018-11-06 15:04:49 +01005618 outputDesc->setStrategyMutedByDevice(productStrategy, false);
Eric Laurente552edb2014-03-10 17:42:56 -07005619 }
Eric Laurent99401132014-05-07 19:48:15 -07005620 if (doMute) {
Eric Laurente552edb2014-03-10 17:42:56 -07005621 for (size_t j = 0; j < mOutputs.size(); j++) {
Eric Laurent1f2f2232014-06-02 12:01:23 -07005622 sp<AudioOutputDescriptor> desc = mOutputs.valueAt(j);
Eric Laurente552edb2014-03-10 17:42:56 -07005623 // skip output if it does not share any device with current output
François Gaffie11d30102018-11-02 16:09:09 +01005624 if (!desc->supportedDevices().containsAtLeastOne(outputDesc->supportedDevices())) {
Eric Laurente552edb2014-03-10 17:42:56 -07005625 continue;
5626 }
François Gaffiec005e562018-11-06 15:04:49 +01005627 ALOGVV("%s() %s (curDevice %s)", __func__,
5628 mute ? "muting" : "unmuting", curDevices.toString().c_str());
5629 setStrategyMute(productStrategy, mute, desc, mute ? 0 : delayMs);
5630 if (desc->isStrategyActive(productStrategy)) {
Eric Laurent99401132014-05-07 19:48:15 -07005631 if (mute) {
5632 // FIXME: should not need to double latency if volume could be applied
5633 // immediately by the audioflinger mixer. We must account for the delay
5634 // between now and the next time the audioflinger thread for this output
5635 // will process a buffer (which corresponds to one buffer size,
5636 // usually 1/2 or 1/4 of the latency).
5637 if (muteWaitMs < desc->latency() * 2) {
5638 muteWaitMs = desc->latency() * 2;
Eric Laurente552edb2014-03-10 17:42:56 -07005639 }
5640 }
5641 }
5642 }
5643 }
5644 }
5645
Eric Laurent99401132014-05-07 19:48:15 -07005646 // temporary mute output if device selection changes to avoid volume bursts due to
5647 // different per device volumes
François Gaffiec005e562018-11-06 15:04:49 +01005648 if (outputDesc->isActive() && (devices != prevDevices)) {
Eric Laurentdc462862016-07-19 12:29:53 -07005649 uint32_t tempMuteWaitMs = outputDesc->latency() * 2;
5650 // temporary mute duration is conservatively set to 4 times the reported latency
5651 uint32_t tempMuteDurationMs = outputDesc->latency() * 4;
5652 if (muteWaitMs < tempMuteWaitMs) {
5653 muteWaitMs = tempMuteWaitMs;
Eric Laurent99401132014-05-07 19:48:15 -07005654 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01005655 for (const auto &activeVs : outputDesc->getActiveVolumeSources()) {
5656 // make sure that we do not start the temporary mute period too early in case of
5657 // delayed device change
5658 setVolumeSourceMute(activeVs, true, outputDesc, delayMs);
5659 setVolumeSourceMute(activeVs, false, outputDesc, delayMs + tempMuteDurationMs,
François Gaffiec005e562018-11-06 15:04:49 +01005660 devices.types());
Eric Laurent99401132014-05-07 19:48:15 -07005661 }
5662 }
5663
Eric Laurente552edb2014-03-10 17:42:56 -07005664 // wait for the PCM output buffers to empty before proceeding with the rest of the command
5665 if (muteWaitMs > delayMs) {
5666 muteWaitMs -= delayMs;
5667 usleep(muteWaitMs * 1000);
5668 return muteWaitMs;
5669 }
5670 return 0;
5671}
5672
François Gaffie11d30102018-11-02 16:09:09 +01005673uint32_t AudioPolicyManager::setOutputDevices(const sp<SwAudioOutputDescriptor>& outputDesc,
5674 const DeviceVector &devices,
5675 bool force,
5676 int delayMs,
5677 audio_patch_handle_t *patchHandle,
5678 bool requiresMuteCheck)
Eric Laurente552edb2014-03-10 17:42:56 -07005679{
François Gaffie11d30102018-11-02 16:09:09 +01005680 ALOGV("%s device %s delayMs %d", __func__, devices.toString().c_str(), delayMs);
Eric Laurente552edb2014-03-10 17:42:56 -07005681 uint32_t muteWaitMs;
5682
5683 if (outputDesc->isDuplicated()) {
François Gaffie11d30102018-11-02 16:09:09 +01005684 muteWaitMs = setOutputDevices(outputDesc->subOutput1(), devices, force, delayMs,
5685 nullptr /* patchHandle */, requiresMuteCheck);
5686 muteWaitMs += setOutputDevices(outputDesc->subOutput2(), devices, force, delayMs,
5687 nullptr /* patchHandle */, requiresMuteCheck);
Eric Laurente552edb2014-03-10 17:42:56 -07005688 return muteWaitMs;
5689 }
Eric Laurente552edb2014-03-10 17:42:56 -07005690
5691 // filter devices according to output selected
Francois Gaffie716e1432019-01-14 16:58:59 +01005692 DeviceVector filteredDevices = outputDesc->filterSupportedDevices(devices);
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01005693 DeviceVector prevDevices = outputDesc->devices();
Eric Laurente552edb2014-03-10 17:42:56 -07005694
François Gaffie11d30102018-11-02 16:09:09 +01005695 // no need to proceed if new device is not AUDIO_DEVICE_NONE and not supported by current
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01005696 // output profile or if new device is not supported AND previous device(s) is(are) still
5697 // available (otherwise reset device must be done on the output)
5698 if (!devices.isEmpty() && filteredDevices.isEmpty() &&
5699 !mAvailableOutputDevices.filter(prevDevices).empty()) {
François Gaffie11d30102018-11-02 16:09:09 +01005700 ALOGV("%s: unsupported device %s for output", __func__, devices.toString().c_str());
5701 return 0;
5702 }
Eric Laurente552edb2014-03-10 17:42:56 -07005703
François Gaffie11d30102018-11-02 16:09:09 +01005704 ALOGV("setOutputDevices() prevDevice %s", prevDevices.toString().c_str());
5705
5706 if (!filteredDevices.isEmpty()) {
5707 outputDesc->setDevices(filteredDevices);
Eric Laurente552edb2014-03-10 17:42:56 -07005708 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00005709
5710 // if the outputs are not materially active, there is no need to mute.
5711 if (requiresMuteCheck) {
François Gaffiec005e562018-11-06 15:04:49 +01005712 muteWaitMs = checkDeviceMuteStrategies(outputDesc, prevDevices, delayMs);
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00005713 } else {
5714 ALOGV("%s: suppressing checkDeviceMuteStrategies", __func__);
5715 muteWaitMs = 0;
5716 }
Eric Laurente552edb2014-03-10 17:42:56 -07005717
5718 // Do not change the routing if:
Eric Laurentb80a2a82014-10-27 16:07:59 -07005719 // the requested device is AUDIO_DEVICE_NONE
5720 // OR the requested device is the same as current device
5721 // AND force is not specified
5722 // AND the output is connected by a valid audio patch.
François Gaffie11d30102018-11-02 16:09:09 +01005723 // Doing this check here allows the caller to call setOutputDevices() without conditions
Mikhail Naganov2d4e1702019-01-24 12:59:44 -08005724 if ((filteredDevices.isEmpty() || filteredDevices == prevDevices) &&
François Gaffie11d30102018-11-02 16:09:09 +01005725 !force && outputDesc->getPatchHandle() != 0) {
5726 ALOGV("%s setting same device %s or null device, force=%d, patch handle=%d", __func__,
5727 filteredDevices.toString().c_str(), force, outputDesc->getPatchHandle());
Eric Laurente552edb2014-03-10 17:42:56 -07005728 return muteWaitMs;
5729 }
5730
François Gaffie11d30102018-11-02 16:09:09 +01005731 ALOGV("%s changing device to %s", __func__, filteredDevices.toString().c_str());
Eric Laurent1c333e22014-05-20 10:48:17 -07005732
Eric Laurente552edb2014-03-10 17:42:56 -07005733 // do the routing
François Gaffie11d30102018-11-02 16:09:09 +01005734 if (filteredDevices.isEmpty()) {
Eric Laurentc75307b2015-03-17 15:29:32 -07005735 resetOutputDevice(outputDesc, delayMs, NULL);
Eric Laurent1c333e22014-05-20 10:48:17 -07005736 } else {
François Gaffie11d30102018-11-02 16:09:09 +01005737 PatchBuilder patchBuilder;
5738 patchBuilder.addSource(outputDesc);
5739 ALOG_ASSERT(filteredDevices.size() <= AUDIO_PATCH_PORTS_MAX, "Too many sink ports");
5740 for (const auto &filteredDevice : filteredDevices) {
5741 patchBuilder.addSink(filteredDevice);
Eric Laurentc40d9692016-04-13 19:14:13 -07005742 }
5743
François Gaffie11d30102018-11-02 16:09:09 +01005744 installPatch(__func__, patchHandle, outputDesc.get(), patchBuilder.patch(), delayMs);
Eric Laurent1c333e22014-05-20 10:48:17 -07005745 }
Eric Laurente552edb2014-03-10 17:42:56 -07005746
5747 // update stream volumes according to new device
François Gaffie11d30102018-11-02 16:09:09 +01005748 applyStreamVolumes(outputDesc, filteredDevices.types(), delayMs);
Eric Laurente552edb2014-03-10 17:42:56 -07005749
5750 return muteWaitMs;
5751}
5752
Eric Laurentc75307b2015-03-17 15:29:32 -07005753status_t AudioPolicyManager::resetOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
Eric Laurent6a94d692014-05-20 11:18:06 -07005754 int delayMs,
5755 audio_patch_handle_t *patchHandle)
Eric Laurent1c333e22014-05-20 10:48:17 -07005756{
Eric Laurent6a94d692014-05-20 11:18:06 -07005757 ssize_t index;
5758 if (patchHandle) {
5759 index = mAudioPatches.indexOfKey(*patchHandle);
5760 } else {
Jean-Michel Triviff155c62016-02-26 12:07:16 -08005761 index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07005762 }
5763 if (index < 0) {
Eric Laurent1c333e22014-05-20 10:48:17 -07005764 return INVALID_OPERATION;
5765 }
Eric Laurent6a94d692014-05-20 11:18:06 -07005766 sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index);
5767 status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, delayMs);
Eric Laurent1c333e22014-05-20 10:48:17 -07005768 ALOGV("resetOutputDevice() releaseAudioPatch returned %d", status);
Glenn Kastena13cde92016-03-28 15:26:02 -07005769 outputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
Eric Laurent6a94d692014-05-20 11:18:06 -07005770 removeAudioPatch(patchDesc->mHandle);
5771 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07005772 mpClientInterface->onAudioPatchListUpdate();
Eric Laurent1c333e22014-05-20 10:48:17 -07005773 return status;
5774}
5775
5776status_t AudioPolicyManager::setInputDevice(audio_io_handle_t input,
François Gaffie11d30102018-11-02 16:09:09 +01005777 const sp<DeviceDescriptor> &device,
Eric Laurent6a94d692014-05-20 11:18:06 -07005778 bool force,
5779 audio_patch_handle_t *patchHandle)
Eric Laurent1c333e22014-05-20 10:48:17 -07005780{
5781 status_t status = NO_ERROR;
5782
Eric Laurent1f2f2232014-06-02 12:01:23 -07005783 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
François Gaffie11d30102018-11-02 16:09:09 +01005784 if ((device != nullptr) && ((device != inputDesc->getDevice()) || force)) {
5785 inputDesc->setDevice(device);
Eric Laurent1c333e22014-05-20 10:48:17 -07005786
François Gaffie11d30102018-11-02 16:09:09 +01005787 if (mAvailableInputDevices.contains(device)) {
Mikhail Naganovdc769682018-05-04 15:34:08 -07005788 PatchBuilder patchBuilder;
5789 patchBuilder.addSink(inputDesc,
Eric Laurentdaf92cc2014-07-22 15:36:10 -07005790 // AUDIO_SOURCE_HOTWORD is for internal use only:
5791 // handled as AUDIO_SOURCE_VOICE_RECOGNITION by the audio HAL
Mikhail Naganovdc769682018-05-04 15:34:08 -07005792 [inputDesc](const PatchBuilder::mix_usecase_t& usecase) {
5793 auto result = usecase;
5794 if (result.source == AUDIO_SOURCE_HOTWORD && !inputDesc->isSoundTrigger()) {
5795 result.source = AUDIO_SOURCE_VOICE_RECOGNITION;
5796 }
5797 return result; }).
Eric Laurent1c333e22014-05-20 10:48:17 -07005798 //only one input device for now
François Gaffie11d30102018-11-02 16:09:09 +01005799 addSource(device);
Mikhail Naganovdc769682018-05-04 15:34:08 -07005800 status = installPatch(__func__, patchHandle, inputDesc.get(), patchBuilder.patch(), 0);
Eric Laurent1c333e22014-05-20 10:48:17 -07005801 }
5802 }
5803 return status;
5804}
5805
Eric Laurent6a94d692014-05-20 11:18:06 -07005806status_t AudioPolicyManager::resetInputDevice(audio_io_handle_t input,
5807 audio_patch_handle_t *patchHandle)
Eric Laurent1c333e22014-05-20 10:48:17 -07005808{
Eric Laurent1f2f2232014-06-02 12:01:23 -07005809 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
Eric Laurent6a94d692014-05-20 11:18:06 -07005810 ssize_t index;
5811 if (patchHandle) {
5812 index = mAudioPatches.indexOfKey(*patchHandle);
5813 } else {
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08005814 index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07005815 }
5816 if (index < 0) {
Eric Laurent1c333e22014-05-20 10:48:17 -07005817 return INVALID_OPERATION;
5818 }
Eric Laurent6a94d692014-05-20 11:18:06 -07005819 sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index);
5820 status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
Eric Laurent1c333e22014-05-20 10:48:17 -07005821 ALOGV("resetInputDevice() releaseAudioPatch returned %d", status);
Glenn Kastena13cde92016-03-28 15:26:02 -07005822 inputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
Eric Laurent6a94d692014-05-20 11:18:06 -07005823 removeAudioPatch(patchDesc->mHandle);
5824 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07005825 mpClientInterface->onAudioPatchListUpdate();
Eric Laurent1c333e22014-05-20 10:48:17 -07005826 return status;
5827}
5828
François Gaffie11d30102018-11-02 16:09:09 +01005829sp<IOProfile> AudioPolicyManager::getInputProfile(const sp<DeviceDescriptor> &device,
François Gaffie53615e22015-03-19 09:24:12 +01005830 uint32_t& samplingRate,
Andy Hungf129b032015-04-07 13:45:50 -07005831 audio_format_t& format,
5832 audio_channel_mask_t& channelMask,
François Gaffie53615e22015-03-19 09:24:12 +01005833 audio_input_flags_t flags)
Eric Laurente552edb2014-03-10 17:42:56 -07005834{
5835 // Choose an input profile based on the requested capture parameters: select the first available
5836 // profile supporting all requested parameters.
Andy Hungf129b032015-04-07 13:45:50 -07005837 //
5838 // TODO: perhaps isCompatibleProfile should return a "matching" score so we can return
5839 // the best matching profile, not the first one.
Eric Laurente552edb2014-03-10 17:42:56 -07005840
Glenn Kasten730b9262018-03-29 15:01:26 -07005841 sp<IOProfile> firstInexact;
5842 uint32_t updatedSamplingRate = 0;
5843 audio_format_t updatedFormat = AUDIO_FORMAT_INVALID;
5844 audio_channel_mask_t updatedChannelMask = AUDIO_CHANNEL_INVALID;
Mikhail Naganov7e22e942017-12-07 10:04:29 -08005845 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08005846 for (const auto& profile : hwModule->getInputProfiles()) {
Eric Laurentd4692962014-05-05 18:13:44 -07005847 // profile->log();
Glenn Kasten730b9262018-03-29 15:01:26 -07005848 //updatedFormat = format;
François Gaffie11d30102018-11-02 16:09:09 +01005849 if (profile->isCompatibleProfile(DeviceVector(device), samplingRate,
Glenn Kasten730b9262018-03-29 15:01:26 -07005850 &samplingRate /*updatedSamplingRate*/,
Andy Hungf129b032015-04-07 13:45:50 -07005851 format,
Glenn Kasten730b9262018-03-29 15:01:26 -07005852 &format, /*updatedFormat*/
Andy Hungf129b032015-04-07 13:45:50 -07005853 channelMask,
Glenn Kasten730b9262018-03-29 15:01:26 -07005854 &channelMask /*updatedChannelMask*/,
5855 // FIXME ugly cast
5856 (audio_output_flags_t) flags,
5857 true /*exactMatchRequiredForInputFlags*/)) {
Eric Laurente552edb2014-03-10 17:42:56 -07005858 return profile;
5859 }
François Gaffie11d30102018-11-02 16:09:09 +01005860 if (firstInexact == nullptr && profile->isCompatibleProfile(DeviceVector(device),
Glenn Kasten730b9262018-03-29 15:01:26 -07005861 samplingRate,
5862 &updatedSamplingRate,
5863 format,
5864 &updatedFormat,
5865 channelMask,
5866 &updatedChannelMask,
5867 // FIXME ugly cast
5868 (audio_output_flags_t) flags,
5869 false /*exactMatchRequiredForInputFlags*/)) {
5870 firstInexact = profile;
5871 }
5872
Eric Laurente552edb2014-03-10 17:42:56 -07005873 }
5874 }
Glenn Kasten730b9262018-03-29 15:01:26 -07005875 if (firstInexact != nullptr) {
5876 samplingRate = updatedSamplingRate;
5877 format = updatedFormat;
5878 channelMask = updatedChannelMask;
5879 return firstInexact;
5880 }
Eric Laurente552edb2014-03-10 17:42:56 -07005881 return NULL;
5882}
5883
François Gaffieaaac0fd2018-11-22 17:56:39 +01005884float AudioPolicyManager::computeVolume(IVolumeCurves &curves,
5885 VolumeSource volumeSource,
François Gaffied1ab2bd2015-12-02 18:20:06 +01005886 int index,
jiabin9a3361e2019-10-01 09:38:30 -07005887 const DeviceTypeSet& deviceTypes)
Eric Laurente552edb2014-03-10 17:42:56 -07005888{
jiabin9a3361e2019-10-01 09:38:30 -07005889 float volumeDb = curves.volIndexToDb(Volume::getDeviceCategory(deviceTypes), index);
Jean-Michel Trivi3d8b4a42016-09-14 18:37:46 -07005890
5891 // handle the case of accessibility active while a ringtone is playing: if the ringtone is much
5892 // louder than the accessibility prompt, the prompt cannot be heard, thus masking the touch
5893 // exploration of the dialer UI. In this situation, bring the accessibility volume closer to
5894 // the ringtone volume
François Gaffieaaac0fd2018-11-22 17:56:39 +01005895 const auto callVolumeSrc = toVolumeSource(AUDIO_STREAM_VOICE_CALL);
5896 const auto ringVolumeSrc = toVolumeSource(AUDIO_STREAM_RING);
5897 const auto musicVolumeSrc = toVolumeSource(AUDIO_STREAM_MUSIC);
5898 const auto alarmVolumeSrc = toVolumeSource(AUDIO_STREAM_ALARM);
Jean-Michel Trivi441ed652019-07-11 14:55:16 -07005899 const auto a11yVolumeSrc = toVolumeSource(AUDIO_STREAM_ACCESSIBILITY);
François Gaffieaaac0fd2018-11-22 17:56:39 +01005900
Jean-Michel Trivi441ed652019-07-11 14:55:16 -07005901 if (volumeSource == a11yVolumeSrc
François Gaffieaaac0fd2018-11-22 17:56:39 +01005902 && (AUDIO_MODE_RINGTONE == mEngine->getPhoneState()) &&
5903 mOutputs.isActive(ringVolumeSrc, 0)) {
5904 auto &ringCurves = getVolumeCurves(AUDIO_STREAM_RING);
jiabin9a3361e2019-10-01 09:38:30 -07005905 const float ringVolumeDb = computeVolume(ringCurves, ringVolumeSrc, index, deviceTypes);
François Gaffieaaac0fd2018-11-22 17:56:39 +01005906 return ringVolumeDb - 4 > volumeDb ? ringVolumeDb - 4 : volumeDb;
Jean-Michel Trivi3d8b4a42016-09-14 18:37:46 -07005907 }
5908
Eric Laurentdcd4ab12018-06-29 17:45:13 -07005909 // in-call: always cap volume by voice volume + some low headroom
François Gaffieaaac0fd2018-11-22 17:56:39 +01005910 if ((volumeSource != callVolumeSrc && (isInCall() ||
5911 mOutputs.isActiveLocally(callVolumeSrc))) &&
5912 (volumeSource == toVolumeSource(AUDIO_STREAM_SYSTEM) ||
5913 volumeSource == ringVolumeSrc || volumeSource == musicVolumeSrc ||
5914 volumeSource == alarmVolumeSrc ||
5915 volumeSource == toVolumeSource(AUDIO_STREAM_NOTIFICATION) ||
5916 volumeSource == toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE) ||
5917 volumeSource == toVolumeSource(AUDIO_STREAM_DTMF) ||
Jean-Michel Trivi441ed652019-07-11 14:55:16 -07005918 volumeSource == a11yVolumeSrc)) {
François Gaffieaaac0fd2018-11-22 17:56:39 +01005919 auto &voiceCurves = getVolumeCurves(callVolumeSrc);
jiabin9a3361e2019-10-01 09:38:30 -07005920 int voiceVolumeIndex = voiceCurves.getVolumeIndex(deviceTypes);
François Gaffieaaac0fd2018-11-22 17:56:39 +01005921 const float maxVoiceVolDb =
jiabin9a3361e2019-10-01 09:38:30 -07005922 computeVolume(voiceCurves, callVolumeSrc, voiceVolumeIndex, deviceTypes)
Eric Laurent7731b5a2018-04-06 15:47:22 -07005923 + IN_CALL_EARPIECE_HEADROOM_DB;
Abhijith Shastry329ddab2019-04-23 11:53:26 -07005924 // FIXME: Workaround for call screening applications until a proper audio mode is defined
5925 // to support this scenario : Exempt the RING stream from the audio cap if the audio was
5926 // programmatically muted.
5927 // VOICE_CALL stream has minVolumeIndex > 0 : Users cannot set the volume of voice calls to
5928 // 0. We don't want to cap volume when the system has programmatically muted the voice call
5929 // stream. See setVolumeCurveIndex() for more information.
Jean-Michel Trivi441ed652019-07-11 14:55:16 -07005930 bool exemptFromCapping =
5931 ((volumeSource == ringVolumeSrc) || (volumeSource == a11yVolumeSrc))
5932 && (voiceVolumeIndex == 0);
Abhijith Shastry329ddab2019-04-23 11:53:26 -07005933 ALOGV_IF(exemptFromCapping, "%s volume source %d at vol=%f not capped", __func__,
5934 volumeSource, volumeDb);
5935 if ((volumeDb > maxVoiceVolDb) && !exemptFromCapping) {
François Gaffieaaac0fd2018-11-22 17:56:39 +01005936 ALOGV("%s volume source %d at vol=%f overriden by volume group %d at vol=%f", __func__,
5937 volumeSource, volumeDb, callVolumeSrc, maxVoiceVolDb);
5938 volumeDb = maxVoiceVolDb;
Jean-Michel Trivi719a9872017-08-05 13:51:35 -07005939 }
5940 }
Eric Laurente552edb2014-03-10 17:42:56 -07005941 // if a headset is connected, apply the following rules to ring tones and notifications
5942 // to avoid sound level bursts in user's ears:
Eric Laurent6af1c1d2016-04-14 11:20:44 -07005943 // - always attenuate notifications volume by 6dB
5944 // - attenuate ring tones volume by 6dB unless music is not playing and
5945 // speaker is part of the select devices
Eric Laurente552edb2014-03-10 17:42:56 -07005946 // - if music is playing, always limit the volume to current music volume,
5947 // with a minimum threshold at -36dB so that notification is always perceived.
jiabin9a3361e2019-10-01 09:38:30 -07005948 if (!Intersection(deviceTypes,
5949 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES,
5950 AUDIO_DEVICE_OUT_WIRED_HEADSET, AUDIO_DEVICE_OUT_WIRED_HEADPHONE,
5951 AUDIO_DEVICE_OUT_USB_HEADSET, AUDIO_DEVICE_OUT_HEARING_AID}).empty() &&
François Gaffieaaac0fd2018-11-22 17:56:39 +01005952 ((volumeSource == alarmVolumeSrc ||
5953 volumeSource == ringVolumeSrc) ||
5954 (volumeSource == toVolumeSource(AUDIO_STREAM_NOTIFICATION)) ||
5955 (volumeSource == toVolumeSource(AUDIO_STREAM_SYSTEM)) ||
5956 ((volumeSource == toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE)) &&
5957 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_NONE))) &&
5958 curves.canBeMuted()) {
5959
Eric Laurente552edb2014-03-10 17:42:56 -07005960 // when the phone is ringing we must consider that music could have been paused just before
5961 // by the music application and behave as if music was active if the last music track was
5962 // just stopped
Eric Laurent3b73df72014-03-11 09:06:29 -07005963 if (isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY) ||
Eric Laurente552edb2014-03-10 17:42:56 -07005964 mLimitRingtoneVolume) {
François Gaffie43c73442018-11-08 08:21:55 +01005965 volumeDb += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
jiabin9a3361e2019-10-01 09:38:30 -07005966 DeviceTypeSet musicDevice =
François Gaffiec005e562018-11-06 15:04:49 +01005967 mEngine->getOutputDevicesForAttributes(attributes_initializer(AUDIO_USAGE_MEDIA),
5968 nullptr, true /*fromCache*/).types();
François Gaffieaaac0fd2018-11-22 17:56:39 +01005969 auto &musicCurves = getVolumeCurves(AUDIO_STREAM_MUSIC);
jiabin9a3361e2019-10-01 09:38:30 -07005970 float musicVolDb = computeVolume(musicCurves,
5971 musicVolumeSrc,
5972 musicCurves.getVolumeIndex(musicDevice),
5973 musicDevice);
François Gaffieaaac0fd2018-11-22 17:56:39 +01005974 float minVolDb = (musicVolDb > SONIFICATION_HEADSET_VOLUME_MIN_DB) ?
5975 musicVolDb : SONIFICATION_HEADSET_VOLUME_MIN_DB;
5976 if (volumeDb > minVolDb) {
5977 volumeDb = minVolDb;
5978 ALOGV("computeVolume limiting volume to %f musicVol %f", minVolDb, musicVolDb);
Eric Laurente552edb2014-03-10 17:42:56 -07005979 }
jiabin9a3361e2019-10-01 09:38:30 -07005980 if (!Intersection(deviceTypes, {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,
5981 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES}).empty()) {
Jean-Michel Trivi00a20962016-05-25 19:11:01 -07005982 // on A2DP, also ensure notification volume is not too low compared to media when
5983 // intended to be played
François Gaffie43c73442018-11-08 08:21:55 +01005984 if ((volumeDb > -96.0f) &&
François Gaffieaaac0fd2018-11-22 17:56:39 +01005985 (musicVolDb - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB > volumeDb)) {
jiabin9a3361e2019-10-01 09:38:30 -07005986 ALOGV("%s increasing volume for volume source=%d device=%s from %f to %f",
5987 __func__, volumeSource, dumpDeviceTypes(deviceTypes).c_str(), volumeDb,
François Gaffieaaac0fd2018-11-22 17:56:39 +01005988 musicVolDb - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB);
5989 volumeDb = musicVolDb - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB;
Jean-Michel Trivi00a20962016-05-25 19:11:01 -07005990 }
5991 }
jiabin9a3361e2019-10-01 09:38:30 -07005992 } else if ((Volume::getDeviceForVolume(deviceTypes) != AUDIO_DEVICE_OUT_SPEAKER) ||
François Gaffieaaac0fd2018-11-22 17:56:39 +01005993 (!(volumeSource == alarmVolumeSrc || volumeSource == ringVolumeSrc))) {
François Gaffie43c73442018-11-08 08:21:55 +01005994 volumeDb += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
Eric Laurente552edb2014-03-10 17:42:56 -07005995 }
5996 }
5997
François Gaffie43c73442018-11-08 08:21:55 +01005998 return volumeDb;
Eric Laurente552edb2014-03-10 17:42:56 -07005999}
6000
Eric Laurent3839bc02018-07-10 18:33:34 -07006001int AudioPolicyManager::rescaleVolumeIndex(int srcIndex,
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01006002 VolumeSource fromVolumeSource,
6003 VolumeSource toVolumeSource)
Eric Laurent3839bc02018-07-10 18:33:34 -07006004{
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01006005 if (fromVolumeSource == toVolumeSource) {
Eric Laurent3839bc02018-07-10 18:33:34 -07006006 return srcIndex;
6007 }
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01006008 auto &srcCurves = getVolumeCurves(fromVolumeSource);
6009 auto &dstCurves = getVolumeCurves(toVolumeSource);
Eric Laurentf5aa58d2019-02-22 18:20:11 -08006010 float minSrc = (float)srcCurves.getVolumeIndexMin();
6011 float maxSrc = (float)srcCurves.getVolumeIndexMax();
6012 float minDst = (float)dstCurves.getVolumeIndexMin();
6013 float maxDst = (float)dstCurves.getVolumeIndexMax();
Eric Laurent3839bc02018-07-10 18:33:34 -07006014
Revathi Uddarajufe0fb8b2017-07-27 17:05:37 +08006015 // preserve mute request or correct range
6016 if (srcIndex < minSrc) {
6017 if (srcIndex == 0) {
6018 return 0;
6019 }
6020 srcIndex = minSrc;
6021 } else if (srcIndex > maxSrc) {
6022 srcIndex = maxSrc;
6023 }
Eric Laurent3839bc02018-07-10 18:33:34 -07006024 return (int)(minDst + ((srcIndex - minSrc) * (maxDst - minDst)) / (maxSrc - minSrc));
6025}
6026
François Gaffieaaac0fd2018-11-22 17:56:39 +01006027status_t AudioPolicyManager::checkAndSetVolume(IVolumeCurves &curves,
6028 VolumeSource volumeSource,
Eric Laurentf5aa58d2019-02-22 18:20:11 -08006029 int index,
6030 const sp<AudioOutputDescriptor>& outputDesc,
jiabin9a3361e2019-10-01 09:38:30 -07006031 DeviceTypeSet deviceTypes,
Eric Laurentf5aa58d2019-02-22 18:20:11 -08006032 int delayMs,
6033 bool force)
Eric Laurente552edb2014-03-10 17:42:56 -07006034{
François Gaffieaaac0fd2018-11-22 17:56:39 +01006035 // do not change actual attributes volume if the attributes is muted
6036 if (outputDesc->isMuted(volumeSource)) {
6037 ALOGVV("%s: volume source %d muted count %d active=%d", __func__, volumeSource,
6038 outputDesc->getMuteCount(volumeSource), outputDesc->isActive(volumeSource));
Eric Laurente552edb2014-03-10 17:42:56 -07006039 return NO_ERROR;
6040 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01006041 VolumeSource callVolSrc = toVolumeSource(AUDIO_STREAM_VOICE_CALL);
6042 VolumeSource btScoVolSrc = toVolumeSource(AUDIO_STREAM_BLUETOOTH_SCO);
6043 bool isVoiceVolSrc = callVolSrc == volumeSource;
6044 bool isBtScoVolSrc = btScoVolSrc == volumeSource;
6045
François Gaffie2110e042015-03-24 08:41:51 +01006046 audio_policy_forced_cfg_t forceUseForComm =
6047 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION);
Eric Laurente552edb2014-03-10 17:42:56 -07006048 // do not change in call volume if bluetooth is connected and vice versa
François Gaffieaaac0fd2018-11-22 17:56:39 +01006049 // if sco and call follow same curves, bypass forceUseForComm
6050 if ((callVolSrc != btScoVolSrc) &&
6051 ((isVoiceVolSrc && forceUseForComm == AUDIO_POLICY_FORCE_BT_SCO) ||
6052 (isBtScoVolSrc && forceUseForComm != AUDIO_POLICY_FORCE_BT_SCO))) {
6053 ALOGV("%s cannot set volume group %d volume with force use = %d for comm", __func__,
6054 volumeSource, forceUseForComm);
Eric Laurente552edb2014-03-10 17:42:56 -07006055 return INVALID_OPERATION;
6056 }
jiabin9a3361e2019-10-01 09:38:30 -07006057 if (deviceTypes.empty()) {
6058 deviceTypes = outputDesc->devices().types();
Eric Laurentc75307b2015-03-17 15:29:32 -07006059 }
Eric Laurent275e8e92014-11-30 15:14:47 -08006060
jiabin9a3361e2019-10-01 09:38:30 -07006061 float volumeDb = computeVolume(curves, volumeSource, index, deviceTypes);
6062 if (outputDesc->isFixedVolume(deviceTypes) ||
HW Leeda7581e2018-05-22 18:31:34 +08006063 // Force VoIP volume to max for bluetooth SCO
jiabin9a3361e2019-10-01 09:38:30 -07006064
6065 ((isVoiceVolSrc || isBtScoVolSrc) &&
6066 isSingleDeviceType(deviceTypes, audio_is_bluetooth_out_sco_device))) {
Eric Laurentffbc80f2015-03-18 18:30:19 -07006067 volumeDb = 0.0f;
Eric Laurent275e8e92014-11-30 15:14:47 -08006068 }
jiabin9a3361e2019-10-01 09:38:30 -07006069 outputDesc->setVolume(
6070 volumeDb, volumeSource, curves.getStreamTypes(), deviceTypes, delayMs, force);
Eric Laurentc75307b2015-03-17 15:29:32 -07006071
François Gaffieaaac0fd2018-11-22 17:56:39 +01006072 if (isVoiceVolSrc || isBtScoVolSrc) {
Eric Laurente552edb2014-03-10 17:42:56 -07006073 float voiceVolume;
Eric Laurentfad001d2019-06-11 19:17:57 -07006074 // Force voice volume to max or mute for Bluetooth SCO as other attenuations are managed by the headset
François Gaffieaaac0fd2018-11-22 17:56:39 +01006075 if (isVoiceVolSrc) {
6076 voiceVolume = (float)index/(float)curves.getVolumeIndexMax();
Eric Laurente552edb2014-03-10 17:42:56 -07006077 } else {
Eric Laurentfad001d2019-06-11 19:17:57 -07006078 voiceVolume = index == 0 ? 0.0 : 1.0;
Eric Laurente552edb2014-03-10 17:42:56 -07006079 }
Eric Laurent18fba842016-03-31 14:41:26 -07006080 if (voiceVolume != mLastVoiceVolume) {
Eric Laurente552edb2014-03-10 17:42:56 -07006081 mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
6082 mLastVoiceVolume = voiceVolume;
6083 }
6084 }
Eric Laurente552edb2014-03-10 17:42:56 -07006085 return NO_ERROR;
6086}
6087
Eric Laurentc75307b2015-03-17 15:29:32 -07006088void AudioPolicyManager::applyStreamVolumes(const sp<AudioOutputDescriptor>& outputDesc,
jiabin9a3361e2019-10-01 09:38:30 -07006089 const DeviceTypeSet& deviceTypes,
6090 int delayMs,
6091 bool force)
Eric Laurente552edb2014-03-10 17:42:56 -07006092{
Eric Laurentc75307b2015-03-17 15:29:32 -07006093 ALOGVV("applyStreamVolumes() for device %08x", device);
François Gaffieaaac0fd2018-11-22 17:56:39 +01006094 for (const auto &volumeGroup : mEngine->getVolumeGroups()) {
6095 auto &curves = getVolumeCurves(toVolumeSource(volumeGroup));
6096 checkAndSetVolume(curves, toVolumeSource(volumeGroup),
jiabin9a3361e2019-10-01 09:38:30 -07006097 curves.getVolumeIndex(deviceTypes),
6098 outputDesc, deviceTypes, delayMs, force);
Eric Laurente552edb2014-03-10 17:42:56 -07006099 }
6100}
6101
François Gaffiec005e562018-11-06 15:04:49 +01006102void AudioPolicyManager::setStrategyMute(product_strategy_t strategy,
6103 bool on,
6104 const sp<AudioOutputDescriptor>& outputDesc,
6105 int delayMs,
jiabin9a3361e2019-10-01 09:38:30 -07006106 DeviceTypeSet deviceTypes)
Eric Laurente552edb2014-03-10 17:42:56 -07006107{
François Gaffieaaac0fd2018-11-22 17:56:39 +01006108 std::vector<VolumeSource> sourcesToMute;
6109 for (auto attributes: mEngine->getAllAttributesForProductStrategy(strategy)) {
6110 ALOGVV("%s() attributes %s, mute %d, output ID %d", __func__,
6111 toString(attributes).c_str(), on, outputDesc->getId());
6112 VolumeSource source = toVolumeSource(attributes);
6113 if (std::find(begin(sourcesToMute), end(sourcesToMute), source) == end(sourcesToMute)) {
6114 sourcesToMute.push_back(source);
6115 }
Eric Laurente552edb2014-03-10 17:42:56 -07006116 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01006117 for (auto source : sourcesToMute) {
jiabin9a3361e2019-10-01 09:38:30 -07006118 setVolumeSourceMute(source, on, outputDesc, delayMs, deviceTypes);
François Gaffieaaac0fd2018-11-22 17:56:39 +01006119 }
6120
Eric Laurente552edb2014-03-10 17:42:56 -07006121}
6122
François Gaffieaaac0fd2018-11-22 17:56:39 +01006123void AudioPolicyManager::setVolumeSourceMute(VolumeSource volumeSource,
6124 bool on,
6125 const sp<AudioOutputDescriptor>& outputDesc,
6126 int delayMs,
jiabin9a3361e2019-10-01 09:38:30 -07006127 DeviceTypeSet deviceTypes)
Eric Laurente552edb2014-03-10 17:42:56 -07006128{
jiabin9a3361e2019-10-01 09:38:30 -07006129 if (deviceTypes.empty()) {
6130 deviceTypes = outputDesc->devices().types();
Eric Laurente552edb2014-03-10 17:42:56 -07006131 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01006132 auto &curves = getVolumeCurves(volumeSource);
Eric Laurente552edb2014-03-10 17:42:56 -07006133 if (on) {
François Gaffieaaac0fd2018-11-22 17:56:39 +01006134 if (!outputDesc->isMuted(volumeSource)) {
Eric Laurentf5aa58d2019-02-22 18:20:11 -08006135 if (curves.canBeMuted() &&
François Gaffieaaac0fd2018-11-22 17:56:39 +01006136 (volumeSource != toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE) ||
6137 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) ==
6138 AUDIO_POLICY_FORCE_NONE))) {
jiabin9a3361e2019-10-01 09:38:30 -07006139 checkAndSetVolume(curves, volumeSource, 0, outputDesc, deviceTypes, delayMs);
Eric Laurente552edb2014-03-10 17:42:56 -07006140 }
6141 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01006142 // increment mMuteCount after calling checkAndSetVolume() so that volume change is not
6143 // ignored
6144 outputDesc->incMuteCount(volumeSource);
Eric Laurente552edb2014-03-10 17:42:56 -07006145 } else {
François Gaffieaaac0fd2018-11-22 17:56:39 +01006146 if (!outputDesc->isMuted(volumeSource)) {
6147 ALOGV("%s unmuting non muted attributes!", __func__);
Eric Laurente552edb2014-03-10 17:42:56 -07006148 return;
6149 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01006150 if (outputDesc->decMuteCount(volumeSource) == 0) {
6151 checkAndSetVolume(curves, volumeSource,
jiabin9a3361e2019-10-01 09:38:30 -07006152 curves.getVolumeIndex(deviceTypes),
Eric Laurentc75307b2015-03-17 15:29:32 -07006153 outputDesc,
jiabin9a3361e2019-10-01 09:38:30 -07006154 deviceTypes,
Eric Laurente552edb2014-03-10 17:42:56 -07006155 delayMs);
6156 }
6157 }
6158}
6159
François Gaffie53615e22015-03-19 09:24:12 +01006160bool AudioPolicyManager::isValidAttributes(const audio_attributes_t *paa)
6161{
François Gaffiec005e562018-11-06 15:04:49 +01006162 // has flags that map to a stream type?
Eric Laurente83b55d2014-11-14 10:06:21 -08006163 if ((paa->flags & (AUDIO_FLAG_AUDIBILITY_ENFORCED | AUDIO_FLAG_SCO | AUDIO_FLAG_BEACON)) != 0) {
6164 return true;
6165 }
6166
6167 // has known usage?
6168 switch (paa->usage) {
6169 case AUDIO_USAGE_UNKNOWN:
6170 case AUDIO_USAGE_MEDIA:
6171 case AUDIO_USAGE_VOICE_COMMUNICATION:
6172 case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
6173 case AUDIO_USAGE_ALARM:
6174 case AUDIO_USAGE_NOTIFICATION:
6175 case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
6176 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
6177 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
6178 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
6179 case AUDIO_USAGE_NOTIFICATION_EVENT:
6180 case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
6181 case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
6182 case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
6183 case AUDIO_USAGE_GAME:
Eric Laurent275e8e92014-11-30 15:14:47 -08006184 case AUDIO_USAGE_VIRTUAL_SOURCE:
Jean-Michel Trivi36867762016-12-29 12:03:28 -08006185 case AUDIO_USAGE_ASSISTANT:
Eric Laurent21777f82019-12-06 18:12:06 -08006186 case AUDIO_USAGE_CALL_ASSISTANT:
Hayden Gomes524159d2019-12-23 14:41:47 -08006187 case AUDIO_USAGE_EMERGENCY:
6188 case AUDIO_USAGE_SAFETY:
6189 case AUDIO_USAGE_VEHICLE_STATUS:
6190 case AUDIO_USAGE_ANNOUNCEMENT:
Eric Laurente83b55d2014-11-14 10:06:21 -08006191 break;
6192 default:
6193 return false;
6194 }
6195 return true;
6196}
6197
François Gaffie2110e042015-03-24 08:41:51 +01006198audio_policy_forced_cfg_t AudioPolicyManager::getForceUse(audio_policy_force_use_t usage)
6199{
6200 return mEngine->getForceUse(usage);
6201}
6202
6203bool AudioPolicyManager::isInCall()
6204{
6205 return isStateInCall(mEngine->getPhoneState());
6206}
6207
6208bool AudioPolicyManager::isStateInCall(int state)
6209{
6210 return is_state_in_call(state);
6211}
6212
Eric Laurent74b71512019-11-06 17:21:57 -08006213bool AudioPolicyManager::isCallAudioAccessible()
6214{
6215 audio_mode_t mode = mEngine->getPhoneState();
6216 return (mode == AUDIO_MODE_IN_CALL)
6217 || (mode == AUDIO_MODE_IN_COMMUNICATION)
6218 || (mode == AUDIO_MODE_CALL_SCREEN);
6219}
6220
Eric Laurentd60560a2015-04-10 11:31:20 -07006221void AudioPolicyManager::cleanUpForDevice(const sp<DeviceDescriptor>& deviceDesc)
6222{
6223 for (ssize_t i = (ssize_t)mAudioSources.size() - 1; i >= 0; i--) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07006224 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
6225 if (sourceDesc->srcDevice()->equals(deviceDesc)) {
6226 ALOGV("%s releasing audio source %d", __FUNCTION__, sourceDesc->portId());
6227 stopAudioSource(sourceDesc->portId());
Eric Laurentd60560a2015-04-10 11:31:20 -07006228 }
6229 }
6230
6231 for (ssize_t i = (ssize_t)mAudioPatches.size() - 1; i >= 0; i--) {
6232 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(i);
6233 bool release = false;
6234 for (size_t j = 0; j < patchDesc->mPatch.num_sources && !release; j++) {
6235 const struct audio_port_config *source = &patchDesc->mPatch.sources[j];
6236 if (source->type == AUDIO_PORT_TYPE_DEVICE &&
6237 source->ext.device.type == deviceDesc->type()) {
6238 release = true;
6239 }
6240 }
6241 for (size_t j = 0; j < patchDesc->mPatch.num_sinks && !release; j++) {
6242 const struct audio_port_config *sink = &patchDesc->mPatch.sinks[j];
6243 if (sink->type == AUDIO_PORT_TYPE_DEVICE &&
6244 sink->ext.device.type == deviceDesc->type()) {
6245 release = true;
6246 }
6247 }
6248 if (release) {
6249 ALOGV("%s releasing patch %u", __FUNCTION__, patchDesc->mHandle);
6250 releaseAudioPatch(patchDesc->mHandle, patchDesc->mUid);
6251 }
6252 }
Francois Gaffie716e1432019-01-14 16:58:59 +01006253
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01006254 mInputs.clearSessionRoutesForDevice(deviceDesc);
6255
Francois Gaffie716e1432019-01-14 16:58:59 +01006256 mHwModules.cleanUpForDevice(deviceDesc);
Eric Laurentd60560a2015-04-10 11:31:20 -07006257}
6258
Mikhail Naganovd5e18052018-11-30 14:55:45 -08006259void AudioPolicyManager::modifySurroundFormats(
6260 const sp<DeviceDescriptor>& devDesc, FormatVector *formatsPtr) {
Mikhail Naganovd5e18052018-11-30 14:55:45 -08006261 std::unordered_set<audio_format_t> enforcedSurround(
6262 devDesc->encodedFormats().begin(), devDesc->encodedFormats().end());
Mikhail Naganov100f0122018-11-29 11:22:16 -08006263 std::unordered_set<audio_format_t> allSurround; // A flat set of all known surround formats
6264 for (const auto& pair : mConfig.getSurroundFormats()) {
6265 allSurround.insert(pair.first);
6266 for (const auto& subformat : pair.second) allSurround.insert(subformat);
6267 }
Phil Burk09bc4612016-02-24 15:58:15 -08006268
6269 audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
6270 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
Phil Burk0709b0a2016-03-31 12:54:57 -07006271 ALOGD("%s: forced use = %d", __FUNCTION__, forceUse);
Mikhail Naganov100f0122018-11-29 11:22:16 -08006272 // This is the resulting set of formats depending on the surround mode:
6273 // 'all surround' = allSurround
6274 // 'enforced surround' = enforcedSurround [may include IEC69137 which isn't raw surround fmt]
6275 // 'non-surround' = not in 'all surround' and not in 'enforced surround'
6276 // 'manual surround' = mManualSurroundFormats
6277 // AUTO: formats v 'enforced surround'
6278 // ALWAYS: formats v 'all surround' v 'enforced surround'
6279 // NEVER: formats ^ 'non-surround'
6280 // MANUAL: formats ^ ('non-surround' v 'manual surround' v (IEC69137 ^ 'enforced surround'))
Phil Burk09bc4612016-02-24 15:58:15 -08006281
Mikhail Naganovd5e18052018-11-30 14:55:45 -08006282 std::unordered_set<audio_format_t> formatSet;
6283 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL
6284 || forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08006285 // formatSet is (formats ^ 'non-surround')
Mikhail Naganovd5e18052018-11-30 14:55:45 -08006286 for (auto formatIter = formatsPtr->begin(); formatIter != formatsPtr->end(); ++formatIter) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08006287 if (allSurround.count(*formatIter) == 0 && enforcedSurround.count(*formatIter) == 0) {
Mikhail Naganovd5e18052018-11-30 14:55:45 -08006288 formatSet.insert(*formatIter);
6289 }
6290 }
6291 } else {
6292 formatSet.insert(formatsPtr->begin(), formatsPtr->end());
6293 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08006294 formatsPtr->clear(); // Re-filled from the formatSet at the end.
Mikhail Naganovd5e18052018-11-30 14:55:45 -08006295
jiabin81772902018-04-02 17:52:27 -07006296 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08006297 formatSet.insert(mManualSurroundFormats.begin(), mManualSurroundFormats.end());
Mikhail Naganovd5e18052018-11-30 14:55:45 -08006298 // Enable IEC61937 when in MANUAL mode if it's enforced for this device.
6299 if (enforcedSurround.count(AUDIO_FORMAT_IEC61937) != 0) {
6300 formatSet.insert(AUDIO_FORMAT_IEC61937);
Phil Burk09bc4612016-02-24 15:58:15 -08006301 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08006302 } else if (forceUse != AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) { // AUTO or ALWAYS
6303 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS) {
6304 formatSet.insert(allSurround.begin(), allSurround.end());
Phil Burk07ac1142016-03-25 13:39:29 -07006305 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08006306 formatSet.insert(enforcedSurround.begin(), enforcedSurround.end());
Phil Burk09bc4612016-02-24 15:58:15 -08006307 }
Mikhail Naganovd5e18052018-11-30 14:55:45 -08006308 for (const auto& format : formatSet) {
jiabin06e4bab2019-07-29 10:13:34 -07006309 formatsPtr->push_back(format);
Mikhail Naganovd5e18052018-11-30 14:55:45 -08006310 }
Phil Burk0709b0a2016-03-31 12:54:57 -07006311}
6312
jiabin06e4bab2019-07-29 10:13:34 -07006313void AudioPolicyManager::modifySurroundChannelMasks(ChannelMaskSet *channelMasksPtr) {
6314 ChannelMaskSet &channelMasks = *channelMasksPtr;
Phil Burk0709b0a2016-03-31 12:54:57 -07006315 audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
6316 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
6317
6318 // If NEVER, then remove support for channelMasks > stereo.
6319 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) {
jiabin06e4bab2019-07-29 10:13:34 -07006320 for (auto it = channelMasks.begin(); it != channelMasks.end();) {
6321 audio_channel_mask_t channelMask = *it;
Phil Burk0709b0a2016-03-31 12:54:57 -07006322 if (channelMask & ~AUDIO_CHANNEL_OUT_STEREO) {
6323 ALOGI("%s: force NEVER, so remove channelMask 0x%08x", __FUNCTION__, channelMask);
jiabin06e4bab2019-07-29 10:13:34 -07006324 it = channelMasks.erase(it);
Phil Burk0709b0a2016-03-31 12:54:57 -07006325 } else {
jiabin06e4bab2019-07-29 10:13:34 -07006326 ++it;
Phil Burk0709b0a2016-03-31 12:54:57 -07006327 }
6328 }
jiabin81772902018-04-02 17:52:27 -07006329 // If ALWAYS or MANUAL, then make sure we at least support 5.1
6330 } else if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS
6331 || forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
Phil Burk0709b0a2016-03-31 12:54:57 -07006332 bool supports5dot1 = false;
6333 // Are there any channel masks that can be considered "surround"?
Mikhail Naganovcf84e592017-12-07 11:25:11 -08006334 for (audio_channel_mask_t channelMask : channelMasks) {
Phil Burk0709b0a2016-03-31 12:54:57 -07006335 if ((channelMask & AUDIO_CHANNEL_OUT_5POINT1) == AUDIO_CHANNEL_OUT_5POINT1) {
6336 supports5dot1 = true;
6337 break;
6338 }
6339 }
6340 // If not then add 5.1 support.
6341 if (!supports5dot1) {
jiabin06e4bab2019-07-29 10:13:34 -07006342 channelMasks.insert(AUDIO_CHANNEL_OUT_5POINT1);
Mikhail Naganov100f0122018-11-29 11:22:16 -08006343 ALOGI("%s: force MANUAL or ALWAYS, so adding channelMask for 5.1 surround", __func__);
Phil Burk0709b0a2016-03-31 12:54:57 -07006344 }
Phil Burk09bc4612016-02-24 15:58:15 -08006345 }
6346}
6347
Mikhail Naganovd5e18052018-11-30 14:55:45 -08006348void AudioPolicyManager::updateAudioProfiles(const sp<DeviceDescriptor>& devDesc,
Phil Burk00eeb322016-03-31 12:41:00 -07006349 audio_io_handle_t ioHandle,
François Gaffie112b0af2015-11-19 16:13:25 +01006350 AudioProfileVector &profiles)
6351{
6352 String8 reply;
Mikhail Naganovd5e18052018-11-30 14:55:45 -08006353 audio_devices_t device = devDesc->type();
Phil Burk0709b0a2016-03-31 12:54:57 -07006354
François Gaffie112b0af2015-11-19 16:13:25 +01006355 // Format MUST be checked first to update the list of AudioProfile
6356 if (profiles.hasDynamicFormat()) {
Mikhail Naganov388360c2016-10-17 17:09:41 -07006357 reply = mpClientInterface->getParameters(
6358 ioHandle, String8(AudioParameter::keyStreamSupportedFormats));
jiabin81772902018-04-02 17:52:27 -07006359 ALOGV("%s: supported formats %d, %s", __FUNCTION__, ioHandle, reply.string());
Eric Laurent62e4bc52016-02-02 18:37:28 -08006360 AudioParameter repliedParameters(reply);
6361 if (repliedParameters.get(
Mikhail Naganov388360c2016-10-17 17:09:41 -07006362 String8(AudioParameter::keyStreamSupportedFormats), reply) != NO_ERROR) {
François Gaffie112b0af2015-11-19 16:13:25 +01006363 ALOGE("%s: failed to retrieve format, bailing out", __FUNCTION__);
6364 return;
6365 }
Phil Burk09bc4612016-02-24 15:58:15 -08006366 FormatVector formats = formatsFromString(reply.string());
Mikhail Naganov100f0122018-11-29 11:22:16 -08006367 if (device == AUDIO_DEVICE_OUT_HDMI
6368 || isDeviceOfModule(devDesc, AUDIO_HARDWARE_MODULE_ID_MSD)) {
Mikhail Naganovd5e18052018-11-30 14:55:45 -08006369 modifySurroundFormats(devDesc, &formats);
Phil Burk00eeb322016-03-31 12:41:00 -07006370 }
jiabin3e277cc2019-09-10 14:27:34 -07006371 addProfilesForFormats(profiles, formats);
François Gaffie112b0af2015-11-19 16:13:25 +01006372 }
François Gaffie112b0af2015-11-19 16:13:25 +01006373
Mikhail Naganovcf84e592017-12-07 11:25:11 -08006374 for (audio_format_t format : profiles.getSupportedFormats()) {
jiabin06e4bab2019-07-29 10:13:34 -07006375 ChannelMaskSet channelMasks;
6376 SampleRateSet samplingRates;
François Gaffie112b0af2015-11-19 16:13:25 +01006377 AudioParameter requestedParameters;
Mikhail Naganov388360c2016-10-17 17:09:41 -07006378 requestedParameters.addInt(String8(AudioParameter::keyFormat), format);
François Gaffie112b0af2015-11-19 16:13:25 +01006379
6380 if (profiles.hasDynamicRateFor(format)) {
Mikhail Naganov388360c2016-10-17 17:09:41 -07006381 reply = mpClientInterface->getParameters(
6382 ioHandle,
6383 requestedParameters.toString() + ";" +
6384 AudioParameter::keyStreamSupportedSamplingRates);
François Gaffie112b0af2015-11-19 16:13:25 +01006385 ALOGV("%s: supported sampling rates %s", __FUNCTION__, reply.string());
Eric Laurent62e4bc52016-02-02 18:37:28 -08006386 AudioParameter repliedParameters(reply);
6387 if (repliedParameters.get(
Mikhail Naganov388360c2016-10-17 17:09:41 -07006388 String8(AudioParameter::keyStreamSupportedSamplingRates), reply) == NO_ERROR) {
Eric Laurent62e4bc52016-02-02 18:37:28 -08006389 samplingRates = samplingRatesFromString(reply.string());
François Gaffie112b0af2015-11-19 16:13:25 +01006390 }
6391 }
6392 if (profiles.hasDynamicChannelsFor(format)) {
6393 reply = mpClientInterface->getParameters(ioHandle,
6394 requestedParameters.toString() + ";" +
Mikhail Naganov388360c2016-10-17 17:09:41 -07006395 AudioParameter::keyStreamSupportedChannels);
François Gaffie112b0af2015-11-19 16:13:25 +01006396 ALOGV("%s: supported channel masks %s", __FUNCTION__, reply.string());
Eric Laurent62e4bc52016-02-02 18:37:28 -08006397 AudioParameter repliedParameters(reply);
6398 if (repliedParameters.get(
Mikhail Naganov388360c2016-10-17 17:09:41 -07006399 String8(AudioParameter::keyStreamSupportedChannels), reply) == NO_ERROR) {
Eric Laurent62e4bc52016-02-02 18:37:28 -08006400 channelMasks = channelMasksFromString(reply.string());
Mikhail Naganov100f0122018-11-29 11:22:16 -08006401 if (device == AUDIO_DEVICE_OUT_HDMI
6402 || isDeviceOfModule(devDesc, AUDIO_HARDWARE_MODULE_ID_MSD)) {
Mikhail Naganovd5e18052018-11-30 14:55:45 -08006403 modifySurroundChannelMasks(&channelMasks);
Phil Burk0709b0a2016-03-31 12:54:57 -07006404 }
François Gaffie112b0af2015-11-19 16:13:25 +01006405 }
6406 }
jiabin3e277cc2019-09-10 14:27:34 -07006407 addDynamicAudioProfileAndSort(
6408 profiles, new AudioProfile(format, channelMasks, samplingRates));
François Gaffie112b0af2015-11-19 16:13:25 +01006409 }
6410}
Eric Laurentd60560a2015-04-10 11:31:20 -07006411
Mikhail Naganovdc769682018-05-04 15:34:08 -07006412status_t AudioPolicyManager::installPatch(const char *caller,
6413 audio_patch_handle_t *patchHandle,
6414 AudioIODescriptorInterface *ioDescriptor,
6415 const struct audio_patch *patch,
6416 int delayMs)
6417{
6418 ssize_t index = mAudioPatches.indexOfKey(
6419 patchHandle && *patchHandle != AUDIO_PATCH_HANDLE_NONE ?
6420 *patchHandle : ioDescriptor->getPatchHandle());
6421 sp<AudioPatch> patchDesc;
6422 status_t status = installPatch(
6423 caller, index, patchHandle, patch, delayMs, mUidCached, &patchDesc);
6424 if (status == NO_ERROR) {
6425 ioDescriptor->setPatchHandle(patchDesc->mHandle);
6426 }
6427 return status;
6428}
6429
6430status_t AudioPolicyManager::installPatch(const char *caller,
6431 ssize_t index,
6432 audio_patch_handle_t *patchHandle,
6433 const struct audio_patch *patch,
6434 int delayMs,
6435 uid_t uid,
6436 sp<AudioPatch> *patchDescPtr)
6437{
6438 sp<AudioPatch> patchDesc;
6439 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
6440 if (index >= 0) {
6441 patchDesc = mAudioPatches.valueAt(index);
6442 afPatchHandle = patchDesc->mAfPatchHandle;
6443 }
6444
6445 status_t status = mpClientInterface->createAudioPatch(patch, &afPatchHandle, delayMs);
6446 ALOGV("%s() AF::createAudioPatch returned %d patchHandle %d num_sources %d num_sinks %d",
6447 caller, status, afPatchHandle, patch->num_sources, patch->num_sinks);
6448 if (status == NO_ERROR) {
6449 if (index < 0) {
6450 patchDesc = new AudioPatch(patch, uid);
6451 addAudioPatch(patchDesc->mHandle, patchDesc);
6452 } else {
6453 patchDesc->mPatch = *patch;
6454 }
6455 patchDesc->mAfPatchHandle = afPatchHandle;
6456 if (patchHandle) {
6457 *patchHandle = patchDesc->mHandle;
6458 }
6459 nextAudioPortGeneration();
6460 mpClientInterface->onAudioPatchListUpdate();
6461 }
6462 if (patchDescPtr) *patchDescPtr = patchDesc;
6463 return status;
6464}
6465
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08006466} // namespace android