Glenn Kasten | 99e53b8 | 2012-01-19 08:59:58 -0800 | [diff] [blame] | 1 | /* |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 2 | ** |
| 3 | ** Copyright 2007, The Android Open Source Project |
| 4 | ** |
| 5 | ** Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | ** you may not use this file except in compliance with the License. |
| 7 | ** You may obtain a copy of the License at |
| 8 | ** |
| 9 | ** http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | ** |
| 11 | ** Unless required by applicable law or agreed to in writing, software |
| 12 | ** distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | ** See the License for the specific language governing permissions and |
| 15 | ** limitations under the License. |
| 16 | */ |
| 17 | |
Andy Hung | 9a57fc3 | 2023-07-19 18:02:19 -0700 | [diff] [blame] | 18 | #pragma once |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 19 | |
Andy Hung | 9a57fc3 | 2023-07-19 18:02:19 -0700 | [diff] [blame] | 20 | // Classes and interfaces directly used. |
Andy Hung | 59867e4 | 2023-06-27 17:05:02 -0700 | [diff] [blame] | 21 | #include "Client.h" |
Andy Hung | 9a57fc3 | 2023-07-19 18:02:19 -0700 | [diff] [blame] | 22 | #include "DeviceEffectManager.h" |
Andy Hung | e374887 | 2023-08-30 19:05:16 -0700 | [diff] [blame] | 23 | #include "EffectConfiguration.h" |
Andy Hung | 6ac17eb | 2023-06-20 18:56:17 -0700 | [diff] [blame] | 24 | #include "IAfEffect.h" |
Andy Hung | 9a57fc3 | 2023-07-19 18:02:19 -0700 | [diff] [blame] | 25 | #include "IAfPatchPanel.h" |
Andy Hung | 440901d | 2023-06-29 21:19:25 -0700 | [diff] [blame] | 26 | #include "IAfThread.h" |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 27 | #include "IAfTrack.h" |
Andy Hung | ad2faf7 | 2023-07-13 20:00:50 -0700 | [diff] [blame] | 28 | #include "MelReporter.h" |
Andy Hung | 9a57fc3 | 2023-07-19 18:02:19 -0700 | [diff] [blame] | 29 | #include "PatchCommandThread.h" |
| 30 | |
| 31 | // External classes |
Andy Hung | 954b971 | 2023-08-28 18:36:53 -0700 | [diff] [blame] | 32 | #include <audio_utils/mutex.h> |
Andy Hung | 9a57fc3 | 2023-07-19 18:02:19 -0700 | [diff] [blame] | 33 | #include <audio_utils/FdToString.h> |
| 34 | #include <audio_utils/SimpleLog.h> |
| 35 | #include <media/IAudioFlinger.h> |
| 36 | #include <media/MediaMetricsItem.h> |
| 37 | #include <media/audiohal/DevicesFactoryHalInterface.h> |
| 38 | #include <mediautils/ServiceUtilities.h> |
| 39 | #include <mediautils/Synchronization.h> |
| 40 | |
| 41 | // not needed with the includes above, added to prevent transitive include dependency. |
| 42 | #include <utils/KeyedVector.h> |
| 43 | #include <utils/String16.h> |
| 44 | #include <atomic> |
| 45 | #include <functional> |
| 46 | #include <map> |
| 47 | #include <optional> |
| 48 | #include <set> |
Andy Hung | d6e8639 | 2023-07-13 19:33:17 -0700 | [diff] [blame] | 49 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 50 | namespace android { |
| 51 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 52 | class AudioFlinger |
| 53 | : public AudioFlingerServerAdapter::Delegate // IAudioFlinger client interface |
Andy Hung | 47c0117 | 2023-07-17 12:40:43 -0700 | [diff] [blame] | 54 | , public IAfClientCallback |
Andy Hung | 692f045 | 2023-07-17 13:45:55 -0700 | [diff] [blame] | 55 | , public IAfDeviceEffectManagerCallback |
Andy Hung | b60a2c8 | 2023-07-17 14:02:52 -0700 | [diff] [blame] | 56 | , public IAfMelReporterCallback |
Andy Hung | 2dc61c4 | 2023-07-17 14:36:08 -0700 | [diff] [blame] | 57 | , public IAfPatchPanelCallback |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 58 | , public IAfThreadCallback |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 59 | { |
Andy Hung | 1d312b9 | 2023-01-03 16:12:50 -0800 | [diff] [blame] | 60 | friend class sp<AudioFlinger>; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 61 | public: |
Ytai Ben-Tsvi | 50b8ccb | 2020-11-24 13:47:54 -0800 | [diff] [blame] | 62 | static void instantiate() ANDROID_API; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 63 | |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 64 | private: |
| 65 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 66 | // ---- begin IAudioFlinger interface |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 67 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 68 | status_t dump(int fd, const Vector<String16>& args) final EXCLUDES_AudioFlinger_Mutex; |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 69 | |
Ytai Ben-Tsvi | 16d8761 | 2020-11-03 16:32:36 -0800 | [diff] [blame] | 70 | status_t createTrack(const media::CreateTrackRequest& input, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 71 | media::CreateTrackResponse& output) final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 72 | |
Ytai Ben-Tsvi | 16d8761 | 2020-11-03 16:32:36 -0800 | [diff] [blame] | 73 | status_t createRecord(const media::CreateRecordRequest& input, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 74 | media::CreateRecordResponse& output) final EXCLUDES_AudioFlinger_Mutex; |
Glenn Kasten | 2f732eb | 2012-01-26 09:48:03 -0800 | [diff] [blame] | 75 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 76 | uint32_t sampleRate(audio_io_handle_t ioHandle) const final EXCLUDES_AudioFlinger_Mutex; |
| 77 | audio_format_t format(audio_io_handle_t output) const final EXCLUDES_AudioFlinger_Mutex; |
| 78 | size_t frameCount(audio_io_handle_t ioHandle) const final EXCLUDES_AudioFlinger_Mutex; |
| 79 | size_t frameCountHAL(audio_io_handle_t ioHandle) const final EXCLUDES_AudioFlinger_Mutex; |
| 80 | uint32_t latency(audio_io_handle_t output) const final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 81 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 82 | status_t setMasterVolume(float value) final EXCLUDES_AudioFlinger_Mutex; |
| 83 | status_t setMasterMute(bool muted) final EXCLUDES_AudioFlinger_Mutex; |
| 84 | float masterVolume() const final EXCLUDES_AudioFlinger_Mutex; |
| 85 | bool masterMute() const final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 86 | |
Richard Folke Tullberg | 3fae037 | 2017-01-13 09:04:25 +0100 | [diff] [blame] | 87 | // Balance value must be within -1.f (left only) to 1.f (right only) inclusive. |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 88 | status_t setMasterBalance(float balance) final EXCLUDES_AudioFlinger_Mutex; |
| 89 | status_t getMasterBalance(float* balance) const final EXCLUDES_AudioFlinger_Mutex; |
Richard Folke Tullberg | 3fae037 | 2017-01-13 09:04:25 +0100 | [diff] [blame] | 90 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 91 | status_t setStreamVolume(audio_stream_type_t stream, float value, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 92 | audio_io_handle_t output) final EXCLUDES_AudioFlinger_Mutex; |
| 93 | status_t setStreamMute(audio_stream_type_t stream, bool muted) final |
| 94 | EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 95 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 96 | float streamVolume(audio_stream_type_t stream, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 97 | audio_io_handle_t output) const final EXCLUDES_AudioFlinger_Mutex; |
| 98 | bool streamMute(audio_stream_type_t stream) const final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 99 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 100 | status_t setMode(audio_mode_t mode) final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 101 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 102 | status_t setMicMute(bool state) final EXCLUDES_AudioFlinger_Mutex; |
| 103 | bool getMicMute() const final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 104 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 105 | void setRecordSilenced(audio_port_handle_t portId, bool silenced) final |
| 106 | EXCLUDES_AudioFlinger_Mutex; |
Svet Ganov | f4ddfef | 2018-01-16 07:37:58 -0800 | [diff] [blame] | 107 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 108 | status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs) final |
| 109 | EXCLUDES_AudioFlinger_Mutex; |
| 110 | String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const final |
| 111 | EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 112 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 113 | void registerClient(const sp<media::IAudioFlingerClient>& client) final |
| 114 | EXCLUDES_AudioFlinger_Mutex; |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 115 | size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 116 | audio_channel_mask_t channelMask) const final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 117 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 118 | status_t openOutput(const media::OpenOutputRequest& request, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 119 | media::OpenOutputResponse* response) final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 120 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 121 | audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 122 | audio_io_handle_t output2) final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 123 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 124 | status_t closeOutput(audio_io_handle_t output) final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 125 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 126 | status_t suspendOutput(audio_io_handle_t output) final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 127 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 128 | status_t restoreOutput(audio_io_handle_t output) final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 129 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 130 | status_t openInput(const media::OpenInputRequest& request, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 131 | media::OpenInputResponse* response) final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 132 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 133 | status_t closeInput(audio_io_handle_t input) final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 134 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 135 | status_t setVoiceVolume(float volume) final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 136 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 137 | status_t getRenderPosition(uint32_t* halFrames, uint32_t* dspFrames, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 138 | audio_io_handle_t output) const final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 139 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 140 | uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const final |
| 141 | EXCLUDES_AudioFlinger_Mutex; |
Glenn Kasten | 2f732eb | 2012-01-26 09:48:03 -0800 | [diff] [blame] | 142 | |
Glenn Kasten | 9d00313 | 2016-04-06 14:38:09 -0700 | [diff] [blame] | 143 | // This is the binder API. For the internal API see nextUniqueId(). |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 144 | audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use) final |
| 145 | EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 146 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 147 | void acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid) final |
| 148 | EXCLUDES_AudioFlinger_Mutex; |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 149 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 150 | void releaseAudioSessionId(audio_session_t audioSession, pid_t pid) final |
| 151 | EXCLUDES_AudioFlinger_Mutex; |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 152 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 153 | status_t queryNumberEffects(uint32_t* numEffects) const final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 154 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 155 | status_t queryEffect(uint32_t index, effect_descriptor_t* descriptor) const final |
| 156 | EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 157 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 158 | status_t getEffectDescriptor(const effect_uuid_t* pUuid, |
| 159 | const effect_uuid_t* pTypeUuid, |
| 160 | uint32_t preferredTypeFlag, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 161 | effect_descriptor_t* descriptor) const final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 162 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 163 | status_t createEffect(const media::CreateEffectRequest& request, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 164 | media::CreateEffectResponse* response) final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 165 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 166 | status_t moveEffects(audio_session_t sessionId, audio_io_handle_t srcOutput, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 167 | audio_io_handle_t dstOutput) final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 168 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 169 | void setEffectSuspended(int effectId, |
| 170 | audio_session_t sessionId, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 171 | bool suspended) final EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | b20cf7d | 2019-04-05 19:37:34 -0700 | [diff] [blame] | 172 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 173 | audio_module_handle_t loadHwModule(const char* name) final EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | a4c5a55 | 2012-03-29 10:12:40 -0700 | [diff] [blame] | 174 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 175 | uint32_t getPrimaryOutputSamplingRate() const final EXCLUDES_AudioFlinger_Mutex; |
| 176 | size_t getPrimaryOutputFrameCount() const final EXCLUDES_AudioFlinger_Mutex; |
Glenn Kasten | cc0f1cf | 2012-09-24 11:27:18 -0700 | [diff] [blame] | 177 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 178 | status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) final |
| 179 | EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 4b12340 | 2014-04-11 09:22:20 -0700 | [diff] [blame] | 180 | |
| 181 | /* Get attributes for a given audio port */ |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 182 | status_t getAudioPort(struct audio_port_v7* port) const final EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 4b12340 | 2014-04-11 09:22:20 -0700 | [diff] [blame] | 183 | |
| 184 | /* Create an audio patch between several source and sink ports */ |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 185 | status_t createAudioPatch(const struct audio_patch *patch, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 186 | audio_patch_handle_t* handle) final EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 4b12340 | 2014-04-11 09:22:20 -0700 | [diff] [blame] | 187 | |
| 188 | /* Release an audio patch */ |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 189 | status_t releaseAudioPatch(audio_patch_handle_t handle) final EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 4b12340 | 2014-04-11 09:22:20 -0700 | [diff] [blame] | 190 | |
| 191 | /* List existing audio patches */ |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 192 | status_t listAudioPatches(unsigned int* num_patches, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 193 | struct audio_patch* patches) const final EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 1c333e2 | 2014-05-20 10:48:17 -0700 | [diff] [blame] | 194 | |
Eric Laurent | 4b12340 | 2014-04-11 09:22:20 -0700 | [diff] [blame] | 195 | /* Set audio port configuration */ |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 196 | status_t setAudioPortConfig(const struct audio_port_config* config) final |
| 197 | EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 4b12340 | 2014-04-11 09:22:20 -0700 | [diff] [blame] | 198 | |
Eric Laurent | 93c3d41 | 2014-08-01 14:48:35 -0700 | [diff] [blame] | 199 | /* Get the HW synchronization source used for an audio session */ |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 200 | audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId) final |
| 201 | EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 93c3d41 | 2014-08-01 14:48:35 -0700 | [diff] [blame] | 202 | |
Eric Laurent | 72e3f39 | 2015-05-20 14:43:50 -0700 | [diff] [blame] | 203 | /* Indicate JAVA services are ready (scheduling, power management ...) */ |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 204 | status_t systemReady() final EXCLUDES_AudioFlinger_Mutex; |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 205 | status_t audioPolicyReady() final { mAudioPolicyReady.store(true); return NO_ERROR; } |
Eric Laurent | d66d7a1 | 2021-07-13 13:35:32 +0200 | [diff] [blame] | 206 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 207 | status_t getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) const final |
| 208 | EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 72e3f39 | 2015-05-20 14:43:50 -0700 | [diff] [blame] | 209 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 210 | status_t setAudioHalPids(const std::vector<pid_t>& pids) final |
| 211 | EXCLUDES_AudioFlinger_Mutex; |
jiabin | 46a76fa | 2018-01-05 10:18:21 -0800 | [diff] [blame] | 212 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 213 | status_t setVibratorInfos(const std::vector<media::AudioVibratorInfo>& vibratorInfos) final |
| 214 | EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 42896a0 | 2019-09-27 15:40:33 -0700 | [diff] [blame] | 215 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 216 | status_t updateSecondaryOutputs( |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 217 | const TrackSecondaryOutputsMap& trackSecondaryOutputs) final |
| 218 | EXCLUDES_AudioFlinger_Mutex; |
jiabin | 1319f5a | 2021-03-30 22:21:24 +0000 | [diff] [blame] | 219 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 220 | status_t getMmapPolicyInfos( |
jiabin | e99d088 | 2021-09-17 05:21:25 +0000 | [diff] [blame] | 221 | media::audio::common::AudioMMapPolicyType policyType, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 222 | std::vector<media::audio::common::AudioMMapPolicyInfo>* policyInfos) final |
| 223 | EXCLUDES_AudioFlinger_Mutex; |
Jiabin Huang | ebe6410 | 2021-09-07 20:01:07 +0000 | [diff] [blame] | 224 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 225 | int32_t getAAudioMixerBurstCount() const final EXCLUDES_AudioFlinger_Mutex; |
jiabin | e504e7b | 2021-09-18 00:27:08 +0000 | [diff] [blame] | 226 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 227 | int32_t getAAudioHardwareBurstMinUsec() const final EXCLUDES_AudioFlinger_Mutex; |
jiabin | e504e7b | 2021-09-18 00:27:08 +0000 | [diff] [blame] | 228 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 229 | status_t setDeviceConnectedState(const struct audio_port_v7* port, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 230 | media::DeviceConnectedState state) final EXCLUDES_AudioFlinger_Mutex; |
Mikhail Naganov | 516d398 | 2022-02-01 23:53:59 +0000 | [diff] [blame] | 231 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 232 | status_t setSimulateDeviceConnections(bool enabled) final EXCLUDES_AudioFlinger_Mutex; |
Mikhail Naganov | b1ddbb0 | 2023-03-15 17:06:59 -0700 | [diff] [blame] | 233 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 234 | status_t setRequestedLatencyMode( |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 235 | audio_io_handle_t output, audio_latency_mode_t mode) final |
| 236 | EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 076e7c7 | 2022-05-03 18:12:28 +0200 | [diff] [blame] | 237 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 238 | status_t getSupportedLatencyModes(audio_io_handle_t output, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 239 | std::vector<audio_latency_mode_t>* modes) const final EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 076e7c7 | 2022-05-03 18:12:28 +0200 | [diff] [blame] | 240 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 241 | status_t setBluetoothVariableLatencyEnabled(bool enabled) final EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 5205764 | 2022-12-16 11:45:07 +0100 | [diff] [blame] | 242 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 243 | status_t isBluetoothVariableLatencyEnabled(bool* enabled) const final |
| 244 | EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 50d7258 | 2022-12-20 20:20:23 +0100 | [diff] [blame] | 245 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 246 | status_t supportsBluetoothVariableLatency(bool* support) const final |
| 247 | EXCLUDES_AudioFlinger_Mutex; |
Eric Laurent | 5205764 | 2022-12-16 11:45:07 +0100 | [diff] [blame] | 248 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 249 | status_t getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 250 | sp<media::ISoundDose>* soundDose) const final EXCLUDES_AudioFlinger_Mutex; |
Vlad Popa | 63f047e | 2022-11-05 14:09:19 +0100 | [diff] [blame] | 251 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 252 | status_t invalidateTracks(const std::vector<audio_port_handle_t>& portIds) final |
| 253 | EXCLUDES_AudioFlinger_Mutex; |
jiabin | c44b346 | 2022-12-08 12:52:31 -0800 | [diff] [blame] | 254 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 255 | status_t getAudioPolicyConfig(media::AudioPolicyConfig* config) final |
| 256 | EXCLUDES_AudioFlinger_Mutex; |
Mikhail Naganov | ffd9771 | 2023-05-03 17:45:36 -0700 | [diff] [blame] | 257 | |
jiabin | 12537fc | 2023-10-12 17:56:08 +0000 | [diff] [blame] | 258 | // Get the attributes of the mix port when connecting to the given device port. |
| 259 | status_t getAudioMixPort(const struct audio_port_v7* devicePort, |
| 260 | struct audio_port_v7* mixPort) const final EXCLUDES_AudioFlinger_Mutex; |
| 261 | |
Ytai Ben-Tsvi | 24b33fc | 2021-05-10 13:08:11 -0700 | [diff] [blame] | 262 | status_t onTransactWrapper(TransactionCode code, const Parcel& data, uint32_t flags, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 263 | const std::function<status_t()>& delegate) final EXCLUDES_AudioFlinger_Mutex; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 264 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 265 | // ---- end of IAudioFlinger interface |
| 266 | |
Andy Hung | 47c0117 | 2023-07-17 12:40:43 -0700 | [diff] [blame] | 267 | // ---- begin IAfClientCallback interface |
| 268 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 269 | audio_utils::mutex& clientMutex() const final |
| 270 | RETURN_CAPABILITY(audio_utils::AudioFlinger_ClientMutex) { |
| 271 | return mClientMutex; |
| 272 | } |
| 273 | void removeClient_l(pid_t pid) REQUIRES(clientMutex()) final; |
| 274 | void removeNotificationClient(pid_t pid) final EXCLUDES_AudioFlinger_Mutex; |
Andy Hung | 47c0117 | 2023-07-17 12:40:43 -0700 | [diff] [blame] | 275 | status_t moveAuxEffectToIo( |
| 276 | int effectId, |
| 277 | const sp<IAfPlaybackThread>& dstThread, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 278 | sp<IAfPlaybackThread>* srcThread) final EXCLUDES_AudioFlinger_Mutex; |
Andy Hung | 47c0117 | 2023-07-17 12:40:43 -0700 | [diff] [blame] | 279 | |
| 280 | // ---- end of IAfClientCallback interface |
| 281 | |
Andy Hung | 692f045 | 2023-07-17 13:45:55 -0700 | [diff] [blame] | 282 | // ---- begin IAfDeviceEffectManagerCallback interface |
| 283 | |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 284 | // also used by IAfThreadCallback |
Andy Hung | 692f045 | 2023-07-17 13:45:55 -0700 | [diff] [blame] | 285 | bool isAudioPolicyReady() const final { return mAudioPolicyReady.load(); } |
Andy Hung | 2dc61c4 | 2023-07-17 14:36:08 -0700 | [diff] [blame] | 286 | // below also used by IAfMelReporterCallback, IAfPatchPanelCallback |
Andy Hung | 692f045 | 2023-07-17 13:45:55 -0700 | [diff] [blame] | 287 | const sp<PatchCommandThread>& getPatchCommandThread() final { return mPatchCommandThread; } |
| 288 | status_t addEffectToHal( |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 289 | const struct audio_port_config* device, const sp<EffectHalInterface>& effect) final |
| 290 | EXCLUDES_AudioFlinger_HardwareMutex; |
Andy Hung | 692f045 | 2023-07-17 13:45:55 -0700 | [diff] [blame] | 291 | status_t removeEffectFromHal( |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 292 | const struct audio_port_config* device, const sp<EffectHalInterface>& effect) final |
| 293 | EXCLUDES_AudioFlinger_HardwareMutex; |
Andy Hung | 692f045 | 2023-07-17 13:45:55 -0700 | [diff] [blame] | 294 | |
| 295 | // ---- end of IAfDeviceEffectManagerCallback interface |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 296 | |
Andy Hung | b60a2c8 | 2023-07-17 14:02:52 -0700 | [diff] [blame] | 297 | // ---- begin IAfMelReporterCallback interface |
| 298 | |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 299 | // below also used by IAfThreadCallback |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 300 | audio_utils::mutex& mutex() const final |
| 301 | RETURN_CAPABILITY(audio_utils::AudioFlinger_Mutex) |
| 302 | EXCLUDES_BELOW_AudioFlinger_Mutex { return mMutex; } |
Andy Hung | 954b971 | 2023-08-28 18:36:53 -0700 | [diff] [blame] | 303 | sp<IAfThreadBase> checkOutputThread_l(audio_io_handle_t ioHandle) const final |
| 304 | REQUIRES(mutex()); |
Andy Hung | b60a2c8 | 2023-07-17 14:02:52 -0700 | [diff] [blame] | 305 | |
| 306 | // ---- end of IAfMelReporterCallback interface |
| 307 | |
Andy Hung | 2dc61c4 | 2023-07-17 14:36:08 -0700 | [diff] [blame] | 308 | // ---- begin IAfPatchPanelCallback interface |
| 309 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 310 | void closeThreadInternal_l(const sp<IAfPlaybackThread>& thread) final REQUIRES(mutex()); |
| 311 | void closeThreadInternal_l(const sp<IAfRecordThread>& thread) final REQUIRES(mutex()); |
Andy Hung | 2dc61c4 | 2023-07-17 14:36:08 -0700 | [diff] [blame] | 312 | // return thread associated with primary hardware device, or NULL |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 313 | IAfPlaybackThread* primaryPlaybackThread_l() const final REQUIRES(mutex()); |
| 314 | IAfPlaybackThread* checkPlaybackThread_l(audio_io_handle_t output) const final |
| 315 | REQUIRES(mutex()); |
| 316 | IAfRecordThread* checkRecordThread_l(audio_io_handle_t input) const final REQUIRES(mutex()); |
| 317 | IAfMmapThread* checkMmapThread_l(audio_io_handle_t io) const final REQUIRES(mutex()); |
Andy Hung | 2dc61c4 | 2023-07-17 14:36:08 -0700 | [diff] [blame] | 318 | sp<IAfThreadBase> openInput_l(audio_module_handle_t module, |
| 319 | audio_io_handle_t* input, |
| 320 | audio_config_t* config, |
| 321 | audio_devices_t device, |
| 322 | const char* address, |
| 323 | audio_source_t source, |
| 324 | audio_input_flags_t flags, |
| 325 | audio_devices_t outputDevice, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 326 | const String8& outputDeviceAddress) final REQUIRES(mutex()); |
Andy Hung | 2dc61c4 | 2023-07-17 14:36:08 -0700 | [diff] [blame] | 327 | sp<IAfThreadBase> openOutput_l(audio_module_handle_t module, |
| 328 | audio_io_handle_t* output, |
| 329 | audio_config_t* halConfig, |
| 330 | audio_config_base_t* mixerConfig, |
| 331 | audio_devices_t deviceType, |
| 332 | const String8& address, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 333 | audio_output_flags_t flags) final REQUIRES(mutex()); |
Andy Hung | 2dc61c4 | 2023-07-17 14:36:08 -0700 | [diff] [blame] | 334 | const DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*>& |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 335 | getAudioHwDevs_l() const final REQUIRES(mutex()) { return mAudioHwDevs; } |
Andy Hung | 2dc61c4 | 2023-07-17 14:36:08 -0700 | [diff] [blame] | 336 | void updateDownStreamPatches_l(const struct audio_patch* patch, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 337 | const std::set<audio_io_handle_t>& streams) final REQUIRES(mutex()); |
| 338 | void updateOutDevicesForRecordThreads_l(const DeviceDescriptorBaseVector& devices) final |
| 339 | REQUIRES(mutex()); |
Andy Hung | 2dc61c4 | 2023-07-17 14:36:08 -0700 | [diff] [blame] | 340 | |
| 341 | // ---- end of IAfPatchPanelCallback interface |
| 342 | |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 343 | // ----- begin IAfThreadCallback interface |
| 344 | |
Andy Hung | ab65b18 | 2023-09-06 19:41:47 -0700 | [diff] [blame] | 345 | bool isNonOffloadableGlobalEffectEnabled_l() const final |
| 346 | REQUIRES(mutex()) EXCLUDES_ThreadBase_Mutex; |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 347 | bool btNrecIsOff() const final { return mBtNrecIsOff.load(); } |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 348 | float masterVolume_l() const final REQUIRES(mutex()); |
| 349 | bool masterMute_l() const final REQUIRES(mutex()); |
| 350 | float getMasterBalance_l() const REQUIRES(mutex()); |
Andy Hung | 954b971 | 2023-08-28 18:36:53 -0700 | [diff] [blame] | 351 | // no range check, AudioFlinger::mutex() held |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 352 | bool streamMute_l(audio_stream_type_t stream) const final REQUIRES(mutex()) { |
| 353 | return mStreamTypes[stream].mute; |
| 354 | } |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 355 | audio_mode_t getMode() const final { return mMode; } |
| 356 | bool isLowRamDevice() const final { return mIsLowRamDevice; } |
Andy Hung | 1d2d2aea | 2023-07-19 16:22:58 -0700 | [diff] [blame] | 357 | uint32_t getScreenState() const final { return mScreenState; } |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 358 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 359 | std::optional<media::AudioVibratorInfo> getDefaultVibratorInfo_l() const final |
| 360 | REQUIRES(mutex()); |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 361 | const sp<IAfPatchPanel>& getPatchPanel() const final { return mPatchPanel; } |
| 362 | const sp<MelReporter>& getMelReporter() const final { return mMelReporter; } |
| 363 | const sp<EffectsFactoryHalInterface>& getEffectsFactoryHal() const final { |
| 364 | return mEffectsFactoryHal; |
| 365 | } |
| 366 | sp<IAudioManager> getOrCreateAudioManager() final; |
| 367 | |
| 368 | // Called when the last effect handle on an effect instance is removed. If this |
| 369 | // effect belongs to an effect chain in mOrphanEffectChains, the chain is updated |
| 370 | // and removed from mOrphanEffectChains if it does not contain any effect. |
| 371 | // Return true if the effect was found in mOrphanEffectChains, false otherwise. |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 372 | bool updateOrphanEffectChains(const sp<IAfEffectModule>& effect) final |
| 373 | EXCLUDES_AudioFlinger_Mutex; |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 374 | |
Andy Hung | 972bec1 | 2023-08-31 16:13:39 -0700 | [diff] [blame] | 375 | status_t moveEffectChain_ll(audio_session_t sessionId, |
| 376 | IAfPlaybackThread* srcThread, IAfPlaybackThread* dstThread) final |
| 377 | REQUIRES(mutex(), audio_utils::ThreadBase_Mutex); |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 378 | |
| 379 | // This is a helper that is called during incoming binder calls. |
| 380 | // Requests media.log to start merging log buffers |
| 381 | void requestLogMerge() final; |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 382 | sp<NBLog::Writer> newWriter_l(size_t size, const char *name) final REQUIRES(mutex()); |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 383 | void unregisterWriter(const sp<NBLog::Writer>& writer) final; |
| 384 | |
| 385 | sp<audioflinger::SyncEvent> createSyncEvent(AudioSystem::sync_event_t type, |
| 386 | audio_session_t triggerSession, |
| 387 | audio_session_t listenerSession, |
| 388 | const audioflinger::SyncEventCallback& callBack, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 389 | const wp<IAfTrackBase>& cookie) final EXCLUDES_AudioFlinger_Mutex; |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 390 | |
Andy Hung | ab65b18 | 2023-09-06 19:41:47 -0700 | [diff] [blame] | 391 | // Hold either AudioFlinger::mutex or ThreadBase::mutex |
| 392 | void ioConfigChanged_l(audio_io_config_event_t event, |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 393 | const sp<AudioIoDescriptor>& ioDesc, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 394 | pid_t pid = 0) final EXCLUDES_AudioFlinger_ClientMutex; |
| 395 | void onNonOffloadableGlobalEffectEnable() final EXCLUDES_AudioFlinger_Mutex; |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 396 | void onSupportedLatencyModesChanged( |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 397 | audio_io_handle_t output, const std::vector<audio_latency_mode_t>& modes) final |
| 398 | EXCLUDES_AudioFlinger_ClientMutex; |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 399 | |
| 400 | // ---- end of IAfThreadCallback interface |
| 401 | |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 402 | /* List available audio ports and their attributes */ |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 403 | status_t listAudioPorts(unsigned int* num_ports, struct audio_port* ports) const |
| 404 | EXCLUDES_AudioFlinger_Mutex; |
Glenn Kasten | 2f732eb | 2012-01-26 09:48:03 -0800 | [diff] [blame] | 405 | |
Mikhail Naganov | 4a3d5c2 | 2016-08-15 13:47:42 -0700 | [diff] [blame] | 406 | sp<EffectsFactoryHalInterface> getEffectsFactory(); |
Eric Laurent | fc23520 | 2016-12-20 18:48:17 -0800 | [diff] [blame] | 407 | |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 408 | public: |
Andy Hung | 9a57fc3 | 2023-07-19 18:02:19 -0700 | [diff] [blame] | 409 | // TODO(b/292281786): Remove this when Oboeservice can get access to |
| 410 | // openMmapStream through an IAudioFlinger handle directly. |
| 411 | static inline std::atomic<AudioFlinger*> gAudioFlinger = nullptr; |
| 412 | |
Eric Laurent | fc23520 | 2016-12-20 18:48:17 -0800 | [diff] [blame] | 413 | status_t openMmapStream(MmapStreamInterface::stream_direction_t direction, |
| 414 | const audio_attributes_t *attr, |
| 415 | audio_config_base_t *config, |
Eric Laurent | cb4dae2 | 2017-07-01 19:39:32 -0700 | [diff] [blame] | 416 | const AudioClient& client, |
Eric Laurent | fc23520 | 2016-12-20 18:48:17 -0800 | [diff] [blame] | 417 | audio_port_handle_t *deviceId, |
Phil Burk | 4e1af9f | 2018-01-03 15:54:35 -0800 | [diff] [blame] | 418 | audio_session_t *sessionId, |
Eric Laurent | fc23520 | 2016-12-20 18:48:17 -0800 | [diff] [blame] | 419 | const sp<MmapStreamCallback>& callback, |
Eric Laurent | cb4dae2 | 2017-07-01 19:39:32 -0700 | [diff] [blame] | 420 | sp<MmapStreamInterface>& interface, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 421 | audio_port_handle_t *handle) EXCLUDES_AudioFlinger_Mutex; |
Glenn Kasten | 9e58b55 | 2013-01-18 15:09:48 -0800 | [diff] [blame] | 422 | private: |
Glenn Kasten | eef598c | 2017-04-03 14:41:13 -0700 | [diff] [blame] | 423 | // FIXME The 400 is temporarily too high until a leak of writers in media.log is fixed. |
| 424 | static const size_t kLogMemorySize = 400 * 1024; |
Glenn Kasten | 9e58b55 | 2013-01-18 15:09:48 -0800 | [diff] [blame] | 425 | sp<MemoryDealer> mLogMemoryDealer; // == 0 when NBLog is disabled |
Glenn Kasten | 481fb67 | 2013-09-30 14:39:28 -0700 | [diff] [blame] | 426 | // When a log writer is unregistered, it is done lazily so that media.log can continue to see it |
| 427 | // for as long as possible. The memory is only freed when it is needed for another log writer. |
| 428 | Vector< sp<NBLog::Writer> > mUnregisteredWriters; |
Andy Hung | 954b971 | 2023-08-28 18:36:53 -0700 | [diff] [blame] | 429 | audio_utils::mutex& unregisteredWritersMutex() const { return mUnregisteredWritersMutex; } |
Andy Hung | a6f1cbb | 2023-10-12 18:18:13 -0700 | [diff] [blame] | 430 | mutable audio_utils::mutex mUnregisteredWritersMutex{ |
| 431 | audio_utils::MutexOrder::kAudioFlinger_UnregisteredWritersMutex}; |
Eric Laurent | fc23520 | 2016-12-20 18:48:17 -0800 | [diff] [blame] | 432 | |
Mathias Agopian | e762be9 | 2013-05-09 16:26:45 -0700 | [diff] [blame] | 433 | AudioFlinger() ANDROID_API; |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 434 | ~AudioFlinger() override; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 435 | |
Glenn Kasten | 2b213bc | 2012-02-02 14:05:20 -0800 | [diff] [blame] | 436 | // call in any IAudioFlinger method that accesses mPrimaryHardwareDev |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 437 | status_t initCheck() const { return mPrimaryHardwareDev == NULL ? |
Glenn Kasten | 85ab62c | 2012-11-01 11:11:38 -0700 | [diff] [blame] | 438 | NO_INIT : NO_ERROR; } |
Glenn Kasten | 2b213bc | 2012-02-02 14:05:20 -0800 | [diff] [blame] | 439 | |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 440 | // RefBase |
Andy Hung | cdd80ef | 2023-07-17 11:37:26 -0700 | [diff] [blame] | 441 | void onFirstRef() override; |
Glenn Kasten | 000f0e3 | 2012-03-01 17:10:56 -0800 | [diff] [blame] | 442 | |
Glenn Kasten | 85ab62c | 2012-11-01 11:11:38 -0700 | [diff] [blame] | 443 | AudioHwDevice* findSuitableHwDev_l(audio_module_handle_t module, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 444 | audio_devices_t deviceType) REQUIRES(mutex()); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 445 | |
Andy Hung | 1d2d2aea | 2023-07-19 16:22:58 -0700 | [diff] [blame] | 446 | // incremented by 2 when screen state changes, bit 0 == 1 means "off" |
Andy Hung | 954b971 | 2023-08-28 18:36:53 -0700 | [diff] [blame] | 447 | // AudioFlinger::setParameters() updates with mutex(). |
Andy Hung | 1d2d2aea | 2023-07-19 16:22:58 -0700 | [diff] [blame] | 448 | std::atomic_uint32_t mScreenState{}; |
| 449 | |
Glenn Kasten | be5f05e | 2012-07-18 15:24:02 -0700 | [diff] [blame] | 450 | void dumpPermissionDenial(int fd, const Vector<String16>& args); |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 451 | void dumpClients_ll(int fd, const Vector<String16>& args) REQUIRES(mutex(), clientMutex()); |
| 452 | void dumpInternals_l(int fd, const Vector<String16>& args) REQUIRES(mutex()); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 453 | |
Andy Hung | dc099c2 | 2018-09-18 13:46:39 -0700 | [diff] [blame] | 454 | SimpleLog mThreadLog{16}; // 16 Thread history limit |
| 455 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 456 | void dumpToThreadLog_l(const sp<IAfThreadBase>& thread) REQUIRES(mutex()); |
Andy Hung | a8115dc | 2018-08-24 15:51:59 -0700 | [diff] [blame] | 457 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 458 | // --- Notification Client --- |
| 459 | class NotificationClient : public IBinder::DeathRecipient { |
| 460 | public: |
| 461 | NotificationClient(const sp<AudioFlinger>& audioFlinger, |
Ytai Ben-Tsvi | 10dc0a6 | 2020-09-18 11:31:55 -0700 | [diff] [blame] | 462 | const sp<media::IAudioFlingerClient>& client, |
Andy Hung | 5bdc535 | 2019-12-23 14:36:31 -0800 | [diff] [blame] | 463 | pid_t pid, |
| 464 | uid_t uid); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 465 | virtual ~NotificationClient(); |
| 466 | |
Ytai Ben-Tsvi | 10dc0a6 | 2020-09-18 11:31:55 -0700 | [diff] [blame] | 467 | sp<media::IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; } |
Andy Hung | 5bdc535 | 2019-12-23 14:36:31 -0800 | [diff] [blame] | 468 | pid_t getPid() const { return mPid; } |
| 469 | uid_t getUid() const { return mUid; } |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 470 | |
| 471 | // IBinder::DeathRecipient |
| 472 | virtual void binderDied(const wp<IBinder>& who); |
| 473 | |
| 474 | private: |
Mikhail Naganov | bf49308 | 2017-04-17 17:37:12 -0700 | [diff] [blame] | 475 | DISALLOW_COPY_AND_ASSIGN(NotificationClient); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 476 | |
Glenn Kasten | 84afa3b | 2012-01-25 15:28:08 -0800 | [diff] [blame] | 477 | const sp<AudioFlinger> mAudioFlinger; |
| 478 | const pid_t mPid; |
Andy Hung | 5bdc535 | 2019-12-23 14:36:31 -0800 | [diff] [blame] | 479 | const uid_t mUid; |
Ytai Ben-Tsvi | 10dc0a6 | 2020-09-18 11:31:55 -0700 | [diff] [blame] | 480 | const sp<media::IAudioFlingerClient> mAudioFlingerClient; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 481 | }; |
| 482 | |
Nicolas Roulet | dcdfaec | 2017-02-14 10:18:39 -0800 | [diff] [blame] | 483 | // --- MediaLogNotifier --- |
| 484 | // Thread in charge of notifying MediaLogService to start merging. |
| 485 | // Receives requests from AudioFlinger's binder activity. It is used to reduce the amount of |
| 486 | // binder calls to MediaLogService in case of bursts of AudioFlinger binder calls. |
| 487 | class MediaLogNotifier : public Thread { |
| 488 | public: |
| 489 | MediaLogNotifier(); |
| 490 | |
| 491 | // Requests a MediaLogService notification. It's ignored if there has recently been another |
| 492 | void requestMerge(); |
| 493 | private: |
| 494 | // Every iteration blocks waiting for a request, then interacts with MediaLogService to |
| 495 | // start merging. |
| 496 | // As every MediaLogService binder call is expensive, once it gets a request it ignores the |
| 497 | // following ones for a period of time. |
| 498 | virtual bool threadLoop() override; |
| 499 | |
| 500 | bool mPendingRequests; |
| 501 | |
| 502 | // Mutex and condition variable around mPendingRequests' value |
Andy Hung | a6f1cbb | 2023-10-12 18:18:13 -0700 | [diff] [blame] | 503 | audio_utils::mutex mMutex{audio_utils::MutexOrder::kMediaLogNotifier_Mutex}; |
Andy Hung | 954b971 | 2023-08-28 18:36:53 -0700 | [diff] [blame] | 504 | audio_utils::condition_variable mCondition; |
Nicolas Roulet | dcdfaec | 2017-02-14 10:18:39 -0800 | [diff] [blame] | 505 | |
| 506 | // Duration of the sleep period after a processed request |
| 507 | static const int kPostTriggerSleepPeriod = 1000000; |
| 508 | }; |
| 509 | |
Andy Hung | e374887 | 2023-08-30 19:05:16 -0700 | [diff] [blame] | 510 | const sp<MediaLogNotifier> mMediaLogNotifier = sp<MediaLogNotifier>::make(); |
Nicolas Roulet | dcdfaec | 2017-02-14 10:18:39 -0800 | [diff] [blame] | 511 | |
Andy Hung | e778c42 | 2019-03-14 15:04:30 -0700 | [diff] [blame] | 512 | // Find io handle by session id. |
| 513 | // Preference is given to an io handle with a matching effect chain to session id. |
| 514 | // If none found, AUDIO_IO_HANDLE_NONE is returned. |
| 515 | template <typename T> |
| 516 | static audio_io_handle_t findIoHandleBySessionId_l( |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 517 | audio_session_t sessionId, const T& threads) |
| 518 | REQUIRES(audio_utils::AudioFlinger_Mutex) { |
Andy Hung | e778c42 | 2019-03-14 15:04:30 -0700 | [diff] [blame] | 519 | audio_io_handle_t io = AUDIO_IO_HANDLE_NONE; |
| 520 | |
| 521 | for (size_t i = 0; i < threads.size(); i++) { |
| 522 | const uint32_t sessionType = threads.valueAt(i)->hasAudioSession(sessionId); |
| 523 | if (sessionType != 0) { |
| 524 | io = threads.keyAt(i); |
Andy Hung | 87c693c | 2023-07-06 20:56:16 -0700 | [diff] [blame] | 525 | if ((sessionType & IAfThreadBase::EFFECT_SESSION) != 0) { |
Andy Hung | e778c42 | 2019-03-14 15:04:30 -0700 | [diff] [blame] | 526 | break; // effect chain here. |
| 527 | } |
| 528 | } |
| 529 | } |
| 530 | return io; |
| 531 | } |
| 532 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 533 | IAfThreadBase* checkThread_l(audio_io_handle_t ioHandle) const REQUIRES(mutex()); |
| 534 | IAfPlaybackThread* checkMixerThread_l(audio_io_handle_t output) const REQUIRES(mutex()); |
Andy Hung | 2dc61c4 | 2023-07-17 14:36:08 -0700 | [diff] [blame] | 535 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 536 | sp<VolumeInterface> getVolumeInterface_l(audio_io_handle_t output) const REQUIRES(mutex()); |
| 537 | std::vector<sp<VolumeInterface>> getAllVolumeInterfaces_l() const REQUIRES(mutex()); |
Eric Laurent | 6acd1d4 | 2017-01-04 14:23:29 -0800 | [diff] [blame] | 538 | |
Eric Laurent | 83b8808 | 2014-06-20 18:31:16 -0700 | [diff] [blame] | 539 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 540 | static void closeOutputFinish(const sp<IAfPlaybackThread>& thread); |
Andy Hung | 87c693c | 2023-07-06 20:56:16 -0700 | [diff] [blame] | 541 | void closeInputFinish(const sp<IAfRecordThread>& thread); |
Eric Laurent | 83b8808 | 2014-06-20 18:31:16 -0700 | [diff] [blame] | 542 | |
Glenn Kasten | eeecb98 | 2016-02-26 10:44:04 -0800 | [diff] [blame] | 543 | // Allocate an audio_unique_id_t. |
| 544 | // Specific types are audio_io_handle_t, audio_session_t, effect ID (int), |
| 545 | // audio_module_handle_t, and audio_patch_handle_t. |
Glenn Kasten | bcefec3 | 2014-01-17 12:09:05 -0800 | [diff] [blame] | 546 | // They all share the same ID space, but the namespaces are actually independent |
| 547 | // because there are separate KeyedVectors for each kind of ID. |
Glenn Kasten | eeecb98 | 2016-02-26 10:44:04 -0800 | [diff] [blame] | 548 | // The return value is cast to the specific type depending on how the ID will be used. |
Glenn Kasten | bcefec3 | 2014-01-17 12:09:05 -0800 | [diff] [blame] | 549 | // FIXME This API does not handle rollover to zero (for unsigned IDs), |
| 550 | // or from positive to negative (for signed IDs). |
| 551 | // Thus it may fail by returning an ID of the wrong sign, |
| 552 | // or by returning a non-unique ID. |
Glenn Kasten | 9d00313 | 2016-04-06 14:38:09 -0700 | [diff] [blame] | 553 | // This is the internal API. For the binder API see newAudioUniqueId(). |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 554 | // used by IAfDeviceEffectManagerCallback, IAfPatchPanelCallback, IAfThreadCallback |
Andy Hung | 692f045 | 2023-07-17 13:45:55 -0700 | [diff] [blame] | 555 | audio_unique_id_t nextUniqueId(audio_unique_id_use_t use) final; |
Glenn Kasten | 72ef00d | 2012-01-17 11:09:42 -0800 | [diff] [blame] | 556 | |
Andy Hung | 972bec1 | 2023-08-31 16:13:39 -0700 | [diff] [blame] | 557 | status_t moveEffectChain_ll(audio_session_t sessionId, |
| 558 | IAfRecordThread* srcThread, IAfRecordThread* dstThread) |
| 559 | REQUIRES(mutex(), audio_utils::ThreadBase_Mutex); |
Eric Laurent | 6c79632 | 2019-04-09 14:13:17 -0700 | [diff] [blame] | 560 | |
Glenn Kasten | 02fe1bf | 2012-02-24 15:42:17 -0800 | [diff] [blame] | 561 | // return thread associated with primary hardware device, or NULL |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 562 | DeviceTypeSet primaryOutputDevice_l() const REQUIRES(mutex()); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 563 | |
Glenn Kasten | a733563 | 2016-06-09 17:09:53 -0700 | [diff] [blame] | 564 | // return the playback thread with smallest HAL buffer size, and prefer fast |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 565 | IAfPlaybackThread* fastPlaybackThread_l() const REQUIRES(mutex()); |
Glenn Kasten | a733563 | 2016-06-09 17:09:53 -0700 | [diff] [blame] | 566 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 567 | sp<IAfThreadBase> getEffectThread_l(audio_session_t sessionId, int effectId) |
| 568 | REQUIRES(mutex()); |
Eric Laurent | 717e128 | 2012-06-29 16:36:52 -0700 | [diff] [blame] | 569 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 570 | IAfThreadBase* hapticPlaybackThread_l() const REQUIRES(mutex()); |
jiabin | eb3bda0 | 2020-06-30 14:07:03 -0700 | [diff] [blame] | 571 | |
jiabin | f042b9b | 2021-05-07 23:46:28 +0000 | [diff] [blame] | 572 | void updateSecondaryOutputsForTrack_l( |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 573 | IAfTrack* track, |
Andy Hung | 87c693c | 2023-07-06 20:56:16 -0700 | [diff] [blame] | 574 | IAfPlaybackThread* thread, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 575 | const std::vector<audio_io_handle_t>& secondaryOutputs) const REQUIRES(mutex()); |
jiabin | f042b9b | 2021-05-07 23:46:28 +0000 | [diff] [blame] | 576 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 577 | bool isSessionAcquired_l(audio_session_t audioSession) REQUIRES(mutex()); |
Eric Laurent | 813e2a7 | 2013-08-31 12:59:48 -0700 | [diff] [blame] | 578 | |
Eric Laurent | aaa4447 | 2014-09-12 17:41:50 -0700 | [diff] [blame] | 579 | // Store an effect chain to mOrphanEffectChains keyed vector. |
| 580 | // Called when a thread exits and effects are still attached to it. |
| 581 | // If effects are later created on the same session, they will reuse the same |
| 582 | // effect chain and same instances in the effect library. |
| 583 | // return ALREADY_EXISTS if a chain with the same session already exists in |
| 584 | // mOrphanEffectChains. Note that this should never happen as there is only one |
| 585 | // chain for a given session and it is attached to only one thread at a time. |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 586 | status_t putOrphanEffectChain_l(const sp<IAfEffectChain>& chain) REQUIRES(mutex()); |
Eric Laurent | aaa4447 | 2014-09-12 17:41:50 -0700 | [diff] [blame] | 587 | // Get an effect chain for the specified session in mOrphanEffectChains and remove |
| 588 | // it if found. Returns 0 if not found (this is the most common case). |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 589 | sp<IAfEffectChain> getOrphanEffectChain_l(audio_session_t session) REQUIRES(mutex()); |
Andy Hung | 583043b | 2023-07-17 17:05:00 -0700 | [diff] [blame] | 590 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 591 | std::vector< sp<IAfEffectModule> > purgeStaleEffects_l() REQUIRES(mutex()); |
Eric Laurent | 6c79632 | 2019-04-09 14:13:17 -0700 | [diff] [blame] | 592 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 593 | std::vector< sp<IAfEffectModule> > purgeOrphanEffectChains_l() REQUIRES(mutex()); |
| 594 | bool updateOrphanEffectChains_l(const sp<IAfEffectModule>& effect) REQUIRES(mutex()); |
François Gaffie | 1b4753e | 2023-02-06 10:36:33 +0100 | [diff] [blame] | 595 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 596 | void broadcastParametersToRecordThreads_l(const String8& keyValuePairs) REQUIRES(mutex()); |
| 597 | void forwardParametersToDownstreamPatches_l( |
Mikhail Naganov | b261ef5 | 2018-07-16 13:34:38 -0700 | [diff] [blame] | 598 | audio_io_handle_t upStream, const String8& keyValuePairs, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 599 | const std::function<bool(const sp<IAfPlaybackThread>&)>& useThread = nullptr) |
| 600 | REQUIRES(mutex()); |
John Grossman | ee578c0 | 2012-07-23 17:05:46 -0700 | [diff] [blame] | 601 | |
Glenn Kasten | 99e53b8 | 2012-01-19 08:59:58 -0800 | [diff] [blame] | 602 | // for mAudioSessionRefs only |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 603 | struct AudioSessionRef { |
Andy Hung | 8b0bfd9 | 2019-12-23 13:11:11 -0800 | [diff] [blame] | 604 | AudioSessionRef(audio_session_t sessionid, pid_t pid, uid_t uid) : |
| 605 | mSessionid(sessionid), mPid(pid), mUid(uid), mCnt(1) {} |
Glenn Kasten | d848eb4 | 2016-03-08 13:42:11 -0800 | [diff] [blame] | 606 | const audio_session_t mSessionid; |
Glenn Kasten | 012ca6b | 2012-03-06 11:22:01 -0800 | [diff] [blame] | 607 | const pid_t mPid; |
Andy Hung | 8b0bfd9 | 2019-12-23 13:11:11 -0800 | [diff] [blame] | 608 | const uid_t mUid; |
Glenn Kasten | 012ca6b | 2012-03-06 11:22:01 -0800 | [diff] [blame] | 609 | int mCnt; |
Marco Nelissen | 3a34bef | 2011-08-02 13:33:41 -0700 | [diff] [blame] | 610 | }; |
| 611 | |
Andy Hung | a6f1cbb | 2023-10-12 18:18:13 -0700 | [diff] [blame] | 612 | mutable audio_utils::mutex mMutex{audio_utils::MutexOrder::kAudioFlinger_Mutex}; |
Eric Laurent | 021cf96 | 2014-05-13 10:18:14 -0700 | [diff] [blame] | 613 | // protects mClients and mNotificationClients. |
Andy Hung | 954b971 | 2023-08-28 18:36:53 -0700 | [diff] [blame] | 614 | // must be locked after mutex() and ThreadBase::mutex() if both must be locked |
| 615 | // avoids acquiring AudioFlinger::mutex() from inside thread loop. |
Andy Hung | 8d31fd2 | 2023-06-26 19:20:57 -0700 | [diff] [blame] | 616 | |
Andy Hung | a6f1cbb | 2023-10-12 18:18:13 -0700 | [diff] [blame] | 617 | mutable audio_utils::mutex mClientMutex{audio_utils::MutexOrder::kAudioFlinger_ClientMutex}; |
Andy Hung | 47c0117 | 2023-07-17 12:40:43 -0700 | [diff] [blame] | 618 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 619 | DefaultKeyedVector<pid_t, wp<Client>> mClients GUARDED_BY(clientMutex()); // see ~Client() |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 620 | |
Andy Hung | 954b971 | 2023-08-28 18:36:53 -0700 | [diff] [blame] | 621 | audio_utils::mutex& hardwareMutex() const { return mHardwareMutex; } |
| 622 | |
Andy Hung | a6f1cbb | 2023-10-12 18:18:13 -0700 | [diff] [blame] | 623 | mutable audio_utils::mutex mHardwareMutex{ |
| 624 | audio_utils::MutexOrder::kAudioFlinger_HardwareMutex}; |
Andy Hung | 954b971 | 2023-08-28 18:36:53 -0700 | [diff] [blame] | 625 | // NOTE: If both mMutex and mHardwareMutex mutexes must be held, |
| 626 | // always take mMutex before mHardwareMutex |
Glenn Kasten | 2b213bc | 2012-02-02 14:05:20 -0800 | [diff] [blame] | 627 | |
Andy Hung | e374887 | 2023-08-30 19:05:16 -0700 | [diff] [blame] | 628 | std::atomic<AudioHwDevice*> mPrimaryHardwareDev = nullptr; |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 629 | DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*> mAudioHwDevs |
| 630 | GUARDED_BY(hardwareMutex()) {nullptr /* defValue */}; |
Glenn Kasten | 2f732eb | 2012-01-26 09:48:03 -0800 | [diff] [blame] | 631 | |
Oleg Lyovin | 7434b72 | 2024-03-05 18:08:01 +0300 | [diff] [blame^] | 632 | static bool inputBufferSizeDevsCmp(const AudioHwDevice* lhs, const AudioHwDevice* rhs); |
| 633 | std::set<AudioHwDevice*, decltype(&inputBufferSizeDevsCmp)> |
| 634 | mInputBufferSizeOrderedDevs GUARDED_BY(hardwareMutex()) {inputBufferSizeDevsCmp}; |
| 635 | |
Andy Hung | e374887 | 2023-08-30 19:05:16 -0700 | [diff] [blame] | 636 | const sp<DevicesFactoryHalInterface> mDevicesFactoryHal = |
| 637 | DevicesFactoryHalInterface::create(); |
| 638 | /* const */ sp<DevicesFactoryHalCallback> mDevicesFactoryHalCallback; // set onFirstRef(). |
Mikhail Naganov | e4f1f63 | 2016-08-31 11:35:10 -0700 | [diff] [blame] | 639 | |
Glenn Kasten | 8abf44d | 2012-02-02 14:16:03 -0800 | [diff] [blame] | 640 | // for dump, indicates which hardware operation is currently in progress (but not stream ops) |
Glenn Kasten | 2f732eb | 2012-01-26 09:48:03 -0800 | [diff] [blame] | 641 | enum hardware_call_state { |
Glenn Kasten | 8abf44d | 2012-02-02 14:16:03 -0800 | [diff] [blame] | 642 | AUDIO_HW_IDLE = 0, // no operation in progress |
| 643 | AUDIO_HW_INIT, // init_check |
| 644 | AUDIO_HW_OUTPUT_OPEN, // open_output_stream |
| 645 | AUDIO_HW_OUTPUT_CLOSE, // unused |
| 646 | AUDIO_HW_INPUT_OPEN, // unused |
| 647 | AUDIO_HW_INPUT_CLOSE, // unused |
| 648 | AUDIO_HW_STANDBY, // unused |
| 649 | AUDIO_HW_SET_MASTER_VOLUME, // set_master_volume |
| 650 | AUDIO_HW_GET_ROUTING, // unused |
| 651 | AUDIO_HW_SET_ROUTING, // unused |
| 652 | AUDIO_HW_GET_MODE, // unused |
| 653 | AUDIO_HW_SET_MODE, // set_mode |
| 654 | AUDIO_HW_GET_MIC_MUTE, // get_mic_mute |
| 655 | AUDIO_HW_SET_MIC_MUTE, // set_mic_mute |
| 656 | AUDIO_HW_SET_VOICE_VOLUME, // set_voice_volume |
| 657 | AUDIO_HW_SET_PARAMETER, // set_parameters |
| 658 | AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size |
| 659 | AUDIO_HW_GET_MASTER_VOLUME, // get_master_volume |
| 660 | AUDIO_HW_GET_PARAMETER, // get_parameters |
John Grossman | d8f178d | 2012-07-20 14:51:35 -0700 | [diff] [blame] | 661 | AUDIO_HW_SET_MASTER_MUTE, // set_master_mute |
| 662 | AUDIO_HW_GET_MASTER_MUTE, // get_master_mute |
Eric Laurent | 00abf0d | 2020-04-22 19:28:22 -0700 | [diff] [blame] | 663 | AUDIO_HW_GET_MICROPHONES, // getMicrophones |
Mikhail Naganov | 516d398 | 2022-02-01 23:53:59 +0000 | [diff] [blame] | 664 | AUDIO_HW_SET_CONNECTED_STATE, // setConnectedState |
Mikhail Naganov | b1ddbb0 | 2023-03-15 17:06:59 -0700 | [diff] [blame] | 665 | AUDIO_HW_SET_SIMULATE_CONNECTIONS, // setSimulateDeviceConnections |
Glenn Kasten | 2f732eb | 2012-01-26 09:48:03 -0800 | [diff] [blame] | 666 | }; |
| 667 | |
Andy Hung | e374887 | 2023-08-30 19:05:16 -0700 | [diff] [blame] | 668 | mutable hardware_call_state mHardwareStatus = AUDIO_HW_IDLE; // for dump only |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 669 | DefaultKeyedVector<audio_io_handle_t, sp<IAfPlaybackThread>> mPlaybackThreads |
| 670 | GUARDED_BY(mutex()); |
| 671 | stream_type_t mStreamTypes[AUDIO_STREAM_CNT] GUARDED_BY(mutex()); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 672 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 673 | float mMasterVolume GUARDED_BY(mutex()) = 1.f; |
| 674 | bool mMasterMute GUARDED_BY(mutex()) = false; |
| 675 | float mMasterBalance GUARDED_BY(mutex()) = 0.f; |
Glenn Kasten | 9806710 | 2011-12-13 11:47:54 -0800 | [diff] [blame] | 676 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 677 | DefaultKeyedVector<audio_io_handle_t, sp<IAfRecordThread>> mRecordThreads GUARDED_BY(mutex()); |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 678 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 679 | DefaultKeyedVector<pid_t, sp<NotificationClient>> mNotificationClients |
| 680 | GUARDED_BY(clientMutex()); |
Glenn Kasten | bcefec3 | 2014-01-17 12:09:05 -0800 | [diff] [blame] | 681 | |
Glenn Kasten | d2e67e1 | 2016-04-11 08:26:37 -0700 | [diff] [blame] | 682 | // updated by atomic_fetch_add_explicit |
Andy Hung | e374887 | 2023-08-30 19:05:16 -0700 | [diff] [blame] | 683 | volatile atomic_uint_fast32_t mNextUniqueIds[AUDIO_UNIQUE_ID_USE_MAX]; // ctor init |
Glenn Kasten | bcefec3 | 2014-01-17 12:09:05 -0800 | [diff] [blame] | 684 | |
Andy Hung | e374887 | 2023-08-30 19:05:16 -0700 | [diff] [blame] | 685 | std::atomic<audio_mode_t> mMode = AUDIO_MODE_INVALID; |
| 686 | std::atomic<bool> mBtNrecIsOff = false; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 687 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 688 | Vector<AudioSessionRef*> mAudioSessionRefs GUARDED_BY(mutex()); |
Glenn Kasten | 9806710 | 2011-12-13 11:47:54 -0800 | [diff] [blame] | 689 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 690 | AudioHwDevice* loadHwModule_ll(const char *name) REQUIRES(mutex(), hardwareMutex()); |
Glenn Kasten | 98ec94c | 2012-01-25 14:28:29 -0800 | [diff] [blame] | 691 | |
Andy Hung | 068e08e | 2023-05-15 19:02:55 -0700 | [diff] [blame] | 692 | // sync events awaiting for a session to be created. |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 693 | std::list<sp<audioflinger::SyncEvent>> mPendingSyncEvents GUARDED_BY(mutex()); |
Eric Laurent | a011e35 | 2012-03-29 15:51:43 -0700 | [diff] [blame] | 694 | |
Eric Laurent | aaa4447 | 2014-09-12 17:41:50 -0700 | [diff] [blame] | 695 | // Effect chains without a valid thread |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 696 | DefaultKeyedVector<audio_session_t, sp<IAfEffectChain>> mOrphanEffectChains |
| 697 | GUARDED_BY(mutex()); |
Eric Laurent | aaa4447 | 2014-09-12 17:41:50 -0700 | [diff] [blame] | 698 | |
Eric Laurent | fa90e84 | 2014-10-17 18:12:31 -0700 | [diff] [blame] | 699 | // list of sessions for which a valid HW A/V sync ID was retrieved from the HAL |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 700 | DefaultKeyedVector<audio_session_t, audio_hw_sync_t> mHwAvSyncIds GUARDED_BY(mutex()); |
Eric Laurent | 6acd1d4 | 2017-01-04 14:23:29 -0800 | [diff] [blame] | 701 | |
| 702 | // list of MMAP stream control threads. Those threads allow for wake lock, routing |
| 703 | // and volume control for activity on the associated MMAP stream at the HAL. |
| 704 | // Audio data transfer is directly handled by the client creating the MMAP stream |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 705 | DefaultKeyedVector<audio_io_handle_t, sp<IAfMmapThread>> mMmapThreads GUARDED_BY(mutex()); |
Eric Laurent | 6acd1d4 | 2017-01-04 14:23:29 -0800 | [diff] [blame] | 706 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 707 | sp<Client> registerPid(pid_t pid) EXCLUDES_AudioFlinger_ClientMutex; // always returns non-0 |
Glenn Kasten | 98ec94c | 2012-01-25 14:28:29 -0800 | [diff] [blame] | 708 | |
Glenn Kasten | d96c572 | 2012-04-25 13:44:49 -0700 | [diff] [blame] | 709 | // for use from destructor |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 710 | status_t closeOutput_nonvirtual(audio_io_handle_t output) EXCLUDES_AudioFlinger_Mutex; |
| 711 | status_t closeInput_nonvirtual(audio_io_handle_t input) EXCLUDES_AudioFlinger_Mutex; |
| 712 | void setAudioHwSyncForSession_l(IAfPlaybackThread* thread, audio_session_t sessionId) |
| 713 | REQUIRES(mutex()); |
Glenn Kasten | d06785b | 2012-09-30 12:29:28 -0700 | [diff] [blame] | 714 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 715 | static status_t checkStreamType(audio_stream_type_t stream); |
Eric Laurent | 223fd5c | 2014-11-11 13:43:36 -0800 | [diff] [blame] | 716 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 717 | // no mutex needed. |
Eric Laurent | f1047e8 | 2018-04-16 19:18:20 -0700 | [diff] [blame] | 718 | void filterReservedParameters(String8& keyValuePairs, uid_t callingUid); |
Kevin Rocard | a0a5d2a | 2018-08-06 15:03:18 -0700 | [diff] [blame] | 719 | void logFilteredParameters(size_t originalKVPSize, const String8& originalKVPs, |
| 720 | size_t rejectedKVPSize, const String8& rejectedKVPs, |
| 721 | uid_t callingUid); |
Eric Laurent | f1047e8 | 2018-04-16 19:18:20 -0700 | [diff] [blame] | 722 | |
Andy Hung | 6f248bb | 2018-01-23 14:04:37 -0800 | [diff] [blame] | 723 | // These methods read variables atomically without mLock, |
| 724 | // though the variables are updated with mLock. |
Andy Hung | 6f248bb | 2018-01-23 14:04:37 -0800 | [diff] [blame] | 725 | size_t getClientSharedHeapSize() const; |
Glenn Kasten | 4182c4e | 2013-07-15 14:45:07 -0700 | [diff] [blame] | 726 | |
Andy Hung | e374887 | 2023-08-30 19:05:16 -0700 | [diff] [blame] | 727 | std::atomic<bool> mIsLowRamDevice = true; |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 728 | bool mIsDeviceTypeKnown GUARDED_BY(mutex()) = false; |
| 729 | int64_t mTotalMemory GUARDED_BY(mutex()) = 0; |
Andy Hung | e374887 | 2023-08-30 19:05:16 -0700 | [diff] [blame] | 730 | std::atomic<size_t> mClientSharedHeapSize = kMinimumClientSharedHeapSizeBytes; |
Andy Hung | 6f248bb | 2018-01-23 14:04:37 -0800 | [diff] [blame] | 731 | static constexpr size_t kMinimumClientSharedHeapSizeBytes = 1024 * 1024; // 1MB |
| 732 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 733 | // when a global effect was last enabled |
| 734 | nsecs_t mGlobalEffectEnableTime GUARDED_BY(mutex()) = 0; |
Eric Laurent | 1c333e2 | 2014-05-20 10:48:17 -0700 | [diff] [blame] | 735 | |
Andy Hung | 2dc61c4 | 2023-07-17 14:36:08 -0700 | [diff] [blame] | 736 | /* const */ sp<IAfPatchPanel> mPatchPanel; |
Andy Hung | b6692eb | 2023-07-13 16:52:46 -0700 | [diff] [blame] | 737 | |
Andy Hung | e374887 | 2023-08-30 19:05:16 -0700 | [diff] [blame] | 738 | const sp<EffectsFactoryHalInterface> mEffectsFactoryHal = |
| 739 | audioflinger::EffectConfiguration::getEffectsFactoryHal(); |
Glenn Kasten | 4ea00a2 | 2014-06-02 08:29:22 -0700 | [diff] [blame] | 740 | |
Andy Hung | e374887 | 2023-08-30 19:05:16 -0700 | [diff] [blame] | 741 | const sp<PatchCommandThread> mPatchCommandThread = sp<PatchCommandThread>::make(); |
Andy Hung | 692f045 | 2023-07-17 13:45:55 -0700 | [diff] [blame] | 742 | /* const */ sp<DeviceEffectManager> mDeviceEffectManager; // set onFirstRef |
Andy Hung | b60a2c8 | 2023-07-17 14:02:52 -0700 | [diff] [blame] | 743 | /* const */ sp<MelReporter> mMelReporter; // set onFirstRef |
Eric Laurent | b82e6b7 | 2019-11-22 17:25:04 -0800 | [diff] [blame] | 744 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 745 | bool mSystemReady GUARDED_BY(mutex()) = false; |
Andy Hung | e374887 | 2023-08-30 19:05:16 -0700 | [diff] [blame] | 746 | std::atomic<bool> mAudioPolicyReady = false; |
Kevin Rocard | a0a5d2a | 2018-08-06 15:03:18 -0700 | [diff] [blame] | 747 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 748 | mediautils::UidInfo mUidInfo GUARDED_BY(mutex()); |
Andy Hung | 5bdc535 | 2019-12-23 14:36:31 -0800 | [diff] [blame] | 749 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 750 | // no mutex needed. |
Kevin Rocard | a0a5d2a | 2018-08-06 15:03:18 -0700 | [diff] [blame] | 751 | SimpleLog mRejectedSetParameterLog; |
| 752 | SimpleLog mAppSetParameterLog; |
| 753 | SimpleLog mSystemSetParameterLog; |
Andy Hung | b68f5eb | 2019-12-03 16:49:17 -0800 | [diff] [blame] | 754 | |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 755 | std::vector<media::AudioVibratorInfo> mAudioVibratorInfos GUARDED_BY(mutex()); |
jiabin | 1319f5a | 2021-03-30 22:21:24 +0000 | [diff] [blame] | 756 | |
Andy Hung | b68f5eb | 2019-12-03 16:49:17 -0800 | [diff] [blame] | 757 | static inline constexpr const char *mMetricsId = AMEDIAMETRICS_KEY_AUDIO_FLINGER; |
Eric Laurent | ec376dc | 2021-04-08 20:41:22 +0200 | [diff] [blame] | 758 | |
jiabin | e99d088 | 2021-09-17 05:21:25 +0000 | [diff] [blame] | 759 | std::map<media::audio::common::AudioMMapPolicyType, |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 760 | std::vector<media::audio::common::AudioMMapPolicyInfo>> mPolicyInfos |
| 761 | GUARDED_BY(mutex()); |
| 762 | int32_t mAAudioBurstsPerBuffer GUARDED_BY(mutex()) = 0; |
| 763 | int32_t mAAudioHwBurstMinMicros GUARDED_BY(mutex()) = 0; |
Vlad Popa | e8d9947 | 2022-06-30 16:02:48 +0200 | [diff] [blame] | 764 | |
| 765 | /** Interface for interacting with the AudioService. */ |
Andy Hung | c2cf7ec | 2023-08-30 18:19:00 -0700 | [diff] [blame] | 766 | mediautils::atomic_sp<IAudioManager> mAudioManager; |
Eric Laurent | 5205764 | 2022-12-16 11:45:07 +0100 | [diff] [blame] | 767 | |
| 768 | // Bluetooth Variable latency control logic is enabled or disabled |
Andy Hung | e374887 | 2023-08-30 19:05:16 -0700 | [diff] [blame] | 769 | std::atomic<bool> mBluetoothLatencyModesEnabled = true; |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 770 | }; |
| 771 | |
Mathias Agopian | 65ab471 | 2010-07-14 17:59:35 -0700 | [diff] [blame] | 772 | // ---------------------------------------------------------------------------- |
| 773 | |
Glenn Kasten | 63238ef | 2015-03-02 15:50:29 -0800 | [diff] [blame] | 774 | } // namespace android |