Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 1 | /* |
| 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 | |
François Gaffie | ad3183e | 2015-03-18 16:55:35 +0100 | [diff] [blame] | 17 | #pragma once |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 18 | |
Mikhail Naganov | 2773dd7 | 2017-12-08 10:12:11 -0800 | [diff] [blame] | 19 | #include <atomic> |
Mikhail Naganov | 3797715 | 2018-07-11 15:54:44 -0700 | [diff] [blame] | 20 | #include <functional> |
Mikhail Naganov | bcbcb1b | 2017-12-13 13:03:35 -0800 | [diff] [blame] | 21 | #include <memory> |
jiabin | 8177290 | 2018-04-02 17:52:27 -0700 | [diff] [blame] | 22 | #include <unordered_set> |
Mikhail Naganov | 2773dd7 | 2017-12-08 10:12:11 -0800 | [diff] [blame] | 23 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 24 | #include <stdint.h> |
| 25 | #include <sys/types.h> |
| 26 | #include <cutils/config_utils.h> |
| 27 | #include <cutils/misc.h> |
| 28 | #include <utils/Timers.h> |
| 29 | #include <utils/Errors.h> |
| 30 | #include <utils/KeyedVector.h> |
| 31 | #include <utils/SortedVector.h> |
Andy Hung | 2ddee19 | 2015-12-18 17:34:44 -0800 | [diff] [blame] | 32 | #include <media/AudioParameter.h> |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 33 | #include <media/AudioPolicy.h> |
jiabin | 811797a | 2019-09-10 14:29:14 -0700 | [diff] [blame] | 34 | #include <media/AudioProfile.h> |
Mikhail Naganov | 15be9d2 | 2017-11-08 14:18:13 +1100 | [diff] [blame] | 35 | #include <media/PatchBuilder.h> |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 36 | #include "AudioPolicyInterface.h" |
| 37 | |
Nathalie Le Clair | 88fa275 | 2021-11-23 13:03:41 +0100 | [diff] [blame] | 38 | #include <android/media/audio/common/AudioPort.h> |
François Gaffie | 2110e04 | 2015-03-24 08:41:51 +0100 | [diff] [blame] | 39 | #include <AudioPolicyManagerObserver.h> |
Mikhail Naganov | ad3f8a1 | 2017-12-12 13:24:23 -0800 | [diff] [blame] | 40 | #include <AudioPolicyConfig.h> |
jiabin | e128485 | 2019-09-11 10:15:46 -0700 | [diff] [blame] | 41 | #include <PolicyAudioPort.h> |
François Gaffie | 98cc191 | 2015-03-18 17:52:40 +0100 | [diff] [blame] | 42 | #include <AudioPatch.h> |
François Gaffie | 98cc191 | 2015-03-18 17:52:40 +0100 | [diff] [blame] | 43 | #include <DeviceDescriptor.h> |
| 44 | #include <IOProfile.h> |
| 45 | #include <HwModule.h> |
| 46 | #include <AudioInputDescriptor.h> |
| 47 | #include <AudioOutputDescriptor.h> |
François Gaffie | 036e1e9 | 2015-03-19 10:16:24 +0100 | [diff] [blame] | 48 | #include <AudioPolicyMix.h> |
François Gaffie | 45ed3b0 | 2015-03-19 10:35:14 +0100 | [diff] [blame] | 49 | #include <EffectDescriptor.h> |
François Gaffie | df37269 | 2015-03-19 10:43:27 +0100 | [diff] [blame] | 50 | #include <SoundTriggerSession.h> |
Mikhail Naganov | 4783555 | 2019-05-14 10:32:51 -0700 | [diff] [blame] | 51 | #include "EngineLibrary.h" |
Eric Laurent | f5aa58d | 2019-02-22 18:20:11 -0800 | [diff] [blame] | 52 | #include "TypeConverter.h" |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 53 | |
| 54 | namespace android { |
| 55 | |
Svet Ganov | 3e5f14f | 2021-05-13 22:51:08 +0000 | [diff] [blame] | 56 | using content::AttributionSourceState; |
| 57 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 58 | // ---------------------------------------------------------------------------- |
| 59 | |
| 60 | // Attenuation applied to STRATEGY_SONIFICATION streams when a headset is connected: 6dB |
Eric Laurent | ffbc80f | 2015-03-18 18:30:19 -0700 | [diff] [blame] | 61 | #define SONIFICATION_HEADSET_VOLUME_FACTOR_DB (-6) |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 62 | // Min volume for STRATEGY_SONIFICATION streams when limited by music volume: -36dB |
Eric Laurent | ffbc80f | 2015-03-18 18:30:19 -0700 | [diff] [blame] | 63 | #define SONIFICATION_HEADSET_VOLUME_MIN_DB (-36) |
Jean-Michel Trivi | 00a2096 | 2016-05-25 19:11:01 -0700 | [diff] [blame] | 64 | // Max volume difference on A2DP between playing media and STRATEGY_SONIFICATION streams: 12dB |
| 65 | #define SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB (12) |
Eric Laurent | ffbc80f | 2015-03-18 18:30:19 -0700 | [diff] [blame] | 66 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 67 | // Time in milliseconds during which we consider that music is still active after a music |
| 68 | // track was stopped - see computeVolume() |
| 69 | #define SONIFICATION_HEADSET_MUSIC_DELAY 5000 |
François Gaffie | 2110e04 | 2015-03-24 08:41:51 +0100 | [diff] [blame] | 70 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 71 | // Time in milliseconds during witch some streams are muted while the audio path |
| 72 | // is switched |
| 73 | #define MUTE_TIME_MS 2000 |
| 74 | |
Eric Laurent | ac3a690 | 2018-05-11 16:39:10 -0700 | [diff] [blame] | 75 | // multiplication factor applied to output latency when calculating a safe mute delay when |
| 76 | // invalidating tracks |
| 77 | #define LATENCY_MUTE_FACTOR 4 |
| 78 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 79 | #define NUM_TEST_OUTPUTS 5 |
| 80 | |
| 81 | #define NUM_VOL_CURVE_KNEES 2 |
| 82 | |
| 83 | // Default minimum length allowed for offloading a compressed track |
| 84 | // Can be overridden by the audio.offload.min.duration.secs property |
| 85 | #define OFFLOAD_DEFAULT_MIN_DURATION_SECS 60 |
| 86 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 87 | // ---------------------------------------------------------------------------- |
| 88 | // AudioPolicyManager implements audio policy manager behavior common to all platforms. |
| 89 | // ---------------------------------------------------------------------------- |
| 90 | |
François Gaffie | 2110e04 | 2015-03-24 08:41:51 +0100 | [diff] [blame] | 91 | class AudioPolicyManager : public AudioPolicyInterface, public AudioPolicyManagerObserver |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 92 | { |
| 93 | |
| 94 | public: |
Chih-Hung Hsieh | e964d4e | 2016-08-09 14:31:32 -0700 | [diff] [blame] | 95 | explicit AudioPolicyManager(AudioPolicyClientInterface *clientInterface); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 96 | virtual ~AudioPolicyManager(); |
| 97 | |
| 98 | // AudioPolicyInterface |
Nathalie Le Clair | 88fa275 | 2021-11-23 13:03:41 +0100 | [diff] [blame] | 99 | virtual status_t setDeviceConnectionState(audio_policy_dev_state_t state, |
| 100 | const android::media::audio::common::AudioPort& port, audio_format_t encodedFormat); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 101 | virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device, |
| 102 | const char *device_address); |
Pavlin Radoslavov | f862bc6 | 2016-12-26 18:57:22 -0800 | [diff] [blame] | 103 | virtual status_t handleDeviceConfigChange(audio_devices_t device, |
| 104 | const char *device_address, |
Aniket Kumar Lata | 4e46470 | 2019-01-10 23:38:46 -0800 | [diff] [blame] | 105 | const char *device_name, |
| 106 | audio_format_t encodedFormat); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 107 | virtual void setPhoneState(audio_mode_t state); |
| 108 | virtual void setForceUse(audio_policy_force_use_t usage, |
| 109 | audio_policy_forced_cfg_t config); |
| 110 | virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage); |
François Gaffie | 2110e04 | 2015-03-24 08:41:51 +0100 | [diff] [blame] | 111 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 112 | virtual void setSystemProperty(const char* property, const char* value); |
| 113 | virtual status_t initCheck(); |
Eric Laurent | f4e6345 | 2017-11-06 19:31:46 +0000 | [diff] [blame] | 114 | virtual audio_io_handle_t getOutput(audio_stream_type_t stream); |
Kevin Rocard | 153f92d | 2018-12-18 18:33:28 -0800 | [diff] [blame] | 115 | status_t getOutputForAttr(const audio_attributes_t *attr, |
| 116 | audio_io_handle_t *output, |
| 117 | audio_session_t session, |
| 118 | audio_stream_type_t *stream, |
Svet Ganov | 3e5f14f | 2021-05-13 22:51:08 +0000 | [diff] [blame] | 119 | const AttributionSourceState& attributionSource, |
Kevin Rocard | 153f92d | 2018-12-18 18:33:28 -0800 | [diff] [blame] | 120 | const audio_config_t *config, |
| 121 | audio_output_flags_t *flags, |
| 122 | audio_port_handle_t *selectedDeviceId, |
| 123 | audio_port_handle_t *portId, |
Eric Laurent | 8a1095a | 2019-11-08 14:44:16 -0800 | [diff] [blame] | 124 | std::vector<audio_io_handle_t> *secondaryOutputs, |
| 125 | output_type_t *outputType) override; |
Eric Laurent | 8fc147b | 2018-07-22 19:13:55 -0700 | [diff] [blame] | 126 | virtual status_t startOutput(audio_port_handle_t portId); |
| 127 | virtual status_t stopOutput(audio_port_handle_t portId); |
jiabin | bce0c1d | 2020-10-05 11:20:18 -0700 | [diff] [blame] | 128 | virtual bool releaseOutput(audio_port_handle_t portId); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 129 | virtual status_t getInputForAttr(const audio_attributes_t *attr, |
| 130 | audio_io_handle_t *input, |
Mikhail Naganov | 2996f67 | 2019-04-18 12:29:59 -0700 | [diff] [blame] | 131 | audio_unique_id_t riid, |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 132 | audio_session_t session, |
Svet Ganov | 3e5f14f | 2021-05-13 22:51:08 +0000 | [diff] [blame] | 133 | const AttributionSourceState& attributionSource, |
Eric Laurent | 20b9ef0 | 2016-12-05 11:03:16 -0800 | [diff] [blame] | 134 | const audio_config_base_t *config, |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 135 | audio_input_flags_t flags, |
Eric Laurent | 2ac7694 | 2017-06-22 17:17:09 -0700 | [diff] [blame] | 136 | audio_port_handle_t *selectedDeviceId, |
Eric Laurent | 20b9ef0 | 2016-12-05 11:03:16 -0800 | [diff] [blame] | 137 | input_type_t *inputType, |
| 138 | audio_port_handle_t *portId); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 139 | |
| 140 | // indicates to the audio policy manager that the input starts being used. |
Eric Laurent | 4eb58f1 | 2018-12-07 16:41:02 -0800 | [diff] [blame] | 141 | virtual status_t startInput(audio_port_handle_t portId); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 142 | |
| 143 | // indicates to the audio policy manager that the input stops being used. |
Eric Laurent | 8fc147b | 2018-07-22 19:13:55 -0700 | [diff] [blame] | 144 | virtual status_t stopInput(audio_port_handle_t portId); |
| 145 | virtual void releaseInput(audio_port_handle_t portId); |
Eric Laurent | 0dd5185 | 2019-04-19 18:18:58 -0700 | [diff] [blame] | 146 | virtual void checkCloseInputs(); |
François Gaffie | 251c7f0 | 2018-11-07 10:41:08 +0100 | [diff] [blame] | 147 | /** |
| 148 | * @brief initStreamVolume: even if the engine volume files provides min and max, keep this |
| 149 | * api for compatibility reason. |
| 150 | * AudioServer will get the min and max and may overwrite them if: |
| 151 | * -using property (highest priority) |
| 152 | * -not defined (-1 by convention), case when still using apm volume tables XML files |
| 153 | * @param stream to be considered |
| 154 | * @param indexMin to set |
| 155 | * @param indexMax to set |
| 156 | */ |
| 157 | virtual void initStreamVolume(audio_stream_type_t stream, int indexMin, int indexMax); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 158 | virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, |
| 159 | int index, |
| 160 | audio_devices_t device); |
| 161 | virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, |
| 162 | int *index, |
| 163 | audio_devices_t device); |
| 164 | |
François Gaffie | cfe1732 | 2018-11-07 13:41:29 +0100 | [diff] [blame] | 165 | virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr, |
| 166 | int index, |
| 167 | audio_devices_t device); |
| 168 | virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr, |
| 169 | int &index, |
| 170 | audio_devices_t device); |
| 171 | virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index); |
| 172 | |
| 173 | virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index); |
| 174 | |
François Gaffie | aaac0fd | 2018-11-22 17:56:39 +0100 | [diff] [blame] | 175 | status_t setVolumeCurveIndex(int index, |
François Gaffie | cfe1732 | 2018-11-07 13:41:29 +0100 | [diff] [blame] | 176 | audio_devices_t device, |
| 177 | IVolumeCurves &volumeCurves); |
| 178 | |
| 179 | status_t getVolumeIndex(const IVolumeCurves &curves, int &index, |
jiabin | 9a3361e | 2019-10-01 09:38:30 -0700 | [diff] [blame] | 180 | const DeviceTypeSet& deviceTypes) const; |
François Gaffie | cfe1732 | 2018-11-07 13:41:29 +0100 | [diff] [blame] | 181 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 182 | // return the strategy corresponding to a given stream type |
Ytai Ben-Tsvi | 0a4904a | 2021-01-06 12:57:05 -0800 | [diff] [blame] | 183 | virtual product_strategy_t getStrategyForStream(audio_stream_type_t stream) |
François Gaffie | c005e56 | 2018-11-06 15:04:49 +0100 | [diff] [blame] | 184 | { |
| 185 | return streamToStrategy(stream); |
| 186 | } |
| 187 | product_strategy_t streamToStrategy(audio_stream_type_t stream) const |
| 188 | { |
| 189 | auto attributes = mEngine->getAttributesForStreamType(stream); |
| 190 | return mEngine->getProductStrategyForAttributes(attributes); |
| 191 | } |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 192 | |
| 193 | // return the enabled output devices for the given stream type |
Mikhail Naganov | 5478fc1 | 2021-07-08 16:13:29 -0700 | [diff] [blame] | 194 | virtual DeviceTypeSet getDevicesForStream(audio_stream_type_t stream); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 195 | |
Andy Hung | 6d23c0f | 2022-02-16 09:37:15 -0800 | [diff] [blame^] | 196 | /** |
| 197 | * Returns a vector of devices associated with attributes. |
| 198 | * |
| 199 | * An AudioTrack opened with specified attributes should play on the returned devices. |
| 200 | * If forVolume is set to true, the caller is AudioService, determining the proper |
| 201 | * device volume to adjust. |
| 202 | * |
| 203 | * Devices are determined in the following precedence: |
| 204 | * 1) Devices associated with a dynamic policy matching the attributes. This is often |
| 205 | * a remote submix from MIX_ROUTE_FLAG_LOOP_BACK. Secondary mixes from a |
| 206 | * dynamic policy are not included. |
| 207 | * |
| 208 | * If no such dynamic policy then |
| 209 | * 2) Devices containing an active client using setPreferredDevice |
| 210 | * with same strategy as the attributes. |
| 211 | * (from the default Engine::getOutputDevicesForAttributes() implementation). |
| 212 | * |
| 213 | * If no corresponding active client with setPreferredDevice then |
| 214 | * 3) Devices associated with the strategy determined by the attributes |
| 215 | * (from the default Engine::getOutputDevicesForAttributes() implementation). |
| 216 | * |
| 217 | * @param attributes to be considered |
| 218 | * @param devices an AudioDeviceTypeAddrVector container passed in that |
| 219 | * will be filled on success. |
| 220 | * @param forVolume true if the devices are to be associated with current device volume. |
| 221 | * @return NO_ERROR on success. |
| 222 | */ |
Jean-Michel Trivi | f41599b | 2020-01-07 14:22:08 -0800 | [diff] [blame] | 223 | virtual status_t getDevicesForAttributes( |
| 224 | const audio_attributes_t &attributes, |
Andy Hung | 6d23c0f | 2022-02-16 09:37:15 -0800 | [diff] [blame^] | 225 | AudioDeviceTypeAddrVector *devices, |
| 226 | bool forVolume); |
Jean-Michel Trivi | f41599b | 2020-01-07 14:22:08 -0800 | [diff] [blame] | 227 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 228 | virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc = NULL); |
| 229 | virtual status_t registerEffect(const effect_descriptor_t *desc, |
| 230 | audio_io_handle_t io, |
Ytai Ben-Tsvi | 0a4904a | 2021-01-06 12:57:05 -0800 | [diff] [blame] | 231 | product_strategy_t strategy, |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 232 | int session, |
| 233 | int id); |
Eric Laurent | c241b0d | 2018-11-28 09:08:49 -0800 | [diff] [blame] | 234 | virtual status_t unregisterEffect(int id); |
| 235 | virtual status_t setEffectEnabled(int id, bool enabled); |
Eric Laurent | 6c79632 | 2019-04-09 14:13:17 -0700 | [diff] [blame] | 236 | status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) override; |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 237 | |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 238 | virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const; |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 239 | // return whether a stream is playing remotely, override to change the definition of |
| 240 | // local/remote playback, used for instance by notification manager to not make |
| 241 | // media players lose audio focus when not playing locally |
| 242 | // For the base implementation, "remotely" means playing during screen mirroring which |
| 243 | // uses an output for playback with a non-empty, non "0" address. |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 244 | virtual bool isStreamActiveRemotely(audio_stream_type_t stream, |
| 245 | uint32_t inPastMs = 0) const; |
| 246 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 247 | virtual bool isSourceActive(audio_source_t source) const; |
| 248 | |
Mikhail Naganov | 100f012 | 2018-11-29 11:22:16 -0800 | [diff] [blame] | 249 | // helpers for dump(int fd) |
| 250 | void dumpManualSurroundFormats(String8 *dst) const; |
| 251 | void dump(String8 *dst) const; |
Andy Hung | c29d82b | 2018-10-05 12:23:17 -0700 | [diff] [blame] | 252 | |
| 253 | status_t dump(int fd) override; |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 254 | |
Kevin Rocard | b99cc75 | 2019-03-21 20:52:24 -0700 | [diff] [blame] | 255 | status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy) override; |
Eric Laurent | 90fe31c | 2020-11-26 20:06:35 +0100 | [diff] [blame] | 256 | virtual audio_offload_mode_t getOffloadSupport(const audio_offload_info_t& offloadInfo); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 257 | |
Michael Chan | a94fbb2 | 2018-04-24 14:31:19 +1000 | [diff] [blame] | 258 | virtual bool isDirectOutputSupported(const audio_config_base_t& config, |
| 259 | const audio_attributes_t& attributes); |
| 260 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 261 | virtual status_t listAudioPorts(audio_port_role_t role, |
| 262 | audio_port_type_t type, |
| 263 | unsigned int *num_ports, |
jiabin | 19cdba5 | 2020-11-24 11:28:58 -0800 | [diff] [blame] | 264 | struct audio_port_v7 *ports, |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 265 | unsigned int *generation); |
jiabin | 19cdba5 | 2020-11-24 11:28:58 -0800 | [diff] [blame] | 266 | virtual status_t getAudioPort(struct audio_port_v7 *port); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 267 | virtual status_t createAudioPatch(const struct audio_patch *patch, |
| 268 | audio_patch_handle_t *handle, |
François Gaffie | afd4cea | 2019-11-18 15:50:22 +0100 | [diff] [blame] | 269 | uid_t uid) { |
| 270 | return createAudioPatchInternal(patch, handle, uid); |
| 271 | } |
| 272 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 273 | virtual status_t releaseAudioPatch(audio_patch_handle_t handle, |
| 274 | uid_t uid); |
| 275 | virtual status_t listAudioPatches(unsigned int *num_patches, |
| 276 | struct audio_patch *patches, |
| 277 | unsigned int *generation); |
| 278 | virtual status_t setAudioPortConfig(const struct audio_port_config *config); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 279 | |
Eric Laurent | d60560a | 2015-04-10 11:31:20 -0700 | [diff] [blame] | 280 | virtual void releaseResourcesForUid(uid_t uid); |
| 281 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 282 | virtual status_t acquireSoundTriggerSession(audio_session_t *session, |
| 283 | audio_io_handle_t *ioHandle, |
| 284 | audio_devices_t *device); |
| 285 | |
François Gaffie | df37269 | 2015-03-19 10:43:27 +0100 | [diff] [blame] | 286 | virtual status_t releaseSoundTriggerSession(audio_session_t session) |
| 287 | { |
| 288 | return mSoundTriggerSessions.releaseSession(session); |
| 289 | } |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 290 | |
Chih-Hung Hsieh | e964d4e | 2016-08-09 14:31:32 -0700 | [diff] [blame] | 291 | virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 292 | virtual status_t unregisterPolicyMixes(Vector<AudioMix> mixes); |
Jean-Michel Trivi | bda70da | 2018-12-19 07:30:15 -0800 | [diff] [blame] | 293 | virtual status_t setUidDeviceAffinities(uid_t uid, |
jiabin | 6a02d53 | 2020-08-07 11:56:38 -0700 | [diff] [blame] | 294 | const AudioDeviceTypeAddrVector& devices); |
Jean-Michel Trivi | bda70da | 2018-12-19 07:30:15 -0800 | [diff] [blame] | 295 | virtual status_t removeUidDeviceAffinities(uid_t uid); |
Oscar Azucena | 90e7763 | 2019-11-27 17:12:28 -0800 | [diff] [blame] | 296 | virtual status_t setUserIdDeviceAffinities(int userId, |
jiabin | 6a02d53 | 2020-08-07 11:56:38 -0700 | [diff] [blame] | 297 | const AudioDeviceTypeAddrVector& devices); |
Oscar Azucena | 90e7763 | 2019-11-27 17:12:28 -0800 | [diff] [blame] | 298 | virtual status_t removeUserIdDeviceAffinities(int userId); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 299 | |
jiabin | 0a48893 | 2020-08-07 17:32:40 -0700 | [diff] [blame] | 300 | virtual status_t setDevicesRoleForStrategy(product_strategy_t strategy, |
| 301 | device_role_t role, |
| 302 | const AudioDeviceTypeAddrVector &devices); |
| 303 | |
| 304 | virtual status_t removeDevicesRoleForStrategy(product_strategy_t strategy, |
| 305 | device_role_t role); |
| 306 | |
| 307 | |
| 308 | virtual status_t getDevicesForRoleAndStrategy(product_strategy_t strategy, |
| 309 | device_role_t role, |
| 310 | AudioDeviceTypeAddrVector &devices); |
Jean-Michel Trivi | 3085715 | 2019-11-01 11:04:15 -0700 | [diff] [blame] | 311 | |
Jiabin Huang | 3b98d32 | 2020-09-03 17:54:16 +0000 | [diff] [blame] | 312 | virtual status_t setDevicesRoleForCapturePreset(audio_source_t audioSource, |
| 313 | device_role_t role, |
| 314 | const AudioDeviceTypeAddrVector &devices); |
| 315 | |
| 316 | virtual status_t addDevicesRoleForCapturePreset(audio_source_t audioSource, |
| 317 | device_role_t role, |
| 318 | const AudioDeviceTypeAddrVector &devices); |
| 319 | |
| 320 | virtual status_t removeDevicesRoleForCapturePreset( |
| 321 | audio_source_t audioSource, device_role_t role, |
| 322 | const AudioDeviceTypeAddrVector& devices); |
| 323 | |
| 324 | virtual status_t clearDevicesRoleForCapturePreset(audio_source_t audioSource, |
| 325 | device_role_t role); |
| 326 | |
| 327 | virtual status_t getDevicesForRoleAndCapturePreset(audio_source_t audioSource, |
| 328 | device_role_t role, |
| 329 | AudioDeviceTypeAddrVector &devices); |
| 330 | |
Eric Laurent | 554a277 | 2015-04-10 11:29:24 -0700 | [diff] [blame] | 331 | virtual status_t startAudioSource(const struct audio_port_config *source, |
| 332 | const audio_attributes_t *attributes, |
Eric Laurent | 3e6c7e1 | 2018-07-27 17:09:23 -0700 | [diff] [blame] | 333 | audio_port_handle_t *portId, |
Eric Laurent | d60560a | 2015-04-10 11:31:20 -0700 | [diff] [blame] | 334 | uid_t uid); |
Eric Laurent | 3e6c7e1 | 2018-07-27 17:09:23 -0700 | [diff] [blame] | 335 | virtual status_t stopAudioSource(audio_port_handle_t portId); |
Eric Laurent | 554a277 | 2015-04-10 11:29:24 -0700 | [diff] [blame] | 336 | |
Andy Hung | 2ddee19 | 2015-12-18 17:34:44 -0800 | [diff] [blame] | 337 | virtual status_t setMasterMono(bool mono); |
| 338 | virtual status_t getMasterMono(bool *mono); |
Eric Laurent | ac9cef5 | 2017-06-09 15:46:26 -0700 | [diff] [blame] | 339 | virtual float getStreamVolumeDB( |
| 340 | audio_stream_type_t stream, int index, audio_devices_t device); |
Andy Hung | 2ddee19 | 2015-12-18 17:34:44 -0800 | [diff] [blame] | 341 | |
jiabin | 8177290 | 2018-04-02 17:52:27 -0700 | [diff] [blame] | 342 | virtual status_t getSurroundFormats(unsigned int *numSurroundFormats, |
| 343 | audio_format_t *surroundFormats, |
Kriti Dang | 6537def | 2021-03-02 13:46:59 +0100 | [diff] [blame] | 344 | bool *surroundFormatsEnabled); |
| 345 | virtual status_t getReportedSurroundFormats(unsigned int *numSurroundFormats, |
| 346 | audio_format_t *surroundFormats); |
jiabin | 8177290 | 2018-04-02 17:52:27 -0700 | [diff] [blame] | 347 | virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled); |
| 348 | |
Patty | dd80758 | 2021-11-04 21:01:03 +0800 | [diff] [blame] | 349 | virtual status_t getHwOffloadFormatsSupportedForBluetoothMedia( |
| 350 | audio_devices_t device, std::vector<audio_format_t> *formats); |
Arun Mirpuri | 11029ad | 2018-12-19 20:45:19 -0800 | [diff] [blame] | 351 | |
Eric Laurent | 5ada82e | 2019-08-29 17:53:54 -0700 | [diff] [blame] | 352 | virtual void setAppState(audio_port_handle_t portId, app_state_t state); |
Svet Ganov | f4ddfef | 2018-01-16 07:37:58 -0800 | [diff] [blame] | 353 | |
jiabin | 6012f91 | 2018-11-02 17:06:30 -0700 | [diff] [blame] | 354 | virtual bool isHapticPlaybackSupported(); |
| 355 | |
Carter Hsu | 325a8eb | 2022-01-19 19:56:51 +0800 | [diff] [blame] | 356 | virtual bool isUltrasoundSupported(); |
| 357 | |
François Gaffie | d0ba9ed | 2018-11-05 11:50:42 +0100 | [diff] [blame] | 358 | virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies) |
| 359 | { |
| 360 | return mEngine->listAudioProductStrategies(strategies); |
| 361 | } |
| 362 | |
Francois Gaffie | 11b6592 | 2020-09-24 16:59:08 +0200 | [diff] [blame] | 363 | virtual status_t getProductStrategyFromAudioAttributes( |
| 364 | const AudioAttributes &aa, product_strategy_t &productStrategy, |
| 365 | bool fallbackOnDefault) |
François Gaffie | d0ba9ed | 2018-11-05 11:50:42 +0100 | [diff] [blame] | 366 | { |
Francois Gaffie | 11b6592 | 2020-09-24 16:59:08 +0200 | [diff] [blame] | 367 | productStrategy = mEngine->getProductStrategyForAttributes( |
| 368 | aa.getAttributes(), fallbackOnDefault); |
| 369 | return (fallbackOnDefault && productStrategy == PRODUCT_STRATEGY_NONE) ? |
| 370 | BAD_VALUE : NO_ERROR; |
François Gaffie | 4b2018b | 2018-11-07 11:18:59 +0100 | [diff] [blame] | 371 | } |
| 372 | |
| 373 | virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups) |
| 374 | { |
| 375 | return mEngine->listAudioVolumeGroups(groups); |
| 376 | } |
| 377 | |
Francois Gaffie | 11b6592 | 2020-09-24 16:59:08 +0200 | [diff] [blame] | 378 | virtual status_t getVolumeGroupFromAudioAttributes( |
| 379 | const AudioAttributes &aa, volume_group_t &volumeGroup, bool fallbackOnDefault) |
François Gaffie | 4b2018b | 2018-11-07 11:18:59 +0100 | [diff] [blame] | 380 | { |
Francois Gaffie | 11b6592 | 2020-09-24 16:59:08 +0200 | [diff] [blame] | 381 | volumeGroup = mEngine->getVolumeGroupForAttributes( |
| 382 | aa.getAttributes(), fallbackOnDefault); |
| 383 | return (fallbackOnDefault && volumeGroup == VOLUME_GROUP_NONE) ? |
| 384 | BAD_VALUE : NO_ERROR; |
François Gaffie | d0ba9ed | 2018-11-05 11:50:42 +0100 | [diff] [blame] | 385 | } |
| 386 | |
Eric Laurent | fa0f674 | 2021-08-17 18:39:44 +0200 | [diff] [blame] | 387 | virtual bool canBeSpatialized(const audio_attributes_t *attr, |
Eric Laurent | cad6c0d | 2021-07-13 15:12:39 +0200 | [diff] [blame] | 388 | const audio_config_t *config, |
Eric Laurent | b4f42a9 | 2022-01-17 17:37:31 +0100 | [diff] [blame] | 389 | const AudioDeviceTypeAddrVector &devices) const { |
| 390 | return canBeSpatializedInt(attr, config, devices); |
| 391 | } |
Eric Laurent | cad6c0d | 2021-07-13 15:12:39 +0200 | [diff] [blame] | 392 | |
Eric Laurent | fa0f674 | 2021-08-17 18:39:44 +0200 | [diff] [blame] | 393 | virtual status_t getSpatializerOutput(const audio_config_base_t *config, |
Eric Laurent | cad6c0d | 2021-07-13 15:12:39 +0200 | [diff] [blame] | 394 | const audio_attributes_t *attr, |
| 395 | audio_io_handle_t *output); |
| 396 | |
Eric Laurent | fa0f674 | 2021-08-17 18:39:44 +0200 | [diff] [blame] | 397 | virtual status_t releaseSpatializerOutput(audio_io_handle_t output); |
Eric Laurent | cad6c0d | 2021-07-13 15:12:39 +0200 | [diff] [blame] | 398 | |
jiabin | 2b9d5a1 | 2021-12-10 01:06:29 +0000 | [diff] [blame] | 399 | virtual audio_direct_mode_t getDirectPlaybackSupport(const audio_attributes_t *attr, |
| 400 | const audio_config_t *config); |
| 401 | |
Dorin Drimus | f2196d8 | 2022-01-03 12:11:18 +0100 | [diff] [blame] | 402 | virtual status_t getDirectProfilesForAttributes(const audio_attributes_t* attr, |
| 403 | AudioProfileVector& audioProfiles); |
| 404 | |
Eric Laurent | 8340e67 | 2019-11-06 11:01:08 -0800 | [diff] [blame] | 405 | bool isCallScreenModeSupported() override; |
| 406 | |
Mikhail Naganov | c0d0498 | 2020-03-02 21:02:28 +0000 | [diff] [blame] | 407 | void onNewAudioModulesAvailable() override; |
| 408 | |
Eric Laurent | caafba4 | 2019-07-13 10:12:45 -0700 | [diff] [blame] | 409 | status_t initialize(); |
| 410 | |
Paul McLean | aa98119 | 2015-03-21 09:55:15 -0700 | [diff] [blame] | 411 | protected: |
Mikhail Naganov | ad3f8a1 | 2017-12-12 13:24:23 -0800 | [diff] [blame] | 412 | // A constructor that allows more fine-grained control over initialization process, |
| 413 | // used in automatic tests. |
| 414 | AudioPolicyManager(AudioPolicyClientInterface *clientInterface, bool forTesting); |
| 415 | |
| 416 | // These methods should be used when finer control over APM initialization |
| 417 | // is needed, e.g. in tests. Must be used in conjunction with the constructor |
| 418 | // that only performs fields initialization. The public constructor comprises |
| 419 | // these steps in the following sequence: |
| 420 | // - field initializing constructor; |
| 421 | // - loadConfig; |
| 422 | // - initialize. |
| 423 | AudioPolicyConfig& getConfig() { return mConfig; } |
| 424 | void loadConfig(); |
Mikhail Naganov | ad3f8a1 | 2017-12-12 13:24:23 -0800 | [diff] [blame] | 425 | |
François Gaffie | 2110e04 | 2015-03-24 08:41:51 +0100 | [diff] [blame] | 426 | // From AudioPolicyManagerObserver |
| 427 | virtual const AudioPatchCollection &getAudioPatches() const |
| 428 | { |
| 429 | return mAudioPatches; |
| 430 | } |
| 431 | virtual const SoundTriggerSessionCollection &getSoundTriggerSessionCollection() const |
| 432 | { |
| 433 | return mSoundTriggerSessions; |
| 434 | } |
| 435 | virtual const AudioPolicyMixCollection &getAudioPolicyMixCollection() const |
| 436 | { |
| 437 | return mPolicyMixes; |
| 438 | } |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 439 | virtual const SwAudioOutputCollection &getOutputs() const |
François Gaffie | 2110e04 | 2015-03-24 08:41:51 +0100 | [diff] [blame] | 440 | { |
| 441 | return mOutputs; |
| 442 | } |
| 443 | virtual const AudioInputCollection &getInputs() const |
| 444 | { |
| 445 | return mInputs; |
| 446 | } |
Eric Laurent | af37777 | 2019-03-29 14:50:21 -0700 | [diff] [blame] | 447 | virtual const DeviceVector getAvailableOutputDevices() const |
François Gaffie | 2110e04 | 2015-03-24 08:41:51 +0100 | [diff] [blame] | 448 | { |
Kevin Rocard | e0d004f | 2019-10-10 10:06:18 +0000 | [diff] [blame] | 449 | return mAvailableOutputDevices.filterForEngine(); |
François Gaffie | 2110e04 | 2015-03-24 08:41:51 +0100 | [diff] [blame] | 450 | } |
Eric Laurent | af37777 | 2019-03-29 14:50:21 -0700 | [diff] [blame] | 451 | virtual const DeviceVector getAvailableInputDevices() const |
François Gaffie | 2110e04 | 2015-03-24 08:41:51 +0100 | [diff] [blame] | 452 | { |
Francois Gaffie | 698d353 | 2019-04-10 15:20:05 +0200 | [diff] [blame] | 453 | // legacy and non-legacy remote-submix are managed by the engine, do not filter |
| 454 | return mAvailableInputDevices; |
François Gaffie | 2110e04 | 2015-03-24 08:41:51 +0100 | [diff] [blame] | 455 | } |
François Gaffie | 2110e04 | 2015-03-24 08:41:51 +0100 | [diff] [blame] | 456 | virtual const sp<DeviceDescriptor> &getDefaultOutputDevice() const |
| 457 | { |
| 458 | return mDefaultOutputDevice; |
| 459 | } |
Mikhail Naganov | d412014 | 2017-12-06 15:49:22 -0800 | [diff] [blame] | 460 | |
François Gaffie | aaac0fd | 2018-11-22 17:56:39 +0100 | [diff] [blame] | 461 | std::vector<volume_group_t> getVolumeGroups() const |
| 462 | { |
| 463 | return mEngine->getVolumeGroups(); |
| 464 | } |
| 465 | |
| 466 | VolumeSource toVolumeSource(volume_group_t volumeGroup) const |
| 467 | { |
| 468 | return static_cast<VolumeSource>(volumeGroup); |
| 469 | } |
Francois Gaffie | 4404ddb | 2021-02-04 17:03:38 +0100 | [diff] [blame] | 470 | /** |
| 471 | * @brief toVolumeSource converts an audio attributes into a volume source |
| 472 | * (either a legacy stream or a volume group). If fallback on default is allowed, and if |
| 473 | * the audio attributes do not follow any specific product strategy's rule, it will be |
| 474 | * associated to default volume source, e.g. music. Thus, any of call of volume API |
| 475 | * using this translation function may affect the default volume source. |
| 476 | * If fallback is not allowed and no matching rule is identified for the given attributes, |
| 477 | * the volume source will be undefined, thus, no volume will be altered/modified. |
| 478 | * @param attributes to be considered |
| 479 | * @param fallbackOnDefault |
| 480 | * @return volume source associated with given attributes, otherwise either music if |
| 481 | * fallbackOnDefault is set or none. |
| 482 | */ |
| 483 | VolumeSource toVolumeSource( |
| 484 | const audio_attributes_t &attributes, bool fallbackOnDefault = true) const |
François Gaffie | aaac0fd | 2018-11-22 17:56:39 +0100 | [diff] [blame] | 485 | { |
Francois Gaffie | 4404ddb | 2021-02-04 17:03:38 +0100 | [diff] [blame] | 486 | return toVolumeSource(mEngine->getVolumeGroupForAttributes( |
| 487 | attributes, fallbackOnDefault)); |
François Gaffie | aaac0fd | 2018-11-22 17:56:39 +0100 | [diff] [blame] | 488 | } |
Francois Gaffie | 4404ddb | 2021-02-04 17:03:38 +0100 | [diff] [blame] | 489 | VolumeSource toVolumeSource( |
| 490 | audio_stream_type_t stream, bool fallbackOnDefault = true) const |
François Gaffie | aaac0fd | 2018-11-22 17:56:39 +0100 | [diff] [blame] | 491 | { |
Francois Gaffie | 4404ddb | 2021-02-04 17:03:38 +0100 | [diff] [blame] | 492 | return toVolumeSource(mEngine->getVolumeGroupForStreamType( |
| 493 | stream, fallbackOnDefault)); |
François Gaffie | aaac0fd | 2018-11-22 17:56:39 +0100 | [diff] [blame] | 494 | } |
| 495 | IVolumeCurves &getVolumeCurves(VolumeSource volumeSource) |
| 496 | { |
| 497 | auto *curves = mEngine->getVolumeCurvesForVolumeGroup( |
| 498 | static_cast<volume_group_t>(volumeSource)); |
| 499 | ALOG_ASSERT(curves != nullptr, "No curves for volume source %d", volumeSource); |
| 500 | return *curves; |
| 501 | } |
Eric Laurent | f5aa58d | 2019-02-22 18:20:11 -0800 | [diff] [blame] | 502 | IVolumeCurves &getVolumeCurves(const audio_attributes_t &attr) |
| 503 | { |
| 504 | auto *curves = mEngine->getVolumeCurvesForAttributes(attr); |
| 505 | ALOG_ASSERT(curves != nullptr, "No curves for attributes %s", toString(attr).c_str()); |
| 506 | return *curves; |
| 507 | } |
| 508 | IVolumeCurves &getVolumeCurves(audio_stream_type_t stream) |
| 509 | { |
| 510 | auto *curves = mEngine->getVolumeCurvesForStreamType(stream); |
| 511 | ALOG_ASSERT(curves != nullptr, "No curves for stream %s", toString(stream).c_str()); |
| 512 | return *curves; |
| 513 | } |
| 514 | |
Chih-Hung Hsieh | e964d4e | 2016-08-09 14:31:32 -0700 | [diff] [blame] | 515 | void addOutput(audio_io_handle_t output, const sp<SwAudioOutputDescriptor>& outputDesc); |
François Gaffie | 53615e2 | 2015-03-19 09:24:12 +0100 | [diff] [blame] | 516 | void removeOutput(audio_io_handle_t output); |
Chih-Hung Hsieh | e964d4e | 2016-08-09 14:31:32 -0700 | [diff] [blame] | 517 | void addInput(audio_io_handle_t input, const sp<AudioInputDescriptor>& inputDesc); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 518 | |
Francois Gaffie | 3523ab3 | 2021-06-22 13:24:34 +0200 | [diff] [blame] | 519 | /** |
| 520 | * @brief setOutputDevices change the route of the specified output. |
| 521 | * @param outputDesc to be considered |
| 522 | * @param device to be considered to route the output |
| 523 | * @param force if true, force the routing even if no change. |
| 524 | * @param delayMs if specified, delay to apply for mute/volume op when changing device |
| 525 | * @param patchHandle if specified, the patch handle this output is connected through. |
| 526 | * @param requiresMuteCheck if specified, for e.g. when another output is on a shared device |
| 527 | * and currently active, allow to have proper drain and avoid pops |
| 528 | * @param requiresVolumeCheck true if called requires to reapply volume if the routing did |
| 529 | * not change (but the output is still routed). |
| 530 | * @return the number of ms we have slept to allow new routing to take effect in certain |
| 531 | * cases. |
| 532 | */ |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 533 | uint32_t setOutputDevices(const sp<SwAudioOutputDescriptor>& outputDesc, |
| 534 | const DeviceVector &device, |
| 535 | bool force = false, |
| 536 | int delayMs = 0, |
| 537 | audio_patch_handle_t *patchHandle = NULL, |
Francois Gaffie | 3523ab3 | 2021-06-22 13:24:34 +0200 | [diff] [blame] | 538 | bool requiresMuteCheck = true, |
| 539 | bool requiresVolumeCheck = false); |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 540 | status_t resetOutputDevice(const sp<AudioOutputDescriptor>& outputDesc, |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 541 | int delayMs = 0, |
| 542 | audio_patch_handle_t *patchHandle = NULL); |
| 543 | status_t setInputDevice(audio_io_handle_t input, |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 544 | const sp<DeviceDescriptor> &device, |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 545 | bool force = false, |
| 546 | audio_patch_handle_t *patchHandle = NULL); |
| 547 | status_t resetInputDevice(audio_io_handle_t input, |
| 548 | audio_patch_handle_t *patchHandle = NULL); |
| 549 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 550 | // compute the actual volume for a given stream according to the requested index and a particular |
| 551 | // device |
François Gaffie | aaac0fd | 2018-11-22 17:56:39 +0100 | [diff] [blame] | 552 | virtual float computeVolume(IVolumeCurves &curves, |
| 553 | VolumeSource volumeSource, |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 554 | int index, |
jiabin | 9a3361e | 2019-10-01 09:38:30 -0700 | [diff] [blame] | 555 | const DeviceTypeSet& deviceTypes); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 556 | |
Eric Laurent | 3839bc0 | 2018-07-10 18:33:34 -0700 | [diff] [blame] | 557 | // rescale volume index from srcStream within range of dstStream |
| 558 | int rescaleVolumeIndex(int srcIndex, |
Francois Gaffie | 2ffdfce | 2019-03-12 11:26:42 +0100 | [diff] [blame] | 559 | VolumeSource fromVolumeSource, |
| 560 | VolumeSource toVolumeSource); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 561 | // check that volume change is permitted, compute and send new volume to audio hardware |
François Gaffie | aaac0fd | 2018-11-22 17:56:39 +0100 | [diff] [blame] | 562 | virtual status_t checkAndSetVolume(IVolumeCurves &curves, |
| 563 | VolumeSource volumeSource, int index, |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 564 | const sp<AudioOutputDescriptor>& outputDesc, |
jiabin | 9a3361e | 2019-10-01 09:38:30 -0700 | [diff] [blame] | 565 | DeviceTypeSet deviceTypes, |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 566 | int delayMs = 0, bool force = false); |
| 567 | |
| 568 | // apply all stream volumes to the specified output and device |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 569 | void applyStreamVolumes(const sp<AudioOutputDescriptor>& outputDesc, |
jiabin | 9a3361e | 2019-10-01 09:38:30 -0700 | [diff] [blame] | 570 | const DeviceTypeSet& deviceTypes, |
| 571 | int delayMs = 0, bool force = false); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 572 | |
François Gaffie | c005e56 | 2018-11-06 15:04:49 +0100 | [diff] [blame] | 573 | /** |
| 574 | * @brief setStrategyMute Mute or unmute all active clients on the considered output |
| 575 | * following the given strategy. |
| 576 | * @param strategy to be considered |
| 577 | * @param on true for mute, false for unmute |
| 578 | * @param outputDesc to be considered |
| 579 | * @param delayMs |
| 580 | * @param device |
| 581 | */ |
| 582 | void setStrategyMute(product_strategy_t strategy, |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 583 | bool on, |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 584 | const sp<AudioOutputDescriptor>& outputDesc, |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 585 | int delayMs = 0, |
jiabin | 9a3361e | 2019-10-01 09:38:30 -0700 | [diff] [blame] | 586 | DeviceTypeSet deviceTypes = DeviceTypeSet()); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 587 | |
François Gaffie | aaac0fd | 2018-11-22 17:56:39 +0100 | [diff] [blame] | 588 | /** |
| 589 | * @brief setVolumeSourceMute Mute or unmute the volume source on the specified output |
| 590 | * @param volumeSource to be muted/unmute (may host legacy streams or by extension set of |
| 591 | * audio attributes) |
| 592 | * @param on true to mute, false to umute |
| 593 | * @param outputDesc on which the client following the volume group shall be muted/umuted |
| 594 | * @param delayMs |
| 595 | * @param device |
François Gaffie | aaac0fd | 2018-11-22 17:56:39 +0100 | [diff] [blame] | 596 | */ |
| 597 | void setVolumeSourceMute(VolumeSource volumeSource, |
| 598 | bool on, |
| 599 | const sp<AudioOutputDescriptor>& outputDesc, |
| 600 | int delayMs = 0, |
jiabin | 9a3361e | 2019-10-01 09:38:30 -0700 | [diff] [blame] | 601 | DeviceTypeSet deviceTypes = DeviceTypeSet()); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 602 | |
Jean-Michel Trivi | 887a9ed | 2015-03-31 18:02:24 -0700 | [diff] [blame] | 603 | audio_mode_t getPhoneState(); |
| 604 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 605 | // true if device is in a telephony or VoIP call |
| 606 | virtual bool isInCall(); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 607 | // true if given state represents a device in a telephony or VoIP call |
| 608 | virtual bool isStateInCall(int state); |
Eric Laurent | 74b7151 | 2019-11-06 17:21:57 -0800 | [diff] [blame] | 609 | // true if playback to call TX or capture from call RX is possible |
| 610 | bool isCallAudioAccessible(); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 611 | |
| 612 | // when a device is connected, checks if an open output can be routed |
| 613 | // to this device. If none is open, tries to open one of the available outputs. |
| 614 | // Returns an output suitable to this device or 0. |
| 615 | // when a device is disconnected, checks if an output is not used any more and |
| 616 | // returns its handle if any. |
| 617 | // transfers the audio tracks and effects from one output thread to another accordingly. |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 618 | status_t checkOutputsForDevice(const sp<DeviceDescriptor>& device, |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 619 | audio_policy_dev_state_t state, |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 620 | SortedVector<audio_io_handle_t>& outputs); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 621 | |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 622 | status_t checkInputsForDevice(const sp<DeviceDescriptor>& device, |
Eric Laurent | 0dd5185 | 2019-04-19 18:18:58 -0700 | [diff] [blame] | 623 | audio_policy_dev_state_t state); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 624 | |
| 625 | // close an output and its companion duplicating output. |
| 626 | void closeOutput(audio_io_handle_t output); |
| 627 | |
| 628 | // close an input. |
| 629 | void closeInput(audio_io_handle_t input); |
| 630 | |
Jean-Michel Trivi | 3085715 | 2019-11-01 11:04:15 -0700 | [diff] [blame] | 631 | // runs all the checks required for accommodating changes in devices and outputs |
Mikhail Naganov | 3797715 | 2018-07-11 15:54:44 -0700 | [diff] [blame] | 632 | // if 'onOutputsChecked' callback is provided, it is executed after the outputs |
| 633 | // check via 'checkOutputForAllStrategies'. If the callback returns 'true', |
| 634 | // A2DP suspend status is rechecked. |
Mikhail Naganov | 15be9d2 | 2017-11-08 14:18:13 +1100 | [diff] [blame] | 635 | void checkForDeviceAndOutputChanges(std::function<bool()> onOutputsChecked = nullptr); |
Mikhail Naganov | 3797715 | 2018-07-11 15:54:44 -0700 | [diff] [blame] | 636 | |
François Gaffie | c005e56 | 2018-11-06 15:04:49 +0100 | [diff] [blame] | 637 | /** |
Jean-Michel Trivi | 3085715 | 2019-11-01 11:04:15 -0700 | [diff] [blame] | 638 | * @brief updates routing for all outputs (including call if call in progress). |
| 639 | * @param delayMs delay for unmuting if required |
| 640 | */ |
| 641 | void updateCallAndOutputRouting(bool forceVolumeReeval = true, uint32_t delayMs = 0); |
| 642 | |
Francois Gaffie | 51c9ccd | 2020-10-14 18:02:07 +0200 | [diff] [blame] | 643 | bool isCallRxAudioSource(const sp<SourceClientDescriptor> &source) { |
| 644 | return mCallRxSourceClientPort != AUDIO_PORT_HANDLE_NONE |
| 645 | && source == mAudioSources.valueFor(mCallRxSourceClientPort); |
| 646 | } |
| 647 | |
| 648 | void connectTelephonyRxAudioSource(); |
| 649 | |
| 650 | void disconnectTelephonyRxAudioSource(); |
| 651 | |
Jean-Michel Trivi | 3085715 | 2019-11-01 11:04:15 -0700 | [diff] [blame] | 652 | /** |
Eric Laurent | 2517af3 | 2020-11-25 15:31:27 +0100 | [diff] [blame] | 653 | * @brief updates routing for all inputs. |
| 654 | */ |
| 655 | void updateInputRouting(); |
| 656 | |
| 657 | /** |
François Gaffie | c005e56 | 2018-11-06 15:04:49 +0100 | [diff] [blame] | 658 | * @brief checkOutputForAttributes checks and if necessary changes outputs used for the |
| 659 | * given audio attributes. |
| 660 | * must be called every time a condition that affects the output choice for a given |
| 661 | * attributes changes: connected device, phone state, force use... |
| 662 | * Must be called before updateDevicesAndOutputs() |
| 663 | * @param attr to be considered |
| 664 | */ |
| 665 | void checkOutputForAttributes(const audio_attributes_t &attr); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 666 | |
Francois Gaffie | ff1eb52 | 2020-05-06 18:37:04 +0200 | [diff] [blame] | 667 | /** |
| 668 | * @brief checkAudioSourceForAttributes checks if any AudioSource following the same routing |
| 669 | * as the given audio attributes is not routed and try to connect it. |
| 670 | * It must be called once checkOutputForAttributes has been called for orphans AudioSource, |
| 671 | * aka AudioSource not attached to any Audio Output (e.g. AudioSource connected to direct |
| 672 | * Output which has been disconnected (and output closed) due to sink device unavailable). |
| 673 | * @param attr to be considered |
| 674 | */ |
| 675 | void checkAudioSourceForAttributes(const audio_attributes_t &attr); |
| 676 | |
François Gaffie | c005e56 | 2018-11-06 15:04:49 +0100 | [diff] [blame] | 677 | bool followsSameRouting(const audio_attributes_t &lAttr, |
| 678 | const audio_attributes_t &rAttr) const; |
| 679 | |
| 680 | /** |
| 681 | * @brief checkOutputForAllStrategies Same as @see checkOutputForAttributes() |
| 682 | * but for a all product strategies in order of priority |
| 683 | */ |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 684 | void checkOutputForAllStrategies(); |
| 685 | |
Kevin Rocard | 153f92d | 2018-12-18 18:33:28 -0800 | [diff] [blame] | 686 | // Same as checkOutputForStrategy but for secondary outputs. Make sure if a secondary |
| 687 | // output condition changes, the track is properly rerouted |
| 688 | void checkSecondaryOutputs(); |
| 689 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 690 | // manages A2DP output suspend/restore according to phone state and BT SCO usage |
| 691 | void checkA2dpSuspend(); |
| 692 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 693 | // selects the most appropriate device on output for current state |
| 694 | // must be called every time a condition that affects the device choice for a given output is |
| 695 | // changed: connected device, phone state, force use, output start, output stop.. |
| 696 | // see getDeviceForStrategy() for the use of fromCache parameter |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 697 | DeviceVector getNewOutputDevices(const sp<SwAudioOutputDescriptor>& outputDesc, |
| 698 | bool fromCache); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 699 | |
François Gaffie | c005e56 | 2018-11-06 15:04:49 +0100 | [diff] [blame] | 700 | /** |
| 701 | * @brief updateDevicesAndOutputs: updates cache of devices of the engine |
| 702 | * must be called every time a condition that affects the device choice is changed: |
| 703 | * connected device, phone state, force use... |
| 704 | * cached values are used by getOutputDevicesForStream()/getDevicesForAttributes if |
| 705 | * parameter fromCache is true. |
| 706 | * Must be called after checkOutputForAllStrategies() |
| 707 | */ |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 708 | void updateDevicesAndOutputs(); |
| 709 | |
| 710 | // selects the most appropriate device on input for current state |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 711 | sp<DeviceDescriptor> getNewInputDevice(const sp<AudioInputDescriptor>& inputDesc); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 712 | |
François Gaffie | 45ed3b0 | 2015-03-19 10:35:14 +0100 | [diff] [blame] | 713 | virtual uint32_t getMaxEffectsCpuLoad() |
| 714 | { |
| 715 | return mEffects.getMaxEffectsCpuLoad(); |
| 716 | } |
| 717 | |
| 718 | virtual uint32_t getMaxEffectsMemory() |
| 719 | { |
| 720 | return mEffects.getMaxEffectsMemory(); |
| 721 | } |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 722 | |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 723 | SortedVector<audio_io_handle_t> getOutputsForDevices( |
| 724 | const DeviceVector &devices, const SwAudioOutputCollection& openOutputs); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 725 | |
François Gaffie | c005e56 | 2018-11-06 15:04:49 +0100 | [diff] [blame] | 726 | /** |
| 727 | * @brief checkDeviceMuteStrategies mute/unmute strategies |
| 728 | * using an incompatible device combination. |
| 729 | * if muting, wait for the audio in pcm buffer to be drained before proceeding |
| 730 | * if unmuting, unmute only after the specified delay |
| 731 | * @param outputDesc |
| 732 | * @param prevDevice |
| 733 | * @param delayMs |
| 734 | * @return the number of ms waited |
| 735 | */ |
| 736 | virtual uint32_t checkDeviceMuteStrategies(const sp<AudioOutputDescriptor>& outputDesc, |
| 737 | const DeviceVector &prevDevices, |
| 738 | uint32_t delayMs); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 739 | |
| 740 | audio_io_handle_t selectOutput(const SortedVector<audio_io_handle_t>& outputs, |
jiabin | 4057332 | 2018-11-08 12:08:02 -0800 | [diff] [blame] | 741 | audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE, |
| 742 | audio_format_t format = AUDIO_FORMAT_INVALID, |
| 743 | audio_channel_mask_t channelMask = AUDIO_CHANNEL_NONE, |
jiabin | ebb6af4 | 2020-06-09 17:31:17 -0700 | [diff] [blame] | 744 | uint32_t samplingRate = 0, |
| 745 | audio_session_t sessionId = AUDIO_SESSION_NONE); |
Andy Hung | f129b03 | 2015-04-07 13:45:50 -0700 | [diff] [blame] | 746 | // samplingRate, format, channelMask are in/out and so may be modified |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 747 | sp<IOProfile> getInputProfile(const sp<DeviceDescriptor> & device, |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 748 | uint32_t& samplingRate, |
Andy Hung | f129b03 | 2015-04-07 13:45:50 -0700 | [diff] [blame] | 749 | audio_format_t& format, |
| 750 | audio_channel_mask_t& channelMask, |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 751 | audio_input_flags_t flags); |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 752 | /** |
| 753 | * @brief getProfileForOutput |
| 754 | * @param devices vector of descriptors, may be empty if ignoring the device is required |
| 755 | * @param samplingRate |
| 756 | * @param format |
| 757 | * @param channelMask |
| 758 | * @param flags |
| 759 | * @param directOnly |
| 760 | * @return IOProfile to be used if found, nullptr otherwise |
| 761 | */ |
| 762 | sp<IOProfile> getProfileForOutput(const DeviceVector &devices, |
Michael Chan | a94fbb2 | 2018-04-24 14:31:19 +1000 | [diff] [blame] | 763 | uint32_t samplingRate, |
| 764 | audio_format_t format, |
| 765 | audio_channel_mask_t channelMask, |
| 766 | audio_output_flags_t flags, |
| 767 | bool directOnly); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 768 | |
Eric Laurent | 36829f9 | 2017-04-07 19:04:42 -0700 | [diff] [blame] | 769 | audio_io_handle_t selectOutputForMusicEffects(); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 770 | |
François Gaffie | 53615e2 | 2015-03-19 09:24:12 +0100 | [diff] [blame] | 771 | virtual status_t addAudioPatch(audio_patch_handle_t handle, const sp<AudioPatch>& patch) |
| 772 | { |
| 773 | return mAudioPatches.addAudioPatch(handle, patch); |
| 774 | } |
| 775 | virtual status_t removeAudioPatch(audio_patch_handle_t handle) |
| 776 | { |
| 777 | return mAudioPatches.removeAudioPatch(handle); |
| 778 | } |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 779 | |
François Gaffie | 9eb1855 | 2018-11-05 10:33:26 +0100 | [diff] [blame] | 780 | bool isPrimaryModule(const sp<HwModule> &module) const |
| 781 | { |
| 782 | if (module == 0 || !hasPrimaryOutput()) { |
| 783 | return false; |
| 784 | } |
| 785 | return module->getHandle() == mPrimaryOutput->getModuleHandle(); |
| 786 | } |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 787 | DeviceVector availablePrimaryOutputDevices() const |
François Gaffie | 53615e2 | 2015-03-19 09:24:12 +0100 | [diff] [blame] | 788 | { |
Eric Laurent | 87ffa39 | 2015-05-22 10:32:38 -0700 | [diff] [blame] | 789 | if (!hasPrimaryOutput()) { |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 790 | return DeviceVector(); |
Eric Laurent | 87ffa39 | 2015-05-22 10:32:38 -0700 | [diff] [blame] | 791 | } |
Francois Gaffie | 716e143 | 2019-01-14 16:58:59 +0100 | [diff] [blame] | 792 | return mAvailableOutputDevices.filter(mPrimaryOutput->supportedDevices()); |
François Gaffie | 53615e2 | 2015-03-19 09:24:12 +0100 | [diff] [blame] | 793 | } |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 794 | DeviceVector availablePrimaryModuleInputDevices() const |
François Gaffie | 53615e2 | 2015-03-19 09:24:12 +0100 | [diff] [blame] | 795 | { |
Eric Laurent | 87ffa39 | 2015-05-22 10:32:38 -0700 | [diff] [blame] | 796 | if (!hasPrimaryOutput()) { |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 797 | return DeviceVector(); |
Eric Laurent | 87ffa39 | 2015-05-22 10:32:38 -0700 | [diff] [blame] | 798 | } |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 799 | return mAvailableInputDevices.getDevicesFromHwModule( |
Mikhail Naganov | 9366193 | 2018-07-26 14:37:41 -0700 | [diff] [blame] | 800 | mPrimaryOutput->getModuleHandle()); |
François Gaffie | 53615e2 | 2015-03-19 09:24:12 +0100 | [diff] [blame] | 801 | } |
François Gaffie | aca677c | 2018-05-03 10:47:50 +0200 | [diff] [blame] | 802 | /** |
| 803 | * @brief getFirstDeviceId of the Device Vector |
| 804 | * @return if the collection is not empty, it returns the first device Id, |
| 805 | * otherwise AUDIO_PORT_HANDLE_NONE |
| 806 | */ |
| 807 | audio_port_handle_t getFirstDeviceId(const DeviceVector &devices) const |
| 808 | { |
| 809 | return (devices.size() > 0) ? devices.itemAt(0)->getId() : AUDIO_PORT_HANDLE_NONE; |
| 810 | } |
| 811 | String8 getFirstDeviceAddress(const DeviceVector &devices) const |
| 812 | { |
jiabin | ce9f20e | 2019-09-12 16:29:15 -0700 | [diff] [blame] | 813 | return (devices.size() > 0) ? |
| 814 | String8(devices.itemAt(0)->address().c_str()) : String8(""); |
François Gaffie | aca677c | 2018-05-03 10:47:50 +0200 | [diff] [blame] | 815 | } |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 816 | |
Francois Gaffie | 19fd6c5 | 2021-02-04 17:02:59 +0100 | [diff] [blame] | 817 | status_t updateCallRouting( |
| 818 | bool fromCache, uint32_t delayMs = 0, uint32_t *waitMs = nullptr); |
| 819 | status_t updateCallRoutingInternal( |
| 820 | const DeviceVector &rxDevices, uint32_t delayMs, uint32_t *waitMs); |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 821 | sp<AudioPatch> createTelephonyPatch(bool isRx, const sp<DeviceDescriptor> &device, |
| 822 | uint32_t delayMs); |
Francois Gaffie | 19fd6c5 | 2021-02-04 17:02:59 +0100 | [diff] [blame] | 823 | /** |
| 824 | * @brief selectBestRxSinkDevicesForCall: if the primary module host both Telephony Rx/Tx |
| 825 | * devices, and it declares also supporting a HW bridge between the Telephony Rx and the |
| 826 | * given sink device for Voice Call audio attributes, select this device in prio. |
| 827 | * Otherwise, getNewOutputDevices() is called on the primary output to select sink device. |
| 828 | * @param fromCache true to prevent engine reconsidering all product strategies and retrieve |
| 829 | * from engine cache. |
| 830 | * @return vector of devices, empty if none is found. |
| 831 | */ |
| 832 | DeviceVector selectBestRxSinkDevicesForCall(bool fromCache); |
Mikhail Naganov | 100f012 | 2018-11-29 11:22:16 -0800 | [diff] [blame] | 833 | bool isDeviceOfModule(const sp<DeviceDescriptor>& devDesc, const char *moduleId) const; |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 834 | |
Eric Laurent | 97ac871 | 2018-07-27 18:59:02 -0700 | [diff] [blame] | 835 | status_t startSource(const sp<SwAudioOutputDescriptor>& outputDesc, |
| 836 | const sp<TrackClientDescriptor>& client, |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 837 | uint32_t *delayMs); |
Eric Laurent | 97ac871 | 2018-07-27 18:59:02 -0700 | [diff] [blame] | 838 | status_t stopSource(const sp<SwAudioOutputDescriptor>& outputDesc, |
| 839 | const sp<TrackClientDescriptor>& client); |
Eric Laurent | 8c7e6da | 2015-04-21 17:37:00 -0700 | [diff] [blame] | 840 | |
| 841 | void clearAudioPatches(uid_t uid); |
| 842 | void clearSessionRoutes(uid_t uid); |
François Gaffie | c005e56 | 2018-11-06 15:04:49 +0100 | [diff] [blame] | 843 | |
| 844 | /** |
| 845 | * @brief checkStrategyRoute: when an output is beeing rerouted, reconsider each output |
| 846 | * that may host a strategy playing on the considered output. |
| 847 | * @param ps product strategy that initiated the rerouting |
| 848 | * @param ouptutToSkip output that initiated the rerouting |
| 849 | */ |
| 850 | void checkStrategyRoute(product_strategy_t ps, audio_io_handle_t ouptutToSkip); |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 851 | |
Eric Laurent | 87ffa39 | 2015-05-22 10:32:38 -0700 | [diff] [blame] | 852 | status_t hasPrimaryOutput() const { return mPrimaryOutput != 0; } |
| 853 | |
Eric Laurent | 3e6c7e1 | 2018-07-27 17:09:23 -0700 | [diff] [blame] | 854 | status_t connectAudioSource(const sp<SourceClientDescriptor>& sourceDesc); |
| 855 | status_t disconnectAudioSource(const sp<SourceClientDescriptor>& sourceDesc); |
Eric Laurent | d60560a | 2015-04-10 11:31:20 -0700 | [diff] [blame] | 856 | |
François Gaffie | c005e56 | 2018-11-06 15:04:49 +0100 | [diff] [blame] | 857 | sp<SourceClientDescriptor> getSourceForAttributesOnOutput(audio_io_handle_t output, |
| 858 | const audio_attributes_t &attr); |
Francois Gaffie | ff1eb52 | 2020-05-06 18:37:04 +0200 | [diff] [blame] | 859 | void clearAudioSourcesForOutput(audio_io_handle_t output); |
Eric Laurent | d60560a | 2015-04-10 11:31:20 -0700 | [diff] [blame] | 860 | |
| 861 | void cleanUpForDevice(const sp<DeviceDescriptor>& deviceDesc); |
| 862 | |
| 863 | void clearAudioSources(uid_t uid); |
| 864 | |
Eric Laurent | 794fde2 | 2016-03-11 09:50:45 -0800 | [diff] [blame] | 865 | static bool streamsMatchForvolume(audio_stream_type_t stream1, |
| 866 | audio_stream_type_t stream2); |
Eric Laurent | 28d09f0 | 2016-03-08 10:43:05 -0800 | [diff] [blame] | 867 | |
Eric Laurent | 8f42ea1 | 2018-08-08 09:08:25 -0700 | [diff] [blame] | 868 | void closeActiveClients(const sp<AudioInputDescriptor>& input); |
| 869 | void closeClient(audio_port_handle_t portId); |
Eric Laurent | 8fc147b | 2018-07-22 19:13:55 -0700 | [diff] [blame] | 870 | |
Andy Hung | 4ef19fa | 2018-05-15 19:35:29 -0700 | [diff] [blame] | 871 | const uid_t mUidCached; // AID_AUDIOSERVER |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 872 | AudioPolicyClientInterface *mpClientInterface; // audio policy client interface |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 873 | sp<SwAudioOutputDescriptor> mPrimaryOutput; // primary output descriptor |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 874 | // list of descriptors for outputs currently opened |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 875 | |
Eric Laurent | fa0f674 | 2021-08-17 18:39:44 +0200 | [diff] [blame] | 876 | sp<SwAudioOutputDescriptor> mSpatializerOutput; |
Eric Laurent | cad6c0d | 2021-07-13 15:12:39 +0200 | [diff] [blame] | 877 | |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 878 | SwAudioOutputCollection mOutputs; |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 879 | // copy of mOutputs before setDeviceConnectionState() opens new outputs |
| 880 | // reset to mOutputs when updateDevicesAndOutputs() is called. |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 881 | SwAudioOutputCollection mPreviousOutputs; |
François Gaffie | 53615e2 | 2015-03-19 09:24:12 +0100 | [diff] [blame] | 882 | AudioInputCollection mInputs; // list of input descriptors |
Eric Laurent | c75307b | 2015-03-17 15:29:32 -0700 | [diff] [blame] | 883 | |
Mikhail Naganov | c0d0498 | 2020-03-02 21:02:28 +0000 | [diff] [blame] | 884 | DeviceVector mOutputDevicesAll; // all output devices from the config |
| 885 | DeviceVector mInputDevicesAll; // all input devices from the config |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 886 | DeviceVector mAvailableOutputDevices; // all available output devices |
| 887 | DeviceVector mAvailableInputDevices; // all available input devices |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 888 | |
François Gaffie | dfd7409 | 2015-03-19 12:10:59 +0100 | [diff] [blame] | 889 | bool mLimitRingtoneVolume; // limit ringtone volume to music volume if headset connected |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 890 | |
François Gaffie | dfd7409 | 2015-03-19 12:10:59 +0100 | [diff] [blame] | 891 | float mLastVoiceVolume; // last voice volume value sent to audio HAL |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 892 | bool mA2dpSuspended; // true if A2DP output is suspended |
Mikhail Naganov | ad3f8a1 | 2017-12-12 13:24:23 -0800 | [diff] [blame] | 893 | |
Mikhail Naganov | ad3f8a1 | 2017-12-12 13:24:23 -0800 | [diff] [blame] | 894 | EffectDescriptorCollection mEffects; // list of registered audio effects |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 895 | sp<DeviceDescriptor> mDefaultOutputDevice; // output device selected by default at boot time |
Mikhail Naganov | c0d0498 | 2020-03-02 21:02:28 +0000 | [diff] [blame] | 896 | HwModuleCollection mHwModules; // contains modules that have been loaded successfully |
| 897 | HwModuleCollection mHwModulesAll; // contains all modules declared in the config |
Eric Laurent | f5aa58d | 2019-02-22 18:20:11 -0800 | [diff] [blame] | 898 | |
Mikhail Naganov | ad3f8a1 | 2017-12-12 13:24:23 -0800 | [diff] [blame] | 899 | AudioPolicyConfig mConfig; |
François Gaffie | 53615e2 | 2015-03-19 09:24:12 +0100 | [diff] [blame] | 900 | |
Mikhail Naganov | 2773dd7 | 2017-12-08 10:12:11 -0800 | [diff] [blame] | 901 | std::atomic<uint32_t> mAudioPortGeneration; |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 902 | |
François Gaffie | 53615e2 | 2015-03-19 09:24:12 +0100 | [diff] [blame] | 903 | AudioPatchCollection mAudioPatches; |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 904 | |
François Gaffie | df37269 | 2015-03-19 10:43:27 +0100 | [diff] [blame] | 905 | SoundTriggerSessionCollection mSoundTriggerSessions; |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 906 | |
| 907 | sp<AudioPatch> mCallTxPatch; |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 908 | |
Eric Laurent | d60560a | 2015-04-10 11:31:20 -0700 | [diff] [blame] | 909 | HwAudioOutputCollection mHwOutputs; |
Eric Laurent | 3e6c7e1 | 2018-07-27 17:09:23 -0700 | [diff] [blame] | 910 | SourceClientCollection mAudioSources; |
Eric Laurent | d60560a | 2015-04-10 11:31:20 -0700 | [diff] [blame] | 911 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 912 | // for supporting "beacon" streams, i.e. streams that only play on speaker, and never |
| 913 | // when something other than STREAM_TTS (a.k.a. "Transmitted Through Speaker") is playing |
| 914 | enum { |
| 915 | STARTING_OUTPUT, |
| 916 | STARTING_BEACON, |
| 917 | STOPPING_OUTPUT, |
| 918 | STOPPING_BEACON |
| 919 | }; |
| 920 | uint32_t mBeaconMuteRefCount; // ref count for stream that would mute beacon |
| 921 | uint32_t mBeaconPlayingRefCount;// ref count for the playing beacon streams |
| 922 | bool mBeaconMuted; // has STREAM_TTS been muted |
Carter Hsu | 1a3364a | 2022-01-21 15:32:56 +0800 | [diff] [blame] | 923 | // true if a dedicated output for TTS stream or Ultrasound is available |
| 924 | bool mTtsOutputAvailable; |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 925 | |
Andy Hung | 2ddee19 | 2015-12-18 17:34:44 -0800 | [diff] [blame] | 926 | bool mMasterMono; // true if we wish to force all outputs to mono |
François Gaffie | 036e1e9 | 2015-03-19 10:16:24 +0100 | [diff] [blame] | 927 | AudioPolicyMixCollection mPolicyMixes; // list of registered mixes |
Eric Laurent | 36829f9 | 2017-04-07 19:04:42 -0700 | [diff] [blame] | 928 | audio_io_handle_t mMusicEffectOutput; // output selected for music effects |
| 929 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 930 | uint32_t nextAudioPortGeneration(); |
Jean-Michel Trivi | 887a9ed | 2015-03-31 18:02:24 -0700 | [diff] [blame] | 931 | |
| 932 | // Audio Policy Engine Interface. |
Mikhail Naganov | 4783555 | 2019-05-14 10:32:51 -0700 | [diff] [blame] | 933 | EngineInstance mEngine; |
jiabin | 8177290 | 2018-04-02 17:52:27 -0700 | [diff] [blame] | 934 | |
Mikhail Naganov | 100f012 | 2018-11-29 11:22:16 -0800 | [diff] [blame] | 935 | // Surround formats that are enabled manually. Taken into account when |
| 936 | // "encoded surround" is forced into "manual" mode. |
| 937 | std::unordered_set<audio_format_t> mManualSurroundFormats; |
Kevin Rocard | b99cc75 | 2019-03-21 20:52:24 -0700 | [diff] [blame] | 938 | |
| 939 | std::unordered_map<uid_t, audio_flags_mask_t> mAllowedCapturePolicies; |
Kriti Dang | ef6be8f | 2020-11-05 11:58:19 +0100 | [diff] [blame] | 940 | |
| 941 | // The map of device descriptor and formats reported by the device. |
| 942 | std::map<wp<DeviceDescriptor>, FormatVector> mReportedFormatsMap; |
Eric Laurent | 2517af3 | 2020-11-25 15:31:27 +0100 | [diff] [blame] | 943 | |
| 944 | // Cached product strategy ID corresponding to legacy strategy STRATEGY_PHONE |
| 945 | product_strategy_t mCommunnicationStrategy; |
| 946 | |
Francois Gaffie | 51c9ccd | 2020-10-14 18:02:07 +0200 | [diff] [blame] | 947 | // The port handle of the hardware audio source created internally for the Call RX audio |
| 948 | // end point. |
| 949 | audio_port_handle_t mCallRxSourceClientPort = AUDIO_PORT_HANDLE_NONE; |
| 950 | |
Mikhail Naganov | 15be9d2 | 2017-11-08 14:18:13 +1100 | [diff] [blame] | 951 | // Support for Multi-Stream Decoder (MSD) module |
| 952 | sp<DeviceDescriptor> getMsdAudioInDevice() const; |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 953 | DeviceVector getMsdAudioOutDevices() const; |
Dean Wheatley | 8bee85a | 2021-02-10 16:02:23 +1100 | [diff] [blame] | 954 | const AudioPatchCollection getMsdOutputPatches() const; |
| 955 | status_t getMsdProfiles(bool hwAvSync, |
| 956 | const InputProfileCollection &inputProfiles, |
| 957 | const OutputProfileCollection &outputProfiles, |
| 958 | const sp<DeviceDescriptor> &sourceDevice, |
| 959 | const sp<DeviceDescriptor> &sinkDevice, |
| 960 | AudioProfileVector &sourceProfiles, |
| 961 | AudioProfileVector &sinkProfiles) const; |
| 962 | status_t getBestMsdConfig(bool hwAvSync, |
| 963 | const AudioProfileVector &sourceProfiles, |
| 964 | const AudioProfileVector &sinkProfiles, |
| 965 | audio_port_config *sourceConfig, |
| 966 | audio_port_config *sinkConfig) const; |
| 967 | PatchBuilder buildMsdPatch(bool msdIsSource, const sp<DeviceDescriptor> &device) const; |
| 968 | status_t setMsdOutputPatches(const DeviceVector *outputDevices = nullptr); |
| 969 | void releaseMsdOutputPatches(const DeviceVector& devices); |
Dorin Drimus | 94d9441 | 2022-02-02 09:05:02 +0100 | [diff] [blame] | 970 | bool msdHasPatchesToAllDevices(const AudioDeviceTypeAddrVector& devices); |
Nathalie Le Clair | 88fa275 | 2021-11-23 13:03:41 +0100 | [diff] [blame] | 971 | |
| 972 | // Overload of setDeviceConnectionState() |
| 973 | status_t setDeviceConnectionState(audio_devices_t deviceType, |
| 974 | audio_policy_dev_state_t state, |
| 975 | const char* device_address, const char* device_name, |
| 976 | audio_format_t encodedFormat); |
| 977 | |
| 978 | // Called by setDeviceConnectionState() |
| 979 | status_t deviceToAudioPort(audio_devices_t deviceType, const char* device_address, |
| 980 | const char* device_name, media::AudioPort* aidPort); |
Michael Chan | 6fb3449 | 2020-12-08 15:44:49 +1100 | [diff] [blame] | 981 | private: |
| 982 | void onNewAudioModulesAvailableInt(DeviceVector *newDevices); |
| 983 | |
| 984 | // Add or remove AC3 DTS encodings based on user preferences. |
| 985 | void modifySurroundFormats(const sp<DeviceDescriptor>& devDesc, FormatVector *formatsPtr); |
| 986 | void modifySurroundChannelMasks(ChannelMaskSet *channelMasksPtr); |
Mikhail Naganov | 15be9d2 | 2017-11-08 14:18:13 +1100 | [diff] [blame] | 987 | |
François Gaffie | 112b0af | 2015-11-19 16:13:25 +0100 | [diff] [blame] | 988 | // If any, resolve any "dynamic" fields of an Audio Profiles collection |
Mikhail Naganov | d5e1805 | 2018-11-30 14:55:45 -0800 | [diff] [blame] | 989 | void updateAudioProfiles(const sp<DeviceDescriptor>& devDesc, audio_io_handle_t ioHandle, |
Phil Burk | 00eeb32 | 2016-03-31 12:41:00 -0700 | [diff] [blame] | 990 | AudioProfileVector &profiles); |
François Gaffie | 112b0af | 2015-11-19 16:13:25 +0100 | [diff] [blame] | 991 | |
François Gaffie | 44481e7 | 2016-04-20 07:49:57 +0200 | [diff] [blame] | 992 | // Notify the policy client of any change of device state with AUDIO_IO_HANDLE_NONE, |
| 993 | // so that the client interprets it as global to audio hardware interfaces. |
| 994 | // It can give a chance to HAL implementer to retrieve dynamic capabilities associated |
| 995 | // to this device for example. |
| 996 | // TODO avoid opening stream to retrieve capabilities of a profile. |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 997 | void broadcastDeviceConnectionState(const sp<DeviceDescriptor> &device, |
| 998 | audio_policy_dev_state_t state); |
François Gaffie | 44481e7 | 2016-04-20 07:49:57 +0200 | [diff] [blame] | 999 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 1000 | // updates device caching and output for streams that can influence the |
| 1001 | // routing of notifications |
| 1002 | void handleNotificationRoutingForStream(audio_stream_type_t stream); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 1003 | uint32_t curAudioPortGeneration() const { return mAudioPortGeneration; } |
Hongwei Wang | bb93dfb | 2018-10-23 13:54:22 -0700 | [diff] [blame] | 1004 | // internal method, get audio_attributes_t from either a source audio_attributes_t |
| 1005 | // or audio_stream_type_t, respectively. |
| 1006 | status_t getAudioAttributes(audio_attributes_t *dstAttr, |
| 1007 | const audio_attributes_t *srcAttr, |
| 1008 | audio_stream_type_t srcStream); |
| 1009 | // internal method, called by getOutputForAttr() and connectAudioSource. |
| 1010 | status_t getOutputForAttrInt(audio_attributes_t *resultAttr, |
| 1011 | audio_io_handle_t *output, |
| 1012 | audio_session_t session, |
| 1013 | const audio_attributes_t *attr, |
| 1014 | audio_stream_type_t *stream, |
| 1015 | uid_t uid, |
| 1016 | const audio_config_t *config, |
| 1017 | audio_output_flags_t *flags, |
François Gaffie | f579db5 | 2018-11-13 11:25:16 +0100 | [diff] [blame] | 1018 | audio_port_handle_t *selectedDeviceId, |
Kevin Rocard | 153f92d | 2018-12-18 18:33:28 -0800 | [diff] [blame] | 1019 | bool *isRequestedDeviceForExclusiveUse, |
Eric Laurent | c529cf6 | 2020-04-17 18:19:10 -0700 | [diff] [blame] | 1020 | std::vector<sp<AudioPolicyMix>> *secondaryMixes, |
Eric Laurent | 8a1095a | 2019-11-08 14:44:16 -0800 | [diff] [blame] | 1021 | output_type_t *outputType); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 1022 | // internal method to return the output handle for the given device and format |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 1023 | audio_io_handle_t getOutputForDevices( |
| 1024 | const DeviceVector &devices, |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 1025 | audio_session_t session, |
Eric Laurent | cad6c0d | 2021-07-13 15:12:39 +0200 | [diff] [blame] | 1026 | const audio_attributes_t *attr, |
Eric Laurent | fe23112 | 2017-11-17 17:48:06 -0800 | [diff] [blame] | 1027 | const audio_config_t *config, |
jiabin | e375d41 | 2019-02-26 12:54:53 -0800 | [diff] [blame] | 1028 | audio_output_flags_t *flags, |
| 1029 | bool forceMutingHaptic = false); |
François Gaffie | c005e56 | 2018-11-06 15:04:49 +0100 | [diff] [blame] | 1030 | |
Eric Laurent | c529cf6 | 2020-04-17 18:19:10 -0700 | [diff] [blame] | 1031 | // Internal method checking if a direct output can be opened matching the requested |
| 1032 | // attributes, flags, config and devices. |
| 1033 | // If NAME_NOT_FOUND is returned, an attempt can be made to open a mixed output. |
| 1034 | status_t openDirectOutput( |
| 1035 | audio_stream_type_t stream, |
| 1036 | audio_session_t session, |
| 1037 | const audio_config_t *config, |
| 1038 | audio_output_flags_t flags, |
| 1039 | const DeviceVector &devices, |
| 1040 | audio_io_handle_t *output); |
Eric Laurent | cad6c0d | 2021-07-13 15:12:39 +0200 | [diff] [blame] | 1041 | |
Eric Laurent | b4f42a9 | 2022-01-17 17:37:31 +0100 | [diff] [blame] | 1042 | /** |
| 1043 | * @brief Queries if some kind of spatialization will be performed if the audio playback |
| 1044 | * context described by the provided arguments is present. |
| 1045 | * The context is made of: |
| 1046 | * - The audio attributes describing the playback use case. |
| 1047 | * - The audio configuration describing the audio format, channels, sampling rate ... |
| 1048 | * - The devices describing the sink audio device selected for playback. |
| 1049 | * All arguments are optional and only the specified arguments are used to match against |
| 1050 | * supported criteria. For instance, supplying no argument will tell if spatialization is |
| 1051 | * supported or not in general. |
| 1052 | * @param attr audio attributes describing the playback use case |
| 1053 | * @param config audio configuration describing the audio format, channels, sample rate... |
| 1054 | * @param devices the sink audio device selected for playback |
| 1055 | * @param allowCurrentOutputReconfig if true, the result will be considering it is possible |
| 1056 | * to close and reopen an existing spatializer output stream to match the requested |
| 1057 | * criteria. If false, the criteria must be compatible with the opened sptializer |
| 1058 | * output. |
| 1059 | * @return true if spatialization is possible for this context, false otherwise. |
| 1060 | */ |
| 1061 | virtual bool canBeSpatializedInt(const audio_attributes_t *attr, |
| 1062 | const audio_config_t *config, |
| 1063 | const AudioDeviceTypeAddrVector &devices, |
| 1064 | bool allowCurrentOutputReconfig = true) const; |
| 1065 | |
Eric Laurent | fa0f674 | 2021-08-17 18:39:44 +0200 | [diff] [blame] | 1066 | sp<IOProfile> getSpatializerOutputProfile(const audio_config_t *config, |
Eric Laurent | 3909598 | 2021-08-24 18:29:27 +0200 | [diff] [blame] | 1067 | const AudioDeviceTypeAddrVector &devices) const; |
| 1068 | |
| 1069 | static bool isChannelMaskSpatialized(audio_channel_mask_t channels); |
Eric Laurent | cad6c0d | 2021-07-13 15:12:39 +0200 | [diff] [blame] | 1070 | |
| 1071 | void checkVirtualizerClientRoutes(); |
| 1072 | |
François Gaffie | c005e56 | 2018-11-06 15:04:49 +0100 | [diff] [blame] | 1073 | /** |
| 1074 | * @brief getInputForDevice selects an input handle for a given input device and |
| 1075 | * requester context |
| 1076 | * @param device to be used by requester, selected by policy mix rules or engine |
| 1077 | * @param session requester session id |
| 1078 | * @param uid requester uid |
| 1079 | * @param attributes requester audio attributes (e.g. input source and tags matter) |
| 1080 | * @param config requester audio configuration (e.g. sample rate, format, channel mask). |
| 1081 | * @param flags requester input flags |
| 1082 | * @param policyMix may be null, policy rules to be followed by the requester |
| 1083 | * @return input io handle aka unique input identifier selected for this device. |
| 1084 | */ |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 1085 | audio_io_handle_t getInputForDevice(const sp<DeviceDescriptor> &device, |
Eric Laurent | 599c758 | 2015-12-07 18:05:55 -0800 | [diff] [blame] | 1086 | audio_session_t session, |
François Gaffie | c005e56 | 2018-11-06 15:04:49 +0100 | [diff] [blame] | 1087 | const audio_attributes_t &attributes, |
Eric Laurent | fe23112 | 2017-11-17 17:48:06 -0800 | [diff] [blame] | 1088 | const audio_config_base_t *config, |
Eric Laurent | 599c758 | 2015-12-07 18:05:55 -0800 | [diff] [blame] | 1089 | audio_input_flags_t flags, |
Mikhail Naganov | bfac583 | 2019-03-05 16:55:28 -0800 | [diff] [blame] | 1090 | const sp<AudioPolicyMix> &policyMix); |
Eric Laurent | 599c758 | 2015-12-07 18:05:55 -0800 | [diff] [blame] | 1091 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 1092 | // event is one of STARTING_OUTPUT, STARTING_BEACON, STOPPING_OUTPUT, STOPPING_BEACON |
| 1093 | // returns 0 if no mute/unmute event happened, the largest latency of the device where |
| 1094 | // the mute/unmute happened |
| 1095 | uint32_t handleEventForBeacon(int event); |
| 1096 | uint32_t setBeaconMute(bool mute); |
| 1097 | bool isValidAttributes(const audio_attributes_t *paa); |
| 1098 | |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 1099 | // Called by setDeviceConnectionState(). |
Nathalie Le Clair | 88fa275 | 2021-11-23 13:03:41 +0100 | [diff] [blame] | 1100 | status_t setDeviceConnectionStateInt(audio_policy_dev_state_t state, |
| 1101 | const android::media::audio::common::AudioPort& port, |
| 1102 | audio_format_t encodedFormat); |
François Gaffie | 11d3010 | 2018-11-02 16:09:09 +0100 | [diff] [blame] | 1103 | status_t setDeviceConnectionStateInt(audio_devices_t deviceType, |
| 1104 | audio_policy_dev_state_t state, |
| 1105 | const char *device_address, |
Aniket Kumar Lata | 4e46470 | 2019-01-10 23:38:46 -0800 | [diff] [blame] | 1106 | const char *device_name, |
| 1107 | audio_format_t encodedFormat); |
Mikhail Naganov | d0e2c74 | 2020-03-25 15:59:59 -0700 | [diff] [blame] | 1108 | status_t setDeviceConnectionStateInt(const sp<DeviceDescriptor> &device, |
| 1109 | audio_policy_dev_state_t state); |
Eric Laurent | 736a102 | 2019-03-27 18:28:46 -0700 | [diff] [blame] | 1110 | |
| 1111 | void setEngineDeviceConnectionState(const sp<DeviceDescriptor> device, |
| 1112 | audio_policy_dev_state_t state); |
| 1113 | |
Andy Hung | 2ddee19 | 2015-12-18 17:34:44 -0800 | [diff] [blame] | 1114 | void updateMono(audio_io_handle_t output) { |
| 1115 | AudioParameter param; |
Mikhail Naganov | 388360c | 2016-10-17 17:09:41 -0700 | [diff] [blame] | 1116 | param.addInt(String8(AudioParameter::keyMonoOutput), (int)mMasterMono); |
Andy Hung | 2ddee19 | 2015-12-18 17:34:44 -0800 | [diff] [blame] | 1117 | mpClientInterface->setParameters(output, param.toString()); |
| 1118 | } |
François Gaffie | afd4cea | 2019-11-18 15:50:22 +0100 | [diff] [blame] | 1119 | |
| 1120 | /** |
| 1121 | * @brief createAudioPatchInternal internal function to manage audio patch creation |
| 1122 | * @param[in] patch structure containing sink and source ports configuration |
| 1123 | * @param[out] handle patch handle to be provided if patch installed correctly |
| 1124 | * @param[in] uid of the client |
| 1125 | * @param[in] delayMs if required |
| 1126 | * @param[in] sourceDesc [optional] in case of external source, source client to be |
| 1127 | * configured by the patch, i.e. assigning an Output (HW or SW) |
| 1128 | * @return NO_ERROR if patch installed correctly, error code otherwise. |
| 1129 | */ |
| 1130 | status_t createAudioPatchInternal(const struct audio_patch *patch, |
| 1131 | audio_patch_handle_t *handle, |
| 1132 | uid_t uid, uint32_t delayMs = 0, |
| 1133 | const sp<SourceClientDescriptor>& sourceDesc = nullptr); |
| 1134 | /** |
| 1135 | * @brief releaseAudioPatchInternal internal function to remove an audio patch |
| 1136 | * @param[in] handle of the patch to be removed |
| 1137 | * @param[in] delayMs if required |
| 1138 | * @return NO_ERROR if patch removed correctly, error code otherwise. |
| 1139 | */ |
| 1140 | status_t releaseAudioPatchInternal(audio_patch_handle_t handle, uint32_t delayMs = 0); |
| 1141 | |
Mikhail Naganov | dc76968 | 2018-05-04 15:34:08 -0700 | [diff] [blame] | 1142 | status_t installPatch(const char *caller, |
| 1143 | audio_patch_handle_t *patchHandle, |
| 1144 | AudioIODescriptorInterface *ioDescriptor, |
| 1145 | const struct audio_patch *patch, |
| 1146 | int delayMs); |
| 1147 | status_t installPatch(const char *caller, |
| 1148 | ssize_t index, |
| 1149 | audio_patch_handle_t *patchHandle, |
| 1150 | const struct audio_patch *patch, |
| 1151 | int delayMs, |
| 1152 | uid_t uid, |
| 1153 | sp<AudioPatch> *patchDescPtr); |
Eric Laurent | c529cf6 | 2020-04-17 18:19:10 -0700 | [diff] [blame] | 1154 | |
| 1155 | bool areAllDevicesSupported( |
jiabin | 6a02d53 | 2020-08-07 11:56:38 -0700 | [diff] [blame] | 1156 | const AudioDeviceTypeAddrVector& devices, |
Eric Laurent | c529cf6 | 2020-04-17 18:19:10 -0700 | [diff] [blame] | 1157 | std::function<bool(audio_devices_t)> predicate, |
| 1158 | const char* context); |
| 1159 | |
Eric Laurent | 2517af3 | 2020-11-25 15:31:27 +0100 | [diff] [blame] | 1160 | bool isScoRequestedForComm() const; |
jiabin | bce0c1d | 2020-10-05 11:20:18 -0700 | [diff] [blame] | 1161 | |
| 1162 | bool areAllActiveTracksRerouted(const sp<SwAudioOutputDescriptor>& output); |
| 1163 | |
Eric Laurent | b4f42a9 | 2022-01-17 17:37:31 +0100 | [diff] [blame] | 1164 | /** |
| 1165 | * @brief Opens an output stream from the supplied IOProfile and route it to the |
| 1166 | * supplied audio devices. If a mixer config is specified, it is forwarded to audio |
| 1167 | * flinger. If not, a default config is derived from the output stream config. |
| 1168 | * Also opens a duplicating output if needed and queries the audio HAL for supported |
| 1169 | * audio profiles if the IOProfile is dynamic. |
| 1170 | * @param[in] profile IOProfile to use as template |
| 1171 | * @param[in] devices initial route to apply to this output stream |
| 1172 | * @param[in] mixerConfig if not null, use this to configure the mixer |
| 1173 | * @return an output descriptor for the newly opened stream or null in case of error. |
| 1174 | */ |
| 1175 | sp<SwAudioOutputDescriptor> openOutputWithProfileAndDevice( |
| 1176 | const sp<IOProfile>& profile, const DeviceVector& devices, |
| 1177 | const audio_config_base_t *mixerConfig = nullptr); |
jiabin | bce0c1d | 2020-10-05 11:20:18 -0700 | [diff] [blame] | 1178 | |
jiabin | 2b9d5a1 | 2021-12-10 01:06:29 +0000 | [diff] [blame] | 1179 | bool isOffloadPossible(const audio_offload_info_t& offloadInfo, |
| 1180 | bool durationIgnored = false); |
| 1181 | |
Dorin Drimus | 94d9441 | 2022-02-02 09:05:02 +0100 | [diff] [blame] | 1182 | // adds the profiles from the outputProfile to the passed audioProfilesVector |
| 1183 | // without duplicating them if already present |
| 1184 | void addPortProfilesToVector(sp<IOProfile> outputProfile, |
| 1185 | AudioProfileVector& audioProfilesVector); |
Jean-Michel Trivi | 56ec4ff | 2015-01-23 16:45:18 -0800 | [diff] [blame] | 1186 | }; |
| 1187 | |
| 1188 | }; |