blob: 8d00a3d8a82a1c617ad6353bda0b6f376ac923c7 [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>
Nathalie Le Clair88fa2752021-11-23 13:03:41 +010041#include <android/media/audio/common/AudioPort.h>
Glenn Kasten76a13442020-07-01 12:10:59 -070042#include <cutils/bitops.h>
Eric Laurente552edb2014-03-10 17:42:56 -070043#include <cutils/properties.h>
Eric Laurent3b73df72014-03-11 09:06:29 -070044#include <media/AudioParameter.h>
Mikhail Naganov946c0032020-10-21 13:04:58 -070045#include <policy.h>
Andy Hung4ef19fa2018-05-15 19:35:29 -070046#include <private/android_filesystem_config.h>
Mikhail Naganovcbc8f612016-10-11 18:05:13 -070047#include <system/audio.h>
Mikhail Naganov27cf37c2020-04-14 14:47:01 -070048#include <system/audio_config.h>
jiabinebb6af42020-06-09 17:31:17 -070049#include <system/audio_effects/effect_hapticgenerator.h>
Mikhail Naganov946c0032020-10-21 13:04:58 -070050#include <utils/Log.h>
51
Eric Laurentd4692962014-05-05 18:13:44 -070052#include "AudioPolicyManager.h"
François Gaffiea8ecc2c2015-11-09 16:10:40 +010053#include "TypeConverter.h"
Eric Laurente552edb2014-03-10 17:42:56 -070054
Eric Laurent3b73df72014-03-11 09:06:29 -070055namespace android {
Eric Laurente552edb2014-03-10 17:42:56 -070056
Nathalie Le Clair88fa2752021-11-23 13:03:41 +010057using android::media::audio::common::AudioDevice;
58using android::media::audio::common::AudioDeviceAddress;
59using android::media::audio::common::AudioPortDeviceExt;
60using android::media::audio::common::AudioPortExt;
Svet Ganov3e5f14f2021-05-13 22:51:08 +000061using content::AttributionSourceState;
Philip P. Moltmannbda45752020-07-17 16:41:18 -070062
Eric Laurentdc462862016-07-19 12:29:53 -070063//FIXME: workaround for truncated touch sounds
64// to be removed when the problem is handled by system UI
65#define TOUCH_SOUND_FIXED_DELAY_MS 100
Jean-Michel Trivi719a9872017-08-05 13:51:35 -070066
67// Largest difference in dB on earpiece in call between the voice volume and another
68// media / notification / system volume.
69constexpr float IN_CALL_EARPIECE_HEADROOM_DB = 3.f;
70
Mikhail Naganov15be9d22017-11-08 14:18:13 +110071// Compressed formats for MSD module, ordered from most preferred to least preferred.
Dean Wheatley8bee85a2021-02-10 16:02:23 +110072static const std::vector<audio_format_t> msdCompressedFormatsOrder = {{
73 AUDIO_FORMAT_IEC60958, AUDIO_FORMAT_MAT_2_1, AUDIO_FORMAT_MAT_2_0, AUDIO_FORMAT_E_AC3,
Mikhail Naganov15be9d22017-11-08 14:18:13 +110074 AUDIO_FORMAT_AC3, AUDIO_FORMAT_PCM_16_BIT }};
75// Channel masks for MSD module, 3D > 2D > 1D ordering (most preferred to least preferred).
Dean Wheatley8bee85a2021-02-10 16:02:23 +110076static const std::vector<audio_channel_mask_t> msdSurroundChannelMasksOrder = {{
Mikhail Naganov15be9d22017-11-08 14:18:13 +110077 AUDIO_CHANNEL_OUT_3POINT1POINT2, AUDIO_CHANNEL_OUT_3POINT0POINT2,
78 AUDIO_CHANNEL_OUT_2POINT1POINT2, AUDIO_CHANNEL_OUT_2POINT0POINT2,
79 AUDIO_CHANNEL_OUT_5POINT1, AUDIO_CHANNEL_OUT_STEREO }};
80
jiabin06e4bab2019-07-29 10:13:34 -070081template <typename T>
82bool operator== (const SortedVector<T> &left, const SortedVector<T> &right)
83{
84 if (left.size() != right.size()) {
85 return false;
86 }
87 for (size_t index = 0; index < right.size(); index++) {
88 if (left[index] != right[index]) {
89 return false;
90 }
91 }
92 return true;
93}
94
95template <typename T>
96bool operator!= (const SortedVector<T> &left, const SortedVector<T> &right)
97{
98 return !(left == right);
99}
100
Eric Laurente552edb2014-03-10 17:42:56 -0700101// ----------------------------------------------------------------------------
102// AudioPolicyInterface implementation
103// ----------------------------------------------------------------------------
104
Nathalie Le Clair88fa2752021-11-23 13:03:41 +0100105status_t AudioPolicyManager::setDeviceConnectionState(audio_policy_dev_state_t state,
106 const android::media::audio::common::AudioPort& port, audio_format_t encodedFormat) {
107 status_t status = setDeviceConnectionStateInt(state, port, encodedFormat);
jiabina7b43792018-02-15 16:04:46 -0800108 nextAudioPortGeneration();
109 return status;
Eric Laurentc73ca6e2014-12-12 14:34:22 -0800110}
111
Nathalie Le Clair88fa2752021-11-23 13:03:41 +0100112status_t AudioPolicyManager::setDeviceConnectionState(audio_devices_t device,
113 audio_policy_dev_state_t state,
114 const char* device_address,
115 const char* device_name,
116 audio_format_t encodedFormat) {
117 media::AudioPort aidlPort;
118 if (status_t status = deviceToAudioPort(device, device_address, device_name, &aidlPort);
119 status == OK) {
120 return setDeviceConnectionState(state, aidlPort.hal, encodedFormat);
121 } else {
122 ALOGE("Failed to convert to AudioPort Parcelable: %s", statusToString(status).c_str());
123 return status;
124 }
125}
126
François Gaffie11d30102018-11-02 16:09:09 +0100127void AudioPolicyManager::broadcastDeviceConnectionState(const sp<DeviceDescriptor> &device,
128 audio_policy_dev_state_t state)
François Gaffie44481e72016-04-20 07:49:57 +0200129{
Mikhail Naganov516d3982022-02-01 23:53:59 +0000130 audio_port_v7 devicePort;
131 device->toAudioPort(&devicePort);
132 if (status_t status = mpClientInterface->setDeviceConnectedState(
133 &devicePort, state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
134 status != OK) {
135 ALOGE("Error %d while setting connected state for device %s", status,
136 device->getDeviceTypeAddr().toString(false).c_str());
137 }
François Gaffie44481e72016-04-20 07:49:57 +0200138}
139
Nathalie Le Clair88fa2752021-11-23 13:03:41 +0100140status_t AudioPolicyManager::setDeviceConnectionStateInt(
141 audio_policy_dev_state_t state, const android::media::audio::common::AudioPort& port,
142 audio_format_t encodedFormat) {
143 // TODO: b/211601178 Forward 'port' to Audio HAL via mHwModules. For now, only device_type,
144 // device_address and device_name are forwarded.
145 if (port.ext.getTag() != AudioPortExt::device) {
146 return BAD_VALUE;
147 }
148 audio_devices_t device_type;
149 std::string device_address;
150 if (status_t status = aidl2legacy_AudioDevice_audio_device(
151 port.ext.get<AudioPortExt::device>().device, &device_type, &device_address);
152 status != OK) {
153 return status;
154 };
155 const char* device_name = port.name.c_str();
156 // connect/disconnect only 1 device at a time
157 if (!audio_is_output_device(device_type) && !audio_is_input_device(device_type))
158 return BAD_VALUE;
159
160 sp<DeviceDescriptor> device = mHwModules.getDeviceDescriptor(
161 device_type, device_address.c_str(), device_name, encodedFormat,
162 state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
163 return device ? setDeviceConnectionStateInt(device, state) : INVALID_OPERATION;
164}
165
François Gaffie11d30102018-11-02 16:09:09 +0100166status_t AudioPolicyManager::setDeviceConnectionStateInt(audio_devices_t deviceType,
Eric Laurenta1d525f2015-01-29 13:36:45 -0800167 audio_policy_dev_state_t state,
Nathalie Le Clair88fa2752021-11-23 13:03:41 +0100168 const char* device_address,
169 const char* device_name,
170 audio_format_t encodedFormat) {
171 media::AudioPort aidlPort;
172 if (status_t status = deviceToAudioPort(deviceType, device_address, device_name, &aidlPort);
173 status == OK) {
174 return setDeviceConnectionStateInt(state, aidlPort.hal, encodedFormat);
175 } else {
176 ALOGE("Failed to convert to AudioPort Parcelable: %s", statusToString(status).c_str());
177 return status;
178 }
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700179}
Paul McLeane743a472015-01-28 11:07:31 -0800180
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700181status_t AudioPolicyManager::setDeviceConnectionStateInt(const sp<DeviceDescriptor> &device,
182 audio_policy_dev_state_t state)
183{
Eric Laurente552edb2014-03-10 17:42:56 -0700184 // handle output devices
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700185 if (audio_is_output_device(device->type())) {
Eric Laurentd4692962014-05-05 18:13:44 -0700186 SortedVector <audio_io_handle_t> outputs;
187
François Gaffie11d30102018-11-02 16:09:09 +0100188 ssize_t index = mAvailableOutputDevices.indexOf(device);
Eric Laurent3a4311c2014-03-17 12:00:47 -0700189
Eric Laurente552edb2014-03-10 17:42:56 -0700190 // save a copy of the opened output descriptors before any output is opened or closed
191 // by checkOutputsForDevice(). This will be needed by checkOutputForAllStrategies()
192 mPreviousOutputs = mOutputs;
Eric Laurent96d1dda2022-03-14 17:14:19 +0100193
194 bool wasLeUnicastActive = isLeUnicastActive();
195
Eric Laurente552edb2014-03-10 17:42:56 -0700196 switch (state)
197 {
198 // handle output device connection
Eric Laurent3ae5f312015-02-03 17:12:08 -0800199 case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700200 if (index >= 0) {
François Gaffie11d30102018-11-02 16:09:09 +0100201 ALOGW("%s() device already connected: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700202 return INVALID_OPERATION;
203 }
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800204 ALOGV("%s() connecting device %s format %x",
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700205 __func__, device->toString().c_str(), device->getEncodedFormat());
Eric Laurente552edb2014-03-10 17:42:56 -0700206
Eric Laurente552edb2014-03-10 17:42:56 -0700207 // register new device as available
Francois Gaffie993f3902019-04-10 15:39:27 +0200208 if (mAvailableOutputDevices.add(device) < 0) {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700209 return NO_MEMORY;
Eric Laurente552edb2014-03-10 17:42:56 -0700210 }
211
François Gaffie44481e72016-04-20 07:49:57 +0200212 // Before checking outputs, broadcast connect event to allow HAL to retrieve dynamic
213 // parameters on newly connected devices (instead of opening the outputs...)
François Gaffie11d30102018-11-02 16:09:09 +0100214 broadcastDeviceConnectionState(device, state);
François Gaffie44481e72016-04-20 07:49:57 +0200215
François Gaffie11d30102018-11-02 16:09:09 +0100216 if (checkOutputsForDevice(device, state, outputs) != NO_ERROR) {
217 mAvailableOutputDevices.remove(device);
François Gaffie44481e72016-04-20 07:49:57 +0200218
Francois Gaffie716e1432019-01-14 16:58:59 +0100219 mHwModules.cleanUpForDevice(device);
220
François Gaffie11d30102018-11-02 16:09:09 +0100221 broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE);
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -0700222 return INVALID_OPERATION;
223 }
François Gaffie2110e042015-03-24 08:41:51 +0100224
jiabin1c4794b2020-05-05 10:08:05 -0700225 // Populate encapsulation information when a output device is connected.
226 device->setEncapsulationInfoFromHal(mpClientInterface);
227
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -0700228 // outputs should never be empty here
229 ALOG_ASSERT(outputs.size() != 0, "setDeviceConnectionState():"
230 "checkOutputsForDevice() returned no outputs but status OK");
François Gaffie11d30102018-11-02 16:09:09 +0100231 ALOGV("%s() checkOutputsForDevice() returned %zu outputs", __func__, outputs.size());
Eric Laurent3ae5f312015-02-03 17:12:08 -0800232
Eric Laurent3ae5f312015-02-03 17:12:08 -0800233 } break;
Eric Laurente552edb2014-03-10 17:42:56 -0700234 // handle output device disconnection
Eric Laurent3b73df72014-03-11 09:06:29 -0700235 case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700236 if (index < 0) {
François Gaffie11d30102018-11-02 16:09:09 +0100237 ALOGW("%s() device not connected: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700238 return INVALID_OPERATION;
239 }
240
François Gaffie11d30102018-11-02 16:09:09 +0100241 ALOGV("%s() disconnecting output device %s", __func__, device->toString().c_str());
Paul McLean5c477aa2014-08-20 16:47:57 -0700242
Paul McLeane743a472015-01-28 11:07:31 -0800243 // Send Disconnect to HALs
François Gaffie11d30102018-11-02 16:09:09 +0100244 broadcastDeviceConnectionState(device, state);
Paul McLean5c477aa2014-08-20 16:47:57 -0700245
Eric Laurente552edb2014-03-10 17:42:56 -0700246 // remove device from available output devices
François Gaffie11d30102018-11-02 16:09:09 +0100247 mAvailableOutputDevices.remove(device);
Eric Laurente552edb2014-03-10 17:42:56 -0700248
Francois Gaffieba2cf0f2018-12-12 16:40:25 +0100249 mOutputs.clearSessionRoutesForDevice(device);
250
François Gaffie11d30102018-11-02 16:09:09 +0100251 checkOutputsForDevice(device, state, outputs);
François Gaffie2110e042015-03-24 08:41:51 +0100252
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800253 // Reset active device codec
254 device->setEncodedFormat(AUDIO_FORMAT_DEFAULT);
255
Kriti Dangef6be8f2020-11-05 11:58:19 +0100256 // remove device from mReportedFormatsMap cache
257 mReportedFormatsMap.erase(device);
258
Eric Laurente552edb2014-03-10 17:42:56 -0700259 } break;
260
261 default:
François Gaffie11d30102018-11-02 16:09:09 +0100262 ALOGE("%s() invalid state: %x", __func__, state);
Eric Laurente552edb2014-03-10 17:42:56 -0700263 return BAD_VALUE;
264 }
265
Eric Laurent736a1022019-03-27 18:28:46 -0700266 // Propagate device availability to Engine
267 setEngineDeviceConnectionState(device, state);
268
Eric Laurentae970022019-01-29 14:25:04 -0800269 // No need to evaluate playback routing when connecting a remote submix
270 // output device used by a dynamic policy of type recorder as no
271 // playback use case is affected.
272 bool doCheckForDeviceAndOutputChanges = true;
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700273 if (device->type() == AUDIO_DEVICE_OUT_REMOTE_SUBMIX && device->address() != "0") {
Eric Laurentae970022019-01-29 14:25:04 -0800274 for (audio_io_handle_t output : outputs) {
275 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
Mikhail Naganovbfac5832019-03-05 16:55:28 -0800276 sp<AudioPolicyMix> policyMix = desc->mPolicyMix.promote();
277 if (policyMix != nullptr
278 && policyMix->mMixType == MIX_TYPE_RECORDERS
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700279 && device->address() == policyMix->mDeviceAddress.string()) {
Eric Laurentae970022019-01-29 14:25:04 -0800280 doCheckForDeviceAndOutputChanges = false;
281 break;
282 }
283 }
284 }
285
286 auto checkCloseOutputs = [&]() {
Mikhail Naganov37977152018-07-11 15:54:44 -0700287 // outputs must be closed after checkOutputForAllStrategies() is executed
288 if (!outputs.isEmpty()) {
289 for (audio_io_handle_t output : outputs) {
290 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
François Gaffie11d30102018-11-02 16:09:09 +0100291 // close unused outputs after device disconnection or direct outputs that have
292 // been opened by checkOutputsForDevice() to query dynamic parameters
Eric Laurente191d1b2022-04-15 11:59:25 +0200293 // "outputs" vector never contains duplicated outputs
Eric Laurentcad6c0d2021-07-13 15:12:39 +0200294 if ((state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE)
295 || (((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) &&
Eric Laurente191d1b2022-04-15 11:59:25 +0200296 (desc->mDirectOpenCount == 0))
297 || (((desc->mFlags & AUDIO_OUTPUT_FLAG_SPATIALIZER) != 0) &&
298 !isOutputOnlyAvailableRouteToSomeDevice(desc))) {
Francois Gaffieff1eb522020-05-06 18:37:04 +0200299 clearAudioSourcesForOutput(output);
Mikhail Naganov37977152018-07-11 15:54:44 -0700300 closeOutput(output);
301 }
Eric Laurente552edb2014-03-10 17:42:56 -0700302 }
Mikhail Naganov37977152018-07-11 15:54:44 -0700303 // check A2DP again after closing A2DP output to reset mA2dpSuspended if needed
304 return true;
Eric Laurente552edb2014-03-10 17:42:56 -0700305 }
Mikhail Naganov37977152018-07-11 15:54:44 -0700306 return false;
Eric Laurentae970022019-01-29 14:25:04 -0800307 };
308
309 if (doCheckForDeviceAndOutputChanges) {
310 checkForDeviceAndOutputChanges(checkCloseOutputs);
311 } else {
312 checkCloseOutputs();
313 }
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100314 (void)updateCallRouting(false /*fromCache*/);
jiabinbce0c1d2020-10-05 11:20:18 -0700315 std::vector<audio_io_handle_t> outputsToReopen;
François Gaffie11d30102018-11-02 16:09:09 +0100316 const DeviceVector msdOutDevices = getMsdAudioOutDevices();
jiabinbce0c1d2020-10-05 11:20:18 -0700317 const DeviceVector activeMediaDevices =
318 mEngine->getActiveMediaDevices(mAvailableOutputDevices);
Eric Laurente552edb2014-03-10 17:42:56 -0700319 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -0700320 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Jaideep Sharma89b5b852020-11-23 16:41:33 +0530321 if (desc->isActive() && ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) ||
322 (desc != mPrimaryOutput))) {
François Gaffie11d30102018-11-02 16:09:09 +0100323 DeviceVector newDevices = getNewOutputDevices(desc, true /*fromCache*/);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700324 // do not force device change on duplicated output because if device is 0, it will
325 // also force a device 0 for the two outputs it is duplicated to which may override
326 // a valid device selection on those outputs.
François Gaffie11d30102018-11-02 16:09:09 +0100327 bool force = (msdOutDevices.isEmpty() || msdOutDevices != desc->devices())
Mikhail Naganov15be9d22017-11-08 14:18:13 +1100328 && !desc->isDuplicated()
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700329 && (!device_distinguishes_on_address(device->type())
Eric Laurentc2730ba2014-07-20 15:47:07 -0700330 // always force when disconnecting (a non-duplicated device)
331 || (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
François Gaffie11d30102018-11-02 16:09:09 +0100332 setOutputDevices(desc, newDevices, force, 0);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700333 }
jiabinbce0c1d2020-10-05 11:20:18 -0700334 if (!desc->isDuplicated() && desc->mProfile->hasDynamicAudioProfile() &&
jiabin498d2152021-04-02 00:26:46 +0000335 !activeMediaDevices.empty() && desc->devices() != activeMediaDevices &&
jiabinbce0c1d2020-10-05 11:20:18 -0700336 desc->supportsDevicesForPlayback(activeMediaDevices)) {
337 // Reopen the output to query the dynamic profiles when there is not active
338 // clients or all active clients will be rerouted. Otherwise, set the flag
339 // `mPendingReopenToQueryProfiles` in the SwOutputDescriptor so that the output
340 // can be reopened to query dynamic profiles when all clients are inactive.
341 if (areAllActiveTracksRerouted(desc)) {
342 outputsToReopen.push_back(mOutputs.keyAt(i));
343 } else {
344 desc->mPendingReopenToQueryProfiles = true;
345 }
346 }
347 if (!desc->supportsDevicesForPlayback(activeMediaDevices)) {
348 // Clear the flag that previously set for re-querying profiles.
349 desc->mPendingReopenToQueryProfiles = false;
350 }
351 }
352 for (const auto& output : outputsToReopen) {
353 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
354 closeOutput(output);
355 openOutputWithProfileAndDevice(desc->mProfile, activeMediaDevices);
Eric Laurente552edb2014-03-10 17:42:56 -0700356 }
357
Eric Laurentd60560a2015-04-10 11:31:20 -0700358 if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
François Gaffie11d30102018-11-02 16:09:09 +0100359 cleanUpForDevice(device);
Eric Laurentd60560a2015-04-10 11:31:20 -0700360 }
361
Eric Laurent96d1dda2022-03-14 17:14:19 +0100362 checkLeBroadcastRoutes(wasLeUnicastActive, nullptr, 0);
363
Eric Laurent72aa32f2014-05-30 18:51:48 -0700364 mpClientInterface->onAudioPortListUpdate();
Eric Laurentb71e58b2014-05-29 16:08:11 -0700365 return NO_ERROR;
Eric Laurentd4692962014-05-05 18:13:44 -0700366 } // end if is output device
367
Eric Laurente552edb2014-03-10 17:42:56 -0700368 // handle input devices
Mikhail Naganovd0e2c742020-03-25 15:59:59 -0700369 if (audio_is_input_device(device->type())) {
François Gaffie11d30102018-11-02 16:09:09 +0100370 ssize_t index = mAvailableInputDevices.indexOf(device);
Eric Laurente552edb2014-03-10 17:42:56 -0700371 switch (state)
372 {
373 // handle input device connection
Eric Laurent3b73df72014-03-11 09:06:29 -0700374 case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700375 if (index >= 0) {
François Gaffie11d30102018-11-02 16:09:09 +0100376 ALOGW("%s() device already connected: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700377 return INVALID_OPERATION;
378 }
Eric Laurent0dd51852019-04-19 18:18:58 -0700379
380 if (mAvailableInputDevices.add(device) < 0) {
381 return NO_MEMORY;
382 }
383
François Gaffie44481e72016-04-20 07:49:57 +0200384 // Before checking intputs, broadcast connect event to allow HAL to retrieve dynamic
385 // parameters on newly connected devices (instead of opening the inputs...)
François Gaffie11d30102018-11-02 16:09:09 +0100386 broadcastDeviceConnectionState(device, state);
François Gaffie44481e72016-04-20 07:49:57 +0200387
Eric Laurent0dd51852019-04-19 18:18:58 -0700388 if (checkInputsForDevice(device, state) != NO_ERROR) {
389 mAvailableInputDevices.remove(device);
390
François Gaffie11d30102018-11-02 16:09:09 +0100391 broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE);
Francois Gaffie716e1432019-01-14 16:58:59 +0100392
393 mHwModules.cleanUpForDevice(device);
394
Eric Laurentd4692962014-05-05 18:13:44 -0700395 return INVALID_OPERATION;
396 }
397
Eric Laurentd4692962014-05-05 18:13:44 -0700398 } break;
Eric Laurente552edb2014-03-10 17:42:56 -0700399
400 // handle input device disconnection
Eric Laurent3b73df72014-03-11 09:06:29 -0700401 case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700402 if (index < 0) {
François Gaffie11d30102018-11-02 16:09:09 +0100403 ALOGW("%s() device not connected: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700404 return INVALID_OPERATION;
405 }
Paul McLean5c477aa2014-08-20 16:47:57 -0700406
François Gaffie11d30102018-11-02 16:09:09 +0100407 ALOGV("%s() disconnecting input device %s", __func__, device->toString().c_str());
Paul McLean5c477aa2014-08-20 16:47:57 -0700408
409 // Set Disconnect to HALs
François Gaffie11d30102018-11-02 16:09:09 +0100410 broadcastDeviceConnectionState(device, state);
Paul McLean5c477aa2014-08-20 16:47:57 -0700411
François Gaffie11d30102018-11-02 16:09:09 +0100412 mAvailableInputDevices.remove(device);
Eric Laurent0dd51852019-04-19 18:18:58 -0700413
414 checkInputsForDevice(device, state);
Kriti Dangef6be8f2020-11-05 11:58:19 +0100415
416 // remove device from mReportedFormatsMap cache
417 mReportedFormatsMap.erase(device);
Eric Laurentd4692962014-05-05 18:13:44 -0700418 } break;
Eric Laurente552edb2014-03-10 17:42:56 -0700419
420 default:
François Gaffie11d30102018-11-02 16:09:09 +0100421 ALOGE("%s() invalid state: %x", __func__, state);
Eric Laurente552edb2014-03-10 17:42:56 -0700422 return BAD_VALUE;
423 }
424
Eric Laurent736a1022019-03-27 18:28:46 -0700425 // Propagate device availability to Engine
426 setEngineDeviceConnectionState(device, state);
427
Eric Laurent0dd51852019-04-19 18:18:58 -0700428 checkCloseInputs();
Eric Laurent5f5fca52016-08-04 11:48:57 -0700429 // As the input device list can impact the output device selection, update
430 // getDeviceForStrategy() cache
431 updateDevicesAndOutputs();
Eric Laurente552edb2014-03-10 17:42:56 -0700432
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100433 (void)updateCallRouting(false /*fromCache*/);
Francois Gaffiea0e5c992020-09-29 16:05:07 +0200434 // Reconnect Audio Source
435 for (const auto &strategy : mEngine->getOrderedProductStrategies()) {
436 auto attributes = mEngine->getAllAttributesForProductStrategy(strategy).front();
437 checkAudioSourceForAttributes(attributes);
438 }
Eric Laurentd60560a2015-04-10 11:31:20 -0700439 if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
François Gaffie11d30102018-11-02 16:09:09 +0100440 cleanUpForDevice(device);
Eric Laurentd60560a2015-04-10 11:31:20 -0700441 }
442
Eric Laurentb52c1522014-05-20 11:27:36 -0700443 mpClientInterface->onAudioPortListUpdate();
Eric Laurente552edb2014-03-10 17:42:56 -0700444 return NO_ERROR;
Eric Laurentd4692962014-05-05 18:13:44 -0700445 } // end if is input device
Eric Laurente552edb2014-03-10 17:42:56 -0700446
François Gaffie11d30102018-11-02 16:09:09 +0100447 ALOGW("%s() invalid device: %s", __func__, device->toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -0700448 return BAD_VALUE;
449}
450
Nathalie Le Clair88fa2752021-11-23 13:03:41 +0100451status_t AudioPolicyManager::deviceToAudioPort(audio_devices_t device, const char* device_address,
452 const char* device_name,
453 media::AudioPort* aidlPort) {
454 DeviceDescriptorBase devDescr(device, device_address);
455 devDescr.setName(device_name);
456 return devDescr.writeToParcelable(aidlPort);
457}
458
Eric Laurent736a1022019-03-27 18:28:46 -0700459void AudioPolicyManager::setEngineDeviceConnectionState(const sp<DeviceDescriptor> device,
460 audio_policy_dev_state_t state) {
461
462 // the Engine does not have to know about remote submix devices used by dynamic audio policies
463 if (audio_is_remote_submix_device(device->type()) && device->address() != "0") {
464 return;
465 }
466 mEngine->setDeviceConnectionState(device, state);
467}
468
469
Eric Laurente0720872014-03-11 09:30:41 -0700470audio_policy_dev_state_t AudioPolicyManager::getDeviceConnectionState(audio_devices_t device,
François Gaffie53615e22015-03-19 09:24:12 +0100471 const char *device_address)
Eric Laurente552edb2014-03-10 17:42:56 -0700472{
Eric Laurent634b7142016-04-20 13:48:02 -0700473 sp<DeviceDescriptor> devDesc =
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800474 mHwModules.getDeviceDescriptor(device, device_address, "", AUDIO_FORMAT_DEFAULT,
475 false /* allowToCreate */,
Eric Laurent634b7142016-04-20 13:48:02 -0700476 (strlen(device_address) != 0)/*matchAddress*/);
477
478 if (devDesc == 0) {
François Gaffie251c7f02018-11-07 10:41:08 +0100479 ALOGV("getDeviceConnectionState() undeclared device, type %08x, address: %s",
Eric Laurent634b7142016-04-20 13:48:02 -0700480 device, device_address);
481 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
482 }
François Gaffie53615e22015-03-19 09:24:12 +0100483
Eric Laurent3a4311c2014-03-17 12:00:47 -0700484 DeviceVector *deviceVector;
485
Eric Laurente552edb2014-03-10 17:42:56 -0700486 if (audio_is_output_device(device)) {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700487 deviceVector = &mAvailableOutputDevices;
Eric Laurente552edb2014-03-10 17:42:56 -0700488 } else if (audio_is_input_device(device)) {
Eric Laurent3a4311c2014-03-17 12:00:47 -0700489 deviceVector = &mAvailableInputDevices;
490 } else {
François Gaffie11d30102018-11-02 16:09:09 +0100491 ALOGW("%s() invalid device type %08x", __func__, device);
Eric Laurent3a4311c2014-03-17 12:00:47 -0700492 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
Eric Laurente552edb2014-03-10 17:42:56 -0700493 }
Eric Laurent634b7142016-04-20 13:48:02 -0700494
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800495 return (deviceVector->getDevice(
496 device, String8(device_address), AUDIO_FORMAT_DEFAULT) != 0) ?
Eric Laurent634b7142016-04-20 13:48:02 -0700497 AUDIO_POLICY_DEVICE_STATE_AVAILABLE : AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
Eric Laurenta1d525f2015-01-29 13:36:45 -0800498}
499
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800500status_t AudioPolicyManager::handleDeviceConfigChange(audio_devices_t device,
501 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800502 const char *device_name,
503 audio_format_t encodedFormat)
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800504{
505 status_t status;
Aniket Kumar Lata3432e042018-04-06 14:22:15 -0700506 String8 reply;
507 AudioParameter param;
508 int isReconfigA2dpSupported = 0;
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800509
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800510 ALOGV("handleDeviceConfigChange(() device: 0x%X, address %s name %s encodedFormat: 0x%X",
511 device, device_address, device_name, encodedFormat);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800512
Pavlin Radoslavovc694ff42017-01-09 23:27:29 -0800513 // connect/disconnect only 1 device at a time
514 if (!audio_is_output_device(device) && !audio_is_input_device(device)) return BAD_VALUE;
515
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800516 // Check if the device is currently connected
jiabin9a3361e2019-10-01 09:38:30 -0700517 DeviceVector deviceList = mAvailableOutputDevices.getDevicesFromType(device);
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800518 if (deviceList.empty()) {
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800519 // Nothing to do: device is not connected
520 return NO_ERROR;
521 }
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800522 sp<DeviceDescriptor> devDesc = deviceList.itemAt(0);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800523
Aniket Kumar Lata3432e042018-04-06 14:22:15 -0700524 // For offloaded A2DP, Hw modules may have the capability to
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800525 // configure codecs.
526 // Handle two specific cases by sending a set parameter to
527 // configure A2DP codecs. No need to toggle device state.
528 // Case 1: A2DP active device switches from primary to primary
529 // module
530 // Case 2: A2DP device config changes on primary module.
Francois Gaffiebce7cd42020-10-14 16:13:20 +0200531 if (audio_is_a2dp_out_device(device) && hasPrimaryOutput()) {
jiabin9a3361e2019-10-01 09:38:30 -0700532 sp<HwModule> module = mHwModules.getModuleForDeviceType(device, encodedFormat);
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800533 audio_module_handle_t primaryHandle = mPrimaryOutput->getModuleHandle();
534 if (availablePrimaryOutputDevices().contains(devDesc) &&
535 (module != 0 && module->getHandle() == primaryHandle)) {
536 reply = mpClientInterface->getParameters(
537 AUDIO_IO_HANDLE_NONE,
538 String8(AudioParameter::keyReconfigA2dpSupported));
539 AudioParameter repliedParameters(reply);
540 repliedParameters.getInt(
541 String8(AudioParameter::keyReconfigA2dpSupported), isReconfigA2dpSupported);
542 if (isReconfigA2dpSupported) {
543 const String8 key(AudioParameter::keyReconfigA2dp);
544 param.add(key, String8("true"));
545 mpClientInterface->setParameters(AUDIO_IO_HANDLE_NONE, param.toString());
546 devDesc->setEncodedFormat(encodedFormat);
547 return NO_ERROR;
548 }
Aniket Kumar Lata3432e042018-04-06 14:22:15 -0700549 }
550 }
cnx421bd2dcc42020-07-11 14:58:44 +0800551 auto musicStrategy = streamToStrategy(AUDIO_STREAM_MUSIC);
552 for (size_t i = 0; i < mOutputs.size(); i++) {
553 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
554 // mute media strategies and delay device switch by the largest
555 // This avoid sending the music tail into the earpiece or headset.
556 setStrategyMute(musicStrategy, true, desc);
557 setStrategyMute(musicStrategy, false, desc, MUTE_TIME_MS,
558 mEngine->getOutputDevicesForAttributes(attributes_initializer(AUDIO_USAGE_MEDIA),
559 nullptr, true /*fromCache*/).types());
560 }
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800561 // Toggle the device state: UNAVAILABLE -> AVAILABLE
562 // This will force reading again the device configuration
563 status = setDeviceConnectionState(device,
564 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800565 device_address, device_name,
566 devDesc->getEncodedFormat());
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800567 if (status != NO_ERROR) {
568 ALOGW("handleDeviceConfigChange() error disabling connection state: %d",
569 status);
570 return status;
571 }
572
573 status = setDeviceConnectionState(device,
574 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -0800575 device_address, device_name, encodedFormat);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800576 if (status != NO_ERROR) {
577 ALOGW("handleDeviceConfigChange() error enabling connection state: %d",
578 status);
579 return status;
580 }
581
582 return NO_ERROR;
583}
584
Pattydd807582021-11-04 21:01:03 +0800585status_t AudioPolicyManager::getHwOffloadFormatsSupportedForBluetoothMedia(
586 audio_devices_t device, std::vector<audio_format_t> *formats)
Arun Mirpuri11029ad2018-12-19 20:45:19 -0800587{
Pattydd807582021-11-04 21:01:03 +0800588 ALOGV("getHwOffloadFormatsSupportedForBluetoothMedia()");
Arun Mirpuri11029ad2018-12-19 20:45:19 -0800589 status_t status = NO_ERROR;
Aniket Kumar Lata89e82232019-01-19 18:14:10 -0800590 std::unordered_set<audio_format_t> formatSet;
591 sp<HwModule> primaryModule =
592 mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_PRIMARY);
Aniket Kumar Latafedb5982019-07-03 11:20:36 -0700593 if (primaryModule == nullptr) {
594 ALOGE("%s() unable to get primary module", __func__);
595 return NO_INIT;
596 }
Pattydd807582021-11-04 21:01:03 +0800597
598 DeviceTypeSet audioDeviceSet;
599
600 switch(device) {
601 case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP:
602 audioDeviceSet = getAudioDeviceOutAllA2dpSet();
603 break;
604 case AUDIO_DEVICE_OUT_BLE_HEADSET:
605 audioDeviceSet = getAudioDeviceOutAllBleSet();
606 break;
607 default:
608 ALOGE("%s() device type 0x%08x not supported", __func__, device);
609 return BAD_VALUE;
610 }
611
jiabin9a3361e2019-10-01 09:38:30 -0700612 DeviceVector declaredDevices = primaryModule->getDeclaredDevices().getDevicesFromTypes(
Pattydd807582021-11-04 21:01:03 +0800613 audioDeviceSet);
Aniket Kumar Lata89e82232019-01-19 18:14:10 -0800614 for (const auto& device : declaredDevices) {
615 formatSet.insert(device->encodedFormats().begin(), device->encodedFormats().end());
Arun Mirpuri11029ad2018-12-19 20:45:19 -0800616 }
Aniket Kumar Lata89e82232019-01-19 18:14:10 -0800617 formats->assign(formatSet.begin(), formatSet.end());
Arun Mirpuri11029ad2018-12-19 20:45:19 -0800618 return status;
619}
620
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100621DeviceVector AudioPolicyManager::selectBestRxSinkDevicesForCall(bool fromCache)
622{
623 DeviceVector rxSinkdevices{};
624 rxSinkdevices = mEngine->getOutputDevicesForAttributes(
625 attributes_initializer(AUDIO_USAGE_VOICE_COMMUNICATION), nullptr, fromCache);
626 if (!rxSinkdevices.isEmpty() && mAvailableOutputDevices.contains(rxSinkdevices.itemAt(0))) {
627 auto rxSinkDevice = rxSinkdevices.itemAt(0);
628 auto telephonyRxModule = mHwModules.getModuleForDeviceType(
629 AUDIO_DEVICE_IN_TELEPHONY_RX, AUDIO_FORMAT_DEFAULT);
630 // retrieve Rx Source device descriptor
631 sp<DeviceDescriptor> rxSourceDevice = mAvailableInputDevices.getDevice(
632 AUDIO_DEVICE_IN_TELEPHONY_RX, String8(), AUDIO_FORMAT_DEFAULT);
633
634 // RX Telephony and Rx sink devices are declared by Primary Audio HAL
635 if (isPrimaryModule(telephonyRxModule) && (telephonyRxModule->getHalVersionMajor() >= 3) &&
636 telephonyRxModule->supportsPatch(rxSourceDevice, rxSinkDevice)) {
637 ALOGW("%s() device %s using HW Bridge", __func__, rxSinkDevice->toString().c_str());
638 return DeviceVector(rxSinkDevice);
639 }
640 }
641 // Note that despite the fact that getNewOutputDevices() is called on the primary output,
642 // the device returned is not necessarily reachable via this output
643 // (filter later by setOutputDevices())
644 return getNewOutputDevices(mPrimaryOutput, fromCache);
645}
646
647status_t AudioPolicyManager::updateCallRouting(bool fromCache, uint32_t delayMs, uint32_t *waitMs)
648{
649 if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
650 DeviceVector rxDevices = selectBestRxSinkDevicesForCall(fromCache);
651 return updateCallRoutingInternal(rxDevices, delayMs, waitMs);
652 }
653 return INVALID_OPERATION;
654}
655
656status_t AudioPolicyManager::updateCallRoutingInternal(
657 const DeviceVector &rxDevices, uint32_t delayMs, uint32_t *waitMs)
Eric Laurentc2730ba2014-07-20 15:47:07 -0700658{
659 bool createTxPatch = false;
François Gaffie9eb18552018-11-05 10:33:26 +0100660 bool createRxPatch = false;
Eric Laurentdc462862016-07-19 12:29:53 -0700661 uint32_t muteWaitMs = 0;
jiabin9a3361e2019-10-01 09:38:30 -0700662 if(!hasPrimaryOutput() ||
663 mPrimaryOutput->devices().onlyContainsDevicesWithType(AUDIO_DEVICE_OUT_STUB)) {
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100664 return INVALID_OPERATION;
Eric Laurent87ffa392015-05-22 10:32:38 -0700665 }
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100666 ALOG_ASSERT(!rxDevices.isEmpty(), "%s() no selected output device", __func__);
François Gaffie11d30102018-11-02 16:09:09 +0100667
Francois Gaffie716e1432019-01-14 16:58:59 +0100668 audio_attributes_t attr = { .source = AUDIO_SOURCE_VOICE_COMMUNICATION };
François Gaffiec005e562018-11-06 15:04:49 +0100669 auto txSourceDevice = mEngine->getInputDeviceForAttributes(attr);
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100670 ALOG_ASSERT(txSourceDevice != 0, "%s() input selected device not available", __func__);
François Gaffiec005e562018-11-06 15:04:49 +0100671
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100672 ALOGV("%s device rxDevice %s txDevice %s", __func__,
François Gaffie9eb18552018-11-05 10:33:26 +0100673 rxDevices.itemAt(0)->toString().c_str(), txSourceDevice->toString().c_str());
Eric Laurentc2730ba2014-07-20 15:47:07 -0700674
Francois Gaffie601801d2021-06-22 13:27:39 +0200675 disconnectTelephonyAudioSource(mCallRxSourceClient);
676 disconnectTelephonyAudioSource(mCallTxSourceClient);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700677
François Gaffie9eb18552018-11-05 10:33:26 +0100678 auto telephonyRxModule =
jiabin9a3361e2019-10-01 09:38:30 -0700679 mHwModules.getModuleForDeviceType(AUDIO_DEVICE_IN_TELEPHONY_RX, AUDIO_FORMAT_DEFAULT);
François Gaffie9eb18552018-11-05 10:33:26 +0100680 auto telephonyTxModule =
jiabin9a3361e2019-10-01 09:38:30 -0700681 mHwModules.getModuleForDeviceType(AUDIO_DEVICE_OUT_TELEPHONY_TX, AUDIO_FORMAT_DEFAULT);
François Gaffie9eb18552018-11-05 10:33:26 +0100682 // retrieve Rx Source and Tx Sink device descriptors
683 sp<DeviceDescriptor> rxSourceDevice =
684 mAvailableInputDevices.getDevice(AUDIO_DEVICE_IN_TELEPHONY_RX,
685 String8(),
686 AUDIO_FORMAT_DEFAULT);
687 sp<DeviceDescriptor> txSinkDevice =
688 mAvailableOutputDevices.getDevice(AUDIO_DEVICE_OUT_TELEPHONY_TX,
689 String8(),
690 AUDIO_FORMAT_DEFAULT);
691
692 // RX and TX Telephony device are declared by Primary Audio HAL
693 if (isPrimaryModule(telephonyRxModule) && isPrimaryModule(telephonyTxModule) &&
694 (telephonyRxModule->getHalVersionMajor() >= 3)) {
695 if (rxSourceDevice == 0 || txSinkDevice == 0) {
696 // RX / TX Telephony device(s) is(are) not currently available
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100697 ALOGE("%s() no telephony Tx and/or RX device", __func__);
698 return INVALID_OPERATION;
François Gaffie9eb18552018-11-05 10:33:26 +0100699 }
François Gaffieafd4cea2019-11-18 15:50:22 +0100700 // createAudioPatchInternal now supports both HW / SW bridging
701 createRxPatch = true;
702 createTxPatch = true;
François Gaffie9eb18552018-11-05 10:33:26 +0100703 } else {
704 // If the RX device is on the primary HW module, then use legacy routing method for
705 // voice calls via setOutputDevice() on primary output.
706 // Otherwise, create two audio patches for TX and RX path.
707 createRxPatch = !(availablePrimaryOutputDevices().contains(rxDevices.itemAt(0))) &&
708 (rxSourceDevice != 0);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700709 // If the TX device is also on the primary HW module, setOutputDevice() will take care
710 // of it due to legacy implementation. If not, create a patch.
François Gaffie9eb18552018-11-05 10:33:26 +0100711 createTxPatch = !(availablePrimaryModuleInputDevices().contains(txSourceDevice)) &&
712 (txSinkDevice != 0);
713 }
714 // Use legacy routing method for voice calls via setOutputDevice() on primary output.
715 // Otherwise, create two audio patches for TX and RX path.
716 if (!createRxPatch) {
717 muteWaitMs = setOutputDevices(mPrimaryOutput, rxDevices, true, delayMs);
Eric Laurent8ae73122016-04-12 10:13:29 -0700718 } else { // create RX path audio patch
Francois Gaffie51c9ccd2020-10-14 18:02:07 +0200719 connectTelephonyRxAudioSource();
juyuchen2224c5a2019-01-21 12:00:58 +0800720 // If the TX device is on the primary HW module but RX device is
721 // on other HW module, SinkMetaData of telephony input should handle it
722 // assuming the device uses audio HAL V5.0 and above
Eric Laurentc2730ba2014-07-20 15:47:07 -0700723 }
Eric Laurent8ae73122016-04-12 10:13:29 -0700724 if (createTxPatch) { // create TX path audio patch
François Gaffieafd4cea2019-11-18 15:50:22 +0100725 // terminate active capture if on the same HW module as the call TX source device
726 // FIXME: would be better to refine to only inputs whose profile connects to the
727 // call TX device but this information is not in the audio patch and logic here must be
728 // symmetric to the one in startInput()
729 for (const auto& activeDesc : mInputs.getActiveInputs()) {
730 if (activeDesc->hasSameHwModuleAs(txSourceDevice)) {
731 closeActiveClients(activeDesc);
732 }
733 }
Francois Gaffieb2e5cb52021-06-22 13:16:09 +0200734 connectTelephonyTxAudioSource(txSourceDevice, txSinkDevice, delayMs);
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800735 }
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100736 if (waitMs != nullptr) {
737 *waitMs = muteWaitMs;
738 }
739 return NO_ERROR;
Mikhail Naganovb567ba02017-12-08 11:16:27 -0800740}
Eric Laurentc2730ba2014-07-20 15:47:07 -0700741
Mikhail Naganov100f0122018-11-29 11:22:16 -0800742bool AudioPolicyManager::isDeviceOfModule(
743 const sp<DeviceDescriptor>& devDesc, const char *moduleId) const {
744 sp<HwModule> module = mHwModules.getModuleFromName(moduleId);
745 if (module != 0) {
746 return mAvailableOutputDevices.getDevicesFromHwModule(module->getHandle())
747 .indexOf(devDesc) != NAME_NOT_FOUND
748 || mAvailableInputDevices.getDevicesFromHwModule(module->getHandle())
749 .indexOf(devDesc) != NAME_NOT_FOUND;
750 }
751 return false;
752}
753
Francois Gaffie51c9ccd2020-10-14 18:02:07 +0200754void AudioPolicyManager::connectTelephonyRxAudioSource()
755{
Francois Gaffie601801d2021-06-22 13:27:39 +0200756 disconnectTelephonyAudioSource(mCallRxSourceClient);
Francois Gaffie51c9ccd2020-10-14 18:02:07 +0200757 const struct audio_port_config source = {
758 .role = AUDIO_PORT_ROLE_SOURCE, .type = AUDIO_PORT_TYPE_DEVICE,
759 .ext.device.type = AUDIO_DEVICE_IN_TELEPHONY_RX, .ext.device.address = ""
760 };
761 const auto aa = mEngine->getAttributesForStreamType(AUDIO_STREAM_VOICE_CALL);
Francois Gaffie601801d2021-06-22 13:27:39 +0200762 mCallRxSourceClient = startAudioSourceInternal(&source, &aa, 0/*uid*/);
763 ALOGE_IF(mCallRxSourceClient == nullptr,
764 "%s failed to start Telephony Rx AudioSource", __func__);
Francois Gaffie51c9ccd2020-10-14 18:02:07 +0200765}
766
Francois Gaffie601801d2021-06-22 13:27:39 +0200767void AudioPolicyManager::disconnectTelephonyAudioSource(sp<SourceClientDescriptor> &clientDesc)
Francois Gaffie51c9ccd2020-10-14 18:02:07 +0200768{
Francois Gaffie601801d2021-06-22 13:27:39 +0200769 if (clientDesc == nullptr) {
770 return;
771 }
772 ALOGW_IF(stopAudioSource(clientDesc->portId()) != NO_ERROR,
773 "%s error stopping audio source", __func__);
774 clientDesc.clear();
Francois Gaffieb2e5cb52021-06-22 13:16:09 +0200775}
776
777void AudioPolicyManager::connectTelephonyTxAudioSource(
778 const sp<DeviceDescriptor> &srcDevice, const sp<DeviceDescriptor> &sinkDevice,
779 uint32_t delayMs)
780{
Francois Gaffie601801d2021-06-22 13:27:39 +0200781 disconnectTelephonyAudioSource(mCallTxSourceClient);
Francois Gaffieb2e5cb52021-06-22 13:16:09 +0200782 if (srcDevice == nullptr || sinkDevice == nullptr) {
783 ALOGW("%s could not create patch, invalid sink and/or source device(s)", __func__);
784 return;
785 }
786 PatchBuilder patchBuilder;
787 patchBuilder.addSource(srcDevice).addSink(sinkDevice);
788 ALOGV("%s between source %s and sink %s", __func__,
789 srcDevice->toString().c_str(), sinkDevice->toString().c_str());
Francois Gaffie601801d2021-06-22 13:27:39 +0200790 auto callTxSourceClientPortId = PolicyAudioPort::getNextUniqueId();
Eric Laurent78b07302022-10-07 16:20:34 +0200791 const auto aa = mEngine->getAttributesForStreamType(AUDIO_STREAM_VOICE_CALL);
792
Francois Gaffieb2e5cb52021-06-22 13:16:09 +0200793 struct audio_port_config source = {};
794 srcDevice->toAudioPortConfig(&source);
Francois Gaffie601801d2021-06-22 13:27:39 +0200795 mCallTxSourceClient = new InternalSourceClientDescriptor(
796 callTxSourceClientPortId, mUidCached, aa, source, srcDevice, sinkDevice,
Francois Gaffieb2e5cb52021-06-22 13:16:09 +0200797 mCommunnicationStrategy, toVolumeSource(aa));
798 audio_patch_handle_t patchHandle = AUDIO_PATCH_HANDLE_NONE;
799 status_t status = connectAudioSourceToSink(
Francois Gaffie601801d2021-06-22 13:27:39 +0200800 mCallTxSourceClient, sinkDevice, patchBuilder.patch(), patchHandle, mUidCached,
801 delayMs);
Francois Gaffieb2e5cb52021-06-22 13:16:09 +0200802 ALOGE_IF(status != NO_ERROR, "%s() error %d creating TX audio patch", __func__, status);
803 if (status == NO_ERROR) {
Francois Gaffie601801d2021-06-22 13:27:39 +0200804 mAudioSources.add(callTxSourceClientPortId, mCallTxSourceClient);
Francois Gaffieb2e5cb52021-06-22 13:16:09 +0200805 }
Francois Gaffie51c9ccd2020-10-14 18:02:07 +0200806}
807
Eric Laurente0720872014-03-11 09:30:41 -0700808void AudioPolicyManager::setPhoneState(audio_mode_t state)
Eric Laurente552edb2014-03-10 17:42:56 -0700809{
810 ALOGV("setPhoneState() state %d", state);
François Gaffie2110e042015-03-24 08:41:51 +0100811 // store previous phone state for management of sonification strategy below
812 int oldState = mEngine->getPhoneState();
Eric Laurent96d1dda2022-03-14 17:14:19 +0100813 bool wasLeUnicastActive = isLeUnicastActive();
François Gaffie2110e042015-03-24 08:41:51 +0100814
815 if (mEngine->setPhoneState(state) != NO_ERROR) {
816 ALOGW("setPhoneState() invalid or same state %d", state);
Eric Laurente552edb2014-03-10 17:42:56 -0700817 return;
818 }
François Gaffie2110e042015-03-24 08:41:51 +0100819 /// Opens: can these line be executed after the switch of volume curves???
Eric Laurent63dea1d2015-07-02 17:10:28 -0700820 if (isStateInCall(oldState)) {
Eric Laurente552edb2014-03-10 17:42:56 -0700821 ALOGV("setPhoneState() in call state management: new state is %d", state);
Eric Laurent63dea1d2015-07-02 17:10:28 -0700822 // force reevaluating accessibility routing when call stops
Eric Laurent2cbe89a2014-12-19 11:49:08 -0800823 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
Eric Laurente552edb2014-03-10 17:42:56 -0700824 }
825
François Gaffie2110e042015-03-24 08:41:51 +0100826 /**
827 * Switching to or from incall state or switching between telephony and VoIP lead to force
828 * routing command.
829 */
Eric Laurent74b71512019-11-06 17:21:57 -0800830 bool force = ((isStateInCall(oldState) != isStateInCall(state))
831 || (isStateInCall(state) && (state != oldState)));
Eric Laurente552edb2014-03-10 17:42:56 -0700832
833 // check for device and output changes triggered by new phone state
Mikhail Naganov37977152018-07-11 15:54:44 -0700834 checkForDeviceAndOutputChanges();
Eric Laurente552edb2014-03-10 17:42:56 -0700835
Eric Laurente552edb2014-03-10 17:42:56 -0700836 int delayMs = 0;
837 if (isStateInCall(state)) {
838 nsecs_t sysTime = systemTime();
François Gaffiec005e562018-11-06 15:04:49 +0100839 auto musicStrategy = streamToStrategy(AUDIO_STREAM_MUSIC);
840 auto sonificationStrategy = streamToStrategy(AUDIO_STREAM_ALARM);
Eric Laurente552edb2014-03-10 17:42:56 -0700841 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -0700842 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Eric Laurente552edb2014-03-10 17:42:56 -0700843 // mute media and sonification strategies and delay device switch by the largest
844 // latency of any output where either strategy is active.
845 // This avoid sending the ring tone or music tail into the earpiece or headset.
François Gaffiec005e562018-11-06 15:04:49 +0100846 if ((desc->isStrategyActive(musicStrategy, SONIFICATION_HEADSET_MUSIC_DELAY, sysTime) ||
847 desc->isStrategyActive(sonificationStrategy, SONIFICATION_HEADSET_MUSIC_DELAY,
848 sysTime)) &&
Eric Laurentc75307b2015-03-17 15:29:32 -0700849 (delayMs < (int)desc->latency()*2)) {
850 delayMs = desc->latency()*2;
Eric Laurente552edb2014-03-10 17:42:56 -0700851 }
François Gaffiec005e562018-11-06 15:04:49 +0100852 setStrategyMute(musicStrategy, true, desc);
853 setStrategyMute(musicStrategy, false, desc, MUTE_TIME_MS,
854 mEngine->getOutputDevicesForAttributes(attributes_initializer(AUDIO_USAGE_MEDIA),
855 nullptr, true /*fromCache*/).types());
856 setStrategyMute(sonificationStrategy, true, desc);
857 setStrategyMute(sonificationStrategy, false, desc, MUTE_TIME_MS,
858 mEngine->getOutputDevicesForAttributes(attributes_initializer(AUDIO_USAGE_ALARM),
859 nullptr, true /*fromCache*/).types());
Eric Laurente552edb2014-03-10 17:42:56 -0700860 }
861 }
862
Eric Laurent87ffa392015-05-22 10:32:38 -0700863 if (hasPrimaryOutput()) {
Eric Laurent87ffa392015-05-22 10:32:38 -0700864 if (state == AUDIO_MODE_IN_CALL) {
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100865 (void)updateCallRouting(false /*fromCache*/, delayMs);
Eric Laurent87ffa392015-05-22 10:32:38 -0700866 } else {
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100867 DeviceVector rxDevices = getNewOutputDevices(mPrimaryOutput, false /*fromCache*/);
868 // force routing command to audio hardware when ending call
869 // even if no device change is needed
870 if (isStateInCall(oldState) && rxDevices.isEmpty()) {
871 rxDevices = mPrimaryOutput->devices();
872 }
873 if (oldState == AUDIO_MODE_IN_CALL) {
Francois Gaffie601801d2021-06-22 13:27:39 +0200874 disconnectTelephonyAudioSource(mCallRxSourceClient);
875 disconnectTelephonyAudioSource(mCallTxSourceClient);
Francois Gaffie19fd6c52021-02-04 17:02:59 +0100876 }
François Gaffie11d30102018-11-02 16:09:09 +0100877 setOutputDevices(mPrimaryOutput, rxDevices, force, 0);
Eric Laurentc2730ba2014-07-20 15:47:07 -0700878 }
Eric Laurentc2730ba2014-07-20 15:47:07 -0700879 }
Eric Laurent2e2a8a92018-04-20 16:21:33 -0700880
881 // reevaluate routing on all outputs in case tracks have been started during the call
882 for (size_t i = 0; i < mOutputs.size(); i++) {
883 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
François Gaffie11d30102018-11-02 16:09:09 +0100884 DeviceVector newDevices = getNewOutputDevices(desc, true /*fromCache*/);
Francois Gaffie601801d2021-06-22 13:27:39 +0200885 if (state != AUDIO_MODE_IN_CALL || (desc != mPrimaryOutput && !isTelephonyRxOrTx(desc))) {
886 bool forceRouting = !newDevices.isEmpty();
887 setOutputDevices(desc, newDevices, forceRouting, 0 /*delayMs*/, nullptr,
888 true /*requiresMuteCheck*/, !forceRouting /*requiresVolumeCheck*/);
Eric Laurent2e2a8a92018-04-20 16:21:33 -0700889 }
890 }
891
Eric Laurent96d1dda2022-03-14 17:14:19 +0100892 checkLeBroadcastRoutes(wasLeUnicastActive, nullptr, delayMs);
893
Eric Laurente552edb2014-03-10 17:42:56 -0700894 if (isStateInCall(state)) {
895 ALOGV("setPhoneState() in call state management: new state is %d", state);
Eric Laurent63dea1d2015-07-02 17:10:28 -0700896 // force reevaluating accessibility routing when call starts
897 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
Eric Laurente552edb2014-03-10 17:42:56 -0700898 }
899
900 // Flag that ringtone volume must be limited to music volume until we exit MODE_RINGTONE
François Gaffiec005e562018-11-06 15:04:49 +0100901 mLimitRingtoneVolume = (state == AUDIO_MODE_RINGTONE &&
902 isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY));
Eric Laurente552edb2014-03-10 17:42:56 -0700903}
904
Jean-Michel Trivi887a9ed2015-03-31 18:02:24 -0700905audio_mode_t AudioPolicyManager::getPhoneState() {
906 return mEngine->getPhoneState();
907}
908
Eric Laurente0720872014-03-11 09:30:41 -0700909void AudioPolicyManager::setForceUse(audio_policy_force_use_t usage,
François Gaffie11d30102018-11-02 16:09:09 +0100910 audio_policy_forced_cfg_t config)
Eric Laurente552edb2014-03-10 17:42:56 -0700911{
François Gaffie2110e042015-03-24 08:41:51 +0100912 ALOGV("setForceUse() usage %d, config %d, mPhoneState %d", usage, config, mEngine->getPhoneState());
Eric Laurent8dc87a62017-05-16 19:00:40 -0700913 if (config == mEngine->getForceUse(usage)) {
914 return;
915 }
Eric Laurente552edb2014-03-10 17:42:56 -0700916
François Gaffie2110e042015-03-24 08:41:51 +0100917 if (mEngine->setForceUse(usage, config) != NO_ERROR) {
918 ALOGW("setForceUse() could not set force cfg %d for usage %d", config, usage);
919 return;
Eric Laurente552edb2014-03-10 17:42:56 -0700920 }
François Gaffie2110e042015-03-24 08:41:51 +0100921 bool forceVolumeReeval = (usage == AUDIO_POLICY_FORCE_FOR_COMMUNICATION) ||
922 (usage == AUDIO_POLICY_FORCE_FOR_DOCK) ||
923 (usage == AUDIO_POLICY_FORCE_FOR_SYSTEM);
Eric Laurente552edb2014-03-10 17:42:56 -0700924
925 // check for device and output changes triggered by new force usage
Mikhail Naganov37977152018-07-11 15:54:44 -0700926 checkForDeviceAndOutputChanges();
Phil Burk09bc4612016-02-24 15:58:15 -0800927
Eric Laurent22fcda22019-05-17 16:28:47 -0700928 // force client reconnection to reevaluate flag AUDIO_FLAG_AUDIBILITY_ENFORCED
929 if (usage == AUDIO_POLICY_FORCE_FOR_SYSTEM) {
930 mpClientInterface->invalidateStream(AUDIO_STREAM_SYSTEM);
931 mpClientInterface->invalidateStream(AUDIO_STREAM_ENFORCED_AUDIBLE);
932 }
933
Eric Laurentdc462862016-07-19 12:29:53 -0700934 //FIXME: workaround for truncated touch sounds
935 // to be removed when the problem is handled by system UI
936 uint32_t delayMs = 0;
Eric Laurentdc462862016-07-19 12:29:53 -0700937 if (usage == AUDIO_POLICY_FORCE_FOR_COMMUNICATION) {
938 delayMs = TOUCH_SOUND_FIXED_DELAY_MS;
939 }
Jean-Michel Trivi30857152019-11-01 11:04:15 -0700940
941 updateCallAndOutputRouting(forceVolumeReeval, delayMs);
Eric Laurent2517af32020-11-25 15:31:27 +0100942 updateInputRouting();
Eric Laurente552edb2014-03-10 17:42:56 -0700943}
944
Eric Laurente0720872014-03-11 09:30:41 -0700945void AudioPolicyManager::setSystemProperty(const char* property, const char* value)
Eric Laurente552edb2014-03-10 17:42:56 -0700946{
947 ALOGV("setSystemProperty() property %s, value %s", property, value);
948}
949
Dorin Drimusecc9f422022-03-09 17:57:40 +0100950// Find an MSD output profile compatible with the parameters passed.
951// When "directOnly" is set, restrict search to profiles for direct outputs.
952sp<IOProfile> AudioPolicyManager::getMsdProfileForOutput(
953 const DeviceVector& devices,
954 uint32_t samplingRate,
955 audio_format_t format,
956 audio_channel_mask_t channelMask,
957 audio_output_flags_t flags,
958 bool directOnly)
959{
960 flags = getRelevantFlags(flags, directOnly);
961
962 sp<HwModule> msdModule = mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD);
963 if (msdModule != nullptr) {
964 // for the msd module check if there are patches to the output devices
965 if (msdHasPatchesToAllDevices(devices.toTypeAddrVector())) {
966 HwModuleCollection modules;
967 modules.add(msdModule);
968 return searchCompatibleProfileHwModules(
969 modules, getMsdAudioOutDevices(), samplingRate, format, channelMask,
970 flags, directOnly);
971 }
972 }
973 return nullptr;
974}
975
Michael Chana94fbb22018-04-24 14:31:19 +1000976// Find an output profile compatible with the parameters passed. When "directOnly" is set, restrict
977// search to profiles for direct outputs.
978sp<IOProfile> AudioPolicyManager::getProfileForOutput(
François Gaffie11d30102018-11-02 16:09:09 +0100979 const DeviceVector& devices,
Michael Chana94fbb22018-04-24 14:31:19 +1000980 uint32_t samplingRate,
981 audio_format_t format,
982 audio_channel_mask_t channelMask,
983 audio_output_flags_t flags,
984 bool directOnly)
Eric Laurente552edb2014-03-10 17:42:56 -0700985{
Dorin Drimusecc9f422022-03-09 17:57:40 +0100986 flags = getRelevantFlags(flags, directOnly);
987
988 return searchCompatibleProfileHwModules(
989 mHwModules, devices, samplingRate, format, channelMask, flags, directOnly);
990}
991
992audio_output_flags_t AudioPolicyManager::getRelevantFlags (
993 audio_output_flags_t flags, bool directOnly) {
Michael Chana94fbb22018-04-24 14:31:19 +1000994 if (directOnly) {
Dorin Drimusecc9f422022-03-09 17:57:40 +0100995 // only retain flags that will drive the direct output profile selection
996 // if explicitly requested
997 static const uint32_t kRelevantFlags =
Michael Chana94fbb22018-04-24 14:31:19 +1000998 (AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD |
Dorin Drimusecc9f422022-03-09 17:57:40 +0100999 AUDIO_OUTPUT_FLAG_VOIP_RX | AUDIO_OUTPUT_FLAG_MMAP_NOIRQ);
1000 flags = (audio_output_flags_t)((flags & kRelevantFlags) | AUDIO_OUTPUT_FLAG_DIRECT);
Michael Chana94fbb22018-04-24 14:31:19 +10001001 }
Dorin Drimusecc9f422022-03-09 17:57:40 +01001002 return flags;
1003}
Eric Laurent861a6282015-05-18 15:40:16 -07001004
Dorin Drimusecc9f422022-03-09 17:57:40 +01001005sp<IOProfile> AudioPolicyManager::searchCompatibleProfileHwModules (
1006 const HwModuleCollection& hwModules,
1007 const DeviceVector& devices,
1008 uint32_t samplingRate,
1009 audio_format_t format,
1010 audio_channel_mask_t channelMask,
1011 audio_output_flags_t flags,
1012 bool directOnly) {
Eric Laurent861a6282015-05-18 15:40:16 -07001013 sp<IOProfile> profile;
Dorin Drimusecc9f422022-03-09 17:57:40 +01001014 for (const auto& hwModule : hwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08001015 for (const auto& curProfile : hwModule->getOutputProfiles()) {
Dorin Drimusecc9f422022-03-09 17:57:40 +01001016 if (!curProfile->isCompatibleProfile(devices,
1017 samplingRate, NULL /*updatedSamplingRate*/,
1018 format, NULL /*updatedFormat*/,
1019 channelMask, NULL /*updatedChannelMask*/,
1020 flags)) {
1021 continue;
1022 }
1023 // reject profiles not corresponding to a device currently available
1024 if (!mAvailableOutputDevices.containsAtLeastOne(curProfile->getSupportedDevices())) {
1025 continue;
1026 }
1027 // reject profiles if connected device does not support codec
1028 if (!curProfile->devicesSupportEncodedFormats(devices.types())) {
1029 continue;
1030 }
1031 if (!directOnly) {
1032 return curProfile;
1033 }
1034
1035 // when searching for direct outputs, if several profiles are compatible, give priority
1036 // to one with offload capability
1037 if (profile != 0 &&
1038 ((curProfile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0)) {
Eric Laurent861a6282015-05-18 15:40:16 -07001039 continue;
Dorin Drimusecc9f422022-03-09 17:57:40 +01001040 }
1041 profile = curProfile;
1042 if ((profile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
1043 break;
1044 }
Eric Laurente552edb2014-03-10 17:42:56 -07001045 }
1046 }
Eric Laurent861a6282015-05-18 15:40:16 -07001047 return profile;
Eric Laurente552edb2014-03-10 17:42:56 -07001048}
1049
Eric Laurentfa0f6742021-08-17 18:39:44 +02001050sp<IOProfile> AudioPolicyManager::getSpatializerOutputProfile(
Eric Laurent39095982021-08-24 18:29:27 +02001051 const audio_config_t *config __unused, const AudioDeviceTypeAddrVector &devices) const
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001052{
1053 for (const auto& hwModule : mHwModules) {
1054 for (const auto& curProfile : hwModule->getOutputProfiles()) {
Eric Laurent1c5e2e32021-08-18 18:50:28 +02001055 if (curProfile->getFlags() != AUDIO_OUTPUT_FLAG_SPATIALIZER) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001056 continue;
1057 }
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001058 if (!devices.empty()) {
Eric Laurent0c8f7cc2022-06-24 14:32:36 +02001059 // reject profiles not corresponding to a device currently available
1060 DeviceVector supportedDevices = curProfile->getSupportedDevices();
1061 if (!mAvailableOutputDevices.containsAtLeastOne(supportedDevices)) {
1062 continue;
1063 }
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001064 if (supportedDevices.getDevicesFromDeviceTypeAddrVec(devices).size()
1065 != devices.size()) {
1066 continue;
1067 }
1068 }
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001069 ALOGV("%s found profile %s", __func__, curProfile->getName().c_str());
1070 return curProfile;
1071 }
1072 }
1073 return nullptr;
1074}
1075
Eric Laurentf4e63452017-11-06 19:31:46 +00001076audio_io_handle_t AudioPolicyManager::getOutput(audio_stream_type_t stream)
Eric Laurente552edb2014-03-10 17:42:56 -07001077{
François Gaffiec005e562018-11-06 15:04:49 +01001078 DeviceVector devices = mEngine->getOutputDevicesForStream(stream, false /*fromCache*/);
Andy Hungc9901522017-11-10 20:07:54 -08001079
1080 // Note that related method getOutputForAttr() uses getOutputForDevice() not selectOutput().
1081 // We use selectOutput() here since we don't have the desired AudioTrack sample rate,
1082 // format, flags, etc. This may result in some discrepancy for functions that utilize
1083 // getOutput() solely on audio_stream_type such as AudioSystem::getOutputFrameCount()
1084 // and AudioSystem::getOutputSamplingRate().
1085
François Gaffie11d30102018-11-02 16:09:09 +01001086 SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
Eric Laurent16c66dd2019-05-01 17:54:10 -07001087 const audio_io_handle_t output = selectOutput(outputs);
Eric Laurente552edb2014-03-10 17:42:56 -07001088
François Gaffie11d30102018-11-02 16:09:09 +01001089 ALOGV("getOutput() stream %d selected devices %s, output %d", stream,
1090 devices.toString().c_str(), output);
Eric Laurentf4e63452017-11-06 19:31:46 +00001091 return output;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001092}
1093
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001094status_t AudioPolicyManager::getAudioAttributes(audio_attributes_t *dstAttr,
1095 const audio_attributes_t *srcAttr,
1096 audio_stream_type_t srcStream)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001097{
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001098 if (srcAttr != NULL) {
1099 if (!isValidAttributes(srcAttr)) {
1100 ALOGE("%s invalid attributes: usage=%d content=%d flags=0x%x tags=[%s]",
1101 __func__,
1102 srcAttr->usage, srcAttr->content_type, srcAttr->flags,
1103 srcAttr->tags);
1104 return BAD_VALUE;
1105 }
1106 *dstAttr = *srcAttr;
1107 } else {
1108 if (srcStream < AUDIO_STREAM_MIN || srcStream >= AUDIO_STREAM_PUBLIC_CNT) {
1109 ALOGE("%s: invalid stream type", __func__);
1110 return BAD_VALUE;
1111 }
François Gaffiec005e562018-11-06 15:04:49 +01001112 *dstAttr = mEngine->getAttributesForStreamType(srcStream);
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001113 }
Eric Laurent22fcda22019-05-17 16:28:47 -07001114
1115 // Only honor audibility enforced when required. The client will be
1116 // forced to reconnect if the forced usage changes.
1117 if (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) != AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
Mikhail Naganov55773032020-10-01 15:08:13 -07001118 dstAttr->flags = static_cast<audio_flags_mask_t>(
1119 dstAttr->flags & ~AUDIO_FLAG_AUDIBILITY_ENFORCED);
Eric Laurent22fcda22019-05-17 16:28:47 -07001120 }
1121
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001122 return NO_ERROR;
1123}
1124
Kevin Rocard153f92d2018-12-18 18:33:28 -08001125status_t AudioPolicyManager::getOutputForAttrInt(
1126 audio_attributes_t *resultAttr,
1127 audio_io_handle_t *output,
1128 audio_session_t session,
1129 const audio_attributes_t *attr,
1130 audio_stream_type_t *stream,
1131 uid_t uid,
1132 const audio_config_t *config,
1133 audio_output_flags_t *flags,
1134 audio_port_handle_t *selectedDeviceId,
1135 bool *isRequestedDeviceForExclusiveUse,
Eric Laurentc529cf62020-04-17 18:19:10 -07001136 std::vector<sp<AudioPolicyMix>> *secondaryMixes,
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001137 output_type_t *outputType,
1138 bool *isSpatialized)
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001139{
François Gaffiec005e562018-11-06 15:04:49 +01001140 DeviceVector outputDevices;
Francois Gaffie716e1432019-01-14 16:58:59 +01001141 const audio_port_handle_t requestedPortId = *selectedDeviceId;
François Gaffie11d30102018-11-02 16:09:09 +01001142 DeviceVector msdDevices = getMsdAudioOutDevices();
François Gaffiec005e562018-11-06 15:04:49 +01001143 const sp<DeviceDescriptor> requestedDevice =
1144 mAvailableOutputDevices.getDeviceFromId(requestedPortId);
1145
Eric Laurent8a1095a2019-11-08 14:44:16 -08001146 *outputType = API_OUTPUT_INVALID;
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001147 *isSpatialized = false;
1148
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001149 status_t status = getAudioAttributes(resultAttr, attr, *stream);
1150 if (status != NO_ERROR) {
1151 return status;
Eric Laurent8f42ea12018-08-08 09:08:25 -07001152 }
Kevin Rocardb99cc752019-03-21 20:52:24 -07001153 if (auto it = mAllowedCapturePolicies.find(uid); it != end(mAllowedCapturePolicies)) {
Mikhail Naganov55773032020-10-01 15:08:13 -07001154 resultAttr->flags = static_cast<audio_flags_mask_t>(resultAttr->flags | it->second);
Kevin Rocardb99cc752019-03-21 20:52:24 -07001155 }
François Gaffiec005e562018-11-06 15:04:49 +01001156 *stream = mEngine->getStreamTypeForAttributes(*resultAttr);
Eric Laurent8f42ea12018-08-08 09:08:25 -07001157
François Gaffiec005e562018-11-06 15:04:49 +01001158 ALOGV("%s() attributes=%s stream=%s session %d selectedDeviceId %d", __func__,
1159 toString(*resultAttr).c_str(), toString(*stream).c_str(), session, requestedPortId);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001160
Kevin Rocard153f92d2018-12-18 18:33:28 -08001161 // The primary output is the explicit routing (eg. setPreferredDevice) if specified,
1162 // otherwise, fallback to the dynamic policies, if none match, query the engine.
1163 // Secondary outputs are always found by dynamic policies as the engine do not support them
Eric Laurentc529cf62020-04-17 18:19:10 -07001164 sp<AudioPolicyMix> primaryMix;
Dean Wheatleyd082f472022-02-04 11:10:48 +11001165 const audio_config_base_t clientConfig = {.sample_rate = config->sample_rate,
1166 .channel_mask = config->channel_mask,
1167 .format = config->format,
1168 };
1169 status = mPolicyMixes.getOutputForAttr(*resultAttr, clientConfig, uid, *flags, primaryMix,
1170 secondaryMixes);
Kevin Rocard94114a22019-04-01 19:38:23 -07001171 if (status != OK) {
1172 return status;
Kevin Rocard153f92d2018-12-18 18:33:28 -08001173 }
Kevin Rocard94114a22019-04-01 19:38:23 -07001174
Kevin Rocard153f92d2018-12-18 18:33:28 -08001175 // Explicit routing is higher priority then any dynamic policy primary output
Eric Laurentc529cf62020-04-17 18:19:10 -07001176 bool usePrimaryOutputFromPolicyMixes = requestedDevice == nullptr && primaryMix != nullptr;
Kevin Rocard153f92d2018-12-18 18:33:28 -08001177
1178 // FIXME: in case of RENDER policy, the output capabilities should be checked
Dean Wheatleyd082f472022-02-04 11:10:48 +11001179 if ((secondaryMixes != nullptr && !secondaryMixes->empty())
1180 && !audio_is_linear_pcm(config->format)) {
1181 ALOGD("%s: rejecting request as secondary mixes only support pcm", __func__);
Kevin Rocard153f92d2018-12-18 18:33:28 -08001182 return BAD_VALUE;
1183 }
1184 if (usePrimaryOutputFromPolicyMixes) {
Eric Laurentc529cf62020-04-17 18:19:10 -07001185 sp<DeviceDescriptor> deviceDesc =
1186 mAvailableOutputDevices.getDevice(primaryMix->mDeviceType,
1187 primaryMix->mDeviceAddress,
1188 AUDIO_FORMAT_DEFAULT);
1189 sp<SwAudioOutputDescriptor> policyDesc = primaryMix->getOutput();
Dean Wheatleyecbf2ee2022-03-04 10:51:36 +11001190 bool tryDirectForFlags = policyDesc == nullptr ||
1191 (policyDesc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT);
1192 // if a direct output can be opened to deliver the track's multi-channel content to the
1193 // output rather than being downmixed by the primary output, then use this direct
1194 // output by by-passing the primary mix if possible, otherwise fall-through to primary
1195 // mix.
1196 bool tryDirectForChannelMask = policyDesc != nullptr
1197 && (audio_channel_count_from_out_mask(policyDesc->getConfig().channel_mask) <
1198 audio_channel_count_from_out_mask(config->channel_mask));
1199 if (deviceDesc != nullptr && (tryDirectForFlags || tryDirectForChannelMask)) {
Eric Laurentc529cf62020-04-17 18:19:10 -07001200 audio_io_handle_t newOutput;
1201 status = openDirectOutput(
1202 *stream, session, config,
1203 (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_DIRECT),
1204 DeviceVector(deviceDesc), &newOutput);
Dean Wheatleyecbf2ee2022-03-04 10:51:36 +11001205 if (status == NO_ERROR) {
Eric Laurentc529cf62020-04-17 18:19:10 -07001206 policyDesc = mOutputs.valueFor(newOutput);
1207 primaryMix->setOutput(policyDesc);
Dean Wheatleyecbf2ee2022-03-04 10:51:36 +11001208 } else if (tryDirectForFlags) {
1209 policyDesc = nullptr;
1210 } // otherwise use primary if available.
Eric Laurentc529cf62020-04-17 18:19:10 -07001211 }
1212 if (policyDesc != nullptr) {
1213 policyDesc->mPolicyMix = primaryMix;
1214 *output = policyDesc->mIoHandle;
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08001215 *selectedDeviceId = deviceDesc != 0 ? deviceDesc->getId() : AUDIO_PORT_HANDLE_NONE;
Eric Laurent8a1095a2019-11-08 14:44:16 -08001216
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08001217 ALOGV("getOutputForAttr() returns output %d", *output);
1218 if (resultAttr->usage == AUDIO_USAGE_VIRTUAL_SOURCE) {
1219 *outputType = API_OUT_MIX_PLAYBACK;
1220 } else {
1221 *outputType = API_OUTPUT_LEGACY;
1222 }
1223 return NO_ERROR;
Eric Laurent8a1095a2019-11-08 14:44:16 -08001224 }
Eric Laurent8c7e6da2015-04-21 17:37:00 -07001225 }
François Gaffiec005e562018-11-06 15:04:49 +01001226 // Virtual sources must always be dynamicaly or explicitly routed
1227 if (resultAttr->usage == AUDIO_USAGE_VIRTUAL_SOURCE) {
1228 ALOGW("getOutputForAttr() no policy mix found for usage AUDIO_USAGE_VIRTUAL_SOURCE");
1229 return BAD_VALUE;
1230 }
1231 // explicit routing managed by getDeviceForStrategy in APM is now handled by engine
1232 // in order to let the choice of the order to future vendor engine
1233 outputDevices = mEngine->getOutputDevicesForAttributes(*resultAttr, requestedDevice, false);
Scott Randolph7b1fd232018-06-18 15:33:03 -07001234
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001235 if ((resultAttr->flags & AUDIO_FLAG_HW_AV_SYNC) != 0) {
Nadav Bar766fb022018-01-07 12:18:03 +02001236 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_HW_AV_SYNC);
Eric Laurent93c3d412014-08-01 14:48:35 -07001237 }
1238
Nadav Barb2f18162018-07-18 13:01:53 +03001239 // Set incall music only if device was explicitly set, and fallback to the device which is
1240 // chosen by the engine if not.
1241 // FIXME: provide a more generic approach which is not device specific and move this back
1242 // to getOutputForDevice.
Nadav Bar20919492018-11-20 10:20:51 +02001243 // TODO: Remove check of AUDIO_STREAM_MUSIC once migration is completed on the app side.
jiabin9a3361e2019-10-01 09:38:30 -07001244 if (outputDevices.onlyContainsDevicesWithType(AUDIO_DEVICE_OUT_TELEPHONY_TX) &&
François Gaffiec005e562018-11-06 15:04:49 +01001245 (*stream == AUDIO_STREAM_MUSIC || resultAttr->usage == AUDIO_USAGE_VOICE_COMMUNICATION) &&
Nadav Barb2f18162018-07-18 13:01:53 +03001246 audio_is_linear_pcm(config->format) &&
Eric Laurent74b71512019-11-06 17:21:57 -08001247 isCallAudioAccessible()) {
Francois Gaffie716e1432019-01-14 16:58:59 +01001248 if (requestedPortId != AUDIO_PORT_HANDLE_NONE) {
Nadav Barb2f18162018-07-18 13:01:53 +03001249 *flags = (audio_output_flags_t)AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
François Gaffief579db52018-11-13 11:25:16 +01001250 *isRequestedDeviceForExclusiveUse = true;
Nadav Barb2f18162018-07-18 13:01:53 +03001251 }
1252 }
1253
François Gaffiec005e562018-11-06 15:04:49 +01001254 ALOGV("%s() device %s, sampling rate %d, format %#x, channel mask %#x, flags %#x stream %s",
1255 __func__, outputDevices.toString().c_str(), config->sample_rate, config->format,
1256 config->channel_mask, *flags, toString(*stream).c_str());
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001257
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001258 *output = AUDIO_IO_HANDLE_NONE;
François Gaffie11d30102018-11-02 16:09:09 +01001259 if (!msdDevices.isEmpty()) {
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001260 *output = getOutputForDevices(msdDevices, session, resultAttr, config, flags, isSpatialized);
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001261 if (*output != AUDIO_IO_HANDLE_NONE && setMsdOutputPatches(&outputDevices) == NO_ERROR) {
François Gaffiec005e562018-11-06 15:04:49 +01001262 ALOGV("%s() Using MSD devices %s instead of devices %s",
1263 __func__, msdDevices.toString().c_str(), outputDevices.toString().c_str());
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001264 } else {
1265 *output = AUDIO_IO_HANDLE_NONE;
1266 }
1267 }
1268 if (*output == AUDIO_IO_HANDLE_NONE) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001269 *output = getOutputForDevices(outputDevices, session, resultAttr, config,
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001270 flags, isSpatialized, resultAttr->flags & AUDIO_FLAG_MUTE_HAPTIC);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001271 }
Eric Laurente83b55d2014-11-14 10:06:21 -08001272 if (*output == AUDIO_IO_HANDLE_NONE) {
1273 return INVALID_OPERATION;
1274 }
Paul McLeanaa981192015-03-21 09:55:15 -07001275
François Gaffiec005e562018-11-06 15:04:49 +01001276 *selectedDeviceId = getFirstDeviceId(outputDevices);
Michael Chan6fb34492020-12-08 15:44:49 +11001277 for (auto &outputDevice : outputDevices) {
1278 if (outputDevice->getId() == getConfig().getDefaultOutputDevice()->getId()) {
1279 *selectedDeviceId = outputDevice->getId();
1280 break;
1281 }
1282 }
Eric Laurent2ac76942017-06-22 17:17:09 -07001283
Eric Laurent8a1095a2019-11-08 14:44:16 -08001284 if (outputDevices.onlyContainsDevicesWithType(AUDIO_DEVICE_OUT_TELEPHONY_TX)) {
1285 *outputType = API_OUTPUT_TELEPHONY_TX;
1286 } else {
1287 *outputType = API_OUTPUT_LEGACY;
1288 }
1289
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001290 ALOGV("%s returns output %d selectedDeviceId %d", __func__, *output, *selectedDeviceId);
1291
1292 return NO_ERROR;
1293}
1294
1295status_t AudioPolicyManager::getOutputForAttr(const audio_attributes_t *attr,
1296 audio_io_handle_t *output,
1297 audio_session_t session,
1298 audio_stream_type_t *stream,
Svet Ganov3e5f14f2021-05-13 22:51:08 +00001299 const AttributionSourceState& attributionSource,
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001300 const audio_config_t *config,
1301 audio_output_flags_t *flags,
1302 audio_port_handle_t *selectedDeviceId,
Kevin Rocard153f92d2018-12-18 18:33:28 -08001303 audio_port_handle_t *portId,
Eric Laurent8a1095a2019-11-08 14:44:16 -08001304 std::vector<audio_io_handle_t> *secondaryOutputs,
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001305 output_type_t *outputType,
1306 bool *isSpatialized)
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001307{
1308 // The supplied portId must be AUDIO_PORT_HANDLE_NONE
1309 if (*portId != AUDIO_PORT_HANDLE_NONE) {
1310 return INVALID_OPERATION;
1311 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001312 const uid_t uid = VALUE_OR_RETURN_STATUS(
Svet Ganov3e5f14f2021-05-13 22:51:08 +00001313 aidl2legacy_int32_t_uid_t(attributionSource.uid));
Francois Gaffie716e1432019-01-14 16:58:59 +01001314 const audio_port_handle_t requestedPortId = *selectedDeviceId;
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001315 audio_attributes_t resultAttr;
François Gaffief579db52018-11-13 11:25:16 +01001316 bool isRequestedDeviceForExclusiveUse = false;
Eric Laurentc529cf62020-04-17 18:19:10 -07001317 std::vector<sp<AudioPolicyMix>> secondaryMixes;
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01001318 const sp<DeviceDescriptor> requestedDevice =
1319 mAvailableOutputDevices.getDeviceFromId(requestedPortId);
1320
1321 // Prevent from storing invalid requested device id in clients
1322 const audio_port_handle_t sanitizedRequestedPortId =
1323 requestedDevice != nullptr ? requestedPortId : AUDIO_PORT_HANDLE_NONE;
1324 *selectedDeviceId = sanitizedRequestedPortId;
1325
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001326 status_t status = getOutputForAttrInt(&resultAttr, output, session, attr, stream, uid,
Kevin Rocard153f92d2018-12-18 18:33:28 -08001327 config, flags, selectedDeviceId, &isRequestedDeviceForExclusiveUse,
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001328 secondaryOutputs != nullptr ? &secondaryMixes : nullptr, outputType, isSpatialized);
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001329 if (status != NO_ERROR) {
1330 return status;
1331 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08001332 std::vector<wp<SwAudioOutputDescriptor>> weakSecondaryOutputDescs;
Eric Laurentc529cf62020-04-17 18:19:10 -07001333 if (secondaryOutputs != nullptr) {
1334 for (auto &secondaryMix : secondaryMixes) {
1335 sp<SwAudioOutputDescriptor> outputDesc = secondaryMix->getOutput();
1336 if (outputDesc != nullptr &&
1337 outputDesc->mIoHandle != AUDIO_IO_HANDLE_NONE) {
1338 secondaryOutputs->push_back(outputDesc->mIoHandle);
1339 weakSecondaryOutputDescs.push_back(outputDesc);
1340 }
1341 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08001342 }
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001343
Eric Laurent8fc147b2018-07-22 19:13:55 -07001344 audio_config_base_t clientConfig = {.sample_rate = config->sample_rate,
Nick Desaulniersa30e3202019-10-18 13:38:23 -07001345 .channel_mask = config->channel_mask,
Eric Laurent8fc147b2018-07-22 19:13:55 -07001346 .format = config->format,
Nick Desaulniersa30e3202019-10-18 13:38:23 -07001347 };
jiabin4ef93452019-09-10 14:29:54 -07001348 *portId = PolicyAudioPort::getNextUniqueId();
Eric Laurent8f42ea12018-08-08 09:08:25 -07001349
Eric Laurentc209fe42020-06-05 18:11:23 -07001350 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(*output);
Eric Laurent8fc147b2018-07-22 19:13:55 -07001351 sp<TrackClientDescriptor> clientDesc =
Hongwei Wangbb93dfb2018-10-23 13:54:22 -07001352 new TrackClientDescriptor(*portId, uid, session, resultAttr, clientConfig,
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01001353 sanitizedRequestedPortId, *stream,
François Gaffiec005e562018-11-06 15:04:49 +01001354 mEngine->getProductStrategyForAttributes(resultAttr),
François Gaffieaaac0fd2018-11-22 17:56:39 +01001355 toVolumeSource(resultAttr),
Kevin Rocard153f92d2018-12-18 18:33:28 -08001356 *flags, isRequestedDeviceForExclusiveUse,
Eric Laurentc209fe42020-06-05 18:11:23 -07001357 std::move(weakSecondaryOutputDescs),
1358 outputDesc->mPolicyMix);
Andy Hung39efb7a2018-09-26 15:39:28 -07001359 outputDesc->addClient(clientDesc);
Eric Laurent8fc147b2018-07-22 19:13:55 -07001360
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01001361 ALOGV("%s() returns output %d requestedPortId %d selectedDeviceId %d for port ID %d", __func__,
1362 *output, requestedPortId, *selectedDeviceId, *portId);
Eric Laurent2ac76942017-06-22 17:17:09 -07001363
Eric Laurente83b55d2014-11-14 10:06:21 -08001364 return NO_ERROR;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001365}
1366
Eric Laurentc529cf62020-04-17 18:19:10 -07001367status_t AudioPolicyManager::openDirectOutput(audio_stream_type_t stream,
1368 audio_session_t session,
1369 const audio_config_t *config,
1370 audio_output_flags_t flags,
1371 const DeviceVector &devices,
1372 audio_io_handle_t *output) {
1373
1374 *output = AUDIO_IO_HANDLE_NONE;
1375
1376 // skip direct output selection if the request can obviously be attached to a mixed output
1377 // and not explicitly requested
1378 if (((flags & AUDIO_OUTPUT_FLAG_DIRECT) == 0) &&
1379 audio_is_linear_pcm(config->format) && config->sample_rate <= SAMPLE_RATE_HZ_MAX &&
1380 audio_channel_count_from_out_mask(config->channel_mask) <= 2) {
1381 return NAME_NOT_FOUND;
1382 }
1383
1384 // Do not allow offloading if one non offloadable effect is enabled or MasterMono is enabled.
1385 // This prevents creating an offloaded track and tearing it down immediately after start
1386 // when audioflinger detects there is an active non offloadable effect.
1387 // FIXME: We should check the audio session here but we do not have it in this context.
1388 // This may prevent offloading in rare situations where effects are left active by apps
1389 // in the background.
1390 sp<IOProfile> profile;
1391 if (((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) ||
1392 !(mEffects.isNonOffloadableEffectEnabled() || mMasterMono)) {
1393 profile = getProfileForOutput(
1394 devices, config->sample_rate, config->format, config->channel_mask,
1395 flags, true /* directOnly */);
1396 }
1397
1398 if (profile == nullptr) {
1399 return NAME_NOT_FOUND;
1400 }
1401
1402 // exclusive outputs for MMAP and Offload are enforced by different session ids.
1403 for (size_t i = 0; i < mOutputs.size(); i++) {
1404 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
1405 if (!desc->isDuplicated() && (profile == desc->mProfile)) {
1406 // reuse direct output if currently open by the same client
1407 // and configured with same parameters
1408 if ((config->sample_rate == desc->getSamplingRate()) &&
1409 (config->format == desc->getFormat()) &&
1410 (config->channel_mask == desc->getChannelMask()) &&
1411 (session == desc->mDirectClientSession)) {
1412 desc->mDirectOpenCount++;
Eric Laurentfecbceb2021-02-09 14:46:43 +01001413 ALOGV("%s reusing direct output %d for session %d", __func__,
Eric Laurentc529cf62020-04-17 18:19:10 -07001414 mOutputs.keyAt(i), session);
1415 *output = mOutputs.keyAt(i);
1416 return NO_ERROR;
1417 }
1418 }
1419 }
1420
1421 if (!profile->canOpenNewIo()) {
1422 return NAME_NOT_FOUND;
1423 }
1424
1425 sp<SwAudioOutputDescriptor> outputDesc =
1426 new SwAudioOutputDescriptor(profile, mpClientInterface);
1427
Michael Chan6fb34492020-12-08 15:44:49 +11001428 // An MSD patch may be using the only output stream that can service this request. Release
1429 // all MSD patches to prioritize this request over any active output on MSD.
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001430 releaseMsdOutputPatches(devices);
Eric Laurentc529cf62020-04-17 18:19:10 -07001431
Eric Laurentf1f22e72021-07-13 14:04:14 +02001432 status_t status =
1433 outputDesc->open(config, nullptr /* mixerConfig */, devices, stream, flags, output);
Eric Laurentc529cf62020-04-17 18:19:10 -07001434
1435 // only accept an output with the requested parameters
1436 if (status != NO_ERROR ||
1437 (config->sample_rate != 0 && config->sample_rate != outputDesc->getSamplingRate()) ||
1438 (config->format != AUDIO_FORMAT_DEFAULT && config->format != outputDesc->getFormat()) ||
1439 (config->channel_mask != 0 && config->channel_mask != outputDesc->getChannelMask())) {
1440 ALOGV("%s failed opening direct output: output %d sample rate %d %d,"
1441 "format %d %d, channel mask %04x %04x", __func__, *output, config->sample_rate,
1442 outputDesc->getSamplingRate(), config->format, outputDesc->getFormat(),
1443 config->channel_mask, outputDesc->getChannelMask());
1444 if (*output != AUDIO_IO_HANDLE_NONE) {
1445 outputDesc->close();
1446 }
1447 // fall back to mixer output if possible when the direct output could not be open
1448 if (audio_is_linear_pcm(config->format) &&
1449 config->sample_rate <= SAMPLE_RATE_HZ_MAX) {
1450 return NAME_NOT_FOUND;
1451 }
1452 *output = AUDIO_IO_HANDLE_NONE;
1453 return BAD_VALUE;
1454 }
1455 outputDesc->mDirectOpenCount = 1;
1456 outputDesc->mDirectClientSession = session;
1457
1458 addOutput(*output, outputDesc);
1459 mPreviousOutputs = mOutputs;
1460 ALOGV("%s returns new direct output %d", __func__, *output);
1461 mpClientInterface->onAudioPortListUpdate();
1462 return NO_ERROR;
1463}
1464
François Gaffie11d30102018-11-02 16:09:09 +01001465audio_io_handle_t AudioPolicyManager::getOutputForDevices(
1466 const DeviceVector &devices,
Kevin Rocard169753c2017-03-06 14:18:23 -08001467 audio_session_t session,
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001468 const audio_attributes_t *attr,
Eric Laurentfe231122017-11-17 17:48:06 -08001469 const audio_config_t *config,
jiabine375d412019-02-26 12:54:53 -08001470 audio_output_flags_t *flags,
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001471 bool *isSpatialized,
jiabine375d412019-02-26 12:54:53 -08001472 bool forceMutingHaptic)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001473{
Andy Hungc88b0642018-04-27 15:42:35 -07001474 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -07001475
jiabine375d412019-02-26 12:54:53 -08001476 // Discard haptic channel mask when forcing muting haptic channels.
1477 audio_channel_mask_t channelMask = forceMutingHaptic
Mikhail Naganov55773032020-10-01 15:08:13 -07001478 ? static_cast<audio_channel_mask_t>(config->channel_mask & ~AUDIO_CHANNEL_HAPTIC_ALL)
1479 : config->channel_mask;
jiabine375d412019-02-26 12:54:53 -08001480
Eric Laurente552edb2014-03-10 17:42:56 -07001481 // open a direct output if required by specified parameters
1482 //force direct flag if offload flag is set: offloading implies a direct output stream
1483 // and all common behaviors are driven by checking only the direct flag
1484 // this should normally be set appropriately in the policy configuration file
Nadav Bar766fb022018-01-07 12:18:03 +02001485 if ((*flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
1486 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_DIRECT);
Eric Laurente552edb2014-03-10 17:42:56 -07001487 }
Nadav Bar766fb022018-01-07 12:18:03 +02001488 if ((*flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) {
1489 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_DIRECT);
Eric Laurent93c3d412014-08-01 14:48:35 -07001490 }
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001491
1492 audio_stream_type_t stream = mEngine->getStreamTypeForAttributes(*attr);
1493
Eric Laurente83b55d2014-11-14 10:06:21 -08001494 // only allow deep buffering for music stream type
1495 if (stream != AUDIO_STREAM_MUSIC) {
Nadav Bar766fb022018-01-07 12:18:03 +02001496 *flags = (audio_output_flags_t)(*flags &~AUDIO_OUTPUT_FLAG_DEEP_BUFFER);
Ravi Kumar Alamanda439e4ed2015-04-03 12:13:21 -07001497 } else if (/* stream == AUDIO_STREAM_MUSIC && */
Nadav Bar766fb022018-01-07 12:18:03 +02001498 *flags == AUDIO_OUTPUT_FLAG_NONE &&
Ravi Kumar Alamanda439e4ed2015-04-03 12:13:21 -07001499 property_get_bool("audio.deep_buffer.media", false /* default_value */)) {
1500 // use DEEP_BUFFER as default output for music stream type
Nadav Bar766fb022018-01-07 12:18:03 +02001501 *flags = (audio_output_flags_t)AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
Eric Laurente83b55d2014-11-14 10:06:21 -08001502 }
Ravi Kumar Alamandac36a8892015-04-24 16:35:49 -07001503 if (stream == AUDIO_STREAM_TTS) {
Nadav Bar766fb022018-01-07 12:18:03 +02001504 *flags = AUDIO_OUTPUT_FLAG_TTS;
Haynes Mathew George84c621e2017-04-25 11:41:50 -07001505 } else if (stream == AUDIO_STREAM_VOICE_CALL &&
Nadav Bar20919492018-11-20 10:20:51 +02001506 audio_is_linear_pcm(config->format) &&
1507 (*flags & AUDIO_OUTPUT_FLAG_INCALL_MUSIC) == 0) {
Nadav Bar766fb022018-01-07 12:18:03 +02001508 *flags = (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_VOIP_RX |
Haynes Mathew George84c621e2017-04-25 11:41:50 -07001509 AUDIO_OUTPUT_FLAG_DIRECT);
1510 ALOGV("Set VoIP and Direct output flags for PCM format");
Ravi Kumar Alamandac36a8892015-04-24 16:35:49 -07001511 }
Eric Laurente552edb2014-03-10 17:42:56 -07001512
Carter Hsua3abb402021-10-26 11:11:20 +08001513 // Attach the Ultrasound flag for the AUDIO_CONTENT_TYPE_ULTRASOUND
1514 if (attr->content_type == AUDIO_CONTENT_TYPE_ULTRASOUND) {
1515 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_ULTRASOUND);
1516 }
1517
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001518 *isSpatialized = false;
Eric Laurentfa0f6742021-08-17 18:39:44 +02001519 if (mSpatializerOutput != nullptr
Andy Hung9dd1a5b2022-05-10 15:39:39 -07001520 && canBeSpatializedInt(attr, config, devices.toTypeAddrVector())) {
Eric Laurentb0a7bc92022-04-05 15:06:08 +02001521 *isSpatialized = true;
Eric Laurentfa0f6742021-08-17 18:39:44 +02001522 return mSpatializerOutput->mIoHandle;
Eric Laurentcad6c0d2021-07-13 15:12:39 +02001523 }
1524
Eric Laurentc529cf62020-04-17 18:19:10 -07001525 audio_config_t directConfig = *config;
1526 directConfig.channel_mask = channelMask;
1527 status_t status = openDirectOutput(stream, session, &directConfig, *flags, devices, &output);
1528 if (status != NAME_NOT_FOUND) {
Eric Laurente552edb2014-03-10 17:42:56 -07001529 return output;
1530 }
1531
Eric Laurent14cbfca2016-03-17 09:42:16 -07001532 // A request for HW A/V sync cannot fallback to a mixed output because time
1533 // stamps are embedded in audio data
Phil Burk2d059932018-02-15 15:55:11 -08001534 if ((*flags & (AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_MMAP_NOIRQ)) != 0) {
Eric Laurent14cbfca2016-03-17 09:42:16 -07001535 return AUDIO_IO_HANDLE_NONE;
1536 }
1537
Eric Laurente552edb2014-03-10 17:42:56 -07001538 // ignoring channel mask due to downmix capability in mixer
1539
1540 // open a non direct output
1541
1542 // for non direct outputs, only PCM is supported
Eric Laurentfe231122017-11-17 17:48:06 -08001543 if (audio_is_linear_pcm(config->format)) {
Eric Laurente552edb2014-03-10 17:42:56 -07001544 // get which output is suitable for the specified stream. The actual
1545 // routing change will happen when startOutput() will be called
François Gaffie11d30102018-11-02 16:09:09 +01001546 SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
Eric Laurente552edb2014-03-10 17:42:56 -07001547
Eric Laurent8838a382014-09-08 16:44:28 -07001548 // at this stage we should ignore the DIRECT flag as no direct output could be found earlier
Nadav Bar766fb022018-01-07 12:18:03 +02001549 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_DIRECT);
jiabinebb6af42020-06-09 17:31:17 -07001550 output = selectOutput(
1551 outputs, *flags, config->format, channelMask, config->sample_rate, session);
Eric Laurente552edb2014-03-10 17:42:56 -07001552 }
François Gaffie11d30102018-11-02 16:09:09 +01001553 ALOGW_IF((output == 0), "getOutputForDevices() could not find output for stream %d, "
Glenn Kasten49f36ba2017-12-06 13:02:02 -08001554 "sampling rate %d, format %#x, channels %#x, flags %#x",
jiabine375d412019-02-26 12:54:53 -08001555 stream, config->sample_rate, config->format, channelMask, *flags);
Eric Laurente552edb2014-03-10 17:42:56 -07001556
Eric Laurente552edb2014-03-10 17:42:56 -07001557 return output;
1558}
1559
Mikhail Naganovf02f3672018-11-09 12:44:16 -08001560sp<DeviceDescriptor> AudioPolicyManager::getMsdAudioInDevice() const {
François Gaffie11d30102018-11-02 16:09:09 +01001561 auto msdInDevices = mHwModules.getAvailableDevicesFromModuleName(AUDIO_HARDWARE_MODULE_ID_MSD,
1562 mAvailableInputDevices);
1563 return msdInDevices.isEmpty()? nullptr : msdInDevices.itemAt(0);
1564}
1565
1566DeviceVector AudioPolicyManager::getMsdAudioOutDevices() const {
1567 return mHwModules.getAvailableDevicesFromModuleName(AUDIO_HARDWARE_MODULE_ID_MSD,
1568 mAvailableOutputDevices);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001569}
1570
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001571const AudioPatchCollection AudioPolicyManager::getMsdOutputPatches() const {
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001572 AudioPatchCollection msdPatches;
Mikhail Naganov86112352018-10-04 09:02:49 -07001573 sp<HwModule> msdModule = mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD);
1574 if (msdModule != 0) {
1575 for (size_t i = 0; i < mAudioPatches.size(); ++i) {
1576 sp<AudioPatch> patch = mAudioPatches.valueAt(i);
1577 for (size_t j = 0; j < patch->mPatch.num_sources; ++j) {
1578 const struct audio_port_config *source = &patch->mPatch.sources[j];
1579 if (source->type == AUDIO_PORT_TYPE_DEVICE &&
1580 source->ext.device.hw_module == msdModule->getHandle()) {
François Gaffieafd4cea2019-11-18 15:50:22 +01001581 msdPatches.addAudioPatch(patch->getHandle(), patch);
Mikhail Naganov86112352018-10-04 09:02:49 -07001582 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001583 }
1584 }
1585 }
1586 return msdPatches;
1587}
1588
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02001589bool AudioPolicyManager::isMsdPatch(const audio_patch_handle_t &handle) const {
1590 ssize_t index = mAudioPatches.indexOfKey(handle);
1591 if (index < 0) {
1592 return false;
1593 }
1594 const sp<AudioPatch> patch = mAudioPatches.valueAt(index);
1595 sp<HwModule> msdModule = mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD);
1596 if (msdModule == nullptr) {
1597 return false;
1598 }
1599 const struct audio_port_config *sink = &patch->mPatch.sinks[0];
1600 if (getMsdAudioOutDevices().contains(mAvailableOutputDevices.getDeviceFromId(sink->id))) {
1601 return true;
1602 }
1603 index = getMsdOutputPatches().indexOfKey(handle);
1604 if (index < 0) {
1605 return false;
1606 }
1607 return true;
1608}
1609
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001610status_t AudioPolicyManager::getMsdProfiles(bool hwAvSync,
1611 const InputProfileCollection &inputProfiles,
1612 const OutputProfileCollection &outputProfiles,
1613 const sp<DeviceDescriptor> &sourceDevice,
1614 const sp<DeviceDescriptor> &sinkDevice,
1615 AudioProfileVector& sourceProfiles,
1616 AudioProfileVector& sinkProfiles) const {
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001617 if (inputProfiles.isEmpty()) {
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001618 ALOGE("%s() no input profiles for source module", __func__);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001619 return NO_INIT;
1620 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001621 if (outputProfiles.isEmpty()) {
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001622 ALOGE("%s() no output profiles for sink module", __func__);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001623 return NO_INIT;
1624 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001625 for (const auto &inProfile : inputProfiles) {
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001626 if (hwAvSync == ((inProfile->getFlags() & AUDIO_INPUT_FLAG_HW_AV_SYNC) != 0) &&
1627 inProfile->supportsDevice(sourceDevice)) {
1628 appendAudioProfiles(sourceProfiles, inProfile->getAudioProfiles());
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001629 }
1630 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001631 for (const auto &outProfile : outputProfiles) {
Michael Chan6fb34492020-12-08 15:44:49 +11001632 if (hwAvSync == ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) &&
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001633 outProfile->supportsDevice(sinkDevice)) {
1634 appendAudioProfiles(sinkProfiles, outProfile->getAudioProfiles());
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001635 }
1636 }
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001637 return NO_ERROR;
1638}
1639
1640status_t AudioPolicyManager::getBestMsdConfig(bool hwAvSync,
1641 const AudioProfileVector &sourceProfiles, const AudioProfileVector &sinkProfiles,
1642 audio_port_config *sourceConfig, audio_port_config *sinkConfig) const
1643{
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001644 struct audio_config_base bestSinkConfig;
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001645 status_t result = findBestMatchingOutputConfig(sourceProfiles, sinkProfiles,
1646 msdCompressedFormatsOrder, msdSurroundChannelMasksOrder,
1647 true /*preferHigherSamplingRates*/, bestSinkConfig);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001648 if (result != NO_ERROR) {
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001649 ALOGD("%s() no matching config found for sink, hwAvSync: %d",
1650 __func__, hwAvSync);
Greg Kaiser83289652018-07-30 06:13:57 -07001651 return result;
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001652 }
1653 sinkConfig->sample_rate = bestSinkConfig.sample_rate;
1654 sinkConfig->channel_mask = bestSinkConfig.channel_mask;
1655 sinkConfig->format = bestSinkConfig.format;
1656 // For encoded streams force direct flag to prevent downstream mixing.
1657 sinkConfig->flags.output = static_cast<audio_output_flags_t>(
1658 sinkConfig->flags.output | AUDIO_OUTPUT_FLAG_DIRECT);
Dean Wheatley5c9f0832019-11-21 13:39:31 +11001659 if (audio_is_iec61937_compatible(sinkConfig->format)) {
1660 // For formats compatible with IEC61937 encapsulation, assume that
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001661 // the input is IEC61937 framed (for proportional buffer sizing).
Dean Wheatley5c9f0832019-11-21 13:39:31 +11001662 // Add the AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO flag so downstream HAL can distinguish between
1663 // raw and IEC61937 framed streams.
1664 sinkConfig->flags.output = static_cast<audio_output_flags_t>(
1665 sinkConfig->flags.output | AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO);
1666 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001667 sourceConfig->sample_rate = bestSinkConfig.sample_rate;
1668 // Specify exact channel mask to prevent guessing by bit count in PatchPanel.
1669 sourceConfig->channel_mask = audio_channel_mask_out_to_in(bestSinkConfig.channel_mask);
1670 sourceConfig->format = bestSinkConfig.format;
1671 // Copy input stream directly without any processing (e.g. resampling).
1672 sourceConfig->flags.input = static_cast<audio_input_flags_t>(
1673 sourceConfig->flags.input | AUDIO_INPUT_FLAG_DIRECT);
1674 if (hwAvSync) {
1675 sinkConfig->flags.output = static_cast<audio_output_flags_t>(
1676 sinkConfig->flags.output | AUDIO_OUTPUT_FLAG_HW_AV_SYNC);
1677 sourceConfig->flags.input = static_cast<audio_input_flags_t>(
1678 sourceConfig->flags.input | AUDIO_INPUT_FLAG_HW_AV_SYNC);
1679 }
1680 const unsigned int config_mask = AUDIO_PORT_CONFIG_SAMPLE_RATE |
1681 AUDIO_PORT_CONFIG_CHANNEL_MASK | AUDIO_PORT_CONFIG_FORMAT | AUDIO_PORT_CONFIG_FLAGS;
1682 sinkConfig->config_mask |= config_mask;
1683 sourceConfig->config_mask |= config_mask;
1684 return NO_ERROR;
1685}
1686
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001687PatchBuilder AudioPolicyManager::buildMsdPatch(bool msdIsSource,
1688 const sp<DeviceDescriptor> &device) const
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001689{
1690 PatchBuilder patchBuilder;
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001691 sp<HwModule> msdModule = mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD);
1692 ALOG_ASSERT(msdModule != nullptr, "MSD module not available");
1693 sp<HwModule> deviceModule = mHwModules.getModuleForDevice(device, AUDIO_FORMAT_DEFAULT);
1694 if (deviceModule == nullptr) {
1695 ALOGE("%s() unable to get module for %s", __func__, device->toString().c_str());
1696 return patchBuilder;
1697 }
1698 const InputProfileCollection inputProfiles = msdIsSource ?
1699 msdModule->getInputProfiles() : deviceModule->getInputProfiles();
1700 const OutputProfileCollection outputProfiles = msdIsSource ?
1701 deviceModule->getOutputProfiles() : msdModule->getOutputProfiles();
1702
1703 const sp<DeviceDescriptor> sourceDevice = msdIsSource ? getMsdAudioInDevice() : device;
1704 const sp<DeviceDescriptor> sinkDevice = msdIsSource ?
1705 device : getMsdAudioOutDevices().itemAt(0);
1706 patchBuilder.addSource(sourceDevice).addSink(sinkDevice);
1707
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001708 audio_port_config sourceConfig = patchBuilder.patch()->sources[0];
1709 audio_port_config sinkConfig = patchBuilder.patch()->sinks[0];
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001710 AudioProfileVector sourceProfiles;
1711 AudioProfileVector sinkProfiles;
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001712 // TODO: Figure out whether MSD module has HW_AV_SYNC flag set in the AP config file.
1713 // For now, we just forcefully try with HwAvSync first.
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001714 for (auto hwAvSync : { true, false }) {
1715 if (getMsdProfiles(hwAvSync, inputProfiles, outputProfiles, sourceDevice, sinkDevice,
1716 sourceProfiles, sinkProfiles) != NO_ERROR) {
1717 continue;
1718 }
1719 if (getBestMsdConfig(hwAvSync, sourceProfiles, sinkProfiles, &sourceConfig,
1720 &sinkConfig) == NO_ERROR) {
1721 // Found a matching config. Re-create PatchBuilder with this config.
1722 return (PatchBuilder()).addSource(sourceConfig).addSink(sinkConfig);
1723 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001724 }
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001725 ALOGV("%s() no matching config found. Fall through to default PCM patch"
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001726 " supporting PCM format conversion.", __func__);
1727 return patchBuilder;
1728}
1729
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001730status_t AudioPolicyManager::setMsdOutputPatches(const DeviceVector *outputDevices) {
Michael Chan6fb34492020-12-08 15:44:49 +11001731 DeviceVector devices;
1732 if (outputDevices != nullptr && outputDevices->size() > 0) {
1733 devices.add(*outputDevices);
1734 } else {
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001735 // Use media strategy for unspecified output device. This should only
1736 // occur on checkForDeviceAndOutputChanges(). Device connection events may
1737 // therefore invalidate explicit routing requests.
Michael Chan6fb34492020-12-08 15:44:49 +11001738 devices = mEngine->getOutputDevicesForAttributes(
François Gaffiec005e562018-11-06 15:04:49 +01001739 attributes_initializer(AUDIO_USAGE_MEDIA), nullptr, false /*fromCache*/);
Michael Chan6fb34492020-12-08 15:44:49 +11001740 LOG_ALWAYS_FATAL_IF(devices.isEmpty(), "no output device to set MSD patch");
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001741 }
Michael Chan6fb34492020-12-08 15:44:49 +11001742 std::vector<PatchBuilder> patchesToCreate;
1743 for (auto i = 0u; i < devices.size(); ++i) {
1744 ALOGV("%s() for device %s", __func__, devices[i]->toString().c_str());
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001745 patchesToCreate.push_back(buildMsdPatch(true /*msdIsSource*/, devices[i]));
Michael Chan6fb34492020-12-08 15:44:49 +11001746 }
1747 // Retain only the MSD patches associated with outputDevices request.
1748 // Tear down the others, and create new ones as needed.
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001749 AudioPatchCollection patchesToRemove = getMsdOutputPatches();
Michael Chan6fb34492020-12-08 15:44:49 +11001750 for (auto it = patchesToCreate.begin(); it != patchesToCreate.end(); ) {
1751 auto retainedPatch = false;
1752 for (auto i = 0u; i < patchesToRemove.size(); ++i) {
1753 if (audio_patches_are_equal(it->patch(), &patchesToRemove[i]->mPatch)) {
1754 patchesToRemove.removeItemsAt(i);
1755 retainedPatch = true;
1756 break;
1757 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001758 }
Michael Chan6fb34492020-12-08 15:44:49 +11001759 if (retainedPatch) {
1760 it = patchesToCreate.erase(it);
1761 continue;
1762 }
1763 ++it;
1764 }
1765 if (patchesToCreate.size() == 0 && patchesToRemove.size() == 0) {
1766 return NO_ERROR;
1767 }
1768 for (auto i = 0u; i < patchesToRemove.size(); ++i) {
1769 auto &currentPatch = patchesToRemove.valueAt(i);
François Gaffieafd4cea2019-11-18 15:50:22 +01001770 releaseAudioPatch(currentPatch->getHandle(), mUidCached);
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001771 }
Michael Chan6fb34492020-12-08 15:44:49 +11001772 status_t status = NO_ERROR;
1773 for (const auto &p : patchesToCreate) {
1774 auto currStatus = installPatch(__func__, -1 /*index*/, nullptr /*patchHandle*/,
1775 p.patch(), 0 /*delayMs*/, mUidCached, nullptr /*patchDescPtr*/);
1776 char message[256];
1777 snprintf(message, sizeof(message), "%s() %s: creating MSD patch from device:IN_BUS to "
1778 "device:%#x (format:%#x channels:%#x samplerate:%d)", __func__,
1779 currStatus == NO_ERROR ? "Success" : "Error",
1780 p.patch()->sinks[0].ext.device.type, p.patch()->sources[0].format,
1781 p.patch()->sources[0].channel_mask, p.patch()->sources[0].sample_rate);
1782 if (currStatus == NO_ERROR) {
1783 ALOGD("%s", message);
1784 } else {
1785 ALOGE("%s", message);
1786 if (status == NO_ERROR) {
1787 status = currStatus;
1788 }
1789 }
1790 }
Mikhail Naganov15be9d22017-11-08 14:18:13 +11001791 return status;
1792}
1793
Dean Wheatley8bee85a2021-02-10 16:02:23 +11001794void AudioPolicyManager::releaseMsdOutputPatches(const DeviceVector& devices) {
1795 AudioPatchCollection msdPatches = getMsdOutputPatches();
Michael Chan6fb34492020-12-08 15:44:49 +11001796 for (size_t i = 0; i < msdPatches.size(); i++) {
1797 const auto& patch = msdPatches[i];
1798 for (size_t j = 0; j < patch->mPatch.num_sinks; ++j) {
1799 const struct audio_port_config *sink = &patch->mPatch.sinks[j];
1800 if (sink->type == AUDIO_PORT_TYPE_DEVICE && devices.getDevice(sink->ext.device.type,
1801 String8(sink->ext.device.address), AUDIO_FORMAT_DEFAULT) != nullptr) {
1802 releaseAudioPatch(patch->getHandle(), mUidCached);
1803 break;
1804 }
1805 }
1806 }
1807}
1808
Dorin Drimus94d94412022-02-02 09:05:02 +01001809bool AudioPolicyManager::msdHasPatchesToAllDevices(const AudioDeviceTypeAddrVector& devices) {
1810 DeviceVector devicesToCheck = mOutputDevicesAll.getDevicesFromDeviceTypeAddrVec(devices);
1811 AudioPatchCollection msdPatches = getMsdOutputPatches();
1812 for (size_t i = 0; i < msdPatches.size(); i++) {
1813 const auto& patch = msdPatches[i];
1814 for (size_t j = 0; j < patch->mPatch.num_sinks; ++j) {
1815 const struct audio_port_config *sink = &patch->mPatch.sinks[j];
1816 if (sink->type == AUDIO_PORT_TYPE_DEVICE) {
1817 const auto& foundDevice = devicesToCheck.getDevice(
1818 sink->ext.device.type, String8(sink->ext.device.address), AUDIO_FORMAT_DEFAULT);
1819 if (foundDevice != nullptr) {
1820 devicesToCheck.remove(foundDevice);
1821 if (devicesToCheck.isEmpty()) {
1822 return true;
1823 }
1824 }
1825 }
1826 }
1827 }
1828 return false;
1829}
1830
Eric Laurente0720872014-03-11 09:30:41 -07001831audio_io_handle_t AudioPolicyManager::selectOutput(const SortedVector<audio_io_handle_t>& outputs,
jiabinebb6af42020-06-09 17:31:17 -07001832 audio_output_flags_t flags,
1833 audio_format_t format,
1834 audio_channel_mask_t channelMask,
1835 uint32_t samplingRate,
1836 audio_session_t sessionId)
Eric Laurente552edb2014-03-10 17:42:56 -07001837{
Eric Laurent16c66dd2019-05-01 17:54:10 -07001838 LOG_ALWAYS_FATAL_IF(!(format == AUDIO_FORMAT_INVALID || audio_is_linear_pcm(format)),
1839 "%s called with format %#x", __func__, format);
1840
jiabinebb6af42020-06-09 17:31:17 -07001841 // Return the output that haptic-generating attached to when 1) session id is specified,
1842 // 2) haptic-generating effect exists for given session id and 3) the output that
1843 // haptic-generating effect attached to is in given outputs.
1844 if (sessionId != AUDIO_SESSION_NONE) {
1845 audio_io_handle_t hapticGeneratingOutput = mEffects.getIoForSession(
1846 sessionId, FX_IID_HAPTICGENERATOR);
1847 if (outputs.indexOf(hapticGeneratingOutput) >= 0) {
1848 return hapticGeneratingOutput;
1849 }
1850 }
1851
Eric Laurent16c66dd2019-05-01 17:54:10 -07001852 // Flags disqualifying an output: the match must happen before calling selectOutput()
1853 static const audio_output_flags_t kExcludedFlags = (audio_output_flags_t)
1854 (AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_MMAP_NOIRQ | AUDIO_OUTPUT_FLAG_DIRECT);
1855
1856 // Flags expressing a functional request: must be honored in priority over
1857 // other criteria
1858 static const audio_output_flags_t kFunctionalFlags = (audio_output_flags_t)
1859 (AUDIO_OUTPUT_FLAG_VOIP_RX | AUDIO_OUTPUT_FLAG_INCALL_MUSIC |
Eric Laurente28c66d2022-01-21 13:40:41 +01001860 AUDIO_OUTPUT_FLAG_TTS | AUDIO_OUTPUT_FLAG_DIRECT_PCM | AUDIO_OUTPUT_FLAG_ULTRASOUND |
1861 AUDIO_OUTPUT_FLAG_SPATIALIZER);
Eric Laurent16c66dd2019-05-01 17:54:10 -07001862 // Flags expressing a performance request: have lower priority than serving
1863 // requested sampling rate or channel mask
1864 static const audio_output_flags_t kPerformanceFlags = (audio_output_flags_t)
1865 (AUDIO_OUTPUT_FLAG_FAST | AUDIO_OUTPUT_FLAG_DEEP_BUFFER |
1866 AUDIO_OUTPUT_FLAG_RAW | AUDIO_OUTPUT_FLAG_SYNC);
1867
1868 const audio_output_flags_t functionalFlags =
1869 (audio_output_flags_t)(flags & kFunctionalFlags);
1870 const audio_output_flags_t performanceFlags =
1871 (audio_output_flags_t)(flags & kPerformanceFlags);
1872
1873 audio_io_handle_t bestOutput = (outputs.size() == 0) ? AUDIO_IO_HANDLE_NONE : outputs[0];
1874
Eric Laurente552edb2014-03-10 17:42:56 -07001875 // select one output among several that provide a path to a particular device or set of
François Gaffie11d30102018-11-02 16:09:09 +01001876 // devices (the list was previously build by getOutputsForDevices()).
Eric Laurente552edb2014-03-10 17:42:56 -07001877 // The priority is as follows:
jiabin40573322018-11-08 12:08:02 -08001878 // 1: the output supporting haptic playback when requesting haptic playback
Eric Laurent16c66dd2019-05-01 17:54:10 -07001879 // 2: the output with the highest number of requested functional flags
Carter Hsu199f1892021-10-15 15:47:29 +08001880 // with tiebreak preferring the minimum number of extra functional flags
1881 // (see b/200293124, the incorrect selection of AUDIO_OUTPUT_FLAG_VOIP_RX).
Eric Laurent16c66dd2019-05-01 17:54:10 -07001882 // 3: the output supporting the exact channel mask
1883 // 4: the output with a higher channel count than requested
jiabind1785f72022-06-03 20:48:18 +00001884 // 5: the output with the highest sampling rate if the requested sample rate is
1885 // greater than default sampling rate
Eric Laurent16c66dd2019-05-01 17:54:10 -07001886 // 6: the output with the highest number of requested performance flags
1887 // 7: the output with the bit depth the closest to the requested one
1888 // 8: the primary output
1889 // 9: the first output in the list
Eric Laurente552edb2014-03-10 17:42:56 -07001890
Eric Laurent16c66dd2019-05-01 17:54:10 -07001891 // matching criteria values in priority order for best matching output so far
1892 std::vector<uint32_t> bestMatchCriteria(8, 0);
Eric Laurente552edb2014-03-10 17:42:56 -07001893
Eric Laurent16c66dd2019-05-01 17:54:10 -07001894 const uint32_t channelCount = audio_channel_count_from_out_mask(channelMask);
1895 const uint32_t hapticChannelCount = audio_channel_count_from_out_mask(
1896 channelMask & AUDIO_CHANNEL_HAPTIC_ALL);
Eric Laurente78b6762018-12-19 16:29:01 -08001897
Mikhail Naganovcf84e592017-12-07 11:25:11 -08001898 for (audio_io_handle_t output : outputs) {
1899 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
Eric Laurent16c66dd2019-05-01 17:54:10 -07001900 // matching criteria values in priority order for current output
1901 std::vector<uint32_t> currentMatchCriteria(8, 0);
jiabin40573322018-11-08 12:08:02 -08001902
Eric Laurent16c66dd2019-05-01 17:54:10 -07001903 if (outputDesc->isDuplicated()) {
1904 continue;
1905 }
1906 if ((kExcludedFlags & outputDesc->mFlags) != 0) {
1907 continue;
1908 }
Eric Laurent8838a382014-09-08 16:44:28 -07001909
Eric Laurent16c66dd2019-05-01 17:54:10 -07001910 // If haptic channel is specified, use the haptic output if present.
1911 // When using haptic output, same audio format and sample rate are required.
1912 const uint32_t outputHapticChannelCount = audio_channel_count_from_out_mask(
jiabin5740f082019-08-19 15:08:30 -07001913 outputDesc->getChannelMask() & AUDIO_CHANNEL_HAPTIC_ALL);
Eric Laurent16c66dd2019-05-01 17:54:10 -07001914 if ((hapticChannelCount == 0) != (outputHapticChannelCount == 0)) {
1915 continue;
1916 }
1917 if (outputHapticChannelCount >= hapticChannelCount
jiabin5740f082019-08-19 15:08:30 -07001918 && format == outputDesc->getFormat()
1919 && samplingRate == outputDesc->getSamplingRate()) {
Eric Laurent16c66dd2019-05-01 17:54:10 -07001920 currentMatchCriteria[0] = outputHapticChannelCount;
1921 }
1922
1923 // functional flags match
Carter Hsu199f1892021-10-15 15:47:29 +08001924 const int matchingFunctionalFlags =
1925 __builtin_popcount(outputDesc->mFlags & functionalFlags);
1926 const int totalFunctionalFlags =
1927 __builtin_popcount(outputDesc->mFlags & kFunctionalFlags);
1928 // Prefer matching functional flags, but subtract unnecessary functional flags.
1929 currentMatchCriteria[1] = 100 * (matchingFunctionalFlags + 1) - totalFunctionalFlags;
Eric Laurent16c66dd2019-05-01 17:54:10 -07001930
1931 // channel mask and channel count match
jiabin5740f082019-08-19 15:08:30 -07001932 uint32_t outputChannelCount = audio_channel_count_from_out_mask(
1933 outputDesc->getChannelMask());
Eric Laurent16c66dd2019-05-01 17:54:10 -07001934 if (channelMask != AUDIO_CHANNEL_NONE && channelCount > 2 &&
1935 channelCount <= outputChannelCount) {
1936 if ((audio_channel_mask_get_representation(channelMask) ==
jiabin5740f082019-08-19 15:08:30 -07001937 audio_channel_mask_get_representation(outputDesc->getChannelMask())) &&
1938 ((channelMask & outputDesc->getChannelMask()) == channelMask)) {
Eric Laurent16c66dd2019-05-01 17:54:10 -07001939 currentMatchCriteria[2] = outputChannelCount;
Eric Laurente552edb2014-03-10 17:42:56 -07001940 }
Eric Laurent16c66dd2019-05-01 17:54:10 -07001941 currentMatchCriteria[3] = outputChannelCount;
1942 }
1943
1944 // sampling rate match
jiabind1785f72022-06-03 20:48:18 +00001945 if (samplingRate > SAMPLE_RATE_HZ_DEFAULT) {
jiabin5740f082019-08-19 15:08:30 -07001946 currentMatchCriteria[4] = outputDesc->getSamplingRate();
Eric Laurent16c66dd2019-05-01 17:54:10 -07001947 }
1948
1949 // performance flags match
1950 currentMatchCriteria[5] = popcount(outputDesc->mFlags & performanceFlags);
1951
1952 // format match
1953 if (format != AUDIO_FORMAT_INVALID) {
1954 currentMatchCriteria[6] =
jiabin4ef93452019-09-10 14:29:54 -07001955 PolicyAudioPort::kFormatDistanceMax -
1956 PolicyAudioPort::formatDistance(format, outputDesc->getFormat());
Eric Laurent16c66dd2019-05-01 17:54:10 -07001957 }
1958
1959 // primary output match
1960 currentMatchCriteria[7] = outputDesc->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY;
1961
1962 // compare match criteria by priority then value
1963 if (std::lexicographical_compare(bestMatchCriteria.begin(), bestMatchCriteria.end(),
1964 currentMatchCriteria.begin(), currentMatchCriteria.end())) {
1965 bestMatchCriteria = currentMatchCriteria;
1966 bestOutput = output;
1967
1968 std::stringstream result;
1969 std::copy(bestMatchCriteria.begin(), bestMatchCriteria.end(),
1970 std::ostream_iterator<int>(result, " "));
1971 ALOGV("%s new bestOutput %d criteria %s",
1972 __func__, bestOutput, result.str().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -07001973 }
1974 }
1975
Eric Laurent16c66dd2019-05-01 17:54:10 -07001976 return bestOutput;
Eric Laurente552edb2014-03-10 17:42:56 -07001977}
1978
Eric Laurent8fc147b2018-07-22 19:13:55 -07001979status_t AudioPolicyManager::startOutput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07001980{
Eric Laurent8fc147b2018-07-22 19:13:55 -07001981 ALOGV("%s portId %d", __FUNCTION__, portId);
1982
1983 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputForClient(portId);
1984 if (outputDesc == 0) {
1985 ALOGW("startOutput() no output for client %d", portId);
Eric Laurente552edb2014-03-10 17:42:56 -07001986 return BAD_VALUE;
1987 }
Andy Hung39efb7a2018-09-26 15:39:28 -07001988 sp<TrackClientDescriptor> client = outputDesc->getClient(portId);
Eric Laurente552edb2014-03-10 17:42:56 -07001989
Eric Laurent8fc147b2018-07-22 19:13:55 -07001990 ALOGV("startOutput() output %d, stream %d, session %d",
Eric Laurent97ac8712018-07-27 18:59:02 -07001991 outputDesc->mIoHandle, client->stream(), client->session());
Eric Laurentc75307b2015-03-17 15:29:32 -07001992
Eric Laurent733ce942017-12-07 12:18:25 -08001993 status_t status = outputDesc->start();
1994 if (status != NO_ERROR) {
1995 return status;
Eric Laurent3974e3b2017-12-07 17:58:43 -08001996 }
1997
Eric Laurent97ac8712018-07-27 18:59:02 -07001998 uint32_t delayMs;
1999 status = startSource(outputDesc, client, &delayMs);
Eric Laurentc75307b2015-03-17 15:29:32 -07002000
2001 if (status != NO_ERROR) {
Eric Laurent733ce942017-12-07 12:18:25 -08002002 outputDesc->stop();
Eric Laurent8c7e6da2015-04-21 17:37:00 -07002003 return status;
Eric Laurentc75307b2015-03-17 15:29:32 -07002004 }
Jean-Michel Trivi32b7a102023-02-07 20:49:04 +00002005 if (client->hasPreferredDevice()) {
2006 // playback activity with preferred device impacts routing occurred, inform upper layers
2007 mpClientInterface->onRoutingUpdated();
2008 }
Eric Laurentc75307b2015-03-17 15:29:32 -07002009 if (delayMs != 0) {
2010 usleep(delayMs * 1000);
2011 }
2012
2013 return status;
2014}
2015
Eric Laurent96d1dda2022-03-14 17:14:19 +01002016bool AudioPolicyManager::isLeUnicastActive() const {
2017 if (isInCall()) {
2018 return true;
2019 }
2020 return isAnyDeviceTypeActive(getAudioDeviceOutLeAudioUnicastSet());
2021}
2022
2023bool AudioPolicyManager::isAnyDeviceTypeActive(const DeviceTypeSet& deviceTypes) const {
2024 if (mAvailableOutputDevices.getDevicesFromTypes(deviceTypes).isEmpty()) {
2025 return false;
2026 }
2027 bool active = mOutputs.isAnyDeviceTypeActive(deviceTypes);
2028 ALOGV("%s active %d", __func__, active);
2029 return active;
2030}
2031
Eric Laurent97ac8712018-07-27 18:59:02 -07002032status_t AudioPolicyManager::startSource(const sp<SwAudioOutputDescriptor>& outputDesc,
2033 const sp<TrackClientDescriptor>& client,
2034 uint32_t *delayMs)
Eric Laurentc75307b2015-03-17 15:29:32 -07002035{
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07002036 // cannot start playback of STREAM_TTS if any other output is being used
2037 uint32_t beaconMuteLatency = 0;
Eric Laurentc75307b2015-03-17 15:29:32 -07002038
2039 *delayMs = 0;
Eric Laurent97ac8712018-07-27 18:59:02 -07002040 audio_stream_type_t stream = client->stream();
François Gaffie1c878552018-11-22 16:53:21 +01002041 auto clientVolSrc = client->volumeSource();
François Gaffiec005e562018-11-06 15:04:49 +01002042 auto clientStrategy = client->strategy();
2043 auto clientAttr = client->attributes();
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07002044 if (stream == AUDIO_STREAM_TTS) {
2045 ALOGV("\t found BEACON stream");
François Gaffie1c878552018-11-22 16:53:21 +01002046 if (!mTtsOutputAvailable && mOutputs.isAnyOutputActive(
Francois Gaffie4404ddb2021-02-04 17:03:38 +01002047 toVolumeSource(AUDIO_STREAM_TTS, false) /*sourceToIgnore*/)) {
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07002048 return INVALID_OPERATION;
2049 } else {
2050 beaconMuteLatency = handleEventForBeacon(STARTING_BEACON);
2051 }
2052 } else {
2053 // some playback other than beacon starts
2054 beaconMuteLatency = handleEventForBeacon(STARTING_OUTPUT);
2055 }
2056
Eric Laurent77305a62016-07-25 16:39:22 -07002057 // force device change if the output is inactive and no audio patch is already present.
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002058 // check active before incrementing usage count
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02002059 bool force = !outputDesc->isActive() && !outputDesc->isRouted();
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07002060
François Gaffie11d30102018-11-02 16:09:09 +01002061 DeviceVector devices;
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002062 sp<AudioPolicyMix> policyMix = outputDesc->mPolicyMix.promote();
Eric Laurent97ac8712018-07-27 18:59:02 -07002063 const char *address = NULL;
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002064 if (policyMix != nullptr) {
François Gaffie11d30102018-11-02 16:09:09 +01002065 audio_devices_t newDeviceType;
Eric Laurent97ac8712018-07-27 18:59:02 -07002066 address = policyMix->mDeviceAddress.string();
Kevin Rocard153f92d2018-12-18 18:33:28 -08002067 if ((policyMix->mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) {
François Gaffie11d30102018-11-02 16:09:09 +01002068 newDeviceType = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
Kevin Rocard153f92d2018-12-18 18:33:28 -08002069 } else {
2070 newDeviceType = policyMix->mDeviceType;
Eric Laurent97ac8712018-07-27 18:59:02 -07002071 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08002072 sp device = mAvailableOutputDevices.getDevice(newDeviceType, String8(address),
2073 AUDIO_FORMAT_DEFAULT);
2074 ALOG_ASSERT(device, "%s: no device found t=%u, a=%s", __func__, newDeviceType, address);
2075 devices.add(device);
Eric Laurent97ac8712018-07-27 18:59:02 -07002076 }
2077
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00002078 // requiresMuteCheck is false when we can bypass mute strategy.
2079 // It covers a common case when there is no materially active audio
2080 // and muting would result in unnecessary delay and dropped audio.
2081 const uint32_t outputLatencyMs = outputDesc->latency();
2082 bool requiresMuteCheck = outputDesc->isActive(outputLatencyMs * 2); // account for drain
Eric Laurent96d1dda2022-03-14 17:14:19 +01002083 bool wasLeUnicastActive = isLeUnicastActive();
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00002084
Eric Laurente552edb2014-03-10 17:42:56 -07002085 // increment usage count for this stream on the requested output:
2086 // NOTE that the usage count is the same for duplicated output and hardware output which is
2087 // necessary for a correct control of hardware output routing by startOutput() and stopOutput()
Eric Laurent592dd7b2018-08-05 18:58:48 -07002088 outputDesc->setClientActive(client, true);
Eric Laurent97ac8712018-07-27 18:59:02 -07002089
2090 if (client->hasPreferredDevice(true)) {
François Gaffief96e5432019-04-09 17:13:56 +02002091 if (outputDesc->clientsList(true /*activeOnly*/).size() == 1 &&
2092 client->isPreferredDeviceForExclusiveUse()) {
2093 // Preferred device may be exclusive, use only if no other active clients on this output
2094 devices = DeviceVector(
2095 mAvailableOutputDevices.getDeviceFromId(client->preferredDeviceId()));
2096 } else {
2097 devices = getNewOutputDevices(outputDesc, false /*fromCache*/);
2098 }
François Gaffie11d30102018-11-02 16:09:09 +01002099 if (devices != outputDesc->devices()) {
François Gaffiec005e562018-11-06 15:04:49 +01002100 checkStrategyRoute(clientStrategy, outputDesc->mIoHandle);
Eric Laurent97ac8712018-07-27 18:59:02 -07002101 }
2102 }
Eric Laurente552edb2014-03-10 17:42:56 -07002103
François Gaffiec005e562018-11-06 15:04:49 +01002104 if (followsSameRouting(clientAttr, attributes_initializer(AUDIO_USAGE_MEDIA))) {
Eric Laurent36829f92017-04-07 19:04:42 -07002105 selectOutputForMusicEffects();
2106 }
2107
François Gaffie1c878552018-11-22 16:53:21 +01002108 if (outputDesc->getActivityCount(clientVolSrc) == 1 || !devices.isEmpty()) {
Eric Laurent275e8e92014-11-30 15:14:47 -08002109 // starting an output being rerouted?
François Gaffie11d30102018-11-02 16:09:09 +01002110 if (devices.isEmpty()) {
2111 devices = getNewOutputDevices(outputDesc, false /*fromCache*/);
Eric Laurent275e8e92014-11-30 15:14:47 -08002112 }
François Gaffiec005e562018-11-06 15:04:49 +01002113 bool shouldWait =
2114 (followsSameRouting(clientAttr, attributes_initializer(AUDIO_USAGE_ALARM)) ||
2115 followsSameRouting(clientAttr, attributes_initializer(AUDIO_USAGE_NOTIFICATION)) ||
2116 (beaconMuteLatency > 0));
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07002117 uint32_t waitMs = beaconMuteLatency;
Eric Laurente552edb2014-03-10 17:42:56 -07002118 for (size_t i = 0; i < mOutputs.size(); i++) {
François Gaffie11d30102018-11-02 16:09:09 +01002119 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Eric Laurente552edb2014-03-10 17:42:56 -07002120 if (desc != outputDesc) {
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00002121 // An output has a shared device if
2122 // - managed by the same hw module
2123 // - supports the currently selected device
2124 const bool sharedDevice = outputDesc->sharesHwModuleWith(desc)
François Gaffie11d30102018-11-02 16:09:09 +01002125 && (!desc->filterSupportedDevices(devices).isEmpty());
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00002126
Eric Laurent77305a62016-07-25 16:39:22 -07002127 // force a device change if any other output is:
2128 // - managed by the same hw module
Jean-Michel Trivi4a5b4812018-02-08 17:22:32 +00002129 // - supports currently selected device
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00002130 // - has a current device selection that differs from selected device.
Eric Laurent77305a62016-07-25 16:39:22 -07002131 // - has an active audio patch
Eric Laurente552edb2014-03-10 17:42:56 -07002132 // In this case, the audio HAL must receive the new device selection so that it can
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00002133 // change the device currently selected by the other output.
2134 if (sharedDevice &&
François Gaffie11d30102018-11-02 16:09:09 +01002135 desc->devices() != devices &&
Eric Laurent77305a62016-07-25 16:39:22 -07002136 desc->getPatchHandle() != AUDIO_PATCH_HANDLE_NONE) {
Eric Laurente552edb2014-03-10 17:42:56 -07002137 force = true;
2138 }
2139 // wait for audio on other active outputs to be presented when starting
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07002140 // a notification so that audio focus effect can propagate, or that a mute/unmute
2141 // event occurred for beacon
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00002142 const uint32_t latencyMs = desc->latency();
2143 const bool isActive = desc->isActive(latencyMs * 2); // account for drain
2144
2145 if (shouldWait && isActive && (waitMs < latencyMs)) {
2146 waitMs = latencyMs;
Eric Laurente552edb2014-03-10 17:42:56 -07002147 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00002148
2149 // Require mute check if another output is on a shared device
2150 // and currently active to have proper drain and avoid pops.
2151 // Note restoring AudioTracks onto this output needs to invoke
2152 // a volume ramp if there is no mute.
2153 requiresMuteCheck |= sharedDevice && isActive;
Eric Laurente552edb2014-03-10 17:42:56 -07002154 }
2155 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00002156
2157 const uint32_t muteWaitMs =
François Gaffie11d30102018-11-02 16:09:09 +01002158 setOutputDevices(outputDesc, devices, force, 0, NULL, requiresMuteCheck);
Eric Laurente552edb2014-03-10 17:42:56 -07002159
Eric Laurente552edb2014-03-10 17:42:56 -07002160 // apply volume rules for current stream and device if necessary
François Gaffieaaac0fd2018-11-22 17:56:39 +01002161 auto &curves = getVolumeCurves(client->attributes());
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002162 if (NO_ERROR != checkAndSetVolume(curves, client->volumeSource(),
François Gaffieaaac0fd2018-11-22 17:56:39 +01002163 curves.getVolumeIndex(outputDesc->devices().types()),
Eric Laurentc75307b2015-03-17 15:29:32 -07002164 outputDesc,
Francois Gaffied11442b2020-04-27 11:51:09 +02002165 outputDesc->devices().types(), 0 /*delay*/,
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002166 outputDesc->useHwGain() /*force*/)) {
2167 // request AudioService to reinitialize the volume curves asynchronously
2168 ALOGE("checkAndSetVolume failed, requesting volume range init");
2169 mpClientInterface->onVolumeRangeInitRequest();
2170 };
Eric Laurente552edb2014-03-10 17:42:56 -07002171
2172 // update the outputs if starting an output with a stream that can affect notification
2173 // routing
2174 handleNotificationRoutingForStream(stream);
Eric Laurentc722f302014-12-10 11:21:49 -08002175
Eric Laurent2cbe89a2014-12-19 11:49:08 -08002176 // force reevaluating accessibility routing when ringtone or alarm starts
François Gaffiec005e562018-11-06 15:04:49 +01002177 if (followsSameRouting(clientAttr, attributes_initializer(AUDIO_USAGE_ALARM))) {
Eric Laurent2cbe89a2014-12-19 11:49:08 -08002178 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
2179 }
Eric Laurentdc462862016-07-19 12:29:53 -07002180
2181 if (waitMs > muteWaitMs) {
2182 *delayMs = waitMs - muteWaitMs;
2183 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00002184
2185 // FIXME: A device change (muteWaitMs > 0) likely introduces a volume change.
2186 // A volume change enacted by APM with 0 delay is not synchronous, as it goes
2187 // via AudioCommandThread to AudioFlinger. Hence it is possible that the volume
2188 // change occurs after the MixerThread starts and causes a stream volume
2189 // glitch.
2190 //
2191 // We do not introduce additional delay here.
Eric Laurente552edb2014-03-10 17:42:56 -07002192 }
Eric Laurentdc462862016-07-19 12:29:53 -07002193
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09002194 if (stream == AUDIO_STREAM_ENFORCED_AUDIBLE &&
jiabin9a3361e2019-10-01 09:38:30 -07002195 mEngine->getForceUse(
2196 AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
François Gaffiec005e562018-11-06 15:04:49 +01002197 setStrategyMute(streamToStrategy(AUDIO_STREAM_ALARM), true, outputDesc);
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09002198 }
2199
Eric Laurent97ac8712018-07-27 18:59:02 -07002200 // Automatically enable the remote submix input when output is started on a re routing mix
2201 // of type MIX_TYPE_RECORDERS
jiabin9a3361e2019-10-01 09:38:30 -07002202 if (isSingleDeviceType(devices.types(), &audio_is_remote_submix_device) &&
2203 policyMix != NULL && policyMix->mMixType == MIX_TYPE_RECORDERS) {
Eric Laurent97ac8712018-07-27 18:59:02 -07002204 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
2205 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2206 address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08002207 "remote-submix",
2208 AUDIO_FORMAT_DEFAULT);
Eric Laurent97ac8712018-07-27 18:59:02 -07002209 }
2210
Eric Laurent96d1dda2022-03-14 17:14:19 +01002211 checkLeBroadcastRoutes(wasLeUnicastActive, outputDesc, *delayMs);
2212
Eric Laurente552edb2014-03-10 17:42:56 -07002213 return NO_ERROR;
2214}
2215
Eric Laurent96d1dda2022-03-14 17:14:19 +01002216void AudioPolicyManager::checkLeBroadcastRoutes(bool wasUnicastActive,
2217 sp<SwAudioOutputDescriptor> ignoredOutput, uint32_t delayMs) {
2218 bool isUnicastActive = isLeUnicastActive();
2219
2220 if (wasUnicastActive != isUnicastActive) {
2221 //reroute all outputs routed to LE broadcast if LE unicast activy changed on any output
2222 for (size_t i = 0; i < mOutputs.size(); i++) {
2223 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
2224 if (desc != ignoredOutput && desc->isActive()
2225 && ((isUnicastActive &&
2226 !desc->devices().
2227 getDevicesFromType(AUDIO_DEVICE_OUT_BLE_BROADCAST).isEmpty())
2228 || (wasUnicastActive &&
2229 !desc->devices().getDevicesFromTypes(
2230 getAudioDeviceOutLeAudioUnicastSet()).isEmpty()))) {
2231 DeviceVector newDevices = getNewOutputDevices(desc, false /*fromCache*/);
2232 bool force = desc->devices() != newDevices;
2233 setOutputDevices(desc, newDevices, force, delayMs);
2234 // re-apply device specific volume if not done by setOutputDevice()
2235 if (!force) {
2236 applyStreamVolumes(desc, newDevices.types(), delayMs);
2237 }
2238 }
2239 }
2240 }
2241}
2242
Eric Laurent8fc147b2018-07-22 19:13:55 -07002243status_t AudioPolicyManager::stopOutput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07002244{
Eric Laurent8fc147b2018-07-22 19:13:55 -07002245 ALOGV("%s portId %d", __FUNCTION__, portId);
2246
2247 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputForClient(portId);
2248 if (outputDesc == 0) {
2249 ALOGW("stopOutput() no output for client %d", portId);
Eric Laurente552edb2014-03-10 17:42:56 -07002250 return BAD_VALUE;
2251 }
Andy Hung39efb7a2018-09-26 15:39:28 -07002252 sp<TrackClientDescriptor> client = outputDesc->getClient(portId);
Eric Laurente552edb2014-03-10 17:42:56 -07002253
Jean-Michel Trivi32b7a102023-02-07 20:49:04 +00002254 if (client->hasPreferredDevice(true)) {
2255 // playback activity with preferred device impacts routing occurred, inform upper layers
2256 mpClientInterface->onRoutingUpdated();
2257 }
2258
Eric Laurent97ac8712018-07-27 18:59:02 -07002259 ALOGV("stopOutput() output %d, stream %d, session %d",
2260 outputDesc->mIoHandle, client->stream(), client->session());
Eric Laurente552edb2014-03-10 17:42:56 -07002261
Eric Laurent97ac8712018-07-27 18:59:02 -07002262 status_t status = stopSource(outputDesc, client);
Eric Laurent3974e3b2017-12-07 17:58:43 -08002263
Eric Laurent733ce942017-12-07 12:18:25 -08002264 if (status == NO_ERROR ) {
2265 outputDesc->stop();
Eric Laurent3974e3b2017-12-07 17:58:43 -08002266 }
2267 return status;
Eric Laurentc75307b2015-03-17 15:29:32 -07002268}
2269
Eric Laurent97ac8712018-07-27 18:59:02 -07002270status_t AudioPolicyManager::stopSource(const sp<SwAudioOutputDescriptor>& outputDesc,
2271 const sp<TrackClientDescriptor>& client)
Eric Laurentc75307b2015-03-17 15:29:32 -07002272{
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07002273 // always handle stream stop, check which stream type is stopping
Eric Laurent97ac8712018-07-27 18:59:02 -07002274 audio_stream_type_t stream = client->stream();
François Gaffie1c878552018-11-22 16:53:21 +01002275 auto clientVolSrc = client->volumeSource();
Eric Laurent96d1dda2022-03-14 17:14:19 +01002276 bool wasLeUnicastActive = isLeUnicastActive();
Eric Laurent97ac8712018-07-27 18:59:02 -07002277
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07002278 handleEventForBeacon(stream == AUDIO_STREAM_TTS ? STOPPING_BEACON : STOPPING_OUTPUT);
2279
François Gaffie1c878552018-11-22 16:53:21 +01002280 if (outputDesc->getActivityCount(clientVolSrc) > 0) {
2281 if (outputDesc->getActivityCount(clientVolSrc) == 1) {
Eric Laurent97ac8712018-07-27 18:59:02 -07002282 // Automatically disable the remote submix input when output is stopped on a
2283 // re routing mix of type MIX_TYPE_RECORDERS
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002284 sp<AudioPolicyMix> policyMix = outputDesc->mPolicyMix.promote();
jiabin9a3361e2019-10-01 09:38:30 -07002285 if (isSingleDeviceType(
2286 outputDesc->devices().types(), &audio_is_remote_submix_device) &&
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002287 policyMix != nullptr &&
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002288 policyMix->mMixType == MIX_TYPE_RECORDERS) {
Eric Laurent97ac8712018-07-27 18:59:02 -07002289 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
2290 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002291 policyMix->mDeviceAddress,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08002292 "remote-submix", AUDIO_FORMAT_DEFAULT);
Eric Laurent97ac8712018-07-27 18:59:02 -07002293 }
2294 }
2295 bool forceDeviceUpdate = false;
2296 if (client->hasPreferredDevice(true)) {
François Gaffiec005e562018-11-06 15:04:49 +01002297 checkStrategyRoute(client->strategy(), AUDIO_IO_HANDLE_NONE);
Eric Laurent97ac8712018-07-27 18:59:02 -07002298 forceDeviceUpdate = true;
2299 }
2300
Eric Laurente552edb2014-03-10 17:42:56 -07002301 // decrement usage count of this stream on the output
Eric Laurent592dd7b2018-08-05 18:58:48 -07002302 outputDesc->setClientActive(client, false);
Paul McLeanaa981192015-03-21 09:55:15 -07002303
Eric Laurente552edb2014-03-10 17:42:56 -07002304 // store time at which the stream was stopped - see isStreamActive()
François Gaffie1c878552018-11-22 16:53:21 +01002305 if (outputDesc->getActivityCount(clientVolSrc) == 0 || forceDeviceUpdate) {
François Gaffiec005e562018-11-06 15:04:49 +01002306 outputDesc->setStopTime(client, systemTime());
François Gaffie11d30102018-11-02 16:09:09 +01002307 DeviceVector newDevices = getNewOutputDevices(outputDesc, false /*fromCache*/);
Francois Gaffie3523ab32021-06-22 13:24:34 +02002308
2309 // If the routing does not change, if an output is routed on a device using HwGain
2310 // (aka setAudioPortConfig) and there are still active clients following different
2311 // volume group(s), force reapply volume
2312 bool requiresVolumeCheck = outputDesc->getActivityCount(clientVolSrc) == 0 &&
2313 outputDesc->useHwGain() && outputDesc->isAnyActive(VOLUME_SOURCE_NONE);
2314
Eric Laurente552edb2014-03-10 17:42:56 -07002315 // delay the device switch by twice the latency because stopOutput() is executed when
2316 // the track stop() command is received and at that time the audio track buffer can
2317 // still contain data that needs to be drained. The latency only covers the audio HAL
2318 // and kernel buffers. Also the latency does not always include additional delay in the
2319 // audio path (audio DSP, CODEC ...)
Francois Gaffie3523ab32021-06-22 13:24:34 +02002320 setOutputDevices(outputDesc, newDevices, false, outputDesc->latency()*2,
2321 nullptr, true /*requiresMuteCheck*/, requiresVolumeCheck);
Eric Laurente552edb2014-03-10 17:42:56 -07002322
2323 // force restoring the device selection on other active outputs if it differs from the
2324 // one being selected for this output
Eric Laurent57de36c2016-09-28 16:59:11 -07002325 uint32_t delayMs = outputDesc->latency()*2;
Eric Laurente552edb2014-03-10 17:42:56 -07002326 for (size_t i = 0; i < mOutputs.size(); i++) {
François Gaffie11d30102018-11-02 16:09:09 +01002327 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Eric Laurentc75307b2015-03-17 15:29:32 -07002328 if (desc != outputDesc &&
Eric Laurente552edb2014-03-10 17:42:56 -07002329 desc->isActive() &&
2330 outputDesc->sharesHwModuleWith(desc) &&
François Gaffie11d30102018-11-02 16:09:09 +01002331 (newDevices != desc->devices())) {
2332 DeviceVector newDevices2 = getNewOutputDevices(desc, false /*fromCache*/);
2333 bool force = desc->devices() != newDevices2;
Eric Laurentf3a5a602018-05-22 18:42:55 -07002334
François Gaffie11d30102018-11-02 16:09:09 +01002335 setOutputDevices(desc, newDevices2, force, delayMs);
2336
Eric Laurent57de36c2016-09-28 16:59:11 -07002337 // re-apply device specific volume if not done by setOutputDevice()
2338 if (!force) {
François Gaffie11d30102018-11-02 16:09:09 +01002339 applyStreamVolumes(desc, newDevices2.types(), delayMs);
Eric Laurent57de36c2016-09-28 16:59:11 -07002340 }
Eric Laurente552edb2014-03-10 17:42:56 -07002341 }
2342 }
2343 // update the outputs if stopping one with a stream that can affect notification routing
2344 handleNotificationRoutingForStream(stream);
2345 }
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09002346
2347 if (stream == AUDIO_STREAM_ENFORCED_AUDIBLE &&
2348 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -08002349 setStrategyMute(streamToStrategy(AUDIO_STREAM_ALARM), false, outputDesc);
Tomoharu Kasaharab62d78b2018-01-18 20:55:02 +09002350 }
2351
François Gaffiec005e562018-11-06 15:04:49 +01002352 if (followsSameRouting(client->attributes(), attributes_initializer(AUDIO_USAGE_MEDIA))) {
Eric Laurent36829f92017-04-07 19:04:42 -07002353 selectOutputForMusicEffects();
2354 }
Eric Laurent96d1dda2022-03-14 17:14:19 +01002355
2356 checkLeBroadcastRoutes(wasLeUnicastActive, outputDesc, outputDesc->latency()*2);
2357
Eric Laurente552edb2014-03-10 17:42:56 -07002358 return NO_ERROR;
2359 } else {
Eric Laurentc75307b2015-03-17 15:29:32 -07002360 ALOGW("stopOutput() refcount is already 0");
Eric Laurente552edb2014-03-10 17:42:56 -07002361 return INVALID_OPERATION;
2362 }
2363}
2364
jiabinbce0c1d2020-10-05 11:20:18 -07002365bool AudioPolicyManager::releaseOutput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07002366{
Eric Laurent8fc147b2018-07-22 19:13:55 -07002367 ALOGV("%s portId %d", __FUNCTION__, portId);
2368
2369 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputForClient(portId);
2370 if (outputDesc == 0) {
Andy Hung39efb7a2018-09-26 15:39:28 -07002371 // If an output descriptor is closed due to a device routing change,
2372 // then there are race conditions with releaseOutput from tracks
2373 // that may be destroyed (with no PlaybackThread) or a PlaybackThread
2374 // destroyed shortly thereafter.
2375 //
2376 // Here we just log a warning, instead of a fatal error.
Eric Laurent8fc147b2018-07-22 19:13:55 -07002377 ALOGW("releaseOutput() no output for client %d", portId);
jiabinbce0c1d2020-10-05 11:20:18 -07002378 return false;
Eric Laurente552edb2014-03-10 17:42:56 -07002379 }
Eric Laurent8fc147b2018-07-22 19:13:55 -07002380
2381 ALOGV("releaseOutput() %d", outputDesc->mIoHandle);
Eric Laurente552edb2014-03-10 17:42:56 -07002382
Jaideep Sharma7bf382e2020-11-26 17:07:29 +05302383 sp<TrackClientDescriptor> client = outputDesc->getClient(portId);
2384 if (outputDesc->isClientActive(client)) {
2385 ALOGW("releaseOutput() inactivates portId %d in good faith", portId);
2386 stopOutput(portId);
2387 }
2388
Eric Laurent8fc147b2018-07-22 19:13:55 -07002389 if (outputDesc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
2390 if (outputDesc->mDirectOpenCount <= 0) {
Eric Laurente552edb2014-03-10 17:42:56 -07002391 ALOGW("releaseOutput() invalid open count %d for output %d",
Eric Laurent8fc147b2018-07-22 19:13:55 -07002392 outputDesc->mDirectOpenCount, outputDesc->mIoHandle);
jiabinbce0c1d2020-10-05 11:20:18 -07002393 return false;
Eric Laurente552edb2014-03-10 17:42:56 -07002394 }
Eric Laurent8fc147b2018-07-22 19:13:55 -07002395 if (--outputDesc->mDirectOpenCount == 0) {
2396 closeOutput(outputDesc->mIoHandle);
Eric Laurentb52c1522014-05-20 11:27:36 -07002397 mpClientInterface->onAudioPortListUpdate();
Eric Laurente552edb2014-03-10 17:42:56 -07002398 }
2399 }
Jaideep Sharma7bf382e2020-11-26 17:07:29 +05302400
Andy Hung39efb7a2018-09-26 15:39:28 -07002401 outputDesc->removeClient(portId);
jiabinbce0c1d2020-10-05 11:20:18 -07002402 if (outputDesc->mPendingReopenToQueryProfiles && outputDesc->getClientCount() == 0) {
2403 // The output is pending reopened to query dynamic profiles and
2404 // there is no active clients
2405 closeOutput(outputDesc->mIoHandle);
2406 sp<SwAudioOutputDescriptor> newOutputDesc = openOutputWithProfileAndDevice(
2407 outputDesc->mProfile, mEngine->getActiveMediaDevices(mAvailableOutputDevices));
2408 if (newOutputDesc == nullptr) {
2409 ALOGE("%s failed to open output", __func__);
2410 }
2411 return true;
2412 }
2413 return false;
Eric Laurente552edb2014-03-10 17:42:56 -07002414}
2415
Eric Laurentcaf7f482014-11-25 17:50:47 -08002416status_t AudioPolicyManager::getInputForAttr(const audio_attributes_t *attr,
2417 audio_io_handle_t *input,
Mikhail Naganov2996f672019-04-18 12:29:59 -07002418 audio_unique_id_t riid,
Eric Laurentcaf7f482014-11-25 17:50:47 -08002419 audio_session_t session,
Svet Ganov3e5f14f2021-05-13 22:51:08 +00002420 const AttributionSourceState& attributionSource,
Eric Laurent20b9ef02016-12-05 11:03:16 -08002421 const audio_config_base_t *config,
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -08002422 audio_input_flags_t flags,
Eric Laurent2ac76942017-06-22 17:17:09 -07002423 audio_port_handle_t *selectedDeviceId,
Eric Laurent20b9ef02016-12-05 11:03:16 -08002424 input_type_t *inputType,
2425 audio_port_handle_t *portId)
Eric Laurente552edb2014-03-10 17:42:56 -07002426{
François Gaffiec005e562018-11-06 15:04:49 +01002427 ALOGV("%s() source %d, sampling rate %d, format %#x, channel mask %#x, session %d, "
Eric Laurent2f2c1982021-06-02 14:03:11 +02002428 "flags %#x attributes=%s requested device ID %d",
2429 __func__, attr->source, config->sample_rate, config->format, config->channel_mask,
2430 session, flags, toString(*attr).c_str(), *selectedDeviceId);
Eric Laurente552edb2014-03-10 17:42:56 -07002431
Eric Laurentad2e7b92017-09-14 20:06:42 -07002432 status_t status = NO_ERROR;
Francois Gaffie716e1432019-01-14 16:58:59 +01002433 audio_attributes_t attributes = *attr;
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002434 sp<AudioPolicyMix> policyMix;
François Gaffie11d30102018-11-02 16:09:09 +01002435 sp<DeviceDescriptor> device;
Eric Laurent8fc147b2018-07-22 19:13:55 -07002436 sp<AudioInputDescriptor> inputDesc;
2437 sp<RecordClientDescriptor> clientDesc;
2438 audio_port_handle_t requestedDeviceId = *selectedDeviceId;
Svet Ganov3e5f14f2021-05-13 22:51:08 +00002439 uid_t uid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_uid_t(attributionSource.uid));
Eric Laurent8f42ea12018-08-08 09:08:25 -07002440 bool isSoundTrigger;
Eric Laurent8f42ea12018-08-08 09:08:25 -07002441
2442 // The supplied portId must be AUDIO_PORT_HANDLE_NONE
2443 if (*portId != AUDIO_PORT_HANDLE_NONE) {
2444 return INVALID_OPERATION;
2445 }
Eric Laurent20b9ef02016-12-05 11:03:16 -08002446
Francois Gaffie716e1432019-01-14 16:58:59 +01002447 if (attr->source == AUDIO_SOURCE_DEFAULT) {
2448 attributes.source = AUDIO_SOURCE_MIC;
Eric Laurentfe231122017-11-17 17:48:06 -08002449 }
2450
Paul McLean466dc8e2015-04-17 13:15:36 -06002451 // Explicit routing?
Pattydd807582021-11-04 21:01:03 +08002452 sp<DeviceDescriptor> explicitRoutingDevice =
François Gaffie11d30102018-11-02 16:09:09 +01002453 mAvailableInputDevices.getDeviceFromId(*selectedDeviceId);
Paul McLean466dc8e2015-04-17 13:15:36 -06002454
Eric Laurentad2e7b92017-09-14 20:06:42 -07002455 // special case for mmap capture: if an input IO handle is specified, we reuse this input if
2456 // possible
2457 if ((flags & AUDIO_INPUT_FLAG_MMAP_NOIRQ) == AUDIO_INPUT_FLAG_MMAP_NOIRQ &&
2458 *input != AUDIO_IO_HANDLE_NONE) {
2459 ssize_t index = mInputs.indexOfKey(*input);
2460 if (index < 0) {
2461 ALOGW("getInputForAttr() unknown MMAP input %d", *input);
2462 status = BAD_VALUE;
2463 goto error;
2464 }
2465 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002466 RecordClientVector clients = inputDesc->getClientsForSession(session);
2467 if (clients.size() == 0) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07002468 ALOGW("getInputForAttr() unknown session %d on input %d", session, *input);
2469 status = BAD_VALUE;
2470 goto error;
2471 }
2472 // For MMAP mode, the first call to getInputForAttr() is made on behalf of audioflinger.
2473 // The second call is for the first active client and sets the UID. Any further call
Eric Laurent331679c2018-04-16 17:03:16 -07002474 // corresponds to a new client and is only permitted from the same UID.
2475 // If the first UID is silenced, allow a new UID connection and replace with new UID
Eric Laurent8f42ea12018-08-08 09:08:25 -07002476 if (clients.size() > 1) {
2477 for (const auto& client : clients) {
2478 // The client map is ordered by key values (portId) and portIds are allocated
2479 // incrementaly. So the first client in this list is the one opened by audio flinger
2480 // when the mmap stream is created and should be ignored as it does not correspond
2481 // to an actual client
2482 if (client == *clients.cbegin()) {
2483 continue;
2484 }
2485 if (uid != client->uid() && !client->isSilenced()) {
2486 ALOGW("getInputForAttr() bad uid %d for client %d uid %d",
2487 uid, client->portId(), client->uid());
2488 status = INVALID_OPERATION;
2489 goto error;
2490 }
Eric Laurent331679c2018-04-16 17:03:16 -07002491 }
Eric Laurentad2e7b92017-09-14 20:06:42 -07002492 }
Eric Laurentad2e7b92017-09-14 20:06:42 -07002493 *inputType = API_INPUT_LEGACY;
François Gaffie11d30102018-11-02 16:09:09 +01002494 device = inputDesc->getDevice();
Eric Laurentad2e7b92017-09-14 20:06:42 -07002495
Eric Laurentfecbceb2021-02-09 14:46:43 +01002496 ALOGV("%s reusing MMAP input %d for session %d", __FUNCTION__, *input, session);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002497 goto exit;
Eric Laurentad2e7b92017-09-14 20:06:42 -07002498 }
2499
2500 *input = AUDIO_IO_HANDLE_NONE;
2501 *inputType = API_INPUT_INVALID;
2502
Francois Gaffie716e1432019-01-14 16:58:59 +01002503 if (attributes.source == AUDIO_SOURCE_REMOTE_SUBMIX &&
2504 strncmp(attributes.tags, "addr=", strlen("addr=")) == 0) {
2505 status = mPolicyMixes.getInputMixForAttr(attributes, &policyMix);
Eric Laurentad2e7b92017-09-14 20:06:42 -07002506 if (status != NO_ERROR) {
jiabinc1de2df2019-05-07 14:26:40 -07002507 ALOGW("%s could not find input mix for attr %s",
2508 __func__, toString(attributes).c_str());
Eric Laurentad2e7b92017-09-14 20:06:42 -07002509 goto error;
François Gaffie036e1e92015-03-19 10:16:24 +01002510 }
jiabinc1de2df2019-05-07 14:26:40 -07002511 device = mAvailableInputDevices.getDevice(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
2512 String8(attr->tags + strlen("addr=")),
2513 AUDIO_FORMAT_DEFAULT);
2514 if (device == nullptr) {
Kevin Rocard04ed0462019-05-02 17:53:24 -07002515 ALOGW("%s could not find in Remote Submix device for source %d, tags %s",
jiabinc1de2df2019-05-07 14:26:40 -07002516 __func__, attributes.source, attributes.tags);
2517 status = BAD_VALUE;
2518 goto error;
2519 }
2520
Kevin Rocard25f9b052019-02-27 15:08:54 -08002521 if (is_mix_loopback_render(policyMix->mRouteFlags)) {
2522 *inputType = API_INPUT_MIX_PUBLIC_CAPTURE_PLAYBACK;
2523 } else {
2524 *inputType = API_INPUT_MIX_EXT_POLICY_REROUTE;
2525 }
Eric Laurent275e8e92014-11-30 15:14:47 -08002526 } else {
François Gaffie11d30102018-11-02 16:09:09 +01002527 if (explicitRoutingDevice != nullptr) {
2528 device = explicitRoutingDevice;
Eric Laurent97ac8712018-07-27 18:59:02 -07002529 } else {
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01002530 // Prevent from storing invalid requested device id in clients
2531 requestedDeviceId = AUDIO_PORT_HANDLE_NONE;
yuanjiahsu0735bf32021-03-18 08:12:54 +08002532 device = mEngine->getInputDeviceForAttributes(attributes, uid, &policyMix);
yuanjiahsu4069d5d2021-04-19 07:54:27 +08002533 ALOGV_IF(device != nullptr, "%s found device type is 0x%X",
2534 __FUNCTION__, device->type());
Eric Laurent97ac8712018-07-27 18:59:02 -07002535 }
François Gaffie11d30102018-11-02 16:09:09 +01002536 if (device == nullptr) {
Francois Gaffie716e1432019-01-14 16:58:59 +01002537 ALOGW("getInputForAttr() could not find device for source %d", attributes.source);
Eric Laurentad2e7b92017-09-14 20:06:42 -07002538 status = BAD_VALUE;
2539 goto error;
Eric Laurent275e8e92014-11-30 15:14:47 -08002540 }
Alden DSouzab7d20782021-02-08 08:51:42 -08002541 if (device->type() == AUDIO_DEVICE_IN_ECHO_REFERENCE) {
2542 *inputType = API_INPUT_MIX_CAPTURE;
2543 } else if (policyMix) {
François Gaffie11d30102018-11-02 16:09:09 +01002544 ALOG_ASSERT(policyMix->mMixType == MIX_TYPE_RECORDERS, "Invalid Mix Type");
2545 // there is an external policy, but this input is attached to a mix of recorders,
2546 // meaning it receives audio injected into the framework, so the recorder doesn't
2547 // know about it and is therefore considered "legacy"
2548 *inputType = API_INPUT_LEGACY;
2549 } else if (audio_is_remote_submix_device(device->type())) {
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -08002550 *inputType = API_INPUT_MIX_CAPTURE;
François Gaffie11d30102018-11-02 16:09:09 +01002551 } else if (device->type() == AUDIO_DEVICE_IN_TELEPHONY_RX) {
Eric Laurent82db2692015-08-07 13:59:42 -07002552 *inputType = API_INPUT_TELEPHONY_RX;
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -08002553 } else {
2554 *inputType = API_INPUT_LEGACY;
Eric Laurentc722f302014-12-10 11:21:49 -08002555 }
Ravi Kumar Alamandab367f5b2015-08-25 08:21:37 -07002556
Eric Laurent599c7582015-12-07 18:05:55 -08002557 }
2558
François Gaffiec005e562018-11-06 15:04:49 +01002559 *input = getInputForDevice(device, session, attributes, config, flags, policyMix);
Eric Laurent599c7582015-12-07 18:05:55 -08002560 if (*input == AUDIO_IO_HANDLE_NONE) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07002561 status = INVALID_OPERATION;
2562 goto error;
Eric Laurent599c7582015-12-07 18:05:55 -08002563 }
Eric Laurent20b9ef02016-12-05 11:03:16 -08002564
Eric Laurent8f42ea12018-08-08 09:08:25 -07002565exit:
2566
François Gaffiec005e562018-11-06 15:04:49 +01002567 *selectedDeviceId = mAvailableInputDevices.contains(device) ?
2568 device->getId() : AUDIO_PORT_HANDLE_NONE;
Eric Laurent2ac76942017-06-22 17:17:09 -07002569
Francois Gaffie716e1432019-01-14 16:58:59 +01002570 isSoundTrigger = attributes.source == AUDIO_SOURCE_HOTWORD &&
Carter Hsud0cce2e2019-05-03 17:36:28 +08002571 mSoundTriggerSessions.indexOfKey(session) >= 0;
jiabin4ef93452019-09-10 14:29:54 -07002572 *portId = PolicyAudioPort::getNextUniqueId();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002573
Mikhail Naganov2996f672019-04-18 12:29:59 -07002574 clientDesc = new RecordClientDescriptor(*portId, riid, uid, session, attributes, *config,
Francois Gaffie716e1432019-01-14 16:58:59 +01002575 requestedDeviceId, attributes.source, flags,
2576 isSoundTrigger);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002577 inputDesc = mInputs.valueFor(*input);
Andy Hung39efb7a2018-09-26 15:39:28 -07002578 inputDesc->addClient(clientDesc);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002579
2580 ALOGV("getInputForAttr() returns input %d type %d selectedDeviceId %d for port ID %d",
2581 *input, *inputType, *selectedDeviceId, *portId);
Eric Laurent2ac76942017-06-22 17:17:09 -07002582
Eric Laurent599c7582015-12-07 18:05:55 -08002583 return NO_ERROR;
Eric Laurentad2e7b92017-09-14 20:06:42 -07002584
2585error:
Eric Laurentad2e7b92017-09-14 20:06:42 -07002586 return status;
Eric Laurent599c7582015-12-07 18:05:55 -08002587}
2588
2589
François Gaffie11d30102018-11-02 16:09:09 +01002590audio_io_handle_t AudioPolicyManager::getInputForDevice(const sp<DeviceDescriptor> &device,
Eric Laurent599c7582015-12-07 18:05:55 -08002591 audio_session_t session,
François Gaffiec005e562018-11-06 15:04:49 +01002592 const audio_attributes_t &attributes,
Eric Laurentfe231122017-11-17 17:48:06 -08002593 const audio_config_base_t *config,
Eric Laurent599c7582015-12-07 18:05:55 -08002594 audio_input_flags_t flags,
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002595 const sp<AudioPolicyMix> &policyMix)
Eric Laurent599c7582015-12-07 18:05:55 -08002596{
2597 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
François Gaffiec005e562018-11-06 15:04:49 +01002598 audio_source_t halInputSource = attributes.source;
Eric Laurent599c7582015-12-07 18:05:55 -08002599 bool isSoundTrigger = false;
2600
François Gaffiec005e562018-11-06 15:04:49 +01002601 if (attributes.source == AUDIO_SOURCE_HOTWORD) {
Eric Laurent599c7582015-12-07 18:05:55 -08002602 ssize_t index = mSoundTriggerSessions.indexOfKey(session);
2603 if (index >= 0) {
2604 input = mSoundTriggerSessions.valueFor(session);
2605 isSoundTrigger = true;
2606 flags = (audio_input_flags_t)(flags | AUDIO_INPUT_FLAG_HW_HOTWORD);
2607 ALOGV("SoundTrigger capture on session %d input %d", session, input);
2608 } else {
2609 halInputSource = AUDIO_SOURCE_VOICE_RECOGNITION;
Eric Laurent5dbe4712014-09-19 19:04:57 -07002610 }
François Gaffiec005e562018-11-06 15:04:49 +01002611 } else if (attributes.source == AUDIO_SOURCE_VOICE_COMMUNICATION &&
Eric Laurentfe231122017-11-17 17:48:06 -08002612 audio_is_linear_pcm(config->format)) {
Haynes Mathew George851d3ff2017-06-19 20:01:57 -07002613 flags = (audio_input_flags_t)(flags | AUDIO_INPUT_FLAG_VOIP_TX);
Eric Laurent5dbe4712014-09-19 19:04:57 -07002614 }
2615
Carter Hsua3abb402021-10-26 11:11:20 +08002616 if (attributes.source == AUDIO_SOURCE_ULTRASOUND) {
2617 flags = (audio_input_flags_t)(flags | AUDIO_INPUT_FLAG_ULTRASOUND);
2618 }
2619
Andy Hungf129b032015-04-07 13:45:50 -07002620 // find a compatible input profile (not necessarily identical in parameters)
2621 sp<IOProfile> profile;
Eric Laurentfe231122017-11-17 17:48:06 -08002622 // sampling rate and flags may be updated by getInputProfile
2623 uint32_t profileSamplingRate = (config->sample_rate == 0) ?
2624 SAMPLE_RATE_HZ_DEFAULT : config->sample_rate;
Glenn Kasten730b9262018-03-29 15:01:26 -07002625 audio_format_t profileFormat;
Eric Laurentfe231122017-11-17 17:48:06 -08002626 audio_channel_mask_t profileChannelMask = config->channel_mask;
Andy Hungf129b032015-04-07 13:45:50 -07002627 audio_input_flags_t profileFlags = flags;
2628 for (;;) {
Glenn Kasten730b9262018-03-29 15:01:26 -07002629 profileFormat = config->format; // reset each time through loop, in case it is updated
François Gaffie11d30102018-11-02 16:09:09 +01002630 profile = getInputProfile(device, profileSamplingRate, profileFormat, profileChannelMask,
Andy Hungf129b032015-04-07 13:45:50 -07002631 profileFlags);
2632 if (profile != 0) {
2633 break; // success
Eric Laurent05067782016-06-01 18:27:28 -07002634 } else if (profileFlags & AUDIO_INPUT_FLAG_RAW) {
2635 profileFlags = (audio_input_flags_t) (profileFlags & ~AUDIO_INPUT_FLAG_RAW); // retry
Atneya Nair497fff12022-01-18 16:23:04 -05002636 } else if (profileFlags != AUDIO_INPUT_FLAG_NONE && audio_is_linear_pcm(config->format)) {
Andy Hungf129b032015-04-07 13:45:50 -07002637 profileFlags = AUDIO_INPUT_FLAG_NONE; // retry
2638 } else { // fail
François Gaffie11d30102018-11-02 16:09:09 +01002639 ALOGW("%s could not find profile for device %s, sampling rate %u, format %#x, "
Pattydd807582021-11-04 21:01:03 +08002640 "channel mask 0x%X, flags %#x", __func__, device->toString().c_str(),
François Gaffie11d30102018-11-02 16:09:09 +01002641 config->sample_rate, config->format, config->channel_mask, flags);
Eric Laurent599c7582015-12-07 18:05:55 -08002642 return input;
Eric Laurent5dbe4712014-09-19 19:04:57 -07002643 }
Eric Laurente552edb2014-03-10 17:42:56 -07002644 }
Glenn Kasten05ddca52016-02-11 08:17:12 -08002645 // Pick input sampling rate if not specified by client
Eric Laurentfe231122017-11-17 17:48:06 -08002646 uint32_t samplingRate = config->sample_rate;
Glenn Kasten05ddca52016-02-11 08:17:12 -08002647 if (samplingRate == 0) {
2648 samplingRate = profileSamplingRate;
2649 }
Eric Laurente552edb2014-03-10 17:42:56 -07002650
Eric Laurent322b4d22015-04-03 15:57:54 -07002651 if (profile->getModuleHandle() == 0) {
2652 ALOGE("getInputForAttr(): HW module %s not opened", profile->getModuleName());
Eric Laurent599c7582015-12-07 18:05:55 -08002653 return input;
Eric Laurentcf2c0212014-07-25 16:20:43 -07002654 }
2655
Eric Laurentec376dc2021-04-08 20:41:22 +02002656 // Reuse an already opened input if a client with the same session ID already exists
2657 // on that input
2658 for (size_t i = 0; i < mInputs.size(); i++) {
2659 sp <AudioInputDescriptor> desc = mInputs.valueAt(i);
2660 if (desc->mProfile != profile) {
2661 continue;
2662 }
2663 RecordClientVector clients = desc->clientsList();
2664 for (const auto &client : clients) {
2665 if (session == client->session()) {
2666 return desc->mIoHandle;
2667 }
2668 }
2669 }
2670
Eric Laurent3974e3b2017-12-07 17:58:43 -08002671 if (!profile->canOpenNewIo()) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08002672 for (size_t i = 0; i < mInputs.size(); ) {
Eric Laurentc529cf62020-04-17 18:19:10 -07002673 sp<AudioInputDescriptor> desc = mInputs.valueAt(i);
Eric Laurent4eb58f12018-12-07 16:41:02 -08002674 if (desc->mProfile != profile) {
Carter Hsu9a645a92019-05-15 12:15:32 +08002675 i++;
Eric Laurent4eb58f12018-12-07 16:41:02 -08002676 continue;
2677 }
2678 // if sound trigger, reuse input if used by other sound trigger on same session
2679 // else
2680 // reuse input if active client app is not in IDLE state
2681 //
2682 RecordClientVector clients = desc->clientsList();
2683 bool doClose = false;
2684 for (const auto& client : clients) {
2685 if (isSoundTrigger != client->isSoundTrigger()) {
2686 continue;
2687 }
2688 if (client->isSoundTrigger()) {
2689 if (session == client->session()) {
2690 return desc->mIoHandle;
2691 }
2692 continue;
2693 }
2694 if (client->active() && client->appState() != APP_STATE_IDLE) {
2695 return desc->mIoHandle;
2696 }
2697 doClose = true;
2698 }
2699 if (doClose) {
2700 closeInput(desc->mIoHandle);
2701 } else {
2702 i++;
2703 }
2704 }
Eric Laurent3974e3b2017-12-07 17:58:43 -08002705 }
2706
Eric Laurentfe231122017-11-17 17:48:06 -08002707 sp<AudioInputDescriptor> inputDesc = new AudioInputDescriptor(profile, mpClientInterface);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07002708
Eric Laurentfe231122017-11-17 17:48:06 -08002709 audio_config_t lConfig = AUDIO_CONFIG_INITIALIZER;
2710 lConfig.sample_rate = profileSamplingRate;
2711 lConfig.channel_mask = profileChannelMask;
2712 lConfig.format = profileFormat;
Eric Laurente3014102017-05-03 11:15:43 -07002713
François Gaffie11d30102018-11-02 16:09:09 +01002714 status_t status = inputDesc->open(&lConfig, device, halInputSource, profileFlags, &input);
Eric Laurentcf2c0212014-07-25 16:20:43 -07002715
2716 // only accept input with the exact requested set of parameters
Eric Laurent599c7582015-12-07 18:05:55 -08002717 if (status != NO_ERROR || input == AUDIO_IO_HANDLE_NONE ||
Eric Laurentfe231122017-11-17 17:48:06 -08002718 (profileSamplingRate != lConfig.sample_rate) ||
2719 !audio_formats_match(profileFormat, lConfig.format) ||
2720 (profileChannelMask != lConfig.channel_mask)) {
2721 ALOGW("getInputForAttr() failed opening input: sampling rate %d"
Glenn Kasten49f36ba2017-12-06 13:02:02 -08002722 ", format %#x, channel mask %#x",
Eric Laurentfe231122017-11-17 17:48:06 -08002723 profileSamplingRate, profileFormat, profileChannelMask);
Eric Laurent599c7582015-12-07 18:05:55 -08002724 if (input != AUDIO_IO_HANDLE_NONE) {
Eric Laurentfe231122017-11-17 17:48:06 -08002725 inputDesc->close();
Eric Laurentcf2c0212014-07-25 16:20:43 -07002726 }
Eric Laurent599c7582015-12-07 18:05:55 -08002727 return AUDIO_IO_HANDLE_NONE;
Eric Laurente552edb2014-03-10 17:42:56 -07002728 }
2729
Eric Laurentc722f302014-12-10 11:21:49 -08002730 inputDesc->mPolicyMix = policyMix;
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002731
Eric Laurent599c7582015-12-07 18:05:55 -08002732 addInput(input, inputDesc);
Eric Laurentb52c1522014-05-20 11:27:36 -07002733 mpClientInterface->onAudioPortListUpdate();
Paul McLean466dc8e2015-04-17 13:15:36 -06002734
Eric Laurent599c7582015-12-07 18:05:55 -08002735 return input;
Eric Laurente552edb2014-03-10 17:42:56 -07002736}
2737
Eric Laurent4eb58f12018-12-07 16:41:02 -08002738status_t AudioPolicyManager::startInput(audio_port_handle_t portId)
Eric Laurentbb948092017-01-23 18:33:30 -08002739{
Eric Laurent8fc147b2018-07-22 19:13:55 -07002740 ALOGV("%s portId %d", __FUNCTION__, portId);
2741
2742 sp<AudioInputDescriptor> inputDesc = mInputs.getInputForClient(portId);
2743 if (inputDesc == 0) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002744 ALOGW("%s no input for client %d", __FUNCTION__, portId);
Eric Laurentd52a28c2020-08-21 17:10:39 -07002745 return DEAD_OBJECT;
Eric Laurent8fc147b2018-07-22 19:13:55 -07002746 }
Eric Laurent8fc147b2018-07-22 19:13:55 -07002747 audio_io_handle_t input = inputDesc->mIoHandle;
Andy Hung39efb7a2018-09-26 15:39:28 -07002748 sp<RecordClientDescriptor> client = inputDesc->getClient(portId);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002749 if (client->active()) {
2750 ALOGW("%s input %d client %d already started", __FUNCTION__, input, client->portId());
2751 return INVALID_OPERATION;
Eric Laurent4dc68062014-07-28 17:26:49 -07002752 }
2753
Eric Laurent8f42ea12018-08-08 09:08:25 -07002754 audio_session_t session = client->session();
2755
Eric Laurent4eb58f12018-12-07 16:41:02 -08002756 ALOGV("%s input:%d, session:%d)", __FUNCTION__, input, session);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002757
Eric Laurent4eb58f12018-12-07 16:41:02 -08002758 Vector<sp<AudioInputDescriptor>> activeInputs = mInputs.getActiveInputs();
Eric Laurent74708e72017-04-07 17:13:42 -07002759
Eric Laurent4eb58f12018-12-07 16:41:02 -08002760 status_t status = inputDesc->start();
2761 if (status != NO_ERROR) {
2762 return status;
Eric Laurent74708e72017-04-07 17:13:42 -07002763 }
Eric Laurente552edb2014-03-10 17:42:56 -07002764
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002765 // increment activity count before calling getNewInputDevice() below as only active sessions
Eric Laurent313d1e72016-01-29 09:56:57 -08002766 // are considered for device selection
Eric Laurent8f42ea12018-08-08 09:08:25 -07002767 inputDesc->setClientActive(client, true);
Eric Laurent313d1e72016-01-29 09:56:57 -08002768
Eric Laurent8f42ea12018-08-08 09:08:25 -07002769 // indicate active capture to sound trigger service if starting capture from a mic on
2770 // primary HW module
François Gaffie11d30102018-11-02 16:09:09 +01002771 sp<DeviceDescriptor> device = getNewInputDevice(inputDesc);
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002772 if (device != nullptr) {
2773 status = setInputDevice(input, device, true /* force */);
2774 } else {
2775 ALOGW("%s no new input device can be found for descriptor %d",
2776 __FUNCTION__, inputDesc->getId());
2777 status = BAD_VALUE;
2778 }
Eric Laurente552edb2014-03-10 17:42:56 -07002779
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002780 if (status == NO_ERROR && inputDesc->activeCount() == 1) {
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002781 sp<AudioPolicyMix> policyMix = inputDesc->mPolicyMix.promote();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002782 // if input maps to a dynamic policy with an activity listener, notify of state change
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002783 if ((policyMix != nullptr)
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002784 && ((policyMix->mCbFlags & AudioMix::kCbFlagNotifyActivity) != 0)) {
2785 mpClientInterface->onDynamicPolicyMixStateUpdate(policyMix->mDeviceAddress,
Eric Laurent8f42ea12018-08-08 09:08:25 -07002786 MIX_STATE_MIXING);
Eric Laurent733ce942017-12-07 12:18:25 -08002787 }
Eric Laurent3974e3b2017-12-07 17:58:43 -08002788
François Gaffie11d30102018-11-02 16:09:09 +01002789 DeviceVector primaryInputDevices = availablePrimaryModuleInputDevices();
2790 if (primaryInputDevices.contains(device) &&
Eric Laurent8f42ea12018-08-08 09:08:25 -07002791 mInputs.activeInputsCountOnDevices(primaryInputDevices) == 1) {
Ytai Ben-Tsvi74cd6b02019-10-25 10:06:40 -07002792 mpClientInterface->setSoundTriggerCaptureState(true);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002793 }
Jean-Michel Trivieb6421d2016-03-17 12:32:52 -07002794
Eric Laurent8f42ea12018-08-08 09:08:25 -07002795 // automatically enable the remote submix output when input is started if not
2796 // used by a policy mix of type MIX_TYPE_RECORDERS
2797 // For remote submix (a virtual device), we open only one input per capture request.
François Gaffie11d30102018-11-02 16:09:09 +01002798 if (audio_is_remote_submix_device(inputDesc->getDeviceType())) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002799 String8 address = String8("");
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002800 if (policyMix == nullptr) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002801 address = String8("0");
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002802 } else if (policyMix->mMixType == MIX_TYPE_PLAYERS) {
2803 address = policyMix->mDeviceAddress;
Jean-Michel Trivieb6421d2016-03-17 12:32:52 -07002804 }
Eric Laurent8f42ea12018-08-08 09:08:25 -07002805 if (address != "") {
2806 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
2807 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08002808 address, "remote-submix", AUDIO_FORMAT_DEFAULT);
Eric Laurentc722f302014-12-10 11:21:49 -08002809 }
Glenn Kasten74a8e252014-07-24 14:09:55 -07002810 }
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002811 } else if (status != NO_ERROR) {
2812 // Restore client activity state.
2813 inputDesc->setClientActive(client, false);
2814 inputDesc->stop();
Eric Laurente552edb2014-03-10 17:42:56 -07002815 }
2816
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002817 ALOGV("%s input %d source = %d status = %d exit",
2818 __FUNCTION__, input, client->source(), status);
Eric Laurente552edb2014-03-10 17:42:56 -07002819
Mikhail Naganov480ffee2019-07-01 15:07:19 -07002820 return status;
Eric Laurente552edb2014-03-10 17:42:56 -07002821}
2822
Eric Laurent8fc147b2018-07-22 19:13:55 -07002823status_t AudioPolicyManager::stopInput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07002824{
Eric Laurent8fc147b2018-07-22 19:13:55 -07002825 ALOGV("%s portId %d", __FUNCTION__, portId);
2826
2827 sp<AudioInputDescriptor> inputDesc = mInputs.getInputForClient(portId);
2828 if (inputDesc == 0) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002829 ALOGW("%s no input for client %d", __FUNCTION__, portId);
Eric Laurente552edb2014-03-10 17:42:56 -07002830 return BAD_VALUE;
2831 }
Eric Laurent8fc147b2018-07-22 19:13:55 -07002832 audio_io_handle_t input = inputDesc->mIoHandle;
Andy Hung39efb7a2018-09-26 15:39:28 -07002833 sp<RecordClientDescriptor> client = inputDesc->getClient(portId);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002834 if (!client->active()) {
2835 ALOGW("%s input %d client %d already stopped", __FUNCTION__, input, client->portId());
Eric Laurente552edb2014-03-10 17:42:56 -07002836 return INVALID_OPERATION;
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002837 }
Carter Hsue6139d52021-07-08 10:30:20 +08002838 auto old_source = inputDesc->source();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002839 inputDesc->setClientActive(client, false);
Paul McLean466dc8e2015-04-17 13:15:36 -06002840
Eric Laurent8f42ea12018-08-08 09:08:25 -07002841 inputDesc->stop();
2842 if (inputDesc->isActive()) {
Carter Hsue6139d52021-07-08 10:30:20 +08002843 auto current_source = inputDesc->source();
2844 setInputDevice(input, getNewInputDevice(inputDesc),
2845 old_source != current_source /* force */);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002846 } else {
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002847 sp<AudioPolicyMix> policyMix = inputDesc->mPolicyMix.promote();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002848 // if input maps to a dynamic policy with an activity listener, notify of state change
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002849 if ((policyMix != nullptr)
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002850 && ((policyMix->mCbFlags & AudioMix::kCbFlagNotifyActivity) != 0)) {
2851 mpClientInterface->onDynamicPolicyMixStateUpdate(policyMix->mDeviceAddress,
Eric Laurent8f42ea12018-08-08 09:08:25 -07002852 MIX_STATE_IDLE);
Eric Laurent84332aa2016-01-28 22:19:18 +00002853 }
Eric Laurent8f42ea12018-08-08 09:08:25 -07002854
2855 // automatically disable the remote submix output when input is stopped if not
2856 // used by a policy mix of type MIX_TYPE_RECORDERS
François Gaffie11d30102018-11-02 16:09:09 +01002857 if (audio_is_remote_submix_device(inputDesc->getDeviceType())) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002858 String8 address = String8("");
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08002859 if (policyMix == nullptr) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002860 address = String8("0");
Mikhail Naganovbfac5832019-03-05 16:55:28 -08002861 } else if (policyMix->mMixType == MIX_TYPE_PLAYERS) {
2862 address = policyMix->mDeviceAddress;
Eric Laurent8f42ea12018-08-08 09:08:25 -07002863 }
2864 if (address != "") {
2865 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
2866 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08002867 address, "remote-submix", AUDIO_FORMAT_DEFAULT);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002868 }
2869 }
Eric Laurent8f42ea12018-08-08 09:08:25 -07002870 resetInputDevice(input);
2871
2872 // indicate inactive capture to sound trigger service if stopping capture from a mic on
2873 // primary HW module
François Gaffie11d30102018-11-02 16:09:09 +01002874 DeviceVector primaryInputDevices = availablePrimaryModuleInputDevices();
2875 if (primaryInputDevices.contains(inputDesc->getDevice()) &&
Eric Laurent8f42ea12018-08-08 09:08:25 -07002876 mInputs.activeInputsCountOnDevices(primaryInputDevices) == 0) {
Ytai Ben-Tsvi74cd6b02019-10-25 10:06:40 -07002877 mpClientInterface->setSoundTriggerCaptureState(false);
Eric Laurent8f42ea12018-08-08 09:08:25 -07002878 }
2879 inputDesc->clearPreemptedSessions();
Eric Laurente552edb2014-03-10 17:42:56 -07002880 }
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002881 return NO_ERROR;
Eric Laurente552edb2014-03-10 17:42:56 -07002882}
2883
Eric Laurent8fc147b2018-07-22 19:13:55 -07002884void AudioPolicyManager::releaseInput(audio_port_handle_t portId)
Eric Laurente552edb2014-03-10 17:42:56 -07002885{
Eric Laurent8fc147b2018-07-22 19:13:55 -07002886 ALOGV("%s portId %d", __FUNCTION__, portId);
2887
2888 sp<AudioInputDescriptor> inputDesc = mInputs.getInputForClient(portId);
2889 if (inputDesc == 0) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002890 ALOGW("%s no input for client %d", __FUNCTION__, portId);
Eric Laurente552edb2014-03-10 17:42:56 -07002891 return;
2892 }
Andy Hung39efb7a2018-09-26 15:39:28 -07002893 sp<RecordClientDescriptor> client = inputDesc->getClient(portId);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002894 audio_io_handle_t input = inputDesc->mIoHandle;
2895
Eric Laurent8f42ea12018-08-08 09:08:25 -07002896 ALOGV("%s %d", __FUNCTION__, input);
Paul McLean466dc8e2015-04-17 13:15:36 -06002897
Andy Hung39efb7a2018-09-26 15:39:28 -07002898 inputDesc->removeClient(portId);
Eric Laurent599c7582015-12-07 18:05:55 -08002899
Andy Hung39efb7a2018-09-26 15:39:28 -07002900 if (inputDesc->getClientCount() > 0) {
2901 ALOGV("%s(%d) %zu clients remaining", __func__, portId, inputDesc->getClientCount());
Glenn Kasten6a8ab052014-07-24 14:08:35 -07002902 return;
2903 }
2904
Eric Laurent05b90f82014-08-27 15:32:29 -07002905 closeInput(input);
Eric Laurentb52c1522014-05-20 11:27:36 -07002906 mpClientInterface->onAudioPortListUpdate();
Eric Laurent8f42ea12018-08-08 09:08:25 -07002907 ALOGV("%s exit", __FUNCTION__);
Eric Laurente552edb2014-03-10 17:42:56 -07002908}
2909
Eric Laurent8f42ea12018-08-08 09:08:25 -07002910void AudioPolicyManager::closeActiveClients(const sp<AudioInputDescriptor>& input)
Eric Laurent8fc147b2018-07-22 19:13:55 -07002911{
Eric Laurent8f42ea12018-08-08 09:08:25 -07002912 RecordClientVector clients = input->clientsList(true);
Eric Laurent8fc147b2018-07-22 19:13:55 -07002913
2914 for (const auto& client : clients) {
Eric Laurent8f42ea12018-08-08 09:08:25 -07002915 closeClient(client->portId());
Eric Laurent8fc147b2018-07-22 19:13:55 -07002916 }
2917}
2918
Eric Laurent8f42ea12018-08-08 09:08:25 -07002919void AudioPolicyManager::closeClient(audio_port_handle_t portId)
2920{
2921 stopInput(portId);
2922 releaseInput(portId);
2923}
Eric Laurent8fc147b2018-07-22 19:13:55 -07002924
Eric Laurent0dd51852019-04-19 18:18:58 -07002925void AudioPolicyManager::checkCloseInputs() {
2926 // After connecting or disconnecting an input device, close input if:
2927 // - it has no client (was just opened to check profile) OR
2928 // - none of its supported devices are connected anymore OR
2929 // - one of its clients cannot be routed to one of its supported
2930 // devices anymore. Otherwise update device selection
2931 std::vector<audio_io_handle_t> inputsToClose;
2932 for (size_t i = 0; i < mInputs.size(); i++) {
2933 const sp<AudioInputDescriptor> input = mInputs.valueAt(i);
2934 if (input->clientsList().size() == 0
Eric Laurent85732f42020-03-19 11:31:10 -07002935 || !mAvailableInputDevices.containsAtLeastOne(input->supportedDevices())) {
Eric Laurent0dd51852019-04-19 18:18:58 -07002936 inputsToClose.push_back(mInputs.keyAt(i));
2937 } else {
2938 bool close = false;
2939 for (const auto& client : input->clientsList()) {
2940 sp<DeviceDescriptor> device =
yuanjiahsu0735bf32021-03-18 08:12:54 +08002941 mEngine->getInputDeviceForAttributes(client->attributes(), client->uid());
Eric Laurent0dd51852019-04-19 18:18:58 -07002942 if (!input->supportedDevices().contains(device)) {
2943 close = true;
2944 break;
2945 }
2946 }
2947 if (close) {
2948 inputsToClose.push_back(mInputs.keyAt(i));
2949 } else {
2950 setInputDevice(input->mIoHandle, getNewInputDevice(input));
2951 }
2952 }
2953 }
2954
2955 for (const audio_io_handle_t handle : inputsToClose) {
2956 ALOGV("%s closing input %d", __func__, handle);
2957 closeInput(handle);
Eric Laurent05b90f82014-08-27 15:32:29 -07002958 }
Eric Laurentd4692962014-05-05 18:13:44 -07002959}
2960
François Gaffie251c7f02018-11-07 10:41:08 +01002961void AudioPolicyManager::initStreamVolume(audio_stream_type_t stream, int indexMin, int indexMax)
Eric Laurente552edb2014-03-10 17:42:56 -07002962{
2963 ALOGV("initStreamVolume() stream %d, min %d, max %d", stream , indexMin, indexMax);
Revathi Uddarajufe0fb8b2017-07-27 17:05:37 +08002964 if (indexMin < 0 || indexMax < 0) {
2965 ALOGE("%s for stream %d: invalid min %d or max %d", __func__, stream , indexMin, indexMax);
2966 return;
2967 }
Eric Laurentf5aa58d2019-02-22 18:20:11 -08002968 getVolumeCurves(stream).initVolume(indexMin, indexMax);
Eric Laurent28d09f02016-03-08 10:43:05 -08002969
2970 // initialize other private stream volumes which follow this one
Eric Laurent794fde22016-03-11 09:50:45 -08002971 for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) {
2972 if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
Eric Laurent28d09f02016-03-08 10:43:05 -08002973 continue;
2974 }
Eric Laurentf5aa58d2019-02-22 18:20:11 -08002975 getVolumeCurves((audio_stream_type_t)curStream).initVolume(indexMin, indexMax);
Eric Laurent223fd5c2014-11-11 13:43:36 -08002976 }
Eric Laurente552edb2014-03-10 17:42:56 -07002977}
2978
Eric Laurente0720872014-03-11 09:30:41 -07002979status_t AudioPolicyManager::setStreamVolumeIndex(audio_stream_type_t stream,
François Gaffie53615e22015-03-19 09:24:12 +01002980 int index,
2981 audio_devices_t device)
Eric Laurente552edb2014-03-10 17:42:56 -07002982{
François Gaffieaaac0fd2018-11-22 17:56:39 +01002983 auto attributes = mEngine->getAttributesForStreamType(stream);
Eric Laurent242a9f82020-03-23 15:57:04 -07002984 if (attributes == AUDIO_ATTRIBUTES_INITIALIZER) {
2985 ALOGW("%s: no group for stream %s, bailing out", __func__, toString(stream).c_str());
2986 return NO_ERROR;
2987 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01002988 ALOGV("%s: stream %s attributes=%s", __func__,
2989 toString(stream).c_str(), toString(attributes).c_str());
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01002990 return setVolumeIndexForAttributes(attributes, index, device);
Eric Laurente552edb2014-03-10 17:42:56 -07002991}
2992
Eric Laurente0720872014-03-11 09:30:41 -07002993status_t AudioPolicyManager::getStreamVolumeIndex(audio_stream_type_t stream,
François Gaffieaaac0fd2018-11-22 17:56:39 +01002994 int *index,
2995 audio_devices_t device)
Eric Laurente552edb2014-03-10 17:42:56 -07002996{
François Gaffiec005e562018-11-06 15:04:49 +01002997 // if device is AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME, return volume for device selected for this
2998 // stream by the engine.
jiabin9a3361e2019-10-01 09:38:30 -07002999 DeviceTypeSet deviceTypes = {device};
Eric Laurent5a2b6292016-04-14 18:05:57 -07003000 if (device == AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
jiabin9a3361e2019-10-01 09:38:30 -07003001 deviceTypes = mEngine->getOutputDevicesForStream(
3002 stream, true /*fromCache*/).types();
Eric Laurente552edb2014-03-10 17:42:56 -07003003 }
jiabin9a3361e2019-10-01 09:38:30 -07003004 return getVolumeIndex(getVolumeCurves(stream), *index, deviceTypes);
Eric Laurente552edb2014-03-10 17:42:56 -07003005}
3006
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01003007status_t AudioPolicyManager::setVolumeIndexForAttributes(const audio_attributes_t &attributes,
François Gaffiecfe17322018-11-07 13:41:29 +01003008 int index,
3009 audio_devices_t device)
3010{
3011 // Get Volume group matching the Audio Attributes
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01003012 auto group = mEngine->getVolumeGroupForAttributes(attributes);
3013 if (group == VOLUME_GROUP_NONE) {
3014 ALOGD("%s: no group matching with %s", __FUNCTION__, toString(attributes).c_str());
François Gaffiecfe17322018-11-07 13:41:29 +01003015 return BAD_VALUE;
3016 }
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01003017 ALOGV("%s: group %d matching with %s", __FUNCTION__, group, toString(attributes).c_str());
François Gaffiecfe17322018-11-07 13:41:29 +01003018 status_t status = NO_ERROR;
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01003019 IVolumeCurves &curves = getVolumeCurves(attributes);
François Gaffieaaac0fd2018-11-22 17:56:39 +01003020 VolumeSource vs = toVolumeSource(group);
Eric Laurentf9cccec2022-11-16 19:12:00 +01003021 // AUDIO_STREAM_BLUETOOTH_SCO is only used for volume control so we remap
3022 // to AUDIO_STREAM_VOICE_CALL to match with relevant playback activity
3023 VolumeSource activityVs = (vs == toVolumeSource(AUDIO_STREAM_BLUETOOTH_SCO, false)) ?
3024 toVolumeSource(AUDIO_STREAM_VOICE_CALL, false) : vs;
François Gaffieaaac0fd2018-11-22 17:56:39 +01003025 product_strategy_t strategy = mEngine->getProductStrategyForAttributes(attributes);
3026
3027 status = setVolumeCurveIndex(index, device, curves);
3028 if (status != NO_ERROR) {
3029 ALOGE("%s failed to set curve index for group %d device 0x%X", __func__, group, device);
3030 return status;
3031 }
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01003032
jiabin9a3361e2019-10-01 09:38:30 -07003033 DeviceTypeSet curSrcDevices;
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01003034 auto curCurvAttrs = curves.getAttributes();
3035 if (!curCurvAttrs.empty() && curCurvAttrs.front() != defaultAttr) {
3036 auto attr = curCurvAttrs.front();
jiabin9a3361e2019-10-01 09:38:30 -07003037 curSrcDevices = mEngine->getOutputDevicesForAttributes(attr, nullptr, false).types();
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01003038 } else if (!curves.getStreamTypes().empty()) {
3039 auto stream = curves.getStreamTypes().front();
jiabin9a3361e2019-10-01 09:38:30 -07003040 curSrcDevices = mEngine->getOutputDevicesForStream(stream, false).types();
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01003041 } else {
3042 ALOGE("%s: Invalid src %d: no valid attributes nor stream",__func__, vs);
3043 return BAD_VALUE;
3044 }
jiabin9a3361e2019-10-01 09:38:30 -07003045 audio_devices_t curSrcDevice = Volume::getDeviceForVolume(curSrcDevices);
3046 resetDeviceTypes(curSrcDevices, curSrcDevice);
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01003047
François Gaffiecfe17322018-11-07 13:41:29 +01003048 // update volume on all outputs and streams matching the following:
3049 // - The requested stream (or a stream matching for volume control) is active on the output
3050 // - The device (or devices) selected by the engine for this stream includes
3051 // the requested device
3052 // - For non default requested device, currently selected device on the output is either the
3053 // requested device or one of the devices selected by the engine for this stream
3054 // - For default requested device (AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME), apply volume only if
3055 // no specific device volume value exists for currently selected device.
François Gaffieaaac0fd2018-11-22 17:56:39 +01003056 for (size_t i = 0; i < mOutputs.size(); i++) {
3057 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
jiabin9a3361e2019-10-01 09:38:30 -07003058 DeviceTypeSet curDevices = desc->devices().types();
François Gaffieaaac0fd2018-11-22 17:56:39 +01003059
jiabin9a3361e2019-10-01 09:38:30 -07003060 if (curDevices.erase(AUDIO_DEVICE_OUT_SPEAKER_SAFE)) {
3061 curDevices.insert(AUDIO_DEVICE_OUT_SPEAKER);
Robert Lee5e66e792019-04-03 18:37:15 +08003062 }
Eric Laurentf9cccec2022-11-16 19:12:00 +01003063
3064 if (!(desc->isActive(activityVs) || isInCallOrScreening())) {
François Gaffieed91f582020-01-31 10:35:37 +01003065 continue;
3066 }
3067 if (device != AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME &&
3068 curDevices.find(device) == curDevices.end()) {
3069 continue;
3070 }
3071 bool applyVolume = false;
3072 if (device != AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
3073 curSrcDevices.insert(device);
3074 applyVolume = (curSrcDevices.find(
3075 Volume::getDeviceForVolume(curDevices)) != curSrcDevices.end());
3076 } else {
3077 applyVolume = !curves.hasVolumeIndexForDevice(curSrcDevice);
3078 }
3079 if (!applyVolume) {
3080 continue; // next output
3081 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01003082 // Inter / intra volume group priority management: Loop on strategies arranged by priority
3083 // If a higher priority strategy is active, and the output is routed to a device with a
3084 // HW Gain management, do not change the volume
François Gaffieaaac0fd2018-11-22 17:56:39 +01003085 if (desc->useHwGain()) {
François Gaffieed91f582020-01-31 10:35:37 +01003086 applyVolume = false;
Francois Gaffie593634d2021-06-22 13:31:31 +02003087 // If the volume source is active with higher priority source, ensure at least Sw Muted
3088 desc->setSwMute((index == 0), vs, curves.getStreamTypes(), curDevices, 0 /*delayMs*/);
François Gaffieaaac0fd2018-11-22 17:56:39 +01003089 for (const auto &productStrategy : mEngine->getOrderedProductStrategies()) {
3090 auto activeClients = desc->clientsList(true /*activeOnly*/, productStrategy,
3091 false /*preferredDevice*/);
3092 if (activeClients.empty()) {
3093 continue;
3094 }
3095 bool isPreempted = false;
3096 bool isHigherPriority = productStrategy < strategy;
3097 for (const auto &client : activeClients) {
Eric Laurentf9cccec2022-11-16 19:12:00 +01003098 if (isHigherPriority && (client->volumeSource() != activityVs)) {
François Gaffieaaac0fd2018-11-22 17:56:39 +01003099 ALOGV("%s: Strategy=%d (\nrequester:\n"
3100 " group %d, volumeGroup=%d attributes=%s)\n"
3101 " higher priority source active:\n"
3102 " volumeGroup=%d attributes=%s) \n"
3103 " on output %zu, bailing out", __func__, productStrategy,
3104 group, group, toString(attributes).c_str(),
3105 client->volumeSource(), toString(client->attributes()).c_str(), i);
3106 applyVolume = false;
3107 isPreempted = true;
3108 break;
3109 }
3110 // However, continue for loop to ensure no higher prio clients running on output
Eric Laurentf9cccec2022-11-16 19:12:00 +01003111 if (client->volumeSource() == activityVs) {
François Gaffieaaac0fd2018-11-22 17:56:39 +01003112 applyVolume = true;
3113 }
3114 }
3115 if (isPreempted || applyVolume) {
3116 break;
3117 }
3118 }
3119 if (!applyVolume) {
3120 continue; // next output
3121 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01003122 }
François Gaffieed91f582020-01-31 10:35:37 +01003123 //FIXME: workaround for truncated touch sounds
3124 // delayed volume change for system stream to be removed when the problem is
3125 // handled by system UI
3126 status_t volStatus = checkAndSetVolume(
3127 curves, vs, index, desc, curDevices,
Francois Gaffie4404ddb2021-02-04 17:03:38 +01003128 ((vs == toVolumeSource(AUDIO_STREAM_SYSTEM, false))?
François Gaffieed91f582020-01-31 10:35:37 +01003129 TOUCH_SOUND_FIXED_DELAY_MS : 0));
3130 if (volStatus != NO_ERROR) {
3131 status = volStatus;
François Gaffieaaac0fd2018-11-22 17:56:39 +01003132 }
3133 }
François Gaffiecfe17322018-11-07 13:41:29 +01003134 mpClientInterface->onAudioVolumeGroupChanged(group, 0 /*flags*/);
3135 return status;
3136}
3137
François Gaffieaaac0fd2018-11-22 17:56:39 +01003138status_t AudioPolicyManager::setVolumeCurveIndex(int index,
François Gaffiecfe17322018-11-07 13:41:29 +01003139 audio_devices_t device,
3140 IVolumeCurves &volumeCurves)
3141{
3142 // VOICE_CALL stream has minVolumeIndex > 0 but can be muted directly by an
3143 // app that has MODIFY_PHONE_STATE permission.
François Gaffieaaac0fd2018-11-22 17:56:39 +01003144 bool hasVoice = hasVoiceStream(volumeCurves.getStreamTypes());
3145 if (((index < volumeCurves.getVolumeIndexMin()) && !(hasVoice && index == 0)) ||
François Gaffiecfe17322018-11-07 13:41:29 +01003146 (index > volumeCurves.getVolumeIndexMax())) {
3147 ALOGD("%s: wrong index %d min=%d max=%d", __FUNCTION__, index,
3148 volumeCurves.getVolumeIndexMin(), volumeCurves.getVolumeIndexMax());
3149 return BAD_VALUE;
3150 }
3151 if (!audio_is_output_device(device)) {
3152 return BAD_VALUE;
3153 }
3154
3155 // Force max volume if stream cannot be muted
3156 if (!volumeCurves.canBeMuted()) index = volumeCurves.getVolumeIndexMax();
3157
François Gaffieaaac0fd2018-11-22 17:56:39 +01003158 ALOGV("%s device %08x, index %d", __FUNCTION__ , device, index);
François Gaffiecfe17322018-11-07 13:41:29 +01003159 volumeCurves.addCurrentVolumeIndex(device, index);
3160 return NO_ERROR;
3161}
3162
3163status_t AudioPolicyManager::getVolumeIndexForAttributes(const audio_attributes_t &attr,
3164 int &index,
3165 audio_devices_t device)
3166{
3167 // if device is AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME, return volume for device selected for this
3168 // stream by the engine.
jiabin9a3361e2019-10-01 09:38:30 -07003169 DeviceTypeSet deviceTypes = {device};
François Gaffiecfe17322018-11-07 13:41:29 +01003170 if (device == AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
jiabin9a3361e2019-10-01 09:38:30 -07003171 DeviceTypeSet deviceTypes = mEngine->getOutputDevicesForAttributes(
3172 attr, nullptr, true /*fromCache*/).types();
François Gaffiecfe17322018-11-07 13:41:29 +01003173 }
jiabin9a3361e2019-10-01 09:38:30 -07003174 return getVolumeIndex(getVolumeCurves(attr), index, deviceTypes);
François Gaffiecfe17322018-11-07 13:41:29 +01003175}
3176
3177status_t AudioPolicyManager::getVolumeIndex(const IVolumeCurves &curves,
3178 int &index,
jiabin9a3361e2019-10-01 09:38:30 -07003179 const DeviceTypeSet& deviceTypes) const
François Gaffiecfe17322018-11-07 13:41:29 +01003180{
jiabin9a3361e2019-10-01 09:38:30 -07003181 if (isSingleDeviceType(deviceTypes, audio_is_output_device)) {
François Gaffiecfe17322018-11-07 13:41:29 +01003182 return BAD_VALUE;
3183 }
jiabin9a3361e2019-10-01 09:38:30 -07003184 index = curves.getVolumeIndex(deviceTypes);
3185 ALOGV("%s: device %s index %d", __FUNCTION__, dumpDeviceTypes(deviceTypes).c_str(), index);
François Gaffiecfe17322018-11-07 13:41:29 +01003186 return NO_ERROR;
3187}
3188
3189status_t AudioPolicyManager::getMinVolumeIndexForAttributes(const audio_attributes_t &attr,
3190 int &index)
3191{
3192 index = getVolumeCurves(attr).getVolumeIndexMin();
3193 return NO_ERROR;
3194}
3195
3196status_t AudioPolicyManager::getMaxVolumeIndexForAttributes(const audio_attributes_t &attr,
3197 int &index)
3198{
3199 index = getVolumeCurves(attr).getVolumeIndexMax();
3200 return NO_ERROR;
3201}
3202
Eric Laurent36829f92017-04-07 19:04:42 -07003203audio_io_handle_t AudioPolicyManager::selectOutputForMusicEffects()
Eric Laurente552edb2014-03-10 17:42:56 -07003204{
3205 // select one output among several suitable for global effects.
3206 // The priority is as follows:
3207 // 1: An offloaded output. If the effect ends up not being offloadable,
3208 // AudioFlinger will invalidate the track and the offloaded output
3209 // will be closed causing the effect to be moved to a PCM output.
3210 // 2: A deep buffer output
Eric Laurent36829f92017-04-07 19:04:42 -07003211 // 3: The primary output
3212 // 4: the first output in the list
Eric Laurente552edb2014-03-10 17:42:56 -07003213
François Gaffiec005e562018-11-06 15:04:49 +01003214 DeviceVector devices = mEngine->getOutputDevicesForAttributes(
3215 attributes_initializer(AUDIO_USAGE_MEDIA), nullptr, false /*fromCache*/);
François Gaffie11d30102018-11-02 16:09:09 +01003216 SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
Eric Laurente552edb2014-03-10 17:42:56 -07003217
Eric Laurent36829f92017-04-07 19:04:42 -07003218 if (outputs.size() == 0) {
3219 return AUDIO_IO_HANDLE_NONE;
3220 }
Eric Laurente552edb2014-03-10 17:42:56 -07003221
Eric Laurent36829f92017-04-07 19:04:42 -07003222 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
3223 bool activeOnly = true;
3224
3225 while (output == AUDIO_IO_HANDLE_NONE) {
3226 audio_io_handle_t outputOffloaded = AUDIO_IO_HANDLE_NONE;
3227 audio_io_handle_t outputDeepBuffer = AUDIO_IO_HANDLE_NONE;
3228 audio_io_handle_t outputPrimary = AUDIO_IO_HANDLE_NONE;
3229
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003230 for (audio_io_handle_t output : outputs) {
3231 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
Eric Laurent83d17c22019-04-02 17:10:01 -07003232 if (activeOnly && !desc->isActive(toVolumeSource(AUDIO_STREAM_MUSIC))) {
Eric Laurent36829f92017-04-07 19:04:42 -07003233 continue;
3234 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003235 ALOGV("selectOutputForMusicEffects activeOnly %d output %d flags 0x%08x",
3236 activeOnly, output, desc->mFlags);
Eric Laurent36829f92017-04-07 19:04:42 -07003237 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003238 outputOffloaded = output;
Eric Laurent36829f92017-04-07 19:04:42 -07003239 }
3240 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) != 0) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003241 outputDeepBuffer = output;
Eric Laurent36829f92017-04-07 19:04:42 -07003242 }
3243 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY) != 0) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003244 outputPrimary = output;
Eric Laurent36829f92017-04-07 19:04:42 -07003245 }
3246 }
3247 if (outputOffloaded != AUDIO_IO_HANDLE_NONE) {
3248 output = outputOffloaded;
3249 } else if (outputDeepBuffer != AUDIO_IO_HANDLE_NONE) {
3250 output = outputDeepBuffer;
3251 } else if (outputPrimary != AUDIO_IO_HANDLE_NONE) {
3252 output = outputPrimary;
3253 } else {
3254 output = outputs[0];
3255 }
3256 activeOnly = false;
3257 }
3258
3259 if (output != mMusicEffectOutput) {
Eric Laurent6c796322019-04-09 14:13:17 -07003260 mEffects.moveEffects(AUDIO_SESSION_OUTPUT_MIX, mMusicEffectOutput, output);
Eric Laurent36829f92017-04-07 19:04:42 -07003261 mpClientInterface->moveEffects(AUDIO_SESSION_OUTPUT_MIX, mMusicEffectOutput, output);
3262 mMusicEffectOutput = output;
3263 }
3264
3265 ALOGV("selectOutputForMusicEffects selected output %d", output);
Eric Laurente552edb2014-03-10 17:42:56 -07003266 return output;
3267}
3268
Eric Laurent36829f92017-04-07 19:04:42 -07003269audio_io_handle_t AudioPolicyManager::getOutputForEffect(const effect_descriptor_t *desc __unused)
3270{
3271 return selectOutputForMusicEffects();
3272}
3273
Eric Laurente0720872014-03-11 09:30:41 -07003274status_t AudioPolicyManager::registerEffect(const effect_descriptor_t *desc,
Eric Laurente552edb2014-03-10 17:42:56 -07003275 audio_io_handle_t io,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08003276 product_strategy_t strategy,
Eric Laurente552edb2014-03-10 17:42:56 -07003277 int session,
3278 int id)
3279{
Eric Laurentb82e6b72019-11-22 17:25:04 -08003280 if (session != AUDIO_SESSION_DEVICE) {
3281 ssize_t index = mOutputs.indexOfKey(io);
Eric Laurente552edb2014-03-10 17:42:56 -07003282 if (index < 0) {
Eric Laurentb82e6b72019-11-22 17:25:04 -08003283 index = mInputs.indexOfKey(io);
3284 if (index < 0) {
3285 ALOGW("registerEffect() unknown io %d", io);
3286 return INVALID_OPERATION;
3287 }
Eric Laurente552edb2014-03-10 17:42:56 -07003288 }
3289 }
Eric Laurentbf8f69f2022-03-25 17:48:38 +01003290 bool isMusicEffect = (session != AUDIO_SESSION_OUTPUT_STAGE)
3291 && ((strategy == streamToStrategy(AUDIO_STREAM_MUSIC)
3292 || strategy == PRODUCT_STRATEGY_NONE));
3293 return mEffects.registerEffect(desc, io, session, id, isMusicEffect);
Eric Laurente552edb2014-03-10 17:42:56 -07003294}
3295
Eric Laurentc241b0d2018-11-28 09:08:49 -08003296status_t AudioPolicyManager::unregisterEffect(int id)
3297{
3298 if (mEffects.getEffect(id) == nullptr) {
3299 return INVALID_OPERATION;
3300 }
Eric Laurentc241b0d2018-11-28 09:08:49 -08003301 if (mEffects.isEffectEnabled(id)) {
3302 ALOGW("%s effect %d enabled", __FUNCTION__, id);
3303 setEffectEnabled(id, false);
3304 }
3305 return mEffects.unregisterEffect(id);
3306}
3307
3308status_t AudioPolicyManager::setEffectEnabled(int id, bool enabled)
3309{
3310 sp<EffectDescriptor> effect = mEffects.getEffect(id);
3311 if (effect == nullptr) {
3312 return INVALID_OPERATION;
3313 }
3314
3315 status_t status = mEffects.setEffectEnabled(id, enabled);
3316 if (status == NO_ERROR) {
3317 mInputs.trackEffectEnabled(effect, enabled);
3318 }
3319 return status;
3320}
3321
Eric Laurent6c796322019-04-09 14:13:17 -07003322
3323status_t AudioPolicyManager::moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io)
3324{
3325 mEffects.moveEffects(ids, io);
3326 return NO_ERROR;
3327}
3328
Eric Laurentc75307b2015-03-17 15:29:32 -07003329bool AudioPolicyManager::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
3330{
Francois Gaffie4404ddb2021-02-04 17:03:38 +01003331 auto vs = toVolumeSource(stream, false);
3332 return vs != VOLUME_SOURCE_NONE ? mOutputs.isActive(vs, inPastMs) : false;
Eric Laurentc75307b2015-03-17 15:29:32 -07003333}
3334
3335bool AudioPolicyManager::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
3336{
Francois Gaffie4404ddb2021-02-04 17:03:38 +01003337 auto vs = toVolumeSource(stream, false);
3338 return vs != VOLUME_SOURCE_NONE ? mOutputs.isActiveRemotely(vs, inPastMs) : false;
Eric Laurentc75307b2015-03-17 15:29:32 -07003339}
3340
Eric Laurente0720872014-03-11 09:30:41 -07003341bool AudioPolicyManager::isSourceActive(audio_source_t source) const
Eric Laurente552edb2014-03-10 17:42:56 -07003342{
3343 for (size_t i = 0; i < mInputs.size(); i++) {
Eric Laurent1f2f2232014-06-02 12:01:23 -07003344 const sp<AudioInputDescriptor> inputDescriptor = mInputs.valueAt(i);
Eric Laurent599c7582015-12-07 18:05:55 -08003345 if (inputDescriptor->isSourceActive(source)) {
Eric Laurente552edb2014-03-10 17:42:56 -07003346 return true;
3347 }
3348 }
3349 return false;
3350}
3351
Eric Laurent275e8e92014-11-30 15:14:47 -08003352// Register a list of custom mixes with their attributes and format.
3353// When a mix is registered, corresponding input and output profiles are
3354// added to the remote submix hw module. The profile contains only the
3355// parameters (sampling rate, format...) specified by the mix.
3356// The corresponding input remote submix device is also connected.
3357//
3358// When a remote submix device is connected, the address is checked to select the
3359// appropriate profile and the corresponding input or output stream is opened.
3360//
3361// When capture starts, getInputForAttr() will:
3362// - 1 look for a mix matching the address passed in attribtutes tags if any
3363// - 2 if none found, getDeviceForInputSource() will:
3364// - 2.1 look for a mix matching the attributes source
3365// - 2.2 if none found, default to device selection by policy rules
3366// At this time, the corresponding output remote submix device is also connected
3367// and active playback use cases can be transferred to this mix if needed when reconnecting
3368// after AudioTracks are invalidated
3369//
3370// When playback starts, getOutputForAttr() will:
3371// - 1 look for a mix matching the address passed in attribtutes tags if any
3372// - 2 if none found, look for a mix matching the attributes usage
3373// - 3 if none found, default to device and output selection by policy rules.
3374
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07003375status_t AudioPolicyManager::registerPolicyMixes(const Vector<AudioMix>& mixes)
Eric Laurent275e8e92014-11-30 15:14:47 -08003376{
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003377 ALOGV("registerPolicyMixes() %zu mix(es)", mixes.size());
3378 status_t res = NO_ERROR;
Eric Laurentc209fe42020-06-05 18:11:23 -07003379 bool checkOutputs = false;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003380 sp<HwModule> rSubmixModule;
3381 // examine each mix's route type
3382 for (size_t i = 0; i < mixes.size(); i++) {
Eric Laurent97ac8712018-07-27 18:59:02 -07003383 AudioMix mix = mixes[i];
Kevin Rocard153f92d2018-12-18 18:33:28 -08003384 // Only capture of playback is allowed in LOOP_BACK & RENDER mode
3385 if (is_mix_loopback_render(mix.mRouteFlags) && mix.mMixType != MIX_TYPE_PLAYERS) {
3386 ALOGE("Unsupported Policy Mix %zu of %zu: "
3387 "Only capture of playback is allowed in LOOP_BACK & RENDER mode",
3388 i, mixes.size());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003389 res = INVALID_OPERATION;
Eric Laurent275e8e92014-11-30 15:14:47 -08003390 break;
3391 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08003392 // LOOP_BACK and LOOP_BACK | RENDER have the same remote submix backend and are handled
3393 // in the same way.
Eric Laurent97ac8712018-07-27 18:59:02 -07003394 if ((mix.mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08003395 ALOGV("registerPolicyMixes() mix %zu of %zu is LOOP_BACK %d", i, mixes.size(),
3396 mix.mRouteFlags);
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003397 if (rSubmixModule == 0) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08003398 rSubmixModule = mHwModules.getModuleFromName(
3399 AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX);
3400 if (rSubmixModule == 0) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08003401 ALOGE("Unable to find audio module for submix, aborting mix %zu registration",
Mikhail Naganovd4120142017-12-06 15:49:22 -08003402 i);
3403 res = INVALID_OPERATION;
3404 break;
3405 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003406 }
Eric Laurent275e8e92014-11-30 15:14:47 -08003407
Eric Laurent97ac8712018-07-27 18:59:02 -07003408 String8 address = mix.mDeviceAddress;
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003409 audio_devices_t deviceTypeToMakeAvailable;
Eric Laurent97ac8712018-07-27 18:59:02 -07003410 if (mix.mMixType == MIX_TYPE_PLAYERS) {
Eric Laurent97ac8712018-07-27 18:59:02 -07003411 mix.mDeviceType = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003412 deviceTypeToMakeAvailable = AUDIO_DEVICE_IN_REMOTE_SUBMIX;
3413 } else {
3414 mix.mDeviceType = AUDIO_DEVICE_IN_REMOTE_SUBMIX;
3415 deviceTypeToMakeAvailable = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
Eric Laurent97ac8712018-07-27 18:59:02 -07003416 }
François Gaffie036e1e92015-03-19 10:16:24 +01003417
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003418 if (mPolicyMixes.registerMix(mix, 0 /*output desc*/) != NO_ERROR) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08003419 ALOGE("Error registering mix %zu for address %s", i, address.string());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003420 res = INVALID_OPERATION;
3421 break;
3422 }
Eric Laurent97ac8712018-07-27 18:59:02 -07003423 audio_config_t outputConfig = mix.mFormat;
3424 audio_config_t inputConfig = mix.mFormat;
Eric Laurentc529cf62020-04-17 18:19:10 -07003425 // NOTE: audio flinger mixer does not support mono output: configure remote submix HAL
3426 // in stereo and let audio flinger do the channel conversion if needed.
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003427 outputConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
3428 inputConfig.channel_mask = AUDIO_CHANNEL_IN_STEREO;
jiabin5740f082019-08-19 15:08:30 -07003429 rSubmixModule->addOutputProfile(address.c_str(), &outputConfig,
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003430 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, address);
jiabin5740f082019-08-19 15:08:30 -07003431 rSubmixModule->addInputProfile(address.c_str(), &inputConfig,
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003432 AUDIO_DEVICE_IN_REMOTE_SUBMIX, address);
François Gaffie036e1e92015-03-19 10:16:24 +01003433
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003434 if ((res = setDeviceConnectionStateInt(deviceTypeToMakeAvailable,
jiabinc1de2df2019-05-07 14:26:40 -07003435 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
3436 address.string(), "remote-submix", AUDIO_FORMAT_DEFAULT)) != NO_ERROR) {
3437 ALOGE("Failed to set remote submix device available, type %u, address %s",
3438 mix.mDeviceType, address.string());
3439 break;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003440 }
Eric Laurent97ac8712018-07-27 18:59:02 -07003441 } else if ((mix.mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) {
3442 String8 address = mix.mDeviceAddress;
Eric Laurent2c80be02019-01-23 18:06:37 -08003443 audio_devices_t type = mix.mDeviceType;
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07003444 ALOGV(" registerPolicyMixes() mix %zu of %zu is RENDER, dev=0x%X addr=%s",
Eric Laurent2c80be02019-01-23 18:06:37 -08003445 i, mixes.size(), type, address.string());
3446
3447 sp<DeviceDescriptor> device = mHwModules.getDeviceDescriptor(
3448 mix.mDeviceType, mix.mDeviceAddress,
3449 String8(), AUDIO_FORMAT_DEFAULT);
3450 if (device == nullptr) {
3451 res = INVALID_OPERATION;
3452 break;
3453 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003454
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07003455 bool foundOutput = false;
Eric Laurentc529cf62020-04-17 18:19:10 -07003456 // First try to find an already opened output supporting the device
3457 for (size_t j = 0 ; j < mOutputs.size() && !foundOutput && res == NO_ERROR; j++) {
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003458 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(j);
Eric Laurent2c80be02019-01-23 18:06:37 -08003459
Eric Laurentc529cf62020-04-17 18:19:10 -07003460 if (!desc->isDuplicated() && desc->supportedDevices().contains(device)) {
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003461 if (mPolicyMixes.registerMix(mix, desc) != NO_ERROR) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08003462 ALOGE("Could not register mix RENDER, dev=0x%X addr=%s", type,
3463 address.string());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003464 res = INVALID_OPERATION;
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07003465 } else {
3466 foundOutput = true;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003467 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003468 }
3469 }
Eric Laurentc529cf62020-04-17 18:19:10 -07003470 // If no output found, try to find a direct output profile supporting the device
3471 for (size_t i = 0; i < mHwModules.size() && !foundOutput && res == NO_ERROR; i++) {
3472 sp<HwModule> module = mHwModules[i];
3473 for (size_t j = 0;
3474 j < module->getOutputProfiles().size() && !foundOutput && res == NO_ERROR;
3475 j++) {
3476 sp<IOProfile> profile = module->getOutputProfiles()[j];
3477 if (profile->isDirectOutput() && profile->supportsDevice(device)) {
3478 if (mPolicyMixes.registerMix(mix, nullptr) != NO_ERROR) {
3479 ALOGE("Could not register mix RENDER, dev=0x%X addr=%s", type,
3480 address.string());
3481 res = INVALID_OPERATION;
3482 } else {
3483 foundOutput = true;
3484 }
3485 }
3486 }
3487 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003488 if (res != NO_ERROR) {
3489 ALOGE(" Error registering mix %zu for device 0x%X addr %s",
Eric Laurent2c80be02019-01-23 18:06:37 -08003490 i, type, address.string());
Jean-Michel Trivi5ac8cd42016-03-24 16:35:36 -07003491 res = INVALID_OPERATION;
3492 break;
3493 } else if (!foundOutput) {
3494 ALOGE(" Output not found for mix %zu for device 0x%X addr %s",
Eric Laurent2c80be02019-01-23 18:06:37 -08003495 i, type, address.string());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003496 res = INVALID_OPERATION;
3497 break;
Eric Laurentc209fe42020-06-05 18:11:23 -07003498 } else {
3499 checkOutputs = true;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003500 }
Eric Laurentc722f302014-12-10 11:21:49 -08003501 }
Eric Laurent275e8e92014-11-30 15:14:47 -08003502 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003503 if (res != NO_ERROR) {
3504 unregisterPolicyMixes(mixes);
Eric Laurentc209fe42020-06-05 18:11:23 -07003505 } else if (checkOutputs) {
3506 checkForDeviceAndOutputChanges();
3507 updateCallAndOutputRouting();
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003508 }
3509 return res;
Eric Laurent275e8e92014-11-30 15:14:47 -08003510}
3511
3512status_t AudioPolicyManager::unregisterPolicyMixes(Vector<AudioMix> mixes)
3513{
Eric Laurent7b279bb2015-12-14 10:18:23 -08003514 ALOGV("unregisterPolicyMixes() num mixes %zu", mixes.size());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003515 status_t res = NO_ERROR;
Eric Laurentc209fe42020-06-05 18:11:23 -07003516 bool checkOutputs = false;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003517 sp<HwModule> rSubmixModule;
3518 // examine each mix's route type
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003519 for (const auto& mix : mixes) {
3520 if ((mix.mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) {
François Gaffie036e1e92015-03-19 10:16:24 +01003521
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003522 if (rSubmixModule == 0) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08003523 rSubmixModule = mHwModules.getModuleFromName(
3524 AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX);
3525 if (rSubmixModule == 0) {
3526 res = INVALID_OPERATION;
3527 continue;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003528 }
3529 }
Eric Laurent275e8e92014-11-30 15:14:47 -08003530
Mikhail Naganovcf84e592017-12-07 11:25:11 -08003531 String8 address = mix.mDeviceAddress;
Eric Laurent275e8e92014-11-30 15:14:47 -08003532
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003533 if (mPolicyMixes.unregisterMix(mix) != NO_ERROR) {
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003534 res = INVALID_OPERATION;
3535 continue;
3536 }
3537
Kevin Rocard04ed0462019-05-02 17:53:24 -07003538 for (auto device : {AUDIO_DEVICE_IN_REMOTE_SUBMIX, AUDIO_DEVICE_OUT_REMOTE_SUBMIX}) {
3539 if (getDeviceConnectionState(device, address.string()) ==
3540 AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
3541 res = setDeviceConnectionStateInt(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
3542 address.string(), "remote-submix",
3543 AUDIO_FORMAT_DEFAULT);
3544 if (res != OK) {
3545 ALOGE("Error making RemoteSubmix device unavailable for mix "
3546 "with type %d, address %s", device, address.string());
3547 }
3548 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003549 }
jiabin5740f082019-08-19 15:08:30 -07003550 rSubmixModule->removeOutputProfile(address.c_str());
3551 rSubmixModule->removeInputProfile(address.c_str());
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003552
Kevin Rocard153f92d2018-12-18 18:33:28 -08003553 } else if ((mix.mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) {
Jean-Michel Trivi67917272019-05-22 11:54:37 -07003554 if (mPolicyMixes.unregisterMix(mix) != NO_ERROR) {
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003555 res = INVALID_OPERATION;
3556 continue;
Eric Laurentc209fe42020-06-05 18:11:23 -07003557 } else {
3558 checkOutputs = true;
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003559 }
Eric Laurent275e8e92014-11-30 15:14:47 -08003560 }
Eric Laurent275e8e92014-11-30 15:14:47 -08003561 }
Eric Laurentc209fe42020-06-05 18:11:23 -07003562 if (res == NO_ERROR && checkOutputs) {
3563 checkForDeviceAndOutputChanges();
3564 updateCallAndOutputRouting();
3565 }
Jean-Michel Trivi7638ca22016-03-04 17:42:44 -08003566 return res;
Eric Laurent275e8e92014-11-30 15:14:47 -08003567}
3568
Mikhail Naganov100f0122018-11-29 11:22:16 -08003569void AudioPolicyManager::dumpManualSurroundFormats(String8 *dst) const
3570{
3571 size_t i = 0;
3572 constexpr size_t audioFormatPrefixLen = sizeof("AUDIO_FORMAT_");
3573 for (const auto& fmt : mManualSurroundFormats) {
3574 if (i++ != 0) dst->append(", ");
3575 std::string sfmt;
3576 FormatConverter::toString(fmt, sfmt);
3577 dst->append(sfmt.size() >= audioFormatPrefixLen ?
3578 sfmt.c_str() + audioFormatPrefixLen - 1 : sfmt.c_str());
3579 }
3580}
3581
Eric Laurentc529cf62020-04-17 18:19:10 -07003582// Returns true if all devices types match the predicate and are supported by one HW module
3583bool AudioPolicyManager::areAllDevicesSupported(
jiabin6a02d532020-08-07 11:56:38 -07003584 const AudioDeviceTypeAddrVector& devices,
Eric Laurentc529cf62020-04-17 18:19:10 -07003585 std::function<bool(audio_devices_t)> predicate,
3586 const char *context) {
3587 for (size_t i = 0; i < devices.size(); i++) {
3588 sp<DeviceDescriptor> devDesc = mHwModules.getDeviceDescriptor(
jiabin0a488932020-08-07 17:32:40 -07003589 devices[i].mType, devices[i].getAddress(), String8(),
Eric Laurent0e26e3f2020-04-29 14:24:16 -07003590 AUDIO_FORMAT_DEFAULT, false /*allowToCreate*/, true /*matchAddress*/);
Eric Laurentc529cf62020-04-17 18:19:10 -07003591 if (devDesc == nullptr || (predicate != nullptr && !predicate(devices[i].mType))) {
Jiabin Huang3b98d322020-09-03 17:54:16 +00003592 ALOGE("%s: device type %#x address %s not supported or not match predicate",
jiabin0a488932020-08-07 17:32:40 -07003593 context, devices[i].mType, devices[i].getAddress());
Eric Laurentc529cf62020-04-17 18:19:10 -07003594 return false;
3595 }
3596 }
3597 return true;
3598}
3599
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003600status_t AudioPolicyManager::setUidDeviceAffinities(uid_t uid,
jiabin6a02d532020-08-07 11:56:38 -07003601 const AudioDeviceTypeAddrVector& devices) {
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003602 ALOGV("%s() uid=%d num devices %zu", __FUNCTION__, uid, devices.size());
Eric Laurentc529cf62020-04-17 18:19:10 -07003603 if (!areAllDevicesSupported(devices, audio_is_output_device, __func__)) {
3604 return BAD_VALUE;
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003605 }
3606 status_t res = mPolicyMixes.setUidDeviceAffinities(uid, devices);
Eric Laurentc529cf62020-04-17 18:19:10 -07003607 if (res != NO_ERROR) {
3608 ALOGE("%s() Could not set all device affinities for uid = %d", __FUNCTION__, uid);
3609 return res;
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003610 }
Eric Laurentc529cf62020-04-17 18:19:10 -07003611
3612 checkForDeviceAndOutputChanges();
3613 updateCallAndOutputRouting();
3614
3615 return NO_ERROR;
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003616}
3617
3618status_t AudioPolicyManager::removeUidDeviceAffinities(uid_t uid) {
3619 ALOGV("%s() uid=%d", __FUNCTION__, uid);
Oscar Azucena4b2a8212019-04-26 23:48:59 -07003620 status_t res = mPolicyMixes.removeUidDeviceAffinities(uid);
3621 if (res != NO_ERROR) {
Eric Laurentc529cf62020-04-17 18:19:10 -07003622 ALOGE("%s() Could not remove all device affinities for uid = %d",
Oscar Azucena4b2a8212019-04-26 23:48:59 -07003623 __FUNCTION__, uid);
3624 return INVALID_OPERATION;
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003625 }
3626
Eric Laurentc529cf62020-04-17 18:19:10 -07003627 checkForDeviceAndOutputChanges();
3628 updateCallAndOutputRouting();
3629
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08003630 return res;
3631}
3632
Eric Laurent2517af32020-11-25 15:31:27 +01003633
jiabin0a488932020-08-07 17:32:40 -07003634status_t AudioPolicyManager::setDevicesRoleForStrategy(product_strategy_t strategy,
3635 device_role_t role,
3636 const AudioDeviceTypeAddrVector &devices) {
3637 ALOGV("%s() strategy=%d role=%d %s", __func__, strategy, role,
3638 dumpAudioDeviceTypeAddrVector(devices).c_str());
Eric Laurentc529cf62020-04-17 18:19:10 -07003639
Eric Laurentc529cf62020-04-17 18:19:10 -07003640 if (!areAllDevicesSupported(devices, audio_is_output_device, __func__)) {
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003641 return BAD_VALUE;
3642 }
jiabin0a488932020-08-07 17:32:40 -07003643 status_t status = mEngine->setDevicesRoleForStrategy(strategy, role, devices);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003644 if (status != NO_ERROR) {
jiabin0a488932020-08-07 17:32:40 -07003645 ALOGW("Engine could not set preferred devices %s for strategy %d role %d",
3646 dumpAudioDeviceTypeAddrVector(devices).c_str(), strategy, role);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003647 return status;
3648 }
3649
3650 checkForDeviceAndOutputChanges();
Eric Laurent2517af32020-11-25 15:31:27 +01003651
3652 bool forceVolumeReeval = false;
3653 // FIXME: workaround for truncated touch sounds
3654 // to be removed when the problem is handled by system UI
3655 uint32_t delayMs = 0;
3656 if (strategy == mCommunnicationStrategy) {
3657 forceVolumeReeval = true;
3658 delayMs = TOUCH_SOUND_FIXED_DELAY_MS;
3659 updateInputRouting();
3660 }
3661 updateCallAndOutputRouting(forceVolumeReeval, delayMs);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003662
3663 return NO_ERROR;
3664}
3665
3666void AudioPolicyManager::updateCallAndOutputRouting(bool forceVolumeReeval, uint32_t delayMs)
3667{
3668 uint32_t waitMs = 0;
Eric Laurent96d1dda2022-03-14 17:14:19 +01003669 bool wasLeUnicastActive = isLeUnicastActive();
Francois Gaffie19fd6c52021-02-04 17:02:59 +01003670 if (updateCallRouting(true /*fromCache*/, delayMs, &waitMs) == NO_ERROR) {
Eric Laurentb36b4ac2020-08-21 12:50:41 -07003671 // Only apply special touch sound delay once
3672 delayMs = 0;
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003673 }
3674 for (size_t i = 0; i < mOutputs.size(); i++) {
3675 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
3676 DeviceVector newDevices = getNewOutputDevices(outputDesc, true /*fromCache*/);
Francois Gaffie601801d2021-06-22 13:27:39 +02003677 if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) ||
3678 (outputDesc != mPrimaryOutput && !isTelephonyRxOrTx(outputDesc))) {
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003679 // As done in setDeviceConnectionState, we could also fix default device issue by
3680 // preventing the force re-routing in case of default dev that distinguishes on address.
3681 // Let's give back to engine full device choice decision however.
Francois Gaffie601801d2021-06-22 13:27:39 +02003682 bool forceRouting = !newDevices.isEmpty();
3683 waitMs = setOutputDevices(outputDesc, newDevices, forceRouting, delayMs, nullptr,
3684 true /*requiresMuteCheck*/,
3685 !forceRouting /*requiresVolumeCheck*/);
Eric Laurentb36b4ac2020-08-21 12:50:41 -07003686 // Only apply special touch sound delay once
3687 delayMs = 0;
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003688 }
3689 if (forceVolumeReeval && !newDevices.isEmpty()) {
3690 applyStreamVolumes(outputDesc, newDevices.types(), waitMs, true);
3691 }
3692 }
Eric Laurent96d1dda2022-03-14 17:14:19 +01003693 checkLeBroadcastRoutes(wasLeUnicastActive, nullptr, delayMs);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003694}
3695
Eric Laurent2517af32020-11-25 15:31:27 +01003696void AudioPolicyManager::updateInputRouting() {
3697 for (const auto& activeDesc : mInputs.getActiveInputs()) {
Jaideep Sharma408349a2020-11-27 14:47:17 +05303698 // Skip for hotword recording as the input device switch
3699 // is handled within sound trigger HAL
3700 if (activeDesc->isSoundTrigger() && activeDesc->source() == AUDIO_SOURCE_HOTWORD) {
3701 continue;
3702 }
Eric Laurent2517af32020-11-25 15:31:27 +01003703 auto newDevice = getNewInputDevice(activeDesc);
3704 // Force new input selection if the new device can not be reached via current input
3705 if (activeDesc->mProfile->getSupportedDevices().contains(newDevice)) {
3706 setInputDevice(activeDesc->mIoHandle, newDevice);
3707 } else {
3708 closeInput(activeDesc->mIoHandle);
3709 }
3710 }
3711}
3712
jiabin0a488932020-08-07 17:32:40 -07003713status_t AudioPolicyManager::removeDevicesRoleForStrategy(product_strategy_t strategy,
3714 device_role_t role)
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003715{
Eric Laurentfecbceb2021-02-09 14:46:43 +01003716 ALOGV("%s() strategy=%d role=%d", __func__, strategy, role);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003717
jiabin0a488932020-08-07 17:32:40 -07003718 status_t status = mEngine->removeDevicesRoleForStrategy(strategy, role);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003719 if (status != NO_ERROR) {
Eric Laurent2517af32020-11-25 15:31:27 +01003720 ALOGV("Engine could not remove preferred device for strategy %d status %d",
3721 strategy, status);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003722 return status;
3723 }
3724
3725 checkForDeviceAndOutputChanges();
Eric Laurent2517af32020-11-25 15:31:27 +01003726
3727 bool forceVolumeReeval = false;
3728 // FIXME: workaround for truncated touch sounds
3729 // to be removed when the problem is handled by system UI
3730 uint32_t delayMs = 0;
3731 if (strategy == mCommunnicationStrategy) {
3732 forceVolumeReeval = true;
3733 delayMs = TOUCH_SOUND_FIXED_DELAY_MS;
3734 updateInputRouting();
3735 }
3736 updateCallAndOutputRouting(forceVolumeReeval, delayMs);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003737
3738 return NO_ERROR;
3739}
3740
jiabin0a488932020-08-07 17:32:40 -07003741status_t AudioPolicyManager::getDevicesForRoleAndStrategy(product_strategy_t strategy,
3742 device_role_t role,
3743 AudioDeviceTypeAddrVector &devices) {
3744 return mEngine->getDevicesForRoleAndStrategy(strategy, role, devices);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07003745}
3746
Jiabin Huang3b98d322020-09-03 17:54:16 +00003747status_t AudioPolicyManager::setDevicesRoleForCapturePreset(
3748 audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector &devices) {
3749 ALOGV("%s() audioSource=%d role=%d %s", __func__, audioSource, role,
3750 dumpAudioDeviceTypeAddrVector(devices).c_str());
3751
Mikhail Naganov55773032020-10-01 15:08:13 -07003752 if (!areAllDevicesSupported(devices, audio_call_is_input_device, __func__)) {
Jiabin Huang3b98d322020-09-03 17:54:16 +00003753 return BAD_VALUE;
3754 }
3755 status_t status = mEngine->setDevicesRoleForCapturePreset(audioSource, role, devices);
3756 ALOGW_IF(status != NO_ERROR,
3757 "Engine could not set preferred devices %s for audio source %d role %d",
3758 dumpAudioDeviceTypeAddrVector(devices).c_str(), audioSource, role);
3759
3760 return status;
3761}
3762
3763status_t AudioPolicyManager::addDevicesRoleForCapturePreset(
3764 audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector &devices) {
3765 ALOGV("%s() audioSource=%d role=%d %s", __func__, audioSource, role,
3766 dumpAudioDeviceTypeAddrVector(devices).c_str());
3767
Mikhail Naganov55773032020-10-01 15:08:13 -07003768 if (!areAllDevicesSupported(devices, audio_call_is_input_device, __func__)) {
Jiabin Huang3b98d322020-09-03 17:54:16 +00003769 return BAD_VALUE;
3770 }
3771 status_t status = mEngine->addDevicesRoleForCapturePreset(audioSource, role, devices);
3772 ALOGW_IF(status != NO_ERROR,
3773 "Engine could not add preferred devices %s for audio source %d role %d",
3774 dumpAudioDeviceTypeAddrVector(devices).c_str(), audioSource, role);
3775
Eric Laurent2517af32020-11-25 15:31:27 +01003776 updateInputRouting();
Jiabin Huang3b98d322020-09-03 17:54:16 +00003777 return status;
3778}
3779
3780status_t AudioPolicyManager::removeDevicesRoleForCapturePreset(
3781 audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector& devices)
3782{
3783 ALOGV("%s() audioSource=%d role=%d devices=%s", __func__, audioSource, role,
3784 dumpAudioDeviceTypeAddrVector(devices).c_str());
3785
Mikhail Naganov55773032020-10-01 15:08:13 -07003786 if (!areAllDevicesSupported(devices, audio_call_is_input_device, __func__)) {
Jiabin Huang3b98d322020-09-03 17:54:16 +00003787 return BAD_VALUE;
3788 }
3789
3790 status_t status = mEngine->removeDevicesRoleForCapturePreset(
3791 audioSource, role, devices);
3792 ALOGW_IF(status != NO_ERROR,
3793 "Engine could not remove devices role (%d) for capture preset %d", role, audioSource);
3794
Eric Laurent2517af32020-11-25 15:31:27 +01003795 updateInputRouting();
Jiabin Huang3b98d322020-09-03 17:54:16 +00003796 return status;
3797}
3798
3799status_t AudioPolicyManager::clearDevicesRoleForCapturePreset(audio_source_t audioSource,
3800 device_role_t role) {
3801 ALOGV("%s() audioSource=%d role=%d", __func__, audioSource, role);
3802
3803 status_t status = mEngine->clearDevicesRoleForCapturePreset(audioSource, role);
3804 ALOGW_IF(status != NO_ERROR,
3805 "Engine could not clear devices role (%d) for capture preset %d", role, audioSource);
3806
Eric Laurent2517af32020-11-25 15:31:27 +01003807 updateInputRouting();
Jiabin Huang3b98d322020-09-03 17:54:16 +00003808 return status;
3809}
3810
3811status_t AudioPolicyManager::getDevicesForRoleAndCapturePreset(
3812 audio_source_t audioSource, device_role_t role, AudioDeviceTypeAddrVector &devices) {
3813 return mEngine->getDevicesForRoleAndCapturePreset(audioSource, role, devices);
3814}
3815
Oscar Azucena90e77632019-11-27 17:12:28 -08003816status_t AudioPolicyManager::setUserIdDeviceAffinities(int userId,
jiabin6a02d532020-08-07 11:56:38 -07003817 const AudioDeviceTypeAddrVector& devices) {
Eric Laurentfecbceb2021-02-09 14:46:43 +01003818 ALOGV("%s() userId=%d num devices %zu", __func__, userId, devices.size());
Eric Laurentc529cf62020-04-17 18:19:10 -07003819 if (!areAllDevicesSupported(devices, audio_is_output_device, __func__)) {
3820 return BAD_VALUE;
Oscar Azucena90e77632019-11-27 17:12:28 -08003821 }
Oscar Azucena90e77632019-11-27 17:12:28 -08003822 status_t status = mPolicyMixes.setUserIdDeviceAffinities(userId, devices);
3823 if (status != NO_ERROR) {
3824 ALOGE("%s() could not set device affinity for userId %d",
3825 __FUNCTION__, userId);
3826 return status;
3827 }
3828
3829 // reevaluate outputs for all devices
3830 checkForDeviceAndOutputChanges();
3831 updateCallAndOutputRouting();
3832
3833 return NO_ERROR;
3834}
3835
3836status_t AudioPolicyManager::removeUserIdDeviceAffinities(int userId) {
Eric Laurentfecbceb2021-02-09 14:46:43 +01003837 ALOGV("%s() userId=%d", __FUNCTION__, userId);
Oscar Azucena90e77632019-11-27 17:12:28 -08003838 status_t status = mPolicyMixes.removeUserIdDeviceAffinities(userId);
3839 if (status != NO_ERROR) {
3840 ALOGE("%s() Could not remove all device affinities fo userId = %d",
3841 __FUNCTION__, userId);
3842 return status;
3843 }
3844
3845 // reevaluate outputs for all devices
3846 checkForDeviceAndOutputChanges();
3847 updateCallAndOutputRouting();
3848
3849 return NO_ERROR;
3850}
3851
Andy Hungc29d82b2018-10-05 12:23:17 -07003852void AudioPolicyManager::dump(String8 *dst) const
Eric Laurente552edb2014-03-10 17:42:56 -07003853{
Andy Hungc29d82b2018-10-05 12:23:17 -07003854 dst->appendFormat("\nAudioPolicyManager Dump: %p\n", this);
Mikhail Naganov0dbe87b2021-12-01 02:03:31 +00003855 dst->appendFormat(" Primary Output I/O handle: %d\n",
Eric Laurent87ffa392015-05-22 10:32:38 -07003856 hasPrimaryOutput() ? mPrimaryOutput->mIoHandle : AUDIO_IO_HANDLE_NONE);
Mikhail Naganov0d6a0332016-04-19 17:12:38 -07003857 std::string stateLiteral;
3858 AudioModeConverter::toString(mEngine->getPhoneState(), stateLiteral);
Andy Hungc29d82b2018-10-05 12:23:17 -07003859 dst->appendFormat(" Phone state: %s\n", stateLiteral.c_str());
Mikhail Naganov2e5167e12018-04-19 13:41:22 -07003860 const char* forceUses[AUDIO_POLICY_FORCE_USE_CNT] = {
3861 "communications", "media", "record", "dock", "system",
3862 "HDMI system audio", "encoded surround output", "vibrate ringing" };
3863 for (audio_policy_force_use_t i = AUDIO_POLICY_FORCE_FOR_COMMUNICATION;
3864 i < AUDIO_POLICY_FORCE_USE_CNT; i = (audio_policy_force_use_t)((int)i + 1)) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08003865 audio_policy_forced_cfg_t forceUseValue = mEngine->getForceUse(i);
3866 dst->appendFormat(" Force use for %s: %d", forceUses[i], forceUseValue);
3867 if (i == AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND &&
3868 forceUseValue == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
3869 dst->append(" (MANUAL: ");
3870 dumpManualSurroundFormats(dst);
3871 dst->append(")");
3872 }
3873 dst->append("\n");
Mikhail Naganov2e5167e12018-04-19 13:41:22 -07003874 }
Andy Hungc29d82b2018-10-05 12:23:17 -07003875 dst->appendFormat(" TTS output %savailable\n", mTtsOutputAvailable ? "" : "not ");
3876 dst->appendFormat(" Master mono: %s\n", mMasterMono ? "on" : "off");
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +00003877 dst->appendFormat(" Communication Strategy id: %d\n", mCommunnicationStrategy);
Andy Hungc29d82b2018-10-05 12:23:17 -07003878 dst->appendFormat(" Config source: %s\n", mConfig.getSource().c_str()); // getConfig not const
Eric Laurent2517af32020-11-25 15:31:27 +01003879
Mikhail Naganov0f413b22021-12-02 05:29:27 +00003880 dst->append("\n");
3881 mAvailableOutputDevices.dump(dst, String8("Available output"), 1);
3882 dst->append("\n");
3883 mAvailableInputDevices.dump(dst, String8("Available input"), 1);
Andy Hungc29d82b2018-10-05 12:23:17 -07003884 mHwModulesAll.dump(dst);
3885 mOutputs.dump(dst);
3886 mInputs.dump(dst);
Mikhail Naganov0f413b22021-12-02 05:29:27 +00003887 mEffects.dump(dst, 1);
Andy Hungc29d82b2018-10-05 12:23:17 -07003888 mAudioPatches.dump(dst);
3889 mPolicyMixes.dump(dst);
3890 mAudioSources.dump(dst);
François Gaffiec005e562018-11-06 15:04:49 +01003891
Kevin Rocardb99cc752019-03-21 20:52:24 -07003892 dst->appendFormat(" AllowedCapturePolicies:\n");
3893 for (auto& policy : mAllowedCapturePolicies) {
3894 dst->appendFormat(" - uid=%d flag_mask=%#x\n", policy.first, policy.second);
3895 }
3896
François Gaffiec005e562018-11-06 15:04:49 +01003897 dst->appendFormat("\nPolicy Engine dump:\n");
3898 mEngine->dump(dst);
Andy Hungc29d82b2018-10-05 12:23:17 -07003899}
3900
3901status_t AudioPolicyManager::dump(int fd)
3902{
3903 String8 result;
3904 dump(&result);
Andy Hungbb54e202018-10-05 11:42:02 -07003905 write(fd, result.string(), result.size());
Eric Laurente552edb2014-03-10 17:42:56 -07003906 return NO_ERROR;
3907}
3908
Kevin Rocardb99cc752019-03-21 20:52:24 -07003909status_t AudioPolicyManager::setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy)
3910{
3911 mAllowedCapturePolicies[uid] = capturePolicy;
3912 return NO_ERROR;
3913}
3914
Eric Laurente552edb2014-03-10 17:42:56 -07003915// This function checks for the parameters which can be offloaded.
3916// This can be enhanced depending on the capability of the DSP and policy
3917// of the system.
Eric Laurent90fe31c2020-11-26 20:06:35 +01003918audio_offload_mode_t AudioPolicyManager::getOffloadSupport(const audio_offload_info_t& offloadInfo)
Eric Laurente552edb2014-03-10 17:42:56 -07003919{
Eric Laurent90fe31c2020-11-26 20:06:35 +01003920 ALOGV("%s: SR=%u, CM=0x%x, Format=0x%x, StreamType=%d,"
Eric Laurentd4692962014-05-05 18:13:44 -07003921 " BitRate=%u, duration=%" PRId64 " us, has_video=%d",
Eric Laurent90fe31c2020-11-26 20:06:35 +01003922 __func__, offloadInfo.sample_rate, offloadInfo.channel_mask,
Eric Laurente552edb2014-03-10 17:42:56 -07003923 offloadInfo.format,
3924 offloadInfo.stream_type, offloadInfo.bit_rate, offloadInfo.duration_us,
3925 offloadInfo.has_video);
3926
jiabin2b9d5a12021-12-10 01:06:29 +00003927 if (!isOffloadPossible(offloadInfo)) {
Eric Laurent90fe31c2020-11-26 20:06:35 +01003928 return AUDIO_OFFLOAD_NOT_SUPPORTED;
Eric Laurente552edb2014-03-10 17:42:56 -07003929 }
3930
3931 // See if there is a profile to support this.
3932 // AUDIO_DEVICE_NONE
François Gaffie11d30102018-11-02 16:09:09 +01003933 sp<IOProfile> profile = getProfileForOutput(DeviceVector() /*ignore device */,
Eric Laurente552edb2014-03-10 17:42:56 -07003934 offloadInfo.sample_rate,
3935 offloadInfo.format,
3936 offloadInfo.channel_mask,
Michael Chana94fbb22018-04-24 14:31:19 +10003937 AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD,
3938 true /* directOnly */);
Eric Laurent94365442021-01-08 18:36:05 +01003939 ALOGV("%s: profile %sfound%s", __func__, profile != nullptr ? "" : "NOT ",
3940 (profile != nullptr && (profile->getFlags() & AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD) != 0)
3941 ? ", supports gapless" : "");
Eric Laurent90fe31c2020-11-26 20:06:35 +01003942 if (profile == nullptr) {
3943 return AUDIO_OFFLOAD_NOT_SUPPORTED;
3944 }
3945 if ((profile->getFlags() & AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD) != 0) {
3946 return AUDIO_OFFLOAD_GAPLESS_SUPPORTED;
3947 }
3948 return AUDIO_OFFLOAD_SUPPORTED;
Eric Laurente552edb2014-03-10 17:42:56 -07003949}
3950
Michael Chana94fbb22018-04-24 14:31:19 +10003951bool AudioPolicyManager::isDirectOutputSupported(const audio_config_base_t& config,
3952 const audio_attributes_t& attributes) {
3953 audio_output_flags_t output_flags = AUDIO_OUTPUT_FLAG_NONE;
François Gaffie58d4be52018-11-06 15:30:12 +01003954 audio_flags_to_audio_output_flags(attributes.flags, &output_flags);
Dorin Drimus9901eb02022-01-14 11:36:51 +00003955 DeviceVector outputDevices = mEngine->getOutputDevicesForAttributes(attributes);
3956 sp<IOProfile> profile = getProfileForOutput(outputDevices,
Michael Chana94fbb22018-04-24 14:31:19 +10003957 config.sample_rate,
3958 config.format,
3959 config.channel_mask,
3960 output_flags,
3961 true /* directOnly */);
3962 ALOGV("%s() profile %sfound with name: %s, "
3963 "sample rate: %u, format: 0x%x, channel_mask: 0x%x, output flags: 0x%x",
3964 __FUNCTION__, profile != 0 ? "" : "NOT ",
jiabin5740f082019-08-19 15:08:30 -07003965 (profile != 0 ? profile->getTagName().c_str() : "null"),
Michael Chana94fbb22018-04-24 14:31:19 +10003966 config.sample_rate, config.format, config.channel_mask, output_flags);
Dorin Drimusecc9f422022-03-09 17:57:40 +01003967
3968 // also try the MSD module if compatible profile not found
3969 if (profile == nullptr) {
3970 profile = getMsdProfileForOutput(outputDevices,
3971 config.sample_rate,
3972 config.format,
3973 config.channel_mask,
3974 output_flags,
3975 true /* directOnly */);
3976 ALOGV("%s() MSD profile %sfound with name: %s, "
3977 "sample rate: %u, format: 0x%x, channel_mask: 0x%x, output flags: 0x%x",
3978 __FUNCTION__, profile != 0 ? "" : "NOT ",
3979 (profile != 0 ? profile->getTagName().c_str() : "null"),
3980 config.sample_rate, config.format, config.channel_mask, output_flags);
3981 }
3982 return (profile != nullptr);
Michael Chana94fbb22018-04-24 14:31:19 +10003983}
3984
jiabin2b9d5a12021-12-10 01:06:29 +00003985bool AudioPolicyManager::isOffloadPossible(const audio_offload_info_t &offloadInfo,
3986 bool durationIgnored) {
3987 if (mMasterMono) {
3988 return false; // no offloading if mono is set.
3989 }
3990
3991 // Check if offload has been disabled
3992 if (property_get_bool("audio.offload.disable", false /* default_value */)) {
3993 ALOGV("%s: offload disabled by audio.offload.disable", __func__);
3994 return false;
3995 }
3996
3997 // Check if stream type is music, then only allow offload as of now.
3998 if (offloadInfo.stream_type != AUDIO_STREAM_MUSIC)
3999 {
4000 ALOGV("%s: stream_type != MUSIC, returning false", __func__);
4001 return false;
4002 }
4003
4004 //TODO: enable audio offloading with video when ready
4005 const bool allowOffloadWithVideo =
4006 property_get_bool("audio.offload.video", false /* default_value */);
4007 if (offloadInfo.has_video && !allowOffloadWithVideo) {
4008 ALOGV("%s: has_video == true, returning false", __func__);
4009 return false;
4010 }
4011
4012 //If duration is less than minimum value defined in property, return false
4013 const int min_duration_secs = property_get_int32(
4014 "audio.offload.min.duration.secs", -1 /* default_value */);
4015 if (!durationIgnored) {
4016 if (min_duration_secs >= 0) {
4017 if (offloadInfo.duration_us < min_duration_secs * 1000000LL) {
4018 ALOGV("%s: Offload denied by duration < audio.offload.min.duration.secs(=%d)",
4019 __func__, min_duration_secs);
4020 return false;
4021 }
4022 } else if (offloadInfo.duration_us < OFFLOAD_DEFAULT_MIN_DURATION_SECS * 1000000) {
4023 ALOGV("%s: Offload denied by duration < default min(=%u)",
4024 __func__, OFFLOAD_DEFAULT_MIN_DURATION_SECS);
4025 return false;
4026 }
4027 }
4028
4029 // Do not allow offloading if one non offloadable effect is enabled. This prevents from
4030 // creating an offloaded track and tearing it down immediately after start when audioflinger
4031 // detects there is an active non offloadable effect.
4032 // FIXME: We should check the audio session here but we do not have it in this context.
4033 // This may prevent offloading in rare situations where effects are left active by apps
4034 // in the background.
4035 if (mEffects.isNonOffloadableEffectEnabled()) {
4036 return false;
4037 }
4038
4039 return true;
4040}
4041
4042audio_direct_mode_t AudioPolicyManager::getDirectPlaybackSupport(const audio_attributes_t *attr,
4043 const audio_config_t *config) {
4044 audio_offload_info_t offloadInfo = AUDIO_INFO_INITIALIZER;
4045 offloadInfo.format = config->format;
4046 offloadInfo.sample_rate = config->sample_rate;
4047 offloadInfo.channel_mask = config->channel_mask;
4048 offloadInfo.stream_type = mEngine->getStreamTypeForAttributes(*attr);
4049 offloadInfo.has_video = false;
4050 offloadInfo.is_streaming = false;
4051 const bool offloadPossible = isOffloadPossible(offloadInfo, true /*durationIgnored*/);
4052
4053 audio_direct_mode_t directMode = AUDIO_DIRECT_NOT_SUPPORTED;
4054 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE;
4055 audio_flags_to_audio_output_flags(attr->flags, &flags);
4056 // only retain flags that will drive compressed offload or passthrough
4057 uint32_t relevantFlags = AUDIO_OUTPUT_FLAG_HW_AV_SYNC;
4058 if (offloadPossible) {
4059 relevantFlags |= AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
4060 }
4061 flags = (audio_output_flags_t)((flags & relevantFlags) | AUDIO_OUTPUT_FLAG_DIRECT);
4062
Dorin Drimusfae3c642022-03-17 18:36:30 +01004063 DeviceVector engineOutputDevices = mEngine->getOutputDevicesForAttributes(*attr);
jiabin2b9d5a12021-12-10 01:06:29 +00004064 for (const auto& hwModule : mHwModules) {
Dorin Drimusfae3c642022-03-17 18:36:30 +01004065 DeviceVector outputDevices = engineOutputDevices;
4066 // the MSD module checks for different conditions and output devices
4067 if (strcmp(hwModule->getName(), AUDIO_HARDWARE_MODULE_ID_MSD) == 0) {
4068 if (!msdHasPatchesToAllDevices(engineOutputDevices.toTypeAddrVector())) {
4069 continue;
4070 }
4071 outputDevices = getMsdAudioOutDevices();
4072 }
jiabin2b9d5a12021-12-10 01:06:29 +00004073 for (const auto& curProfile : hwModule->getOutputProfiles()) {
jiabinc8f7dfc2022-01-06 18:42:08 +00004074 if (!curProfile->isCompatibleProfile(outputDevices,
jiabin2b9d5a12021-12-10 01:06:29 +00004075 config->sample_rate, nullptr /*updatedSamplingRate*/,
4076 config->format, nullptr /*updatedFormat*/,
4077 config->channel_mask, nullptr /*updatedChannelMask*/,
4078 flags)) {
4079 continue;
4080 }
4081 // reject profiles not corresponding to a device currently available
4082 if (!mAvailableOutputDevices.containsAtLeastOne(curProfile->getSupportedDevices())) {
4083 continue;
4084 }
4085 if ((curProfile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
4086 != AUDIO_OUTPUT_FLAG_NONE) {
jiabinc6132d62022-01-01 07:36:31 +00004087 if ((directMode & AUDIO_DIRECT_OFFLOAD_GAPLESS_SUPPORTED)
jiabin2b9d5a12021-12-10 01:06:29 +00004088 != AUDIO_DIRECT_NOT_SUPPORTED) {
4089 // Already reports offload gapless supported. No need to report offload support.
4090 continue;
4091 }
4092 if ((curProfile->getFlags() & AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD)
4093 != AUDIO_OUTPUT_FLAG_NONE) {
4094 // If offload gapless is reported, no need to report offload support.
4095 directMode = (audio_direct_mode_t) ((directMode &
4096 ~AUDIO_DIRECT_OFFLOAD_SUPPORTED) |
4097 AUDIO_DIRECT_OFFLOAD_GAPLESS_SUPPORTED);
4098 } else {
Dorin Drimusfae3c642022-03-17 18:36:30 +01004099 directMode = (audio_direct_mode_t)(directMode | AUDIO_DIRECT_OFFLOAD_SUPPORTED);
jiabin2b9d5a12021-12-10 01:06:29 +00004100 }
4101 } else {
Dorin Drimusfae3c642022-03-17 18:36:30 +01004102 directMode = (audio_direct_mode_t) (directMode | AUDIO_DIRECT_BITSTREAM_SUPPORTED);
jiabin2b9d5a12021-12-10 01:06:29 +00004103 }
4104 }
4105 }
4106 return directMode;
4107}
4108
Dorin Drimusf2196d82022-01-03 12:11:18 +01004109status_t AudioPolicyManager::getDirectProfilesForAttributes(const audio_attributes_t* attr,
4110 AudioProfileVector& audioProfilesVector) {
Dorin Drimus76e69572022-09-23 15:28:51 +00004111 if (mEffects.isNonOffloadableEffectEnabled()) {
4112 return OK;
4113 }
Dorin Drimusf2196d82022-01-03 12:11:18 +01004114 AudioDeviceTypeAddrVector devices;
Andy Hung6d23c0f2022-02-16 09:37:15 -08004115 status_t status = getDevicesForAttributes(*attr, &devices, false /* forVolume */);
Dorin Drimusf2196d82022-01-03 12:11:18 +01004116 if (status != OK) {
4117 return status;
4118 }
4119 ALOGV("%s: found %zu output devices for attributes.", __func__, devices.size());
4120 if (devices.empty()) {
4121 return OK; // no output devices for the attributes
4122 }
4123
4124 for (const auto& hwModule : mHwModules) {
Dorin Drimus94d94412022-02-02 09:05:02 +01004125 // the MSD module checks for different conditions
4126 if (strcmp(hwModule->getName(), AUDIO_HARDWARE_MODULE_ID_MSD) == 0) {
4127 continue;
4128 }
4129 for (const auto& outputProfile : hwModule->getOutputProfiles()) {
4130 if (!outputProfile->asAudioPort()->isDirectOutput()) {
Dorin Drimusf2196d82022-01-03 12:11:18 +01004131 continue;
4132 }
Dorin Drimus94d94412022-02-02 09:05:02 +01004133 // allow only profiles that support all the available and routed devices
4134 if (outputProfile->getSupportedDevices().getDevicesFromDeviceTypeAddrVec(devices).size()
Dorin Drimusf2196d82022-01-03 12:11:18 +01004135 != devices.size()) {
4136 continue;
4137 }
Dorin Drimus94d94412022-02-02 09:05:02 +01004138 audioProfilesVector.addAllValidProfiles(
4139 outputProfile->asAudioPort()->getAudioProfiles());
Dorin Drimusf2196d82022-01-03 12:11:18 +01004140 }
4141 }
Dorin Drimus94d94412022-02-02 09:05:02 +01004142
4143 // add the direct profiles from MSD if present and has audio patches to all the output(s)
4144 const auto& msdModule = mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD);
4145 if (msdModule != nullptr) {
4146 if (msdHasPatchesToAllDevices(devices)) {
4147 ALOGV("%s: MSD audio patches set to all output devices.", __func__);
4148 for (const auto& outputProfile : msdModule->getOutputProfiles()) {
4149 if (!outputProfile->asAudioPort()->isDirectOutput()) {
4150 continue;
4151 }
4152 audioProfilesVector.addAllValidProfiles(
4153 outputProfile->asAudioPort()->getAudioProfiles());
4154 }
4155 } else {
4156 ALOGV("%s: MSD audio patches NOT set to all output devices.", __func__);
4157 }
4158 }
4159
Dorin Drimusf2196d82022-01-03 12:11:18 +01004160 return NO_ERROR;
4161}
4162
Eric Laurent6a94d692014-05-20 11:18:06 -07004163status_t AudioPolicyManager::listAudioPorts(audio_port_role_t role,
4164 audio_port_type_t type,
4165 unsigned int *num_ports,
jiabin19cdba52020-11-24 11:28:58 -08004166 struct audio_port_v7 *ports,
Eric Laurent6a94d692014-05-20 11:18:06 -07004167 unsigned int *generation)
4168{
jiabin19cdba52020-11-24 11:28:58 -08004169 if (num_ports == nullptr || (*num_ports != 0 && ports == nullptr) ||
4170 generation == nullptr) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004171 return BAD_VALUE;
4172 }
4173 ALOGV("listAudioPorts() role %d type %d num_ports %d ports %p", role, type, *num_ports, ports);
jiabin19cdba52020-11-24 11:28:58 -08004174 if (ports == nullptr) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004175 *num_ports = 0;
4176 }
4177
4178 size_t portsWritten = 0;
4179 size_t portsMax = *num_ports;
4180 *num_ports = 0;
4181 if (type == AUDIO_PORT_TYPE_NONE || type == AUDIO_PORT_TYPE_DEVICE) {
Eric Laurent5a2b6292016-04-14 18:05:57 -07004182 // do not report devices with type AUDIO_DEVICE_IN_STUB or AUDIO_DEVICE_OUT_STUB
4183 // as they are used by stub HALs by convention
Eric Laurent6a94d692014-05-20 11:18:06 -07004184 if (role == AUDIO_PORT_ROLE_SINK || role == AUDIO_PORT_ROLE_NONE) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08004185 for (const auto& dev : mAvailableOutputDevices) {
4186 if (dev->type() == AUDIO_DEVICE_OUT_STUB) {
Eric Laurent5a2b6292016-04-14 18:05:57 -07004187 continue;
4188 }
4189 if (portsWritten < portsMax) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08004190 dev->toAudioPort(&ports[portsWritten++]);
Eric Laurent5a2b6292016-04-14 18:05:57 -07004191 }
4192 (*num_ports)++;
Eric Laurent6a94d692014-05-20 11:18:06 -07004193 }
Eric Laurent6a94d692014-05-20 11:18:06 -07004194 }
4195 if (role == AUDIO_PORT_ROLE_SOURCE || role == AUDIO_PORT_ROLE_NONE) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08004196 for (const auto& dev : mAvailableInputDevices) {
4197 if (dev->type() == AUDIO_DEVICE_IN_STUB) {
Eric Laurent5a2b6292016-04-14 18:05:57 -07004198 continue;
4199 }
4200 if (portsWritten < portsMax) {
Mikhail Naganovcf84e592017-12-07 11:25:11 -08004201 dev->toAudioPort(&ports[portsWritten++]);
Eric Laurent5a2b6292016-04-14 18:05:57 -07004202 }
4203 (*num_ports)++;
Eric Laurent6a94d692014-05-20 11:18:06 -07004204 }
Eric Laurent6a94d692014-05-20 11:18:06 -07004205 }
4206 }
4207 if (type == AUDIO_PORT_TYPE_NONE || type == AUDIO_PORT_TYPE_MIX) {
4208 if (role == AUDIO_PORT_ROLE_SINK || role == AUDIO_PORT_ROLE_NONE) {
4209 for (size_t i = 0; i < mInputs.size() && portsWritten < portsMax; i++) {
4210 mInputs[i]->toAudioPort(&ports[portsWritten++]);
4211 }
4212 *num_ports += mInputs.size();
4213 }
4214 if (role == AUDIO_PORT_ROLE_SOURCE || role == AUDIO_PORT_ROLE_NONE) {
Eric Laurent84c70242014-06-23 08:46:27 -07004215 size_t numOutputs = 0;
4216 for (size_t i = 0; i < mOutputs.size(); i++) {
4217 if (!mOutputs[i]->isDuplicated()) {
4218 numOutputs++;
4219 if (portsWritten < portsMax) {
4220 mOutputs[i]->toAudioPort(&ports[portsWritten++]);
4221 }
4222 }
Eric Laurent6a94d692014-05-20 11:18:06 -07004223 }
Eric Laurent84c70242014-06-23 08:46:27 -07004224 *num_ports += numOutputs;
Eric Laurent6a94d692014-05-20 11:18:06 -07004225 }
4226 }
4227 *generation = curAudioPortGeneration();
Mark Salyzynbeb9e302014-06-18 16:33:15 -07004228 ALOGV("listAudioPorts() got %zu ports needed %d", portsWritten, *num_ports);
Eric Laurent6a94d692014-05-20 11:18:06 -07004229 return NO_ERROR;
4230}
4231
jiabin19cdba52020-11-24 11:28:58 -08004232status_t AudioPolicyManager::getAudioPort(struct audio_port_v7 *port)
Eric Laurent6a94d692014-05-20 11:18:06 -07004233{
Eric Laurent99fcae42018-05-17 16:59:18 -07004234 if (port == nullptr || port->id == AUDIO_PORT_HANDLE_NONE) {
4235 return BAD_VALUE;
4236 }
4237 sp<DeviceDescriptor> dev = mAvailableOutputDevices.getDeviceFromId(port->id);
4238 if (dev != 0) {
4239 dev->toAudioPort(port);
4240 return NO_ERROR;
4241 }
4242 dev = mAvailableInputDevices.getDeviceFromId(port->id);
4243 if (dev != 0) {
4244 dev->toAudioPort(port);
4245 return NO_ERROR;
4246 }
4247 sp<SwAudioOutputDescriptor> out = mOutputs.getOutputFromId(port->id);
4248 if (out != 0) {
4249 out->toAudioPort(port);
4250 return NO_ERROR;
4251 }
4252 sp<AudioInputDescriptor> in = mInputs.getInputFromId(port->id);
4253 if (in != 0) {
4254 in->toAudioPort(port);
4255 return NO_ERROR;
4256 }
4257 return BAD_VALUE;
Eric Laurent6a94d692014-05-20 11:18:06 -07004258}
4259
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004260status_t AudioPolicyManager::createAudioPatch(const struct audio_patch *patch,
4261 audio_patch_handle_t *handle,
4262 uid_t uid)
Eric Laurent6a94d692014-05-20 11:18:06 -07004263{
François Gaffieafd4cea2019-11-18 15:50:22 +01004264 ALOGV("%s", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07004265 if (handle == NULL || patch == NULL) {
4266 return BAD_VALUE;
4267 }
François Gaffieafd4cea2019-11-18 15:50:22 +01004268 ALOGV("%s num sources %d num sinks %d", __func__, patch->num_sources, patch->num_sinks);
Mikhail Naganovac9858b2018-06-15 13:12:37 -07004269 if (!audio_patch_is_valid(patch)) {
Eric Laurent874c42872014-08-08 15:13:39 -07004270 return BAD_VALUE;
4271 }
4272 // only one source per audio patch supported for now
4273 if (patch->num_sources > 1) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004274 return INVALID_OPERATION;
4275 }
Eric Laurent874c42872014-08-08 15:13:39 -07004276 if (patch->sources[0].role != AUDIO_PORT_ROLE_SOURCE) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004277 return INVALID_OPERATION;
4278 }
Eric Laurent874c42872014-08-08 15:13:39 -07004279 for (size_t i = 0; i < patch->num_sinks; i++) {
4280 if (patch->sinks[i].role != AUDIO_PORT_ROLE_SINK) {
4281 return INVALID_OPERATION;
4282 }
4283 }
Eric Laurent6a94d692014-05-20 11:18:06 -07004284
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004285 sp<DeviceDescriptor> srcDevice = mAvailableInputDevices.getDeviceFromId(patch->sources[0].id);
4286 sp<DeviceDescriptor> sinkDevice = mAvailableOutputDevices.getDeviceFromId(patch->sinks[0].id);
4287 if (srcDevice == nullptr || sinkDevice == nullptr) {
4288 ALOGW("%s could not create patch, invalid sink and/or source device(s)", __func__);
4289 return BAD_VALUE;
4290 }
4291 ALOGV("%s between source %s and sink %s", __func__,
4292 srcDevice->toString().c_str(), sinkDevice->toString().c_str());
4293 audio_port_handle_t portId = PolicyAudioPort::getNextUniqueId();
4294 // Default attributes, default volume priority, not to infer with non raw audio patches.
4295 audio_attributes_t attributes = attributes_initializer(AUDIO_USAGE_MEDIA);
4296 const struct audio_port_config *source = &patch->sources[0];
4297 sp<SourceClientDescriptor> sourceDesc =
4298 new InternalSourceClientDescriptor(
4299 portId, uid, attributes, *source, srcDevice, sinkDevice,
4300 mEngine->getProductStrategyForAttributes(attributes), toVolumeSource(attributes));
4301
4302 status_t status =
4303 connectAudioSourceToSink(sourceDesc, sinkDevice, patch, *handle, uid, 0 /* delayMs */);
4304
4305 if (status != NO_ERROR) {
4306 return INVALID_OPERATION;
4307 }
4308 mAudioSources.add(portId, sourceDesc);
4309 return NO_ERROR;
4310}
4311
4312status_t AudioPolicyManager::connectAudioSourceToSink(
4313 const sp<SourceClientDescriptor>& sourceDesc, const sp<DeviceDescriptor> &sinkDevice,
4314 const struct audio_patch *patch,
4315 audio_patch_handle_t &handle,
4316 uid_t uid, uint32_t delayMs)
4317{
4318 status_t status = createAudioPatchInternal(patch, &handle, uid, delayMs, sourceDesc);
4319 if (status != NO_ERROR || mAudioPatches.indexOfKey(handle) < 0) {
4320 ALOGW("%s patch panel could not connect device patch, error %d", __func__, status);
4321 return INVALID_OPERATION;
4322 }
4323 sourceDesc->connect(handle, sinkDevice);
4324 if (isMsdPatch(handle)) {
4325 return NO_ERROR;
4326 }
4327 // SW Bridge? (@todo: HW bridge, keep track of HwOutput for device selection "reconsideration")
4328 sp<SwAudioOutputDescriptor> swOutput = sourceDesc->swOutput().promote();
4329 ALOG_ASSERT(swOutput != nullptr, "%s: a swOutput shall always be associated", __func__);
4330 if (swOutput->getClient(sourceDesc->portId()) != nullptr) {
4331 ALOGW("%s source portId has already been attached to outputDesc", __func__);
4332 goto FailurePatchAdded;
4333 }
4334 status = swOutput->start();
4335 if (status != NO_ERROR) {
4336 goto FailureSourceAdded;
4337 }
4338 swOutput->addClient(sourceDesc);
4339 status = startSource(swOutput, sourceDesc, &delayMs);
4340 if (status != NO_ERROR) {
4341 ALOGW("%s failed to start source, error %d", __FUNCTION__, status);
4342 goto FailureSourceActive;
4343 }
4344 if (delayMs != 0) {
4345 usleep(delayMs * 1000);
4346 }
4347 return NO_ERROR;
4348
4349FailureSourceActive:
4350 swOutput->stop();
4351 releaseOutput(sourceDesc->portId());
4352FailureSourceAdded:
4353 sourceDesc->setSwOutput(nullptr);
4354FailurePatchAdded:
4355 releaseAudioPatchInternal(handle);
4356 return INVALID_OPERATION;
4357}
4358
4359status_t AudioPolicyManager::createAudioPatchInternal(const struct audio_patch *patch,
4360 audio_patch_handle_t *handle,
4361 uid_t uid, uint32_t delayMs,
4362 const sp<SourceClientDescriptor>& sourceDesc)
4363{
4364 ALOGV("%s num sources %d num sinks %d", __func__, patch->num_sources, patch->num_sinks);
Eric Laurent6a94d692014-05-20 11:18:06 -07004365 sp<AudioPatch> patchDesc;
4366 ssize_t index = mAudioPatches.indexOfKey(*handle);
4367
François Gaffieafd4cea2019-11-18 15:50:22 +01004368 ALOGV("%s source id %d role %d type %d", __func__, patch->sources[0].id,
4369 patch->sources[0].role,
4370 patch->sources[0].type);
Eric Laurent874c42872014-08-08 15:13:39 -07004371#if LOG_NDEBUG == 0
4372 for (size_t i = 0; i < patch->num_sinks; i++) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004373 ALOGV("%s sink %zu: id %d role %d type %d", __func__ ,i, patch->sinks[i].id,
4374 patch->sinks[i].role,
4375 patch->sinks[i].type);
Eric Laurent874c42872014-08-08 15:13:39 -07004376 }
4377#endif
Eric Laurent6a94d692014-05-20 11:18:06 -07004378
4379 if (index >= 0) {
4380 patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01004381 ALOGV("%s mUidCached %d patchDesc->mUid %d uid %d",
4382 __func__, mUidCached, patchDesc->getUid(), uid);
4383 if (patchDesc->getUid() != mUidCached && uid != patchDesc->getUid()) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004384 return INVALID_OPERATION;
4385 }
4386 } else {
Glenn Kastena13cde92016-03-28 15:26:02 -07004387 *handle = AUDIO_PATCH_HANDLE_NONE;
Eric Laurent6a94d692014-05-20 11:18:06 -07004388 }
4389
4390 if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) {
Eric Laurentc75307b2015-03-17 15:29:32 -07004391 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07004392 if (outputDesc == NULL) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004393 ALOGV("%s output not found for id %d", __func__, patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07004394 return BAD_VALUE;
4395 }
Eric Laurent84c70242014-06-23 08:46:27 -07004396 ALOG_ASSERT(!outputDesc->isDuplicated(),"duplicated output %d in source in ports",
4397 outputDesc->mIoHandle);
Eric Laurent6a94d692014-05-20 11:18:06 -07004398 if (patchDesc != 0) {
4399 if (patchDesc->mPatch.sources[0].id != patch->sources[0].id) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004400 ALOGV("%s source id differs for patch current id %d new id %d",
4401 __func__, patchDesc->mPatch.sources[0].id, patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07004402 return BAD_VALUE;
4403 }
4404 }
Eric Laurent874c42872014-08-08 15:13:39 -07004405 DeviceVector devices;
4406 for (size_t i = 0; i < patch->num_sinks; i++) {
4407 // Only support mix to devices connection
4408 // TODO add support for mix to mix connection
4409 if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004410 ALOGV("%s source mix but sink is not a device", __func__);
Eric Laurent874c42872014-08-08 15:13:39 -07004411 return INVALID_OPERATION;
4412 }
4413 sp<DeviceDescriptor> devDesc =
4414 mAvailableOutputDevices.getDeviceFromId(patch->sinks[i].id);
4415 if (devDesc == 0) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004416 ALOGV("%s out device not found for id %d", __func__, patch->sinks[i].id);
Eric Laurent874c42872014-08-08 15:13:39 -07004417 return BAD_VALUE;
4418 }
Eric Laurent6a94d692014-05-20 11:18:06 -07004419
François Gaffie11d30102018-11-02 16:09:09 +01004420 if (!outputDesc->mProfile->isCompatibleProfile(DeviceVector(devDesc),
Eric Laurent874c42872014-08-08 15:13:39 -07004421 patch->sources[0].sample_rate,
François Gaffie53615e22015-03-19 09:24:12 +01004422 NULL, // updatedSamplingRate
4423 patch->sources[0].format,
Andy Hungf129b032015-04-07 13:45:50 -07004424 NULL, // updatedFormat
François Gaffie53615e22015-03-19 09:24:12 +01004425 patch->sources[0].channel_mask,
Andy Hungf129b032015-04-07 13:45:50 -07004426 NULL, // updatedChannelMask
François Gaffie53615e22015-03-19 09:24:12 +01004427 AUDIO_OUTPUT_FLAG_NONE /*FIXME*/)) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004428 ALOGV("%s profile not supported for device %08x", __func__, devDesc->type());
Eric Laurent874c42872014-08-08 15:13:39 -07004429 return INVALID_OPERATION;
4430 }
4431 devices.add(devDesc);
4432 }
4433 if (devices.size() == 0) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004434 return INVALID_OPERATION;
4435 }
Eric Laurent874c42872014-08-08 15:13:39 -07004436
Eric Laurent6a94d692014-05-20 11:18:06 -07004437 // TODO: reconfigure output format and channels here
François Gaffieafd4cea2019-11-18 15:50:22 +01004438 ALOGV("%s setting device %s on output %d",
4439 __func__, dumpDeviceTypes(devices.types()).c_str(), outputDesc->mIoHandle);
François Gaffie11d30102018-11-02 16:09:09 +01004440 setOutputDevices(outputDesc, devices, true, 0, handle);
Eric Laurent6a94d692014-05-20 11:18:06 -07004441 index = mAudioPatches.indexOfKey(*handle);
4442 if (index >= 0) {
4443 if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004444 ALOGW("%s setOutputDevice() did not reuse the patch provided", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07004445 }
4446 patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01004447 patchDesc->setUid(uid);
4448 ALOGV("%s success", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07004449 } else {
François Gaffieafd4cea2019-11-18 15:50:22 +01004450 ALOGW("%s setOutputDevice() failed to create a patch", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07004451 return INVALID_OPERATION;
4452 }
4453 } else if (patch->sources[0].type == AUDIO_PORT_TYPE_DEVICE) {
4454 if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
4455 // input device to input mix connection
Eric Laurent874c42872014-08-08 15:13:39 -07004456 // only one sink supported when connecting an input device to a mix
4457 if (patch->num_sinks > 1) {
4458 return INVALID_OPERATION;
4459 }
François Gaffie53615e22015-03-19 09:24:12 +01004460 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(patch->sinks[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07004461 if (inputDesc == NULL) {
4462 return BAD_VALUE;
4463 }
4464 if (patchDesc != 0) {
4465 if (patchDesc->mPatch.sinks[0].id != patch->sinks[0].id) {
4466 return BAD_VALUE;
4467 }
4468 }
François Gaffie11d30102018-11-02 16:09:09 +01004469 sp<DeviceDescriptor> device =
Eric Laurent6a94d692014-05-20 11:18:06 -07004470 mAvailableInputDevices.getDeviceFromId(patch->sources[0].id);
François Gaffie11d30102018-11-02 16:09:09 +01004471 if (device == 0) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004472 return BAD_VALUE;
4473 }
4474
François Gaffie11d30102018-11-02 16:09:09 +01004475 if (!inputDesc->mProfile->isCompatibleProfile(DeviceVector(device),
Eric Laurent275e8e92014-11-30 15:14:47 -08004476 patch->sinks[0].sample_rate,
4477 NULL, /*updatedSampleRate*/
4478 patch->sinks[0].format,
Andy Hungf129b032015-04-07 13:45:50 -07004479 NULL, /*updatedFormat*/
Eric Laurent275e8e92014-11-30 15:14:47 -08004480 patch->sinks[0].channel_mask,
Andy Hungf129b032015-04-07 13:45:50 -07004481 NULL, /*updatedChannelMask*/
Eric Laurent275e8e92014-11-30 15:14:47 -08004482 // FIXME for the parameter type,
4483 // and the NONE
4484 (audio_output_flags_t)
Glenn Kasten6a8ab052014-07-24 14:08:35 -07004485 AUDIO_INPUT_FLAG_NONE)) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004486 return INVALID_OPERATION;
4487 }
4488 // TODO: reconfigure output format and channels here
François Gaffieafd4cea2019-11-18 15:50:22 +01004489 ALOGV("%s setting device %s on output %d", __func__,
François Gaffie11d30102018-11-02 16:09:09 +01004490 device->toString().c_str(), inputDesc->mIoHandle);
4491 setInputDevice(inputDesc->mIoHandle, device, true, handle);
Eric Laurent6a94d692014-05-20 11:18:06 -07004492 index = mAudioPatches.indexOfKey(*handle);
4493 if (index >= 0) {
4494 if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004495 ALOGW("%s setInputDevice() did not reuse the patch provided", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07004496 }
4497 patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01004498 patchDesc->setUid(uid);
4499 ALOGV("%s success", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07004500 } else {
François Gaffieafd4cea2019-11-18 15:50:22 +01004501 ALOGW("%s setInputDevice() failed to create a patch", __func__);
Eric Laurent6a94d692014-05-20 11:18:06 -07004502 return INVALID_OPERATION;
4503 }
4504 } else if (patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) {
4505 // device to device connection
4506 if (patchDesc != 0) {
Eric Laurent874c42872014-08-08 15:13:39 -07004507 if (patchDesc->mPatch.sources[0].id != patch->sources[0].id) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004508 return BAD_VALUE;
4509 }
4510 }
François Gaffie11d30102018-11-02 16:09:09 +01004511 sp<DeviceDescriptor> srcDevice =
Eric Laurent6a94d692014-05-20 11:18:06 -07004512 mAvailableInputDevices.getDeviceFromId(patch->sources[0].id);
François Gaffie11d30102018-11-02 16:09:09 +01004513 if (srcDevice == 0) {
Eric Laurent58f8eb72014-09-12 16:19:41 -07004514 return BAD_VALUE;
4515 }
Eric Laurent874c42872014-08-08 15:13:39 -07004516
Eric Laurent6a94d692014-05-20 11:18:06 -07004517 //update source and sink with our own data as the data passed in the patch may
4518 // be incomplete.
François Gaffieafd4cea2019-11-18 15:50:22 +01004519 PatchBuilder patchBuilder;
4520 audio_port_config sourcePortConfig = {};
Dean Wheatley8bee85a2021-02-10 16:02:23 +11004521
4522 // if first sink is to MSD, establish single MSD patch
4523 if (getMsdAudioOutDevices().contains(
4524 mAvailableOutputDevices.getDeviceFromId(patch->sinks[0].id))) {
4525 ALOGV("%s patching to MSD", __FUNCTION__);
4526 patchBuilder = buildMsdPatch(false /*msdIsSource*/, srcDevice);
4527 goto installPatch;
4528 }
4529
François Gaffieafd4cea2019-11-18 15:50:22 +01004530 srcDevice->toAudioPortConfig(&sourcePortConfig, &patch->sources[0]);
4531 patchBuilder.addSource(sourcePortConfig);
Eric Laurent6a94d692014-05-20 11:18:06 -07004532
Eric Laurent874c42872014-08-08 15:13:39 -07004533 for (size_t i = 0; i < patch->num_sinks; i++) {
4534 if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004535 ALOGV("%s source device but one sink is not a device", __func__);
Eric Laurent874c42872014-08-08 15:13:39 -07004536 return INVALID_OPERATION;
4537 }
François Gaffie11d30102018-11-02 16:09:09 +01004538 sp<DeviceDescriptor> sinkDevice =
Eric Laurent874c42872014-08-08 15:13:39 -07004539 mAvailableOutputDevices.getDeviceFromId(patch->sinks[i].id);
François Gaffie11d30102018-11-02 16:09:09 +01004540 if (sinkDevice == 0) {
Eric Laurent874c42872014-08-08 15:13:39 -07004541 return BAD_VALUE;
4542 }
François Gaffieafd4cea2019-11-18 15:50:22 +01004543 audio_port_config sinkPortConfig = {};
4544 sinkDevice->toAudioPortConfig(&sinkPortConfig, &patch->sinks[i]);
4545 patchBuilder.addSink(sinkPortConfig);
Eric Laurent874c42872014-08-08 15:13:39 -07004546
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02004547 // Whatever Sw or Hw bridge, we do attach an SwOutput to an Audio Source for
4548 // volume management purpose (tracking activity)
4549 // In case of Hw bridge, it is a Work Around. The mixPort used is the one declared
4550 // in config XML to reach the sink so that is can be declared as available.
4551 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
Eric Laurent78b07302022-10-07 16:20:34 +02004552 sp<SwAudioOutputDescriptor> outputDesc;
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004553 if (!sourceDesc->isInternal()) {
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02004554 // take care of dynamic routing for SwOutput selection,
4555 audio_attributes_t attributes = sourceDesc->attributes();
4556 audio_stream_type_t stream = sourceDesc->stream();
4557 audio_attributes_t resultAttr;
4558 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
4559 config.sample_rate = sourceDesc->config().sample_rate;
4560 config.channel_mask = sourceDesc->config().channel_mask;
4561 config.format = sourceDesc->config().format;
4562 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE;
4563 audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
4564 bool isRequestedDeviceForExclusiveUse = false;
4565 output_type_t outputType;
Eric Laurentb0a7bc92022-04-05 15:06:08 +02004566 bool isSpatialized;
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02004567 getOutputForAttrInt(&resultAttr, &output, AUDIO_SESSION_NONE, &attributes,
4568 &stream, sourceDesc->uid(), &config, &flags,
4569 &selectedDeviceId, &isRequestedDeviceForExclusiveUse,
Eric Laurentb0a7bc92022-04-05 15:06:08 +02004570 nullptr, &outputType, &isSpatialized);
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02004571 if (output == AUDIO_IO_HANDLE_NONE) {
4572 ALOGV("%s no output for device %s",
4573 __FUNCTION__, sinkDevice->toString().c_str());
4574 return INVALID_OPERATION;
4575 }
4576 outputDesc = mOutputs.valueFor(output);
4577 if (outputDesc->isDuplicated()) {
4578 ALOGE("%s output is duplicated", __func__);
4579 return INVALID_OPERATION;
4580 }
François Gaffie1765c5b2022-04-26 12:48:49 +02004581 bool closeOutput = outputDesc->mDirectOpenCount != 0;
4582 sourceDesc->setSwOutput(outputDesc, closeOutput);
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004583 } else {
4584 // Same for "raw patches" aka created from createAudioPatch API
4585 SortedVector<audio_io_handle_t> outputs =
4586 getOutputsForDevices(DeviceVector(sinkDevice), mOutputs);
4587 // if the sink device is reachable via an opened output stream, request to
4588 // go via this output stream by adding a second source to the patch
4589 // description
4590 output = selectOutput(outputs);
4591 if (output == AUDIO_IO_HANDLE_NONE) {
4592 ALOGE("%s no output available for internal patch sink", __func__);
4593 return INVALID_OPERATION;
4594 }
4595 outputDesc = mOutputs.valueFor(output);
4596 if (outputDesc->isDuplicated()) {
4597 ALOGV("%s output for device %s is duplicated",
4598 __func__, sinkDevice->toString().c_str());
4599 return INVALID_OPERATION;
4600 }
François Gaffie1765c5b2022-04-26 12:48:49 +02004601 sourceDesc->setSwOutput(outputDesc, /* closeOutput= */ false);
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02004602 }
Eric Laurent3bcf8592015-04-03 12:13:24 -07004603 // create a software bridge in PatchPanel if:
Scott Randolphf3172402018-01-23 17:06:53 -08004604 // - source and sink devices are on different HW modules OR
Eric Laurent3bcf8592015-04-03 12:13:24 -07004605 // - audio HAL version is < 3.0
Francois Gaffie99896da2018-04-09 11:05:33 +02004606 // - audio HAL version is >= 3.0 but no route has been declared between devices
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004607 // - called from startAudioSource (aka sourceDesc is not internal) and source device
4608 // does not have a gain controller
François Gaffie11d30102018-11-02 16:09:09 +01004609 if (!srcDevice->hasSameHwModuleAs(sinkDevice) ||
4610 (srcDevice->getModuleVersionMajor() < 3) ||
François Gaffieafd4cea2019-11-18 15:50:22 +01004611 !srcDevice->getModule()->supportsPatch(srcDevice, sinkDevice) ||
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004612 (!sourceDesc->isInternal() &&
François Gaffieafd4cea2019-11-18 15:50:22 +01004613 srcDevice->getAudioPort()->getGains().size() == 0)) {
Eric Laurent3bcf8592015-04-03 12:13:24 -07004614 // support only one sink device for now to simplify output selection logic
Eric Laurent874c42872014-08-08 15:13:39 -07004615 if (patch->num_sinks > 1) {
Eric Laurent83b88082014-06-20 18:31:16 -07004616 return INVALID_OPERATION;
4617 }
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004618 sourceDesc->setUseSwBridge();
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02004619 if (outputDesc != nullptr) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004620 audio_port_config srcMixPortConfig = {};
Ytai Ben-Tsvic9d2a912021-11-22 16:43:09 -08004621 outputDesc->toAudioPortConfig(&srcMixPortConfig, nullptr);
François Gaffieafd4cea2019-11-18 15:50:22 +01004622 // for volume control, we may need a valid stream
Eric Laurent78b07302022-10-07 16:20:34 +02004623 srcMixPortConfig.ext.mix.usecase.stream =
4624 (!sourceDesc->isInternal() || isCallTxAudioSource(sourceDesc)) ?
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004625 mEngine->getStreamTypeForAttributes(sourceDesc->attributes()) :
4626 AUDIO_STREAM_PATCH;
François Gaffieafd4cea2019-11-18 15:50:22 +01004627 patchBuilder.addSource(srcMixPortConfig);
Eric Laurent874c42872014-08-08 15:13:39 -07004628 }
Eric Laurent83b88082014-06-20 18:31:16 -07004629 }
Eric Laurent6a94d692014-05-20 11:18:06 -07004630 }
4631 // TODO: check from routing capabilities in config file and other conflicting patches
4632
Dean Wheatley8bee85a2021-02-10 16:02:23 +11004633installPatch:
François Gaffieafd4cea2019-11-18 15:50:22 +01004634 status_t status = installPatch(
4635 __func__, index, handle, patchBuilder.patch(), delayMs, uid, &patchDesc);
Mikhail Naganovdc769682018-05-04 15:34:08 -07004636 if (status != NO_ERROR) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004637 ALOGW("%s patch panel could not connect device patch, error %d", __func__, status);
Eric Laurent6a94d692014-05-20 11:18:06 -07004638 return INVALID_OPERATION;
4639 }
4640 } else {
4641 return BAD_VALUE;
4642 }
4643 } else {
4644 return BAD_VALUE;
4645 }
4646 return NO_ERROR;
4647}
4648
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004649status_t AudioPolicyManager::releaseAudioPatch(audio_patch_handle_t handle, uid_t uid)
Eric Laurent6a94d692014-05-20 11:18:06 -07004650{
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004651 ALOGV("%s patch %d", __func__, handle);
Eric Laurent6a94d692014-05-20 11:18:06 -07004652 ssize_t index = mAudioPatches.indexOfKey(handle);
4653
4654 if (index < 0) {
4655 return BAD_VALUE;
4656 }
4657 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01004658 ALOGV("%s() mUidCached %d patchDesc->mUid %d uid %d",
4659 __func__, mUidCached, patchDesc->getUid(), uid);
4660 if (patchDesc->getUid() != mUidCached && uid != patchDesc->getUid()) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004661 return INVALID_OPERATION;
4662 }
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004663 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
4664 for (size_t i = 0; i < mAudioSources.size(); i++) {
4665 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
4666 if (sourceDesc != nullptr && sourceDesc->getPatchHandle() == handle) {
4667 portId = sourceDesc->portId();
4668 break;
4669 }
4670 }
4671 return portId != AUDIO_PORT_HANDLE_NONE ?
4672 stopAudioSource(portId) : releaseAudioPatchInternal(handle);
François Gaffieafd4cea2019-11-18 15:50:22 +01004673}
Eric Laurent6a94d692014-05-20 11:18:06 -07004674
François Gaffieafd4cea2019-11-18 15:50:22 +01004675status_t AudioPolicyManager::releaseAudioPatchInternal(audio_patch_handle_t handle,
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004676 uint32_t delayMs,
4677 const sp<SourceClientDescriptor>& sourceDesc)
François Gaffieafd4cea2019-11-18 15:50:22 +01004678{
4679 ALOGV("%s patch %d", __func__, handle);
4680 if (mAudioPatches.indexOfKey(handle) < 0) {
4681 ALOGE("%s: no patch found with handle=%d", __func__, handle);
4682 return BAD_VALUE;
4683 }
4684 sp<AudioPatch> patchDesc = mAudioPatches.valueFor(handle);
Eric Laurent6a94d692014-05-20 11:18:06 -07004685 struct audio_patch *patch = &patchDesc->mPatch;
François Gaffieafd4cea2019-11-18 15:50:22 +01004686 patchDesc->setUid(mUidCached);
Eric Laurent6a94d692014-05-20 11:18:06 -07004687 if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) {
Eric Laurentc75307b2015-03-17 15:29:32 -07004688 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07004689 if (outputDesc == NULL) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004690 ALOGV("%s output not found for id %d", __func__, patch->sources[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07004691 return BAD_VALUE;
4692 }
4693
François Gaffie11d30102018-11-02 16:09:09 +01004694 setOutputDevices(outputDesc,
4695 getNewOutputDevices(outputDesc, true /*fromCache*/),
4696 true,
4697 0,
4698 NULL);
Eric Laurent6a94d692014-05-20 11:18:06 -07004699 } else if (patch->sources[0].type == AUDIO_PORT_TYPE_DEVICE) {
4700 if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
François Gaffie53615e22015-03-19 09:24:12 +01004701 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(patch->sinks[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07004702 if (inputDesc == NULL) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004703 ALOGV("%s input not found for id %d", __func__, patch->sinks[0].id);
Eric Laurent6a94d692014-05-20 11:18:06 -07004704 return BAD_VALUE;
4705 }
4706 setInputDevice(inputDesc->mIoHandle,
Eric Laurentfb66dd92016-01-28 18:32:03 -08004707 getNewInputDevice(inputDesc),
Eric Laurent6a94d692014-05-20 11:18:06 -07004708 true,
4709 NULL);
4710 } else if (patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) {
François Gaffieafd4cea2019-11-18 15:50:22 +01004711 status_t status =
4712 mpClientInterface->releaseAudioPatch(patchDesc->getAfHandle(), delayMs);
4713 ALOGV("%s patch panel returned %d patchHandle %d",
4714 __func__, status, patchDesc->getAfHandle());
4715 removeAudioPatch(patchDesc->getHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07004716 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07004717 mpClientInterface->onAudioPatchListUpdate();
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004718 // SW or HW Bridge
4719 sp<SwAudioOutputDescriptor> outputDesc = nullptr;
4720 audio_patch_handle_t patchHandle = AUDIO_PATCH_HANDLE_NONE;
Francois Gaffie7feb8542020-04-06 17:39:47 +02004721 if (patch->num_sources > 1 && patch->sources[1].type == AUDIO_PORT_TYPE_MIX) {
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02004722 outputDesc = mOutputs.getOutputFromId(patch->sources[1].id);
4723 } else if (patch->num_sources == 1 && sourceDesc != nullptr) {
4724 outputDesc = sourceDesc->swOutput().promote();
4725 }
4726 if (outputDesc == nullptr) {
4727 ALOGW("%s no output for id %d", __func__, patch->sources[0].id);
4728 // releaseOutput has already called closeOutput in case of direct output
4729 return NO_ERROR;
4730 }
François Gaffie1765c5b2022-04-26 12:48:49 +02004731 patchHandle = outputDesc->getPatchHandle();
4732 // When a Sw bridge is released, the mixer used by this bridge will release its
4733 // patch at AudioFlinger side. Hence, the mixer audio patch must be recreated
4734 // Reuse patch handle to force audio flinger removing initial mixer patch removal
4735 // updating hal patch handle (prevent leaks).
4736 // While using a HwBridge, force reconsidering device only if not reusing an existing
4737 // output and no more activity on output (will force to close).
4738 bool force = sourceDesc->useSwBridge() ||
4739 (sourceDesc->canCloseOutput() && !outputDesc->isActive());
4740 // APM pattern is to have always outputs opened / patch realized for reachable devices.
4741 // Update device may result to NONE (empty), coupled with force, it releases the patch.
4742 // Reconsider device only for cases:
4743 // 1 / Active Output
4744 // 2 / Inactive Output previously hosting HwBridge
4745 // 3 / Inactive Output previously hosting SwBridge that can be closed.
4746 bool updateDevice = outputDesc->isActive() || !sourceDesc->useSwBridge() ||
4747 sourceDesc->canCloseOutput();
4748 setOutputDevices(outputDesc,
4749 updateDevice ? getNewOutputDevices(outputDesc, true /*fromCache*/) :
4750 outputDesc->devices(),
4751 force,
4752 0,
4753 patchHandle == AUDIO_PATCH_HANDLE_NONE ? nullptr : &patchHandle);
Eric Laurent6a94d692014-05-20 11:18:06 -07004754 } else {
4755 return BAD_VALUE;
4756 }
4757 } else {
4758 return BAD_VALUE;
4759 }
4760 return NO_ERROR;
4761}
4762
4763status_t AudioPolicyManager::listAudioPatches(unsigned int *num_patches,
4764 struct audio_patch *patches,
4765 unsigned int *generation)
4766{
François Gaffie53615e22015-03-19 09:24:12 +01004767 if (generation == NULL) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004768 return BAD_VALUE;
4769 }
Eric Laurent6a94d692014-05-20 11:18:06 -07004770 *generation = curAudioPortGeneration();
François Gaffie53615e22015-03-19 09:24:12 +01004771 return mAudioPatches.listAudioPatches(num_patches, patches);
Eric Laurent6a94d692014-05-20 11:18:06 -07004772}
4773
Eric Laurente1715a42014-05-20 11:30:42 -07004774status_t AudioPolicyManager::setAudioPortConfig(const struct audio_port_config *config)
Eric Laurent6a94d692014-05-20 11:18:06 -07004775{
Eric Laurente1715a42014-05-20 11:30:42 -07004776 ALOGV("setAudioPortConfig()");
4777
4778 if (config == NULL) {
4779 return BAD_VALUE;
4780 }
4781 ALOGV("setAudioPortConfig() on port handle %d", config->id);
4782 // Only support gain configuration for now
Eric Laurenta121f902014-06-03 13:32:54 -07004783 if (config->config_mask != AUDIO_PORT_CONFIG_GAIN) {
4784 return INVALID_OPERATION;
Eric Laurente1715a42014-05-20 11:30:42 -07004785 }
4786
Eric Laurenta121f902014-06-03 13:32:54 -07004787 sp<AudioPortConfig> audioPortConfig;
Eric Laurente1715a42014-05-20 11:30:42 -07004788 if (config->type == AUDIO_PORT_TYPE_MIX) {
4789 if (config->role == AUDIO_PORT_ROLE_SOURCE) {
Eric Laurentc75307b2015-03-17 15:29:32 -07004790 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(config->id);
Eric Laurente1715a42014-05-20 11:30:42 -07004791 if (outputDesc == NULL) {
4792 return BAD_VALUE;
4793 }
Eric Laurent84c70242014-06-23 08:46:27 -07004794 ALOG_ASSERT(!outputDesc->isDuplicated(),
4795 "setAudioPortConfig() called on duplicated output %d",
4796 outputDesc->mIoHandle);
Eric Laurenta121f902014-06-03 13:32:54 -07004797 audioPortConfig = outputDesc;
Eric Laurente1715a42014-05-20 11:30:42 -07004798 } else if (config->role == AUDIO_PORT_ROLE_SINK) {
François Gaffie53615e22015-03-19 09:24:12 +01004799 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(config->id);
Eric Laurente1715a42014-05-20 11:30:42 -07004800 if (inputDesc == NULL) {
4801 return BAD_VALUE;
4802 }
Eric Laurenta121f902014-06-03 13:32:54 -07004803 audioPortConfig = inputDesc;
Eric Laurente1715a42014-05-20 11:30:42 -07004804 } else {
4805 return BAD_VALUE;
4806 }
4807 } else if (config->type == AUDIO_PORT_TYPE_DEVICE) {
4808 sp<DeviceDescriptor> deviceDesc;
4809 if (config->role == AUDIO_PORT_ROLE_SOURCE) {
4810 deviceDesc = mAvailableInputDevices.getDeviceFromId(config->id);
4811 } else if (config->role == AUDIO_PORT_ROLE_SINK) {
4812 deviceDesc = mAvailableOutputDevices.getDeviceFromId(config->id);
4813 } else {
4814 return BAD_VALUE;
4815 }
4816 if (deviceDesc == NULL) {
4817 return BAD_VALUE;
4818 }
Eric Laurenta121f902014-06-03 13:32:54 -07004819 audioPortConfig = deviceDesc;
Eric Laurente1715a42014-05-20 11:30:42 -07004820 } else {
4821 return BAD_VALUE;
4822 }
4823
Mikhail Naganov7be71d22018-05-23 16:51:46 -07004824 struct audio_port_config backupConfig = {};
Eric Laurenta121f902014-06-03 13:32:54 -07004825 status_t status = audioPortConfig->applyAudioPortConfig(config, &backupConfig);
4826 if (status == NO_ERROR) {
Mikhail Naganov7be71d22018-05-23 16:51:46 -07004827 struct audio_port_config newConfig = {};
Eric Laurenta121f902014-06-03 13:32:54 -07004828 audioPortConfig->toAudioPortConfig(&newConfig, config);
4829 status = mpClientInterface->setAudioPortConfig(&newConfig, 0);
Eric Laurente1715a42014-05-20 11:30:42 -07004830 }
Eric Laurenta121f902014-06-03 13:32:54 -07004831 if (status != NO_ERROR) {
4832 audioPortConfig->applyAudioPortConfig(&backupConfig);
Eric Laurente1715a42014-05-20 11:30:42 -07004833 }
Eric Laurente1715a42014-05-20 11:30:42 -07004834
4835 return status;
Eric Laurent6a94d692014-05-20 11:18:06 -07004836}
4837
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004838void AudioPolicyManager::releaseResourcesForUid(uid_t uid)
4839{
Eric Laurentd60560a2015-04-10 11:31:20 -07004840 clearAudioSources(uid);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004841 clearAudioPatches(uid);
4842 clearSessionRoutes(uid);
4843}
4844
Eric Laurent6a94d692014-05-20 11:18:06 -07004845void AudioPolicyManager::clearAudioPatches(uid_t uid)
4846{
Eric Laurent0add0fd2014-12-04 18:58:14 -08004847 for (ssize_t i = (ssize_t)mAudioPatches.size() - 1; i >= 0; i--) {
Eric Laurent6a94d692014-05-20 11:18:06 -07004848 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(i);
François Gaffieafd4cea2019-11-18 15:50:22 +01004849 if (patchDesc->getUid() == uid) {
Eric Laurent0add0fd2014-12-04 18:58:14 -08004850 releaseAudioPatch(mAudioPatches.keyAt(i), uid);
Eric Laurent6a94d692014-05-20 11:18:06 -07004851 }
4852 }
4853}
4854
François Gaffiec005e562018-11-06 15:04:49 +01004855void AudioPolicyManager::checkStrategyRoute(product_strategy_t ps, audio_io_handle_t ouptutToSkip)
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004856{
François Gaffiec005e562018-11-06 15:04:49 +01004857 // Take the first attributes following the product strategy as it is used to retrieve the routed
4858 // device. All attributes wihin a strategy follows the same "routing strategy"
4859 auto attributes = mEngine->getAllAttributesForProductStrategy(ps).front();
4860 DeviceVector devices = mEngine->getOutputDevicesForAttributes(attributes, nullptr, false);
François Gaffie11d30102018-11-02 16:09:09 +01004861 SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004862 for (size_t j = 0; j < mOutputs.size(); j++) {
4863 if (mOutputs.keyAt(j) == ouptutToSkip) {
4864 continue;
4865 }
4866 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(j);
François Gaffiec005e562018-11-06 15:04:49 +01004867 if (!outputDesc->isStrategyActive(ps)) {
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004868 continue;
4869 }
4870 // If the default device for this strategy is on another output mix,
4871 // invalidate all tracks in this strategy to force re connection.
4872 // Otherwise select new device on the output mix.
4873 if (outputs.indexOf(mOutputs.keyAt(j)) < 0) {
François Gaffiec005e562018-11-06 15:04:49 +01004874 for (auto stream : mEngine->getStreamTypesForProductStrategy(ps)) {
4875 mpClientInterface->invalidateStream(stream);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004876 }
4877 } else {
François Gaffie11d30102018-11-02 16:09:09 +01004878 setOutputDevices(
4879 outputDesc, getNewOutputDevices(outputDesc, false /*fromCache*/), false);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004880 }
4881 }
4882}
4883
4884void AudioPolicyManager::clearSessionRoutes(uid_t uid)
4885{
4886 // remove output routes associated with this uid
François Gaffiec005e562018-11-06 15:04:49 +01004887 std::vector<product_strategy_t> affectedStrategies;
Eric Laurent97ac8712018-07-27 18:59:02 -07004888 for (size_t i = 0; i < mOutputs.size(); i++) {
4889 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
Andy Hung39efb7a2018-09-26 15:39:28 -07004890 for (const auto& client : outputDesc->getClientIterable()) {
4891 if (client->hasPreferredDevice() && client->uid() == uid) {
4892 client->setPreferredDeviceId(AUDIO_PORT_HANDLE_NONE);
François Gaffiec005e562018-11-06 15:04:49 +01004893 auto clientStrategy = client->strategy();
4894 if (std::find(begin(affectedStrategies), end(affectedStrategies), clientStrategy) !=
4895 end(affectedStrategies)) {
4896 continue;
4897 }
4898 affectedStrategies.push_back(client->strategy());
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004899 }
4900 }
4901 }
4902 // reroute outputs if necessary
Mikhail Naganovcf84e592017-12-07 11:25:11 -08004903 for (const auto& strategy : affectedStrategies) {
4904 checkStrategyRoute(strategy, AUDIO_IO_HANDLE_NONE);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004905 }
4906
4907 // remove input routes associated with this uid
4908 SortedVector<audio_source_t> affectedSources;
Eric Laurent97ac8712018-07-27 18:59:02 -07004909 for (size_t i = 0; i < mInputs.size(); i++) {
4910 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(i);
Andy Hung39efb7a2018-09-26 15:39:28 -07004911 for (const auto& client : inputDesc->getClientIterable()) {
4912 if (client->hasPreferredDevice() && client->uid() == uid) {
4913 client->setPreferredDeviceId(AUDIO_PORT_HANDLE_NONE);
4914 affectedSources.add(client->source());
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004915 }
4916 }
4917 }
4918 // reroute inputs if necessary
4919 SortedVector<audio_io_handle_t> inputsToClose;
4920 for (size_t i = 0; i < mInputs.size(); i++) {
4921 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(i);
Eric Laurent4eb58f12018-12-07 16:41:02 -08004922 if (affectedSources.indexOf(inputDesc->source()) >= 0) {
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004923 inputsToClose.add(inputDesc->mIoHandle);
4924 }
4925 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08004926 for (const auto& input : inputsToClose) {
4927 closeInput(input);
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004928 }
4929}
4930
Eric Laurentd60560a2015-04-10 11:31:20 -07004931void AudioPolicyManager::clearAudioSources(uid_t uid)
4932{
4933 for (ssize_t i = (ssize_t)mAudioSources.size() - 1; i >= 0; i--) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004934 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
4935 if (sourceDesc->uid() == uid) {
Eric Laurentd60560a2015-04-10 11:31:20 -07004936 stopAudioSource(mAudioSources.keyAt(i));
4937 }
4938 }
4939}
Eric Laurent8c7e6da2015-04-21 17:37:00 -07004940
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07004941status_t AudioPolicyManager::acquireSoundTriggerSession(audio_session_t *session,
4942 audio_io_handle_t *ioHandle,
4943 audio_devices_t *device)
4944{
Glenn Kastenf0c6d7d2016-02-26 10:44:04 -08004945 *session = (audio_session_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
4946 *ioHandle = (audio_io_handle_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_INPUT);
Francois Gaffie716e1432019-01-14 16:58:59 +01004947 audio_attributes_t attr = { .source = AUDIO_SOURCE_HOTWORD };
François Gaffiec005e562018-11-06 15:04:49 +01004948 *device = mEngine->getInputDeviceForAttributes(attr)->type();
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07004949
François Gaffiedf372692015-03-19 10:43:27 +01004950 return mSoundTriggerSessions.acquireSession(*session, *ioHandle);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07004951}
4952
Eric Laurentd60560a2015-04-10 11:31:20 -07004953status_t AudioPolicyManager::startAudioSource(const struct audio_port_config *source,
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004954 const audio_attributes_t *attributes,
4955 audio_port_handle_t *portId,
4956 uid_t uid)
Eric Laurent554a2772015-04-10 11:29:24 -07004957{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004958 ALOGV("%s", __FUNCTION__);
4959 *portId = AUDIO_PORT_HANDLE_NONE;
4960
4961 if (source == NULL || attributes == NULL || portId == NULL) {
4962 ALOGW("%s invalid argument: source %p attributes %p handle %p",
4963 __FUNCTION__, source, attributes, portId);
Eric Laurentd60560a2015-04-10 11:31:20 -07004964 return BAD_VALUE;
4965 }
4966
Eric Laurentd60560a2015-04-10 11:31:20 -07004967 if (source->role != AUDIO_PORT_ROLE_SOURCE ||
4968 source->type != AUDIO_PORT_TYPE_DEVICE) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004969 ALOGW("%s INVALID_OPERATION source->role %d source->type %d",
4970 __FUNCTION__, source->role, source->type);
Eric Laurentd60560a2015-04-10 11:31:20 -07004971 return INVALID_OPERATION;
4972 }
4973
François Gaffie11d30102018-11-02 16:09:09 +01004974 sp<DeviceDescriptor> srcDevice =
Eric Laurentd60560a2015-04-10 11:31:20 -07004975 mAvailableInputDevices.getDevice(source->ext.device.type,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08004976 String8(source->ext.device.address),
4977 AUDIO_FORMAT_DEFAULT);
François Gaffie11d30102018-11-02 16:09:09 +01004978 if (srcDevice == 0) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004979 ALOGW("%s source->ext.device.type %08x not found", __FUNCTION__, source->ext.device.type);
Eric Laurentd60560a2015-04-10 11:31:20 -07004980 return BAD_VALUE;
4981 }
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004982
jiabin4ef93452019-09-10 14:29:54 -07004983 *portId = PolicyAudioPort::getNextUniqueId();
Eric Laurentd60560a2015-04-10 11:31:20 -07004984
François Gaffieaaac0fd2018-11-22 17:56:39 +01004985 sp<SourceClientDescriptor> sourceDesc =
François Gaffieafd4cea2019-11-18 15:50:22 +01004986 new SourceClientDescriptor(*portId, uid, *attributes, *source, srcDevice,
François Gaffieaaac0fd2018-11-22 17:56:39 +01004987 mEngine->getStreamTypeForAttributes(*attributes),
4988 mEngine->getProductStrategyForAttributes(*attributes),
4989 toVolumeSource(*attributes));
Eric Laurentd60560a2015-04-10 11:31:20 -07004990
4991 status_t status = connectAudioSource(sourceDesc);
4992 if (status == NO_ERROR) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07004993 mAudioSources.add(*portId, sourceDesc);
Eric Laurentd60560a2015-04-10 11:31:20 -07004994 }
4995 return status;
4996}
4997
Francois Gaffie601801d2021-06-22 13:27:39 +02004998sp<SourceClientDescriptor> AudioPolicyManager::startAudioSourceInternal(
4999 const struct audio_port_config *source, const audio_attributes_t *attributes, uid_t uid)
5000{
5001 ALOGV("%s", __FUNCTION__);
5002 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
5003
5004 status_t status = startAudioSource(source, attributes, &portId, uid);
5005 ALOGE_IF(status != OK, "%s: failed to start audio source (%d)", __func__, status);
5006 return mAudioSources.valueFor(portId);
5007}
5008
5009
Eric Laurent3e6c7e12018-07-27 17:09:23 -07005010status_t AudioPolicyManager::connectAudioSource(const sp<SourceClientDescriptor>& sourceDesc)
Eric Laurentd60560a2015-04-10 11:31:20 -07005011{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07005012 ALOGV("%s handle %d", __FUNCTION__, sourceDesc->portId());
Eric Laurentd60560a2015-04-10 11:31:20 -07005013
5014 // make sure we only have one patch per source.
5015 disconnectAudioSource(sourceDesc);
5016
Eric Laurent3e6c7e12018-07-27 17:09:23 -07005017 audio_attributes_t attributes = sourceDesc->attributes();
Francois Gaffiea0e5c992020-09-29 16:05:07 +02005018 // May the device (dynamic) have been disconnected/reconnected, id has changed.
5019 sp<DeviceDescriptor> srcDevice = mAvailableInputDevices.getDevice(
5020 sourceDesc->srcDevice()->type(),
5021 String8(sourceDesc->srcDevice()->address().c_str()),
5022 AUDIO_FORMAT_DEFAULT);
François Gaffiec005e562018-11-06 15:04:49 +01005023 DeviceVector sinkDevices =
Francois Gaffieff1eb522020-05-06 18:37:04 +02005024 mEngine->getOutputDevicesForAttributes(attributes, nullptr, false /*fromCache*/);
François Gaffiec005e562018-11-06 15:04:49 +01005025 ALOG_ASSERT(!sinkDevices.isEmpty(), "connectAudioSource(): no device found for attributes");
François Gaffie11d30102018-11-02 16:09:09 +01005026 sp<DeviceDescriptor> sinkDevice = sinkDevices.itemAt(0);
Francois Gaffiea0e5c992020-09-29 16:05:07 +02005027 if (!mAvailableOutputDevices.contains(sinkDevice)) {
5028 ALOGE("%s Device %s not available", __func__, sinkDevice->toString().c_str());
5029 return INVALID_OPERATION;
5030 }
François Gaffieafd4cea2019-11-18 15:50:22 +01005031 PatchBuilder patchBuilder;
5032 patchBuilder.addSink(sinkDevice).addSource(srcDevice);
5033 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
François Gaffieafd4cea2019-11-18 15:50:22 +01005034
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02005035 return connectAudioSourceToSink(
5036 sourceDesc, sinkDevice, patchBuilder.patch(), handle, mUidCached, 0 /*delayMs*/);
Eric Laurent554a2772015-04-10 11:29:24 -07005037}
5038
Eric Laurent3e6c7e12018-07-27 17:09:23 -07005039status_t AudioPolicyManager::stopAudioSource(audio_port_handle_t portId)
Eric Laurent554a2772015-04-10 11:29:24 -07005040{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07005041 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueFor(portId);
5042 ALOGV("%s port ID %d", __FUNCTION__, portId);
Eric Laurentd60560a2015-04-10 11:31:20 -07005043 if (sourceDesc == 0) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07005044 ALOGW("%s unknown source for port ID %d", __FUNCTION__, portId);
Eric Laurentd60560a2015-04-10 11:31:20 -07005045 return BAD_VALUE;
5046 }
5047 status_t status = disconnectAudioSource(sourceDesc);
5048
Eric Laurent3e6c7e12018-07-27 17:09:23 -07005049 mAudioSources.removeItem(portId);
Eric Laurentd60560a2015-04-10 11:31:20 -07005050 return status;
5051}
5052
Andy Hung2ddee192015-12-18 17:34:44 -08005053status_t AudioPolicyManager::setMasterMono(bool mono)
5054{
5055 if (mMasterMono == mono) {
5056 return NO_ERROR;
5057 }
5058 mMasterMono = mono;
5059 // if enabling mono we close all offloaded devices, which will invalidate the
5060 // corresponding AudioTrack. The AudioTrack client/MediaPlayer is responsible
5061 // for recreating the new AudioTrack as non-offloaded PCM.
5062 //
5063 // If disabling mono, we leave all tracks as is: we don't know which clients
5064 // and tracks are able to be recreated as offloaded. The next "song" should
5065 // play back offloaded.
5066 if (mMasterMono) {
5067 Vector<audio_io_handle_t> offloaded;
5068 for (size_t i = 0; i < mOutputs.size(); ++i) {
5069 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
5070 if (desc->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
5071 offloaded.push(desc->mIoHandle);
5072 }
5073 }
Mikhail Naganovcf84e592017-12-07 11:25:11 -08005074 for (const auto& handle : offloaded) {
5075 closeOutput(handle);
Andy Hung2ddee192015-12-18 17:34:44 -08005076 }
5077 }
5078 // update master mono for all remaining outputs
5079 for (size_t i = 0; i < mOutputs.size(); ++i) {
5080 updateMono(mOutputs.keyAt(i));
5081 }
5082 return NO_ERROR;
5083}
5084
5085status_t AudioPolicyManager::getMasterMono(bool *mono)
5086{
5087 *mono = mMasterMono;
5088 return NO_ERROR;
5089}
5090
Eric Laurentac9cef52017-06-09 15:46:26 -07005091float AudioPolicyManager::getStreamVolumeDB(
5092 audio_stream_type_t stream, int index, audio_devices_t device)
5093{
jiabin9a3361e2019-10-01 09:38:30 -07005094 return computeVolume(getVolumeCurves(stream), toVolumeSource(stream), index, {device});
Eric Laurentac9cef52017-06-09 15:46:26 -07005095}
5096
jiabin81772902018-04-02 17:52:27 -07005097status_t AudioPolicyManager::getSurroundFormats(unsigned int *numSurroundFormats,
5098 audio_format_t *surroundFormats,
Kriti Dang6537def2021-03-02 13:46:59 +01005099 bool *surroundFormatsEnabled)
jiabin81772902018-04-02 17:52:27 -07005100{
Kriti Dang6537def2021-03-02 13:46:59 +01005101 if (numSurroundFormats == nullptr || (*numSurroundFormats != 0 &&
5102 (surroundFormats == nullptr || surroundFormatsEnabled == nullptr))) {
jiabin81772902018-04-02 17:52:27 -07005103 return BAD_VALUE;
5104 }
Kriti Dang6537def2021-03-02 13:46:59 +01005105 ALOGV("%s() numSurroundFormats %d surroundFormats %p surroundFormatsEnabled %p",
5106 __func__, *numSurroundFormats, surroundFormats, surroundFormatsEnabled);
jiabin81772902018-04-02 17:52:27 -07005107
5108 size_t formatsWritten = 0;
5109 size_t formatsMax = *numSurroundFormats;
Kriti Dangef6be8f2020-11-05 11:58:19 +01005110
Kriti Dang6537def2021-03-02 13:46:59 +01005111 *numSurroundFormats = mConfig.getSurroundFormats().size();
Mikhail Naganov100f0122018-11-29 11:22:16 -08005112 audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
5113 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
Kriti Dang6537def2021-03-02 13:46:59 +01005114 for (const auto& format: mConfig.getSurroundFormats()) {
jiabin81772902018-04-02 17:52:27 -07005115 if (formatsWritten < formatsMax) {
Kriti Dang6537def2021-03-02 13:46:59 +01005116 surroundFormats[formatsWritten] = format.first;
Mikhail Naganov100f0122018-11-29 11:22:16 -08005117 bool formatEnabled = true;
5118 switch (forceUse) {
5119 case AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL:
Kriti Dang6537def2021-03-02 13:46:59 +01005120 formatEnabled = mManualSurroundFormats.count(format.first) != 0;
Mikhail Naganov100f0122018-11-29 11:22:16 -08005121 break;
5122 case AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER:
5123 formatEnabled = false;
5124 break;
5125 default: // AUTO or ALWAYS => true
5126 break;
jiabin81772902018-04-02 17:52:27 -07005127 }
5128 surroundFormatsEnabled[formatsWritten++] = formatEnabled;
5129 }
jiabin81772902018-04-02 17:52:27 -07005130 }
5131 return NO_ERROR;
5132}
5133
Kriti Dang6537def2021-03-02 13:46:59 +01005134status_t AudioPolicyManager::getReportedSurroundFormats(unsigned int *numSurroundFormats,
5135 audio_format_t *surroundFormats) {
5136 if (numSurroundFormats == nullptr || (*numSurroundFormats != 0 && surroundFormats == nullptr)) {
5137 return BAD_VALUE;
5138 }
5139 ALOGV("%s() numSurroundFormats %d surroundFormats %p",
5140 __func__, *numSurroundFormats, surroundFormats);
5141
5142 size_t formatsWritten = 0;
5143 size_t formatsMax = *numSurroundFormats;
5144 std::unordered_set<audio_format_t> formats; // Uses primary surround formats only
5145
5146 // Return formats from all device profiles that have already been resolved by
5147 // checkOutputsForDevice().
5148 for (size_t i = 0; i < mAvailableOutputDevices.size(); i++) {
5149 sp<DeviceDescriptor> device = mAvailableOutputDevices[i];
5150 audio_devices_t deviceType = device->type();
5151 // Enabling/disabling formats are applied to only HDMI devices. So, this function
5152 // returns formats reported by HDMI devices.
5153 if (deviceType != AUDIO_DEVICE_OUT_HDMI) {
5154 continue;
5155 }
5156 // Formats reported by sink devices
5157 std::unordered_set<audio_format_t> formatset;
5158 if (auto it = mReportedFormatsMap.find(device); it != mReportedFormatsMap.end()) {
5159 formatset.insert(it->second.begin(), it->second.end());
5160 }
5161
5162 // Formats hard-coded in the in policy configuration file (if any).
5163 FormatVector encodedFormats = device->encodedFormats();
5164 formatset.insert(encodedFormats.begin(), encodedFormats.end());
5165 // Filter the formats which are supported by the vendor hardware.
5166 for (auto it = formatset.begin(); it != formatset.end(); ++it) {
5167 if (mConfig.getSurroundFormats().count(*it) != 0) {
5168 formats.insert(*it);
5169 } else {
5170 for (const auto& pair : mConfig.getSurroundFormats()) {
5171 if (pair.second.count(*it) != 0) {
5172 formats.insert(pair.first);
5173 break;
5174 }
5175 }
5176 }
5177 }
5178 }
5179 *numSurroundFormats = formats.size();
5180 for (const auto& format: formats) {
5181 if (formatsWritten < formatsMax) {
5182 surroundFormats[formatsWritten++] = format;
5183 }
5184 }
5185 return NO_ERROR;
5186}
5187
jiabin81772902018-04-02 17:52:27 -07005188status_t AudioPolicyManager::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
5189{
Mikhail Naganov5dddbfd2018-09-11 14:15:05 -07005190 ALOGV("%s() format 0x%X enabled %d", __func__, audioFormat, enabled);
Mikhail Naganov778bc1f2018-09-14 16:28:52 -07005191 const auto& formatIter = mConfig.getSurroundFormats().find(audioFormat);
5192 if (formatIter == mConfig.getSurroundFormats().end()) {
Mikhail Naganov5dddbfd2018-09-11 14:15:05 -07005193 ALOGW("%s() format 0x%X is not a known surround format", __func__, audioFormat);
jiabin81772902018-04-02 17:52:27 -07005194 return BAD_VALUE;
5195 }
5196
Mikhail Naganov100f0122018-11-29 11:22:16 -08005197 if (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND) !=
5198 AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
Mikhail Naganov5dddbfd2018-09-11 14:15:05 -07005199 ALOGW("%s() not in manual mode for surround sound format selection", __func__);
jiabin81772902018-04-02 17:52:27 -07005200 return INVALID_OPERATION;
5201 }
5202
Mikhail Naganov100f0122018-11-29 11:22:16 -08005203 if ((mManualSurroundFormats.count(audioFormat) != 0) == enabled) {
jiabin81772902018-04-02 17:52:27 -07005204 return NO_ERROR;
5205 }
5206
Mikhail Naganov100f0122018-11-29 11:22:16 -08005207 std::unordered_set<audio_format_t> surroundFormatsBackup(mManualSurroundFormats);
jiabin81772902018-04-02 17:52:27 -07005208 if (enabled) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08005209 mManualSurroundFormats.insert(audioFormat);
Mikhail Naganov778bc1f2018-09-14 16:28:52 -07005210 for (const auto& subFormat : formatIter->second) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08005211 mManualSurroundFormats.insert(subFormat);
jiabin81772902018-04-02 17:52:27 -07005212 }
5213 } else {
Mikhail Naganov100f0122018-11-29 11:22:16 -08005214 mManualSurroundFormats.erase(audioFormat);
Mikhail Naganov778bc1f2018-09-14 16:28:52 -07005215 for (const auto& subFormat : formatIter->second) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08005216 mManualSurroundFormats.erase(subFormat);
jiabin81772902018-04-02 17:52:27 -07005217 }
5218 }
5219
5220 sp<SwAudioOutputDescriptor> outputDesc;
5221 bool profileUpdated = false;
jiabin9a3361e2019-10-01 09:38:30 -07005222 DeviceVector hdmiOutputDevices = mAvailableOutputDevices.getDevicesFromType(
5223 AUDIO_DEVICE_OUT_HDMI);
jiabin81772902018-04-02 17:52:27 -07005224 for (size_t i = 0; i < hdmiOutputDevices.size(); i++) {
5225 // Simulate reconnection to update enabled surround sound formats.
jiabince9f20e2019-09-12 16:29:15 -07005226 String8 address = String8(hdmiOutputDevices[i]->address().c_str());
jiabin5740f082019-08-19 15:08:30 -07005227 std::string name = hdmiOutputDevices[i]->getName();
jiabin81772902018-04-02 17:52:27 -07005228 status_t status = setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_HDMI,
5229 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
5230 address.c_str(),
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005231 name.c_str(),
5232 AUDIO_FORMAT_DEFAULT);
jiabin81772902018-04-02 17:52:27 -07005233 if (status != NO_ERROR) {
5234 continue;
5235 }
5236 status = setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_HDMI,
5237 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
5238 address.c_str(),
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005239 name.c_str(),
5240 AUDIO_FORMAT_DEFAULT);
jiabin81772902018-04-02 17:52:27 -07005241 profileUpdated |= (status == NO_ERROR);
5242 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08005243 // FIXME: Why doing this for input HDMI devices if we don't augment their reported formats?
jiabin9a3361e2019-10-01 09:38:30 -07005244 DeviceVector hdmiInputDevices = mAvailableInputDevices.getDevicesFromType(
jiabin81772902018-04-02 17:52:27 -07005245 AUDIO_DEVICE_IN_HDMI);
5246 for (size_t i = 0; i < hdmiInputDevices.size(); i++) {
5247 // Simulate reconnection to update enabled surround sound formats.
jiabince9f20e2019-09-12 16:29:15 -07005248 String8 address = String8(hdmiInputDevices[i]->address().c_str());
jiabin5740f082019-08-19 15:08:30 -07005249 std::string name = hdmiInputDevices[i]->getName();
jiabin81772902018-04-02 17:52:27 -07005250 status_t status = setDeviceConnectionStateInt(AUDIO_DEVICE_IN_HDMI,
5251 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
5252 address.c_str(),
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005253 name.c_str(),
5254 AUDIO_FORMAT_DEFAULT);
jiabin81772902018-04-02 17:52:27 -07005255 if (status != NO_ERROR) {
5256 continue;
5257 }
5258 status = setDeviceConnectionStateInt(AUDIO_DEVICE_IN_HDMI,
5259 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
5260 address.c_str(),
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005261 name.c_str(),
5262 AUDIO_FORMAT_DEFAULT);
jiabin81772902018-04-02 17:52:27 -07005263 profileUpdated |= (status == NO_ERROR);
5264 }
5265
jiabin81772902018-04-02 17:52:27 -07005266 if (!profileUpdated) {
Mikhail Naganov5dddbfd2018-09-11 14:15:05 -07005267 ALOGW("%s() no audio profiles updated, undoing surround formats change", __func__);
Mikhail Naganov100f0122018-11-29 11:22:16 -08005268 mManualSurroundFormats = std::move(surroundFormatsBackup);
jiabin81772902018-04-02 17:52:27 -07005269 }
5270
5271 return profileUpdated ? NO_ERROR : INVALID_OPERATION;
5272}
5273
Eric Laurent5ada82e2019-08-29 17:53:54 -07005274void AudioPolicyManager::setAppState(audio_port_handle_t portId, app_state_t state)
Svet Ganovf4ddfef2018-01-16 07:37:58 -08005275{
Eric Laurent5ada82e2019-08-29 17:53:54 -07005276 ALOGV("%s(portId:%d, state:%d)", __func__, portId, state);
Eric Laurenta9f86652018-11-28 17:23:11 -08005277 for (size_t i = 0; i < mInputs.size(); i++) {
Eric Laurent5ada82e2019-08-29 17:53:54 -07005278 mInputs.valueAt(i)->setAppState(portId, state);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08005279 }
5280}
5281
jiabin6012f912018-11-02 17:06:30 -07005282bool AudioPolicyManager::isHapticPlaybackSupported()
5283{
5284 for (const auto& hwModule : mHwModules) {
5285 const OutputProfileCollection &outputProfiles = hwModule->getOutputProfiles();
5286 for (const auto &outProfile : outputProfiles) {
5287 struct audio_port audioPort;
5288 outProfile->toAudioPort(&audioPort);
5289 for (size_t i = 0; i < audioPort.num_channel_masks; i++) {
5290 if (audioPort.channel_masks[i] & AUDIO_CHANNEL_HAPTIC_ALL) {
5291 return true;
5292 }
5293 }
5294 }
5295 }
5296 return false;
5297}
5298
Carter Hsu325a8eb2022-01-19 19:56:51 +08005299bool AudioPolicyManager::isUltrasoundSupported()
5300{
5301 bool hasUltrasoundOutput = false;
5302 bool hasUltrasoundInput = false;
5303 for (const auto& hwModule : mHwModules) {
5304 const OutputProfileCollection &outputProfiles = hwModule->getOutputProfiles();
5305 if (!hasUltrasoundOutput) {
5306 for (const auto &outProfile : outputProfiles) {
5307 if (outProfile->getFlags() & AUDIO_OUTPUT_FLAG_ULTRASOUND) {
5308 hasUltrasoundOutput = true;
5309 break;
5310 }
5311 }
5312 }
5313
5314 const InputProfileCollection &inputProfiles = hwModule->getInputProfiles();
5315 if (!hasUltrasoundInput) {
5316 for (const auto &inputProfile : inputProfiles) {
5317 if (inputProfile->getFlags() & AUDIO_INPUT_FLAG_ULTRASOUND) {
5318 hasUltrasoundInput = true;
5319 break;
5320 }
5321 }
5322 }
5323
5324 if (hasUltrasoundOutput && hasUltrasoundInput)
5325 return true;
5326 }
5327 return false;
5328}
5329
Eric Laurent8340e672019-11-06 11:01:08 -08005330bool AudioPolicyManager::isCallScreenModeSupported()
5331{
5332 return getConfig().isCallScreenModeSupported();
5333}
5334
5335
Eric Laurent3e6c7e12018-07-27 17:09:23 -07005336status_t AudioPolicyManager::disconnectAudioSource(const sp<SourceClientDescriptor>& sourceDesc)
Eric Laurentd60560a2015-04-10 11:31:20 -07005337{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07005338 ALOGV("%s port Id %d", __FUNCTION__, sourceDesc->portId());
Francois Gaffiea0e5c992020-09-29 16:05:07 +02005339 if (!sourceDesc->isConnected()) {
5340 ALOGV("%s port Id %d already disconnected", __FUNCTION__, sourceDesc->portId());
5341 return NO_ERROR;
5342 }
François Gaffieafd4cea2019-11-18 15:50:22 +01005343 sp<SwAudioOutputDescriptor> swOutput = sourceDesc->swOutput().promote();
5344 if (swOutput != 0) {
5345 status_t status = stopSource(swOutput, sourceDesc);
Eric Laurent733ce942017-12-07 12:18:25 -08005346 if (status == NO_ERROR) {
François Gaffieafd4cea2019-11-18 15:50:22 +01005347 swOutput->stop();
Eric Laurent733ce942017-12-07 12:18:25 -08005348 }
jiabinbce0c1d2020-10-05 11:20:18 -07005349 if (releaseOutput(sourceDesc->portId())) {
5350 // The output descriptor is reopened to query dynamic profiles. In that case, there is
5351 // no need to release audio patch here but just return NO_ERROR.
5352 return NO_ERROR;
5353 }
Eric Laurentd60560a2015-04-10 11:31:20 -07005354 } else {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07005355 sp<HwAudioOutputDescriptor> hwOutputDesc = sourceDesc->hwOutput().promote();
Eric Laurentd60560a2015-04-10 11:31:20 -07005356 if (hwOutputDesc != 0) {
Eric Laurentd60560a2015-04-10 11:31:20 -07005357 // close Hwoutput and remove from mHwOutputs
5358 } else {
5359 ALOGW("%s source has neither SW nor HW output", __FUNCTION__);
5360 }
5361 }
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02005362 status_t status = releaseAudioPatchInternal(sourceDesc->getPatchHandle(), 0, sourceDesc);
Francois Gaffiea0e5c992020-09-29 16:05:07 +02005363 sourceDesc->disconnect();
5364 return status;
Eric Laurentd60560a2015-04-10 11:31:20 -07005365}
5366
François Gaffiec005e562018-11-06 15:04:49 +01005367sp<SourceClientDescriptor> AudioPolicyManager::getSourceForAttributesOnOutput(
5368 audio_io_handle_t output, const audio_attributes_t &attr)
Eric Laurentd60560a2015-04-10 11:31:20 -07005369{
Eric Laurent3e6c7e12018-07-27 17:09:23 -07005370 sp<SourceClientDescriptor> source;
Eric Laurentd60560a2015-04-10 11:31:20 -07005371 for (size_t i = 0; i < mAudioSources.size(); i++) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07005372 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
Eric Laurent3e6c7e12018-07-27 17:09:23 -07005373 sp<SwAudioOutputDescriptor> outputDesc = sourceDesc->swOutput().promote();
François Gaffiec005e562018-11-06 15:04:49 +01005374 if (followsSameRouting(attr, sourceDesc->attributes()) &&
5375 outputDesc != 0 && outputDesc->mIoHandle == output) {
Eric Laurentd60560a2015-04-10 11:31:20 -07005376 source = sourceDesc;
5377 break;
5378 }
5379 }
5380 return source;
Eric Laurent554a2772015-04-10 11:29:24 -07005381}
5382
Eric Laurentb4f42a92022-01-17 17:37:31 +01005383bool AudioPolicyManager::canBeSpatializedInt(const audio_attributes_t *attr,
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005384 const audio_config_t *config,
Andy Hung9dd1a5b2022-05-10 15:39:39 -07005385 const AudioDeviceTypeAddrVector &devices) const
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005386{
5387 // The caller can have the audio attributes criteria ignored by either passing a null ptr or
5388 // the AUDIO_ATTRIBUTES_INITIALIZER value.
Eric Laurentfa0f6742021-08-17 18:39:44 +02005389 // If attributes are specified, current policy is to only allow spatialization for media
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005390 // and game usages.
Eric Laurent39095982021-08-24 18:29:27 +02005391 if (attr != nullptr && *attr != AUDIO_ATTRIBUTES_INITIALIZER) {
5392 if (attr->usage != AUDIO_USAGE_MEDIA && attr->usage != AUDIO_USAGE_GAME) {
5393 return false;
5394 }
5395 if ((attr->flags & (AUDIO_FLAG_CONTENT_SPATIALIZED | AUDIO_FLAG_NEVER_SPATIALIZE)) != 0) {
5396 return false;
5397 }
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005398 }
5399
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005400 sp<IOProfile> profile =
Eric Laurent39095982021-08-24 18:29:27 +02005401 getSpatializerOutputProfile(config, devices);
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005402 if (profile == nullptr) {
5403 return false;
5404 }
5405
5406 // The caller can have the audio config criteria ignored by either passing a null ptr or
5407 // the AUDIO_CONFIG_INITIALIZER value.
Eric Laurentfa0f6742021-08-17 18:39:44 +02005408 // If an audio config is specified, current policy is to only allow spatialization for
Eric Laurent39095982021-08-24 18:29:27 +02005409 // some positional channel masks.
Eric Laurent39095982021-08-24 18:29:27 +02005410
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005411 if (config != nullptr && *config != AUDIO_CONFIG_INITIALIZER) {
Andy Hung9dd1a5b2022-05-10 15:39:39 -07005412 if (!audio_is_channel_mask_spatialized(config->channel_mask)) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005413 return false;
5414 }
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005415 }
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005416 return true;
5417}
5418
5419void AudioPolicyManager::checkVirtualizerClientRoutes() {
5420 std::set<audio_stream_type_t> streamsToInvalidate;
5421 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurent39095982021-08-24 18:29:27 +02005422 const sp<SwAudioOutputDescriptor>& desc = mOutputs[i];
5423 for (const sp<TrackClientDescriptor>& client : desc->getClientIterable()) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005424 audio_attributes_t attr = client->attributes();
5425 DeviceVector devices = mEngine->getOutputDevicesForAttributes(attr, nullptr, false);
5426 AudioDeviceTypeAddrVector devicesTypeAddress = devices.toTypeAddrVector();
5427 audio_config_base_t clientConfig = client->config();
5428 audio_config_t config = audio_config_initializer(&clientConfig);
Eric Laurent39095982021-08-24 18:29:27 +02005429 if (desc != mSpatializerOutput
Andy Hung9dd1a5b2022-05-10 15:39:39 -07005430 && canBeSpatializedInt(&attr, &config, devicesTypeAddress)) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005431 streamsToInvalidate.insert(client->stream());
5432 }
5433 }
5434 }
5435
5436 for (audio_stream_type_t stream : streamsToInvalidate) {
5437 mpClientInterface->invalidateStream(stream);
5438 }
5439}
5440
Eric Laurente191d1b2022-04-15 11:59:25 +02005441
5442bool AudioPolicyManager::isOutputOnlyAvailableRouteToSomeDevice(
5443 const sp<SwAudioOutputDescriptor>& outputDesc) {
5444 if (outputDesc->isDuplicated()) {
5445 return false;
5446 }
5447 DeviceVector devices = outputDesc->supportedDevices();
5448 for (size_t i = 0; i < mOutputs.size(); i++) {
5449 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
5450 if (desc == outputDesc || desc->isDuplicated()) {
5451 continue;
5452 }
5453 DeviceVector sharedDevices = desc->filterSupportedDevices(devices);
5454 if (!sharedDevices.isEmpty()
5455 && (desc->devicesSupportEncodedFormats(sharedDevices.types())
5456 == outputDesc->devicesSupportEncodedFormats(sharedDevices.types()))) {
5457 return false;
5458 }
5459 }
5460 return true;
5461}
5462
5463
Eric Laurentfa0f6742021-08-17 18:39:44 +02005464status_t AudioPolicyManager::getSpatializerOutput(const audio_config_base_t *mixerConfig,
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005465 const audio_attributes_t *attr,
5466 audio_io_handle_t *output) {
5467 *output = AUDIO_IO_HANDLE_NONE;
5468
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005469 DeviceVector devices = mEngine->getOutputDevicesForAttributes(*attr, nullptr, false);
5470 AudioDeviceTypeAddrVector devicesTypeAddress = devices.toTypeAddrVector();
5471 audio_config_t *configPtr = nullptr;
5472 audio_config_t config;
5473 if (mixerConfig != nullptr) {
5474 config = audio_config_initializer(mixerConfig);
5475 configPtr = &config;
5476 }
Andy Hung9dd1a5b2022-05-10 15:39:39 -07005477 if (!canBeSpatializedInt(attr, configPtr, devicesTypeAddress)) {
Eric Laurente191d1b2022-04-15 11:59:25 +02005478 ALOGV("%s provided attributes or mixer config cannot be spatialized", __func__);
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005479 return BAD_VALUE;
5480 }
5481
5482 sp<IOProfile> profile =
Eric Laurent39095982021-08-24 18:29:27 +02005483 getSpatializerOutputProfile(configPtr, devicesTypeAddress);
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005484 if (profile == nullptr) {
Eric Laurente191d1b2022-04-15 11:59:25 +02005485 ALOGV("%s no suitable output profile for provided attributes or mixer config", __func__);
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005486 return BAD_VALUE;
5487 }
5488
Eric Laurente191d1b2022-04-15 11:59:25 +02005489 std::vector<sp<SwAudioOutputDescriptor>> spatializerOutputs;
Eric Laurent39095982021-08-24 18:29:27 +02005490 for (size_t i = 0; i < mOutputs.size(); i++) {
5491 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
Eric Laurente191d1b2022-04-15 11:59:25 +02005492 if (!desc->isDuplicated()
5493 && (desc->mFlags & AUDIO_OUTPUT_FLAG_SPATIALIZER) != 0) {
5494 spatializerOutputs.push_back(desc);
5495 ALOGV("%s adding opened spatializer Output %d", __func__, desc->mIoHandle);
Eric Laurent39095982021-08-24 18:29:27 +02005496 }
5497 }
Eric Laurente191d1b2022-04-15 11:59:25 +02005498 mSpatializerOutput.clear();
5499 bool outputsChanged = false;
5500 for (const auto& desc : spatializerOutputs) {
5501 if (desc->mProfile == profile
5502 && (configPtr == nullptr
5503 || configPtr->channel_mask == desc->mMixerChannelMask)) {
5504 mSpatializerOutput = desc;
5505 ALOGV("%s reusing current spatializer output %d", __func__, desc->mIoHandle);
5506 } else {
5507 ALOGV("%s closing spatializerOutput output %d to match channel mask %#x"
5508 " and devices %s", __func__, desc->mIoHandle,
5509 configPtr != nullptr ? configPtr->channel_mask : 0,
5510 devices.toString().c_str());
5511 closeOutput(desc->mIoHandle);
5512 outputsChanged = true;
5513 }
Eric Laurent39095982021-08-24 18:29:27 +02005514 }
5515
Eric Laurente191d1b2022-04-15 11:59:25 +02005516 if (mSpatializerOutput == nullptr) {
Eric Laurentb4f42a92022-01-17 17:37:31 +01005517 sp<SwAudioOutputDescriptor> desc =
5518 openOutputWithProfileAndDevice(profile, devices, mixerConfig);
Eric Laurente191d1b2022-04-15 11:59:25 +02005519 if (desc != nullptr) {
5520 mSpatializerOutput = desc;
5521 outputsChanged = true;
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005522 }
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005523 }
5524
5525 checkVirtualizerClientRoutes();
5526
Eric Laurente191d1b2022-04-15 11:59:25 +02005527 if (outputsChanged) {
5528 mPreviousOutputs = mOutputs;
5529 mpClientInterface->onAudioPortListUpdate();
5530 }
5531
5532 if (mSpatializerOutput == nullptr) {
5533 ALOGV("%s could not open spatializer output with requested config", __func__);
5534 return BAD_VALUE;
5535 }
Eric Laurent39095982021-08-24 18:29:27 +02005536 *output = mSpatializerOutput->mIoHandle;
Eric Laurente191d1b2022-04-15 11:59:25 +02005537 ALOGV("%s returning new spatializer output %d", __func__, *output);
5538 return OK;
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005539}
5540
Eric Laurentfa0f6742021-08-17 18:39:44 +02005541status_t AudioPolicyManager::releaseSpatializerOutput(audio_io_handle_t output) {
5542 if (mSpatializerOutput == nullptr) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005543 return INVALID_OPERATION;
5544 }
Eric Laurentfa0f6742021-08-17 18:39:44 +02005545 if (mSpatializerOutput->mIoHandle != output) {
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005546 return BAD_VALUE;
5547 }
Eric Laurent39095982021-08-24 18:29:27 +02005548
Eric Laurente191d1b2022-04-15 11:59:25 +02005549 if (!isOutputOnlyAvailableRouteToSomeDevice(mSpatializerOutput)) {
5550 ALOGV("%s closing spatializer output %d", __func__, mSpatializerOutput->mIoHandle);
5551 closeOutput(mSpatializerOutput->mIoHandle);
5552 //from now on mSpatializerOutput is null
5553 checkVirtualizerClientRoutes();
5554 }
Eric Laurent39095982021-08-24 18:29:27 +02005555
Eric Laurentcad6c0d2021-07-13 15:12:39 +02005556 return NO_ERROR;
5557}
5558
Eric Laurente552edb2014-03-10 17:42:56 -07005559// ----------------------------------------------------------------------------
Eric Laurente0720872014-03-11 09:30:41 -07005560// AudioPolicyManager
Eric Laurente552edb2014-03-10 17:42:56 -07005561// ----------------------------------------------------------------------------
Eric Laurent6a94d692014-05-20 11:18:06 -07005562uint32_t AudioPolicyManager::nextAudioPortGeneration()
5563{
Mikhail Naganov2773dd72017-12-08 10:12:11 -08005564 return mAudioPortGeneration++;
Eric Laurent6a94d692014-05-20 11:18:06 -07005565}
5566
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +09005567static status_t deserializeAudioPolicyXmlConfig(AudioPolicyConfig &config) {
Mikhail Naganov946c0032020-10-21 13:04:58 -07005568 if (std::string audioPolicyXmlConfigFile = audio_get_audio_policy_config_file();
5569 !audioPolicyXmlConfigFile.empty()) {
5570 status_t ret = deserializeAudioPolicyFile(audioPolicyXmlConfigFile.c_str(), &config);
5571 if (ret == NO_ERROR) {
5572 config.setSource(audioPolicyXmlConfigFile);
Cheney Ni6851adb2018-11-01 06:30:37 +08005573 }
Mikhail Naganov946c0032020-10-21 13:04:58 -07005574 return ret;
Petri Gyntherf497f292018-04-17 18:46:10 -07005575 }
Mikhail Naganov946c0032020-10-21 13:04:58 -07005576 return BAD_VALUE;
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +09005577}
Jaekyun Seok0d4a6af2017-02-17 17:10:17 +09005578
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005579AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface,
5580 bool /*forTesting*/)
Eric Laurente552edb2014-03-10 17:42:56 -07005581 :
Andy Hung4ef19fa2018-05-15 19:35:29 -07005582 mUidCached(AID_AUDIOSERVER), // no need to call getuid(), there's only one of us running.
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005583 mpClientInterface(clientInterface),
Eric Laurente552edb2014-03-10 17:42:56 -07005584 mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f),
Eric Laurent3a4311c2014-03-17 12:00:47 -07005585 mA2dpSuspended(false),
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005586 mConfig(mHwModulesAll, mOutputDevicesAll, mInputDevicesAll, mDefaultOutputDevice),
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07005587 mAudioPortGeneration(1),
5588 mBeaconMuteRefCount(0),
5589 mBeaconPlayingRefCount(0),
Eric Laurent9459fb02015-08-12 18:36:32 -07005590 mBeaconMuted(false),
Andy Hung2ddee192015-12-18 17:34:44 -08005591 mTtsOutputAvailable(false),
Eric Laurent36829f92017-04-07 19:04:42 -07005592 mMasterMono(false),
Eric Laurent4eb58f12018-12-07 16:41:02 -08005593 mMusicEffectOutput(AUDIO_IO_HANDLE_NONE)
Eric Laurente552edb2014-03-10 17:42:56 -07005594{
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005595}
François Gaffied1ab2bd2015-12-02 18:20:06 +01005596
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005597AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface)
5598 : AudioPolicyManager(clientInterface, false /*forTesting*/)
5599{
5600 loadConfig();
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005601}
François Gaffied1ab2bd2015-12-02 18:20:06 +01005602
Kevin Rocarddfa1e8a2018-10-26 16:42:07 -07005603void AudioPolicyManager::loadConfig() {
5604 if (deserializeAudioPolicyXmlConfig(getConfig()) != NO_ERROR) {
François Gaffied1ab2bd2015-12-02 18:20:06 +01005605 ALOGE("could not load audio policy configuration file, setting defaults");
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005606 getConfig().setDefault();
François Gaffied1ab2bd2015-12-02 18:20:06 +01005607 }
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005608}
5609
5610status_t AudioPolicyManager::initialize() {
Mikhail Naganov47835552019-05-14 10:32:51 -07005611 {
5612 auto engLib = EngineLibrary::load(
5613 "libaudiopolicyengine" + getConfig().getEngineLibraryNameSuffix() + ".so");
5614 if (!engLib) {
5615 ALOGE("%s: Failed to load the engine library", __FUNCTION__);
5616 return NO_INIT;
5617 }
5618 mEngine = engLib->createEngine();
5619 if (mEngine == nullptr) {
5620 ALOGE("%s: Failed to instantiate the APM engine", __FUNCTION__);
5621 return NO_INIT;
5622 }
François Gaffie2110e042015-03-24 08:41:51 +01005623 }
5624 mEngine->setObserver(this);
5625 status_t status = mEngine->initCheck();
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005626 if (status != NO_ERROR) {
5627 LOG_FATAL("Policy engine not initialized(err=%d)", status);
5628 return status;
5629 }
François Gaffie2110e042015-03-24 08:41:51 +01005630
Eric Laurent1a8b45f2022-04-13 16:01:47 +02005631 mEngine->updateDeviceSelectionCache();
Eric Laurent1d69c872021-01-11 18:53:01 +01005632 mCommunnicationStrategy = mEngine->getProductStrategyForAttributes(
5633 mEngine->getAttributesForStreamType(AUDIO_STREAM_VOICE_CALL));
5634
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005635 // after parsing the config, mOutputDevicesAll and mInputDevicesAll contain all known devices;
Eric Laurente552edb2014-03-10 17:42:56 -07005636 // open all output streams needed to access attached devices
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07005637 onNewAudioModulesAvailableInt(nullptr /*newDevices*/);
François Gaffie11d30102018-11-02 16:09:09 +01005638
Eric Laurent3a4311c2014-03-17 12:00:47 -07005639 // make sure default device is reachable
François Gaffie11d30102018-11-02 16:09:09 +01005640 if (mDefaultOutputDevice == 0 || !mAvailableOutputDevices.contains(mDefaultOutputDevice)) {
5641 ALOGE_IF(mDefaultOutputDevice != 0, "Default device %s is unreachable",
5642 mDefaultOutputDevice->toString().c_str());
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005643 status = NO_INIT;
Eric Laurent3a4311c2014-03-17 12:00:47 -07005644 }
jiabin9ff780e2018-03-19 18:19:52 -07005645 // If microphones address is empty, set it according to device type
Eric Laurent736a1022019-03-27 18:28:46 -07005646 for (size_t i = 0; i < mAvailableInputDevices.size(); i++) {
jiabince9f20e2019-09-12 16:29:15 -07005647 if (mAvailableInputDevices[i]->address().empty()) {
jiabin9ff780e2018-03-19 18:19:52 -07005648 if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_BUILTIN_MIC) {
jiabince9f20e2019-09-12 16:29:15 -07005649 mAvailableInputDevices[i]->setAddress(AUDIO_BOTTOM_MICROPHONE_ADDRESS);
jiabin9ff780e2018-03-19 18:19:52 -07005650 } else if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_BACK_MIC) {
jiabince9f20e2019-09-12 16:29:15 -07005651 mAvailableInputDevices[i]->setAddress(AUDIO_BACK_MICROPHONE_ADDRESS);
jiabin9ff780e2018-03-19 18:19:52 -07005652 }
5653 }
5654 }
Eric Laurente552edb2014-03-10 17:42:56 -07005655
Francois Gaffiebce7cd42020-10-14 16:13:20 +02005656 ALOGW_IF(mPrimaryOutput == nullptr, "The policy configuration does not declare a primary output");
Eric Laurente552edb2014-03-10 17:42:56 -07005657
Tomoharu Kasahara71c90912018-10-31 09:10:12 +09005658 // Silence ALOGV statements
5659 property_set("log.tag." LOG_TAG, "D");
5660
Eric Laurente552edb2014-03-10 17:42:56 -07005661 updateDevicesAndOutputs();
Mikhail Naganovad3f8a12017-12-12 13:24:23 -08005662 return status;
Eric Laurente552edb2014-03-10 17:42:56 -07005663}
5664
Eric Laurente0720872014-03-11 09:30:41 -07005665AudioPolicyManager::~AudioPolicyManager()
Eric Laurente552edb2014-03-10 17:42:56 -07005666{
Eric Laurente552edb2014-03-10 17:42:56 -07005667 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentfe231122017-11-17 17:48:06 -08005668 mOutputs.valueAt(i)->close();
Eric Laurente552edb2014-03-10 17:42:56 -07005669 }
5670 for (size_t i = 0; i < mInputs.size(); i++) {
Eric Laurentfe231122017-11-17 17:48:06 -08005671 mInputs.valueAt(i)->close();
Eric Laurente552edb2014-03-10 17:42:56 -07005672 }
Eric Laurent3a4311c2014-03-17 12:00:47 -07005673 mAvailableOutputDevices.clear();
5674 mAvailableInputDevices.clear();
Eric Laurent1f2f2232014-06-02 12:01:23 -07005675 mOutputs.clear();
5676 mInputs.clear();
5677 mHwModules.clear();
Mikhail Naganovd4120142017-12-06 15:49:22 -08005678 mHwModulesAll.clear();
Mikhail Naganov100f0122018-11-29 11:22:16 -08005679 mManualSurroundFormats.clear();
Eric Laurente552edb2014-03-10 17:42:56 -07005680}
5681
Eric Laurente0720872014-03-11 09:30:41 -07005682status_t AudioPolicyManager::initCheck()
Eric Laurente552edb2014-03-10 17:42:56 -07005683{
Eric Laurent87ffa392015-05-22 10:32:38 -07005684 return hasPrimaryOutput() ? NO_ERROR : NO_INIT;
Eric Laurente552edb2014-03-10 17:42:56 -07005685}
5686
Eric Laurente552edb2014-03-10 17:42:56 -07005687// ---
5688
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005689void AudioPolicyManager::onNewAudioModulesAvailable()
5690{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07005691 DeviceVector newDevices;
5692 onNewAudioModulesAvailableInt(&newDevices);
5693 if (!newDevices.empty()) {
5694 nextAudioPortGeneration();
5695 mpClientInterface->onAudioPortListUpdate();
5696 }
5697}
5698
5699void AudioPolicyManager::onNewAudioModulesAvailableInt(DeviceVector *newDevices)
5700{
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005701 for (const auto& hwModule : mHwModulesAll) {
5702 if (std::find(mHwModules.begin(), mHwModules.end(), hwModule) != mHwModules.end()) {
5703 continue;
5704 }
5705 hwModule->setHandle(mpClientInterface->loadHwModule(hwModule->getName()));
5706 if (hwModule->getHandle() == AUDIO_MODULE_HANDLE_NONE) {
5707 ALOGW("could not open HW module %s", hwModule->getName());
5708 continue;
5709 }
5710 mHwModules.push_back(hwModule);
Dean Wheatley12a87132021-04-16 10:08:49 +10005711 // open all output streams needed to access attached devices.
5712 // direct outputs are closed immediately after checking the availability of attached devices
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005713 // This also validates mAvailableOutputDevices list
5714 for (const auto& outProfile : hwModule->getOutputProfiles()) {
5715 if (!outProfile->canOpenNewIo()) {
5716 ALOGE("Invalid Output profile max open count %u for profile %s",
5717 outProfile->maxOpenCount, outProfile->getTagName().c_str());
5718 continue;
5719 }
5720 if (!outProfile->hasSupportedDevices()) {
5721 ALOGW("Output profile contains no device on module %s", hwModule->getName());
5722 continue;
5723 }
Carter Hsu1a3364a2022-01-21 15:32:56 +08005724 if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_TTS) != 0 ||
5725 (outProfile->getFlags() & AUDIO_OUTPUT_FLAG_ULTRASOUND) != 0) {
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005726 mTtsOutputAvailable = true;
5727 }
5728
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005729 const DeviceVector &supportedDevices = outProfile->getSupportedDevices();
5730 DeviceVector availProfileDevices = supportedDevices.filter(mOutputDevicesAll);
5731 sp<DeviceDescriptor> supportedDevice = 0;
5732 if (supportedDevices.contains(mDefaultOutputDevice)) {
5733 supportedDevice = mDefaultOutputDevice;
5734 } else {
5735 // choose first device present in profile's SupportedDevices also part of
5736 // mAvailableOutputDevices.
5737 if (availProfileDevices.isEmpty()) {
5738 continue;
5739 }
5740 supportedDevice = availProfileDevices.itemAt(0);
5741 }
5742 if (!mOutputDevicesAll.contains(supportedDevice)) {
5743 continue;
5744 }
5745 sp<SwAudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(outProfile,
5746 mpClientInterface);
5747 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
Eric Laurentf1f22e72021-07-13 14:04:14 +02005748 status_t status = outputDesc->open(nullptr /* halConfig */, nullptr /* mixerConfig */,
5749 DeviceVector(supportedDevice),
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005750 AUDIO_STREAM_DEFAULT,
5751 AUDIO_OUTPUT_FLAG_NONE, &output);
5752 if (status != NO_ERROR) {
5753 ALOGW("Cannot open output stream for devices %s on hw module %s",
5754 supportedDevice->toString().c_str(), hwModule->getName());
5755 continue;
5756 }
5757 for (const auto &device : availProfileDevices) {
5758 // give a valid ID to an attached device once confirmed it is reachable
5759 if (!device->isAttached()) {
5760 device->attach(hwModule);
5761 mAvailableOutputDevices.add(device);
jiabin1c4794b2020-05-05 10:08:05 -07005762 device->setEncapsulationInfoFromHal(mpClientInterface);
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07005763 if (newDevices) newDevices->add(device);
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005764 setEngineDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
5765 }
5766 }
Francois Gaffiebce7cd42020-10-14 16:13:20 +02005767 if (mPrimaryOutput == nullptr &&
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005768 outProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
5769 mPrimaryOutput = outputDesc;
5770 }
Eric Laurent39095982021-08-24 18:29:27 +02005771 if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_DIRECT) != 0) {
Eric Laurentc529cf62020-04-17 18:19:10 -07005772 outputDesc->close();
5773 } else {
5774 addOutput(output, outputDesc);
5775 setOutputDevices(outputDesc,
5776 DeviceVector(supportedDevice),
5777 true,
5778 0,
5779 NULL);
5780 }
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005781 }
5782 // open input streams needed to access attached devices to validate
5783 // mAvailableInputDevices list
5784 for (const auto& inProfile : hwModule->getInputProfiles()) {
5785 if (!inProfile->canOpenNewIo()) {
5786 ALOGE("Invalid Input profile max open count %u for profile %s",
5787 inProfile->maxOpenCount, inProfile->getTagName().c_str());
5788 continue;
5789 }
5790 if (!inProfile->hasSupportedDevices()) {
5791 ALOGW("Input profile contains no device on module %s", hwModule->getName());
5792 continue;
5793 }
5794 // chose first device present in profile's SupportedDevices also part of
5795 // available input devices
5796 const DeviceVector &supportedDevices = inProfile->getSupportedDevices();
5797 DeviceVector availProfileDevices = supportedDevices.filter(mInputDevicesAll);
5798 if (availProfileDevices.isEmpty()) {
Eric Laurentfecbceb2021-02-09 14:46:43 +01005799 ALOGV("%s: Input device list is empty! for profile %s",
5800 __func__, inProfile->getTagName().c_str());
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005801 continue;
5802 }
5803 sp<AudioInputDescriptor> inputDesc =
5804 new AudioInputDescriptor(inProfile, mpClientInterface);
5805
5806 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
5807 status_t status = inputDesc->open(nullptr,
5808 availProfileDevices.itemAt(0),
5809 AUDIO_SOURCE_MIC,
5810 AUDIO_INPUT_FLAG_NONE,
5811 &input);
5812 if (status != NO_ERROR) {
5813 ALOGW("Cannot open input stream for device %s on hw module %s",
5814 availProfileDevices.toString().c_str(),
5815 hwModule->getName());
5816 continue;
5817 }
5818 for (const auto &device : availProfileDevices) {
5819 // give a valid ID to an attached device once confirmed it is reachable
5820 if (!device->isAttached()) {
5821 device->attach(hwModule);
5822 device->importAudioPortAndPickAudioProfile(inProfile, true);
5823 mAvailableInputDevices.add(device);
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07005824 if (newDevices) newDevices->add(device);
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005825 setEngineDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
5826 }
5827 }
5828 inputDesc->close();
5829 }
5830 }
Eric Laurente191d1b2022-04-15 11:59:25 +02005831
5832 // Check if spatializer outputs can be closed until used.
5833 // mOutputs vector never contains duplicated outputs at this point.
5834 std::vector<audio_io_handle_t> outputsClosed;
5835 for (size_t i = 0; i < mOutputs.size(); i++) {
5836 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
5837 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_SPATIALIZER) != 0
5838 && !isOutputOnlyAvailableRouteToSomeDevice(desc)) {
5839 outputsClosed.push_back(desc->mIoHandle);
5840 desc->close();
5841 }
5842 }
5843 for (auto output : outputsClosed) {
5844 removeOutput(output);
5845 }
Mikhail Naganovc0d04982020-03-02 21:02:28 +00005846}
5847
Eric Laurent98e38192018-02-15 18:31:53 -08005848void AudioPolicyManager::addOutput(audio_io_handle_t output,
5849 const sp<SwAudioOutputDescriptor>& outputDesc)
Eric Laurente552edb2014-03-10 17:42:56 -07005850{
Eric Laurent1c333e22014-05-20 10:48:17 -07005851 mOutputs.add(output, outputDesc);
jiabin9a3361e2019-10-01 09:38:30 -07005852 applyStreamVolumes(outputDesc, DeviceTypeSet(), 0 /* delayMs */, true /* force */);
Andy Hung2ddee192015-12-18 17:34:44 -08005853 updateMono(output); // update mono status when adding to output list
Eric Laurent36829f92017-04-07 19:04:42 -07005854 selectOutputForMusicEffects();
Eric Laurent6a94d692014-05-20 11:18:06 -07005855 nextAudioPortGeneration();
Eric Laurente552edb2014-03-10 17:42:56 -07005856}
5857
François Gaffie53615e22015-03-19 09:24:12 +01005858void AudioPolicyManager::removeOutput(audio_io_handle_t output)
5859{
Francois Gaffiebce7cd42020-10-14 16:13:20 +02005860 if (mPrimaryOutput != 0 && mPrimaryOutput == mOutputs.valueFor(output)) {
5861 ALOGV("%s: removing primary output", __func__);
5862 mPrimaryOutput = nullptr;
5863 }
François Gaffie53615e22015-03-19 09:24:12 +01005864 mOutputs.removeItem(output);
Eric Laurent36829f92017-04-07 19:04:42 -07005865 selectOutputForMusicEffects();
François Gaffie53615e22015-03-19 09:24:12 +01005866}
5867
Eric Laurent98e38192018-02-15 18:31:53 -08005868void AudioPolicyManager::addInput(audio_io_handle_t input,
5869 const sp<AudioInputDescriptor>& inputDesc)
Eric Laurentd4692962014-05-05 18:13:44 -07005870{
Eric Laurent1c333e22014-05-20 10:48:17 -07005871 mInputs.add(input, inputDesc);
Eric Laurent6a94d692014-05-20 11:18:06 -07005872 nextAudioPortGeneration();
Eric Laurentd4692962014-05-05 18:13:44 -07005873}
Eric Laurente552edb2014-03-10 17:42:56 -07005874
François Gaffie11d30102018-11-02 16:09:09 +01005875status_t AudioPolicyManager::checkOutputsForDevice(const sp<DeviceDescriptor>& device,
François Gaffie53615e22015-03-19 09:24:12 +01005876 audio_policy_dev_state_t state,
François Gaffie11d30102018-11-02 16:09:09 +01005877 SortedVector<audio_io_handle_t>& outputs)
Eric Laurente552edb2014-03-10 17:42:56 -07005878{
François Gaffie11d30102018-11-02 16:09:09 +01005879 audio_devices_t deviceType = device->type();
jiabince9f20e2019-09-12 16:29:15 -07005880 const String8 &address = String8(device->address().c_str());
Eric Laurentc75307b2015-03-17 15:29:32 -07005881 sp<SwAudioOutputDescriptor> desc;
Eric Laurentcc750d32015-06-25 11:48:20 -07005882
François Gaffie11d30102018-11-02 16:09:09 +01005883 if (audio_device_is_digital(deviceType)) {
Eric Laurentcc750d32015-06-25 11:48:20 -07005884 // erase all current sample rates, formats and channel masks
François Gaffie11d30102018-11-02 16:09:09 +01005885 device->clearAudioProfiles();
Eric Laurentcc750d32015-06-25 11:48:20 -07005886 }
Eric Laurente552edb2014-03-10 17:42:56 -07005887
Eric Laurent3b73df72014-03-11 09:06:29 -07005888 if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
jiabinb4fed192020-09-22 14:45:40 -07005889 // first call getAudioPort to get the supported attributes from the HAL
5890 struct audio_port_v7 port = {};
5891 device->toAudioPort(&port);
5892 status_t status = mpClientInterface->getAudioPort(&port);
5893 if (status == NO_ERROR) {
5894 device->importAudioPort(port);
5895 }
5896
5897 // then list already open outputs that can be routed to this device
Eric Laurente552edb2014-03-10 17:42:56 -07005898 for (size_t i = 0; i < mOutputs.size(); i++) {
5899 desc = mOutputs.valueAt(i);
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005900 if (!desc->isDuplicated() && desc->supportsDevice(device)
jiabin9a3361e2019-10-01 09:38:30 -07005901 && desc->devicesSupportEncodedFormats({deviceType})) {
François Gaffie11d30102018-11-02 16:09:09 +01005902 ALOGV("checkOutputsForDevice(): adding opened output %d on device %s",
5903 mOutputs.keyAt(i), device->toString().c_str());
5904 outputs.add(mOutputs.keyAt(i));
Eric Laurente552edb2014-03-10 17:42:56 -07005905 }
5906 }
5907 // then look for output profiles that can be routed to this device
Eric Laurent1c333e22014-05-20 10:48:17 -07005908 SortedVector< sp<IOProfile> > profiles;
Mikhail Naganov7e22e942017-12-07 10:04:29 -08005909 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08005910 for (size_t j = 0; j < hwModule->getOutputProfiles().size(); j++) {
5911 sp<IOProfile> profile = hwModule->getOutputProfiles()[j];
François Gaffie11d30102018-11-02 16:09:09 +01005912 if (profile->supportsDevice(device)) {
5913 profiles.add(profile);
5914 ALOGV("checkOutputsForDevice(): adding profile %zu from module %s",
5915 j, hwModule->getName());
Eric Laurente552edb2014-03-10 17:42:56 -07005916 }
5917 }
5918 }
5919
Eric Laurent7b279bb2015-12-14 10:18:23 -08005920 ALOGV(" found %zu profiles, %zu outputs", profiles.size(), outputs.size());
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005921
Eric Laurente552edb2014-03-10 17:42:56 -07005922 if (profiles.isEmpty() && outputs.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01005923 ALOGW("checkOutputsForDevice(): No output available for device %04x", deviceType);
Eric Laurente552edb2014-03-10 17:42:56 -07005924 return BAD_VALUE;
5925 }
5926
5927 // open outputs for matching profiles if needed. Direct outputs are also opened to
5928 // query for dynamic parameters and will be closed later by setDeviceConnectionState()
5929 for (ssize_t profile_index = 0; profile_index < (ssize_t)profiles.size(); profile_index++) {
Eric Laurent1c333e22014-05-20 10:48:17 -07005930 sp<IOProfile> profile = profiles[profile_index];
Eric Laurente552edb2014-03-10 17:42:56 -07005931
5932 // nothing to do if one output is already opened for this profile
5933 size_t j;
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005934 for (j = 0; j < outputs.size(); j++) {
5935 desc = mOutputs.valueFor(outputs.itemAt(j));
Eric Laurente552edb2014-03-10 17:42:56 -07005936 if (!desc->isDuplicated() && desc->mProfile == profile) {
Jean-Michel Trivif17026d2014-08-10 14:30:48 -07005937 // matching profile: save the sample rates, format and channel masks supported
5938 // by the profile in our device descriptor
François Gaffie11d30102018-11-02 16:09:09 +01005939 if (audio_device_is_digital(deviceType)) {
jiabin4ef93452019-09-10 14:29:54 -07005940 device->importAudioPortAndPickAudioProfile(profile);
Paul McLean9080a4c2015-06-18 08:24:02 -07005941 }
Eric Laurente552edb2014-03-10 17:42:56 -07005942 break;
5943 }
5944 }
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005945 if (j != outputs.size()) {
Eric Laurente552edb2014-03-10 17:42:56 -07005946 continue;
5947 }
5948
Eric Laurent3974e3b2017-12-07 17:58:43 -08005949 if (!profile->canOpenNewIo()) {
5950 ALOGW("Max Output number %u already opened for this profile %s",
5951 profile->maxOpenCount, profile->getTagName().c_str());
5952 continue;
5953 }
5954
Eric Laurent83efe1c2017-07-09 16:51:08 -07005955 ALOGV("opening output for device %08x with params %s profile %p name %s",
jiabin5740f082019-08-19 15:08:30 -07005956 deviceType, address.string(), profile.get(), profile->getName().c_str());
jiabinbce0c1d2020-10-05 11:20:18 -07005957 desc = openOutputWithProfileAndDevice(profile, DeviceVector(device));
5958 audio_io_handle_t output = desc == nullptr ? AUDIO_IO_HANDLE_NONE : desc->mIoHandle;
Eric Laurentcf2c0212014-07-25 16:20:43 -07005959 if (output == AUDIO_IO_HANDLE_NONE) {
François Gaffie11d30102018-11-02 16:09:09 +01005960 ALOGW("checkOutputsForDevice() could not open output for device %x", deviceType);
Eric Laurente552edb2014-03-10 17:42:56 -07005961 profiles.removeAt(profile_index);
5962 profile_index--;
5963 } else {
5964 outputs.add(output);
Paul McLean9080a4c2015-06-18 08:24:02 -07005965 // Load digital format info only for digital devices
François Gaffie11d30102018-11-02 16:09:09 +01005966 if (audio_device_is_digital(deviceType)) {
jiabinbce0c1d2020-10-05 11:20:18 -07005967 // TODO: when getAudioPort is ready, it may not be needed to import the audio
5968 // port but just pick audio profile
jiabin4ef93452019-09-10 14:29:54 -07005969 device->importAudioPortAndPickAudioProfile(profile);
Paul McLean9080a4c2015-06-18 08:24:02 -07005970 }
Jean-Michel Trivif17026d2014-08-10 14:30:48 -07005971
François Gaffie11d30102018-11-02 16:09:09 +01005972 if (device_distinguishes_on_address(deviceType)) {
5973 ALOGV("checkOutputsForDevice(): setOutputDevices %s",
5974 device->toString().c_str());
5975 setOutputDevices(desc, DeviceVector(device), true/*force*/, 0/*delay*/,
5976 NULL/*patch handle*/);
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005977 }
Eric Laurente552edb2014-03-10 17:42:56 -07005978 ALOGV("checkOutputsForDevice(): adding output %d", output);
5979 }
5980 }
5981
5982 if (profiles.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01005983 ALOGW("checkOutputsForDevice(): No output available for device %04x", deviceType);
Eric Laurente552edb2014-03-10 17:42:56 -07005984 return BAD_VALUE;
5985 }
Eric Laurentd4692962014-05-05 18:13:44 -07005986 } else { // Disconnect
Eric Laurente552edb2014-03-10 17:42:56 -07005987 // check if one opened output is not needed any more after disconnecting one device
5988 for (size_t i = 0; i < mOutputs.size(); i++) {
5989 desc = mOutputs.valueAt(i);
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005990 if (!desc->isDuplicated()) {
Eric Laurent275e8e92014-11-30 15:14:47 -08005991 // exact match on device
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08005992 if (device_distinguishes_on_address(deviceType) && desc->supportsDevice(device)
Francois Gaffiec7d4c222021-12-02 11:12:52 +01005993 && desc->containsSingleDeviceSupportingEncodedFormats(device)) {
François Gaffie11d30102018-11-02 16:09:09 +01005994 outputs.add(mOutputs.keyAt(i));
Francois Gaffie716e1432019-01-14 16:58:59 +01005995 } else if (!mAvailableOutputDevices.containsAtLeastOne(desc->supportedDevices())) {
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005996 ALOGV("checkOutputsForDevice(): disconnecting adding output %d",
5997 mOutputs.keyAt(i));
5998 outputs.add(mOutputs.keyAt(i));
Jean-Michel Trivi0fb47752014-07-22 16:19:14 -07005999 }
Eric Laurente552edb2014-03-10 17:42:56 -07006000 }
6001 }
Eric Laurentd4692962014-05-05 18:13:44 -07006002 // Clear any profiles associated with the disconnected device.
Mikhail Naganov7e22e942017-12-07 10:04:29 -08006003 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08006004 for (size_t j = 0; j < hwModule->getOutputProfiles().size(); j++) {
6005 sp<IOProfile> profile = hwModule->getOutputProfiles()[j];
jiabinbce0c1d2020-10-05 11:20:18 -07006006 if (!profile->supportsDevice(device)) {
6007 continue;
6008 }
6009 ALOGV("checkOutputsForDevice(): "
6010 "clearing direct output profile %zu on module %s",
6011 j, hwModule->getName());
6012 profile->clearAudioProfiles();
6013 if (!profile->hasDynamicAudioProfile()) {
6014 continue;
6015 }
6016 // When a device is disconnected, if there is an IOProfile that contains dynamic
6017 // profiles and supports the disconnected device, call getAudioPort to repopulate
6018 // the capabilities of the devices that is supported by the IOProfile.
6019 for (const auto& supportedDevice : profile->getSupportedDevices()) {
6020 if (supportedDevice == device ||
6021 !mAvailableOutputDevices.contains(supportedDevice)) {
6022 continue;
6023 }
6024 struct audio_port_v7 port;
6025 supportedDevice->toAudioPort(&port);
6026 status_t status = mpClientInterface->getAudioPort(&port);
6027 if (status == NO_ERROR) {
6028 supportedDevice->importAudioPort(port);
6029 }
Eric Laurente552edb2014-03-10 17:42:56 -07006030 }
6031 }
6032 }
6033 }
6034 return NO_ERROR;
6035}
6036
François Gaffie11d30102018-11-02 16:09:09 +01006037status_t AudioPolicyManager::checkInputsForDevice(const sp<DeviceDescriptor>& device,
Eric Laurent0dd51852019-04-19 18:18:58 -07006038 audio_policy_dev_state_t state)
Eric Laurentd4692962014-05-05 18:13:44 -07006039{
Eric Laurent1f2f2232014-06-02 12:01:23 -07006040 sp<AudioInputDescriptor> desc;
Eric Laurentcc750d32015-06-25 11:48:20 -07006041
François Gaffie11d30102018-11-02 16:09:09 +01006042 if (audio_device_is_digital(device->type())) {
Eric Laurentcc750d32015-06-25 11:48:20 -07006043 // erase all current sample rates, formats and channel masks
François Gaffie11d30102018-11-02 16:09:09 +01006044 device->clearAudioProfiles();
Eric Laurentcc750d32015-06-25 11:48:20 -07006045 }
6046
Eric Laurentd4692962014-05-05 18:13:44 -07006047 if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
Eric Laurent0dd51852019-04-19 18:18:58 -07006048 // look for input profiles that can be routed to this device
Eric Laurent1c333e22014-05-20 10:48:17 -07006049 SortedVector< sp<IOProfile> > profiles;
Mikhail Naganov7e22e942017-12-07 10:04:29 -08006050 for (const auto& hwModule : mHwModules) {
Eric Laurentd4692962014-05-05 18:13:44 -07006051 for (size_t profile_index = 0;
Mikhail Naganova5e165d2017-12-07 17:08:02 -08006052 profile_index < hwModule->getInputProfiles().size();
Mikhail Naganov7e22e942017-12-07 10:04:29 -08006053 profile_index++) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08006054 sp<IOProfile> profile = hwModule->getInputProfiles()[profile_index];
Eric Laurent275e8e92014-11-30 15:14:47 -08006055
François Gaffie11d30102018-11-02 16:09:09 +01006056 if (profile->supportsDevice(device)) {
6057 profiles.add(profile);
6058 ALOGV("checkInputsForDevice(): adding profile %zu from module %s",
6059 profile_index, hwModule->getName());
Eric Laurentd4692962014-05-05 18:13:44 -07006060 }
6061 }
6062 }
6063
Eric Laurent0dd51852019-04-19 18:18:58 -07006064 if (profiles.isEmpty()) {
6065 ALOGW("%s: No input profile available for device %s",
6066 __func__, device->toString().c_str());
Eric Laurentd4692962014-05-05 18:13:44 -07006067 return BAD_VALUE;
6068 }
6069
6070 // open inputs for matching profiles if needed. Direct inputs are also opened to
6071 // query for dynamic parameters and will be closed later by setDeviceConnectionState()
6072 for (ssize_t profile_index = 0; profile_index < (ssize_t)profiles.size(); profile_index++) {
6073
Eric Laurent1c333e22014-05-20 10:48:17 -07006074 sp<IOProfile> profile = profiles[profile_index];
Eric Laurent3974e3b2017-12-07 17:58:43 -08006075
Eric Laurentd4692962014-05-05 18:13:44 -07006076 // nothing to do if one input is already opened for this profile
6077 size_t input_index;
6078 for (input_index = 0; input_index < mInputs.size(); input_index++) {
6079 desc = mInputs.valueAt(input_index);
6080 if (desc->mProfile == profile) {
François Gaffie11d30102018-11-02 16:09:09 +01006081 if (audio_device_is_digital(device->type())) {
jiabin4ef93452019-09-10 14:29:54 -07006082 device->importAudioPortAndPickAudioProfile(profile);
Paul McLean9080a4c2015-06-18 08:24:02 -07006083 }
Eric Laurentd4692962014-05-05 18:13:44 -07006084 break;
6085 }
6086 }
6087 if (input_index != mInputs.size()) {
6088 continue;
6089 }
6090
Eric Laurent3974e3b2017-12-07 17:58:43 -08006091 if (!profile->canOpenNewIo()) {
6092 ALOGW("Max Input number %u already opened for this profile %s",
6093 profile->maxOpenCount, profile->getTagName().c_str());
6094 continue;
6095 }
6096
Eric Laurentfe231122017-11-17 17:48:06 -08006097 desc = new AudioInputDescriptor(profile, mpClientInterface);
Eric Laurentcf2c0212014-07-25 16:20:43 -07006098 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
Eric Laurentfe231122017-11-17 17:48:06 -08006099 status_t status = desc->open(nullptr,
6100 device,
Eric Laurentfe231122017-11-17 17:48:06 -08006101 AUDIO_SOURCE_MIC,
6102 AUDIO_INPUT_FLAG_NONE,
6103 &input);
Eric Laurentd4692962014-05-05 18:13:44 -07006104
Eric Laurentcf2c0212014-07-25 16:20:43 -07006105 if (status == NO_ERROR) {
jiabince9f20e2019-09-12 16:29:15 -07006106 const String8& address = String8(device->address().c_str());
Eric Laurentd4692962014-05-05 18:13:44 -07006107 if (!address.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01006108 char *param = audio_device_address_to_parameter(device->type(), address);
Eric Laurentcf2c0212014-07-25 16:20:43 -07006109 mpClientInterface->setParameters(input, String8(param));
6110 free(param);
Eric Laurentd4692962014-05-05 18:13:44 -07006111 }
François Gaffie11d30102018-11-02 16:09:09 +01006112 updateAudioProfiles(device, input, profile->getAudioProfiles());
François Gaffie112b0af2015-11-19 16:13:25 +01006113 if (!profile->hasValidAudioProfile()) {
Eric Laurentd4692962014-05-05 18:13:44 -07006114 ALOGW("checkInputsForDevice() direct input missing param");
Eric Laurentfe231122017-11-17 17:48:06 -08006115 desc->close();
Eric Laurentcf2c0212014-07-25 16:20:43 -07006116 input = AUDIO_IO_HANDLE_NONE;
Eric Laurentd4692962014-05-05 18:13:44 -07006117 }
6118
Eric Laurent0dd51852019-04-19 18:18:58 -07006119 if (input != AUDIO_IO_HANDLE_NONE) {
Eric Laurentd4692962014-05-05 18:13:44 -07006120 addInput(input, desc);
6121 }
6122 } // endif input != 0
6123
Eric Laurentcf2c0212014-07-25 16:20:43 -07006124 if (input == AUDIO_IO_HANDLE_NONE) {
Pattydd807582021-11-04 21:01:03 +08006125 ALOGW("%s could not open input for device %s", __func__,
François Gaffie11d30102018-11-02 16:09:09 +01006126 device->toString().c_str());
Eric Laurentd4692962014-05-05 18:13:44 -07006127 profiles.removeAt(profile_index);
6128 profile_index--;
6129 } else {
François Gaffie11d30102018-11-02 16:09:09 +01006130 if (audio_device_is_digital(device->type())) {
jiabin4ef93452019-09-10 14:29:54 -07006131 device->importAudioPortAndPickAudioProfile(profile);
Paul McLean9080a4c2015-06-18 08:24:02 -07006132 }
Eric Laurentd4692962014-05-05 18:13:44 -07006133 ALOGV("checkInputsForDevice(): adding input %d", input);
6134 }
6135 } // end scan profiles
6136
6137 if (profiles.isEmpty()) {
François Gaffie11d30102018-11-02 16:09:09 +01006138 ALOGW("%s: No input available for device %s", __func__, device->toString().c_str());
Eric Laurentd4692962014-05-05 18:13:44 -07006139 return BAD_VALUE;
6140 }
6141 } else {
6142 // Disconnect
Eric Laurentd4692962014-05-05 18:13:44 -07006143 // Clear any profiles associated with the disconnected device.
Mikhail Naganovd4120142017-12-06 15:49:22 -08006144 for (const auto& hwModule : mHwModules) {
Eric Laurentd4692962014-05-05 18:13:44 -07006145 for (size_t profile_index = 0;
Mikhail Naganova5e165d2017-12-07 17:08:02 -08006146 profile_index < hwModule->getInputProfiles().size();
Eric Laurentd4692962014-05-05 18:13:44 -07006147 profile_index++) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08006148 sp<IOProfile> profile = hwModule->getInputProfiles()[profile_index];
Francois Gaffie716e1432019-01-14 16:58:59 +01006149 if (profile->supportsDevice(device)) {
Mikhail Naganovd4120142017-12-06 15:49:22 -08006150 ALOGV("checkInputsForDevice(): clearing direct input profile %zu on module %s",
6151 profile_index, hwModule->getName());
François Gaffie112b0af2015-11-19 16:13:25 +01006152 profile->clearAudioProfiles();
Eric Laurentd4692962014-05-05 18:13:44 -07006153 }
6154 }
6155 }
6156 } // end disconnect
6157
6158 return NO_ERROR;
6159}
6160
6161
Eric Laurente0720872014-03-11 09:30:41 -07006162void AudioPolicyManager::closeOutput(audio_io_handle_t output)
Eric Laurente552edb2014-03-10 17:42:56 -07006163{
6164 ALOGV("closeOutput(%d)", output);
6165
François Gaffie1c878552018-11-22 16:53:21 +01006166 sp<SwAudioOutputDescriptor> closingOutput = mOutputs.valueFor(output);
6167 if (closingOutput == NULL) {
Eric Laurente552edb2014-03-10 17:42:56 -07006168 ALOGW("closeOutput() unknown output %d", output);
6169 return;
6170 }
Mikhail Naganov32ebca32019-03-22 15:42:52 -07006171 const bool closingOutputWasActive = closingOutput->isActive();
François Gaffie1c878552018-11-22 16:53:21 +01006172 mPolicyMixes.closeOutput(closingOutput);
Eric Laurent275e8e92014-11-30 15:14:47 -08006173
Eric Laurente552edb2014-03-10 17:42:56 -07006174 // look for duplicated outputs connected to the output being removed.
6175 for (size_t i = 0; i < mOutputs.size(); i++) {
François Gaffie1c878552018-11-22 16:53:21 +01006176 sp<SwAudioOutputDescriptor> dupOutput = mOutputs.valueAt(i);
6177 if (dupOutput->isDuplicated() &&
6178 (dupOutput->mOutput1 == closingOutput || dupOutput->mOutput2 == closingOutput)) {
6179 sp<SwAudioOutputDescriptor> remainingOutput =
6180 dupOutput->mOutput1 == closingOutput ? dupOutput->mOutput2 : dupOutput->mOutput1;
Eric Laurente552edb2014-03-10 17:42:56 -07006181 // As all active tracks on duplicated output will be deleted,
6182 // and as they were also referenced on the other output, the reference
6183 // count for their stream type must be adjusted accordingly on
6184 // the other output.
François Gaffie1c878552018-11-22 16:53:21 +01006185 const bool wasActive = remainingOutput->isActive();
6186 // Note: no-op on the closing output where all clients has already been set inactive
6187 dupOutput->setAllClientsInactive();
Eric Laurent733ce942017-12-07 12:18:25 -08006188 // stop() will be a no op if the output is still active but is needed in case all
6189 // active streams refcounts where cleared above
6190 if (wasActive) {
François Gaffie1c878552018-11-22 16:53:21 +01006191 remainingOutput->stop();
Eric Laurent733ce942017-12-07 12:18:25 -08006192 }
Eric Laurente552edb2014-03-10 17:42:56 -07006193 audio_io_handle_t duplicatedOutput = mOutputs.keyAt(i);
6194 ALOGV("closeOutput() closing also duplicated output %d", duplicatedOutput);
6195
6196 mpClientInterface->closeOutput(duplicatedOutput);
François Gaffie53615e22015-03-19 09:24:12 +01006197 removeOutput(duplicatedOutput);
Eric Laurente552edb2014-03-10 17:42:56 -07006198 }
6199 }
6200
Eric Laurent05b90f82014-08-27 15:32:29 -07006201 nextAudioPortGeneration();
6202
François Gaffie1c878552018-11-22 16:53:21 +01006203 ssize_t index = mAudioPatches.indexOfKey(closingOutput->getPatchHandle());
Eric Laurent05b90f82014-08-27 15:32:29 -07006204 if (index >= 0) {
6205 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01006206 (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(
6207 patchDesc->getAfHandle(), 0);
Eric Laurent05b90f82014-08-27 15:32:29 -07006208 mAudioPatches.removeItemsAt(index);
6209 mpClientInterface->onAudioPatchListUpdate();
6210 }
6211
Mikhail Naganov32ebca32019-03-22 15:42:52 -07006212 if (closingOutputWasActive) {
6213 closingOutput->stop();
6214 }
François Gaffie1c878552018-11-22 16:53:21 +01006215 closingOutput->close();
Eric Laurente552edb2014-03-10 17:42:56 -07006216
François Gaffie53615e22015-03-19 09:24:12 +01006217 removeOutput(output);
Eric Laurente552edb2014-03-10 17:42:56 -07006218 mPreviousOutputs = mOutputs;
Eric Laurentb4f42a92022-01-17 17:37:31 +01006219 if (closingOutput == mSpatializerOutput) {
6220 mSpatializerOutput.clear();
6221 }
Dean Wheatley3023b382018-08-09 07:42:40 +10006222
6223 // MSD patches may have been released to support a non-MSD direct output. Reset MSD patch if
6224 // no direct outputs are open.
François Gaffie11d30102018-11-02 16:09:09 +01006225 if (!getMsdAudioOutDevices().isEmpty()) {
Dean Wheatley3023b382018-08-09 07:42:40 +10006226 bool directOutputOpen = false;
6227 for (size_t i = 0; i < mOutputs.size(); i++) {
6228 if (mOutputs[i]->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
6229 directOutputOpen = true;
6230 break;
6231 }
6232 }
6233 if (!directOutputOpen) {
Michael Chan6fb34492020-12-08 15:44:49 +11006234 ALOGV("no direct outputs open, reset MSD patches");
6235 // TODO: The MSD patches to be established here may differ to current MSD patches due to
6236 // how output devices for patching are resolved. Avoid by caching and reusing the
6237 // arguments to mEngine->getOutputDevicesForAttributes() when resolving which output
6238 // devices to patch to. This may be complicated by the fact that devices may become
6239 // unavailable.
Dean Wheatley8bee85a2021-02-10 16:02:23 +11006240 setMsdOutputPatches();
Dean Wheatley3023b382018-08-09 07:42:40 +10006241 }
6242 }
Eric Laurent05b90f82014-08-27 15:32:29 -07006243}
6244
6245void AudioPolicyManager::closeInput(audio_io_handle_t input)
6246{
6247 ALOGV("closeInput(%d)", input);
6248
6249 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
6250 if (inputDesc == NULL) {
6251 ALOGW("closeInput() unknown input %d", input);
6252 return;
6253 }
6254
Eric Laurent6a94d692014-05-20 11:18:06 -07006255 nextAudioPortGeneration();
Eric Laurent05b90f82014-08-27 15:32:29 -07006256
François Gaffie11d30102018-11-02 16:09:09 +01006257 sp<DeviceDescriptor> device = inputDesc->getDevice();
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08006258 ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent05b90f82014-08-27 15:32:29 -07006259 if (index >= 0) {
6260 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01006261 (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(
6262 patchDesc->getAfHandle(), 0);
Eric Laurent05b90f82014-08-27 15:32:29 -07006263 mAudioPatches.removeItemsAt(index);
6264 mpClientInterface->onAudioPatchListUpdate();
6265 }
6266
Eric Laurentfe231122017-11-17 17:48:06 -08006267 inputDesc->close();
Eric Laurent05b90f82014-08-27 15:32:29 -07006268 mInputs.removeItem(input);
Haynes Mathew George1d539d92018-03-16 11:40:49 -07006269
François Gaffie11d30102018-11-02 16:09:09 +01006270 DeviceVector primaryInputDevices = availablePrimaryModuleInputDevices();
6271 if (primaryInputDevices.contains(device) &&
Haynes Mathew George1d539d92018-03-16 11:40:49 -07006272 mInputs.activeInputsCountOnDevices(primaryInputDevices) == 0) {
Ytai Ben-Tsvi74cd6b02019-10-25 10:06:40 -07006273 mpClientInterface->setSoundTriggerCaptureState(false);
Haynes Mathew George1d539d92018-03-16 11:40:49 -07006274 }
Eric Laurente552edb2014-03-10 17:42:56 -07006275}
6276
François Gaffie11d30102018-11-02 16:09:09 +01006277SortedVector<audio_io_handle_t> AudioPolicyManager::getOutputsForDevices(
6278 const DeviceVector &devices,
6279 const SwAudioOutputCollection& openOutputs)
Eric Laurente552edb2014-03-10 17:42:56 -07006280{
6281 SortedVector<audio_io_handle_t> outputs;
6282
François Gaffie11d30102018-11-02 16:09:09 +01006283 ALOGVV("%s() devices %s", __func__, devices.toString().c_str());
Eric Laurente552edb2014-03-10 17:42:56 -07006284 for (size_t i = 0; i < openOutputs.size(); i++) {
François Gaffie11d30102018-11-02 16:09:09 +01006285 ALOGVV("output %zu isDuplicated=%d device=%s",
Eric Laurent8c7e6da2015-04-21 17:37:00 -07006286 i, openOutputs.valueAt(i)->isDuplicated(),
François Gaffie11d30102018-11-02 16:09:09 +01006287 openOutputs.valueAt(i)->supportedDevices().toString().c_str());
Aniket Kumar Lata4e464702019-01-10 23:38:46 -08006288 if (openOutputs.valueAt(i)->supportsAllDevices(devices)
jiabin9a3361e2019-10-01 09:38:30 -07006289 && openOutputs.valueAt(i)->devicesSupportEncodedFormats(devices.types())) {
François Gaffie11d30102018-11-02 16:09:09 +01006290 ALOGVV("%s() found output %d", __func__, openOutputs.keyAt(i));
Eric Laurente552edb2014-03-10 17:42:56 -07006291 outputs.add(openOutputs.keyAt(i));
6292 }
6293 }
6294 return outputs;
6295}
6296
Mikhail Naganov37977152018-07-11 15:54:44 -07006297void AudioPolicyManager::checkForDeviceAndOutputChanges(std::function<bool()> onOutputsChecked)
6298{
6299 // checkA2dpSuspend must run before checkOutputForAllStrategies so that A2DP
6300 // output is suspended before any tracks are moved to it
6301 checkA2dpSuspend();
6302 checkOutputForAllStrategies();
Kevin Rocard153f92d2018-12-18 18:33:28 -08006303 checkSecondaryOutputs();
Mikhail Naganov15be9d22017-11-08 14:18:13 +11006304 if (onOutputsChecked != nullptr && onOutputsChecked()) checkA2dpSuspend();
Mikhail Naganov37977152018-07-11 15:54:44 -07006305 updateDevicesAndOutputs();
Mikhail Naganov7bd9b8d2018-11-15 02:09:03 +00006306 if (mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD) != 0) {
Michael Chan6fb34492020-12-08 15:44:49 +11006307 // TODO: The MSD patches to be established here may differ to current MSD patches due to how
6308 // output devices for patching are resolved. Nevertheless, AudioTracks affected by device
6309 // configuration changes will ultimately be rerouted correctly. We can still avoid
6310 // unnecessary rerouting by caching and reusing the arguments to
6311 // mEngine->getOutputDevicesForAttributes() when resolving which output devices to patch to.
6312 // This may be complicated by the fact that devices may become unavailable.
Dean Wheatley8bee85a2021-02-10 16:02:23 +11006313 setMsdOutputPatches();
Mikhail Naganov15be9d22017-11-08 14:18:13 +11006314 }
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07006315 // an event that changed routing likely occurred, inform upper layers
6316 mpClientInterface->onRoutingUpdated();
Mikhail Naganov37977152018-07-11 15:54:44 -07006317}
6318
François Gaffiec005e562018-11-06 15:04:49 +01006319bool AudioPolicyManager::followsSameRouting(const audio_attributes_t &lAttr,
6320 const audio_attributes_t &rAttr) const
Eric Laurente552edb2014-03-10 17:42:56 -07006321{
François Gaffiec005e562018-11-06 15:04:49 +01006322 return mEngine->getProductStrategyForAttributes(lAttr) ==
6323 mEngine->getProductStrategyForAttributes(rAttr);
6324}
6325
Francois Gaffieff1eb522020-05-06 18:37:04 +02006326void AudioPolicyManager::checkAudioSourceForAttributes(const audio_attributes_t &attr)
6327{
6328 for (size_t i = 0; i < mAudioSources.size(); i++) {
6329 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
6330 if (sourceDesc != nullptr && followsSameRouting(attr, sourceDesc->attributes())
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02006331 && sourceDesc->getPatchHandle() == AUDIO_PATCH_HANDLE_NONE
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02006332 && !isCallRxAudioSource(sourceDesc) && !sourceDesc->isInternal()) {
Francois Gaffieff1eb522020-05-06 18:37:04 +02006333 connectAudioSource(sourceDesc);
6334 }
6335 }
6336}
6337
6338void AudioPolicyManager::clearAudioSourcesForOutput(audio_io_handle_t output)
6339{
6340 for (size_t i = 0; i < mAudioSources.size(); i++) {
6341 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
6342 if (sourceDesc != nullptr && sourceDesc->swOutput().promote() != nullptr
6343 && sourceDesc->swOutput().promote()->mIoHandle == output) {
6344 disconnectAudioSource(sourceDesc);
6345 }
6346 }
6347}
6348
François Gaffiec005e562018-11-06 15:04:49 +01006349void AudioPolicyManager::checkOutputForAttributes(const audio_attributes_t &attr)
6350{
6351 auto psId = mEngine->getProductStrategyForAttributes(attr);
6352
6353 DeviceVector oldDevices = mEngine->getOutputDevicesForAttributes(attr, 0, true /*fromCache*/);
6354 DeviceVector newDevices = mEngine->getOutputDevicesForAttributes(attr, 0, false /*fromCache*/);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07006355
François Gaffie11d30102018-11-02 16:09:09 +01006356 SortedVector<audio_io_handle_t> srcOutputs = getOutputsForDevices(oldDevices, mPreviousOutputs);
6357 SortedVector<audio_io_handle_t> dstOutputs = getOutputsForDevices(newDevices, mOutputs);
Eric Laurente552edb2014-03-10 17:42:56 -07006358
Eric Laurentc209fe42020-06-05 18:11:23 -07006359 uint32_t maxLatency = 0;
Eric Laurent56ed8842022-11-15 16:04:41 +01006360 std::vector<sp<SwAudioOutputDescriptor>> invalidatedOutputs;
Eric Laurentc209fe42020-06-05 18:11:23 -07006361 // take into account dynamic audio policies related changes: if a client is now associated
6362 // to a different policy mix than at creation time, invalidate corresponding stream
Eric Laurent56ed8842022-11-15 16:04:41 +01006363 for (size_t i = 0; i < mPreviousOutputs.size(); i++) {
Eric Laurentc209fe42020-06-05 18:11:23 -07006364 const sp<SwAudioOutputDescriptor>& desc = mPreviousOutputs.valueAt(i);
6365 if (desc->isDuplicated()) {
6366 continue;
Jean-Michel Trivife472e22014-12-16 14:23:13 -08006367 }
Eric Laurentc209fe42020-06-05 18:11:23 -07006368 for (const sp<TrackClientDescriptor>& client : desc->getClientIterable()) {
6369 if (mEngine->getProductStrategyForAttributes(client->attributes()) != psId) {
6370 continue;
6371 }
6372 sp<AudioPolicyMix> primaryMix;
Dean Wheatleyd082f472022-02-04 11:10:48 +11006373 status_t status = mPolicyMixes.getOutputForAttr(client->attributes(), client->config(),
6374 client->uid(), client->flags(), primaryMix, nullptr);
Eric Laurentc209fe42020-06-05 18:11:23 -07006375 if (status != OK) {
6376 continue;
6377 }
yucliuf4de36d2020-09-14 14:57:56 -07006378 if (client->getPrimaryMix() != primaryMix || client->hasLostPrimaryMix()) {
Eric Laurent56ed8842022-11-15 16:04:41 +01006379 if (desc->isStrategyActive(psId) && maxLatency < desc->latency()) {
Eric Laurentc209fe42020-06-05 18:11:23 -07006380 maxLatency = desc->latency();
6381 }
Eric Laurent56ed8842022-11-15 16:04:41 +01006382 invalidatedOutputs.push_back(desc);
Eric Laurentc209fe42020-06-05 18:11:23 -07006383 }
Jean-Michel Trivife472e22014-12-16 14:23:13 -08006384 }
6385 }
6386
Eric Laurent56ed8842022-11-15 16:04:41 +01006387 if (srcOutputs != dstOutputs || !invalidatedOutputs.empty()) {
Eric Laurentac3a6902018-05-11 16:39:10 -07006388 // get maximum latency of all source outputs to determine the minimum mute time guaranteeing
6389 // audio from invalidated tracks will be rendered when unmuting
Eric Laurentac3a6902018-05-11 16:39:10 -07006390 for (audio_io_handle_t srcOut : srcOutputs) {
6391 sp<SwAudioOutputDescriptor> desc = mPreviousOutputs.valueFor(srcOut);
Eric Laurentaa02db82019-09-05 17:31:49 -07006392 if (desc == nullptr) continue;
6393
6394 if (desc->isStrategyActive(psId) && maxLatency < desc->latency()) {
Eric Laurentac3a6902018-05-11 16:39:10 -07006395 maxLatency = desc->latency();
6396 }
Eric Laurentaa02db82019-09-05 17:31:49 -07006397
Eric Laurent56ed8842022-11-15 16:04:41 +01006398 bool invalidate = false;
Eric Laurentaa02db82019-09-05 17:31:49 -07006399 for (auto client : desc->clientsList(false /*activeOnly*/)) {
Eric Laurent78aade82019-09-13 18:55:08 -07006400 if (desc->isDuplicated() || !desc->mProfile->isDirectOutput()) {
Eric Laurentaa02db82019-09-05 17:31:49 -07006401 // a client on a non direct outputs has necessarily a linear PCM format
6402 // so we can call selectOutput() safely
6403 const audio_io_handle_t newOutput = selectOutput(dstOutputs,
6404 client->flags(),
6405 client->config().format,
6406 client->config().channel_mask,
jiabinebb6af42020-06-09 17:31:17 -07006407 client->config().sample_rate,
6408 client->session());
Eric Laurentaa02db82019-09-05 17:31:49 -07006409 if (newOutput != srcOut) {
6410 invalidate = true;
6411 break;
6412 }
6413 } else {
6414 sp<IOProfile> profile = getProfileForOutput(newDevices,
6415 client->config().sample_rate,
6416 client->config().format,
6417 client->config().channel_mask,
6418 client->flags(),
6419 true /* directOnly */);
6420 if (profile != desc->mProfile) {
6421 invalidate = true;
6422 break;
6423 }
6424 }
6425 }
Eric Laurent56ed8842022-11-15 16:04:41 +01006426 // mute strategy while moving tracks from one output to another
6427 if (invalidate) {
6428 invalidatedOutputs.push_back(desc);
6429 if (desc->isStrategyActive(psId)) {
6430 setStrategyMute(psId, true, desc);
6431 setStrategyMute(psId, false, desc, maxLatency * LATENCY_MUTE_FACTOR,
6432 newDevices.types());
6433 }
Eric Laurente552edb2014-03-10 17:42:56 -07006434 }
François Gaffiec005e562018-11-06 15:04:49 +01006435 sp<SourceClientDescriptor> source = getSourceForAttributesOnOutput(srcOut, attr);
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02006436 if (source != nullptr && !isCallRxAudioSource(source) && !source->isInternal()) {
Eric Laurentd60560a2015-04-10 11:31:20 -07006437 connectAudioSource(source);
6438 }
Eric Laurente552edb2014-03-10 17:42:56 -07006439 }
6440
Eric Laurent56ed8842022-11-15 16:04:41 +01006441 ALOGV_IF(!(srcOutputs.isEmpty() || dstOutputs.isEmpty()),
6442 "%s: strategy %d, moving from output %s to output %s", __func__, psId,
6443 std::to_string(srcOutputs[0]).c_str(),
6444 std::to_string(dstOutputs[0]).c_str());
6445
François Gaffiec005e562018-11-06 15:04:49 +01006446 // Move effects associated to this stream from previous output to new output
6447 if (followsSameRouting(attr, attributes_initializer(AUDIO_USAGE_MEDIA))) {
Eric Laurent36829f92017-04-07 19:04:42 -07006448 selectOutputForMusicEffects();
Eric Laurente552edb2014-03-10 17:42:56 -07006449 }
François Gaffiec005e562018-11-06 15:04:49 +01006450 // Move tracks associated to this stream (and linked) from previous output to new output
Eric Laurent56ed8842022-11-15 16:04:41 +01006451 if (!invalidatedOutputs.empty()) {
Eric Laurentaa02db82019-09-05 17:31:49 -07006452 for (auto stream : mEngine->getStreamTypesForProductStrategy(psId)) {
6453 mpClientInterface->invalidateStream(stream);
6454 }
Eric Laurent56ed8842022-11-15 16:04:41 +01006455 for (sp<SwAudioOutputDescriptor> desc : invalidatedOutputs) {
jiabin49256852022-03-09 11:21:35 -08006456 desc->setTracksInvalidatedStatusByStrategy(psId);
6457 }
Eric Laurente552edb2014-03-10 17:42:56 -07006458 }
6459 }
6460}
6461
Eric Laurente0720872014-03-11 09:30:41 -07006462void AudioPolicyManager::checkOutputForAllStrategies()
Eric Laurente552edb2014-03-10 17:42:56 -07006463{
François Gaffiec005e562018-11-06 15:04:49 +01006464 for (const auto &strategy : mEngine->getOrderedProductStrategies()) {
6465 auto attributes = mEngine->getAllAttributesForProductStrategy(strategy).front();
6466 checkOutputForAttributes(attributes);
Francois Gaffieff1eb522020-05-06 18:37:04 +02006467 checkAudioSourceForAttributes(attributes);
François Gaffiec005e562018-11-06 15:04:49 +01006468 }
Eric Laurente552edb2014-03-10 17:42:56 -07006469}
6470
Kevin Rocard153f92d2018-12-18 18:33:28 -08006471void AudioPolicyManager::checkSecondaryOutputs() {
6472 std::set<audio_stream_type_t> streamsToInvalidate;
jiabin10a03f12021-05-07 23:46:28 +00006473 TrackSecondaryOutputsMap trackSecondaryOutputs;
Kevin Rocard153f92d2018-12-18 18:33:28 -08006474 for (size_t i = 0; i < mOutputs.size(); i++) {
6475 const sp<SwAudioOutputDescriptor>& outputDescriptor = mOutputs[i];
6476 for (const sp<TrackClientDescriptor>& client : outputDescriptor->getClientIterable()) {
Eric Laurentc529cf62020-04-17 18:19:10 -07006477 sp<AudioPolicyMix> primaryMix;
6478 std::vector<sp<AudioPolicyMix>> secondaryMixes;
Dean Wheatleyd082f472022-02-04 11:10:48 +11006479 status_t status = mPolicyMixes.getOutputForAttr(client->attributes(), client->config(),
6480 client->uid(), client->flags(), primaryMix, &secondaryMixes);
Eric Laurentc529cf62020-04-17 18:19:10 -07006481 std::vector<sp<SwAudioOutputDescriptor>> secondaryDescs;
6482 for (auto &secondaryMix : secondaryMixes) {
6483 sp<SwAudioOutputDescriptor> outputDesc = secondaryMix->getOutput();
6484 if (outputDesc != nullptr &&
6485 outputDesc->mIoHandle != AUDIO_IO_HANDLE_NONE) {
6486 secondaryDescs.push_back(outputDesc);
6487 }
6488 }
6489
jiabin10a03f12021-05-07 23:46:28 +00006490 if (status != OK) {
Kevin Rocard153f92d2018-12-18 18:33:28 -08006491 streamsToInvalidate.insert(client->stream());
jiabin10a03f12021-05-07 23:46:28 +00006492 } else if (!std::equal(
6493 client->getSecondaryOutputs().begin(),
6494 client->getSecondaryOutputs().end(),
6495 secondaryDescs.begin(), secondaryDescs.end())) {
jiabina5281062021-11-23 00:10:23 +00006496 if (!audio_is_linear_pcm(client->config().format)) {
6497 // If the format is not PCM, the tracks should be invalidated to get correct
6498 // behavior when the secondary output is changed.
6499 streamsToInvalidate.insert(client->stream());
6500 } else {
6501 std::vector<wp<SwAudioOutputDescriptor>> weakSecondaryDescs;
6502 std::vector<audio_io_handle_t> secondaryOutputIds;
6503 for (const auto &secondaryDesc: secondaryDescs) {
6504 secondaryOutputIds.push_back(secondaryDesc->mIoHandle);
6505 weakSecondaryDescs.push_back(secondaryDesc);
6506 }
6507 trackSecondaryOutputs.emplace(client->portId(), secondaryOutputIds);
6508 client->setSecondaryOutputs(std::move(weakSecondaryDescs));
jiabin10a03f12021-05-07 23:46:28 +00006509 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08006510 }
6511 }
6512 }
jiabin10a03f12021-05-07 23:46:28 +00006513 if (!trackSecondaryOutputs.empty()) {
6514 mpClientInterface->updateSecondaryOutputs(trackSecondaryOutputs);
6515 }
Kevin Rocard153f92d2018-12-18 18:33:28 -08006516 for (audio_stream_type_t stream : streamsToInvalidate) {
jiabin10a03f12021-05-07 23:46:28 +00006517 ALOGD("%s Invalidate stream %d due to fail getting output for attr", __func__, stream);
Kevin Rocard153f92d2018-12-18 18:33:28 -08006518 mpClientInterface->invalidateStream(stream);
6519 }
6520}
6521
Eric Laurent2517af32020-11-25 15:31:27 +01006522bool AudioPolicyManager::isScoRequestedForComm() const {
6523 AudioDeviceTypeAddrVector devices;
6524 mEngine->getDevicesForRoleAndStrategy(mCommunnicationStrategy, DEVICE_ROLE_PREFERRED, devices);
6525 for (const auto &device : devices) {
6526 if (audio_is_bluetooth_out_sco_device(device.mType)) {
6527 return true;
6528 }
6529 }
6530 return false;
6531}
6532
Eric Laurent1a8b45f2022-04-13 16:01:47 +02006533bool AudioPolicyManager::isHearingAidUsedForComm() const {
6534 DeviceVector devices = mEngine->getOutputDevicesForStream(AUDIO_STREAM_VOICE_CALL,
6535 true /*fromCache*/);
6536 for (const auto &device : devices) {
6537 if (device->type() == AUDIO_DEVICE_OUT_HEARING_AID) {
6538 return true;
6539 }
6540 }
6541 return false;
6542}
6543
6544
Eric Laurente0720872014-03-11 09:30:41 -07006545void AudioPolicyManager::checkA2dpSuspend()
Eric Laurente552edb2014-03-10 17:42:56 -07006546{
François Gaffie53615e22015-03-19 09:24:12 +01006547 audio_io_handle_t a2dpOutput = mOutputs.getA2dpOutput();
Aniket Kumar Lataa8ee9962018-01-31 20:24:23 -08006548 if (a2dpOutput == 0 || mOutputs.isA2dpOffloadedOnPrimary()) {
Eric Laurent3a4311c2014-03-17 12:00:47 -07006549 mA2dpSuspended = false;
Eric Laurente552edb2014-03-10 17:42:56 -07006550 return;
6551 }
6552
Eric Laurent3a4311c2014-03-17 12:00:47 -07006553 bool isScoConnected =
jiabin9a3361e2019-10-01 09:38:30 -07006554 (mAvailableInputDevices.types().count(AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) != 0 ||
6555 !Intersection(mAvailableOutputDevices.types(), getAudioDeviceOutAllScoSet()).empty());
Eric Laurent2517af32020-11-25 15:31:27 +01006556 bool isScoRequested = isScoRequestedForComm();
Eric Laurentf732e072016-08-03 19:30:28 -07006557
6558 // if suspended, restore A2DP output if:
6559 // ((SCO device is NOT connected) ||
Eric Laurent2517af32020-11-25 15:31:27 +01006560 // ((SCO is not requested) &&
Eric Laurentf732e072016-08-03 19:30:28 -07006561 // (phone state is NOT in call) && (phone state is NOT ringing)))
Eric Laurente552edb2014-03-10 17:42:56 -07006562 //
Eric Laurentf732e072016-08-03 19:30:28 -07006563 // if not suspended, suspend A2DP output if:
6564 // (SCO device is connected) &&
Eric Laurent2517af32020-11-25 15:31:27 +01006565 // ((SCO is requested) ||
Eric Laurentf732e072016-08-03 19:30:28 -07006566 // ((phone state is in call) || (phone state is ringing)))
Eric Laurente552edb2014-03-10 17:42:56 -07006567 //
6568 if (mA2dpSuspended) {
Eric Laurentf732e072016-08-03 19:30:28 -07006569 if (!isScoConnected ||
Eric Laurent2517af32020-11-25 15:31:27 +01006570 (!isScoRequested &&
Eric Laurentf732e072016-08-03 19:30:28 -07006571 (mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) &&
François Gaffie2110e042015-03-24 08:41:51 +01006572 (mEngine->getPhoneState() != AUDIO_MODE_RINGTONE))) {
Eric Laurente552edb2014-03-10 17:42:56 -07006573
6574 mpClientInterface->restoreOutput(a2dpOutput);
6575 mA2dpSuspended = false;
6576 }
6577 } else {
Eric Laurentf732e072016-08-03 19:30:28 -07006578 if (isScoConnected &&
Eric Laurent2517af32020-11-25 15:31:27 +01006579 (isScoRequested ||
Eric Laurentf732e072016-08-03 19:30:28 -07006580 (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL) ||
François Gaffie2110e042015-03-24 08:41:51 +01006581 (mEngine->getPhoneState() == AUDIO_MODE_RINGTONE))) {
Eric Laurente552edb2014-03-10 17:42:56 -07006582
6583 mpClientInterface->suspendOutput(a2dpOutput);
6584 mA2dpSuspended = true;
6585 }
6586 }
6587}
6588
François Gaffie11d30102018-11-02 16:09:09 +01006589DeviceVector AudioPolicyManager::getNewOutputDevices(const sp<SwAudioOutputDescriptor>& outputDesc,
6590 bool fromCache)
Eric Laurente552edb2014-03-10 17:42:56 -07006591{
François Gaffie11d30102018-11-02 16:09:09 +01006592 DeviceVector devices;
6593
Jean-Michel Triviff155c62016-02-26 12:07:16 -08006594 ssize_t index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07006595 if (index >= 0) {
6596 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01006597 if (patchDesc->getUid() != mUidCached) {
François Gaffie11d30102018-11-02 16:09:09 +01006598 ALOGV("%s device %s forced by patch %d", __func__,
6599 outputDesc->devices().toString().c_str(), outputDesc->getPatchHandle());
6600 return outputDesc->devices();
Eric Laurent6a94d692014-05-20 11:18:06 -07006601 }
6602 }
6603
Dean Wheatley514b4312020-06-17 21:45:00 +10006604 // Do not retrieve engine device for outputs through MSD
6605 // TODO: support explicit routing requests by resetting MSD patch to engine device.
6606 if (outputDesc->devices() == getMsdAudioOutDevices()) {
6607 return outputDesc->devices();
6608 }
6609
Eric Laurent97ac8712018-07-27 18:59:02 -07006610 // Honor explicit routing requests only if no client using default routing is active on this
6611 // input: a specific app can not force routing for other apps by setting a preferred device.
6612 bool active; // unused
François Gaffie11d30102018-11-02 16:09:09 +01006613 sp<DeviceDescriptor> device =
François Gaffiec005e562018-11-06 15:04:49 +01006614 findPreferredDevice(outputDesc, PRODUCT_STRATEGY_NONE, active, mAvailableOutputDevices);
François Gaffie11d30102018-11-02 16:09:09 +01006615 if (device != nullptr) {
6616 return DeviceVector(device);
Eric Laurentf3a5a602018-05-22 18:42:55 -07006617 }
6618
François Gaffiea807ef92018-11-05 10:44:33 +01006619 // Legacy Engine cannot take care of bus devices and mix, so we need to handle the conflict
6620 // of setForceUse / Default Bus device here
6621 device = mPolicyMixes.getDeviceAndMixForOutput(outputDesc, mAvailableOutputDevices);
6622 if (device != nullptr) {
6623 return DeviceVector(device);
6624 }
6625
François Gaffiec005e562018-11-06 15:04:49 +01006626 for (const auto &productStrategy : mEngine->getOrderedProductStrategies()) {
6627 StreamTypeVector streams = mEngine->getStreamTypesForProductStrategy(productStrategy);
6628 auto attr = mEngine->getAllAttributesForProductStrategy(productStrategy).front();
Jaideep Sharmae4d123a2020-11-24 15:14:03 +05306629 auto hasStreamActive = [&](auto stream) {
6630 return hasStream(streams, stream) && isStreamActive(stream, 0);
6631 };
Eric Laurent484e9272018-06-07 17:29:23 -07006632
Jaideep Sharmae4d123a2020-11-24 15:14:03 +05306633 auto doGetOutputDevicesForVoice = [&]() {
6634 return hasVoiceStream(streams) && (outputDesc == mPrimaryOutput ||
Francois Gaffie4404ddb2021-02-04 17:03:38 +01006635 outputDesc->isActive(toVolumeSource(AUDIO_STREAM_VOICE_CALL, false))) &&
Jaideep Sharmae4d123a2020-11-24 15:14:03 +05306636 (isInCall() ||
Henrik Backlund07c654a2021-10-14 15:57:10 +02006637 mOutputs.isStrategyActiveOnSameModule(productStrategy, outputDesc)) &&
6638 !isStreamActive(AUDIO_STREAM_ENFORCED_AUDIBLE, 0);
Jaideep Sharmae4d123a2020-11-24 15:14:03 +05306639 };
6640
6641 // With low-latency playing on speaker, music on WFD, when the first low-latency
6642 // output is stopped, getNewOutputDevices checks for a product strategy
6643 // from the list, as STRATEGY_SONIFICATION comes prior to STRATEGY_MEDIA.
Carter Hsucc58a6b2021-07-20 08:44:50 +00006644 // If an ALARM or ENFORCED_AUDIBLE stream is supported by the product strategy,
Jaideep Sharmae4d123a2020-11-24 15:14:03 +05306645 // devices are returned for STRATEGY_SONIFICATION without checking whether the
6646 // stream is associated to the output descriptor.
6647 if (doGetOutputDevicesForVoice() || outputDesc->isStrategyActive(productStrategy) ||
6648 ((hasStreamActive(AUDIO_STREAM_ALARM) ||
6649 hasStreamActive(AUDIO_STREAM_ENFORCED_AUDIBLE)) &&
6650 mOutputs.isStrategyActiveOnSameModule(productStrategy, outputDesc))) {
François Gaffiec005e562018-11-06 15:04:49 +01006651 // Retrieval of devices for voice DL is done on primary output profile, cannot
6652 // check the route (would force modifying configuration file for this profile)
6653 devices = mEngine->getOutputDevicesForAttributes(attr, nullptr, fromCache);
6654 break;
6655 }
Eric Laurente552edb2014-03-10 17:42:56 -07006656 }
François Gaffiec005e562018-11-06 15:04:49 +01006657 ALOGV("%s selected devices %s", __func__, devices.toString().c_str());
François Gaffie11d30102018-11-02 16:09:09 +01006658 return devices;
Eric Laurent1c333e22014-05-20 10:48:17 -07006659}
6660
François Gaffie11d30102018-11-02 16:09:09 +01006661sp<DeviceDescriptor> AudioPolicyManager::getNewInputDevice(
6662 const sp<AudioInputDescriptor>& inputDesc)
Eric Laurent1c333e22014-05-20 10:48:17 -07006663{
François Gaffie11d30102018-11-02 16:09:09 +01006664 sp<DeviceDescriptor> device;
Eric Laurent6a94d692014-05-20 11:18:06 -07006665
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08006666 ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07006667 if (index >= 0) {
6668 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01006669 if (patchDesc->getUid() != mUidCached) {
François Gaffie11d30102018-11-02 16:09:09 +01006670 ALOGV("getNewInputDevice() device %s forced by patch %d",
6671 inputDesc->getDevice()->toString().c_str(), inputDesc->getPatchHandle());
6672 return inputDesc->getDevice();
Eric Laurent6a94d692014-05-20 11:18:06 -07006673 }
6674 }
6675
Eric Laurent97ac8712018-07-27 18:59:02 -07006676 // Honor explicit routing requests only if no client using default routing is active on this
6677 // input: a specific app can not force routing for other apps by setting a preferred device.
6678 bool active;
François Gaffie11d30102018-11-02 16:09:09 +01006679 device = findPreferredDevice(inputDesc, AUDIO_SOURCE_DEFAULT, active, mAvailableInputDevices);
6680 if (device != nullptr) {
6681 return device;
Eric Laurent97ac8712018-07-27 18:59:02 -07006682 }
6683
Eric Laurentdc95a252018-04-12 12:46:56 -07006684 // If we are not in call and no client is active on this input, this methods returns
Andy Hungf024a9e2019-01-30 16:01:02 -08006685 // a null sp<>, causing the patch on the input stream to be released.
yuanjiahsu0735bf32021-03-18 08:12:54 +08006686 audio_attributes_t attributes;
6687 uid_t uid;
6688 sp<RecordClientDescriptor> topClient = inputDesc->getHighestPriorityClient();
6689 if (topClient != nullptr) {
Eric Laurentc8c4f1f2021-11-09 11:51:34 +01006690 attributes = topClient->attributes();
6691 uid = topClient->uid();
yuanjiahsu0735bf32021-03-18 08:12:54 +08006692 } else {
Eric Laurentc8c4f1f2021-11-09 11:51:34 +01006693 attributes = { .source = AUDIO_SOURCE_DEFAULT };
6694 uid = 0;
yuanjiahsu0735bf32021-03-18 08:12:54 +08006695 }
6696
Francois Gaffie716e1432019-01-14 16:58:59 +01006697 if (attributes.source == AUDIO_SOURCE_DEFAULT && isInCall()) {
6698 attributes.source = AUDIO_SOURCE_VOICE_COMMUNICATION;
Eric Laurentdc95a252018-04-12 12:46:56 -07006699 }
Francois Gaffie716e1432019-01-14 16:58:59 +01006700 if (attributes.source != AUDIO_SOURCE_DEFAULT) {
yuanjiahsu0735bf32021-03-18 08:12:54 +08006701 device = mEngine->getInputDeviceForAttributes(attributes, uid);
Eric Laurentfb66dd92016-01-28 18:32:03 -08006702 }
Eric Laurent1c333e22014-05-20 10:48:17 -07006703
Eric Laurente552edb2014-03-10 17:42:56 -07006704 return device;
6705}
6706
Eric Laurent794fde22016-03-11 09:50:45 -08006707bool AudioPolicyManager::streamsMatchForvolume(audio_stream_type_t stream1,
6708 audio_stream_type_t stream2) {
Jean-Michel Trivi99bb2f92016-11-23 15:52:07 -08006709 return (stream1 == stream2);
Eric Laurent28d09f02016-03-08 10:43:05 -08006710}
6711
Dorin Drimusf2196d82022-01-03 12:11:18 +01006712// TODO - consider MSD routes b/214971780
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08006713status_t AudioPolicyManager::getDevicesForAttributes(
Andy Hung6d23c0f2022-02-16 09:37:15 -08006714 const audio_attributes_t &attr, AudioDeviceTypeAddrVector *devices, bool forVolume) {
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08006715 if (devices == nullptr) {
6716 return BAD_VALUE;
6717 }
Andy Hung6d23c0f2022-02-16 09:37:15 -08006718
6719 // Devices are determined in the following precedence:
6720 //
6721 // 1) Devices associated with a dynamic policy matching the attributes. This is often
6722 // a remote submix from MIX_ROUTE_FLAG_LOOP_BACK.
6723 //
6724 // If no such dynamic policy then
6725 // 2) Devices containing an active client using setPreferredDevice
6726 // with same strategy as the attributes.
6727 // (from the default Engine::getOutputDevicesForAttributes() implementation).
6728 //
6729 // If no corresponding active client with setPreferredDevice then
6730 // 3) Devices associated with the strategy determined by the attributes
6731 // (from the default Engine::getOutputDevicesForAttributes() implementation).
6732 //
6733 // See related getOutputForAttrInt().
6734
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08006735 // check dynamic policies but only for primary descriptors (secondary not used for audible
6736 // audio routing, only used for duplication for playback capture)
Eric Laurentc529cf62020-04-17 18:19:10 -07006737 sp<AudioPolicyMix> policyMix;
Dean Wheatleyd082f472022-02-04 11:10:48 +11006738 status_t status = mPolicyMixes.getOutputForAttr(attr, AUDIO_CONFIG_BASE_INITIALIZER,
6739 0 /*uid unknown here*/, AUDIO_OUTPUT_FLAG_NONE, policyMix, nullptr);
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08006740 if (status != OK) {
6741 return status;
6742 }
Andy Hung6d23c0f2022-02-16 09:37:15 -08006743
6744 DeviceVector curDevices;
6745 if (policyMix != nullptr && policyMix->getOutput() != nullptr &&
6746 // For volume control, skip LOOPBACK mixes which use AUDIO_DEVICE_OUT_REMOTE_SUBMIX
6747 // as they are unaffected by device/stream volume
6748 // (per SwAudioOutputDescriptor::isFixedVolume()).
6749 (!forVolume || policyMix->mDeviceType != AUDIO_DEVICE_OUT_REMOTE_SUBMIX)
6750 ) {
6751 sp<DeviceDescriptor> deviceDesc = mAvailableOutputDevices.getDevice(
6752 policyMix->mDeviceType, policyMix->mDeviceAddress, AUDIO_FORMAT_DEFAULT);
6753 curDevices.add(deviceDesc);
6754 } else {
6755 // The default Engine::getOutputDevicesForAttributes() uses findPreferredDevice()
6756 // which selects setPreferredDevice if active. This means forVolume call
6757 // will take an active setPreferredDevice, if such exists.
6758
6759 curDevices = mEngine->getOutputDevicesForAttributes(
6760 attr, nullptr /* preferredDevice */, false /* fromCache */);
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08006761 }
Andy Hung6d23c0f2022-02-16 09:37:15 -08006762
6763 if (forVolume) {
6764 // We alias the device AUDIO_DEVICE_OUT_SPEAKER_SAFE to AUDIO_DEVICE_OUT_SPEAKER
6765 // for single volume control in AudioService (such relationship should exist if
6766 // SPEAKER_SAFE is present).
6767 //
6768 // (This is unrelated to a different device grouping as Volume::getDeviceCategory)
6769 DeviceVector speakerSafeDevices =
6770 curDevices.getDevicesFromType(AUDIO_DEVICE_OUT_SPEAKER_SAFE);
6771 if (!speakerSafeDevices.isEmpty()) {
6772 curDevices.merge(
6773 mAvailableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_SPEAKER));
6774 curDevices.remove(speakerSafeDevices);
6775 }
6776 }
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08006777 for (const auto& device : curDevices) {
6778 devices->push_back(device->getDeviceTypeAddr());
6779 }
6780 return NO_ERROR;
6781}
6782
Eric Laurente0720872014-03-11 09:30:41 -07006783void AudioPolicyManager::handleNotificationRoutingForStream(audio_stream_type_t stream) {
Eric Laurente552edb2014-03-10 17:42:56 -07006784 switch(stream) {
Eric Laurent3b73df72014-03-11 09:06:29 -07006785 case AUDIO_STREAM_MUSIC:
François Gaffiec005e562018-11-06 15:04:49 +01006786 checkOutputForAttributes(attributes_initializer(AUDIO_USAGE_NOTIFICATION));
Eric Laurente552edb2014-03-10 17:42:56 -07006787 updateDevicesAndOutputs();
6788 break;
6789 default:
6790 break;
6791 }
6792}
6793
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07006794uint32_t AudioPolicyManager::handleEventForBeacon(int event) {
Eric Laurent9459fb02015-08-12 18:36:32 -07006795
6796 // skip beacon mute management if a dedicated TTS output is available
6797 if (mTtsOutputAvailable) {
6798 return 0;
6799 }
6800
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07006801 switch(event) {
6802 case STARTING_OUTPUT:
6803 mBeaconMuteRefCount++;
6804 break;
6805 case STOPPING_OUTPUT:
6806 if (mBeaconMuteRefCount > 0) {
6807 mBeaconMuteRefCount--;
6808 }
6809 break;
6810 case STARTING_BEACON:
6811 mBeaconPlayingRefCount++;
6812 break;
6813 case STOPPING_BEACON:
6814 if (mBeaconPlayingRefCount > 0) {
6815 mBeaconPlayingRefCount--;
6816 }
6817 break;
6818 }
6819
6820 if (mBeaconMuteRefCount > 0) {
6821 // any playback causes beacon to be muted
6822 return setBeaconMute(true);
6823 } else {
6824 // no other playback: unmute when beacon starts playing, mute when it stops
6825 return setBeaconMute(mBeaconPlayingRefCount == 0);
6826 }
6827}
6828
6829uint32_t AudioPolicyManager::setBeaconMute(bool mute) {
6830 ALOGV("setBeaconMute(%d) mBeaconMuteRefCount=%d mBeaconPlayingRefCount=%d",
6831 mute, mBeaconMuteRefCount, mBeaconPlayingRefCount);
6832 // keep track of muted state to avoid repeating mute/unmute operations
6833 if (mBeaconMuted != mute) {
6834 // mute/unmute AUDIO_STREAM_TTS on all outputs
6835 ALOGV("\t muting %d", mute);
6836 uint32_t maxLatency = 0;
Francois Gaffie4404ddb2021-02-04 17:03:38 +01006837 auto ttsVolumeSource = toVolumeSource(AUDIO_STREAM_TTS, false);
6838 if (ttsVolumeSource == VOLUME_SOURCE_NONE) {
6839 ALOGV("\t no tts volume source available");
6840 return 0;
6841 }
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07006842 for (size_t i = 0; i < mOutputs.size(); i++) {
Eric Laurentc75307b2015-03-17 15:29:32 -07006843 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
jiabin9a3361e2019-10-01 09:38:30 -07006844 setVolumeSourceMute(ttsVolumeSource, mute/*on*/, desc, 0 /*delay*/, DeviceTypeSet());
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07006845 const uint32_t latency = desc->latency() * 2;
Eric Laurentcdb2b352020-07-23 10:57:02 -07006846 if (desc->isActive(latency * 2) && latency > maxLatency) {
Jean-Michel Trivid9cfeb42014-09-22 16:51:34 -07006847 maxLatency = latency;
6848 }
6849 }
6850 mBeaconMuted = mute;
6851 return maxLatency;
6852 }
6853 return 0;
6854}
6855
Eric Laurente0720872014-03-11 09:30:41 -07006856void AudioPolicyManager::updateDevicesAndOutputs()
Eric Laurente552edb2014-03-10 17:42:56 -07006857{
François Gaffiec005e562018-11-06 15:04:49 +01006858 mEngine->updateDeviceSelectionCache();
Eric Laurente552edb2014-03-10 17:42:56 -07006859 mPreviousOutputs = mOutputs;
6860}
6861
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07006862uint32_t AudioPolicyManager::checkDeviceMuteStrategies(const sp<AudioOutputDescriptor>& outputDesc,
François Gaffiec005e562018-11-06 15:04:49 +01006863 const DeviceVector &prevDevices,
Eric Laurente552edb2014-03-10 17:42:56 -07006864 uint32_t delayMs)
6865{
6866 // mute/unmute strategies using an incompatible device combination
6867 // if muting, wait for the audio in pcm buffer to be drained before proceeding
6868 // if unmuting, unmute only after the specified delay
6869 if (outputDesc->isDuplicated()) {
6870 return 0;
6871 }
6872
6873 uint32_t muteWaitMs = 0;
François Gaffiec005e562018-11-06 15:04:49 +01006874 DeviceVector devices = outputDesc->devices();
6875 bool shouldMute = outputDesc->isActive() && (devices.size() >= 2);
Eric Laurente552edb2014-03-10 17:42:56 -07006876
François Gaffiec005e562018-11-06 15:04:49 +01006877 auto productStrategies = mEngine->getOrderedProductStrategies();
6878 for (const auto &productStrategy : productStrategies) {
6879 auto attributes = mEngine->getAllAttributesForProductStrategy(productStrategy).front();
6880 DeviceVector curDevices =
6881 mEngine->getOutputDevicesForAttributes(attributes, nullptr, false/*fromCache*/);
6882 curDevices = curDevices.filter(outputDesc->supportedDevices());
6883 bool mute = shouldMute && curDevices.containsAtLeastOne(devices) && curDevices != devices;
Eric Laurente552edb2014-03-10 17:42:56 -07006884 bool doMute = false;
6885
François Gaffiec005e562018-11-06 15:04:49 +01006886 if (mute && !outputDesc->isStrategyMutedByDevice(productStrategy)) {
Eric Laurente552edb2014-03-10 17:42:56 -07006887 doMute = true;
François Gaffiec005e562018-11-06 15:04:49 +01006888 outputDesc->setStrategyMutedByDevice(productStrategy, true);
6889 } else if (!mute && outputDesc->isStrategyMutedByDevice(productStrategy)) {
Eric Laurente552edb2014-03-10 17:42:56 -07006890 doMute = true;
François Gaffiec005e562018-11-06 15:04:49 +01006891 outputDesc->setStrategyMutedByDevice(productStrategy, false);
Eric Laurente552edb2014-03-10 17:42:56 -07006892 }
Eric Laurent99401132014-05-07 19:48:15 -07006893 if (doMute) {
Eric Laurente552edb2014-03-10 17:42:56 -07006894 for (size_t j = 0; j < mOutputs.size(); j++) {
Eric Laurent1f2f2232014-06-02 12:01:23 -07006895 sp<AudioOutputDescriptor> desc = mOutputs.valueAt(j);
Eric Laurente552edb2014-03-10 17:42:56 -07006896 // skip output if it does not share any device with current output
François Gaffie11d30102018-11-02 16:09:09 +01006897 if (!desc->supportedDevices().containsAtLeastOne(outputDesc->supportedDevices())) {
Eric Laurente552edb2014-03-10 17:42:56 -07006898 continue;
6899 }
François Gaffiec005e562018-11-06 15:04:49 +01006900 ALOGVV("%s() %s (curDevice %s)", __func__,
6901 mute ? "muting" : "unmuting", curDevices.toString().c_str());
6902 setStrategyMute(productStrategy, mute, desc, mute ? 0 : delayMs);
6903 if (desc->isStrategyActive(productStrategy)) {
Eric Laurent99401132014-05-07 19:48:15 -07006904 if (mute) {
6905 // FIXME: should not need to double latency if volume could be applied
6906 // immediately by the audioflinger mixer. We must account for the delay
6907 // between now and the next time the audioflinger thread for this output
6908 // will process a buffer (which corresponds to one buffer size,
6909 // usually 1/2 or 1/4 of the latency).
6910 if (muteWaitMs < desc->latency() * 2) {
6911 muteWaitMs = desc->latency() * 2;
Eric Laurente552edb2014-03-10 17:42:56 -07006912 }
6913 }
6914 }
6915 }
6916 }
6917 }
6918
Eric Laurent99401132014-05-07 19:48:15 -07006919 // temporary mute output if device selection changes to avoid volume bursts due to
6920 // different per device volumes
François Gaffiec005e562018-11-06 15:04:49 +01006921 if (outputDesc->isActive() && (devices != prevDevices)) {
Eric Laurentdc462862016-07-19 12:29:53 -07006922 uint32_t tempMuteWaitMs = outputDesc->latency() * 2;
Jasmine Chaf6074fe2021-08-17 13:44:31 +08006923
Eric Laurentdc462862016-07-19 12:29:53 -07006924 if (muteWaitMs < tempMuteWaitMs) {
6925 muteWaitMs = tempMuteWaitMs;
Eric Laurent99401132014-05-07 19:48:15 -07006926 }
Jasmine Chaf6074fe2021-08-17 13:44:31 +08006927
6928 // If recommended duration is defined, replace temporary mute duration to avoid
6929 // truncated notifications at beginning, which depends on duration of changing path in HAL.
6930 // Otherwise, temporary mute duration is conservatively set to 4 times the reported latency.
6931 uint32_t tempRecommendedMuteDuration = outputDesc->getRecommendedMuteDurationMs();
6932 uint32_t tempMuteDurationMs = tempRecommendedMuteDuration > 0 ?
6933 tempRecommendedMuteDuration : outputDesc->latency() * 4;
6934
François Gaffieaaac0fd2018-11-22 17:56:39 +01006935 for (const auto &activeVs : outputDesc->getActiveVolumeSources()) {
6936 // make sure that we do not start the temporary mute period too early in case of
6937 // delayed device change
6938 setVolumeSourceMute(activeVs, true, outputDesc, delayMs);
6939 setVolumeSourceMute(activeVs, false, outputDesc, delayMs + tempMuteDurationMs,
François Gaffiec005e562018-11-06 15:04:49 +01006940 devices.types());
Eric Laurent99401132014-05-07 19:48:15 -07006941 }
6942 }
6943
Eric Laurente552edb2014-03-10 17:42:56 -07006944 // wait for the PCM output buffers to empty before proceeding with the rest of the command
6945 if (muteWaitMs > delayMs) {
6946 muteWaitMs -= delayMs;
6947 usleep(muteWaitMs * 1000);
6948 return muteWaitMs;
6949 }
6950 return 0;
6951}
6952
François Gaffie11d30102018-11-02 16:09:09 +01006953uint32_t AudioPolicyManager::setOutputDevices(const sp<SwAudioOutputDescriptor>& outputDesc,
6954 const DeviceVector &devices,
6955 bool force,
6956 int delayMs,
6957 audio_patch_handle_t *patchHandle,
Francois Gaffie3523ab32021-06-22 13:24:34 +02006958 bool requiresMuteCheck, bool requiresVolumeCheck)
Eric Laurente552edb2014-03-10 17:42:56 -07006959{
François Gaffie11d30102018-11-02 16:09:09 +01006960 ALOGV("%s device %s delayMs %d", __func__, devices.toString().c_str(), delayMs);
Eric Laurente552edb2014-03-10 17:42:56 -07006961 uint32_t muteWaitMs;
6962
6963 if (outputDesc->isDuplicated()) {
François Gaffie11d30102018-11-02 16:09:09 +01006964 muteWaitMs = setOutputDevices(outputDesc->subOutput1(), devices, force, delayMs,
6965 nullptr /* patchHandle */, requiresMuteCheck);
6966 muteWaitMs += setOutputDevices(outputDesc->subOutput2(), devices, force, delayMs,
6967 nullptr /* patchHandle */, requiresMuteCheck);
Eric Laurente552edb2014-03-10 17:42:56 -07006968 return muteWaitMs;
6969 }
Eric Laurente552edb2014-03-10 17:42:56 -07006970
6971 // filter devices according to output selected
Francois Gaffie716e1432019-01-14 16:58:59 +01006972 DeviceVector filteredDevices = outputDesc->filterSupportedDevices(devices);
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01006973 DeviceVector prevDevices = outputDesc->devices();
Francois Gaffie3523ab32021-06-22 13:24:34 +02006974 DeviceVector availPrevDevices = mAvailableOutputDevices.filter(prevDevices);
Eric Laurente552edb2014-03-10 17:42:56 -07006975
François Gaffie11d30102018-11-02 16:09:09 +01006976 ALOGV("setOutputDevices() prevDevice %s", prevDevices.toString().c_str());
6977
6978 if (!filteredDevices.isEmpty()) {
6979 outputDesc->setDevices(filteredDevices);
Eric Laurente552edb2014-03-10 17:42:56 -07006980 }
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00006981
6982 // if the outputs are not materially active, there is no need to mute.
6983 if (requiresMuteCheck) {
François Gaffiec005e562018-11-06 15:04:49 +01006984 muteWaitMs = checkDeviceMuteStrategies(outputDesc, prevDevices, delayMs);
Jean-Michel Trivib3733cf2018-02-15 19:17:50 +00006985 } else {
6986 ALOGV("%s: suppressing checkDeviceMuteStrategies", __func__);
6987 muteWaitMs = 0;
6988 }
Eric Laurente552edb2014-03-10 17:42:56 -07006989
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02006990 bool outputRouted = outputDesc->isRouted();
6991
Eric Laurent79ea9582020-06-11 18:49:24 -07006992 // no need to proceed if new device is not AUDIO_DEVICE_NONE and not supported by current
6993 // output profile or if new device is not supported AND previous device(s) is(are) still
6994 // available (otherwise reset device must be done on the output)
Francois Gaffie3523ab32021-06-22 13:24:34 +02006995 if (!devices.isEmpty() && filteredDevices.isEmpty() && !availPrevDevices.empty()) {
Eric Laurent79ea9582020-06-11 18:49:24 -07006996 ALOGV("%s: unsupported device %s for output", __func__, devices.toString().c_str());
6997 // restore previous device after evaluating strategy mute state
6998 outputDesc->setDevices(prevDevices);
6999 return muteWaitMs;
7000 }
7001
Eric Laurente552edb2014-03-10 17:42:56 -07007002 // Do not change the routing if:
Eric Laurentb80a2a82014-10-27 16:07:59 -07007003 // the requested device is AUDIO_DEVICE_NONE
7004 // OR the requested device is the same as current device
7005 // AND force is not specified
7006 // AND the output is connected by a valid audio patch.
François Gaffie11d30102018-11-02 16:09:09 +01007007 // Doing this check here allows the caller to call setOutputDevices() without conditions
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02007008 if ((filteredDevices.isEmpty() || filteredDevices == prevDevices) && !force && outputRouted) {
François Gaffie11d30102018-11-02 16:09:09 +01007009 ALOGV("%s setting same device %s or null device, force=%d, patch handle=%d", __func__,
7010 filteredDevices.toString().c_str(), force, outputDesc->getPatchHandle());
Francois Gaffie3523ab32021-06-22 13:24:34 +02007011 if (requiresVolumeCheck && !filteredDevices.isEmpty()) {
7012 ALOGV("%s setting same device on routed output, force apply volumes", __func__);
7013 applyStreamVolumes(outputDesc, filteredDevices.types(), delayMs, true /*force*/);
7014 }
Eric Laurente552edb2014-03-10 17:42:56 -07007015 return muteWaitMs;
7016 }
7017
François Gaffie11d30102018-11-02 16:09:09 +01007018 ALOGV("%s changing device to %s", __func__, filteredDevices.toString().c_str());
Eric Laurent1c333e22014-05-20 10:48:17 -07007019
Eric Laurente552edb2014-03-10 17:42:56 -07007020 // do the routing
Francois Gaffie3523ab32021-06-22 13:24:34 +02007021 if (filteredDevices.isEmpty() || mAvailableOutputDevices.filter(filteredDevices).empty()) {
Eric Laurentc75307b2015-03-17 15:29:32 -07007022 resetOutputDevice(outputDesc, delayMs, NULL);
Eric Laurent1c333e22014-05-20 10:48:17 -07007023 } else {
François Gaffie11d30102018-11-02 16:09:09 +01007024 PatchBuilder patchBuilder;
7025 patchBuilder.addSource(outputDesc);
7026 ALOG_ASSERT(filteredDevices.size() <= AUDIO_PATCH_PORTS_MAX, "Too many sink ports");
7027 for (const auto &filteredDevice : filteredDevices) {
7028 patchBuilder.addSink(filteredDevice);
Eric Laurentc40d9692016-04-13 19:14:13 -07007029 }
7030
Jasmine Cha7f82d1a2020-03-16 13:21:47 +08007031 // Add half reported latency to delayMs when muteWaitMs is null in order
7032 // to avoid disordered sequence of muting volume and changing devices.
7033 installPatch(__func__, patchHandle, outputDesc.get(), patchBuilder.patch(),
7034 muteWaitMs == 0 ? (delayMs + (outputDesc->latency() / 2)) : delayMs);
Eric Laurent1c333e22014-05-20 10:48:17 -07007035 }
Eric Laurente552edb2014-03-10 17:42:56 -07007036
7037 // update stream volumes according to new device
François Gaffie11d30102018-11-02 16:09:09 +01007038 applyStreamVolumes(outputDesc, filteredDevices.types(), delayMs);
Eric Laurente552edb2014-03-10 17:42:56 -07007039
7040 return muteWaitMs;
7041}
7042
Eric Laurentc75307b2015-03-17 15:29:32 -07007043status_t AudioPolicyManager::resetOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
Eric Laurent6a94d692014-05-20 11:18:06 -07007044 int delayMs,
7045 audio_patch_handle_t *patchHandle)
Eric Laurent1c333e22014-05-20 10:48:17 -07007046{
Eric Laurent6a94d692014-05-20 11:18:06 -07007047 ssize_t index;
Francois Gaffieb2e5cb52021-06-22 13:16:09 +02007048 if (patchHandle == nullptr && !outputDesc->isRouted()) {
7049 return INVALID_OPERATION;
7050 }
Eric Laurent6a94d692014-05-20 11:18:06 -07007051 if (patchHandle) {
7052 index = mAudioPatches.indexOfKey(*patchHandle);
7053 } else {
Jean-Michel Triviff155c62016-02-26 12:07:16 -08007054 index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07007055 }
7056 if (index < 0) {
Eric Laurent1c333e22014-05-20 10:48:17 -07007057 return INVALID_OPERATION;
7058 }
Eric Laurent6a94d692014-05-20 11:18:06 -07007059 sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01007060 status_t status = mpClientInterface->releaseAudioPatch(patchDesc->getAfHandle(), delayMs);
Eric Laurent1c333e22014-05-20 10:48:17 -07007061 ALOGV("resetOutputDevice() releaseAudioPatch returned %d", status);
Glenn Kastena13cde92016-03-28 15:26:02 -07007062 outputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
François Gaffieafd4cea2019-11-18 15:50:22 +01007063 removeAudioPatch(patchDesc->getHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07007064 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07007065 mpClientInterface->onAudioPatchListUpdate();
Eric Laurent1c333e22014-05-20 10:48:17 -07007066 return status;
7067}
7068
7069status_t AudioPolicyManager::setInputDevice(audio_io_handle_t input,
François Gaffie11d30102018-11-02 16:09:09 +01007070 const sp<DeviceDescriptor> &device,
Eric Laurent6a94d692014-05-20 11:18:06 -07007071 bool force,
7072 audio_patch_handle_t *patchHandle)
Eric Laurent1c333e22014-05-20 10:48:17 -07007073{
7074 status_t status = NO_ERROR;
7075
Eric Laurent1f2f2232014-06-02 12:01:23 -07007076 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
François Gaffie11d30102018-11-02 16:09:09 +01007077 if ((device != nullptr) && ((device != inputDesc->getDevice()) || force)) {
7078 inputDesc->setDevice(device);
Eric Laurent1c333e22014-05-20 10:48:17 -07007079
François Gaffie11d30102018-11-02 16:09:09 +01007080 if (mAvailableInputDevices.contains(device)) {
Mikhail Naganovdc769682018-05-04 15:34:08 -07007081 PatchBuilder patchBuilder;
7082 patchBuilder.addSink(inputDesc,
Eric Laurentdaf92cc2014-07-22 15:36:10 -07007083 // AUDIO_SOURCE_HOTWORD is for internal use only:
7084 // handled as AUDIO_SOURCE_VOICE_RECOGNITION by the audio HAL
Mikhail Naganovdc769682018-05-04 15:34:08 -07007085 [inputDesc](const PatchBuilder::mix_usecase_t& usecase) {
7086 auto result = usecase;
7087 if (result.source == AUDIO_SOURCE_HOTWORD && !inputDesc->isSoundTrigger()) {
7088 result.source = AUDIO_SOURCE_VOICE_RECOGNITION;
7089 }
7090 return result; }).
Eric Laurent1c333e22014-05-20 10:48:17 -07007091 //only one input device for now
François Gaffie11d30102018-11-02 16:09:09 +01007092 addSource(device);
Mikhail Naganovdc769682018-05-04 15:34:08 -07007093 status = installPatch(__func__, patchHandle, inputDesc.get(), patchBuilder.patch(), 0);
Eric Laurent1c333e22014-05-20 10:48:17 -07007094 }
7095 }
7096 return status;
7097}
7098
Eric Laurent6a94d692014-05-20 11:18:06 -07007099status_t AudioPolicyManager::resetInputDevice(audio_io_handle_t input,
7100 audio_patch_handle_t *patchHandle)
Eric Laurent1c333e22014-05-20 10:48:17 -07007101{
Eric Laurent1f2f2232014-06-02 12:01:23 -07007102 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
Eric Laurent6a94d692014-05-20 11:18:06 -07007103 ssize_t index;
7104 if (patchHandle) {
7105 index = mAudioPatches.indexOfKey(*patchHandle);
7106 } else {
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08007107 index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07007108 }
7109 if (index < 0) {
Eric Laurent1c333e22014-05-20 10:48:17 -07007110 return INVALID_OPERATION;
7111 }
Eric Laurent6a94d692014-05-20 11:18:06 -07007112 sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01007113 status_t status = mpClientInterface->releaseAudioPatch(patchDesc->getAfHandle(), 0);
Eric Laurent1c333e22014-05-20 10:48:17 -07007114 ALOGV("resetInputDevice() releaseAudioPatch returned %d", status);
Glenn Kastena13cde92016-03-28 15:26:02 -07007115 inputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
François Gaffieafd4cea2019-11-18 15:50:22 +01007116 removeAudioPatch(patchDesc->getHandle());
Eric Laurent6a94d692014-05-20 11:18:06 -07007117 nextAudioPortGeneration();
Eric Laurentb52c1522014-05-20 11:27:36 -07007118 mpClientInterface->onAudioPatchListUpdate();
Eric Laurent1c333e22014-05-20 10:48:17 -07007119 return status;
7120}
7121
François Gaffie11d30102018-11-02 16:09:09 +01007122sp<IOProfile> AudioPolicyManager::getInputProfile(const sp<DeviceDescriptor> &device,
François Gaffie53615e22015-03-19 09:24:12 +01007123 uint32_t& samplingRate,
Andy Hungf129b032015-04-07 13:45:50 -07007124 audio_format_t& format,
7125 audio_channel_mask_t& channelMask,
François Gaffie53615e22015-03-19 09:24:12 +01007126 audio_input_flags_t flags)
Eric Laurente552edb2014-03-10 17:42:56 -07007127{
7128 // Choose an input profile based on the requested capture parameters: select the first available
7129 // profile supporting all requested parameters.
Andy Hungf129b032015-04-07 13:45:50 -07007130 //
7131 // TODO: perhaps isCompatibleProfile should return a "matching" score so we can return
7132 // the best matching profile, not the first one.
Eric Laurente552edb2014-03-10 17:42:56 -07007133
Glenn Kasten730b9262018-03-29 15:01:26 -07007134 sp<IOProfile> firstInexact;
7135 uint32_t updatedSamplingRate = 0;
7136 audio_format_t updatedFormat = AUDIO_FORMAT_INVALID;
7137 audio_channel_mask_t updatedChannelMask = AUDIO_CHANNEL_INVALID;
Mikhail Naganov7e22e942017-12-07 10:04:29 -08007138 for (const auto& hwModule : mHwModules) {
Mikhail Naganova5e165d2017-12-07 17:08:02 -08007139 for (const auto& profile : hwModule->getInputProfiles()) {
Eric Laurentd4692962014-05-05 18:13:44 -07007140 // profile->log();
Glenn Kasten730b9262018-03-29 15:01:26 -07007141 //updatedFormat = format;
François Gaffie11d30102018-11-02 16:09:09 +01007142 if (profile->isCompatibleProfile(DeviceVector(device), samplingRate,
Glenn Kasten730b9262018-03-29 15:01:26 -07007143 &samplingRate /*updatedSamplingRate*/,
Andy Hungf129b032015-04-07 13:45:50 -07007144 format,
Glenn Kasten730b9262018-03-29 15:01:26 -07007145 &format, /*updatedFormat*/
Andy Hungf129b032015-04-07 13:45:50 -07007146 channelMask,
Glenn Kasten730b9262018-03-29 15:01:26 -07007147 &channelMask /*updatedChannelMask*/,
7148 // FIXME ugly cast
7149 (audio_output_flags_t) flags,
7150 true /*exactMatchRequiredForInputFlags*/)) {
Eric Laurente552edb2014-03-10 17:42:56 -07007151 return profile;
7152 }
François Gaffie11d30102018-11-02 16:09:09 +01007153 if (firstInexact == nullptr && profile->isCompatibleProfile(DeviceVector(device),
Glenn Kasten730b9262018-03-29 15:01:26 -07007154 samplingRate,
7155 &updatedSamplingRate,
7156 format,
7157 &updatedFormat,
7158 channelMask,
7159 &updatedChannelMask,
7160 // FIXME ugly cast
7161 (audio_output_flags_t) flags,
7162 false /*exactMatchRequiredForInputFlags*/)) {
7163 firstInexact = profile;
7164 }
7165
Eric Laurente552edb2014-03-10 17:42:56 -07007166 }
7167 }
Glenn Kasten730b9262018-03-29 15:01:26 -07007168 if (firstInexact != nullptr) {
7169 samplingRate = updatedSamplingRate;
7170 format = updatedFormat;
7171 channelMask = updatedChannelMask;
7172 return firstInexact;
7173 }
Eric Laurente552edb2014-03-10 17:42:56 -07007174 return NULL;
7175}
7176
François Gaffieaaac0fd2018-11-22 17:56:39 +01007177float AudioPolicyManager::computeVolume(IVolumeCurves &curves,
7178 VolumeSource volumeSource,
François Gaffied1ab2bd2015-12-02 18:20:06 +01007179 int index,
jiabin9a3361e2019-10-01 09:38:30 -07007180 const DeviceTypeSet& deviceTypes)
Eric Laurente552edb2014-03-10 17:42:56 -07007181{
jiabin9a3361e2019-10-01 09:38:30 -07007182 float volumeDb = curves.volIndexToDb(Volume::getDeviceCategory(deviceTypes), index);
Jean-Michel Trivi3d8b4a42016-09-14 18:37:46 -07007183
7184 // handle the case of accessibility active while a ringtone is playing: if the ringtone is much
7185 // louder than the accessibility prompt, the prompt cannot be heard, thus masking the touch
7186 // exploration of the dialer UI. In this situation, bring the accessibility volume closer to
7187 // the ringtone volume
Francois Gaffie4404ddb2021-02-04 17:03:38 +01007188 const auto callVolumeSrc = toVolumeSource(AUDIO_STREAM_VOICE_CALL, false);
7189 const auto ringVolumeSrc = toVolumeSource(AUDIO_STREAM_RING, false);
7190 const auto musicVolumeSrc = toVolumeSource(AUDIO_STREAM_MUSIC, false);
7191 const auto alarmVolumeSrc = toVolumeSource(AUDIO_STREAM_ALARM, false);
7192 const auto a11yVolumeSrc = toVolumeSource(AUDIO_STREAM_ACCESSIBILITY, false);
François Gaffieaaac0fd2018-11-22 17:56:39 +01007193
Jean-Michel Trivi441ed652019-07-11 14:55:16 -07007194 if (volumeSource == a11yVolumeSrc
François Gaffieaaac0fd2018-11-22 17:56:39 +01007195 && (AUDIO_MODE_RINGTONE == mEngine->getPhoneState()) &&
7196 mOutputs.isActive(ringVolumeSrc, 0)) {
7197 auto &ringCurves = getVolumeCurves(AUDIO_STREAM_RING);
jiabin9a3361e2019-10-01 09:38:30 -07007198 const float ringVolumeDb = computeVolume(ringCurves, ringVolumeSrc, index, deviceTypes);
François Gaffieaaac0fd2018-11-22 17:56:39 +01007199 return ringVolumeDb - 4 > volumeDb ? ringVolumeDb - 4 : volumeDb;
Jean-Michel Trivi3d8b4a42016-09-14 18:37:46 -07007200 }
7201
Eric Laurentdcd4ab12018-06-29 17:45:13 -07007202 // in-call: always cap volume by voice volume + some low headroom
François Gaffieaaac0fd2018-11-22 17:56:39 +01007203 if ((volumeSource != callVolumeSrc && (isInCall() ||
7204 mOutputs.isActiveLocally(callVolumeSrc))) &&
Francois Gaffie4404ddb2021-02-04 17:03:38 +01007205 (volumeSource == toVolumeSource(AUDIO_STREAM_SYSTEM, false) ||
François Gaffieaaac0fd2018-11-22 17:56:39 +01007206 volumeSource == ringVolumeSrc || volumeSource == musicVolumeSrc ||
7207 volumeSource == alarmVolumeSrc ||
Francois Gaffie4404ddb2021-02-04 17:03:38 +01007208 volumeSource == toVolumeSource(AUDIO_STREAM_NOTIFICATION, false) ||
7209 volumeSource == toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE, false) ||
7210 volumeSource == toVolumeSource(AUDIO_STREAM_DTMF, false) ||
Jean-Michel Trivi441ed652019-07-11 14:55:16 -07007211 volumeSource == a11yVolumeSrc)) {
François Gaffieaaac0fd2018-11-22 17:56:39 +01007212 auto &voiceCurves = getVolumeCurves(callVolumeSrc);
jiabin9a3361e2019-10-01 09:38:30 -07007213 int voiceVolumeIndex = voiceCurves.getVolumeIndex(deviceTypes);
François Gaffieaaac0fd2018-11-22 17:56:39 +01007214 const float maxVoiceVolDb =
jiabin9a3361e2019-10-01 09:38:30 -07007215 computeVolume(voiceCurves, callVolumeSrc, voiceVolumeIndex, deviceTypes)
Eric Laurent7731b5a2018-04-06 15:47:22 -07007216 + IN_CALL_EARPIECE_HEADROOM_DB;
Abhijith Shastry329ddab2019-04-23 11:53:26 -07007217 // FIXME: Workaround for call screening applications until a proper audio mode is defined
7218 // to support this scenario : Exempt the RING stream from the audio cap if the audio was
7219 // programmatically muted.
7220 // VOICE_CALL stream has minVolumeIndex > 0 : Users cannot set the volume of voice calls to
7221 // 0. We don't want to cap volume when the system has programmatically muted the voice call
7222 // stream. See setVolumeCurveIndex() for more information.
Jean-Michel Trivi441ed652019-07-11 14:55:16 -07007223 bool exemptFromCapping =
7224 ((volumeSource == ringVolumeSrc) || (volumeSource == a11yVolumeSrc))
7225 && (voiceVolumeIndex == 0);
Abhijith Shastry329ddab2019-04-23 11:53:26 -07007226 ALOGV_IF(exemptFromCapping, "%s volume source %d at vol=%f not capped", __func__,
7227 volumeSource, volumeDb);
7228 if ((volumeDb > maxVoiceVolDb) && !exemptFromCapping) {
François Gaffieaaac0fd2018-11-22 17:56:39 +01007229 ALOGV("%s volume source %d at vol=%f overriden by volume group %d at vol=%f", __func__,
7230 volumeSource, volumeDb, callVolumeSrc, maxVoiceVolDb);
7231 volumeDb = maxVoiceVolDb;
Jean-Michel Trivi719a9872017-08-05 13:51:35 -07007232 }
7233 }
Eric Laurente552edb2014-03-10 17:42:56 -07007234 // if a headset is connected, apply the following rules to ring tones and notifications
7235 // to avoid sound level bursts in user's ears:
Eric Laurent6af1c1d2016-04-14 11:20:44 -07007236 // - always attenuate notifications volume by 6dB
7237 // - attenuate ring tones volume by 6dB unless music is not playing and
7238 // speaker is part of the select devices
Eric Laurente552edb2014-03-10 17:42:56 -07007239 // - if music is playing, always limit the volume to current music volume,
7240 // with a minimum threshold at -36dB so that notification is always perceived.
jiabin9a3361e2019-10-01 09:38:30 -07007241 if (!Intersection(deviceTypes,
7242 {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES,
7243 AUDIO_DEVICE_OUT_WIRED_HEADSET, AUDIO_DEVICE_OUT_WIRED_HEADPHONE,
Eric Laurentc42df452020-08-07 10:51:53 -07007244 AUDIO_DEVICE_OUT_USB_HEADSET, AUDIO_DEVICE_OUT_HEARING_AID,
7245 AUDIO_DEVICE_OUT_BLE_HEADSET}).empty() &&
François Gaffieaaac0fd2018-11-22 17:56:39 +01007246 ((volumeSource == alarmVolumeSrc ||
7247 volumeSource == ringVolumeSrc) ||
Francois Gaffie4404ddb2021-02-04 17:03:38 +01007248 (volumeSource == toVolumeSource(AUDIO_STREAM_NOTIFICATION, false)) ||
7249 (volumeSource == toVolumeSource(AUDIO_STREAM_SYSTEM, false)) ||
7250 ((volumeSource == toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE, false)) &&
François Gaffieaaac0fd2018-11-22 17:56:39 +01007251 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_NONE))) &&
7252 curves.canBeMuted()) {
7253
Eric Laurente552edb2014-03-10 17:42:56 -07007254 // when the phone is ringing we must consider that music could have been paused just before
7255 // by the music application and behave as if music was active if the last music track was
7256 // just stopped
Eric Laurent3b73df72014-03-11 09:06:29 -07007257 if (isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY) ||
Eric Laurente552edb2014-03-10 17:42:56 -07007258 mLimitRingtoneVolume) {
François Gaffie43c73442018-11-08 08:21:55 +01007259 volumeDb += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
jiabin9a3361e2019-10-01 09:38:30 -07007260 DeviceTypeSet musicDevice =
François Gaffiec005e562018-11-06 15:04:49 +01007261 mEngine->getOutputDevicesForAttributes(attributes_initializer(AUDIO_USAGE_MEDIA),
7262 nullptr, true /*fromCache*/).types();
François Gaffieaaac0fd2018-11-22 17:56:39 +01007263 auto &musicCurves = getVolumeCurves(AUDIO_STREAM_MUSIC);
jiabin9a3361e2019-10-01 09:38:30 -07007264 float musicVolDb = computeVolume(musicCurves,
7265 musicVolumeSrc,
7266 musicCurves.getVolumeIndex(musicDevice),
7267 musicDevice);
François Gaffieaaac0fd2018-11-22 17:56:39 +01007268 float minVolDb = (musicVolDb > SONIFICATION_HEADSET_VOLUME_MIN_DB) ?
7269 musicVolDb : SONIFICATION_HEADSET_VOLUME_MIN_DB;
7270 if (volumeDb > minVolDb) {
7271 volumeDb = minVolDb;
7272 ALOGV("computeVolume limiting volume to %f musicVol %f", minVolDb, musicVolDb);
Eric Laurente552edb2014-03-10 17:42:56 -07007273 }
Eric Laurent7b6385c2021-05-12 17:55:36 +02007274 if (Volume::getDeviceForVolume(deviceTypes) != AUDIO_DEVICE_OUT_SPEAKER
7275 && !Intersection(deviceTypes, {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,
7276 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES}).empty()) {
Jean-Michel Trivi00a20962016-05-25 19:11:01 -07007277 // on A2DP, also ensure notification volume is not too low compared to media when
7278 // intended to be played
François Gaffie43c73442018-11-08 08:21:55 +01007279 if ((volumeDb > -96.0f) &&
François Gaffieaaac0fd2018-11-22 17:56:39 +01007280 (musicVolDb - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB > volumeDb)) {
jiabin9a3361e2019-10-01 09:38:30 -07007281 ALOGV("%s increasing volume for volume source=%d device=%s from %f to %f",
7282 __func__, volumeSource, dumpDeviceTypes(deviceTypes).c_str(), volumeDb,
François Gaffieaaac0fd2018-11-22 17:56:39 +01007283 musicVolDb - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB);
7284 volumeDb = musicVolDb - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB;
Jean-Michel Trivi00a20962016-05-25 19:11:01 -07007285 }
7286 }
jiabin9a3361e2019-10-01 09:38:30 -07007287 } else if ((Volume::getDeviceForVolume(deviceTypes) != AUDIO_DEVICE_OUT_SPEAKER) ||
François Gaffieaaac0fd2018-11-22 17:56:39 +01007288 (!(volumeSource == alarmVolumeSrc || volumeSource == ringVolumeSrc))) {
François Gaffie43c73442018-11-08 08:21:55 +01007289 volumeDb += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
Eric Laurente552edb2014-03-10 17:42:56 -07007290 }
7291 }
7292
François Gaffie43c73442018-11-08 08:21:55 +01007293 return volumeDb;
Eric Laurente552edb2014-03-10 17:42:56 -07007294}
7295
Eric Laurent3839bc02018-07-10 18:33:34 -07007296int AudioPolicyManager::rescaleVolumeIndex(int srcIndex,
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01007297 VolumeSource fromVolumeSource,
7298 VolumeSource toVolumeSource)
Eric Laurent3839bc02018-07-10 18:33:34 -07007299{
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01007300 if (fromVolumeSource == toVolumeSource) {
Eric Laurent3839bc02018-07-10 18:33:34 -07007301 return srcIndex;
7302 }
Francois Gaffie2ffdfce2019-03-12 11:26:42 +01007303 auto &srcCurves = getVolumeCurves(fromVolumeSource);
7304 auto &dstCurves = getVolumeCurves(toVolumeSource);
Eric Laurentf5aa58d2019-02-22 18:20:11 -08007305 float minSrc = (float)srcCurves.getVolumeIndexMin();
7306 float maxSrc = (float)srcCurves.getVolumeIndexMax();
7307 float minDst = (float)dstCurves.getVolumeIndexMin();
7308 float maxDst = (float)dstCurves.getVolumeIndexMax();
Eric Laurent3839bc02018-07-10 18:33:34 -07007309
Revathi Uddarajufe0fb8b2017-07-27 17:05:37 +08007310 // preserve mute request or correct range
7311 if (srcIndex < minSrc) {
7312 if (srcIndex == 0) {
7313 return 0;
7314 }
7315 srcIndex = minSrc;
7316 } else if (srcIndex > maxSrc) {
7317 srcIndex = maxSrc;
7318 }
Eric Laurent3839bc02018-07-10 18:33:34 -07007319 return (int)(minDst + ((srcIndex - minSrc) * (maxDst - minDst)) / (maxSrc - minSrc));
7320}
7321
François Gaffieaaac0fd2018-11-22 17:56:39 +01007322status_t AudioPolicyManager::checkAndSetVolume(IVolumeCurves &curves,
7323 VolumeSource volumeSource,
Eric Laurentf5aa58d2019-02-22 18:20:11 -08007324 int index,
7325 const sp<AudioOutputDescriptor>& outputDesc,
jiabin9a3361e2019-10-01 09:38:30 -07007326 DeviceTypeSet deviceTypes,
Eric Laurentf5aa58d2019-02-22 18:20:11 -08007327 int delayMs,
7328 bool force)
Eric Laurente552edb2014-03-10 17:42:56 -07007329{
François Gaffieaaac0fd2018-11-22 17:56:39 +01007330 // do not change actual attributes volume if the attributes is muted
7331 if (outputDesc->isMuted(volumeSource)) {
7332 ALOGVV("%s: volume source %d muted count %d active=%d", __func__, volumeSource,
7333 outputDesc->getMuteCount(volumeSource), outputDesc->isActive(volumeSource));
Eric Laurente552edb2014-03-10 17:42:56 -07007334 return NO_ERROR;
7335 }
Francois Gaffie4404ddb2021-02-04 17:03:38 +01007336 VolumeSource callVolSrc = toVolumeSource(AUDIO_STREAM_VOICE_CALL, false);
7337 VolumeSource btScoVolSrc = toVolumeSource(AUDIO_STREAM_BLUETOOTH_SCO, false);
7338 bool isVoiceVolSrc = (volumeSource != VOLUME_SOURCE_NONE) && (callVolSrc == volumeSource);
7339 bool isBtScoVolSrc = (volumeSource != VOLUME_SOURCE_NONE) && (btScoVolSrc == volumeSource);
François Gaffieaaac0fd2018-11-22 17:56:39 +01007340
Eric Laurent2517af32020-11-25 15:31:27 +01007341 bool isScoRequested = isScoRequestedForComm();
Eric Laurent1a8b45f2022-04-13 16:01:47 +02007342 bool isHAUsed = isHearingAidUsedForComm();
7343
Eric Laurente552edb2014-03-10 17:42:56 -07007344 // do not change in call volume if bluetooth is connected and vice versa
François Gaffieaaac0fd2018-11-22 17:56:39 +01007345 // if sco and call follow same curves, bypass forceUseForComm
7346 if ((callVolSrc != btScoVolSrc) &&
Eric Laurent2517af32020-11-25 15:31:27 +01007347 ((isVoiceVolSrc && isScoRequested) ||
Eric Laurent1a8b45f2022-04-13 16:01:47 +02007348 (isBtScoVolSrc && !(isScoRequested || isHAUsed)))) {
Eric Laurent2517af32020-11-25 15:31:27 +01007349 ALOGV("%s cannot set volume group %d volume when is%srequested for comm", __func__,
Eric Laurent1a8b45f2022-04-13 16:01:47 +02007350 volumeSource, isScoRequested ? " " : " not ");
Eric Laurent571ef962020-07-24 11:43:48 -07007351 // Do not return an error here as AudioService will always set both voice call
7352 // and bluetooth SCO volumes due to stream aliasing.
7353 return NO_ERROR;
Eric Laurente552edb2014-03-10 17:42:56 -07007354 }
jiabin9a3361e2019-10-01 09:38:30 -07007355 if (deviceTypes.empty()) {
7356 deviceTypes = outputDesc->devices().types();
Eric Laurentc75307b2015-03-17 15:29:32 -07007357 }
Eric Laurent275e8e92014-11-30 15:14:47 -08007358
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00007359 if (curves.getVolumeIndexMin() < 0 || curves.getVolumeIndexMax() < 0) {
7360 ALOGE("invalid volume index range");
7361 return BAD_VALUE;
7362 }
7363
jiabin9a3361e2019-10-01 09:38:30 -07007364 float volumeDb = computeVolume(curves, volumeSource, index, deviceTypes);
7365 if (outputDesc->isFixedVolume(deviceTypes) ||
Eric Laurent9698a4c2020-10-12 17:10:23 -07007366 // Force VoIP volume to max for bluetooth SCO device except if muted
7367 (index != 0 && (isVoiceVolSrc || isBtScoVolSrc) &&
jiabin9a3361e2019-10-01 09:38:30 -07007368 isSingleDeviceType(deviceTypes, audio_is_bluetooth_out_sco_device))) {
Eric Laurentffbc80f2015-03-18 18:30:19 -07007369 volumeDb = 0.0f;
Eric Laurent275e8e92014-11-30 15:14:47 -08007370 }
Francois Gaffie593634d2021-06-22 13:31:31 +02007371 const bool muted = (index == 0) && (volumeDb != 0.0f);
jiabin9a3361e2019-10-01 09:38:30 -07007372 outputDesc->setVolume(
Francois Gaffie593634d2021-06-22 13:31:31 +02007373 volumeDb, muted, volumeSource, curves.getStreamTypes(), deviceTypes, delayMs, force);
Eric Laurentc75307b2015-03-17 15:29:32 -07007374
Eric Laurente8f2c0f2021-08-17 11:17:19 +02007375 if (outputDesc == mPrimaryOutput && (isVoiceVolSrc || isBtScoVolSrc)) {
Eric Laurente552edb2014-03-10 17:42:56 -07007376 float voiceVolume;
Eric Laurentfad001d2019-06-11 19:17:57 -07007377 // 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 +01007378 if (isVoiceVolSrc) {
7379 voiceVolume = (float)index/(float)curves.getVolumeIndexMax();
Eric Laurente552edb2014-03-10 17:42:56 -07007380 } else {
Eric Laurentfad001d2019-06-11 19:17:57 -07007381 voiceVolume = index == 0 ? 0.0 : 1.0;
Eric Laurente552edb2014-03-10 17:42:56 -07007382 }
Eric Laurent18fba842016-03-31 14:41:26 -07007383 if (voiceVolume != mLastVoiceVolume) {
Eric Laurente552edb2014-03-10 17:42:56 -07007384 mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
7385 mLastVoiceVolume = voiceVolume;
7386 }
7387 }
Eric Laurente552edb2014-03-10 17:42:56 -07007388 return NO_ERROR;
7389}
7390
Eric Laurentc75307b2015-03-17 15:29:32 -07007391void AudioPolicyManager::applyStreamVolumes(const sp<AudioOutputDescriptor>& outputDesc,
jiabin9a3361e2019-10-01 09:38:30 -07007392 const DeviceTypeSet& deviceTypes,
7393 int delayMs,
7394 bool force)
Eric Laurente552edb2014-03-10 17:42:56 -07007395{
jiabincd510522020-01-22 09:40:55 -08007396 ALOGVV("applyStreamVolumes() for device %s", dumpDeviceTypes(deviceTypes).c_str());
François Gaffieaaac0fd2018-11-22 17:56:39 +01007397 for (const auto &volumeGroup : mEngine->getVolumeGroups()) {
7398 auto &curves = getVolumeCurves(toVolumeSource(volumeGroup));
7399 checkAndSetVolume(curves, toVolumeSource(volumeGroup),
jiabin9a3361e2019-10-01 09:38:30 -07007400 curves.getVolumeIndex(deviceTypes),
7401 outputDesc, deviceTypes, delayMs, force);
Eric Laurente552edb2014-03-10 17:42:56 -07007402 }
7403}
7404
François Gaffiec005e562018-11-06 15:04:49 +01007405void AudioPolicyManager::setStrategyMute(product_strategy_t strategy,
7406 bool on,
7407 const sp<AudioOutputDescriptor>& outputDesc,
7408 int delayMs,
jiabin9a3361e2019-10-01 09:38:30 -07007409 DeviceTypeSet deviceTypes)
Eric Laurente552edb2014-03-10 17:42:56 -07007410{
François Gaffieaaac0fd2018-11-22 17:56:39 +01007411 std::vector<VolumeSource> sourcesToMute;
7412 for (auto attributes: mEngine->getAllAttributesForProductStrategy(strategy)) {
7413 ALOGVV("%s() attributes %s, mute %d, output ID %d", __func__,
7414 toString(attributes).c_str(), on, outputDesc->getId());
Francois Gaffie4404ddb2021-02-04 17:03:38 +01007415 VolumeSource source = toVolumeSource(attributes, false);
7416 if ((source != VOLUME_SOURCE_NONE) &&
7417 (std::find(begin(sourcesToMute), end(sourcesToMute), source)
7418 == end(sourcesToMute))) {
François Gaffieaaac0fd2018-11-22 17:56:39 +01007419 sourcesToMute.push_back(source);
7420 }
Eric Laurente552edb2014-03-10 17:42:56 -07007421 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01007422 for (auto source : sourcesToMute) {
jiabin9a3361e2019-10-01 09:38:30 -07007423 setVolumeSourceMute(source, on, outputDesc, delayMs, deviceTypes);
François Gaffieaaac0fd2018-11-22 17:56:39 +01007424 }
7425
Eric Laurente552edb2014-03-10 17:42:56 -07007426}
7427
François Gaffieaaac0fd2018-11-22 17:56:39 +01007428void AudioPolicyManager::setVolumeSourceMute(VolumeSource volumeSource,
7429 bool on,
7430 const sp<AudioOutputDescriptor>& outputDesc,
7431 int delayMs,
jiabin9a3361e2019-10-01 09:38:30 -07007432 DeviceTypeSet deviceTypes)
Eric Laurente552edb2014-03-10 17:42:56 -07007433{
jiabin9a3361e2019-10-01 09:38:30 -07007434 if (deviceTypes.empty()) {
7435 deviceTypes = outputDesc->devices().types();
Eric Laurente552edb2014-03-10 17:42:56 -07007436 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01007437 auto &curves = getVolumeCurves(volumeSource);
Eric Laurente552edb2014-03-10 17:42:56 -07007438 if (on) {
François Gaffieaaac0fd2018-11-22 17:56:39 +01007439 if (!outputDesc->isMuted(volumeSource)) {
Eric Laurentf5aa58d2019-02-22 18:20:11 -08007440 if (curves.canBeMuted() &&
Francois Gaffie4404ddb2021-02-04 17:03:38 +01007441 (volumeSource != toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE, false) ||
François Gaffieaaac0fd2018-11-22 17:56:39 +01007442 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) ==
7443 AUDIO_POLICY_FORCE_NONE))) {
jiabin9a3361e2019-10-01 09:38:30 -07007444 checkAndSetVolume(curves, volumeSource, 0, outputDesc, deviceTypes, delayMs);
Eric Laurente552edb2014-03-10 17:42:56 -07007445 }
7446 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01007447 // increment mMuteCount after calling checkAndSetVolume() so that volume change is not
7448 // ignored
7449 outputDesc->incMuteCount(volumeSource);
Eric Laurente552edb2014-03-10 17:42:56 -07007450 } else {
François Gaffieaaac0fd2018-11-22 17:56:39 +01007451 if (!outputDesc->isMuted(volumeSource)) {
7452 ALOGV("%s unmuting non muted attributes!", __func__);
Eric Laurente552edb2014-03-10 17:42:56 -07007453 return;
7454 }
François Gaffieaaac0fd2018-11-22 17:56:39 +01007455 if (outputDesc->decMuteCount(volumeSource) == 0) {
7456 checkAndSetVolume(curves, volumeSource,
jiabin9a3361e2019-10-01 09:38:30 -07007457 curves.getVolumeIndex(deviceTypes),
Eric Laurentc75307b2015-03-17 15:29:32 -07007458 outputDesc,
jiabin9a3361e2019-10-01 09:38:30 -07007459 deviceTypes,
Eric Laurente552edb2014-03-10 17:42:56 -07007460 delayMs);
7461 }
7462 }
7463}
7464
François Gaffie53615e22015-03-19 09:24:12 +01007465bool AudioPolicyManager::isValidAttributes(const audio_attributes_t *paa)
7466{
François Gaffiec005e562018-11-06 15:04:49 +01007467 // has flags that map to a stream type?
Eric Laurente83b55d2014-11-14 10:06:21 -08007468 if ((paa->flags & (AUDIO_FLAG_AUDIBILITY_ENFORCED | AUDIO_FLAG_SCO | AUDIO_FLAG_BEACON)) != 0) {
7469 return true;
7470 }
7471
7472 // has known usage?
7473 switch (paa->usage) {
7474 case AUDIO_USAGE_UNKNOWN:
7475 case AUDIO_USAGE_MEDIA:
7476 case AUDIO_USAGE_VOICE_COMMUNICATION:
7477 case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
7478 case AUDIO_USAGE_ALARM:
7479 case AUDIO_USAGE_NOTIFICATION:
7480 case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
7481 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
7482 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
7483 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
7484 case AUDIO_USAGE_NOTIFICATION_EVENT:
7485 case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
7486 case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
7487 case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
7488 case AUDIO_USAGE_GAME:
Eric Laurent275e8e92014-11-30 15:14:47 -08007489 case AUDIO_USAGE_VIRTUAL_SOURCE:
Jean-Michel Trivi36867762016-12-29 12:03:28 -08007490 case AUDIO_USAGE_ASSISTANT:
Eric Laurent21777f82019-12-06 18:12:06 -08007491 case AUDIO_USAGE_CALL_ASSISTANT:
Hayden Gomes524159d2019-12-23 14:41:47 -08007492 case AUDIO_USAGE_EMERGENCY:
7493 case AUDIO_USAGE_SAFETY:
7494 case AUDIO_USAGE_VEHICLE_STATUS:
7495 case AUDIO_USAGE_ANNOUNCEMENT:
Eric Laurente83b55d2014-11-14 10:06:21 -08007496 break;
7497 default:
7498 return false;
7499 }
7500 return true;
7501}
7502
François Gaffie2110e042015-03-24 08:41:51 +01007503audio_policy_forced_cfg_t AudioPolicyManager::getForceUse(audio_policy_force_use_t usage)
7504{
7505 return mEngine->getForceUse(usage);
7506}
7507
Eric Laurent96d1dda2022-03-14 17:14:19 +01007508bool AudioPolicyManager::isInCall() const {
François Gaffie2110e042015-03-24 08:41:51 +01007509 return isStateInCall(mEngine->getPhoneState());
7510}
7511
Eric Laurent96d1dda2022-03-14 17:14:19 +01007512bool AudioPolicyManager::isStateInCall(int state) const {
François Gaffie2110e042015-03-24 08:41:51 +01007513 return is_state_in_call(state);
7514}
7515
Eric Laurentf9cccec2022-11-16 19:12:00 +01007516bool AudioPolicyManager::isCallAudioAccessible() const {
Eric Laurent74b71512019-11-06 17:21:57 -08007517 audio_mode_t mode = mEngine->getPhoneState();
7518 return (mode == AUDIO_MODE_IN_CALL)
Eric Laurentc8c4f1f2021-11-09 11:51:34 +01007519 || (mode == AUDIO_MODE_CALL_SCREEN)
7520 || (mode == AUDIO_MODE_CALL_REDIRECT);
Eric Laurent74b71512019-11-06 17:21:57 -08007521}
7522
Eric Laurentf9cccec2022-11-16 19:12:00 +01007523bool AudioPolicyManager::isInCallOrScreening() const {
7524 audio_mode_t mode = mEngine->getPhoneState();
7525 return isStateInCall(mode) || mode == AUDIO_MODE_CALL_SCREEN;
7526}
7527
Eric Laurentd60560a2015-04-10 11:31:20 -07007528void AudioPolicyManager::cleanUpForDevice(const sp<DeviceDescriptor>& deviceDesc)
7529{
7530 for (ssize_t i = (ssize_t)mAudioSources.size() - 1; i >= 0; i--) {
Eric Laurent3e6c7e12018-07-27 17:09:23 -07007531 sp<SourceClientDescriptor> sourceDesc = mAudioSources.valueAt(i);
Francois Gaffiea0e5c992020-09-29 16:05:07 +02007532 if (sourceDesc->isConnected() && (sourceDesc->srcDevice()->equals(deviceDesc) ||
Francois Gaffie51c9ccd2020-10-14 18:02:07 +02007533 sourceDesc->sinkDevice()->equals(deviceDesc))
7534 && !isCallRxAudioSource(sourceDesc)) {
Francois Gaffiea0e5c992020-09-29 16:05:07 +02007535 disconnectAudioSource(sourceDesc);
Eric Laurentd60560a2015-04-10 11:31:20 -07007536 }
7537 }
7538
7539 for (ssize_t i = (ssize_t)mAudioPatches.size() - 1; i >= 0; i--) {
7540 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(i);
7541 bool release = false;
7542 for (size_t j = 0; j < patchDesc->mPatch.num_sources && !release; j++) {
7543 const struct audio_port_config *source = &patchDesc->mPatch.sources[j];
7544 if (source->type == AUDIO_PORT_TYPE_DEVICE &&
7545 source->ext.device.type == deviceDesc->type()) {
7546 release = true;
7547 }
7548 }
Francois Gaffiea0e5c992020-09-29 16:05:07 +02007549 const char *address = deviceDesc->address().c_str();
Eric Laurentd60560a2015-04-10 11:31:20 -07007550 for (size_t j = 0; j < patchDesc->mPatch.num_sinks && !release; j++) {
7551 const struct audio_port_config *sink = &patchDesc->mPatch.sinks[j];
7552 if (sink->type == AUDIO_PORT_TYPE_DEVICE &&
Francois Gaffiea0e5c992020-09-29 16:05:07 +02007553 sink->ext.device.type == deviceDesc->type() &&
7554 (strnlen(address, AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0
7555 || strncmp(sink->ext.device.address, address,
7556 AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0)) {
Eric Laurentd60560a2015-04-10 11:31:20 -07007557 release = true;
7558 }
7559 }
7560 if (release) {
François Gaffieafd4cea2019-11-18 15:50:22 +01007561 ALOGV("%s releasing patch %u", __FUNCTION__, patchDesc->getHandle());
7562 releaseAudioPatch(patchDesc->getHandle(), patchDesc->getUid());
Eric Laurentd60560a2015-04-10 11:31:20 -07007563 }
7564 }
Francois Gaffie716e1432019-01-14 16:58:59 +01007565
Francois Gaffieba2cf0f2018-12-12 16:40:25 +01007566 mInputs.clearSessionRoutesForDevice(deviceDesc);
7567
Francois Gaffie716e1432019-01-14 16:58:59 +01007568 mHwModules.cleanUpForDevice(deviceDesc);
Eric Laurentd60560a2015-04-10 11:31:20 -07007569}
7570
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007571void AudioPolicyManager::modifySurroundFormats(
7572 const sp<DeviceDescriptor>& devDesc, FormatVector *formatsPtr) {
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007573 std::unordered_set<audio_format_t> enforcedSurround(
7574 devDesc->encodedFormats().begin(), devDesc->encodedFormats().end());
Mikhail Naganov100f0122018-11-29 11:22:16 -08007575 std::unordered_set<audio_format_t> allSurround; // A flat set of all known surround formats
7576 for (const auto& pair : mConfig.getSurroundFormats()) {
7577 allSurround.insert(pair.first);
7578 for (const auto& subformat : pair.second) allSurround.insert(subformat);
7579 }
Phil Burk09bc4612016-02-24 15:58:15 -08007580
7581 audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
7582 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
Phil Burk0709b0a2016-03-31 12:54:57 -07007583 ALOGD("%s: forced use = %d", __FUNCTION__, forceUse);
Mikhail Naganov100f0122018-11-29 11:22:16 -08007584 // This is the resulting set of formats depending on the surround mode:
7585 // 'all surround' = allSurround
7586 // 'enforced surround' = enforcedSurround [may include IEC69137 which isn't raw surround fmt]
7587 // 'non-surround' = not in 'all surround' and not in 'enforced surround'
7588 // 'manual surround' = mManualSurroundFormats
7589 // AUTO: formats v 'enforced surround'
7590 // ALWAYS: formats v 'all surround' v 'enforced surround'
7591 // NEVER: formats ^ 'non-surround'
7592 // MANUAL: formats ^ ('non-surround' v 'manual surround' v (IEC69137 ^ 'enforced surround'))
Phil Burk09bc4612016-02-24 15:58:15 -08007593
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007594 std::unordered_set<audio_format_t> formatSet;
7595 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL
7596 || forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08007597 // formatSet is (formats ^ 'non-surround')
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007598 for (auto formatIter = formatsPtr->begin(); formatIter != formatsPtr->end(); ++formatIter) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08007599 if (allSurround.count(*formatIter) == 0 && enforcedSurround.count(*formatIter) == 0) {
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007600 formatSet.insert(*formatIter);
7601 }
7602 }
7603 } else {
7604 formatSet.insert(formatsPtr->begin(), formatsPtr->end());
7605 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08007606 formatsPtr->clear(); // Re-filled from the formatSet at the end.
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007607
jiabin81772902018-04-02 17:52:27 -07007608 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
Mikhail Naganov100f0122018-11-29 11:22:16 -08007609 formatSet.insert(mManualSurroundFormats.begin(), mManualSurroundFormats.end());
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007610 // Enable IEC61937 when in MANUAL mode if it's enforced for this device.
7611 if (enforcedSurround.count(AUDIO_FORMAT_IEC61937) != 0) {
7612 formatSet.insert(AUDIO_FORMAT_IEC61937);
Phil Burk09bc4612016-02-24 15:58:15 -08007613 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08007614 } else if (forceUse != AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) { // AUTO or ALWAYS
7615 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS) {
7616 formatSet.insert(allSurround.begin(), allSurround.end());
Phil Burk07ac1142016-03-25 13:39:29 -07007617 }
Mikhail Naganov100f0122018-11-29 11:22:16 -08007618 formatSet.insert(enforcedSurround.begin(), enforcedSurround.end());
Phil Burk09bc4612016-02-24 15:58:15 -08007619 }
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007620 for (const auto& format : formatSet) {
jiabin06e4bab2019-07-29 10:13:34 -07007621 formatsPtr->push_back(format);
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007622 }
Phil Burk0709b0a2016-03-31 12:54:57 -07007623}
7624
jiabin06e4bab2019-07-29 10:13:34 -07007625void AudioPolicyManager::modifySurroundChannelMasks(ChannelMaskSet *channelMasksPtr) {
7626 ChannelMaskSet &channelMasks = *channelMasksPtr;
Phil Burk0709b0a2016-03-31 12:54:57 -07007627 audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
7628 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
7629
7630 // If NEVER, then remove support for channelMasks > stereo.
7631 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) {
jiabin06e4bab2019-07-29 10:13:34 -07007632 for (auto it = channelMasks.begin(); it != channelMasks.end();) {
7633 audio_channel_mask_t channelMask = *it;
Phil Burk0709b0a2016-03-31 12:54:57 -07007634 if (channelMask & ~AUDIO_CHANNEL_OUT_STEREO) {
Eric Laurentfecbceb2021-02-09 14:46:43 +01007635 ALOGV("%s: force NEVER, so remove channelMask 0x%08x", __FUNCTION__, channelMask);
jiabin06e4bab2019-07-29 10:13:34 -07007636 it = channelMasks.erase(it);
Phil Burk0709b0a2016-03-31 12:54:57 -07007637 } else {
jiabin06e4bab2019-07-29 10:13:34 -07007638 ++it;
Phil Burk0709b0a2016-03-31 12:54:57 -07007639 }
7640 }
jiabin81772902018-04-02 17:52:27 -07007641 // If ALWAYS or MANUAL, then make sure we at least support 5.1
7642 } else if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS
7643 || forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
Phil Burk0709b0a2016-03-31 12:54:57 -07007644 bool supports5dot1 = false;
7645 // Are there any channel masks that can be considered "surround"?
Mikhail Naganovcf84e592017-12-07 11:25:11 -08007646 for (audio_channel_mask_t channelMask : channelMasks) {
Phil Burk0709b0a2016-03-31 12:54:57 -07007647 if ((channelMask & AUDIO_CHANNEL_OUT_5POINT1) == AUDIO_CHANNEL_OUT_5POINT1) {
7648 supports5dot1 = true;
7649 break;
7650 }
7651 }
7652 // If not then add 5.1 support.
7653 if (!supports5dot1) {
jiabin06e4bab2019-07-29 10:13:34 -07007654 channelMasks.insert(AUDIO_CHANNEL_OUT_5POINT1);
Eric Laurentfecbceb2021-02-09 14:46:43 +01007655 ALOGV("%s: force MANUAL or ALWAYS, so adding channelMask for 5.1 surround", __func__);
Phil Burk0709b0a2016-03-31 12:54:57 -07007656 }
Phil Burk09bc4612016-02-24 15:58:15 -08007657 }
7658}
7659
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007660void AudioPolicyManager::updateAudioProfiles(const sp<DeviceDescriptor>& devDesc,
Phil Burk00eeb322016-03-31 12:41:00 -07007661 audio_io_handle_t ioHandle,
François Gaffie112b0af2015-11-19 16:13:25 +01007662 AudioProfileVector &profiles)
7663{
7664 String8 reply;
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007665 audio_devices_t device = devDesc->type();
Phil Burk0709b0a2016-03-31 12:54:57 -07007666
François Gaffie112b0af2015-11-19 16:13:25 +01007667 // Format MUST be checked first to update the list of AudioProfile
7668 if (profiles.hasDynamicFormat()) {
Mikhail Naganov388360c2016-10-17 17:09:41 -07007669 reply = mpClientInterface->getParameters(
7670 ioHandle, String8(AudioParameter::keyStreamSupportedFormats));
jiabin81772902018-04-02 17:52:27 -07007671 ALOGV("%s: supported formats %d, %s", __FUNCTION__, ioHandle, reply.string());
Eric Laurent62e4bc52016-02-02 18:37:28 -08007672 AudioParameter repliedParameters(reply);
7673 if (repliedParameters.get(
Mikhail Naganov388360c2016-10-17 17:09:41 -07007674 String8(AudioParameter::keyStreamSupportedFormats), reply) != NO_ERROR) {
François Gaffie112b0af2015-11-19 16:13:25 +01007675 ALOGE("%s: failed to retrieve format, bailing out", __FUNCTION__);
7676 return;
7677 }
Phil Burk09bc4612016-02-24 15:58:15 -08007678 FormatVector formats = formatsFromString(reply.string());
Kriti Dangef6be8f2020-11-05 11:58:19 +01007679 mReportedFormatsMap[devDesc] = formats;
Mikhail Naganov100f0122018-11-29 11:22:16 -08007680 if (device == AUDIO_DEVICE_OUT_HDMI
7681 || isDeviceOfModule(devDesc, AUDIO_HARDWARE_MODULE_ID_MSD)) {
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007682 modifySurroundFormats(devDesc, &formats);
Phil Burk00eeb322016-03-31 12:41:00 -07007683 }
jiabin3e277cc2019-09-10 14:27:34 -07007684 addProfilesForFormats(profiles, formats);
François Gaffie112b0af2015-11-19 16:13:25 +01007685 }
François Gaffie112b0af2015-11-19 16:13:25 +01007686
Mikhail Naganovcf84e592017-12-07 11:25:11 -08007687 for (audio_format_t format : profiles.getSupportedFormats()) {
jiabin06e4bab2019-07-29 10:13:34 -07007688 ChannelMaskSet channelMasks;
7689 SampleRateSet samplingRates;
François Gaffie112b0af2015-11-19 16:13:25 +01007690 AudioParameter requestedParameters;
Mikhail Naganov388360c2016-10-17 17:09:41 -07007691 requestedParameters.addInt(String8(AudioParameter::keyFormat), format);
François Gaffie112b0af2015-11-19 16:13:25 +01007692
7693 if (profiles.hasDynamicRateFor(format)) {
Mikhail Naganov388360c2016-10-17 17:09:41 -07007694 reply = mpClientInterface->getParameters(
7695 ioHandle,
7696 requestedParameters.toString() + ";" +
7697 AudioParameter::keyStreamSupportedSamplingRates);
François Gaffie112b0af2015-11-19 16:13:25 +01007698 ALOGV("%s: supported sampling rates %s", __FUNCTION__, reply.string());
Eric Laurent62e4bc52016-02-02 18:37:28 -08007699 AudioParameter repliedParameters(reply);
7700 if (repliedParameters.get(
Mikhail Naganov388360c2016-10-17 17:09:41 -07007701 String8(AudioParameter::keyStreamSupportedSamplingRates), reply) == NO_ERROR) {
Eric Laurent62e4bc52016-02-02 18:37:28 -08007702 samplingRates = samplingRatesFromString(reply.string());
François Gaffie112b0af2015-11-19 16:13:25 +01007703 }
7704 }
7705 if (profiles.hasDynamicChannelsFor(format)) {
7706 reply = mpClientInterface->getParameters(ioHandle,
7707 requestedParameters.toString() + ";" +
Mikhail Naganov388360c2016-10-17 17:09:41 -07007708 AudioParameter::keyStreamSupportedChannels);
François Gaffie112b0af2015-11-19 16:13:25 +01007709 ALOGV("%s: supported channel masks %s", __FUNCTION__, reply.string());
Eric Laurent62e4bc52016-02-02 18:37:28 -08007710 AudioParameter repliedParameters(reply);
7711 if (repliedParameters.get(
Mikhail Naganov388360c2016-10-17 17:09:41 -07007712 String8(AudioParameter::keyStreamSupportedChannels), reply) == NO_ERROR) {
Eric Laurent62e4bc52016-02-02 18:37:28 -08007713 channelMasks = channelMasksFromString(reply.string());
Mikhail Naganov100f0122018-11-29 11:22:16 -08007714 if (device == AUDIO_DEVICE_OUT_HDMI
7715 || isDeviceOfModule(devDesc, AUDIO_HARDWARE_MODULE_ID_MSD)) {
Mikhail Naganovd5e18052018-11-30 14:55:45 -08007716 modifySurroundChannelMasks(&channelMasks);
Phil Burk0709b0a2016-03-31 12:54:57 -07007717 }
François Gaffie112b0af2015-11-19 16:13:25 +01007718 }
7719 }
jiabin3e277cc2019-09-10 14:27:34 -07007720 addDynamicAudioProfileAndSort(
7721 profiles, new AudioProfile(format, channelMasks, samplingRates));
François Gaffie112b0af2015-11-19 16:13:25 +01007722 }
7723}
Eric Laurentd60560a2015-04-10 11:31:20 -07007724
Mikhail Naganovdc769682018-05-04 15:34:08 -07007725status_t AudioPolicyManager::installPatch(const char *caller,
7726 audio_patch_handle_t *patchHandle,
7727 AudioIODescriptorInterface *ioDescriptor,
7728 const struct audio_patch *patch,
7729 int delayMs)
7730{
7731 ssize_t index = mAudioPatches.indexOfKey(
7732 patchHandle && *patchHandle != AUDIO_PATCH_HANDLE_NONE ?
7733 *patchHandle : ioDescriptor->getPatchHandle());
7734 sp<AudioPatch> patchDesc;
7735 status_t status = installPatch(
7736 caller, index, patchHandle, patch, delayMs, mUidCached, &patchDesc);
7737 if (status == NO_ERROR) {
François Gaffieafd4cea2019-11-18 15:50:22 +01007738 ioDescriptor->setPatchHandle(patchDesc->getHandle());
Mikhail Naganovdc769682018-05-04 15:34:08 -07007739 }
7740 return status;
7741}
7742
7743status_t AudioPolicyManager::installPatch(const char *caller,
7744 ssize_t index,
7745 audio_patch_handle_t *patchHandle,
7746 const struct audio_patch *patch,
7747 int delayMs,
7748 uid_t uid,
7749 sp<AudioPatch> *patchDescPtr)
7750{
7751 sp<AudioPatch> patchDesc;
7752 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
7753 if (index >= 0) {
7754 patchDesc = mAudioPatches.valueAt(index);
François Gaffieafd4cea2019-11-18 15:50:22 +01007755 afPatchHandle = patchDesc->getAfHandle();
Mikhail Naganovdc769682018-05-04 15:34:08 -07007756 }
7757
7758 status_t status = mpClientInterface->createAudioPatch(patch, &afPatchHandle, delayMs);
7759 ALOGV("%s() AF::createAudioPatch returned %d patchHandle %d num_sources %d num_sinks %d",
7760 caller, status, afPatchHandle, patch->num_sources, patch->num_sinks);
7761 if (status == NO_ERROR) {
7762 if (index < 0) {
7763 patchDesc = new AudioPatch(patch, uid);
François Gaffieafd4cea2019-11-18 15:50:22 +01007764 addAudioPatch(patchDesc->getHandle(), patchDesc);
Mikhail Naganovdc769682018-05-04 15:34:08 -07007765 } else {
7766 patchDesc->mPatch = *patch;
7767 }
François Gaffieafd4cea2019-11-18 15:50:22 +01007768 patchDesc->setAfHandle(afPatchHandle);
Mikhail Naganovdc769682018-05-04 15:34:08 -07007769 if (patchHandle) {
François Gaffieafd4cea2019-11-18 15:50:22 +01007770 *patchHandle = patchDesc->getHandle();
Mikhail Naganovdc769682018-05-04 15:34:08 -07007771 }
7772 nextAudioPortGeneration();
7773 mpClientInterface->onAudioPatchListUpdate();
7774 }
7775 if (patchDescPtr) *patchDescPtr = patchDesc;
7776 return status;
7777}
7778
jiabinbce0c1d2020-10-05 11:20:18 -07007779bool AudioPolicyManager::areAllActiveTracksRerouted(const sp<SwAudioOutputDescriptor>& output)
7780{
7781 const TrackClientVector activeClients = output->getActiveClients();
7782 if (activeClients.empty()) {
7783 return true;
7784 }
7785 ssize_t index = mAudioPatches.indexOfKey(output->getPatchHandle());
7786 if (index < 0) {
7787 ALOGE("%s, no audio patch found while there are active clients on output %d",
7788 __func__, output->getId());
7789 return false;
7790 }
7791 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
7792 DeviceVector routedDevices;
7793 for (int i = 0; i < patchDesc->mPatch.num_sinks; ++i) {
7794 sp<DeviceDescriptor> device = mAvailableOutputDevices.getDeviceFromId(
7795 patchDesc->mPatch.sinks[i].id);
7796 if (device == nullptr) {
7797 ALOGE("%s, no audio device found with id(%d)",
7798 __func__, patchDesc->mPatch.sinks[i].id);
7799 return false;
7800 }
7801 routedDevices.add(device);
7802 }
7803 for (const auto& client : activeClients) {
jiabin49256852022-03-09 11:21:35 -08007804 if (client->isInvalid()) {
7805 // No need to take care about invalidated clients.
7806 continue;
7807 }
jiabinbce0c1d2020-10-05 11:20:18 -07007808 sp<DeviceDescriptor> preferredDevice =
7809 mAvailableOutputDevices.getDeviceFromId(client->preferredDeviceId());
7810 if (mEngine->getOutputDevicesForAttributes(
7811 client->attributes(), preferredDevice, false) == routedDevices) {
7812 return false;
7813 }
7814 }
7815 return true;
7816}
7817
7818sp<SwAudioOutputDescriptor> AudioPolicyManager::openOutputWithProfileAndDevice(
Eric Laurentb4f42a92022-01-17 17:37:31 +01007819 const sp<IOProfile>& profile, const DeviceVector& devices,
7820 const audio_config_base_t *mixerConfig)
jiabinbce0c1d2020-10-05 11:20:18 -07007821{
7822 for (const auto& device : devices) {
7823 // TODO: This should be checking if the profile supports the device combo.
7824 if (!profile->supportsDevice(device)) {
7825 return nullptr;
7826 }
7827 }
7828 sp<SwAudioOutputDescriptor> desc = new SwAudioOutputDescriptor(profile, mpClientInterface);
7829 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
Eric Laurentb4f42a92022-01-17 17:37:31 +01007830 status_t status = desc->open(nullptr /* halConfig */, mixerConfig, devices,
jiabinbce0c1d2020-10-05 11:20:18 -07007831 AUDIO_STREAM_DEFAULT, AUDIO_OUTPUT_FLAG_NONE, &output);
7832 if (status != NO_ERROR) {
7833 return nullptr;
7834 }
7835
7836 // Here is where the out_set_parameters() for card & device gets called
7837 sp<DeviceDescriptor> device = devices.getDeviceForOpening();
7838 const audio_devices_t deviceType = device->type();
7839 const String8 &address = String8(device->address().c_str());
7840 if (!address.isEmpty()) {
7841 char *param = audio_device_address_to_parameter(deviceType, address.c_str());
7842 mpClientInterface->setParameters(output, String8(param));
7843 free(param);
7844 }
7845 updateAudioProfiles(device, output, profile->getAudioProfiles());
7846 if (!profile->hasValidAudioProfile()) {
7847 ALOGW("%s() missing param", __func__);
7848 desc->close();
7849 return nullptr;
7850 } else if (profile->hasDynamicAudioProfile()) {
7851 desc->close();
7852 output = AUDIO_IO_HANDLE_NONE;
7853 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
7854 profile->pickAudioProfile(
7855 config.sample_rate, config.channel_mask, config.format);
7856 config.offload_info.sample_rate = config.sample_rate;
7857 config.offload_info.channel_mask = config.channel_mask;
7858 config.offload_info.format = config.format;
7859
Eric Laurentb4f42a92022-01-17 17:37:31 +01007860 status = desc->open(&config, mixerConfig, devices,
jiabinbce0c1d2020-10-05 11:20:18 -07007861 AUDIO_STREAM_DEFAULT, AUDIO_OUTPUT_FLAG_NONE, &output);
7862 if (status != NO_ERROR) {
7863 return nullptr;
7864 }
7865 }
7866
7867 addOutput(output, desc);
Eric Laurentb4f42a92022-01-17 17:37:31 +01007868
jiabinbce0c1d2020-10-05 11:20:18 -07007869 if (audio_is_remote_submix_device(deviceType) && address != "0") {
7870 sp<AudioPolicyMix> policyMix;
7871 if (mPolicyMixes.getAudioPolicyMix(deviceType, address, policyMix) == NO_ERROR) {
7872 policyMix->setOutput(desc);
7873 desc->mPolicyMix = policyMix;
7874 } else {
7875 ALOGW("checkOutputsForDevice() cannot find policy for address %s",
7876 address.string());
7877 }
7878
Eric Laurentb4f42a92022-01-17 17:37:31 +01007879 } else if (hasPrimaryOutput() && profile->getModule()
7880 != mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_PRIMARY)
7881 && ((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) == 0)) {
7882 // no duplicated output for:
7883 // - direct outputs
7884 // - outputs used by dynamic policy mixes
7885 // - outputs opened on the primary HW module
jiabinbce0c1d2020-10-05 11:20:18 -07007886 audio_io_handle_t duplicatedOutput = AUDIO_IO_HANDLE_NONE;
7887
7888 //TODO: configure audio effect output stage here
7889
7890 // open a duplicating output thread for the new output and the primary output
7891 sp<SwAudioOutputDescriptor> dupOutputDesc =
7892 new SwAudioOutputDescriptor(nullptr, mpClientInterface);
7893 status = dupOutputDesc->openDuplicating(mPrimaryOutput, desc, &duplicatedOutput);
7894 if (status == NO_ERROR) {
7895 // add duplicated output descriptor
7896 addOutput(duplicatedOutput, dupOutputDesc);
7897 } else {
7898 ALOGW("checkOutputsForDevice() could not open dup output for %d and %d",
7899 mPrimaryOutput->mIoHandle, output);
7900 desc->close();
7901 removeOutput(output);
7902 nextAudioPortGeneration();
7903 return nullptr;
7904 }
7905 }
Francois Gaffiebce7cd42020-10-14 16:13:20 +02007906 if (mPrimaryOutput == nullptr && profile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
7907 ALOGV("%s(): re-assigning mPrimaryOutput", __func__);
7908 mPrimaryOutput = desc;
7909 }
jiabinbce0c1d2020-10-05 11:20:18 -07007910 return desc;
7911}
7912
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08007913} // namespace android