blob: 607ea4963168aaf18abc6b70f71fb399e7242f0b [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
Eric Laurent16c66dd2019-05-01 17:54:10 -070032#include <algorithm>
Eric Laurentd4692962014-05-05 18:13:44 -070033#include <inttypes.h>
jiabin10a03f12021-05-07 23:46:28 +000034#include <map>
Eric Laurente552edb2014-03-10 17:42:56 -070035#include <math.h>
Kevin Rocard153f92d2018-12-18 18:33:28 -080036#include <set>
Mikhail Naganovd5e18052018-11-30 14:55:45 -080037#include <unordered_set>
Mikhail Naganov15be9d22017-11-08 14:18:13 +110038#include <vector>
Mikhail Naganov946c0032020-10-21 13:04:58 -070039
40#include <Serializer.h>
Glenn Kasten76a13442020-07-01 12:10:59 -070041#include <cutils/bitops.h>
Eric Laurente552edb2014-03-10 17:42:56 -070042#include <cutils/properties.h>
Eric Laurent3b73df72014-03-11 09:06:29 -070043#include <media/AudioParameter.h>
Mikhail Naganov946c0032020-10-21 13:04:58 -070044#include <policy.h>
Andy Hung4ef19fa2018-05-15 19:35:29 -070045#include <private/android_filesystem_config.h>
Mikhail Naganovcbc8f612016-10-11 18:05:13 -070046#include <system/audio.h>
Mikhail Naganov27cf37c2020-04-14 14:47:01 -070047#include <system/audio_config.h>
jiabinebb6af42020-06-09 17:31:17 -070048#include <system/audio_effects/effect_hapticgenerator.h>
Mikhail Naganov946c0032020-10-21 13:04:58 -070049#include <utils/Log.h>
50
Eric Laurentd4692962014-05-05 18:13:44 -070051#include "AudioPolicyManager.h"
François Gaffiea8ecc2c2015-11-09 16:10:40 +010052#include "TypeConverter.h"
Eric Laurente552edb2014-03-10 17:42:56 -070053
Eric Laurent3b73df72014-03-11 09:06:29 -070054namespace android {
Eric Laurente552edb2014-03-10 17:42:56 -070055
Svet Ganov3e5f14f2021-05-13 22:51:08 +000056using content::AttributionSourceState;
Philip P. Moltmannbda45752020-07-17 16:41:18 -070057
Eric Laurentdc462862016-07-19 12:29:53 -070058//FIXME: workaround for truncated touch sounds
59// to be removed when the problem is handled by system UI
60#define TOUCH_SOUND_FIXED_DELAY_MS 100
Jean-Michel Trivi719a9872017-08-05 13:51:35 -070061
62// Largest difference in dB on earpiece in call between the voice volume and another
63// media / notification / system volume.
64constexpr float IN_CALL_EARPIECE_HEADROOM_DB = 3.f;
65
Mikhail Naganov15be9d22017-11-08 14:18:13 +110066// Compressed formats for MSD module, ordered from most preferred to least preferred.
Dean Wheatley8bee85a2021-02-10 16:02:23 +110067static const std::vector<audio_format_t> msdCompressedFormatsOrder = {{
68 AUDIO_FORMAT_IEC60958, AUDIO_FORMAT_MAT_2_1, AUDIO_FORMAT_MAT_2_0, AUDIO_FORMAT_E_AC3,
Mikhail Naganov15be9d22017-11-08 14:18:13 +110069 AUDIO_FORMAT_AC3, AUDIO_FORMAT_PCM_16_BIT }};
70// Channel masks for MSD module, 3D > 2D > 1D ordering (most preferred to least preferred).
Dean Wheatley8bee85a2021-02-10 16:02:23 +110071static const std::vector<audio_channel_mask_t> msdSurroundChannelMasksOrder = {{
Mikhail Naganov15be9d22017-11-08 14:18:13 +110072 AUDIO_CHANNEL_OUT_3POINT1POINT2, AUDIO_CHANNEL_OUT_3POINT0POINT2,
73 AUDIO_CHANNEL_OUT_2POINT1POINT2, AUDIO_CHANNEL_OUT_2POINT0POINT2,
74 AUDIO_CHANNEL_OUT_5POINT1, AUDIO_CHANNEL_OUT_STEREO }};
75
jiabin06e4bab2019-07-29 10:13:34 -070076template <typename T>
77bool operator== (const SortedVector<T> &left, const SortedVector<T> &right)
78{
79 if (left.size() != right.size()) {
80 return false;
81 }
82 for (size_t index = 0; index < right.size(); index++) {
83 if (left[index] != right[index]) {
84 return false;
85 }
86 }
87 return true;
88}
89
90template <typename T>
91bool operator!= (const SortedVector<T> &left, const SortedVector<T> &right)
92{
93 return !(left == right);
94}
95
Eric Laurente552edb2014-03-10 17:42:56 -070096// ----------------------------------------------------------------------------
97// AudioPolicyInterface implementation
98// ----------------------------------------------------------------------------
99
Eric Laurente0720872014-03-11 09:30:41 -0700100status_t AudioPolicyManager::setDeviceConnectionState(audio_devices_t device,
Paul McLeane743a472015-01-28 11:07:31 -0800101 audio_policy_dev_state_t state,
102 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800103 const char *device_name,
104 audio_format_t encodedFormat)
Eric Laurente552edb2014-03-10 17:42:56 -0700105{
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800106 status_t status = setDeviceConnectionStateInt(device, state, device_address,
107 device_name, encodedFormat);
jiabina7b43792018-02-15 16:04:46 -0800108 nextAudioPortGeneration();
109 return status;
Eric Laurentc73ca6e2014-12-12 14:34:22 -0800110}
111
François Gaffie11d30102018-11-02 16:09:09 +0100112void AudioPolicyManager::broadcastDeviceConnectionState(const sp<DeviceDescriptor> &device,
113 audio_policy_dev_state_t state)
François Gaffie44481e72016-04-20 07:49:57 +0200114{
jiabince9f20e2019-09-12 16:29:15 -0700115 AudioParameter param(String8(device->address().c_str()));
François Gaffie44481e72016-04-20 07:49:57 +0200116 const String8 key(state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE ?
Mikhail Naganovf23fcf62019-07-08 15:28:43 -0700117 AudioParameter::keyDeviceConnect : AudioParameter::keyDeviceDisconnect);
François Gaffie11d30102018-11-02 16:09:09 +0100118 param.addInt(key, device->type());
François Gaffie44481e72016-04-20 07:49:57 +0200119 mpClientInterface->setParameters(AUDIO_IO_HANDLE_NONE, param.toString());
120}
121
François Gaffie11d30102018-11-02 16:09:09 +0100122status_t AudioPolicyManager::setDeviceConnectionStateInt(audio_devices_t deviceType,
Eric Laurenta1d525f2015-01-29 13:36:45 -0800123 audio_policy_dev_state_t state,
Paul McLeane743a472015-01-28 11:07:31 -0800124 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800125 const char *device_name,
126 audio_format_t encodedFormat)
Eric Laurentc73ca6e2014-12-12 14:34:22 -0800127{
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800128 ALOGV("setDeviceConnectionStateInt() device: 0x%X, state %d, address %s name %s format 0x%X",
129 deviceType, state, device_address, device_name, encodedFormat);
Eric Laurente552edb2014-03-10 17:42:56 -0700130
131 // connect/disconnect only 1 device at a time
François Gaffie11d30102018-11-02 16:09:09 +0100132 if (!audio_is_output_device(deviceType) && !audio_is_input_device(deviceType)) return BAD_VALUE;
Eric Laurente552edb2014-03-10 17:42:56 -0700133
François Gaffie11d30102018-11-02 16:09:09 +0100134 sp<DeviceDescriptor> device =
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800135 mHwModules.getDeviceDescriptor(deviceType, device_address, device_name, encodedFormat,
Francois Gaffie716e1432019-01-14 16:58:59 +0100136 state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700137 return device ? setDeviceConnectionStateInt(device, state) : INVALID_OPERATION;
138}
Paul McLeane743a472015-01-28 11:07:31 -0800139
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700140status_t AudioPolicyManager::setDeviceConnectionStateInt(const sp<DeviceDescriptor> &device,
141 audio_policy_dev_state_t state)
142{
Eric Laurente552edb2014-03-10 17:42:56 -0700143 // handle output devices
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700144 if (audio_is_output_device(device->type())) {
Eric Laurentd4692962014-05-05 18:13:44 -0700145 SortedVector <audio_io_handle_t> outputs;
146
François Gaffie11d30102018-11-02 16:09:09 +0100147 ssize_t index = mAvailableOutputDevices.indexOf(device);
Eric Laurent3a4311c2014-03-17 12:00:47 -0700148
Eric Laurente552edb2014-03-10 17:42:56 -0700149 // save a copy of the opened output descriptors before any output is opened or closed
150 // by checkOutputsForDevice(). This will be needed by checkOutputForAllStrategies()
151 mPreviousOutputs = mOutputs;
Eric Laurente552edb2014-03-10 17:42:56 -0700152 switch (state)
153 {
154 // handle output device connection
Eric Laurent3ae5f312015-02-03 17:12:08 -0800155 case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700156 if (index >= 0) {
François Gaffie11d30102018-11-02 16:09:09 +0100157 ALOGW("%s() device already connected: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700158 return INVALID_OPERATION;
159 }
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800160 ALOGV("%s() connecting device %s format %x",
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700161 __func__, device->toString().c_str(), device->getEncodedFormat());
Eric Laurente552edb2014-03-10 17:42:56 -0700162
Eric Laurente552edb2014-03-10 17:42:56 -0700163 // register new device as available
Francois Gaffie993f3902019-04-10 15:39:27 +0200164 if (mAvailableOutputDevices.add(device) < 0) {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700165 return NO_MEMORY;
Eric Laurente552edb2014-03-10 17:42:56 -0700166 }
167
François Gaffie44481e72016-04-20 07:49:57 +0200168 // Before checking outputs, broadcast connect event to allow HAL to retrieve dynamic
169 // parameters on newly connected devices (instead of opening the outputs...)
François Gaffie11d30102018-11-02 16:09:09 +0100170 broadcastDeviceConnectionState(device, state);
François Gaffie44481e72016-04-20 07:49:57 +0200171
François Gaffie11d30102018-11-02 16:09:09 +0100172 if (checkOutputsForDevice(device, state, outputs) != NO_ERROR) {
173 mAvailableOutputDevices.remove(device);
François Gaffie44481e72016-04-20 07:49:57 +0200174
Francois Gaffie716e1432019-01-14 16:58:59 +0100175 mHwModules.cleanUpForDevice(device);
176
François Gaffie11d30102018-11-02 16:09:09 +0100177 broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE);
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -0700178 return INVALID_OPERATION;
179 }
François Gaffie2110e042015-03-24 08:41:51 +0100180
jiabin1c4794b2020-05-05 10:08:05 -0700181 // Populate encapsulation information when a output device is connected.
182 device->setEncapsulationInfoFromHal(mpClientInterface);
183
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -0700184 // outputs should never be empty here
185 ALOG_ASSERT(outputs.size() != 0, "setDeviceConnectionState():"
186 "checkOutputsForDevice() returned no outputs but status OK");
François Gaffie11d30102018-11-02 16:09:09 +0100187 ALOGV("%s() checkOutputsForDevice() returned %zu outputs", __func__, outputs.size());
Eric Laurent3ae5f312015-02-03 17:12:08 -0800188
Eric Laurent3ae5f312015-02-03 17:12:08 -0800189 } break;
Eric Laurente552edb2014-03-10 17:42:56 -0700190 // handle output device disconnection
Eric Laurent3b73df72014-03-11 09:06:29 -0700191 case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700192 if (index < 0) {
François Gaffie11d30102018-11-02 16:09:09 +0100193 ALOGW("%s() device not connected: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700194 return INVALID_OPERATION;
195 }
196
François Gaffie11d30102018-11-02 16:09:09 +0100197 ALOGV("%s() disconnecting output device %s", __func__, device->toString().c_str());
Paul McLean5c477aa2014-08-20 16:47:57 -0700198
Paul McLeane743a472015-01-28 11:07:31 -0800199 // Send Disconnect to HALs
François Gaffie11d30102018-11-02 16:09:09 +0100200 broadcastDeviceConnectionState(device, state);
Paul McLean5c477aa2014-08-20 16:47:57 -0700201
Eric Laurente552edb2014-03-10 17:42:56 -0700202 // remove device from available output devices
François Gaffie11d30102018-11-02 16:09:09 +0100203 mAvailableOutputDevices.remove(device);
Eric Laurente552edb2014-03-10 17:42:56 -0700204
Francois Gaffieba2cf0f2018-12-12 16:40:25 +0100205 mOutputs.clearSessionRoutesForDevice(device);
206
François Gaffie11d30102018-11-02 16:09:09 +0100207 checkOutputsForDevice(device, state, outputs);
François Gaffie2110e042015-03-24 08:41:51 +0100208
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800209 // Reset active device codec
210 device->setEncodedFormat(AUDIO_FORMAT_DEFAULT);
211
Kriti Dangef6be8f2020-11-05 11:58:19 +0100212 // remove device from mReportedFormatsMap cache
213 mReportedFormatsMap.erase(device);
214
Eric Laurente552edb2014-03-10 17:42:56 -0700215 } break;
216
217 default:
François Gaffie11d30102018-11-02 16:09:09 +0100218 ALOGE("%s() invalid state: %x", __func__, state);
Eric Laurente552edb2014-03-10 17:42:56 -0700219 return BAD_VALUE;
220 }
221
Eric Laurent736a1022019-03-27 18:28:46 -0700222 // Propagate device availability to Engine
223 setEngineDeviceConnectionState(device, state);
224
Eric Laurentae970022019-01-29 14:25:04 -0800225 // No need to evaluate playback routing when connecting a remote submix
226 // output device used by a dynamic policy of type recorder as no
227 // playback use case is affected.
228 bool doCheckForDeviceAndOutputChanges = true;
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700229 if (device->type() == AUDIO_DEVICE_OUT_REMOTE_SUBMIX && device->address() != "0") {
Eric Laurentae970022019-01-29 14:25:04 -0800230 for (audio_io_handle_t output : outputs) {
231 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
Mikhail Naganovbfac5832019-03-05 16:55:28 -0800232 sp<AudioPolicyMix> policyMix = desc->mPolicyMix.promote();
233 if (policyMix != nullptr
234 && policyMix->mMixType == MIX_TYPE_RECORDERS
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700235 && device->address() == policyMix->mDeviceAddress.string()) {
Eric Laurentae970022019-01-29 14:25:04 -0800236 doCheckForDeviceAndOutputChanges = false;
237 break;
238 }
239 }
240 }
241
242 auto checkCloseOutputs = [&]() {
Mikhail Naganov37977152018-07-11 15:54:44 -0700243 // outputs must be closed after checkOutputForAllStrategies() is executed
244 if (!outputs.isEmpty()) {
245 for (audio_io_handle_t output : outputs) {
246 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
François Gaffie11d30102018-11-02 16:09:09 +0100247 // close unused outputs after device disconnection or direct outputs that have
248 // been opened by checkOutputsForDevice() to query dynamic parameters
Eric Laurentcad6c0d2021-07-13 15:12:39 +0200249 if ((state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE)
250 || (((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) &&
Eric Laurent39095982021-08-24 18:29:27 +0200251 (desc->mDirectOpenCount == 0))) {
Francois Gaffieff1eb522020-05-06 18:37:04 +0200252 clearAudioSourcesForOutput(output);
Mikhail Naganov37977152018-07-11 15:54:44 -0700253 closeOutput(output);
254 }
Eric Laurente552edb2014-03-10 17:42:56 -0700255 }
Mikhail Naganov37977152018-07-11 15:54:44 -0700256 // check A2DP again after closing A2DP output to reset mA2dpSuspended if needed
257 return true;
Eric Laurente552edb2014-03-10 17:42:56 -0700258 }
Mikhail Naganov37977152018-07-11 15:54:44 -0700259 return false;
Eric Laurentae970022019-01-29 14:25:04 -0800260 };
261
262 if (doCheckForDeviceAndOutputChanges) {
263 checkForDeviceAndOutputChanges(checkCloseOutputs);
264 } else {
265 checkCloseOutputs();
266 }
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100267 (void)updateCallRouting(false /*fromCache*/);
jiabinbce0c1d2020-10-05 11:20:18 -0700268 std::vector<audio_io_handle_t> outputsToReopen;
François Gaffie11d30102018-11-02 16:09:09 +0100269 const DeviceVector msdOutDevices = getMsdAudioOutDevices();
jiabinbce0c1d2020-10-05 11:20:18 -0700270 const DeviceVector activeMediaDevices =
271 mEngine->getActiveMediaDevices(mAvailableOutputDevices);
Eric Laurente552edb2014-03-10 17:42:56 -0700272 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -0700273 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Jaideep Sharma89b5b852020-11-23 16:41:33 +0530274 if (desc->isActive() && ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) ||
275 (desc != mPrimaryOutput))) {
François Gaffie11d30102018-11-02 16:09:09 +0100276 DeviceVector newDevices = getNewOutputDevices(desc, true /*fromCache*/);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700277 // do not force device change on duplicated output because if device is 0, it will
278 // also force a device 0 for the two outputs it is duplicated to which may override
279 // a valid device selection on those outputs.
François Gaffie11d30102018-11-02 16:09:09 +0100280 bool force = (msdOutDevices.isEmpty() || msdOutDevices != desc->devices())
Mikhail Naganov15be9d22017-11-08 14:18:13 +1100281 && !desc->isDuplicated()
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700282 && (!device_distinguishes_on_address(device->type())
Eric Laurentc2730ba2014-07-20 15:47:07 -0700283 // always force when disconnecting (a non-duplicated device)
284 || (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
François Gaffie11d30102018-11-02 16:09:09 +0100285 setOutputDevices(desc, newDevices, force, 0);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700286 }
jiabinbce0c1d2020-10-05 11:20:18 -0700287 if (!desc->isDuplicated() && desc->mProfile->hasDynamicAudioProfile() &&
jiabin498d2152021-04-02 00:26:46 +0000288 !activeMediaDevices.empty() && desc->devices() != activeMediaDevices &&
jiabinbce0c1d2020-10-05 11:20:18 -0700289 desc->supportsDevicesForPlayback(activeMediaDevices)) {
290 // Reopen the output to query the dynamic profiles when there is not active
291 // clients or all active clients will be rerouted. Otherwise, set the flag
292 // `mPendingReopenToQueryProfiles` in the SwOutputDescriptor so that the output
293 // can be reopened to query dynamic profiles when all clients are inactive.
294 if (areAllActiveTracksRerouted(desc)) {
295 outputsToReopen.push_back(mOutputs.keyAt(i));
296 } else {
297 desc->mPendingReopenToQueryProfiles = true;
298 }
299 }
300 if (!desc->supportsDevicesForPlayback(activeMediaDevices)) {
301 // Clear the flag that previously set for re-querying profiles.
302 desc->mPendingReopenToQueryProfiles = false;
303 }
304 }
305 for (const auto& output : outputsToReopen) {
306 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
307 closeOutput(output);
308 openOutputWithProfileAndDevice(desc->mProfile, activeMediaDevices);
Eric Laurente552edb2014-03-10 17:42:56 -0700309 }
310
Eric Laurentd60560a2015-04-10 11:31:20 -0700311 if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
François Gaffie11d30102018-11-02 16:09:09 +0100312 cleanUpForDevice(device);
Eric Laurentd60560a2015-04-10 11:31:20 -0700313 }
314
Eric Laurent72aa32f2014-05-30 18:51:48 -0700315 mpClientInterface->onAudioPortListUpdate();
Eric Laurentb71e58b2014-05-29 16:08:11 -0700316 return NO_ERROR;
Eric Laurentd4692962014-05-05 18:13:44 -0700317 } // end if is output device
318
Eric Laurente552edb2014-03-10 17:42:56 -0700319 // handle input devices
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700320 if (audio_is_input_device(device->type())) {
François Gaffie11d30102018-11-02 16:09:09 +0100321 ssize_t index = mAvailableInputDevices.indexOf(device);
Eric Laurente552edb2014-03-10 17:42:56 -0700322 switch (state)
323 {
324 // handle input device connection
Eric Laurent3b73df72014-03-11 09:06:29 -0700325 case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700326 if (index >= 0) {
François Gaffie11d30102018-11-02 16:09:09 +0100327 ALOGW("%s() device already connected: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700328 return INVALID_OPERATION;
329 }
Eric Laurent0dd51852019-04-19 18:18:58 -0700330
331 if (mAvailableInputDevices.add(device) < 0) {
332 return NO_MEMORY;
333 }
334
François Gaffie44481e72016-04-20 07:49:57 +0200335 // Before checking intputs, broadcast connect event to allow HAL to retrieve dynamic
336 // parameters on newly connected devices (instead of opening the inputs...)
François Gaffie11d30102018-11-02 16:09:09 +0100337 broadcastDeviceConnectionState(device, state);
François Gaffie44481e72016-04-20 07:49:57 +0200338
Eric Laurent0dd51852019-04-19 18:18:58 -0700339 if (checkInputsForDevice(device, state) != NO_ERROR) {
340 mAvailableInputDevices.remove(device);
341
François Gaffie11d30102018-11-02 16:09:09 +0100342 broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE);
Francois Gaffie716e1432019-01-14 16:58:59 +0100343
344 mHwModules.cleanUpForDevice(device);
345
Eric Laurentd4692962014-05-05 18:13:44 -0700346 return INVALID_OPERATION;
347 }
348
Eric Laurentd4692962014-05-05 18:13:44 -0700349 } break;
Eric Laurente552edb2014-03-10 17:42:56 -0700350
351 // handle input device disconnection
Eric Laurent3b73df72014-03-11 09:06:29 -0700352 case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700353 if (index < 0) {
François Gaffie11d30102018-11-02 16:09:09 +0100354 ALOGW("%s() device not connected: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700355 return INVALID_OPERATION;
356 }
Paul McLean5c477aa2014-08-20 16:47:57 -0700357
François Gaffie11d30102018-11-02 16:09:09 +0100358 ALOGV("%s() disconnecting input device %s", __func__, device->toString().c_str());
Paul McLean5c477aa2014-08-20 16:47:57 -0700359
360 // Set Disconnect to HALs
François Gaffie11d30102018-11-02 16:09:09 +0100361 broadcastDeviceConnectionState(device, state);
Paul McLean5c477aa2014-08-20 16:47:57 -0700362
François Gaffie11d30102018-11-02 16:09:09 +0100363 mAvailableInputDevices.remove(device);
Eric Laurent0dd51852019-04-19 18:18:58 -0700364
365 checkInputsForDevice(device, state);
Kriti Dangef6be8f2020-11-05 11:58:19 +0100366
367 // remove device from mReportedFormatsMap cache
368 mReportedFormatsMap.erase(device);
Eric Laurentd4692962014-05-05 18:13:44 -0700369 } break;
Eric Laurente552edb2014-03-10 17:42:56 -0700370
371 default:
François Gaffie11d30102018-11-02 16:09:09 +0100372 ALOGE("%s() invalid state: %x", __func__, state);
Eric Laurente552edb2014-03-10 17:42:56 -0700373 return BAD_VALUE;
374 }
375
Eric Laurent736a1022019-03-27 18:28:46 -0700376 // Propagate device availability to Engine
377 setEngineDeviceConnectionState(device, state);
378
Eric Laurent0dd51852019-04-19 18:18:58 -0700379 checkCloseInputs();
Eric Laurent5f5fca52016-08-04 11:48:57 -0700380 // As the input device list can impact the output device selection, update
381 // getDeviceForStrategy() cache
382 updateDevicesAndOutputs();
Eric Laurente552edb2014-03-10 17:42:56 -0700383
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100384 (void)updateCallRouting(false /*fromCache*/);
Francois Gaffiea0e5c992020-09-29 16:05:07 +0200385 // Reconnect Audio Source
386 for (const auto &strategy : mEngine->getOrderedProductStrategies()) {
387 auto attributes = mEngine->getAllAttributesForProductStrategy(strategy).front();
388 checkAudioSourceForAttributes(attributes);
389 }
Eric Laurentd60560a2015-04-10 11:31:20 -0700390 if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
François Gaffie11d30102018-11-02 16:09:09 +0100391 cleanUpForDevice(device);
Eric Laurentd60560a2015-04-10 11:31:20 -0700392 }
393
Eric Laurentb52c1522014-05-20 11:27:36 -0700394 mpClientInterface->onAudioPortListUpdate();
Eric Laurente552edb2014-03-10 17:42:56 -0700395 return NO_ERROR;
Eric Laurentd4692962014-05-05 18:13:44 -0700396 } // end if is input device
Eric Laurente552edb2014-03-10 17:42:56 -0700397
François Gaffie11d30102018-11-02 16:09:09 +0100398 ALOGW("%s() invalid device: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700399 return BAD_VALUE;
400}
401
Eric Laurent736a1022019-03-27 18:28:46 -0700402void AudioPolicyManager::setEngineDeviceConnectionState(const sp<DeviceDescriptor> device,
403 audio_policy_dev_state_t state) {
404
405 // the Engine does not have to know about remote submix devices used by dynamic audio policies
406 if (audio_is_remote_submix_device(device->type()) && device->address() != "0") {
407 return;
408 }
409 mEngine->setDeviceConnectionState(device, state);
410}
411
412
Eric Laurente0720872014-03-11 09:30:41 -0700413audio_policy_dev_state_t AudioPolicyManager::getDeviceConnectionState(audio_devices_t device,
François Gaffie53615e22015-03-19 09:24:12 +0100414 const char *device_address)
Eric Laurente552edb2014-03-10 17:42:56 -0700415{
Eric Laurent634b7142016-04-20 13:48:02 -0700416 sp<DeviceDescriptor> devDesc =
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800417 mHwModules.getDeviceDescriptor(device, device_address, "", AUDIO_FORMAT_DEFAULT,
418 false /* allowToCreate */,
Eric Laurent634b7142016-04-20 13:48:02 -0700419 (strlen(device_address) != 0)/*matchAddress*/);
420
421 if (devDesc == 0) {
François Gaffie251c7f02018-11-07 10:41:08 +0100422 ALOGV("getDeviceConnectionState() undeclared device, type %08x, address: %s",
Eric Laurent634b7142016-04-20 13:48:02 -0700423 device, device_address);
424 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
425 }
François Gaffie53615e22015-03-19 09:24:12 +0100426
Eric Laurent3a4311c2014-03-17 12:00:47 -0700427 DeviceVector *deviceVector;
428
Eric Laurente552edb2014-03-10 17:42:56 -0700429 if (audio_is_output_device(device)) {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700430 deviceVector = &mAvailableOutputDevices;
Eric Laurente552edb2014-03-10 17:42:56 -0700431 } else if (audio_is_input_device(device)) {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700432 deviceVector = &mAvailableInputDevices;
433 } else {
François Gaffie11d30102018-11-02 16:09:09 +0100434 ALOGW("%s() invalid device type %08x", __func__, device);
Eric Laurent3a4311c2014-03-17 12:00:47 -0700435 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
Eric Laurente552edb2014-03-10 17:42:56 -0700436 }
Eric Laurent634b7142016-04-20 13:48:02 -0700437
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800438 return (deviceVector->getDevice(
439 device, String8(device_address), AUDIO_FORMAT_DEFAULT) != 0) ?
Eric Laurent634b7142016-04-20 13:48:02 -0700440 AUDIO_POLICY_DEVICE_STATE_AVAILABLE : AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
Eric Laurenta1d525f2015-01-29 13:36:45 -0800441}
442
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800443status_t AudioPolicyManager::handleDeviceConfigChange(audio_devices_t device,
444 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800445 const char *device_name,
446 audio_format_t encodedFormat)
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800447{
448 status_t status;
Aniket Kumar Lata3432e042018-04-06 14:22:15 -0700449 String8 reply;
450 AudioParameter param;
451 int isReconfigA2dpSupported = 0;
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800452
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800453 ALOGV("handleDeviceConfigChange(() device: 0x%X, address %s name %s encodedFormat: 0x%X",
454 device, device_address, device_name, encodedFormat);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800455
Pavlin Radoslavovc694ff42017-01-09 23:27:29 -0800456 // connect/disconnect only 1 device at a time
457 if (!audio_is_output_device(device) && !audio_is_input_device(device)) return BAD_VALUE;
458
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800459 // Check if the device is currently connected
jiabin9a3361e2019-10-01 09:38:30 -0700460 DeviceVector deviceList = mAvailableOutputDevices.getDevicesFromType(device);
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800461 if (deviceList.empty()) {
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800462 // Nothing to do: device is not connected
463 return NO_ERROR;
464 }
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800465 sp<DeviceDescriptor> devDesc = deviceList.itemAt(0);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800466
Aniket Kumar Lata3432e042018-04-06 14:22:15 -0700467 // For offloaded A2DP, Hw modules may have the capability to
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800468 // configure codecs.
469 // Handle two specific cases by sending a set parameter to
470 // configure A2DP codecs. No need to toggle device state.
471 // Case 1: A2DP active device switches from primary to primary
472 // module
473 // Case 2: A2DP device config changes on primary module.
Francois Gaffiebce7cd42020-10-14 16:13:20 +0200474 if (audio_is_a2dp_out_device(device) && hasPrimaryOutput()) {
jiabin9a3361e2019-10-01 09:38:30 -0700475 sp<HwModule> module = mHwModules.getModuleForDeviceType(device, encodedFormat);
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800476 audio_module_handle_t primaryHandle = mPrimaryOutput->getModuleHandle();
477 if (availablePrimaryOutputDevices().contains(devDesc) &&
478 (module != 0 && module->getHandle() == primaryHandle)) {
479 reply = mpClientInterface->getParameters(
480 AUDIO_IO_HANDLE_NONE,
481 String8(AudioParameter::keyReconfigA2dpSupported));
482 AudioParameter repliedParameters(reply);
483 repliedParameters.getInt(
484 String8(AudioParameter::keyReconfigA2dpSupported), isReconfigA2dpSupported);
485 if (isReconfigA2dpSupported) {
486 const String8 key(AudioParameter::keyReconfigA2dp);
487 param.add(key, String8("true"));
488 mpClientInterface->setParameters(AUDIO_IO_HANDLE_NONE, param.toString());
489 devDesc->setEncodedFormat(encodedFormat);
490 return NO_ERROR;
491 }
Aniket Kumar Lata3432e042018-04-06 14:22:15 -0700492 }
493 }
cnx421bd2dcc42020-07-11 14:58:44 +0800494 auto musicStrategy = streamToStrategy(AUDIO_STREAM_MUSIC);
495 for (size_t i = 0; i < mOutputs.size(); i++) {
496 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
497 // mute media strategies and delay device switch by the largest
498 // This avoid sending the music tail into the earpiece or headset.
499 setStrategyMute(musicStrategy, true, desc);
500 setStrategyMute(musicStrategy, false, desc, MUTE_TIME_MS,
501 mEngine->getOutputDevicesForAttributes(attributes_initializer(AUDIO_USAGE_MEDIA),
502 nullptr, true /*fromCache*/).types());
503 }
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800504 // Toggle the device state: UNAVAILABLE -> AVAILABLE
505 // This will force reading again the device configuration
506 status = setDeviceConnectionState(device,
507 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800508 device_address, device_name,
509 devDesc->getEncodedFormat());
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800510 if (status != NO_ERROR) {
511 ALOGW("handleDeviceConfigChange() error disabling connection state: %d",
512 status);
513 return status;
514 }
515
516 status = setDeviceConnectionState(device,
517 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800518 device_address, device_name, encodedFormat);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800519 if (status != NO_ERROR) {
520 ALOGW("handleDeviceConfigChange() error enabling connection state: %d",
521 status);
522 return status;
523 }
524
525 return NO_ERROR;
526}
527
Pattydd807582021-11-04 21:01:03 +0800528status_t AudioPolicyManager::getHwOffloadFormatsSupportedForBluetoothMedia(
529 audio_devices_t device, std::vector<audio_format_t> *formats)
Arun Mirpuri11029ad2018-12-19 20:45:19 -0800530{
Pattydd807582021-11-04 21:01:03 +0800531 ALOGV("getHwOffloadFormatsSupportedForBluetoothMedia()");
Arun Mirpuri11029ad2018-12-19 20:45:19 -0800532 status_t status = NO_ERROR;
Aniket Kumar Lata89e82232019-01-19 18:14:10 -0800533 std::unordered_set<audio_format_t> formatSet;
534 sp<HwModule> primaryModule =
535 mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_PRIMARY);
Aniket Kumar Latafedb5982019-07-03 11:20:36 -0700536 if (primaryModule == nullptr) {
537 ALOGE("%s() unable to get primary module", __func__);
538 return NO_INIT;
539 }
Pattydd807582021-11-04 21:01:03 +0800540
541 DeviceTypeSet audioDeviceSet;
542
543 switch(device) {
544 case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP:
545 audioDeviceSet = getAudioDeviceOutAllA2dpSet();
546 break;
547 case AUDIO_DEVICE_OUT_BLE_HEADSET:
548 audioDeviceSet = getAudioDeviceOutAllBleSet();
549 break;
550 default:
551 ALOGE("%s() device type 0x%08x not supported", __func__, device);
552 return BAD_VALUE;
553 }
554
jiabin9a3361e2019-10-01 09:38:30 -0700555 DeviceVector declaredDevices = primaryModule->getDeclaredDevices().getDevicesFromTypes(
Pattydd807582021-11-04 21:01:03 +0800556 audioDeviceSet);
Aniket Kumar Lata89e82232019-01-19 18:14:10 -0800557 for (const auto& device : declaredDevices) {
558 formatSet.insert(device->encodedFormats().begin(), device->encodedFormats().end());
Arun Mirpuri11029ad2018-12-19 20:45:19 -0800559 }
Aniket Kumar Lata89e82232019-01-19 18:14:10 -0800560 formats->assign(formatSet.begin(), formatSet.end());
Arun Mirpuri11029ad2018-12-19 20:45:19 -0800561 return status;
562}
563
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100564DeviceVector AudioPolicyManager::selectBestRxSinkDevicesForCall(bool fromCache)
565{
566 DeviceVector rxSinkdevices{};
567 rxSinkdevices = mEngine->getOutputDevicesForAttributes(
568 attributes_initializer(AUDIO_USAGE_VOICE_COMMUNICATION), nullptr, fromCache);
569 if (!rxSinkdevices.isEmpty() && mAvailableOutputDevices.contains(rxSinkdevices.itemAt(0))) {
570 auto rxSinkDevice = rxSinkdevices.itemAt(0);
571 auto telephonyRxModule = mHwModules.getModuleForDeviceType(
572 AUDIO_DEVICE_IN_TELEPHONY_RX, AUDIO_FORMAT_DEFAULT);
573 // retrieve Rx Source device descriptor
574 sp<DeviceDescriptor> rxSourceDevice = mAvailableInputDevices.getDevice(
575 AUDIO_DEVICE_IN_TELEPHONY_RX, String8(), AUDIO_FORMAT_DEFAULT);
576
577 // RX Telephony and Rx sink devices are declared by Primary Audio HAL
578 if (isPrimaryModule(telephonyRxModule) && (telephonyRxModule->getHalVersionMajor() >= 3) &&
579 telephonyRxModule->supportsPatch(rxSourceDevice, rxSinkDevice)) {
580 ALOGW("%s() device %s using HW Bridge", __func__, rxSinkDevice->toString().c_str());
581 return DeviceVector(rxSinkDevice);
582 }
583 }
584 // Note that despite the fact that getNewOutputDevices() is called on the primary output,
585 // the device returned is not necessarily reachable via this output
586 // (filter later by setOutputDevices())
587 return getNewOutputDevices(mPrimaryOutput, fromCache);
588}
589
590status_t AudioPolicyManager::updateCallRouting(bool fromCache, uint32_t delayMs, uint32_t *waitMs)
591{
592 if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
593 DeviceVector rxDevices = selectBestRxSinkDevicesForCall(fromCache);
594 return updateCallRoutingInternal(rxDevices, delayMs, waitMs);
595 }
596 return INVALID_OPERATION;
597}
598
599status_t AudioPolicyManager::updateCallRoutingInternal(
600 const DeviceVector &rxDevices, uint32_t delayMs, uint32_t *waitMs)
Eric Laurentc2730ba2014-07-20 15:47:07 -0700601{
602 bool createTxPatch = false;
François Gaffie9eb18552018-11-05 10:33:26 +0100603 bool createRxPatch = false;
Eric Laurentdc462862016-07-19 12:29:53 -0700604 uint32_t muteWaitMs = 0;
jiabin9a3361e2019-10-01 09:38:30 -0700605 if(!hasPrimaryOutput() ||
606 mPrimaryOutput->devices().onlyContainsDevicesWithType(AUDIO_DEVICE_OUT_STUB)) {
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100607 return INVALID_OPERATION;
Eric Laurent87ffa392015-05-22 10:32:38 -0700608 }
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100609 ALOG_ASSERT(!rxDevices.isEmpty(), "%s() no selected output device", __func__);
François Gaffie11d30102018-11-02 16:09:09 +0100610
Francois Gaffie716e1432019-01-14 16:58:59 +0100611 audio_attributes_t attr = { .source = AUDIO_SOURCE_VOICE_COMMUNICATION };
François Gaffiec005e562018-11-06 15:04:49 +0100612 auto txSourceDevice = mEngine->getInputDeviceForAttributes(attr);
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100613 ALOG_ASSERT(txSourceDevice != 0, "%s() input selected device not available", __func__);
François Gaffiec005e562018-11-06 15:04:49 +0100614
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100615 ALOGV("%s device rxDevice %s txDevice %s", __func__,
François Gaffie9eb18552018-11-05 10:33:26 +0100616 rxDevices.itemAt(0)->toString().c_str(), txSourceDevice->toString().c_str());
Eric Laurentc2730ba2014-07-20 15:47:07 -0700617
Francois Gaffie51c9ccd2020-10-14 18:02:07 +0200618 disconnectTelephonyRxAudioSource();
Eric Laurentc2730ba2014-07-20 15:47:07 -0700619 // release TX patch if any
620 if (mCallTxPatch != 0) {
François Gaffieafd4cea2019-11-18 15:50:22 +0100621 releaseAudioPatchInternal(mCallTxPatch->getHandle());
Eric Laurentc2730ba2014-07-20 15:47:07 -0700622 mCallTxPatch.clear();
623 }
624
François Gaffie9eb18552018-11-05 10:33:26 +0100625 auto telephonyRxModule =
jiabin9a3361e2019-10-01 09:38:30 -0700626 mHwModules.getModuleForDeviceType(AUDIO_DEVICE_IN_TELEPHONY_RX, AUDIO_FORMAT_DEFAULT);
François Gaffie9eb18552018-11-05 10:33:26 +0100627 auto telephonyTxModule =
jiabin9a3361e2019-10-01 09:38:30 -0700628 mHwModules.getModuleForDeviceType(AUDIO_DEVICE_OUT_TELEPHONY_TX, AUDIO_FORMAT_DEFAULT);
François Gaffie9eb18552018-11-05 10:33:26 +0100629 // retrieve Rx Source and Tx Sink device descriptors
630 sp<DeviceDescriptor> rxSourceDevice =
631 mAvailableInputDevices.getDevice(AUDIO_DEVICE_IN_TELEPHONY_RX,
632 String8(),
633 AUDIO_FORMAT_DEFAULT);
634 sp<DeviceDescriptor> txSinkDevice =
635 mAvailableOutputDevices.getDevice(AUDIO_DEVICE_OUT_TELEPHONY_TX,
636 String8(),
637 AUDIO_FORMAT_DEFAULT);
638
639 // RX and TX Telephony device are declared by Primary Audio HAL
640 if (isPrimaryModule(telephonyRxModule) && isPrimaryModule(telephonyTxModule) &&
641 (telephonyRxModule->getHalVersionMajor() >= 3)) {
642 if (rxSourceDevice == 0 || txSinkDevice == 0) {
643 // RX / TX Telephony device(s) is(are) not currently available
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100644 ALOGE("%s() no telephony Tx and/or RX device", __func__);
645 return INVALID_OPERATION;
François Gaffie9eb18552018-11-05 10:33:26 +0100646 }
François Gaffieafd4cea2019-11-18 15:50:22 +0100647 // createAudioPatchInternal now supports both HW / SW bridging
648 createRxPatch = true;
649 createTxPatch = true;
François Gaffie9eb18552018-11-05 10:33:26 +0100650 } else {
651 // If the RX device is on the primary HW module, then use legacy routing method for
652 // voice calls via setOutputDevice() on primary output.
653 // Otherwise, create two audio patches for TX and RX path.
654 createRxPatch = !(availablePrimaryOutputDevices().contains(rxDevices.itemAt(0))) &&
655 (rxSourceDevice != 0);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700656 // If the TX device is also on the primary HW module, setOutputDevice() will take care
657 // of it due to legacy implementation. If not, create a patch.
François Gaffie9eb18552018-11-05 10:33:26 +0100658 createTxPatch = !(availablePrimaryModuleInputDevices().contains(txSourceDevice)) &&
659 (txSinkDevice != 0);
660 }
661 // Use legacy routing method for voice calls via setOutputDevice() on primary output.
662 // Otherwise, create two audio patches for TX and RX path.
663 if (!createRxPatch) {
664 muteWaitMs = setOutputDevices(mPrimaryOutput, rxDevices, true, delayMs);
Eric Laurent8ae73122016-04-12 10:13:29 -0700665 } else { // create RX path audio patch
Francois Gaffie51c9ccd2020-10-14 18:02:07 +0200666 connectTelephonyRxAudioSource();
juyuchen2224c5a2019-01-21 12:00:58 +0800667 // If the TX device is on the primary HW module but RX device is
668 // on other HW module, SinkMetaData of telephony input should handle it
669 // assuming the device uses audio HAL V5.0 and above
Eric Laurentc2730ba2014-07-20 15:47:07 -0700670 }
Eric Laurent8ae73122016-04-12 10:13:29 -0700671 if (createTxPatch) { // create TX path audio patch
François Gaffieafd4cea2019-11-18 15:50:22 +0100672 // terminate active capture if on the same HW module as the call TX source device
673 // FIXME: would be better to refine to only inputs whose profile connects to the
674 // call TX device but this information is not in the audio patch and logic here must be
675 // symmetric to the one in startInput()
676 for (const auto& activeDesc : mInputs.getActiveInputs()) {
677 if (activeDesc->hasSameHwModuleAs(txSourceDevice)) {
678 closeActiveClients(activeDesc);
679 }
680 }
François Gaffie9eb18552018-11-05 10:33:26 +0100681 mCallTxPatch = createTelephonyPatch(false /*isRx*/, txSourceDevice, delayMs);
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800682 }
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100683 if (waitMs != nullptr) {
684 *waitMs = muteWaitMs;
685 }
686 return NO_ERROR;
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800687}
Eric Laurentc2730ba2014-07-20 15:47:07 -0700688
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800689sp<AudioPatch> AudioPolicyManager::createTelephonyPatch(
François Gaffie11d30102018-11-02 16:09:09 +0100690 bool isRx, const sp<DeviceDescriptor> &device, uint32_t delayMs) {
Mikhail Naganovdc769682018-05-04 15:34:08 -0700691 PatchBuilder patchBuilder;
Eric Laurentc2730ba2014-07-20 15:47:07 -0700692
François Gaffie11d30102018-11-02 16:09:09 +0100693 if (device == nullptr) {
694 return nullptr;
695 }
François Gaffieafd4cea2019-11-18 15:50:22 +0100696
697 // @TODO: still ignoring the address, or not dealing platform with multiple telephony devices
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800698 if (isRx) {
François Gaffie11d30102018-11-02 16:09:09 +0100699 patchBuilder.addSink(device).
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800700 addSource(mAvailableInputDevices.getDevice(
701 AUDIO_DEVICE_IN_TELEPHONY_RX, String8(), AUDIO_FORMAT_DEFAULT));
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800702 } else {
François Gaffie11d30102018-11-02 16:09:09 +0100703 patchBuilder.addSource(device).
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800704 addSink(mAvailableOutputDevices.getDevice(
705 AUDIO_DEVICE_OUT_TELEPHONY_TX, String8(), AUDIO_FORMAT_DEFAULT));
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800706 }
707
François Gaffieafd4cea2019-11-18 15:50:22 +0100708 audio_patch_handle_t patchHandle = AUDIO_PATCH_HANDLE_NONE;
709 status_t status =
710 createAudioPatchInternal(patchBuilder.patch(), &patchHandle, mUidCached, delayMs);
711 ssize_t index = mAudioPatches.indexOfKey(patchHandle);
712 if (status != NO_ERROR || index < 0) {
713 ALOGW("%s() error %d creating %s audio patch", __func__, status, isRx ? "RX" : "TX");
714 return nullptr;
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800715 }
François Gaffieafd4cea2019-11-18 15:50:22 +0100716 return mAudioPatches.valueAt(index);
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800717}
718
Mikhail Naganov100f0122018-11-29 11:22:16 -0800719bool AudioPolicyManager::isDeviceOfModule(
720 const sp<DeviceDescriptor>& devDesc, const char *moduleId) const {
721 sp<HwModule> module = mHwModules.getModuleFromName(moduleId);
722 if (module != 0) {
723 return mAvailableOutputDevices.getDevicesFromHwModule(module->getHandle())
724 .indexOf(devDesc) != NAME_NOT_FOUND
725 || mAvailableInputDevices.getDevicesFromHwModule(module->getHandle())
726 .indexOf(devDesc) != NAME_NOT_FOUND;
727 }
728 return false;
729}
730
Francois Gaffie51c9ccd2020-10-14 18:02:07 +0200731void AudioPolicyManager::connectTelephonyRxAudioSource()
732{
733 disconnectTelephonyRxAudioSource();
734 const struct audio_port_config source = {
735 .role = AUDIO_PORT_ROLE_SOURCE, .type = AUDIO_PORT_TYPE_DEVICE,
736 .ext.device.type = AUDIO_DEVICE_IN_TELEPHONY_RX, .ext.device.address = ""
737 };
738 const auto aa = mEngine->getAttributesForStreamType(AUDIO_STREAM_VOICE_CALL);
739 status_t status = startAudioSource(&source, &aa, &mCallRxSourceClientPort, 0/*uid*/);
740 ALOGE_IF(status != NO_ERROR, "%s failed to start Telephony Rx AudioSource", __func__);
741}
742
743void AudioPolicyManager::disconnectTelephonyRxAudioSource()
744{
745 stopAudioSource(mCallRxSourceClientPort);
746 mCallRxSourceClientPort = AUDIO_PORT_HANDLE_NONE;
747}
748
Eric Laurente0720872014-03-11 09:30:41 -0700749void AudioPolicyManager::setPhoneState(audio_mode_t state)
Eric Laurente552edb2014-03-10 17:42:56 -0700750{
751 ALOGV("setPhoneState() state %d", state);
François Gaffie2110e042015-03-24 08:41:51 +0100752 // store previous phone state for management of sonification strategy below
753 int oldState = mEngine->getPhoneState();
754
755 if (mEngine->setPhoneState(state) != NO_ERROR) {
756 ALOGW("setPhoneState() invalid or same state %d", state);
Eric Laurente552edb2014-03-10 17:42:56 -0700757 return;
758 }
François Gaffie2110e042015-03-24 08:41:51 +0100759 /// Opens: can these line be executed after the switch of volume curves???
Eric Laurent63dea1d2015-07-02 17:10:28 -0700760 if (isStateInCall(oldState)) {
Eric Laurente552edb2014-03-10 17:42:56 -0700761 ALOGV("setPhoneState() in call state management: new state is %d", state);
Eric Laurent63dea1d2015-07-02 17:10:28 -0700762 // force reevaluating accessibility routing when call stops
Eric Laurent2cbe89a2014-12-19 11:49:08 -0800763 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
Eric Laurente552edb2014-03-10 17:42:56 -0700764 }
765
François Gaffie2110e042015-03-24 08:41:51 +0100766 /**
767 * Switching to or from incall state or switching between telephony and VoIP lead to force
768 * routing command.
769 */
Eric Laurent74b71512019-11-06 17:21:57 -0800770 bool force = ((isStateInCall(oldState) != isStateInCall(state))
771 || (isStateInCall(state) && (state != oldState)));
Eric Laurente552edb2014-03-10 17:42:56 -0700772
773 // check for device and output changes triggered by new phone state
Mikhail Naganov37977152018-07-11 15:54:44 -0700774 checkForDeviceAndOutputChanges();
Eric Laurente552edb2014-03-10 17:42:56 -0700775
Eric Laurente552edb2014-03-10 17:42:56 -0700776 int delayMs = 0;
777 if (isStateInCall(state)) {
778 nsecs_t sysTime = systemTime();
François Gaffiec005e562018-11-06 15:04:49 +0100779 auto musicStrategy = streamToStrategy(AUDIO_STREAM_MUSIC);
780 auto sonificationStrategy = streamToStrategy(AUDIO_STREAM_ALARM);
Eric Laurente552edb2014-03-10 17:42:56 -0700781 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -0700782 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Eric Laurente552edb2014-03-10 17:42:56 -0700783 // mute media and sonification strategies and delay device switch by the largest
784 // latency of any output where either strategy is active.
785 // This avoid sending the ring tone or music tail into the earpiece or headset.
François Gaffiec005e562018-11-06 15:04:49 +0100786 if ((desc->isStrategyActive(musicStrategy, SONIFICATION_HEADSET_MUSIC_DELAY, sysTime) ||
787 desc->isStrategyActive(sonificationStrategy, SONIFICATION_HEADSET_MUSIC_DELAY,
788 sysTime)) &&
Eric Laurentc75307b2015-03-17 15:29:32 -0700789 (delayMs < (int)desc->latency()*2)) {
790 delayMs = desc->latency()*2;
Eric Laurente552edb2014-03-10 17:42:56 -0700791 }
François Gaffiec005e562018-11-06 15:04:49 +0100792 setStrategyMute(musicStrategy, true, desc);
793 setStrategyMute(musicStrategy, false, desc, MUTE_TIME_MS,
794 mEngine->getOutputDevicesForAttributes(attributes_initializer(AUDIO_USAGE_MEDIA),
795 nullptr, true /*fromCache*/).types());
796 setStrategyMute(sonificationStrategy, true, desc);
797 setStrategyMute(sonificationStrategy, false, desc, MUTE_TIME_MS,
798 mEngine->getOutputDevicesForAttributes(attributes_initializer(AUDIO_USAGE_ALARM),
799 nullptr, true /*fromCache*/).types());
Eric Laurente552edb2014-03-10 17:42:56 -0700800 }
801 }
802
Eric Laurent87ffa392015-05-22 10:32:38 -0700803 if (hasPrimaryOutput()) {
Eric Laurent87ffa392015-05-22 10:32:38 -0700804 if (state == AUDIO_MODE_IN_CALL) {
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100805 (void)updateCallRouting(false /*fromCache*/, delayMs);
Eric Laurent87ffa392015-05-22 10:32:38 -0700806 } else {
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100807 DeviceVector rxDevices = getNewOutputDevices(mPrimaryOutput, false /*fromCache*/);
808 // force routing command to audio hardware when ending call
809 // even if no device change is needed
810 if (isStateInCall(oldState) && rxDevices.isEmpty()) {
811 rxDevices = mPrimaryOutput->devices();
812 }
813 if (oldState == AUDIO_MODE_IN_CALL) {
814 disconnectTelephonyRxAudioSource();
815 if (mCallTxPatch != 0) {
816 releaseAudioPatchInternal(mCallTxPatch->getHandle());
817 mCallTxPatch.clear();
818 }
819 }
François Gaffie11d30102018-11-02 16:09:09 +0100820 setOutputDevices(mPrimaryOutput, rxDevices, force, 0);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700821 }
Eric Laurentc2730ba2014-07-20 15:47:07 -0700822 }
Eric Laurent2e2a8a92018-04-20 16:21:33 -0700823
824 // reevaluate routing on all outputs in case tracks have been started during the call
825 for (size_t i = 0; i < mOutputs.size(); i++) {
826 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
François Gaffie11d30102018-11-02 16:09:09 +0100827 DeviceVector newDevices = getNewOutputDevices(desc, true /*fromCache*/);
Eric Laurent2e2a8a92018-04-20 16:21:33 -0700828 if (state != AUDIO_MODE_IN_CALL || desc != mPrimaryOutput) {
François Gaffie11d30102018-11-02 16:09:09 +0100829 setOutputDevices(desc, newDevices, !newDevices.isEmpty(), 0 /*delayMs*/);
Eric Laurent2e2a8a92018-04-20 16:21:33 -0700830 }
831 }
832
Eric Laurente552edb2014-03-10 17:42:56 -0700833 if (isStateInCall(state)) {
834 ALOGV("setPhoneState() in call state management: new state is %d", state);
Eric Laurent63dea1d2015-07-02 17:10:28 -0700835 // force reevaluating accessibility routing when call starts
836 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
Eric Laurente552edb2014-03-10 17:42:56 -0700837 }
838
839 // Flag that ringtone volume must be limited to music volume until we exit MODE_RINGTONE
François Gaffiec005e562018-11-06 15:04:49 +0100840 mLimitRingtoneVolume = (state == AUDIO_MODE_RINGTONE &&
841 isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY));
Eric Laurente552edb2014-03-10 17:42:56 -0700842}
843
Jean-Michel Trivi887a9ed2015-03-31 18:02:24 -0700844audio_mode_t AudioPolicyManager::getPhoneState() {
845 return mEngine->getPhoneState();
846}
847
Eric Laurente0720872014-03-11 09:30:41 -0700848void AudioPolicyManager::setForceUse(audio_policy_force_use_t usage,
François Gaffie11d30102018-11-02 16:09:09 +0100849 audio_policy_forced_cfg_t config)
Eric Laurente552edb2014-03-10 17:42:56 -0700850{
François Gaffie2110e042015-03-24 08:41:51 +0100851 ALOGV("setForceUse() usage %d, config %d, mPhoneState %d", usage, config, mEngine->getPhoneState());
Eric Laurent8dc87a62017-05-16 19:00:40 -0700852 if (config == mEngine->getForceUse(usage)) {
853 return;
854 }
Eric Laurente552edb2014-03-10 17:42:56 -0700855
François Gaffie2110e042015-03-24 08:41:51 +0100856 if (mEngine->setForceUse(usage, config) != NO_ERROR) {
857 ALOGW("setForceUse() could not set force cfg %d for usage %d", config, usage);
858 return;
Eric Laurente552edb2014-03-10 17:42:56 -0700859 }
François Gaffie2110e042015-03-24 08:41:51 +0100860 bool forceVolumeReeval = (usage == AUDIO_POLICY_FORCE_FOR_COMMUNICATION) ||
861 (usage == AUDIO_POLICY_FORCE_FOR_DOCK) ||
862 (usage == AUDIO_POLICY_FORCE_FOR_SYSTEM);
Eric Laurente552edb2014-03-10 17:42:56 -0700863
864 // check for device and output changes triggered by new force usage
Mikhail Naganov37977152018-07-11 15:54:44 -0700865 checkForDeviceAndOutputChanges();
Phil Burk09bc4612016-02-24 15:58:15 -0800866
Eric Laurent22fcda22019-05-17 16:28:47 -0700867 // force client reconnection to reevaluate flag AUDIO_FLAG_AUDIBILITY_ENFORCED
868 if (usage == AUDIO_POLICY_FORCE_FOR_SYSTEM) {
869 mpClientInterface->invalidateStream(AUDIO_STREAM_SYSTEM);
870 mpClientInterface->invalidateStream(AUDIO_STREAM_ENFORCED_AUDIBLE);
871 }
872
Eric Laurentdc462862016-07-19 12:29:53 -0700873 //FIXME: workaround for truncated touch sounds
874 // to be removed when the problem is handled by system UI
875 uint32_t delayMs = 0;
Eric Laurentdc462862016-07-19 12:29:53 -0700876 if (usage == AUDIO_POLICY_FORCE_FOR_COMMUNICATION) {
877 delayMs = TOUCH_SOUND_FIXED_DELAY_MS;
878 }
Jean-Michel Trivi30857152019-11-01 11:04:15 -0700879
880 updateCallAndOutputRouting(forceVolumeReeval, delayMs);
Eric Laurent2517af32020-11-25 15:31:27 +0100881 updateInputRouting();
Eric Laurente552edb2014-03-10 17:42:56 -0700882}
883
Eric Laurente0720872014-03-11 09:30:41 -0700884void AudioPolicyManager::setSystemProperty(const char* property, const char* value)
Eric Laurente552edb2014-03-10 17:42:56 -0700885{
886 ALOGV("setSystemProperty() property %s, value %s", property, value);
887}
888
Michael Chana94fbb22018-04-24 14:31:19 +1000889// Find an output profile compatible with the parameters passed. When "directOnly" is set, restrict
890// search to profiles for direct outputs.
891sp<IOProfile> AudioPolicyManager::getProfileForOutput(
François Gaffie11d30102018-11-02 16:09:09 +0100892 const DeviceVector& devices,
Michael Chana94fbb22018-04-24 14:31:19 +1000893 uint32_t samplingRate,
894 audio_format_t format,
895 audio_channel_mask_t channelMask,
896 audio_output_flags_t flags,
897 bool directOnly)
Eric Laurente552edb2014-03-10 17:42:56 -0700898{
Michael Chana94fbb22018-04-24 14:31:19 +1000899 if (directOnly) {
900 // only retain flags that will drive the direct output profile selection
901 // if explicitly requested
902 static const uint32_t kRelevantFlags =
903 (AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD |
Aniket Kumar Lataba810b82019-07-03 11:15:33 -0700904 AUDIO_OUTPUT_FLAG_VOIP_RX | AUDIO_OUTPUT_FLAG_MMAP_NOIRQ);
Michael Chana94fbb22018-04-24 14:31:19 +1000905 flags =
906 (audio_output_flags_t)((flags & kRelevantFlags) | AUDIO_OUTPUT_FLAG_DIRECT);
907 }
Eric Laurent861a6282015-05-18 15:40:16 -0700908
909 sp<IOProfile> profile;
910
Mikhail Naganovd4120142017-12-06 15:49:22 -0800911 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -0800912 for (const auto& curProfile : hwModule->getOutputProfiles()) {
François Gaffie11d30102018-11-02 16:09:09 +0100913 if (!curProfile->isCompatibleProfile(devices,
Andy Hungf129b032015-04-07 13:45:50 -0700914 samplingRate, NULL /*updatedSamplingRate*/,
915 format, NULL /*updatedFormat*/,
916 channelMask, NULL /*updatedChannelMask*/,
Eric Laurent861a6282015-05-18 15:40:16 -0700917 flags)) {
918 continue;
919 }
920 // reject profiles not corresponding to a device currently available
François Gaffie11d30102018-11-02 16:09:09 +0100921 if (!mAvailableOutputDevices.containsAtLeastOne(curProfile->getSupportedDevices())) {
Eric Laurent861a6282015-05-18 15:40:16 -0700922 continue;
923 }
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800924 // reject profiles if connected device does not support codec
jiabin9a3361e2019-10-01 09:38:30 -0700925 if (!curProfile->devicesSupportEncodedFormats(devices.types())) {
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800926 continue;
927 }
Michael Chana94fbb22018-04-24 14:31:19 +1000928 if (!directOnly) return curProfile;
929 // when searching for direct outputs, if several profiles are compatible, give priority
930 // to one with offload capability
François Gaffiea8ecc2c2015-11-09 16:10:40 +0100931 if (profile != 0 && ((curProfile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0)) {
Eric Laurent861a6282015-05-18 15:40:16 -0700932 continue;
933 }
934 profile = curProfile;
François Gaffiea8ecc2c2015-11-09 16:10:40 +0100935 if ((profile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
Eric Laurent861a6282015-05-18 15:40:16 -0700936 break;
Eric Laurent3a4311c2014-03-17 12:00:47 -0700937 }
Eric Laurente552edb2014-03-10 17:42:56 -0700938 }
939 }
Eric Laurent861a6282015-05-18 15:40:16 -0700940 return profile;
Eric Laurente552edb2014-03-10 17:42:56 -0700941}
942
Eric Laurentfa0f6742021-08-17 18:39:44 +0200943sp<IOProfile> AudioPolicyManager::getSpatializerOutputProfile(
Eric Laurent39095982021-08-24 18:29:27 +0200944 const audio_config_t *config __unused, const AudioDeviceTypeAddrVector &devices) const
Eric Laurentcad6c0d2021-07-13 15:12:39 +0200945{
946 for (const auto& hwModule : mHwModules) {
947 for (const auto& curProfile : hwModule->getOutputProfiles()) {
Eric Laurent1c5e2e32021-08-18 18:50:28 +0200948 if (curProfile->getFlags() != AUDIO_OUTPUT_FLAG_SPATIALIZER) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +0200949 continue;
950 }
951 // reject profiles not corresponding to a device currently available
952 DeviceVector supportedDevices = curProfile->getSupportedDevices();
953 if (!mAvailableOutputDevices.containsAtLeastOne(supportedDevices)) {
954 continue;
955 }
956 if (!devices.empty()) {
957 if (supportedDevices.getDevicesFromDeviceTypeAddrVec(devices).size()
958 != devices.size()) {
959 continue;
960 }
961 }
Eric Laurentcad6c0d2021-07-13 15:12:39 +0200962 ALOGV("%s found profile %s", __func__, curProfile->getName().c_str());
963 return curProfile;
964 }
965 }
966 return nullptr;
967}
968
Eric Laurentf4e63452017-11-06 19:31:46 +0000969audio_io_handle_t AudioPolicyManager::getOutput(audio_stream_type_t stream)
Eric Laurente552edb2014-03-10 17:42:56 -0700970{
François Gaffiec005e562018-11-06 15:04:49 +0100971 DeviceVector devices = mEngine->getOutputDevicesForStream(stream, false /*fromCache*/);
Andy Hungc9901522017-11-10 20:07:54 -0800972
973 // Note that related method getOutputForAttr() uses getOutputForDevice() not selectOutput().
974 // We use selectOutput() here since we don't have the desired AudioTrack sample rate,
975 // format, flags, etc. This may result in some discrepancy for functions that utilize
976 // getOutput() solely on audio_stream_type such as AudioSystem::getOutputFrameCount()
977 // and AudioSystem::getOutputSamplingRate().
978
François Gaffie11d30102018-11-02 16:09:09 +0100979 SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
Eric Laurent16c66dd2019-05-01 17:54:10 -0700980 const audio_io_handle_t output = selectOutput(outputs);
Eric Laurente552edb2014-03-10 17:42:56 -0700981
François Gaffie11d30102018-11-02 16:09:09 +0100982 ALOGV("getOutput() stream %d selected devices %s, output %d", stream,
983 devices.toString().c_str(), output);
Eric Laurentf4e63452017-11-06 19:31:46 +0000984 return output;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700985}
986
Hongwei Wangbb93dfb2018-10-23 13:54:22 -0700987status_t AudioPolicyManager::getAudioAttributes(audio_attributes_t *dstAttr,
988 const audio_attributes_t *srcAttr,
989 audio_stream_type_t srcStream)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700990{
Hongwei Wangbb93dfb2018-10-23 13:54:22 -0700991 if (srcAttr != NULL) {
992 if (!isValidAttributes(srcAttr)) {
993 ALOGE("%s invalid attributes: usage=%d content=%d flags=0x%x tags=[%s]",
994 __func__,
995 srcAttr->usage, srcAttr->content_type, srcAttr->flags,
996 srcAttr->tags);
997 return BAD_VALUE;
998 }
999 *dstAttr = *srcAttr;
1000 } else {
1001 if (srcStream < AUDIO_STREAM_MIN || srcStream >= AUDIO_STREAM_PUBLIC_CNT) {
1002 ALOGE("%s: invalid stream type", __func__);
1003 return BAD_VALUE;
1004 }
François Gaffiec005e562018-11-06 15:04:49 +01001005 *dstAttr = mEngine->getAttributesForStreamType(srcStream);
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001006 }
Eric Laurent22fcda22019-05-17 16:28:47 -07001007
1008 // Only honor audibility enforced when required. The client will be
1009 // forced to reconnect if the forced usage changes.
1010 if (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) != AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
Mikhail Naganov55773032020-10-01 15:08:13 -07001011 dstAttr->flags = static_cast<audio_flags_mask_t>(
1012 dstAttr->flags & ~AUDIO_FLAG_AUDIBILITY_ENFORCED);
Eric Laurent22fcda22019-05-17 16:28:47 -07001013 }
1014
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001015 return NO_ERROR;
1016}
1017
Kevin Rocard153f92d2018-12-18 18:33:28 -08001018status_t AudioPolicyManager::getOutputForAttrInt(
1019 audio_attributes_t *resultAttr,
1020 audio_io_handle_t *output,
1021 audio_session_t session,
1022 const audio_attributes_t *attr,
1023 audio_stream_type_t *stream,
1024 uid_t uid,
1025 const audio_config_t *config,
1026 audio_output_flags_t *flags,
1027 audio_port_handle_t *selectedDeviceId,
1028 bool *isRequestedDeviceForExclusiveUse,
Eric Laurentc529cf62020-04-17 18:19:10 -07001029 std::vector<sp<AudioPolicyMix>> *secondaryMixes,
Eric Laurent8a1095a2019-11-08 14:44:16 -08001030 output_type_t *outputType)
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001031{
François Gaffiec005e562018-11-06 15:04:49 +01001032 DeviceVector outputDevices;
Francois Gaffie716e1432019-01-14 16:58:59 +01001033 const audio_port_handle_t requestedPortId = *selectedDeviceId;
François Gaffie11d30102018-11-02 16:09:09 +01001034 DeviceVector msdDevices = getMsdAudioOutDevices();
François Gaffiec005e562018-11-06 15:04:49 +01001035 const sp<DeviceDescriptor> requestedDevice =
1036 mAvailableOutputDevices.getDeviceFromId(requestedPortId);
1037
Eric Laurent8a1095a2019-11-08 14:44:16 -08001038 *outputType = API_OUTPUT_INVALID;
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001039 status_t status = getAudioAttributes(resultAttr, attr, *stream);
1040 if (status != NO_ERROR) {
1041 return status;
Eric Laurent8f42ea12018-08-08 09:08:25 -07001042 }
Kevin Rocardb99cc752019-03-21 20:52:24 -07001043 if (auto it = mAllowedCapturePolicies.find(uid); it != end(mAllowedCapturePolicies)) {
Mikhail Naganov55773032020-10-01 15:08:13 -07001044 resultAttr->flags = static_cast<audio_flags_mask_t>(resultAttr->flags | it->second);
Kevin Rocardb99cc752019-03-21 20:52:24 -07001045 }
François Gaffiec005e562018-11-06 15:04:49 +01001046 *stream = mEngine->getStreamTypeForAttributes(*resultAttr);
Eric Laurent8f42ea12018-08-08 09:08:25 -07001047
François Gaffiec005e562018-11-06 15:04:49 +01001048 ALOGV("%s() attributes=%s stream=%s session %d selectedDeviceId %d", __func__,
1049 toString(*resultAttr).c_str(), toString(*stream).c_str(), session, requestedPortId);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001050
Kevin Rocard153f92d2018-12-18 18:33:28 -08001051 // The primary output is the explicit routing (eg. setPreferredDevice) if specified,
1052 // otherwise, fallback to the dynamic policies, if none match, query the engine.
1053 // Secondary outputs are always found by dynamic policies as the engine do not support them
Eric Laurentc529cf62020-04-17 18:19:10 -07001054 sp<AudioPolicyMix> primaryMix;
1055 status = mPolicyMixes.getOutputForAttr(*resultAttr, uid, *flags, primaryMix, secondaryMixes);
Kevin Rocard94114a22019-04-01 19:38:23 -07001056 if (status != OK) {
1057 return status;
Kevin Rocard153f92d2018-12-18 18:33:28 -08001058 }
Kevin Rocard94114a22019-04-01 19:38:23 -07001059
Kevin Rocard153f92d2018-12-18 18:33:28 -08001060 // Explicit routing is higher priority then any dynamic policy primary output
Eric Laurentc529cf62020-04-17 18:19:10 -07001061 bool usePrimaryOutputFromPolicyMixes = requestedDevice == nullptr && primaryMix != nullptr;
Kevin Rocard153f92d2018-12-18 18:33:28 -08001062
1063 // FIXME: in case of RENDER policy, the output capabilities should be checked
Eric Laurentc529cf62020-04-17 18:19:10 -07001064 if ((usePrimaryOutputFromPolicyMixes
1065 || (secondaryMixes != nullptr && !secondaryMixes->empty()))
Kevin Rocardc2afbdf2019-01-31 18:18:06 -08001066 && !audio_is_linear_pcm(config->format)) {
1067 ALOGD("%s: rejecting request as dynamic audio policy only support pcm", __func__);
Kevin Rocard153f92d2018-12-18 18:33:28 -08001068 return BAD_VALUE;
1069 }
1070 if (usePrimaryOutputFromPolicyMixes) {
Eric Laurentc529cf62020-04-17 18:19:10 -07001071 sp<DeviceDescriptor> deviceDesc =
1072 mAvailableOutputDevices.getDevice(primaryMix->mDeviceType,
1073 primaryMix->mDeviceAddress,
1074 AUDIO_FORMAT_DEFAULT);
1075 sp<SwAudioOutputDescriptor> policyDesc = primaryMix->getOutput();
Eric Laurentc64e0ab2020-04-30 15:59:34 -07001076 if (deviceDesc != nullptr
1077 && (policyDesc == nullptr || (policyDesc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT))) {
Eric Laurentc529cf62020-04-17 18:19:10 -07001078 audio_io_handle_t newOutput;
1079 status = openDirectOutput(
1080 *stream, session, config,
1081 (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_DIRECT),
1082 DeviceVector(deviceDesc), &newOutput);
1083 if (status != NO_ERROR) {
1084 policyDesc = nullptr;
1085 } else {
1086 policyDesc = mOutputs.valueFor(newOutput);
1087 primaryMix->setOutput(policyDesc);
1088 }
1089 }
1090 if (policyDesc != nullptr) {
1091 policyDesc->mPolicyMix = primaryMix;
1092 *output = policyDesc->mIoHandle;
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08001093 *selectedDeviceId = deviceDesc != 0 ? deviceDesc->getId() : AUDIO_PORT_HANDLE_NONE;
Eric Laurent8a1095a2019-11-08 14:44:16 -08001094
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08001095 ALOGV("getOutputForAttr() returns output %d", *output);
1096 if (resultAttr->usage == AUDIO_USAGE_VIRTUAL_SOURCE) {
1097 *outputType = API_OUT_MIX_PLAYBACK;
1098 } else {
1099 *outputType = API_OUTPUT_LEGACY;
1100 }
1101 return NO_ERROR;
Eric Laurent8a1095a2019-11-08 14:44:16 -08001102 }
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001103 }
François Gaffiec005e562018-11-06 15:04:49 +01001104 // Virtual sources must always be dynamicaly or explicitly routed
1105 if (resultAttr->usage == AUDIO_USAGE_VIRTUAL_SOURCE) {
1106 ALOGW("getOutputForAttr() no policy mix found for usage AUDIO_USAGE_VIRTUAL_SOURCE");
1107 return BAD_VALUE;
1108 }
1109 // explicit routing managed by getDeviceForStrategy in APM is now handled by engine
1110 // in order to let the choice of the order to future vendor engine
1111 outputDevices = mEngine->getOutputDevicesForAttributes(*resultAttr, requestedDevice, false);
Scott Randolph7b1fd232018-06-18 15:33:03 -07001112
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001113 if ((resultAttr->flags & AUDIO_FLAG_HW_AV_SYNC) != 0) {
Nadav Bar766fb022018-01-07 12:18:03 +02001114 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_HW_AV_SYNC);
Eric Laurent93c3d412014-08-01 14:48:35 -07001115 }
1116
Nadav Barb2f18162018-07-18 13:01:53 +03001117 // Set incall music only if device was explicitly set, and fallback to the device which is
1118 // chosen by the engine if not.
1119 // FIXME: provide a more generic approach which is not device specific and move this back
1120 // to getOutputForDevice.
Nadav Bar20919492018-11-20 10:20:51 +02001121 // TODO: Remove check of AUDIO_STREAM_MUSIC once migration is completed on the app side.
jiabin9a3361e2019-10-01 09:38:30 -07001122 if (outputDevices.onlyContainsDevicesWithType(AUDIO_DEVICE_OUT_TELEPHONY_TX) &&
François Gaffiec005e562018-11-06 15:04:49 +01001123 (*stream == AUDIO_STREAM_MUSIC || resultAttr->usage == AUDIO_USAGE_VOICE_COMMUNICATION) &&
Nadav Barb2f18162018-07-18 13:01:53 +03001124 audio_is_linear_pcm(config->format) &&
Eric Laurent74b71512019-11-06 17:21:57 -08001125 isCallAudioAccessible()) {
Francois Gaffie716e1432019-01-14 16:58:59 +01001126 if (requestedPortId != AUDIO_PORT_HANDLE_NONE) {
Nadav Barb2f18162018-07-18 13:01:53 +03001127 *flags = (audio_output_flags_t)AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
François Gaffief579db52018-11-13 11:25:16 +01001128 *isRequestedDeviceForExclusiveUse = true;
Nadav Barb2f18162018-07-18 13:01:53 +03001129 }
1130 }
1131
François Gaffiec005e562018-11-06 15:04:49 +01001132 ALOGV("%s() device %s, sampling rate %d, format %#x, channel mask %#x, flags %#x stream %s",
1133 __func__, outputDevices.toString().c_str(), config->sample_rate, config->format,
1134 config->channel_mask, *flags, toString(*stream).c_str());
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001135
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001136 *output = AUDIO_IO_HANDLE_NONE;
François Gaffie11d30102018-11-02 16:09:09 +01001137 if (!msdDevices.isEmpty()) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001138 *output = getOutputForDevices(msdDevices, session, resultAttr, config, flags);
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001139 if (*output != AUDIO_IO_HANDLE_NONE && setMsdOutputPatches(&outputDevices) == NO_ERROR) {
François Gaffiec005e562018-11-06 15:04:49 +01001140 ALOGV("%s() Using MSD devices %s instead of devices %s",
1141 __func__, msdDevices.toString().c_str(), outputDevices.toString().c_str());
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001142 } else {
1143 *output = AUDIO_IO_HANDLE_NONE;
1144 }
1145 }
1146 if (*output == AUDIO_IO_HANDLE_NONE) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001147 *output = getOutputForDevices(outputDevices, session, resultAttr, config,
Eric Laurent42984412019-05-09 17:57:03 -07001148 flags, resultAttr->flags & AUDIO_FLAG_MUTE_HAPTIC);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001149 }
Eric Laurente83b55d2014-11-14 10:06:21 -08001150 if (*output == AUDIO_IO_HANDLE_NONE) {
1151 return INVALID_OPERATION;
1152 }
Paul McLeanaa981192015-03-21 09:55:15 -07001153
François Gaffiec005e562018-11-06 15:04:49 +01001154 *selectedDeviceId = getFirstDeviceId(outputDevices);
Michael Chan6fb34492020-12-08 15:44:49 +11001155 for (auto &outputDevice : outputDevices) {
1156 if (outputDevice->getId() == getConfig().getDefaultOutputDevice()->getId()) {
1157 *selectedDeviceId = outputDevice->getId();
1158 break;
1159 }
1160 }
Eric Laurent2ac76942017-06-22 17:17:09 -07001161
Eric Laurent8a1095a2019-11-08 14:44:16 -08001162 if (outputDevices.onlyContainsDevicesWithType(AUDIO_DEVICE_OUT_TELEPHONY_TX)) {
1163 *outputType = API_OUTPUT_TELEPHONY_TX;
1164 } else {
1165 *outputType = API_OUTPUT_LEGACY;
1166 }
1167
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001168 ALOGV("%s returns output %d selectedDeviceId %d", __func__, *output, *selectedDeviceId);
1169
1170 return NO_ERROR;
1171}
1172
1173status_t AudioPolicyManager::getOutputForAttr(const audio_attributes_t *attr,
1174 audio_io_handle_t *output,
1175 audio_session_t session,
1176 audio_stream_type_t *stream,
Svet Ganov3e5f14f2021-05-13 22:51:08 +00001177 const AttributionSourceState& attributionSource,
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001178 const audio_config_t *config,
1179 audio_output_flags_t *flags,
1180 audio_port_handle_t *selectedDeviceId,
Kevin Rocard153f92d2018-12-18 18:33:28 -08001181 audio_port_handle_t *portId,
Eric Laurent8a1095a2019-11-08 14:44:16 -08001182 std::vector<audio_io_handle_t> *secondaryOutputs,
1183 output_type_t *outputType)
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001184{
1185 // The supplied portId must be AUDIO_PORT_HANDLE_NONE
1186 if (*portId != AUDIO_PORT_HANDLE_NONE) {
1187 return INVALID_OPERATION;
1188 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001189 const uid_t uid = VALUE_OR_RETURN_STATUS(
Svet Ganov3e5f14f2021-05-13 22:51:08 +00001190 aidl2legacy_int32_t_uid_t(attributionSource.uid));
Francois Gaffie716e1432019-01-14 16:58:59 +01001191 const audio_port_handle_t requestedPortId = *selectedDeviceId;
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001192 audio_attributes_t resultAttr;
François Gaffief579db52018-11-13 11:25:16 +01001193 bool isRequestedDeviceForExclusiveUse = false;
Eric Laurentc529cf62020-04-17 18:19:10 -07001194 std::vector<sp<AudioPolicyMix>> secondaryMixes;
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01001195 const sp<DeviceDescriptor> requestedDevice =
1196 mAvailableOutputDevices.getDeviceFromId(requestedPortId);
1197
1198 // Prevent from storing invalid requested device id in clients
1199 const audio_port_handle_t sanitizedRequestedPortId =
1200 requestedDevice != nullptr ? requestedPortId : AUDIO_PORT_HANDLE_NONE;
1201 *selectedDeviceId = sanitizedRequestedPortId;
1202
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001203 status_t status = getOutputForAttrInt(&resultAttr, output, session, attr, stream, uid,
Kevin Rocard153f92d2018-12-18 18:33:28 -08001204 config, flags, selectedDeviceId, &isRequestedDeviceForExclusiveUse,
Eric Laurentc529cf62020-04-17 18:19:10 -07001205 secondaryOutputs != nullptr ? &secondaryMixes : nullptr, outputType);
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001206 if (status != NO_ERROR) {
1207 return status;
1208 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08001209 std::vector<wp<SwAudioOutputDescriptor>> weakSecondaryOutputDescs;
Eric Laurentc529cf62020-04-17 18:19:10 -07001210 if (secondaryOutputs != nullptr) {
1211 for (auto &secondaryMix : secondaryMixes) {
1212 sp<SwAudioOutputDescriptor> outputDesc = secondaryMix->getOutput();
1213 if (outputDesc != nullptr &&
1214 outputDesc->mIoHandle != AUDIO_IO_HANDLE_NONE) {
1215 secondaryOutputs->push_back(outputDesc->mIoHandle);
1216 weakSecondaryOutputDescs.push_back(outputDesc);
1217 }
1218 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08001219 }
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001220
Eric Laurent8fc147b2018-07-22 19:13:55 -07001221 audio_config_base_t clientConfig = {.sample_rate = config->sample_rate,
Nick Desaulniersa30e3202019-10-18 13:38:23 -07001222 .channel_mask = config->channel_mask,
Eric Laurent8fc147b2018-07-22 19:13:55 -07001223 .format = config->format,
Nick Desaulniersa30e3202019-10-18 13:38:23 -07001224 };
jiabin4ef93452019-09-10 14:29:54 -07001225 *portId = PolicyAudioPort::getNextUniqueId();
Eric Laurent8f42ea12018-08-08 09:08:25 -07001226
Eric Laurentc209fe42020-06-05 18:11:23 -07001227 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(*output);
Eric Laurent8fc147b2018-07-22 19:13:55 -07001228 sp<TrackClientDescriptor> clientDesc =
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001229 new TrackClientDescriptor(*portId, uid, session, resultAttr, clientConfig,
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01001230 sanitizedRequestedPortId, *stream,
François Gaffiec005e562018-11-06 15:04:49 +01001231 mEngine->getProductStrategyForAttributes(resultAttr),
François Gaffieaaac0fd2018-11-22 17:56:39 +01001232 toVolumeSource(resultAttr),
Kevin Rocard153f92d2018-12-18 18:33:28 -08001233 *flags, isRequestedDeviceForExclusiveUse,
Eric Laurentc209fe42020-06-05 18:11:23 -07001234 std::move(weakSecondaryOutputDescs),
1235 outputDesc->mPolicyMix);
Andy Hung39efb7a2018-09-26 15:39:28 -07001236 outputDesc->addClient(clientDesc);
Eric Laurent8fc147b2018-07-22 19:13:55 -07001237
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01001238 ALOGV("%s() returns output %d requestedPortId %d selectedDeviceId %d for port ID %d", __func__,
1239 *output, requestedPortId, *selectedDeviceId, *portId);
Eric Laurent2ac76942017-06-22 17:17:09 -07001240
Eric Laurente83b55d2014-11-14 10:06:21 -08001241 return NO_ERROR;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001242}
1243
Eric Laurentc529cf62020-04-17 18:19:10 -07001244status_t AudioPolicyManager::openDirectOutput(audio_stream_type_t stream,
1245 audio_session_t session,
1246 const audio_config_t *config,
1247 audio_output_flags_t flags,
1248 const DeviceVector &devices,
1249 audio_io_handle_t *output) {
1250
1251 *output = AUDIO_IO_HANDLE_NONE;
1252
1253 // skip direct output selection if the request can obviously be attached to a mixed output
1254 // and not explicitly requested
1255 if (((flags & AUDIO_OUTPUT_FLAG_DIRECT) == 0) &&
1256 audio_is_linear_pcm(config->format) && config->sample_rate <= SAMPLE_RATE_HZ_MAX &&
1257 audio_channel_count_from_out_mask(config->channel_mask) <= 2) {
1258 return NAME_NOT_FOUND;
1259 }
1260
1261 // Do not allow offloading if one non offloadable effect is enabled or MasterMono is enabled.
1262 // This prevents creating an offloaded track and tearing it down immediately after start
1263 // when audioflinger detects there is an active non offloadable effect.
1264 // FIXME: We should check the audio session here but we do not have it in this context.
1265 // This may prevent offloading in rare situations where effects are left active by apps
1266 // in the background.
1267 sp<IOProfile> profile;
1268 if (((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) ||
1269 !(mEffects.isNonOffloadableEffectEnabled() || mMasterMono)) {
1270 profile = getProfileForOutput(
1271 devices, config->sample_rate, config->format, config->channel_mask,
1272 flags, true /* directOnly */);
1273 }
1274
1275 if (profile == nullptr) {
1276 return NAME_NOT_FOUND;
1277 }
1278
1279 // exclusive outputs for MMAP and Offload are enforced by different session ids.
1280 for (size_t i = 0; i < mOutputs.size(); i++) {
1281 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
1282 if (!desc->isDuplicated() && (profile == desc->mProfile)) {
1283 // reuse direct output if currently open by the same client
1284 // and configured with same parameters
1285 if ((config->sample_rate == desc->getSamplingRate()) &&
1286 (config->format == desc->getFormat()) &&
1287 (config->channel_mask == desc->getChannelMask()) &&
1288 (session == desc->mDirectClientSession)) {
1289 desc->mDirectOpenCount++;
Eric Laurentfecbceb2021-02-09 14:46:43 +01001290 ALOGV("%s reusing direct output %d for session %d", __func__,
Eric Laurentc529cf62020-04-17 18:19:10 -07001291 mOutputs.keyAt(i), session);
1292 *output = mOutputs.keyAt(i);
1293 return NO_ERROR;
1294 }
1295 }
1296 }
1297
1298 if (!profile->canOpenNewIo()) {
1299 return NAME_NOT_FOUND;
1300 }
1301
1302 sp<SwAudioOutputDescriptor> outputDesc =
1303 new SwAudioOutputDescriptor(profile, mpClientInterface);
1304
Michael Chan6fb34492020-12-08 15:44:49 +11001305 // An MSD patch may be using the only output stream that can service this request. Release
1306 // all MSD patches to prioritize this request over any active output on MSD.
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001307 releaseMsdOutputPatches(devices);
Eric Laurentc529cf62020-04-17 18:19:10 -07001308
Eric Laurentf1f22e72021-07-13 14:04:14 +02001309 status_t status =
1310 outputDesc->open(config, nullptr /* mixerConfig */, devices, stream, flags, output);
Eric Laurentc529cf62020-04-17 18:19:10 -07001311
1312 // only accept an output with the requested parameters
1313 if (status != NO_ERROR ||
1314 (config->sample_rate != 0 && config->sample_rate != outputDesc->getSamplingRate()) ||
1315 (config->format != AUDIO_FORMAT_DEFAULT && config->format != outputDesc->getFormat()) ||
1316 (config->channel_mask != 0 && config->channel_mask != outputDesc->getChannelMask())) {
1317 ALOGV("%s failed opening direct output: output %d sample rate %d %d,"
1318 "format %d %d, channel mask %04x %04x", __func__, *output, config->sample_rate,
1319 outputDesc->getSamplingRate(), config->format, outputDesc->getFormat(),
1320 config->channel_mask, outputDesc->getChannelMask());
1321 if (*output != AUDIO_IO_HANDLE_NONE) {
1322 outputDesc->close();
1323 }
1324 // fall back to mixer output if possible when the direct output could not be open
1325 if (audio_is_linear_pcm(config->format) &&
1326 config->sample_rate <= SAMPLE_RATE_HZ_MAX) {
1327 return NAME_NOT_FOUND;
1328 }
1329 *output = AUDIO_IO_HANDLE_NONE;
1330 return BAD_VALUE;
1331 }
1332 outputDesc->mDirectOpenCount = 1;
1333 outputDesc->mDirectClientSession = session;
1334
1335 addOutput(*output, outputDesc);
1336 mPreviousOutputs = mOutputs;
1337 ALOGV("%s returns new direct output %d", __func__, *output);
1338 mpClientInterface->onAudioPortListUpdate();
1339 return NO_ERROR;
1340}
1341
François Gaffie11d30102018-11-02 16:09:09 +01001342audio_io_handle_t AudioPolicyManager::getOutputForDevices(
1343 const DeviceVector &devices,
Kevin Rocard169753c2017-03-06 14:18:23 -08001344 audio_session_t session,
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001345 const audio_attributes_t *attr,
Eric Laurentfe231122017-11-17 17:48:06 -08001346 const audio_config_t *config,
jiabine375d412019-02-26 12:54:53 -08001347 audio_output_flags_t *flags,
1348 bool forceMutingHaptic)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001349{
Andy Hungc88b0642018-04-27 15:42:35 -07001350 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001351
jiabine375d412019-02-26 12:54:53 -08001352 // Discard haptic channel mask when forcing muting haptic channels.
1353 audio_channel_mask_t channelMask = forceMutingHaptic
Mikhail Naganov55773032020-10-01 15:08:13 -07001354 ? static_cast<audio_channel_mask_t>(config->channel_mask & ~AUDIO_CHANNEL_HAPTIC_ALL)
1355 : config->channel_mask;
jiabine375d412019-02-26 12:54:53 -08001356
Eric Laurente552edb2014-03-10 17:42:56 -07001357 // open a direct output if required by specified parameters
1358 //force direct flag if offload flag is set: offloading implies a direct output stream
1359 // and all common behaviors are driven by checking only the direct flag
1360 // this should normally be set appropriately in the policy configuration file
Nadav Bar766fb022018-01-07 12:18:03 +02001361 if ((*flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
1362 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_DIRECT);
Eric Laurente552edb2014-03-10 17:42:56 -07001363 }
Nadav Bar766fb022018-01-07 12:18:03 +02001364 if ((*flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) {
1365 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_DIRECT);
Eric Laurent93c3d412014-08-01 14:48:35 -07001366 }
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001367
1368 audio_stream_type_t stream = mEngine->getStreamTypeForAttributes(*attr);
1369
Eric Laurente83b55d2014-11-14 10:06:21 -08001370 // only allow deep buffering for music stream type
1371 if (stream != AUDIO_STREAM_MUSIC) {
Nadav Bar766fb022018-01-07 12:18:03 +02001372 *flags = (audio_output_flags_t)(*flags &~AUDIO_OUTPUT_FLAG_DEEP_BUFFER);
Ravi Kumar Alamanda439e4ed2015-04-03 12:13:21 -07001373 } else if (/* stream == AUDIO_STREAM_MUSIC && */
Nadav Bar766fb022018-01-07 12:18:03 +02001374 *flags == AUDIO_OUTPUT_FLAG_NONE &&
Ravi Kumar Alamanda439e4ed2015-04-03 12:13:21 -07001375 property_get_bool("audio.deep_buffer.media", false /* default_value */)) {
1376 // use DEEP_BUFFER as default output for music stream type
Nadav Bar766fb022018-01-07 12:18:03 +02001377 *flags = (audio_output_flags_t)AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
Eric Laurente83b55d2014-11-14 10:06:21 -08001378 }
Ravi Kumar Alamandac36a8892015-04-24 16:35:49 -07001379 if (stream == AUDIO_STREAM_TTS) {
Nadav Bar766fb022018-01-07 12:18:03 +02001380 *flags = AUDIO_OUTPUT_FLAG_TTS;
Haynes Mathew George84c621e2017-04-25 11:41:50 -07001381 } else if (stream == AUDIO_STREAM_VOICE_CALL &&
Nadav Bar20919492018-11-20 10:20:51 +02001382 audio_is_linear_pcm(config->format) &&
1383 (*flags & AUDIO_OUTPUT_FLAG_INCALL_MUSIC) == 0) {
Nadav Bar766fb022018-01-07 12:18:03 +02001384 *flags = (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_VOIP_RX |
Haynes Mathew George84c621e2017-04-25 11:41:50 -07001385 AUDIO_OUTPUT_FLAG_DIRECT);
1386 ALOGV("Set VoIP and Direct output flags for PCM format");
Ravi Kumar Alamandac36a8892015-04-24 16:35:49 -07001387 }
Eric Laurente552edb2014-03-10 17:42:56 -07001388
Eric Laurentfa0f6742021-08-17 18:39:44 +02001389 if (mSpatializerOutput != nullptr
1390 && canBeSpatialized(attr, config, devices.toTypeAddrVector())) {
1391 return mSpatializerOutput->mIoHandle;
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001392 }
1393
Eric Laurentc529cf62020-04-17 18:19:10 -07001394 audio_config_t directConfig = *config;
1395 directConfig.channel_mask = channelMask;
1396 status_t status = openDirectOutput(stream, session, &directConfig, *flags, devices, &output);
1397 if (status != NAME_NOT_FOUND) {
Eric Laurente552edb2014-03-10 17:42:56 -07001398 return output;
1399 }
1400
Eric Laurent14cbfca2016-03-17 09:42:16 -07001401 // A request for HW A/V sync cannot fallback to a mixed output because time
1402 // stamps are embedded in audio data
Phil Burk2d059932018-02-15 15:55:11 -08001403 if ((*flags & (AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_MMAP_NOIRQ)) != 0) {
Eric Laurent14cbfca2016-03-17 09:42:16 -07001404 return AUDIO_IO_HANDLE_NONE;
1405 }
1406
Eric Laurente552edb2014-03-10 17:42:56 -07001407 // ignoring channel mask due to downmix capability in mixer
1408
1409 // open a non direct output
1410
1411 // for non direct outputs, only PCM is supported
Eric Laurentfe231122017-11-17 17:48:06 -08001412 if (audio_is_linear_pcm(config->format)) {
Eric Laurente552edb2014-03-10 17:42:56 -07001413 // get which output is suitable for the specified stream. The actual
1414 // routing change will happen when startOutput() will be called
François Gaffie11d30102018-11-02 16:09:09 +01001415 SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
Eric Laurente552edb2014-03-10 17:42:56 -07001416
Eric Laurent8838a382014-09-08 16:44:28 -07001417 // at this stage we should ignore the DIRECT flag as no direct output could be found earlier
Nadav Bar766fb022018-01-07 12:18:03 +02001418 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_DIRECT);
jiabinebb6af42020-06-09 17:31:17 -07001419 output = selectOutput(
1420 outputs, *flags, config->format, channelMask, config->sample_rate, session);
Eric Laurente552edb2014-03-10 17:42:56 -07001421 }
François Gaffie11d30102018-11-02 16:09:09 +01001422 ALOGW_IF((output == 0), "getOutputForDevices() could not find output for stream %d, "
Glenn Kasten49f36ba2017-12-06 13:02:02 -08001423 "sampling rate %d, format %#x, channels %#x, flags %#x",
jiabine375d412019-02-26 12:54:53 -08001424 stream, config->sample_rate, config->format, channelMask, *flags);
Eric Laurente552edb2014-03-10 17:42:56 -07001425
Eric Laurente552edb2014-03-10 17:42:56 -07001426 return output;
1427}
1428
Mikhail Naganovf02f3672018-11-09 12:44:16 -08001429sp<DeviceDescriptor> AudioPolicyManager::getMsdAudioInDevice() const {
François Gaffie11d30102018-11-02 16:09:09 +01001430 auto msdInDevices = mHwModules.getAvailableDevicesFromModuleName(AUDIO_HARDWARE_MODULE_ID_MSD,
1431 mAvailableInputDevices);
1432 return msdInDevices.isEmpty()? nullptr : msdInDevices.itemAt(0);
1433}
1434
1435DeviceVector AudioPolicyManager::getMsdAudioOutDevices() const {
1436 return mHwModules.getAvailableDevicesFromModuleName(AUDIO_HARDWARE_MODULE_ID_MSD,
1437 mAvailableOutputDevices);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001438}
1439
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001440const AudioPatchCollection AudioPolicyManager::getMsdOutputPatches() const {
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001441 AudioPatchCollection msdPatches;
Mikhail Naganov86112352018-10-04 09:02:49 -07001442 sp<HwModule> msdModule = mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD);
1443 if (msdModule != 0) {
1444 for (size_t i = 0; i < mAudioPatches.size(); ++i) {
1445 sp<AudioPatch> patch = mAudioPatches.valueAt(i);
1446 for (size_t j = 0; j < patch->mPatch.num_sources; ++j) {
1447 const struct audio_port_config *source = &patch->mPatch.sources[j];
1448 if (source->type == AUDIO_PORT_TYPE_DEVICE &&
1449 source->ext.device.hw_module == msdModule->getHandle()) {
François Gaffieafd4cea2019-11-18 15:50:22 +01001450 msdPatches.addAudioPatch(patch->getHandle(), patch);
Mikhail Naganov86112352018-10-04 09:02:49 -07001451 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001452 }
1453 }
1454 }
1455 return msdPatches;
1456}
1457
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001458status_t AudioPolicyManager::getMsdProfiles(bool hwAvSync,
1459 const InputProfileCollection &inputProfiles,
1460 const OutputProfileCollection &outputProfiles,
1461 const sp<DeviceDescriptor> &sourceDevice,
1462 const sp<DeviceDescriptor> &sinkDevice,
1463 AudioProfileVector& sourceProfiles,
1464 AudioProfileVector& sinkProfiles) const {
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001465 if (inputProfiles.isEmpty()) {
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001466 ALOGE("%s() no input profiles for source module", __func__);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001467 return NO_INIT;
1468 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001469 if (outputProfiles.isEmpty()) {
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001470 ALOGE("%s() no output profiles for sink module", __func__);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001471 return NO_INIT;
1472 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001473 for (const auto &inProfile : inputProfiles) {
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001474 if (hwAvSync == ((inProfile->getFlags() & AUDIO_INPUT_FLAG_HW_AV_SYNC) != 0) &&
1475 inProfile->supportsDevice(sourceDevice)) {
1476 appendAudioProfiles(sourceProfiles, inProfile->getAudioProfiles());
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001477 }
1478 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001479 for (const auto &outProfile : outputProfiles) {
Michael Chan6fb34492020-12-08 15:44:49 +11001480 if (hwAvSync == ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) &&
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001481 outProfile->supportsDevice(sinkDevice)) {
1482 appendAudioProfiles(sinkProfiles, outProfile->getAudioProfiles());
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001483 }
1484 }
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001485 return NO_ERROR;
1486}
1487
1488status_t AudioPolicyManager::getBestMsdConfig(bool hwAvSync,
1489 const AudioProfileVector &sourceProfiles, const AudioProfileVector &sinkProfiles,
1490 audio_port_config *sourceConfig, audio_port_config *sinkConfig) const
1491{
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001492 struct audio_config_base bestSinkConfig;
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001493 status_t result = findBestMatchingOutputConfig(sourceProfiles, sinkProfiles,
1494 msdCompressedFormatsOrder, msdSurroundChannelMasksOrder,
1495 true /*preferHigherSamplingRates*/, bestSinkConfig);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001496 if (result != NO_ERROR) {
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001497 ALOGD("%s() no matching config found for sink, hwAvSync: %d",
1498 __func__, hwAvSync);
Greg Kaiser83289652018-07-30 06:13:57 -07001499 return result;
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001500 }
1501 sinkConfig->sample_rate = bestSinkConfig.sample_rate;
1502 sinkConfig->channel_mask = bestSinkConfig.channel_mask;
1503 sinkConfig->format = bestSinkConfig.format;
1504 // For encoded streams force direct flag to prevent downstream mixing.
1505 sinkConfig->flags.output = static_cast<audio_output_flags_t>(
1506 sinkConfig->flags.output | AUDIO_OUTPUT_FLAG_DIRECT);
Dean Wheatley5c9f0832019-11-21 13:39:31 +11001507 if (audio_is_iec61937_compatible(sinkConfig->format)) {
1508 // For formats compatible with IEC61937 encapsulation, assume that
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001509 // the input is IEC61937 framed (for proportional buffer sizing).
Dean Wheatley5c9f0832019-11-21 13:39:31 +11001510 // Add the AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO flag so downstream HAL can distinguish between
1511 // raw and IEC61937 framed streams.
1512 sinkConfig->flags.output = static_cast<audio_output_flags_t>(
1513 sinkConfig->flags.output | AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO);
1514 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001515 sourceConfig->sample_rate = bestSinkConfig.sample_rate;
1516 // Specify exact channel mask to prevent guessing by bit count in PatchPanel.
1517 sourceConfig->channel_mask = audio_channel_mask_out_to_in(bestSinkConfig.channel_mask);
1518 sourceConfig->format = bestSinkConfig.format;
1519 // Copy input stream directly without any processing (e.g. resampling).
1520 sourceConfig->flags.input = static_cast<audio_input_flags_t>(
1521 sourceConfig->flags.input | AUDIO_INPUT_FLAG_DIRECT);
1522 if (hwAvSync) {
1523 sinkConfig->flags.output = static_cast<audio_output_flags_t>(
1524 sinkConfig->flags.output | AUDIO_OUTPUT_FLAG_HW_AV_SYNC);
1525 sourceConfig->flags.input = static_cast<audio_input_flags_t>(
1526 sourceConfig->flags.input | AUDIO_INPUT_FLAG_HW_AV_SYNC);
1527 }
1528 const unsigned int config_mask = AUDIO_PORT_CONFIG_SAMPLE_RATE |
1529 AUDIO_PORT_CONFIG_CHANNEL_MASK | AUDIO_PORT_CONFIG_FORMAT | AUDIO_PORT_CONFIG_FLAGS;
1530 sinkConfig->config_mask |= config_mask;
1531 sourceConfig->config_mask |= config_mask;
1532 return NO_ERROR;
1533}
1534
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001535PatchBuilder AudioPolicyManager::buildMsdPatch(bool msdIsSource,
1536 const sp<DeviceDescriptor> &device) const
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001537{
1538 PatchBuilder patchBuilder;
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001539 sp<HwModule> msdModule = mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD);
1540 ALOG_ASSERT(msdModule != nullptr, "MSD module not available");
1541 sp<HwModule> deviceModule = mHwModules.getModuleForDevice(device, AUDIO_FORMAT_DEFAULT);
1542 if (deviceModule == nullptr) {
1543 ALOGE("%s() unable to get module for %s", __func__, device->toString().c_str());
1544 return patchBuilder;
1545 }
1546 const InputProfileCollection inputProfiles = msdIsSource ?
1547 msdModule->getInputProfiles() : deviceModule->getInputProfiles();
1548 const OutputProfileCollection outputProfiles = msdIsSource ?
1549 deviceModule->getOutputProfiles() : msdModule->getOutputProfiles();
1550
1551 const sp<DeviceDescriptor> sourceDevice = msdIsSource ? getMsdAudioInDevice() : device;
1552 const sp<DeviceDescriptor> sinkDevice = msdIsSource ?
1553 device : getMsdAudioOutDevices().itemAt(0);
1554 patchBuilder.addSource(sourceDevice).addSink(sinkDevice);
1555
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001556 audio_port_config sourceConfig = patchBuilder.patch()->sources[0];
1557 audio_port_config sinkConfig = patchBuilder.patch()->sinks[0];
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001558 AudioProfileVector sourceProfiles;
1559 AudioProfileVector sinkProfiles;
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001560 // TODO: Figure out whether MSD module has HW_AV_SYNC flag set in the AP config file.
1561 // For now, we just forcefully try with HwAvSync first.
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001562 for (auto hwAvSync : { true, false }) {
1563 if (getMsdProfiles(hwAvSync, inputProfiles, outputProfiles, sourceDevice, sinkDevice,
1564 sourceProfiles, sinkProfiles) != NO_ERROR) {
1565 continue;
1566 }
1567 if (getBestMsdConfig(hwAvSync, sourceProfiles, sinkProfiles, &sourceConfig,
1568 &sinkConfig) == NO_ERROR) {
1569 // Found a matching config. Re-create PatchBuilder with this config.
1570 return (PatchBuilder()).addSource(sourceConfig).addSink(sinkConfig);
1571 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001572 }
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001573 ALOGV("%s() no matching config found. Fall through to default PCM patch"
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001574 " supporting PCM format conversion.", __func__);
1575 return patchBuilder;
1576}
1577
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001578status_t AudioPolicyManager::setMsdOutputPatches(const DeviceVector *outputDevices) {
Michael Chan6fb34492020-12-08 15:44:49 +11001579 DeviceVector devices;
1580 if (outputDevices != nullptr && outputDevices->size() > 0) {
1581 devices.add(*outputDevices);
1582 } else {
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001583 // Use media strategy for unspecified output device. This should only
1584 // occur on checkForDeviceAndOutputChanges(). Device connection events may
1585 // therefore invalidate explicit routing requests.
Michael Chan6fb34492020-12-08 15:44:49 +11001586 devices = mEngine->getOutputDevicesForAttributes(
François Gaffiec005e562018-11-06 15:04:49 +01001587 attributes_initializer(AUDIO_USAGE_MEDIA), nullptr, false /*fromCache*/);
Michael Chan6fb34492020-12-08 15:44:49 +11001588 LOG_ALWAYS_FATAL_IF(devices.isEmpty(), "no output device to set MSD patch");
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001589 }
Michael Chan6fb34492020-12-08 15:44:49 +11001590 std::vector<PatchBuilder> patchesToCreate;
1591 for (auto i = 0u; i < devices.size(); ++i) {
1592 ALOGV("%s() for device %s", __func__, devices[i]->toString().c_str());
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001593 patchesToCreate.push_back(buildMsdPatch(true /*msdIsSource*/, devices[i]));
Michael Chan6fb34492020-12-08 15:44:49 +11001594 }
1595 // Retain only the MSD patches associated with outputDevices request.
1596 // Tear down the others, and create new ones as needed.
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001597 AudioPatchCollection patchesToRemove = getMsdOutputPatches();
Michael Chan6fb34492020-12-08 15:44:49 +11001598 for (auto it = patchesToCreate.begin(); it != patchesToCreate.end(); ) {
1599 auto retainedPatch = false;
1600 for (auto i = 0u; i < patchesToRemove.size(); ++i) {
1601 if (audio_patches_are_equal(it->patch(), &patchesToRemove[i]->mPatch)) {
1602 patchesToRemove.removeItemsAt(i);
1603 retainedPatch = true;
1604 break;
1605 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001606 }
Michael Chan6fb34492020-12-08 15:44:49 +11001607 if (retainedPatch) {
1608 it = patchesToCreate.erase(it);
1609 continue;
1610 }
1611 ++it;
1612 }
1613 if (patchesToCreate.size() == 0 && patchesToRemove.size() == 0) {
1614 return NO_ERROR;
1615 }
1616 for (auto i = 0u; i < patchesToRemove.size(); ++i) {
1617 auto &currentPatch = patchesToRemove.valueAt(i);
François Gaffieafd4cea2019-11-18 15:50:22 +01001618 releaseAudioPatch(currentPatch->getHandle(), mUidCached);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001619 }
Michael Chan6fb34492020-12-08 15:44:49 +11001620 status_t status = NO_ERROR;
1621 for (const auto &p : patchesToCreate) {
1622 auto currStatus = installPatch(__func__, -1 /*index*/, nullptr /*patchHandle*/,
1623 p.patch(), 0 /*delayMs*/, mUidCached, nullptr /*patchDescPtr*/);
1624 char message[256];
1625 snprintf(message, sizeof(message), "%s() %s: creating MSD patch from device:IN_BUS to "
1626 "device:%#x (format:%#x channels:%#x samplerate:%d)", __func__,
1627 currStatus == NO_ERROR ? "Success" : "Error",
1628 p.patch()->sinks[0].ext.device.type, p.patch()->sources[0].format,
1629 p.patch()->sources[0].channel_mask, p.patch()->sources[0].sample_rate);
1630 if (currStatus == NO_ERROR) {
1631 ALOGD("%s", message);
1632 } else {
1633 ALOGE("%s", message);
1634 if (status == NO_ERROR) {
1635 status = currStatus;
1636 }
1637 }
1638 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001639 return status;
1640}
1641
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001642void AudioPolicyManager::releaseMsdOutputPatches(const DeviceVector& devices) {
1643 AudioPatchCollection msdPatches = getMsdOutputPatches();
Michael Chan6fb34492020-12-08 15:44:49 +11001644 for (size_t i = 0; i < msdPatches.size(); i++) {
1645 const auto& patch = msdPatches[i];
1646 for (size_t j = 0; j < patch->mPatch.num_sinks; ++j) {
1647 const struct audio_port_config *sink = &patch->mPatch.sinks[j];
1648 if (sink->type == AUDIO_PORT_TYPE_DEVICE && devices.getDevice(sink->ext.device.type,
1649 String8(sink->ext.device.address), AUDIO_FORMAT_DEFAULT) != nullptr) {
1650 releaseAudioPatch(patch->getHandle(), mUidCached);
1651 break;
1652 }
1653 }
1654 }
1655}
1656
Eric Laurente0720872014-03-11 09:30:41 -07001657audio_io_handle_t AudioPolicyManager::selectOutput(const SortedVector<audio_io_handle_t>& outputs,
jiabinebb6af42020-06-09 17:31:17 -07001658 audio_output_flags_t flags,
1659 audio_format_t format,
1660 audio_channel_mask_t channelMask,
1661 uint32_t samplingRate,
1662 audio_session_t sessionId)
Eric Laurente552edb2014-03-10 17:42:56 -07001663{
Eric Laurent16c66dd2019-05-01 17:54:10 -07001664 LOG_ALWAYS_FATAL_IF(!(format == AUDIO_FORMAT_INVALID || audio_is_linear_pcm(format)),
1665 "%s called with format %#x", __func__, format);
1666
jiabinebb6af42020-06-09 17:31:17 -07001667 // Return the output that haptic-generating attached to when 1) session id is specified,
1668 // 2) haptic-generating effect exists for given session id and 3) the output that
1669 // haptic-generating effect attached to is in given outputs.
1670 if (sessionId != AUDIO_SESSION_NONE) {
1671 audio_io_handle_t hapticGeneratingOutput = mEffects.getIoForSession(
1672 sessionId, FX_IID_HAPTICGENERATOR);
1673 if (outputs.indexOf(hapticGeneratingOutput) >= 0) {
1674 return hapticGeneratingOutput;
1675 }
1676 }
1677
Eric Laurent16c66dd2019-05-01 17:54:10 -07001678 // Flags disqualifying an output: the match must happen before calling selectOutput()
1679 static const audio_output_flags_t kExcludedFlags = (audio_output_flags_t)
1680 (AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_MMAP_NOIRQ | AUDIO_OUTPUT_FLAG_DIRECT);
1681
1682 // Flags expressing a functional request: must be honored in priority over
1683 // other criteria
1684 static const audio_output_flags_t kFunctionalFlags = (audio_output_flags_t)
1685 (AUDIO_OUTPUT_FLAG_VOIP_RX | AUDIO_OUTPUT_FLAG_INCALL_MUSIC |
1686 AUDIO_OUTPUT_FLAG_TTS | AUDIO_OUTPUT_FLAG_DIRECT_PCM);
1687 // Flags expressing a performance request: have lower priority than serving
1688 // requested sampling rate or channel mask
1689 static const audio_output_flags_t kPerformanceFlags = (audio_output_flags_t)
1690 (AUDIO_OUTPUT_FLAG_FAST | AUDIO_OUTPUT_FLAG_DEEP_BUFFER |
1691 AUDIO_OUTPUT_FLAG_RAW | AUDIO_OUTPUT_FLAG_SYNC);
1692
1693 const audio_output_flags_t functionalFlags =
1694 (audio_output_flags_t)(flags & kFunctionalFlags);
1695 const audio_output_flags_t performanceFlags =
1696 (audio_output_flags_t)(flags & kPerformanceFlags);
1697
1698 audio_io_handle_t bestOutput = (outputs.size() == 0) ? AUDIO_IO_HANDLE_NONE : outputs[0];
1699
Eric Laurente552edb2014-03-10 17:42:56 -07001700 // select one output among several that provide a path to a particular device or set of
François Gaffie11d30102018-11-02 16:09:09 +01001701 // devices (the list was previously build by getOutputsForDevices()).
Eric Laurente552edb2014-03-10 17:42:56 -07001702 // The priority is as follows:
jiabin40573322018-11-08 12:08:02 -08001703 // 1: the output supporting haptic playback when requesting haptic playback
Eric Laurent16c66dd2019-05-01 17:54:10 -07001704 // 2: the output with the highest number of requested functional flags
Carter Hsu199f1892021-10-15 15:47:29 +08001705 // with tiebreak preferring the minimum number of extra functional flags
1706 // (see b/200293124, the incorrect selection of AUDIO_OUTPUT_FLAG_VOIP_RX).
Eric Laurent16c66dd2019-05-01 17:54:10 -07001707 // 3: the output supporting the exact channel mask
1708 // 4: the output with a higher channel count than requested
1709 // 5: the output with a higher sampling rate than requested
1710 // 6: the output with the highest number of requested performance flags
1711 // 7: the output with the bit depth the closest to the requested one
1712 // 8: the primary output
1713 // 9: the first output in the list
Eric Laurente552edb2014-03-10 17:42:56 -07001714
Eric Laurent16c66dd2019-05-01 17:54:10 -07001715 // matching criteria values in priority order for best matching output so far
1716 std::vector<uint32_t> bestMatchCriteria(8, 0);
Eric Laurente552edb2014-03-10 17:42:56 -07001717
Eric Laurent16c66dd2019-05-01 17:54:10 -07001718 const uint32_t channelCount = audio_channel_count_from_out_mask(channelMask);
1719 const uint32_t hapticChannelCount = audio_channel_count_from_out_mask(
1720 channelMask & AUDIO_CHANNEL_HAPTIC_ALL);
Eric Laurente78b6762018-12-19 16:29:01 -08001721
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001722 for (audio_io_handle_t output : outputs) {
1723 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
Eric Laurent16c66dd2019-05-01 17:54:10 -07001724 // matching criteria values in priority order for current output
1725 std::vector<uint32_t> currentMatchCriteria(8, 0);
jiabin40573322018-11-08 12:08:02 -08001726
Eric Laurent16c66dd2019-05-01 17:54:10 -07001727 if (outputDesc->isDuplicated()) {
1728 continue;
1729 }
1730 if ((kExcludedFlags & outputDesc->mFlags) != 0) {
1731 continue;
1732 }
Eric Laurent8838a382014-09-08 16:44:28 -07001733
Eric Laurent16c66dd2019-05-01 17:54:10 -07001734 // If haptic channel is specified, use the haptic output if present.
1735 // When using haptic output, same audio format and sample rate are required.
1736 const uint32_t outputHapticChannelCount = audio_channel_count_from_out_mask(
jiabin5740f082019-08-19 15:08:30 -07001737 outputDesc->getChannelMask() & AUDIO_CHANNEL_HAPTIC_ALL);
Eric Laurent16c66dd2019-05-01 17:54:10 -07001738 if ((hapticChannelCount == 0) != (outputHapticChannelCount == 0)) {
1739 continue;
1740 }
1741 if (outputHapticChannelCount >= hapticChannelCount
jiabin5740f082019-08-19 15:08:30 -07001742 && format == outputDesc->getFormat()
1743 && samplingRate == outputDesc->getSamplingRate()) {
Eric Laurent16c66dd2019-05-01 17:54:10 -07001744 currentMatchCriteria[0] = outputHapticChannelCount;
1745 }
1746
1747 // functional flags match
Carter Hsu199f1892021-10-15 15:47:29 +08001748 const int matchingFunctionalFlags =
1749 __builtin_popcount(outputDesc->mFlags & functionalFlags);
1750 const int totalFunctionalFlags =
1751 __builtin_popcount(outputDesc->mFlags & kFunctionalFlags);
1752 // Prefer matching functional flags, but subtract unnecessary functional flags.
1753 currentMatchCriteria[1] = 100 * (matchingFunctionalFlags + 1) - totalFunctionalFlags;
Eric Laurent16c66dd2019-05-01 17:54:10 -07001754
1755 // channel mask and channel count match
jiabin5740f082019-08-19 15:08:30 -07001756 uint32_t outputChannelCount = audio_channel_count_from_out_mask(
1757 outputDesc->getChannelMask());
Eric Laurent16c66dd2019-05-01 17:54:10 -07001758 if (channelMask != AUDIO_CHANNEL_NONE && channelCount > 2 &&
1759 channelCount <= outputChannelCount) {
1760 if ((audio_channel_mask_get_representation(channelMask) ==
jiabin5740f082019-08-19 15:08:30 -07001761 audio_channel_mask_get_representation(outputDesc->getChannelMask())) &&
1762 ((channelMask & outputDesc->getChannelMask()) == channelMask)) {
Eric Laurent16c66dd2019-05-01 17:54:10 -07001763 currentMatchCriteria[2] = outputChannelCount;
Eric Laurente552edb2014-03-10 17:42:56 -07001764 }
Eric Laurent16c66dd2019-05-01 17:54:10 -07001765 currentMatchCriteria[3] = outputChannelCount;
1766 }
1767
1768 // sampling rate match
1769 if (samplingRate > SAMPLE_RATE_HZ_DEFAULT &&
jiabin5740f082019-08-19 15:08:30 -07001770 samplingRate <= outputDesc->getSamplingRate()) {
1771 currentMatchCriteria[4] = outputDesc->getSamplingRate();
Eric Laurent16c66dd2019-05-01 17:54:10 -07001772 }
1773
1774 // performance flags match
1775 currentMatchCriteria[5] = popcount(outputDesc->mFlags & performanceFlags);
1776
1777 // format match
1778 if (format != AUDIO_FORMAT_INVALID) {
1779 currentMatchCriteria[6] =
jiabin4ef93452019-09-10 14:29:54 -07001780 PolicyAudioPort::kFormatDistanceMax -
1781 PolicyAudioPort::formatDistance(format, outputDesc->getFormat());
Eric Laurent16c66dd2019-05-01 17:54:10 -07001782 }
1783
1784 // primary output match
1785 currentMatchCriteria[7] = outputDesc->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY;
1786
1787 // compare match criteria by priority then value
1788 if (std::lexicographical_compare(bestMatchCriteria.begin(), bestMatchCriteria.end(),
1789 currentMatchCriteria.begin(), currentMatchCriteria.end())) {
1790 bestMatchCriteria = currentMatchCriteria;
1791 bestOutput = output;
1792
1793 std::stringstream result;
1794 std::copy(bestMatchCriteria.begin(), bestMatchCriteria.end(),
1795 std::ostream_iterator<int>(result, " "));
1796 ALOGV("%s new bestOutput %d criteria %s",
1797 __func__, bestOutput, result.str().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -07001798 }
1799 }
1800
Eric Laurent16c66dd2019-05-01 17:54:10 -07001801 return bestOutput;
Eric Laurente552edb2014-03-10 17:42:56 -07001802}
1803
Eric Laurent8fc147b2018-07-22 19:13:55 -07001804status_t AudioPolicyManager::startOutput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07001805{
Eric Laurent8fc147b2018-07-22 19:13:55 -07001806 ALOGV("%s portId %d", __FUNCTION__, portId);
1807
1808 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputForClient(portId);
1809 if (outputDesc == 0) {
1810 ALOGW("startOutput() no output for client %d", portId);
Eric Laurente552edb2014-03-10 17:42:56 -07001811 return BAD_VALUE;
1812 }
Andy Hung39efb7a2018-09-26 15:39:28 -07001813 sp<TrackClientDescriptor> client = outputDesc->getClient(portId);
Eric Laurente552edb2014-03-10 17:42:56 -07001814
Eric Laurent8fc147b2018-07-22 19:13:55 -07001815 ALOGV("startOutput() output %d, stream %d, session %d",
Eric Laurent97ac8712018-07-27 18:59:02 -07001816 outputDesc->mIoHandle, client->stream(), client->session());
Eric Laurentc75307b2015-03-17 15:29:32 -07001817
Eric Laurent733ce942017-12-07 12:18:25 -08001818 status_t status = outputDesc->start();
1819 if (status != NO_ERROR) {
1820 return status;
Eric Laurent3974e3b2017-12-07 17:58:43 -08001821 }
1822
Eric Laurent97ac8712018-07-27 18:59:02 -07001823 uint32_t delayMs;
1824 status = startSource(outputDesc, client, &delayMs);
Eric Laurentc75307b2015-03-17 15:29:32 -07001825
1826 if (status != NO_ERROR) {
Eric Laurent733ce942017-12-07 12:18:25 -08001827 outputDesc->stop();
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001828 return status;
Eric Laurentc75307b2015-03-17 15:29:32 -07001829 }
Eric Laurentc75307b2015-03-17 15:29:32 -07001830 if (delayMs != 0) {
1831 usleep(delayMs * 1000);
1832 }
1833
1834 return status;
1835}
1836
Eric Laurent97ac8712018-07-27 18:59:02 -07001837status_t AudioPolicyManager::startSource(const sp<SwAudioOutputDescriptor>& outputDesc,
1838 const sp<TrackClientDescriptor>& client,
1839 uint32_t *delayMs)
Eric Laurentc75307b2015-03-17 15:29:32 -07001840{
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001841 // cannot start playback of STREAM_TTS if any other output is being used
1842 uint32_t beaconMuteLatency = 0;
Eric Laurentc75307b2015-03-17 15:29:32 -07001843
1844 *delayMs = 0;
Eric Laurent97ac8712018-07-27 18:59:02 -07001845 audio_stream_type_t stream = client->stream();
François Gaffie1c878552018-11-22 16:53:21 +01001846 auto clientVolSrc = client->volumeSource();
François Gaffiec005e562018-11-06 15:04:49 +01001847 auto clientStrategy = client->strategy();
1848 auto clientAttr = client->attributes();
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001849 if (stream == AUDIO_STREAM_TTS) {
1850 ALOGV("\t found BEACON stream");
François Gaffie1c878552018-11-22 16:53:21 +01001851 if (!mTtsOutputAvailable && mOutputs.isAnyOutputActive(
Eric Laurent83d17c22019-04-02 17:10:01 -07001852 toVolumeSource(AUDIO_STREAM_TTS) /*sourceToIgnore*/)) {
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001853 return INVALID_OPERATION;
1854 } else {
1855 beaconMuteLatency = handleEventForBeacon(STARTING_BEACON);
1856 }
1857 } else {
1858 // some playback other than beacon starts
1859 beaconMuteLatency = handleEventForBeacon(STARTING_OUTPUT);
1860 }
1861
Eric Laurent77305a62016-07-25 16:39:22 -07001862 // force device change if the output is inactive and no audio patch is already present.
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001863 // check active before incrementing usage count
Eric Laurent77305a62016-07-25 16:39:22 -07001864 bool force = !outputDesc->isActive() &&
1865 (outputDesc->getPatchHandle() == AUDIO_PATCH_HANDLE_NONE);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001866
François Gaffie11d30102018-11-02 16:09:09 +01001867 DeviceVector devices;
Mikhail Naganovbfac5832019-03-05 16:55:28 -08001868 sp<AudioPolicyMix> policyMix = outputDesc->mPolicyMix.promote();
Eric Laurent97ac8712018-07-27 18:59:02 -07001869 const char *address = NULL;
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08001870 if (policyMix != nullptr) {
François Gaffie11d30102018-11-02 16:09:09 +01001871 audio_devices_t newDeviceType;
Eric Laurent97ac8712018-07-27 18:59:02 -07001872 address = policyMix->mDeviceAddress.string();
Kevin Rocard153f92d2018-12-18 18:33:28 -08001873 if ((policyMix->mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) {
François Gaffie11d30102018-11-02 16:09:09 +01001874 newDeviceType = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
Kevin Rocard153f92d2018-12-18 18:33:28 -08001875 } else {
1876 newDeviceType = policyMix->mDeviceType;
Eric Laurent97ac8712018-07-27 18:59:02 -07001877 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08001878 sp device = mAvailableOutputDevices.getDevice(newDeviceType, String8(address),
1879 AUDIO_FORMAT_DEFAULT);
1880 ALOG_ASSERT(device, "%s: no device found t=%u, a=%s", __func__, newDeviceType, address);
1881 devices.add(device);
Eric Laurent97ac8712018-07-27 18:59:02 -07001882 }
1883
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001884 // requiresMuteCheck is false when we can bypass mute strategy.
1885 // It covers a common case when there is no materially active audio
1886 // and muting would result in unnecessary delay and dropped audio.
1887 const uint32_t outputLatencyMs = outputDesc->latency();
1888 bool requiresMuteCheck = outputDesc->isActive(outputLatencyMs * 2); // account for drain
1889
Eric Laurente552edb2014-03-10 17:42:56 -07001890 // increment usage count for this stream on the requested output:
1891 // NOTE that the usage count is the same for duplicated output and hardware output which is
1892 // necessary for a correct control of hardware output routing by startOutput() and stopOutput()
Eric Laurent592dd7b2018-08-05 18:58:48 -07001893 outputDesc->setClientActive(client, true);
Eric Laurent97ac8712018-07-27 18:59:02 -07001894
1895 if (client->hasPreferredDevice(true)) {
François Gaffief96e5432019-04-09 17:13:56 +02001896 if (outputDesc->clientsList(true /*activeOnly*/).size() == 1 &&
1897 client->isPreferredDeviceForExclusiveUse()) {
1898 // Preferred device may be exclusive, use only if no other active clients on this output
1899 devices = DeviceVector(
1900 mAvailableOutputDevices.getDeviceFromId(client->preferredDeviceId()));
1901 } else {
1902 devices = getNewOutputDevices(outputDesc, false /*fromCache*/);
1903 }
François Gaffie11d30102018-11-02 16:09:09 +01001904 if (devices != outputDesc->devices()) {
François Gaffiec005e562018-11-06 15:04:49 +01001905 checkStrategyRoute(clientStrategy, outputDesc->mIoHandle);
Eric Laurent97ac8712018-07-27 18:59:02 -07001906 }
1907 }
Eric Laurente552edb2014-03-10 17:42:56 -07001908
François Gaffiec005e562018-11-06 15:04:49 +01001909 if (followsSameRouting(clientAttr, attributes_initializer(AUDIO_USAGE_MEDIA))) {
Eric Laurent36829f92017-04-07 19:04:42 -07001910 selectOutputForMusicEffects();
1911 }
1912
François Gaffie1c878552018-11-22 16:53:21 +01001913 if (outputDesc->getActivityCount(clientVolSrc) == 1 || !devices.isEmpty()) {
Eric Laurent275e8e92014-11-30 15:14:47 -08001914 // starting an output being rerouted?
François Gaffie11d30102018-11-02 16:09:09 +01001915 if (devices.isEmpty()) {
1916 devices = getNewOutputDevices(outputDesc, false /*fromCache*/);
Eric Laurent275e8e92014-11-30 15:14:47 -08001917 }
François Gaffiec005e562018-11-06 15:04:49 +01001918 bool shouldWait =
1919 (followsSameRouting(clientAttr, attributes_initializer(AUDIO_USAGE_ALARM)) ||
1920 followsSameRouting(clientAttr, attributes_initializer(AUDIO_USAGE_NOTIFICATION)) ||
1921 (beaconMuteLatency > 0));
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001922 uint32_t waitMs = beaconMuteLatency;
Eric Laurente552edb2014-03-10 17:42:56 -07001923 for (size_t i = 0; i < mOutputs.size(); i++) {
François Gaffie11d30102018-11-02 16:09:09 +01001924 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Eric Laurente552edb2014-03-10 17:42:56 -07001925 if (desc != outputDesc) {
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001926 // An output has a shared device if
1927 // - managed by the same hw module
1928 // - supports the currently selected device
1929 const bool sharedDevice = outputDesc->sharesHwModuleWith(desc)
François Gaffie11d30102018-11-02 16:09:09 +01001930 && (!desc->filterSupportedDevices(devices).isEmpty());
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001931
Eric Laurent77305a62016-07-25 16:39:22 -07001932 // force a device change if any other output is:
1933 // - managed by the same hw module
Jean-Michel Trivi4a5b4812018-02-08 17:22:32 +00001934 // - supports currently selected device
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001935 // - has a current device selection that differs from selected device.
Eric Laurent77305a62016-07-25 16:39:22 -07001936 // - has an active audio patch
Eric Laurente552edb2014-03-10 17:42:56 -07001937 // In this case, the audio HAL must receive the new device selection so that it can
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001938 // change the device currently selected by the other output.
1939 if (sharedDevice &&
François Gaffie11d30102018-11-02 16:09:09 +01001940 desc->devices() != devices &&
Eric Laurent77305a62016-07-25 16:39:22 -07001941 desc->getPatchHandle() != AUDIO_PATCH_HANDLE_NONE) {
Eric Laurente552edb2014-03-10 17:42:56 -07001942 force = true;
1943 }
1944 // wait for audio on other active outputs to be presented when starting
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07001945 // a notification so that audio focus effect can propagate, or that a mute/unmute
1946 // event occurred for beacon
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001947 const uint32_t latencyMs = desc->latency();
1948 const bool isActive = desc->isActive(latencyMs * 2); // account for drain
1949
1950 if (shouldWait && isActive && (waitMs < latencyMs)) {
1951 waitMs = latencyMs;
Eric Laurente552edb2014-03-10 17:42:56 -07001952 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001953
1954 // Require mute check if another output is on a shared device
1955 // and currently active to have proper drain and avoid pops.
1956 // Note restoring AudioTracks onto this output needs to invoke
1957 // a volume ramp if there is no mute.
1958 requiresMuteCheck |= sharedDevice && isActive;
Eric Laurente552edb2014-03-10 17:42:56 -07001959 }
1960 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001961
1962 const uint32_t muteWaitMs =
François Gaffie11d30102018-11-02 16:09:09 +01001963 setOutputDevices(outputDesc, devices, force, 0, NULL, requiresMuteCheck);
Eric Laurente552edb2014-03-10 17:42:56 -07001964
Eric Laurente552edb2014-03-10 17:42:56 -07001965 // apply volume rules for current stream and device if necessary
François Gaffieaaac0fd2018-11-22 17:56:39 +01001966 auto &curves = getVolumeCurves(client->attributes());
1967 checkAndSetVolume(curves, client->volumeSource(),
1968 curves.getVolumeIndex(outputDesc->devices().types()),
Eric Laurentc75307b2015-03-17 15:29:32 -07001969 outputDesc,
Francois Gaffied11442b2020-04-27 11:51:09 +02001970 outputDesc->devices().types(), 0 /*delay*/,
1971 outputDesc->useHwGain() /*force*/);
Eric Laurente552edb2014-03-10 17:42:56 -07001972
1973 // update the outputs if starting an output with a stream that can affect notification
1974 // routing
1975 handleNotificationRoutingForStream(stream);
Eric Laurentc722f302014-12-10 11:21:49 -08001976
Eric Laurent2cbe89a2014-12-19 11:49:08 -08001977 // force reevaluating accessibility routing when ringtone or alarm starts
François Gaffiec005e562018-11-06 15:04:49 +01001978 if (followsSameRouting(clientAttr, attributes_initializer(AUDIO_USAGE_ALARM))) {
Eric Laurent2cbe89a2014-12-19 11:49:08 -08001979 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
1980 }
Eric Laurentdc462862016-07-19 12:29:53 -07001981
1982 if (waitMs > muteWaitMs) {
1983 *delayMs = waitMs - muteWaitMs;
1984 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00001985
1986 // FIXME: A device change (muteWaitMs > 0) likely introduces a volume change.
1987 // A volume change enacted by APM with 0 delay is not synchronous, as it goes
1988 // via AudioCommandThread to AudioFlinger. Hence it is possible that the volume
1989 // change occurs after the MixerThread starts and causes a stream volume
1990 // glitch.
1991 //
1992 // We do not introduce additional delay here.
Eric Laurente552edb2014-03-10 17:42:56 -07001993 }
Eric Laurentdc462862016-07-19 12:29:53 -07001994
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09001995 if (stream == AUDIO_STREAM_ENFORCED_AUDIBLE &&
jiabin9a3361e2019-10-01 09:38:30 -07001996 mEngine->getForceUse(
1997 AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
François Gaffiec005e562018-11-06 15:04:49 +01001998 setStrategyMute(streamToStrategy(AUDIO_STREAM_ALARM), true, outputDesc);
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09001999 }
2000
Eric Laurent97ac8712018-07-27 18:59:02 -07002001 // Automatically enable the remote submix input when output is started on a re routing mix
2002 // of type MIX_TYPE_RECORDERS
jiabin9a3361e2019-10-01 09:38:30 -07002003 if (isSingleDeviceType(devices.types(), &audio_is_remote_submix_device) &&
2004 policyMix != NULL && policyMix->mMixType == MIX_TYPE_RECORDERS) {
Eric Laurent97ac8712018-07-27 18:59:02 -07002005 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
2006 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2007 address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08002008 "remote-submix",
2009 AUDIO_FORMAT_DEFAULT);
Eric Laurent97ac8712018-07-27 18:59:02 -07002010 }
2011
Eric Laurente552edb2014-03-10 17:42:56 -07002012 return NO_ERROR;
2013}
2014
Eric Laurent8fc147b2018-07-22 19:13:55 -07002015status_t AudioPolicyManager::stopOutput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07002016{
Eric Laurent8fc147b2018-07-22 19:13:55 -07002017 ALOGV("%s portId %d", __FUNCTION__, portId);
2018
2019 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputForClient(portId);
2020 if (outputDesc == 0) {
2021 ALOGW("stopOutput() no output for client %d", portId);
Eric Laurente552edb2014-03-10 17:42:56 -07002022 return BAD_VALUE;
2023 }
Andy Hung39efb7a2018-09-26 15:39:28 -07002024 sp<TrackClientDescriptor> client = outputDesc->getClient(portId);
Eric Laurente552edb2014-03-10 17:42:56 -07002025
Eric Laurent97ac8712018-07-27 18:59:02 -07002026 ALOGV("stopOutput() output %d, stream %d, session %d",
2027 outputDesc->mIoHandle, client->stream(), client->session());
Eric Laurente552edb2014-03-10 17:42:56 -07002028
Eric Laurent97ac8712018-07-27 18:59:02 -07002029 status_t status = stopSource(outputDesc, client);
Eric Laurent3974e3b2017-12-07 17:58:43 -08002030
Eric Laurent733ce942017-12-07 12:18:25 -08002031 if (status == NO_ERROR ) {
2032 outputDesc->stop();
Eric Laurent3974e3b2017-12-07 17:58:43 -08002033 }
2034 return status;
Eric Laurentc75307b2015-03-17 15:29:32 -07002035}
2036
Eric Laurent97ac8712018-07-27 18:59:02 -07002037status_t AudioPolicyManager::stopSource(const sp<SwAudioOutputDescriptor>& outputDesc,
2038 const sp<TrackClientDescriptor>& client)
Eric Laurentc75307b2015-03-17 15:29:32 -07002039{
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07002040 // always handle stream stop, check which stream type is stopping
Eric Laurent97ac8712018-07-27 18:59:02 -07002041 audio_stream_type_t stream = client->stream();
François Gaffie1c878552018-11-22 16:53:21 +01002042 auto clientVolSrc = client->volumeSource();
Eric Laurent97ac8712018-07-27 18:59:02 -07002043
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07002044 handleEventForBeacon(stream == AUDIO_STREAM_TTS ? STOPPING_BEACON : STOPPING_OUTPUT);
2045
François Gaffie1c878552018-11-22 16:53:21 +01002046 if (outputDesc->getActivityCount(clientVolSrc) > 0) {
2047 if (outputDesc->getActivityCount(clientVolSrc) == 1) {
Eric Laurent97ac8712018-07-27 18:59:02 -07002048 // Automatically disable the remote submix input when output is stopped on a
2049 // re routing mix of type MIX_TYPE_RECORDERS
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002050 sp<AudioPolicyMix> policyMix = outputDesc->mPolicyMix.promote();
jiabin9a3361e2019-10-01 09:38:30 -07002051 if (isSingleDeviceType(
2052 outputDesc->devices().types(), &audio_is_remote_submix_device) &&
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002053 policyMix != nullptr &&
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002054 policyMix->mMixType == MIX_TYPE_RECORDERS) {
Eric Laurent97ac8712018-07-27 18:59:02 -07002055 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
2056 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002057 policyMix->mDeviceAddress,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08002058 "remote-submix", AUDIO_FORMAT_DEFAULT);
Eric Laurent97ac8712018-07-27 18:59:02 -07002059 }
2060 }
2061 bool forceDeviceUpdate = false;
2062 if (client->hasPreferredDevice(true)) {
François Gaffiec005e562018-11-06 15:04:49 +01002063 checkStrategyRoute(client->strategy(), AUDIO_IO_HANDLE_NONE);
Eric Laurent97ac8712018-07-27 18:59:02 -07002064 forceDeviceUpdate = true;
2065 }
2066
Eric Laurente552edb2014-03-10 17:42:56 -07002067 // decrement usage count of this stream on the output
Eric Laurent592dd7b2018-08-05 18:58:48 -07002068 outputDesc->setClientActive(client, false);
Paul McLeanaa981192015-03-21 09:55:15 -07002069
Eric Laurente552edb2014-03-10 17:42:56 -07002070 // store time at which the stream was stopped - see isStreamActive()
François Gaffie1c878552018-11-22 16:53:21 +01002071 if (outputDesc->getActivityCount(clientVolSrc) == 0 || forceDeviceUpdate) {
François Gaffiec005e562018-11-06 15:04:49 +01002072 outputDesc->setStopTime(client, systemTime());
François Gaffie11d30102018-11-02 16:09:09 +01002073 DeviceVector newDevices = getNewOutputDevices(outputDesc, false /*fromCache*/);
Eric Laurente552edb2014-03-10 17:42:56 -07002074 // delay the device switch by twice the latency because stopOutput() is executed when
2075 // the track stop() command is received and at that time the audio track buffer can
2076 // still contain data that needs to be drained. The latency only covers the audio HAL
2077 // and kernel buffers. Also the latency does not always include additional delay in the
2078 // audio path (audio DSP, CODEC ...)
François Gaffie11d30102018-11-02 16:09:09 +01002079 setOutputDevices(outputDesc, newDevices, false, outputDesc->latency()*2);
Eric Laurente552edb2014-03-10 17:42:56 -07002080
2081 // force restoring the device selection on other active outputs if it differs from the
2082 // one being selected for this output
Eric Laurent57de36c2016-09-28 16:59:11 -07002083 uint32_t delayMs = outputDesc->latency()*2;
Eric Laurente552edb2014-03-10 17:42:56 -07002084 for (size_t i = 0; i < mOutputs.size(); i++) {
François Gaffie11d30102018-11-02 16:09:09 +01002085 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Eric Laurentc75307b2015-03-17 15:29:32 -07002086 if (desc != outputDesc &&
Eric Laurente552edb2014-03-10 17:42:56 -07002087 desc->isActive() &&
2088 outputDesc->sharesHwModuleWith(desc) &&
François Gaffie11d30102018-11-02 16:09:09 +01002089 (newDevices != desc->devices())) {
2090 DeviceVector newDevices2 = getNewOutputDevices(desc, false /*fromCache*/);
2091 bool force = desc->devices() != newDevices2;
Eric Laurentf3a5a602018-05-22 18:42:55 -07002092
François Gaffie11d30102018-11-02 16:09:09 +01002093 setOutputDevices(desc, newDevices2, force, delayMs);
2094
Eric Laurent57de36c2016-09-28 16:59:11 -07002095 // re-apply device specific volume if not done by setOutputDevice()
2096 if (!force) {
François Gaffie11d30102018-11-02 16:09:09 +01002097 applyStreamVolumes(desc, newDevices2.types(), delayMs);
Eric Laurent57de36c2016-09-28 16:59:11 -07002098 }
Eric Laurente552edb2014-03-10 17:42:56 -07002099 }
2100 }
2101 // update the outputs if stopping one with a stream that can affect notification routing
2102 handleNotificationRoutingForStream(stream);
2103 }
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09002104
2105 if (stream == AUDIO_STREAM_ENFORCED_AUDIBLE &&
2106 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -08002107 setStrategyMute(streamToStrategy(AUDIO_STREAM_ALARM), false, outputDesc);
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09002108 }
2109
François Gaffiec005e562018-11-06 15:04:49 +01002110 if (followsSameRouting(client->attributes(), attributes_initializer(AUDIO_USAGE_MEDIA))) {
Eric Laurent36829f92017-04-07 19:04:42 -07002111 selectOutputForMusicEffects();
2112 }
Eric Laurente552edb2014-03-10 17:42:56 -07002113 return NO_ERROR;
2114 } else {
Eric Laurentc75307b2015-03-17 15:29:32 -07002115 ALOGW("stopOutput() refcount is already 0");
Eric Laurente552edb2014-03-10 17:42:56 -07002116 return INVALID_OPERATION;
2117 }
2118}
2119
jiabinbce0c1d2020-10-05 11:20:18 -07002120bool AudioPolicyManager::releaseOutput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07002121{
Eric Laurent8fc147b2018-07-22 19:13:55 -07002122 ALOGV("%s portId %d", __FUNCTION__, portId);
2123
2124 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputForClient(portId);
2125 if (outputDesc == 0) {
Andy Hung39efb7a2018-09-26 15:39:28 -07002126 // If an output descriptor is closed due to a device routing change,
2127 // then there are race conditions with releaseOutput from tracks
2128 // that may be destroyed (with no PlaybackThread) or a PlaybackThread
2129 // destroyed shortly thereafter.
2130 //
2131 // Here we just log a warning, instead of a fatal error.
Eric Laurent8fc147b2018-07-22 19:13:55 -07002132 ALOGW("releaseOutput() no output for client %d", portId);
jiabinbce0c1d2020-10-05 11:20:18 -07002133 return false;
Eric Laurente552edb2014-03-10 17:42:56 -07002134 }
Eric Laurent8fc147b2018-07-22 19:13:55 -07002135
2136 ALOGV("releaseOutput() %d", outputDesc->mIoHandle);
Eric Laurente552edb2014-03-10 17:42:56 -07002137
Jaideep Sharma7bf382e2020-11-26 17:07:29 +05302138 sp<TrackClientDescriptor> client = outputDesc->getClient(portId);
2139 if (outputDesc->isClientActive(client)) {
2140 ALOGW("releaseOutput() inactivates portId %d in good faith", portId);
2141 stopOutput(portId);
2142 }
2143
Eric Laurent8fc147b2018-07-22 19:13:55 -07002144 if (outputDesc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
2145 if (outputDesc->mDirectOpenCount <= 0) {
Eric Laurente552edb2014-03-10 17:42:56 -07002146 ALOGW("releaseOutput() invalid open count %d for output %d",
Eric Laurent8fc147b2018-07-22 19:13:55 -07002147 outputDesc->mDirectOpenCount, outputDesc->mIoHandle);
jiabinbce0c1d2020-10-05 11:20:18 -07002148 return false;
Eric Laurente552edb2014-03-10 17:42:56 -07002149 }
Eric Laurent8fc147b2018-07-22 19:13:55 -07002150 if (--outputDesc->mDirectOpenCount == 0) {
2151 closeOutput(outputDesc->mIoHandle);
Eric Laurentb52c1522014-05-20 11:27:36 -07002152 mpClientInterface->onAudioPortListUpdate();
Eric Laurente552edb2014-03-10 17:42:56 -07002153 }
2154 }
Jaideep Sharma7bf382e2020-11-26 17:07:29 +05302155
Andy Hung39efb7a2018-09-26 15:39:28 -07002156 outputDesc->removeClient(portId);
jiabinbce0c1d2020-10-05 11:20:18 -07002157 if (outputDesc->mPendingReopenToQueryProfiles && outputDesc->getClientCount() == 0) {
2158 // The output is pending reopened to query dynamic profiles and
2159 // there is no active clients
2160 closeOutput(outputDesc->mIoHandle);
2161 sp<SwAudioOutputDescriptor> newOutputDesc = openOutputWithProfileAndDevice(
2162 outputDesc->mProfile, mEngine->getActiveMediaDevices(mAvailableOutputDevices));
2163 if (newOutputDesc == nullptr) {
2164 ALOGE("%s failed to open output", __func__);
2165 }
2166 return true;
2167 }
2168 return false;
Eric Laurente552edb2014-03-10 17:42:56 -07002169}
2170
Eric Laurentcaf7f482014-11-25 17:50:47 -08002171status_t AudioPolicyManager::getInputForAttr(const audio_attributes_t *attr,
2172 audio_io_handle_t *input,
Mikhail Naganov2996f672019-04-18 12:29:59 -07002173 audio_unique_id_t riid,
Eric Laurentcaf7f482014-11-25 17:50:47 -08002174 audio_session_t session,
Svet Ganov3e5f14f2021-05-13 22:51:08 +00002175 const AttributionSourceState& attributionSource,
Eric Laurent20b9ef02016-12-05 11:03:16 -08002176 const audio_config_base_t *config,
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -08002177 audio_input_flags_t flags,
Eric Laurent2ac76942017-06-22 17:17:09 -07002178 audio_port_handle_t *selectedDeviceId,
Eric Laurent20b9ef02016-12-05 11:03:16 -08002179 input_type_t *inputType,
2180 audio_port_handle_t *portId)
Eric Laurente552edb2014-03-10 17:42:56 -07002181{
François Gaffiec005e562018-11-06 15:04:49 +01002182 ALOGV("%s() source %d, sampling rate %d, format %#x, channel mask %#x, session %d, "
Eric Laurent2f2c1982021-06-02 14:03:11 +02002183 "flags %#x attributes=%s requested device ID %d",
2184 __func__, attr->source, config->sample_rate, config->format, config->channel_mask,
2185 session, flags, toString(*attr).c_str(), *selectedDeviceId);
Eric Laurente552edb2014-03-10 17:42:56 -07002186
Eric Laurentad2e7b92017-09-14 20:06:42 -07002187 status_t status = NO_ERROR;
Eric Laurentc447ded2015-01-06 08:47:05 -08002188 audio_source_t halInputSource;
Francois Gaffie716e1432019-01-14 16:58:59 +01002189 audio_attributes_t attributes = *attr;
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002190 sp<AudioPolicyMix> policyMix;
François Gaffie11d30102018-11-02 16:09:09 +01002191 sp<DeviceDescriptor> device;
Eric Laurent8fc147b2018-07-22 19:13:55 -07002192 sp<AudioInputDescriptor> inputDesc;
2193 sp<RecordClientDescriptor> clientDesc;
2194 audio_port_handle_t requestedDeviceId = *selectedDeviceId;
Svet Ganov3e5f14f2021-05-13 22:51:08 +00002195 uid_t uid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_uid_t(attributionSource.uid));
Eric Laurent8f42ea12018-08-08 09:08:25 -07002196 bool isSoundTrigger;
Eric Laurent8f42ea12018-08-08 09:08:25 -07002197
2198 // The supplied portId must be AUDIO_PORT_HANDLE_NONE
2199 if (*portId != AUDIO_PORT_HANDLE_NONE) {
2200 return INVALID_OPERATION;
2201 }
Eric Laurent20b9ef02016-12-05 11:03:16 -08002202
Francois Gaffie716e1432019-01-14 16:58:59 +01002203 if (attr->source == AUDIO_SOURCE_DEFAULT) {
2204 attributes.source = AUDIO_SOURCE_MIC;
Eric Laurentfe231122017-11-17 17:48:06 -08002205 }
2206
Paul McLean466dc8e2015-04-17 13:15:36 -06002207 // Explicit routing?
Pattydd807582021-11-04 21:01:03 +08002208 sp<DeviceDescriptor> explicitRoutingDevice =
François Gaffie11d30102018-11-02 16:09:09 +01002209 mAvailableInputDevices.getDeviceFromId(*selectedDeviceId);
Paul McLean466dc8e2015-04-17 13:15:36 -06002210
Eric Laurentad2e7b92017-09-14 20:06:42 -07002211 // special case for mmap capture: if an input IO handle is specified, we reuse this input if
2212 // possible
2213 if ((flags & AUDIO_INPUT_FLAG_MMAP_NOIRQ) == AUDIO_INPUT_FLAG_MMAP_NOIRQ &&
2214 *input != AUDIO_IO_HANDLE_NONE) {
2215 ssize_t index = mInputs.indexOfKey(*input);
2216 if (index < 0) {
2217 ALOGW("getInputForAttr() unknown MMAP input %d", *input);
2218 status = BAD_VALUE;
2219 goto error;
2220 }
2221 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002222 RecordClientVector clients = inputDesc->getClientsForSession(session);
2223 if (clients.size() == 0) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07002224 ALOGW("getInputForAttr() unknown session %d on input %d", session, *input);
2225 status = BAD_VALUE;
2226 goto error;
2227 }
2228 // For MMAP mode, the first call to getInputForAttr() is made on behalf of audioflinger.
2229 // The second call is for the first active client and sets the UID. Any further call
Eric Laurent331679c2018-04-16 17:03:16 -07002230 // corresponds to a new client and is only permitted from the same UID.
2231 // If the first UID is silenced, allow a new UID connection and replace with new UID
Eric Laurent8f42ea12018-08-08 09:08:25 -07002232 if (clients.size() > 1) {
2233 for (const auto& client : clients) {
2234 // The client map is ordered by key values (portId) and portIds are allocated
2235 // incrementaly. So the first client in this list is the one opened by audio flinger
2236 // when the mmap stream is created and should be ignored as it does not correspond
2237 // to an actual client
2238 if (client == *clients.cbegin()) {
2239 continue;
2240 }
2241 if (uid != client->uid() && !client->isSilenced()) {
2242 ALOGW("getInputForAttr() bad uid %d for client %d uid %d",
2243 uid, client->portId(), client->uid());
2244 status = INVALID_OPERATION;
2245 goto error;
2246 }
Eric Laurent331679c2018-04-16 17:03:16 -07002247 }
Eric Laurentad2e7b92017-09-14 20:06:42 -07002248 }
Eric Laurentad2e7b92017-09-14 20:06:42 -07002249 *inputType = API_INPUT_LEGACY;
François Gaffie11d30102018-11-02 16:09:09 +01002250 device = inputDesc->getDevice();
Eric Laurentad2e7b92017-09-14 20:06:42 -07002251
Eric Laurentfecbceb2021-02-09 14:46:43 +01002252 ALOGV("%s reusing MMAP input %d for session %d", __FUNCTION__, *input, session);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002253 goto exit;
Eric Laurentad2e7b92017-09-14 20:06:42 -07002254 }
2255
2256 *input = AUDIO_IO_HANDLE_NONE;
2257 *inputType = API_INPUT_INVALID;
2258
Francois Gaffie716e1432019-01-14 16:58:59 +01002259 halInputSource = attributes.source;
Eric Laurentad2e7b92017-09-14 20:06:42 -07002260
Francois Gaffie716e1432019-01-14 16:58:59 +01002261 if (attributes.source == AUDIO_SOURCE_REMOTE_SUBMIX &&
2262 strncmp(attributes.tags, "addr=", strlen("addr=")) == 0) {
2263 status = mPolicyMixes.getInputMixForAttr(attributes, &policyMix);
Eric Laurentad2e7b92017-09-14 20:06:42 -07002264 if (status != NO_ERROR) {
jiabinc1de2df2019-05-07 14:26:40 -07002265 ALOGW("%s could not find input mix for attr %s",
2266 __func__, toString(attributes).c_str());
Eric Laurentad2e7b92017-09-14 20:06:42 -07002267 goto error;
François Gaffie036e1e92015-03-19 10:16:24 +01002268 }
jiabinc1de2df2019-05-07 14:26:40 -07002269 device = mAvailableInputDevices.getDevice(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
2270 String8(attr->tags + strlen("addr=")),
2271 AUDIO_FORMAT_DEFAULT);
2272 if (device == nullptr) {
Kevin Rocard04ed0462019-05-02 17:53:24 -07002273 ALOGW("%s could not find in Remote Submix device for source %d, tags %s",
jiabinc1de2df2019-05-07 14:26:40 -07002274 __func__, attributes.source, attributes.tags);
2275 status = BAD_VALUE;
2276 goto error;
2277 }
2278
Kevin Rocard25f9b052019-02-27 15:08:54 -08002279 if (is_mix_loopback_render(policyMix->mRouteFlags)) {
2280 *inputType = API_INPUT_MIX_PUBLIC_CAPTURE_PLAYBACK;
2281 } else {
2282 *inputType = API_INPUT_MIX_EXT_POLICY_REROUTE;
2283 }
Eric Laurent275e8e92014-11-30 15:14:47 -08002284 } else {
François Gaffie11d30102018-11-02 16:09:09 +01002285 if (explicitRoutingDevice != nullptr) {
2286 device = explicitRoutingDevice;
Eric Laurent97ac8712018-07-27 18:59:02 -07002287 } else {
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01002288 // Prevent from storing invalid requested device id in clients
2289 requestedDeviceId = AUDIO_PORT_HANDLE_NONE;
yuanjiahsu0735bf32021-03-18 08:12:54 +08002290 device = mEngine->getInputDeviceForAttributes(attributes, uid, &policyMix);
yuanjiahsu4069d5d2021-04-19 07:54:27 +08002291 ALOGV_IF(device != nullptr, "%s found device type is 0x%X",
2292 __FUNCTION__, device->type());
Eric Laurent97ac8712018-07-27 18:59:02 -07002293 }
François Gaffie11d30102018-11-02 16:09:09 +01002294 if (device == nullptr) {
Francois Gaffie716e1432019-01-14 16:58:59 +01002295 ALOGW("getInputForAttr() could not find device for source %d", attributes.source);
Eric Laurentad2e7b92017-09-14 20:06:42 -07002296 status = BAD_VALUE;
2297 goto error;
Eric Laurent275e8e92014-11-30 15:14:47 -08002298 }
Alden DSouzab7d20782021-02-08 08:51:42 -08002299 if (device->type() == AUDIO_DEVICE_IN_ECHO_REFERENCE) {
2300 *inputType = API_INPUT_MIX_CAPTURE;
2301 } else if (policyMix) {
François Gaffie11d30102018-11-02 16:09:09 +01002302 ALOG_ASSERT(policyMix->mMixType == MIX_TYPE_RECORDERS, "Invalid Mix Type");
2303 // there is an external policy, but this input is attached to a mix of recorders,
2304 // meaning it receives audio injected into the framework, so the recorder doesn't
2305 // know about it and is therefore considered "legacy"
2306 *inputType = API_INPUT_LEGACY;
2307 } else if (audio_is_remote_submix_device(device->type())) {
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -08002308 *inputType = API_INPUT_MIX_CAPTURE;
François Gaffie11d30102018-11-02 16:09:09 +01002309 } else if (device->type() == AUDIO_DEVICE_IN_TELEPHONY_RX) {
Eric Laurent82db2692015-08-07 13:59:42 -07002310 *inputType = API_INPUT_TELEPHONY_RX;
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -08002311 } else {
2312 *inputType = API_INPUT_LEGACY;
Eric Laurentc722f302014-12-10 11:21:49 -08002313 }
Ravi Kumar Alamandab367f5b2015-08-25 08:21:37 -07002314
Eric Laurent599c7582015-12-07 18:05:55 -08002315 }
2316
François Gaffiec005e562018-11-06 15:04:49 +01002317 *input = getInputForDevice(device, session, attributes, config, flags, policyMix);
Eric Laurent599c7582015-12-07 18:05:55 -08002318 if (*input == AUDIO_IO_HANDLE_NONE) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07002319 status = INVALID_OPERATION;
2320 goto error;
Eric Laurent599c7582015-12-07 18:05:55 -08002321 }
Eric Laurent20b9ef02016-12-05 11:03:16 -08002322
Eric Laurent8f42ea12018-08-08 09:08:25 -07002323exit:
2324
François Gaffiec005e562018-11-06 15:04:49 +01002325 *selectedDeviceId = mAvailableInputDevices.contains(device) ?
2326 device->getId() : AUDIO_PORT_HANDLE_NONE;
Eric Laurent2ac76942017-06-22 17:17:09 -07002327
Francois Gaffie716e1432019-01-14 16:58:59 +01002328 isSoundTrigger = attributes.source == AUDIO_SOURCE_HOTWORD &&
Carter Hsud0cce2e2019-05-03 17:36:28 +08002329 mSoundTriggerSessions.indexOfKey(session) >= 0;
jiabin4ef93452019-09-10 14:29:54 -07002330 *portId = PolicyAudioPort::getNextUniqueId();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002331
Mikhail Naganov2996f672019-04-18 12:29:59 -07002332 clientDesc = new RecordClientDescriptor(*portId, riid, uid, session, attributes, *config,
Francois Gaffie716e1432019-01-14 16:58:59 +01002333 requestedDeviceId, attributes.source, flags,
2334 isSoundTrigger);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002335 inputDesc = mInputs.valueFor(*input);
Andy Hung39efb7a2018-09-26 15:39:28 -07002336 inputDesc->addClient(clientDesc);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002337
2338 ALOGV("getInputForAttr() returns input %d type %d selectedDeviceId %d for port ID %d",
2339 *input, *inputType, *selectedDeviceId, *portId);
Eric Laurent2ac76942017-06-22 17:17:09 -07002340
Eric Laurent599c7582015-12-07 18:05:55 -08002341 return NO_ERROR;
Eric Laurentad2e7b92017-09-14 20:06:42 -07002342
2343error:
Eric Laurentad2e7b92017-09-14 20:06:42 -07002344 return status;
Eric Laurent599c7582015-12-07 18:05:55 -08002345}
2346
2347
François Gaffie11d30102018-11-02 16:09:09 +01002348audio_io_handle_t AudioPolicyManager::getInputForDevice(const sp<DeviceDescriptor> &device,
Eric Laurent599c7582015-12-07 18:05:55 -08002349 audio_session_t session,
François Gaffiec005e562018-11-06 15:04:49 +01002350 const audio_attributes_t &attributes,
Eric Laurentfe231122017-11-17 17:48:06 -08002351 const audio_config_base_t *config,
Eric Laurent599c7582015-12-07 18:05:55 -08002352 audio_input_flags_t flags,
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002353 const sp<AudioPolicyMix> &policyMix)
Eric Laurent599c7582015-12-07 18:05:55 -08002354{
2355 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
François Gaffiec005e562018-11-06 15:04:49 +01002356 audio_source_t halInputSource = attributes.source;
Eric Laurent599c7582015-12-07 18:05:55 -08002357 bool isSoundTrigger = false;
2358
François Gaffiec005e562018-11-06 15:04:49 +01002359 if (attributes.source == AUDIO_SOURCE_HOTWORD) {
Eric Laurent599c7582015-12-07 18:05:55 -08002360 ssize_t index = mSoundTriggerSessions.indexOfKey(session);
2361 if (index >= 0) {
2362 input = mSoundTriggerSessions.valueFor(session);
2363 isSoundTrigger = true;
2364 flags = (audio_input_flags_t)(flags | AUDIO_INPUT_FLAG_HW_HOTWORD);
2365 ALOGV("SoundTrigger capture on session %d input %d", session, input);
2366 } else {
2367 halInputSource = AUDIO_SOURCE_VOICE_RECOGNITION;
Eric Laurent5dbe4712014-09-19 19:04:57 -07002368 }
François Gaffiec005e562018-11-06 15:04:49 +01002369 } else if (attributes.source == AUDIO_SOURCE_VOICE_COMMUNICATION &&
Eric Laurentfe231122017-11-17 17:48:06 -08002370 audio_is_linear_pcm(config->format)) {
Haynes Mathew George851d3ff2017-06-19 20:01:57 -07002371 flags = (audio_input_flags_t)(flags | AUDIO_INPUT_FLAG_VOIP_TX);
Eric Laurent5dbe4712014-09-19 19:04:57 -07002372 }
2373
Andy Hungf129b032015-04-07 13:45:50 -07002374 // find a compatible input profile (not necessarily identical in parameters)
2375 sp<IOProfile> profile;
Eric Laurentfe231122017-11-17 17:48:06 -08002376 // sampling rate and flags may be updated by getInputProfile
2377 uint32_t profileSamplingRate = (config->sample_rate == 0) ?
2378 SAMPLE_RATE_HZ_DEFAULT : config->sample_rate;
Glenn Kasten730b9262018-03-29 15:01:26 -07002379 audio_format_t profileFormat;
Eric Laurentfe231122017-11-17 17:48:06 -08002380 audio_channel_mask_t profileChannelMask = config->channel_mask;
Andy Hungf129b032015-04-07 13:45:50 -07002381 audio_input_flags_t profileFlags = flags;
2382 for (;;) {
Glenn Kasten730b9262018-03-29 15:01:26 -07002383 profileFormat = config->format; // reset each time through loop, in case it is updated
François Gaffie11d30102018-11-02 16:09:09 +01002384 profile = getInputProfile(device, profileSamplingRate, profileFormat, profileChannelMask,
Andy Hungf129b032015-04-07 13:45:50 -07002385 profileFlags);
2386 if (profile != 0) {
2387 break; // success
Eric Laurent05067782016-06-01 18:27:28 -07002388 } else if (profileFlags & AUDIO_INPUT_FLAG_RAW) {
2389 profileFlags = (audio_input_flags_t) (profileFlags & ~AUDIO_INPUT_FLAG_RAW); // retry
Andy Hungf129b032015-04-07 13:45:50 -07002390 } else if (profileFlags != AUDIO_INPUT_FLAG_NONE) {
2391 profileFlags = AUDIO_INPUT_FLAG_NONE; // retry
2392 } else { // fail
François Gaffie11d30102018-11-02 16:09:09 +01002393 ALOGW("%s could not find profile for device %s, sampling rate %u, format %#x, "
Pattydd807582021-11-04 21:01:03 +08002394 "channel mask 0x%X, flags %#x", __func__, device->toString().c_str(),
François Gaffie11d30102018-11-02 16:09:09 +01002395 config->sample_rate, config->format, config->channel_mask, flags);
Eric Laurent599c7582015-12-07 18:05:55 -08002396 return input;
Eric Laurent5dbe4712014-09-19 19:04:57 -07002397 }
Eric Laurente552edb2014-03-10 17:42:56 -07002398 }
Glenn Kasten05ddca52016-02-11 08:17:12 -08002399 // Pick input sampling rate if not specified by client
Eric Laurentfe231122017-11-17 17:48:06 -08002400 uint32_t samplingRate = config->sample_rate;
Glenn Kasten05ddca52016-02-11 08:17:12 -08002401 if (samplingRate == 0) {
2402 samplingRate = profileSamplingRate;
2403 }
Eric Laurente552edb2014-03-10 17:42:56 -07002404
Eric Laurent322b4d22015-04-03 15:57:54 -07002405 if (profile->getModuleHandle() == 0) {
2406 ALOGE("getInputForAttr(): HW module %s not opened", profile->getModuleName());
Eric Laurent599c7582015-12-07 18:05:55 -08002407 return input;
Eric Laurentcf2c0212014-07-25 16:20:43 -07002408 }
2409
Eric Laurentec376dc2021-04-08 20:41:22 +02002410 // Reuse an already opened input if a client with the same session ID already exists
2411 // on that input
2412 for (size_t i = 0; i < mInputs.size(); i++) {
2413 sp <AudioInputDescriptor> desc = mInputs.valueAt(i);
2414 if (desc->mProfile != profile) {
2415 continue;
2416 }
2417 RecordClientVector clients = desc->clientsList();
2418 for (const auto &client : clients) {
2419 if (session == client->session()) {
2420 return desc->mIoHandle;
2421 }
2422 }
2423 }
2424
Eric Laurent3974e3b2017-12-07 17:58:43 -08002425 if (!profile->canOpenNewIo()) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08002426 for (size_t i = 0; i < mInputs.size(); ) {
Eric Laurentc529cf62020-04-17 18:19:10 -07002427 sp<AudioInputDescriptor> desc = mInputs.valueAt(i);
Eric Laurent4eb58f12018-12-07 16:41:02 -08002428 if (desc->mProfile != profile) {
Carter Hsu9a645a92019-05-15 12:15:32 +08002429 i++;
Eric Laurent4eb58f12018-12-07 16:41:02 -08002430 continue;
2431 }
2432 // if sound trigger, reuse input if used by other sound trigger on same session
2433 // else
2434 // reuse input if active client app is not in IDLE state
2435 //
2436 RecordClientVector clients = desc->clientsList();
2437 bool doClose = false;
2438 for (const auto& client : clients) {
2439 if (isSoundTrigger != client->isSoundTrigger()) {
2440 continue;
2441 }
2442 if (client->isSoundTrigger()) {
2443 if (session == client->session()) {
2444 return desc->mIoHandle;
2445 }
2446 continue;
2447 }
2448 if (client->active() && client->appState() != APP_STATE_IDLE) {
2449 return desc->mIoHandle;
2450 }
2451 doClose = true;
2452 }
2453 if (doClose) {
2454 closeInput(desc->mIoHandle);
2455 } else {
2456 i++;
2457 }
2458 }
Eric Laurent3974e3b2017-12-07 17:58:43 -08002459 }
2460
Eric Laurentfe231122017-11-17 17:48:06 -08002461 sp<AudioInputDescriptor> inputDesc = new AudioInputDescriptor(profile, mpClientInterface);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07002462
Eric Laurentfe231122017-11-17 17:48:06 -08002463 audio_config_t lConfig = AUDIO_CONFIG_INITIALIZER;
2464 lConfig.sample_rate = profileSamplingRate;
2465 lConfig.channel_mask = profileChannelMask;
2466 lConfig.format = profileFormat;
Eric Laurente3014102017-05-03 11:15:43 -07002467
François Gaffie11d30102018-11-02 16:09:09 +01002468 status_t status = inputDesc->open(&lConfig, device, halInputSource, profileFlags, &input);
Eric Laurentcf2c0212014-07-25 16:20:43 -07002469
2470 // only accept input with the exact requested set of parameters
Eric Laurent599c7582015-12-07 18:05:55 -08002471 if (status != NO_ERROR || input == AUDIO_IO_HANDLE_NONE ||
Eric Laurentfe231122017-11-17 17:48:06 -08002472 (profileSamplingRate != lConfig.sample_rate) ||
2473 !audio_formats_match(profileFormat, lConfig.format) ||
2474 (profileChannelMask != lConfig.channel_mask)) {
2475 ALOGW("getInputForAttr() failed opening input: sampling rate %d"
Glenn Kasten49f36ba2017-12-06 13:02:02 -08002476 ", format %#x, channel mask %#x",
Eric Laurentfe231122017-11-17 17:48:06 -08002477 profileSamplingRate, profileFormat, profileChannelMask);
Eric Laurent599c7582015-12-07 18:05:55 -08002478 if (input != AUDIO_IO_HANDLE_NONE) {
Eric Laurentfe231122017-11-17 17:48:06 -08002479 inputDesc->close();
Eric Laurentcf2c0212014-07-25 16:20:43 -07002480 }
Eric Laurent599c7582015-12-07 18:05:55 -08002481 return AUDIO_IO_HANDLE_NONE;
Eric Laurente552edb2014-03-10 17:42:56 -07002482 }
2483
Eric Laurentc722f302014-12-10 11:21:49 -08002484 inputDesc->mPolicyMix = policyMix;
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002485
Eric Laurent599c7582015-12-07 18:05:55 -08002486 addInput(input, inputDesc);
Eric Laurentb52c1522014-05-20 11:27:36 -07002487 mpClientInterface->onAudioPortListUpdate();
Paul McLean466dc8e2015-04-17 13:15:36 -06002488
Eric Laurent599c7582015-12-07 18:05:55 -08002489 return input;
Eric Laurente552edb2014-03-10 17:42:56 -07002490}
2491
Eric Laurent4eb58f12018-12-07 16:41:02 -08002492status_t AudioPolicyManager::startInput(audio_port_handle_t portId)
Eric Laurentbb948092017-01-23 18:33:30 -08002493{
Eric Laurent8fc147b2018-07-22 19:13:55 -07002494 ALOGV("%s portId %d", __FUNCTION__, portId);
2495
2496 sp<AudioInputDescriptor> inputDesc = mInputs.getInputForClient(portId);
2497 if (inputDesc == 0) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002498 ALOGW("%s no input for client %d", __FUNCTION__, portId);
Eric Laurentd52a28c2020-08-21 17:10:39 -07002499 return DEAD_OBJECT;
Eric Laurent8fc147b2018-07-22 19:13:55 -07002500 }
Eric Laurent8fc147b2018-07-22 19:13:55 -07002501 audio_io_handle_t input = inputDesc->mIoHandle;
Andy Hung39efb7a2018-09-26 15:39:28 -07002502 sp<RecordClientDescriptor> client = inputDesc->getClient(portId);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002503 if (client->active()) {
2504 ALOGW("%s input %d client %d already started", __FUNCTION__, input, client->portId());
2505 return INVALID_OPERATION;
Eric Laurent4dc68062014-07-28 17:26:49 -07002506 }
2507
Eric Laurent8f42ea12018-08-08 09:08:25 -07002508 audio_session_t session = client->session();
2509
Eric Laurent4eb58f12018-12-07 16:41:02 -08002510 ALOGV("%s input:%d, session:%d)", __FUNCTION__, input, session);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002511
Eric Laurent4eb58f12018-12-07 16:41:02 -08002512 Vector<sp<AudioInputDescriptor>> activeInputs = mInputs.getActiveInputs();
Eric Laurent74708e72017-04-07 17:13:42 -07002513
Eric Laurent4eb58f12018-12-07 16:41:02 -08002514 status_t status = inputDesc->start();
2515 if (status != NO_ERROR) {
2516 return status;
Eric Laurent74708e72017-04-07 17:13:42 -07002517 }
Eric Laurente552edb2014-03-10 17:42:56 -07002518
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002519 // increment activity count before calling getNewInputDevice() below as only active sessions
Eric Laurent313d1e72016-01-29 09:56:57 -08002520 // are considered for device selection
Eric Laurent8f42ea12018-08-08 09:08:25 -07002521 inputDesc->setClientActive(client, true);
Eric Laurent313d1e72016-01-29 09:56:57 -08002522
Eric Laurent8f42ea12018-08-08 09:08:25 -07002523 // indicate active capture to sound trigger service if starting capture from a mic on
2524 // primary HW module
François Gaffie11d30102018-11-02 16:09:09 +01002525 sp<DeviceDescriptor> device = getNewInputDevice(inputDesc);
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002526 if (device != nullptr) {
2527 status = setInputDevice(input, device, true /* force */);
2528 } else {
2529 ALOGW("%s no new input device can be found for descriptor %d",
2530 __FUNCTION__, inputDesc->getId());
2531 status = BAD_VALUE;
2532 }
Eric Laurente552edb2014-03-10 17:42:56 -07002533
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002534 if (status == NO_ERROR && inputDesc->activeCount() == 1) {
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002535 sp<AudioPolicyMix> policyMix = inputDesc->mPolicyMix.promote();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002536 // if input maps to a dynamic policy with an activity listener, notify of state change
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002537 if ((policyMix != nullptr)
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002538 && ((policyMix->mCbFlags & AudioMix::kCbFlagNotifyActivity) != 0)) {
2539 mpClientInterface->onDynamicPolicyMixStateUpdate(policyMix->mDeviceAddress,
Eric Laurent8f42ea12018-08-08 09:08:25 -07002540 MIX_STATE_MIXING);
Eric Laurent733ce942017-12-07 12:18:25 -08002541 }
Eric Laurent3974e3b2017-12-07 17:58:43 -08002542
François Gaffie11d30102018-11-02 16:09:09 +01002543 DeviceVector primaryInputDevices = availablePrimaryModuleInputDevices();
2544 if (primaryInputDevices.contains(device) &&
Eric Laurent8f42ea12018-08-08 09:08:25 -07002545 mInputs.activeInputsCountOnDevices(primaryInputDevices) == 1) {
Ytai Ben-Tsvi74cd6b02019-10-25 10:06:40 -07002546 mpClientInterface->setSoundTriggerCaptureState(true);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002547 }
Jean-Michel Trivieb6421d2016-03-17 12:32:52 -07002548
Eric Laurent8f42ea12018-08-08 09:08:25 -07002549 // automatically enable the remote submix output when input is started if not
2550 // used by a policy mix of type MIX_TYPE_RECORDERS
2551 // For remote submix (a virtual device), we open only one input per capture request.
François Gaffie11d30102018-11-02 16:09:09 +01002552 if (audio_is_remote_submix_device(inputDesc->getDeviceType())) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002553 String8 address = String8("");
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002554 if (policyMix == nullptr) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002555 address = String8("0");
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002556 } else if (policyMix->mMixType == MIX_TYPE_PLAYERS) {
2557 address = policyMix->mDeviceAddress;
Jean-Michel Trivieb6421d2016-03-17 12:32:52 -07002558 }
Eric Laurent8f42ea12018-08-08 09:08:25 -07002559 if (address != "") {
2560 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
2561 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08002562 address, "remote-submix", AUDIO_FORMAT_DEFAULT);
Eric Laurentc722f302014-12-10 11:21:49 -08002563 }
Glenn Kasten74a8e252014-07-24 14:09:55 -07002564 }
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002565 } else if (status != NO_ERROR) {
2566 // Restore client activity state.
2567 inputDesc->setClientActive(client, false);
2568 inputDesc->stop();
Eric Laurente552edb2014-03-10 17:42:56 -07002569 }
2570
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002571 ALOGV("%s input %d source = %d status = %d exit",
2572 __FUNCTION__, input, client->source(), status);
Eric Laurente552edb2014-03-10 17:42:56 -07002573
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002574 return status;
Eric Laurente552edb2014-03-10 17:42:56 -07002575}
2576
Eric Laurent8fc147b2018-07-22 19:13:55 -07002577status_t AudioPolicyManager::stopInput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07002578{
Eric Laurent8fc147b2018-07-22 19:13:55 -07002579 ALOGV("%s portId %d", __FUNCTION__, portId);
2580
2581 sp<AudioInputDescriptor> inputDesc = mInputs.getInputForClient(portId);
2582 if (inputDesc == 0) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002583 ALOGW("%s no input for client %d", __FUNCTION__, portId);
Eric Laurente552edb2014-03-10 17:42:56 -07002584 return BAD_VALUE;
2585 }
Eric Laurent8fc147b2018-07-22 19:13:55 -07002586 audio_io_handle_t input = inputDesc->mIoHandle;
Andy Hung39efb7a2018-09-26 15:39:28 -07002587 sp<RecordClientDescriptor> client = inputDesc->getClient(portId);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002588 if (!client->active()) {
2589 ALOGW("%s input %d client %d already stopped", __FUNCTION__, input, client->portId());
Eric Laurente552edb2014-03-10 17:42:56 -07002590 return INVALID_OPERATION;
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002591 }
Carter Hsue6139d52021-07-08 10:30:20 +08002592 auto old_source = inputDesc->source();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002593 inputDesc->setClientActive(client, false);
Paul McLean466dc8e2015-04-17 13:15:36 -06002594
Eric Laurent8f42ea12018-08-08 09:08:25 -07002595 inputDesc->stop();
2596 if (inputDesc->isActive()) {
Carter Hsue6139d52021-07-08 10:30:20 +08002597 auto current_source = inputDesc->source();
2598 setInputDevice(input, getNewInputDevice(inputDesc),
2599 old_source != current_source /* force */);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002600 } else {
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002601 sp<AudioPolicyMix> policyMix = inputDesc->mPolicyMix.promote();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002602 // if input maps to a dynamic policy with an activity listener, notify of state change
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002603 if ((policyMix != nullptr)
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002604 && ((policyMix->mCbFlags & AudioMix::kCbFlagNotifyActivity) != 0)) {
2605 mpClientInterface->onDynamicPolicyMixStateUpdate(policyMix->mDeviceAddress,
Eric Laurent8f42ea12018-08-08 09:08:25 -07002606 MIX_STATE_IDLE);
Eric Laurent84332aa2016-01-28 22:19:18 +00002607 }
Eric Laurent8f42ea12018-08-08 09:08:25 -07002608
2609 // automatically disable the remote submix output when input is stopped if not
2610 // used by a policy mix of type MIX_TYPE_RECORDERS
François Gaffie11d30102018-11-02 16:09:09 +01002611 if (audio_is_remote_submix_device(inputDesc->getDeviceType())) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002612 String8 address = String8("");
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002613 if (policyMix == nullptr) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002614 address = String8("0");
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002615 } else if (policyMix->mMixType == MIX_TYPE_PLAYERS) {
2616 address = policyMix->mDeviceAddress;
Eric Laurent8f42ea12018-08-08 09:08:25 -07002617 }
2618 if (address != "") {
2619 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
2620 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08002621 address, "remote-submix", AUDIO_FORMAT_DEFAULT);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002622 }
2623 }
Eric Laurent8f42ea12018-08-08 09:08:25 -07002624 resetInputDevice(input);
2625
2626 // indicate inactive capture to sound trigger service if stopping capture from a mic on
2627 // primary HW module
François Gaffie11d30102018-11-02 16:09:09 +01002628 DeviceVector primaryInputDevices = availablePrimaryModuleInputDevices();
2629 if (primaryInputDevices.contains(inputDesc->getDevice()) &&
Eric Laurent8f42ea12018-08-08 09:08:25 -07002630 mInputs.activeInputsCountOnDevices(primaryInputDevices) == 0) {
Ytai Ben-Tsvi74cd6b02019-10-25 10:06:40 -07002631 mpClientInterface->setSoundTriggerCaptureState(false);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002632 }
2633 inputDesc->clearPreemptedSessions();
Eric Laurente552edb2014-03-10 17:42:56 -07002634 }
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002635 return NO_ERROR;
Eric Laurente552edb2014-03-10 17:42:56 -07002636}
2637
Eric Laurent8fc147b2018-07-22 19:13:55 -07002638void AudioPolicyManager::releaseInput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07002639{
Eric Laurent8fc147b2018-07-22 19:13:55 -07002640 ALOGV("%s portId %d", __FUNCTION__, portId);
2641
2642 sp<AudioInputDescriptor> inputDesc = mInputs.getInputForClient(portId);
2643 if (inputDesc == 0) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002644 ALOGW("%s no input for client %d", __FUNCTION__, portId);
Eric Laurente552edb2014-03-10 17:42:56 -07002645 return;
2646 }
Andy Hung39efb7a2018-09-26 15:39:28 -07002647 sp<RecordClientDescriptor> client = inputDesc->getClient(portId);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002648 audio_io_handle_t input = inputDesc->mIoHandle;
2649
Eric Laurent8f42ea12018-08-08 09:08:25 -07002650 ALOGV("%s %d", __FUNCTION__, input);
Paul McLean466dc8e2015-04-17 13:15:36 -06002651
Andy Hung39efb7a2018-09-26 15:39:28 -07002652 inputDesc->removeClient(portId);
Eric Laurent599c7582015-12-07 18:05:55 -08002653
Andy Hung39efb7a2018-09-26 15:39:28 -07002654 if (inputDesc->getClientCount() > 0) {
2655 ALOGV("%s(%d) %zu clients remaining", __func__, portId, inputDesc->getClientCount());
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002656 return;
2657 }
2658
Eric Laurent05b90f82014-08-27 15:32:29 -07002659 closeInput(input);
Eric Laurentb52c1522014-05-20 11:27:36 -07002660 mpClientInterface->onAudioPortListUpdate();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002661 ALOGV("%s exit", __FUNCTION__);
Eric Laurente552edb2014-03-10 17:42:56 -07002662}
2663
Eric Laurent8f42ea12018-08-08 09:08:25 -07002664void AudioPolicyManager::closeActiveClients(const sp<AudioInputDescriptor>& input)
Eric Laurent8fc147b2018-07-22 19:13:55 -07002665{
Eric Laurent8f42ea12018-08-08 09:08:25 -07002666 RecordClientVector clients = input->clientsList(true);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002667
2668 for (const auto& client : clients) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002669 closeClient(client->portId());
Eric Laurent8fc147b2018-07-22 19:13:55 -07002670 }
2671}
2672
Eric Laurent8f42ea12018-08-08 09:08:25 -07002673void AudioPolicyManager::closeClient(audio_port_handle_t portId)
2674{
2675 stopInput(portId);
2676 releaseInput(portId);
2677}
Eric Laurent8fc147b2018-07-22 19:13:55 -07002678
Eric Laurent0dd51852019-04-19 18:18:58 -07002679void AudioPolicyManager::checkCloseInputs() {
2680 // After connecting or disconnecting an input device, close input if:
2681 // - it has no client (was just opened to check profile) OR
2682 // - none of its supported devices are connected anymore OR
2683 // - one of its clients cannot be routed to one of its supported
2684 // devices anymore. Otherwise update device selection
2685 std::vector<audio_io_handle_t> inputsToClose;
2686 for (size_t i = 0; i < mInputs.size(); i++) {
2687 const sp<AudioInputDescriptor> input = mInputs.valueAt(i);
2688 if (input->clientsList().size() == 0
Eric Laurent85732f42020-03-19 11:31:10 -07002689 || !mAvailableInputDevices.containsAtLeastOne(input->supportedDevices())) {
Eric Laurent0dd51852019-04-19 18:18:58 -07002690 inputsToClose.push_back(mInputs.keyAt(i));
2691 } else {
2692 bool close = false;
2693 for (const auto& client : input->clientsList()) {
2694 sp<DeviceDescriptor> device =
yuanjiahsu0735bf32021-03-18 08:12:54 +08002695 mEngine->getInputDeviceForAttributes(client->attributes(), client->uid());
Eric Laurent0dd51852019-04-19 18:18:58 -07002696 if (!input->supportedDevices().contains(device)) {
2697 close = true;
2698 break;
2699 }
2700 }
2701 if (close) {
2702 inputsToClose.push_back(mInputs.keyAt(i));
2703 } else {
2704 setInputDevice(input->mIoHandle, getNewInputDevice(input));
2705 }
2706 }
2707 }
2708
2709 for (const audio_io_handle_t handle : inputsToClose) {
2710 ALOGV("%s closing input %d", __func__, handle);
2711 closeInput(handle);
Eric Laurent05b90f82014-08-27 15:32:29 -07002712 }
Eric Laurentd4692962014-05-05 18:13:44 -07002713}
2714
François Gaffie251c7f02018-11-07 10:41:08 +01002715void AudioPolicyManager::initStreamVolume(audio_stream_type_t stream, int indexMin, int indexMax)
Eric Laurente552edb2014-03-10 17:42:56 -07002716{
2717 ALOGV("initStreamVolume() stream %d, min %d, max %d", stream , indexMin, indexMax);
Revathi Uddarajufe0fb8b2017-07-27 17:05:37 +08002718 if (indexMin < 0 || indexMax < 0) {
2719 ALOGE("%s for stream %d: invalid min %d or max %d", __func__, stream , indexMin, indexMax);
2720 return;
2721 }
Eric Laurentf5aa58d2019-02-22 18:20:11 -08002722 getVolumeCurves(stream).initVolume(indexMin, indexMax);
Eric Laurent28d09f02016-03-08 10:43:05 -08002723
2724 // initialize other private stream volumes which follow this one
Eric Laurent794fde22016-03-11 09:50:45 -08002725 for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) {
2726 if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
Eric Laurent28d09f02016-03-08 10:43:05 -08002727 continue;
2728 }
Eric Laurentf5aa58d2019-02-22 18:20:11 -08002729 getVolumeCurves((audio_stream_type_t)curStream).initVolume(indexMin, indexMax);
Eric Laurent223fd5c2014-11-11 13:43:36 -08002730 }
Eric Laurente552edb2014-03-10 17:42:56 -07002731}
2732
Eric Laurente0720872014-03-11 09:30:41 -07002733status_t AudioPolicyManager::setStreamVolumeIndex(audio_stream_type_t stream,
François Gaffie53615e22015-03-19 09:24:12 +01002734 int index,
2735 audio_devices_t device)
Eric Laurente552edb2014-03-10 17:42:56 -07002736{
François Gaffieaaac0fd2018-11-22 17:56:39 +01002737 auto attributes = mEngine->getAttributesForStreamType(stream);
Eric Laurent242a9f82020-03-23 15:57:04 -07002738 if (attributes == AUDIO_ATTRIBUTES_INITIALIZER) {
2739 ALOGW("%s: no group for stream %s, bailing out", __func__, toString(stream).c_str());
2740 return NO_ERROR;
2741 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01002742 ALOGV("%s: stream %s attributes=%s", __func__,
2743 toString(stream).c_str(), toString(attributes).c_str());
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002744 return setVolumeIndexForAttributes(attributes, index, device);
Eric Laurente552edb2014-03-10 17:42:56 -07002745}
2746
Eric Laurente0720872014-03-11 09:30:41 -07002747status_t AudioPolicyManager::getStreamVolumeIndex(audio_stream_type_t stream,
François Gaffieaaac0fd2018-11-22 17:56:39 +01002748 int *index,
2749 audio_devices_t device)
Eric Laurente552edb2014-03-10 17:42:56 -07002750{
François Gaffiec005e562018-11-06 15:04:49 +01002751 // if device is AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME, return volume for device selected for this
2752 // stream by the engine.
jiabin9a3361e2019-10-01 09:38:30 -07002753 DeviceTypeSet deviceTypes = {device};
Eric Laurent5a2b6292016-04-14 18:05:57 -07002754 if (device == AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
jiabin9a3361e2019-10-01 09:38:30 -07002755 deviceTypes = mEngine->getOutputDevicesForStream(
2756 stream, true /*fromCache*/).types();
Eric Laurente552edb2014-03-10 17:42:56 -07002757 }
jiabin9a3361e2019-10-01 09:38:30 -07002758 return getVolumeIndex(getVolumeCurves(stream), *index, deviceTypes);
Eric Laurente552edb2014-03-10 17:42:56 -07002759}
2760
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002761status_t AudioPolicyManager::setVolumeIndexForAttributes(const audio_attributes_t &attributes,
François Gaffiecfe17322018-11-07 13:41:29 +01002762 int index,
2763 audio_devices_t device)
2764{
2765 // Get Volume group matching the Audio Attributes
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002766 auto group = mEngine->getVolumeGroupForAttributes(attributes);
2767 if (group == VOLUME_GROUP_NONE) {
2768 ALOGD("%s: no group matching with %s", __FUNCTION__, toString(attributes).c_str());
François Gaffiecfe17322018-11-07 13:41:29 +01002769 return BAD_VALUE;
2770 }
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002771 ALOGV("%s: group %d matching with %s", __FUNCTION__, group, toString(attributes).c_str());
François Gaffiecfe17322018-11-07 13:41:29 +01002772 status_t status = NO_ERROR;
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002773 IVolumeCurves &curves = getVolumeCurves(attributes);
François Gaffieaaac0fd2018-11-22 17:56:39 +01002774 VolumeSource vs = toVolumeSource(group);
2775 product_strategy_t strategy = mEngine->getProductStrategyForAttributes(attributes);
2776
2777 status = setVolumeCurveIndex(index, device, curves);
2778 if (status != NO_ERROR) {
2779 ALOGE("%s failed to set curve index for group %d device 0x%X", __func__, group, device);
2780 return status;
2781 }
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002782
jiabin9a3361e2019-10-01 09:38:30 -07002783 DeviceTypeSet curSrcDevices;
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002784 auto curCurvAttrs = curves.getAttributes();
2785 if (!curCurvAttrs.empty() && curCurvAttrs.front() != defaultAttr) {
2786 auto attr = curCurvAttrs.front();
jiabin9a3361e2019-10-01 09:38:30 -07002787 curSrcDevices = mEngine->getOutputDevicesForAttributes(attr, nullptr, false).types();
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002788 } else if (!curves.getStreamTypes().empty()) {
2789 auto stream = curves.getStreamTypes().front();
jiabin9a3361e2019-10-01 09:38:30 -07002790 curSrcDevices = mEngine->getOutputDevicesForStream(stream, false).types();
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002791 } else {
2792 ALOGE("%s: Invalid src %d: no valid attributes nor stream",__func__, vs);
2793 return BAD_VALUE;
2794 }
jiabin9a3361e2019-10-01 09:38:30 -07002795 audio_devices_t curSrcDevice = Volume::getDeviceForVolume(curSrcDevices);
2796 resetDeviceTypes(curSrcDevices, curSrcDevice);
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002797
François Gaffiecfe17322018-11-07 13:41:29 +01002798 // update volume on all outputs and streams matching the following:
2799 // - The requested stream (or a stream matching for volume control) is active on the output
2800 // - The device (or devices) selected by the engine for this stream includes
2801 // the requested device
2802 // - For non default requested device, currently selected device on the output is either the
2803 // requested device or one of the devices selected by the engine for this stream
2804 // - For default requested device (AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME), apply volume only if
2805 // no specific device volume value exists for currently selected device.
François Gaffieaaac0fd2018-11-22 17:56:39 +01002806 for (size_t i = 0; i < mOutputs.size(); i++) {
2807 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
jiabin9a3361e2019-10-01 09:38:30 -07002808 DeviceTypeSet curDevices = desc->devices().types();
François Gaffieaaac0fd2018-11-22 17:56:39 +01002809
jiabin9a3361e2019-10-01 09:38:30 -07002810 if (curDevices.erase(AUDIO_DEVICE_OUT_SPEAKER_SAFE)) {
2811 curDevices.insert(AUDIO_DEVICE_OUT_SPEAKER);
Robert Lee5e66e792019-04-03 18:37:15 +08002812 }
François Gaffieed91f582020-01-31 10:35:37 +01002813 if (!(desc->isActive(vs) || isInCall())) {
2814 continue;
2815 }
2816 if (device != AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME &&
2817 curDevices.find(device) == curDevices.end()) {
2818 continue;
2819 }
2820 bool applyVolume = false;
2821 if (device != AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
2822 curSrcDevices.insert(device);
2823 applyVolume = (curSrcDevices.find(
2824 Volume::getDeviceForVolume(curDevices)) != curSrcDevices.end());
2825 } else {
2826 applyVolume = !curves.hasVolumeIndexForDevice(curSrcDevice);
2827 }
2828 if (!applyVolume) {
2829 continue; // next output
2830 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01002831 // Inter / intra volume group priority management: Loop on strategies arranged by priority
2832 // If a higher priority strategy is active, and the output is routed to a device with a
2833 // HW Gain management, do not change the volume
François Gaffieaaac0fd2018-11-22 17:56:39 +01002834 if (desc->useHwGain()) {
François Gaffieed91f582020-01-31 10:35:37 +01002835 applyVolume = false;
François Gaffieaaac0fd2018-11-22 17:56:39 +01002836 for (const auto &productStrategy : mEngine->getOrderedProductStrategies()) {
2837 auto activeClients = desc->clientsList(true /*activeOnly*/, productStrategy,
2838 false /*preferredDevice*/);
2839 if (activeClients.empty()) {
2840 continue;
2841 }
2842 bool isPreempted = false;
2843 bool isHigherPriority = productStrategy < strategy;
2844 for (const auto &client : activeClients) {
2845 if (isHigherPriority && (client->volumeSource() != vs)) {
2846 ALOGV("%s: Strategy=%d (\nrequester:\n"
2847 " group %d, volumeGroup=%d attributes=%s)\n"
2848 " higher priority source active:\n"
2849 " volumeGroup=%d attributes=%s) \n"
2850 " on output %zu, bailing out", __func__, productStrategy,
2851 group, group, toString(attributes).c_str(),
2852 client->volumeSource(), toString(client->attributes()).c_str(), i);
2853 applyVolume = false;
2854 isPreempted = true;
2855 break;
2856 }
2857 // However, continue for loop to ensure no higher prio clients running on output
2858 if (client->volumeSource() == vs) {
2859 applyVolume = true;
2860 }
2861 }
2862 if (isPreempted || applyVolume) {
2863 break;
2864 }
2865 }
2866 if (!applyVolume) {
2867 continue; // next output
2868 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01002869 }
François Gaffieed91f582020-01-31 10:35:37 +01002870 //FIXME: workaround for truncated touch sounds
2871 // delayed volume change for system stream to be removed when the problem is
2872 // handled by system UI
2873 status_t volStatus = checkAndSetVolume(
2874 curves, vs, index, desc, curDevices,
2875 ((vs == toVolumeSource(AUDIO_STREAM_SYSTEM))?
2876 TOUCH_SOUND_FIXED_DELAY_MS : 0));
2877 if (volStatus != NO_ERROR) {
2878 status = volStatus;
François Gaffieaaac0fd2018-11-22 17:56:39 +01002879 }
2880 }
François Gaffiecfe17322018-11-07 13:41:29 +01002881 mpClientInterface->onAudioVolumeGroupChanged(group, 0 /*flags*/);
2882 return status;
2883}
2884
François Gaffieaaac0fd2018-11-22 17:56:39 +01002885status_t AudioPolicyManager::setVolumeCurveIndex(int index,
François Gaffiecfe17322018-11-07 13:41:29 +01002886 audio_devices_t device,
2887 IVolumeCurves &volumeCurves)
2888{
2889 // VOICE_CALL stream has minVolumeIndex > 0 but can be muted directly by an
2890 // app that has MODIFY_PHONE_STATE permission.
François Gaffieaaac0fd2018-11-22 17:56:39 +01002891 bool hasVoice = hasVoiceStream(volumeCurves.getStreamTypes());
2892 if (((index < volumeCurves.getVolumeIndexMin()) && !(hasVoice && index == 0)) ||
François Gaffiecfe17322018-11-07 13:41:29 +01002893 (index > volumeCurves.getVolumeIndexMax())) {
2894 ALOGD("%s: wrong index %d min=%d max=%d", __FUNCTION__, index,
2895 volumeCurves.getVolumeIndexMin(), volumeCurves.getVolumeIndexMax());
2896 return BAD_VALUE;
2897 }
2898 if (!audio_is_output_device(device)) {
2899 return BAD_VALUE;
2900 }
2901
2902 // Force max volume if stream cannot be muted
2903 if (!volumeCurves.canBeMuted()) index = volumeCurves.getVolumeIndexMax();
2904
François Gaffieaaac0fd2018-11-22 17:56:39 +01002905 ALOGV("%s device %08x, index %d", __FUNCTION__ , device, index);
François Gaffiecfe17322018-11-07 13:41:29 +01002906 volumeCurves.addCurrentVolumeIndex(device, index);
2907 return NO_ERROR;
2908}
2909
2910status_t AudioPolicyManager::getVolumeIndexForAttributes(const audio_attributes_t &attr,
2911 int &index,
2912 audio_devices_t device)
2913{
2914 // if device is AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME, return volume for device selected for this
2915 // stream by the engine.
jiabin9a3361e2019-10-01 09:38:30 -07002916 DeviceTypeSet deviceTypes = {device};
François Gaffiecfe17322018-11-07 13:41:29 +01002917 if (device == AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
jiabin9a3361e2019-10-01 09:38:30 -07002918 DeviceTypeSet deviceTypes = mEngine->getOutputDevicesForAttributes(
2919 attr, nullptr, true /*fromCache*/).types();
François Gaffiecfe17322018-11-07 13:41:29 +01002920 }
jiabin9a3361e2019-10-01 09:38:30 -07002921 return getVolumeIndex(getVolumeCurves(attr), index, deviceTypes);
François Gaffiecfe17322018-11-07 13:41:29 +01002922}
2923
2924status_t AudioPolicyManager::getVolumeIndex(const IVolumeCurves &curves,
2925 int &index,
jiabin9a3361e2019-10-01 09:38:30 -07002926 const DeviceTypeSet& deviceTypes) const
François Gaffiecfe17322018-11-07 13:41:29 +01002927{
jiabin9a3361e2019-10-01 09:38:30 -07002928 if (isSingleDeviceType(deviceTypes, audio_is_output_device)) {
François Gaffiecfe17322018-11-07 13:41:29 +01002929 return BAD_VALUE;
2930 }
jiabin9a3361e2019-10-01 09:38:30 -07002931 index = curves.getVolumeIndex(deviceTypes);
2932 ALOGV("%s: device %s index %d", __FUNCTION__, dumpDeviceTypes(deviceTypes).c_str(), index);
François Gaffiecfe17322018-11-07 13:41:29 +01002933 return NO_ERROR;
2934}
2935
2936status_t AudioPolicyManager::getMinVolumeIndexForAttributes(const audio_attributes_t &attr,
2937 int &index)
2938{
2939 index = getVolumeCurves(attr).getVolumeIndexMin();
2940 return NO_ERROR;
2941}
2942
2943status_t AudioPolicyManager::getMaxVolumeIndexForAttributes(const audio_attributes_t &attr,
2944 int &index)
2945{
2946 index = getVolumeCurves(attr).getVolumeIndexMax();
2947 return NO_ERROR;
2948}
2949
Eric Laurent36829f92017-04-07 19:04:42 -07002950audio_io_handle_t AudioPolicyManager::selectOutputForMusicEffects()
Eric Laurente552edb2014-03-10 17:42:56 -07002951{
2952 // select one output among several suitable for global effects.
2953 // The priority is as follows:
2954 // 1: An offloaded output. If the effect ends up not being offloadable,
2955 // AudioFlinger will invalidate the track and the offloaded output
2956 // will be closed causing the effect to be moved to a PCM output.
2957 // 2: A deep buffer output
Eric Laurent36829f92017-04-07 19:04:42 -07002958 // 3: The primary output
2959 // 4: the first output in the list
Eric Laurente552edb2014-03-10 17:42:56 -07002960
François Gaffiec005e562018-11-06 15:04:49 +01002961 DeviceVector devices = mEngine->getOutputDevicesForAttributes(
2962 attributes_initializer(AUDIO_USAGE_MEDIA), nullptr, false /*fromCache*/);
François Gaffie11d30102018-11-02 16:09:09 +01002963 SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
Eric Laurente552edb2014-03-10 17:42:56 -07002964
Eric Laurent36829f92017-04-07 19:04:42 -07002965 if (outputs.size() == 0) {
2966 return AUDIO_IO_HANDLE_NONE;
2967 }
Eric Laurente552edb2014-03-10 17:42:56 -07002968
Eric Laurent36829f92017-04-07 19:04:42 -07002969 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
2970 bool activeOnly = true;
2971
2972 while (output == AUDIO_IO_HANDLE_NONE) {
2973 audio_io_handle_t outputOffloaded = AUDIO_IO_HANDLE_NONE;
2974 audio_io_handle_t outputDeepBuffer = AUDIO_IO_HANDLE_NONE;
2975 audio_io_handle_t outputPrimary = AUDIO_IO_HANDLE_NONE;
2976
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002977 for (audio_io_handle_t output : outputs) {
2978 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
Eric Laurent83d17c22019-04-02 17:10:01 -07002979 if (activeOnly && !desc->isActive(toVolumeSource(AUDIO_STREAM_MUSIC))) {
Eric Laurent36829f92017-04-07 19:04:42 -07002980 continue;
2981 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002982 ALOGV("selectOutputForMusicEffects activeOnly %d output %d flags 0x%08x",
2983 activeOnly, output, desc->mFlags);
Eric Laurent36829f92017-04-07 19:04:42 -07002984 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002985 outputOffloaded = output;
Eric Laurent36829f92017-04-07 19:04:42 -07002986 }
2987 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) != 0) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002988 outputDeepBuffer = output;
Eric Laurent36829f92017-04-07 19:04:42 -07002989 }
2990 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY) != 0) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08002991 outputPrimary = output;
Eric Laurent36829f92017-04-07 19:04:42 -07002992 }
2993 }
2994 if (outputOffloaded != AUDIO_IO_HANDLE_NONE) {
2995 output = outputOffloaded;
2996 } else if (outputDeepBuffer != AUDIO_IO_HANDLE_NONE) {
2997 output = outputDeepBuffer;
2998 } else if (outputPrimary != AUDIO_IO_HANDLE_NONE) {
2999 output = outputPrimary;
3000 } else {
3001 output = outputs[0];
3002 }
3003 activeOnly = false;
3004 }
3005
3006 if (output != mMusicEffectOutput) {
Eric Laurent6c796322019-04-09 14:13:17 -07003007 mEffects.moveEffects(AUDIO_SESSION_OUTPUT_MIX, mMusicEffectOutput, output);
Eric Laurent36829f92017-04-07 19:04:42 -07003008 mpClientInterface->moveEffects(AUDIO_SESSION_OUTPUT_MIX, mMusicEffectOutput, output);
3009 mMusicEffectOutput = output;
3010 }
3011
3012 ALOGV("selectOutputForMusicEffects selected output %d", output);
Eric Laurente552edb2014-03-10 17:42:56 -07003013 return output;
3014}
3015
Eric Laurent36829f92017-04-07 19:04:42 -07003016audio_io_handle_t AudioPolicyManager::getOutputForEffect(const effect_descriptor_t *desc __unused)
3017{
3018 return selectOutputForMusicEffects();
3019}
3020
Eric Laurente0720872014-03-11 09:30:41 -07003021status_t AudioPolicyManager::registerEffect(const effect_descriptor_t *desc,
Eric Laurente552edb2014-03-10 17:42:56 -07003022 audio_io_handle_t io,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08003023 product_strategy_t strategy,
Eric Laurente552edb2014-03-10 17:42:56 -07003024 int session,
3025 int id)
3026{
Eric Laurentb82e6b72019-11-22 17:25:04 -08003027 if (session != AUDIO_SESSION_DEVICE) {
3028 ssize_t index = mOutputs.indexOfKey(io);
Eric Laurente552edb2014-03-10 17:42:56 -07003029 if (index < 0) {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003030 index = mInputs.indexOfKey(io);
3031 if (index < 0) {
3032 ALOGW("registerEffect() unknown io %d", io);
3033 return INVALID_OPERATION;
3034 }
Eric Laurente552edb2014-03-10 17:42:56 -07003035 }
3036 }
François Gaffiec005e562018-11-06 15:04:49 +01003037 return mEffects.registerEffect(desc, io, session, id,
3038 (strategy == streamToStrategy(AUDIO_STREAM_MUSIC) ||
3039 strategy == PRODUCT_STRATEGY_NONE));
Eric Laurente552edb2014-03-10 17:42:56 -07003040}
3041
Eric Laurentc241b0d2018-11-28 09:08:49 -08003042status_t AudioPolicyManager::unregisterEffect(int id)
3043{
3044 if (mEffects.getEffect(id) == nullptr) {
3045 return INVALID_OPERATION;
3046 }
Eric Laurentc241b0d2018-11-28 09:08:49 -08003047 if (mEffects.isEffectEnabled(id)) {
3048 ALOGW("%s effect %d enabled", __FUNCTION__, id);
3049 setEffectEnabled(id, false);
3050 }
3051 return mEffects.unregisterEffect(id);
3052}
3053
3054status_t AudioPolicyManager::setEffectEnabled(int id, bool enabled)
3055{
3056 sp<EffectDescriptor> effect = mEffects.getEffect(id);
3057 if (effect == nullptr) {
3058 return INVALID_OPERATION;
3059 }
3060
3061 status_t status = mEffects.setEffectEnabled(id, enabled);
3062 if (status == NO_ERROR) {
3063 mInputs.trackEffectEnabled(effect, enabled);
3064 }
3065 return status;
3066}
3067
Eric Laurent6c796322019-04-09 14:13:17 -07003068
3069status_t AudioPolicyManager::moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io)
3070{
3071 mEffects.moveEffects(ids, io);
3072 return NO_ERROR;
3073}
3074
Eric Laurentc75307b2015-03-17 15:29:32 -07003075bool AudioPolicyManager::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
3076{
François Gaffieaaac0fd2018-11-22 17:56:39 +01003077 return mOutputs.isActive(toVolumeSource(stream), inPastMs);
Eric Laurentc75307b2015-03-17 15:29:32 -07003078}
3079
3080bool AudioPolicyManager::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
3081{
François Gaffieaaac0fd2018-11-22 17:56:39 +01003082 return mOutputs.isActiveRemotely(toVolumeSource(stream), inPastMs);
Eric Laurentc75307b2015-03-17 15:29:32 -07003083}
3084
Eric Laurente0720872014-03-11 09:30:41 -07003085bool AudioPolicyManager::isSourceActive(audio_source_t source) const
Eric Laurente552edb2014-03-10 17:42:56 -07003086{
3087 for (size_t i = 0; i < mInputs.size(); i++) {
Eric Laurent1f2f2232014-06-02 12:01:23 -07003088 const sp<AudioInputDescriptor> inputDescriptor = mInputs.valueAt(i);
Eric Laurent599c7582015-12-07 18:05:55 -08003089 if (inputDescriptor->isSourceActive(source)) {
Eric Laurente552edb2014-03-10 17:42:56 -07003090 return true;
3091 }
3092 }
3093 return false;
3094}
3095
Eric Laurent275e8e92014-11-30 15:14:47 -08003096// Register a list of custom mixes with their attributes and format.
3097// When a mix is registered, corresponding input and output profiles are
3098// added to the remote submix hw module. The profile contains only the
3099// parameters (sampling rate, format...) specified by the mix.
3100// The corresponding input remote submix device is also connected.
3101//
3102// When a remote submix device is connected, the address is checked to select the
3103// appropriate profile and the corresponding input or output stream is opened.
3104//
3105// When capture starts, getInputForAttr() will:
3106// - 1 look for a mix matching the address passed in attribtutes tags if any
3107// - 2 if none found, getDeviceForInputSource() will:
3108// - 2.1 look for a mix matching the attributes source
3109// - 2.2 if none found, default to device selection by policy rules
3110// At this time, the corresponding output remote submix device is also connected
3111// and active playback use cases can be transferred to this mix if needed when reconnecting
3112// after AudioTracks are invalidated
3113//
3114// When playback starts, getOutputForAttr() will:
3115// - 1 look for a mix matching the address passed in attribtutes tags if any
3116// - 2 if none found, look for a mix matching the attributes usage
3117// - 3 if none found, default to device and output selection by policy rules.
3118
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003119status_t AudioPolicyManager::registerPolicyMixes(const Vector<AudioMix>& mixes)
Eric Laurent275e8e92014-11-30 15:14:47 -08003120{
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003121 ALOGV("registerPolicyMixes() %zu mix(es)", mixes.size());
3122 status_t res = NO_ERROR;
Eric Laurentc209fe42020-06-05 18:11:23 -07003123 bool checkOutputs = false;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003124 sp<HwModule> rSubmixModule;
3125 // examine each mix's route type
3126 for (size_t i = 0; i < mixes.size(); i++) {
Eric Laurent97ac8712018-07-27 18:59:02 -07003127 AudioMix mix = mixes[i];
Kevin Rocard153f92d2018-12-18 18:33:28 -08003128 // Only capture of playback is allowed in LOOP_BACK & RENDER mode
3129 if (is_mix_loopback_render(mix.mRouteFlags) && mix.mMixType != MIX_TYPE_PLAYERS) {
3130 ALOGE("Unsupported Policy Mix %zu of %zu: "
3131 "Only capture of playback is allowed in LOOP_BACK & RENDER mode",
3132 i, mixes.size());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003133 res = INVALID_OPERATION;
Eric Laurent275e8e92014-11-30 15:14:47 -08003134 break;
3135 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08003136 // LOOP_BACK and LOOP_BACK | RENDER have the same remote submix backend and are handled
3137 // in the same way.
Eric Laurent97ac8712018-07-27 18:59:02 -07003138 if ((mix.mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08003139 ALOGV("registerPolicyMixes() mix %zu of %zu is LOOP_BACK %d", i, mixes.size(),
3140 mix.mRouteFlags);
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003141 if (rSubmixModule == 0) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08003142 rSubmixModule = mHwModules.getModuleFromName(
3143 AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX);
3144 if (rSubmixModule == 0) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08003145 ALOGE("Unable to find audio module for submix, aborting mix %zu registration",
Mikhail Naganovd4120142017-12-06 15:49:22 -08003146 i);
3147 res = INVALID_OPERATION;
3148 break;
3149 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003150 }
Eric Laurent275e8e92014-11-30 15:14:47 -08003151
Eric Laurent97ac8712018-07-27 18:59:02 -07003152 String8 address = mix.mDeviceAddress;
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003153 audio_devices_t deviceTypeToMakeAvailable;
Eric Laurent97ac8712018-07-27 18:59:02 -07003154 if (mix.mMixType == MIX_TYPE_PLAYERS) {
Eric Laurent97ac8712018-07-27 18:59:02 -07003155 mix.mDeviceType = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003156 deviceTypeToMakeAvailable = AUDIO_DEVICE_IN_REMOTE_SUBMIX;
3157 } else {
3158 mix.mDeviceType = AUDIO_DEVICE_IN_REMOTE_SUBMIX;
3159 deviceTypeToMakeAvailable = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
Eric Laurent97ac8712018-07-27 18:59:02 -07003160 }
François Gaffie036e1e92015-03-19 10:16:24 +01003161
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003162 if (mPolicyMixes.registerMix(mix, 0 /*output desc*/) != NO_ERROR) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08003163 ALOGE("Error registering mix %zu for address %s", i, address.string());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003164 res = INVALID_OPERATION;
3165 break;
3166 }
Eric Laurent97ac8712018-07-27 18:59:02 -07003167 audio_config_t outputConfig = mix.mFormat;
3168 audio_config_t inputConfig = mix.mFormat;
Eric Laurentc529cf62020-04-17 18:19:10 -07003169 // NOTE: audio flinger mixer does not support mono output: configure remote submix HAL
3170 // in stereo and let audio flinger do the channel conversion if needed.
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003171 outputConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
3172 inputConfig.channel_mask = AUDIO_CHANNEL_IN_STEREO;
jiabin5740f082019-08-19 15:08:30 -07003173 rSubmixModule->addOutputProfile(address.c_str(), &outputConfig,
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003174 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, address);
jiabin5740f082019-08-19 15:08:30 -07003175 rSubmixModule->addInputProfile(address.c_str(), &inputConfig,
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003176 AUDIO_DEVICE_IN_REMOTE_SUBMIX, address);
François Gaffie036e1e92015-03-19 10:16:24 +01003177
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003178 if ((res = setDeviceConnectionStateInt(deviceTypeToMakeAvailable,
jiabinc1de2df2019-05-07 14:26:40 -07003179 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
3180 address.string(), "remote-submix", AUDIO_FORMAT_DEFAULT)) != NO_ERROR) {
3181 ALOGE("Failed to set remote submix device available, type %u, address %s",
3182 mix.mDeviceType, address.string());
3183 break;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003184 }
Eric Laurent97ac8712018-07-27 18:59:02 -07003185 } else if ((mix.mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) {
3186 String8 address = mix.mDeviceAddress;
Eric Laurent2c80be02019-01-23 18:06:37 -08003187 audio_devices_t type = mix.mDeviceType;
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07003188 ALOGV(" registerPolicyMixes() mix %zu of %zu is RENDER, dev=0x%X addr=%s",
Eric Laurent2c80be02019-01-23 18:06:37 -08003189 i, mixes.size(), type, address.string());
3190
3191 sp<DeviceDescriptor> device = mHwModules.getDeviceDescriptor(
3192 mix.mDeviceType, mix.mDeviceAddress,
3193 String8(), AUDIO_FORMAT_DEFAULT);
3194 if (device == nullptr) {
3195 res = INVALID_OPERATION;
3196 break;
3197 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003198
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07003199 bool foundOutput = false;
Eric Laurentc529cf62020-04-17 18:19:10 -07003200 // First try to find an already opened output supporting the device
3201 for (size_t j = 0 ; j < mOutputs.size() && !foundOutput && res == NO_ERROR; j++) {
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003202 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(j);
Eric Laurent2c80be02019-01-23 18:06:37 -08003203
Eric Laurentc529cf62020-04-17 18:19:10 -07003204 if (!desc->isDuplicated() && desc->supportedDevices().contains(device)) {
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003205 if (mPolicyMixes.registerMix(mix, desc) != NO_ERROR) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08003206 ALOGE("Could not register mix RENDER, dev=0x%X addr=%s", type,
3207 address.string());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003208 res = INVALID_OPERATION;
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07003209 } else {
3210 foundOutput = true;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003211 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003212 }
3213 }
Eric Laurentc529cf62020-04-17 18:19:10 -07003214 // If no output found, try to find a direct output profile supporting the device
3215 for (size_t i = 0; i < mHwModules.size() && !foundOutput && res == NO_ERROR; i++) {
3216 sp<HwModule> module = mHwModules[i];
3217 for (size_t j = 0;
3218 j < module->getOutputProfiles().size() && !foundOutput && res == NO_ERROR;
3219 j++) {
3220 sp<IOProfile> profile = module->getOutputProfiles()[j];
3221 if (profile->isDirectOutput() && profile->supportsDevice(device)) {
3222 if (mPolicyMixes.registerMix(mix, nullptr) != NO_ERROR) {
3223 ALOGE("Could not register mix RENDER, dev=0x%X addr=%s", type,
3224 address.string());
3225 res = INVALID_OPERATION;
3226 } else {
3227 foundOutput = true;
3228 }
3229 }
3230 }
3231 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003232 if (res != NO_ERROR) {
3233 ALOGE(" Error registering mix %zu for device 0x%X addr %s",
Eric Laurent2c80be02019-01-23 18:06:37 -08003234 i, type, address.string());
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07003235 res = INVALID_OPERATION;
3236 break;
3237 } else if (!foundOutput) {
3238 ALOGE(" Output not found for mix %zu for device 0x%X addr %s",
Eric Laurent2c80be02019-01-23 18:06:37 -08003239 i, type, address.string());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003240 res = INVALID_OPERATION;
3241 break;
Eric Laurentc209fe42020-06-05 18:11:23 -07003242 } else {
3243 checkOutputs = true;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003244 }
Eric Laurentc722f302014-12-10 11:21:49 -08003245 }
Eric Laurent275e8e92014-11-30 15:14:47 -08003246 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003247 if (res != NO_ERROR) {
3248 unregisterPolicyMixes(mixes);
Eric Laurentc209fe42020-06-05 18:11:23 -07003249 } else if (checkOutputs) {
3250 checkForDeviceAndOutputChanges();
3251 updateCallAndOutputRouting();
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003252 }
3253 return res;
Eric Laurent275e8e92014-11-30 15:14:47 -08003254}
3255
3256status_t AudioPolicyManager::unregisterPolicyMixes(Vector<AudioMix> mixes)
3257{
Eric Laurent7b279bb2015-12-14 10:18:23 -08003258 ALOGV("unregisterPolicyMixes() num mixes %zu", mixes.size());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003259 status_t res = NO_ERROR;
Eric Laurentc209fe42020-06-05 18:11:23 -07003260 bool checkOutputs = false;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003261 sp<HwModule> rSubmixModule;
3262 // examine each mix's route type
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003263 for (const auto& mix : mixes) {
3264 if ((mix.mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) {
François Gaffie036e1e92015-03-19 10:16:24 +01003265
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003266 if (rSubmixModule == 0) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08003267 rSubmixModule = mHwModules.getModuleFromName(
3268 AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX);
3269 if (rSubmixModule == 0) {
3270 res = INVALID_OPERATION;
3271 continue;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003272 }
3273 }
Eric Laurent275e8e92014-11-30 15:14:47 -08003274
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003275 String8 address = mix.mDeviceAddress;
Eric Laurent275e8e92014-11-30 15:14:47 -08003276
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003277 if (mPolicyMixes.unregisterMix(mix) != NO_ERROR) {
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003278 res = INVALID_OPERATION;
3279 continue;
3280 }
3281
Kevin Rocard04ed0462019-05-02 17:53:24 -07003282 for (auto device : {AUDIO_DEVICE_IN_REMOTE_SUBMIX, AUDIO_DEVICE_OUT_REMOTE_SUBMIX}) {
3283 if (getDeviceConnectionState(device, address.string()) ==
3284 AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
3285 res = setDeviceConnectionStateInt(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
3286 address.string(), "remote-submix",
3287 AUDIO_FORMAT_DEFAULT);
3288 if (res != OK) {
3289 ALOGE("Error making RemoteSubmix device unavailable for mix "
3290 "with type %d, address %s", device, address.string());
3291 }
3292 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003293 }
jiabin5740f082019-08-19 15:08:30 -07003294 rSubmixModule->removeOutputProfile(address.c_str());
3295 rSubmixModule->removeInputProfile(address.c_str());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003296
Kevin Rocard153f92d2018-12-18 18:33:28 -08003297 } else if ((mix.mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) {
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003298 if (mPolicyMixes.unregisterMix(mix) != NO_ERROR) {
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003299 res = INVALID_OPERATION;
3300 continue;
Eric Laurentc209fe42020-06-05 18:11:23 -07003301 } else {
3302 checkOutputs = true;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003303 }
Eric Laurent275e8e92014-11-30 15:14:47 -08003304 }
Eric Laurent275e8e92014-11-30 15:14:47 -08003305 }
Eric Laurentc209fe42020-06-05 18:11:23 -07003306 if (res == NO_ERROR && checkOutputs) {
3307 checkForDeviceAndOutputChanges();
3308 updateCallAndOutputRouting();
3309 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003310 return res;
Eric Laurent275e8e92014-11-30 15:14:47 -08003311}
3312
Mikhail Naganov100f0122018-11-29 11:22:16 -08003313void AudioPolicyManager::dumpManualSurroundFormats(String8 *dst) const
3314{
3315 size_t i = 0;
3316 constexpr size_t audioFormatPrefixLen = sizeof("AUDIO_FORMAT_");
3317 for (const auto& fmt : mManualSurroundFormats) {
3318 if (i++ != 0) dst->append(", ");
3319 std::string sfmt;
3320 FormatConverter::toString(fmt, sfmt);
3321 dst->append(sfmt.size() >= audioFormatPrefixLen ?
3322 sfmt.c_str() + audioFormatPrefixLen - 1 : sfmt.c_str());
3323 }
3324}
3325
Eric Laurentc529cf62020-04-17 18:19:10 -07003326// Returns true if all devices types match the predicate and are supported by one HW module
3327bool AudioPolicyManager::areAllDevicesSupported(
jiabin6a02d532020-08-07 11:56:38 -07003328 const AudioDeviceTypeAddrVector& devices,
Eric Laurentc529cf62020-04-17 18:19:10 -07003329 std::function<bool(audio_devices_t)> predicate,
3330 const char *context) {
3331 for (size_t i = 0; i < devices.size(); i++) {
3332 sp<DeviceDescriptor> devDesc = mHwModules.getDeviceDescriptor(
jiabin0a488932020-08-07 17:32:40 -07003333 devices[i].mType, devices[i].getAddress(), String8(),
Eric Laurent0e26e3f2020-04-29 14:24:16 -07003334 AUDIO_FORMAT_DEFAULT, false /*allowToCreate*/, true /*matchAddress*/);
Eric Laurentc529cf62020-04-17 18:19:10 -07003335 if (devDesc == nullptr || (predicate != nullptr && !predicate(devices[i].mType))) {
Jiabin Huang3b98d322020-09-03 17:54:16 +00003336 ALOGE("%s: device type %#x address %s not supported or not match predicate",
jiabin0a488932020-08-07 17:32:40 -07003337 context, devices[i].mType, devices[i].getAddress());
Eric Laurentc529cf62020-04-17 18:19:10 -07003338 return false;
3339 }
3340 }
3341 return true;
3342}
3343
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003344status_t AudioPolicyManager::setUidDeviceAffinities(uid_t uid,
jiabin6a02d532020-08-07 11:56:38 -07003345 const AudioDeviceTypeAddrVector& devices) {
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003346 ALOGV("%s() uid=%d num devices %zu", __FUNCTION__, uid, devices.size());
Eric Laurentc529cf62020-04-17 18:19:10 -07003347 if (!areAllDevicesSupported(devices, audio_is_output_device, __func__)) {
3348 return BAD_VALUE;
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003349 }
3350 status_t res = mPolicyMixes.setUidDeviceAffinities(uid, devices);
Eric Laurentc529cf62020-04-17 18:19:10 -07003351 if (res != NO_ERROR) {
3352 ALOGE("%s() Could not set all device affinities for uid = %d", __FUNCTION__, uid);
3353 return res;
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003354 }
Eric Laurentc529cf62020-04-17 18:19:10 -07003355
3356 checkForDeviceAndOutputChanges();
3357 updateCallAndOutputRouting();
3358
3359 return NO_ERROR;
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003360}
3361
3362status_t AudioPolicyManager::removeUidDeviceAffinities(uid_t uid) {
3363 ALOGV("%s() uid=%d", __FUNCTION__, uid);
Oscar Azucena4b2a8212019-04-26 23:48:59 -07003364 status_t res = mPolicyMixes.removeUidDeviceAffinities(uid);
3365 if (res != NO_ERROR) {
Eric Laurentc529cf62020-04-17 18:19:10 -07003366 ALOGE("%s() Could not remove all device affinities for uid = %d",
Oscar Azucena4b2a8212019-04-26 23:48:59 -07003367 __FUNCTION__, uid);
3368 return INVALID_OPERATION;
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003369 }
3370
Eric Laurentc529cf62020-04-17 18:19:10 -07003371 checkForDeviceAndOutputChanges();
3372 updateCallAndOutputRouting();
3373
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003374 return res;
3375}
3376
Eric Laurent2517af32020-11-25 15:31:27 +01003377
jiabin0a488932020-08-07 17:32:40 -07003378status_t AudioPolicyManager::setDevicesRoleForStrategy(product_strategy_t strategy,
3379 device_role_t role,
3380 const AudioDeviceTypeAddrVector &devices) {
3381 ALOGV("%s() strategy=%d role=%d %s", __func__, strategy, role,
3382 dumpAudioDeviceTypeAddrVector(devices).c_str());
Eric Laurentc529cf62020-04-17 18:19:10 -07003383
Eric Laurentc529cf62020-04-17 18:19:10 -07003384 if (!areAllDevicesSupported(devices, audio_is_output_device, __func__)) {
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003385 return BAD_VALUE;
3386 }
jiabin0a488932020-08-07 17:32:40 -07003387 status_t status = mEngine->setDevicesRoleForStrategy(strategy, role, devices);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003388 if (status != NO_ERROR) {
jiabin0a488932020-08-07 17:32:40 -07003389 ALOGW("Engine could not set preferred devices %s for strategy %d role %d",
3390 dumpAudioDeviceTypeAddrVector(devices).c_str(), strategy, role);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003391 return status;
3392 }
3393
3394 checkForDeviceAndOutputChanges();
Eric Laurent2517af32020-11-25 15:31:27 +01003395
3396 bool forceVolumeReeval = false;
3397 // FIXME: workaround for truncated touch sounds
3398 // to be removed when the problem is handled by system UI
3399 uint32_t delayMs = 0;
3400 if (strategy == mCommunnicationStrategy) {
3401 forceVolumeReeval = true;
3402 delayMs = TOUCH_SOUND_FIXED_DELAY_MS;
3403 updateInputRouting();
3404 }
3405 updateCallAndOutputRouting(forceVolumeReeval, delayMs);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003406
3407 return NO_ERROR;
3408}
3409
3410void AudioPolicyManager::updateCallAndOutputRouting(bool forceVolumeReeval, uint32_t delayMs)
3411{
3412 uint32_t waitMs = 0;
Francois Gaffie19fd6c52021-02-04 17:02:59 +01003413 if (updateCallRouting(true /*fromCache*/, delayMs, &waitMs) == NO_ERROR) {
Eric Laurentb36b4ac2020-08-21 12:50:41 -07003414 // Only apply special touch sound delay once
3415 delayMs = 0;
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003416 }
3417 for (size_t i = 0; i < mOutputs.size(); i++) {
3418 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
3419 DeviceVector newDevices = getNewOutputDevices(outputDesc, true /*fromCache*/);
3420 if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) || (outputDesc != mPrimaryOutput)) {
3421 // As done in setDeviceConnectionState, we could also fix default device issue by
3422 // preventing the force re-routing in case of default dev that distinguishes on address.
3423 // Let's give back to engine full device choice decision however.
3424 waitMs = setOutputDevices(outputDesc, newDevices, !newDevices.isEmpty(), delayMs);
Eric Laurentb36b4ac2020-08-21 12:50:41 -07003425 // Only apply special touch sound delay once
3426 delayMs = 0;
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003427 }
3428 if (forceVolumeReeval && !newDevices.isEmpty()) {
3429 applyStreamVolumes(outputDesc, newDevices.types(), waitMs, true);
3430 }
3431 }
3432}
3433
Eric Laurent2517af32020-11-25 15:31:27 +01003434void AudioPolicyManager::updateInputRouting() {
3435 for (const auto& activeDesc : mInputs.getActiveInputs()) {
Jaideep Sharma408349a2020-11-27 14:47:17 +05303436 // Skip for hotword recording as the input device switch
3437 // is handled within sound trigger HAL
3438 if (activeDesc->isSoundTrigger() && activeDesc->source() == AUDIO_SOURCE_HOTWORD) {
3439 continue;
3440 }
Eric Laurent2517af32020-11-25 15:31:27 +01003441 auto newDevice = getNewInputDevice(activeDesc);
3442 // Force new input selection if the new device can not be reached via current input
3443 if (activeDesc->mProfile->getSupportedDevices().contains(newDevice)) {
3444 setInputDevice(activeDesc->mIoHandle, newDevice);
3445 } else {
3446 closeInput(activeDesc->mIoHandle);
3447 }
3448 }
3449}
3450
jiabin0a488932020-08-07 17:32:40 -07003451status_t AudioPolicyManager::removeDevicesRoleForStrategy(product_strategy_t strategy,
3452 device_role_t role)
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003453{
Eric Laurentfecbceb2021-02-09 14:46:43 +01003454 ALOGV("%s() strategy=%d role=%d", __func__, strategy, role);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003455
jiabin0a488932020-08-07 17:32:40 -07003456 status_t status = mEngine->removeDevicesRoleForStrategy(strategy, role);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003457 if (status != NO_ERROR) {
Eric Laurent2517af32020-11-25 15:31:27 +01003458 ALOGV("Engine could not remove preferred device for strategy %d status %d",
3459 strategy, status);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003460 return status;
3461 }
3462
3463 checkForDeviceAndOutputChanges();
Eric Laurent2517af32020-11-25 15:31:27 +01003464
3465 bool forceVolumeReeval = false;
3466 // FIXME: workaround for truncated touch sounds
3467 // to be removed when the problem is handled by system UI
3468 uint32_t delayMs = 0;
3469 if (strategy == mCommunnicationStrategy) {
3470 forceVolumeReeval = true;
3471 delayMs = TOUCH_SOUND_FIXED_DELAY_MS;
3472 updateInputRouting();
3473 }
3474 updateCallAndOutputRouting(forceVolumeReeval, delayMs);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003475
3476 return NO_ERROR;
3477}
3478
jiabin0a488932020-08-07 17:32:40 -07003479status_t AudioPolicyManager::getDevicesForRoleAndStrategy(product_strategy_t strategy,
3480 device_role_t role,
3481 AudioDeviceTypeAddrVector &devices) {
3482 return mEngine->getDevicesForRoleAndStrategy(strategy, role, devices);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003483}
3484
Jiabin Huang3b98d322020-09-03 17:54:16 +00003485status_t AudioPolicyManager::setDevicesRoleForCapturePreset(
3486 audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector &devices) {
3487 ALOGV("%s() audioSource=%d role=%d %s", __func__, audioSource, role,
3488 dumpAudioDeviceTypeAddrVector(devices).c_str());
3489
Mikhail Naganov55773032020-10-01 15:08:13 -07003490 if (!areAllDevicesSupported(devices, audio_call_is_input_device, __func__)) {
Jiabin Huang3b98d322020-09-03 17:54:16 +00003491 return BAD_VALUE;
3492 }
3493 status_t status = mEngine->setDevicesRoleForCapturePreset(audioSource, role, devices);
3494 ALOGW_IF(status != NO_ERROR,
3495 "Engine could not set preferred devices %s for audio source %d role %d",
3496 dumpAudioDeviceTypeAddrVector(devices).c_str(), audioSource, role);
3497
3498 return status;
3499}
3500
3501status_t AudioPolicyManager::addDevicesRoleForCapturePreset(
3502 audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector &devices) {
3503 ALOGV("%s() audioSource=%d role=%d %s", __func__, audioSource, role,
3504 dumpAudioDeviceTypeAddrVector(devices).c_str());
3505
Mikhail Naganov55773032020-10-01 15:08:13 -07003506 if (!areAllDevicesSupported(devices, audio_call_is_input_device, __func__)) {
Jiabin Huang3b98d322020-09-03 17:54:16 +00003507 return BAD_VALUE;
3508 }
3509 status_t status = mEngine->addDevicesRoleForCapturePreset(audioSource, role, devices);
3510 ALOGW_IF(status != NO_ERROR,
3511 "Engine could not add preferred devices %s for audio source %d role %d",
3512 dumpAudioDeviceTypeAddrVector(devices).c_str(), audioSource, role);
3513
Eric Laurent2517af32020-11-25 15:31:27 +01003514 updateInputRouting();
Jiabin Huang3b98d322020-09-03 17:54:16 +00003515 return status;
3516}
3517
3518status_t AudioPolicyManager::removeDevicesRoleForCapturePreset(
3519 audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector& devices)
3520{
3521 ALOGV("%s() audioSource=%d role=%d devices=%s", __func__, audioSource, role,
3522 dumpAudioDeviceTypeAddrVector(devices).c_str());
3523
Mikhail Naganov55773032020-10-01 15:08:13 -07003524 if (!areAllDevicesSupported(devices, audio_call_is_input_device, __func__)) {
Jiabin Huang3b98d322020-09-03 17:54:16 +00003525 return BAD_VALUE;
3526 }
3527
3528 status_t status = mEngine->removeDevicesRoleForCapturePreset(
3529 audioSource, role, devices);
3530 ALOGW_IF(status != NO_ERROR,
3531 "Engine could not remove devices role (%d) for capture preset %d", role, audioSource);
3532
Eric Laurent2517af32020-11-25 15:31:27 +01003533 updateInputRouting();
Jiabin Huang3b98d322020-09-03 17:54:16 +00003534 return status;
3535}
3536
3537status_t AudioPolicyManager::clearDevicesRoleForCapturePreset(audio_source_t audioSource,
3538 device_role_t role) {
3539 ALOGV("%s() audioSource=%d role=%d", __func__, audioSource, role);
3540
3541 status_t status = mEngine->clearDevicesRoleForCapturePreset(audioSource, role);
3542 ALOGW_IF(status != NO_ERROR,
3543 "Engine could not clear devices role (%d) for capture preset %d", role, audioSource);
3544
Eric Laurent2517af32020-11-25 15:31:27 +01003545 updateInputRouting();
Jiabin Huang3b98d322020-09-03 17:54:16 +00003546 return status;
3547}
3548
3549status_t AudioPolicyManager::getDevicesForRoleAndCapturePreset(
3550 audio_source_t audioSource, device_role_t role, AudioDeviceTypeAddrVector &devices) {
3551 return mEngine->getDevicesForRoleAndCapturePreset(audioSource, role, devices);
3552}
3553
Oscar Azucena90e77632019-11-27 17:12:28 -08003554status_t AudioPolicyManager::setUserIdDeviceAffinities(int userId,
jiabin6a02d532020-08-07 11:56:38 -07003555 const AudioDeviceTypeAddrVector& devices) {
Eric Laurentfecbceb2021-02-09 14:46:43 +01003556 ALOGV("%s() userId=%d num devices %zu", __func__, userId, devices.size());
Eric Laurentc529cf62020-04-17 18:19:10 -07003557 if (!areAllDevicesSupported(devices, audio_is_output_device, __func__)) {
3558 return BAD_VALUE;
Oscar Azucena90e77632019-11-27 17:12:28 -08003559 }
Oscar Azucena90e77632019-11-27 17:12:28 -08003560 status_t status = mPolicyMixes.setUserIdDeviceAffinities(userId, devices);
3561 if (status != NO_ERROR) {
3562 ALOGE("%s() could not set device affinity for userId %d",
3563 __FUNCTION__, userId);
3564 return status;
3565 }
3566
3567 // reevaluate outputs for all devices
3568 checkForDeviceAndOutputChanges();
3569 updateCallAndOutputRouting();
3570
3571 return NO_ERROR;
3572}
3573
3574status_t AudioPolicyManager::removeUserIdDeviceAffinities(int userId) {
Eric Laurentfecbceb2021-02-09 14:46:43 +01003575 ALOGV("%s() userId=%d", __FUNCTION__, userId);
Oscar Azucena90e77632019-11-27 17:12:28 -08003576 status_t status = mPolicyMixes.removeUserIdDeviceAffinities(userId);
3577 if (status != NO_ERROR) {
3578 ALOGE("%s() Could not remove all device affinities fo userId = %d",
3579 __FUNCTION__, userId);
3580 return status;
3581 }
3582
3583 // reevaluate outputs for all devices
3584 checkForDeviceAndOutputChanges();
3585 updateCallAndOutputRouting();
3586
3587 return NO_ERROR;
3588}
3589
Andy Hungc29d82b2018-10-05 12:23:17 -07003590void AudioPolicyManager::dump(String8 *dst) const
Eric Laurente552edb2014-03-10 17:42:56 -07003591{
Andy Hungc29d82b2018-10-05 12:23:17 -07003592 dst->appendFormat("\nAudioPolicyManager Dump: %p\n", this);
Mikhail Naganov0dbe87b2021-12-01 02:03:31 +00003593 dst->appendFormat(" Primary Output I/O handle: %d\n",
Eric Laurent87ffa392015-05-22 10:32:38 -07003594 hasPrimaryOutput() ? mPrimaryOutput->mIoHandle : AUDIO_IO_HANDLE_NONE);
Mikhail Naganov0d6a0332016-04-19 17:12:38 -07003595 std::string stateLiteral;
3596 AudioModeConverter::toString(mEngine->getPhoneState(), stateLiteral);
Andy Hungc29d82b2018-10-05 12:23:17 -07003597 dst->appendFormat(" Phone state: %s\n", stateLiteral.c_str());
Mikhail Naganov2e5167e12018-04-19 13:41:22 -07003598 const char* forceUses[AUDIO_POLICY_FORCE_USE_CNT] = {
3599 "communications", "media", "record", "dock", "system",
3600 "HDMI system audio", "encoded surround output", "vibrate ringing" };
3601 for (audio_policy_force_use_t i = AUDIO_POLICY_FORCE_FOR_COMMUNICATION;
3602 i < AUDIO_POLICY_FORCE_USE_CNT; i = (audio_policy_force_use_t)((int)i + 1)) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08003603 audio_policy_forced_cfg_t forceUseValue = mEngine->getForceUse(i);
3604 dst->appendFormat(" Force use for %s: %d", forceUses[i], forceUseValue);
3605 if (i == AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND &&
3606 forceUseValue == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
3607 dst->append(" (MANUAL: ");
3608 dumpManualSurroundFormats(dst);
3609 dst->append(")");
3610 }
3611 dst->append("\n");
Mikhail Naganov2e5167e12018-04-19 13:41:22 -07003612 }
Andy Hungc29d82b2018-10-05 12:23:17 -07003613 dst->appendFormat(" TTS output %savailable\n", mTtsOutputAvailable ? "" : "not ");
3614 dst->appendFormat(" Master mono: %s\n", mMasterMono ? "on" : "off");
Eric Laurent2517af32020-11-25 15:31:27 +01003615 dst->appendFormat(" Communnication Strategy: %d\n", mCommunnicationStrategy);
Andy Hungc29d82b2018-10-05 12:23:17 -07003616 dst->appendFormat(" Config source: %s\n", mConfig.getSource().c_str()); // getConfig not const
Eric Laurent2517af32020-11-25 15:31:27 +01003617
Mikhail Naganov0f413b22021-12-02 05:29:27 +00003618 dst->append("\n");
3619 mAvailableOutputDevices.dump(dst, String8("Available output"), 1);
3620 dst->append("\n");
3621 mAvailableInputDevices.dump(dst, String8("Available input"), 1);
Andy Hungc29d82b2018-10-05 12:23:17 -07003622 mHwModulesAll.dump(dst);
3623 mOutputs.dump(dst);
3624 mInputs.dump(dst);
Mikhail Naganov0f413b22021-12-02 05:29:27 +00003625 mEffects.dump(dst, 1);
Andy Hungc29d82b2018-10-05 12:23:17 -07003626 mAudioPatches.dump(dst);
3627 mPolicyMixes.dump(dst);
3628 mAudioSources.dump(dst);
François Gaffiec005e562018-11-06 15:04:49 +01003629
Kevin Rocardb99cc752019-03-21 20:52:24 -07003630 dst->appendFormat(" AllowedCapturePolicies:\n");
3631 for (auto& policy : mAllowedCapturePolicies) {
3632 dst->appendFormat(" - uid=%d flag_mask=%#x\n", policy.first, policy.second);
3633 }
3634
François Gaffiec005e562018-11-06 15:04:49 +01003635 dst->appendFormat("\nPolicy Engine dump:\n");
3636 mEngine->dump(dst);
Andy Hungc29d82b2018-10-05 12:23:17 -07003637}
3638
3639status_t AudioPolicyManager::dump(int fd)
3640{
3641 String8 result;
3642 dump(&result);
Andy Hungbb54e202018-10-05 11:42:02 -07003643 write(fd, result.string(), result.size());
Eric Laurente552edb2014-03-10 17:42:56 -07003644 return NO_ERROR;
3645}
3646
Kevin Rocardb99cc752019-03-21 20:52:24 -07003647status_t AudioPolicyManager::setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy)
3648{
3649 mAllowedCapturePolicies[uid] = capturePolicy;
3650 return NO_ERROR;
3651}
3652
Eric Laurente552edb2014-03-10 17:42:56 -07003653// This function checks for the parameters which can be offloaded.
3654// This can be enhanced depending on the capability of the DSP and policy
3655// of the system.
Eric Laurent90fe31c2020-11-26 20:06:35 +01003656audio_offload_mode_t AudioPolicyManager::getOffloadSupport(const audio_offload_info_t& offloadInfo)
Eric Laurente552edb2014-03-10 17:42:56 -07003657{
Eric Laurent90fe31c2020-11-26 20:06:35 +01003658 ALOGV("%s: SR=%u, CM=0x%x, Format=0x%x, StreamType=%d,"
Eric Laurentd4692962014-05-05 18:13:44 -07003659 " BitRate=%u, duration=%" PRId64 " us, has_video=%d",
Eric Laurent90fe31c2020-11-26 20:06:35 +01003660 __func__, offloadInfo.sample_rate, offloadInfo.channel_mask,
Eric Laurente552edb2014-03-10 17:42:56 -07003661 offloadInfo.format,
3662 offloadInfo.stream_type, offloadInfo.bit_rate, offloadInfo.duration_us,
3663 offloadInfo.has_video);
3664
jiabin2b9d5a12021-12-10 01:06:29 +00003665 if (!isOffloadPossible(offloadInfo)) {
Eric Laurent90fe31c2020-11-26 20:06:35 +01003666 return AUDIO_OFFLOAD_NOT_SUPPORTED;
Eric Laurente552edb2014-03-10 17:42:56 -07003667 }
3668
3669 // See if there is a profile to support this.
3670 // AUDIO_DEVICE_NONE
François Gaffie11d30102018-11-02 16:09:09 +01003671 sp<IOProfile> profile = getProfileForOutput(DeviceVector() /*ignore device */,
Eric Laurente552edb2014-03-10 17:42:56 -07003672 offloadInfo.sample_rate,
3673 offloadInfo.format,
3674 offloadInfo.channel_mask,
Michael Chana94fbb22018-04-24 14:31:19 +10003675 AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD,
3676 true /* directOnly */);
Eric Laurent94365442021-01-08 18:36:05 +01003677 ALOGV("%s: profile %sfound%s", __func__, profile != nullptr ? "" : "NOT ",
3678 (profile != nullptr && (profile->getFlags() & AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD) != 0)
3679 ? ", supports gapless" : "");
Eric Laurent90fe31c2020-11-26 20:06:35 +01003680 if (profile == nullptr) {
3681 return AUDIO_OFFLOAD_NOT_SUPPORTED;
3682 }
3683 if ((profile->getFlags() & AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD) != 0) {
3684 return AUDIO_OFFLOAD_GAPLESS_SUPPORTED;
3685 }
3686 return AUDIO_OFFLOAD_SUPPORTED;
Eric Laurente552edb2014-03-10 17:42:56 -07003687}
3688
Michael Chana94fbb22018-04-24 14:31:19 +10003689bool AudioPolicyManager::isDirectOutputSupported(const audio_config_base_t& config,
3690 const audio_attributes_t& attributes) {
3691 audio_output_flags_t output_flags = AUDIO_OUTPUT_FLAG_NONE;
François Gaffie58d4be52018-11-06 15:30:12 +01003692 audio_flags_to_audio_output_flags(attributes.flags, &output_flags);
François Gaffie11d30102018-11-02 16:09:09 +01003693 sp<IOProfile> profile = getProfileForOutput(DeviceVector() /*ignore device */,
Michael Chana94fbb22018-04-24 14:31:19 +10003694 config.sample_rate,
3695 config.format,
3696 config.channel_mask,
3697 output_flags,
3698 true /* directOnly */);
3699 ALOGV("%s() profile %sfound with name: %s, "
3700 "sample rate: %u, format: 0x%x, channel_mask: 0x%x, output flags: 0x%x",
3701 __FUNCTION__, profile != 0 ? "" : "NOT ",
jiabin5740f082019-08-19 15:08:30 -07003702 (profile != 0 ? profile->getTagName().c_str() : "null"),
Michael Chana94fbb22018-04-24 14:31:19 +10003703 config.sample_rate, config.format, config.channel_mask, output_flags);
3704 return (profile != 0);
3705}
3706
jiabin2b9d5a12021-12-10 01:06:29 +00003707bool AudioPolicyManager::isOffloadPossible(const audio_offload_info_t &offloadInfo,
3708 bool durationIgnored) {
3709 if (mMasterMono) {
3710 return false; // no offloading if mono is set.
3711 }
3712
3713 // Check if offload has been disabled
3714 if (property_get_bool("audio.offload.disable", false /* default_value */)) {
3715 ALOGV("%s: offload disabled by audio.offload.disable", __func__);
3716 return false;
3717 }
3718
3719 // Check if stream type is music, then only allow offload as of now.
3720 if (offloadInfo.stream_type != AUDIO_STREAM_MUSIC)
3721 {
3722 ALOGV("%s: stream_type != MUSIC, returning false", __func__);
3723 return false;
3724 }
3725
3726 //TODO: enable audio offloading with video when ready
3727 const bool allowOffloadWithVideo =
3728 property_get_bool("audio.offload.video", false /* default_value */);
3729 if (offloadInfo.has_video && !allowOffloadWithVideo) {
3730 ALOGV("%s: has_video == true, returning false", __func__);
3731 return false;
3732 }
3733
3734 //If duration is less than minimum value defined in property, return false
3735 const int min_duration_secs = property_get_int32(
3736 "audio.offload.min.duration.secs", -1 /* default_value */);
3737 if (!durationIgnored) {
3738 if (min_duration_secs >= 0) {
3739 if (offloadInfo.duration_us < min_duration_secs * 1000000LL) {
3740 ALOGV("%s: Offload denied by duration < audio.offload.min.duration.secs(=%d)",
3741 __func__, min_duration_secs);
3742 return false;
3743 }
3744 } else if (offloadInfo.duration_us < OFFLOAD_DEFAULT_MIN_DURATION_SECS * 1000000) {
3745 ALOGV("%s: Offload denied by duration < default min(=%u)",
3746 __func__, OFFLOAD_DEFAULT_MIN_DURATION_SECS);
3747 return false;
3748 }
3749 }
3750
3751 // Do not allow offloading if one non offloadable effect is enabled. This prevents from
3752 // creating an offloaded track and tearing it down immediately after start when audioflinger
3753 // detects there is an active non offloadable effect.
3754 // FIXME: We should check the audio session here but we do not have it in this context.
3755 // This may prevent offloading in rare situations where effects are left active by apps
3756 // in the background.
3757 if (mEffects.isNonOffloadableEffectEnabled()) {
3758 return false;
3759 }
3760
3761 return true;
3762}
3763
3764audio_direct_mode_t AudioPolicyManager::getDirectPlaybackSupport(const audio_attributes_t *attr,
3765 const audio_config_t *config) {
3766 audio_offload_info_t offloadInfo = AUDIO_INFO_INITIALIZER;
3767 offloadInfo.format = config->format;
3768 offloadInfo.sample_rate = config->sample_rate;
3769 offloadInfo.channel_mask = config->channel_mask;
3770 offloadInfo.stream_type = mEngine->getStreamTypeForAttributes(*attr);
3771 offloadInfo.has_video = false;
3772 offloadInfo.is_streaming = false;
3773 const bool offloadPossible = isOffloadPossible(offloadInfo, true /*durationIgnored*/);
3774
3775 audio_direct_mode_t directMode = AUDIO_DIRECT_NOT_SUPPORTED;
3776 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE;
3777 audio_flags_to_audio_output_flags(attr->flags, &flags);
3778 // only retain flags that will drive compressed offload or passthrough
3779 uint32_t relevantFlags = AUDIO_OUTPUT_FLAG_HW_AV_SYNC;
3780 if (offloadPossible) {
3781 relevantFlags |= AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
3782 }
3783 flags = (audio_output_flags_t)((flags & relevantFlags) | AUDIO_OUTPUT_FLAG_DIRECT);
3784
jiabinc8f7dfc2022-01-06 18:42:08 +00003785 DeviceVector outputDevices = mEngine->getOutputDevicesForAttributes(*attr);
jiabin2b9d5a12021-12-10 01:06:29 +00003786 for (const auto& hwModule : mHwModules) {
3787 for (const auto& curProfile : hwModule->getOutputProfiles()) {
jiabinc8f7dfc2022-01-06 18:42:08 +00003788 if (!curProfile->isCompatibleProfile(outputDevices,
jiabin2b9d5a12021-12-10 01:06:29 +00003789 config->sample_rate, nullptr /*updatedSamplingRate*/,
3790 config->format, nullptr /*updatedFormat*/,
3791 config->channel_mask, nullptr /*updatedChannelMask*/,
3792 flags)) {
3793 continue;
3794 }
3795 // reject profiles not corresponding to a device currently available
3796 if (!mAvailableOutputDevices.containsAtLeastOne(curProfile->getSupportedDevices())) {
3797 continue;
3798 }
3799 if ((curProfile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
3800 != AUDIO_OUTPUT_FLAG_NONE) {
jiabinc6132d62022-01-01 07:36:31 +00003801 if ((directMode & AUDIO_DIRECT_OFFLOAD_GAPLESS_SUPPORTED)
jiabin2b9d5a12021-12-10 01:06:29 +00003802 != AUDIO_DIRECT_NOT_SUPPORTED) {
3803 // Already reports offload gapless supported. No need to report offload support.
3804 continue;
3805 }
3806 if ((curProfile->getFlags() & AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD)
3807 != AUDIO_OUTPUT_FLAG_NONE) {
3808 // If offload gapless is reported, no need to report offload support.
3809 directMode = (audio_direct_mode_t) ((directMode &
3810 ~AUDIO_DIRECT_OFFLOAD_SUPPORTED) |
3811 AUDIO_DIRECT_OFFLOAD_GAPLESS_SUPPORTED);
3812 } else {
3813 directMode = (audio_direct_mode_t)(directMode |AUDIO_DIRECT_OFFLOAD_SUPPORTED);
3814 }
3815 } else {
3816 directMode = (audio_direct_mode_t) (directMode |
3817 AUDIO_DIRECT_BITSTREAM_SUPPORTED);
3818 }
3819 }
3820 }
3821 return directMode;
3822}
3823
Eric Laurent6a94d692014-05-20 11:18:06 -07003824status_t AudioPolicyManager::listAudioPorts(audio_port_role_t role,
3825 audio_port_type_t type,
3826 unsigned int *num_ports,
jiabin19cdba52020-11-24 11:28:58 -08003827 struct audio_port_v7 *ports,
Eric Laurent6a94d692014-05-20 11:18:06 -07003828 unsigned int *generation)
3829{
jiabin19cdba52020-11-24 11:28:58 -08003830 if (num_ports == nullptr || (*num_ports != 0 && ports == nullptr) ||
3831 generation == nullptr) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003832 return BAD_VALUE;
3833 }
3834 ALOGV("listAudioPorts() role %d type %d num_ports %d ports %p", role, type, *num_ports, ports);
jiabin19cdba52020-11-24 11:28:58 -08003835 if (ports == nullptr) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003836 *num_ports = 0;
3837 }
3838
3839 size_t portsWritten = 0;
3840 size_t portsMax = *num_ports;
3841 *num_ports = 0;
3842 if (type == AUDIO_PORT_TYPE_NONE || type == AUDIO_PORT_TYPE_DEVICE) {
Eric Laurent5a2b6292016-04-14 18:05:57 -07003843 // do not report devices with type AUDIO_DEVICE_IN_STUB or AUDIO_DEVICE_OUT_STUB
3844 // as they are used by stub HALs by convention
Eric Laurent6a94d692014-05-20 11:18:06 -07003845 if (role == AUDIO_PORT_ROLE_SINK || role == AUDIO_PORT_ROLE_NONE) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003846 for (const auto& dev : mAvailableOutputDevices) {
3847 if (dev->type() == AUDIO_DEVICE_OUT_STUB) {
Eric Laurent5a2b6292016-04-14 18:05:57 -07003848 continue;
3849 }
3850 if (portsWritten < portsMax) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003851 dev->toAudioPort(&ports[portsWritten++]);
Eric Laurent5a2b6292016-04-14 18:05:57 -07003852 }
3853 (*num_ports)++;
Eric Laurent6a94d692014-05-20 11:18:06 -07003854 }
Eric Laurent6a94d692014-05-20 11:18:06 -07003855 }
3856 if (role == AUDIO_PORT_ROLE_SOURCE || role == AUDIO_PORT_ROLE_NONE) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003857 for (const auto& dev : mAvailableInputDevices) {
3858 if (dev->type() == AUDIO_DEVICE_IN_STUB) {
Eric Laurent5a2b6292016-04-14 18:05:57 -07003859 continue;
3860 }
3861 if (portsWritten < portsMax) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003862 dev->toAudioPort(&ports[portsWritten++]);
Eric Laurent5a2b6292016-04-14 18:05:57 -07003863 }
3864 (*num_ports)++;
Eric Laurent6a94d692014-05-20 11:18:06 -07003865 }
Eric Laurent6a94d692014-05-20 11:18:06 -07003866 }
3867 }
3868 if (type == AUDIO_PORT_TYPE_NONE || type == AUDIO_PORT_TYPE_MIX) {
3869 if (role == AUDIO_PORT_ROLE_SINK || role == AUDIO_PORT_ROLE_NONE) {
3870 for (size_t i = 0; i < mInputs.size() && portsWritten < portsMax; i++) {
3871 mInputs[i]->toAudioPort(&ports[portsWritten++]);
3872 }
3873 *num_ports += mInputs.size();
3874 }
3875 if (role == AUDIO_PORT_ROLE_SOURCE || role == AUDIO_PORT_ROLE_NONE) {
Eric Laurent84c70242014-06-23 08:46:27 -07003876 size_t numOutputs = 0;
3877 for (size_t i = 0; i < mOutputs.size(); i++) {
3878 if (!mOutputs[i]->isDuplicated()) {
3879 numOutputs++;
3880 if (portsWritten < portsMax) {
3881 mOutputs[i]->toAudioPort(&ports[portsWritten++]);
3882 }
3883 }
Eric Laurent6a94d692014-05-20 11:18:06 -07003884 }
Eric Laurent84c70242014-06-23 08:46:27 -07003885 *num_ports += numOutputs;
Eric Laurent6a94d692014-05-20 11:18:06 -07003886 }
3887 }
3888 *generation = curAudioPortGeneration();
Mark Salyzynbeb9e302014-06-18 16:33:15 -07003889 ALOGV("listAudioPorts() got %zu ports needed %d", portsWritten, *num_ports);
Eric Laurent6a94d692014-05-20 11:18:06 -07003890 return NO_ERROR;
3891}
3892
jiabin19cdba52020-11-24 11:28:58 -08003893status_t AudioPolicyManager::getAudioPort(struct audio_port_v7 *port)
Eric Laurent6a94d692014-05-20 11:18:06 -07003894{
Eric Laurent99fcae42018-05-17 16:59:18 -07003895 if (port == nullptr || port->id == AUDIO_PORT_HANDLE_NONE) {
3896 return BAD_VALUE;
3897 }
3898 sp<DeviceDescriptor> dev = mAvailableOutputDevices.getDeviceFromId(port->id);
3899 if (dev != 0) {
3900 dev->toAudioPort(port);
3901 return NO_ERROR;
3902 }
3903 dev = mAvailableInputDevices.getDeviceFromId(port->id);
3904 if (dev != 0) {
3905 dev->toAudioPort(port);
3906 return NO_ERROR;
3907 }
3908 sp<SwAudioOutputDescriptor> out = mOutputs.getOutputFromId(port->id);
3909 if (out != 0) {
3910 out->toAudioPort(port);
3911 return NO_ERROR;
3912 }
3913 sp<AudioInputDescriptor> in = mInputs.getInputFromId(port->id);
3914 if (in != 0) {
3915 in->toAudioPort(port);
3916 return NO_ERROR;
3917 }
3918 return BAD_VALUE;
Eric Laurent6a94d692014-05-20 11:18:06 -07003919}
3920
François Gaffieafd4cea2019-11-18 15:50:22 +01003921status_t AudioPolicyManager::createAudioPatchInternal(const struct audio_patch *patch,
3922 audio_patch_handle_t *handle,
3923 uid_t uid, uint32_t delayMs,
3924 const sp<SourceClientDescriptor>& sourceDesc)
Eric Laurent6a94d692014-05-20 11:18:06 -07003925{
François Gaffieafd4cea2019-11-18 15:50:22 +01003926 ALOGV("%s", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07003927 if (handle == NULL || patch == NULL) {
3928 return BAD_VALUE;
3929 }
François Gaffieafd4cea2019-11-18 15:50:22 +01003930 ALOGV("%s num sources %d num sinks %d", __func__, patch->num_sources, patch->num_sinks);
Eric Laurent6a94d692014-05-20 11:18:06 -07003931
Mikhail Naganovac9858b2018-06-15 13:12:37 -07003932 if (!audio_patch_is_valid(patch)) {
Eric Laurent874c42872014-08-08 15:13:39 -07003933 return BAD_VALUE;
3934 }
3935 // only one source per audio patch supported for now
3936 if (patch->num_sources > 1) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003937 return INVALID_OPERATION;
3938 }
Eric Laurent874c42872014-08-08 15:13:39 -07003939
3940 if (patch->sources[0].role != AUDIO_PORT_ROLE_SOURCE) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003941 return INVALID_OPERATION;
3942 }
Eric Laurent874c42872014-08-08 15:13:39 -07003943 for (size_t i = 0; i < patch->num_sinks; i++) {
3944 if (patch->sinks[i].role != AUDIO_PORT_ROLE_SINK) {
3945 return INVALID_OPERATION;
3946 }
3947 }
Eric Laurent6a94d692014-05-20 11:18:06 -07003948
3949 sp<AudioPatch> patchDesc;
3950 ssize_t index = mAudioPatches.indexOfKey(*handle);
3951
François Gaffieafd4cea2019-11-18 15:50:22 +01003952 ALOGV("%s source id %d role %d type %d", __func__, patch->sources[0].id,
3953 patch->sources[0].role,
3954 patch->sources[0].type);
Eric Laurent874c42872014-08-08 15:13:39 -07003955#if LOG_NDEBUG == 0
3956 for (size_t i = 0; i < patch->num_sinks; i++) {
François Gaffieafd4cea2019-11-18 15:50:22 +01003957 ALOGV("%s sink %zu: id %d role %d type %d", __func__ ,i, patch->sinks[i].id,
3958 patch->sinks[i].role,
3959 patch->sinks[i].type);
Eric Laurent874c42872014-08-08 15:13:39 -07003960 }
3961#endif
Eric Laurent6a94d692014-05-20 11:18:06 -07003962
3963 if (index >= 0) {
3964 patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01003965 ALOGV("%s mUidCached %d patchDesc->mUid %d uid %d",
3966 __func__, mUidCached, patchDesc->getUid(), uid);
3967 if (patchDesc->getUid() != mUidCached && uid != patchDesc->getUid()) {
Eric Laurent6a94d692014-05-20 11:18:06 -07003968 return INVALID_OPERATION;
3969 }
3970 } else {
Glenn Kastena13cde92016-03-28 15:26:02 -07003971 *handle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurent6a94d692014-05-20 11:18:06 -07003972 }
3973
3974 if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) {
Eric Laurentc75307b2015-03-17 15:29:32 -07003975 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07003976 if (outputDesc == NULL) {
François Gaffieafd4cea2019-11-18 15:50:22 +01003977 ALOGV("%s output not found for id %d", __func__, patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07003978 return BAD_VALUE;
3979 }
Eric Laurent84c70242014-06-23 08:46:27 -07003980 ALOG_ASSERT(!outputDesc->isDuplicated(),"duplicated output %d in source in ports",
3981 outputDesc->mIoHandle);
Eric Laurent6a94d692014-05-20 11:18:06 -07003982 if (patchDesc != 0) {
3983 if (patchDesc->mPatch.sources[0].id != patch->sources[0].id) {
François Gaffieafd4cea2019-11-18 15:50:22 +01003984 ALOGV("%s source id differs for patch current id %d new id %d",
3985 __func__, patchDesc->mPatch.sources[0].id, patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07003986 return BAD_VALUE;
3987 }
3988 }
Eric Laurent874c42872014-08-08 15:13:39 -07003989 DeviceVector devices;
3990 for (size_t i = 0; i < patch->num_sinks; i++) {
3991 // Only support mix to devices connection
3992 // TODO add support for mix to mix connection
3993 if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) {
François Gaffieafd4cea2019-11-18 15:50:22 +01003994 ALOGV("%s source mix but sink is not a device", __func__);
Eric Laurent874c42872014-08-08 15:13:39 -07003995 return INVALID_OPERATION;
3996 }
3997 sp<DeviceDescriptor> devDesc =
3998 mAvailableOutputDevices.getDeviceFromId(patch->sinks[i].id);
3999 if (devDesc == 0) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004000 ALOGV("%s out device not found for id %d", __func__, patch->sinks[i].id);
Eric Laurent874c42872014-08-08 15:13:39 -07004001 return BAD_VALUE;
4002 }
Eric Laurent6a94d692014-05-20 11:18:06 -07004003
François Gaffie11d30102018-11-02 16:09:09 +01004004 if (!outputDesc->mProfile->isCompatibleProfile(DeviceVector(devDesc),
Eric Laurent874c42872014-08-08 15:13:39 -07004005 patch->sources[0].sample_rate,
François Gaffie53615e22015-03-19 09:24:12 +01004006 NULL, // updatedSamplingRate
4007 patch->sources[0].format,
Andy Hungf129b032015-04-07 13:45:50 -07004008 NULL, // updatedFormat
François Gaffie53615e22015-03-19 09:24:12 +01004009 patch->sources[0].channel_mask,
Andy Hungf129b032015-04-07 13:45:50 -07004010 NULL, // updatedChannelMask
François Gaffie53615e22015-03-19 09:24:12 +01004011 AUDIO_OUTPUT_FLAG_NONE /*FIXME*/)) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004012 ALOGV("%s profile not supported for device %08x", __func__, devDesc->type());
Eric Laurent874c42872014-08-08 15:13:39 -07004013 return INVALID_OPERATION;
4014 }
4015 devices.add(devDesc);
4016 }
4017 if (devices.size() == 0) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004018 return INVALID_OPERATION;
4019 }
Eric Laurent874c42872014-08-08 15:13:39 -07004020
Eric Laurent6a94d692014-05-20 11:18:06 -07004021 // TODO: reconfigure output format and channels here
François Gaffieafd4cea2019-11-18 15:50:22 +01004022 ALOGV("%s setting device %s on output %d",
4023 __func__, dumpDeviceTypes(devices.types()).c_str(), outputDesc->mIoHandle);
François Gaffie11d30102018-11-02 16:09:09 +01004024 setOutputDevices(outputDesc, devices, true, 0, handle);
Eric Laurent6a94d692014-05-20 11:18:06 -07004025 index = mAudioPatches.indexOfKey(*handle);
4026 if (index >= 0) {
4027 if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004028 ALOGW("%s setOutputDevice() did not reuse the patch provided", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07004029 }
4030 patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01004031 patchDesc->setUid(uid);
4032 ALOGV("%s success", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07004033 } else {
François Gaffieafd4cea2019-11-18 15:50:22 +01004034 ALOGW("%s setOutputDevice() failed to create a patch", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07004035 return INVALID_OPERATION;
4036 }
4037 } else if (patch->sources[0].type == AUDIO_PORT_TYPE_DEVICE) {
4038 if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
4039 // input device to input mix connection
Eric Laurent874c42872014-08-08 15:13:39 -07004040 // only one sink supported when connecting an input device to a mix
4041 if (patch->num_sinks > 1) {
4042 return INVALID_OPERATION;
4043 }
François Gaffie53615e22015-03-19 09:24:12 +01004044 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(patch->sinks[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07004045 if (inputDesc == NULL) {
4046 return BAD_VALUE;
4047 }
4048 if (patchDesc != 0) {
4049 if (patchDesc->mPatch.sinks[0].id != patch->sinks[0].id) {
4050 return BAD_VALUE;
4051 }
4052 }
François Gaffie11d30102018-11-02 16:09:09 +01004053 sp<DeviceDescriptor> device =
Eric Laurent6a94d692014-05-20 11:18:06 -07004054 mAvailableInputDevices.getDeviceFromId(patch->sources[0].id);
François Gaffie11d30102018-11-02 16:09:09 +01004055 if (device == 0) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004056 return BAD_VALUE;
4057 }
4058
François Gaffie11d30102018-11-02 16:09:09 +01004059 if (!inputDesc->mProfile->isCompatibleProfile(DeviceVector(device),
Eric Laurent275e8e92014-11-30 15:14:47 -08004060 patch->sinks[0].sample_rate,
4061 NULL, /*updatedSampleRate*/
4062 patch->sinks[0].format,
Andy Hungf129b032015-04-07 13:45:50 -07004063 NULL, /*updatedFormat*/
Eric Laurent275e8e92014-11-30 15:14:47 -08004064 patch->sinks[0].channel_mask,
Andy Hungf129b032015-04-07 13:45:50 -07004065 NULL, /*updatedChannelMask*/
Eric Laurent275e8e92014-11-30 15:14:47 -08004066 // FIXME for the parameter type,
4067 // and the NONE
4068 (audio_output_flags_t)
Glenn Kasten6a8ab052014-07-24 14:08:35 -07004069 AUDIO_INPUT_FLAG_NONE)) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004070 return INVALID_OPERATION;
4071 }
4072 // TODO: reconfigure output format and channels here
François Gaffieafd4cea2019-11-18 15:50:22 +01004073 ALOGV("%s setting device %s on output %d", __func__,
François Gaffie11d30102018-11-02 16:09:09 +01004074 device->toString().c_str(), inputDesc->mIoHandle);
4075 setInputDevice(inputDesc->mIoHandle, device, true, handle);
Eric Laurent6a94d692014-05-20 11:18:06 -07004076 index = mAudioPatches.indexOfKey(*handle);
4077 if (index >= 0) {
4078 if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004079 ALOGW("%s setInputDevice() did not reuse the patch provided", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07004080 }
4081 patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01004082 patchDesc->setUid(uid);
4083 ALOGV("%s success", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07004084 } else {
François Gaffieafd4cea2019-11-18 15:50:22 +01004085 ALOGW("%s setInputDevice() failed to create a patch", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07004086 return INVALID_OPERATION;
4087 }
4088 } else if (patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) {
4089 // device to device connection
4090 if (patchDesc != 0) {
Eric Laurent874c42872014-08-08 15:13:39 -07004091 if (patchDesc->mPatch.sources[0].id != patch->sources[0].id) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004092 return BAD_VALUE;
4093 }
4094 }
François Gaffie11d30102018-11-02 16:09:09 +01004095 sp<DeviceDescriptor> srcDevice =
Eric Laurent6a94d692014-05-20 11:18:06 -07004096 mAvailableInputDevices.getDeviceFromId(patch->sources[0].id);
François Gaffie11d30102018-11-02 16:09:09 +01004097 if (srcDevice == 0) {
Eric Laurent58f8eb72014-09-12 16:19:41 -07004098 return BAD_VALUE;
4099 }
Eric Laurent874c42872014-08-08 15:13:39 -07004100
Eric Laurent6a94d692014-05-20 11:18:06 -07004101 //update source and sink with our own data as the data passed in the patch may
4102 // be incomplete.
François Gaffieafd4cea2019-11-18 15:50:22 +01004103 PatchBuilder patchBuilder;
4104 audio_port_config sourcePortConfig = {};
Dean Wheatley8bee85a2021-02-10 16:02:23 +11004105
4106 // if first sink is to MSD, establish single MSD patch
4107 if (getMsdAudioOutDevices().contains(
4108 mAvailableOutputDevices.getDeviceFromId(patch->sinks[0].id))) {
4109 ALOGV("%s patching to MSD", __FUNCTION__);
4110 patchBuilder = buildMsdPatch(false /*msdIsSource*/, srcDevice);
4111 goto installPatch;
4112 }
4113
François Gaffieafd4cea2019-11-18 15:50:22 +01004114 srcDevice->toAudioPortConfig(&sourcePortConfig, &patch->sources[0]);
4115 patchBuilder.addSource(sourcePortConfig);
Eric Laurent6a94d692014-05-20 11:18:06 -07004116
Eric Laurent874c42872014-08-08 15:13:39 -07004117 for (size_t i = 0; i < patch->num_sinks; i++) {
4118 if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004119 ALOGV("%s source device but one sink is not a device", __func__);
Eric Laurent874c42872014-08-08 15:13:39 -07004120 return INVALID_OPERATION;
4121 }
François Gaffie11d30102018-11-02 16:09:09 +01004122 sp<DeviceDescriptor> sinkDevice =
Eric Laurent874c42872014-08-08 15:13:39 -07004123 mAvailableOutputDevices.getDeviceFromId(patch->sinks[i].id);
François Gaffie11d30102018-11-02 16:09:09 +01004124 if (sinkDevice == 0) {
Eric Laurent874c42872014-08-08 15:13:39 -07004125 return BAD_VALUE;
4126 }
François Gaffieafd4cea2019-11-18 15:50:22 +01004127 audio_port_config sinkPortConfig = {};
4128 sinkDevice->toAudioPortConfig(&sinkPortConfig, &patch->sinks[i]);
4129 patchBuilder.addSink(sinkPortConfig);
Eric Laurent874c42872014-08-08 15:13:39 -07004130
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02004131 // Whatever Sw or Hw bridge, we do attach an SwOutput to an Audio Source for
4132 // volume management purpose (tracking activity)
4133 // In case of Hw bridge, it is a Work Around. The mixPort used is the one declared
4134 // in config XML to reach the sink so that is can be declared as available.
4135 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
4136 sp<SwAudioOutputDescriptor> outputDesc = nullptr;
4137 if (sourceDesc != nullptr) {
4138 // take care of dynamic routing for SwOutput selection,
4139 audio_attributes_t attributes = sourceDesc->attributes();
4140 audio_stream_type_t stream = sourceDesc->stream();
4141 audio_attributes_t resultAttr;
4142 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
4143 config.sample_rate = sourceDesc->config().sample_rate;
4144 config.channel_mask = sourceDesc->config().channel_mask;
4145 config.format = sourceDesc->config().format;
4146 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE;
4147 audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
4148 bool isRequestedDeviceForExclusiveUse = false;
4149 output_type_t outputType;
4150 getOutputForAttrInt(&resultAttr, &output, AUDIO_SESSION_NONE, &attributes,
4151 &stream, sourceDesc->uid(), &config, &flags,
4152 &selectedDeviceId, &isRequestedDeviceForExclusiveUse,
4153 nullptr, &outputType);
4154 if (output == AUDIO_IO_HANDLE_NONE) {
4155 ALOGV("%s no output for device %s",
4156 __FUNCTION__, sinkDevice->toString().c_str());
4157 return INVALID_OPERATION;
4158 }
4159 outputDesc = mOutputs.valueFor(output);
4160 if (outputDesc->isDuplicated()) {
4161 ALOGE("%s output is duplicated", __func__);
4162 return INVALID_OPERATION;
4163 }
4164 sourceDesc->setSwOutput(outputDesc);
4165 }
Eric Laurent3bcf8592015-04-03 12:13:24 -07004166 // create a software bridge in PatchPanel if:
Scott Randolphf3172402018-01-23 17:06:53 -08004167 // - source and sink devices are on different HW modules OR
Eric Laurent3bcf8592015-04-03 12:13:24 -07004168 // - audio HAL version is < 3.0
Francois Gaffie99896da2018-04-09 11:05:33 +02004169 // - audio HAL version is >= 3.0 but no route has been declared between devices
François Gaffieafd4cea2019-11-18 15:50:22 +01004170 // - called from startAudioSource (aka sourceDesc != nullptr) and source device does
4171 // not have a gain controller
François Gaffie11d30102018-11-02 16:09:09 +01004172 if (!srcDevice->hasSameHwModuleAs(sinkDevice) ||
4173 (srcDevice->getModuleVersionMajor() < 3) ||
François Gaffieafd4cea2019-11-18 15:50:22 +01004174 !srcDevice->getModule()->supportsPatch(srcDevice, sinkDevice) ||
4175 (sourceDesc != nullptr &&
4176 srcDevice->getAudioPort()->getGains().size() == 0)) {
Eric Laurent3bcf8592015-04-03 12:13:24 -07004177 // support only one sink device for now to simplify output selection logic
Eric Laurent874c42872014-08-08 15:13:39 -07004178 if (patch->num_sinks > 1) {
Eric Laurent83b88082014-06-20 18:31:16 -07004179 return INVALID_OPERATION;
4180 }
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02004181 if (sourceDesc == nullptr) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004182 SortedVector<audio_io_handle_t> outputs =
4183 getOutputsForDevices(DeviceVector(sinkDevice), mOutputs);
4184 // if the sink device is reachable via an opened output stream, request to
4185 // go via this output stream by adding a second source to the patch
4186 // description
4187 output = selectOutput(outputs);
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02004188 if (output != AUDIO_IO_HANDLE_NONE) {
4189 outputDesc = mOutputs.valueFor(output);
4190 if (outputDesc->isDuplicated()) {
4191 ALOGV("%s output for device %s is duplicated",
4192 __FUNCTION__, sinkDevice->toString().c_str());
4193 return INVALID_OPERATION;
4194 }
François Gaffieafd4cea2019-11-18 15:50:22 +01004195 }
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02004196 }
4197 if (outputDesc != nullptr) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004198 audio_port_config srcMixPortConfig = {};
Ytai Ben-Tsvic9d2a912021-11-22 16:43:09 -08004199 outputDesc->toAudioPortConfig(&srcMixPortConfig, nullptr);
François Gaffieafd4cea2019-11-18 15:50:22 +01004200 // for volume control, we may need a valid stream
4201 srcMixPortConfig.ext.mix.usecase.stream = sourceDesc != nullptr ?
4202 sourceDesc->stream() : AUDIO_STREAM_PATCH;
4203 patchBuilder.addSource(srcMixPortConfig);
Eric Laurent874c42872014-08-08 15:13:39 -07004204 }
Eric Laurent83b88082014-06-20 18:31:16 -07004205 }
Eric Laurent6a94d692014-05-20 11:18:06 -07004206 }
4207 // TODO: check from routing capabilities in config file and other conflicting patches
4208
Dean Wheatley8bee85a2021-02-10 16:02:23 +11004209installPatch:
François Gaffieafd4cea2019-11-18 15:50:22 +01004210 status_t status = installPatch(
4211 __func__, index, handle, patchBuilder.patch(), delayMs, uid, &patchDesc);
Mikhail Naganovdc769682018-05-04 15:34:08 -07004212 if (status != NO_ERROR) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004213 ALOGW("%s patch panel could not connect device patch, error %d", __func__, status);
Eric Laurent6a94d692014-05-20 11:18:06 -07004214 return INVALID_OPERATION;
4215 }
4216 } else {
4217 return BAD_VALUE;
4218 }
4219 } else {
4220 return BAD_VALUE;
4221 }
4222 return NO_ERROR;
4223}
4224
4225status_t AudioPolicyManager::releaseAudioPatch(audio_patch_handle_t handle,
4226 uid_t uid)
4227{
4228 ALOGV("releaseAudioPatch() patch %d", handle);
4229
4230 ssize_t index = mAudioPatches.indexOfKey(handle);
4231
4232 if (index < 0) {
4233 return BAD_VALUE;
4234 }
4235 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01004236 ALOGV("%s() mUidCached %d patchDesc->mUid %d uid %d",
4237 __func__, mUidCached, patchDesc->getUid(), uid);
4238 if (patchDesc->getUid() != mUidCached && uid != patchDesc->getUid()) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004239 return INVALID_OPERATION;
4240 }
François Gaffieafd4cea2019-11-18 15:50:22 +01004241 return releaseAudioPatchInternal(handle);
4242}
Eric Laurent6a94d692014-05-20 11:18:06 -07004243
François Gaffieafd4cea2019-11-18 15:50:22 +01004244status_t AudioPolicyManager::releaseAudioPatchInternal(audio_patch_handle_t handle,
4245 uint32_t delayMs)
4246{
4247 ALOGV("%s patch %d", __func__, handle);
4248 if (mAudioPatches.indexOfKey(handle) < 0) {
4249 ALOGE("%s: no patch found with handle=%d", __func__, handle);
4250 return BAD_VALUE;
4251 }
4252 sp<AudioPatch> patchDesc = mAudioPatches.valueFor(handle);
Eric Laurent6a94d692014-05-20 11:18:06 -07004253 struct audio_patch *patch = &patchDesc->mPatch;
François Gaffieafd4cea2019-11-18 15:50:22 +01004254 patchDesc->setUid(mUidCached);
Eric Laurent6a94d692014-05-20 11:18:06 -07004255 if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) {
Eric Laurentc75307b2015-03-17 15:29:32 -07004256 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07004257 if (outputDesc == NULL) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004258 ALOGV("%s output not found for id %d", __func__, patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07004259 return BAD_VALUE;
4260 }
4261
François Gaffie11d30102018-11-02 16:09:09 +01004262 setOutputDevices(outputDesc,
4263 getNewOutputDevices(outputDesc, true /*fromCache*/),
4264 true,
4265 0,
4266 NULL);
Eric Laurent6a94d692014-05-20 11:18:06 -07004267 } else if (patch->sources[0].type == AUDIO_PORT_TYPE_DEVICE) {
4268 if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
François Gaffie53615e22015-03-19 09:24:12 +01004269 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(patch->sinks[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07004270 if (inputDesc == NULL) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004271 ALOGV("%s input not found for id %d", __func__, patch->sinks[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07004272 return BAD_VALUE;
4273 }
4274 setInputDevice(inputDesc->mIoHandle,
Eric Laurentfb66dd92016-01-28 18:32:03 -08004275 getNewInputDevice(inputDesc),
Eric Laurent6a94d692014-05-20 11:18:06 -07004276 true,
4277 NULL);
4278 } else if (patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004279 status_t status =
4280 mpClientInterface->releaseAudioPatch(patchDesc->getAfHandle(), delayMs);
4281 ALOGV("%s patch panel returned %d patchHandle %d",
4282 __func__, status, patchDesc->getAfHandle());
4283 removeAudioPatch(patchDesc->getHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07004284 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07004285 mpClientInterface->onAudioPatchListUpdate();
Francois Gaffie7feb8542020-04-06 17:39:47 +02004286 // SW Bridge
4287 if (patch->num_sources > 1 && patch->sources[1].type == AUDIO_PORT_TYPE_MIX) {
4288 sp<SwAudioOutputDescriptor> outputDesc =
4289 mOutputs.getOutputFromId(patch->sources[1].id);
4290 if (outputDesc == NULL) {
Francois Gaffieff1eb522020-05-06 18:37:04 +02004291 ALOGW("%s output not found for id %d", __func__, patch->sources[0].id);
4292 // releaseOutput has already called closeOuput in case of direct output
4293 return NO_ERROR;
Francois Gaffie7feb8542020-04-06 17:39:47 +02004294 }
Francois Gaffie8e544542020-05-11 14:12:53 +02004295 if (patchDesc->getHandle() != outputDesc->getPatchHandle()) {
4296 // force SwOutput patch removal as AF counter part patch has already gone.
4297 ALOGV("%s reset patch handle on Output as different from SWBridge", __func__);
4298 removeAudioPatch(outputDesc->getPatchHandle());
4299 }
Francois Gaffie7feb8542020-04-06 17:39:47 +02004300 outputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
4301 setOutputDevices(outputDesc,
4302 getNewOutputDevices(outputDesc, true /*fromCache*/),
4303 true, /*force*/
4304 0,
4305 NULL);
4306 }
Eric Laurent6a94d692014-05-20 11:18:06 -07004307 } else {
4308 return BAD_VALUE;
4309 }
4310 } else {
4311 return BAD_VALUE;
4312 }
4313 return NO_ERROR;
4314}
4315
4316status_t AudioPolicyManager::listAudioPatches(unsigned int *num_patches,
4317 struct audio_patch *patches,
4318 unsigned int *generation)
4319{
François Gaffie53615e22015-03-19 09:24:12 +01004320 if (generation == NULL) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004321 return BAD_VALUE;
4322 }
Eric Laurent6a94d692014-05-20 11:18:06 -07004323 *generation = curAudioPortGeneration();
François Gaffie53615e22015-03-19 09:24:12 +01004324 return mAudioPatches.listAudioPatches(num_patches, patches);
Eric Laurent6a94d692014-05-20 11:18:06 -07004325}
4326
Eric Laurente1715a42014-05-20 11:30:42 -07004327status_t AudioPolicyManager::setAudioPortConfig(const struct audio_port_config *config)
Eric Laurent6a94d692014-05-20 11:18:06 -07004328{
Eric Laurente1715a42014-05-20 11:30:42 -07004329 ALOGV("setAudioPortConfig()");
4330
4331 if (config == NULL) {
4332 return BAD_VALUE;
4333 }
4334 ALOGV("setAudioPortConfig() on port handle %d", config->id);
4335 // Only support gain configuration for now
Eric Laurenta121f902014-06-03 13:32:54 -07004336 if (config->config_mask != AUDIO_PORT_CONFIG_GAIN) {
4337 return INVALID_OPERATION;
Eric Laurente1715a42014-05-20 11:30:42 -07004338 }
4339
Eric Laurenta121f902014-06-03 13:32:54 -07004340 sp<AudioPortConfig> audioPortConfig;
Eric Laurente1715a42014-05-20 11:30:42 -07004341 if (config->type == AUDIO_PORT_TYPE_MIX) {
4342 if (config->role == AUDIO_PORT_ROLE_SOURCE) {
Eric Laurentc75307b2015-03-17 15:29:32 -07004343 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(config->id);
Eric Laurente1715a42014-05-20 11:30:42 -07004344 if (outputDesc == NULL) {
4345 return BAD_VALUE;
4346 }
Eric Laurent84c70242014-06-23 08:46:27 -07004347 ALOG_ASSERT(!outputDesc->isDuplicated(),
4348 "setAudioPortConfig() called on duplicated output %d",
4349 outputDesc->mIoHandle);
Eric Laurenta121f902014-06-03 13:32:54 -07004350 audioPortConfig = outputDesc;
Eric Laurente1715a42014-05-20 11:30:42 -07004351 } else if (config->role == AUDIO_PORT_ROLE_SINK) {
François Gaffie53615e22015-03-19 09:24:12 +01004352 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(config->id);
Eric Laurente1715a42014-05-20 11:30:42 -07004353 if (inputDesc == NULL) {
4354 return BAD_VALUE;
4355 }
Eric Laurenta121f902014-06-03 13:32:54 -07004356 audioPortConfig = inputDesc;
Eric Laurente1715a42014-05-20 11:30:42 -07004357 } else {
4358 return BAD_VALUE;
4359 }
4360 } else if (config->type == AUDIO_PORT_TYPE_DEVICE) {
4361 sp<DeviceDescriptor> deviceDesc;
4362 if (config->role == AUDIO_PORT_ROLE_SOURCE) {
4363 deviceDesc = mAvailableInputDevices.getDeviceFromId(config->id);
4364 } else if (config->role == AUDIO_PORT_ROLE_SINK) {
4365 deviceDesc = mAvailableOutputDevices.getDeviceFromId(config->id);
4366 } else {
4367 return BAD_VALUE;
4368 }
4369 if (deviceDesc == NULL) {
4370 return BAD_VALUE;
4371 }
Eric Laurenta121f902014-06-03 13:32:54 -07004372 audioPortConfig = deviceDesc;
Eric Laurente1715a42014-05-20 11:30:42 -07004373 } else {
4374 return BAD_VALUE;
4375 }
4376
Mikhail Naganov7be71d22018-05-23 16:51:46 -07004377 struct audio_port_config backupConfig = {};
Eric Laurenta121f902014-06-03 13:32:54 -07004378 status_t status = audioPortConfig->applyAudioPortConfig(config, &backupConfig);
4379 if (status == NO_ERROR) {
Mikhail Naganov7be71d22018-05-23 16:51:46 -07004380 struct audio_port_config newConfig = {};
Eric Laurenta121f902014-06-03 13:32:54 -07004381 audioPortConfig->toAudioPortConfig(&newConfig, config);
4382 status = mpClientInterface->setAudioPortConfig(&newConfig, 0);
Eric Laurente1715a42014-05-20 11:30:42 -07004383 }
Eric Laurenta121f902014-06-03 13:32:54 -07004384 if (status != NO_ERROR) {
4385 audioPortConfig->applyAudioPortConfig(&backupConfig);
Eric Laurente1715a42014-05-20 11:30:42 -07004386 }
Eric Laurente1715a42014-05-20 11:30:42 -07004387
4388 return status;
Eric Laurent6a94d692014-05-20 11:18:06 -07004389}
4390
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004391void AudioPolicyManager::releaseResourcesForUid(uid_t uid)
4392{
Eric Laurentd60560a2015-04-10 11:31:20 -07004393 clearAudioSources(uid);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004394 clearAudioPatches(uid);
4395 clearSessionRoutes(uid);
4396}
4397
Eric Laurent6a94d692014-05-20 11:18:06 -07004398void AudioPolicyManager::clearAudioPatches(uid_t uid)
4399{
Eric Laurent0add0fd2014-12-04 18:58:14 -08004400 for (ssize_t i = (ssize_t)mAudioPatches.size() - 1; i >= 0; i--) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004401 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(i);
François Gaffieafd4cea2019-11-18 15:50:22 +01004402 if (patchDesc->getUid() == uid) {
Eric Laurent0add0fd2014-12-04 18:58:14 -08004403 releaseAudioPatch(mAudioPatches.keyAt(i), uid);
Eric Laurent6a94d692014-05-20 11:18:06 -07004404 }
4405 }
4406}
4407
François Gaffiec005e562018-11-06 15:04:49 +01004408void AudioPolicyManager::checkStrategyRoute(product_strategy_t ps, audio_io_handle_t ouptutToSkip)
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004409{
François Gaffiec005e562018-11-06 15:04:49 +01004410 // Take the first attributes following the product strategy as it is used to retrieve the routed
4411 // device. All attributes wihin a strategy follows the same "routing strategy"
4412 auto attributes = mEngine->getAllAttributesForProductStrategy(ps).front();
4413 DeviceVector devices = mEngine->getOutputDevicesForAttributes(attributes, nullptr, false);
François Gaffie11d30102018-11-02 16:09:09 +01004414 SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004415 for (size_t j = 0; j < mOutputs.size(); j++) {
4416 if (mOutputs.keyAt(j) == ouptutToSkip) {
4417 continue;
4418 }
4419 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(j);
François Gaffiec005e562018-11-06 15:04:49 +01004420 if (!outputDesc->isStrategyActive(ps)) {
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004421 continue;
4422 }
4423 // If the default device for this strategy is on another output mix,
4424 // invalidate all tracks in this strategy to force re connection.
4425 // Otherwise select new device on the output mix.
4426 if (outputs.indexOf(mOutputs.keyAt(j)) < 0) {
François Gaffiec005e562018-11-06 15:04:49 +01004427 for (auto stream : mEngine->getStreamTypesForProductStrategy(ps)) {
4428 mpClientInterface->invalidateStream(stream);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004429 }
4430 } else {
François Gaffie11d30102018-11-02 16:09:09 +01004431 setOutputDevices(
4432 outputDesc, getNewOutputDevices(outputDesc, false /*fromCache*/), false);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004433 }
4434 }
4435}
4436
4437void AudioPolicyManager::clearSessionRoutes(uid_t uid)
4438{
4439 // remove output routes associated with this uid
François Gaffiec005e562018-11-06 15:04:49 +01004440 std::vector<product_strategy_t> affectedStrategies;
Eric Laurent97ac8712018-07-27 18:59:02 -07004441 for (size_t i = 0; i < mOutputs.size(); i++) {
4442 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
Andy Hung39efb7a2018-09-26 15:39:28 -07004443 for (const auto& client : outputDesc->getClientIterable()) {
4444 if (client->hasPreferredDevice() && client->uid() == uid) {
4445 client->setPreferredDeviceId(AUDIO_PORT_HANDLE_NONE);
François Gaffiec005e562018-11-06 15:04:49 +01004446 auto clientStrategy = client->strategy();
4447 if (std::find(begin(affectedStrategies), end(affectedStrategies), clientStrategy) !=
4448 end(affectedStrategies)) {
4449 continue;
4450 }
4451 affectedStrategies.push_back(client->strategy());
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004452 }
4453 }
4454 }
4455 // reroute outputs if necessary
Mikhail Naganovcf84e592017-12-07 11:25:11 -08004456 for (const auto& strategy : affectedStrategies) {
4457 checkStrategyRoute(strategy, AUDIO_IO_HANDLE_NONE);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004458 }
4459
4460 // remove input routes associated with this uid
4461 SortedVector<audio_source_t> affectedSources;
Eric Laurent97ac8712018-07-27 18:59:02 -07004462 for (size_t i = 0; i < mInputs.size(); i++) {
4463 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(i);
Andy Hung39efb7a2018-09-26 15:39:28 -07004464 for (const auto& client : inputDesc->getClientIterable()) {
4465 if (client->hasPreferredDevice() && client->uid() == uid) {
4466 client->setPreferredDeviceId(AUDIO_PORT_HANDLE_NONE);
4467 affectedSources.add(client->source());
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004468 }
4469 }
4470 }
4471 // reroute inputs if necessary
4472 SortedVector<audio_io_handle_t> inputsToClose;
4473 for (size_t i = 0; i < mInputs.size(); i++) {
4474 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(i);
Eric Laurent4eb58f12018-12-07 16:41:02 -08004475 if (affectedSources.indexOf(inputDesc->source()) >= 0) {
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004476 inputsToClose.add(inputDesc->mIoHandle);
4477 }
4478 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08004479 for (const auto& input : inputsToClose) {
4480 closeInput(input);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004481 }
4482}
4483
Eric Laurentd60560a2015-04-10 11:31:20 -07004484void AudioPolicyManager::clearAudioSources(uid_t uid)
4485{
4486 for (ssize_t i = (ssize_t)mAudioSources.size() - 1; i >= 0; i--) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004487 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
4488 if (sourceDesc->uid() == uid) {
Eric Laurentd60560a2015-04-10 11:31:20 -07004489 stopAudioSource(mAudioSources.keyAt(i));
4490 }
4491 }
4492}
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004493
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07004494status_t AudioPolicyManager::acquireSoundTriggerSession(audio_session_t *session,
4495 audio_io_handle_t *ioHandle,
4496 audio_devices_t *device)
4497{
Glenn Kastenf0c6d7d2016-02-26 10:44:04 -08004498 *session = (audio_session_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
4499 *ioHandle = (audio_io_handle_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_INPUT);
Francois Gaffie716e1432019-01-14 16:58:59 +01004500 audio_attributes_t attr = { .source = AUDIO_SOURCE_HOTWORD };
François Gaffiec005e562018-11-06 15:04:49 +01004501 *device = mEngine->getInputDeviceForAttributes(attr)->type();
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07004502
François Gaffiedf372692015-03-19 10:43:27 +01004503 return mSoundTriggerSessions.acquireSession(*session, *ioHandle);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07004504}
4505
Eric Laurentd60560a2015-04-10 11:31:20 -07004506status_t AudioPolicyManager::startAudioSource(const struct audio_port_config *source,
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004507 const audio_attributes_t *attributes,
4508 audio_port_handle_t *portId,
4509 uid_t uid)
Eric Laurent554a2772015-04-10 11:29:24 -07004510{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004511 ALOGV("%s", __FUNCTION__);
4512 *portId = AUDIO_PORT_HANDLE_NONE;
4513
4514 if (source == NULL || attributes == NULL || portId == NULL) {
4515 ALOGW("%s invalid argument: source %p attributes %p handle %p",
4516 __FUNCTION__, source, attributes, portId);
Eric Laurentd60560a2015-04-10 11:31:20 -07004517 return BAD_VALUE;
4518 }
4519
Eric Laurentd60560a2015-04-10 11:31:20 -07004520 if (source->role != AUDIO_PORT_ROLE_SOURCE ||
4521 source->type != AUDIO_PORT_TYPE_DEVICE) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004522 ALOGW("%s INVALID_OPERATION source->role %d source->type %d",
4523 __FUNCTION__, source->role, source->type);
Eric Laurentd60560a2015-04-10 11:31:20 -07004524 return INVALID_OPERATION;
4525 }
4526
François Gaffie11d30102018-11-02 16:09:09 +01004527 sp<DeviceDescriptor> srcDevice =
Eric Laurentd60560a2015-04-10 11:31:20 -07004528 mAvailableInputDevices.getDevice(source->ext.device.type,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08004529 String8(source->ext.device.address),
4530 AUDIO_FORMAT_DEFAULT);
François Gaffie11d30102018-11-02 16:09:09 +01004531 if (srcDevice == 0) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004532 ALOGW("%s source->ext.device.type %08x not found", __FUNCTION__, source->ext.device.type);
Eric Laurentd60560a2015-04-10 11:31:20 -07004533 return BAD_VALUE;
4534 }
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004535
jiabin4ef93452019-09-10 14:29:54 -07004536 *portId = PolicyAudioPort::getNextUniqueId();
Eric Laurentd60560a2015-04-10 11:31:20 -07004537
François Gaffieaaac0fd2018-11-22 17:56:39 +01004538 sp<SourceClientDescriptor> sourceDesc =
François Gaffieafd4cea2019-11-18 15:50:22 +01004539 new SourceClientDescriptor(*portId, uid, *attributes, *source, srcDevice,
François Gaffieaaac0fd2018-11-22 17:56:39 +01004540 mEngine->getStreamTypeForAttributes(*attributes),
4541 mEngine->getProductStrategyForAttributes(*attributes),
4542 toVolumeSource(*attributes));
Eric Laurentd60560a2015-04-10 11:31:20 -07004543
4544 status_t status = connectAudioSource(sourceDesc);
4545 if (status == NO_ERROR) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004546 mAudioSources.add(*portId, sourceDesc);
Eric Laurentd60560a2015-04-10 11:31:20 -07004547 }
4548 return status;
4549}
4550
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004551status_t AudioPolicyManager::connectAudioSource(const sp<SourceClientDescriptor>& sourceDesc)
Eric Laurentd60560a2015-04-10 11:31:20 -07004552{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004553 ALOGV("%s handle %d", __FUNCTION__, sourceDesc->portId());
Eric Laurentd60560a2015-04-10 11:31:20 -07004554
4555 // make sure we only have one patch per source.
4556 disconnectAudioSource(sourceDesc);
4557
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004558 audio_attributes_t attributes = sourceDesc->attributes();
Francois Gaffiea0e5c992020-09-29 16:05:07 +02004559 // May the device (dynamic) have been disconnected/reconnected, id has changed.
4560 sp<DeviceDescriptor> srcDevice = mAvailableInputDevices.getDevice(
4561 sourceDesc->srcDevice()->type(),
4562 String8(sourceDesc->srcDevice()->address().c_str()),
4563 AUDIO_FORMAT_DEFAULT);
François Gaffiec005e562018-11-06 15:04:49 +01004564 DeviceVector sinkDevices =
Francois Gaffieff1eb522020-05-06 18:37:04 +02004565 mEngine->getOutputDevicesForAttributes(attributes, nullptr, false /*fromCache*/);
François Gaffiec005e562018-11-06 15:04:49 +01004566 ALOG_ASSERT(!sinkDevices.isEmpty(), "connectAudioSource(): no device found for attributes");
François Gaffie11d30102018-11-02 16:09:09 +01004567 sp<DeviceDescriptor> sinkDevice = sinkDevices.itemAt(0);
Francois Gaffiea0e5c992020-09-29 16:05:07 +02004568 if (!mAvailableOutputDevices.contains(sinkDevice)) {
4569 ALOGE("%s Device %s not available", __func__, sinkDevice->toString().c_str());
4570 return INVALID_OPERATION;
4571 }
François Gaffieafd4cea2019-11-18 15:50:22 +01004572 PatchBuilder patchBuilder;
4573 patchBuilder.addSink(sinkDevice).addSource(srcDevice);
4574 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
4575 status_t status =
4576 createAudioPatchInternal(patchBuilder.patch(), &handle, mUidCached, 0, sourceDesc);
4577 if (status != NO_ERROR || mAudioPatches.indexOfKey(handle) < 0) {
4578 ALOGW("%s patch panel could not connect device patch, error %d", __func__, status);
4579 return INVALID_OPERATION;
4580 }
Francois Gaffiea0e5c992020-09-29 16:05:07 +02004581 sourceDesc->connect(handle, sinkDevice);
François Gaffieafd4cea2019-11-18 15:50:22 +01004582 // SW Bridge? (@todo: HW bridge, keep track of HwOutput for device selection "reconsideration")
4583 sp<SwAudioOutputDescriptor> swOutput = sourceDesc->swOutput().promote();
4584 if (swOutput != 0) {
4585 status = swOutput->start();
Eric Laurent733ce942017-12-07 12:18:25 -08004586 if (status != NO_ERROR) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004587 goto FailureSourceAdded;
Eric Laurent733ce942017-12-07 12:18:25 -08004588 }
François Gaffieafd4cea2019-11-18 15:50:22 +01004589 if (swOutput->getClient(sourceDesc->portId()) != nullptr) {
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07004590 ALOGW("%s source portId has already been attached to outputDesc", __func__);
François Gaffieafd4cea2019-11-18 15:50:22 +01004591 goto FailureReleasePatch;
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07004592 }
François Gaffieafd4cea2019-11-18 15:50:22 +01004593 swOutput->addClient(sourceDesc);
Eric Laurentd60560a2015-04-10 11:31:20 -07004594 uint32_t delayMs = 0;
François Gaffieafd4cea2019-11-18 15:50:22 +01004595 status = startSource(swOutput, sourceDesc, &delayMs);
Eric Laurentd60560a2015-04-10 11:31:20 -07004596 if (status != NO_ERROR) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004597 ALOGW("%s failed to start source, error %d", __FUNCTION__, status);
4598 goto FailureSourceActive;
Eric Laurentd60560a2015-04-10 11:31:20 -07004599 }
Eric Laurentd60560a2015-04-10 11:31:20 -07004600 if (delayMs != 0) {
4601 usleep(delayMs * 1000);
4602 }
François Gaffieafd4cea2019-11-18 15:50:22 +01004603 } else {
4604 sp<HwAudioOutputDescriptor> hwOutputDesc = sourceDesc->hwOutput().promote();
4605 if (hwOutputDesc != 0) {
4606 // create Hwoutput and add to mHwOutputs
4607 } else {
4608 ALOGW("%s source has neither SW nor HW output", __FUNCTION__);
4609 }
Eric Laurentd60560a2015-04-10 11:31:20 -07004610 }
Eric Laurentd60560a2015-04-10 11:31:20 -07004611 return NO_ERROR;
François Gaffieafd4cea2019-11-18 15:50:22 +01004612
4613FailureSourceActive:
4614 swOutput->stop();
4615 releaseOutput(sourceDesc->portId());
4616FailureSourceAdded:
4617 sourceDesc->setSwOutput(nullptr);
4618FailureReleasePatch:
4619 releaseAudioPatchInternal(handle);
4620 return INVALID_OPERATION;
Eric Laurent554a2772015-04-10 11:29:24 -07004621}
4622
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004623status_t AudioPolicyManager::stopAudioSource(audio_port_handle_t portId)
Eric Laurent554a2772015-04-10 11:29:24 -07004624{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004625 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueFor(portId);
4626 ALOGV("%s port ID %d", __FUNCTION__, portId);
Eric Laurentd60560a2015-04-10 11:31:20 -07004627 if (sourceDesc == 0) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004628 ALOGW("%s unknown source for port ID %d", __FUNCTION__, portId);
Eric Laurentd60560a2015-04-10 11:31:20 -07004629 return BAD_VALUE;
4630 }
4631 status_t status = disconnectAudioSource(sourceDesc);
4632
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004633 mAudioSources.removeItem(portId);
Eric Laurentd60560a2015-04-10 11:31:20 -07004634 return status;
4635}
4636
Andy Hung2ddee192015-12-18 17:34:44 -08004637status_t AudioPolicyManager::setMasterMono(bool mono)
4638{
4639 if (mMasterMono == mono) {
4640 return NO_ERROR;
4641 }
4642 mMasterMono = mono;
4643 // if enabling mono we close all offloaded devices, which will invalidate the
4644 // corresponding AudioTrack. The AudioTrack client/MediaPlayer is responsible
4645 // for recreating the new AudioTrack as non-offloaded PCM.
4646 //
4647 // If disabling mono, we leave all tracks as is: we don't know which clients
4648 // and tracks are able to be recreated as offloaded. The next "song" should
4649 // play back offloaded.
4650 if (mMasterMono) {
4651 Vector<audio_io_handle_t> offloaded;
4652 for (size_t i = 0; i < mOutputs.size(); ++i) {
4653 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
4654 if (desc->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
4655 offloaded.push(desc->mIoHandle);
4656 }
4657 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08004658 for (const auto& handle : offloaded) {
4659 closeOutput(handle);
Andy Hung2ddee192015-12-18 17:34:44 -08004660 }
4661 }
4662 // update master mono for all remaining outputs
4663 for (size_t i = 0; i < mOutputs.size(); ++i) {
4664 updateMono(mOutputs.keyAt(i));
4665 }
4666 return NO_ERROR;
4667}
4668
4669status_t AudioPolicyManager::getMasterMono(bool *mono)
4670{
4671 *mono = mMasterMono;
4672 return NO_ERROR;
4673}
4674
Eric Laurentac9cef52017-06-09 15:46:26 -07004675float AudioPolicyManager::getStreamVolumeDB(
4676 audio_stream_type_t stream, int index, audio_devices_t device)
4677{
jiabin9a3361e2019-10-01 09:38:30 -07004678 return computeVolume(getVolumeCurves(stream), toVolumeSource(stream), index, {device});
Eric Laurentac9cef52017-06-09 15:46:26 -07004679}
4680
jiabin81772902018-04-02 17:52:27 -07004681status_t AudioPolicyManager::getSurroundFormats(unsigned int *numSurroundFormats,
4682 audio_format_t *surroundFormats,
Kriti Dang6537def2021-03-02 13:46:59 +01004683 bool *surroundFormatsEnabled)
jiabin81772902018-04-02 17:52:27 -07004684{
Kriti Dang6537def2021-03-02 13:46:59 +01004685 if (numSurroundFormats == nullptr || (*numSurroundFormats != 0 &&
4686 (surroundFormats == nullptr || surroundFormatsEnabled == nullptr))) {
jiabin81772902018-04-02 17:52:27 -07004687 return BAD_VALUE;
4688 }
Kriti Dang6537def2021-03-02 13:46:59 +01004689 ALOGV("%s() numSurroundFormats %d surroundFormats %p surroundFormatsEnabled %p",
4690 __func__, *numSurroundFormats, surroundFormats, surroundFormatsEnabled);
jiabin81772902018-04-02 17:52:27 -07004691
4692 size_t formatsWritten = 0;
4693 size_t formatsMax = *numSurroundFormats;
Kriti Dangef6be8f2020-11-05 11:58:19 +01004694
Kriti Dang6537def2021-03-02 13:46:59 +01004695 *numSurroundFormats = mConfig.getSurroundFormats().size();
Mikhail Naganov100f0122018-11-29 11:22:16 -08004696 audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
4697 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
Kriti Dang6537def2021-03-02 13:46:59 +01004698 for (const auto& format: mConfig.getSurroundFormats()) {
jiabin81772902018-04-02 17:52:27 -07004699 if (formatsWritten < formatsMax) {
Kriti Dang6537def2021-03-02 13:46:59 +01004700 surroundFormats[formatsWritten] = format.first;
Mikhail Naganov100f0122018-11-29 11:22:16 -08004701 bool formatEnabled = true;
4702 switch (forceUse) {
4703 case AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL:
Kriti Dang6537def2021-03-02 13:46:59 +01004704 formatEnabled = mManualSurroundFormats.count(format.first) != 0;
Mikhail Naganov100f0122018-11-29 11:22:16 -08004705 break;
4706 case AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER:
4707 formatEnabled = false;
4708 break;
4709 default: // AUTO or ALWAYS => true
4710 break;
jiabin81772902018-04-02 17:52:27 -07004711 }
4712 surroundFormatsEnabled[formatsWritten++] = formatEnabled;
4713 }
jiabin81772902018-04-02 17:52:27 -07004714 }
4715 return NO_ERROR;
4716}
4717
Kriti Dang6537def2021-03-02 13:46:59 +01004718status_t AudioPolicyManager::getReportedSurroundFormats(unsigned int *numSurroundFormats,
4719 audio_format_t *surroundFormats) {
4720 if (numSurroundFormats == nullptr || (*numSurroundFormats != 0 && surroundFormats == nullptr)) {
4721 return BAD_VALUE;
4722 }
4723 ALOGV("%s() numSurroundFormats %d surroundFormats %p",
4724 __func__, *numSurroundFormats, surroundFormats);
4725
4726 size_t formatsWritten = 0;
4727 size_t formatsMax = *numSurroundFormats;
4728 std::unordered_set<audio_format_t> formats; // Uses primary surround formats only
4729
4730 // Return formats from all device profiles that have already been resolved by
4731 // checkOutputsForDevice().
4732 for (size_t i = 0; i < mAvailableOutputDevices.size(); i++) {
4733 sp<DeviceDescriptor> device = mAvailableOutputDevices[i];
4734 audio_devices_t deviceType = device->type();
4735 // Enabling/disabling formats are applied to only HDMI devices. So, this function
4736 // returns formats reported by HDMI devices.
4737 if (deviceType != AUDIO_DEVICE_OUT_HDMI) {
4738 continue;
4739 }
4740 // Formats reported by sink devices
4741 std::unordered_set<audio_format_t> formatset;
4742 if (auto it = mReportedFormatsMap.find(device); it != mReportedFormatsMap.end()) {
4743 formatset.insert(it->second.begin(), it->second.end());
4744 }
4745
4746 // Formats hard-coded in the in policy configuration file (if any).
4747 FormatVector encodedFormats = device->encodedFormats();
4748 formatset.insert(encodedFormats.begin(), encodedFormats.end());
4749 // Filter the formats which are supported by the vendor hardware.
4750 for (auto it = formatset.begin(); it != formatset.end(); ++it) {
4751 if (mConfig.getSurroundFormats().count(*it) != 0) {
4752 formats.insert(*it);
4753 } else {
4754 for (const auto& pair : mConfig.getSurroundFormats()) {
4755 if (pair.second.count(*it) != 0) {
4756 formats.insert(pair.first);
4757 break;
4758 }
4759 }
4760 }
4761 }
4762 }
4763 *numSurroundFormats = formats.size();
4764 for (const auto& format: formats) {
4765 if (formatsWritten < formatsMax) {
4766 surroundFormats[formatsWritten++] = format;
4767 }
4768 }
4769 return NO_ERROR;
4770}
4771
jiabin81772902018-04-02 17:52:27 -07004772status_t AudioPolicyManager::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
4773{
Mikhail Naganov5dddbfd2018-09-11 14:15:05 -07004774 ALOGV("%s() format 0x%X enabled %d", __func__, audioFormat, enabled);
Mikhail Naganov778bc1f2018-09-14 16:28:52 -07004775 const auto& formatIter = mConfig.getSurroundFormats().find(audioFormat);
4776 if (formatIter == mConfig.getSurroundFormats().end()) {
Mikhail Naganov5dddbfd2018-09-11 14:15:05 -07004777 ALOGW("%s() format 0x%X is not a known surround format", __func__, audioFormat);
jiabin81772902018-04-02 17:52:27 -07004778 return BAD_VALUE;
4779 }
4780
Mikhail Naganov100f0122018-11-29 11:22:16 -08004781 if (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND) !=
4782 AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
Mikhail Naganov5dddbfd2018-09-11 14:15:05 -07004783 ALOGW("%s() not in manual mode for surround sound format selection", __func__);
jiabin81772902018-04-02 17:52:27 -07004784 return INVALID_OPERATION;
4785 }
4786
Mikhail Naganov100f0122018-11-29 11:22:16 -08004787 if ((mManualSurroundFormats.count(audioFormat) != 0) == enabled) {
jiabin81772902018-04-02 17:52:27 -07004788 return NO_ERROR;
4789 }
4790
Mikhail Naganov100f0122018-11-29 11:22:16 -08004791 std::unordered_set<audio_format_t> surroundFormatsBackup(mManualSurroundFormats);
jiabin81772902018-04-02 17:52:27 -07004792 if (enabled) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08004793 mManualSurroundFormats.insert(audioFormat);
Mikhail Naganov778bc1f2018-09-14 16:28:52 -07004794 for (const auto& subFormat : formatIter->second) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08004795 mManualSurroundFormats.insert(subFormat);
jiabin81772902018-04-02 17:52:27 -07004796 }
4797 } else {
Mikhail Naganov100f0122018-11-29 11:22:16 -08004798 mManualSurroundFormats.erase(audioFormat);
Mikhail Naganov778bc1f2018-09-14 16:28:52 -07004799 for (const auto& subFormat : formatIter->second) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08004800 mManualSurroundFormats.erase(subFormat);
jiabin81772902018-04-02 17:52:27 -07004801 }
4802 }
4803
4804 sp<SwAudioOutputDescriptor> outputDesc;
4805 bool profileUpdated = false;
jiabin9a3361e2019-10-01 09:38:30 -07004806 DeviceVector hdmiOutputDevices = mAvailableOutputDevices.getDevicesFromType(
4807 AUDIO_DEVICE_OUT_HDMI);
jiabin81772902018-04-02 17:52:27 -07004808 for (size_t i = 0; i < hdmiOutputDevices.size(); i++) {
4809 // Simulate reconnection to update enabled surround sound formats.
jiabince9f20e2019-09-12 16:29:15 -07004810 String8 address = String8(hdmiOutputDevices[i]->address().c_str());
jiabin5740f082019-08-19 15:08:30 -07004811 std::string name = hdmiOutputDevices[i]->getName();
jiabin81772902018-04-02 17:52:27 -07004812 status_t status = setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_HDMI,
4813 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
4814 address.c_str(),
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08004815 name.c_str(),
4816 AUDIO_FORMAT_DEFAULT);
jiabin81772902018-04-02 17:52:27 -07004817 if (status != NO_ERROR) {
4818 continue;
4819 }
4820 status = setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_HDMI,
4821 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
4822 address.c_str(),
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08004823 name.c_str(),
4824 AUDIO_FORMAT_DEFAULT);
jiabin81772902018-04-02 17:52:27 -07004825 profileUpdated |= (status == NO_ERROR);
4826 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08004827 // FIXME: Why doing this for input HDMI devices if we don't augment their reported formats?
jiabin9a3361e2019-10-01 09:38:30 -07004828 DeviceVector hdmiInputDevices = mAvailableInputDevices.getDevicesFromType(
jiabin81772902018-04-02 17:52:27 -07004829 AUDIO_DEVICE_IN_HDMI);
4830 for (size_t i = 0; i < hdmiInputDevices.size(); i++) {
4831 // Simulate reconnection to update enabled surround sound formats.
jiabince9f20e2019-09-12 16:29:15 -07004832 String8 address = String8(hdmiInputDevices[i]->address().c_str());
jiabin5740f082019-08-19 15:08:30 -07004833 std::string name = hdmiInputDevices[i]->getName();
jiabin81772902018-04-02 17:52:27 -07004834 status_t status = setDeviceConnectionStateInt(AUDIO_DEVICE_IN_HDMI,
4835 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
4836 address.c_str(),
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08004837 name.c_str(),
4838 AUDIO_FORMAT_DEFAULT);
jiabin81772902018-04-02 17:52:27 -07004839 if (status != NO_ERROR) {
4840 continue;
4841 }
4842 status = setDeviceConnectionStateInt(AUDIO_DEVICE_IN_HDMI,
4843 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
4844 address.c_str(),
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08004845 name.c_str(),
4846 AUDIO_FORMAT_DEFAULT);
jiabin81772902018-04-02 17:52:27 -07004847 profileUpdated |= (status == NO_ERROR);
4848 }
4849
jiabin81772902018-04-02 17:52:27 -07004850 if (!profileUpdated) {
Mikhail Naganov5dddbfd2018-09-11 14:15:05 -07004851 ALOGW("%s() no audio profiles updated, undoing surround formats change", __func__);
Mikhail Naganov100f0122018-11-29 11:22:16 -08004852 mManualSurroundFormats = std::move(surroundFormatsBackup);
jiabin81772902018-04-02 17:52:27 -07004853 }
4854
4855 return profileUpdated ? NO_ERROR : INVALID_OPERATION;
4856}
4857
Eric Laurent5ada82e2019-08-29 17:53:54 -07004858void AudioPolicyManager::setAppState(audio_port_handle_t portId, app_state_t state)
Svet Ganovf4ddfef2018-01-16 07:37:58 -08004859{
Eric Laurent5ada82e2019-08-29 17:53:54 -07004860 ALOGV("%s(portId:%d, state:%d)", __func__, portId, state);
Eric Laurenta9f86652018-11-28 17:23:11 -08004861 for (size_t i = 0; i < mInputs.size(); i++) {
Eric Laurent5ada82e2019-08-29 17:53:54 -07004862 mInputs.valueAt(i)->setAppState(portId, state);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08004863 }
4864}
4865
jiabin6012f912018-11-02 17:06:30 -07004866bool AudioPolicyManager::isHapticPlaybackSupported()
4867{
4868 for (const auto& hwModule : mHwModules) {
4869 const OutputProfileCollection &outputProfiles = hwModule->getOutputProfiles();
4870 for (const auto &outProfile : outputProfiles) {
4871 struct audio_port audioPort;
4872 outProfile->toAudioPort(&audioPort);
4873 for (size_t i = 0; i < audioPort.num_channel_masks; i++) {
4874 if (audioPort.channel_masks[i] & AUDIO_CHANNEL_HAPTIC_ALL) {
4875 return true;
4876 }
4877 }
4878 }
4879 }
4880 return false;
4881}
4882
Eric Laurent8340e672019-11-06 11:01:08 -08004883bool AudioPolicyManager::isCallScreenModeSupported()
4884{
4885 return getConfig().isCallScreenModeSupported();
4886}
4887
4888
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004889status_t AudioPolicyManager::disconnectAudioSource(const sp<SourceClientDescriptor>& sourceDesc)
Eric Laurentd60560a2015-04-10 11:31:20 -07004890{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004891 ALOGV("%s port Id %d", __FUNCTION__, sourceDesc->portId());
Francois Gaffiea0e5c992020-09-29 16:05:07 +02004892 if (!sourceDesc->isConnected()) {
4893 ALOGV("%s port Id %d already disconnected", __FUNCTION__, sourceDesc->portId());
4894 return NO_ERROR;
4895 }
François Gaffieafd4cea2019-11-18 15:50:22 +01004896 sp<SwAudioOutputDescriptor> swOutput = sourceDesc->swOutput().promote();
4897 if (swOutput != 0) {
4898 status_t status = stopSource(swOutput, sourceDesc);
Eric Laurent733ce942017-12-07 12:18:25 -08004899 if (status == NO_ERROR) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004900 swOutput->stop();
Eric Laurent733ce942017-12-07 12:18:25 -08004901 }
jiabinbce0c1d2020-10-05 11:20:18 -07004902 if (releaseOutput(sourceDesc->portId())) {
4903 // The output descriptor is reopened to query dynamic profiles. In that case, there is
4904 // no need to release audio patch here but just return NO_ERROR.
4905 return NO_ERROR;
4906 }
Eric Laurentd60560a2015-04-10 11:31:20 -07004907 } else {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004908 sp<HwAudioOutputDescriptor> hwOutputDesc = sourceDesc->hwOutput().promote();
Eric Laurentd60560a2015-04-10 11:31:20 -07004909 if (hwOutputDesc != 0) {
Eric Laurentd60560a2015-04-10 11:31:20 -07004910 // close Hwoutput and remove from mHwOutputs
4911 } else {
4912 ALOGW("%s source has neither SW nor HW output", __FUNCTION__);
4913 }
4914 }
Francois Gaffiea0e5c992020-09-29 16:05:07 +02004915 status_t status = releaseAudioPatchInternal(sourceDesc->getPatchHandle());
4916 sourceDesc->disconnect();
4917 return status;
Eric Laurentd60560a2015-04-10 11:31:20 -07004918}
4919
François Gaffiec005e562018-11-06 15:04:49 +01004920sp<SourceClientDescriptor> AudioPolicyManager::getSourceForAttributesOnOutput(
4921 audio_io_handle_t output, const audio_attributes_t &attr)
Eric Laurentd60560a2015-04-10 11:31:20 -07004922{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004923 sp<SourceClientDescriptor> source;
Eric Laurentd60560a2015-04-10 11:31:20 -07004924 for (size_t i = 0; i < mAudioSources.size(); i++) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004925 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004926 sp<SwAudioOutputDescriptor> outputDesc = sourceDesc->swOutput().promote();
François Gaffiec005e562018-11-06 15:04:49 +01004927 if (followsSameRouting(attr, sourceDesc->attributes()) &&
4928 outputDesc != 0 && outputDesc->mIoHandle == output) {
Eric Laurentd60560a2015-04-10 11:31:20 -07004929 source = sourceDesc;
4930 break;
4931 }
4932 }
4933 return source;
Eric Laurent554a2772015-04-10 11:29:24 -07004934}
4935
Eric Laurent39095982021-08-24 18:29:27 +02004936/* static */
4937bool AudioPolicyManager::isChannelMaskSpatialized(audio_channel_mask_t channels) {
4938 switch (channels) {
4939 case AUDIO_CHANNEL_OUT_5POINT1:
4940 case AUDIO_CHANNEL_OUT_5POINT1POINT2:
4941 case AUDIO_CHANNEL_OUT_5POINT1POINT4:
4942 case AUDIO_CHANNEL_OUT_7POINT1:
4943 case AUDIO_CHANNEL_OUT_7POINT1POINT2:
4944 case AUDIO_CHANNEL_OUT_7POINT1POINT4:
4945 return true;
4946 default:
4947 return false;
4948 }
4949}
4950
Eric Laurentfa0f6742021-08-17 18:39:44 +02004951bool AudioPolicyManager::canBeSpatialized(const audio_attributes_t *attr,
Eric Laurentcad6c0d2021-07-13 15:12:39 +02004952 const audio_config_t *config,
4953 const AudioDeviceTypeAddrVector &devices) const
4954{
4955 // The caller can have the audio attributes criteria ignored by either passing a null ptr or
4956 // the AUDIO_ATTRIBUTES_INITIALIZER value.
Eric Laurentfa0f6742021-08-17 18:39:44 +02004957 // If attributes are specified, current policy is to only allow spatialization for media
Eric Laurentcad6c0d2021-07-13 15:12:39 +02004958 // and game usages.
Eric Laurent39095982021-08-24 18:29:27 +02004959 if (attr != nullptr && *attr != AUDIO_ATTRIBUTES_INITIALIZER) {
4960 if (attr->usage != AUDIO_USAGE_MEDIA && attr->usage != AUDIO_USAGE_GAME) {
4961 return false;
4962 }
4963 if ((attr->flags & (AUDIO_FLAG_CONTENT_SPATIALIZED | AUDIO_FLAG_NEVER_SPATIALIZE)) != 0) {
4964 return false;
4965 }
Eric Laurentcad6c0d2021-07-13 15:12:39 +02004966 }
4967
4968 // The caller can have the devices criteria ignored by passing and empty vector, and
Eric Laurentfa0f6742021-08-17 18:39:44 +02004969 // getSpatializerOutputProfile() will ignore the devices when looking for a match.
4970 // Otherwise an output profile supporting a spatializer effect that can be routed
Eric Laurentcad6c0d2021-07-13 15:12:39 +02004971 // to the specified devices must exist.
4972 sp<IOProfile> profile =
Eric Laurent39095982021-08-24 18:29:27 +02004973 getSpatializerOutputProfile(config, devices);
Eric Laurentcad6c0d2021-07-13 15:12:39 +02004974 if (profile == nullptr) {
4975 return false;
4976 }
4977
4978 // The caller can have the audio config criteria ignored by either passing a null ptr or
4979 // the AUDIO_CONFIG_INITIALIZER value.
Eric Laurentfa0f6742021-08-17 18:39:44 +02004980 // If an audio config is specified, current policy is to only allow spatialization for
Eric Laurent39095982021-08-24 18:29:27 +02004981 // some positional channel masks.
Eric Laurentfa0f6742021-08-17 18:39:44 +02004982 // If the spatializer output is already opened, only channel masks included in the
4983 // spatializer output mixer channel mask are allowed.
Eric Laurent39095982021-08-24 18:29:27 +02004984
Eric Laurentcad6c0d2021-07-13 15:12:39 +02004985 if (config != nullptr && *config != AUDIO_CONFIG_INITIALIZER) {
Eric Laurent39095982021-08-24 18:29:27 +02004986 if (!isChannelMaskSpatialized(config->channel_mask)) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02004987 return false;
4988 }
Eric Laurent39095982021-08-24 18:29:27 +02004989 if (mSpatializerOutput != nullptr && mSpatializerOutput->mProfile == profile) {
Eric Laurentfa0f6742021-08-17 18:39:44 +02004990 if ((config->channel_mask & mSpatializerOutput->mMixerChannelMask)
Eric Laurentcad6c0d2021-07-13 15:12:39 +02004991 != config->channel_mask) {
4992 return false;
4993 }
4994 }
4995 }
Eric Laurentcad6c0d2021-07-13 15:12:39 +02004996 return true;
4997}
4998
4999void AudioPolicyManager::checkVirtualizerClientRoutes() {
5000 std::set<audio_stream_type_t> streamsToInvalidate;
5001 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurent39095982021-08-24 18:29:27 +02005002 const sp<SwAudioOutputDescriptor>& desc = mOutputs[i];
5003 for (const sp<TrackClientDescriptor>& client : desc->getClientIterable()) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005004 audio_attributes_t attr = client->attributes();
5005 DeviceVector devices = mEngine->getOutputDevicesForAttributes(attr, nullptr, false);
5006 AudioDeviceTypeAddrVector devicesTypeAddress = devices.toTypeAddrVector();
5007 audio_config_base_t clientConfig = client->config();
5008 audio_config_t config = audio_config_initializer(&clientConfig);
Eric Laurent39095982021-08-24 18:29:27 +02005009 if (desc != mSpatializerOutput
5010 && canBeSpatialized(&attr, &config, devicesTypeAddress)) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005011 streamsToInvalidate.insert(client->stream());
5012 }
5013 }
5014 }
5015
5016 for (audio_stream_type_t stream : streamsToInvalidate) {
5017 mpClientInterface->invalidateStream(stream);
5018 }
5019}
5020
Eric Laurentfa0f6742021-08-17 18:39:44 +02005021status_t AudioPolicyManager::getSpatializerOutput(const audio_config_base_t *mixerConfig,
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005022 const audio_attributes_t *attr,
5023 audio_io_handle_t *output) {
5024 *output = AUDIO_IO_HANDLE_NONE;
5025
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005026 DeviceVector devices = mEngine->getOutputDevicesForAttributes(*attr, nullptr, false);
5027 AudioDeviceTypeAddrVector devicesTypeAddress = devices.toTypeAddrVector();
5028 audio_config_t *configPtr = nullptr;
5029 audio_config_t config;
5030 if (mixerConfig != nullptr) {
5031 config = audio_config_initializer(mixerConfig);
5032 configPtr = &config;
5033 }
Eric Laurentfa0f6742021-08-17 18:39:44 +02005034 if (!canBeSpatialized(attr, configPtr, devicesTypeAddress)) {
Eric Laurent39095982021-08-24 18:29:27 +02005035 ALOGW("%s provided attributes or mixer config cannot be spatialized", __func__);
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005036 return BAD_VALUE;
5037 }
5038
5039 sp<IOProfile> profile =
Eric Laurent39095982021-08-24 18:29:27 +02005040 getSpatializerOutputProfile(configPtr, devicesTypeAddress);
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005041 if (profile == nullptr) {
Eric Laurent39095982021-08-24 18:29:27 +02005042 ALOGW("%s no suitable output profile for provided attributes or mixer config", __func__);
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005043 return BAD_VALUE;
5044 }
5045
Eric Laurent39095982021-08-24 18:29:27 +02005046 if (mSpatializerOutput != nullptr && mSpatializerOutput->mProfile == profile
5047 && configPtr != nullptr
5048 && configPtr->channel_mask == mSpatializerOutput->mMixerChannelMask) {
5049 *output = mSpatializerOutput->mIoHandle;
5050 ALOGV("%s returns current spatializer output %d", __func__, *output);
5051 return NO_ERROR;
5052 }
5053 mSpatializerOutput.clear();
5054 for (size_t i = 0; i < mOutputs.size(); i++) {
5055 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
5056 if (!desc->isDuplicated() && desc->mProfile == profile) {
5057 mSpatializerOutput = desc;
5058 break;
5059 }
5060 }
5061 if (mSpatializerOutput == nullptr) {
5062 ALOGW("%s no opened spatializer output for profile %s",
5063 __func__, profile->getName().c_str());
5064 return BAD_VALUE;
5065 }
5066
5067 if (configPtr != nullptr
5068 && configPtr->channel_mask != mSpatializerOutput->mMixerChannelMask) {
5069 audio_config_base_t savedMixerConfig = {
5070 .sample_rate = mSpatializerOutput->getSamplingRate(),
5071 .format = mSpatializerOutput->getFormat(),
5072 .channel_mask = mSpatializerOutput->mMixerChannelMask,
5073 };
5074 DeviceVector savedDevices = mSpatializerOutput->devices();
5075
5076 closeOutput(mSpatializerOutput->mIoHandle);
5077 mSpatializerOutput.clear();
5078
5079 const sp<SwAudioOutputDescriptor> desc =
5080 new SwAudioOutputDescriptor(profile, mpClientInterface);
5081 status_t status = desc->open(nullptr, mixerConfig, devices,
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005082 mEngine->getStreamTypeForAttributes(*attr),
Eric Laurent1c5e2e32021-08-18 18:50:28 +02005083 AUDIO_OUTPUT_FLAG_SPATIALIZER, output);
Eric Laurent39095982021-08-24 18:29:27 +02005084 if (status != NO_ERROR) {
5085 ALOGW("%s failed opening output: status %d, output %d", __func__, status, *output);
5086 if (*output != AUDIO_IO_HANDLE_NONE) {
5087 desc->close();
5088 }
5089 // re open the spatializer output with previous channel mask
5090 status_t newStatus = desc->open(nullptr, &savedMixerConfig, savedDevices,
5091 mEngine->getStreamTypeForAttributes(*attr),
5092 AUDIO_OUTPUT_FLAG_SPATIALIZER, output);
5093 if (newStatus != NO_ERROR) {
5094 if (*output != AUDIO_IO_HANDLE_NONE) {
5095 desc->close();
5096 }
5097 ALOGE("%s failed to re-open mSpatializerOutput, status %d", __func__, newStatus);
5098 } else {
5099 mSpatializerOutput = desc;
5100 addOutput(*output, desc);
5101 }
5102 mPreviousOutputs = mOutputs;
5103 mpClientInterface->onAudioPortListUpdate();
5104 *output = AUDIO_IO_HANDLE_NONE;
5105 return status;
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005106 }
Eric Laurent39095982021-08-24 18:29:27 +02005107 mSpatializerOutput = desc;
5108 addOutput(*output, desc);
5109 mPreviousOutputs = mOutputs;
5110 mpClientInterface->onAudioPortListUpdate();
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005111 }
5112
5113 checkVirtualizerClientRoutes();
5114
Eric Laurent39095982021-08-24 18:29:27 +02005115 *output = mSpatializerOutput->mIoHandle;
Eric Laurentfa0f6742021-08-17 18:39:44 +02005116 ALOGV("%s returns new spatializer output %d", __func__, *output);
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005117 return NO_ERROR;
5118}
5119
Eric Laurentfa0f6742021-08-17 18:39:44 +02005120status_t AudioPolicyManager::releaseSpatializerOutput(audio_io_handle_t output) {
5121 if (mSpatializerOutput == nullptr) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005122 return INVALID_OPERATION;
5123 }
Eric Laurentfa0f6742021-08-17 18:39:44 +02005124 if (mSpatializerOutput->mIoHandle != output) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005125 return BAD_VALUE;
5126 }
Eric Laurent39095982021-08-24 18:29:27 +02005127
Eric Laurentfa0f6742021-08-17 18:39:44 +02005128 mSpatializerOutput.clear();
Eric Laurent39095982021-08-24 18:29:27 +02005129
5130 checkVirtualizerClientRoutes();
5131
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005132 return NO_ERROR;
5133}
5134
Eric Laurente552edb2014-03-10 17:42:56 -07005135// ----------------------------------------------------------------------------
Eric Laurente0720872014-03-11 09:30:41 -07005136// AudioPolicyManager
Eric Laurente552edb2014-03-10 17:42:56 -07005137// ----------------------------------------------------------------------------
Eric Laurent6a94d692014-05-20 11:18:06 -07005138uint32_t AudioPolicyManager::nextAudioPortGeneration()
5139{
Mikhail Naganov2773dd72017-12-08 10:12:11 -08005140 return mAudioPortGeneration++;
Eric Laurent6a94d692014-05-20 11:18:06 -07005141}
5142
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +09005143static status_t deserializeAudioPolicyXmlConfig(AudioPolicyConfig &config) {
Mikhail Naganov946c0032020-10-21 13:04:58 -07005144 if (std::string audioPolicyXmlConfigFile = audio_get_audio_policy_config_file();
5145 !audioPolicyXmlConfigFile.empty()) {
5146 status_t ret = deserializeAudioPolicyFile(audioPolicyXmlConfigFile.c_str(), &config);
5147 if (ret == NO_ERROR) {
5148 config.setSource(audioPolicyXmlConfigFile);
Cheney Ni6851adb2018-11-01 06:30:37 +08005149 }
Mikhail Naganov946c0032020-10-21 13:04:58 -07005150 return ret;
Petri Gyntherf497f292018-04-17 18:46:10 -07005151 }
Mikhail Naganov946c0032020-10-21 13:04:58 -07005152 return BAD_VALUE;
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +09005153}
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +09005154
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005155AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface,
5156 bool /*forTesting*/)
Eric Laurente552edb2014-03-10 17:42:56 -07005157 :
Andy Hung4ef19fa2018-05-15 19:35:29 -07005158 mUidCached(AID_AUDIOSERVER), // no need to call getuid(), there's only one of us running.
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005159 mpClientInterface(clientInterface),
Eric Laurente552edb2014-03-10 17:42:56 -07005160 mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f),
Eric Laurent3a4311c2014-03-17 12:00:47 -07005161 mA2dpSuspended(false),
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005162 mConfig(mHwModulesAll, mOutputDevicesAll, mInputDevicesAll, mDefaultOutputDevice),
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07005163 mAudioPortGeneration(1),
5164 mBeaconMuteRefCount(0),
5165 mBeaconPlayingRefCount(0),
Eric Laurent9459fb02015-08-12 18:36:32 -07005166 mBeaconMuted(false),
Andy Hung2ddee192015-12-18 17:34:44 -08005167 mTtsOutputAvailable(false),
Eric Laurent36829f92017-04-07 19:04:42 -07005168 mMasterMono(false),
Eric Laurent4eb58f12018-12-07 16:41:02 -08005169 mMusicEffectOutput(AUDIO_IO_HANDLE_NONE)
Eric Laurente552edb2014-03-10 17:42:56 -07005170{
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005171}
François Gaffied1ab2bd2015-12-02 18:20:06 +01005172
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005173AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface)
5174 : AudioPolicyManager(clientInterface, false /*forTesting*/)
5175{
5176 loadConfig();
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005177}
François Gaffied1ab2bd2015-12-02 18:20:06 +01005178
Kevin Rocarddfa1e8a2018-10-26 16:42:07 -07005179void AudioPolicyManager::loadConfig() {
5180 if (deserializeAudioPolicyXmlConfig(getConfig()) != NO_ERROR) {
François Gaffied1ab2bd2015-12-02 18:20:06 +01005181 ALOGE("could not load audio policy configuration file, setting defaults");
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005182 getConfig().setDefault();
François Gaffied1ab2bd2015-12-02 18:20:06 +01005183 }
Eric Laurentfa0f6742021-08-17 18:39:44 +02005184 //TODO: b/193496180 use spatializer flag at audio HAL when available
5185 getConfig().convertSpatializerFlag();
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005186}
5187
5188status_t AudioPolicyManager::initialize() {
Mikhail Naganov47835552019-05-14 10:32:51 -07005189 {
5190 auto engLib = EngineLibrary::load(
5191 "libaudiopolicyengine" + getConfig().getEngineLibraryNameSuffix() + ".so");
5192 if (!engLib) {
5193 ALOGE("%s: Failed to load the engine library", __FUNCTION__);
5194 return NO_INIT;
5195 }
5196 mEngine = engLib->createEngine();
5197 if (mEngine == nullptr) {
5198 ALOGE("%s: Failed to instantiate the APM engine", __FUNCTION__);
5199 return NO_INIT;
5200 }
François Gaffie2110e042015-03-24 08:41:51 +01005201 }
5202 mEngine->setObserver(this);
5203 status_t status = mEngine->initCheck();
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005204 if (status != NO_ERROR) {
5205 LOG_FATAL("Policy engine not initialized(err=%d)", status);
5206 return status;
5207 }
François Gaffie2110e042015-03-24 08:41:51 +01005208
Eric Laurent1d69c872021-01-11 18:53:01 +01005209 mCommunnicationStrategy = mEngine->getProductStrategyForAttributes(
5210 mEngine->getAttributesForStreamType(AUDIO_STREAM_VOICE_CALL));
5211
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005212 // after parsing the config, mOutputDevicesAll and mInputDevicesAll contain all known devices;
Eric Laurente552edb2014-03-10 17:42:56 -07005213 // open all output streams needed to access attached devices
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07005214 onNewAudioModulesAvailableInt(nullptr /*newDevices*/);
François Gaffie11d30102018-11-02 16:09:09 +01005215
Eric Laurent3a4311c2014-03-17 12:00:47 -07005216 // make sure default device is reachable
François Gaffie11d30102018-11-02 16:09:09 +01005217 if (mDefaultOutputDevice == 0 || !mAvailableOutputDevices.contains(mDefaultOutputDevice)) {
5218 ALOGE_IF(mDefaultOutputDevice != 0, "Default device %s is unreachable",
5219 mDefaultOutputDevice->toString().c_str());
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005220 status = NO_INIT;
Eric Laurent3a4311c2014-03-17 12:00:47 -07005221 }
jiabin9ff780e2018-03-19 18:19:52 -07005222 // If microphones address is empty, set it according to device type
Eric Laurent736a1022019-03-27 18:28:46 -07005223 for (size_t i = 0; i < mAvailableInputDevices.size(); i++) {
jiabince9f20e2019-09-12 16:29:15 -07005224 if (mAvailableInputDevices[i]->address().empty()) {
jiabin9ff780e2018-03-19 18:19:52 -07005225 if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_BUILTIN_MIC) {
jiabince9f20e2019-09-12 16:29:15 -07005226 mAvailableInputDevices[i]->setAddress(AUDIO_BOTTOM_MICROPHONE_ADDRESS);
jiabin9ff780e2018-03-19 18:19:52 -07005227 } else if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_BACK_MIC) {
jiabince9f20e2019-09-12 16:29:15 -07005228 mAvailableInputDevices[i]->setAddress(AUDIO_BACK_MICROPHONE_ADDRESS);
jiabin9ff780e2018-03-19 18:19:52 -07005229 }
5230 }
5231 }
Eric Laurente552edb2014-03-10 17:42:56 -07005232
Francois Gaffiebce7cd42020-10-14 16:13:20 +02005233 ALOGW_IF(mPrimaryOutput == nullptr, "The policy configuration does not declare a primary output");
Eric Laurente552edb2014-03-10 17:42:56 -07005234
Tomoharu Kasahara71c90912018-10-31 09:10:12 +09005235 // Silence ALOGV statements
5236 property_set("log.tag." LOG_TAG, "D");
5237
Eric Laurente552edb2014-03-10 17:42:56 -07005238 updateDevicesAndOutputs();
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005239 return status;
Eric Laurente552edb2014-03-10 17:42:56 -07005240}
5241
Eric Laurente0720872014-03-11 09:30:41 -07005242AudioPolicyManager::~AudioPolicyManager()
Eric Laurente552edb2014-03-10 17:42:56 -07005243{
Eric Laurente552edb2014-03-10 17:42:56 -07005244 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentfe231122017-11-17 17:48:06 -08005245 mOutputs.valueAt(i)->close();
Eric Laurente552edb2014-03-10 17:42:56 -07005246 }
5247 for (size_t i = 0; i < mInputs.size(); i++) {
Eric Laurentfe231122017-11-17 17:48:06 -08005248 mInputs.valueAt(i)->close();
Eric Laurente552edb2014-03-10 17:42:56 -07005249 }
Eric Laurent3a4311c2014-03-17 12:00:47 -07005250 mAvailableOutputDevices.clear();
5251 mAvailableInputDevices.clear();
Eric Laurent1f2f2232014-06-02 12:01:23 -07005252 mOutputs.clear();
5253 mInputs.clear();
5254 mHwModules.clear();
Mikhail Naganovd4120142017-12-06 15:49:22 -08005255 mHwModulesAll.clear();
Mikhail Naganov100f0122018-11-29 11:22:16 -08005256 mManualSurroundFormats.clear();
Eric Laurente552edb2014-03-10 17:42:56 -07005257}
5258
Eric Laurente0720872014-03-11 09:30:41 -07005259status_t AudioPolicyManager::initCheck()
Eric Laurente552edb2014-03-10 17:42:56 -07005260{
Eric Laurent87ffa392015-05-22 10:32:38 -07005261 return hasPrimaryOutput() ? NO_ERROR : NO_INIT;
Eric Laurente552edb2014-03-10 17:42:56 -07005262}
5263
Eric Laurente552edb2014-03-10 17:42:56 -07005264// ---
5265
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005266void AudioPolicyManager::onNewAudioModulesAvailable()
5267{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07005268 DeviceVector newDevices;
5269 onNewAudioModulesAvailableInt(&newDevices);
5270 if (!newDevices.empty()) {
5271 nextAudioPortGeneration();
5272 mpClientInterface->onAudioPortListUpdate();
5273 }
5274}
5275
5276void AudioPolicyManager::onNewAudioModulesAvailableInt(DeviceVector *newDevices)
5277{
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005278 for (const auto& hwModule : mHwModulesAll) {
5279 if (std::find(mHwModules.begin(), mHwModules.end(), hwModule) != mHwModules.end()) {
5280 continue;
5281 }
5282 hwModule->setHandle(mpClientInterface->loadHwModule(hwModule->getName()));
5283 if (hwModule->getHandle() == AUDIO_MODULE_HANDLE_NONE) {
5284 ALOGW("could not open HW module %s", hwModule->getName());
5285 continue;
5286 }
5287 mHwModules.push_back(hwModule);
Dean Wheatley12a87132021-04-16 10:08:49 +10005288 // open all output streams needed to access attached devices.
5289 // direct outputs are closed immediately after checking the availability of attached devices
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005290 // This also validates mAvailableOutputDevices list
5291 for (const auto& outProfile : hwModule->getOutputProfiles()) {
5292 if (!outProfile->canOpenNewIo()) {
5293 ALOGE("Invalid Output profile max open count %u for profile %s",
5294 outProfile->maxOpenCount, outProfile->getTagName().c_str());
5295 continue;
5296 }
5297 if (!outProfile->hasSupportedDevices()) {
5298 ALOGW("Output profile contains no device on module %s", hwModule->getName());
5299 continue;
5300 }
5301 if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_TTS) != 0) {
5302 mTtsOutputAvailable = true;
5303 }
5304
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005305 const DeviceVector &supportedDevices = outProfile->getSupportedDevices();
5306 DeviceVector availProfileDevices = supportedDevices.filter(mOutputDevicesAll);
5307 sp<DeviceDescriptor> supportedDevice = 0;
5308 if (supportedDevices.contains(mDefaultOutputDevice)) {
5309 supportedDevice = mDefaultOutputDevice;
5310 } else {
5311 // choose first device present in profile's SupportedDevices also part of
5312 // mAvailableOutputDevices.
5313 if (availProfileDevices.isEmpty()) {
5314 continue;
5315 }
5316 supportedDevice = availProfileDevices.itemAt(0);
5317 }
5318 if (!mOutputDevicesAll.contains(supportedDevice)) {
5319 continue;
5320 }
5321 sp<SwAudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(outProfile,
5322 mpClientInterface);
5323 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
Eric Laurentf1f22e72021-07-13 14:04:14 +02005324 status_t status = outputDesc->open(nullptr /* halConfig */, nullptr /* mixerConfig */,
5325 DeviceVector(supportedDevice),
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005326 AUDIO_STREAM_DEFAULT,
5327 AUDIO_OUTPUT_FLAG_NONE, &output);
5328 if (status != NO_ERROR) {
5329 ALOGW("Cannot open output stream for devices %s on hw module %s",
5330 supportedDevice->toString().c_str(), hwModule->getName());
5331 continue;
5332 }
5333 for (const auto &device : availProfileDevices) {
5334 // give a valid ID to an attached device once confirmed it is reachable
5335 if (!device->isAttached()) {
5336 device->attach(hwModule);
5337 mAvailableOutputDevices.add(device);
jiabin1c4794b2020-05-05 10:08:05 -07005338 device->setEncapsulationInfoFromHal(mpClientInterface);
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07005339 if (newDevices) newDevices->add(device);
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005340 setEngineDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
5341 }
5342 }
Francois Gaffiebce7cd42020-10-14 16:13:20 +02005343 if (mPrimaryOutput == nullptr &&
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005344 outProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
5345 mPrimaryOutput = outputDesc;
5346 }
Eric Laurent39095982021-08-24 18:29:27 +02005347 if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_DIRECT) != 0) {
Eric Laurentc529cf62020-04-17 18:19:10 -07005348 outputDesc->close();
5349 } else {
5350 addOutput(output, outputDesc);
5351 setOutputDevices(outputDesc,
5352 DeviceVector(supportedDevice),
5353 true,
5354 0,
5355 NULL);
5356 }
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005357 }
5358 // open input streams needed to access attached devices to validate
5359 // mAvailableInputDevices list
5360 for (const auto& inProfile : hwModule->getInputProfiles()) {
5361 if (!inProfile->canOpenNewIo()) {
5362 ALOGE("Invalid Input profile max open count %u for profile %s",
5363 inProfile->maxOpenCount, inProfile->getTagName().c_str());
5364 continue;
5365 }
5366 if (!inProfile->hasSupportedDevices()) {
5367 ALOGW("Input profile contains no device on module %s", hwModule->getName());
5368 continue;
5369 }
5370 // chose first device present in profile's SupportedDevices also part of
5371 // available input devices
5372 const DeviceVector &supportedDevices = inProfile->getSupportedDevices();
5373 DeviceVector availProfileDevices = supportedDevices.filter(mInputDevicesAll);
5374 if (availProfileDevices.isEmpty()) {
Eric Laurentfecbceb2021-02-09 14:46:43 +01005375 ALOGV("%s: Input device list is empty! for profile %s",
5376 __func__, inProfile->getTagName().c_str());
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005377 continue;
5378 }
5379 sp<AudioInputDescriptor> inputDesc =
5380 new AudioInputDescriptor(inProfile, mpClientInterface);
5381
5382 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
5383 status_t status = inputDesc->open(nullptr,
5384 availProfileDevices.itemAt(0),
5385 AUDIO_SOURCE_MIC,
5386 AUDIO_INPUT_FLAG_NONE,
5387 &input);
5388 if (status != NO_ERROR) {
5389 ALOGW("Cannot open input stream for device %s on hw module %s",
5390 availProfileDevices.toString().c_str(),
5391 hwModule->getName());
5392 continue;
5393 }
5394 for (const auto &device : availProfileDevices) {
5395 // give a valid ID to an attached device once confirmed it is reachable
5396 if (!device->isAttached()) {
5397 device->attach(hwModule);
5398 device->importAudioPortAndPickAudioProfile(inProfile, true);
5399 mAvailableInputDevices.add(device);
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07005400 if (newDevices) newDevices->add(device);
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005401 setEngineDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
5402 }
5403 }
5404 inputDesc->close();
5405 }
5406 }
5407}
5408
Eric Laurent98e38192018-02-15 18:31:53 -08005409void AudioPolicyManager::addOutput(audio_io_handle_t output,
5410 const sp<SwAudioOutputDescriptor>& outputDesc)
Eric Laurente552edb2014-03-10 17:42:56 -07005411{
Eric Laurent1c333e22014-05-20 10:48:17 -07005412 mOutputs.add(output, outputDesc);
jiabin9a3361e2019-10-01 09:38:30 -07005413 applyStreamVolumes(outputDesc, DeviceTypeSet(), 0 /* delayMs */, true /* force */);
Andy Hung2ddee192015-12-18 17:34:44 -08005414 updateMono(output); // update mono status when adding to output list
Eric Laurent36829f92017-04-07 19:04:42 -07005415 selectOutputForMusicEffects();
Eric Laurent6a94d692014-05-20 11:18:06 -07005416 nextAudioPortGeneration();
Eric Laurente552edb2014-03-10 17:42:56 -07005417}
5418
François Gaffie53615e22015-03-19 09:24:12 +01005419void AudioPolicyManager::removeOutput(audio_io_handle_t output)
5420{
Francois Gaffiebce7cd42020-10-14 16:13:20 +02005421 if (mPrimaryOutput != 0 && mPrimaryOutput == mOutputs.valueFor(output)) {
5422 ALOGV("%s: removing primary output", __func__);
5423 mPrimaryOutput = nullptr;
5424 }
François Gaffie53615e22015-03-19 09:24:12 +01005425 mOutputs.removeItem(output);
Eric Laurent36829f92017-04-07 19:04:42 -07005426 selectOutputForMusicEffects();
François Gaffie53615e22015-03-19 09:24:12 +01005427}
5428
Eric Laurent98e38192018-02-15 18:31:53 -08005429void AudioPolicyManager::addInput(audio_io_handle_t input,
5430 const sp<AudioInputDescriptor>& inputDesc)
Eric Laurentd4692962014-05-05 18:13:44 -07005431{
Eric Laurent1c333e22014-05-20 10:48:17 -07005432 mInputs.add(input, inputDesc);
Eric Laurent6a94d692014-05-20 11:18:06 -07005433 nextAudioPortGeneration();
Eric Laurentd4692962014-05-05 18:13:44 -07005434}
Eric Laurente552edb2014-03-10 17:42:56 -07005435
François Gaffie11d30102018-11-02 16:09:09 +01005436status_t AudioPolicyManager::checkOutputsForDevice(const sp<DeviceDescriptor>& device,
François Gaffie53615e22015-03-19 09:24:12 +01005437 audio_policy_dev_state_t state,
François Gaffie11d30102018-11-02 16:09:09 +01005438 SortedVector<audio_io_handle_t>& outputs)
Eric Laurente552edb2014-03-10 17:42:56 -07005439{
François Gaffie11d30102018-11-02 16:09:09 +01005440 audio_devices_t deviceType = device->type();
jiabince9f20e2019-09-12 16:29:15 -07005441 const String8 &address = String8(device->address().c_str());
Eric Laurentc75307b2015-03-17 15:29:32 -07005442 sp<SwAudioOutputDescriptor> desc;
Eric Laurentcc750d32015-06-25 11:48:20 -07005443
François Gaffie11d30102018-11-02 16:09:09 +01005444 if (audio_device_is_digital(deviceType)) {
Eric Laurentcc750d32015-06-25 11:48:20 -07005445 // erase all current sample rates, formats and channel masks
François Gaffie11d30102018-11-02 16:09:09 +01005446 device->clearAudioProfiles();
Eric Laurentcc750d32015-06-25 11:48:20 -07005447 }
Eric Laurente552edb2014-03-10 17:42:56 -07005448
Eric Laurent3b73df72014-03-11 09:06:29 -07005449 if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
jiabinb4fed192020-09-22 14:45:40 -07005450 // first call getAudioPort to get the supported attributes from the HAL
5451 struct audio_port_v7 port = {};
5452 device->toAudioPort(&port);
5453 status_t status = mpClientInterface->getAudioPort(&port);
5454 if (status == NO_ERROR) {
5455 device->importAudioPort(port);
5456 }
5457
5458 // then list already open outputs that can be routed to this device
Eric Laurente552edb2014-03-10 17:42:56 -07005459 for (size_t i = 0; i < mOutputs.size(); i++) {
5460 desc = mOutputs.valueAt(i);
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005461 if (!desc->isDuplicated() && desc->supportsDevice(device)
jiabin9a3361e2019-10-01 09:38:30 -07005462 && desc->devicesSupportEncodedFormats({deviceType})) {
François Gaffie11d30102018-11-02 16:09:09 +01005463 ALOGV("checkOutputsForDevice(): adding opened output %d on device %s",
5464 mOutputs.keyAt(i), device->toString().c_str());
5465 outputs.add(mOutputs.keyAt(i));
Eric Laurente552edb2014-03-10 17:42:56 -07005466 }
5467 }
5468 // then look for output profiles that can be routed to this device
Eric Laurent1c333e22014-05-20 10:48:17 -07005469 SortedVector< sp<IOProfile> > profiles;
Mikhail Naganov7e22e942017-12-07 10:04:29 -08005470 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08005471 for (size_t j = 0; j < hwModule->getOutputProfiles().size(); j++) {
5472 sp<IOProfile> profile = hwModule->getOutputProfiles()[j];
François Gaffie11d30102018-11-02 16:09:09 +01005473 if (profile->supportsDevice(device)) {
5474 profiles.add(profile);
5475 ALOGV("checkOutputsForDevice(): adding profile %zu from module %s",
5476 j, hwModule->getName());
Eric Laurente552edb2014-03-10 17:42:56 -07005477 }
5478 }
5479 }
5480
Eric Laurent7b279bb2015-12-14 10:18:23 -08005481 ALOGV(" found %zu profiles, %zu outputs", profiles.size(), outputs.size());
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005482
Eric Laurente552edb2014-03-10 17:42:56 -07005483 if (profiles.isEmpty() && outputs.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01005484 ALOGW("checkOutputsForDevice(): No output available for device %04x", deviceType);
Eric Laurente552edb2014-03-10 17:42:56 -07005485 return BAD_VALUE;
5486 }
5487
5488 // open outputs for matching profiles if needed. Direct outputs are also opened to
5489 // query for dynamic parameters and will be closed later by setDeviceConnectionState()
5490 for (ssize_t profile_index = 0; profile_index < (ssize_t)profiles.size(); profile_index++) {
Eric Laurent1c333e22014-05-20 10:48:17 -07005491 sp<IOProfile> profile = profiles[profile_index];
Eric Laurente552edb2014-03-10 17:42:56 -07005492
5493 // nothing to do if one output is already opened for this profile
5494 size_t j;
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005495 for (j = 0; j < outputs.size(); j++) {
5496 desc = mOutputs.valueFor(outputs.itemAt(j));
Eric Laurente552edb2014-03-10 17:42:56 -07005497 if (!desc->isDuplicated() && desc->mProfile == profile) {
Jean-Michel Trivif17026d2014-08-10 14:30:48 -07005498 // matching profile: save the sample rates, format and channel masks supported
5499 // by the profile in our device descriptor
François Gaffie11d30102018-11-02 16:09:09 +01005500 if (audio_device_is_digital(deviceType)) {
jiabin4ef93452019-09-10 14:29:54 -07005501 device->importAudioPortAndPickAudioProfile(profile);
Paul McLean9080a4c2015-06-18 08:24:02 -07005502 }
Eric Laurente552edb2014-03-10 17:42:56 -07005503 break;
5504 }
5505 }
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005506 if (j != outputs.size()) {
Eric Laurente552edb2014-03-10 17:42:56 -07005507 continue;
5508 }
5509
Eric Laurent3974e3b2017-12-07 17:58:43 -08005510 if (!profile->canOpenNewIo()) {
5511 ALOGW("Max Output number %u already opened for this profile %s",
5512 profile->maxOpenCount, profile->getTagName().c_str());
5513 continue;
5514 }
5515
Eric Laurent83efe1c2017-07-09 16:51:08 -07005516 ALOGV("opening output for device %08x with params %s profile %p name %s",
jiabin5740f082019-08-19 15:08:30 -07005517 deviceType, address.string(), profile.get(), profile->getName().c_str());
jiabinbce0c1d2020-10-05 11:20:18 -07005518 desc = openOutputWithProfileAndDevice(profile, DeviceVector(device));
5519 audio_io_handle_t output = desc == nullptr ? AUDIO_IO_HANDLE_NONE : desc->mIoHandle;
Eric Laurentcf2c0212014-07-25 16:20:43 -07005520 if (output == AUDIO_IO_HANDLE_NONE) {
François Gaffie11d30102018-11-02 16:09:09 +01005521 ALOGW("checkOutputsForDevice() could not open output for device %x", deviceType);
Eric Laurente552edb2014-03-10 17:42:56 -07005522 profiles.removeAt(profile_index);
5523 profile_index--;
5524 } else {
5525 outputs.add(output);
Paul McLean9080a4c2015-06-18 08:24:02 -07005526 // Load digital format info only for digital devices
François Gaffie11d30102018-11-02 16:09:09 +01005527 if (audio_device_is_digital(deviceType)) {
jiabinbce0c1d2020-10-05 11:20:18 -07005528 // TODO: when getAudioPort is ready, it may not be needed to import the audio
5529 // port but just pick audio profile
jiabin4ef93452019-09-10 14:29:54 -07005530 device->importAudioPortAndPickAudioProfile(profile);
Paul McLean9080a4c2015-06-18 08:24:02 -07005531 }
Jean-Michel Trivif17026d2014-08-10 14:30:48 -07005532
François Gaffie11d30102018-11-02 16:09:09 +01005533 if (device_distinguishes_on_address(deviceType)) {
5534 ALOGV("checkOutputsForDevice(): setOutputDevices %s",
5535 device->toString().c_str());
5536 setOutputDevices(desc, DeviceVector(device), true/*force*/, 0/*delay*/,
5537 NULL/*patch handle*/);
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005538 }
Eric Laurente552edb2014-03-10 17:42:56 -07005539 ALOGV("checkOutputsForDevice(): adding output %d", output);
5540 }
5541 }
5542
5543 if (profiles.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01005544 ALOGW("checkOutputsForDevice(): No output available for device %04x", deviceType);
Eric Laurente552edb2014-03-10 17:42:56 -07005545 return BAD_VALUE;
5546 }
Eric Laurentd4692962014-05-05 18:13:44 -07005547 } else { // Disconnect
Eric Laurente552edb2014-03-10 17:42:56 -07005548 // check if one opened output is not needed any more after disconnecting one device
5549 for (size_t i = 0; i < mOutputs.size(); i++) {
5550 desc = mOutputs.valueAt(i);
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005551 if (!desc->isDuplicated()) {
Eric Laurent275e8e92014-11-30 15:14:47 -08005552 // exact match on device
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005553 if (device_distinguishes_on_address(deviceType) && desc->supportsDevice(device)
Francois Gaffiec7d4c222021-12-02 11:12:52 +01005554 && desc->containsSingleDeviceSupportingEncodedFormats(device)) {
François Gaffie11d30102018-11-02 16:09:09 +01005555 outputs.add(mOutputs.keyAt(i));
Francois Gaffie716e1432019-01-14 16:58:59 +01005556 } else if (!mAvailableOutputDevices.containsAtLeastOne(desc->supportedDevices())) {
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005557 ALOGV("checkOutputsForDevice(): disconnecting adding output %d",
5558 mOutputs.keyAt(i));
5559 outputs.add(mOutputs.keyAt(i));
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005560 }
Eric Laurente552edb2014-03-10 17:42:56 -07005561 }
5562 }
Eric Laurentd4692962014-05-05 18:13:44 -07005563 // Clear any profiles associated with the disconnected device.
Mikhail Naganov7e22e942017-12-07 10:04:29 -08005564 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08005565 for (size_t j = 0; j < hwModule->getOutputProfiles().size(); j++) {
5566 sp<IOProfile> profile = hwModule->getOutputProfiles()[j];
jiabinbce0c1d2020-10-05 11:20:18 -07005567 if (!profile->supportsDevice(device)) {
5568 continue;
5569 }
5570 ALOGV("checkOutputsForDevice(): "
5571 "clearing direct output profile %zu on module %s",
5572 j, hwModule->getName());
5573 profile->clearAudioProfiles();
5574 if (!profile->hasDynamicAudioProfile()) {
5575 continue;
5576 }
5577 // When a device is disconnected, if there is an IOProfile that contains dynamic
5578 // profiles and supports the disconnected device, call getAudioPort to repopulate
5579 // the capabilities of the devices that is supported by the IOProfile.
5580 for (const auto& supportedDevice : profile->getSupportedDevices()) {
5581 if (supportedDevice == device ||
5582 !mAvailableOutputDevices.contains(supportedDevice)) {
5583 continue;
5584 }
5585 struct audio_port_v7 port;
5586 supportedDevice->toAudioPort(&port);
5587 status_t status = mpClientInterface->getAudioPort(&port);
5588 if (status == NO_ERROR) {
5589 supportedDevice->importAudioPort(port);
5590 }
Eric Laurente552edb2014-03-10 17:42:56 -07005591 }
5592 }
5593 }
5594 }
5595 return NO_ERROR;
5596}
5597
François Gaffie11d30102018-11-02 16:09:09 +01005598status_t AudioPolicyManager::checkInputsForDevice(const sp<DeviceDescriptor>& device,
Eric Laurent0dd51852019-04-19 18:18:58 -07005599 audio_policy_dev_state_t state)
Eric Laurentd4692962014-05-05 18:13:44 -07005600{
Eric Laurent1f2f2232014-06-02 12:01:23 -07005601 sp<AudioInputDescriptor> desc;
Eric Laurentcc750d32015-06-25 11:48:20 -07005602
François Gaffie11d30102018-11-02 16:09:09 +01005603 if (audio_device_is_digital(device->type())) {
Eric Laurentcc750d32015-06-25 11:48:20 -07005604 // erase all current sample rates, formats and channel masks
François Gaffie11d30102018-11-02 16:09:09 +01005605 device->clearAudioProfiles();
Eric Laurentcc750d32015-06-25 11:48:20 -07005606 }
5607
Eric Laurentd4692962014-05-05 18:13:44 -07005608 if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
Eric Laurent0dd51852019-04-19 18:18:58 -07005609 // look for input profiles that can be routed to this device
Eric Laurent1c333e22014-05-20 10:48:17 -07005610 SortedVector< sp<IOProfile> > profiles;
Mikhail Naganov7e22e942017-12-07 10:04:29 -08005611 for (const auto& hwModule : mHwModules) {
Eric Laurentd4692962014-05-05 18:13:44 -07005612 for (size_t profile_index = 0;
Mikhail Naganova5e165d2017-12-07 17:08:02 -08005613 profile_index < hwModule->getInputProfiles().size();
Mikhail Naganov7e22e942017-12-07 10:04:29 -08005614 profile_index++) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08005615 sp<IOProfile> profile = hwModule->getInputProfiles()[profile_index];
Eric Laurent275e8e92014-11-30 15:14:47 -08005616
François Gaffie11d30102018-11-02 16:09:09 +01005617 if (profile->supportsDevice(device)) {
5618 profiles.add(profile);
5619 ALOGV("checkInputsForDevice(): adding profile %zu from module %s",
5620 profile_index, hwModule->getName());
Eric Laurentd4692962014-05-05 18:13:44 -07005621 }
5622 }
5623 }
5624
Eric Laurent0dd51852019-04-19 18:18:58 -07005625 if (profiles.isEmpty()) {
5626 ALOGW("%s: No input profile available for device %s",
5627 __func__, device->toString().c_str());
Eric Laurentd4692962014-05-05 18:13:44 -07005628 return BAD_VALUE;
5629 }
5630
5631 // open inputs for matching profiles if needed. Direct inputs are also opened to
5632 // query for dynamic parameters and will be closed later by setDeviceConnectionState()
5633 for (ssize_t profile_index = 0; profile_index < (ssize_t)profiles.size(); profile_index++) {
5634
Eric Laurent1c333e22014-05-20 10:48:17 -07005635 sp<IOProfile> profile = profiles[profile_index];
Eric Laurent3974e3b2017-12-07 17:58:43 -08005636
Eric Laurentd4692962014-05-05 18:13:44 -07005637 // nothing to do if one input is already opened for this profile
5638 size_t input_index;
5639 for (input_index = 0; input_index < mInputs.size(); input_index++) {
5640 desc = mInputs.valueAt(input_index);
5641 if (desc->mProfile == profile) {
François Gaffie11d30102018-11-02 16:09:09 +01005642 if (audio_device_is_digital(device->type())) {
jiabin4ef93452019-09-10 14:29:54 -07005643 device->importAudioPortAndPickAudioProfile(profile);
Paul McLean9080a4c2015-06-18 08:24:02 -07005644 }
Eric Laurentd4692962014-05-05 18:13:44 -07005645 break;
5646 }
5647 }
5648 if (input_index != mInputs.size()) {
5649 continue;
5650 }
5651
Eric Laurent3974e3b2017-12-07 17:58:43 -08005652 if (!profile->canOpenNewIo()) {
5653 ALOGW("Max Input number %u already opened for this profile %s",
5654 profile->maxOpenCount, profile->getTagName().c_str());
5655 continue;
5656 }
5657
Eric Laurentfe231122017-11-17 17:48:06 -08005658 desc = new AudioInputDescriptor(profile, mpClientInterface);
Eric Laurentcf2c0212014-07-25 16:20:43 -07005659 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
Eric Laurentfe231122017-11-17 17:48:06 -08005660 status_t status = desc->open(nullptr,
5661 device,
Eric Laurentfe231122017-11-17 17:48:06 -08005662 AUDIO_SOURCE_MIC,
5663 AUDIO_INPUT_FLAG_NONE,
5664 &input);
Eric Laurentd4692962014-05-05 18:13:44 -07005665
Eric Laurentcf2c0212014-07-25 16:20:43 -07005666 if (status == NO_ERROR) {
jiabince9f20e2019-09-12 16:29:15 -07005667 const String8& address = String8(device->address().c_str());
Eric Laurentd4692962014-05-05 18:13:44 -07005668 if (!address.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01005669 char *param = audio_device_address_to_parameter(device->type(), address);
Eric Laurentcf2c0212014-07-25 16:20:43 -07005670 mpClientInterface->setParameters(input, String8(param));
5671 free(param);
Eric Laurentd4692962014-05-05 18:13:44 -07005672 }
François Gaffie11d30102018-11-02 16:09:09 +01005673 updateAudioProfiles(device, input, profile->getAudioProfiles());
François Gaffie112b0af2015-11-19 16:13:25 +01005674 if (!profile->hasValidAudioProfile()) {
Eric Laurentd4692962014-05-05 18:13:44 -07005675 ALOGW("checkInputsForDevice() direct input missing param");
Eric Laurentfe231122017-11-17 17:48:06 -08005676 desc->close();
Eric Laurentcf2c0212014-07-25 16:20:43 -07005677 input = AUDIO_IO_HANDLE_NONE;
Eric Laurentd4692962014-05-05 18:13:44 -07005678 }
5679
Eric Laurent0dd51852019-04-19 18:18:58 -07005680 if (input != AUDIO_IO_HANDLE_NONE) {
Eric Laurentd4692962014-05-05 18:13:44 -07005681 addInput(input, desc);
5682 }
5683 } // endif input != 0
5684
Eric Laurentcf2c0212014-07-25 16:20:43 -07005685 if (input == AUDIO_IO_HANDLE_NONE) {
Pattydd807582021-11-04 21:01:03 +08005686 ALOGW("%s could not open input for device %s", __func__,
François Gaffie11d30102018-11-02 16:09:09 +01005687 device->toString().c_str());
Eric Laurentd4692962014-05-05 18:13:44 -07005688 profiles.removeAt(profile_index);
5689 profile_index--;
5690 } else {
François Gaffie11d30102018-11-02 16:09:09 +01005691 if (audio_device_is_digital(device->type())) {
jiabin4ef93452019-09-10 14:29:54 -07005692 device->importAudioPortAndPickAudioProfile(profile);
Paul McLean9080a4c2015-06-18 08:24:02 -07005693 }
Eric Laurentd4692962014-05-05 18:13:44 -07005694 ALOGV("checkInputsForDevice(): adding input %d", input);
5695 }
5696 } // end scan profiles
5697
5698 if (profiles.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01005699 ALOGW("%s: No input available for device %s", __func__, device->toString().c_str());
Eric Laurentd4692962014-05-05 18:13:44 -07005700 return BAD_VALUE;
5701 }
5702 } else {
5703 // Disconnect
Eric Laurentd4692962014-05-05 18:13:44 -07005704 // Clear any profiles associated with the disconnected device.
Mikhail Naganovd4120142017-12-06 15:49:22 -08005705 for (const auto& hwModule : mHwModules) {
Eric Laurentd4692962014-05-05 18:13:44 -07005706 for (size_t profile_index = 0;
Mikhail Naganova5e165d2017-12-07 17:08:02 -08005707 profile_index < hwModule->getInputProfiles().size();
Eric Laurentd4692962014-05-05 18:13:44 -07005708 profile_index++) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08005709 sp<IOProfile> profile = hwModule->getInputProfiles()[profile_index];
Francois Gaffie716e1432019-01-14 16:58:59 +01005710 if (profile->supportsDevice(device)) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08005711 ALOGV("checkInputsForDevice(): clearing direct input profile %zu on module %s",
5712 profile_index, hwModule->getName());
François Gaffie112b0af2015-11-19 16:13:25 +01005713 profile->clearAudioProfiles();
Eric Laurentd4692962014-05-05 18:13:44 -07005714 }
5715 }
5716 }
5717 } // end disconnect
5718
5719 return NO_ERROR;
5720}
5721
5722
Eric Laurente0720872014-03-11 09:30:41 -07005723void AudioPolicyManager::closeOutput(audio_io_handle_t output)
Eric Laurente552edb2014-03-10 17:42:56 -07005724{
5725 ALOGV("closeOutput(%d)", output);
5726
François Gaffie1c878552018-11-22 16:53:21 +01005727 sp<SwAudioOutputDescriptor> closingOutput = mOutputs.valueFor(output);
5728 if (closingOutput == NULL) {
Eric Laurente552edb2014-03-10 17:42:56 -07005729 ALOGW("closeOutput() unknown output %d", output);
5730 return;
5731 }
Mikhail Naganov32ebca32019-03-22 15:42:52 -07005732 const bool closingOutputWasActive = closingOutput->isActive();
François Gaffie1c878552018-11-22 16:53:21 +01005733 mPolicyMixes.closeOutput(closingOutput);
Eric Laurent275e8e92014-11-30 15:14:47 -08005734
Eric Laurente552edb2014-03-10 17:42:56 -07005735 // look for duplicated outputs connected to the output being removed.
5736 for (size_t i = 0; i < mOutputs.size(); i++) {
François Gaffie1c878552018-11-22 16:53:21 +01005737 sp<SwAudioOutputDescriptor> dupOutput = mOutputs.valueAt(i);
5738 if (dupOutput->isDuplicated() &&
5739 (dupOutput->mOutput1 == closingOutput || dupOutput->mOutput2 == closingOutput)) {
5740 sp<SwAudioOutputDescriptor> remainingOutput =
5741 dupOutput->mOutput1 == closingOutput ? dupOutput->mOutput2 : dupOutput->mOutput1;
Eric Laurente552edb2014-03-10 17:42:56 -07005742 // As all active tracks on duplicated output will be deleted,
5743 // and as they were also referenced on the other output, the reference
5744 // count for their stream type must be adjusted accordingly on
5745 // the other output.
François Gaffie1c878552018-11-22 16:53:21 +01005746 const bool wasActive = remainingOutput->isActive();
5747 // Note: no-op on the closing output where all clients has already been set inactive
5748 dupOutput->setAllClientsInactive();
Eric Laurent733ce942017-12-07 12:18:25 -08005749 // stop() will be a no op if the output is still active but is needed in case all
5750 // active streams refcounts where cleared above
5751 if (wasActive) {
François Gaffie1c878552018-11-22 16:53:21 +01005752 remainingOutput->stop();
Eric Laurent733ce942017-12-07 12:18:25 -08005753 }
Eric Laurente552edb2014-03-10 17:42:56 -07005754 audio_io_handle_t duplicatedOutput = mOutputs.keyAt(i);
5755 ALOGV("closeOutput() closing also duplicated output %d", duplicatedOutput);
5756
5757 mpClientInterface->closeOutput(duplicatedOutput);
François Gaffie53615e22015-03-19 09:24:12 +01005758 removeOutput(duplicatedOutput);
Eric Laurente552edb2014-03-10 17:42:56 -07005759 }
5760 }
5761
Eric Laurent05b90f82014-08-27 15:32:29 -07005762 nextAudioPortGeneration();
5763
François Gaffie1c878552018-11-22 16:53:21 +01005764 ssize_t index = mAudioPatches.indexOfKey(closingOutput->getPatchHandle());
Eric Laurent05b90f82014-08-27 15:32:29 -07005765 if (index >= 0) {
5766 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01005767 (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(
5768 patchDesc->getAfHandle(), 0);
Eric Laurent05b90f82014-08-27 15:32:29 -07005769 mAudioPatches.removeItemsAt(index);
5770 mpClientInterface->onAudioPatchListUpdate();
5771 }
5772
Mikhail Naganov32ebca32019-03-22 15:42:52 -07005773 if (closingOutputWasActive) {
5774 closingOutput->stop();
5775 }
François Gaffie1c878552018-11-22 16:53:21 +01005776 closingOutput->close();
Eric Laurente552edb2014-03-10 17:42:56 -07005777
François Gaffie53615e22015-03-19 09:24:12 +01005778 removeOutput(output);
Eric Laurente552edb2014-03-10 17:42:56 -07005779 mPreviousOutputs = mOutputs;
Dean Wheatley3023b382018-08-09 07:42:40 +10005780
5781 // MSD patches may have been released to support a non-MSD direct output. Reset MSD patch if
5782 // no direct outputs are open.
François Gaffie11d30102018-11-02 16:09:09 +01005783 if (!getMsdAudioOutDevices().isEmpty()) {
Dean Wheatley3023b382018-08-09 07:42:40 +10005784 bool directOutputOpen = false;
5785 for (size_t i = 0; i < mOutputs.size(); i++) {
5786 if (mOutputs[i]->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
5787 directOutputOpen = true;
5788 break;
5789 }
5790 }
5791 if (!directOutputOpen) {
Michael Chan6fb34492020-12-08 15:44:49 +11005792 ALOGV("no direct outputs open, reset MSD patches");
5793 // TODO: The MSD patches to be established here may differ to current MSD patches due to
5794 // how output devices for patching are resolved. Avoid by caching and reusing the
5795 // arguments to mEngine->getOutputDevicesForAttributes() when resolving which output
5796 // devices to patch to. This may be complicated by the fact that devices may become
5797 // unavailable.
Dean Wheatley8bee85a2021-02-10 16:02:23 +11005798 setMsdOutputPatches();
Dean Wheatley3023b382018-08-09 07:42:40 +10005799 }
5800 }
Eric Laurent05b90f82014-08-27 15:32:29 -07005801}
5802
5803void AudioPolicyManager::closeInput(audio_io_handle_t input)
5804{
5805 ALOGV("closeInput(%d)", input);
5806
5807 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
5808 if (inputDesc == NULL) {
5809 ALOGW("closeInput() unknown input %d", input);
5810 return;
5811 }
5812
Eric Laurent6a94d692014-05-20 11:18:06 -07005813 nextAudioPortGeneration();
Eric Laurent05b90f82014-08-27 15:32:29 -07005814
François Gaffie11d30102018-11-02 16:09:09 +01005815 sp<DeviceDescriptor> device = inputDesc->getDevice();
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08005816 ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent05b90f82014-08-27 15:32:29 -07005817 if (index >= 0) {
5818 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01005819 (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(
5820 patchDesc->getAfHandle(), 0);
Eric Laurent05b90f82014-08-27 15:32:29 -07005821 mAudioPatches.removeItemsAt(index);
5822 mpClientInterface->onAudioPatchListUpdate();
5823 }
5824
Eric Laurentfe231122017-11-17 17:48:06 -08005825 inputDesc->close();
Eric Laurent05b90f82014-08-27 15:32:29 -07005826 mInputs.removeItem(input);
Haynes Mathew George1d539d92018-03-16 11:40:49 -07005827
François Gaffie11d30102018-11-02 16:09:09 +01005828 DeviceVector primaryInputDevices = availablePrimaryModuleInputDevices();
5829 if (primaryInputDevices.contains(device) &&
Haynes Mathew George1d539d92018-03-16 11:40:49 -07005830 mInputs.activeInputsCountOnDevices(primaryInputDevices) == 0) {
Ytai Ben-Tsvi74cd6b02019-10-25 10:06:40 -07005831 mpClientInterface->setSoundTriggerCaptureState(false);
Haynes Mathew George1d539d92018-03-16 11:40:49 -07005832 }
Eric Laurente552edb2014-03-10 17:42:56 -07005833}
5834
François Gaffie11d30102018-11-02 16:09:09 +01005835SortedVector<audio_io_handle_t> AudioPolicyManager::getOutputsForDevices(
5836 const DeviceVector &devices,
5837 const SwAudioOutputCollection& openOutputs)
Eric Laurente552edb2014-03-10 17:42:56 -07005838{
5839 SortedVector<audio_io_handle_t> outputs;
5840
François Gaffie11d30102018-11-02 16:09:09 +01005841 ALOGVV("%s() devices %s", __func__, devices.toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -07005842 for (size_t i = 0; i < openOutputs.size(); i++) {
François Gaffie11d30102018-11-02 16:09:09 +01005843 ALOGVV("output %zu isDuplicated=%d device=%s",
Eric Laurent8c7e6da2015-04-21 17:37:00 -07005844 i, openOutputs.valueAt(i)->isDuplicated(),
François Gaffie11d30102018-11-02 16:09:09 +01005845 openOutputs.valueAt(i)->supportedDevices().toString().c_str());
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005846 if (openOutputs.valueAt(i)->supportsAllDevices(devices)
jiabin9a3361e2019-10-01 09:38:30 -07005847 && openOutputs.valueAt(i)->devicesSupportEncodedFormats(devices.types())) {
François Gaffie11d30102018-11-02 16:09:09 +01005848 ALOGVV("%s() found output %d", __func__, openOutputs.keyAt(i));
Eric Laurente552edb2014-03-10 17:42:56 -07005849 outputs.add(openOutputs.keyAt(i));
5850 }
5851 }
5852 return outputs;
5853}
5854
Mikhail Naganov37977152018-07-11 15:54:44 -07005855void AudioPolicyManager::checkForDeviceAndOutputChanges(std::function<bool()> onOutputsChecked)
5856{
5857 // checkA2dpSuspend must run before checkOutputForAllStrategies so that A2DP
5858 // output is suspended before any tracks are moved to it
5859 checkA2dpSuspend();
5860 checkOutputForAllStrategies();
Kevin Rocard153f92d2018-12-18 18:33:28 -08005861 checkSecondaryOutputs();
Mikhail Naganov15be9d22017-11-08 14:18:13 +11005862 if (onOutputsChecked != nullptr && onOutputsChecked()) checkA2dpSuspend();
Mikhail Naganov37977152018-07-11 15:54:44 -07005863 updateDevicesAndOutputs();
Mikhail Naganov7bd9b8d2018-11-15 02:09:03 +00005864 if (mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD) != 0) {
Michael Chan6fb34492020-12-08 15:44:49 +11005865 // TODO: The MSD patches to be established here may differ to current MSD patches due to how
5866 // output devices for patching are resolved. Nevertheless, AudioTracks affected by device
5867 // configuration changes will ultimately be rerouted correctly. We can still avoid
5868 // unnecessary rerouting by caching and reusing the arguments to
5869 // mEngine->getOutputDevicesForAttributes() when resolving which output devices to patch to.
5870 // This may be complicated by the fact that devices may become unavailable.
Dean Wheatley8bee85a2021-02-10 16:02:23 +11005871 setMsdOutputPatches();
Mikhail Naganov15be9d22017-11-08 14:18:13 +11005872 }
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07005873 // an event that changed routing likely occurred, inform upper layers
5874 mpClientInterface->onRoutingUpdated();
Mikhail Naganov37977152018-07-11 15:54:44 -07005875}
5876
François Gaffiec005e562018-11-06 15:04:49 +01005877bool AudioPolicyManager::followsSameRouting(const audio_attributes_t &lAttr,
5878 const audio_attributes_t &rAttr) const
Eric Laurente552edb2014-03-10 17:42:56 -07005879{
François Gaffiec005e562018-11-06 15:04:49 +01005880 return mEngine->getProductStrategyForAttributes(lAttr) ==
5881 mEngine->getProductStrategyForAttributes(rAttr);
5882}
5883
Francois Gaffieff1eb522020-05-06 18:37:04 +02005884void AudioPolicyManager::checkAudioSourceForAttributes(const audio_attributes_t &attr)
5885{
5886 for (size_t i = 0; i < mAudioSources.size(); i++) {
5887 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
5888 if (sourceDesc != nullptr && followsSameRouting(attr, sourceDesc->attributes())
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02005889 && sourceDesc->getPatchHandle() == AUDIO_PATCH_HANDLE_NONE
5890 && !isCallRxAudioSource(sourceDesc)) {
Francois Gaffieff1eb522020-05-06 18:37:04 +02005891 connectAudioSource(sourceDesc);
5892 }
5893 }
5894}
5895
5896void AudioPolicyManager::clearAudioSourcesForOutput(audio_io_handle_t output)
5897{
5898 for (size_t i = 0; i < mAudioSources.size(); i++) {
5899 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
5900 if (sourceDesc != nullptr && sourceDesc->swOutput().promote() != nullptr
5901 && sourceDesc->swOutput().promote()->mIoHandle == output) {
5902 disconnectAudioSource(sourceDesc);
5903 }
5904 }
5905}
5906
François Gaffiec005e562018-11-06 15:04:49 +01005907void AudioPolicyManager::checkOutputForAttributes(const audio_attributes_t &attr)
5908{
5909 auto psId = mEngine->getProductStrategyForAttributes(attr);
5910
5911 DeviceVector oldDevices = mEngine->getOutputDevicesForAttributes(attr, 0, true /*fromCache*/);
5912 DeviceVector newDevices = mEngine->getOutputDevicesForAttributes(attr, 0, false /*fromCache*/);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07005913
François Gaffie11d30102018-11-02 16:09:09 +01005914 SortedVector<audio_io_handle_t> srcOutputs = getOutputsForDevices(oldDevices, mPreviousOutputs);
5915 SortedVector<audio_io_handle_t> dstOutputs = getOutputsForDevices(newDevices, mOutputs);
Eric Laurente552edb2014-03-10 17:42:56 -07005916
Eric Laurentc209fe42020-06-05 18:11:23 -07005917 uint32_t maxLatency = 0;
5918 bool invalidate = false;
5919 // take into account dynamic audio policies related changes: if a client is now associated
5920 // to a different policy mix than at creation time, invalidate corresponding stream
5921 for (size_t i = 0; i < mPreviousOutputs.size() && !invalidate; i++) {
5922 const sp<SwAudioOutputDescriptor>& desc = mPreviousOutputs.valueAt(i);
5923 if (desc->isDuplicated()) {
5924 continue;
Jean-Michel Trivife472e22014-12-16 14:23:13 -08005925 }
Eric Laurentc209fe42020-06-05 18:11:23 -07005926 for (const sp<TrackClientDescriptor>& client : desc->getClientIterable()) {
5927 if (mEngine->getProductStrategyForAttributes(client->attributes()) != psId) {
5928 continue;
5929 }
5930 sp<AudioPolicyMix> primaryMix;
5931 status_t status = mPolicyMixes.getOutputForAttr(client->attributes(), client->uid(),
5932 client->flags(), primaryMix, nullptr);
5933 if (status != OK) {
5934 continue;
5935 }
yucliuf4de36d2020-09-14 14:57:56 -07005936 if (client->getPrimaryMix() != primaryMix || client->hasLostPrimaryMix()) {
Eric Laurentc209fe42020-06-05 18:11:23 -07005937 invalidate = true;
5938 if (desc->isStrategyActive(psId)) {
5939 maxLatency = desc->latency();
5940 }
5941 break;
5942 }
Jean-Michel Trivife472e22014-12-16 14:23:13 -08005943 }
5944 }
5945
Eric Laurentc209fe42020-06-05 18:11:23 -07005946 if (srcOutputs != dstOutputs || invalidate) {
Eric Laurentac3a6902018-05-11 16:39:10 -07005947 // get maximum latency of all source outputs to determine the minimum mute time guaranteeing
5948 // audio from invalidated tracks will be rendered when unmuting
Eric Laurentac3a6902018-05-11 16:39:10 -07005949 for (audio_io_handle_t srcOut : srcOutputs) {
5950 sp<SwAudioOutputDescriptor> desc = mPreviousOutputs.valueFor(srcOut);
Eric Laurentaa02db82019-09-05 17:31:49 -07005951 if (desc == nullptr) continue;
5952
5953 if (desc->isStrategyActive(psId) && maxLatency < desc->latency()) {
Eric Laurentac3a6902018-05-11 16:39:10 -07005954 maxLatency = desc->latency();
5955 }
Eric Laurentaa02db82019-09-05 17:31:49 -07005956
5957 if (invalidate) continue;
5958
5959 for (auto client : desc->clientsList(false /*activeOnly*/)) {
Eric Laurent78aade82019-09-13 18:55:08 -07005960 if (desc->isDuplicated() || !desc->mProfile->isDirectOutput()) {
Eric Laurentaa02db82019-09-05 17:31:49 -07005961 // a client on a non direct outputs has necessarily a linear PCM format
5962 // so we can call selectOutput() safely
5963 const audio_io_handle_t newOutput = selectOutput(dstOutputs,
5964 client->flags(),
5965 client->config().format,
5966 client->config().channel_mask,
jiabinebb6af42020-06-09 17:31:17 -07005967 client->config().sample_rate,
5968 client->session());
Eric Laurentaa02db82019-09-05 17:31:49 -07005969 if (newOutput != srcOut) {
5970 invalidate = true;
5971 break;
5972 }
5973 } else {
5974 sp<IOProfile> profile = getProfileForOutput(newDevices,
5975 client->config().sample_rate,
5976 client->config().format,
5977 client->config().channel_mask,
5978 client->flags(),
5979 true /* directOnly */);
5980 if (profile != desc->mProfile) {
5981 invalidate = true;
5982 break;
5983 }
5984 }
5985 }
Eric Laurentac3a6902018-05-11 16:39:10 -07005986 }
Eric Laurentaa02db82019-09-05 17:31:49 -07005987
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005988 ALOGV_IF(!(srcOutputs.isEmpty() || dstOutputs.isEmpty()),
François Gaffiec005e562018-11-06 15:04:49 +01005989 "%s: strategy %d, moving from output %s to output %s", __func__, psId,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005990 std::to_string(srcOutputs[0]).c_str(),
5991 std::to_string(dstOutputs[0]).c_str());
Eric Laurente552edb2014-03-10 17:42:56 -07005992 // mute strategy while moving tracks from one output to another
Mikhail Naganovcf84e592017-12-07 11:25:11 -08005993 for (audio_io_handle_t srcOut : srcOutputs) {
Eric Laurentac3a6902018-05-11 16:39:10 -07005994 sp<SwAudioOutputDescriptor> desc = mPreviousOutputs.valueFor(srcOut);
Eric Laurentaa02db82019-09-05 17:31:49 -07005995 if (desc == nullptr) continue;
5996
5997 if (desc->isStrategyActive(psId)) {
François Gaffiec005e562018-11-06 15:04:49 +01005998 setStrategyMute(psId, true, desc);
5999 setStrategyMute(psId, false, desc, maxLatency * LATENCY_MUTE_FACTOR,
François Gaffie11d30102018-11-02 16:09:09 +01006000 newDevices.types());
Eric Laurente552edb2014-03-10 17:42:56 -07006001 }
François Gaffiec005e562018-11-06 15:04:49 +01006002 sp<SourceClientDescriptor> source = getSourceForAttributesOnOutput(srcOut, attr);
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02006003 if (source != nullptr && !isCallRxAudioSource(source)) {
Eric Laurentd60560a2015-04-10 11:31:20 -07006004 connectAudioSource(source);
6005 }
Eric Laurente552edb2014-03-10 17:42:56 -07006006 }
6007
François Gaffiec005e562018-11-06 15:04:49 +01006008 // Move effects associated to this stream from previous output to new output
6009 if (followsSameRouting(attr, attributes_initializer(AUDIO_USAGE_MEDIA))) {
Eric Laurent36829f92017-04-07 19:04:42 -07006010 selectOutputForMusicEffects();
Eric Laurente552edb2014-03-10 17:42:56 -07006011 }
François Gaffiec005e562018-11-06 15:04:49 +01006012 // Move tracks associated to this stream (and linked) from previous output to new output
Eric Laurentaa02db82019-09-05 17:31:49 -07006013 if (invalidate) {
6014 for (auto stream : mEngine->getStreamTypesForProductStrategy(psId)) {
6015 mpClientInterface->invalidateStream(stream);
6016 }
Eric Laurente552edb2014-03-10 17:42:56 -07006017 }
6018 }
6019}
6020
Eric Laurente0720872014-03-11 09:30:41 -07006021void AudioPolicyManager::checkOutputForAllStrategies()
Eric Laurente552edb2014-03-10 17:42:56 -07006022{
François Gaffiec005e562018-11-06 15:04:49 +01006023 for (const auto &strategy : mEngine->getOrderedProductStrategies()) {
6024 auto attributes = mEngine->getAllAttributesForProductStrategy(strategy).front();
6025 checkOutputForAttributes(attributes);
Francois Gaffieff1eb522020-05-06 18:37:04 +02006026 checkAudioSourceForAttributes(attributes);
François Gaffiec005e562018-11-06 15:04:49 +01006027 }
Eric Laurente552edb2014-03-10 17:42:56 -07006028}
6029
Kevin Rocard153f92d2018-12-18 18:33:28 -08006030void AudioPolicyManager::checkSecondaryOutputs() {
6031 std::set<audio_stream_type_t> streamsToInvalidate;
jiabin10a03f12021-05-07 23:46:28 +00006032 TrackSecondaryOutputsMap trackSecondaryOutputs;
Kevin Rocard153f92d2018-12-18 18:33:28 -08006033 for (size_t i = 0; i < mOutputs.size(); i++) {
6034 const sp<SwAudioOutputDescriptor>& outputDescriptor = mOutputs[i];
6035 for (const sp<TrackClientDescriptor>& client : outputDescriptor->getClientIterable()) {
Eric Laurentc529cf62020-04-17 18:19:10 -07006036 sp<AudioPolicyMix> primaryMix;
6037 std::vector<sp<AudioPolicyMix>> secondaryMixes;
Kevin Rocard94114a22019-04-01 19:38:23 -07006038 status_t status = mPolicyMixes.getOutputForAttr(client->attributes(), client->uid(),
Eric Laurentc529cf62020-04-17 18:19:10 -07006039 client->flags(), primaryMix, &secondaryMixes);
6040 std::vector<sp<SwAudioOutputDescriptor>> secondaryDescs;
6041 for (auto &secondaryMix : secondaryMixes) {
6042 sp<SwAudioOutputDescriptor> outputDesc = secondaryMix->getOutput();
6043 if (outputDesc != nullptr &&
6044 outputDesc->mIoHandle != AUDIO_IO_HANDLE_NONE) {
6045 secondaryDescs.push_back(outputDesc);
6046 }
6047 }
6048
jiabin10a03f12021-05-07 23:46:28 +00006049 if (status != OK) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08006050 streamsToInvalidate.insert(client->stream());
jiabin10a03f12021-05-07 23:46:28 +00006051 } else if (!std::equal(
6052 client->getSecondaryOutputs().begin(),
6053 client->getSecondaryOutputs().end(),
6054 secondaryDescs.begin(), secondaryDescs.end())) {
jiabina5281062021-11-23 00:10:23 +00006055 if (!audio_is_linear_pcm(client->config().format)) {
6056 // If the format is not PCM, the tracks should be invalidated to get correct
6057 // behavior when the secondary output is changed.
6058 streamsToInvalidate.insert(client->stream());
6059 } else {
6060 std::vector<wp<SwAudioOutputDescriptor>> weakSecondaryDescs;
6061 std::vector<audio_io_handle_t> secondaryOutputIds;
6062 for (const auto &secondaryDesc: secondaryDescs) {
6063 secondaryOutputIds.push_back(secondaryDesc->mIoHandle);
6064 weakSecondaryDescs.push_back(secondaryDesc);
6065 }
6066 trackSecondaryOutputs.emplace(client->portId(), secondaryOutputIds);
6067 client->setSecondaryOutputs(std::move(weakSecondaryDescs));
jiabin10a03f12021-05-07 23:46:28 +00006068 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08006069 }
6070 }
6071 }
jiabin10a03f12021-05-07 23:46:28 +00006072 if (!trackSecondaryOutputs.empty()) {
6073 mpClientInterface->updateSecondaryOutputs(trackSecondaryOutputs);
6074 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08006075 for (audio_stream_type_t stream : streamsToInvalidate) {
jiabin10a03f12021-05-07 23:46:28 +00006076 ALOGD("%s Invalidate stream %d due to fail getting output for attr", __func__, stream);
Kevin Rocard153f92d2018-12-18 18:33:28 -08006077 mpClientInterface->invalidateStream(stream);
6078 }
6079}
6080
Eric Laurent2517af32020-11-25 15:31:27 +01006081bool AudioPolicyManager::isScoRequestedForComm() const {
6082 AudioDeviceTypeAddrVector devices;
6083 mEngine->getDevicesForRoleAndStrategy(mCommunnicationStrategy, DEVICE_ROLE_PREFERRED, devices);
6084 for (const auto &device : devices) {
6085 if (audio_is_bluetooth_out_sco_device(device.mType)) {
6086 return true;
6087 }
6088 }
6089 return false;
6090}
6091
Eric Laurente0720872014-03-11 09:30:41 -07006092void AudioPolicyManager::checkA2dpSuspend()
Eric Laurente552edb2014-03-10 17:42:56 -07006093{
François Gaffie53615e22015-03-19 09:24:12 +01006094 audio_io_handle_t a2dpOutput = mOutputs.getA2dpOutput();
Aniket Kumar Lataa8ee9962018-01-31 20:24:23 -08006095 if (a2dpOutput == 0 || mOutputs.isA2dpOffloadedOnPrimary()) {
Eric Laurent3a4311c2014-03-17 12:00:47 -07006096 mA2dpSuspended = false;
Eric Laurente552edb2014-03-10 17:42:56 -07006097 return;
6098 }
6099
Eric Laurent3a4311c2014-03-17 12:00:47 -07006100 bool isScoConnected =
jiabin9a3361e2019-10-01 09:38:30 -07006101 (mAvailableInputDevices.types().count(AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) != 0 ||
6102 !Intersection(mAvailableOutputDevices.types(), getAudioDeviceOutAllScoSet()).empty());
Eric Laurent2517af32020-11-25 15:31:27 +01006103 bool isScoRequested = isScoRequestedForComm();
Eric Laurentf732e072016-08-03 19:30:28 -07006104
6105 // if suspended, restore A2DP output if:
6106 // ((SCO device is NOT connected) ||
Eric Laurent2517af32020-11-25 15:31:27 +01006107 // ((SCO is not requested) &&
Eric Laurentf732e072016-08-03 19:30:28 -07006108 // (phone state is NOT in call) && (phone state is NOT ringing)))
Eric Laurente552edb2014-03-10 17:42:56 -07006109 //
Eric Laurentf732e072016-08-03 19:30:28 -07006110 // if not suspended, suspend A2DP output if:
6111 // (SCO device is connected) &&
Eric Laurent2517af32020-11-25 15:31:27 +01006112 // ((SCO is requested) ||
Eric Laurentf732e072016-08-03 19:30:28 -07006113 // ((phone state is in call) || (phone state is ringing)))
Eric Laurente552edb2014-03-10 17:42:56 -07006114 //
6115 if (mA2dpSuspended) {
Eric Laurentf732e072016-08-03 19:30:28 -07006116 if (!isScoConnected ||
Eric Laurent2517af32020-11-25 15:31:27 +01006117 (!isScoRequested &&
Eric Laurentf732e072016-08-03 19:30:28 -07006118 (mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) &&
François Gaffie2110e042015-03-24 08:41:51 +01006119 (mEngine->getPhoneState() != AUDIO_MODE_RINGTONE))) {
Eric Laurente552edb2014-03-10 17:42:56 -07006120
6121 mpClientInterface->restoreOutput(a2dpOutput);
6122 mA2dpSuspended = false;
6123 }
6124 } else {
Eric Laurentf732e072016-08-03 19:30:28 -07006125 if (isScoConnected &&
Eric Laurent2517af32020-11-25 15:31:27 +01006126 (isScoRequested ||
Eric Laurentf732e072016-08-03 19:30:28 -07006127 (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL) ||
François Gaffie2110e042015-03-24 08:41:51 +01006128 (mEngine->getPhoneState() == AUDIO_MODE_RINGTONE))) {
Eric Laurente552edb2014-03-10 17:42:56 -07006129
6130 mpClientInterface->suspendOutput(a2dpOutput);
6131 mA2dpSuspended = true;
6132 }
6133 }
6134}
6135
François Gaffie11d30102018-11-02 16:09:09 +01006136DeviceVector AudioPolicyManager::getNewOutputDevices(const sp<SwAudioOutputDescriptor>& outputDesc,
6137 bool fromCache)
Eric Laurente552edb2014-03-10 17:42:56 -07006138{
François Gaffie11d30102018-11-02 16:09:09 +01006139 DeviceVector devices;
6140
Jean-Michel Triviff155c62016-02-26 12:07:16 -08006141 ssize_t index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07006142 if (index >= 0) {
6143 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01006144 if (patchDesc->getUid() != mUidCached) {
François Gaffie11d30102018-11-02 16:09:09 +01006145 ALOGV("%s device %s forced by patch %d", __func__,
6146 outputDesc->devices().toString().c_str(), outputDesc->getPatchHandle());
6147 return outputDesc->devices();
Eric Laurent6a94d692014-05-20 11:18:06 -07006148 }
6149 }
6150
Dean Wheatley514b4312020-06-17 21:45:00 +10006151 // Do not retrieve engine device for outputs through MSD
6152 // TODO: support explicit routing requests by resetting MSD patch to engine device.
6153 if (outputDesc->devices() == getMsdAudioOutDevices()) {
6154 return outputDesc->devices();
6155 }
6156
Eric Laurent97ac8712018-07-27 18:59:02 -07006157 // Honor explicit routing requests only if no client using default routing is active on this
6158 // input: a specific app can not force routing for other apps by setting a preferred device.
6159 bool active; // unused
François Gaffie11d30102018-11-02 16:09:09 +01006160 sp<DeviceDescriptor> device =
François Gaffiec005e562018-11-06 15:04:49 +01006161 findPreferredDevice(outputDesc, PRODUCT_STRATEGY_NONE, active, mAvailableOutputDevices);
François Gaffie11d30102018-11-02 16:09:09 +01006162 if (device != nullptr) {
6163 return DeviceVector(device);
Eric Laurentf3a5a602018-05-22 18:42:55 -07006164 }
6165
François Gaffiea807ef92018-11-05 10:44:33 +01006166 // Legacy Engine cannot take care of bus devices and mix, so we need to handle the conflict
6167 // of setForceUse / Default Bus device here
6168 device = mPolicyMixes.getDeviceAndMixForOutput(outputDesc, mAvailableOutputDevices);
6169 if (device != nullptr) {
6170 return DeviceVector(device);
6171 }
6172
François Gaffiec005e562018-11-06 15:04:49 +01006173 for (const auto &productStrategy : mEngine->getOrderedProductStrategies()) {
6174 StreamTypeVector streams = mEngine->getStreamTypesForProductStrategy(productStrategy);
6175 auto attr = mEngine->getAllAttributesForProductStrategy(productStrategy).front();
Jaideep Sharmae4d123a2020-11-24 15:14:03 +05306176 auto hasStreamActive = [&](auto stream) {
6177 return hasStream(streams, stream) && isStreamActive(stream, 0);
6178 };
Eric Laurent484e9272018-06-07 17:29:23 -07006179
Jaideep Sharmae4d123a2020-11-24 15:14:03 +05306180 auto doGetOutputDevicesForVoice = [&]() {
6181 return hasVoiceStream(streams) && (outputDesc == mPrimaryOutput ||
6182 outputDesc->isActive(toVolumeSource(AUDIO_STREAM_VOICE_CALL))) &&
6183 (isInCall() ||
Henrik Backlund07c654a2021-10-14 15:57:10 +02006184 mOutputs.isStrategyActiveOnSameModule(productStrategy, outputDesc)) &&
6185 !isStreamActive(AUDIO_STREAM_ENFORCED_AUDIBLE, 0);
Jaideep Sharmae4d123a2020-11-24 15:14:03 +05306186 };
6187
6188 // With low-latency playing on speaker, music on WFD, when the first low-latency
6189 // output is stopped, getNewOutputDevices checks for a product strategy
6190 // from the list, as STRATEGY_SONIFICATION comes prior to STRATEGY_MEDIA.
Carter Hsucc58a6b2021-07-20 08:44:50 +00006191 // If an ALARM or ENFORCED_AUDIBLE stream is supported by the product strategy,
Jaideep Sharmae4d123a2020-11-24 15:14:03 +05306192 // devices are returned for STRATEGY_SONIFICATION without checking whether the
6193 // stream is associated to the output descriptor.
6194 if (doGetOutputDevicesForVoice() || outputDesc->isStrategyActive(productStrategy) ||
6195 ((hasStreamActive(AUDIO_STREAM_ALARM) ||
6196 hasStreamActive(AUDIO_STREAM_ENFORCED_AUDIBLE)) &&
6197 mOutputs.isStrategyActiveOnSameModule(productStrategy, outputDesc))) {
François Gaffiec005e562018-11-06 15:04:49 +01006198 // Retrieval of devices for voice DL is done on primary output profile, cannot
6199 // check the route (would force modifying configuration file for this profile)
6200 devices = mEngine->getOutputDevicesForAttributes(attr, nullptr, fromCache);
6201 break;
6202 }
Eric Laurente552edb2014-03-10 17:42:56 -07006203 }
François Gaffiec005e562018-11-06 15:04:49 +01006204 ALOGV("%s selected devices %s", __func__, devices.toString().c_str());
François Gaffie11d30102018-11-02 16:09:09 +01006205 return devices;
Eric Laurent1c333e22014-05-20 10:48:17 -07006206}
6207
François Gaffie11d30102018-11-02 16:09:09 +01006208sp<DeviceDescriptor> AudioPolicyManager::getNewInputDevice(
6209 const sp<AudioInputDescriptor>& inputDesc)
Eric Laurent1c333e22014-05-20 10:48:17 -07006210{
François Gaffie11d30102018-11-02 16:09:09 +01006211 sp<DeviceDescriptor> device;
Eric Laurent6a94d692014-05-20 11:18:06 -07006212
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08006213 ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07006214 if (index >= 0) {
6215 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01006216 if (patchDesc->getUid() != mUidCached) {
François Gaffie11d30102018-11-02 16:09:09 +01006217 ALOGV("getNewInputDevice() device %s forced by patch %d",
6218 inputDesc->getDevice()->toString().c_str(), inputDesc->getPatchHandle());
6219 return inputDesc->getDevice();
Eric Laurent6a94d692014-05-20 11:18:06 -07006220 }
6221 }
6222
Eric Laurent97ac8712018-07-27 18:59:02 -07006223 // Honor explicit routing requests only if no client using default routing is active on this
6224 // input: a specific app can not force routing for other apps by setting a preferred device.
6225 bool active;
François Gaffie11d30102018-11-02 16:09:09 +01006226 device = findPreferredDevice(inputDesc, AUDIO_SOURCE_DEFAULT, active, mAvailableInputDevices);
6227 if (device != nullptr) {
6228 return device;
Eric Laurent97ac8712018-07-27 18:59:02 -07006229 }
6230
Eric Laurentdc95a252018-04-12 12:46:56 -07006231 // If we are not in call and no client is active on this input, this methods returns
Andy Hungf024a9e2019-01-30 16:01:02 -08006232 // a null sp<>, causing the patch on the input stream to be released.
yuanjiahsu0735bf32021-03-18 08:12:54 +08006233 audio_attributes_t attributes;
6234 uid_t uid;
6235 sp<RecordClientDescriptor> topClient = inputDesc->getHighestPriorityClient();
6236 if (topClient != nullptr) {
Eric Laurentc8c4f1f2021-11-09 11:51:34 +01006237 attributes = topClient->attributes();
6238 uid = topClient->uid();
yuanjiahsu0735bf32021-03-18 08:12:54 +08006239 } else {
Eric Laurentc8c4f1f2021-11-09 11:51:34 +01006240 attributes = { .source = AUDIO_SOURCE_DEFAULT };
6241 uid = 0;
yuanjiahsu0735bf32021-03-18 08:12:54 +08006242 }
6243
Francois Gaffie716e1432019-01-14 16:58:59 +01006244 if (attributes.source == AUDIO_SOURCE_DEFAULT && isInCall()) {
6245 attributes.source = AUDIO_SOURCE_VOICE_COMMUNICATION;
Eric Laurentdc95a252018-04-12 12:46:56 -07006246 }
Francois Gaffie716e1432019-01-14 16:58:59 +01006247 if (attributes.source != AUDIO_SOURCE_DEFAULT) {
yuanjiahsu0735bf32021-03-18 08:12:54 +08006248 device = mEngine->getInputDeviceForAttributes(attributes, uid);
Eric Laurentfb66dd92016-01-28 18:32:03 -08006249 }
Eric Laurent1c333e22014-05-20 10:48:17 -07006250
Eric Laurente552edb2014-03-10 17:42:56 -07006251 return device;
6252}
6253
Eric Laurent794fde22016-03-11 09:50:45 -08006254bool AudioPolicyManager::streamsMatchForvolume(audio_stream_type_t stream1,
6255 audio_stream_type_t stream2) {
Jean-Michel Trivi99bb2f92016-11-23 15:52:07 -08006256 return (stream1 == stream2);
Eric Laurent28d09f02016-03-08 10:43:05 -08006257}
6258
Mikhail Naganov5478fc12021-07-08 16:13:29 -07006259DeviceTypeSet AudioPolicyManager::getDevicesForStream(audio_stream_type_t stream) {
Eric Laurente552edb2014-03-10 17:42:56 -07006260 // By checking the range of stream before calling getStrategy, we avoid
François Gaffiec005e562018-11-06 15:04:49 +01006261 // getOutputDevicesForStream's behavior for invalid streams.
6262 // engine's getOutputDevicesForStream would fallback on its default behavior (most probably
6263 // device for music stream), but we want to return the empty set.
6264 if (stream < AUDIO_STREAM_MIN || stream >= AUDIO_STREAM_PUBLIC_CNT) {
Mikhail Naganov5478fc12021-07-08 16:13:29 -07006265 return DeviceTypeSet{};
Eric Laurent6a94d692014-05-20 11:18:06 -07006266 }
François Gaffie11d30102018-11-02 16:09:09 +01006267 DeviceVector activeDevices;
6268 DeviceVector devices;
Mikhail Naganovf33115d2020-09-25 23:03:05 +00006269 for (int i = AUDIO_STREAM_MIN; i < AUDIO_STREAM_PUBLIC_CNT; ++i) {
6270 const audio_stream_type_t curStream{static_cast<audio_stream_type_t>(i)};
François Gaffiec005e562018-11-06 15:04:49 +01006271 if (!streamsMatchForvolume(stream, curStream)) {
Eric Laurent28d09f02016-03-08 10:43:05 -08006272 continue;
Eric Laurent6a94d692014-05-20 11:18:06 -07006273 }
François Gaffiec005e562018-11-06 15:04:49 +01006274 DeviceVector curDevices = mEngine->getOutputDevicesForStream(curStream, false/*fromCache*/);
François Gaffie11d30102018-11-02 16:09:09 +01006275 devices.merge(curDevices);
6276 for (audio_io_handle_t output : getOutputsForDevices(curDevices, mOutputs)) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08006277 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
Eric Laurent83d17c22019-04-02 17:10:01 -07006278 if (outputDesc->isActive(toVolumeSource(curStream))) {
François Gaffie11d30102018-11-02 16:09:09 +01006279 activeDevices.merge(outputDesc->devices());
Eric Laurent28d09f02016-03-08 10:43:05 -08006280 }
6281 }
Eric Laurente552edb2014-03-10 17:42:56 -07006282 }
Jon Eklund11c9fb12014-06-23 14:47:03 -05006283
Eric Laurentb0688d62018-08-14 15:49:18 -07006284 // Favor devices selected on active streams if any to report correct device in case of
6285 // explicit device selection
François Gaffie11d30102018-11-02 16:09:09 +01006286 if (!activeDevices.isEmpty()) {
Eric Laurentb0688d62018-08-14 15:49:18 -07006287 devices = activeDevices;
6288 }
Jon Eklund11c9fb12014-06-23 14:47:03 -05006289 /*Filter SPEAKER_SAFE out of results, as AudioService doesn't know about it
6290 and doesn't really need to.*/
jiabin9a3361e2019-10-01 09:38:30 -07006291 DeviceVector speakerSafeDevices = devices.getDevicesFromType(AUDIO_DEVICE_OUT_SPEAKER_SAFE);
François Gaffie11d30102018-11-02 16:09:09 +01006292 if (!speakerSafeDevices.isEmpty()) {
jiabin9a3361e2019-10-01 09:38:30 -07006293 devices.merge(mAvailableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_SPEAKER));
François Gaffie11d30102018-11-02 16:09:09 +01006294 devices.remove(speakerSafeDevices);
Jon Eklund11c9fb12014-06-23 14:47:03 -05006295 }
Mikhail Naganov5478fc12021-07-08 16:13:29 -07006296 return devices.types();
Eric Laurente552edb2014-03-10 17:42:56 -07006297}
6298
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08006299status_t AudioPolicyManager::getDevicesForAttributes(
6300 const audio_attributes_t &attr, AudioDeviceTypeAddrVector *devices) {
6301 if (devices == nullptr) {
6302 return BAD_VALUE;
6303 }
6304 // check dynamic policies but only for primary descriptors (secondary not used for audible
6305 // audio routing, only used for duplication for playback capture)
Eric Laurentc529cf62020-04-17 18:19:10 -07006306 sp<AudioPolicyMix> policyMix;
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08006307 status_t status = mPolicyMixes.getOutputForAttr(attr, 0 /*uid unknown here*/,
Eric Laurentc529cf62020-04-17 18:19:10 -07006308 AUDIO_OUTPUT_FLAG_NONE, policyMix, nullptr);
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08006309 if (status != OK) {
6310 return status;
6311 }
Eric Laurentc529cf62020-04-17 18:19:10 -07006312 if (policyMix != nullptr && policyMix->getOutput() != nullptr) {
6313 AudioDeviceTypeAddr device(policyMix->mDeviceType, policyMix->mDeviceAddress.c_str());
6314 devices->push_back(device);
6315 return NO_ERROR;
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08006316 }
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08006317 DeviceVector curDevices = mEngine->getOutputDevicesForAttributes(attr, nullptr, false);
6318 for (const auto& device : curDevices) {
6319 devices->push_back(device->getDeviceTypeAddr());
6320 }
6321 return NO_ERROR;
6322}
6323
Eric Laurente0720872014-03-11 09:30:41 -07006324void AudioPolicyManager::handleNotificationRoutingForStream(audio_stream_type_t stream) {
Eric Laurente552edb2014-03-10 17:42:56 -07006325 switch(stream) {
Eric Laurent3b73df72014-03-11 09:06:29 -07006326 case AUDIO_STREAM_MUSIC:
François Gaffiec005e562018-11-06 15:04:49 +01006327 checkOutputForAttributes(attributes_initializer(AUDIO_USAGE_NOTIFICATION));
Eric Laurente552edb2014-03-10 17:42:56 -07006328 updateDevicesAndOutputs();
6329 break;
6330 default:
6331 break;
6332 }
6333}
6334
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07006335uint32_t AudioPolicyManager::handleEventForBeacon(int event) {
Eric Laurent9459fb02015-08-12 18:36:32 -07006336
6337 // skip beacon mute management if a dedicated TTS output is available
6338 if (mTtsOutputAvailable) {
6339 return 0;
6340 }
6341
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07006342 switch(event) {
6343 case STARTING_OUTPUT:
6344 mBeaconMuteRefCount++;
6345 break;
6346 case STOPPING_OUTPUT:
6347 if (mBeaconMuteRefCount > 0) {
6348 mBeaconMuteRefCount--;
6349 }
6350 break;
6351 case STARTING_BEACON:
6352 mBeaconPlayingRefCount++;
6353 break;
6354 case STOPPING_BEACON:
6355 if (mBeaconPlayingRefCount > 0) {
6356 mBeaconPlayingRefCount--;
6357 }
6358 break;
6359 }
6360
6361 if (mBeaconMuteRefCount > 0) {
6362 // any playback causes beacon to be muted
6363 return setBeaconMute(true);
6364 } else {
6365 // no other playback: unmute when beacon starts playing, mute when it stops
6366 return setBeaconMute(mBeaconPlayingRefCount == 0);
6367 }
6368}
6369
6370uint32_t AudioPolicyManager::setBeaconMute(bool mute) {
6371 ALOGV("setBeaconMute(%d) mBeaconMuteRefCount=%d mBeaconPlayingRefCount=%d",
6372 mute, mBeaconMuteRefCount, mBeaconPlayingRefCount);
6373 // keep track of muted state to avoid repeating mute/unmute operations
6374 if (mBeaconMuted != mute) {
6375 // mute/unmute AUDIO_STREAM_TTS on all outputs
6376 ALOGV("\t muting %d", mute);
6377 uint32_t maxLatency = 0;
François Gaffieaaac0fd2018-11-22 17:56:39 +01006378 auto ttsVolumeSource = toVolumeSource(AUDIO_STREAM_TTS);
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07006379 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -07006380 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
jiabin9a3361e2019-10-01 09:38:30 -07006381 setVolumeSourceMute(ttsVolumeSource, mute/*on*/, desc, 0 /*delay*/, DeviceTypeSet());
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07006382 const uint32_t latency = desc->latency() * 2;
Eric Laurentcdb2b352020-07-23 10:57:02 -07006383 if (desc->isActive(latency * 2) && latency > maxLatency) {
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07006384 maxLatency = latency;
6385 }
6386 }
6387 mBeaconMuted = mute;
6388 return maxLatency;
6389 }
6390 return 0;
6391}
6392
Eric Laurente0720872014-03-11 09:30:41 -07006393void AudioPolicyManager::updateDevicesAndOutputs()
Eric Laurente552edb2014-03-10 17:42:56 -07006394{
François Gaffiec005e562018-11-06 15:04:49 +01006395 mEngine->updateDeviceSelectionCache();
Eric Laurente552edb2014-03-10 17:42:56 -07006396 mPreviousOutputs = mOutputs;
6397}
6398
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07006399uint32_t AudioPolicyManager::checkDeviceMuteStrategies(const sp<AudioOutputDescriptor>& outputDesc,
François Gaffiec005e562018-11-06 15:04:49 +01006400 const DeviceVector &prevDevices,
Eric Laurente552edb2014-03-10 17:42:56 -07006401 uint32_t delayMs)
6402{
6403 // mute/unmute strategies using an incompatible device combination
6404 // if muting, wait for the audio in pcm buffer to be drained before proceeding
6405 // if unmuting, unmute only after the specified delay
6406 if (outputDesc->isDuplicated()) {
6407 return 0;
6408 }
6409
6410 uint32_t muteWaitMs = 0;
François Gaffiec005e562018-11-06 15:04:49 +01006411 DeviceVector devices = outputDesc->devices();
6412 bool shouldMute = outputDesc->isActive() && (devices.size() >= 2);
Eric Laurente552edb2014-03-10 17:42:56 -07006413
François Gaffiec005e562018-11-06 15:04:49 +01006414 auto productStrategies = mEngine->getOrderedProductStrategies();
6415 for (const auto &productStrategy : productStrategies) {
6416 auto attributes = mEngine->getAllAttributesForProductStrategy(productStrategy).front();
6417 DeviceVector curDevices =
6418 mEngine->getOutputDevicesForAttributes(attributes, nullptr, false/*fromCache*/);
6419 curDevices = curDevices.filter(outputDesc->supportedDevices());
6420 bool mute = shouldMute && curDevices.containsAtLeastOne(devices) && curDevices != devices;
Eric Laurente552edb2014-03-10 17:42:56 -07006421 bool doMute = false;
6422
François Gaffiec005e562018-11-06 15:04:49 +01006423 if (mute && !outputDesc->isStrategyMutedByDevice(productStrategy)) {
Eric Laurente552edb2014-03-10 17:42:56 -07006424 doMute = true;
François Gaffiec005e562018-11-06 15:04:49 +01006425 outputDesc->setStrategyMutedByDevice(productStrategy, true);
6426 } else if (!mute && outputDesc->isStrategyMutedByDevice(productStrategy)) {
Eric Laurente552edb2014-03-10 17:42:56 -07006427 doMute = true;
François Gaffiec005e562018-11-06 15:04:49 +01006428 outputDesc->setStrategyMutedByDevice(productStrategy, false);
Eric Laurente552edb2014-03-10 17:42:56 -07006429 }
Eric Laurent99401132014-05-07 19:48:15 -07006430 if (doMute) {
Eric Laurente552edb2014-03-10 17:42:56 -07006431 for (size_t j = 0; j < mOutputs.size(); j++) {
Eric Laurent1f2f2232014-06-02 12:01:23 -07006432 sp<AudioOutputDescriptor> desc = mOutputs.valueAt(j);
Eric Laurente552edb2014-03-10 17:42:56 -07006433 // skip output if it does not share any device with current output
François Gaffie11d30102018-11-02 16:09:09 +01006434 if (!desc->supportedDevices().containsAtLeastOne(outputDesc->supportedDevices())) {
Eric Laurente552edb2014-03-10 17:42:56 -07006435 continue;
6436 }
François Gaffiec005e562018-11-06 15:04:49 +01006437 ALOGVV("%s() %s (curDevice %s)", __func__,
6438 mute ? "muting" : "unmuting", curDevices.toString().c_str());
6439 setStrategyMute(productStrategy, mute, desc, mute ? 0 : delayMs);
6440 if (desc->isStrategyActive(productStrategy)) {
Eric Laurent99401132014-05-07 19:48:15 -07006441 if (mute) {
6442 // FIXME: should not need to double latency if volume could be applied
6443 // immediately by the audioflinger mixer. We must account for the delay
6444 // between now and the next time the audioflinger thread for this output
6445 // will process a buffer (which corresponds to one buffer size,
6446 // usually 1/2 or 1/4 of the latency).
6447 if (muteWaitMs < desc->latency() * 2) {
6448 muteWaitMs = desc->latency() * 2;
Eric Laurente552edb2014-03-10 17:42:56 -07006449 }
6450 }
6451 }
6452 }
6453 }
6454 }
6455
Eric Laurent99401132014-05-07 19:48:15 -07006456 // temporary mute output if device selection changes to avoid volume bursts due to
6457 // different per device volumes
François Gaffiec005e562018-11-06 15:04:49 +01006458 if (outputDesc->isActive() && (devices != prevDevices)) {
Eric Laurentdc462862016-07-19 12:29:53 -07006459 uint32_t tempMuteWaitMs = outputDesc->latency() * 2;
Jasmine Chaf6074fe2021-08-17 13:44:31 +08006460
Eric Laurentdc462862016-07-19 12:29:53 -07006461 if (muteWaitMs < tempMuteWaitMs) {
6462 muteWaitMs = tempMuteWaitMs;
Eric Laurent99401132014-05-07 19:48:15 -07006463 }
Jasmine Chaf6074fe2021-08-17 13:44:31 +08006464
6465 // If recommended duration is defined, replace temporary mute duration to avoid
6466 // truncated notifications at beginning, which depends on duration of changing path in HAL.
6467 // Otherwise, temporary mute duration is conservatively set to 4 times the reported latency.
6468 uint32_t tempRecommendedMuteDuration = outputDesc->getRecommendedMuteDurationMs();
6469 uint32_t tempMuteDurationMs = tempRecommendedMuteDuration > 0 ?
6470 tempRecommendedMuteDuration : outputDesc->latency() * 4;
6471
François Gaffieaaac0fd2018-11-22 17:56:39 +01006472 for (const auto &activeVs : outputDesc->getActiveVolumeSources()) {
6473 // make sure that we do not start the temporary mute period too early in case of
6474 // delayed device change
6475 setVolumeSourceMute(activeVs, true, outputDesc, delayMs);
6476 setVolumeSourceMute(activeVs, false, outputDesc, delayMs + tempMuteDurationMs,
François Gaffiec005e562018-11-06 15:04:49 +01006477 devices.types());
Eric Laurent99401132014-05-07 19:48:15 -07006478 }
6479 }
6480
Eric Laurente552edb2014-03-10 17:42:56 -07006481 // wait for the PCM output buffers to empty before proceeding with the rest of the command
6482 if (muteWaitMs > delayMs) {
6483 muteWaitMs -= delayMs;
6484 usleep(muteWaitMs * 1000);
6485 return muteWaitMs;
6486 }
6487 return 0;
6488}
6489
François Gaffie11d30102018-11-02 16:09:09 +01006490uint32_t AudioPolicyManager::setOutputDevices(const sp<SwAudioOutputDescriptor>& outputDesc,
6491 const DeviceVector &devices,
6492 bool force,
6493 int delayMs,
6494 audio_patch_handle_t *patchHandle,
6495 bool requiresMuteCheck)
Eric Laurente552edb2014-03-10 17:42:56 -07006496{
François Gaffie11d30102018-11-02 16:09:09 +01006497 ALOGV("%s device %s delayMs %d", __func__, devices.toString().c_str(), delayMs);
Eric Laurente552edb2014-03-10 17:42:56 -07006498 uint32_t muteWaitMs;
6499
6500 if (outputDesc->isDuplicated()) {
François Gaffie11d30102018-11-02 16:09:09 +01006501 muteWaitMs = setOutputDevices(outputDesc->subOutput1(), devices, force, delayMs,
6502 nullptr /* patchHandle */, requiresMuteCheck);
6503 muteWaitMs += setOutputDevices(outputDesc->subOutput2(), devices, force, delayMs,
6504 nullptr /* patchHandle */, requiresMuteCheck);
Eric Laurente552edb2014-03-10 17:42:56 -07006505 return muteWaitMs;
6506 }
Eric Laurente552edb2014-03-10 17:42:56 -07006507
6508 // filter devices according to output selected
Francois Gaffie716e1432019-01-14 16:58:59 +01006509 DeviceVector filteredDevices = outputDesc->filterSupportedDevices(devices);
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01006510 DeviceVector prevDevices = outputDesc->devices();
Eric Laurente552edb2014-03-10 17:42:56 -07006511
François Gaffie11d30102018-11-02 16:09:09 +01006512 ALOGV("setOutputDevices() prevDevice %s", prevDevices.toString().c_str());
6513
6514 if (!filteredDevices.isEmpty()) {
6515 outputDesc->setDevices(filteredDevices);
Eric Laurente552edb2014-03-10 17:42:56 -07006516 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00006517
6518 // if the outputs are not materially active, there is no need to mute.
6519 if (requiresMuteCheck) {
François Gaffiec005e562018-11-06 15:04:49 +01006520 muteWaitMs = checkDeviceMuteStrategies(outputDesc, prevDevices, delayMs);
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00006521 } else {
6522 ALOGV("%s: suppressing checkDeviceMuteStrategies", __func__);
6523 muteWaitMs = 0;
6524 }
Eric Laurente552edb2014-03-10 17:42:56 -07006525
Eric Laurent79ea9582020-06-11 18:49:24 -07006526 // no need to proceed if new device is not AUDIO_DEVICE_NONE and not supported by current
6527 // output profile or if new device is not supported AND previous device(s) is(are) still
6528 // available (otherwise reset device must be done on the output)
6529 if (!devices.isEmpty() && filteredDevices.isEmpty() &&
6530 !mAvailableOutputDevices.filter(prevDevices).empty()) {
6531 ALOGV("%s: unsupported device %s for output", __func__, devices.toString().c_str());
6532 // restore previous device after evaluating strategy mute state
6533 outputDesc->setDevices(prevDevices);
6534 return muteWaitMs;
6535 }
6536
Eric Laurente552edb2014-03-10 17:42:56 -07006537 // Do not change the routing if:
Eric Laurentb80a2a82014-10-27 16:07:59 -07006538 // the requested device is AUDIO_DEVICE_NONE
6539 // OR the requested device is the same as current device
6540 // AND force is not specified
6541 // AND the output is connected by a valid audio patch.
François Gaffie11d30102018-11-02 16:09:09 +01006542 // Doing this check here allows the caller to call setOutputDevices() without conditions
Mikhail Naganov2d4e1702019-01-24 12:59:44 -08006543 if ((filteredDevices.isEmpty() || filteredDevices == prevDevices) &&
François Gaffie11d30102018-11-02 16:09:09 +01006544 !force && outputDesc->getPatchHandle() != 0) {
6545 ALOGV("%s setting same device %s or null device, force=%d, patch handle=%d", __func__,
6546 filteredDevices.toString().c_str(), force, outputDesc->getPatchHandle());
Eric Laurente552edb2014-03-10 17:42:56 -07006547 return muteWaitMs;
6548 }
6549
François Gaffie11d30102018-11-02 16:09:09 +01006550 ALOGV("%s changing device to %s", __func__, filteredDevices.toString().c_str());
Eric Laurent1c333e22014-05-20 10:48:17 -07006551
Eric Laurente552edb2014-03-10 17:42:56 -07006552 // do the routing
François Gaffie11d30102018-11-02 16:09:09 +01006553 if (filteredDevices.isEmpty()) {
Eric Laurentc75307b2015-03-17 15:29:32 -07006554 resetOutputDevice(outputDesc, delayMs, NULL);
Eric Laurent1c333e22014-05-20 10:48:17 -07006555 } else {
François Gaffie11d30102018-11-02 16:09:09 +01006556 PatchBuilder patchBuilder;
6557 patchBuilder.addSource(outputDesc);
6558 ALOG_ASSERT(filteredDevices.size() <= AUDIO_PATCH_PORTS_MAX, "Too many sink ports");
6559 for (const auto &filteredDevice : filteredDevices) {
6560 patchBuilder.addSink(filteredDevice);
Eric Laurentc40d9692016-04-13 19:14:13 -07006561 }
6562
Jasmine Cha7f82d1a2020-03-16 13:21:47 +08006563 // Add half reported latency to delayMs when muteWaitMs is null in order
6564 // to avoid disordered sequence of muting volume and changing devices.
6565 installPatch(__func__, patchHandle, outputDesc.get(), patchBuilder.patch(),
6566 muteWaitMs == 0 ? (delayMs + (outputDesc->latency() / 2)) : delayMs);
Eric Laurent1c333e22014-05-20 10:48:17 -07006567 }
Eric Laurente552edb2014-03-10 17:42:56 -07006568
6569 // update stream volumes according to new device
François Gaffie11d30102018-11-02 16:09:09 +01006570 applyStreamVolumes(outputDesc, filteredDevices.types(), delayMs);
Eric Laurente552edb2014-03-10 17:42:56 -07006571
6572 return muteWaitMs;
6573}
6574
Eric Laurentc75307b2015-03-17 15:29:32 -07006575status_t AudioPolicyManager::resetOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
Eric Laurent6a94d692014-05-20 11:18:06 -07006576 int delayMs,
6577 audio_patch_handle_t *patchHandle)
Eric Laurent1c333e22014-05-20 10:48:17 -07006578{
Eric Laurent6a94d692014-05-20 11:18:06 -07006579 ssize_t index;
6580 if (patchHandle) {
6581 index = mAudioPatches.indexOfKey(*patchHandle);
6582 } else {
Jean-Michel Triviff155c62016-02-26 12:07:16 -08006583 index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07006584 }
6585 if (index < 0) {
Eric Laurent1c333e22014-05-20 10:48:17 -07006586 return INVALID_OPERATION;
6587 }
Eric Laurent6a94d692014-05-20 11:18:06 -07006588 sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01006589 status_t status = mpClientInterface->releaseAudioPatch(patchDesc->getAfHandle(), delayMs);
Eric Laurent1c333e22014-05-20 10:48:17 -07006590 ALOGV("resetOutputDevice() releaseAudioPatch returned %d", status);
Glenn Kastena13cde92016-03-28 15:26:02 -07006591 outputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
François Gaffieafd4cea2019-11-18 15:50:22 +01006592 removeAudioPatch(patchDesc->getHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07006593 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07006594 mpClientInterface->onAudioPatchListUpdate();
Eric Laurent1c333e22014-05-20 10:48:17 -07006595 return status;
6596}
6597
6598status_t AudioPolicyManager::setInputDevice(audio_io_handle_t input,
François Gaffie11d30102018-11-02 16:09:09 +01006599 const sp<DeviceDescriptor> &device,
Eric Laurent6a94d692014-05-20 11:18:06 -07006600 bool force,
6601 audio_patch_handle_t *patchHandle)
Eric Laurent1c333e22014-05-20 10:48:17 -07006602{
6603 status_t status = NO_ERROR;
6604
Eric Laurent1f2f2232014-06-02 12:01:23 -07006605 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
François Gaffie11d30102018-11-02 16:09:09 +01006606 if ((device != nullptr) && ((device != inputDesc->getDevice()) || force)) {
6607 inputDesc->setDevice(device);
Eric Laurent1c333e22014-05-20 10:48:17 -07006608
François Gaffie11d30102018-11-02 16:09:09 +01006609 if (mAvailableInputDevices.contains(device)) {
Mikhail Naganovdc769682018-05-04 15:34:08 -07006610 PatchBuilder patchBuilder;
6611 patchBuilder.addSink(inputDesc,
Eric Laurentdaf92cc2014-07-22 15:36:10 -07006612 // AUDIO_SOURCE_HOTWORD is for internal use only:
6613 // handled as AUDIO_SOURCE_VOICE_RECOGNITION by the audio HAL
Mikhail Naganovdc769682018-05-04 15:34:08 -07006614 [inputDesc](const PatchBuilder::mix_usecase_t& usecase) {
6615 auto result = usecase;
6616 if (result.source == AUDIO_SOURCE_HOTWORD && !inputDesc->isSoundTrigger()) {
6617 result.source = AUDIO_SOURCE_VOICE_RECOGNITION;
6618 }
6619 return result; }).
Eric Laurent1c333e22014-05-20 10:48:17 -07006620 //only one input device for now
François Gaffie11d30102018-11-02 16:09:09 +01006621 addSource(device);
Mikhail Naganovdc769682018-05-04 15:34:08 -07006622 status = installPatch(__func__, patchHandle, inputDesc.get(), patchBuilder.patch(), 0);
Eric Laurent1c333e22014-05-20 10:48:17 -07006623 }
6624 }
6625 return status;
6626}
6627
Eric Laurent6a94d692014-05-20 11:18:06 -07006628status_t AudioPolicyManager::resetInputDevice(audio_io_handle_t input,
6629 audio_patch_handle_t *patchHandle)
Eric Laurent1c333e22014-05-20 10:48:17 -07006630{
Eric Laurent1f2f2232014-06-02 12:01:23 -07006631 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
Eric Laurent6a94d692014-05-20 11:18:06 -07006632 ssize_t index;
6633 if (patchHandle) {
6634 index = mAudioPatches.indexOfKey(*patchHandle);
6635 } else {
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08006636 index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07006637 }
6638 if (index < 0) {
Eric Laurent1c333e22014-05-20 10:48:17 -07006639 return INVALID_OPERATION;
6640 }
Eric Laurent6a94d692014-05-20 11:18:06 -07006641 sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01006642 status_t status = mpClientInterface->releaseAudioPatch(patchDesc->getAfHandle(), 0);
Eric Laurent1c333e22014-05-20 10:48:17 -07006643 ALOGV("resetInputDevice() releaseAudioPatch returned %d", status);
Glenn Kastena13cde92016-03-28 15:26:02 -07006644 inputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
François Gaffieafd4cea2019-11-18 15:50:22 +01006645 removeAudioPatch(patchDesc->getHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07006646 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07006647 mpClientInterface->onAudioPatchListUpdate();
Eric Laurent1c333e22014-05-20 10:48:17 -07006648 return status;
6649}
6650
François Gaffie11d30102018-11-02 16:09:09 +01006651sp<IOProfile> AudioPolicyManager::getInputProfile(const sp<DeviceDescriptor> &device,
François Gaffie53615e22015-03-19 09:24:12 +01006652 uint32_t& samplingRate,
Andy Hungf129b032015-04-07 13:45:50 -07006653 audio_format_t& format,
6654 audio_channel_mask_t& channelMask,
François Gaffie53615e22015-03-19 09:24:12 +01006655 audio_input_flags_t flags)
Eric Laurente552edb2014-03-10 17:42:56 -07006656{
6657 // Choose an input profile based on the requested capture parameters: select the first available
6658 // profile supporting all requested parameters.
Andy Hungf129b032015-04-07 13:45:50 -07006659 //
6660 // TODO: perhaps isCompatibleProfile should return a "matching" score so we can return
6661 // the best matching profile, not the first one.
Eric Laurente552edb2014-03-10 17:42:56 -07006662
Glenn Kasten730b9262018-03-29 15:01:26 -07006663 sp<IOProfile> firstInexact;
6664 uint32_t updatedSamplingRate = 0;
6665 audio_format_t updatedFormat = AUDIO_FORMAT_INVALID;
6666 audio_channel_mask_t updatedChannelMask = AUDIO_CHANNEL_INVALID;
Mikhail Naganov7e22e942017-12-07 10:04:29 -08006667 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08006668 for (const auto& profile : hwModule->getInputProfiles()) {
Eric Laurentd4692962014-05-05 18:13:44 -07006669 // profile->log();
Glenn Kasten730b9262018-03-29 15:01:26 -07006670 //updatedFormat = format;
François Gaffie11d30102018-11-02 16:09:09 +01006671 if (profile->isCompatibleProfile(DeviceVector(device), samplingRate,
Glenn Kasten730b9262018-03-29 15:01:26 -07006672 &samplingRate /*updatedSamplingRate*/,
Andy Hungf129b032015-04-07 13:45:50 -07006673 format,
Glenn Kasten730b9262018-03-29 15:01:26 -07006674 &format, /*updatedFormat*/
Andy Hungf129b032015-04-07 13:45:50 -07006675 channelMask,
Glenn Kasten730b9262018-03-29 15:01:26 -07006676 &channelMask /*updatedChannelMask*/,
6677 // FIXME ugly cast
6678 (audio_output_flags_t) flags,
6679 true /*exactMatchRequiredForInputFlags*/)) {
Eric Laurente552edb2014-03-10 17:42:56 -07006680 return profile;
6681 }
François Gaffie11d30102018-11-02 16:09:09 +01006682 if (firstInexact == nullptr && profile->isCompatibleProfile(DeviceVector(device),
Glenn Kasten730b9262018-03-29 15:01:26 -07006683 samplingRate,
6684 &updatedSamplingRate,
6685 format,
6686 &updatedFormat,
6687 channelMask,
6688 &updatedChannelMask,
6689 // FIXME ugly cast
6690 (audio_output_flags_t) flags,
6691 false /*exactMatchRequiredForInputFlags*/)) {
6692 firstInexact = profile;
6693 }
6694
Eric Laurente552edb2014-03-10 17:42:56 -07006695 }
6696 }
Glenn Kasten730b9262018-03-29 15:01:26 -07006697 if (firstInexact != nullptr) {
6698 samplingRate = updatedSamplingRate;
6699 format = updatedFormat;
6700 channelMask = updatedChannelMask;
6701 return firstInexact;
6702 }
Eric Laurente552edb2014-03-10 17:42:56 -07006703 return NULL;
6704}
6705
François Gaffieaaac0fd2018-11-22 17:56:39 +01006706float AudioPolicyManager::computeVolume(IVolumeCurves &curves,
6707 VolumeSource volumeSource,
François Gaffied1ab2bd2015-12-02 18:20:06 +01006708 int index,
jiabin9a3361e2019-10-01 09:38:30 -07006709 const DeviceTypeSet& deviceTypes)
Eric Laurente552edb2014-03-10 17:42:56 -07006710{
jiabin9a3361e2019-10-01 09:38:30 -07006711 float volumeDb = curves.volIndexToDb(Volume::getDeviceCategory(deviceTypes), index);
Jean-Michel Trivi3d8b4a42016-09-14 18:37:46 -07006712
6713 // handle the case of accessibility active while a ringtone is playing: if the ringtone is much
6714 // louder than the accessibility prompt, the prompt cannot be heard, thus masking the touch
6715 // exploration of the dialer UI. In this situation, bring the accessibility volume closer to
6716 // the ringtone volume
François Gaffieaaac0fd2018-11-22 17:56:39 +01006717 const auto callVolumeSrc = toVolumeSource(AUDIO_STREAM_VOICE_CALL);
6718 const auto ringVolumeSrc = toVolumeSource(AUDIO_STREAM_RING);
6719 const auto musicVolumeSrc = toVolumeSource(AUDIO_STREAM_MUSIC);
6720 const auto alarmVolumeSrc = toVolumeSource(AUDIO_STREAM_ALARM);
Jean-Michel Trivi441ed652019-07-11 14:55:16 -07006721 const auto a11yVolumeSrc = toVolumeSource(AUDIO_STREAM_ACCESSIBILITY);
François Gaffieaaac0fd2018-11-22 17:56:39 +01006722
Jean-Michel Trivi441ed652019-07-11 14:55:16 -07006723 if (volumeSource == a11yVolumeSrc
François Gaffieaaac0fd2018-11-22 17:56:39 +01006724 && (AUDIO_MODE_RINGTONE == mEngine->getPhoneState()) &&
6725 mOutputs.isActive(ringVolumeSrc, 0)) {
6726 auto &ringCurves = getVolumeCurves(AUDIO_STREAM_RING);
jiabin9a3361e2019-10-01 09:38:30 -07006727 const float ringVolumeDb = computeVolume(ringCurves, ringVolumeSrc, index, deviceTypes);
François Gaffieaaac0fd2018-11-22 17:56:39 +01006728 return ringVolumeDb - 4 > volumeDb ? ringVolumeDb - 4 : volumeDb;
Jean-Michel Trivi3d8b4a42016-09-14 18:37:46 -07006729 }
6730
Eric Laurentdcd4ab12018-06-29 17:45:13 -07006731 // in-call: always cap volume by voice volume + some low headroom
François Gaffieaaac0fd2018-11-22 17:56:39 +01006732 if ((volumeSource != callVolumeSrc && (isInCall() ||
6733 mOutputs.isActiveLocally(callVolumeSrc))) &&
6734 (volumeSource == toVolumeSource(AUDIO_STREAM_SYSTEM) ||
6735 volumeSource == ringVolumeSrc || volumeSource == musicVolumeSrc ||
6736 volumeSource == alarmVolumeSrc ||
6737 volumeSource == toVolumeSource(AUDIO_STREAM_NOTIFICATION) ||
6738 volumeSource == toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE) ||
6739 volumeSource == toVolumeSource(AUDIO_STREAM_DTMF) ||
Jean-Michel Trivi441ed652019-07-11 14:55:16 -07006740 volumeSource == a11yVolumeSrc)) {
François Gaffieaaac0fd2018-11-22 17:56:39 +01006741 auto &voiceCurves = getVolumeCurves(callVolumeSrc);
jiabin9a3361e2019-10-01 09:38:30 -07006742 int voiceVolumeIndex = voiceCurves.getVolumeIndex(deviceTypes);
François Gaffieaaac0fd2018-11-22 17:56:39 +01006743 const float maxVoiceVolDb =
jiabin9a3361e2019-10-01 09:38:30 -07006744 computeVolume(voiceCurves, callVolumeSrc, voiceVolumeIndex, deviceTypes)
Eric Laurent7731b5a2018-04-06 15:47:22 -07006745 + IN_CALL_EARPIECE_HEADROOM_DB;
Abhijith Shastry329ddab2019-04-23 11:53:26 -07006746 // FIXME: Workaround for call screening applications until a proper audio mode is defined
6747 // to support this scenario : Exempt the RING stream from the audio cap if the audio was
6748 // programmatically muted.
6749 // VOICE_CALL stream has minVolumeIndex > 0 : Users cannot set the volume of voice calls to
6750 // 0. We don't want to cap volume when the system has programmatically muted the voice call
6751 // stream. See setVolumeCurveIndex() for more information.
Jean-Michel Trivi441ed652019-07-11 14:55:16 -07006752 bool exemptFromCapping =
6753 ((volumeSource == ringVolumeSrc) || (volumeSource == a11yVolumeSrc))
6754 && (voiceVolumeIndex == 0);
Abhijith Shastry329ddab2019-04-23 11:53:26 -07006755 ALOGV_IF(exemptFromCapping, "%s volume source %d at vol=%f not capped", __func__,
6756 volumeSource, volumeDb);
6757 if ((volumeDb > maxVoiceVolDb) && !exemptFromCapping) {
François Gaffieaaac0fd2018-11-22 17:56:39 +01006758 ALOGV("%s volume source %d at vol=%f overriden by volume group %d at vol=%f", __func__,
6759 volumeSource, volumeDb, callVolumeSrc, maxVoiceVolDb);
6760 volumeDb = maxVoiceVolDb;
Jean-Michel Trivi719a9872017-08-05 13:51:35 -07006761 }
6762 }
Eric Laurente552edb2014-03-10 17:42:56 -07006763 // if a headset is connected, apply the following rules to ring tones and notifications
6764 // to avoid sound level bursts in user's ears:
Eric Laurent6af1c1d2016-04-14 11:20:44 -07006765 // - always attenuate notifications volume by 6dB
6766 // - attenuate ring tones volume by 6dB unless music is not playing and
6767 // speaker is part of the select devices
Eric Laurente552edb2014-03-10 17:42:56 -07006768 // - if music is playing, always limit the volume to current music volume,
6769 // with a minimum threshold at -36dB so that notification is always perceived.
jiabin9a3361e2019-10-01 09:38:30 -07006770 if (!Intersection(deviceTypes,
6771 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES,
6772 AUDIO_DEVICE_OUT_WIRED_HEADSET, AUDIO_DEVICE_OUT_WIRED_HEADPHONE,
Eric Laurentc42df452020-08-07 10:51:53 -07006773 AUDIO_DEVICE_OUT_USB_HEADSET, AUDIO_DEVICE_OUT_HEARING_AID,
6774 AUDIO_DEVICE_OUT_BLE_HEADSET}).empty() &&
François Gaffieaaac0fd2018-11-22 17:56:39 +01006775 ((volumeSource == alarmVolumeSrc ||
6776 volumeSource == ringVolumeSrc) ||
6777 (volumeSource == toVolumeSource(AUDIO_STREAM_NOTIFICATION)) ||
6778 (volumeSource == toVolumeSource(AUDIO_STREAM_SYSTEM)) ||
6779 ((volumeSource == toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE)) &&
6780 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_NONE))) &&
6781 curves.canBeMuted()) {
6782
Eric Laurente552edb2014-03-10 17:42:56 -07006783 // when the phone is ringing we must consider that music could have been paused just before
6784 // by the music application and behave as if music was active if the last music track was
6785 // just stopped
Eric Laurent3b73df72014-03-11 09:06:29 -07006786 if (isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY) ||
Eric Laurente552edb2014-03-10 17:42:56 -07006787 mLimitRingtoneVolume) {
François Gaffie43c73442018-11-08 08:21:55 +01006788 volumeDb += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
jiabin9a3361e2019-10-01 09:38:30 -07006789 DeviceTypeSet musicDevice =
François Gaffiec005e562018-11-06 15:04:49 +01006790 mEngine->getOutputDevicesForAttributes(attributes_initializer(AUDIO_USAGE_MEDIA),
6791 nullptr, true /*fromCache*/).types();
François Gaffieaaac0fd2018-11-22 17:56:39 +01006792 auto &musicCurves = getVolumeCurves(AUDIO_STREAM_MUSIC);
jiabin9a3361e2019-10-01 09:38:30 -07006793 float musicVolDb = computeVolume(musicCurves,
6794 musicVolumeSrc,
6795 musicCurves.getVolumeIndex(musicDevice),
6796 musicDevice);
François Gaffieaaac0fd2018-11-22 17:56:39 +01006797 float minVolDb = (musicVolDb > SONIFICATION_HEADSET_VOLUME_MIN_DB) ?
6798 musicVolDb : SONIFICATION_HEADSET_VOLUME_MIN_DB;
6799 if (volumeDb > minVolDb) {
6800 volumeDb = minVolDb;
6801 ALOGV("computeVolume limiting volume to %f musicVol %f", minVolDb, musicVolDb);
Eric Laurente552edb2014-03-10 17:42:56 -07006802 }
Eric Laurent7b6385c2021-05-12 17:55:36 +02006803 if (Volume::getDeviceForVolume(deviceTypes) != AUDIO_DEVICE_OUT_SPEAKER
6804 && !Intersection(deviceTypes, {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,
6805 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES}).empty()) {
Jean-Michel Trivi00a20962016-05-25 19:11:01 -07006806 // on A2DP, also ensure notification volume is not too low compared to media when
6807 // intended to be played
François Gaffie43c73442018-11-08 08:21:55 +01006808 if ((volumeDb > -96.0f) &&
François Gaffieaaac0fd2018-11-22 17:56:39 +01006809 (musicVolDb - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB > volumeDb)) {
jiabin9a3361e2019-10-01 09:38:30 -07006810 ALOGV("%s increasing volume for volume source=%d device=%s from %f to %f",
6811 __func__, volumeSource, dumpDeviceTypes(deviceTypes).c_str(), volumeDb,
François Gaffieaaac0fd2018-11-22 17:56:39 +01006812 musicVolDb - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB);
6813 volumeDb = musicVolDb - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB;
Jean-Michel Trivi00a20962016-05-25 19:11:01 -07006814 }
6815 }
jiabin9a3361e2019-10-01 09:38:30 -07006816 } else if ((Volume::getDeviceForVolume(deviceTypes) != AUDIO_DEVICE_OUT_SPEAKER) ||
François Gaffieaaac0fd2018-11-22 17:56:39 +01006817 (!(volumeSource == alarmVolumeSrc || volumeSource == ringVolumeSrc))) {
François Gaffie43c73442018-11-08 08:21:55 +01006818 volumeDb += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
Eric Laurente552edb2014-03-10 17:42:56 -07006819 }
6820 }
6821
François Gaffie43c73442018-11-08 08:21:55 +01006822 return volumeDb;
Eric Laurente552edb2014-03-10 17:42:56 -07006823}
6824
Eric Laurent3839bc02018-07-10 18:33:34 -07006825int AudioPolicyManager::rescaleVolumeIndex(int srcIndex,
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01006826 VolumeSource fromVolumeSource,
6827 VolumeSource toVolumeSource)
Eric Laurent3839bc02018-07-10 18:33:34 -07006828{
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01006829 if (fromVolumeSource == toVolumeSource) {
Eric Laurent3839bc02018-07-10 18:33:34 -07006830 return srcIndex;
6831 }
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01006832 auto &srcCurves = getVolumeCurves(fromVolumeSource);
6833 auto &dstCurves = getVolumeCurves(toVolumeSource);
Eric Laurentf5aa58d2019-02-22 18:20:11 -08006834 float minSrc = (float)srcCurves.getVolumeIndexMin();
6835 float maxSrc = (float)srcCurves.getVolumeIndexMax();
6836 float minDst = (float)dstCurves.getVolumeIndexMin();
6837 float maxDst = (float)dstCurves.getVolumeIndexMax();
Eric Laurent3839bc02018-07-10 18:33:34 -07006838
Revathi Uddarajufe0fb8b2017-07-27 17:05:37 +08006839 // preserve mute request or correct range
6840 if (srcIndex < minSrc) {
6841 if (srcIndex == 0) {
6842 return 0;
6843 }
6844 srcIndex = minSrc;
6845 } else if (srcIndex > maxSrc) {
6846 srcIndex = maxSrc;
6847 }
Eric Laurent3839bc02018-07-10 18:33:34 -07006848 return (int)(minDst + ((srcIndex - minSrc) * (maxDst - minDst)) / (maxSrc - minSrc));
6849}
6850
François Gaffieaaac0fd2018-11-22 17:56:39 +01006851status_t AudioPolicyManager::checkAndSetVolume(IVolumeCurves &curves,
6852 VolumeSource volumeSource,
Eric Laurentf5aa58d2019-02-22 18:20:11 -08006853 int index,
6854 const sp<AudioOutputDescriptor>& outputDesc,
jiabin9a3361e2019-10-01 09:38:30 -07006855 DeviceTypeSet deviceTypes,
Eric Laurentf5aa58d2019-02-22 18:20:11 -08006856 int delayMs,
6857 bool force)
Eric Laurente552edb2014-03-10 17:42:56 -07006858{
François Gaffieaaac0fd2018-11-22 17:56:39 +01006859 // do not change actual attributes volume if the attributes is muted
6860 if (outputDesc->isMuted(volumeSource)) {
6861 ALOGVV("%s: volume source %d muted count %d active=%d", __func__, volumeSource,
6862 outputDesc->getMuteCount(volumeSource), outputDesc->isActive(volumeSource));
Eric Laurente552edb2014-03-10 17:42:56 -07006863 return NO_ERROR;
6864 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01006865 VolumeSource callVolSrc = toVolumeSource(AUDIO_STREAM_VOICE_CALL);
6866 VolumeSource btScoVolSrc = toVolumeSource(AUDIO_STREAM_BLUETOOTH_SCO);
6867 bool isVoiceVolSrc = callVolSrc == volumeSource;
6868 bool isBtScoVolSrc = btScoVolSrc == volumeSource;
6869
Eric Laurent2517af32020-11-25 15:31:27 +01006870 bool isScoRequested = isScoRequestedForComm();
Eric Laurente552edb2014-03-10 17:42:56 -07006871 // do not change in call volume if bluetooth is connected and vice versa
François Gaffieaaac0fd2018-11-22 17:56:39 +01006872 // if sco and call follow same curves, bypass forceUseForComm
6873 if ((callVolSrc != btScoVolSrc) &&
Eric Laurent2517af32020-11-25 15:31:27 +01006874 ((isVoiceVolSrc && isScoRequested) ||
6875 (isBtScoVolSrc && !isScoRequested))) {
6876 ALOGV("%s cannot set volume group %d volume when is%srequested for comm", __func__,
6877 volumeSource, isScoRequested ? " " : "n ot ");
Eric Laurent571ef962020-07-24 11:43:48 -07006878 // Do not return an error here as AudioService will always set both voice call
6879 // and bluetooth SCO volumes due to stream aliasing.
6880 return NO_ERROR;
Eric Laurente552edb2014-03-10 17:42:56 -07006881 }
jiabin9a3361e2019-10-01 09:38:30 -07006882 if (deviceTypes.empty()) {
6883 deviceTypes = outputDesc->devices().types();
Eric Laurentc75307b2015-03-17 15:29:32 -07006884 }
Eric Laurent275e8e92014-11-30 15:14:47 -08006885
jiabin9a3361e2019-10-01 09:38:30 -07006886 float volumeDb = computeVolume(curves, volumeSource, index, deviceTypes);
6887 if (outputDesc->isFixedVolume(deviceTypes) ||
Eric Laurent9698a4c2020-10-12 17:10:23 -07006888 // Force VoIP volume to max for bluetooth SCO device except if muted
6889 (index != 0 && (isVoiceVolSrc || isBtScoVolSrc) &&
jiabin9a3361e2019-10-01 09:38:30 -07006890 isSingleDeviceType(deviceTypes, audio_is_bluetooth_out_sco_device))) {
Eric Laurentffbc80f2015-03-18 18:30:19 -07006891 volumeDb = 0.0f;
Eric Laurent275e8e92014-11-30 15:14:47 -08006892 }
jiabin9a3361e2019-10-01 09:38:30 -07006893 outputDesc->setVolume(
6894 volumeDb, volumeSource, curves.getStreamTypes(), deviceTypes, delayMs, force);
Eric Laurentc75307b2015-03-17 15:29:32 -07006895
Eric Laurente8f2c0f2021-08-17 11:17:19 +02006896 if (outputDesc == mPrimaryOutput && (isVoiceVolSrc || isBtScoVolSrc)) {
Eric Laurente552edb2014-03-10 17:42:56 -07006897 float voiceVolume;
Eric Laurentfad001d2019-06-11 19:17:57 -07006898 // 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 +01006899 if (isVoiceVolSrc) {
6900 voiceVolume = (float)index/(float)curves.getVolumeIndexMax();
Eric Laurente552edb2014-03-10 17:42:56 -07006901 } else {
Eric Laurentfad001d2019-06-11 19:17:57 -07006902 voiceVolume = index == 0 ? 0.0 : 1.0;
Eric Laurente552edb2014-03-10 17:42:56 -07006903 }
Eric Laurent18fba842016-03-31 14:41:26 -07006904 if (voiceVolume != mLastVoiceVolume) {
Eric Laurente552edb2014-03-10 17:42:56 -07006905 mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
6906 mLastVoiceVolume = voiceVolume;
6907 }
6908 }
Eric Laurente552edb2014-03-10 17:42:56 -07006909 return NO_ERROR;
6910}
6911
Eric Laurentc75307b2015-03-17 15:29:32 -07006912void AudioPolicyManager::applyStreamVolumes(const sp<AudioOutputDescriptor>& outputDesc,
jiabin9a3361e2019-10-01 09:38:30 -07006913 const DeviceTypeSet& deviceTypes,
6914 int delayMs,
6915 bool force)
Eric Laurente552edb2014-03-10 17:42:56 -07006916{
jiabincd510522020-01-22 09:40:55 -08006917 ALOGVV("applyStreamVolumes() for device %s", dumpDeviceTypes(deviceTypes).c_str());
François Gaffieaaac0fd2018-11-22 17:56:39 +01006918 for (const auto &volumeGroup : mEngine->getVolumeGroups()) {
6919 auto &curves = getVolumeCurves(toVolumeSource(volumeGroup));
6920 checkAndSetVolume(curves, toVolumeSource(volumeGroup),
jiabin9a3361e2019-10-01 09:38:30 -07006921 curves.getVolumeIndex(deviceTypes),
6922 outputDesc, deviceTypes, delayMs, force);
Eric Laurente552edb2014-03-10 17:42:56 -07006923 }
6924}
6925
François Gaffiec005e562018-11-06 15:04:49 +01006926void AudioPolicyManager::setStrategyMute(product_strategy_t strategy,
6927 bool on,
6928 const sp<AudioOutputDescriptor>& outputDesc,
6929 int delayMs,
jiabin9a3361e2019-10-01 09:38:30 -07006930 DeviceTypeSet deviceTypes)
Eric Laurente552edb2014-03-10 17:42:56 -07006931{
François Gaffieaaac0fd2018-11-22 17:56:39 +01006932 std::vector<VolumeSource> sourcesToMute;
6933 for (auto attributes: mEngine->getAllAttributesForProductStrategy(strategy)) {
6934 ALOGVV("%s() attributes %s, mute %d, output ID %d", __func__,
6935 toString(attributes).c_str(), on, outputDesc->getId());
6936 VolumeSource source = toVolumeSource(attributes);
6937 if (std::find(begin(sourcesToMute), end(sourcesToMute), source) == end(sourcesToMute)) {
6938 sourcesToMute.push_back(source);
6939 }
Eric Laurente552edb2014-03-10 17:42:56 -07006940 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01006941 for (auto source : sourcesToMute) {
jiabin9a3361e2019-10-01 09:38:30 -07006942 setVolumeSourceMute(source, on, outputDesc, delayMs, deviceTypes);
François Gaffieaaac0fd2018-11-22 17:56:39 +01006943 }
6944
Eric Laurente552edb2014-03-10 17:42:56 -07006945}
6946
François Gaffieaaac0fd2018-11-22 17:56:39 +01006947void AudioPolicyManager::setVolumeSourceMute(VolumeSource volumeSource,
6948 bool on,
6949 const sp<AudioOutputDescriptor>& outputDesc,
6950 int delayMs,
jiabin9a3361e2019-10-01 09:38:30 -07006951 DeviceTypeSet deviceTypes)
Eric Laurente552edb2014-03-10 17:42:56 -07006952{
jiabin9a3361e2019-10-01 09:38:30 -07006953 if (deviceTypes.empty()) {
6954 deviceTypes = outputDesc->devices().types();
Eric Laurente552edb2014-03-10 17:42:56 -07006955 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01006956 auto &curves = getVolumeCurves(volumeSource);
Eric Laurente552edb2014-03-10 17:42:56 -07006957 if (on) {
François Gaffieaaac0fd2018-11-22 17:56:39 +01006958 if (!outputDesc->isMuted(volumeSource)) {
Eric Laurentf5aa58d2019-02-22 18:20:11 -08006959 if (curves.canBeMuted() &&
François Gaffieaaac0fd2018-11-22 17:56:39 +01006960 (volumeSource != toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE) ||
6961 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) ==
6962 AUDIO_POLICY_FORCE_NONE))) {
jiabin9a3361e2019-10-01 09:38:30 -07006963 checkAndSetVolume(curves, volumeSource, 0, outputDesc, deviceTypes, delayMs);
Eric Laurente552edb2014-03-10 17:42:56 -07006964 }
6965 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01006966 // increment mMuteCount after calling checkAndSetVolume() so that volume change is not
6967 // ignored
6968 outputDesc->incMuteCount(volumeSource);
Eric Laurente552edb2014-03-10 17:42:56 -07006969 } else {
François Gaffieaaac0fd2018-11-22 17:56:39 +01006970 if (!outputDesc->isMuted(volumeSource)) {
6971 ALOGV("%s unmuting non muted attributes!", __func__);
Eric Laurente552edb2014-03-10 17:42:56 -07006972 return;
6973 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01006974 if (outputDesc->decMuteCount(volumeSource) == 0) {
6975 checkAndSetVolume(curves, volumeSource,
jiabin9a3361e2019-10-01 09:38:30 -07006976 curves.getVolumeIndex(deviceTypes),
Eric Laurentc75307b2015-03-17 15:29:32 -07006977 outputDesc,
jiabin9a3361e2019-10-01 09:38:30 -07006978 deviceTypes,
Eric Laurente552edb2014-03-10 17:42:56 -07006979 delayMs);
6980 }
6981 }
6982}
6983
François Gaffie53615e22015-03-19 09:24:12 +01006984bool AudioPolicyManager::isValidAttributes(const audio_attributes_t *paa)
6985{
François Gaffiec005e562018-11-06 15:04:49 +01006986 // has flags that map to a stream type?
Eric Laurente83b55d2014-11-14 10:06:21 -08006987 if ((paa->flags & (AUDIO_FLAG_AUDIBILITY_ENFORCED | AUDIO_FLAG_SCO | AUDIO_FLAG_BEACON)) != 0) {
6988 return true;
6989 }
6990
6991 // has known usage?
6992 switch (paa->usage) {
6993 case AUDIO_USAGE_UNKNOWN:
6994 case AUDIO_USAGE_MEDIA:
6995 case AUDIO_USAGE_VOICE_COMMUNICATION:
6996 case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
6997 case AUDIO_USAGE_ALARM:
6998 case AUDIO_USAGE_NOTIFICATION:
6999 case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
7000 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
7001 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
7002 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
7003 case AUDIO_USAGE_NOTIFICATION_EVENT:
7004 case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
7005 case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
7006 case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
7007 case AUDIO_USAGE_GAME:
Eric Laurent275e8e92014-11-30 15:14:47 -08007008 case AUDIO_USAGE_VIRTUAL_SOURCE:
Jean-Michel Trivi36867762016-12-29 12:03:28 -08007009 case AUDIO_USAGE_ASSISTANT:
Eric Laurent21777f82019-12-06 18:12:06 -08007010 case AUDIO_USAGE_CALL_ASSISTANT:
Hayden Gomes524159d2019-12-23 14:41:47 -08007011 case AUDIO_USAGE_EMERGENCY:
7012 case AUDIO_USAGE_SAFETY:
7013 case AUDIO_USAGE_VEHICLE_STATUS:
7014 case AUDIO_USAGE_ANNOUNCEMENT:
Eric Laurente83b55d2014-11-14 10:06:21 -08007015 break;
7016 default:
7017 return false;
7018 }
7019 return true;
7020}
7021
François Gaffie2110e042015-03-24 08:41:51 +01007022audio_policy_forced_cfg_t AudioPolicyManager::getForceUse(audio_policy_force_use_t usage)
7023{
7024 return mEngine->getForceUse(usage);
7025}
7026
7027bool AudioPolicyManager::isInCall()
7028{
7029 return isStateInCall(mEngine->getPhoneState());
7030}
7031
7032bool AudioPolicyManager::isStateInCall(int state)
7033{
7034 return is_state_in_call(state);
7035}
7036
Eric Laurent74b71512019-11-06 17:21:57 -08007037bool AudioPolicyManager::isCallAudioAccessible()
7038{
7039 audio_mode_t mode = mEngine->getPhoneState();
7040 return (mode == AUDIO_MODE_IN_CALL)
Eric Laurentc8c4f1f2021-11-09 11:51:34 +01007041 || (mode == AUDIO_MODE_CALL_SCREEN)
7042 || (mode == AUDIO_MODE_CALL_REDIRECT);
Eric Laurent74b71512019-11-06 17:21:57 -08007043}
7044
Eric Laurentd60560a2015-04-10 11:31:20 -07007045void AudioPolicyManager::cleanUpForDevice(const sp<DeviceDescriptor>& deviceDesc)
7046{
7047 for (ssize_t i = (ssize_t)mAudioSources.size() - 1; i >= 0; i--) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07007048 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
Francois Gaffiea0e5c992020-09-29 16:05:07 +02007049 if (sourceDesc->isConnected() && (sourceDesc->srcDevice()->equals(deviceDesc) ||
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02007050 sourceDesc->sinkDevice()->equals(deviceDesc))
7051 && !isCallRxAudioSource(sourceDesc)) {
Francois Gaffiea0e5c992020-09-29 16:05:07 +02007052 disconnectAudioSource(sourceDesc);
Eric Laurentd60560a2015-04-10 11:31:20 -07007053 }
7054 }
7055
7056 for (ssize_t i = (ssize_t)mAudioPatches.size() - 1; i >= 0; i--) {
7057 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(i);
7058 bool release = false;
7059 for (size_t j = 0; j < patchDesc->mPatch.num_sources && !release; j++) {
7060 const struct audio_port_config *source = &patchDesc->mPatch.sources[j];
7061 if (source->type == AUDIO_PORT_TYPE_DEVICE &&
7062 source->ext.device.type == deviceDesc->type()) {
7063 release = true;
7064 }
7065 }
Francois Gaffiea0e5c992020-09-29 16:05:07 +02007066 const char *address = deviceDesc->address().c_str();
Eric Laurentd60560a2015-04-10 11:31:20 -07007067 for (size_t j = 0; j < patchDesc->mPatch.num_sinks && !release; j++) {
7068 const struct audio_port_config *sink = &patchDesc->mPatch.sinks[j];
7069 if (sink->type == AUDIO_PORT_TYPE_DEVICE &&
Francois Gaffiea0e5c992020-09-29 16:05:07 +02007070 sink->ext.device.type == deviceDesc->type() &&
7071 (strnlen(address, AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0
7072 || strncmp(sink->ext.device.address, address,
7073 AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0)) {
Eric Laurentd60560a2015-04-10 11:31:20 -07007074 release = true;
7075 }
7076 }
7077 if (release) {
François Gaffieafd4cea2019-11-18 15:50:22 +01007078 ALOGV("%s releasing patch %u", __FUNCTION__, patchDesc->getHandle());
7079 releaseAudioPatch(patchDesc->getHandle(), patchDesc->getUid());
Eric Laurentd60560a2015-04-10 11:31:20 -07007080 }
7081 }
Francois Gaffie716e1432019-01-14 16:58:59 +01007082
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01007083 mInputs.clearSessionRoutesForDevice(deviceDesc);
7084
Francois Gaffie716e1432019-01-14 16:58:59 +01007085 mHwModules.cleanUpForDevice(deviceDesc);
Eric Laurentd60560a2015-04-10 11:31:20 -07007086}
7087
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007088void AudioPolicyManager::modifySurroundFormats(
7089 const sp<DeviceDescriptor>& devDesc, FormatVector *formatsPtr) {
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007090 std::unordered_set<audio_format_t> enforcedSurround(
7091 devDesc->encodedFormats().begin(), devDesc->encodedFormats().end());
Mikhail Naganov100f0122018-11-29 11:22:16 -08007092 std::unordered_set<audio_format_t> allSurround; // A flat set of all known surround formats
7093 for (const auto& pair : mConfig.getSurroundFormats()) {
7094 allSurround.insert(pair.first);
7095 for (const auto& subformat : pair.second) allSurround.insert(subformat);
7096 }
Phil Burk09bc4612016-02-24 15:58:15 -08007097
7098 audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
7099 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
Phil Burk0709b0a2016-03-31 12:54:57 -07007100 ALOGD("%s: forced use = %d", __FUNCTION__, forceUse);
Mikhail Naganov100f0122018-11-29 11:22:16 -08007101 // This is the resulting set of formats depending on the surround mode:
7102 // 'all surround' = allSurround
7103 // 'enforced surround' = enforcedSurround [may include IEC69137 which isn't raw surround fmt]
7104 // 'non-surround' = not in 'all surround' and not in 'enforced surround'
7105 // 'manual surround' = mManualSurroundFormats
7106 // AUTO: formats v 'enforced surround'
7107 // ALWAYS: formats v 'all surround' v 'enforced surround'
7108 // NEVER: formats ^ 'non-surround'
7109 // MANUAL: formats ^ ('non-surround' v 'manual surround' v (IEC69137 ^ 'enforced surround'))
Phil Burk09bc4612016-02-24 15:58:15 -08007110
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007111 std::unordered_set<audio_format_t> formatSet;
7112 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL
7113 || forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08007114 // formatSet is (formats ^ 'non-surround')
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007115 for (auto formatIter = formatsPtr->begin(); formatIter != formatsPtr->end(); ++formatIter) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08007116 if (allSurround.count(*formatIter) == 0 && enforcedSurround.count(*formatIter) == 0) {
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007117 formatSet.insert(*formatIter);
7118 }
7119 }
7120 } else {
7121 formatSet.insert(formatsPtr->begin(), formatsPtr->end());
7122 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08007123 formatsPtr->clear(); // Re-filled from the formatSet at the end.
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007124
jiabin81772902018-04-02 17:52:27 -07007125 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08007126 formatSet.insert(mManualSurroundFormats.begin(), mManualSurroundFormats.end());
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007127 // Enable IEC61937 when in MANUAL mode if it's enforced for this device.
7128 if (enforcedSurround.count(AUDIO_FORMAT_IEC61937) != 0) {
7129 formatSet.insert(AUDIO_FORMAT_IEC61937);
Phil Burk09bc4612016-02-24 15:58:15 -08007130 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08007131 } else if (forceUse != AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) { // AUTO or ALWAYS
7132 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS) {
7133 formatSet.insert(allSurround.begin(), allSurround.end());
Phil Burk07ac1142016-03-25 13:39:29 -07007134 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08007135 formatSet.insert(enforcedSurround.begin(), enforcedSurround.end());
Phil Burk09bc4612016-02-24 15:58:15 -08007136 }
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007137 for (const auto& format : formatSet) {
jiabin06e4bab2019-07-29 10:13:34 -07007138 formatsPtr->push_back(format);
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007139 }
Phil Burk0709b0a2016-03-31 12:54:57 -07007140}
7141
jiabin06e4bab2019-07-29 10:13:34 -07007142void AudioPolicyManager::modifySurroundChannelMasks(ChannelMaskSet *channelMasksPtr) {
7143 ChannelMaskSet &channelMasks = *channelMasksPtr;
Phil Burk0709b0a2016-03-31 12:54:57 -07007144 audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
7145 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
7146
7147 // If NEVER, then remove support for channelMasks > stereo.
7148 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) {
jiabin06e4bab2019-07-29 10:13:34 -07007149 for (auto it = channelMasks.begin(); it != channelMasks.end();) {
7150 audio_channel_mask_t channelMask = *it;
Phil Burk0709b0a2016-03-31 12:54:57 -07007151 if (channelMask & ~AUDIO_CHANNEL_OUT_STEREO) {
Eric Laurentfecbceb2021-02-09 14:46:43 +01007152 ALOGV("%s: force NEVER, so remove channelMask 0x%08x", __FUNCTION__, channelMask);
jiabin06e4bab2019-07-29 10:13:34 -07007153 it = channelMasks.erase(it);
Phil Burk0709b0a2016-03-31 12:54:57 -07007154 } else {
jiabin06e4bab2019-07-29 10:13:34 -07007155 ++it;
Phil Burk0709b0a2016-03-31 12:54:57 -07007156 }
7157 }
jiabin81772902018-04-02 17:52:27 -07007158 // If ALWAYS or MANUAL, then make sure we at least support 5.1
7159 } else if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS
7160 || forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
Phil Burk0709b0a2016-03-31 12:54:57 -07007161 bool supports5dot1 = false;
7162 // Are there any channel masks that can be considered "surround"?
Mikhail Naganovcf84e592017-12-07 11:25:11 -08007163 for (audio_channel_mask_t channelMask : channelMasks) {
Phil Burk0709b0a2016-03-31 12:54:57 -07007164 if ((channelMask & AUDIO_CHANNEL_OUT_5POINT1) == AUDIO_CHANNEL_OUT_5POINT1) {
7165 supports5dot1 = true;
7166 break;
7167 }
7168 }
7169 // If not then add 5.1 support.
7170 if (!supports5dot1) {
jiabin06e4bab2019-07-29 10:13:34 -07007171 channelMasks.insert(AUDIO_CHANNEL_OUT_5POINT1);
Eric Laurentfecbceb2021-02-09 14:46:43 +01007172 ALOGV("%s: force MANUAL or ALWAYS, so adding channelMask for 5.1 surround", __func__);
Phil Burk0709b0a2016-03-31 12:54:57 -07007173 }
Phil Burk09bc4612016-02-24 15:58:15 -08007174 }
7175}
7176
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007177void AudioPolicyManager::updateAudioProfiles(const sp<DeviceDescriptor>& devDesc,
Phil Burk00eeb322016-03-31 12:41:00 -07007178 audio_io_handle_t ioHandle,
François Gaffie112b0af2015-11-19 16:13:25 +01007179 AudioProfileVector &profiles)
7180{
7181 String8 reply;
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007182 audio_devices_t device = devDesc->type();
Phil Burk0709b0a2016-03-31 12:54:57 -07007183
François Gaffie112b0af2015-11-19 16:13:25 +01007184 // Format MUST be checked first to update the list of AudioProfile
7185 if (profiles.hasDynamicFormat()) {
Mikhail Naganov388360c2016-10-17 17:09:41 -07007186 reply = mpClientInterface->getParameters(
7187 ioHandle, String8(AudioParameter::keyStreamSupportedFormats));
jiabin81772902018-04-02 17:52:27 -07007188 ALOGV("%s: supported formats %d, %s", __FUNCTION__, ioHandle, reply.string());
Eric Laurent62e4bc52016-02-02 18:37:28 -08007189 AudioParameter repliedParameters(reply);
7190 if (repliedParameters.get(
Mikhail Naganov388360c2016-10-17 17:09:41 -07007191 String8(AudioParameter::keyStreamSupportedFormats), reply) != NO_ERROR) {
François Gaffie112b0af2015-11-19 16:13:25 +01007192 ALOGE("%s: failed to retrieve format, bailing out", __FUNCTION__);
7193 return;
7194 }
Phil Burk09bc4612016-02-24 15:58:15 -08007195 FormatVector formats = formatsFromString(reply.string());
Kriti Dangef6be8f2020-11-05 11:58:19 +01007196 mReportedFormatsMap[devDesc] = formats;
Mikhail Naganov100f0122018-11-29 11:22:16 -08007197 if (device == AUDIO_DEVICE_OUT_HDMI
7198 || isDeviceOfModule(devDesc, AUDIO_HARDWARE_MODULE_ID_MSD)) {
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007199 modifySurroundFormats(devDesc, &formats);
Phil Burk00eeb322016-03-31 12:41:00 -07007200 }
jiabin3e277cc2019-09-10 14:27:34 -07007201 addProfilesForFormats(profiles, formats);
François Gaffie112b0af2015-11-19 16:13:25 +01007202 }
François Gaffie112b0af2015-11-19 16:13:25 +01007203
Mikhail Naganovcf84e592017-12-07 11:25:11 -08007204 for (audio_format_t format : profiles.getSupportedFormats()) {
jiabin06e4bab2019-07-29 10:13:34 -07007205 ChannelMaskSet channelMasks;
7206 SampleRateSet samplingRates;
François Gaffie112b0af2015-11-19 16:13:25 +01007207 AudioParameter requestedParameters;
Mikhail Naganov388360c2016-10-17 17:09:41 -07007208 requestedParameters.addInt(String8(AudioParameter::keyFormat), format);
François Gaffie112b0af2015-11-19 16:13:25 +01007209
7210 if (profiles.hasDynamicRateFor(format)) {
Mikhail Naganov388360c2016-10-17 17:09:41 -07007211 reply = mpClientInterface->getParameters(
7212 ioHandle,
7213 requestedParameters.toString() + ";" +
7214 AudioParameter::keyStreamSupportedSamplingRates);
François Gaffie112b0af2015-11-19 16:13:25 +01007215 ALOGV("%s: supported sampling rates %s", __FUNCTION__, reply.string());
Eric Laurent62e4bc52016-02-02 18:37:28 -08007216 AudioParameter repliedParameters(reply);
7217 if (repliedParameters.get(
Mikhail Naganov388360c2016-10-17 17:09:41 -07007218 String8(AudioParameter::keyStreamSupportedSamplingRates), reply) == NO_ERROR) {
Eric Laurent62e4bc52016-02-02 18:37:28 -08007219 samplingRates = samplingRatesFromString(reply.string());
François Gaffie112b0af2015-11-19 16:13:25 +01007220 }
7221 }
7222 if (profiles.hasDynamicChannelsFor(format)) {
7223 reply = mpClientInterface->getParameters(ioHandle,
7224 requestedParameters.toString() + ";" +
Mikhail Naganov388360c2016-10-17 17:09:41 -07007225 AudioParameter::keyStreamSupportedChannels);
François Gaffie112b0af2015-11-19 16:13:25 +01007226 ALOGV("%s: supported channel masks %s", __FUNCTION__, reply.string());
Eric Laurent62e4bc52016-02-02 18:37:28 -08007227 AudioParameter repliedParameters(reply);
7228 if (repliedParameters.get(
Mikhail Naganov388360c2016-10-17 17:09:41 -07007229 String8(AudioParameter::keyStreamSupportedChannels), reply) == NO_ERROR) {
Eric Laurent62e4bc52016-02-02 18:37:28 -08007230 channelMasks = channelMasksFromString(reply.string());
Mikhail Naganov100f0122018-11-29 11:22:16 -08007231 if (device == AUDIO_DEVICE_OUT_HDMI
7232 || isDeviceOfModule(devDesc, AUDIO_HARDWARE_MODULE_ID_MSD)) {
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007233 modifySurroundChannelMasks(&channelMasks);
Phil Burk0709b0a2016-03-31 12:54:57 -07007234 }
François Gaffie112b0af2015-11-19 16:13:25 +01007235 }
7236 }
jiabin3e277cc2019-09-10 14:27:34 -07007237 addDynamicAudioProfileAndSort(
7238 profiles, new AudioProfile(format, channelMasks, samplingRates));
François Gaffie112b0af2015-11-19 16:13:25 +01007239 }
7240}
Eric Laurentd60560a2015-04-10 11:31:20 -07007241
Mikhail Naganovdc769682018-05-04 15:34:08 -07007242status_t AudioPolicyManager::installPatch(const char *caller,
7243 audio_patch_handle_t *patchHandle,
7244 AudioIODescriptorInterface *ioDescriptor,
7245 const struct audio_patch *patch,
7246 int delayMs)
7247{
7248 ssize_t index = mAudioPatches.indexOfKey(
7249 patchHandle && *patchHandle != AUDIO_PATCH_HANDLE_NONE ?
7250 *patchHandle : ioDescriptor->getPatchHandle());
7251 sp<AudioPatch> patchDesc;
7252 status_t status = installPatch(
7253 caller, index, patchHandle, patch, delayMs, mUidCached, &patchDesc);
7254 if (status == NO_ERROR) {
François Gaffieafd4cea2019-11-18 15:50:22 +01007255 ioDescriptor->setPatchHandle(patchDesc->getHandle());
Mikhail Naganovdc769682018-05-04 15:34:08 -07007256 }
7257 return status;
7258}
7259
7260status_t AudioPolicyManager::installPatch(const char *caller,
7261 ssize_t index,
7262 audio_patch_handle_t *patchHandle,
7263 const struct audio_patch *patch,
7264 int delayMs,
7265 uid_t uid,
7266 sp<AudioPatch> *patchDescPtr)
7267{
7268 sp<AudioPatch> patchDesc;
7269 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
7270 if (index >= 0) {
7271 patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01007272 afPatchHandle = patchDesc->getAfHandle();
Mikhail Naganovdc769682018-05-04 15:34:08 -07007273 }
7274
7275 status_t status = mpClientInterface->createAudioPatch(patch, &afPatchHandle, delayMs);
7276 ALOGV("%s() AF::createAudioPatch returned %d patchHandle %d num_sources %d num_sinks %d",
7277 caller, status, afPatchHandle, patch->num_sources, patch->num_sinks);
7278 if (status == NO_ERROR) {
7279 if (index < 0) {
7280 patchDesc = new AudioPatch(patch, uid);
François Gaffieafd4cea2019-11-18 15:50:22 +01007281 addAudioPatch(patchDesc->getHandle(), patchDesc);
Mikhail Naganovdc769682018-05-04 15:34:08 -07007282 } else {
7283 patchDesc->mPatch = *patch;
7284 }
François Gaffieafd4cea2019-11-18 15:50:22 +01007285 patchDesc->setAfHandle(afPatchHandle);
Mikhail Naganovdc769682018-05-04 15:34:08 -07007286 if (patchHandle) {
François Gaffieafd4cea2019-11-18 15:50:22 +01007287 *patchHandle = patchDesc->getHandle();
Mikhail Naganovdc769682018-05-04 15:34:08 -07007288 }
7289 nextAudioPortGeneration();
7290 mpClientInterface->onAudioPatchListUpdate();
7291 }
7292 if (patchDescPtr) *patchDescPtr = patchDesc;
7293 return status;
7294}
7295
jiabinbce0c1d2020-10-05 11:20:18 -07007296bool AudioPolicyManager::areAllActiveTracksRerouted(const sp<SwAudioOutputDescriptor>& output)
7297{
7298 const TrackClientVector activeClients = output->getActiveClients();
7299 if (activeClients.empty()) {
7300 return true;
7301 }
7302 ssize_t index = mAudioPatches.indexOfKey(output->getPatchHandle());
7303 if (index < 0) {
7304 ALOGE("%s, no audio patch found while there are active clients on output %d",
7305 __func__, output->getId());
7306 return false;
7307 }
7308 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
7309 DeviceVector routedDevices;
7310 for (int i = 0; i < patchDesc->mPatch.num_sinks; ++i) {
7311 sp<DeviceDescriptor> device = mAvailableOutputDevices.getDeviceFromId(
7312 patchDesc->mPatch.sinks[i].id);
7313 if (device == nullptr) {
7314 ALOGE("%s, no audio device found with id(%d)",
7315 __func__, patchDesc->mPatch.sinks[i].id);
7316 return false;
7317 }
7318 routedDevices.add(device);
7319 }
7320 for (const auto& client : activeClients) {
7321 // TODO: b/175343099 only travel the valid client
7322 sp<DeviceDescriptor> preferredDevice =
7323 mAvailableOutputDevices.getDeviceFromId(client->preferredDeviceId());
7324 if (mEngine->getOutputDevicesForAttributes(
7325 client->attributes(), preferredDevice, false) == routedDevices) {
7326 return false;
7327 }
7328 }
7329 return true;
7330}
7331
7332sp<SwAudioOutputDescriptor> AudioPolicyManager::openOutputWithProfileAndDevice(
7333 const sp<IOProfile>& profile, const DeviceVector& devices)
7334{
7335 for (const auto& device : devices) {
7336 // TODO: This should be checking if the profile supports the device combo.
7337 if (!profile->supportsDevice(device)) {
7338 return nullptr;
7339 }
7340 }
7341 sp<SwAudioOutputDescriptor> desc = new SwAudioOutputDescriptor(profile, mpClientInterface);
7342 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
Eric Laurentf1f22e72021-07-13 14:04:14 +02007343 status_t status = desc->open(nullptr /* halConfig */, nullptr /* mixerConfig */, devices,
jiabinbce0c1d2020-10-05 11:20:18 -07007344 AUDIO_STREAM_DEFAULT, AUDIO_OUTPUT_FLAG_NONE, &output);
7345 if (status != NO_ERROR) {
7346 return nullptr;
7347 }
7348
7349 // Here is where the out_set_parameters() for card & device gets called
7350 sp<DeviceDescriptor> device = devices.getDeviceForOpening();
7351 const audio_devices_t deviceType = device->type();
7352 const String8 &address = String8(device->address().c_str());
7353 if (!address.isEmpty()) {
7354 char *param = audio_device_address_to_parameter(deviceType, address.c_str());
7355 mpClientInterface->setParameters(output, String8(param));
7356 free(param);
7357 }
7358 updateAudioProfiles(device, output, profile->getAudioProfiles());
7359 if (!profile->hasValidAudioProfile()) {
7360 ALOGW("%s() missing param", __func__);
7361 desc->close();
7362 return nullptr;
7363 } else if (profile->hasDynamicAudioProfile()) {
7364 desc->close();
7365 output = AUDIO_IO_HANDLE_NONE;
7366 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
7367 profile->pickAudioProfile(
7368 config.sample_rate, config.channel_mask, config.format);
7369 config.offload_info.sample_rate = config.sample_rate;
7370 config.offload_info.channel_mask = config.channel_mask;
7371 config.offload_info.format = config.format;
7372
Eric Laurentf1f22e72021-07-13 14:04:14 +02007373 status = desc->open(&config, nullptr /* mixerConfig */, devices,
jiabinbce0c1d2020-10-05 11:20:18 -07007374 AUDIO_STREAM_DEFAULT, AUDIO_OUTPUT_FLAG_NONE, &output);
7375 if (status != NO_ERROR) {
7376 return nullptr;
7377 }
7378 }
7379
7380 addOutput(output, desc);
7381 if (audio_is_remote_submix_device(deviceType) && address != "0") {
7382 sp<AudioPolicyMix> policyMix;
7383 if (mPolicyMixes.getAudioPolicyMix(deviceType, address, policyMix) == NO_ERROR) {
7384 policyMix->setOutput(desc);
7385 desc->mPolicyMix = policyMix;
7386 } else {
7387 ALOGW("checkOutputsForDevice() cannot find policy for address %s",
7388 address.string());
7389 }
7390
7391 } else if (((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) == 0) && hasPrimaryOutput()) {
7392 // no duplicated output for direct outputs and
7393 // outputs used by dynamic policy mixes
7394 audio_io_handle_t duplicatedOutput = AUDIO_IO_HANDLE_NONE;
7395
7396 //TODO: configure audio effect output stage here
7397
7398 // open a duplicating output thread for the new output and the primary output
7399 sp<SwAudioOutputDescriptor> dupOutputDesc =
7400 new SwAudioOutputDescriptor(nullptr, mpClientInterface);
7401 status = dupOutputDesc->openDuplicating(mPrimaryOutput, desc, &duplicatedOutput);
7402 if (status == NO_ERROR) {
7403 // add duplicated output descriptor
7404 addOutput(duplicatedOutput, dupOutputDesc);
7405 } else {
7406 ALOGW("checkOutputsForDevice() could not open dup output for %d and %d",
7407 mPrimaryOutput->mIoHandle, output);
7408 desc->close();
7409 removeOutput(output);
7410 nextAudioPortGeneration();
7411 return nullptr;
7412 }
7413 }
Francois Gaffiebce7cd42020-10-14 16:13:20 +02007414 if (mPrimaryOutput == nullptr && profile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
7415 ALOGV("%s(): re-assigning mPrimaryOutput", __func__);
7416 mPrimaryOutput = desc;
7417 }
jiabinbce0c1d2020-10-05 11:20:18 -07007418 return desc;
7419}
7420
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08007421} // namespace android