blob: 845e38e24bf851a9b6568f85cc7ce6aee3145207 [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
32 OFFLOAD // Thread class is OffloadThread
Eric Laurent81784c32012-11-19 14:55:58 -080033 };
34
Glenn Kasten97b7b752014-09-28 13:04:24 -070035 static const char *threadTypeToString(type_t type);
36
Eric Laurent81784c32012-11-19 14:55:58 -080037 ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -070038 audio_devices_t outDevice, audio_devices_t inDevice, type_t type,
39 bool systemReady);
Eric Laurent81784c32012-11-19 14:55:58 -080040 virtual ~ThreadBase();
41
Glenn Kastencf04c2c2013-08-06 07:41:16 -070042 virtual status_t readyToRun();
43
Eric Laurent81784c32012-11-19 14:55:58 -080044 void dumpBase(int fd, const Vector<String16>& args);
45 void dumpEffectChains(int fd, const Vector<String16>& args);
46
47 void clearPowerManager();
48
49 // base for record and playback
50 enum {
51 CFG_EVENT_IO,
Eric Laurent10351942014-05-08 18:49:52 -070052 CFG_EVENT_PRIO,
53 CFG_EVENT_SET_PARAMETER,
Eric Laurent1c333e22014-05-20 10:48:17 -070054 CFG_EVENT_CREATE_AUDIO_PATCH,
55 CFG_EVENT_RELEASE_AUDIO_PATCH,
Eric Laurent81784c32012-11-19 14:55:58 -080056 };
57
Eric Laurent10351942014-05-08 18:49:52 -070058 class ConfigEventData: public RefBase {
Eric Laurent81784c32012-11-19 14:55:58 -080059 public:
Eric Laurent10351942014-05-08 18:49:52 -070060 virtual ~ConfigEventData() {}
Eric Laurent81784c32012-11-19 14:55:58 -080061
62 virtual void dump(char *buffer, size_t size) = 0;
Eric Laurent10351942014-05-08 18:49:52 -070063 protected:
64 ConfigEventData() {}
Eric Laurent81784c32012-11-19 14:55:58 -080065 };
66
Eric Laurent10351942014-05-08 18:49:52 -070067 // Config event sequence by client if status needed (e.g binder thread calling setParameters()):
68 // 1. create SetParameterConfigEvent. This sets mWaitStatus in config event
69 // 2. Lock mLock
70 // 3. Call sendConfigEvent_l(): Append to mConfigEvents and mWaitWorkCV.signal
71 // 4. sendConfigEvent_l() reads status from event->mStatus;
72 // 5. sendConfigEvent_l() returns status
73 // 6. Unlock
74 //
75 // Parameter sequence by server: threadLoop calling processConfigEvents_l():
76 // 1. Lock mLock
77 // 2. If there is an entry in mConfigEvents proceed ...
78 // 3. Read first entry in mConfigEvents
79 // 4. Remove first entry from mConfigEvents
80 // 5. Process
81 // 6. Set event->mStatus
82 // 7. event->mCond.signal
83 // 8. Unlock
Eric Laurent81784c32012-11-19 14:55:58 -080084
Eric Laurent10351942014-05-08 18:49:52 -070085 class ConfigEvent: public RefBase {
86 public:
87 virtual ~ConfigEvent() {}
88
89 void dump(char *buffer, size_t size) { mData->dump(buffer, size); }
90
91 const int mType; // event type e.g. CFG_EVENT_IO
92 Mutex mLock; // mutex associated with mCond
93 Condition mCond; // condition for status return
94 status_t mStatus; // status communicated to sender
95 bool mWaitStatus; // true if sender is waiting for status
Eric Laurent72e3f392015-05-20 14:43:50 -070096 bool mRequiresSystemReady; // true if must wait for system ready to enter event queue
Eric Laurent10351942014-05-08 18:49:52 -070097 sp<ConfigEventData> mData; // event specific parameter data
98
99 protected:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700100 explicit ConfigEvent(int type, bool requiresSystemReady = false) :
Eric Laurent72e3f392015-05-20 14:43:50 -0700101 mType(type), mStatus(NO_ERROR), mWaitStatus(false),
102 mRequiresSystemReady(requiresSystemReady), mData(NULL) {}
Eric Laurent10351942014-05-08 18:49:52 -0700103 };
104
105 class IoConfigEventData : public ConfigEventData {
106 public:
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700107 IoConfigEventData(audio_io_config_event event, pid_t pid) :
108 mEvent(event), mPid(pid) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800109
110 virtual void dump(char *buffer, size_t size) {
Eric Laurent73e26b62015-04-27 16:55:58 -0700111 snprintf(buffer, size, "IO event: event %d\n", mEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800112 }
113
Eric Laurent73e26b62015-04-27 16:55:58 -0700114 const audio_io_config_event mEvent;
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700115 const pid_t mPid;
Eric Laurent81784c32012-11-19 14:55:58 -0800116 };
117
Eric Laurent10351942014-05-08 18:49:52 -0700118 class IoConfigEvent : public ConfigEvent {
Eric Laurent81784c32012-11-19 14:55:58 -0800119 public:
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700120 IoConfigEvent(audio_io_config_event event, pid_t pid) :
Eric Laurent10351942014-05-08 18:49:52 -0700121 ConfigEvent(CFG_EVENT_IO) {
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700122 mData = new IoConfigEventData(event, pid);
Eric Laurent10351942014-05-08 18:49:52 -0700123 }
124 virtual ~IoConfigEvent() {}
125 };
Eric Laurent81784c32012-11-19 14:55:58 -0800126
Eric Laurent10351942014-05-08 18:49:52 -0700127 class PrioConfigEventData : public ConfigEventData {
128 public:
Mikhail Naganov83f04272017-02-07 10:45:09 -0800129 PrioConfigEventData(pid_t pid, pid_t tid, int32_t prio, bool forApp) :
130 mPid(pid), mTid(tid), mPrio(prio), mForApp(forApp) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800131
132 virtual void dump(char *buffer, size_t size) {
Mikhail Naganov83f04272017-02-07 10:45:09 -0800133 snprintf(buffer, size, "Prio event: pid %d, tid %d, prio %d, for app? %d\n",
134 mPid, mTid, mPrio, mForApp);
Eric Laurent81784c32012-11-19 14:55:58 -0800135 }
136
Eric Laurent81784c32012-11-19 14:55:58 -0800137 const pid_t mPid;
138 const pid_t mTid;
139 const int32_t mPrio;
Mikhail Naganov83f04272017-02-07 10:45:09 -0800140 const bool mForApp;
Eric Laurent81784c32012-11-19 14:55:58 -0800141 };
142
Eric Laurent10351942014-05-08 18:49:52 -0700143 class PrioConfigEvent : public ConfigEvent {
144 public:
Mikhail Naganov83f04272017-02-07 10:45:09 -0800145 PrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp) :
Eric Laurent72e3f392015-05-20 14:43:50 -0700146 ConfigEvent(CFG_EVENT_PRIO, true) {
Mikhail Naganov83f04272017-02-07 10:45:09 -0800147 mData = new PrioConfigEventData(pid, tid, prio, forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700148 }
149 virtual ~PrioConfigEvent() {}
150 };
151
152 class SetParameterConfigEventData : public ConfigEventData {
153 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700154 explicit SetParameterConfigEventData(String8 keyValuePairs) :
Eric Laurent10351942014-05-08 18:49:52 -0700155 mKeyValuePairs(keyValuePairs) {}
156
157 virtual void dump(char *buffer, size_t size) {
158 snprintf(buffer, size, "KeyValue: %s\n", mKeyValuePairs.string());
159 }
160
161 const String8 mKeyValuePairs;
162 };
163
164 class SetParameterConfigEvent : public ConfigEvent {
165 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700166 explicit SetParameterConfigEvent(String8 keyValuePairs) :
Eric Laurent10351942014-05-08 18:49:52 -0700167 ConfigEvent(CFG_EVENT_SET_PARAMETER) {
168 mData = new SetParameterConfigEventData(keyValuePairs);
169 mWaitStatus = true;
170 }
171 virtual ~SetParameterConfigEvent() {}
172 };
173
Eric Laurent1c333e22014-05-20 10:48:17 -0700174 class CreateAudioPatchConfigEventData : public ConfigEventData {
175 public:
176 CreateAudioPatchConfigEventData(const struct audio_patch patch,
177 audio_patch_handle_t handle) :
178 mPatch(patch), mHandle(handle) {}
179
180 virtual void dump(char *buffer, size_t size) {
181 snprintf(buffer, size, "Patch handle: %u\n", mHandle);
182 }
183
184 const struct audio_patch mPatch;
185 audio_patch_handle_t mHandle;
186 };
187
188 class CreateAudioPatchConfigEvent : public ConfigEvent {
189 public:
190 CreateAudioPatchConfigEvent(const struct audio_patch patch,
191 audio_patch_handle_t handle) :
192 ConfigEvent(CFG_EVENT_CREATE_AUDIO_PATCH) {
193 mData = new CreateAudioPatchConfigEventData(patch, handle);
194 mWaitStatus = true;
195 }
196 virtual ~CreateAudioPatchConfigEvent() {}
197 };
198
199 class ReleaseAudioPatchConfigEventData : public ConfigEventData {
200 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700201 explicit ReleaseAudioPatchConfigEventData(const audio_patch_handle_t handle) :
Eric Laurent1c333e22014-05-20 10:48:17 -0700202 mHandle(handle) {}
203
204 virtual void dump(char *buffer, size_t size) {
205 snprintf(buffer, size, "Patch handle: %u\n", mHandle);
206 }
207
208 audio_patch_handle_t mHandle;
209 };
210
211 class ReleaseAudioPatchConfigEvent : public ConfigEvent {
212 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700213 explicit ReleaseAudioPatchConfigEvent(const audio_patch_handle_t handle) :
Eric Laurent1c333e22014-05-20 10:48:17 -0700214 ConfigEvent(CFG_EVENT_RELEASE_AUDIO_PATCH) {
215 mData = new ReleaseAudioPatchConfigEventData(handle);
216 mWaitStatus = true;
217 }
218 virtual ~ReleaseAudioPatchConfigEvent() {}
219 };
Eric Laurent81784c32012-11-19 14:55:58 -0800220
221 class PMDeathRecipient : public IBinder::DeathRecipient {
222 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700223 explicit PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800224 virtual ~PMDeathRecipient() {}
225
226 // IBinder::DeathRecipient
227 virtual void binderDied(const wp<IBinder>& who);
228
229 private:
230 PMDeathRecipient(const PMDeathRecipient&);
231 PMDeathRecipient& operator = (const PMDeathRecipient&);
232
233 wp<ThreadBase> mThread;
234 };
235
236 virtual status_t initCheck() const = 0;
237
238 // static externally-visible
239 type_t type() const { return mType; }
Eric Laurentf6870ae2015-05-08 10:50:03 -0700240 bool isDuplicating() const { return (mType == DUPLICATING); }
241
Eric Laurent81784c32012-11-19 14:55:58 -0800242 audio_io_handle_t id() const { return mId;}
243
244 // dynamic externally-visible
245 uint32_t sampleRate() const { return mSampleRate; }
Eric Laurent81784c32012-11-19 14:55:58 -0800246 audio_channel_mask_t channelMask() const { return mChannelMask; }
Andy Hung463be252014-07-10 16:56:07 -0700247 audio_format_t format() const { return mHALFormat; }
Eric Laurent83b88082014-06-20 18:31:16 -0700248 uint32_t channelCount() const { return mChannelCount; }
Eric Laurent81784c32012-11-19 14:55:58 -0800249 // Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects,
Glenn Kasten9b58f632013-07-16 11:37:48 -0700250 // and returns the [normal mix] buffer's frame count.
251 virtual size_t frameCount() const = 0;
Glenn Kasten4a8308b2016-04-18 14:10:01 -0700252
253 // Return's the HAL's frame count i.e. fast mixer buffer size.
254 size_t frameCountHAL() const { return mFrameCount; }
255
Eric Laurentbfb1b832013-01-07 09:53:42 -0800256 size_t frameSize() const { return mFrameSize; }
Eric Laurent81784c32012-11-19 14:55:58 -0800257
258 // Should be "virtual status_t requestExitAndWait()" and override same
259 // method in Thread, but Thread::requestExitAndWait() is not yet virtual.
260 void exit();
Eric Laurent10351942014-05-08 18:49:52 -0700261 virtual bool checkForNewParameter_l(const String8& keyValuePair,
262 status_t& status) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800263 virtual status_t setParameters(const String8& keyValuePairs);
264 virtual String8 getParameters(const String8& keys) = 0;
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700265 virtual void ioConfigChanged(audio_io_config_event event, pid_t pid = 0) = 0;
Eric Laurent10351942014-05-08 18:49:52 -0700266 // sendConfigEvent_l() must be called with ThreadBase::mLock held
267 // Can temporarily release the lock if waiting for a reply from
268 // processConfigEvents_l().
269 status_t sendConfigEvent_l(sp<ConfigEvent>& event);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700270 void sendIoConfigEvent(audio_io_config_event event, pid_t pid = 0);
271 void sendIoConfigEvent_l(audio_io_config_event event, pid_t pid = 0);
Mikhail Naganov83f04272017-02-07 10:45:09 -0800272 void sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp);
273 void sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio, bool forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700274 status_t sendSetParameterConfigEvent_l(const String8& keyValuePair);
Eric Laurent1c333e22014-05-20 10:48:17 -0700275 status_t sendCreateAudioPatchConfigEvent(const struct audio_patch *patch,
276 audio_patch_handle_t *handle);
277 status_t sendReleaseAudioPatchConfigEvent(audio_patch_handle_t handle);
Eric Laurent021cf962014-05-13 10:18:14 -0700278 void processConfigEvents_l();
Eric Laurent10351942014-05-08 18:49:52 -0700279 virtual void cacheParameters_l() = 0;
Eric Laurent1c333e22014-05-20 10:48:17 -0700280 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
281 audio_patch_handle_t *handle) = 0;
282 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle) = 0;
Eric Laurent83b88082014-06-20 18:31:16 -0700283 virtual void getAudioPortConfig(struct audio_port_config *config) = 0;
Eric Laurent1c333e22014-05-20 10:48:17 -0700284
Eric Laurent81784c32012-11-19 14:55:58 -0800285
286 // see note at declaration of mStandby, mOutDevice and mInDevice
287 bool standby() const { return mStandby; }
288 audio_devices_t outDevice() const { return mOutDevice; }
289 audio_devices_t inDevice() const { return mInDevice; }
290
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700291 virtual sp<StreamHalInterface> stream() const = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800292
293 sp<EffectHandle> createEffect_l(
294 const sp<AudioFlinger::Client>& client,
295 const sp<IEffectClient>& effectClient,
296 int32_t priority,
Glenn Kastend848eb42016-03-08 13:42:11 -0800297 audio_session_t sessionId,
Eric Laurent81784c32012-11-19 14:55:58 -0800298 effect_descriptor_t *desc,
299 int *enabled,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800300 status_t *status /*non-NULL*/,
301 bool pinned);
Eric Laurent81784c32012-11-19 14:55:58 -0800302
303 // return values for hasAudioSession (bit field)
304 enum effect_state {
305 EFFECT_SESSION = 0x1, // the audio session corresponds to at least one
306 // effect
Eric Laurent4c415062016-06-17 16:14:16 -0700307 TRACK_SESSION = 0x2, // the audio session corresponds to at least one
Eric Laurent81784c32012-11-19 14:55:58 -0800308 // track
Eric Laurent4c415062016-06-17 16:14:16 -0700309 FAST_SESSION = 0x4 // the audio session corresponds to at least one
310 // fast track
Eric Laurent81784c32012-11-19 14:55:58 -0800311 };
312
313 // get effect chain corresponding to session Id.
Glenn Kastend848eb42016-03-08 13:42:11 -0800314 sp<EffectChain> getEffectChain(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800315 // same as getEffectChain() but must be called with ThreadBase mutex locked
Glenn Kastend848eb42016-03-08 13:42:11 -0800316 sp<EffectChain> getEffectChain_l(audio_session_t sessionId) const;
Eric Laurent81784c32012-11-19 14:55:58 -0800317 // add an effect chain to the chain list (mEffectChains)
318 virtual status_t addEffectChain_l(const sp<EffectChain>& chain) = 0;
319 // remove an effect chain from the chain list (mEffectChains)
320 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0;
321 // lock all effect chains Mutexes. Must be called before releasing the
322 // ThreadBase mutex before processing the mixer and effects. This guarantees the
323 // integrity of the chains during the process.
324 // Also sets the parameter 'effectChains' to current value of mEffectChains.
325 void lockEffectChains_l(Vector< sp<EffectChain> >& effectChains);
326 // unlock effect chains after process
327 void unlockEffectChains(const Vector< sp<EffectChain> >& effectChains);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800328 // get a copy of mEffectChains vector
329 Vector< sp<EffectChain> > getEffectChains_l() const { return mEffectChains; };
Eric Laurent81784c32012-11-19 14:55:58 -0800330 // set audio mode to all effect chains
331 void setMode(audio_mode_t mode);
332 // get effect module with corresponding ID on specified audio session
Glenn Kastend848eb42016-03-08 13:42:11 -0800333 sp<AudioFlinger::EffectModule> getEffect(audio_session_t sessionId, int effectId);
334 sp<AudioFlinger::EffectModule> getEffect_l(audio_session_t sessionId, int effectId);
Eric Laurent81784c32012-11-19 14:55:58 -0800335 // add and effect module. Also creates the effect chain is none exists for
336 // the effects audio session
337 status_t addEffect_l(const sp< EffectModule>& effect);
338 // remove and effect module. Also removes the effect chain is this was the last
339 // effect
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800340 void removeEffect_l(const sp< EffectModule>& effect, bool release = false);
341 // disconnect an effect handle from module and destroy module if last handle
342 void disconnectEffectHandle(EffectHandle *handle, bool unpinIfLast);
Eric Laurent81784c32012-11-19 14:55:58 -0800343 // detach all tracks connected to an auxiliary effect
Glenn Kasten0f11b512014-01-31 16:18:54 -0800344 virtual void detachAuxEffect_l(int effectId __unused) {}
Eric Laurent4c415062016-06-17 16:14:16 -0700345 // returns a combination of:
346 // - EFFECT_SESSION if effects on this audio session exist in one chain
347 // - TRACK_SESSION if tracks on this audio session exist
348 // - FAST_SESSION if fast tracks on this audio session exist
349 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const = 0;
350 uint32_t hasAudioSession(audio_session_t sessionId) const {
351 Mutex::Autolock _l(mLock);
352 return hasAudioSession_l(sessionId);
353 }
354
Eric Laurent81784c32012-11-19 14:55:58 -0800355 // the value returned by default implementation is not important as the
356 // strategy is only meaningful for PlaybackThread which implements this method
Glenn Kastend848eb42016-03-08 13:42:11 -0800357 virtual uint32_t getStrategyForSession_l(audio_session_t sessionId __unused)
358 { return 0; }
Eric Laurent81784c32012-11-19 14:55:58 -0800359
360 // suspend or restore effect according to the type of effect passed. a NULL
361 // type pointer means suspend all effects in the session
362 void setEffectSuspended(const effect_uuid_t *type,
363 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -0800364 audio_session_t sessionId = AUDIO_SESSION_OUTPUT_MIX);
Eric Laurent81784c32012-11-19 14:55:58 -0800365 // check if some effects must be suspended/restored when an effect is enabled
366 // or disabled
367 void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
368 bool enabled,
Glenn Kastend848eb42016-03-08 13:42:11 -0800369 audio_session_t sessionId =
370 AUDIO_SESSION_OUTPUT_MIX);
Eric Laurent81784c32012-11-19 14:55:58 -0800371 void checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect,
372 bool enabled,
Glenn Kastend848eb42016-03-08 13:42:11 -0800373 audio_session_t sessionId =
374 AUDIO_SESSION_OUTPUT_MIX);
Eric Laurent81784c32012-11-19 14:55:58 -0800375
376 virtual status_t setSyncEvent(const sp<SyncEvent>& event) = 0;
377 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const = 0;
378
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700379 // Return a reference to a per-thread heap which can be used to allocate IMemory
380 // objects that will be read-only to client processes, read/write to mediaserver,
381 // and shared by all client processes of the thread.
382 // The heap is per-thread rather than common across all threads, because
383 // clients can't be trusted not to modify the offset of the IMemory they receive.
384 // If a thread does not have such a heap, this method returns 0.
385 virtual sp<MemoryDealer> readOnlyHeap() const { return 0; }
Eric Laurent81784c32012-11-19 14:55:58 -0800386
Glenn Kasten6181ffd2014-05-13 10:41:52 -0700387 virtual sp<IMemory> pipeMemory() const { return 0; }
388
Eric Laurent72e3f392015-05-20 14:43:50 -0700389 void systemReady();
390
Eric Laurent4c415062016-06-17 16:14:16 -0700391 // checkEffectCompatibility_l() must be called with ThreadBase::mLock held
392 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
393 audio_session_t sessionId) = 0;
394
Eric Laurent81784c32012-11-19 14:55:58 -0800395 mutable Mutex mLock;
396
397protected:
398
399 // entry describing an effect being suspended in mSuspendedSessions keyed vector
400 class SuspendedSessionDesc : public RefBase {
401 public:
402 SuspendedSessionDesc() : mRefCount(0) {}
403
404 int mRefCount; // number of active suspend requests
405 effect_uuid_t mType; // effect type UUID
406 };
407
Andy Hungdae27702016-10-31 14:01:16 -0700408 void acquireWakeLock();
409 virtual void acquireWakeLock_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800410 void releaseWakeLock();
411 void releaseWakeLock_l();
Andy Hungd01b0f12016-11-07 16:10:30 -0800412 void updateWakeLockUids_l(const SortedVector<uid_t> &uids);
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800413 void getPowerManager_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800414 void setEffectSuspended_l(const effect_uuid_t *type,
415 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -0800416 audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800417 // updated mSuspendedSessions when an effect suspended or restored
418 void updateSuspendedSessions_l(const effect_uuid_t *type,
419 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -0800420 audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800421 // check if some effects must be suspended when an effect chain is added
422 void checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain);
423
Narayan Kamath014e7fa2013-10-14 15:03:38 +0100424 String16 getWakeLockTag();
425
Eric Laurent81784c32012-11-19 14:55:58 -0800426 virtual void preExit() { }
Andy Hung2ddee192015-12-18 17:34:44 -0800427 virtual void setMasterMono_l(bool mono __unused) { }
428 virtual bool requireMonoBlend() { return false; }
Eric Laurent81784c32012-11-19 14:55:58 -0800429
430 friend class AudioFlinger; // for mEffectChains
431
432 const type_t mType;
433
434 // Used by parameters, config events, addTrack_l, exit
435 Condition mWaitWorkCV;
436
437 const sp<AudioFlinger> mAudioFlinger;
Glenn Kasten9b58f632013-07-16 11:37:48 -0700438
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800439 // updated by PlaybackThread::readOutputParameters_l() or
440 // RecordThread::readInputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -0800441 uint32_t mSampleRate;
442 size_t mFrameCount; // output HAL, direct output, record
Eric Laurent81784c32012-11-19 14:55:58 -0800443 audio_channel_mask_t mChannelMask;
Glenn Kastenf6ed4232013-07-16 11:16:27 -0700444 uint32_t mChannelCount;
Eric Laurent81784c32012-11-19 14:55:58 -0800445 size_t mFrameSize;
Glenn Kasten97b7b752014-09-28 13:04:24 -0700446 // not HAL frame size, this is for output sink (to pipe to fast mixer)
Andy Hung463be252014-07-10 16:56:07 -0700447 audio_format_t mFormat; // Source format for Recording and
448 // Sink format for Playback.
449 // Sink format may be different than
450 // HAL format if Fastmixer is used.
451 audio_format_t mHALFormat;
Glenn Kasten70949c42013-08-06 07:40:12 -0700452 size_t mBufferSize; // HAL buffer size for read() or write()
Eric Laurent81784c32012-11-19 14:55:58 -0800453
Eric Laurent10351942014-05-08 18:49:52 -0700454 Vector< sp<ConfigEvent> > mConfigEvents;
Eric Laurent72e3f392015-05-20 14:43:50 -0700455 Vector< sp<ConfigEvent> > mPendingConfigEvents; // events awaiting system ready
Eric Laurent81784c32012-11-19 14:55:58 -0800456
457 // These fields are written and read by thread itself without lock or barrier,
Glenn Kasten4944acb2013-08-19 08:39:20 -0700458 // and read by other threads without lock or barrier via standby(), outDevice()
Eric Laurent81784c32012-11-19 14:55:58 -0800459 // and inDevice().
460 // Because of the absence of a lock or barrier, any other thread that reads
461 // these fields must use the information in isolation, or be prepared to deal
462 // with possibility that it might be inconsistent with other information.
Glenn Kasten4944acb2013-08-19 08:39:20 -0700463 bool mStandby; // Whether thread is currently in standby.
Eric Laurent81784c32012-11-19 14:55:58 -0800464 audio_devices_t mOutDevice; // output device
465 audio_devices_t mInDevice; // input device
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700466 audio_devices_t mPrevOutDevice; // previous output device
Eric Laurente8726fe2015-06-26 09:39:24 -0700467 audio_devices_t mPrevInDevice; // previous input device
Eric Laurent296fb132015-05-01 11:38:42 -0700468 struct audio_patch mPatch;
Glenn Kastenf59497b2015-01-26 16:35:47 -0800469 audio_source_t mAudioSource;
Eric Laurent81784c32012-11-19 14:55:58 -0800470
471 const audio_io_handle_t mId;
472 Vector< sp<EffectChain> > mEffectChains;
473
Glenn Kastend7dca052015-03-05 16:05:54 -0800474 static const int kThreadNameLength = 16; // prctl(PR_SET_NAME) limit
475 char mThreadName[kThreadNameLength]; // guaranteed NUL-terminated
Eric Laurent81784c32012-11-19 14:55:58 -0800476 sp<IPowerManager> mPowerManager;
477 sp<IBinder> mWakeLockToken;
478 const sp<PMDeathRecipient> mDeathRecipient;
Glenn Kastend848eb42016-03-08 13:42:11 -0800479 // list of suspended effects per session and per type. The first (outer) vector is
480 // keyed by session ID, the second (inner) by type UUID timeLow field
481 KeyedVector< audio_session_t, KeyedVector< int, sp<SuspendedSessionDesc> > >
Eric Laurent81784c32012-11-19 14:55:58 -0800482 mSuspendedSessions;
Glenn Kastenab7d72f2013-02-27 09:05:28 -0800483 static const size_t kLogSize = 4 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -0800484 sp<NBLog::Writer> mNBLogWriter;
Eric Laurent72e3f392015-05-20 14:43:50 -0700485 bool mSystemReady;
Andy Hung818e7a32016-02-16 18:08:07 -0800486 ExtendedTimestamp mTimestamp;
Andy Hungdae27702016-10-31 14:01:16 -0700487
488 // ActiveTracks is a sorted vector of track type T representing the
489 // active tracks of threadLoop() to be considered by the locked prepare portion.
490 // ActiveTracks should be accessed with the ThreadBase lock held.
491 //
492 // During processing and I/O, the threadLoop does not hold the lock;
493 // hence it does not directly use ActiveTracks. Care should be taken
494 // to hold local strong references or defer removal of tracks
495 // if the threadLoop may still be accessing those tracks due to mix, etc.
496 //
497 // This class updates power information appropriately.
498 //
499
500 template <typename T>
501 class ActiveTracks {
502 public:
503 ActiveTracks()
504 : mActiveTracksGeneration(0)
505 , mLastActiveTracksGeneration(0)
506 { }
507
508 ~ActiveTracks() {
509 ALOGW_IF(!mActiveTracks.isEmpty(),
510 "ActiveTracks should be empty in destructor");
511 }
512 // returns the last track added (even though it may have been
513 // subsequently removed from ActiveTracks).
514 //
515 // Used for DirectOutputThread to ensure a flush is called when transitioning
516 // to a new track (even though it may be on the same session).
517 // Used for OffloadThread to ensure that volume and mixer state is
518 // taken from the latest track added.
519 //
520 // The latest track is saved with a weak pointer to prevent keeping an
521 // otherwise useless track alive. Thus the function will return nullptr
522 // if the latest track has subsequently been removed and destroyed.
523 sp<T> getLatest() {
524 return mLatestActiveTrack.promote();
525 }
526
527 // SortedVector methods
528 ssize_t add(const sp<T> &track);
529 ssize_t remove(const sp<T> &track);
530 size_t size() const {
531 return mActiveTracks.size();
532 }
533 ssize_t indexOf(const sp<T>& item) {
534 return mActiveTracks.indexOf(item);
535 }
536 sp<T> operator[](size_t index) const {
537 return mActiveTracks[index];
538 }
539 typename SortedVector<sp<T>>::iterator begin() {
540 return mActiveTracks.begin();
541 }
542 typename SortedVector<sp<T>>::iterator end() {
543 return mActiveTracks.end();
544 }
545
546 // Due to Binder recursion optimization, clear() and updatePowerState()
547 // cannot be called from a Binder thread because they may call back into
548 // the original calling process (system server) for BatteryNotifier
549 // (which requires a Java environment that may not be present).
550 // Hence, call clear() and updatePowerState() only from the
551 // ThreadBase thread.
552 void clear();
553 // periodically called in the threadLoop() to update power state uids.
554 void updatePowerState(sp<ThreadBase> thread, bool force = false);
555
556 private:
Andy Hungd01b0f12016-11-07 16:10:30 -0800557 SortedVector<uid_t> getWakeLockUids() {
558 SortedVector<uid_t> wakeLockUids;
Andy Hungdae27702016-10-31 14:01:16 -0700559 for (const sp<T> &track : mActiveTracks) {
560 wakeLockUids.add(track->uid());
561 }
562 return wakeLockUids; // moved by underlying SharedBuffer
563 }
564
565 std::map<uid_t, std::pair<ssize_t /* previous */, ssize_t /* current */>>
566 mBatteryCounter;
567 SortedVector<sp<T>> mActiveTracks;
568 int mActiveTracksGeneration;
569 int mLastActiveTracksGeneration;
570 wp<T> mLatestActiveTrack; // latest track added to ActiveTracks
571 };
Eric Laurent81784c32012-11-19 14:55:58 -0800572};
573
574// --- PlaybackThread ---
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700575class PlaybackThread : public ThreadBase, public StreamOutHalInterfaceCallback {
Eric Laurent81784c32012-11-19 14:55:58 -0800576public:
577
578#include "PlaybackTracks.h"
579
580 enum mixer_state {
581 MIXER_IDLE, // no active tracks
582 MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready
Eric Laurentbfb1b832013-01-07 09:53:42 -0800583 MIXER_TRACKS_READY, // at least one active track, and at least one track has data
584 MIXER_DRAIN_TRACK, // drain currently playing track
585 MIXER_DRAIN_ALL, // fully drain the hardware
Eric Laurent81784c32012-11-19 14:55:58 -0800586 // standby mode does not have an enum value
587 // suspend by audio policy manager is orthogonal to mixer state
588 };
589
Eric Laurente93cc032016-05-05 10:15:10 -0700590 // retry count before removing active track in case of underrun on offloaded thread:
591 // we need to make sure that AudioTrack client has enough time to send large buffers
592 //FIXME may be more appropriate if expressed in time units. Need to revise how underrun is
593 // handled for offloaded tracks
594 static const int8_t kMaxTrackRetriesOffload = 20;
595 static const int8_t kMaxTrackStartupRetriesOffload = 100;
596 static const int8_t kMaxTrackStopRetriesOffload = 2;
Eric Laurentad7dd962016-09-22 12:38:37 -0700597 // 14 tracks max per client allows for 2 misbehaving application leaving 4 available tracks.
598 static const uint32_t kMaxTracksPerUid = 14;
Eric Laurente93cc032016-05-05 10:15:10 -0700599
Eric Laurent81784c32012-11-19 14:55:58 -0800600 PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurente93cc032016-05-05 10:15:10 -0700601 audio_io_handle_t id, audio_devices_t device, type_t type, bool systemReady);
Eric Laurent81784c32012-11-19 14:55:58 -0800602 virtual ~PlaybackThread();
603
604 void dump(int fd, const Vector<String16>& args);
605
606 // Thread virtuals
Eric Laurent81784c32012-11-19 14:55:58 -0800607 virtual bool threadLoop();
608
609 // RefBase
610 virtual void onFirstRef();
611
Eric Laurent4c415062016-06-17 16:14:16 -0700612 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
613 audio_session_t sessionId);
614
Eric Laurent81784c32012-11-19 14:55:58 -0800615protected:
616 // Code snippets that were lifted up out of threadLoop()
617 virtual void threadLoop_mix() = 0;
618 virtual void threadLoop_sleepTime() = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800619 virtual ssize_t threadLoop_write();
620 virtual void threadLoop_drain();
Eric Laurent81784c32012-11-19 14:55:58 -0800621 virtual void threadLoop_standby();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800622 virtual void threadLoop_exit();
Eric Laurent81784c32012-11-19 14:55:58 -0800623 virtual void threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove);
624
625 // prepareTracks_l reads and writes mActiveTracks, and returns
626 // the pending set of tracks to remove via Vector 'tracksToRemove'. The caller
627 // is responsible for clearing or destroying this Vector later on, when it
628 // is safe to do so. That will drop the final ref count and destroy the tracks.
629 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove) = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800630 void removeTracks_l(const Vector< sp<Track> >& tracksToRemove);
631
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700632 // StreamOutHalInterfaceCallback implementation
633 virtual void onWriteReady();
634 virtual void onDrainReady();
635 virtual void onError();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800636
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700637 void resetWriteBlocked(uint32_t sequence);
638 void resetDraining(uint32_t sequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800639
640 virtual bool waitingAsyncCallback();
641 virtual bool waitingAsyncCallback_l();
642 virtual bool shouldStandby_l();
Haynes Mathew George4c6a4332014-01-15 12:31:39 -0800643 virtual void onAddNewTrack_l();
Haynes Mathew George4527b9e2016-07-07 19:54:17 -0700644 void onAsyncError(); // error reported by AsyncCallbackThread
Eric Laurent81784c32012-11-19 14:55:58 -0800645
646 // ThreadBase virtuals
647 virtual void preExit();
648
Eric Laurent64667972016-03-30 18:19:46 -0700649 virtual bool keepWakeLock() const { return true; }
Andy Hungdae27702016-10-31 14:01:16 -0700650 virtual void acquireWakeLock_l() {
651 ThreadBase::acquireWakeLock_l();
652 mActiveTracks.updatePowerState(this, true /* force */);
653 }
Eric Laurent64667972016-03-30 18:19:46 -0700654
Eric Laurent81784c32012-11-19 14:55:58 -0800655public:
656
657 virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; }
658
659 // return estimated latency in milliseconds, as reported by HAL
660 uint32_t latency() const;
661 // same, but lock must already be held
662 uint32_t latency_l() const;
663
664 void setMasterVolume(float value);
665 void setMasterMute(bool muted);
666
667 void setStreamVolume(audio_stream_type_t stream, float value);
668 void setStreamMute(audio_stream_type_t stream, bool muted);
669
670 float streamVolume(audio_stream_type_t stream) const;
671
672 sp<Track> createTrack_l(
673 const sp<AudioFlinger::Client>& client,
674 audio_stream_type_t streamType,
675 uint32_t sampleRate,
676 audio_format_t format,
677 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -0800678 size_t *pFrameCount,
Eric Laurent81784c32012-11-19 14:55:58 -0800679 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -0800680 audio_session_t sessionId,
Eric Laurent05067782016-06-01 18:27:28 -0700681 audio_output_flags_t *flags,
Eric Laurent81784c32012-11-19 14:55:58 -0800682 pid_t tid,
Andy Hung1f12a8a2016-11-07 16:10:30 -0800683 uid_t uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800684 status_t *status /*non-NULL*/,
685 audio_port_handle_t portId);
Eric Laurent81784c32012-11-19 14:55:58 -0800686
687 AudioStreamOut* getOutput() const;
688 AudioStreamOut* clearOutput();
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700689 virtual sp<StreamHalInterface> stream() const;
Eric Laurent81784c32012-11-19 14:55:58 -0800690
691 // a very large number of suspend() will eventually wraparound, but unlikely
692 void suspend() { (void) android_atomic_inc(&mSuspended); }
693 void restore()
694 {
695 // if restore() is done without suspend(), get back into
696 // range so that the next suspend() will operate correctly
697 if (android_atomic_dec(&mSuspended) <= 0) {
698 android_atomic_release_store(0, &mSuspended);
699 }
700 }
701 bool isSuspended() const
702 { return android_atomic_acquire_load(&mSuspended) > 0; }
703
704 virtual String8 getParameters(const String8& keys);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700705 virtual void ioConfigChanged(audio_io_config_event event, pid_t pid = 0);
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000706 status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames);
Andy Hung010a1a12014-03-13 13:57:33 -0700707 // FIXME rename mixBuffer() to sinkBuffer() and remove int16_t* dependency.
708 // Consider also removing and passing an explicit mMainBuffer initialization
709 // parameter to AF::PlaybackThread::Track::Track().
710 int16_t *mixBuffer() const {
711 return reinterpret_cast<int16_t *>(mSinkBuffer); };
Eric Laurent81784c32012-11-19 14:55:58 -0800712
713 virtual void detachAuxEffect_l(int effectId);
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700714 status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track>& track,
Eric Laurent81784c32012-11-19 14:55:58 -0800715 int EffectId);
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700716 status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track>& track,
Eric Laurent81784c32012-11-19 14:55:58 -0800717 int EffectId);
718
719 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
720 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
Eric Laurent4c415062016-06-17 16:14:16 -0700721 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const;
Glenn Kastend848eb42016-03-08 13:42:11 -0800722 virtual uint32_t getStrategyForSession_l(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800723
724
725 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
726 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const;
Glenn Kastenfb1fdc92013-07-10 17:03:19 -0700727
728 // called with AudioFlinger lock held
Eric Laurent13084622016-05-17 10:51:49 -0700729 bool invalidateTracks_l(audio_stream_type_t streamType);
Haynes Mathew George05317d22016-05-03 16:34:26 -0700730 virtual void invalidateTracks(audio_stream_type_t streamType);
Eric Laurent81784c32012-11-19 14:55:58 -0800731
Glenn Kasten9b58f632013-07-16 11:37:48 -0700732 virtual size_t frameCount() const { return mNormalFrameCount; }
733
Eric Laurent83b88082014-06-20 18:31:16 -0700734 status_t getTimestamp_l(AudioTimestamp& timestamp);
735
736 void addPatchTrack(const sp<PatchTrack>& track);
737 void deletePatchTrack(const sp<PatchTrack>& track);
738
739 virtual void getAudioPortConfig(struct audio_port_config *config);
Eric Laurentaccc1472013-09-20 09:36:34 -0700740
Eric Laurent81784c32012-11-19 14:55:58 -0800741protected:
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800742 // updated by readOutputParameters_l()
Glenn Kasten9b58f632013-07-16 11:37:48 -0700743 size_t mNormalFrameCount; // normal mixer and effects
744
Andy Hung08fb1742015-05-31 23:22:10 -0700745 bool mThreadThrottle; // throttle the thread processing
Andy Hung40eb1a12015-06-18 13:42:02 -0700746 uint32_t mThreadThrottleTimeMs; // throttle time for MIXER threads
747 uint32_t mThreadThrottleEndMs; // notify once per throttling
Andy Hung08fb1742015-05-31 23:22:10 -0700748 uint32_t mHalfBufferMs; // half the buffer size in milliseconds
749
Andy Hung010a1a12014-03-13 13:57:33 -0700750 void* mSinkBuffer; // frame size aligned sink buffer
Eric Laurent81784c32012-11-19 14:55:58 -0800751
Andy Hung98ef9782014-03-04 14:46:50 -0800752 // TODO:
753 // Rearrange the buffer info into a struct/class with
754 // clear, copy, construction, destruction methods.
755 //
756 // mSinkBuffer also has associated with it:
757 //
758 // mSinkBufferSize: Sink Buffer Size
759 // mFormat: Sink Buffer Format
760
Andy Hung69aed5f2014-02-25 17:24:40 -0800761 // Mixer Buffer (mMixerBuffer*)
762 //
763 // In the case of floating point or multichannel data, which is not in the
764 // sink format, it is required to accumulate in a higher precision or greater channel count
765 // buffer before downmixing or data conversion to the sink buffer.
766
767 // Set to "true" to enable the Mixer Buffer otherwise mixer output goes to sink buffer.
768 bool mMixerBufferEnabled;
769
770 // Storage, 32 byte aligned (may make this alignment a requirement later).
771 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
772 void* mMixerBuffer;
773
774 // Size of mMixerBuffer in bytes: mNormalFrameCount * #channels * sampsize.
775 size_t mMixerBufferSize;
776
777 // The audio format of mMixerBuffer. Set to AUDIO_FORMAT_PCM_(FLOAT|16_BIT) only.
778 audio_format_t mMixerBufferFormat;
779
780 // An internal flag set to true by MixerThread::prepareTracks_l()
781 // when mMixerBuffer contains valid data after mixing.
782 bool mMixerBufferValid;
783
Andy Hung98ef9782014-03-04 14:46:50 -0800784 // Effects Buffer (mEffectsBuffer*)
785 //
786 // In the case of effects data, which is not in the sink format,
787 // it is required to accumulate in a different buffer before data conversion
788 // to the sink buffer.
789
790 // Set to "true" to enable the Effects Buffer otherwise effects output goes to sink buffer.
791 bool mEffectBufferEnabled;
792
793 // Storage, 32 byte aligned (may make this alignment a requirement later).
794 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
795 void* mEffectBuffer;
796
797 // Size of mEffectsBuffer in bytes: mNormalFrameCount * #channels * sampsize.
798 size_t mEffectBufferSize;
799
800 // The audio format of mEffectsBuffer. Set to AUDIO_FORMAT_PCM_16_BIT only.
801 audio_format_t mEffectBufferFormat;
802
803 // An internal flag set to true by MixerThread::prepareTracks_l()
804 // when mEffectsBuffer contains valid data after mixing.
805 //
806 // When this is set, all mixer data is routed into the effects buffer
807 // for any processing (including output processing).
808 bool mEffectBufferValid;
809
Eric Laurent81784c32012-11-19 14:55:58 -0800810 // suspend count, > 0 means suspended. While suspended, the thread continues to pull from
811 // tracks and mix, but doesn't write to HAL. A2DP and SCO HAL implementations can't handle
812 // concurrent use of both of them, so Audio Policy Service suspends one of the threads to
813 // workaround that restriction.
814 // 'volatile' means accessed via atomic operations and no lock.
815 volatile int32_t mSuspended;
816
Andy Hung818e7a32016-02-16 18:08:07 -0800817 int64_t mBytesWritten;
Andy Hungc54b1ff2016-02-23 14:07:07 -0800818 int64_t mFramesWritten; // not reset on standby
Andy Hung238fa3d2016-07-28 10:53:22 -0700819 int64_t mSuspendedFrames; // not reset on standby
Eric Laurent81784c32012-11-19 14:55:58 -0800820private:
821 // mMasterMute is in both PlaybackThread and in AudioFlinger. When a
822 // PlaybackThread needs to find out if master-muted, it checks it's local
823 // copy rather than the one in AudioFlinger. This optimization saves a lock.
824 bool mMasterMute;
825 void setMasterMute_l(bool muted) { mMasterMute = muted; }
826protected:
Andy Hungdae27702016-10-31 14:01:16 -0700827 ActiveTracks<Track> mActiveTracks;
Eric Laurent81784c32012-11-19 14:55:58 -0800828
829 // Allocate a track name for a given channel mask.
830 // Returns name >= 0 if successful, -1 on failure.
Eric Laurentad7dd962016-09-22 12:38:37 -0700831 virtual int getTrackName_l(audio_channel_mask_t channelMask, audio_format_t format,
832 audio_session_t sessionId, uid_t uid) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800833 virtual void deleteTrackName_l(int name) = 0;
834
835 // Time to sleep between cycles when:
836 virtual uint32_t activeSleepTimeUs() const; // mixer state MIXER_TRACKS_ENABLED
837 virtual uint32_t idleSleepTimeUs() const = 0; // mixer state MIXER_IDLE
838 virtual uint32_t suspendSleepTimeUs() const = 0; // audio policy manager suspended us
839 // No sleep when mixer state == MIXER_TRACKS_READY; relies on audio HAL stream->write()
840 // No sleep in standby mode; waits on a condition
841
842 // Code snippets that are temporarily lifted up out of threadLoop() until the merge
843 void checkSilentMode_l();
844
845 // Non-trivial for DUPLICATING only
846 virtual void saveOutputTracks() { }
847 virtual void clearOutputTracks() { }
848
849 // Cache various calculated values, at threadLoop() entry and after a parameter change
850 virtual void cacheParameters_l();
851
852 virtual uint32_t correctLatency_l(uint32_t latency) const;
853
Eric Laurent1c333e22014-05-20 10:48:17 -0700854 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
855 audio_patch_handle_t *handle);
856 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
857
Phil Burk6fc2a7c2015-04-30 16:08:10 -0700858 bool usesHwAvSync() const { return (mType == DIRECT) && (mOutput != NULL)
859 && mHwSupportsPause
860 && (mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC); }
Eric Laurent0f7b5f22014-12-19 10:43:21 -0800861
Eric Laurentad7dd962016-09-22 12:38:37 -0700862 uint32_t trackCountForUid_l(uid_t uid);
863
Eric Laurent81784c32012-11-19 14:55:58 -0800864private:
865
866 friend class AudioFlinger; // for numerous
867
Eric Laurent81784c32012-11-19 14:55:58 -0800868 PlaybackThread& operator = (const PlaybackThread&);
869
870 status_t addTrack_l(const sp<Track>& track);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800871 bool destroyTrack_l(const sp<Track>& track);
Eric Laurent81784c32012-11-19 14:55:58 -0800872 void removeTrack_l(const sp<Track>& track);
Eric Laurentede6c3b2013-09-19 14:37:46 -0700873 void broadcast_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800874
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800875 void readOutputParameters_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800876
877 virtual void dumpInternals(int fd, const Vector<String16>& args);
878 void dumpTracks(int fd, const Vector<String16>& args);
879
880 SortedVector< sp<Track> > mTracks;
Eric Laurent223fd5c2014-11-11 13:43:36 -0800881 stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
Eric Laurent81784c32012-11-19 14:55:58 -0800882 AudioStreamOut *mOutput;
883
884 float mMasterVolume;
885 nsecs_t mLastWriteTime;
886 int mNumWrites;
887 int mNumDelayedWrites;
888 bool mInWrite;
889
890 // FIXME rename these former local variables of threadLoop to standard "m" names
Eric Laurentad9cb8b2015-05-26 16:38:19 -0700891 nsecs_t mStandbyTimeNs;
Andy Hung25c2dac2014-02-27 14:56:00 -0800892 size_t mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -0800893
894 // cached copies of activeSleepTimeUs() and idleSleepTimeUs() made by cacheParameters_l()
Eric Laurentad9cb8b2015-05-26 16:38:19 -0700895 uint32_t mActiveSleepTimeUs;
896 uint32_t mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -0800897
Eric Laurentad9cb8b2015-05-26 16:38:19 -0700898 uint32_t mSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -0800899
900 // mixer status returned by prepareTracks_l()
901 mixer_state mMixerStatus; // current cycle
902 // previous cycle when in prepareTracks_l()
903 mixer_state mMixerStatusIgnoringFastTracks;
904 // FIXME or a separate ready state per track
905
906 // FIXME move these declarations into the specific sub-class that needs them
907 // MIXER only
908 uint32_t sleepTimeShift;
909
910 // same as AudioFlinger::mStandbyTimeInNsecs except for DIRECT which uses a shorter value
Eric Laurentad9cb8b2015-05-26 16:38:19 -0700911 nsecs_t mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -0800912
913 // MIXER only
914 nsecs_t maxPeriod;
915
916 // DUPLICATING only
917 uint32_t writeFrames;
918
Eric Laurentbfb1b832013-01-07 09:53:42 -0800919 size_t mBytesRemaining;
920 size_t mCurrentWriteLength;
921 bool mUseAsyncWrite;
Eric Laurent3b4529e2013-09-05 18:09:19 -0700922 // mWriteAckSequence contains current write sequence on bits 31-1. The write sequence is
923 // incremented each time a write(), a flush() or a standby() occurs.
924 // Bit 0 is set when a write blocks and indicates a callback is expected.
925 // Bit 0 is reset by the async callback thread calling resetWriteBlocked(). Out of sequence
926 // callbacks are ignored.
927 uint32_t mWriteAckSequence;
928 // mDrainSequence contains current drain sequence on bits 31-1. The drain sequence is
929 // incremented each time a drain is requested or a flush() or standby() occurs.
930 // Bit 0 is set when the drain() command is called at the HAL and indicates a callback is
931 // expected.
932 // Bit 0 is reset by the async callback thread calling resetDraining(). Out of sequence
933 // callbacks are ignored.
934 uint32_t mDrainSequence;
Eric Laurentede6c3b2013-09-19 14:37:46 -0700935 // A condition that must be evaluated by prepareTrack_l() has changed and we must not wait
936 // for async write callback in the thread loop before evaluating it
Eric Laurentbfb1b832013-01-07 09:53:42 -0800937 bool mSignalPending;
938 sp<AsyncCallbackThread> mCallbackThread;
939
Eric Laurent81784c32012-11-19 14:55:58 -0800940private:
941 // The HAL output sink is treated as non-blocking, but current implementation is blocking
942 sp<NBAIO_Sink> mOutputSink;
943 // If a fast mixer is present, the blocking pipe sink, otherwise clear
944 sp<NBAIO_Sink> mPipeSink;
945 // The current sink for the normal mixer to write it's (sub)mix, mOutputSink or mPipeSink
946 sp<NBAIO_Sink> mNormalSink;
Glenn Kasten46909e72013-02-26 09:20:22 -0800947#ifdef TEE_SINK
Eric Laurent81784c32012-11-19 14:55:58 -0800948 // For dumpsys
949 sp<NBAIO_Sink> mTeeSink;
950 sp<NBAIO_Source> mTeeSource;
Glenn Kasten46909e72013-02-26 09:20:22 -0800951#endif
Eric Laurent81784c32012-11-19 14:55:58 -0800952 uint32_t mScreenState; // cached copy of gScreenState
Glenn Kastenab7d72f2013-02-27 09:05:28 -0800953 static const size_t kFastMixerLogSize = 4 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -0800954 sp<NBLog::Writer> mFastMixerNBLogWriter;
Andy Hung2148bf02016-11-28 19:01:02 -0800955
956 // Do not call from a sched_fifo thread as it uses a system time call
957 // and obtains a local mutex.
958 class LocalLog {
959 public:
960 void log(const char *fmt, ...) {
961 va_list val;
962 va_start(val, fmt);
963
964 // format to buffer
965 char buffer[512];
966 int length = vsnprintf(buffer, sizeof(buffer), fmt, val);
967 if (length >= (signed)sizeof(buffer)) {
968 length = sizeof(buffer) - 1;
969 }
970
971 // strip out trailing newline
972 while (length > 0 && buffer[length - 1] == '\n') {
973 buffer[--length] = 0;
974 }
975
976 // store in circular array
977 AutoMutex _l(mLock);
978 mLog.emplace_back(
979 std::make_pair(systemTime(SYSTEM_TIME_REALTIME), std::string(buffer)));
980 if (mLog.size() > kLogSize) {
981 mLog.pop_front();
982 }
983
984 va_end(val);
985 }
986
987 void dump(int fd, const Vector<String16>& args, const char *prefix = "") {
988 if (!AudioFlinger::dumpTryLock(mLock)) return; // a local lock, shouldn't happen
989 if (mLog.size() > 0) {
990 bool dumpAll = false;
991 for (const auto &arg : args) {
992 if (arg == String16("--locallog")) {
993 dumpAll = true;
994 }
995 }
996
997 dprintf(fd, "Local Log:\n");
998 auto it = mLog.begin();
Andy Hungf28bcf52016-12-20 12:52:39 -0800999 if (!dumpAll) {
1000 const size_t lines =
1001 (size_t)property_get_int32("audio.locallog.lines", kLogPrint);
1002 if (mLog.size() > lines) {
1003 it += (mLog.size() - lines);
1004 }
Andy Hung2148bf02016-11-28 19:01:02 -08001005 }
1006 for (; it != mLog.end(); ++it) {
1007 const int64_t ns = it->first;
1008 const int ns_per_sec = 1000000000;
1009 const time_t sec = ns / ns_per_sec;
1010 struct tm tm;
1011 localtime_r(&sec, &tm);
1012
1013 dprintf(fd, "%s%02d-%02d %02d:%02d:%02d.%03d %s\n",
1014 prefix,
1015 tm.tm_mon + 1, // localtime_r uses months in 0 - 11 range
1016 tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec,
1017 (int)(ns % ns_per_sec / 1000000),
1018 it->second.c_str());
1019 }
1020 }
1021 mLock.unlock();
1022 }
1023
1024 private:
1025 Mutex mLock;
1026 static const size_t kLogSize = 256; // full history
1027 static const size_t kLogPrint = 32; // default print history
1028 std::deque<std::pair<int64_t, std::string>> mLog;
1029 } mLocalLog;
1030
Eric Laurent81784c32012-11-19 14:55:58 -08001031public:
1032 virtual bool hasFastMixer() const = 0;
Glenn Kasten0f11b512014-01-31 16:18:54 -08001033 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex __unused) const
Eric Laurent81784c32012-11-19 14:55:58 -08001034 { FastTrackUnderruns dummy; return dummy; }
1035
1036protected:
1037 // accessed by both binder threads and within threadLoop(), lock on mutex needed
1038 unsigned mFastTrackAvailMask; // bit i set if fast track [i] is available
Eric Laurentd1f69b02014-12-15 14:33:13 -08001039 bool mHwSupportsPause;
1040 bool mHwPaused;
1041 bool mFlushPending;
Eric Laurent81784c32012-11-19 14:55:58 -08001042};
1043
1044class MixerThread : public PlaybackThread {
1045public:
1046 MixerThread(const sp<AudioFlinger>& audioFlinger,
1047 AudioStreamOut* output,
1048 audio_io_handle_t id,
1049 audio_devices_t device,
Eric Laurent72e3f392015-05-20 14:43:50 -07001050 bool systemReady,
Eric Laurent81784c32012-11-19 14:55:58 -08001051 type_t type = MIXER);
1052 virtual ~MixerThread();
1053
1054 // Thread virtuals
1055
Eric Laurent10351942014-05-08 18:49:52 -07001056 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1057 status_t& status);
Eric Laurent81784c32012-11-19 14:55:58 -08001058 virtual void dumpInternals(int fd, const Vector<String16>& args);
1059
1060protected:
1061 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
Eric Laurentad7dd962016-09-22 12:38:37 -07001062 virtual int getTrackName_l(audio_channel_mask_t channelMask, audio_format_t format,
1063 audio_session_t sessionId, uid_t uid);
Eric Laurent81784c32012-11-19 14:55:58 -08001064 virtual void deleteTrackName_l(int name);
1065 virtual uint32_t idleSleepTimeUs() const;
1066 virtual uint32_t suspendSleepTimeUs() const;
1067 virtual void cacheParameters_l();
1068
Andy Hungdae27702016-10-31 14:01:16 -07001069 virtual void acquireWakeLock_l() {
1070 PlaybackThread::acquireWakeLock_l();
Andy Hung818e7a32016-02-16 18:08:07 -08001071 if (hasFastMixer()) {
1072 mFastMixer->setBoottimeOffset(
1073 mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME]);
1074 }
1075 }
1076
Eric Laurent81784c32012-11-19 14:55:58 -08001077 // threadLoop snippets
Eric Laurentbfb1b832013-01-07 09:53:42 -08001078 virtual ssize_t threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08001079 virtual void threadLoop_standby();
1080 virtual void threadLoop_mix();
1081 virtual void threadLoop_sleepTime();
1082 virtual void threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove);
1083 virtual uint32_t correctLatency_l(uint32_t latency) const;
1084
Eric Laurent054d9d32015-04-24 08:48:48 -07001085 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1086 audio_patch_handle_t *handle);
1087 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
1088
Eric Laurent81784c32012-11-19 14:55:58 -08001089 AudioMixer* mAudioMixer; // normal mixer
1090private:
1091 // one-time initialization, no locks required
Glenn Kasten4d23ca32014-05-13 10:39:51 -07001092 sp<FastMixer> mFastMixer; // non-0 if there is also a fast mixer
Eric Laurent81784c32012-11-19 14:55:58 -08001093 sp<AudioWatchdog> mAudioWatchdog; // non-0 if there is an audio watchdog thread
1094
1095 // contents are not guaranteed to be consistent, no locks required
1096 FastMixerDumpState mFastMixerDumpState;
1097#ifdef STATE_QUEUE_DUMP
1098 StateQueueObserverDump mStateQueueObserverDump;
1099 StateQueueMutatorDump mStateQueueMutatorDump;
1100#endif
1101 AudioWatchdogDump mAudioWatchdogDump;
1102
1103 // accessible only within the threadLoop(), no locks required
1104 // mFastMixer->sq() // for mutating and pushing state
1105 int32_t mFastMixerFutex; // for cold idle
1106
Andy Hung2ddee192015-12-18 17:34:44 -08001107 std::atomic_bool mMasterMono;
Eric Laurent81784c32012-11-19 14:55:58 -08001108public:
Glenn Kasten4d23ca32014-05-13 10:39:51 -07001109 virtual bool hasFastMixer() const { return mFastMixer != 0; }
Eric Laurent81784c32012-11-19 14:55:58 -08001110 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const {
Glenn Kastendc2c50b2016-04-21 08:13:14 -07001111 ALOG_ASSERT(fastIndex < FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08001112 return mFastMixerDumpState.mTracks[fastIndex].mUnderruns;
1113 }
Eric Laurent83b88082014-06-20 18:31:16 -07001114
Andy Hung2ddee192015-12-18 17:34:44 -08001115protected:
1116 virtual void setMasterMono_l(bool mono) {
1117 mMasterMono.store(mono);
1118 if (mFastMixer != nullptr) { /* hasFastMixer() */
1119 mFastMixer->setMasterMono(mMasterMono);
1120 }
1121 }
1122 // the FastMixer performs mono blend if it exists.
Glenn Kasten03c48d52016-01-27 17:25:17 -08001123 // Blending with limiter is not idempotent,
1124 // and blending without limiter is idempotent but inefficient to do twice.
Andy Hung2ddee192015-12-18 17:34:44 -08001125 virtual bool requireMonoBlend() { return mMasterMono.load() && !hasFastMixer(); }
Eric Laurent81784c32012-11-19 14:55:58 -08001126};
1127
1128class DirectOutputThread : public PlaybackThread {
1129public:
1130
1131 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurente93cc032016-05-05 10:15:10 -07001132 audio_io_handle_t id, audio_devices_t device, bool systemReady);
Eric Laurent81784c32012-11-19 14:55:58 -08001133 virtual ~DirectOutputThread();
1134
1135 // Thread virtuals
1136
Eric Laurent10351942014-05-08 18:49:52 -07001137 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1138 status_t& status);
Eric Laurente659ef42014-09-29 13:06:46 -07001139 virtual void flushHw_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001140
1141protected:
Eric Laurentad7dd962016-09-22 12:38:37 -07001142 virtual int getTrackName_l(audio_channel_mask_t channelMask, audio_format_t format,
1143 audio_session_t sessionId, uid_t uid);
Eric Laurent81784c32012-11-19 14:55:58 -08001144 virtual void deleteTrackName_l(int name);
1145 virtual uint32_t activeSleepTimeUs() const;
1146 virtual uint32_t idleSleepTimeUs() const;
1147 virtual uint32_t suspendSleepTimeUs() const;
1148 virtual void cacheParameters_l();
1149
1150 // threadLoop snippets
1151 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
1152 virtual void threadLoop_mix();
1153 virtual void threadLoop_sleepTime();
Eric Laurentd1f69b02014-12-15 14:33:13 -08001154 virtual void threadLoop_exit();
1155 virtual bool shouldStandby_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001156
Phil Burk43b4dcc2015-06-09 16:53:44 -07001157 virtual void onAddNewTrack_l();
1158
Eric Laurent81784c32012-11-19 14:55:58 -08001159 // volumes last sent to audio HAL with stream->set_volume()
1160 float mLeftVolFloat;
1161 float mRightVolFloat;
1162
Eric Laurentbfb1b832013-01-07 09:53:42 -08001163 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurent72e3f392015-05-20 14:43:50 -07001164 audio_io_handle_t id, uint32_t device, ThreadBase::type_t type,
Eric Laurente93cc032016-05-05 10:15:10 -07001165 bool systemReady);
Eric Laurent5850c4c2016-11-10 13:04:31 -08001166 void processVolume_l(Track *track, bool lastTrack);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001167
Eric Laurent81784c32012-11-19 14:55:58 -08001168 // prepareTracks_l() tells threadLoop_mix() the name of the single active track
1169 sp<Track> mActiveTrack;
Phil Burk43b4dcc2015-06-09 16:53:44 -07001170
1171 wp<Track> mPreviousTrack; // used to detect track switch
1172
Eric Laurent81784c32012-11-19 14:55:58 -08001173public:
1174 virtual bool hasFastMixer() const { return false; }
1175};
1176
Eric Laurentbfb1b832013-01-07 09:53:42 -08001177class OffloadThread : public DirectOutputThread {
1178public:
1179
1180 OffloadThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurente93cc032016-05-05 10:15:10 -07001181 audio_io_handle_t id, uint32_t device, bool systemReady);
Eric Laurent6a51d7e2013-10-17 18:59:26 -07001182 virtual ~OffloadThread() {};
Eric Laurente659ef42014-09-29 13:06:46 -07001183 virtual void flushHw_l();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001184
1185protected:
1186 // threadLoop snippets
1187 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
1188 virtual void threadLoop_exit();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001189
1190 virtual bool waitingAsyncCallback();
1191 virtual bool waitingAsyncCallback_l();
Haynes Mathew George05317d22016-05-03 16:34:26 -07001192 virtual void invalidateTracks(audio_stream_type_t streamType);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001193
Eric Laurentde0613d2016-07-22 18:19:11 -07001194 virtual bool keepWakeLock() const { return (mKeepWakeLock || (mDrainSequence & 1)); }
Eric Laurent64667972016-03-30 18:19:46 -07001195
Eric Laurentbfb1b832013-01-07 09:53:42 -08001196private:
Eric Laurentbfb1b832013-01-07 09:53:42 -08001197 size_t mPausedWriteLength; // length in bytes of write interrupted by pause
1198 size_t mPausedBytesRemaining; // bytes still waiting in mixbuffer after resume
Eric Laurent64667972016-03-30 18:19:46 -07001199 bool mKeepWakeLock; // keep wake lock while waiting for write callback
Andy Hungf8044752016-07-27 14:58:11 -07001200 uint64_t mOffloadUnderrunPosition; // Current frame position for offloaded playback
1201 // used and valid only during underrun. ~0 if
1202 // no underrun has occurred during playback and
1203 // is not reset on standby.
Eric Laurentbfb1b832013-01-07 09:53:42 -08001204};
1205
1206class AsyncCallbackThread : public Thread {
1207public:
1208
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001209 explicit AsyncCallbackThread(const wp<PlaybackThread>& playbackThread);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001210
1211 virtual ~AsyncCallbackThread();
1212
1213 // Thread virtuals
1214 virtual bool threadLoop();
1215
1216 // RefBase
1217 virtual void onFirstRef();
1218
1219 void exit();
Eric Laurent3b4529e2013-09-05 18:09:19 -07001220 void setWriteBlocked(uint32_t sequence);
1221 void resetWriteBlocked();
1222 void setDraining(uint32_t sequence);
1223 void resetDraining();
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07001224 void setAsyncError();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001225
1226private:
Eric Laurent4de95592013-09-26 15:28:21 -07001227 const wp<PlaybackThread> mPlaybackThread;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001228 // mWriteAckSequence corresponds to the last write sequence passed by the offload thread via
1229 // setWriteBlocked(). The sequence is shifted one bit to the left and the lsb is used
1230 // to indicate that the callback has been received via resetWriteBlocked()
Eric Laurent4de95592013-09-26 15:28:21 -07001231 uint32_t mWriteAckSequence;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001232 // mDrainSequence corresponds to the last drain sequence passed by the offload thread via
1233 // setDraining(). The sequence is shifted one bit to the left and the lsb is used
1234 // to indicate that the callback has been received via resetDraining()
Eric Laurent4de95592013-09-26 15:28:21 -07001235 uint32_t mDrainSequence;
1236 Condition mWaitWorkCV;
1237 Mutex mLock;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07001238 bool mAsyncError;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001239};
1240
Eric Laurent81784c32012-11-19 14:55:58 -08001241class DuplicatingThread : public MixerThread {
1242public:
1243 DuplicatingThread(const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread,
Eric Laurent72e3f392015-05-20 14:43:50 -07001244 audio_io_handle_t id, bool systemReady);
Eric Laurent81784c32012-11-19 14:55:58 -08001245 virtual ~DuplicatingThread();
1246
1247 // Thread virtuals
1248 void addOutputTrack(MixerThread* thread);
1249 void removeOutputTrack(MixerThread* thread);
1250 uint32_t waitTimeMs() const { return mWaitTimeMs; }
1251protected:
1252 virtual uint32_t activeSleepTimeUs() const;
1253
1254private:
1255 bool outputsReady(const SortedVector< sp<OutputTrack> > &outputTracks);
1256protected:
1257 // threadLoop snippets
1258 virtual void threadLoop_mix();
1259 virtual void threadLoop_sleepTime();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001260 virtual ssize_t threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08001261 virtual void threadLoop_standby();
1262 virtual void cacheParameters_l();
1263
1264private:
1265 // called from threadLoop, addOutputTrack, removeOutputTrack
1266 virtual void updateWaitTime_l();
1267protected:
1268 virtual void saveOutputTracks();
1269 virtual void clearOutputTracks();
1270private:
1271
1272 uint32_t mWaitTimeMs;
1273 SortedVector < sp<OutputTrack> > outputTracks;
1274 SortedVector < sp<OutputTrack> > mOutputTracks;
1275public:
1276 virtual bool hasFastMixer() const { return false; }
1277};
1278
1279
1280// record thread
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001281class RecordThread : public ThreadBase
Eric Laurent81784c32012-11-19 14:55:58 -08001282{
1283public:
1284
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001285 class RecordTrack;
Andy Hung73c02e42015-03-29 01:13:58 -07001286
1287 /* The ResamplerBufferProvider is used to retrieve recorded input data from the
1288 * RecordThread. It maintains local state on the relative position of the read
1289 * position of the RecordTrack compared with the RecordThread.
1290 */
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001291 class ResamplerBufferProvider : public AudioBufferProvider
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001292 {
1293 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001294 explicit ResamplerBufferProvider(RecordTrack* recordTrack) :
Andy Hung73c02e42015-03-29 01:13:58 -07001295 mRecordTrack(recordTrack),
1296 mRsmpInUnrel(0), mRsmpInFront(0) { }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001297 virtual ~ResamplerBufferProvider() { }
Andy Hung73c02e42015-03-29 01:13:58 -07001298
1299 // called to set the ResamplerBufferProvider to head of the RecordThread data buffer,
1300 // skipping any previous data read from the hal.
1301 virtual void reset();
1302
1303 /* Synchronizes RecordTrack position with the RecordThread.
1304 * Calculates available frames and handle overruns if the RecordThread
1305 * has advanced faster than the ResamplerBufferProvider has retrieved data.
1306 * TODO: why not do this for every getNextBuffer?
1307 *
1308 * Parameters
1309 * framesAvailable: pointer to optional output size_t to store record track
1310 * frames available.
1311 * hasOverrun: pointer to optional boolean, returns true if track has overrun.
1312 */
1313
1314 virtual void sync(size_t *framesAvailable = NULL, bool *hasOverrun = NULL);
1315
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001316 // AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -08001317 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001318 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
1319 private:
1320 RecordTrack * const mRecordTrack;
Andy Hung73c02e42015-03-29 01:13:58 -07001321 size_t mRsmpInUnrel; // unreleased frames remaining from
1322 // most recent getNextBuffer
1323 // for debug only
1324 int32_t mRsmpInFront; // next available frame
1325 // rolling counter that is never cleared
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001326 };
1327
Eric Laurent81784c32012-11-19 14:55:58 -08001328#include "RecordTracks.h"
1329
1330 RecordThread(const sp<AudioFlinger>& audioFlinger,
1331 AudioStreamIn *input,
Eric Laurent81784c32012-11-19 14:55:58 -08001332 audio_io_handle_t id,
Eric Laurentd3922f72013-02-01 17:57:04 -08001333 audio_devices_t outDevice,
Eric Laurent72e3f392015-05-20 14:43:50 -07001334 audio_devices_t inDevice,
1335 bool systemReady
Glenn Kasten46909e72013-02-26 09:20:22 -08001336#ifdef TEE_SINK
1337 , const sp<NBAIO_Sink>& teeSink
1338#endif
1339 );
Eric Laurent81784c32012-11-19 14:55:58 -08001340 virtual ~RecordThread();
1341
1342 // no addTrack_l ?
1343 void destroyTrack_l(const sp<RecordTrack>& track);
1344 void removeTrack_l(const sp<RecordTrack>& track);
1345
1346 void dumpInternals(int fd, const Vector<String16>& args);
1347 void dumpTracks(int fd, const Vector<String16>& args);
1348
1349 // Thread virtuals
1350 virtual bool threadLoop();
Eric Laurent81784c32012-11-19 14:55:58 -08001351
1352 // RefBase
1353 virtual void onFirstRef();
1354
1355 virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; }
Glenn Kastene198c362013-08-13 09:13:36 -07001356
Glenn Kastenb880f5e2014-05-07 08:43:45 -07001357 virtual sp<MemoryDealer> readOnlyHeap() const { return mReadOnlyHeap; }
1358
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001359 virtual sp<IMemory> pipeMemory() const { return mPipeMemory; }
1360
Eric Laurent81784c32012-11-19 14:55:58 -08001361 sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l(
1362 const sp<AudioFlinger::Client>& client,
1363 uint32_t sampleRate,
1364 audio_format_t format,
1365 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08001366 size_t *pFrameCount,
Glenn Kastend848eb42016-03-08 13:42:11 -08001367 audio_session_t sessionId,
Glenn Kasten7df8c0b2014-07-03 12:23:29 -07001368 size_t *notificationFrames,
Andy Hung1f12a8a2016-11-07 16:10:30 -08001369 uid_t uid,
Eric Laurent05067782016-06-01 18:27:28 -07001370 audio_input_flags_t *flags,
Eric Laurent81784c32012-11-19 14:55:58 -08001371 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001372 status_t *status /*non-NULL*/,
1373 audio_port_handle_t portId);
Eric Laurent81784c32012-11-19 14:55:58 -08001374
1375 status_t start(RecordTrack* recordTrack,
1376 AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08001377 audio_session_t triggerSession);
Eric Laurent81784c32012-11-19 14:55:58 -08001378
1379 // ask the thread to stop the specified track, and
1380 // return true if the caller should then do it's part of the stopping process
Glenn Kastena8356f62013-07-25 14:37:52 -07001381 bool stop(RecordTrack* recordTrack);
Eric Laurent81784c32012-11-19 14:55:58 -08001382
1383 void dump(int fd, const Vector<String16>& args);
1384 AudioStreamIn* clearInput();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07001385 virtual sp<StreamHalInterface> stream() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001386
Eric Laurent81784c32012-11-19 14:55:58 -08001387
Eric Laurent10351942014-05-08 18:49:52 -07001388 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1389 status_t& status);
1390 virtual void cacheParameters_l() {}
Eric Laurent81784c32012-11-19 14:55:58 -08001391 virtual String8 getParameters(const String8& keys);
Eric Laurent7c1ec5f2015-07-09 14:52:47 -07001392 virtual void ioConfigChanged(audio_io_config_event event, pid_t pid = 0);
Eric Laurent1c333e22014-05-20 10:48:17 -07001393 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1394 audio_patch_handle_t *handle);
1395 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
Eric Laurent83b88082014-06-20 18:31:16 -07001396
1397 void addPatchRecord(const sp<PatchRecord>& record);
1398 void deletePatchRecord(const sp<PatchRecord>& record);
1399
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001400 void readInputParameters_l();
Glenn Kasten5f972c02014-01-13 09:59:31 -08001401 virtual uint32_t getInputFramesLost();
Eric Laurent81784c32012-11-19 14:55:58 -08001402
1403 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
1404 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
Eric Laurent4c415062016-06-17 16:14:16 -07001405 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const;
Eric Laurent81784c32012-11-19 14:55:58 -08001406
1407 // Return the set of unique session IDs across all tracks.
1408 // The keys are the session IDs, and the associated values are meaningless.
1409 // FIXME replace by Set [and implement Bag/Multiset for other uses].
Glenn Kastend848eb42016-03-08 13:42:11 -08001410 KeyedVector<audio_session_t, bool> sessionIds() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001411
1412 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
1413 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const;
1414
1415 static void syncStartEventCallback(const wp<SyncEvent>& event);
Eric Laurent81784c32012-11-19 14:55:58 -08001416
Glenn Kasten9b58f632013-07-16 11:37:48 -07001417 virtual size_t frameCount() const { return mFrameCount; }
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001418 bool hasFastCapture() const { return mFastCapture != 0; }
Eric Laurent83b88082014-06-20 18:31:16 -07001419 virtual void getAudioPortConfig(struct audio_port_config *config);
Glenn Kasten9b58f632013-07-16 11:37:48 -07001420
Eric Laurent4c415062016-06-17 16:14:16 -07001421 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
1422 audio_session_t sessionId);
1423
Andy Hungdae27702016-10-31 14:01:16 -07001424 virtual void acquireWakeLock_l() {
1425 ThreadBase::acquireWakeLock_l();
1426 mActiveTracks.updatePowerState(this, true /* force */);
1427 }
1428
Eric Laurent81784c32012-11-19 14:55:58 -08001429private:
Eric Laurent81784c32012-11-19 14:55:58 -08001430 // Enter standby if not already in standby, and set mStandby flag
Glenn Kasten93e471f2013-08-19 08:40:07 -07001431 void standbyIfNotAlreadyInStandby();
Eric Laurent81784c32012-11-19 14:55:58 -08001432
1433 // Call the HAL standby method unconditionally, and don't change mStandby flag
Glenn Kastene198c362013-08-13 09:13:36 -07001434 void inputStandBy();
Eric Laurent81784c32012-11-19 14:55:58 -08001435
1436 AudioStreamIn *mInput;
1437 SortedVector < sp<RecordTrack> > mTracks;
Glenn Kasten2b806402013-11-20 16:37:38 -08001438 // mActiveTracks has dual roles: it indicates the current active track(s), and
Eric Laurent81784c32012-11-19 14:55:58 -08001439 // is used together with mStartStopCond to indicate start()/stop() progress
Andy Hungdae27702016-10-31 14:01:16 -07001440 ActiveTracks<RecordTrack> mActiveTracks;
1441
Eric Laurent81784c32012-11-19 14:55:58 -08001442 Condition mStartStopCond;
Glenn Kasten9b58f632013-07-16 11:37:48 -07001443
Glenn Kasten85948432013-08-19 12:09:05 -07001444 // resampler converts input at HAL Hz to output at AudioRecord client Hz
Glenn Kasten1b291842016-07-18 14:55:21 -07001445 void *mRsmpInBuffer; // size = mRsmpInFramesOA
Glenn Kasten85948432013-08-19 12:09:05 -07001446 size_t mRsmpInFrames; // size of resampler input in frames
1447 size_t mRsmpInFramesP2;// size rounded up to a power-of-2
Glenn Kasten1b291842016-07-18 14:55:21 -07001448 size_t mRsmpInFramesOA;// mRsmpInFramesP2 + over-allocation
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001449
1450 // rolling index that is never cleared
Glenn Kasten85948432013-08-19 12:09:05 -07001451 int32_t mRsmpInRear; // last filled frame + 1
Glenn Kasten85948432013-08-19 12:09:05 -07001452
Eric Laurent81784c32012-11-19 14:55:58 -08001453 // For dumpsys
1454 const sp<NBAIO_Sink> mTeeSink;
Glenn Kastenb880f5e2014-05-07 08:43:45 -07001455
1456 const sp<MemoryDealer> mReadOnlyHeap;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001457
1458 // one-time initialization, no locks required
Glenn Kastenb187de12014-12-30 08:18:15 -08001459 sp<FastCapture> mFastCapture; // non-0 if there is also
1460 // a fast capture
Eric Laurent72e3f392015-05-20 14:43:50 -07001461
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001462 // FIXME audio watchdog thread
1463
1464 // contents are not guaranteed to be consistent, no locks required
1465 FastCaptureDumpState mFastCaptureDumpState;
1466#ifdef STATE_QUEUE_DUMP
1467 // FIXME StateQueue observer and mutator dump fields
1468#endif
1469 // FIXME audio watchdog dump
1470
1471 // accessible only within the threadLoop(), no locks required
1472 // mFastCapture->sq() // for mutating and pushing state
1473 int32_t mFastCaptureFutex; // for cold idle
1474
1475 // The HAL input source is treated as non-blocking,
1476 // but current implementation is blocking
1477 sp<NBAIO_Source> mInputSource;
1478 // The source for the normal capture thread to read from: mInputSource or mPipeSource
1479 sp<NBAIO_Source> mNormalSource;
1480 // If a fast capture is present, the non-blocking pipe sink written to by fast capture,
1481 // otherwise clear
1482 sp<NBAIO_Sink> mPipeSink;
1483 // If a fast capture is present, the non-blocking pipe source read by normal thread,
1484 // otherwise clear
1485 sp<NBAIO_Source> mPipeSource;
1486 // Depth of pipe from fast capture to normal thread and fast clients, always power of 2
1487 size_t mPipeFramesP2;
1488 // If a fast capture is present, the Pipe as IMemory, otherwise clear
1489 sp<IMemory> mPipeMemory;
1490
1491 static const size_t kFastCaptureLogSize = 4 * 1024;
1492 sp<NBLog::Writer> mFastCaptureNBLogWriter;
1493
1494 bool mFastTrackAvail; // true if fast track available
Eric Laurent81784c32012-11-19 14:55:58 -08001495};