blob: fb83d75e7b4d128d1053947d5a9a1de677e33983 [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 Tan7b651152018-07-13 10:17:19 -070026#include <memory>
27#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 Hung293558a2017-03-21 12:19:20 -070067#include <audio_utils/SimpleLog.h>
Andy Hung2e2c0bb2018-06-11 19:13:11 -070068#include <audio_utils/TimestampVerifier.h>
Andy Hung293558a2017-03-21 12:19:20 -070069
Glenn Kasten6dbb5e32014-05-13 10:38:42 -070070#include "FastCapture.h"
Glenn Kasten58912562012-04-03 10:45:00 -070071#include "FastMixer.h"
Glenn Kasten2dd4bdd2012-08-29 11:10:32 -070072#include <media/nbaio/NBAIO.h>
Glenn Kastenc15d6652012-05-30 14:52:57 -070073#include "AudioWatchdog.h"
Phil Burk062e67a2015-02-11 13:40:50 -080074#include "AudioStreamOut.h"
75#include "SpdifStreamOut.h"
76#include "AudioHwDevice.h"
Andy Hung8946a282018-04-19 20:04:56 -070077#include "NBAIO_Tee.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070078
Eric Laurentfeb0db62011-07-22 09:04:31 -070079#include <powermanager/IPowerManager.h>
80
Glenn Kasten8589ce72017-09-08 17:03:42 -070081#include <media/nblog/NBLog.h>
Glenn Kasten444841f2016-12-16 15:36:43 -080082#include <private/media/AudioEffectShared.h>
Glenn Kasten9f80dd22012-12-18 15:57:32 -080083#include <private/media/AudioTrackShared.h>
Glenn Kasten9e58b552013-01-18 15:09:48 -080084
Ivan Lozanoff6900d2017-08-01 15:47:38 -070085#include "android/media/BnAudioRecord.h"
86
Mathias Agopian65ab4712010-07-14 17:59:35 -070087namespace android {
88
Mathias Agopian65ab4712010-07-14 17:59:35 -070089class AudioMixer;
90class AudioBuffer;
91class AudioResampler;
Mikhail Naganove4f1f632016-08-31 11:35:10 -070092class DeviceHalInterface;
93class DevicesFactoryHalInterface;
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -070094class EffectsFactoryHalInterface;
Glenn Kasten58912562012-04-03 10:45:00 -070095class FastMixer;
Andy Hungd330ee42015-04-20 13:23:41 -070096class PassthruBufferProvider;
Andy Hung89816052017-01-11 17:08:23 -080097class RecordBufferConverter;
Glenn Kastene3aa6592012-12-04 12:22:46 -080098class ServerProxy;
Mathias Agopian65ab4712010-07-14 17:59:35 -070099
Mathias Agopian65ab4712010-07-14 17:59:35 -0700100// ----------------------------------------------------------------------------
101
John Grossman4ff14ba2012-02-08 16:37:41 -0800102static const nsecs_t kDefaultStandbyTimeInNsecs = seconds(3);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700103
Eric Laurent81784c32012-11-19 14:55:58 -0800104#define INCLUDING_FROM_AUDIOFLINGER_H
105
Mathias Agopian5462fc92010-07-14 18:41:18 -0700106class AudioFlinger :
107 public BinderService<AudioFlinger>,
108 public BnAudioFlinger
Mathias Agopian65ab4712010-07-14 17:59:35 -0700109{
Glenn Kasten19986612012-03-09 12:07:30 -0800110 friend class BinderService<AudioFlinger>; // for AudioFlinger()
Eric Laurentfc235202016-12-20 18:48:17 -0800111
Mathias Agopian65ab4712010-07-14 17:59:35 -0700112public:
Mathias Agopiane762be92013-05-09 16:26:45 -0700113 static const char* getServiceName() ANDROID_API { return "media.audio_flinger"; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700114
115 virtual status_t dump(int fd, const Vector<String16>& args);
Eric Tan7b651152018-07-13 10:17:19 -0700116 std::string getJsonString();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700117
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800118 // IAudioFlinger interface, in binder opcode order
Eric Laurent21da6472017-11-09 16:29:26 -0800119 virtual sp<IAudioTrack> createTrack(const CreateTrackInput& input,
120 CreateTrackOutput& output,
121 status_t *status);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700122
Eric Laurentf14db3c2017-12-08 14:20:36 -0800123 virtual sp<media::IAudioRecord> createRecord(const CreateRecordInput& input,
124 CreateRecordOutput& output,
125 status_t *status);
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800126
Glenn Kasten2c073da2016-02-26 09:14:08 -0800127 virtual uint32_t sampleRate(audio_io_handle_t ioHandle) const;
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800128 virtual audio_format_t format(audio_io_handle_t output) const;
Glenn Kasten2c073da2016-02-26 09:14:08 -0800129 virtual size_t frameCount(audio_io_handle_t ioHandle) const;
Glenn Kasten4a8308b2016-04-18 14:10:01 -0700130 virtual size_t frameCountHAL(audio_io_handle_t ioHandle) const;
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800131 virtual uint32_t latency(audio_io_handle_t output) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700132
133 virtual status_t setMasterVolume(float value);
134 virtual status_t setMasterMute(bool muted);
135
136 virtual float masterVolume() const;
137 virtual bool masterMute() const;
138
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800139 virtual status_t setStreamVolume(audio_stream_type_t stream, float value,
140 audio_io_handle_t output);
Glenn Kastenfff6d712012-01-12 16:38:12 -0800141 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700142
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800143 virtual float streamVolume(audio_stream_type_t stream,
144 audio_io_handle_t output) const;
Glenn Kastenfff6d712012-01-12 16:38:12 -0800145 virtual bool streamMute(audio_stream_type_t stream) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700146
Glenn Kastenf78aee72012-01-04 11:00:47 -0800147 virtual status_t setMode(audio_mode_t mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700148
149 virtual status_t setMicMute(bool state);
150 virtual bool getMicMute() const;
151
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800152 virtual void setRecordSilenced(uid_t uid, bool silenced);
153
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800154 virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs);
155 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700156
157 virtual void registerClient(const sp<IAudioFlingerClient>& client);
158
Glenn Kastendd8104c2012-07-02 12:42:44 -0700159 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format,
160 audio_channel_mask_t channelMask) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700161
Eric Laurentcf2c0212014-07-25 16:20:43 -0700162 virtual status_t openOutput(audio_module_handle_t module,
163 audio_io_handle_t *output,
164 audio_config_t *config,
165 audio_devices_t *devices,
166 const String8& address,
167 uint32_t *latencyMs,
168 audio_output_flags_t flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700169
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800170 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
171 audio_io_handle_t output2);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700172
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800173 virtual status_t closeOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700174
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800175 virtual status_t suspendOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700176
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800177 virtual status_t restoreOutput(audio_io_handle_t output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700178
Eric Laurentcf2c0212014-07-25 16:20:43 -0700179 virtual status_t openInput(audio_module_handle_t module,
180 audio_io_handle_t *input,
181 audio_config_t *config,
182 audio_devices_t *device,
183 const String8& address,
184 audio_source_t source,
185 audio_input_flags_t flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700186
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800187 virtual status_t closeInput(audio_io_handle_t input);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700188
Glenn Kastend2304db2014-02-03 07:40:31 -0800189 virtual status_t invalidateStream(audio_stream_type_t stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700190
191 virtual status_t setVoiceVolume(float volume);
192
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000193 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800194 audio_io_handle_t output) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700195
Glenn Kasten5f972c02014-01-13 09:59:31 -0800196 virtual uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const;
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800197
Glenn Kasten9d003132016-04-06 14:38:09 -0700198 // This is the binder API. For the internal API see nextUniqueId().
Glenn Kasteneeecb982016-02-26 10:44:04 -0800199 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700200
Glenn Kastend848eb42016-03-08 13:42:11 -0800201 virtual void acquireAudioSessionId(audio_session_t audioSession, pid_t pid);
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700202
Glenn Kastend848eb42016-03-08 13:42:11 -0800203 virtual void releaseAudioSessionId(audio_session_t audioSession, pid_t pid);
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700204
Glenn Kastenf587ba52012-01-26 16:25:10 -0800205 virtual status_t queryNumberEffects(uint32_t *numEffects) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700206
Glenn Kastenf587ba52012-01-26 16:25:10 -0800207 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700208
Glenn Kasten5e92a782012-01-30 07:40:52 -0800209 virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid,
Glenn Kastenf587ba52012-01-26 16:25:10 -0800210 effect_descriptor_t *descriptor) const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700211
Glenn Kasten8d6cc842012-02-03 11:06:53 -0800212 virtual sp<IEffect> createEffect(
Mathias Agopian65ab4712010-07-14 17:59:35 -0700213 effect_descriptor_t *pDesc,
214 const sp<IEffectClient>& effectClient,
215 int32_t priority,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800216 audio_io_handle_t io,
Glenn Kastend848eb42016-03-08 13:42:11 -0800217 audio_session_t sessionId,
Svet Ganovbe71aa22015-04-28 12:06:02 -0700218 const String16& opPackageName,
Eric Laurentb6436272016-12-07 19:24:50 -0800219 pid_t pid,
Glenn Kasten9156ef32013-08-06 15:39:08 -0700220 status_t *status /*non-NULL*/,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700221 int *id,
222 int *enabled);
223
Glenn Kastend848eb42016-03-08 13:42:11 -0800224 virtual status_t moveEffects(audio_session_t sessionId, audio_io_handle_t srcOutput,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800225 audio_io_handle_t dstOutput);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700226
Eric Laurenta4c5a552012-03-29 10:12:40 -0700227 virtual audio_module_handle_t loadHwModule(const char *name);
228
Glenn Kasten3b16c762012-11-14 08:44:39 -0800229 virtual uint32_t getPrimaryOutputSamplingRate();
Glenn Kastene33054e2012-11-14 12:54:39 -0800230 virtual size_t getPrimaryOutputFrameCount();
Glenn Kastencc0f1cf2012-09-24 11:27:18 -0700231
Andy Hung6f248bb2018-01-23 14:04:37 -0800232 virtual status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) override;
Glenn Kasten4182c4e2013-07-15 14:45:07 -0700233
Eric Laurent4b123402014-04-11 09:22:20 -0700234 /* List available audio ports and their attributes */
235 virtual status_t listAudioPorts(unsigned int *num_ports,
Eric Laurent1c333e22014-05-20 10:48:17 -0700236 struct audio_port *ports);
Eric Laurent4b123402014-04-11 09:22:20 -0700237
238 /* Get attributes for a given audio port */
Eric Laurent1c333e22014-05-20 10:48:17 -0700239 virtual status_t getAudioPort(struct audio_port *port);
Eric Laurent4b123402014-04-11 09:22:20 -0700240
241 /* Create an audio patch between several source and sink ports */
242 virtual status_t createAudioPatch(const struct audio_patch *patch,
Eric Laurent1c333e22014-05-20 10:48:17 -0700243 audio_patch_handle_t *handle);
Eric Laurent4b123402014-04-11 09:22:20 -0700244
245 /* Release an audio patch */
Eric Laurent1c333e22014-05-20 10:48:17 -0700246 virtual status_t releaseAudioPatch(audio_patch_handle_t handle);
Eric Laurent4b123402014-04-11 09:22:20 -0700247
248 /* List existing audio patches */
249 virtual status_t listAudioPatches(unsigned int *num_patches,
Eric Laurent1c333e22014-05-20 10:48:17 -0700250 struct audio_patch *patches);
251
Eric Laurent4b123402014-04-11 09:22:20 -0700252 /* Set audio port configuration */
Eric Laurent1c333e22014-05-20 10:48:17 -0700253 virtual status_t setAudioPortConfig(const struct audio_port_config *config);
Eric Laurent4b123402014-04-11 09:22:20 -0700254
Eric Laurent93c3d412014-08-01 14:48:35 -0700255 /* Get the HW synchronization source used for an audio session */
256 virtual audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId);
257
Eric Laurent72e3f392015-05-20 14:43:50 -0700258 /* Indicate JAVA services are ready (scheduling, power management ...) */
259 virtual status_t systemReady();
260
jiabin46a76fa2018-01-05 10:18:21 -0800261 virtual status_t getMicrophones(std::vector<media::MicrophoneInfo> *microphones);
262
Mathias Agopian65ab4712010-07-14 17:59:35 -0700263 virtual status_t onTransact(
264 uint32_t code,
265 const Parcel& data,
266 Parcel* reply,
267 uint32_t flags);
268
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800269 // end of IAudioFlinger interface
270
Glenn Kasten9e58b552013-01-18 15:09:48 -0800271 sp<NBLog::Writer> newWriter_l(size_t size, const char *name);
272 void unregisterWriter(const sp<NBLog::Writer>& writer);
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700273 sp<EffectsFactoryHalInterface> getEffectsFactory();
Eric Laurentfc235202016-12-20 18:48:17 -0800274
275 status_t openMmapStream(MmapStreamInterface::stream_direction_t direction,
276 const audio_attributes_t *attr,
277 audio_config_base_t *config,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700278 const AudioClient& client,
Eric Laurentfc235202016-12-20 18:48:17 -0800279 audio_port_handle_t *deviceId,
Phil Burk4e1af9f2018-01-03 15:54:35 -0800280 audio_session_t *sessionId,
Eric Laurentfc235202016-12-20 18:48:17 -0800281 const sp<MmapStreamCallback>& callback,
Eric Laurentcb4dae22017-07-01 19:39:32 -0700282 sp<MmapStreamInterface>& interface,
283 audio_port_handle_t *handle);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800284private:
Glenn Kasteneef598c2017-04-03 14:41:13 -0700285 // FIXME The 400 is temporarily too high until a leak of writers in media.log is fixed.
286 static const size_t kLogMemorySize = 400 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -0800287 sp<MemoryDealer> mLogMemoryDealer; // == 0 when NBLog is disabled
Glenn Kasten481fb672013-09-30 14:39:28 -0700288 // When a log writer is unregistered, it is done lazily so that media.log can continue to see it
289 // for as long as possible. The memory is only freed when it is needed for another log writer.
290 Vector< sp<NBLog::Writer> > mUnregisteredWriters;
291 Mutex mUnregisteredWritersLock;
Eric Laurentfc235202016-12-20 18:48:17 -0800292
Glenn Kasten9e58b552013-01-18 15:09:48 -0800293public:
294
Eric Laurenta011e352012-03-29 15:51:43 -0700295 class SyncEvent;
296
297 typedef void (*sync_event_callback_t)(const wp<SyncEvent>& event) ;
298
299 class SyncEvent : public RefBase {
300 public:
301 SyncEvent(AudioSystem::sync_event_t type,
Glenn Kastend848eb42016-03-08 13:42:11 -0800302 audio_session_t triggerSession,
303 audio_session_t listenerSession,
Eric Laurenta011e352012-03-29 15:51:43 -0700304 sync_event_callback_t callBack,
Eric Laurent8ea16e42014-02-20 16:26:11 -0800305 wp<RefBase> cookie)
Eric Laurenta011e352012-03-29 15:51:43 -0700306 : mType(type), mTriggerSession(triggerSession), mListenerSession(listenerSession),
307 mCallback(callBack), mCookie(cookie)
308 {}
309
310 virtual ~SyncEvent() {}
311
312 void trigger() { Mutex::Autolock _l(mLock); if (mCallback) mCallback(this); }
Glenn Kasten106e8a42012-08-02 13:37:12 -0700313 bool isCancelled() const { Mutex::Autolock _l(mLock); return (mCallback == NULL); }
314 void cancel() { Mutex::Autolock _l(mLock); mCallback = NULL; }
Eric Laurenta011e352012-03-29 15:51:43 -0700315 AudioSystem::sync_event_t type() const { return mType; }
Glenn Kastend848eb42016-03-08 13:42:11 -0800316 audio_session_t triggerSession() const { return mTriggerSession; }
317 audio_session_t listenerSession() const { return mListenerSession; }
Eric Laurent8ea16e42014-02-20 16:26:11 -0800318 wp<RefBase> cookie() const { return mCookie; }
Eric Laurenta011e352012-03-29 15:51:43 -0700319
320 private:
321 const AudioSystem::sync_event_t mType;
Glenn Kastend848eb42016-03-08 13:42:11 -0800322 const audio_session_t mTriggerSession;
323 const audio_session_t mListenerSession;
Eric Laurenta011e352012-03-29 15:51:43 -0700324 sync_event_callback_t mCallback;
Eric Laurent8ea16e42014-02-20 16:26:11 -0800325 const wp<RefBase> mCookie;
Glenn Kasten106e8a42012-08-02 13:37:12 -0700326 mutable Mutex mLock;
Eric Laurenta011e352012-03-29 15:51:43 -0700327 };
328
329 sp<SyncEvent> createSyncEvent(AudioSystem::sync_event_t type,
Glenn Kastend848eb42016-03-08 13:42:11 -0800330 audio_session_t triggerSession,
331 audio_session_t listenerSession,
Eric Laurenta011e352012-03-29 15:51:43 -0700332 sync_event_callback_t callBack,
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700333 const wp<RefBase>& cookie);
Eric Laurent717e1282012-06-29 16:36:52 -0700334
Eric Laurentd8365c52017-07-16 15:27:05 -0700335 bool btNrecIsOff() const { return mBtNrecIsOff.load(); }
336
337
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800338private:
John Grossmanee578c02012-07-23 17:05:46 -0700339
Glenn Kastenf78aee72012-01-04 11:00:47 -0800340 audio_mode_t getMode() const { return mMode; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700341
Mathias Agopiane762be92013-05-09 16:26:45 -0700342 AudioFlinger() ANDROID_API;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700343 virtual ~AudioFlinger();
344
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800345 // call in any IAudioFlinger method that accesses mPrimaryHardwareDev
Glenn Kasten85ab62c2012-11-01 11:11:38 -0700346 status_t initCheck() const { return mPrimaryHardwareDev == NULL ?
347 NO_INIT : NO_ERROR; }
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800348
Glenn Kasten000f0e32012-03-01 17:10:56 -0800349 // RefBase
Dima Zavin5a61d2f2011-04-19 19:04:32 -0700350 virtual void onFirstRef();
Glenn Kasten000f0e32012-03-01 17:10:56 -0800351
Glenn Kasten85ab62c2012-11-01 11:11:38 -0700352 AudioHwDevice* findSuitableHwDev_l(audio_module_handle_t module,
353 audio_devices_t devices);
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700354 void purgeStaleEffects_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700355
Andy Hung9a592762014-07-21 21:56:01 -0700356 // Set kEnableExtendedChannels to true to enable greater than stereo output
357 // for the MixerThread and device sink. Number of channels allowed is
358 // FCC_2 <= channels <= AudioMixer::MAX_NUM_CHANNELS.
Andy Hungb1ee3952014-07-28 16:28:06 -0700359 static const bool kEnableExtendedChannels = true;
Andy Hung9a592762014-07-21 21:56:01 -0700360
361 // Returns true if channel mask is permitted for the PCM sink in the MixerThread
362 static inline bool isValidPcmSinkChannelMask(audio_channel_mask_t channelMask) {
363 switch (audio_channel_mask_get_representation(channelMask)) {
364 case AUDIO_CHANNEL_REPRESENTATION_POSITION: {
365 uint32_t channelCount = FCC_2; // stereo is default
366 if (kEnableExtendedChannels) {
367 channelCount = audio_channel_count_from_out_mask(channelMask);
Andy Hung389cfdb2014-08-07 17:49:53 -0700368 if (channelCount < FCC_2 // mono is not supported at this time
369 || channelCount > AudioMixer::MAX_NUM_CHANNELS) {
Andy Hung9a592762014-07-21 21:56:01 -0700370 return false;
371 }
372 }
373 // check that channelMask is the "canonical" one we expect for the channelCount.
374 return channelMask == audio_channel_out_mask_from_count(channelCount);
375 }
Andy Hung64b6cb22015-05-19 12:32:58 -0700376 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
377 if (kEnableExtendedChannels) {
378 const uint32_t channelCount = audio_channel_count_from_out_mask(channelMask);
379 if (channelCount >= FCC_2 // mono is not supported at this time
380 && channelCount <= AudioMixer::MAX_NUM_CHANNELS) {
381 return true;
382 }
383 }
384 return false;
Andy Hung9a592762014-07-21 21:56:01 -0700385 default:
386 return false;
387 }
388 }
389
Andy Hung6146c082014-03-18 11:56:15 -0700390 // Set kEnableExtendedPrecision to true to use extended precision in MixerThread
Andy Hunga494e822014-07-08 18:09:40 -0700391 static const bool kEnableExtendedPrecision = true;
Andy Hung6146c082014-03-18 11:56:15 -0700392
393 // Returns true if format is permitted for the PCM sink in the MixerThread
394 static inline bool isValidPcmSinkFormat(audio_format_t format) {
395 switch (format) {
396 case AUDIO_FORMAT_PCM_16_BIT:
397 return true;
398 case AUDIO_FORMAT_PCM_FLOAT:
399 case AUDIO_FORMAT_PCM_24_BIT_PACKED:
400 case AUDIO_FORMAT_PCM_32_BIT:
401 case AUDIO_FORMAT_PCM_8_24_BIT:
402 return kEnableExtendedPrecision;
403 default:
404 return false;
405 }
406 }
407
Glenn Kasten66fcab92012-02-24 14:59:21 -0800408 // standby delay for MIXER and DUPLICATING playback threads is read from property
409 // ro.audio.flinger_standbytime_ms or defaults to kDefaultStandbyTimeInNsecs
John Grossman4ff14ba2012-02-08 16:37:41 -0800410 static nsecs_t mStandbyTimeInNsecs;
411
Eric Laurent81784c32012-11-19 14:55:58 -0800412 // incremented by 2 when screen state changes, bit 0 == 1 means "off"
413 // AudioFlinger::setParameters() updates, other threads read w/o lock
414 static uint32_t mScreenState;
415
Glenn Kastenbe5f05e2012-07-18 15:24:02 -0700416 // Internal dump utilities.
Eric Laurent81784c32012-11-19 14:55:58 -0800417 static const int kDumpLockRetries = 50;
418 static const int kDumpLockSleepUs = 20000;
419 static bool dumpTryLock(Mutex& mutex);
Glenn Kastenbe5f05e2012-07-18 15:24:02 -0700420 void dumpPermissionDenial(int fd, const Vector<String16>& args);
421 void dumpClients(int fd, const Vector<String16>& args);
422 void dumpInternals(int fd, const Vector<String16>& args);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700423
424 // --- Client ---
425 class Client : public RefBase {
426 public:
427 Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
428 virtual ~Client();
Glenn Kasten435dbe62012-01-30 10:15:48 -0800429 sp<MemoryDealer> heap() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700430 pid_t pid() const { return mPid; }
Glenn Kastenc59c0042012-02-02 14:06:11 -0800431 sp<AudioFlinger> audioFlinger() const { return mAudioFlinger; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700432
433 private:
Mikhail Naganovbf493082017-04-17 17:37:12 -0700434 DISALLOW_COPY_AND_ASSIGN(Client);
435
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800436 const sp<AudioFlinger> mAudioFlinger;
Eric Laurentda73b6c2015-08-20 16:18:53 -0700437 sp<MemoryDealer> mMemoryDealer;
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800438 const pid_t mPid;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700439 };
440
441 // --- Notification Client ---
442 class NotificationClient : public IBinder::DeathRecipient {
443 public:
444 NotificationClient(const sp<AudioFlinger>& audioFlinger,
445 const sp<IAudioFlingerClient>& client,
446 pid_t pid);
447 virtual ~NotificationClient();
448
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800449 sp<IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700450
451 // IBinder::DeathRecipient
452 virtual void binderDied(const wp<IBinder>& who);
453
454 private:
Mikhail Naganovbf493082017-04-17 17:37:12 -0700455 DISALLOW_COPY_AND_ASSIGN(NotificationClient);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700456
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800457 const sp<AudioFlinger> mAudioFlinger;
458 const pid_t mPid;
459 const sp<IAudioFlingerClient> mAudioFlingerClient;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700460 };
461
Nicolas Rouletdcdfaec2017-02-14 10:18:39 -0800462 // --- MediaLogNotifier ---
463 // Thread in charge of notifying MediaLogService to start merging.
464 // Receives requests from AudioFlinger's binder activity. It is used to reduce the amount of
465 // binder calls to MediaLogService in case of bursts of AudioFlinger binder calls.
466 class MediaLogNotifier : public Thread {
467 public:
468 MediaLogNotifier();
469
470 // Requests a MediaLogService notification. It's ignored if there has recently been another
471 void requestMerge();
472 private:
473 // Every iteration blocks waiting for a request, then interacts with MediaLogService to
474 // start merging.
475 // As every MediaLogService binder call is expensive, once it gets a request it ignores the
476 // following ones for a period of time.
477 virtual bool threadLoop() override;
478
479 bool mPendingRequests;
480
481 // Mutex and condition variable around mPendingRequests' value
482 Mutex mMutex;
483 Condition mCond;
484
485 // Duration of the sleep period after a processed request
486 static const int kPostTriggerSleepPeriod = 1000000;
487 };
488
489 const sp<MediaLogNotifier> mMediaLogNotifier;
490
491 // This is a helper that is called during incoming binder calls.
492 void requestLogMerge();
493
Mathias Agopian65ab4712010-07-14 17:59:35 -0700494 class TrackHandle;
495 class RecordHandle;
496 class RecordThread;
497 class PlaybackThread;
498 class MixerThread;
499 class DirectOutputThread;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800500 class OffloadThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700501 class DuplicatingThread;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800502 class AsyncCallbackThread;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700503 class Track;
504 class RecordTrack;
505 class EffectModule;
506 class EffectHandle;
507 class EffectChain;
Phil Burk062e67a2015-02-11 13:40:50 -0800508
Dima Zavin799a70e2011-04-18 16:57:27 -0700509 struct AudioStreamIn;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700510
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800511 struct stream_type_t {
512 stream_type_t()
513 : volume(1.0f),
Eric Laurent1a9ed112012-03-20 18:36:01 -0700514 mute(false)
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800515 {
516 }
517 float volume;
518 bool mute;
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800519 };
520
Mathias Agopian65ab4712010-07-14 17:59:35 -0700521 // --- PlaybackThread ---
rago94a1ee82017-07-21 15:11:02 -0700522#ifdef FLOAT_EFFECT_CHAIN
523#define EFFECT_BUFFER_FORMAT AUDIO_FORMAT_PCM_FLOAT
524using effect_buffer_t = float;
525#else
526#define EFFECT_BUFFER_FORMAT AUDIO_FORMAT_PCM_16_BIT
527using effect_buffer_t = int16_t;
528#endif
Eric Laurent81784c32012-11-19 14:55:58 -0800529
530#include "Threads.h"
531
532#include "Effects.h"
533
Eric Laurent1c333e22014-05-20 10:48:17 -0700534#include "PatchPanel.h"
535
Eric Laurent81784c32012-11-19 14:55:58 -0800536 // server side of the client's IAudioTrack
537 class TrackHandle : public android::BnAudioTrack {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700538 public:
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700539 explicit TrackHandle(const sp<PlaybackThread::Track>& track);
Eric Laurent81784c32012-11-19 14:55:58 -0800540 virtual ~TrackHandle();
541 virtual sp<IMemory> getCblk() const;
542 virtual status_t start();
543 virtual void stop();
544 virtual void flush();
Eric Laurent81784c32012-11-19 14:55:58 -0800545 virtual void pause();
546 virtual status_t attachAuxEffect(int effectId);
Glenn Kasten3dcd00d2013-07-17 10:10:23 -0700547 virtual status_t setParameters(const String8& keyValuePairs);
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700548 virtual media::VolumeShaper::Status applyVolumeShaper(
549 const sp<media::VolumeShaper::Configuration>& configuration,
550 const sp<media::VolumeShaper::Operation>& operation) override;
551 virtual sp<media::VolumeShaper::State> getVolumeShaperState(int id) override;
Glenn Kasten53cec222013-08-29 09:01:02 -0700552 virtual status_t getTimestamp(AudioTimestamp& timestamp);
Eric Laurent59fe0102013-09-27 18:48:26 -0700553 virtual void signal(); // signal playback thread for a change in control block
Glenn Kasten3dcd00d2013-07-17 10:10:23 -0700554
Eric Laurent81784c32012-11-19 14:55:58 -0800555 virtual status_t onTransact(
556 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
Richard Fitzgeraldad3af332013-03-25 16:54:37 +0000557
Glenn Kasten98067102011-12-13 11:47:54 -0800558 private:
Eric Laurent81784c32012-11-19 14:55:58 -0800559 const sp<PlaybackThread::Track> mTrack;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700560 };
561
Eric Laurent81784c32012-11-19 14:55:58 -0800562 // server side of the client's IAudioRecord
Ivan Lozanoff6900d2017-08-01 15:47:38 -0700563 class RecordHandle : public android::media::BnAudioRecord {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700564 public:
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700565 explicit RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack);
Eric Laurent81784c32012-11-19 14:55:58 -0800566 virtual ~RecordHandle();
Ivan Lozanoff6900d2017-08-01 15:47:38 -0700567 virtual binder::Status start(int /*AudioSystem::sync_event_t*/ event,
568 int /*audio_session_t*/ triggerSession);
569 virtual binder::Status stop();
jiabin653cc0a2018-01-17 17:54:10 -0800570 virtual binder::Status getActiveMicrophones(
571 std::vector<media::MicrophoneInfo>* activeMicrophones);
Glenn Kasten58912562012-04-03 10:45:00 -0700572 private:
Eric Laurent81784c32012-11-19 14:55:58 -0800573 const sp<RecordThread::RecordTrack> mRecordTrack;
Glenn Kasten58912562012-04-03 10:45:00 -0700574
Eric Laurent81784c32012-11-19 14:55:58 -0800575 // for use from destructor
576 void stop_nonvirtual();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700577 };
578
Eric Laurent6acd1d42017-01-04 14:23:29 -0800579 // Mmap stream control interface implementation. Each MmapThreadHandle controls one
580 // MmapPlaybackThread or MmapCaptureThread instance.
581 class MmapThreadHandle : public MmapStreamInterface {
582 public:
583 explicit MmapThreadHandle(const sp<MmapThread>& thread);
584 virtual ~MmapThreadHandle();
585
586 // MmapStreamInterface virtuals
587 virtual status_t createMmapBuffer(int32_t minSizeFrames,
588 struct audio_mmap_buffer_info *info);
589 virtual status_t getMmapPosition(struct audio_mmap_position *position);
Eric Laurentcb4dae22017-07-01 19:39:32 -0700590 virtual status_t start(const AudioClient& client,
Glenn Kastend3bb6452016-12-05 18:14:37 -0800591 audio_port_handle_t *handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800592 virtual status_t stop(audio_port_handle_t handle);
Eric Laurent18b57012017-02-13 16:23:52 -0800593 virtual status_t standby();
Eric Laurent6acd1d42017-01-04 14:23:29 -0800594
595 private:
Phil Burk9fabbf82017-08-03 12:02:00 -0700596 const sp<MmapThread> mThread;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800597 };
Eric Laurentbfb1b832013-01-07 09:53:42 -0800598
Glenn Kasteneeecb982016-02-26 10:44:04 -0800599 ThreadBase *checkThread_l(audio_io_handle_t ioHandle) const;
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800600 PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const;
601 MixerThread *checkMixerThread_l(audio_io_handle_t output) const;
602 RecordThread *checkRecordThread_l(audio_io_handle_t input) const;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800603 MmapThread *checkMmapThread_l(audio_io_handle_t io) const;
604 VolumeInterface *getVolumeInterface_l(audio_io_handle_t output) const;
605 Vector <VolumeInterface *> getAllVolumeInterfaces_l() const;
606
607 sp<ThreadBase> openInput_l(audio_module_handle_t module,
Eric Laurentcf2c0212014-07-25 16:20:43 -0700608 audio_io_handle_t *input,
609 audio_config_t *config,
Eric Laurent83b88082014-06-20 18:31:16 -0700610 audio_devices_t device,
Eric Laurentcf2c0212014-07-25 16:20:43 -0700611 const String8& address,
612 audio_source_t source,
Eric Laurent83b88082014-06-20 18:31:16 -0700613 audio_input_flags_t flags);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800614 sp<ThreadBase> openOutput_l(audio_module_handle_t module,
Eric Laurentcf2c0212014-07-25 16:20:43 -0700615 audio_io_handle_t *output,
616 audio_config_t *config,
617 audio_devices_t devices,
618 const String8& address,
Eric Laurent83b88082014-06-20 18:31:16 -0700619 audio_output_flags_t flags);
620
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700621 void closeOutputFinish(const sp<PlaybackThread>& thread);
622 void closeInputFinish(const sp<RecordThread>& thread);
Eric Laurent83b88082014-06-20 18:31:16 -0700623
Glenn Kasten6637baa2012-01-09 09:40:36 -0800624 // no range check, AudioFlinger::mLock held
625 bool streamMute_l(audio_stream_type_t stream) const
626 { return mStreamTypes[stream].mute; }
Eric Laurent73e26b62015-04-27 16:55:58 -0700627 void ioConfigChanged(audio_io_config_event event,
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700628 const sp<AudioIoDescriptor>& ioDesc,
629 pid_t pid = 0);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700630
Glenn Kasteneeecb982016-02-26 10:44:04 -0800631 // Allocate an audio_unique_id_t.
632 // Specific types are audio_io_handle_t, audio_session_t, effect ID (int),
633 // audio_module_handle_t, and audio_patch_handle_t.
Glenn Kastenbcefec32014-01-17 12:09:05 -0800634 // They all share the same ID space, but the namespaces are actually independent
635 // because there are separate KeyedVectors for each kind of ID.
Glenn Kasteneeecb982016-02-26 10:44:04 -0800636 // The return value is cast to the specific type depending on how the ID will be used.
Glenn Kastenbcefec32014-01-17 12:09:05 -0800637 // FIXME This API does not handle rollover to zero (for unsigned IDs),
638 // or from positive to negative (for signed IDs).
639 // Thus it may fail by returning an ID of the wrong sign,
640 // or by returning a non-unique ID.
Glenn Kasten9d003132016-04-06 14:38:09 -0700641 // This is the internal API. For the binder API see newAudioUniqueId().
Glenn Kasteneeecb982016-02-26 10:44:04 -0800642 audio_unique_id_t nextUniqueId(audio_unique_id_use_t use);
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800643
Glenn Kastend848eb42016-03-08 13:42:11 -0800644 status_t moveEffectChain_l(audio_session_t sessionId,
Glenn Kastena1117922012-01-26 10:53:32 -0800645 PlaybackThread *srcThread,
646 PlaybackThread *dstThread,
Eric Laurent39e94f82010-07-28 01:32:47 -0700647 bool reRegister);
Glenn Kasten7fd04222016-02-02 12:38:16 -0800648
Glenn Kasten02fe1bf2012-02-24 15:42:17 -0800649 // return thread associated with primary hardware device, or NULL
650 PlaybackThread *primaryPlaybackThread_l() const;
Glenn Kastenbb4350d2012-07-03 15:56:38 -0700651 audio_devices_t primaryOutputDevice_l() const;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700652
Glenn Kastena7335632016-06-09 17:09:53 -0700653 // return the playback thread with smallest HAL buffer size, and prefer fast
654 PlaybackThread *fastPlaybackThread_l() const;
655
Glenn Kastend848eb42016-03-08 13:42:11 -0800656 sp<PlaybackThread> getEffectThread_l(audio_session_t sessionId, int EffectId);
Eric Laurent717e1282012-06-29 16:36:52 -0700657
Mathias Agopian65ab4712010-07-14 17:59:35 -0700658
Mathias Agopian65ab4712010-07-14 17:59:35 -0700659 void removeClient_l(pid_t pid);
660 void removeNotificationClient(pid_t pid);
Eric Laurent5baf2af2013-09-12 17:37:00 -0700661 bool isNonOffloadableGlobalEffectEnabled_l();
662 void onNonOffloadableGlobalEffectEnable();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800663 bool isSessionAcquired_l(audio_session_t audioSession);
Eric Laurent813e2a72013-08-31 12:59:48 -0700664
Eric Laurentaaa44472014-09-12 17:41:50 -0700665 // Store an effect chain to mOrphanEffectChains keyed vector.
666 // Called when a thread exits and effects are still attached to it.
667 // If effects are later created on the same session, they will reuse the same
668 // effect chain and same instances in the effect library.
669 // return ALREADY_EXISTS if a chain with the same session already exists in
670 // mOrphanEffectChains. Note that this should never happen as there is only one
671 // chain for a given session and it is attached to only one thread at a time.
672 status_t putOrphanEffectChain_l(const sp<EffectChain>& chain);
673 // Get an effect chain for the specified session in mOrphanEffectChains and remove
674 // it if found. Returns 0 if not found (this is the most common case).
675 sp<EffectChain> getOrphanEffectChain_l(audio_session_t session);
676 // Called when the last effect handle on an effect instance is removed. If this
677 // effect belongs to an effect chain in mOrphanEffectChains, the chain is updated
678 // and removed from mOrphanEffectChains if it does not contain any effect.
679 // Return true if the effect was found in mOrphanEffectChains, false otherwise.
680 bool updateOrphanEffectChains(const sp<EffectModule>& effect);
681
Eric Laurent054d9d32015-04-24 08:48:48 -0700682 void broacastParametersToRecordThreads_l(const String8& keyValuePairs);
John Grossmanee578c02012-07-23 17:05:46 -0700683
Phil Burk062e67a2015-02-11 13:40:50 -0800684 // AudioStreamIn is immutable, so their fields are const.
Glenn Kastenaed850d2012-01-26 09:46:34 -0800685 // For emphasis, we could also make all pointers to them be "const *",
686 // but that would clutter the code unnecessarily.
687
Dima Zavin799a70e2011-04-18 16:57:27 -0700688 struct AudioStreamIn {
John Grossmanee578c02012-07-23 17:05:46 -0700689 AudioHwDevice* const audioHwDev;
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700690 sp<StreamInHalInterface> stream;
Eric Laurent05067782016-06-01 18:27:28 -0700691 audio_input_flags_t flags;
Dima Zavin799a70e2011-04-18 16:57:27 -0700692
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700693 sp<DeviceHalInterface> hwDev() const { return audioHwDev->hwDevice(); }
John Grossmanee578c02012-07-23 17:05:46 -0700694
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700695 AudioStreamIn(AudioHwDevice *dev, sp<StreamInHalInterface> in, audio_input_flags_t flags) :
Eric Laurent05067782016-06-01 18:27:28 -0700696 audioHwDev(dev), stream(in), flags(flags) {}
Dima Zavin799a70e2011-04-18 16:57:27 -0700697 };
698
Glenn Kasten99e53b82012-01-19 08:59:58 -0800699 // for mAudioSessionRefs only
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700700 struct AudioSessionRef {
Glenn Kastend848eb42016-03-08 13:42:11 -0800701 AudioSessionRef(audio_session_t sessionid, pid_t pid) :
Glenn Kasten012ca6b2012-03-06 11:22:01 -0800702 mSessionid(sessionid), mPid(pid), mCnt(1) {}
Glenn Kastend848eb42016-03-08 13:42:11 -0800703 const audio_session_t mSessionid;
Glenn Kasten012ca6b2012-03-06 11:22:01 -0800704 const pid_t mPid;
705 int mCnt;
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700706 };
707
Mathias Agopian65ab4712010-07-14 17:59:35 -0700708 mutable Mutex mLock;
Eric Laurent021cf962014-05-13 10:18:14 -0700709 // protects mClients and mNotificationClients.
710 // must be locked after mLock and ThreadBase::mLock if both must be locked
711 // avoids acquiring AudioFlinger::mLock from inside thread loop.
712 mutable Mutex mClientLock;
713 // protected by mClientLock
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800714 DefaultKeyedVector< pid_t, wp<Client> > mClients; // see ~Client()
Mathias Agopian65ab4712010-07-14 17:59:35 -0700715
716 mutable Mutex mHardwareLock;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700717 // NOTE: If both mLock and mHardwareLock mutexes must be held,
718 // always take mLock before mHardwareLock
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800719
720 // These two fields are immutable after onFirstRef(), so no lock needed to access
John Grossmanee578c02012-07-23 17:05:46 -0700721 AudioHwDevice* mPrimaryHardwareDev; // mAudioHwDevs[0] or NULL
Eric Laurenta4c5a552012-03-29 10:12:40 -0700722 DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*> mAudioHwDevs;
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800723
Mikhail Naganove4f1f632016-08-31 11:35:10 -0700724 sp<DevicesFactoryHalInterface> mDevicesFactoryHal;
725
Glenn Kasten8abf44d2012-02-02 14:16:03 -0800726 // for dump, indicates which hardware operation is currently in progress (but not stream ops)
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800727 enum hardware_call_state {
Glenn Kasten8abf44d2012-02-02 14:16:03 -0800728 AUDIO_HW_IDLE = 0, // no operation in progress
729 AUDIO_HW_INIT, // init_check
730 AUDIO_HW_OUTPUT_OPEN, // open_output_stream
731 AUDIO_HW_OUTPUT_CLOSE, // unused
732 AUDIO_HW_INPUT_OPEN, // unused
733 AUDIO_HW_INPUT_CLOSE, // unused
734 AUDIO_HW_STANDBY, // unused
735 AUDIO_HW_SET_MASTER_VOLUME, // set_master_volume
736 AUDIO_HW_GET_ROUTING, // unused
737 AUDIO_HW_SET_ROUTING, // unused
738 AUDIO_HW_GET_MODE, // unused
739 AUDIO_HW_SET_MODE, // set_mode
740 AUDIO_HW_GET_MIC_MUTE, // get_mic_mute
741 AUDIO_HW_SET_MIC_MUTE, // set_mic_mute
742 AUDIO_HW_SET_VOICE_VOLUME, // set_voice_volume
743 AUDIO_HW_SET_PARAMETER, // set_parameters
744 AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size
745 AUDIO_HW_GET_MASTER_VOLUME, // get_master_volume
746 AUDIO_HW_GET_PARAMETER, // get_parameters
John Grossmand8f178d2012-07-20 14:51:35 -0700747 AUDIO_HW_SET_MASTER_MUTE, // set_master_mute
748 AUDIO_HW_GET_MASTER_MUTE, // get_master_mute
Glenn Kasten2f732eb2012-01-26 09:48:03 -0800749 };
750
Glenn Kastena4454b42012-01-04 11:02:33 -0800751 mutable hardware_call_state mHardwareStatus; // for dump only
Mathias Agopian65ab4712010-07-14 17:59:35 -0700752
753
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800754 DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> > mPlaybackThreads;
Glenn Kastenb7bf7962012-02-08 12:36:25 -0800755 stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
Glenn Kasten98067102011-12-13 11:47:54 -0800756
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700757 // member variables below are protected by mLock
Mathias Agopian65ab4712010-07-14 17:59:35 -0700758 float mMasterVolume;
759 bool mMasterMute;
Glenn Kastenc3ae93f2012-07-30 10:59:30 -0700760 // end of variables protected by mLock
Mathias Agopian65ab4712010-07-14 17:59:35 -0700761
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800762 DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> > mRecordThreads;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700763
Eric Laurent021cf962014-05-13 10:18:14 -0700764 // protected by mClientLock
Mathias Agopian65ab4712010-07-14 17:59:35 -0700765 DefaultKeyedVector< pid_t, sp<NotificationClient> > mNotificationClients;
Glenn Kastenbcefec32014-01-17 12:09:05 -0800766
Glenn Kastend2e67e12016-04-11 08:26:37 -0700767 // updated by atomic_fetch_add_explicit
768 volatile atomic_uint_fast32_t mNextUniqueIds[AUDIO_UNIQUE_ID_USE_MAX];
Glenn Kastenbcefec32014-01-17 12:09:05 -0800769
Glenn Kastenf78aee72012-01-04 11:00:47 -0800770 audio_mode_t mMode;
Eric Laurentd8365c52017-07-16 15:27:05 -0700771 std::atomic_bool mBtNrecIsOff;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700772
Glenn Kasten99e53b82012-01-19 08:59:58 -0800773 // protected by mLock
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700774 Vector<AudioSessionRef*> mAudioSessionRefs;
Glenn Kasten98067102011-12-13 11:47:54 -0800775
John Grossman4ff14ba2012-02-08 16:37:41 -0800776 float masterVolume_l() const;
John Grossmand8f178d2012-07-20 14:51:35 -0700777 bool masterMute_l() const;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700778 audio_module_handle_t loadHwModule_l(const char *name);
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800779
Eric Laurenta011e352012-03-29 15:51:43 -0700780 Vector < sp<SyncEvent> > mPendingSyncEvents; // sync events awaiting for a session
781 // to be created
782
Eric Laurentaaa44472014-09-12 17:41:50 -0700783 // Effect chains without a valid thread
784 DefaultKeyedVector< audio_session_t , sp<EffectChain> > mOrphanEffectChains;
785
Eric Laurentfa90e842014-10-17 18:12:31 -0700786 // list of sessions for which a valid HW A/V sync ID was retrieved from the HAL
787 DefaultKeyedVector< audio_session_t , audio_hw_sync_t >mHwAvSyncIds;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800788
789 // list of MMAP stream control threads. Those threads allow for wake lock, routing
790 // and volume control for activity on the associated MMAP stream at the HAL.
791 // Audio data transfer is directly handled by the client creating the MMAP stream
792 DefaultKeyedVector< audio_io_handle_t, sp<MmapThread> > mMmapThreads;
793
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800794private:
Eric Laurent021cf962014-05-13 10:18:14 -0700795 sp<Client> registerPid(pid_t pid); // always returns non-0
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800796
Glenn Kastend96c5722012-04-25 13:44:49 -0700797 // for use from destructor
798 status_t closeOutput_nonvirtual(audio_io_handle_t output);
Mikhail Naganov444ecc32018-05-01 17:40:05 -0700799 void closeThreadInternal_l(const sp<PlaybackThread>& thread);
Glenn Kastend96c5722012-04-25 13:44:49 -0700800 status_t closeInput_nonvirtual(audio_io_handle_t input);
Mikhail Naganov444ecc32018-05-01 17:40:05 -0700801 void closeThreadInternal_l(const sp<RecordThread>& thread);
Eric Laurentfa90e842014-10-17 18:12:31 -0700802 void setAudioHwSyncForSession_l(PlaybackThread *thread, audio_session_t sessionId);
Glenn Kastend06785b2012-09-30 12:29:28 -0700803
Eric Laurent223fd5c2014-11-11 13:43:36 -0800804 status_t checkStreamType(audio_stream_type_t stream) const;
805
Eric Laurentf1047e82018-04-16 19:18:20 -0700806 void filterReservedParameters(String8& keyValuePairs, uid_t callingUid);
807
Glenn Kastend06785b2012-09-30 12:29:28 -0700808public:
Andy Hung6f248bb2018-01-23 14:04:37 -0800809 // These methods read variables atomically without mLock,
810 // though the variables are updated with mLock.
Glenn Kasten4182c4e2013-07-15 14:45:07 -0700811 bool isLowRamDevice() const { return mIsLowRamDevice; }
Andy Hung6f248bb2018-01-23 14:04:37 -0800812 size_t getClientSharedHeapSize() const;
Glenn Kasten4182c4e2013-07-15 14:45:07 -0700813
814private:
Andy Hung6f248bb2018-01-23 14:04:37 -0800815 std::atomic<bool> mIsLowRamDevice;
Glenn Kasten4182c4e2013-07-15 14:45:07 -0700816 bool mIsDeviceTypeKnown;
Andy Hung6f248bb2018-01-23 14:04:37 -0800817 int64_t mTotalMemory;
818 std::atomic<size_t> mClientSharedHeapSize;
819 static constexpr size_t kMinimumClientSharedHeapSizeBytes = 1024 * 1024; // 1MB
820
Eric Laurent813e2a72013-08-31 12:59:48 -0700821 nsecs_t mGlobalEffectEnableTime; // when a global effect was last enabled
Eric Laurent1c333e22014-05-20 10:48:17 -0700822
Mikhail Naganovdea53042018-04-26 13:10:21 -0700823 // protected by mLock
824 PatchPanel mPatchPanel;
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700825 sp<EffectsFactoryHalInterface> mEffectsFactoryHal;
Glenn Kasten4ea00a22014-06-02 08:29:22 -0700826
Glenn Kasteneb9487e2015-07-22 09:15:17 -0700827 bool mSystemReady;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700828};
829
Eric Laurent81784c32012-11-19 14:55:58 -0800830#undef INCLUDING_FROM_AUDIOFLINGER_H
Dima Zavin799a70e2011-04-18 16:57:27 -0700831
Mikhail Naganov913d06c2016-11-01 12:49:22 -0700832std::string formatToString(audio_format_t format);
833std::string inputFlagsToString(audio_input_flags_t flags);
834std::string outputFlagsToString(audio_output_flags_t flags);
835std::string devicesToString(audio_devices_t devices);
Glenn Kasten0f5b5622015-02-18 14:33:30 -0800836const char *sourceToString(audio_source_t source);
Marco Nelissenb2208842014-02-07 14:00:50 -0800837
Mathias Agopian65ab4712010-07-14 17:59:35 -0700838// ----------------------------------------------------------------------------
839
Glenn Kasten63238ef2015-03-02 15:50:29 -0800840} // namespace android
Mathias Agopian65ab4712010-07-14 17:59:35 -0700841
842#endif // ANDROID_AUDIO_FLINGER_H