blob: 077fa26e25518a347ad3d1e1857ff4bb2ea937ba [file] [log] [blame]
Glenn Kasten99e53b82012-01-19 08:59:58 -08001/*
Mathias Agopian65ab4712010-07-14 17:59:35 -07002**
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
18#ifndef ANDROID_AUDIO_FLINGER_H
19#define ANDROID_AUDIO_FLINGER_H
20
Glenn Kasten5b17c0b2014-05-13 10:55:33 -070021#include "Configuration.h"
Kevin Rocard12381092018-04-11 09:19:59 -070022#include <atomic>
23#include <mutex>
Kevin Rocard45986c72018-12-18 18:22:59 -080024#include <chrono>
Andy Hung2148bf02016-11-28 19:01:02 -080025#include <deque>
Andy Hungdae27702016-10-31 14:01:16 -070026#include <map>
Kevin Rocard153f92d2018-12-18 18:33:28 -080027#include <numeric>
Kevin Rocard45986c72018-12-18 18:22:59 -080028#include <optional>
Eric Tan5786e012018-08-15 09:03:47 -070029#include <set>
Eric Tan7b651152018-07-13 10:17:19 -070030#include <string>
Kevin Rocard12381092018-04-11 09:19:59 -070031#include <vector>
Mathias Agopian65ab4712010-07-14 17:59:35 -070032#include <stdint.h>
33#include <sys/types.h>
34#include <limits.h>
35
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -080036#include <android/media/BnAudioTrack.h>
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -070037#include <android/media/IAudioFlingerClient.h>
jiabinf6eb4c32020-02-25 14:06:25 -080038#include <android/media/IAudioTrackCallback.h>
jiabin57303cc2018-12-18 15:45:57 -080039#include <android/os/BnExternalVibrationController.h>
Svet Ganov33761132021-05-13 22:51:08 +000040#include <android/content/AttributionSourceState.h>
41
Mikhail Naganovbf493082017-04-17 17:37:12 -070042
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -070043#include <android-base/macros.h>
Steven Morelandf0c02ce2018-02-23 14:53:55 -080044#include <cutils/atomic.h>
Mathias Agopiane762be92013-05-09 16:26:45 -070045#include <cutils/compiler.h>
46
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -070047#include <cutils/properties.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070048#include <media/IAudioFlinger.h>
Glenn Kasten335787f2012-01-20 17:00:00 -080049#include <media/AudioSystem.h>
John Grossman4ff14ba2012-02-08 16:37:41 -080050#include <media/AudioTrack.h>
Eric Laurentfc235202016-12-20 18:48:17 -080051#include <media/MmapStreamInterface.h>
52#include <media/MmapStreamCallback.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070053
Mathias Agopian65ab4712010-07-14 17:59:35 -070054#include <utils/Errors.h>
55#include <utils/threads.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070056#include <utils/SortedVector.h>
Dima Zavin799a70e2011-04-18 16:57:27 -070057#include <utils/TypeHelpers.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070058#include <utils/Vector.h>
59
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080060#include <binder/AppOpsManager.h>
Mathias Agopian5462fc92010-07-14 18:41:18 -070061#include <binder/BinderService.h>
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080062#include <binder/IAppOpsCallback.h>
Mathias Agopian5462fc92010-07-14 18:41:18 -070063#include <binder/MemoryDealer.h>
64
Dima Zavin64760242011-05-11 14:15:23 -070065#include <system/audio.h>
Mikhail Naganov61a4fac2016-10-13 14:44:18 -070066#include <system/audio_policy.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070067
Mikhail Naganov022b9952017-01-04 16:36:51 -080068#include <media/audiohal/EffectBufferHalInterface.h>
Mikhail Naganova0c91332016-09-19 10:01:12 -070069#include <media/audiohal/StreamHalInterface.h>
Glenn Kasten2dd4bdd2012-08-29 11:10:32 -070070#include <media/AudioBufferProvider.h>
jiabinc52b1ff2019-10-31 17:20:42 -070071#include <media/AudioContainers.h>
72#include <media/AudioDeviceTypeAddr.h>
Andy Hung068561c2017-01-03 17:09:32 -080073#include <media/AudioMixer.h>
jiabinc52b1ff2019-10-31 17:20:42 -070074#include <media/DeviceDescriptorBase.h>
Glenn Kasten2dd4bdd2012-08-29 11:10:32 -070075#include <media/ExtendedAudioBufferProvider.h>
Andy Hung9fc8b5c2017-01-24 13:36:48 -080076#include <media/VolumeShaper.h>
Andy Hung5bdc5352019-12-23 14:36:31 -080077#include <mediautils/ServiceUtilities.h>
Atneya3c61d882021-09-20 14:52:15 -040078#include <mediautils/SharedMemoryAllocator.h>
Andy Hung328d6772021-01-12 12:32:21 -080079#include <mediautils/Synchronization.h>
Andy Hung44d648b2022-04-08 17:33:40 -070080#include <mediautils/ThreadSnapshot.h>
Glenn Kasten6dbb5e32014-05-13 10:38:42 -070081
Andy Hungf3234512018-07-03 14:51:47 -070082#include <audio_utils/clock.h>
Andy Hungdc099c22018-09-18 13:46:39 -070083#include <audio_utils/FdToString.h>
jiabin63e2c522019-10-22 16:48:20 -070084#include <audio_utils/LinearMap.h>
Vlad Popab042ee62022-10-20 18:05:00 +020085#include <audio_utils/MelAggregator.h>
86#include <audio_utils/MelProcessor.h>
Andy Hung293558a2017-03-21 12:19:20 -070087#include <audio_utils/SimpleLog.h>
Andy Hung2e2c0bb2018-06-11 19:13:11 -070088#include <audio_utils/TimestampVerifier.h>
Andy Hung293558a2017-03-21 12:19:20 -070089
Vlad Popa2900c0a2022-10-24 13:38:00 +020090#include <sounddose/SoundDoseManager.h>
Andy Hung398ffa22022-12-13 19:19:53 -080091#include <timing/MonotonicFrameCounter.h>
Vlad Popa2900c0a2022-10-24 13:38:00 +020092
Glenn Kasten6dbb5e32014-05-13 10:38:42 -070093#include "FastCapture.h"
Glenn Kasten58912562012-04-03 10:45:00 -070094#include "FastMixer.h"
Glenn Kasten2dd4bdd2012-08-29 11:10:32 -070095#include <media/nbaio/NBAIO.h>
Glenn Kastenc15d6652012-05-30 14:52:57 -070096#include "AudioWatchdog.h"
Phil Burk062e67a2015-02-11 13:40:50 -080097#include "AudioStreamOut.h"
98#include "SpdifStreamOut.h"
99#include "AudioHwDevice.h"
Andy Hung8946a282018-04-19 20:04:56 -0700100#include "NBAIO_Tee.h"
Andy Hungcf10d742020-04-28 15:38:24 -0700101#include "ThreadMetrics.h"
Andy Hungc2b11cb2020-04-22 09:04:01 -0700102#include "TrackMetrics.h"
Atneya3c61d882021-09-20 14:52:15 -0400103#include "AllocatorFactory.h"
Chris Ye6597d732020-02-28 22:38:25 -0800104#include <android/os/IPowerManager.h>
Eric Laurentfeb0db62011-07-22 09:04:31 -0700105
Glenn Kasten8589ce72017-09-08 17:03:42 -0700106#include <media/nblog/NBLog.h>
Glenn Kasten444841f2016-12-16 15:36:43 -0800107#include <private/media/AudioEffectShared.h>
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800108#include <private/media/AudioTrackShared.h>
Glenn Kasten9e58b552013-01-18 15:09:48 -0800109
jiabin57303cc2018-12-18 15:45:57 -0800110#include <vibrator/ExternalVibration.h>
jiabine70bc7f2020-06-30 22:07:55 -0700111#include <vibrator/ExternalVibrationUtils.h>
jiabin57303cc2018-12-18 15:45:57 -0800112
Ivan Lozanoff6900d2017-08-01 15:47:38 -0700113#include "android/media/BnAudioRecord.h"
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700114#include "android/media/BnEffect.h"
Ivan Lozanoff6900d2017-08-01 15:47:38 -0700115
Mathias Agopian65ab4712010-07-14 17:59:35 -0700116namespace android {
117
Mathias Agopian65ab4712010-07-14 17:59:35 -0700118class AudioMixer;
119class AudioBuffer;
120class AudioResampler;
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700121class DeviceHalInterface;
Mikhail Naganov88b30d22020-03-09 19:43:13 +0000122class DevicesFactoryHalCallback;
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700123class DevicesFactoryHalInterface;
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700124class EffectsFactoryHalInterface;
Glenn Kasten58912562012-04-03 10:45:00 -0700125class FastMixer;
Vlad Popae8d99472022-06-30 16:02:48 +0200126class IAudioManager;
Andy Hungd330ee42015-04-20 13:23:41 -0700127class PassthruBufferProvider;
Andy Hung89816052017-01-11 17:08:23 -0800128class RecordBufferConverter;
Glenn Kastene3aa6592012-12-04 12:22:46 -0800129class ServerProxy;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700130
Mathias Agopian65ab4712010-07-14 17:59:35 -0700131// ----------------------------------------------------------------------------
132
John Grossman4ff14ba2012-02-08 16:37:41 -0800133static const nsecs_t kDefaultStandbyTimeInNsecs = seconds(3);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700134
Eric Laurent81784c32012-11-19 14:55:58 -0800135#define INCLUDING_FROM_AUDIOFLINGER_H
136
Svet Ganov33761132021-05-13 22:51:08 +0000137using android::content::AttributionSourceState;
138
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800139class AudioFlinger : public AudioFlingerServerAdapter::Delegate
Mathias Agopian65ab4712010-07-14 17:59:35 -0700140{
Andy Hung1d312b92023-01-03 16:12:50 -0800141 friend class sp<AudioFlinger>;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700142public:
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800143 static void instantiate() ANDROID_API;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700144
Svet Ganov33761132021-05-13 22:51:08 +0000145 static AttributionSourceState checkAttributionSourcePackage(
146 const AttributionSourceState& attributionSource);
Eric Laurentec376dc2021-04-08 20:41:22 +0200147
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800148 status_t dump(int fd, const Vector<String16>& args) override;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700149
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800150 // IAudioFlinger interface, in binder opcode order
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -0800151 status_t createTrack(const media::CreateTrackRequest& input,
152 media::CreateTrackResponse& output) override;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700153
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -0800154 status_t createRecord(const media::CreateRecordRequest& input,
155 media::CreateRecordResponse& output) override;
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800156
Glenn Kasten2c073da2016-02-26 09:14:08 -0800157 virtual uint32_t sampleRate(audio_io_handle_t ioHandle) const;
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800158 virtual audio_format_t format(audio_io_handle_t output) const;
Glenn Kasten2c073da2016-02-26 09:14:08 -0800159 virtual size_t frameCount(audio_io_handle_t ioHandle) const;
Glenn Kasten4a8308b2016-04-18 14:10:01 -0700160 virtual size_t frameCountHAL(audio_io_handle_t ioHandle) const;
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800161 virtual uint32_t latency(audio_io_handle_t output) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700162
163 virtual status_t setMasterVolume(float value);
164 virtual status_t setMasterMute(bool muted);
165
166 virtual float masterVolume() const;
167 virtual bool masterMute() const;
168
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +0100169 // Balance value must be within -1.f (left only) to 1.f (right only) inclusive.
170 status_t setMasterBalance(float balance) override;
171 status_t getMasterBalance(float *balance) const override;
172
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800173 virtual status_t setStreamVolume(audio_stream_type_t stream, float value,
174 audio_io_handle_t output);
Glenn Kastenfff6d712012-01-12 16:38:12 -0800175 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700176
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800177 virtual float streamVolume(audio_stream_type_t stream,
178 audio_io_handle_t output) const;
Glenn Kastenfff6d712012-01-12 16:38:12 -0800179 virtual bool streamMute(audio_stream_type_t stream) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700180
Glenn Kastenf78aee72012-01-04 11:00:47 -0800181 virtual status_t setMode(audio_mode_t mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700182
183 virtual status_t setMicMute(bool state);
184 virtual bool getMicMute() const;
185
Eric Laurent5ada82e2019-08-29 17:53:54 -0700186 virtual void setRecordSilenced(audio_port_handle_t portId, bool silenced);
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800187
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800188 virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs);
189 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700190
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700191 virtual void registerClient(const sp<media::IAudioFlingerClient>& client);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700192
Glenn Kastendd8104c2012-07-02 12:42:44 -0700193 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format,
194 audio_channel_mask_t channelMask) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700195
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -0800196 virtual status_t openOutput(const media::OpenOutputRequest& request,
197 media::OpenOutputResponse* response);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700198
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800199 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
200 audio_io_handle_t output2);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700201
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800202 virtual status_t closeOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700203
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800204 virtual status_t suspendOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700205
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800206 virtual status_t restoreOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700207
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -0800208 virtual status_t openInput(const media::OpenInputRequest& request,
209 media::OpenInputResponse* response);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700210
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800211 virtual status_t closeInput(audio_io_handle_t input);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700212
Mathias Agopian65ab4712010-07-14 17:59:35 -0700213 virtual status_t setVoiceVolume(float volume);
214
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000215 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800216 audio_io_handle_t output) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700217
Glenn Kasten5f972c02014-01-13 09:59:31 -0800218 virtual uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const;
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800219
Glenn Kasten9d003132016-04-06 14:38:09 -0700220 // This is the binder API. For the internal API see nextUniqueId().
Glenn Kasteneeecb982016-02-26 10:44:04 -0800221 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700222
Andy Hung8b0bfd92019-12-23 13:11:11 -0800223 void acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid) override;
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700224
Glenn Kastend848eb42016-03-08 13:42:11 -0800225 virtual void releaseAudioSessionId(audio_session_t audioSession, pid_t pid);
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700226
Glenn Kastenf587ba52012-01-26 16:25:10 -0800227 virtual status_t queryNumberEffects(uint32_t *numEffects) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700228
Glenn Kastenf587ba52012-01-26 16:25:10 -0800229 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700230
Glenn Kasten5e92a782012-01-30 07:40:52 -0800231 virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid,
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -0700232 const effect_uuid_t *pTypeUuid,
233 uint32_t preferredTypeFlag,
Glenn Kastenf587ba52012-01-26 16:25:10 -0800234 effect_descriptor_t *descriptor) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700235
Ytai Ben-Tsvice182942020-11-04 14:48:01 -0800236 virtual status_t createEffect(const media::CreateEffectRequest& request,
237 media::CreateEffectResponse* response);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700238
Glenn Kastend848eb42016-03-08 13:42:11 -0800239 virtual status_t moveEffects(audio_session_t sessionId, audio_io_handle_t srcOutput,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800240 audio_io_handle_t dstOutput);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700241
Eric Laurentb20cf7d2019-04-05 19:37:34 -0700242 void setEffectSuspended(int effectId,
243 audio_session_t sessionId,
244 bool suspended) override;
245
Eric Laurenta4c5a552012-03-29 10:12:40 -0700246 virtual audio_module_handle_t loadHwModule(const char *name);
247
Glenn Kasten3b16c762012-11-14 08:44:39 -0800248 virtual uint32_t getPrimaryOutputSamplingRate();
Glenn Kastene33054e2012-11-14 12:54:39 -0800249 virtual size_t getPrimaryOutputFrameCount();
Glenn Kastencc0f1cf2012-09-24 11:27:18 -0700250
Andy Hung6f248bb2018-01-23 14:04:37 -0800251 virtual status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) override;
Glenn Kasten4182c4e2013-07-15 14:45:07 -0700252
Eric Laurent4b123402014-04-11 09:22:20 -0700253 /* List available audio ports and their attributes */
254 virtual status_t listAudioPorts(unsigned int *num_ports,
Eric Laurent1c333e22014-05-20 10:48:17 -0700255 struct audio_port *ports);
Eric Laurent4b123402014-04-11 09:22:20 -0700256
257 /* Get attributes for a given audio port */
jiabinb4fed192020-09-22 14:45:40 -0700258 virtual status_t getAudioPort(struct audio_port_v7 *port);
Eric Laurent4b123402014-04-11 09:22:20 -0700259
260 /* Create an audio patch between several source and sink ports */
261 virtual status_t createAudioPatch(const struct audio_patch *patch,
Eric Laurent1c333e22014-05-20 10:48:17 -0700262 audio_patch_handle_t *handle);
Eric Laurent4b123402014-04-11 09:22:20 -0700263
264 /* Release an audio patch */
Eric Laurent1c333e22014-05-20 10:48:17 -0700265 virtual status_t releaseAudioPatch(audio_patch_handle_t handle);
Eric Laurent4b123402014-04-11 09:22:20 -0700266
267 /* List existing audio patches */
268 virtual status_t listAudioPatches(unsigned int *num_patches,
Eric Laurent1c333e22014-05-20 10:48:17 -0700269 struct audio_patch *patches);
270
Eric Laurent4b123402014-04-11 09:22:20 -0700271 /* Set audio port configuration */
Eric Laurent1c333e22014-05-20 10:48:17 -0700272 virtual status_t setAudioPortConfig(const struct audio_port_config *config);
Eric Laurent4b123402014-04-11 09:22:20 -0700273
Eric Laurent93c3d412014-08-01 14:48:35 -0700274 /* Get the HW synchronization source used for an audio session */
275 virtual audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId);
276
Eric Laurent72e3f392015-05-20 14:43:50 -0700277 /* Indicate JAVA services are ready (scheduling, power management ...) */
278 virtual status_t systemReady();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200279 virtual status_t audioPolicyReady() { mAudioPolicyReady.store(true); return NO_ERROR; }
280 bool isAudioPolicyReady() const { return mAudioPolicyReady.load(); }
281
Eric Laurent72e3f392015-05-20 14:43:50 -0700282
Mikhail Naganovd5d9de72023-02-13 11:45:03 -0800283 virtual status_t getMicrophones(std::vector<media::MicrophoneInfoFw> *microphones);
jiabin46a76fa2018-01-05 10:18:21 -0800284
Eric Laurent42896a02019-09-27 15:40:33 -0700285 virtual status_t setAudioHalPids(const std::vector<pid_t>& pids);
286
jiabin1319f5a2021-03-30 22:21:24 +0000287 virtual status_t setVibratorInfos(const std::vector<media::AudioVibratorInfo>& vibratorInfos);
288
jiabinf042b9b2021-05-07 23:46:28 +0000289 virtual status_t updateSecondaryOutputs(
290 const TrackSecondaryOutputsMap& trackSecondaryOutputs);
291
Jiabin Huangebe64102021-09-07 20:01:07 +0000292 virtual status_t getMmapPolicyInfos(
jiabine99d0882021-09-17 05:21:25 +0000293 media::audio::common::AudioMMapPolicyType policyType,
294 std::vector<media::audio::common::AudioMMapPolicyInfo> *policyInfos);
Jiabin Huangebe64102021-09-07 20:01:07 +0000295
jiabine504e7b2021-09-18 00:27:08 +0000296 virtual int32_t getAAudioMixerBurstCount();
297
298 virtual int32_t getAAudioHardwareBurstMinUsec();
299
Mikhail Naganov516d3982022-02-01 23:53:59 +0000300 virtual status_t setDeviceConnectedState(const struct audio_port_v7 *port, bool connected);
301
Mikhail Naganovb1ddbb02023-03-15 17:06:59 -0700302 virtual status_t setSimulateDeviceConnections(bool enabled);
303
Eric Laurent076e7c72022-05-03 18:12:28 +0200304 virtual status_t setRequestedLatencyMode(
305 audio_io_handle_t output, audio_latency_mode_t mode);
306
307 virtual status_t getSupportedLatencyModes(audio_io_handle_t output,
308 std::vector<audio_latency_mode_t>* modes);
309
Eric Laurent50d72582022-12-20 20:20:23 +0100310 virtual status_t setBluetoothVariableLatencyEnabled(bool enabled);
Eric Laurent52057642022-12-16 11:45:07 +0100311
Eric Laurent50d72582022-12-20 20:20:23 +0100312 virtual status_t isBluetoothVariableLatencyEnabled(bool* enabled);
313
314 virtual status_t supportsBluetoothVariableLatency(bool* support);
Eric Laurent52057642022-12-16 11:45:07 +0100315
Vlad Popae3fd1c22022-11-07 21:03:18 +0100316 virtual status_t getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback,
317 sp<media::ISoundDose>* soundDose);
Vlad Popa63f047e2022-11-05 14:09:19 +0100318
jiabinc44b3462022-12-08 12:52:31 -0800319 status_t invalidateTracks(const std::vector<audio_port_handle_t>& portIds) override;
320
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -0700321 status_t onTransactWrapper(TransactionCode code, const Parcel& data, uint32_t flags,
322 const std::function<status_t()>& delegate) override;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700323
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800324 // end of IAudioFlinger interface
325
Glenn Kasten9e58b552013-01-18 15:09:48 -0800326 sp<NBLog::Writer> newWriter_l(size_t size, const char *name);
327 void unregisterWriter(const sp<NBLog::Writer>& writer);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700328 sp<EffectsFactoryHalInterface> getEffectsFactory();
Eric Laurentfc235202016-12-20 18:48:17 -0800329
330 status_t openMmapStream(MmapStreamInterface::stream_direction_t direction,
331 const audio_attributes_t *attr,
332 audio_config_base_t *config,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700333 const AudioClient& client,
Eric Laurentfc235202016-12-20 18:48:17 -0800334 audio_port_handle_t *deviceId,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800335 audio_session_t *sessionId,
Eric Laurentfc235202016-12-20 18:48:17 -0800336 const sp<MmapStreamCallback>& callback,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700337 sp<MmapStreamInterface>& interface,
338 audio_port_handle_t *handle);
jiabin57303cc2018-12-18 15:45:57 -0800339
Simon Bowden62823412022-10-17 14:52:26 +0000340 static os::HapticScale onExternalVibrationStart(
341 const sp<os::ExternalVibration>& externalVibration);
jiabin57303cc2018-12-18 15:45:57 -0800342 static void onExternalVibrationStop(const sp<os::ExternalVibration>& externalVibration);
Eric Laurentb82e6b72019-11-22 17:25:04 -0800343
344 status_t addEffectToHal(audio_port_handle_t deviceId,
Andy Hung920f6572022-10-06 12:09:49 -0700345 audio_module_handle_t hwModuleId, const sp<EffectHalInterface>& effect);
Eric Laurentb82e6b72019-11-22 17:25:04 -0800346 status_t removeEffectFromHal(audio_port_handle_t deviceId,
Andy Hung920f6572022-10-06 12:09:49 -0700347 audio_module_handle_t hwModuleId, const sp<EffectHalInterface>& effect);
Eric Laurentb82e6b72019-11-22 17:25:04 -0800348
Eric Laurent74c38dc2020-12-23 18:19:44 +0100349 void updateDownStreamPatches_l(const struct audio_patch *patch,
Andy Hung920f6572022-10-06 12:09:49 -0700350 const std::set<audio_io_handle_t>& streams);
Eric Laurent74c38dc2020-12-23 18:19:44 +0100351
Lais Andradebc3f37a2021-07-02 00:13:19 +0100352 std::optional<media::AudioVibratorInfo> getDefaultVibratorInfo_l();
jiabin1319f5a2021-03-30 22:21:24 +0000353
Glenn Kasten9e58b552013-01-18 15:09:48 -0800354private:
Glenn Kasteneef598c2017-04-03 14:41:13 -0700355 // FIXME The 400 is temporarily too high until a leak of writers in media.log is fixed.
356 static const size_t kLogMemorySize = 400 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -0800357 sp<MemoryDealer> mLogMemoryDealer; // == 0 when NBLog is disabled
Glenn Kasten481fb672013-09-30 14:39:28 -0700358 // When a log writer is unregistered, it is done lazily so that media.log can continue to see it
359 // for as long as possible. The memory is only freed when it is needed for another log writer.
360 Vector< sp<NBLog::Writer> > mUnregisteredWriters;
361 Mutex mUnregisteredWritersLock;
Eric Laurentfc235202016-12-20 18:48:17 -0800362
Glenn Kasten9e58b552013-01-18 15:09:48 -0800363public:
Andy Hung6626a012021-01-12 13:38:00 -0800364 // Life cycle of gAudioFlinger and AudioFlinger:
365 //
366 // AudioFlinger is created once and survives until audioserver crashes
367 // irrespective of sp<> and wp<> as it is refcounted by ServiceManager and we
368 // don't issue a ServiceManager::tryUnregisterService().
369 //
370 // gAudioFlinger is an atomic pointer set on AudioFlinger::onFirstRef().
371 // After this is set, it is safe to obtain a wp<> or sp<> from it as the
372 // underlying object does not go away.
373 //
374 // Note: For most inner classes, it is acceptable to hold a reference to the outer
375 // AudioFlinger instance as creation requires AudioFlinger to exist in the first place.
376 //
377 // An atomic here ensures underlying writes have completed before setting
378 // the pointer. Access by memory_order_seq_cst.
379 //
380
381 static inline std::atomic<AudioFlinger *> gAudioFlinger = nullptr;
Glenn Kasten9e58b552013-01-18 15:09:48 -0800382
Eric Laurenta011e352012-03-29 15:51:43 -0700383 class SyncEvent;
384
385 typedef void (*sync_event_callback_t)(const wp<SyncEvent>& event) ;
386
387 class SyncEvent : public RefBase {
388 public:
389 SyncEvent(AudioSystem::sync_event_t type,
Glenn Kastend848eb42016-03-08 13:42:11 -0800390 audio_session_t triggerSession,
391 audio_session_t listenerSession,
Eric Laurenta011e352012-03-29 15:51:43 -0700392 sync_event_callback_t callBack,
Andy Hung920f6572022-10-06 12:09:49 -0700393 const wp<RefBase>& cookie)
Eric Laurenta011e352012-03-29 15:51:43 -0700394 : mType(type), mTriggerSession(triggerSession), mListenerSession(listenerSession),
395 mCallback(callBack), mCookie(cookie)
396 {}
397
398 virtual ~SyncEvent() {}
399
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -0800400 void trigger() {
401 Mutex::Autolock _l(mLock);
402 if (mCallback) mCallback(wp<SyncEvent>(this));
403 }
Glenn Kasten106e8a42012-08-02 13:37:12 -0700404 bool isCancelled() const { Mutex::Autolock _l(mLock); return (mCallback == NULL); }
405 void cancel() { Mutex::Autolock _l(mLock); mCallback = NULL; }
Eric Laurenta011e352012-03-29 15:51:43 -0700406 AudioSystem::sync_event_t type() const { return mType; }
Glenn Kastend848eb42016-03-08 13:42:11 -0800407 audio_session_t triggerSession() const { return mTriggerSession; }
408 audio_session_t listenerSession() const { return mListenerSession; }
Eric Laurent8ea16e42014-02-20 16:26:11 -0800409 wp<RefBase> cookie() const { return mCookie; }
Eric Laurenta011e352012-03-29 15:51:43 -0700410
411 private:
412 const AudioSystem::sync_event_t mType;
Glenn Kastend848eb42016-03-08 13:42:11 -0800413 const audio_session_t mTriggerSession;
414 const audio_session_t mListenerSession;
Eric Laurenta011e352012-03-29 15:51:43 -0700415 sync_event_callback_t mCallback;
Eric Laurent8ea16e42014-02-20 16:26:11 -0800416 const wp<RefBase> mCookie;
Glenn Kasten106e8a42012-08-02 13:37:12 -0700417 mutable Mutex mLock;
Eric Laurenta011e352012-03-29 15:51:43 -0700418 };
419
420 sp<SyncEvent> createSyncEvent(AudioSystem::sync_event_t type,
Glenn Kastend848eb42016-03-08 13:42:11 -0800421 audio_session_t triggerSession,
422 audio_session_t listenerSession,
Eric Laurenta011e352012-03-29 15:51:43 -0700423 sync_event_callback_t callBack,
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700424 const wp<RefBase>& cookie);
Eric Laurent717e1282012-06-29 16:36:52 -0700425
Eric Laurentd8365c52017-07-16 15:27:05 -0700426 bool btNrecIsOff() const { return mBtNrecIsOff.load(); }
427
428
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800429private:
John Grossmanee578c02012-07-23 17:05:46 -0700430
Glenn Kastenf78aee72012-01-04 11:00:47 -0800431 audio_mode_t getMode() const { return mMode; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700432
Mathias Agopiane762be92013-05-09 16:26:45 -0700433 AudioFlinger() ANDROID_API;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700434 virtual ~AudioFlinger();
435
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800436 // call in any IAudioFlinger method that accesses mPrimaryHardwareDev
Glenn Kasten85ab62c2012-11-01 11:11:38 -0700437 status_t initCheck() const { return mPrimaryHardwareDev == NULL ?
438 NO_INIT : NO_ERROR; }
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800439
Glenn Kasten000f0e32012-03-01 17:10:56 -0800440 // RefBase
Dima Zavin5a61d2f2011-04-19 19:04:32 -0700441 virtual void onFirstRef();
Glenn Kasten000f0e32012-03-01 17:10:56 -0800442
Glenn Kasten85ab62c2012-11-01 11:11:38 -0700443 AudioHwDevice* findSuitableHwDev_l(audio_module_handle_t module,
jiabin43810402019-10-24 14:58:31 -0700444 audio_devices_t deviceType);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700445
Andy Hung9a592762014-07-21 21:56:01 -0700446 // Set kEnableExtendedChannels to true to enable greater than stereo output
447 // for the MixerThread and device sink. Number of channels allowed is
448 // FCC_2 <= channels <= AudioMixer::MAX_NUM_CHANNELS.
Andy Hungb1ee3952014-07-28 16:28:06 -0700449 static const bool kEnableExtendedChannels = true;
Andy Hung9a592762014-07-21 21:56:01 -0700450
451 // Returns true if channel mask is permitted for the PCM sink in the MixerThread
452 static inline bool isValidPcmSinkChannelMask(audio_channel_mask_t channelMask) {
453 switch (audio_channel_mask_get_representation(channelMask)) {
454 case AUDIO_CHANNEL_REPRESENTATION_POSITION: {
jiabin40573322018-11-08 12:08:02 -0800455 // Haptic channel mask is only applicable for channel position mask.
456 const uint32_t channelCount = audio_channel_count_from_out_mask(
Mikhail Naganov55773032020-10-01 15:08:13 -0700457 static_cast<audio_channel_mask_t>(channelMask & ~AUDIO_CHANNEL_HAPTIC_ALL));
jiabin40573322018-11-08 12:08:02 -0800458 const uint32_t maxChannelCount = kEnableExtendedChannels
459 ? AudioMixer::MAX_NUM_CHANNELS : FCC_2;
460 if (channelCount < FCC_2 // mono is not supported at this time
461 || channelCount > maxChannelCount) {
462 return false;
Andy Hung9a592762014-07-21 21:56:01 -0700463 }
464 // check that channelMask is the "canonical" one we expect for the channelCount.
jiabin40573322018-11-08 12:08:02 -0800465 return audio_channel_position_mask_is_out_canonical(channelMask);
Andy Hung9a592762014-07-21 21:56:01 -0700466 }
Andy Hung64b6cb22015-05-19 12:32:58 -0700467 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
468 if (kEnableExtendedChannels) {
469 const uint32_t channelCount = audio_channel_count_from_out_mask(channelMask);
470 if (channelCount >= FCC_2 // mono is not supported at this time
471 && channelCount <= AudioMixer::MAX_NUM_CHANNELS) {
472 return true;
473 }
474 }
475 return false;
Andy Hung9a592762014-07-21 21:56:01 -0700476 default:
477 return false;
478 }
479 }
480
Andy Hung6146c082014-03-18 11:56:15 -0700481 // Set kEnableExtendedPrecision to true to use extended precision in MixerThread
Andy Hunga494e822014-07-08 18:09:40 -0700482 static const bool kEnableExtendedPrecision = true;
Andy Hung6146c082014-03-18 11:56:15 -0700483
484 // Returns true if format is permitted for the PCM sink in the MixerThread
485 static inline bool isValidPcmSinkFormat(audio_format_t format) {
486 switch (format) {
487 case AUDIO_FORMAT_PCM_16_BIT:
488 return true;
489 case AUDIO_FORMAT_PCM_FLOAT:
490 case AUDIO_FORMAT_PCM_24_BIT_PACKED:
491 case AUDIO_FORMAT_PCM_32_BIT:
492 case AUDIO_FORMAT_PCM_8_24_BIT:
493 return kEnableExtendedPrecision;
494 default:
495 return false;
496 }
497 }
498
Glenn Kasten66fcab92012-02-24 14:59:21 -0800499 // standby delay for MIXER and DUPLICATING playback threads is read from property
500 // ro.audio.flinger_standbytime_ms or defaults to kDefaultStandbyTimeInNsecs
John Grossman4ff14ba2012-02-08 16:37:41 -0800501 static nsecs_t mStandbyTimeInNsecs;
502
Eric Laurent81784c32012-11-19 14:55:58 -0800503 // incremented by 2 when screen state changes, bit 0 == 1 means "off"
504 // AudioFlinger::setParameters() updates, other threads read w/o lock
505 static uint32_t mScreenState;
506
Glenn Kastenbe5f05e2012-07-18 15:24:02 -0700507 // Internal dump utilities.
Mikhail Naganov959e2d02019-03-28 11:08:19 -0700508 static const int kDumpLockTimeoutNs = 1 * NANOS_PER_SECOND;
Eric Laurent81784c32012-11-19 14:55:58 -0800509 static bool dumpTryLock(Mutex& mutex);
Glenn Kastenbe5f05e2012-07-18 15:24:02 -0700510 void dumpPermissionDenial(int fd, const Vector<String16>& args);
511 void dumpClients(int fd, const Vector<String16>& args);
512 void dumpInternals(int fd, const Vector<String16>& args);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700513
Andy Hungdc099c22018-09-18 13:46:39 -0700514 SimpleLog mThreadLog{16}; // 16 Thread history limit
515
516 class ThreadBase;
517 void dumpToThreadLog_l(const sp<ThreadBase> &thread);
Andy Hunga8115dc2018-08-24 15:51:59 -0700518
Mathias Agopian65ab4712010-07-14 17:59:35 -0700519 // --- Client ---
520 class Client : public RefBase {
Atneya3c61d882021-09-20 14:52:15 -0400521 public:
522 Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700523 virtual ~Client();
Atneya3c61d882021-09-20 14:52:15 -0400524 AllocatorFactory::ClientAllocator& allocator();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700525 pid_t pid() const { return mPid; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800526 sp<AudioFlinger> audioFlinger() const { return mAudioFlinger; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700527
528 private:
Mikhail Naganovbf493082017-04-17 17:37:12 -0700529 DISALLOW_COPY_AND_ASSIGN(Client);
530
Atneya3c61d882021-09-20 14:52:15 -0400531 const sp<AudioFlinger> mAudioFlinger;
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800532 const pid_t mPid;
Atneya3c61d882021-09-20 14:52:15 -0400533 AllocatorFactory::ClientAllocator mClientAllocator;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700534 };
535
536 // --- Notification Client ---
537 class NotificationClient : public IBinder::DeathRecipient {
538 public:
539 NotificationClient(const sp<AudioFlinger>& audioFlinger,
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700540 const sp<media::IAudioFlingerClient>& client,
Andy Hung5bdc5352019-12-23 14:36:31 -0800541 pid_t pid,
542 uid_t uid);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700543 virtual ~NotificationClient();
544
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700545 sp<media::IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; }
Andy Hung5bdc5352019-12-23 14:36:31 -0800546 pid_t getPid() const { return mPid; }
547 uid_t getUid() const { return mUid; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700548
549 // IBinder::DeathRecipient
550 virtual void binderDied(const wp<IBinder>& who);
551
552 private:
Mikhail Naganovbf493082017-04-17 17:37:12 -0700553 DISALLOW_COPY_AND_ASSIGN(NotificationClient);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700554
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800555 const sp<AudioFlinger> mAudioFlinger;
556 const pid_t mPid;
Andy Hung5bdc5352019-12-23 14:36:31 -0800557 const uid_t mUid;
Ytai Ben-Tsvi10dc0a62020-09-18 11:31:55 -0700558 const sp<media::IAudioFlingerClient> mAudioFlingerClient;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700559 };
560
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -0800561 // --- MediaLogNotifier ---
562 // Thread in charge of notifying MediaLogService to start merging.
563 // Receives requests from AudioFlinger's binder activity. It is used to reduce the amount of
564 // binder calls to MediaLogService in case of bursts of AudioFlinger binder calls.
565 class MediaLogNotifier : public Thread {
566 public:
567 MediaLogNotifier();
568
569 // Requests a MediaLogService notification. It's ignored if there has recently been another
570 void requestMerge();
571 private:
572 // Every iteration blocks waiting for a request, then interacts with MediaLogService to
573 // start merging.
574 // As every MediaLogService binder call is expensive, once it gets a request it ignores the
575 // following ones for a period of time.
576 virtual bool threadLoop() override;
577
578 bool mPendingRequests;
579
580 // Mutex and condition variable around mPendingRequests' value
581 Mutex mMutex;
582 Condition mCond;
583
584 // Duration of the sleep period after a processed request
585 static const int kPostTriggerSleepPeriod = 1000000;
586 };
587
588 const sp<MediaLogNotifier> mMediaLogNotifier;
589
590 // This is a helper that is called during incoming binder calls.
Ytai Ben-Tsvi53858472020-11-30 11:04:46 -0800591 // Requests media.log to start merging log buffers
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -0800592 void requestLogMerge();
593
Mathias Agopian65ab4712010-07-14 17:59:35 -0700594 class TrackHandle;
595 class RecordHandle;
596 class RecordThread;
597 class PlaybackThread;
598 class MixerThread;
599 class DirectOutputThread;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800600 class OffloadThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700601 class DuplicatingThread;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800602 class AsyncCallbackThread;
jiabinc658e452022-10-21 20:52:21 +0000603 class BitPerfectThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700604 class Track;
605 class RecordTrack;
Eric Laurent41709552019-12-16 19:34:05 -0800606 class EffectBase;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700607 class EffectModule;
608 class EffectHandle;
609 class EffectChain;
Eric Laurentb82e6b72019-11-22 17:25:04 -0800610 class DeviceEffectProxy;
611 class DeviceEffectManager;
612 class PatchPanel;
613 class DeviceEffectManagerCallback;
Phil Burk062e67a2015-02-11 13:40:50 -0800614
Dima Zavin799a70e2011-04-18 16:57:27 -0700615 struct AudioStreamIn;
Kevin Rocard153f92d2018-12-18 18:33:28 -0800616 struct TeePatch;
617 using TeePatches = std::vector<TeePatch>;
618
Mathias Agopian65ab4712010-07-14 17:59:35 -0700619
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800620 struct stream_type_t {
621 stream_type_t()
622 : volume(1.0f),
Eric Laurent1a9ed112012-03-20 18:36:01 -0700623 mute(false)
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800624 {
625 }
626 float volume;
627 bool mute;
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800628 };
629
Mikhail Naganov2534b382019-09-25 13:05:02 -0700630 // Abstraction for the Audio Source for the RecordThread (HAL or PassthruPatchRecord).
631 struct Source
632 {
633 virtual ~Source() = default;
634 // The following methods have the same signatures as in StreamHalInterface.
635 virtual status_t read(void *buffer, size_t bytes, size_t *read) = 0;
636 virtual status_t getCapturePosition(int64_t *frames, int64_t *time) = 0;
637 virtual status_t standby() = 0;
638 };
639
Mathias Agopian65ab4712010-07-14 17:59:35 -0700640 // --- PlaybackThread ---
rago94a1ee82017-07-21 15:11:02 -0700641#ifdef FLOAT_EFFECT_CHAIN
642#define EFFECT_BUFFER_FORMAT AUDIO_FORMAT_PCM_FLOAT
643using effect_buffer_t = float;
644#else
645#define EFFECT_BUFFER_FORMAT AUDIO_FORMAT_PCM_16_BIT
646using effect_buffer_t = int16_t;
647#endif
Eric Laurent81784c32012-11-19 14:55:58 -0800648
649#include "Threads.h"
650
Eric Laurentb82e6b72019-11-22 17:25:04 -0800651#include "PatchPanel.h"
652
Vlad Popa5161f8a2022-10-10 16:17:20 +0200653#include "PatchCommandThread.h"
654
Vlad Popab042ee62022-10-20 18:05:00 +0200655#include "Effects.h"
656
Eric Laurentb82e6b72019-11-22 17:25:04 -0800657#include "DeviceEffectManager.h"
Eric Laurent1c333e22014-05-20 10:48:17 -0700658
Vlad Popab042ee62022-10-20 18:05:00 +0200659#include "MelReporter.h"
660
Andy Hunge778c422019-03-14 15:04:30 -0700661 // Find io handle by session id.
662 // Preference is given to an io handle with a matching effect chain to session id.
663 // If none found, AUDIO_IO_HANDLE_NONE is returned.
664 template <typename T>
665 static audio_io_handle_t findIoHandleBySessionId_l(
666 audio_session_t sessionId, const T& threads) {
667 audio_io_handle_t io = AUDIO_IO_HANDLE_NONE;
668
669 for (size_t i = 0; i < threads.size(); i++) {
670 const uint32_t sessionType = threads.valueAt(i)->hasAudioSession(sessionId);
671 if (sessionType != 0) {
672 io = threads.keyAt(i);
673 if ((sessionType & AudioFlinger::ThreadBase::EFFECT_SESSION) != 0) {
674 break; // effect chain here.
675 }
676 }
677 }
678 return io;
679 }
680
Eric Laurent81784c32012-11-19 14:55:58 -0800681 // server side of the client's IAudioTrack
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800682 class TrackHandle : public android::media::BnAudioTrack {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700683 public:
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700684 explicit TrackHandle(const sp<PlaybackThread::Track>& track);
Eric Laurent81784c32012-11-19 14:55:58 -0800685 virtual ~TrackHandle();
Glenn Kasten3dcd00d2013-07-17 10:10:23 -0700686
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800687 binder::Status getCblk(std::optional<media::SharedFileRegion>* _aidl_return) override;
688 binder::Status start(int32_t* _aidl_return) override;
689 binder::Status stop() override;
690 binder::Status flush() override;
691 binder::Status pause() override;
692 binder::Status attachAuxEffect(int32_t effectId, int32_t* _aidl_return) override;
693 binder::Status setParameters(const std::string& keyValuePairs,
694 int32_t* _aidl_return) override;
695 binder::Status selectPresentation(int32_t presentationId, int32_t programId,
696 int32_t* _aidl_return) override;
697 binder::Status getTimestamp(media::AudioTimestampInternal* timestamp,
698 int32_t* _aidl_return) override;
699 binder::Status signal() override;
700 binder::Status applyVolumeShaper(const media::VolumeShaperConfiguration& configuration,
701 const media::VolumeShaperOperation& operation,
702 int32_t* _aidl_return) override;
703 binder::Status getVolumeShaperState(
704 int32_t id,
705 std::optional<media::VolumeShaperState>* _aidl_return) override;
Mikhail Naganovf53e1822022-12-18 02:48:14 +0000706 binder::Status getDualMonoMode(
707 media::audio::common::AudioDualMonoMode* _aidl_return) override;
708 binder::Status setDualMonoMode(
709 media::audio::common::AudioDualMonoMode mode) override;
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800710 binder::Status getAudioDescriptionMixLevel(float* _aidl_return) override;
711 binder::Status setAudioDescriptionMixLevel(float leveldB) override;
712 binder::Status getPlaybackRateParameters(
Mikhail Naganovf53e1822022-12-18 02:48:14 +0000713 media::audio::common::AudioPlaybackRate* _aidl_return) override;
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800714 binder::Status setPlaybackRateParameters(
Mikhail Naganovf53e1822022-12-18 02:48:14 +0000715 const media::audio::common::AudioPlaybackRate& playbackRate) override;
Richard Fitzgeraldad3af332013-03-25 16:54:37 +0000716
Glenn Kasten98067102011-12-13 11:47:54 -0800717 private:
Eric Laurent81784c32012-11-19 14:55:58 -0800718 const sp<PlaybackThread::Track> mTrack;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700719 };
720
Eric Laurent81784c32012-11-19 14:55:58 -0800721 // server side of the client's IAudioRecord
Ivan Lozanoff6900d2017-08-01 15:47:38 -0700722 class RecordHandle : public android::media::BnAudioRecord {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700723 public:
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700724 explicit RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack);
Eric Laurent81784c32012-11-19 14:55:58 -0800725 virtual ~RecordHandle();
Ivan Lozanoff6900d2017-08-01 15:47:38 -0700726 virtual binder::Status start(int /*AudioSystem::sync_event_t*/ event,
727 int /*audio_session_t*/ triggerSession);
728 virtual binder::Status stop();
jiabin653cc0a2018-01-17 17:54:10 -0800729 virtual binder::Status getActiveMicrophones(
Mikhail Naganovd5d9de72023-02-13 11:45:03 -0800730 std::vector<media::MicrophoneInfoFw>* activeMicrophones);
Paul McLean12340082019-03-19 09:35:05 -0600731 virtual binder::Status setPreferredMicrophoneDirection(
Paul McLean03a6e6a2018-12-04 10:54:13 -0700732 int /*audio_microphone_direction_t*/ direction);
Paul McLean12340082019-03-19 09:35:05 -0600733 virtual binder::Status setPreferredMicrophoneFieldDimension(float zoom);
Eric Laurentec376dc2021-04-08 20:41:22 +0200734 virtual binder::Status shareAudioHistory(const std::string& sharedAudioPackageName,
735 int64_t sharedAudioStartMs);
Paul McLean03a6e6a2018-12-04 10:54:13 -0700736
Glenn Kasten58912562012-04-03 10:45:00 -0700737 private:
Eric Laurent81784c32012-11-19 14:55:58 -0800738 const sp<RecordThread::RecordTrack> mRecordTrack;
Glenn Kasten58912562012-04-03 10:45:00 -0700739
Eric Laurent81784c32012-11-19 14:55:58 -0800740 // for use from destructor
741 void stop_nonvirtual();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700742 };
743
Eric Laurent6acd1d42017-01-04 14:23:29 -0800744 // Mmap stream control interface implementation. Each MmapThreadHandle controls one
745 // MmapPlaybackThread or MmapCaptureThread instance.
746 class MmapThreadHandle : public MmapStreamInterface {
747 public:
748 explicit MmapThreadHandle(const sp<MmapThread>& thread);
749 virtual ~MmapThreadHandle();
750
751 // MmapStreamInterface virtuals
752 virtual status_t createMmapBuffer(int32_t minSizeFrames,
753 struct audio_mmap_buffer_info *info);
754 virtual status_t getMmapPosition(struct audio_mmap_position *position);
jiabinb7d8c5a2020-08-26 17:24:52 -0700755 virtual status_t getExternalPosition(uint64_t *position, int64_t *timeNanos);
Eric Laurentcb4dae22017-07-01 19:39:32 -0700756 virtual status_t start(const AudioClient& client,
jiabind1f1cb62020-03-24 11:57:57 -0700757 const audio_attributes_t *attr,
758 audio_port_handle_t *handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800759 virtual status_t stop(audio_port_handle_t handle);
Eric Laurent18b57012017-02-13 16:23:52 -0800760 virtual status_t standby();
jiabinfc791ee2023-02-15 19:43:40 +0000761 status_t reportData(const void* buffer, size_t frameCount) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800762
763 private:
Phil Burk9fabbf82017-08-03 12:02:00 -0700764 const sp<MmapThread> mThread;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800765 };
Eric Laurentbfb1b832013-01-07 09:53:42 -0800766
Glenn Kasteneeecb982016-02-26 10:44:04 -0800767 ThreadBase *checkThread_l(audio_io_handle_t ioHandle) const;
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100768 sp<AudioFlinger::ThreadBase> checkOutputThread_l(audio_io_handle_t ioHandle) const
769 REQUIRES(mLock);
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800770 PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const;
771 MixerThread *checkMixerThread_l(audio_io_handle_t output) const;
772 RecordThread *checkRecordThread_l(audio_io_handle_t input) const;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800773 MmapThread *checkMmapThread_l(audio_io_handle_t io) const;
774 VolumeInterface *getVolumeInterface_l(audio_io_handle_t output) const;
775 Vector <VolumeInterface *> getAllVolumeInterfaces_l() const;
776
777 sp<ThreadBase> openInput_l(audio_module_handle_t module,
Eric Laurentcf2c0212014-07-25 16:20:43 -0700778 audio_io_handle_t *input,
779 audio_config_t *config,
Eric Laurent83b88082014-06-20 18:31:16 -0700780 audio_devices_t device,
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -0800781 const char* address,
Eric Laurentcf2c0212014-07-25 16:20:43 -0700782 audio_source_t source,
Mikhail Naganovb4e037e2019-01-14 15:56:33 -0800783 audio_input_flags_t flags,
784 audio_devices_t outputDevice,
785 const String8& outputDeviceAddress);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800786 sp<ThreadBase> openOutput_l(audio_module_handle_t module,
jiabin43810402019-10-24 14:58:31 -0700787 audio_io_handle_t *output,
Eric Laurentf1f22e72021-07-13 14:04:14 +0200788 audio_config_t *halConfig,
789 audio_config_base_t *mixerConfig,
jiabin43810402019-10-24 14:58:31 -0700790 audio_devices_t deviceType,
791 const String8& address,
792 audio_output_flags_t flags);
Eric Laurent83b88082014-06-20 18:31:16 -0700793
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700794 void closeOutputFinish(const sp<PlaybackThread>& thread);
795 void closeInputFinish(const sp<RecordThread>& thread);
Eric Laurent83b88082014-06-20 18:31:16 -0700796
Glenn Kasten6637baa2012-01-09 09:40:36 -0800797 // no range check, AudioFlinger::mLock held
798 bool streamMute_l(audio_stream_type_t stream) const
799 { return mStreamTypes[stream].mute; }
Mikhail Naganov88536df2021-07-26 17:30:29 -0700800 void ioConfigChanged(audio_io_config_event_t event,
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700801 const sp<AudioIoDescriptor>& ioDesc,
802 pid_t pid = 0);
Eric Laurent076e7c72022-05-03 18:12:28 +0200803 void onSupportedLatencyModesChanged(
804 audio_io_handle_t output, const std::vector<audio_latency_mode_t>& modes);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700805
Glenn Kasteneeecb982016-02-26 10:44:04 -0800806 // Allocate an audio_unique_id_t.
807 // Specific types are audio_io_handle_t, audio_session_t, effect ID (int),
808 // audio_module_handle_t, and audio_patch_handle_t.
Glenn Kastenbcefec32014-01-17 12:09:05 -0800809 // They all share the same ID space, but the namespaces are actually independent
810 // because there are separate KeyedVectors for each kind of ID.
Glenn Kasteneeecb982016-02-26 10:44:04 -0800811 // The return value is cast to the specific type depending on how the ID will be used.
Glenn Kastenbcefec32014-01-17 12:09:05 -0800812 // FIXME This API does not handle rollover to zero (for unsigned IDs),
813 // or from positive to negative (for signed IDs).
814 // Thus it may fail by returning an ID of the wrong sign,
815 // or by returning a non-unique ID.
Glenn Kasten9d003132016-04-06 14:38:09 -0700816 // This is the internal API. For the binder API see newAudioUniqueId().
Glenn Kasteneeecb982016-02-26 10:44:04 -0800817 audio_unique_id_t nextUniqueId(audio_unique_id_use_t use);
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800818
Glenn Kastend848eb42016-03-08 13:42:11 -0800819 status_t moveEffectChain_l(audio_session_t sessionId,
Glenn Kastena1117922012-01-26 10:53:32 -0800820 PlaybackThread *srcThread,
Eric Laurent6c796322019-04-09 14:13:17 -0700821 PlaybackThread *dstThread);
822
823 status_t moveAuxEffectToIo(int EffectId,
824 const sp<PlaybackThread>& dstThread,
825 sp<PlaybackThread> *srcThread);
Glenn Kasten7fd04222016-02-02 12:38:16 -0800826
Glenn Kasten02fe1bf2012-02-24 15:42:17 -0800827 // return thread associated with primary hardware device, or NULL
828 PlaybackThread *primaryPlaybackThread_l() const;
jiabinc52b1ff2019-10-31 17:20:42 -0700829 DeviceTypeSet primaryOutputDevice_l() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700830
Glenn Kastena7335632016-06-09 17:09:53 -0700831 // return the playback thread with smallest HAL buffer size, and prefer fast
832 PlaybackThread *fastPlaybackThread_l() const;
833
Eric Laurentb20cf7d2019-04-05 19:37:34 -0700834 sp<ThreadBase> getEffectThread_l(audio_session_t sessionId, int effectId);
Eric Laurent717e1282012-06-29 16:36:52 -0700835
jiabineb3bda02020-06-30 14:07:03 -0700836 ThreadBase *hapticPlaybackThread_l() const;
837
jiabinf042b9b2021-05-07 23:46:28 +0000838 void updateSecondaryOutputsForTrack_l(
839 PlaybackThread::Track* track,
840 PlaybackThread* thread,
841 const std::vector<audio_io_handle_t>& secondaryOutputs) const;
842
Mathias Agopian65ab4712010-07-14 17:59:35 -0700843
Mathias Agopian65ab4712010-07-14 17:59:35 -0700844 void removeClient_l(pid_t pid);
845 void removeNotificationClient(pid_t pid);
Eric Laurent5baf2af2013-09-12 17:37:00 -0700846 bool isNonOffloadableGlobalEffectEnabled_l();
847 void onNonOffloadableGlobalEffectEnable();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800848 bool isSessionAcquired_l(audio_session_t audioSession);
Eric Laurent813e2a72013-08-31 12:59:48 -0700849
Eric Laurentaaa44472014-09-12 17:41:50 -0700850 // Store an effect chain to mOrphanEffectChains keyed vector.
851 // Called when a thread exits and effects are still attached to it.
852 // If effects are later created on the same session, they will reuse the same
853 // effect chain and same instances in the effect library.
854 // return ALREADY_EXISTS if a chain with the same session already exists in
855 // mOrphanEffectChains. Note that this should never happen as there is only one
856 // chain for a given session and it is attached to only one thread at a time.
857 status_t putOrphanEffectChain_l(const sp<EffectChain>& chain);
858 // Get an effect chain for the specified session in mOrphanEffectChains and remove
859 // it if found. Returns 0 if not found (this is the most common case).
860 sp<EffectChain> getOrphanEffectChain_l(audio_session_t session);
861 // Called when the last effect handle on an effect instance is removed. If this
862 // effect belongs to an effect chain in mOrphanEffectChains, the chain is updated
863 // and removed from mOrphanEffectChains if it does not contain any effect.
864 // Return true if the effect was found in mOrphanEffectChains, false otherwise.
865 bool updateOrphanEffectChains(const sp<EffectModule>& effect);
866
Eric Laurent6c796322019-04-09 14:13:17 -0700867 std::vector< sp<EffectModule> > purgeStaleEffects_l();
868
Andy Hungd9ef4b12020-11-11 15:13:18 -0800869 void broadcastParametersToRecordThreads_l(const String8& keyValuePairs);
jiabinc52b1ff2019-10-31 17:20:42 -0700870 void updateOutDevicesForRecordThreads_l(const DeviceDescriptorBaseVector& devices);
Mikhail Naganovb261ef52018-07-16 13:34:38 -0700871 void forwardParametersToDownstreamPatches_l(
872 audio_io_handle_t upStream, const String8& keyValuePairs,
Andy Hung920f6572022-10-06 12:09:49 -0700873 const std::function<bool(const sp<PlaybackThread>&)>& useThread = nullptr);
John Grossmanee578c02012-07-23 17:05:46 -0700874
Phil Burk062e67a2015-02-11 13:40:50 -0800875 // AudioStreamIn is immutable, so their fields are const.
Glenn Kastenaed850d2012-01-26 09:46:34 -0800876 // For emphasis, we could also make all pointers to them be "const *",
877 // but that would clutter the code unnecessarily.
878
Mikhail Naganov2534b382019-09-25 13:05:02 -0700879 struct AudioStreamIn : public Source {
John Grossmanee578c02012-07-23 17:05:46 -0700880 AudioHwDevice* const audioHwDev;
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700881 sp<StreamInHalInterface> stream;
Eric Laurent05067782016-06-01 18:27:28 -0700882 audio_input_flags_t flags;
Dima Zavin799a70e2011-04-18 16:57:27 -0700883
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700884 sp<DeviceHalInterface> hwDev() const { return audioHwDev->hwDevice(); }
John Grossmanee578c02012-07-23 17:05:46 -0700885
Andy Hung920f6572022-10-06 12:09:49 -0700886 AudioStreamIn(AudioHwDevice *dev, const sp<StreamInHalInterface>& in,
887 audio_input_flags_t flags) :
Eric Laurent05067782016-06-01 18:27:28 -0700888 audioHwDev(dev), stream(in), flags(flags) {}
Mikhail Naganov2534b382019-09-25 13:05:02 -0700889 status_t read(void *buffer, size_t bytes, size_t *read) override {
890 return stream->read(buffer, bytes, read);
891 }
892 status_t getCapturePosition(int64_t *frames, int64_t *time) override {
893 return stream->getCapturePosition(frames, time);
894 }
895 status_t standby() override { return stream->standby(); }
Dima Zavin799a70e2011-04-18 16:57:27 -0700896 };
897
Kevin Rocard153f92d2018-12-18 18:33:28 -0800898 struct TeePatch {
899 sp<RecordThread::PatchRecord> patchRecord;
900 sp<PlaybackThread::PatchTrack> patchTrack;
901 };
902
Glenn Kasten99e53b82012-01-19 08:59:58 -0800903 // for mAudioSessionRefs only
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700904 struct AudioSessionRef {
Andy Hung8b0bfd92019-12-23 13:11:11 -0800905 AudioSessionRef(audio_session_t sessionid, pid_t pid, uid_t uid) :
906 mSessionid(sessionid), mPid(pid), mUid(uid), mCnt(1) {}
Glenn Kastend848eb42016-03-08 13:42:11 -0800907 const audio_session_t mSessionid;
Glenn Kasten012ca6b2012-03-06 11:22:01 -0800908 const pid_t mPid;
Andy Hung8b0bfd92019-12-23 13:11:11 -0800909 const uid_t mUid;
Glenn Kasten012ca6b2012-03-06 11:22:01 -0800910 int mCnt;
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700911 };
912
Mathias Agopian65ab4712010-07-14 17:59:35 -0700913 mutable Mutex mLock;
Eric Laurent021cf962014-05-13 10:18:14 -0700914 // protects mClients and mNotificationClients.
915 // must be locked after mLock and ThreadBase::mLock if both must be locked
916 // avoids acquiring AudioFlinger::mLock from inside thread loop.
917 mutable Mutex mClientLock;
918 // protected by mClientLock
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800919 DefaultKeyedVector< pid_t, wp<Client> > mClients; // see ~Client()
Mathias Agopian65ab4712010-07-14 17:59:35 -0700920
921 mutable Mutex mHardwareLock;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700922 // NOTE: If both mLock and mHardwareLock mutexes must be held,
923 // always take mLock before mHardwareLock
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800924
Eric Laurent00abf0d2020-04-22 19:28:22 -0700925 // guarded by mHardwareLock
926 AudioHwDevice* mPrimaryHardwareDev;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700927 DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*> mAudioHwDevs;
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800928
Eric Laurent00abf0d2020-04-22 19:28:22 -0700929 // These two fields are immutable after onFirstRef(), so no lock needed to access
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700930 sp<DevicesFactoryHalInterface> mDevicesFactoryHal;
Mikhail Naganov88b30d22020-03-09 19:43:13 +0000931 sp<DevicesFactoryHalCallback> mDevicesFactoryHalCallback;
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700932
Glenn Kasten8abf44d2012-02-02 14:16:03 -0800933 // for dump, indicates which hardware operation is currently in progress (but not stream ops)
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800934 enum hardware_call_state {
Glenn Kasten8abf44d2012-02-02 14:16:03 -0800935 AUDIO_HW_IDLE = 0, // no operation in progress
936 AUDIO_HW_INIT, // init_check
937 AUDIO_HW_OUTPUT_OPEN, // open_output_stream
938 AUDIO_HW_OUTPUT_CLOSE, // unused
939 AUDIO_HW_INPUT_OPEN, // unused
940 AUDIO_HW_INPUT_CLOSE, // unused
941 AUDIO_HW_STANDBY, // unused
942 AUDIO_HW_SET_MASTER_VOLUME, // set_master_volume
943 AUDIO_HW_GET_ROUTING, // unused
944 AUDIO_HW_SET_ROUTING, // unused
945 AUDIO_HW_GET_MODE, // unused
946 AUDIO_HW_SET_MODE, // set_mode
947 AUDIO_HW_GET_MIC_MUTE, // get_mic_mute
948 AUDIO_HW_SET_MIC_MUTE, // set_mic_mute
949 AUDIO_HW_SET_VOICE_VOLUME, // set_voice_volume
950 AUDIO_HW_SET_PARAMETER, // set_parameters
951 AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size
952 AUDIO_HW_GET_MASTER_VOLUME, // get_master_volume
953 AUDIO_HW_GET_PARAMETER, // get_parameters
John Grossmand8f178d2012-07-20 14:51:35 -0700954 AUDIO_HW_SET_MASTER_MUTE, // set_master_mute
955 AUDIO_HW_GET_MASTER_MUTE, // get_master_mute
Eric Laurent00abf0d2020-04-22 19:28:22 -0700956 AUDIO_HW_GET_MICROPHONES, // getMicrophones
Mikhail Naganov516d3982022-02-01 23:53:59 +0000957 AUDIO_HW_SET_CONNECTED_STATE, // setConnectedState
Mikhail Naganovb1ddbb02023-03-15 17:06:59 -0700958 AUDIO_HW_SET_SIMULATE_CONNECTIONS, // setSimulateDeviceConnections
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800959 };
960
Glenn Kastena4454b42012-01-04 11:02:33 -0800961 mutable hardware_call_state mHardwareStatus; // for dump only
Mathias Agopian65ab4712010-07-14 17:59:35 -0700962
963
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800964 DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> > mPlaybackThreads;
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800965 stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
Glenn Kasten98067102011-12-13 11:47:54 -0800966
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700967 // member variables below are protected by mLock
Mathias Agopian65ab4712010-07-14 17:59:35 -0700968 float mMasterVolume;
969 bool mMasterMute;
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +0100970 float mMasterBalance = 0.f;
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700971 // end of variables protected by mLock
Mathias Agopian65ab4712010-07-14 17:59:35 -0700972
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800973 DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> > mRecordThreads;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700974
Eric Laurent021cf962014-05-13 10:18:14 -0700975 // protected by mClientLock
Mathias Agopian65ab4712010-07-14 17:59:35 -0700976 DefaultKeyedVector< pid_t, sp<NotificationClient> > mNotificationClients;
Glenn Kastenbcefec32014-01-17 12:09:05 -0800977
Glenn Kastend2e67e12016-04-11 08:26:37 -0700978 // updated by atomic_fetch_add_explicit
979 volatile atomic_uint_fast32_t mNextUniqueIds[AUDIO_UNIQUE_ID_USE_MAX];
Glenn Kastenbcefec32014-01-17 12:09:05 -0800980
Glenn Kastenf78aee72012-01-04 11:00:47 -0800981 audio_mode_t mMode;
Eric Laurentd8365c52017-07-16 15:27:05 -0700982 std::atomic_bool mBtNrecIsOff;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700983
Glenn Kasten99e53b82012-01-19 08:59:58 -0800984 // protected by mLock
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700985 Vector<AudioSessionRef*> mAudioSessionRefs;
Glenn Kasten98067102011-12-13 11:47:54 -0800986
John Grossman4ff14ba2012-02-08 16:37:41 -0800987 float masterVolume_l() const;
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +0100988 float getMasterBalance_l() const;
John Grossmand8f178d2012-07-20 14:51:35 -0700989 bool masterMute_l() const;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700990 audio_module_handle_t loadHwModule_l(const char *name);
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800991
Eric Laurenta011e352012-03-29 15:51:43 -0700992 Vector < sp<SyncEvent> > mPendingSyncEvents; // sync events awaiting for a session
993 // to be created
994
Eric Laurentaaa44472014-09-12 17:41:50 -0700995 // Effect chains without a valid thread
996 DefaultKeyedVector< audio_session_t , sp<EffectChain> > mOrphanEffectChains;
997
Eric Laurentfa90e842014-10-17 18:12:31 -0700998 // list of sessions for which a valid HW A/V sync ID was retrieved from the HAL
999 DefaultKeyedVector< audio_session_t , audio_hw_sync_t >mHwAvSyncIds;
Eric Laurent6acd1d42017-01-04 14:23:29 -08001000
1001 // list of MMAP stream control threads. Those threads allow for wake lock, routing
1002 // and volume control for activity on the associated MMAP stream at the HAL.
1003 // Audio data transfer is directly handled by the client creating the MMAP stream
1004 DefaultKeyedVector< audio_io_handle_t, sp<MmapThread> > mMmapThreads;
1005
Glenn Kasten98ec94c2012-01-25 14:28:29 -08001006private:
Eric Laurent021cf962014-05-13 10:18:14 -07001007 sp<Client> registerPid(pid_t pid); // always returns non-0
Glenn Kasten98ec94c2012-01-25 14:28:29 -08001008
Glenn Kastend96c5722012-04-25 13:44:49 -07001009 // for use from destructor
1010 status_t closeOutput_nonvirtual(audio_io_handle_t output);
Mikhail Naganov444ecc32018-05-01 17:40:05 -07001011 void closeThreadInternal_l(const sp<PlaybackThread>& thread);
Glenn Kastend96c5722012-04-25 13:44:49 -07001012 status_t closeInput_nonvirtual(audio_io_handle_t input);
Mikhail Naganov444ecc32018-05-01 17:40:05 -07001013 void closeThreadInternal_l(const sp<RecordThread>& thread);
Eric Laurentfa90e842014-10-17 18:12:31 -07001014 void setAudioHwSyncForSession_l(PlaybackThread *thread, audio_session_t sessionId);
Glenn Kastend06785b2012-09-30 12:29:28 -07001015
Eric Laurent223fd5c2014-11-11 13:43:36 -08001016 status_t checkStreamType(audio_stream_type_t stream) const;
1017
Eric Laurentf1047e82018-04-16 19:18:20 -07001018 void filterReservedParameters(String8& keyValuePairs, uid_t callingUid);
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001019 void logFilteredParameters(size_t originalKVPSize, const String8& originalKVPs,
1020 size_t rejectedKVPSize, const String8& rejectedKVPs,
1021 uid_t callingUid);
Eric Laurentf1047e82018-04-16 19:18:20 -07001022
Vlad Popae8d99472022-06-30 16:02:48 +02001023 sp<IAudioManager> getOrCreateAudioManager();
1024
Glenn Kastend06785b2012-09-30 12:29:28 -07001025public:
Andy Hung6f248bb2018-01-23 14:04:37 -08001026 // These methods read variables atomically without mLock,
1027 // though the variables are updated with mLock.
Glenn Kasten4182c4e2013-07-15 14:45:07 -07001028 bool isLowRamDevice() const { return mIsLowRamDevice; }
Andy Hung6f248bb2018-01-23 14:04:37 -08001029 size_t getClientSharedHeapSize() const;
Glenn Kasten4182c4e2013-07-15 14:45:07 -07001030
1031private:
Andy Hung6f248bb2018-01-23 14:04:37 -08001032 std::atomic<bool> mIsLowRamDevice;
Glenn Kasten4182c4e2013-07-15 14:45:07 -07001033 bool mIsDeviceTypeKnown;
Andy Hung6f248bb2018-01-23 14:04:37 -08001034 int64_t mTotalMemory;
1035 std::atomic<size_t> mClientSharedHeapSize;
1036 static constexpr size_t kMinimumClientSharedHeapSizeBytes = 1024 * 1024; // 1MB
1037
Eric Laurent813e2a72013-08-31 12:59:48 -07001038 nsecs_t mGlobalEffectEnableTime; // when a global effect was last enabled
Eric Laurent1c333e22014-05-20 10:48:17 -07001039
Mikhail Naganovdea53042018-04-26 13:10:21 -07001040 // protected by mLock
1041 PatchPanel mPatchPanel;
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -07001042 sp<EffectsFactoryHalInterface> mEffectsFactoryHal;
Glenn Kasten4ea00a22014-06-02 08:29:22 -07001043
Vlad Popa5161f8a2022-10-10 16:17:20 +02001044 const sp<PatchCommandThread> mPatchCommandThread;
1045 sp<DeviceEffectManager> mDeviceEffectManager;
Vlad Popab042ee62022-10-20 18:05:00 +02001046 sp<MelReporter> mMelReporter;
Eric Laurentb82e6b72019-11-22 17:25:04 -08001047
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001048 bool mSystemReady;
Eric Laurentd66d7a12021-07-13 13:35:32 +02001049 std::atomic_bool mAudioPolicyReady{};
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001050
Andy Hung5bdc5352019-12-23 14:36:31 -08001051 mediautils::UidInfo mUidInfo;
1052
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -07001053 SimpleLog mRejectedSetParameterLog;
1054 SimpleLog mAppSetParameterLog;
1055 SimpleLog mSystemSetParameterLog;
Andy Hungb68f5eb2019-12-03 16:49:17 -08001056
jiabin1319f5a2021-03-30 22:21:24 +00001057 std::vector<media::AudioVibratorInfo> mAudioVibratorInfos;
1058
Andy Hungb68f5eb2019-12-03 16:49:17 -08001059 static inline constexpr const char *mMetricsId = AMEDIAMETRICS_KEY_AUDIO_FLINGER;
Eric Laurentec376dc2021-04-08 20:41:22 +02001060
1061 // Keep in sync with java definition in media/java/android/media/AudioRecord.java
1062 static constexpr int32_t kMaxSharedAudioHistoryMs = 5000;
Jiabin Huangebe64102021-09-07 20:01:07 +00001063
jiabine99d0882021-09-17 05:21:25 +00001064 std::map<media::audio::common::AudioMMapPolicyType,
1065 std::vector<media::audio::common::AudioMMapPolicyInfo>> mPolicyInfos;
jiabine504e7b2021-09-18 00:27:08 +00001066 int32_t mAAudioBurstsPerBuffer = 0;
1067 int32_t mAAudioHwBurstMinMicros = 0;
Vlad Popae8d99472022-06-30 16:02:48 +02001068
1069 /** Interface for interacting with the AudioService. */
1070 mediautils::atomic_sp<IAudioManager> mAudioManager;
Eric Laurent52057642022-12-16 11:45:07 +01001071
1072 // Bluetooth Variable latency control logic is enabled or disabled
1073 std::atomic_bool mBluetoothLatencyModesEnabled;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001074};
1075
Eric Laurent81784c32012-11-19 14:55:58 -08001076#undef INCLUDING_FROM_AUDIOFLINGER_H
Dima Zavin799a70e2011-04-18 16:57:27 -07001077
Mikhail Naganov913d06c2016-11-01 12:49:22 -07001078std::string formatToString(audio_format_t format);
1079std::string inputFlagsToString(audio_input_flags_t flags);
1080std::string outputFlagsToString(audio_output_flags_t flags);
1081std::string devicesToString(audio_devices_t devices);
Glenn Kasten0f5b5622015-02-18 14:33:30 -08001082const char *sourceToString(audio_source_t source);
Marco Nelissenb2208842014-02-07 14:00:50 -08001083
Mathias Agopian65ab4712010-07-14 17:59:35 -07001084// ----------------------------------------------------------------------------
1085
Glenn Kasten63238ef2015-03-02 15:50:29 -08001086} // namespace android
Mathias Agopian65ab4712010-07-14 17:59:35 -07001087
1088#endif // ANDROID_AUDIO_FLINGER_H