blob: e8b2158e7137ed918b35ef47296e6c61bf7687c7 [file] [log] [blame]
Eric Laurent81784c32012-11-19 14:55:58 -08001/*
2**
3** Copyright 2012, 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 INCLUDING_FROM_AUDIOFLINGER_H
19 #error This header file should only be included from AudioFlinger.h
20#endif
21
22class ThreadBase : public Thread {
23public:
24
25#include "TrackBase.h"
26
27 enum type_t {
28 MIXER, // Thread class is MixerThread
29 DIRECT, // Thread class is DirectOutputThread
30 DUPLICATING, // Thread class is DuplicatingThread
Eric Laurentbfb1b832013-01-07 09:53:42 -080031 RECORD, // Thread class is RecordThread
Eric Laurent6acd1d42017-01-04 14:23:29 -080032 OFFLOAD, // Thread class is OffloadThread
33 MMAP // control thread for MMAP stream
Glenn Kasten1bfe09a2017-02-21 13:05:56 -080034 // If you add any values here, also update ThreadBase::threadTypeToString()
Eric Laurent81784c32012-11-19 14:55:58 -080035 };
36
Glenn Kasten97b7b752014-09-28 13:04:24 -070037 static const char *threadTypeToString(type_t type);
38
Eric Laurent81784c32012-11-19 14:55:58 -080039 ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -070040 audio_devices_t outDevice, audio_devices_t inDevice, type_t type,
41 bool systemReady);
Eric Laurent81784c32012-11-19 14:55:58 -080042 virtual ~ThreadBase();
43
Glenn Kastencf04c2c2013-08-06 07:41:16 -070044 virtual status_t readyToRun();
45
Eric Laurent81784c32012-11-19 14:55:58 -080046 void dumpBase(int fd, const Vector<String16>& args);
47 void dumpEffectChains(int fd, const Vector<String16>& args);
48
49 void clearPowerManager();
50
51 // base for record and playback
52 enum {
53 CFG_EVENT_IO,
Eric Laurent10351942014-05-08 18:49:52 -070054 CFG_EVENT_PRIO,
55 CFG_EVENT_SET_PARAMETER,
Eric Laurent1c333e22014-05-20 10:48:17 -070056 CFG_EVENT_CREATE_AUDIO_PATCH,
57 CFG_EVENT_RELEASE_AUDIO_PATCH,
Eric Laurent81784c32012-11-19 14:55:58 -080058 };
59
Eric Laurent10351942014-05-08 18:49:52 -070060 class ConfigEventData: public RefBase {
Eric Laurent81784c32012-11-19 14:55:58 -080061 public:
Eric Laurent10351942014-05-08 18:49:52 -070062 virtual ~ConfigEventData() {}
Eric Laurent81784c32012-11-19 14:55:58 -080063
64 virtual void dump(char *buffer, size_t size) = 0;
Eric Laurent10351942014-05-08 18:49:52 -070065 protected:
66 ConfigEventData() {}
Eric Laurent81784c32012-11-19 14:55:58 -080067 };
68
Eric Laurent10351942014-05-08 18:49:52 -070069 // Config event sequence by client if status needed (e.g binder thread calling setParameters()):
70 // 1. create SetParameterConfigEvent. This sets mWaitStatus in config event
71 // 2. Lock mLock
72 // 3. Call sendConfigEvent_l(): Append to mConfigEvents and mWaitWorkCV.signal
73 // 4. sendConfigEvent_l() reads status from event->mStatus;
74 // 5. sendConfigEvent_l() returns status
75 // 6. Unlock
76 //
77 // Parameter sequence by server: threadLoop calling processConfigEvents_l():
78 // 1. Lock mLock
79 // 2. If there is an entry in mConfigEvents proceed ...
80 // 3. Read first entry in mConfigEvents
81 // 4. Remove first entry from mConfigEvents
82 // 5. Process
83 // 6. Set event->mStatus
84 // 7. event->mCond.signal
85 // 8. Unlock
Eric Laurent81784c32012-11-19 14:55:58 -080086
Eric Laurent10351942014-05-08 18:49:52 -070087 class ConfigEvent: public RefBase {
88 public:
89 virtual ~ConfigEvent() {}
90
91 void dump(char *buffer, size_t size) { mData->dump(buffer, size); }
92
93 const int mType; // event type e.g. CFG_EVENT_IO
94 Mutex mLock; // mutex associated with mCond
95 Condition mCond; // condition for status return
96 status_t mStatus; // status communicated to sender
97 bool mWaitStatus; // true if sender is waiting for status
Eric Laurent72e3f392015-05-20 14:43:50 -070098 bool mRequiresSystemReady; // true if must wait for system ready to enter event queue
Eric Laurent10351942014-05-08 18:49:52 -070099 sp<ConfigEventData> mData; // event specific parameter data
100
101 protected:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700102 explicit ConfigEvent(int type, bool requiresSystemReady = false) :
Eric Laurent72e3f392015-05-20 14:43:50 -0700103 mType(type), mStatus(NO_ERROR), mWaitStatus(false),
104 mRequiresSystemReady(requiresSystemReady), mData(NULL) {}
Eric Laurent10351942014-05-08 18:49:52 -0700105 };
106
107 class IoConfigEventData : public ConfigEventData {
108 public:
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700109 IoConfigEventData(audio_io_config_event event, pid_t pid) :
110 mEvent(event), mPid(pid) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800111
112 virtual void dump(char *buffer, size_t size) {
Eric Laurent73e26b62015-04-27 16:55:58 -0700113 snprintf(buffer, size, "IO event: event %d\n", mEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800114 }
115
Eric Laurent73e26b62015-04-27 16:55:58 -0700116 const audio_io_config_event mEvent;
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700117 const pid_t mPid;
Eric Laurent81784c32012-11-19 14:55:58 -0800118 };
119
Eric Laurent10351942014-05-08 18:49:52 -0700120 class IoConfigEvent : public ConfigEvent {
Eric Laurent81784c32012-11-19 14:55:58 -0800121 public:
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700122 IoConfigEvent(audio_io_config_event event, pid_t pid) :
Eric Laurent10351942014-05-08 18:49:52 -0700123 ConfigEvent(CFG_EVENT_IO) {
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700124 mData = new IoConfigEventData(event, pid);
Eric Laurent10351942014-05-08 18:49:52 -0700125 }
126 virtual ~IoConfigEvent() {}
127 };
Eric Laurent81784c32012-11-19 14:55:58 -0800128
Eric Laurent10351942014-05-08 18:49:52 -0700129 class PrioConfigEventData : public ConfigEventData {
130 public:
Mikhail Naganov83f04272017-02-07 10:45:09 -0800131 PrioConfigEventData(pid_t pid, pid_t tid, int32_t prio, bool forApp) :
132 mPid(pid), mTid(tid), mPrio(prio), mForApp(forApp) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800133
134 virtual void dump(char *buffer, size_t size) {
Mikhail Naganov83f04272017-02-07 10:45:09 -0800135 snprintf(buffer, size, "Prio event: pid %d, tid %d, prio %d, for app? %d\n",
136 mPid, mTid, mPrio, mForApp);
Eric Laurent81784c32012-11-19 14:55:58 -0800137 }
138
Eric Laurent81784c32012-11-19 14:55:58 -0800139 const pid_t mPid;
140 const pid_t mTid;
141 const int32_t mPrio;
Mikhail Naganov83f04272017-02-07 10:45:09 -0800142 const bool mForApp;
Eric Laurent81784c32012-11-19 14:55:58 -0800143 };
144
Eric Laurent10351942014-05-08 18:49:52 -0700145 class PrioConfigEvent : public ConfigEvent {
146 public:
Mikhail Naganov83f04272017-02-07 10:45:09 -0800147 PrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp) :
Eric Laurent72e3f392015-05-20 14:43:50 -0700148 ConfigEvent(CFG_EVENT_PRIO, true) {
Mikhail Naganov83f04272017-02-07 10:45:09 -0800149 mData = new PrioConfigEventData(pid, tid, prio, forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700150 }
151 virtual ~PrioConfigEvent() {}
152 };
153
154 class SetParameterConfigEventData : public ConfigEventData {
155 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700156 explicit SetParameterConfigEventData(String8 keyValuePairs) :
Eric Laurent10351942014-05-08 18:49:52 -0700157 mKeyValuePairs(keyValuePairs) {}
158
159 virtual void dump(char *buffer, size_t size) {
160 snprintf(buffer, size, "KeyValue: %s\n", mKeyValuePairs.string());
161 }
162
163 const String8 mKeyValuePairs;
164 };
165
166 class SetParameterConfigEvent : public ConfigEvent {
167 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700168 explicit SetParameterConfigEvent(String8 keyValuePairs) :
Eric Laurent10351942014-05-08 18:49:52 -0700169 ConfigEvent(CFG_EVENT_SET_PARAMETER) {
170 mData = new SetParameterConfigEventData(keyValuePairs);
171 mWaitStatus = true;
172 }
173 virtual ~SetParameterConfigEvent() {}
174 };
175
Eric Laurent1c333e22014-05-20 10:48:17 -0700176 class CreateAudioPatchConfigEventData : public ConfigEventData {
177 public:
178 CreateAudioPatchConfigEventData(const struct audio_patch patch,
179 audio_patch_handle_t handle) :
180 mPatch(patch), mHandle(handle) {}
181
182 virtual void dump(char *buffer, size_t size) {
183 snprintf(buffer, size, "Patch handle: %u\n", mHandle);
184 }
185
186 const struct audio_patch mPatch;
187 audio_patch_handle_t mHandle;
188 };
189
190 class CreateAudioPatchConfigEvent : public ConfigEvent {
191 public:
192 CreateAudioPatchConfigEvent(const struct audio_patch patch,
193 audio_patch_handle_t handle) :
194 ConfigEvent(CFG_EVENT_CREATE_AUDIO_PATCH) {
195 mData = new CreateAudioPatchConfigEventData(patch, handle);
196 mWaitStatus = true;
197 }
198 virtual ~CreateAudioPatchConfigEvent() {}
199 };
200
201 class ReleaseAudioPatchConfigEventData : public ConfigEventData {
202 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700203 explicit ReleaseAudioPatchConfigEventData(const audio_patch_handle_t handle) :
Eric Laurent1c333e22014-05-20 10:48:17 -0700204 mHandle(handle) {}
205
206 virtual void dump(char *buffer, size_t size) {
207 snprintf(buffer, size, "Patch handle: %u\n", mHandle);
208 }
209
210 audio_patch_handle_t mHandle;
211 };
212
213 class ReleaseAudioPatchConfigEvent : public ConfigEvent {
214 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700215 explicit ReleaseAudioPatchConfigEvent(const audio_patch_handle_t handle) :
Eric Laurent1c333e22014-05-20 10:48:17 -0700216 ConfigEvent(CFG_EVENT_RELEASE_AUDIO_PATCH) {
217 mData = new ReleaseAudioPatchConfigEventData(handle);
218 mWaitStatus = true;
219 }
220 virtual ~ReleaseAudioPatchConfigEvent() {}
221 };
Eric Laurent81784c32012-11-19 14:55:58 -0800222
223 class PMDeathRecipient : public IBinder::DeathRecipient {
224 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700225 explicit PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800226 virtual ~PMDeathRecipient() {}
227
228 // IBinder::DeathRecipient
229 virtual void binderDied(const wp<IBinder>& who);
230
231 private:
Mikhail Naganovbf493082017-04-17 17:37:12 -0700232 DISALLOW_COPY_AND_ASSIGN(PMDeathRecipient);
Eric Laurent81784c32012-11-19 14:55:58 -0800233
234 wp<ThreadBase> mThread;
235 };
236
237 virtual status_t initCheck() const = 0;
238
239 // static externally-visible
240 type_t type() const { return mType; }
Eric Laurentf6870ae2015-05-08 10:50:03 -0700241 bool isDuplicating() const { return (mType == DUPLICATING); }
242
Eric Laurent81784c32012-11-19 14:55:58 -0800243 audio_io_handle_t id() const { return mId;}
244
245 // dynamic externally-visible
246 uint32_t sampleRate() const { return mSampleRate; }
Eric Laurent81784c32012-11-19 14:55:58 -0800247 audio_channel_mask_t channelMask() const { return mChannelMask; }
Andy Hung463be252014-07-10 16:56:07 -0700248 audio_format_t format() const { return mHALFormat; }
Eric Laurent83b88082014-06-20 18:31:16 -0700249 uint32_t channelCount() const { return mChannelCount; }
Eric Laurent81784c32012-11-19 14:55:58 -0800250 // Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects,
Glenn Kasten9b58f632013-07-16 11:37:48 -0700251 // and returns the [normal mix] buffer's frame count.
252 virtual size_t frameCount() const = 0;
Glenn Kasten4a8308b2016-04-18 14:10:01 -0700253
254 // Return's the HAL's frame count i.e. fast mixer buffer size.
255 size_t frameCountHAL() const { return mFrameCount; }
256
Eric Laurentbfb1b832013-01-07 09:53:42 -0800257 size_t frameSize() const { return mFrameSize; }
Eric Laurent81784c32012-11-19 14:55:58 -0800258
259 // Should be "virtual status_t requestExitAndWait()" and override same
260 // method in Thread, but Thread::requestExitAndWait() is not yet virtual.
261 void exit();
Eric Laurent10351942014-05-08 18:49:52 -0700262 virtual bool checkForNewParameter_l(const String8& keyValuePair,
263 status_t& status) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800264 virtual status_t setParameters(const String8& keyValuePairs);
265 virtual String8 getParameters(const String8& keys) = 0;
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700266 virtual void ioConfigChanged(audio_io_config_event event, pid_t pid = 0) = 0;
Eric Laurent10351942014-05-08 18:49:52 -0700267 // sendConfigEvent_l() must be called with ThreadBase::mLock held
268 // Can temporarily release the lock if waiting for a reply from
269 // processConfigEvents_l().
270 status_t sendConfigEvent_l(sp<ConfigEvent>& event);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700271 void sendIoConfigEvent(audio_io_config_event event, pid_t pid = 0);
272 void sendIoConfigEvent_l(audio_io_config_event event, pid_t pid = 0);
Mikhail Naganov83f04272017-02-07 10:45:09 -0800273 void sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp);
274 void sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio, bool forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700275 status_t sendSetParameterConfigEvent_l(const String8& keyValuePair);
Eric Laurent1c333e22014-05-20 10:48:17 -0700276 status_t sendCreateAudioPatchConfigEvent(const struct audio_patch *patch,
277 audio_patch_handle_t *handle);
278 status_t sendReleaseAudioPatchConfigEvent(audio_patch_handle_t handle);
Eric Laurent021cf962014-05-13 10:18:14 -0700279 void processConfigEvents_l();
Eric Laurent10351942014-05-08 18:49:52 -0700280 virtual void cacheParameters_l() = 0;
Eric Laurent1c333e22014-05-20 10:48:17 -0700281 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
282 audio_patch_handle_t *handle) = 0;
283 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle) = 0;
Mikhail Naganovdc769682018-05-04 15:34:08 -0700284 virtual void toAudioPortConfig(struct audio_port_config *config) = 0;
Eric Laurent1c333e22014-05-20 10:48:17 -0700285
Eric Laurent81784c32012-11-19 14:55:58 -0800286
287 // see note at declaration of mStandby, mOutDevice and mInDevice
288 bool standby() const { return mStandby; }
289 audio_devices_t outDevice() const { return mOutDevice; }
290 audio_devices_t inDevice() const { return mInDevice; }
Andy Hung293558a2017-03-21 12:19:20 -0700291 audio_devices_t getDevice() const { return isOutput() ? mOutDevice : mInDevice; }
292
293 virtual bool isOutput() const = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800294
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700295 virtual sp<StreamHalInterface> stream() const = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800296
297 sp<EffectHandle> createEffect_l(
298 const sp<AudioFlinger::Client>& client,
299 const sp<IEffectClient>& effectClient,
300 int32_t priority,
Glenn Kastend848eb42016-03-08 13:42:11 -0800301 audio_session_t sessionId,
Eric Laurent81784c32012-11-19 14:55:58 -0800302 effect_descriptor_t *desc,
303 int *enabled,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800304 status_t *status /*non-NULL*/,
305 bool pinned);
Eric Laurent81784c32012-11-19 14:55:58 -0800306
307 // return values for hasAudioSession (bit field)
308 enum effect_state {
309 EFFECT_SESSION = 0x1, // the audio session corresponds to at least one
310 // effect
Eric Laurent4c415062016-06-17 16:14:16 -0700311 TRACK_SESSION = 0x2, // the audio session corresponds to at least one
Eric Laurent81784c32012-11-19 14:55:58 -0800312 // track
Eric Laurent4c415062016-06-17 16:14:16 -0700313 FAST_SESSION = 0x4 // the audio session corresponds to at least one
314 // fast track
Eric Laurent81784c32012-11-19 14:55:58 -0800315 };
316
317 // get effect chain corresponding to session Id.
Glenn Kastend848eb42016-03-08 13:42:11 -0800318 sp<EffectChain> getEffectChain(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800319 // same as getEffectChain() but must be called with ThreadBase mutex locked
Glenn Kastend848eb42016-03-08 13:42:11 -0800320 sp<EffectChain> getEffectChain_l(audio_session_t sessionId) const;
Eric Laurent81784c32012-11-19 14:55:58 -0800321 // add an effect chain to the chain list (mEffectChains)
322 virtual status_t addEffectChain_l(const sp<EffectChain>& chain) = 0;
323 // remove an effect chain from the chain list (mEffectChains)
324 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0;
325 // lock all effect chains Mutexes. Must be called before releasing the
326 // ThreadBase mutex before processing the mixer and effects. This guarantees the
327 // integrity of the chains during the process.
328 // Also sets the parameter 'effectChains' to current value of mEffectChains.
329 void lockEffectChains_l(Vector< sp<EffectChain> >& effectChains);
330 // unlock effect chains after process
331 void unlockEffectChains(const Vector< sp<EffectChain> >& effectChains);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800332 // get a copy of mEffectChains vector
333 Vector< sp<EffectChain> > getEffectChains_l() const { return mEffectChains; };
Eric Laurent81784c32012-11-19 14:55:58 -0800334 // set audio mode to all effect chains
335 void setMode(audio_mode_t mode);
336 // get effect module with corresponding ID on specified audio session
Glenn Kastend848eb42016-03-08 13:42:11 -0800337 sp<AudioFlinger::EffectModule> getEffect(audio_session_t sessionId, int effectId);
338 sp<AudioFlinger::EffectModule> getEffect_l(audio_session_t sessionId, int effectId);
Eric Laurent81784c32012-11-19 14:55:58 -0800339 // add and effect module. Also creates the effect chain is none exists for
340 // the effects audio session
341 status_t addEffect_l(const sp< EffectModule>& effect);
342 // remove and effect module. Also removes the effect chain is this was the last
343 // effect
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800344 void removeEffect_l(const sp< EffectModule>& effect, bool release = false);
345 // disconnect an effect handle from module and destroy module if last handle
346 void disconnectEffectHandle(EffectHandle *handle, bool unpinIfLast);
Eric Laurent81784c32012-11-19 14:55:58 -0800347 // detach all tracks connected to an auxiliary effect
Glenn Kasten0f11b512014-01-31 16:18:54 -0800348 virtual void detachAuxEffect_l(int effectId __unused) {}
Eric Laurent4c415062016-06-17 16:14:16 -0700349 // returns a combination of:
350 // - EFFECT_SESSION if effects on this audio session exist in one chain
351 // - TRACK_SESSION if tracks on this audio session exist
352 // - FAST_SESSION if fast tracks on this audio session exist
353 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const = 0;
354 uint32_t hasAudioSession(audio_session_t sessionId) const {
355 Mutex::Autolock _l(mLock);
356 return hasAudioSession_l(sessionId);
357 }
358
Eric Laurent81784c32012-11-19 14:55:58 -0800359 // the value returned by default implementation is not important as the
360 // strategy is only meaningful for PlaybackThread which implements this method
Glenn Kastend848eb42016-03-08 13:42:11 -0800361 virtual uint32_t getStrategyForSession_l(audio_session_t sessionId __unused)
362 { return 0; }
Eric Laurent81784c32012-11-19 14:55:58 -0800363
Eric Laurent81784c32012-11-19 14:55:58 -0800364 // check if some effects must be suspended/restored when an effect is enabled
365 // or disabled
366 void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
367 bool enabled,
Glenn Kastend848eb42016-03-08 13:42:11 -0800368 audio_session_t sessionId =
369 AUDIO_SESSION_OUTPUT_MIX);
Eric Laurent81784c32012-11-19 14:55:58 -0800370 void checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect,
371 bool enabled,
Glenn Kastend848eb42016-03-08 13:42:11 -0800372 audio_session_t sessionId =
373 AUDIO_SESSION_OUTPUT_MIX);
Eric Laurent81784c32012-11-19 14:55:58 -0800374
375 virtual status_t setSyncEvent(const sp<SyncEvent>& event) = 0;
376 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const = 0;
377
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700378 // Return a reference to a per-thread heap which can be used to allocate IMemory
379 // objects that will be read-only to client processes, read/write to mediaserver,
380 // and shared by all client processes of the thread.
381 // The heap is per-thread rather than common across all threads, because
382 // clients can't be trusted not to modify the offset of the IMemory they receive.
383 // If a thread does not have such a heap, this method returns 0.
384 virtual sp<MemoryDealer> readOnlyHeap() const { return 0; }
Eric Laurent81784c32012-11-19 14:55:58 -0800385
Glenn Kasten6181ffd2014-05-13 10:41:52 -0700386 virtual sp<IMemory> pipeMemory() const { return 0; }
387
Eric Laurent72e3f392015-05-20 14:43:50 -0700388 void systemReady();
389
Eric Laurent4c415062016-06-17 16:14:16 -0700390 // checkEffectCompatibility_l() must be called with ThreadBase::mLock held
391 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
392 audio_session_t sessionId) = 0;
393
Eric Laurent6acd1d42017-01-04 14:23:29 -0800394 void broadcast_l();
395
Andy Hungc8fddf32018-08-08 18:32:37 -0700396 virtual bool isTimestampCorrectionEnabled() const { return false; }
397
398 bool isMsdDevice() const { return mIsMsdDevice; }
399
Andy Hungdc099c22018-09-18 13:46:39 -0700400 virtual void dump(int fd, const Vector<String16>& args) = 0;
401
Eric Laurent81784c32012-11-19 14:55:58 -0800402 mutable Mutex mLock;
403
404protected:
405
406 // entry describing an effect being suspended in mSuspendedSessions keyed vector
407 class SuspendedSessionDesc : public RefBase {
408 public:
409 SuspendedSessionDesc() : mRefCount(0) {}
410
411 int mRefCount; // number of active suspend requests
412 effect_uuid_t mType; // effect type UUID
413 };
414
Andy Hungdae27702016-10-31 14:01:16 -0700415 void acquireWakeLock();
416 virtual void acquireWakeLock_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800417 void releaseWakeLock();
418 void releaseWakeLock_l();
Andy Hungd01b0f12016-11-07 16:10:30 -0800419 void updateWakeLockUids_l(const SortedVector<uid_t> &uids);
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800420 void getPowerManager_l();
Eric Laurentd8365c52017-07-16 15:27:05 -0700421 // suspend or restore effects of the specified type (or all if type is NULL)
422 // on a given session. The number of suspend requests is counted and restore
423 // occurs when all suspend requests are cancelled.
Eric Laurent81784c32012-11-19 14:55:58 -0800424 void setEffectSuspended_l(const effect_uuid_t *type,
425 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -0800426 audio_session_t sessionId);
Eric Laurentd8365c52017-07-16 15:27:05 -0700427 // updated mSuspendedSessions when an effect is suspended or restored
Eric Laurent81784c32012-11-19 14:55:58 -0800428 void updateSuspendedSessions_l(const effect_uuid_t *type,
429 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -0800430 audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800431 // check if some effects must be suspended when an effect chain is added
432 void checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain);
433
Kevin Rocard069c2712018-03-29 19:09:14 -0700434 // sends the metadata of the active tracks to the HAL
435 virtual void updateMetadata_l() = 0;
436
Narayan Kamath014e7fa2013-10-14 15:03:38 +0100437 String16 getWakeLockTag();
438
Eric Laurent81784c32012-11-19 14:55:58 -0800439 virtual void preExit() { }
Andy Hung2ddee192015-12-18 17:34:44 -0800440 virtual void setMasterMono_l(bool mono __unused) { }
441 virtual bool requireMonoBlend() { return false; }
Eric Laurent81784c32012-11-19 14:55:58 -0800442
Andy Hung1c86ebe2018-05-29 20:29:08 -0700443 // called within the threadLoop to obtain timestamp from the HAL.
444 virtual status_t threadloop_getHalTimestamp_l(
445 ExtendedTimestamp *timestamp __unused) const {
446 return INVALID_OPERATION;
447 }
448
Eric Laurent81784c32012-11-19 14:55:58 -0800449 friend class AudioFlinger; // for mEffectChains
450
451 const type_t mType;
452
453 // Used by parameters, config events, addTrack_l, exit
454 Condition mWaitWorkCV;
455
456 const sp<AudioFlinger> mAudioFlinger;
Glenn Kasten9b58f632013-07-16 11:37:48 -0700457
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800458 // updated by PlaybackThread::readOutputParameters_l() or
459 // RecordThread::readInputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -0800460 uint32_t mSampleRate;
461 size_t mFrameCount; // output HAL, direct output, record
Eric Laurent81784c32012-11-19 14:55:58 -0800462 audio_channel_mask_t mChannelMask;
Glenn Kastenf6ed4232013-07-16 11:16:27 -0700463 uint32_t mChannelCount;
Eric Laurent81784c32012-11-19 14:55:58 -0800464 size_t mFrameSize;
Glenn Kasten97b7b752014-09-28 13:04:24 -0700465 // not HAL frame size, this is for output sink (to pipe to fast mixer)
Andy Hung463be252014-07-10 16:56:07 -0700466 audio_format_t mFormat; // Source format for Recording and
467 // Sink format for Playback.
468 // Sink format may be different than
469 // HAL format if Fastmixer is used.
470 audio_format_t mHALFormat;
Glenn Kasten70949c42013-08-06 07:40:12 -0700471 size_t mBufferSize; // HAL buffer size for read() or write()
Eric Laurent81784c32012-11-19 14:55:58 -0800472
Eric Laurent10351942014-05-08 18:49:52 -0700473 Vector< sp<ConfigEvent> > mConfigEvents;
Eric Laurent72e3f392015-05-20 14:43:50 -0700474 Vector< sp<ConfigEvent> > mPendingConfigEvents; // events awaiting system ready
Eric Laurent81784c32012-11-19 14:55:58 -0800475
476 // These fields are written and read by thread itself without lock or barrier,
Glenn Kasten4944acb2013-08-19 08:39:20 -0700477 // and read by other threads without lock or barrier via standby(), outDevice()
Eric Laurent81784c32012-11-19 14:55:58 -0800478 // and inDevice().
479 // Because of the absence of a lock or barrier, any other thread that reads
480 // these fields must use the information in isolation, or be prepared to deal
481 // with possibility that it might be inconsistent with other information.
Glenn Kasten4944acb2013-08-19 08:39:20 -0700482 bool mStandby; // Whether thread is currently in standby.
Eric Laurent81784c32012-11-19 14:55:58 -0800483 audio_devices_t mOutDevice; // output device
484 audio_devices_t mInDevice; // input device
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700485 audio_devices_t mPrevOutDevice; // previous output device
Eric Laurente8726fe2015-06-26 09:39:24 -0700486 audio_devices_t mPrevInDevice; // previous input device
Eric Laurent296fb132015-05-01 11:38:42 -0700487 struct audio_patch mPatch;
Glenn Kastenf59497b2015-01-26 16:35:47 -0800488 audio_source_t mAudioSource;
Eric Laurent81784c32012-11-19 14:55:58 -0800489
490 const audio_io_handle_t mId;
491 Vector< sp<EffectChain> > mEffectChains;
492
Glenn Kastend7dca052015-03-05 16:05:54 -0800493 static const int kThreadNameLength = 16; // prctl(PR_SET_NAME) limit
494 char mThreadName[kThreadNameLength]; // guaranteed NUL-terminated
Eric Laurent81784c32012-11-19 14:55:58 -0800495 sp<IPowerManager> mPowerManager;
496 sp<IBinder> mWakeLockToken;
497 const sp<PMDeathRecipient> mDeathRecipient;
Glenn Kastend848eb42016-03-08 13:42:11 -0800498 // list of suspended effects per session and per type. The first (outer) vector is
499 // keyed by session ID, the second (inner) by type UUID timeLow field
Eric Laurentd8365c52017-07-16 15:27:05 -0700500 // Updated by updateSuspendedSessions_l() only.
Glenn Kastend848eb42016-03-08 13:42:11 -0800501 KeyedVector< audio_session_t, KeyedVector< int, sp<SuspendedSessionDesc> > >
Eric Laurent81784c32012-11-19 14:55:58 -0800502 mSuspendedSessions;
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -0700503 // TODO: add comment and adjust size as needed
Glenn Kastenab7d72f2013-02-27 09:05:28 -0800504 static const size_t kLogSize = 4 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -0800505 sp<NBLog::Writer> mNBLogWriter;
Eric Laurent72e3f392015-05-20 14:43:50 -0700506 bool mSystemReady;
Andy Hung818e7a32016-02-16 18:08:07 -0800507 ExtendedTimestamp mTimestamp;
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700508 TimestampVerifier< // For timestamp statistics.
509 int64_t /* frame count */, int64_t /* time ns */> mTimestampVerifier;
Andy Hungc8fddf32018-08-08 18:32:37 -0700510 audio_devices_t mTimestampCorrectedDevices = AUDIO_DEVICE_NONE;
511 bool mIsMsdDevice = false;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800512 // A condition that must be evaluated by the thread loop has changed and
513 // we must not wait for async write callback in the thread loop before evaluating it
514 bool mSignalPending;
Andy Hungdae27702016-10-31 14:01:16 -0700515
Andy Hung8946a282018-04-19 20:04:56 -0700516#ifdef TEE_SINK
517 NBAIO_Tee mTee;
518#endif
Andy Hungdae27702016-10-31 14:01:16 -0700519 // ActiveTracks is a sorted vector of track type T representing the
520 // active tracks of threadLoop() to be considered by the locked prepare portion.
521 // ActiveTracks should be accessed with the ThreadBase lock held.
522 //
523 // During processing and I/O, the threadLoop does not hold the lock;
524 // hence it does not directly use ActiveTracks. Care should be taken
525 // to hold local strong references or defer removal of tracks
526 // if the threadLoop may still be accessing those tracks due to mix, etc.
527 //
528 // This class updates power information appropriately.
529 //
530
531 template <typename T>
532 class ActiveTracks {
533 public:
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700534 explicit ActiveTracks(SimpleLog *localLog = nullptr)
Andy Hungdae27702016-10-31 14:01:16 -0700535 : mActiveTracksGeneration(0)
536 , mLastActiveTracksGeneration(0)
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700537 , mLocalLog(localLog)
Andy Hungdae27702016-10-31 14:01:16 -0700538 { }
539
540 ~ActiveTracks() {
541 ALOGW_IF(!mActiveTracks.isEmpty(),
542 "ActiveTracks should be empty in destructor");
543 }
544 // returns the last track added (even though it may have been
545 // subsequently removed from ActiveTracks).
546 //
547 // Used for DirectOutputThread to ensure a flush is called when transitioning
548 // to a new track (even though it may be on the same session).
549 // Used for OffloadThread to ensure that volume and mixer state is
550 // taken from the latest track added.
551 //
552 // The latest track is saved with a weak pointer to prevent keeping an
553 // otherwise useless track alive. Thus the function will return nullptr
554 // if the latest track has subsequently been removed and destroyed.
555 sp<T> getLatest() {
556 return mLatestActiveTrack.promote();
557 }
558
559 // SortedVector methods
560 ssize_t add(const sp<T> &track);
561 ssize_t remove(const sp<T> &track);
562 size_t size() const {
563 return mActiveTracks.size();
564 }
Eric Tan39ec8d62018-07-24 09:49:29 -0700565 bool isEmpty() const {
566 return mActiveTracks.isEmpty();
567 }
Andy Hungdae27702016-10-31 14:01:16 -0700568 ssize_t indexOf(const sp<T>& item) {
569 return mActiveTracks.indexOf(item);
570 }
571 sp<T> operator[](size_t index) const {
572 return mActiveTracks[index];
573 }
574 typename SortedVector<sp<T>>::iterator begin() {
575 return mActiveTracks.begin();
576 }
577 typename SortedVector<sp<T>>::iterator end() {
578 return mActiveTracks.end();
579 }
580
581 // Due to Binder recursion optimization, clear() and updatePowerState()
582 // cannot be called from a Binder thread because they may call back into
583 // the original calling process (system server) for BatteryNotifier
584 // (which requires a Java environment that may not be present).
585 // Hence, call clear() and updatePowerState() only from the
586 // ThreadBase thread.
587 void clear();
588 // periodically called in the threadLoop() to update power state uids.
589 void updatePowerState(sp<ThreadBase> thread, bool force = false);
590
Kevin Rocardc86a7f72018-04-03 09:00:09 -0700591 /** @return true if one or move active tracks was added or removed since the
592 * last time this function was called or the vector was created. */
Kevin Rocard069c2712018-03-29 19:09:14 -0700593 bool readAndClearHasChanged();
594
Andy Hungdae27702016-10-31 14:01:16 -0700595 private:
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700596 void logTrack(const char *funcName, const sp<T> &track) const;
597
Andy Hungd01b0f12016-11-07 16:10:30 -0800598 SortedVector<uid_t> getWakeLockUids() {
599 SortedVector<uid_t> wakeLockUids;
Andy Hungdae27702016-10-31 14:01:16 -0700600 for (const sp<T> &track : mActiveTracks) {
601 wakeLockUids.add(track->uid());
602 }
603 return wakeLockUids; // moved by underlying SharedBuffer
604 }
605
606 std::map<uid_t, std::pair<ssize_t /* previous */, ssize_t /* current */>>
607 mBatteryCounter;
608 SortedVector<sp<T>> mActiveTracks;
609 int mActiveTracksGeneration;
610 int mLastActiveTracksGeneration;
611 wp<T> mLatestActiveTrack; // latest track added to ActiveTracks
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700612 SimpleLog * const mLocalLog;
Kevin Rocardc86a7f72018-04-03 09:00:09 -0700613 // If the vector has changed since last call to readAndClearHasChanged
Kevin Rocard069c2712018-03-29 19:09:14 -0700614 bool mHasChanged = false;
Andy Hungdae27702016-10-31 14:01:16 -0700615 };
Andy Hung293558a2017-03-21 12:19:20 -0700616
617 SimpleLog mLocalLog;
Eric Laurent81784c32012-11-19 14:55:58 -0800618};
619
Eric Laurent6acd1d42017-01-04 14:23:29 -0800620class VolumeInterface {
621 public:
622
623 virtual ~VolumeInterface() {}
624
625 virtual void setMasterVolume(float value) = 0;
626 virtual void setMasterMute(bool muted) = 0;
627 virtual void setStreamVolume(audio_stream_type_t stream, float value) = 0;
628 virtual void setStreamMute(audio_stream_type_t stream, bool muted) = 0;
629 virtual float streamVolume(audio_stream_type_t stream) const = 0;
630
631};
632
Eric Laurent81784c32012-11-19 14:55:58 -0800633// --- PlaybackThread ---
Eric Laurent6acd1d42017-01-04 14:23:29 -0800634class PlaybackThread : public ThreadBase, public StreamOutHalInterfaceCallback,
635 public VolumeInterface {
Eric Laurent81784c32012-11-19 14:55:58 -0800636public:
637
638#include "PlaybackTracks.h"
639
640 enum mixer_state {
641 MIXER_IDLE, // no active tracks
642 MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready
Eric Laurentbfb1b832013-01-07 09:53:42 -0800643 MIXER_TRACKS_READY, // at least one active track, and at least one track has data
644 MIXER_DRAIN_TRACK, // drain currently playing track
645 MIXER_DRAIN_ALL, // fully drain the hardware
Eric Laurent81784c32012-11-19 14:55:58 -0800646 // standby mode does not have an enum value
647 // suspend by audio policy manager is orthogonal to mixer state
648 };
649
Eric Laurente93cc032016-05-05 10:15:10 -0700650 // retry count before removing active track in case of underrun on offloaded thread:
651 // we need to make sure that AudioTrack client has enough time to send large buffers
652 //FIXME may be more appropriate if expressed in time units. Need to revise how underrun is
653 // handled for offloaded tracks
654 static const int8_t kMaxTrackRetriesOffload = 20;
655 static const int8_t kMaxTrackStartupRetriesOffload = 100;
656 static const int8_t kMaxTrackStopRetriesOffload = 2;
Andy Hung8ed196a2018-01-05 13:21:11 -0800657 static constexpr uint32_t kMaxTracksPerUid = 40;
Andy Hung1bc088a2018-02-09 15:57:31 -0800658 static constexpr size_t kMaxTracks = 256;
Eric Laurente93cc032016-05-05 10:15:10 -0700659
rago1bb90822017-05-02 18:31:48 -0700660 // Maximum delay (in nanoseconds) for upcoming buffers in suspend mode, otherwise
661 // if delay is greater, the estimated time for timeLoopNextNs is reset.
662 // This allows for catch-up to be done for small delays, while resetting the estimate
663 // for initial conditions or large delays.
664 static const nsecs_t kMaxNextBufferDelayNs = 100000000;
665
Eric Laurent81784c32012-11-19 14:55:58 -0800666 PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurente93cc032016-05-05 10:15:10 -0700667 audio_io_handle_t id, audio_devices_t device, type_t type, bool systemReady);
Eric Laurent81784c32012-11-19 14:55:58 -0800668 virtual ~PlaybackThread();
669
Andy Hungdc099c22018-09-18 13:46:39 -0700670 void dump(int fd, const Vector<String16>& args) override;
Eric Laurent81784c32012-11-19 14:55:58 -0800671
672 // Thread virtuals
Eric Laurent81784c32012-11-19 14:55:58 -0800673 virtual bool threadLoop();
674
675 // RefBase
676 virtual void onFirstRef();
677
Eric Laurent4c415062016-06-17 16:14:16 -0700678 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
679 audio_session_t sessionId);
680
Eric Laurent81784c32012-11-19 14:55:58 -0800681protected:
682 // Code snippets that were lifted up out of threadLoop()
683 virtual void threadLoop_mix() = 0;
684 virtual void threadLoop_sleepTime() = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800685 virtual ssize_t threadLoop_write();
686 virtual void threadLoop_drain();
Eric Laurent81784c32012-11-19 14:55:58 -0800687 virtual void threadLoop_standby();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800688 virtual void threadLoop_exit();
Eric Laurent81784c32012-11-19 14:55:58 -0800689 virtual void threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove);
690
691 // prepareTracks_l reads and writes mActiveTracks, and returns
692 // the pending set of tracks to remove via Vector 'tracksToRemove'. The caller
693 // is responsible for clearing or destroying this Vector later on, when it
694 // is safe to do so. That will drop the final ref count and destroy the tracks.
695 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove) = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800696 void removeTracks_l(const Vector< sp<Track> >& tracksToRemove);
697
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700698 // StreamOutHalInterfaceCallback implementation
699 virtual void onWriteReady();
700 virtual void onDrainReady();
701 virtual void onError();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800702
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700703 void resetWriteBlocked(uint32_t sequence);
704 void resetDraining(uint32_t sequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800705
706 virtual bool waitingAsyncCallback();
707 virtual bool waitingAsyncCallback_l();
708 virtual bool shouldStandby_l();
Haynes Mathew George4c6a4332014-01-15 12:31:39 -0800709 virtual void onAddNewTrack_l();
Haynes Mathew George4527b9e2016-07-07 19:54:17 -0700710 void onAsyncError(); // error reported by AsyncCallbackThread
Eric Laurent81784c32012-11-19 14:55:58 -0800711
712 // ThreadBase virtuals
713 virtual void preExit();
714
Eric Laurent64667972016-03-30 18:19:46 -0700715 virtual bool keepWakeLock() const { return true; }
Andy Hungdae27702016-10-31 14:01:16 -0700716 virtual void acquireWakeLock_l() {
717 ThreadBase::acquireWakeLock_l();
718 mActiveTracks.updatePowerState(this, true /* force */);
719 }
Eric Laurent64667972016-03-30 18:19:46 -0700720
Eric Laurent81784c32012-11-19 14:55:58 -0800721public:
722
723 virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; }
724
725 // return estimated latency in milliseconds, as reported by HAL
726 uint32_t latency() const;
727 // same, but lock must already be held
728 uint32_t latency_l() const;
729
Eric Laurent6acd1d42017-01-04 14:23:29 -0800730 // VolumeInterface
731 virtual void setMasterVolume(float value);
732 virtual void setMasterMute(bool muted);
733 virtual void setStreamVolume(audio_stream_type_t stream, float value);
734 virtual void setStreamMute(audio_stream_type_t stream, bool muted);
735 virtual float streamVolume(audio_stream_type_t stream) const;
Eric Laurent81784c32012-11-19 14:55:58 -0800736
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +0900737 void setVolumeForOutput_l(float left, float right) const;
738
Eric Laurent81784c32012-11-19 14:55:58 -0800739 sp<Track> createTrack_l(
740 const sp<AudioFlinger::Client>& client,
741 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700742 const audio_attributes_t& attr,
Eric Laurent21da6472017-11-09 16:29:26 -0800743 uint32_t *sampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -0800744 audio_format_t format,
745 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -0800746 size_t *pFrameCount,
Eric Laurent21da6472017-11-09 16:29:26 -0800747 size_t *pNotificationFrameCount,
748 uint32_t notificationsPerBuffer,
749 float speed,
Eric Laurent81784c32012-11-19 14:55:58 -0800750 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -0800751 audio_session_t sessionId,
Eric Laurent05067782016-06-01 18:27:28 -0700752 audio_output_flags_t *flags,
Eric Laurent81784c32012-11-19 14:55:58 -0800753 pid_t tid,
Andy Hung1f12a8a2016-11-07 16:10:30 -0800754 uid_t uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800755 status_t *status /*non-NULL*/,
756 audio_port_handle_t portId);
Eric Laurent81784c32012-11-19 14:55:58 -0800757
758 AudioStreamOut* getOutput() const;
759 AudioStreamOut* clearOutput();
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700760 virtual sp<StreamHalInterface> stream() const;
Eric Laurent81784c32012-11-19 14:55:58 -0800761
762 // a very large number of suspend() will eventually wraparound, but unlikely
763 void suspend() { (void) android_atomic_inc(&mSuspended); }
764 void restore()
765 {
766 // if restore() is done without suspend(), get back into
767 // range so that the next suspend() will operate correctly
768 if (android_atomic_dec(&mSuspended) <= 0) {
769 android_atomic_release_store(0, &mSuspended);
770 }
771 }
772 bool isSuspended() const
773 { return android_atomic_acquire_load(&mSuspended) > 0; }
774
775 virtual String8 getParameters(const String8& keys);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700776 virtual void ioConfigChanged(audio_io_config_event event, pid_t pid = 0);
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000777 status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames);
Andy Hung010a1a12014-03-13 13:57:33 -0700778 // Consider also removing and passing an explicit mMainBuffer initialization
779 // parameter to AF::PlaybackThread::Track::Track().
rago94a1ee82017-07-21 15:11:02 -0700780 effect_buffer_t *sinkBuffer() const {
781 return reinterpret_cast<effect_buffer_t *>(mSinkBuffer); };
Eric Laurent81784c32012-11-19 14:55:58 -0800782
783 virtual void detachAuxEffect_l(int effectId);
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700784 status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track>& track,
Eric Laurent81784c32012-11-19 14:55:58 -0800785 int EffectId);
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700786 status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track>& track,
Eric Laurent81784c32012-11-19 14:55:58 -0800787 int EffectId);
788
789 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
790 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
Eric Laurent4c415062016-06-17 16:14:16 -0700791 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const;
Glenn Kastend848eb42016-03-08 13:42:11 -0800792 virtual uint32_t getStrategyForSession_l(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800793
794
795 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
796 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const;
Glenn Kastenfb1fdc92013-07-10 17:03:19 -0700797
798 // called with AudioFlinger lock held
Eric Laurent13084622016-05-17 10:51:49 -0700799 bool invalidateTracks_l(audio_stream_type_t streamType);
Haynes Mathew George05317d22016-05-03 16:34:26 -0700800 virtual void invalidateTracks(audio_stream_type_t streamType);
Eric Laurent81784c32012-11-19 14:55:58 -0800801
Glenn Kasten9b58f632013-07-16 11:37:48 -0700802 virtual size_t frameCount() const { return mNormalFrameCount; }
803
Eric Laurent83b88082014-06-20 18:31:16 -0700804 status_t getTimestamp_l(AudioTimestamp& timestamp);
805
806 void addPatchTrack(const sp<PatchTrack>& track);
807 void deletePatchTrack(const sp<PatchTrack>& track);
808
Mikhail Naganovdc769682018-05-04 15:34:08 -0700809 virtual void toAudioPortConfig(struct audio_port_config *config);
Eric Laurentaccc1472013-09-20 09:36:34 -0700810
Andy Hung10cbff12017-02-21 17:30:14 -0800811 // Return the asynchronous signal wait time.
812 virtual int64_t computeWaitTimeNs_l() const { return INT64_MAX; }
813
Andy Hung293558a2017-03-21 12:19:20 -0700814 virtual bool isOutput() const override { return true; }
815
Andy Hung1bc088a2018-02-09 15:57:31 -0800816 // returns true if the track is allowed to be added to the thread.
817 virtual bool isTrackAllowed_l(
818 audio_channel_mask_t channelMask __unused,
819 audio_format_t format __unused,
820 audio_session_t sessionId __unused,
821 uid_t uid) const {
822 return trackCountForUid_l(uid) < PlaybackThread::kMaxTracksPerUid
823 && mTracks.size() < PlaybackThread::kMaxTracks;
824 }
825
Andy Hungc8fddf32018-08-08 18:32:37 -0700826 bool isTimestampCorrectionEnabled() const override {
827 const audio_devices_t device =
828 mOutDevice & mTimestampCorrectedDevices;
829 return audio_is_output_devices(device) && popcount(device) > 0;
830 }
Eric Laurent81784c32012-11-19 14:55:58 -0800831protected:
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800832 // updated by readOutputParameters_l()
Glenn Kasten9b58f632013-07-16 11:37:48 -0700833 size_t mNormalFrameCount; // normal mixer and effects
834
Andy Hung08fb1742015-05-31 23:22:10 -0700835 bool mThreadThrottle; // throttle the thread processing
Andy Hung40eb1a12015-06-18 13:42:02 -0700836 uint32_t mThreadThrottleTimeMs; // throttle time for MIXER threads
837 uint32_t mThreadThrottleEndMs; // notify once per throttling
Andy Hung08fb1742015-05-31 23:22:10 -0700838 uint32_t mHalfBufferMs; // half the buffer size in milliseconds
839
Andy Hung010a1a12014-03-13 13:57:33 -0700840 void* mSinkBuffer; // frame size aligned sink buffer
Eric Laurent81784c32012-11-19 14:55:58 -0800841
Andy Hung98ef9782014-03-04 14:46:50 -0800842 // TODO:
843 // Rearrange the buffer info into a struct/class with
844 // clear, copy, construction, destruction methods.
845 //
846 // mSinkBuffer also has associated with it:
847 //
848 // mSinkBufferSize: Sink Buffer Size
849 // mFormat: Sink Buffer Format
850
Andy Hung69aed5f2014-02-25 17:24:40 -0800851 // Mixer Buffer (mMixerBuffer*)
852 //
853 // In the case of floating point or multichannel data, which is not in the
854 // sink format, it is required to accumulate in a higher precision or greater channel count
855 // buffer before downmixing or data conversion to the sink buffer.
856
857 // Set to "true" to enable the Mixer Buffer otherwise mixer output goes to sink buffer.
858 bool mMixerBufferEnabled;
859
860 // Storage, 32 byte aligned (may make this alignment a requirement later).
861 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
862 void* mMixerBuffer;
863
864 // Size of mMixerBuffer in bytes: mNormalFrameCount * #channels * sampsize.
865 size_t mMixerBufferSize;
866
867 // The audio format of mMixerBuffer. Set to AUDIO_FORMAT_PCM_(FLOAT|16_BIT) only.
868 audio_format_t mMixerBufferFormat;
869
870 // An internal flag set to true by MixerThread::prepareTracks_l()
871 // when mMixerBuffer contains valid data after mixing.
872 bool mMixerBufferValid;
873
Andy Hung98ef9782014-03-04 14:46:50 -0800874 // Effects Buffer (mEffectsBuffer*)
875 //
876 // In the case of effects data, which is not in the sink format,
877 // it is required to accumulate in a different buffer before data conversion
878 // to the sink buffer.
879
880 // Set to "true" to enable the Effects Buffer otherwise effects output goes to sink buffer.
881 bool mEffectBufferEnabled;
882
883 // Storage, 32 byte aligned (may make this alignment a requirement later).
884 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
885 void* mEffectBuffer;
886
887 // Size of mEffectsBuffer in bytes: mNormalFrameCount * #channels * sampsize.
888 size_t mEffectBufferSize;
889
890 // The audio format of mEffectsBuffer. Set to AUDIO_FORMAT_PCM_16_BIT only.
891 audio_format_t mEffectBufferFormat;
892
893 // An internal flag set to true by MixerThread::prepareTracks_l()
894 // when mEffectsBuffer contains valid data after mixing.
895 //
896 // When this is set, all mixer data is routed into the effects buffer
897 // for any processing (including output processing).
898 bool mEffectBufferValid;
899
Eric Laurent81784c32012-11-19 14:55:58 -0800900 // suspend count, > 0 means suspended. While suspended, the thread continues to pull from
901 // tracks and mix, but doesn't write to HAL. A2DP and SCO HAL implementations can't handle
902 // concurrent use of both of them, so Audio Policy Service suspends one of the threads to
903 // workaround that restriction.
904 // 'volatile' means accessed via atomic operations and no lock.
905 volatile int32_t mSuspended;
906
Andy Hung818e7a32016-02-16 18:08:07 -0800907 int64_t mBytesWritten;
Andy Hungc54b1ff2016-02-23 14:07:07 -0800908 int64_t mFramesWritten; // not reset on standby
Andy Hung238fa3d2016-07-28 10:53:22 -0700909 int64_t mSuspendedFrames; // not reset on standby
jiabin245cdd92018-12-07 17:55:15 -0800910
911 // mHapticChannelMask and mHapticChannelCount will only be valid when the thread support
912 // haptic playback.
913 audio_channel_mask_t mHapticChannelMask = AUDIO_CHANNEL_NONE;
914 uint32_t mHapticChannelCount = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800915private:
916 // mMasterMute is in both PlaybackThread and in AudioFlinger. When a
917 // PlaybackThread needs to find out if master-muted, it checks it's local
918 // copy rather than the one in AudioFlinger. This optimization saves a lock.
919 bool mMasterMute;
920 void setMasterMute_l(bool muted) { mMasterMute = muted; }
921protected:
Andy Hungdae27702016-10-31 14:01:16 -0700922 ActiveTracks<Track> mActiveTracks;
Eric Laurent81784c32012-11-19 14:55:58 -0800923
Eric Laurent81784c32012-11-19 14:55:58 -0800924 // Time to sleep between cycles when:
925 virtual uint32_t activeSleepTimeUs() const; // mixer state MIXER_TRACKS_ENABLED
926 virtual uint32_t idleSleepTimeUs() const = 0; // mixer state MIXER_IDLE
927 virtual uint32_t suspendSleepTimeUs() const = 0; // audio policy manager suspended us
928 // No sleep when mixer state == MIXER_TRACKS_READY; relies on audio HAL stream->write()
929 // No sleep in standby mode; waits on a condition
930
931 // Code snippets that are temporarily lifted up out of threadLoop() until the merge
932 void checkSilentMode_l();
933
934 // Non-trivial for DUPLICATING only
935 virtual void saveOutputTracks() { }
936 virtual void clearOutputTracks() { }
937
938 // Cache various calculated values, at threadLoop() entry and after a parameter change
939 virtual void cacheParameters_l();
940
941 virtual uint32_t correctLatency_l(uint32_t latency) const;
942
Eric Laurent1c333e22014-05-20 10:48:17 -0700943 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
944 audio_patch_handle_t *handle);
945 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
946
Phil Burk6fc2a7c2015-04-30 16:08:10 -0700947 bool usesHwAvSync() const { return (mType == DIRECT) && (mOutput != NULL)
948 && mHwSupportsPause
949 && (mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC); }
Eric Laurent0f7b5f22014-12-19 10:43:21 -0800950
Andy Hung1bc088a2018-02-09 15:57:31 -0800951 uint32_t trackCountForUid_l(uid_t uid) const;
Eric Laurentad7dd962016-09-22 12:38:37 -0700952
Eric Laurent81784c32012-11-19 14:55:58 -0800953private:
954
955 friend class AudioFlinger; // for numerous
956
Mikhail Naganovbf493082017-04-17 17:37:12 -0700957 DISALLOW_COPY_AND_ASSIGN(PlaybackThread);
Eric Laurent81784c32012-11-19 14:55:58 -0800958
959 status_t addTrack_l(const sp<Track>& track);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800960 bool destroyTrack_l(const sp<Track>& track);
Eric Laurent81784c32012-11-19 14:55:58 -0800961 void removeTrack_l(const sp<Track>& track);
962
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800963 void readOutputParameters_l();
Kevin Rocardc86a7f72018-04-03 09:00:09 -0700964 void updateMetadata_l() final;
965 virtual void sendMetadataToBackend_l(const StreamOutHalInterface::SourceMetadata& metadata);
Eric Laurent81784c32012-11-19 14:55:58 -0800966
967 virtual void dumpInternals(int fd, const Vector<String16>& args);
968 void dumpTracks(int fd, const Vector<String16>& args);
969
Andy Hungc0691382018-09-12 18:01:57 -0700970 // The Tracks class manages tracks added and removed from the Thread.
Andy Hung1bc088a2018-02-09 15:57:31 -0800971 template <typename T>
972 class Tracks {
973 public:
Andy Hungc0691382018-09-12 18:01:57 -0700974 Tracks(bool saveDeletedTrackIds) :
975 mSaveDeletedTrackIds(saveDeletedTrackIds) { }
Andy Hung1bc088a2018-02-09 15:57:31 -0800976
977 // SortedVector methods
Andy Hungc0691382018-09-12 18:01:57 -0700978 ssize_t add(const sp<T> &track) {
979 const ssize_t index = mTracks.add(track);
980 LOG_ALWAYS_FATAL_IF(index < 0, "cannot add track");
981 return index;
982 }
Andy Hung1bc088a2018-02-09 15:57:31 -0800983 ssize_t remove(const sp<T> &track);
984 size_t size() const {
985 return mTracks.size();
986 }
987 bool isEmpty() const {
988 return mTracks.isEmpty();
989 }
990 ssize_t indexOf(const sp<T> &item) {
991 return mTracks.indexOf(item);
992 }
993 sp<T> operator[](size_t index) const {
994 return mTracks[index];
995 }
996 typename SortedVector<sp<T>>::iterator begin() {
997 return mTracks.begin();
998 }
999 typename SortedVector<sp<T>>::iterator end() {
1000 return mTracks.end();
1001 }
1002
Andy Hungc0691382018-09-12 18:01:57 -07001003 size_t processDeletedTrackIds(std::function<void(int)> f) {
1004 for (const int trackId : mDeletedTrackIds) {
1005 f(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08001006 }
Andy Hungc0691382018-09-12 18:01:57 -07001007 return mDeletedTrackIds.size();
Andy Hung1bc088a2018-02-09 15:57:31 -08001008 }
1009
Andy Hungc0691382018-09-12 18:01:57 -07001010 void clearDeletedTrackIds() { mDeletedTrackIds.clear(); }
Andy Hung1bc088a2018-02-09 15:57:31 -08001011
1012 private:
Andy Hungc0691382018-09-12 18:01:57 -07001013 // Tracks pending deletion for MIXER type threads
1014 const bool mSaveDeletedTrackIds; // true to enable tracking
1015 std::set<int> mDeletedTrackIds;
Andy Hung1bc088a2018-02-09 15:57:31 -08001016
1017 SortedVector<sp<T>> mTracks; // wrapped SortedVector.
1018 };
1019
1020 Tracks<Track> mTracks;
1021
Eric Laurent223fd5c2014-11-11 13:43:36 -08001022 stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
Eric Laurent81784c32012-11-19 14:55:58 -08001023 AudioStreamOut *mOutput;
1024
1025 float mMasterVolume;
1026 nsecs_t mLastWriteTime;
1027 int mNumWrites;
1028 int mNumDelayedWrites;
1029 bool mInWrite;
1030
1031 // FIXME rename these former local variables of threadLoop to standard "m" names
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001032 nsecs_t mStandbyTimeNs;
Andy Hung25c2dac2014-02-27 14:56:00 -08001033 size_t mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -08001034
1035 // cached copies of activeSleepTimeUs() and idleSleepTimeUs() made by cacheParameters_l()
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001036 uint32_t mActiveSleepTimeUs;
1037 uint32_t mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08001038
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001039 uint32_t mSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08001040
1041 // mixer status returned by prepareTracks_l()
1042 mixer_state mMixerStatus; // current cycle
1043 // previous cycle when in prepareTracks_l()
1044 mixer_state mMixerStatusIgnoringFastTracks;
1045 // FIXME or a separate ready state per track
1046
1047 // FIXME move these declarations into the specific sub-class that needs them
1048 // MIXER only
1049 uint32_t sleepTimeShift;
1050
1051 // same as AudioFlinger::mStandbyTimeInNsecs except for DIRECT which uses a shorter value
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001052 nsecs_t mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08001053
1054 // MIXER only
1055 nsecs_t maxPeriod;
1056
1057 // DUPLICATING only
1058 uint32_t writeFrames;
1059
Eric Laurentbfb1b832013-01-07 09:53:42 -08001060 size_t mBytesRemaining;
1061 size_t mCurrentWriteLength;
1062 bool mUseAsyncWrite;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001063 // mWriteAckSequence contains current write sequence on bits 31-1. The write sequence is
1064 // incremented each time a write(), a flush() or a standby() occurs.
1065 // Bit 0 is set when a write blocks and indicates a callback is expected.
1066 // Bit 0 is reset by the async callback thread calling resetWriteBlocked(). Out of sequence
1067 // callbacks are ignored.
1068 uint32_t mWriteAckSequence;
1069 // mDrainSequence contains current drain sequence on bits 31-1. The drain sequence is
1070 // incremented each time a drain is requested or a flush() or standby() occurs.
1071 // Bit 0 is set when the drain() command is called at the HAL and indicates a callback is
1072 // expected.
1073 // Bit 0 is reset by the async callback thread calling resetDraining(). Out of sequence
1074 // callbacks are ignored.
1075 uint32_t mDrainSequence;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001076 sp<AsyncCallbackThread> mCallbackThread;
1077
Eric Laurent81784c32012-11-19 14:55:58 -08001078private:
1079 // The HAL output sink is treated as non-blocking, but current implementation is blocking
1080 sp<NBAIO_Sink> mOutputSink;
1081 // If a fast mixer is present, the blocking pipe sink, otherwise clear
1082 sp<NBAIO_Sink> mPipeSink;
1083 // The current sink for the normal mixer to write it's (sub)mix, mOutputSink or mPipeSink
1084 sp<NBAIO_Sink> mNormalSink;
Eric Laurent81784c32012-11-19 14:55:58 -08001085 uint32_t mScreenState; // cached copy of gScreenState
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07001086 // TODO: add comment and adjust size as needed
Glenn Kasteneef598c2017-04-03 14:41:13 -07001087 static const size_t kFastMixerLogSize = 8 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -08001088 sp<NBLog::Writer> mFastMixerNBLogWriter;
Andy Hung2148bf02016-11-28 19:01:02 -08001089
Dean Wheatley30d28422018-11-06 10:27:40 +11001090 // Downstream patch latency, available if mDownstreamLatencyStatMs.getN() > 0.
1091 audio_utils::Statistics<double> mDownstreamLatencyStatMs{0.999};
Andy Hung2148bf02016-11-28 19:01:02 -08001092
Eric Laurent81784c32012-11-19 14:55:58 -08001093public:
1094 virtual bool hasFastMixer() const = 0;
Glenn Kasten0f11b512014-01-31 16:18:54 -08001095 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex __unused) const
Eric Laurent81784c32012-11-19 14:55:58 -08001096 { FastTrackUnderruns dummy; return dummy; }
1097
1098protected:
1099 // accessed by both binder threads and within threadLoop(), lock on mutex needed
1100 unsigned mFastTrackAvailMask; // bit i set if fast track [i] is available
Eric Laurentd1f69b02014-12-15 14:33:13 -08001101 bool mHwSupportsPause;
1102 bool mHwPaused;
1103 bool mFlushPending;
Eric Laurent7c29ec92017-09-20 17:54:22 -07001104 // volumes last sent to audio HAL with stream->setVolume()
1105 float mLeftVolFloat;
1106 float mRightVolFloat;
Eric Laurent81784c32012-11-19 14:55:58 -08001107};
1108
1109class MixerThread : public PlaybackThread {
1110public:
1111 MixerThread(const sp<AudioFlinger>& audioFlinger,
1112 AudioStreamOut* output,
1113 audio_io_handle_t id,
1114 audio_devices_t device,
Eric Laurent72e3f392015-05-20 14:43:50 -07001115 bool systemReady,
Eric Laurent81784c32012-11-19 14:55:58 -08001116 type_t type = MIXER);
1117 virtual ~MixerThread();
1118
1119 // Thread virtuals
1120
Eric Laurent10351942014-05-08 18:49:52 -07001121 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1122 status_t& status);
Eric Laurent81784c32012-11-19 14:55:58 -08001123 virtual void dumpInternals(int fd, const Vector<String16>& args);
1124
Andy Hung1bc088a2018-02-09 15:57:31 -08001125 virtual bool isTrackAllowed_l(
1126 audio_channel_mask_t channelMask, audio_format_t format,
1127 audio_session_t sessionId, uid_t uid) const override;
Eric Laurent81784c32012-11-19 14:55:58 -08001128protected:
1129 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08001130 virtual uint32_t idleSleepTimeUs() const;
1131 virtual uint32_t suspendSleepTimeUs() const;
1132 virtual void cacheParameters_l();
1133
Andy Hungdae27702016-10-31 14:01:16 -07001134 virtual void acquireWakeLock_l() {
1135 PlaybackThread::acquireWakeLock_l();
Andy Hung818e7a32016-02-16 18:08:07 -08001136 if (hasFastMixer()) {
1137 mFastMixer->setBoottimeOffset(
1138 mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME]);
1139 }
1140 }
1141
Eric Laurent81784c32012-11-19 14:55:58 -08001142 // threadLoop snippets
Eric Laurentbfb1b832013-01-07 09:53:42 -08001143 virtual ssize_t threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08001144 virtual void threadLoop_standby();
1145 virtual void threadLoop_mix();
1146 virtual void threadLoop_sleepTime();
Eric Laurent81784c32012-11-19 14:55:58 -08001147 virtual uint32_t correctLatency_l(uint32_t latency) const;
1148
Eric Laurent054d9d32015-04-24 08:48:48 -07001149 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1150 audio_patch_handle_t *handle);
1151 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
1152
Eric Laurent81784c32012-11-19 14:55:58 -08001153 AudioMixer* mAudioMixer; // normal mixer
1154private:
1155 // one-time initialization, no locks required
Glenn Kasten4d23ca32014-05-13 10:39:51 -07001156 sp<FastMixer> mFastMixer; // non-0 if there is also a fast mixer
Eric Laurent81784c32012-11-19 14:55:58 -08001157 sp<AudioWatchdog> mAudioWatchdog; // non-0 if there is an audio watchdog thread
1158
1159 // contents are not guaranteed to be consistent, no locks required
1160 FastMixerDumpState mFastMixerDumpState;
1161#ifdef STATE_QUEUE_DUMP
1162 StateQueueObserverDump mStateQueueObserverDump;
1163 StateQueueMutatorDump mStateQueueMutatorDump;
1164#endif
1165 AudioWatchdogDump mAudioWatchdogDump;
1166
1167 // accessible only within the threadLoop(), no locks required
1168 // mFastMixer->sq() // for mutating and pushing state
1169 int32_t mFastMixerFutex; // for cold idle
1170
Andy Hung2ddee192015-12-18 17:34:44 -08001171 std::atomic_bool mMasterMono;
Eric Laurent81784c32012-11-19 14:55:58 -08001172public:
Glenn Kasten4d23ca32014-05-13 10:39:51 -07001173 virtual bool hasFastMixer() const { return mFastMixer != 0; }
Eric Laurent81784c32012-11-19 14:55:58 -08001174 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const {
Glenn Kastendc2c50b2016-04-21 08:13:14 -07001175 ALOG_ASSERT(fastIndex < FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08001176 return mFastMixerDumpState.mTracks[fastIndex].mUnderruns;
1177 }
Eric Laurent83b88082014-06-20 18:31:16 -07001178
Andy Hung1c86ebe2018-05-29 20:29:08 -07001179 status_t threadloop_getHalTimestamp_l(
1180 ExtendedTimestamp *timestamp) const override {
1181 if (mNormalSink.get() != nullptr) {
1182 return mNormalSink->getTimestamp(*timestamp);
1183 }
1184 return INVALID_OPERATION;
1185 }
1186
Andy Hung2ddee192015-12-18 17:34:44 -08001187protected:
1188 virtual void setMasterMono_l(bool mono) {
1189 mMasterMono.store(mono);
1190 if (mFastMixer != nullptr) { /* hasFastMixer() */
1191 mFastMixer->setMasterMono(mMasterMono);
1192 }
1193 }
1194 // the FastMixer performs mono blend if it exists.
Glenn Kasten03c48d52016-01-27 17:25:17 -08001195 // Blending with limiter is not idempotent,
1196 // and blending without limiter is idempotent but inefficient to do twice.
Andy Hung2ddee192015-12-18 17:34:44 -08001197 virtual bool requireMonoBlend() { return mMasterMono.load() && !hasFastMixer(); }
Eric Laurent81784c32012-11-19 14:55:58 -08001198};
1199
1200class DirectOutputThread : public PlaybackThread {
1201public:
1202
1203 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurente93cc032016-05-05 10:15:10 -07001204 audio_io_handle_t id, audio_devices_t device, bool systemReady);
Eric Laurent81784c32012-11-19 14:55:58 -08001205 virtual ~DirectOutputThread();
1206
Mikhail Naganovac917ac2018-11-28 14:03:52 -08001207 status_t selectPresentation(int presentationId, int programId);
1208
Eric Laurent81784c32012-11-19 14:55:58 -08001209 // Thread virtuals
1210
Eric Laurent10351942014-05-08 18:49:52 -07001211 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1212 status_t& status);
Eric Laurente659ef42014-09-29 13:06:46 -07001213 virtual void flushHw_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001214
1215protected:
Eric Laurent81784c32012-11-19 14:55:58 -08001216 virtual uint32_t activeSleepTimeUs() const;
1217 virtual uint32_t idleSleepTimeUs() const;
1218 virtual uint32_t suspendSleepTimeUs() const;
1219 virtual void cacheParameters_l();
1220
1221 // threadLoop snippets
1222 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
1223 virtual void threadLoop_mix();
1224 virtual void threadLoop_sleepTime();
Eric Laurentd1f69b02014-12-15 14:33:13 -08001225 virtual void threadLoop_exit();
1226 virtual bool shouldStandby_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001227
Phil Burk43b4dcc2015-06-09 16:53:44 -07001228 virtual void onAddNewTrack_l();
1229
Andy Hung10cbff12017-02-21 17:30:14 -08001230 bool mVolumeShaperActive;
Eric Laurent81784c32012-11-19 14:55:58 -08001231
Eric Laurentbfb1b832013-01-07 09:53:42 -08001232 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurent72e3f392015-05-20 14:43:50 -07001233 audio_io_handle_t id, uint32_t device, ThreadBase::type_t type,
Eric Laurente93cc032016-05-05 10:15:10 -07001234 bool systemReady);
Eric Laurent5850c4c2016-11-10 13:04:31 -08001235 void processVolume_l(Track *track, bool lastTrack);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001236
Eric Laurent81784c32012-11-19 14:55:58 -08001237 // prepareTracks_l() tells threadLoop_mix() the name of the single active track
1238 sp<Track> mActiveTrack;
Phil Burk43b4dcc2015-06-09 16:53:44 -07001239
1240 wp<Track> mPreviousTrack; // used to detect track switch
1241
Eric Laurent81784c32012-11-19 14:55:58 -08001242public:
1243 virtual bool hasFastMixer() const { return false; }
Andy Hung10cbff12017-02-21 17:30:14 -08001244
1245 virtual int64_t computeWaitTimeNs_l() const override;
Andy Hungf3234512018-07-03 14:51:47 -07001246
1247 status_t threadloop_getHalTimestamp_l(ExtendedTimestamp *timestamp) const override {
1248 // For DIRECT and OFFLOAD threads, query the output sink directly.
1249 if (mOutput != nullptr) {
1250 uint64_t uposition64;
1251 struct timespec time;
1252 if (mOutput->getPresentationPosition(
1253 &uposition64, &time) == OK) {
1254 timestamp->mPosition[ExtendedTimestamp::LOCATION_KERNEL]
1255 = (int64_t)uposition64;
1256 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]
1257 = audio_utils_ns_from_timespec(&time);
1258 return NO_ERROR;
1259 }
1260 }
1261 return INVALID_OPERATION;
1262 }
Eric Laurent81784c32012-11-19 14:55:58 -08001263};
1264
Eric Laurentbfb1b832013-01-07 09:53:42 -08001265class OffloadThread : public DirectOutputThread {
1266public:
1267
1268 OffloadThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurente93cc032016-05-05 10:15:10 -07001269 audio_io_handle_t id, uint32_t device, bool systemReady);
Eric Laurent6a51d7e2013-10-17 18:59:26 -07001270 virtual ~OffloadThread() {};
Eric Laurente659ef42014-09-29 13:06:46 -07001271 virtual void flushHw_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001272
1273protected:
1274 // threadLoop snippets
1275 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
1276 virtual void threadLoop_exit();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001277
1278 virtual bool waitingAsyncCallback();
1279 virtual bool waitingAsyncCallback_l();
Haynes Mathew George05317d22016-05-03 16:34:26 -07001280 virtual void invalidateTracks(audio_stream_type_t streamType);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001281
Eric Laurentde0613d2016-07-22 18:19:11 -07001282 virtual bool keepWakeLock() const { return (mKeepWakeLock || (mDrainSequence & 1)); }
Eric Laurent64667972016-03-30 18:19:46 -07001283
Eric Laurentbfb1b832013-01-07 09:53:42 -08001284private:
Eric Laurentbfb1b832013-01-07 09:53:42 -08001285 size_t mPausedWriteLength; // length in bytes of write interrupted by pause
1286 size_t mPausedBytesRemaining; // bytes still waiting in mixbuffer after resume
Eric Laurent64667972016-03-30 18:19:46 -07001287 bool mKeepWakeLock; // keep wake lock while waiting for write callback
Andy Hungf8044752016-07-27 14:58:11 -07001288 uint64_t mOffloadUnderrunPosition; // Current frame position for offloaded playback
1289 // used and valid only during underrun. ~0 if
1290 // no underrun has occurred during playback and
1291 // is not reset on standby.
Eric Laurentbfb1b832013-01-07 09:53:42 -08001292};
1293
1294class AsyncCallbackThread : public Thread {
1295public:
1296
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001297 explicit AsyncCallbackThread(const wp<PlaybackThread>& playbackThread);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001298
1299 virtual ~AsyncCallbackThread();
1300
1301 // Thread virtuals
1302 virtual bool threadLoop();
1303
1304 // RefBase
1305 virtual void onFirstRef();
1306
1307 void exit();
Eric Laurent3b4529e2013-09-05 18:09:19 -07001308 void setWriteBlocked(uint32_t sequence);
1309 void resetWriteBlocked();
1310 void setDraining(uint32_t sequence);
1311 void resetDraining();
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07001312 void setAsyncError();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001313
1314private:
Eric Laurent4de95592013-09-26 15:28:21 -07001315 const wp<PlaybackThread> mPlaybackThread;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001316 // mWriteAckSequence corresponds to the last write sequence passed by the offload thread via
1317 // setWriteBlocked(). The sequence is shifted one bit to the left and the lsb is used
1318 // to indicate that the callback has been received via resetWriteBlocked()
Eric Laurent4de95592013-09-26 15:28:21 -07001319 uint32_t mWriteAckSequence;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001320 // mDrainSequence corresponds to the last drain sequence passed by the offload thread via
1321 // setDraining(). The sequence is shifted one bit to the left and the lsb is used
1322 // to indicate that the callback has been received via resetDraining()
Eric Laurent4de95592013-09-26 15:28:21 -07001323 uint32_t mDrainSequence;
1324 Condition mWaitWorkCV;
1325 Mutex mLock;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07001326 bool mAsyncError;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001327};
1328
Eric Laurent81784c32012-11-19 14:55:58 -08001329class DuplicatingThread : public MixerThread {
1330public:
1331 DuplicatingThread(const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread,
Eric Laurent72e3f392015-05-20 14:43:50 -07001332 audio_io_handle_t id, bool systemReady);
Eric Laurent81784c32012-11-19 14:55:58 -08001333 virtual ~DuplicatingThread();
1334
1335 // Thread virtuals
Andy Hung1bc088a2018-02-09 15:57:31 -08001336 virtual void dumpInternals(int fd, const Vector<String16>& args) override;
1337
Eric Laurent81784c32012-11-19 14:55:58 -08001338 void addOutputTrack(MixerThread* thread);
1339 void removeOutputTrack(MixerThread* thread);
1340 uint32_t waitTimeMs() const { return mWaitTimeMs; }
Kevin Rocard069c2712018-03-29 19:09:14 -07001341
Kevin Rocardc86a7f72018-04-03 09:00:09 -07001342 void sendMetadataToBackend_l(
1343 const StreamOutHalInterface::SourceMetadata& metadata) override;
Eric Laurent81784c32012-11-19 14:55:58 -08001344protected:
1345 virtual uint32_t activeSleepTimeUs() const;
1346
1347private:
1348 bool outputsReady(const SortedVector< sp<OutputTrack> > &outputTracks);
1349protected:
1350 // threadLoop snippets
1351 virtual void threadLoop_mix();
1352 virtual void threadLoop_sleepTime();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001353 virtual ssize_t threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08001354 virtual void threadLoop_standby();
1355 virtual void cacheParameters_l();
1356
1357private:
1358 // called from threadLoop, addOutputTrack, removeOutputTrack
1359 virtual void updateWaitTime_l();
1360protected:
1361 virtual void saveOutputTracks();
1362 virtual void clearOutputTracks();
1363private:
1364
1365 uint32_t mWaitTimeMs;
1366 SortedVector < sp<OutputTrack> > outputTracks;
1367 SortedVector < sp<OutputTrack> > mOutputTracks;
1368public:
1369 virtual bool hasFastMixer() const { return false; }
Andy Hung1c86ebe2018-05-29 20:29:08 -07001370 status_t threadloop_getHalTimestamp_l(
1371 ExtendedTimestamp *timestamp) const override {
1372 if (mOutputTracks.size() > 0) {
1373 // forward the first OutputTrack's kernel information for timestamp.
1374 const ExtendedTimestamp trackTimestamp =
1375 mOutputTracks[0]->getClientProxyTimestamp();
1376 if (trackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0) {
1377 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] =
1378 trackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
1379 timestamp->mPosition[ExtendedTimestamp::LOCATION_KERNEL] =
1380 trackTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
1381 return OK; // discard server timestamp - that's ignored.
1382 }
1383 }
1384 return INVALID_OPERATION;
1385 }
Eric Laurent81784c32012-11-19 14:55:58 -08001386};
1387
Eric Laurent81784c32012-11-19 14:55:58 -08001388// record thread
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001389class RecordThread : public ThreadBase
Eric Laurent81784c32012-11-19 14:55:58 -08001390{
1391public:
1392
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001393 class RecordTrack;
Andy Hung73c02e42015-03-29 01:13:58 -07001394
1395 /* The ResamplerBufferProvider is used to retrieve recorded input data from the
1396 * RecordThread. It maintains local state on the relative position of the read
1397 * position of the RecordTrack compared with the RecordThread.
1398 */
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001399 class ResamplerBufferProvider : public AudioBufferProvider
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001400 {
1401 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001402 explicit ResamplerBufferProvider(RecordTrack* recordTrack) :
Andy Hung73c02e42015-03-29 01:13:58 -07001403 mRecordTrack(recordTrack),
1404 mRsmpInUnrel(0), mRsmpInFront(0) { }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001405 virtual ~ResamplerBufferProvider() { }
Andy Hung73c02e42015-03-29 01:13:58 -07001406
1407 // called to set the ResamplerBufferProvider to head of the RecordThread data buffer,
1408 // skipping any previous data read from the hal.
1409 virtual void reset();
1410
1411 /* Synchronizes RecordTrack position with the RecordThread.
1412 * Calculates available frames and handle overruns if the RecordThread
1413 * has advanced faster than the ResamplerBufferProvider has retrieved data.
1414 * TODO: why not do this for every getNextBuffer?
1415 *
1416 * Parameters
1417 * framesAvailable: pointer to optional output size_t to store record track
1418 * frames available.
1419 * hasOverrun: pointer to optional boolean, returns true if track has overrun.
1420 */
1421
1422 virtual void sync(size_t *framesAvailable = NULL, bool *hasOverrun = NULL);
1423
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001424 // AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -08001425 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001426 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
1427 private:
1428 RecordTrack * const mRecordTrack;
Andy Hung73c02e42015-03-29 01:13:58 -07001429 size_t mRsmpInUnrel; // unreleased frames remaining from
1430 // most recent getNextBuffer
1431 // for debug only
1432 int32_t mRsmpInFront; // next available frame
1433 // rolling counter that is never cleared
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001434 };
1435
Eric Laurent81784c32012-11-19 14:55:58 -08001436#include "RecordTracks.h"
1437
1438 RecordThread(const sp<AudioFlinger>& audioFlinger,
1439 AudioStreamIn *input,
Eric Laurent81784c32012-11-19 14:55:58 -08001440 audio_io_handle_t id,
Eric Laurentd3922f72013-02-01 17:57:04 -08001441 audio_devices_t outDevice,
Eric Laurent72e3f392015-05-20 14:43:50 -07001442 audio_devices_t inDevice,
1443 bool systemReady
Glenn Kasten46909e72013-02-26 09:20:22 -08001444 );
Eric Laurent81784c32012-11-19 14:55:58 -08001445 virtual ~RecordThread();
1446
1447 // no addTrack_l ?
1448 void destroyTrack_l(const sp<RecordTrack>& track);
1449 void removeTrack_l(const sp<RecordTrack>& track);
1450
1451 void dumpInternals(int fd, const Vector<String16>& args);
1452 void dumpTracks(int fd, const Vector<String16>& args);
1453
1454 // Thread virtuals
1455 virtual bool threadLoop();
Eric Laurent555530a2017-02-07 18:17:24 -08001456 virtual void preExit();
Eric Laurent81784c32012-11-19 14:55:58 -08001457
1458 // RefBase
1459 virtual void onFirstRef();
1460
1461 virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; }
Glenn Kastene198c362013-08-13 09:13:36 -07001462
Glenn Kastenb880f5e2014-05-07 08:43:45 -07001463 virtual sp<MemoryDealer> readOnlyHeap() const { return mReadOnlyHeap; }
1464
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001465 virtual sp<IMemory> pipeMemory() const { return mPipeMemory; }
1466
Eric Laurent81784c32012-11-19 14:55:58 -08001467 sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l(
1468 const sp<AudioFlinger::Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001469 const audio_attributes_t& attr,
Eric Laurentf14db3c2017-12-08 14:20:36 -08001470 uint32_t *pSampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -08001471 audio_format_t format,
1472 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08001473 size_t *pFrameCount,
Glenn Kastend848eb42016-03-08 13:42:11 -08001474 audio_session_t sessionId,
Eric Laurentf14db3c2017-12-08 14:20:36 -08001475 size_t *pNotificationFrameCount,
Andy Hung1f12a8a2016-11-07 16:10:30 -08001476 uid_t uid,
Eric Laurent05067782016-06-01 18:27:28 -07001477 audio_input_flags_t *flags,
Eric Laurent81784c32012-11-19 14:55:58 -08001478 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001479 status_t *status /*non-NULL*/,
1480 audio_port_handle_t portId);
Eric Laurent81784c32012-11-19 14:55:58 -08001481
1482 status_t start(RecordTrack* recordTrack,
1483 AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08001484 audio_session_t triggerSession);
Eric Laurent81784c32012-11-19 14:55:58 -08001485
1486 // ask the thread to stop the specified track, and
1487 // return true if the caller should then do it's part of the stopping process
Glenn Kastena8356f62013-07-25 14:37:52 -07001488 bool stop(RecordTrack* recordTrack);
Eric Laurent81784c32012-11-19 14:55:58 -08001489
Andy Hungdc099c22018-09-18 13:46:39 -07001490 void dump(int fd, const Vector<String16>& args) override;
Eric Laurent81784c32012-11-19 14:55:58 -08001491 AudioStreamIn* clearInput();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07001492 virtual sp<StreamHalInterface> stream() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001493
Eric Laurent81784c32012-11-19 14:55:58 -08001494
Eric Laurent10351942014-05-08 18:49:52 -07001495 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1496 status_t& status);
1497 virtual void cacheParameters_l() {}
Eric Laurent81784c32012-11-19 14:55:58 -08001498 virtual String8 getParameters(const String8& keys);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001499 virtual void ioConfigChanged(audio_io_config_event event, pid_t pid = 0);
Eric Laurent1c333e22014-05-20 10:48:17 -07001500 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1501 audio_patch_handle_t *handle);
1502 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
Eric Laurent83b88082014-06-20 18:31:16 -07001503
Mikhail Naganov444ecc32018-05-01 17:40:05 -07001504 void addPatchTrack(const sp<PatchRecord>& record);
1505 void deletePatchTrack(const sp<PatchRecord>& record);
Eric Laurent83b88082014-06-20 18:31:16 -07001506
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001507 void readInputParameters_l();
Glenn Kasten5f972c02014-01-13 09:59:31 -08001508 virtual uint32_t getInputFramesLost();
Eric Laurent81784c32012-11-19 14:55:58 -08001509
1510 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
1511 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
Eric Laurent4c415062016-06-17 16:14:16 -07001512 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const;
Eric Laurent81784c32012-11-19 14:55:58 -08001513
1514 // Return the set of unique session IDs across all tracks.
1515 // The keys are the session IDs, and the associated values are meaningless.
1516 // FIXME replace by Set [and implement Bag/Multiset for other uses].
Glenn Kastend848eb42016-03-08 13:42:11 -08001517 KeyedVector<audio_session_t, bool> sessionIds() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001518
1519 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
1520 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const;
1521
1522 static void syncStartEventCallback(const wp<SyncEvent>& event);
Eric Laurent81784c32012-11-19 14:55:58 -08001523
Glenn Kasten9b58f632013-07-16 11:37:48 -07001524 virtual size_t frameCount() const { return mFrameCount; }
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001525 bool hasFastCapture() const { return mFastCapture != 0; }
Mikhail Naganovdc769682018-05-04 15:34:08 -07001526 virtual void toAudioPortConfig(struct audio_port_config *config);
Glenn Kasten9b58f632013-07-16 11:37:48 -07001527
Eric Laurent4c415062016-06-17 16:14:16 -07001528 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
1529 audio_session_t sessionId);
1530
Andy Hungdae27702016-10-31 14:01:16 -07001531 virtual void acquireWakeLock_l() {
1532 ThreadBase::acquireWakeLock_l();
1533 mActiveTracks.updatePowerState(this, true /* force */);
1534 }
Andy Hung293558a2017-03-21 12:19:20 -07001535 virtual bool isOutput() const override { return false; }
Andy Hungdae27702016-10-31 14:01:16 -07001536
Eric Laurentd8365c52017-07-16 15:27:05 -07001537 void checkBtNrec();
1538
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001539 // Sets the UID records silence
1540 void setRecordSilenced(uid_t uid, bool silenced);
1541
jiabin653cc0a2018-01-17 17:54:10 -08001542 status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
1543
Kevin Rocard069c2712018-03-29 19:09:14 -07001544 void updateMetadata_l() override;
1545
jiabin01c8f562018-07-19 17:47:28 -07001546 bool fastTrackAvailable() const { return mFastTrackAvail; }
1547
Andy Hungc8fddf32018-08-08 18:32:37 -07001548 bool isTimestampCorrectionEnabled() const override {
1549 // checks popcount for exactly one device.
1550 return audio_is_input_device(
1551 mInDevice & mTimestampCorrectedDevices);
1552 }
Eric Laurent81784c32012-11-19 14:55:58 -08001553private:
Eric Laurent81784c32012-11-19 14:55:58 -08001554 // Enter standby if not already in standby, and set mStandby flag
Glenn Kasten93e471f2013-08-19 08:40:07 -07001555 void standbyIfNotAlreadyInStandby();
Eric Laurent81784c32012-11-19 14:55:58 -08001556
1557 // Call the HAL standby method unconditionally, and don't change mStandby flag
Glenn Kastene198c362013-08-13 09:13:36 -07001558 void inputStandBy();
Eric Laurent81784c32012-11-19 14:55:58 -08001559
Eric Laurentd8365c52017-07-16 15:27:05 -07001560 void checkBtNrec_l();
1561
Eric Laurent81784c32012-11-19 14:55:58 -08001562 AudioStreamIn *mInput;
1563 SortedVector < sp<RecordTrack> > mTracks;
Glenn Kasten2b806402013-11-20 16:37:38 -08001564 // mActiveTracks has dual roles: it indicates the current active track(s), and
Eric Laurent81784c32012-11-19 14:55:58 -08001565 // is used together with mStartStopCond to indicate start()/stop() progress
Andy Hungdae27702016-10-31 14:01:16 -07001566 ActiveTracks<RecordTrack> mActiveTracks;
1567
Eric Laurent81784c32012-11-19 14:55:58 -08001568 Condition mStartStopCond;
Glenn Kasten9b58f632013-07-16 11:37:48 -07001569
Glenn Kasten85948432013-08-19 12:09:05 -07001570 // resampler converts input at HAL Hz to output at AudioRecord client Hz
Glenn Kasten1b291842016-07-18 14:55:21 -07001571 void *mRsmpInBuffer; // size = mRsmpInFramesOA
Glenn Kasten85948432013-08-19 12:09:05 -07001572 size_t mRsmpInFrames; // size of resampler input in frames
1573 size_t mRsmpInFramesP2;// size rounded up to a power-of-2
Glenn Kasten1b291842016-07-18 14:55:21 -07001574 size_t mRsmpInFramesOA;// mRsmpInFramesP2 + over-allocation
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001575
1576 // rolling index that is never cleared
Glenn Kasten85948432013-08-19 12:09:05 -07001577 int32_t mRsmpInRear; // last filled frame + 1
Glenn Kasten85948432013-08-19 12:09:05 -07001578
Eric Laurent81784c32012-11-19 14:55:58 -08001579 // For dumpsys
Glenn Kastenb880f5e2014-05-07 08:43:45 -07001580 const sp<MemoryDealer> mReadOnlyHeap;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001581
1582 // one-time initialization, no locks required
Glenn Kastenb187de12014-12-30 08:18:15 -08001583 sp<FastCapture> mFastCapture; // non-0 if there is also
1584 // a fast capture
Eric Laurent72e3f392015-05-20 14:43:50 -07001585
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001586 // FIXME audio watchdog thread
1587
1588 // contents are not guaranteed to be consistent, no locks required
1589 FastCaptureDumpState mFastCaptureDumpState;
1590#ifdef STATE_QUEUE_DUMP
1591 // FIXME StateQueue observer and mutator dump fields
1592#endif
1593 // FIXME audio watchdog dump
1594
1595 // accessible only within the threadLoop(), no locks required
1596 // mFastCapture->sq() // for mutating and pushing state
1597 int32_t mFastCaptureFutex; // for cold idle
1598
1599 // The HAL input source is treated as non-blocking,
1600 // but current implementation is blocking
1601 sp<NBAIO_Source> mInputSource;
1602 // The source for the normal capture thread to read from: mInputSource or mPipeSource
1603 sp<NBAIO_Source> mNormalSource;
1604 // If a fast capture is present, the non-blocking pipe sink written to by fast capture,
1605 // otherwise clear
1606 sp<NBAIO_Sink> mPipeSink;
1607 // If a fast capture is present, the non-blocking pipe source read by normal thread,
1608 // otherwise clear
1609 sp<NBAIO_Source> mPipeSource;
1610 // Depth of pipe from fast capture to normal thread and fast clients, always power of 2
1611 size_t mPipeFramesP2;
1612 // If a fast capture is present, the Pipe as IMemory, otherwise clear
1613 sp<IMemory> mPipeMemory;
1614
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07001615 // TODO: add comment and adjust size as needed
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001616 static const size_t kFastCaptureLogSize = 4 * 1024;
1617 sp<NBLog::Writer> mFastCaptureNBLogWriter;
1618
1619 bool mFastTrackAvail; // true if fast track available
Eric Laurentd8365c52017-07-16 15:27:05 -07001620 // common state to all record threads
1621 std::atomic_bool mBtNrecSuspended;
Andy Hung6427e442018-08-09 12:51:02 -07001622
1623 int64_t mFramesRead = 0; // continuous running counter.
Eric Laurent81784c32012-11-19 14:55:58 -08001624};
Eric Laurent6acd1d42017-01-04 14:23:29 -08001625
1626class MmapThread : public ThreadBase
1627{
1628 public:
1629
1630#include "MmapTracks.h"
1631
1632 MmapThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
1633 AudioHwDevice *hwDev, sp<StreamHalInterface> stream,
1634 audio_devices_t outDevice, audio_devices_t inDevice, bool systemReady);
1635 virtual ~MmapThread();
1636
1637 virtual void configure(const audio_attributes_t *attr,
1638 audio_stream_type_t streamType,
1639 audio_session_t sessionId,
1640 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07001641 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08001642 audio_port_handle_t portId);
1643
1644 void disconnect();
1645
1646 // MmapStreamInterface
1647 status_t createMmapBuffer(int32_t minSizeFrames,
1648 struct audio_mmap_buffer_info *info);
1649 status_t getMmapPosition(struct audio_mmap_position *position);
Eric Laurenta54f1282017-07-01 19:39:32 -07001650 status_t start(const AudioClient& client, audio_port_handle_t *handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08001651 status_t stop(audio_port_handle_t handle);
Eric Laurent18b57012017-02-13 16:23:52 -08001652 status_t standby();
Eric Laurent6acd1d42017-01-04 14:23:29 -08001653
1654 // RefBase
1655 virtual void onFirstRef();
1656
1657 // Thread virtuals
1658 virtual bool threadLoop();
1659
1660 virtual void threadLoop_exit();
1661 virtual void threadLoop_standby();
Eric Laurent18b57012017-02-13 16:23:52 -08001662 virtual bool shouldStandby_l() { return false; }
Eric Laurent331679c2018-04-16 17:03:16 -07001663 virtual status_t exitStandby();
Eric Laurent6acd1d42017-01-04 14:23:29 -08001664
1665 virtual status_t initCheck() const { return (mHalStream == 0) ? NO_INIT : NO_ERROR; }
1666 virtual size_t frameCount() const { return mFrameCount; }
1667 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1668 status_t& status);
1669 virtual String8 getParameters(const String8& keys);
1670 virtual void ioConfigChanged(audio_io_config_event event, pid_t pid = 0);
1671 void readHalParameters_l();
1672 virtual void cacheParameters_l() {}
1673 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1674 audio_patch_handle_t *handle);
1675 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
Mikhail Naganovdc769682018-05-04 15:34:08 -07001676 virtual void toAudioPortConfig(struct audio_port_config *config);
Eric Laurent6acd1d42017-01-04 14:23:29 -08001677
1678 virtual sp<StreamHalInterface> stream() const { return mHalStream; }
1679 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
1680 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
1681 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
1682 audio_session_t sessionId);
1683
1684 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const;
1685 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
1686 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const;
1687
1688 virtual void checkSilentMode_l() {}
1689 virtual void processVolume_l() {}
1690 void checkInvalidTracks_l();
1691
1692 virtual audio_stream_type_t streamType() { return AUDIO_STREAM_DEFAULT; }
1693
1694 virtual void invalidateTracks(audio_stream_type_t streamType __unused) {}
1695
Eric Laurent331679c2018-04-16 17:03:16 -07001696 // Sets the UID records silence
1697 virtual void setRecordSilenced(uid_t uid __unused, bool silenced __unused) {}
1698
Andy Hungdc099c22018-09-18 13:46:39 -07001699 void dump(int fd, const Vector<String16>& args) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08001700 virtual void dumpInternals(int fd, const Vector<String16>& args);
1701 void dumpTracks(int fd, const Vector<String16>& args);
1702
Eric Laurent6acd1d42017-01-04 14:23:29 -08001703 protected:
1704
1705 audio_attributes_t mAttr;
1706 audio_session_t mSessionId;
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07001707 audio_port_handle_t mDeviceId;
Eric Laurent6acd1d42017-01-04 14:23:29 -08001708 audio_port_handle_t mPortId;
1709
Phil Burk7f6b40d2017-02-09 13:18:38 -08001710 wp<MmapStreamCallback> mCallback;
Eric Laurent6acd1d42017-01-04 14:23:29 -08001711 sp<StreamHalInterface> mHalStream;
1712 sp<DeviceHalInterface> mHalDevice;
1713 AudioHwDevice* const mAudioHwDev;
1714 ActiveTracks<MmapTrack> mActiveTracks;
Eric Laurent67f97292018-04-20 18:05:41 -07001715 float mHalVolFloat;
Eric Laurent331679c2018-04-16 17:03:16 -07001716
1717 int32_t mNoCallbackWarningCount;
1718 static constexpr int32_t kMaxNoCallbackWarnings = 5;
Eric Laurent6acd1d42017-01-04 14:23:29 -08001719};
1720
1721class MmapPlaybackThread : public MmapThread, public VolumeInterface
1722{
1723
1724public:
1725 MmapPlaybackThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
1726 AudioHwDevice *hwDev, AudioStreamOut *output,
1727 audio_devices_t outDevice, audio_devices_t inDevice, bool systemReady);
1728 virtual ~MmapPlaybackThread() {}
1729
1730 virtual void configure(const audio_attributes_t *attr,
1731 audio_stream_type_t streamType,
1732 audio_session_t sessionId,
1733 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07001734 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08001735 audio_port_handle_t portId);
1736
1737 AudioStreamOut* clearOutput();
1738
1739 // VolumeInterface
1740 virtual void setMasterVolume(float value);
1741 virtual void setMasterMute(bool muted);
1742 virtual void setStreamVolume(audio_stream_type_t stream, float value);
1743 virtual void setStreamMute(audio_stream_type_t stream, bool muted);
1744 virtual float streamVolume(audio_stream_type_t stream) const;
1745
1746 void setMasterMute_l(bool muted) { mMasterMute = muted; }
1747
1748 virtual void invalidateTracks(audio_stream_type_t streamType);
1749
1750 virtual audio_stream_type_t streamType() { return mStreamType; }
1751 virtual void checkSilentMode_l();
Eric Laurent331679c2018-04-16 17:03:16 -07001752 void processVolume_l() override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08001753
1754 virtual void dumpInternals(int fd, const Vector<String16>& args);
1755
Andy Hung293558a2017-03-21 12:19:20 -07001756 virtual bool isOutput() const override { return true; }
Eric Laurent6acd1d42017-01-04 14:23:29 -08001757
Kevin Rocard069c2712018-03-29 19:09:14 -07001758 void updateMetadata_l() override;
1759
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07001760 virtual void toAudioPortConfig(struct audio_port_config *config);
1761
Eric Laurent6acd1d42017-01-04 14:23:29 -08001762protected:
1763
1764 audio_stream_type_t mStreamType;
1765 float mMasterVolume;
1766 float mStreamVolume;
1767 bool mMasterMute;
1768 bool mStreamMute;
Eric Laurent6acd1d42017-01-04 14:23:29 -08001769 AudioStreamOut* mOutput;
1770};
1771
1772class MmapCaptureThread : public MmapThread
1773{
1774
1775public:
1776 MmapCaptureThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
1777 AudioHwDevice *hwDev, AudioStreamIn *input,
1778 audio_devices_t outDevice, audio_devices_t inDevice, bool systemReady);
1779 virtual ~MmapCaptureThread() {}
1780
1781 AudioStreamIn* clearInput();
1782
Eric Laurent331679c2018-04-16 17:03:16 -07001783 status_t exitStandby() override;
Andy Hung293558a2017-03-21 12:19:20 -07001784 virtual bool isOutput() const override { return false; }
Eric Laurent6acd1d42017-01-04 14:23:29 -08001785
Kevin Rocard069c2712018-03-29 19:09:14 -07001786 void updateMetadata_l() override;
Eric Laurent331679c2018-04-16 17:03:16 -07001787 void processVolume_l() override;
1788 void setRecordSilenced(uid_t uid, bool silenced) override;
Kevin Rocard069c2712018-03-29 19:09:14 -07001789
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07001790 virtual void toAudioPortConfig(struct audio_port_config *config);
1791
Eric Laurent6acd1d42017-01-04 14:23:29 -08001792protected:
1793
1794 AudioStreamIn* mInput;
1795};