blob: 7e3a77547e488517c3a79a0011a2cb088f63ce51 [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>
Andy Hung2148bf02016-11-28 19:01:02 -080024#include <deque>
Andy Hungdae27702016-10-31 14:01:16 -070025#include <map>
Eric Tan5786e012018-08-15 09:03:47 -070026#include <set>
Eric Tan7b651152018-07-13 10:17:19 -070027#include <string>
Kevin Rocard12381092018-04-11 09:19:59 -070028#include <vector>
Mathias Agopian65ab4712010-07-14 17:59:35 -070029#include <stdint.h>
30#include <sys/types.h>
31#include <limits.h>
32
Mikhail Naganovbf493082017-04-17 17:37:12 -070033#include <android-base/macros.h>
34
Steven Morelandf0c02ce2018-02-23 14:53:55 -080035#include <cutils/atomic.h>
Mathias Agopiane762be92013-05-09 16:26:45 -070036#include <cutils/compiler.h>
Andy Hungf28bcf52016-12-20 12:52:39 -080037#include <cutils/properties.h>
Mathias Agopiane762be92013-05-09 16:26:45 -070038
Mathias Agopian65ab4712010-07-14 17:59:35 -070039#include <media/IAudioFlinger.h>
40#include <media/IAudioFlingerClient.h>
41#include <media/IAudioTrack.h>
Glenn Kasten335787f2012-01-20 17:00:00 -080042#include <media/AudioSystem.h>
John Grossman4ff14ba2012-02-08 16:37:41 -080043#include <media/AudioTrack.h>
Eric Laurentfc235202016-12-20 18:48:17 -080044#include <media/MmapStreamInterface.h>
45#include <media/MmapStreamCallback.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070046
Mathias Agopian65ab4712010-07-14 17:59:35 -070047#include <utils/Errors.h>
48#include <utils/threads.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070049#include <utils/SortedVector.h>
Dima Zavin799a70e2011-04-18 16:57:27 -070050#include <utils/TypeHelpers.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070051#include <utils/Vector.h>
52
Mathias Agopian5462fc92010-07-14 18:41:18 -070053#include <binder/BinderService.h>
54#include <binder/MemoryDealer.h>
55
Dima Zavin64760242011-05-11 14:15:23 -070056#include <system/audio.h>
Mikhail Naganov61a4fac2016-10-13 14:44:18 -070057#include <system/audio_policy.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070058
Mikhail Naganov022b9952017-01-04 16:36:51 -080059#include <media/audiohal/EffectBufferHalInterface.h>
Mikhail Naganova0c91332016-09-19 10:01:12 -070060#include <media/audiohal/StreamHalInterface.h>
Glenn Kasten2dd4bdd2012-08-29 11:10:32 -070061#include <media/AudioBufferProvider.h>
Andy Hung068561c2017-01-03 17:09:32 -080062#include <media/AudioMixer.h>
Glenn Kasten2dd4bdd2012-08-29 11:10:32 -070063#include <media/ExtendedAudioBufferProvider.h>
Andy Hung068561c2017-01-03 17:09:32 -080064#include <media/LinearMap.h>
Andy Hung9fc8b5c2017-01-24 13:36:48 -080065#include <media/VolumeShaper.h>
Glenn Kasten6dbb5e32014-05-13 10:38:42 -070066
Andy Hungf3234512018-07-03 14:51:47 -070067#include <audio_utils/clock.h>
Andy Hungdc099c22018-09-18 13:46:39 -070068#include <audio_utils/FdToString.h>
Andy Hung293558a2017-03-21 12:19:20 -070069#include <audio_utils/SimpleLog.h>
Andy Hung2e2c0bb2018-06-11 19:13:11 -070070#include <audio_utils/TimestampVerifier.h>
Andy Hung293558a2017-03-21 12:19:20 -070071
Glenn Kasten6dbb5e32014-05-13 10:38:42 -070072#include "FastCapture.h"
Glenn Kasten58912562012-04-03 10:45:00 -070073#include "FastMixer.h"
Glenn Kasten2dd4bdd2012-08-29 11:10:32 -070074#include <media/nbaio/NBAIO.h>
Glenn Kastenc15d6652012-05-30 14:52:57 -070075#include "AudioWatchdog.h"
Phil Burk062e67a2015-02-11 13:40:50 -080076#include "AudioStreamOut.h"
77#include "SpdifStreamOut.h"
78#include "AudioHwDevice.h"
Andy Hung8946a282018-04-19 20:04:56 -070079#include "NBAIO_Tee.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070080
Eric Laurentfeb0db62011-07-22 09:04:31 -070081#include <powermanager/IPowerManager.h>
82
Glenn Kasten8589ce72017-09-08 17:03:42 -070083#include <media/nblog/NBLog.h>
Glenn Kasten444841f2016-12-16 15:36:43 -080084#include <private/media/AudioEffectShared.h>
Glenn Kasten9f80dd22012-12-18 15:57:32 -080085#include <private/media/AudioTrackShared.h>
Glenn Kasten9e58b552013-01-18 15:09:48 -080086
Ivan Lozanoff6900d2017-08-01 15:47:38 -070087#include "android/media/BnAudioRecord.h"
88
Mathias Agopian65ab4712010-07-14 17:59:35 -070089namespace android {
90
Mathias Agopian65ab4712010-07-14 17:59:35 -070091class AudioMixer;
92class AudioBuffer;
93class AudioResampler;
Mikhail Naganove4f1f632016-08-31 11:35:10 -070094class DeviceHalInterface;
95class DevicesFactoryHalInterface;
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -070096class EffectsFactoryHalInterface;
Glenn Kasten58912562012-04-03 10:45:00 -070097class FastMixer;
Andy Hungd330ee42015-04-20 13:23:41 -070098class PassthruBufferProvider;
Andy Hung89816052017-01-11 17:08:23 -080099class RecordBufferConverter;
Glenn Kastene3aa6592012-12-04 12:22:46 -0800100class ServerProxy;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700101
Mathias Agopian65ab4712010-07-14 17:59:35 -0700102// ----------------------------------------------------------------------------
103
John Grossman4ff14ba2012-02-08 16:37:41 -0800104static const nsecs_t kDefaultStandbyTimeInNsecs = seconds(3);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700105
Eric Laurent81784c32012-11-19 14:55:58 -0800106#define INCLUDING_FROM_AUDIOFLINGER_H
107
Mathias Agopian5462fc92010-07-14 18:41:18 -0700108class AudioFlinger :
109 public BinderService<AudioFlinger>,
110 public BnAudioFlinger
Mathias Agopian65ab4712010-07-14 17:59:35 -0700111{
Glenn Kasten19986612012-03-09 12:07:30 -0800112 friend class BinderService<AudioFlinger>; // for AudioFlinger()
Eric Laurentfc235202016-12-20 18:48:17 -0800113
Mathias Agopian65ab4712010-07-14 17:59:35 -0700114public:
Mathias Agopiane762be92013-05-09 16:26:45 -0700115 static const char* getServiceName() ANDROID_API { return "media.audio_flinger"; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700116
117 virtual status_t dump(int fd, const Vector<String16>& args);
118
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800119 // IAudioFlinger interface, in binder opcode order
Eric Laurent21da6472017-11-09 16:29:26 -0800120 virtual sp<IAudioTrack> createTrack(const CreateTrackInput& input,
121 CreateTrackOutput& output,
122 status_t *status);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700123
Eric Laurentf14db3c2017-12-08 14:20:36 -0800124 virtual sp<media::IAudioRecord> createRecord(const CreateRecordInput& input,
125 CreateRecordOutput& output,
126 status_t *status);
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800127
Glenn Kasten2c073da2016-02-26 09:14:08 -0800128 virtual uint32_t sampleRate(audio_io_handle_t ioHandle) const;
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800129 virtual audio_format_t format(audio_io_handle_t output) const;
Glenn Kasten2c073da2016-02-26 09:14:08 -0800130 virtual size_t frameCount(audio_io_handle_t ioHandle) const;
Glenn Kasten4a8308b2016-04-18 14:10:01 -0700131 virtual size_t frameCountHAL(audio_io_handle_t ioHandle) const;
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800132 virtual uint32_t latency(audio_io_handle_t output) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700133
134 virtual status_t setMasterVolume(float value);
135 virtual status_t setMasterMute(bool muted);
136
137 virtual float masterVolume() const;
138 virtual bool masterMute() const;
139
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +0100140 // Balance value must be within -1.f (left only) to 1.f (right only) inclusive.
141 status_t setMasterBalance(float balance) override;
142 status_t getMasterBalance(float *balance) const override;
143
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800144 virtual status_t setStreamVolume(audio_stream_type_t stream, float value,
145 audio_io_handle_t output);
Glenn Kastenfff6d712012-01-12 16:38:12 -0800146 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700147
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800148 virtual float streamVolume(audio_stream_type_t stream,
149 audio_io_handle_t output) const;
Glenn Kastenfff6d712012-01-12 16:38:12 -0800150 virtual bool streamMute(audio_stream_type_t stream) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700151
Glenn Kastenf78aee72012-01-04 11:00:47 -0800152 virtual status_t setMode(audio_mode_t mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700153
154 virtual status_t setMicMute(bool state);
155 virtual bool getMicMute() const;
156
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800157 virtual void setRecordSilenced(uid_t uid, bool silenced);
158
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800159 virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs);
160 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700161
162 virtual void registerClient(const sp<IAudioFlingerClient>& client);
163
Glenn Kastendd8104c2012-07-02 12:42:44 -0700164 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format,
165 audio_channel_mask_t channelMask) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700166
Eric Laurentcf2c0212014-07-25 16:20:43 -0700167 virtual status_t openOutput(audio_module_handle_t module,
168 audio_io_handle_t *output,
169 audio_config_t *config,
170 audio_devices_t *devices,
171 const String8& address,
172 uint32_t *latencyMs,
173 audio_output_flags_t flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700174
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800175 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
176 audio_io_handle_t output2);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700177
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800178 virtual status_t closeOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700179
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800180 virtual status_t suspendOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700181
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800182 virtual status_t restoreOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700183
Eric Laurentcf2c0212014-07-25 16:20:43 -0700184 virtual status_t openInput(audio_module_handle_t module,
185 audio_io_handle_t *input,
186 audio_config_t *config,
187 audio_devices_t *device,
188 const String8& address,
189 audio_source_t source,
190 audio_input_flags_t flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700191
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800192 virtual status_t closeInput(audio_io_handle_t input);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700193
Glenn Kastend2304db2014-02-03 07:40:31 -0800194 virtual status_t invalidateStream(audio_stream_type_t stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700195
196 virtual status_t setVoiceVolume(float volume);
197
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000198 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800199 audio_io_handle_t output) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700200
Glenn Kasten5f972c02014-01-13 09:59:31 -0800201 virtual uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const;
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800202
Glenn Kasten9d003132016-04-06 14:38:09 -0700203 // This is the binder API. For the internal API see nextUniqueId().
Glenn Kasteneeecb982016-02-26 10:44:04 -0800204 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700205
Glenn Kastend848eb42016-03-08 13:42:11 -0800206 virtual void acquireAudioSessionId(audio_session_t audioSession, pid_t pid);
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700207
Glenn Kastend848eb42016-03-08 13:42:11 -0800208 virtual void releaseAudioSessionId(audio_session_t audioSession, pid_t pid);
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700209
Glenn Kastenf587ba52012-01-26 16:25:10 -0800210 virtual status_t queryNumberEffects(uint32_t *numEffects) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700211
Glenn Kastenf587ba52012-01-26 16:25:10 -0800212 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700213
Glenn Kasten5e92a782012-01-30 07:40:52 -0800214 virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid,
Ari Hausman-Cohen2046ec72018-04-24 14:00:55 -0700215 const effect_uuid_t *pTypeUuid,
216 uint32_t preferredTypeFlag,
Glenn Kastenf587ba52012-01-26 16:25:10 -0800217 effect_descriptor_t *descriptor) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700218
Glenn Kasten8d6cc842012-02-03 11:06:53 -0800219 virtual sp<IEffect> createEffect(
Mathias Agopian65ab4712010-07-14 17:59:35 -0700220 effect_descriptor_t *pDesc,
221 const sp<IEffectClient>& effectClient,
222 int32_t priority,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800223 audio_io_handle_t io,
Glenn Kastend848eb42016-03-08 13:42:11 -0800224 audio_session_t sessionId,
Svet Ganovbe71aa22015-04-28 12:06:02 -0700225 const String16& opPackageName,
Eric Laurentb6436272016-12-07 19:24:50 -0800226 pid_t pid,
Glenn Kasten9156ef32013-08-06 15:39:08 -0700227 status_t *status /*non-NULL*/,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700228 int *id,
229 int *enabled);
230
Glenn Kastend848eb42016-03-08 13:42:11 -0800231 virtual status_t moveEffects(audio_session_t sessionId, audio_io_handle_t srcOutput,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800232 audio_io_handle_t dstOutput);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700233
Eric Laurenta4c5a552012-03-29 10:12:40 -0700234 virtual audio_module_handle_t loadHwModule(const char *name);
235
Glenn Kasten3b16c762012-11-14 08:44:39 -0800236 virtual uint32_t getPrimaryOutputSamplingRate();
Glenn Kastene33054e2012-11-14 12:54:39 -0800237 virtual size_t getPrimaryOutputFrameCount();
Glenn Kastencc0f1cf2012-09-24 11:27:18 -0700238
Andy Hung6f248bb2018-01-23 14:04:37 -0800239 virtual status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) override;
Glenn Kasten4182c4e2013-07-15 14:45:07 -0700240
Eric Laurent4b123402014-04-11 09:22:20 -0700241 /* List available audio ports and their attributes */
242 virtual status_t listAudioPorts(unsigned int *num_ports,
Eric Laurent1c333e22014-05-20 10:48:17 -0700243 struct audio_port *ports);
Eric Laurent4b123402014-04-11 09:22:20 -0700244
245 /* Get attributes for a given audio port */
Eric Laurent1c333e22014-05-20 10:48:17 -0700246 virtual status_t getAudioPort(struct audio_port *port);
Eric Laurent4b123402014-04-11 09:22:20 -0700247
248 /* Create an audio patch between several source and sink ports */
249 virtual status_t createAudioPatch(const struct audio_patch *patch,
Eric Laurent1c333e22014-05-20 10:48:17 -0700250 audio_patch_handle_t *handle);
Eric Laurent4b123402014-04-11 09:22:20 -0700251
252 /* Release an audio patch */
Eric Laurent1c333e22014-05-20 10:48:17 -0700253 virtual status_t releaseAudioPatch(audio_patch_handle_t handle);
Eric Laurent4b123402014-04-11 09:22:20 -0700254
255 /* List existing audio patches */
256 virtual status_t listAudioPatches(unsigned int *num_patches,
Eric Laurent1c333e22014-05-20 10:48:17 -0700257 struct audio_patch *patches);
258
Eric Laurent4b123402014-04-11 09:22:20 -0700259 /* Set audio port configuration */
Eric Laurent1c333e22014-05-20 10:48:17 -0700260 virtual status_t setAudioPortConfig(const struct audio_port_config *config);
Eric Laurent4b123402014-04-11 09:22:20 -0700261
Eric Laurent93c3d412014-08-01 14:48:35 -0700262 /* Get the HW synchronization source used for an audio session */
263 virtual audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId);
264
Eric Laurent72e3f392015-05-20 14:43:50 -0700265 /* Indicate JAVA services are ready (scheduling, power management ...) */
266 virtual status_t systemReady();
267
jiabin46a76fa2018-01-05 10:18:21 -0800268 virtual status_t getMicrophones(std::vector<media::MicrophoneInfo> *microphones);
269
Mathias Agopian65ab4712010-07-14 17:59:35 -0700270 virtual status_t onTransact(
271 uint32_t code,
272 const Parcel& data,
273 Parcel* reply,
274 uint32_t flags);
275
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800276 // end of IAudioFlinger interface
277
Glenn Kasten9e58b552013-01-18 15:09:48 -0800278 sp<NBLog::Writer> newWriter_l(size_t size, const char *name);
279 void unregisterWriter(const sp<NBLog::Writer>& writer);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700280 sp<EffectsFactoryHalInterface> getEffectsFactory();
Eric Laurentfc235202016-12-20 18:48:17 -0800281
282 status_t openMmapStream(MmapStreamInterface::stream_direction_t direction,
283 const audio_attributes_t *attr,
284 audio_config_base_t *config,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700285 const AudioClient& client,
Eric Laurentfc235202016-12-20 18:48:17 -0800286 audio_port_handle_t *deviceId,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800287 audio_session_t *sessionId,
Eric Laurentfc235202016-12-20 18:48:17 -0800288 const sp<MmapStreamCallback>& callback,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700289 sp<MmapStreamInterface>& interface,
290 audio_port_handle_t *handle);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800291private:
Glenn Kasteneef598c2017-04-03 14:41:13 -0700292 // FIXME The 400 is temporarily too high until a leak of writers in media.log is fixed.
293 static const size_t kLogMemorySize = 400 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -0800294 sp<MemoryDealer> mLogMemoryDealer; // == 0 when NBLog is disabled
Glenn Kasten481fb672013-09-30 14:39:28 -0700295 // When a log writer is unregistered, it is done lazily so that media.log can continue to see it
296 // for as long as possible. The memory is only freed when it is needed for another log writer.
297 Vector< sp<NBLog::Writer> > mUnregisteredWriters;
298 Mutex mUnregisteredWritersLock;
Eric Laurentfc235202016-12-20 18:48:17 -0800299
Glenn Kasten9e58b552013-01-18 15:09:48 -0800300public:
301
Eric Laurenta011e352012-03-29 15:51:43 -0700302 class SyncEvent;
303
304 typedef void (*sync_event_callback_t)(const wp<SyncEvent>& event) ;
305
306 class SyncEvent : public RefBase {
307 public:
308 SyncEvent(AudioSystem::sync_event_t type,
Glenn Kastend848eb42016-03-08 13:42:11 -0800309 audio_session_t triggerSession,
310 audio_session_t listenerSession,
Eric Laurenta011e352012-03-29 15:51:43 -0700311 sync_event_callback_t callBack,
Eric Laurent8ea16e42014-02-20 16:26:11 -0800312 wp<RefBase> cookie)
Eric Laurenta011e352012-03-29 15:51:43 -0700313 : mType(type), mTriggerSession(triggerSession), mListenerSession(listenerSession),
314 mCallback(callBack), mCookie(cookie)
315 {}
316
317 virtual ~SyncEvent() {}
318
319 void trigger() { Mutex::Autolock _l(mLock); if (mCallback) mCallback(this); }
Glenn Kasten106e8a42012-08-02 13:37:12 -0700320 bool isCancelled() const { Mutex::Autolock _l(mLock); return (mCallback == NULL); }
321 void cancel() { Mutex::Autolock _l(mLock); mCallback = NULL; }
Eric Laurenta011e352012-03-29 15:51:43 -0700322 AudioSystem::sync_event_t type() const { return mType; }
Glenn Kastend848eb42016-03-08 13:42:11 -0800323 audio_session_t triggerSession() const { return mTriggerSession; }
324 audio_session_t listenerSession() const { return mListenerSession; }
Eric Laurent8ea16e42014-02-20 16:26:11 -0800325 wp<RefBase> cookie() const { return mCookie; }
Eric Laurenta011e352012-03-29 15:51:43 -0700326
327 private:
328 const AudioSystem::sync_event_t mType;
Glenn Kastend848eb42016-03-08 13:42:11 -0800329 const audio_session_t mTriggerSession;
330 const audio_session_t mListenerSession;
Eric Laurenta011e352012-03-29 15:51:43 -0700331 sync_event_callback_t mCallback;
Eric Laurent8ea16e42014-02-20 16:26:11 -0800332 const wp<RefBase> mCookie;
Glenn Kasten106e8a42012-08-02 13:37:12 -0700333 mutable Mutex mLock;
Eric Laurenta011e352012-03-29 15:51:43 -0700334 };
335
336 sp<SyncEvent> createSyncEvent(AudioSystem::sync_event_t type,
Glenn Kastend848eb42016-03-08 13:42:11 -0800337 audio_session_t triggerSession,
338 audio_session_t listenerSession,
Eric Laurenta011e352012-03-29 15:51:43 -0700339 sync_event_callback_t callBack,
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700340 const wp<RefBase>& cookie);
Eric Laurent717e1282012-06-29 16:36:52 -0700341
Eric Laurentd8365c52017-07-16 15:27:05 -0700342 bool btNrecIsOff() const { return mBtNrecIsOff.load(); }
343
344
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800345private:
John Grossmanee578c02012-07-23 17:05:46 -0700346
Glenn Kastenf78aee72012-01-04 11:00:47 -0800347 audio_mode_t getMode() const { return mMode; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700348
Mathias Agopiane762be92013-05-09 16:26:45 -0700349 AudioFlinger() ANDROID_API;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700350 virtual ~AudioFlinger();
351
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800352 // call in any IAudioFlinger method that accesses mPrimaryHardwareDev
Glenn Kasten85ab62c2012-11-01 11:11:38 -0700353 status_t initCheck() const { return mPrimaryHardwareDev == NULL ?
354 NO_INIT : NO_ERROR; }
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800355
Glenn Kasten000f0e32012-03-01 17:10:56 -0800356 // RefBase
Dima Zavin5a61d2f2011-04-19 19:04:32 -0700357 virtual void onFirstRef();
Glenn Kasten000f0e32012-03-01 17:10:56 -0800358
Glenn Kasten85ab62c2012-11-01 11:11:38 -0700359 AudioHwDevice* findSuitableHwDev_l(audio_module_handle_t module,
360 audio_devices_t devices);
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700361 void purgeStaleEffects_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700362
Andy Hung9a592762014-07-21 21:56:01 -0700363 // Set kEnableExtendedChannels to true to enable greater than stereo output
364 // for the MixerThread and device sink. Number of channels allowed is
365 // FCC_2 <= channels <= AudioMixer::MAX_NUM_CHANNELS.
Andy Hungb1ee3952014-07-28 16:28:06 -0700366 static const bool kEnableExtendedChannels = true;
Andy Hung9a592762014-07-21 21:56:01 -0700367
368 // Returns true if channel mask is permitted for the PCM sink in the MixerThread
369 static inline bool isValidPcmSinkChannelMask(audio_channel_mask_t channelMask) {
370 switch (audio_channel_mask_get_representation(channelMask)) {
371 case AUDIO_CHANNEL_REPRESENTATION_POSITION: {
jiabin40573322018-11-08 12:08:02 -0800372 // Haptic channel mask is only applicable for channel position mask.
373 const uint32_t channelCount = audio_channel_count_from_out_mask(
374 channelMask & ~AUDIO_CHANNEL_HAPTIC_ALL);
375 const uint32_t maxChannelCount = kEnableExtendedChannels
376 ? AudioMixer::MAX_NUM_CHANNELS : FCC_2;
377 if (channelCount < FCC_2 // mono is not supported at this time
378 || channelCount > maxChannelCount) {
379 return false;
Andy Hung9a592762014-07-21 21:56:01 -0700380 }
381 // check that channelMask is the "canonical" one we expect for the channelCount.
jiabin40573322018-11-08 12:08:02 -0800382 return audio_channel_position_mask_is_out_canonical(channelMask);
Andy Hung9a592762014-07-21 21:56:01 -0700383 }
Andy Hung64b6cb22015-05-19 12:32:58 -0700384 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
385 if (kEnableExtendedChannels) {
386 const uint32_t channelCount = audio_channel_count_from_out_mask(channelMask);
387 if (channelCount >= FCC_2 // mono is not supported at this time
388 && channelCount <= AudioMixer::MAX_NUM_CHANNELS) {
389 return true;
390 }
391 }
392 return false;
Andy Hung9a592762014-07-21 21:56:01 -0700393 default:
394 return false;
395 }
396 }
397
Andy Hung6146c082014-03-18 11:56:15 -0700398 // Set kEnableExtendedPrecision to true to use extended precision in MixerThread
Andy Hunga494e822014-07-08 18:09:40 -0700399 static const bool kEnableExtendedPrecision = true;
Andy Hung6146c082014-03-18 11:56:15 -0700400
401 // Returns true if format is permitted for the PCM sink in the MixerThread
402 static inline bool isValidPcmSinkFormat(audio_format_t format) {
403 switch (format) {
404 case AUDIO_FORMAT_PCM_16_BIT:
405 return true;
406 case AUDIO_FORMAT_PCM_FLOAT:
407 case AUDIO_FORMAT_PCM_24_BIT_PACKED:
408 case AUDIO_FORMAT_PCM_32_BIT:
409 case AUDIO_FORMAT_PCM_8_24_BIT:
410 return kEnableExtendedPrecision;
411 default:
412 return false;
413 }
414 }
415
Glenn Kasten66fcab92012-02-24 14:59:21 -0800416 // standby delay for MIXER and DUPLICATING playback threads is read from property
417 // ro.audio.flinger_standbytime_ms or defaults to kDefaultStandbyTimeInNsecs
John Grossman4ff14ba2012-02-08 16:37:41 -0800418 static nsecs_t mStandbyTimeInNsecs;
419
Eric Laurent81784c32012-11-19 14:55:58 -0800420 // incremented by 2 when screen state changes, bit 0 == 1 means "off"
421 // AudioFlinger::setParameters() updates, other threads read w/o lock
422 static uint32_t mScreenState;
423
Glenn Kastenbe5f05e2012-07-18 15:24:02 -0700424 // Internal dump utilities.
Eric Laurent81784c32012-11-19 14:55:58 -0800425 static const int kDumpLockRetries = 50;
426 static const int kDumpLockSleepUs = 20000;
427 static bool dumpTryLock(Mutex& mutex);
Glenn Kastenbe5f05e2012-07-18 15:24:02 -0700428 void dumpPermissionDenial(int fd, const Vector<String16>& args);
429 void dumpClients(int fd, const Vector<String16>& args);
430 void dumpInternals(int fd, const Vector<String16>& args);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700431
Andy Hungdc099c22018-09-18 13:46:39 -0700432 SimpleLog mThreadLog{16}; // 16 Thread history limit
433
434 class ThreadBase;
435 void dumpToThreadLog_l(const sp<ThreadBase> &thread);
Andy Hunga8115dc2018-08-24 15:51:59 -0700436
Mathias Agopian65ab4712010-07-14 17:59:35 -0700437 // --- Client ---
438 class Client : public RefBase {
439 public:
440 Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
441 virtual ~Client();
Glenn Kasten435dbe62012-01-30 10:15:48 -0800442 sp<MemoryDealer> heap() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700443 pid_t pid() const { return mPid; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800444 sp<AudioFlinger> audioFlinger() const { return mAudioFlinger; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700445
446 private:
Mikhail Naganovbf493082017-04-17 17:37:12 -0700447 DISALLOW_COPY_AND_ASSIGN(Client);
448
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800449 const sp<AudioFlinger> mAudioFlinger;
Eric Laurentda73b6c2015-08-20 16:18:53 -0700450 sp<MemoryDealer> mMemoryDealer;
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800451 const pid_t mPid;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700452 };
453
454 // --- Notification Client ---
455 class NotificationClient : public IBinder::DeathRecipient {
456 public:
457 NotificationClient(const sp<AudioFlinger>& audioFlinger,
458 const sp<IAudioFlingerClient>& client,
459 pid_t pid);
460 virtual ~NotificationClient();
461
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800462 sp<IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700463
464 // IBinder::DeathRecipient
465 virtual void binderDied(const wp<IBinder>& who);
466
467 private:
Mikhail Naganovbf493082017-04-17 17:37:12 -0700468 DISALLOW_COPY_AND_ASSIGN(NotificationClient);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700469
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800470 const sp<AudioFlinger> mAudioFlinger;
471 const pid_t mPid;
472 const sp<IAudioFlingerClient> mAudioFlingerClient;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700473 };
474
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -0800475 // --- MediaLogNotifier ---
476 // Thread in charge of notifying MediaLogService to start merging.
477 // Receives requests from AudioFlinger's binder activity. It is used to reduce the amount of
478 // binder calls to MediaLogService in case of bursts of AudioFlinger binder calls.
479 class MediaLogNotifier : public Thread {
480 public:
481 MediaLogNotifier();
482
483 // Requests a MediaLogService notification. It's ignored if there has recently been another
484 void requestMerge();
485 private:
486 // Every iteration blocks waiting for a request, then interacts with MediaLogService to
487 // start merging.
488 // As every MediaLogService binder call is expensive, once it gets a request it ignores the
489 // following ones for a period of time.
490 virtual bool threadLoop() override;
491
492 bool mPendingRequests;
493
494 // Mutex and condition variable around mPendingRequests' value
495 Mutex mMutex;
496 Condition mCond;
497
498 // Duration of the sleep period after a processed request
499 static const int kPostTriggerSleepPeriod = 1000000;
500 };
501
502 const sp<MediaLogNotifier> mMediaLogNotifier;
503
504 // This is a helper that is called during incoming binder calls.
505 void requestLogMerge();
506
Mathias Agopian65ab4712010-07-14 17:59:35 -0700507 class TrackHandle;
508 class RecordHandle;
509 class RecordThread;
510 class PlaybackThread;
511 class MixerThread;
512 class DirectOutputThread;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800513 class OffloadThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700514 class DuplicatingThread;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800515 class AsyncCallbackThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700516 class Track;
517 class RecordTrack;
518 class EffectModule;
519 class EffectHandle;
520 class EffectChain;
Phil Burk062e67a2015-02-11 13:40:50 -0800521
Dima Zavin799a70e2011-04-18 16:57:27 -0700522 struct AudioStreamIn;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700523
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800524 struct stream_type_t {
525 stream_type_t()
526 : volume(1.0f),
Eric Laurent1a9ed112012-03-20 18:36:01 -0700527 mute(false)
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800528 {
529 }
530 float volume;
531 bool mute;
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800532 };
533
Mathias Agopian65ab4712010-07-14 17:59:35 -0700534 // --- PlaybackThread ---
rago94a1ee82017-07-21 15:11:02 -0700535#ifdef FLOAT_EFFECT_CHAIN
536#define EFFECT_BUFFER_FORMAT AUDIO_FORMAT_PCM_FLOAT
537using effect_buffer_t = float;
538#else
539#define EFFECT_BUFFER_FORMAT AUDIO_FORMAT_PCM_16_BIT
540using effect_buffer_t = int16_t;
541#endif
Eric Laurent81784c32012-11-19 14:55:58 -0800542
543#include "Threads.h"
544
545#include "Effects.h"
546
Eric Laurent1c333e22014-05-20 10:48:17 -0700547#include "PatchPanel.h"
548
Eric Laurent81784c32012-11-19 14:55:58 -0800549 // server side of the client's IAudioTrack
550 class TrackHandle : public android::BnAudioTrack {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700551 public:
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700552 explicit TrackHandle(const sp<PlaybackThread::Track>& track);
Eric Laurent81784c32012-11-19 14:55:58 -0800553 virtual ~TrackHandle();
554 virtual sp<IMemory> getCblk() const;
555 virtual status_t start();
556 virtual void stop();
557 virtual void flush();
Eric Laurent81784c32012-11-19 14:55:58 -0800558 virtual void pause();
559 virtual status_t attachAuxEffect(int effectId);
Glenn Kasten3dcd00d2013-07-17 10:10:23 -0700560 virtual status_t setParameters(const String8& keyValuePairs);
Mikhail Naganovac917ac2018-11-28 14:03:52 -0800561 virtual status_t selectPresentation(int presentationId, int programId);
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700562 virtual media::VolumeShaper::Status applyVolumeShaper(
563 const sp<media::VolumeShaper::Configuration>& configuration,
564 const sp<media::VolumeShaper::Operation>& operation) override;
565 virtual sp<media::VolumeShaper::State> getVolumeShaperState(int id) override;
Glenn Kasten53cec222013-08-29 09:01:02 -0700566 virtual status_t getTimestamp(AudioTimestamp& timestamp);
Eric Laurent59fe0102013-09-27 18:48:26 -0700567 virtual void signal(); // signal playback thread for a change in control block
Glenn Kasten3dcd00d2013-07-17 10:10:23 -0700568
Eric Laurent81784c32012-11-19 14:55:58 -0800569 virtual status_t onTransact(
570 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
Richard Fitzgeraldad3af332013-03-25 16:54:37 +0000571
Glenn Kasten98067102011-12-13 11:47:54 -0800572 private:
Eric Laurent81784c32012-11-19 14:55:58 -0800573 const sp<PlaybackThread::Track> mTrack;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700574 };
575
Eric Laurent81784c32012-11-19 14:55:58 -0800576 // server side of the client's IAudioRecord
Ivan Lozanoff6900d2017-08-01 15:47:38 -0700577 class RecordHandle : public android::media::BnAudioRecord {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700578 public:
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700579 explicit RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack);
Eric Laurent81784c32012-11-19 14:55:58 -0800580 virtual ~RecordHandle();
Ivan Lozanoff6900d2017-08-01 15:47:38 -0700581 virtual binder::Status start(int /*AudioSystem::sync_event_t*/ event,
582 int /*audio_session_t*/ triggerSession);
583 virtual binder::Status stop();
jiabin653cc0a2018-01-17 17:54:10 -0800584 virtual binder::Status getActiveMicrophones(
585 std::vector<media::MicrophoneInfo>* activeMicrophones);
Paul McLean03a6e6a2018-12-04 10:54:13 -0700586 virtual binder::Status setMicrophoneDirection(
587 int /*audio_microphone_direction_t*/ direction);
588 virtual binder::Status setMicrophoneFieldDimension(float zoom);
589
Glenn Kasten58912562012-04-03 10:45:00 -0700590 private:
Eric Laurent81784c32012-11-19 14:55:58 -0800591 const sp<RecordThread::RecordTrack> mRecordTrack;
Glenn Kasten58912562012-04-03 10:45:00 -0700592
Eric Laurent81784c32012-11-19 14:55:58 -0800593 // for use from destructor
594 void stop_nonvirtual();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700595 };
596
Eric Laurent6acd1d42017-01-04 14:23:29 -0800597 // Mmap stream control interface implementation. Each MmapThreadHandle controls one
598 // MmapPlaybackThread or MmapCaptureThread instance.
599 class MmapThreadHandle : public MmapStreamInterface {
600 public:
601 explicit MmapThreadHandle(const sp<MmapThread>& thread);
602 virtual ~MmapThreadHandle();
603
604 // MmapStreamInterface virtuals
605 virtual status_t createMmapBuffer(int32_t minSizeFrames,
606 struct audio_mmap_buffer_info *info);
607 virtual status_t getMmapPosition(struct audio_mmap_position *position);
Eric Laurentcb4dae22017-07-01 19:39:32 -0700608 virtual status_t start(const AudioClient& client,
Glenn Kastend3bb6452016-12-05 18:14:37 -0800609 audio_port_handle_t *handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800610 virtual status_t stop(audio_port_handle_t handle);
Eric Laurent18b57012017-02-13 16:23:52 -0800611 virtual status_t standby();
Eric Laurent6acd1d42017-01-04 14:23:29 -0800612
613 private:
Phil Burk9fabbf82017-08-03 12:02:00 -0700614 const sp<MmapThread> mThread;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800615 };
Eric Laurentbfb1b832013-01-07 09:53:42 -0800616
Glenn Kasteneeecb982016-02-26 10:44:04 -0800617 ThreadBase *checkThread_l(audio_io_handle_t ioHandle) const;
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800618 PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const;
619 MixerThread *checkMixerThread_l(audio_io_handle_t output) const;
620 RecordThread *checkRecordThread_l(audio_io_handle_t input) const;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800621 MmapThread *checkMmapThread_l(audio_io_handle_t io) const;
622 VolumeInterface *getVolumeInterface_l(audio_io_handle_t output) const;
623 Vector <VolumeInterface *> getAllVolumeInterfaces_l() const;
624
625 sp<ThreadBase> openInput_l(audio_module_handle_t module,
Eric Laurentcf2c0212014-07-25 16:20:43 -0700626 audio_io_handle_t *input,
627 audio_config_t *config,
Eric Laurent83b88082014-06-20 18:31:16 -0700628 audio_devices_t device,
Eric Laurentcf2c0212014-07-25 16:20:43 -0700629 const String8& address,
630 audio_source_t source,
Mikhail Naganovb4e037e2019-01-14 15:56:33 -0800631 audio_input_flags_t flags,
632 audio_devices_t outputDevice,
633 const String8& outputDeviceAddress);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800634 sp<ThreadBase> openOutput_l(audio_module_handle_t module,
Eric Laurentcf2c0212014-07-25 16:20:43 -0700635 audio_io_handle_t *output,
636 audio_config_t *config,
637 audio_devices_t devices,
638 const String8& address,
Eric Laurent83b88082014-06-20 18:31:16 -0700639 audio_output_flags_t flags);
640
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700641 void closeOutputFinish(const sp<PlaybackThread>& thread);
642 void closeInputFinish(const sp<RecordThread>& thread);
Eric Laurent83b88082014-06-20 18:31:16 -0700643
Glenn Kasten6637baa2012-01-09 09:40:36 -0800644 // no range check, AudioFlinger::mLock held
645 bool streamMute_l(audio_stream_type_t stream) const
646 { return mStreamTypes[stream].mute; }
Eric Laurent73e26b62015-04-27 16:55:58 -0700647 void ioConfigChanged(audio_io_config_event event,
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700648 const sp<AudioIoDescriptor>& ioDesc,
649 pid_t pid = 0);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700650
Glenn Kasteneeecb982016-02-26 10:44:04 -0800651 // Allocate an audio_unique_id_t.
652 // Specific types are audio_io_handle_t, audio_session_t, effect ID (int),
653 // audio_module_handle_t, and audio_patch_handle_t.
Glenn Kastenbcefec32014-01-17 12:09:05 -0800654 // They all share the same ID space, but the namespaces are actually independent
655 // because there are separate KeyedVectors for each kind of ID.
Glenn Kasteneeecb982016-02-26 10:44:04 -0800656 // The return value is cast to the specific type depending on how the ID will be used.
Glenn Kastenbcefec32014-01-17 12:09:05 -0800657 // FIXME This API does not handle rollover to zero (for unsigned IDs),
658 // or from positive to negative (for signed IDs).
659 // Thus it may fail by returning an ID of the wrong sign,
660 // or by returning a non-unique ID.
Glenn Kasten9d003132016-04-06 14:38:09 -0700661 // This is the internal API. For the binder API see newAudioUniqueId().
Glenn Kasteneeecb982016-02-26 10:44:04 -0800662 audio_unique_id_t nextUniqueId(audio_unique_id_use_t use);
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800663
Glenn Kastend848eb42016-03-08 13:42:11 -0800664 status_t moveEffectChain_l(audio_session_t sessionId,
Glenn Kastena1117922012-01-26 10:53:32 -0800665 PlaybackThread *srcThread,
666 PlaybackThread *dstThread,
Eric Laurent39e94f82010-07-28 01:32:47 -0700667 bool reRegister);
Glenn Kasten7fd04222016-02-02 12:38:16 -0800668
Glenn Kasten02fe1bf2012-02-24 15:42:17 -0800669 // return thread associated with primary hardware device, or NULL
670 PlaybackThread *primaryPlaybackThread_l() const;
Glenn Kastenbb4350d2012-07-03 15:56:38 -0700671 audio_devices_t primaryOutputDevice_l() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700672
Glenn Kastena7335632016-06-09 17:09:53 -0700673 // return the playback thread with smallest HAL buffer size, and prefer fast
674 PlaybackThread *fastPlaybackThread_l() const;
675
Glenn Kastend848eb42016-03-08 13:42:11 -0800676 sp<PlaybackThread> getEffectThread_l(audio_session_t sessionId, int EffectId);
Eric Laurent717e1282012-06-29 16:36:52 -0700677
Mathias Agopian65ab4712010-07-14 17:59:35 -0700678
Mathias Agopian65ab4712010-07-14 17:59:35 -0700679 void removeClient_l(pid_t pid);
680 void removeNotificationClient(pid_t pid);
Eric Laurent5baf2af2013-09-12 17:37:00 -0700681 bool isNonOffloadableGlobalEffectEnabled_l();
682 void onNonOffloadableGlobalEffectEnable();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800683 bool isSessionAcquired_l(audio_session_t audioSession);
Eric Laurent813e2a72013-08-31 12:59:48 -0700684
Eric Laurentaaa44472014-09-12 17:41:50 -0700685 // Store an effect chain to mOrphanEffectChains keyed vector.
686 // Called when a thread exits and effects are still attached to it.
687 // If effects are later created on the same session, they will reuse the same
688 // effect chain and same instances in the effect library.
689 // return ALREADY_EXISTS if a chain with the same session already exists in
690 // mOrphanEffectChains. Note that this should never happen as there is only one
691 // chain for a given session and it is attached to only one thread at a time.
692 status_t putOrphanEffectChain_l(const sp<EffectChain>& chain);
693 // Get an effect chain for the specified session in mOrphanEffectChains and remove
694 // it if found. Returns 0 if not found (this is the most common case).
695 sp<EffectChain> getOrphanEffectChain_l(audio_session_t session);
696 // Called when the last effect handle on an effect instance is removed. If this
697 // effect belongs to an effect chain in mOrphanEffectChains, the chain is updated
698 // and removed from mOrphanEffectChains if it does not contain any effect.
699 // Return true if the effect was found in mOrphanEffectChains, false otherwise.
700 bool updateOrphanEffectChains(const sp<EffectModule>& effect);
701
Eric Laurent054d9d32015-04-24 08:48:48 -0700702 void broacastParametersToRecordThreads_l(const String8& keyValuePairs);
Mikhail Naganovb261ef52018-07-16 13:34:38 -0700703 void forwardParametersToDownstreamPatches_l(
704 audio_io_handle_t upStream, const String8& keyValuePairs,
705 std::function<bool(const sp<PlaybackThread>&)> useThread = nullptr);
John Grossmanee578c02012-07-23 17:05:46 -0700706
Phil Burk062e67a2015-02-11 13:40:50 -0800707 // AudioStreamIn is immutable, so their fields are const.
Glenn Kastenaed850d2012-01-26 09:46:34 -0800708 // For emphasis, we could also make all pointers to them be "const *",
709 // but that would clutter the code unnecessarily.
710
Dima Zavin799a70e2011-04-18 16:57:27 -0700711 struct AudioStreamIn {
John Grossmanee578c02012-07-23 17:05:46 -0700712 AudioHwDevice* const audioHwDev;
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700713 sp<StreamInHalInterface> stream;
Eric Laurent05067782016-06-01 18:27:28 -0700714 audio_input_flags_t flags;
Dima Zavin799a70e2011-04-18 16:57:27 -0700715
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700716 sp<DeviceHalInterface> hwDev() const { return audioHwDev->hwDevice(); }
John Grossmanee578c02012-07-23 17:05:46 -0700717
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700718 AudioStreamIn(AudioHwDevice *dev, sp<StreamInHalInterface> in, audio_input_flags_t flags) :
Eric Laurent05067782016-06-01 18:27:28 -0700719 audioHwDev(dev), stream(in), flags(flags) {}
Dima Zavin799a70e2011-04-18 16:57:27 -0700720 };
721
Glenn Kasten99e53b82012-01-19 08:59:58 -0800722 // for mAudioSessionRefs only
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700723 struct AudioSessionRef {
Glenn Kastend848eb42016-03-08 13:42:11 -0800724 AudioSessionRef(audio_session_t sessionid, pid_t pid) :
Glenn Kasten012ca6b2012-03-06 11:22:01 -0800725 mSessionid(sessionid), mPid(pid), mCnt(1) {}
Glenn Kastend848eb42016-03-08 13:42:11 -0800726 const audio_session_t mSessionid;
Glenn Kasten012ca6b2012-03-06 11:22:01 -0800727 const pid_t mPid;
728 int mCnt;
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700729 };
730
Mathias Agopian65ab4712010-07-14 17:59:35 -0700731 mutable Mutex mLock;
Eric Laurent021cf962014-05-13 10:18:14 -0700732 // protects mClients and mNotificationClients.
733 // must be locked after mLock and ThreadBase::mLock if both must be locked
734 // avoids acquiring AudioFlinger::mLock from inside thread loop.
735 mutable Mutex mClientLock;
736 // protected by mClientLock
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800737 DefaultKeyedVector< pid_t, wp<Client> > mClients; // see ~Client()
Mathias Agopian65ab4712010-07-14 17:59:35 -0700738
739 mutable Mutex mHardwareLock;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700740 // NOTE: If both mLock and mHardwareLock mutexes must be held,
741 // always take mLock before mHardwareLock
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800742
743 // These two fields are immutable after onFirstRef(), so no lock needed to access
John Grossmanee578c02012-07-23 17:05:46 -0700744 AudioHwDevice* mPrimaryHardwareDev; // mAudioHwDevs[0] or NULL
Eric Laurenta4c5a552012-03-29 10:12:40 -0700745 DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*> mAudioHwDevs;
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800746
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700747 sp<DevicesFactoryHalInterface> mDevicesFactoryHal;
748
Glenn Kasten8abf44d2012-02-02 14:16:03 -0800749 // for dump, indicates which hardware operation is currently in progress (but not stream ops)
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800750 enum hardware_call_state {
Glenn Kasten8abf44d2012-02-02 14:16:03 -0800751 AUDIO_HW_IDLE = 0, // no operation in progress
752 AUDIO_HW_INIT, // init_check
753 AUDIO_HW_OUTPUT_OPEN, // open_output_stream
754 AUDIO_HW_OUTPUT_CLOSE, // unused
755 AUDIO_HW_INPUT_OPEN, // unused
756 AUDIO_HW_INPUT_CLOSE, // unused
757 AUDIO_HW_STANDBY, // unused
758 AUDIO_HW_SET_MASTER_VOLUME, // set_master_volume
759 AUDIO_HW_GET_ROUTING, // unused
760 AUDIO_HW_SET_ROUTING, // unused
761 AUDIO_HW_GET_MODE, // unused
762 AUDIO_HW_SET_MODE, // set_mode
763 AUDIO_HW_GET_MIC_MUTE, // get_mic_mute
764 AUDIO_HW_SET_MIC_MUTE, // set_mic_mute
765 AUDIO_HW_SET_VOICE_VOLUME, // set_voice_volume
766 AUDIO_HW_SET_PARAMETER, // set_parameters
767 AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size
768 AUDIO_HW_GET_MASTER_VOLUME, // get_master_volume
769 AUDIO_HW_GET_PARAMETER, // get_parameters
John Grossmand8f178d2012-07-20 14:51:35 -0700770 AUDIO_HW_SET_MASTER_MUTE, // set_master_mute
771 AUDIO_HW_GET_MASTER_MUTE, // get_master_mute
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800772 };
773
Glenn Kastena4454b42012-01-04 11:02:33 -0800774 mutable hardware_call_state mHardwareStatus; // for dump only
Mathias Agopian65ab4712010-07-14 17:59:35 -0700775
776
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800777 DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> > mPlaybackThreads;
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800778 stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
Glenn Kasten98067102011-12-13 11:47:54 -0800779
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700780 // member variables below are protected by mLock
Mathias Agopian65ab4712010-07-14 17:59:35 -0700781 float mMasterVolume;
782 bool mMasterMute;
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +0100783 float mMasterBalance = 0.f;
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700784 // end of variables protected by mLock
Mathias Agopian65ab4712010-07-14 17:59:35 -0700785
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800786 DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> > mRecordThreads;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700787
Eric Laurent021cf962014-05-13 10:18:14 -0700788 // protected by mClientLock
Mathias Agopian65ab4712010-07-14 17:59:35 -0700789 DefaultKeyedVector< pid_t, sp<NotificationClient> > mNotificationClients;
Glenn Kastenbcefec32014-01-17 12:09:05 -0800790
Glenn Kastend2e67e12016-04-11 08:26:37 -0700791 // updated by atomic_fetch_add_explicit
792 volatile atomic_uint_fast32_t mNextUniqueIds[AUDIO_UNIQUE_ID_USE_MAX];
Glenn Kastenbcefec32014-01-17 12:09:05 -0800793
Glenn Kastenf78aee72012-01-04 11:00:47 -0800794 audio_mode_t mMode;
Eric Laurentd8365c52017-07-16 15:27:05 -0700795 std::atomic_bool mBtNrecIsOff;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700796
Glenn Kasten99e53b82012-01-19 08:59:58 -0800797 // protected by mLock
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700798 Vector<AudioSessionRef*> mAudioSessionRefs;
Glenn Kasten98067102011-12-13 11:47:54 -0800799
John Grossman4ff14ba2012-02-08 16:37:41 -0800800 float masterVolume_l() const;
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +0100801 float getMasterBalance_l() const;
John Grossmand8f178d2012-07-20 14:51:35 -0700802 bool masterMute_l() const;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700803 audio_module_handle_t loadHwModule_l(const char *name);
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800804
Eric Laurenta011e352012-03-29 15:51:43 -0700805 Vector < sp<SyncEvent> > mPendingSyncEvents; // sync events awaiting for a session
806 // to be created
807
Eric Laurentaaa44472014-09-12 17:41:50 -0700808 // Effect chains without a valid thread
809 DefaultKeyedVector< audio_session_t , sp<EffectChain> > mOrphanEffectChains;
810
Eric Laurentfa90e842014-10-17 18:12:31 -0700811 // list of sessions for which a valid HW A/V sync ID was retrieved from the HAL
812 DefaultKeyedVector< audio_session_t , audio_hw_sync_t >mHwAvSyncIds;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800813
814 // list of MMAP stream control threads. Those threads allow for wake lock, routing
815 // and volume control for activity on the associated MMAP stream at the HAL.
816 // Audio data transfer is directly handled by the client creating the MMAP stream
817 DefaultKeyedVector< audio_io_handle_t, sp<MmapThread> > mMmapThreads;
818
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800819private:
Eric Laurent021cf962014-05-13 10:18:14 -0700820 sp<Client> registerPid(pid_t pid); // always returns non-0
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800821
Glenn Kastend96c5722012-04-25 13:44:49 -0700822 // for use from destructor
823 status_t closeOutput_nonvirtual(audio_io_handle_t output);
Mikhail Naganov444ecc32018-05-01 17:40:05 -0700824 void closeThreadInternal_l(const sp<PlaybackThread>& thread);
Glenn Kastend96c5722012-04-25 13:44:49 -0700825 status_t closeInput_nonvirtual(audio_io_handle_t input);
Mikhail Naganov444ecc32018-05-01 17:40:05 -0700826 void closeThreadInternal_l(const sp<RecordThread>& thread);
Eric Laurentfa90e842014-10-17 18:12:31 -0700827 void setAudioHwSyncForSession_l(PlaybackThread *thread, audio_session_t sessionId);
Glenn Kastend06785b2012-09-30 12:29:28 -0700828
Eric Laurent223fd5c2014-11-11 13:43:36 -0800829 status_t checkStreamType(audio_stream_type_t stream) const;
830
Eric Laurentf1047e82018-04-16 19:18:20 -0700831 void filterReservedParameters(String8& keyValuePairs, uid_t callingUid);
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -0700832 void logFilteredParameters(size_t originalKVPSize, const String8& originalKVPs,
833 size_t rejectedKVPSize, const String8& rejectedKVPs,
834 uid_t callingUid);
Eric Laurentf1047e82018-04-16 19:18:20 -0700835
Glenn Kastend06785b2012-09-30 12:29:28 -0700836public:
Andy Hung6f248bb2018-01-23 14:04:37 -0800837 // These methods read variables atomically without mLock,
838 // though the variables are updated with mLock.
Glenn Kasten4182c4e2013-07-15 14:45:07 -0700839 bool isLowRamDevice() const { return mIsLowRamDevice; }
Andy Hung6f248bb2018-01-23 14:04:37 -0800840 size_t getClientSharedHeapSize() const;
Glenn Kasten4182c4e2013-07-15 14:45:07 -0700841
842private:
Andy Hung6f248bb2018-01-23 14:04:37 -0800843 std::atomic<bool> mIsLowRamDevice;
Glenn Kasten4182c4e2013-07-15 14:45:07 -0700844 bool mIsDeviceTypeKnown;
Andy Hung6f248bb2018-01-23 14:04:37 -0800845 int64_t mTotalMemory;
846 std::atomic<size_t> mClientSharedHeapSize;
847 static constexpr size_t kMinimumClientSharedHeapSizeBytes = 1024 * 1024; // 1MB
848
Eric Laurent813e2a72013-08-31 12:59:48 -0700849 nsecs_t mGlobalEffectEnableTime; // when a global effect was last enabled
Eric Laurent1c333e22014-05-20 10:48:17 -0700850
Mikhail Naganovdea53042018-04-26 13:10:21 -0700851 // protected by mLock
852 PatchPanel mPatchPanel;
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700853 sp<EffectsFactoryHalInterface> mEffectsFactoryHal;
Glenn Kasten4ea00a22014-06-02 08:29:22 -0700854
Kevin Rocarda0a5d2a2018-08-06 15:03:18 -0700855 bool mSystemReady;
856
857 SimpleLog mRejectedSetParameterLog;
858 SimpleLog mAppSetParameterLog;
859 SimpleLog mSystemSetParameterLog;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700860};
861
Eric Laurent81784c32012-11-19 14:55:58 -0800862#undef INCLUDING_FROM_AUDIOFLINGER_H
Dima Zavin799a70e2011-04-18 16:57:27 -0700863
Mikhail Naganov913d06c2016-11-01 12:49:22 -0700864std::string formatToString(audio_format_t format);
865std::string inputFlagsToString(audio_input_flags_t flags);
866std::string outputFlagsToString(audio_output_flags_t flags);
867std::string devicesToString(audio_devices_t devices);
Glenn Kasten0f5b5622015-02-18 14:33:30 -0800868const char *sourceToString(audio_source_t source);
Marco Nelissenb2208842014-02-07 14:00:50 -0800869
Mathias Agopian65ab4712010-07-14 17:59:35 -0700870// ----------------------------------------------------------------------------
871
Glenn Kasten63238ef2015-03-02 15:50:29 -0800872} // namespace android
Mathias Agopian65ab4712010-07-14 17:59:35 -0700873
874#endif // ANDROID_AUDIO_FLINGER_H