blob: c7ba5c4dfb716e74170b6bc77bb463e2a3bd472f [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
Andy Hungea840382020-05-05 21:50:17 -070033 MMAP_PLAYBACK, // Thread class for MMAP playback stream
34 MMAP_CAPTURE, // Thread class for MMAP capture stream
Eric Laurent1c5e2e32021-08-18 18:50:28 +020035 SPATIALIZER, //
Glenn Kasten1bfe09a2017-02-21 13:05:56 -080036 // If you add any values here, also update ThreadBase::threadTypeToString()
Eric Laurent81784c32012-11-19 14:55:58 -080037 };
38
Glenn Kasten97b7b752014-09-28 13:04:24 -070039 static const char *threadTypeToString(type_t type);
40
Eric Laurent81784c32012-11-19 14:55:58 -080041 ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hungcf10d742020-04-28 15:38:24 -070042 type_t type, bool systemReady, bool isOut);
Eric Laurent81784c32012-11-19 14:55:58 -080043 virtual ~ThreadBase();
44
Glenn Kastencf04c2c2013-08-06 07:41:16 -070045 virtual status_t readyToRun();
46
Eric Laurent81784c32012-11-19 14:55:58 -080047 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,
jiabinc52b1ff2019-10-31 17:20:42 -070056 CFG_EVENT_UPDATE_OUT_DEVICE,
Eric Laurentb3f315a2021-07-13 15:09:05 +020057 CFG_EVENT_RESIZE_BUFFER,
58 CFG_EVENT_CHECK_OUTPUT_STAGE_EFFECTS
Eric Laurent81784c32012-11-19 14:55:58 -080059 };
60
Eric Laurent10351942014-05-08 18:49:52 -070061 class ConfigEventData: public RefBase {
Eric Laurent81784c32012-11-19 14:55:58 -080062 public:
Eric Laurent10351942014-05-08 18:49:52 -070063 virtual ~ConfigEventData() {}
Eric Laurent81784c32012-11-19 14:55:58 -080064
65 virtual void dump(char *buffer, size_t size) = 0;
Eric Laurent10351942014-05-08 18:49:52 -070066 protected:
67 ConfigEventData() {}
Eric Laurent81784c32012-11-19 14:55:58 -080068 };
69
Eric Laurent10351942014-05-08 18:49:52 -070070 // Config event sequence by client if status needed (e.g binder thread calling setParameters()):
71 // 1. create SetParameterConfigEvent. This sets mWaitStatus in config event
72 // 2. Lock mLock
73 // 3. Call sendConfigEvent_l(): Append to mConfigEvents and mWaitWorkCV.signal
74 // 4. sendConfigEvent_l() reads status from event->mStatus;
75 // 5. sendConfigEvent_l() returns status
76 // 6. Unlock
77 //
78 // Parameter sequence by server: threadLoop calling processConfigEvents_l():
79 // 1. Lock mLock
80 // 2. If there is an entry in mConfigEvents proceed ...
81 // 3. Read first entry in mConfigEvents
82 // 4. Remove first entry from mConfigEvents
83 // 5. Process
84 // 6. Set event->mStatus
85 // 7. event->mCond.signal
86 // 8. Unlock
Eric Laurent81784c32012-11-19 14:55:58 -080087
Eric Laurent10351942014-05-08 18:49:52 -070088 class ConfigEvent: public RefBase {
89 public:
90 virtual ~ConfigEvent() {}
91
Eric Laurentb3f315a2021-07-13 15:09:05 +020092 void dump(char *buffer, size_t size) {
93 snprintf(buffer, size, "Event type: %d\n", mType);
94 if (mData != nullptr) {
95 snprintf(buffer, size, "Data:\n");
96 mData->dump(buffer, size);
97 }
98 }
Eric Laurent10351942014-05-08 18:49:52 -070099
100 const int mType; // event type e.g. CFG_EVENT_IO
101 Mutex mLock; // mutex associated with mCond
102 Condition mCond; // condition for status return
103 status_t mStatus; // status communicated to sender
104 bool mWaitStatus; // true if sender is waiting for status
Eric Laurent72e3f392015-05-20 14:43:50 -0700105 bool mRequiresSystemReady; // true if must wait for system ready to enter event queue
Eric Laurent10351942014-05-08 18:49:52 -0700106 sp<ConfigEventData> mData; // event specific parameter data
107
108 protected:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700109 explicit ConfigEvent(int type, bool requiresSystemReady = false) :
Eric Laurent72e3f392015-05-20 14:43:50 -0700110 mType(type), mStatus(NO_ERROR), mWaitStatus(false),
111 mRequiresSystemReady(requiresSystemReady), mData(NULL) {}
Eric Laurent10351942014-05-08 18:49:52 -0700112 };
113
114 class IoConfigEventData : public ConfigEventData {
115 public:
Mikhail Naganov88536df2021-07-26 17:30:29 -0700116 IoConfigEventData(audio_io_config_event_t event, pid_t pid,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700117 audio_port_handle_t portId) :
118 mEvent(event), mPid(pid), mPortId(portId) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800119
120 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200121 snprintf(buffer, size, "- IO event: event %d\n", mEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800122 }
123
Mikhail Naganov88536df2021-07-26 17:30:29 -0700124 const audio_io_config_event_t mEvent;
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700125 const pid_t mPid;
Eric Laurent09f1ed22019-04-24 17:45:17 -0700126 const audio_port_handle_t mPortId;
Eric Laurent81784c32012-11-19 14:55:58 -0800127 };
128
Eric Laurent10351942014-05-08 18:49:52 -0700129 class IoConfigEvent : public ConfigEvent {
Eric Laurent81784c32012-11-19 14:55:58 -0800130 public:
Mikhail Naganov88536df2021-07-26 17:30:29 -0700131 IoConfigEvent(audio_io_config_event_t event, pid_t pid, audio_port_handle_t portId) :
Eric Laurent10351942014-05-08 18:49:52 -0700132 ConfigEvent(CFG_EVENT_IO) {
Eric Laurent09f1ed22019-04-24 17:45:17 -0700133 mData = new IoConfigEventData(event, pid, portId);
Eric Laurent10351942014-05-08 18:49:52 -0700134 }
135 virtual ~IoConfigEvent() {}
136 };
Eric Laurent81784c32012-11-19 14:55:58 -0800137
Eric Laurent10351942014-05-08 18:49:52 -0700138 class PrioConfigEventData : public ConfigEventData {
139 public:
Mikhail Naganov83f04272017-02-07 10:45:09 -0800140 PrioConfigEventData(pid_t pid, pid_t tid, int32_t prio, bool forApp) :
141 mPid(pid), mTid(tid), mPrio(prio), mForApp(forApp) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800142
143 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200144 snprintf(buffer, size, "- Prio event: pid %d, tid %d, prio %d, for app? %d\n",
Mikhail Naganov83f04272017-02-07 10:45:09 -0800145 mPid, mTid, mPrio, mForApp);
Eric Laurent81784c32012-11-19 14:55:58 -0800146 }
147
Eric Laurent81784c32012-11-19 14:55:58 -0800148 const pid_t mPid;
149 const pid_t mTid;
150 const int32_t mPrio;
Mikhail Naganov83f04272017-02-07 10:45:09 -0800151 const bool mForApp;
Eric Laurent81784c32012-11-19 14:55:58 -0800152 };
153
Eric Laurent10351942014-05-08 18:49:52 -0700154 class PrioConfigEvent : public ConfigEvent {
155 public:
Mikhail Naganov83f04272017-02-07 10:45:09 -0800156 PrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp) :
Eric Laurent72e3f392015-05-20 14:43:50 -0700157 ConfigEvent(CFG_EVENT_PRIO, true) {
Mikhail Naganov83f04272017-02-07 10:45:09 -0800158 mData = new PrioConfigEventData(pid, tid, prio, forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700159 }
160 virtual ~PrioConfigEvent() {}
161 };
162
163 class SetParameterConfigEventData : public ConfigEventData {
164 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700165 explicit SetParameterConfigEventData(String8 keyValuePairs) :
Eric Laurent10351942014-05-08 18:49:52 -0700166 mKeyValuePairs(keyValuePairs) {}
167
168 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200169 snprintf(buffer, size, "- KeyValue: %s\n", mKeyValuePairs.string());
Eric Laurent10351942014-05-08 18:49:52 -0700170 }
171
172 const String8 mKeyValuePairs;
173 };
174
175 class SetParameterConfigEvent : public ConfigEvent {
176 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700177 explicit SetParameterConfigEvent(String8 keyValuePairs) :
Eric Laurent10351942014-05-08 18:49:52 -0700178 ConfigEvent(CFG_EVENT_SET_PARAMETER) {
179 mData = new SetParameterConfigEventData(keyValuePairs);
180 mWaitStatus = true;
181 }
182 virtual ~SetParameterConfigEvent() {}
183 };
184
Eric Laurent1c333e22014-05-20 10:48:17 -0700185 class CreateAudioPatchConfigEventData : public ConfigEventData {
186 public:
187 CreateAudioPatchConfigEventData(const struct audio_patch patch,
188 audio_patch_handle_t handle) :
189 mPatch(patch), mHandle(handle) {}
190
191 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200192 snprintf(buffer, size, "- Patch handle: %u\n", mHandle);
Eric Laurent1c333e22014-05-20 10:48:17 -0700193 }
194
195 const struct audio_patch mPatch;
196 audio_patch_handle_t mHandle;
197 };
198
199 class CreateAudioPatchConfigEvent : public ConfigEvent {
200 public:
201 CreateAudioPatchConfigEvent(const struct audio_patch patch,
202 audio_patch_handle_t handle) :
203 ConfigEvent(CFG_EVENT_CREATE_AUDIO_PATCH) {
204 mData = new CreateAudioPatchConfigEventData(patch, handle);
205 mWaitStatus = true;
206 }
207 virtual ~CreateAudioPatchConfigEvent() {}
208 };
209
210 class ReleaseAudioPatchConfigEventData : public ConfigEventData {
211 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700212 explicit ReleaseAudioPatchConfigEventData(const audio_patch_handle_t handle) :
Eric Laurent1c333e22014-05-20 10:48:17 -0700213 mHandle(handle) {}
214
215 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200216 snprintf(buffer, size, "- Patch handle: %u\n", mHandle);
Eric Laurent1c333e22014-05-20 10:48:17 -0700217 }
218
219 audio_patch_handle_t mHandle;
220 };
221
222 class ReleaseAudioPatchConfigEvent : public ConfigEvent {
223 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700224 explicit ReleaseAudioPatchConfigEvent(const audio_patch_handle_t handle) :
Eric Laurent1c333e22014-05-20 10:48:17 -0700225 ConfigEvent(CFG_EVENT_RELEASE_AUDIO_PATCH) {
226 mData = new ReleaseAudioPatchConfigEventData(handle);
227 mWaitStatus = true;
228 }
229 virtual ~ReleaseAudioPatchConfigEvent() {}
230 };
Eric Laurent81784c32012-11-19 14:55:58 -0800231
jiabinc52b1ff2019-10-31 17:20:42 -0700232 class UpdateOutDevicesConfigEventData : public ConfigEventData {
233 public:
234 explicit UpdateOutDevicesConfigEventData(const DeviceDescriptorBaseVector& outDevices) :
235 mOutDevices(outDevices) {}
236
237 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200238 snprintf(buffer, size, "- Devices: %s", android::toString(mOutDevices).c_str());
jiabinc52b1ff2019-10-31 17:20:42 -0700239 }
240
241 DeviceDescriptorBaseVector mOutDevices;
242 };
243
244 class UpdateOutDevicesConfigEvent : public ConfigEvent {
245 public:
246 explicit UpdateOutDevicesConfigEvent(const DeviceDescriptorBaseVector& outDevices) :
247 ConfigEvent(CFG_EVENT_UPDATE_OUT_DEVICE) {
248 mData = new UpdateOutDevicesConfigEventData(outDevices);
249 }
250
251 virtual ~UpdateOutDevicesConfigEvent();
252 };
253
Eric Laurentec376dc2021-04-08 20:41:22 +0200254 class ResizeBufferConfigEventData : public ConfigEventData {
255 public:
256 explicit ResizeBufferConfigEventData(int32_t maxSharedAudioHistoryMs) :
257 mMaxSharedAudioHistoryMs(maxSharedAudioHistoryMs) {}
258
259 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200260 snprintf(buffer, size, "- mMaxSharedAudioHistoryMs: %d", mMaxSharedAudioHistoryMs);
Eric Laurentec376dc2021-04-08 20:41:22 +0200261 }
262
263 int32_t mMaxSharedAudioHistoryMs;
264 };
265
266 class ResizeBufferConfigEvent : public ConfigEvent {
267 public:
268 explicit ResizeBufferConfigEvent(int32_t maxSharedAudioHistoryMs) :
269 ConfigEvent(CFG_EVENT_RESIZE_BUFFER) {
270 mData = new ResizeBufferConfigEventData(maxSharedAudioHistoryMs);
271 }
272
273 virtual ~ResizeBufferConfigEvent() {}
274 };
275
Eric Laurentb3f315a2021-07-13 15:09:05 +0200276 class CheckOutputStageEffectsEvent : public ConfigEvent {
277 public:
278 CheckOutputStageEffectsEvent() :
279 ConfigEvent(CFG_EVENT_CHECK_OUTPUT_STAGE_EFFECTS) {
280 }
281
282 virtual ~CheckOutputStageEffectsEvent() {}
283 };
284
285
Eric Laurent81784c32012-11-19 14:55:58 -0800286 class PMDeathRecipient : public IBinder::DeathRecipient {
287 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700288 explicit PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800289 virtual ~PMDeathRecipient() {}
290
291 // IBinder::DeathRecipient
292 virtual void binderDied(const wp<IBinder>& who);
293
294 private:
Mikhail Naganovbf493082017-04-17 17:37:12 -0700295 DISALLOW_COPY_AND_ASSIGN(PMDeathRecipient);
Eric Laurent81784c32012-11-19 14:55:58 -0800296
297 wp<ThreadBase> mThread;
298 };
299
300 virtual status_t initCheck() const = 0;
301
302 // static externally-visible
303 type_t type() const { return mType; }
Eric Laurentf6870ae2015-05-08 10:50:03 -0700304 bool isDuplicating() const { return (mType == DUPLICATING); }
305
Eric Laurent81784c32012-11-19 14:55:58 -0800306 audio_io_handle_t id() const { return mId;}
307
308 // dynamic externally-visible
309 uint32_t sampleRate() const { return mSampleRate; }
Eric Laurent81784c32012-11-19 14:55:58 -0800310 audio_channel_mask_t channelMask() const { return mChannelMask; }
Eric Laurentf1f22e72021-07-13 14:04:14 +0200311 virtual audio_channel_mask_t mixerChannelMask() const { return mChannelMask; }
312
Andy Hung463be252014-07-10 16:56:07 -0700313 audio_format_t format() const { return mHALFormat; }
Eric Laurent83b88082014-06-20 18:31:16 -0700314 uint32_t channelCount() const { return mChannelCount; }
Eric Laurentf1f22e72021-07-13 14:04:14 +0200315
Eric Laurent81784c32012-11-19 14:55:58 -0800316 // Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects,
Glenn Kasten9b58f632013-07-16 11:37:48 -0700317 // and returns the [normal mix] buffer's frame count.
318 virtual size_t frameCount() const = 0;
jiabineb3bda02020-06-30 14:07:03 -0700319 virtual audio_channel_mask_t hapticChannelMask() const { return AUDIO_CHANNEL_NONE; }
Eric Laurent6b446ce2019-12-13 10:56:31 -0800320 virtual uint32_t latency_l() const { return 0; }
321 virtual void setVolumeForOutput_l(float left __unused, float right __unused) const {}
Glenn Kasten4a8308b2016-04-18 14:10:01 -0700322
323 // Return's the HAL's frame count i.e. fast mixer buffer size.
324 size_t frameCountHAL() const { return mFrameCount; }
325
Eric Laurentbfb1b832013-01-07 09:53:42 -0800326 size_t frameSize() const { return mFrameSize; }
Eric Laurent81784c32012-11-19 14:55:58 -0800327
328 // Should be "virtual status_t requestExitAndWait()" and override same
329 // method in Thread, but Thread::requestExitAndWait() is not yet virtual.
330 void exit();
Eric Laurent10351942014-05-08 18:49:52 -0700331 virtual bool checkForNewParameter_l(const String8& keyValuePair,
332 status_t& status) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800333 virtual status_t setParameters(const String8& keyValuePairs);
334 virtual String8 getParameters(const String8& keys) = 0;
Mikhail Naganov88536df2021-07-26 17:30:29 -0700335 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700336 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) = 0;
Eric Laurent10351942014-05-08 18:49:52 -0700337 // sendConfigEvent_l() must be called with ThreadBase::mLock held
338 // Can temporarily release the lock if waiting for a reply from
339 // processConfigEvents_l().
340 status_t sendConfigEvent_l(sp<ConfigEvent>& event);
Mikhail Naganov88536df2021-07-26 17:30:29 -0700341 void sendIoConfigEvent(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700342 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Mikhail Naganov88536df2021-07-26 17:30:29 -0700343 void sendIoConfigEvent_l(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700344 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Mikhail Naganov83f04272017-02-07 10:45:09 -0800345 void sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp);
346 void sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio, bool forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700347 status_t sendSetParameterConfigEvent_l(const String8& keyValuePair);
Eric Laurent1c333e22014-05-20 10:48:17 -0700348 status_t sendCreateAudioPatchConfigEvent(const struct audio_patch *patch,
349 audio_patch_handle_t *handle);
350 status_t sendReleaseAudioPatchConfigEvent(audio_patch_handle_t handle);
jiabinc52b1ff2019-10-31 17:20:42 -0700351 status_t sendUpdateOutDeviceConfigEvent(
352 const DeviceDescriptorBaseVector& outDevices);
Eric Laurentec376dc2021-04-08 20:41:22 +0200353 void sendResizeBufferConfigEvent_l(int32_t maxSharedAudioHistoryMs);
Eric Laurentb3f315a2021-07-13 15:09:05 +0200354 void sendCheckOutputStageEffectsEvent();
355 void sendCheckOutputStageEffectsEvent_l();
356
Eric Laurent021cf962014-05-13 10:18:14 -0700357 void processConfigEvents_l();
Eric Laurentb3f315a2021-07-13 15:09:05 +0200358 virtual void setCheckOutputStageEffects() {}
Eric Laurent10351942014-05-08 18:49:52 -0700359 virtual void cacheParameters_l() = 0;
Eric Laurent1c333e22014-05-20 10:48:17 -0700360 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
361 audio_patch_handle_t *handle) = 0;
362 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle) = 0;
jiabinc52b1ff2019-10-31 17:20:42 -0700363 virtual void updateOutDevices(const DeviceDescriptorBaseVector& outDevices);
Mikhail Naganovdc769682018-05-04 15:34:08 -0700364 virtual void toAudioPortConfig(struct audio_port_config *config) = 0;
Eric Laurent1c333e22014-05-20 10:48:17 -0700365
Eric Laurent5f0fd7b2021-05-07 16:33:26 +0200366 virtual void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs);
Eric Laurentec376dc2021-04-08 20:41:22 +0200367
368
Eric Laurent81784c32012-11-19 14:55:58 -0800369
370 // see note at declaration of mStandby, mOutDevice and mInDevice
371 bool standby() const { return mStandby; }
jiabinc52b1ff2019-10-31 17:20:42 -0700372 const DeviceTypeSet outDeviceTypes() const {
373 return getAudioDeviceTypes(mOutDeviceTypeAddrs);
374 }
375 audio_devices_t inDeviceType() const { return mInDeviceTypeAddr.mType; }
376 DeviceTypeSet getDeviceTypes() const {
377 return isOutput() ? outDeviceTypes() : DeviceTypeSet({inDeviceType()});
378 }
Andy Hung293558a2017-03-21 12:19:20 -0700379
jiabin8f278ee2019-11-11 12:16:27 -0800380 const AudioDeviceTypeAddrVector& outDeviceTypeAddrs() const {
381 return mOutDeviceTypeAddrs;
382 }
383 const AudioDeviceTypeAddr& inDeviceTypeAddr() const {
384 return mInDeviceTypeAddr;
385 }
386
Andy Hungcf10d742020-04-28 15:38:24 -0700387 bool isOutput() const { return mIsOut; }
Eric Laurent81784c32012-11-19 14:55:58 -0800388
Andy Hungea840382020-05-05 21:50:17 -0700389 bool isOffloadOrMmap() const {
390 switch (mType) {
391 case OFFLOAD:
392 case MMAP_PLAYBACK:
393 case MMAP_CAPTURE:
394 return true;
395 default:
396 return false;
397 }
398 }
399
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700400 virtual sp<StreamHalInterface> stream() const = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800401
402 sp<EffectHandle> createEffect_l(
403 const sp<AudioFlinger::Client>& client,
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700404 const sp<media::IEffectClient>& effectClient,
Eric Laurent81784c32012-11-19 14:55:58 -0800405 int32_t priority,
Glenn Kastend848eb42016-03-08 13:42:11 -0800406 audio_session_t sessionId,
Eric Laurent81784c32012-11-19 14:55:58 -0800407 effect_descriptor_t *desc,
408 int *enabled,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800409 status_t *status /*non-NULL*/,
Eric Laurent2fe0acd2020-03-13 14:30:46 -0700410 bool pinned,
Eric Laurentde8caf42021-08-11 17:19:25 +0200411 bool probe,
412 bool notifyFramesProcessed);
Eric Laurent81784c32012-11-19 14:55:58 -0800413
414 // return values for hasAudioSession (bit field)
415 enum effect_state {
416 EFFECT_SESSION = 0x1, // the audio session corresponds to at least one
417 // effect
Eric Laurent4c415062016-06-17 16:14:16 -0700418 TRACK_SESSION = 0x2, // the audio session corresponds to at least one
Eric Laurent81784c32012-11-19 14:55:58 -0800419 // track
Eric Laurentb62d0362021-10-26 17:40:18 +0200420 FAST_SESSION = 0x4, // the audio session corresponds to at least one
Eric Laurent4c415062016-06-17 16:14:16 -0700421 // fast track
Eric Laurentb62d0362021-10-26 17:40:18 +0200422 SPATIALIZED_SESSION = 0x8 // the audio session corresponds to at least one
423 // spatialized track
Eric Laurent81784c32012-11-19 14:55:58 -0800424 };
425
426 // get effect chain corresponding to session Id.
Glenn Kastend848eb42016-03-08 13:42:11 -0800427 sp<EffectChain> getEffectChain(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800428 // same as getEffectChain() but must be called with ThreadBase mutex locked
Glenn Kastend848eb42016-03-08 13:42:11 -0800429 sp<EffectChain> getEffectChain_l(audio_session_t sessionId) const;
Eric Laurent6c796322019-04-09 14:13:17 -0700430 std::vector<int> getEffectIds_l(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800431 // add an effect chain to the chain list (mEffectChains)
432 virtual status_t addEffectChain_l(const sp<EffectChain>& chain) = 0;
433 // remove an effect chain from the chain list (mEffectChains)
434 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0;
435 // lock all effect chains Mutexes. Must be called before releasing the
436 // ThreadBase mutex before processing the mixer and effects. This guarantees the
437 // integrity of the chains during the process.
438 // Also sets the parameter 'effectChains' to current value of mEffectChains.
439 void lockEffectChains_l(Vector< sp<EffectChain> >& effectChains);
440 // unlock effect chains after process
441 void unlockEffectChains(const Vector< sp<EffectChain> >& effectChains);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800442 // get a copy of mEffectChains vector
443 Vector< sp<EffectChain> > getEffectChains_l() const { return mEffectChains; };
Eric Laurent81784c32012-11-19 14:55:58 -0800444 // set audio mode to all effect chains
445 void setMode(audio_mode_t mode);
446 // get effect module with corresponding ID on specified audio session
Glenn Kastend848eb42016-03-08 13:42:11 -0800447 sp<AudioFlinger::EffectModule> getEffect(audio_session_t sessionId, int effectId);
448 sp<AudioFlinger::EffectModule> getEffect_l(audio_session_t sessionId, int effectId);
Eric Laurent81784c32012-11-19 14:55:58 -0800449 // add and effect module. Also creates the effect chain is none exists for
Eric Laurent6c796322019-04-09 14:13:17 -0700450 // the effects audio session. Only called in a context of moving an effect
451 // from one thread to another
Eric Laurent81784c32012-11-19 14:55:58 -0800452 status_t addEffect_l(const sp< EffectModule>& effect);
453 // remove and effect module. Also removes the effect chain is this was the last
454 // effect
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800455 void removeEffect_l(const sp< EffectModule>& effect, bool release = false);
456 // disconnect an effect handle from module and destroy module if last handle
457 void disconnectEffectHandle(EffectHandle *handle, bool unpinIfLast);
Eric Laurent81784c32012-11-19 14:55:58 -0800458 // detach all tracks connected to an auxiliary effect
Glenn Kasten0f11b512014-01-31 16:18:54 -0800459 virtual void detachAuxEffect_l(int effectId __unused) {}
Eric Laurent4c415062016-06-17 16:14:16 -0700460 // returns a combination of:
461 // - EFFECT_SESSION if effects on this audio session exist in one chain
462 // - TRACK_SESSION if tracks on this audio session exist
463 // - FAST_SESSION if fast tracks on this audio session exist
Eric Laurentb62d0362021-10-26 17:40:18 +0200464 // - SPATIALIZED_SESSION if spatialized tracks on this audio session exist
Eric Laurent4c415062016-06-17 16:14:16 -0700465 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const = 0;
466 uint32_t hasAudioSession(audio_session_t sessionId) const {
467 Mutex::Autolock _l(mLock);
468 return hasAudioSession_l(sessionId);
469 }
470
Andy Hungc3d62f92019-03-14 13:38:51 -0700471 template <typename T>
472 uint32_t hasAudioSession_l(audio_session_t sessionId, const T& tracks) const {
473 uint32_t result = 0;
474 if (getEffectChain_l(sessionId) != 0) {
475 result = EFFECT_SESSION;
476 }
477 for (size_t i = 0; i < tracks.size(); ++i) {
478 const sp<TrackBase>& track = tracks[i];
479 if (sessionId == track->sessionId()
480 && !track->isInvalid() // not yet removed from tracks.
481 && !track->isTerminated()) {
482 result |= TRACK_SESSION;
483 if (track->isFastTrack()) {
484 result |= FAST_SESSION; // caution, only represents first track.
485 }
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200486 if (track->isSpatialized()) {
Eric Laurentb62d0362021-10-26 17:40:18 +0200487 result |= SPATIALIZED_SESSION; // caution, only first track.
488 }
Andy Hungc3d62f92019-03-14 13:38:51 -0700489 break;
490 }
491 }
492 return result;
493 }
494
Eric Laurent81784c32012-11-19 14:55:58 -0800495 // the value returned by default implementation is not important as the
496 // strategy is only meaningful for PlaybackThread which implements this method
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800497 virtual product_strategy_t getStrategyForSession_l(
498 audio_session_t sessionId __unused) {
499 return static_cast<product_strategy_t>(0);
500 }
Eric Laurent81784c32012-11-19 14:55:58 -0800501
Eric Laurent81784c32012-11-19 14:55:58 -0800502 // check if some effects must be suspended/restored when an effect is enabled
503 // or disabled
Eric Laurent6b446ce2019-12-13 10:56:31 -0800504 void checkSuspendOnEffectEnabled(bool enabled,
505 audio_session_t sessionId,
506 bool threadLocked);
Eric Laurent81784c32012-11-19 14:55:58 -0800507
508 virtual status_t setSyncEvent(const sp<SyncEvent>& event) = 0;
509 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const = 0;
510
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700511 // Return a reference to a per-thread heap which can be used to allocate IMemory
512 // objects that will be read-only to client processes, read/write to mediaserver,
513 // and shared by all client processes of the thread.
514 // The heap is per-thread rather than common across all threads, because
515 // clients can't be trusted not to modify the offset of the IMemory they receive.
516 // If a thread does not have such a heap, this method returns 0.
517 virtual sp<MemoryDealer> readOnlyHeap() const { return 0; }
Eric Laurent81784c32012-11-19 14:55:58 -0800518
Glenn Kasten6181ffd2014-05-13 10:41:52 -0700519 virtual sp<IMemory> pipeMemory() const { return 0; }
520
Eric Laurent72e3f392015-05-20 14:43:50 -0700521 void systemReady();
522
Eric Laurent4c415062016-06-17 16:14:16 -0700523 // checkEffectCompatibility_l() must be called with ThreadBase::mLock held
524 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
525 audio_session_t sessionId) = 0;
526
Eric Laurent6acd1d42017-01-04 14:23:29 -0800527 void broadcast_l();
528
Andy Hungc8fddf32018-08-08 18:32:37 -0700529 virtual bool isTimestampCorrectionEnabled() const { return false; }
530
531 bool isMsdDevice() const { return mIsMsdDevice; }
532
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700533 void dump(int fd, const Vector<String16>& args);
Andy Hungdc099c22018-09-18 13:46:39 -0700534
Andy Hungd0979812019-02-21 15:51:44 -0800535 // deliver stats to mediametrics.
536 void sendStatistics(bool force);
537
Eric Laurent81784c32012-11-19 14:55:58 -0800538 mutable Mutex mLock;
539
Eric Laurent6b446ce2019-12-13 10:56:31 -0800540 void onEffectEnable(const sp<EffectModule>& effect);
541 void onEffectDisable();
542
jiabineb3bda02020-06-30 14:07:03 -0700543 // invalidateTracksForAudioSession_l must be called with holding mLock.
544 virtual void invalidateTracksForAudioSession_l(audio_session_t sessionId __unused) const { }
545 // Invalidate all the tracks with the given audio session.
546 void invalidateTracksForAudioSession(audio_session_t sessionId) const {
547 Mutex::Autolock _l(mLock);
548 invalidateTracksForAudioSession_l(sessionId);
549 }
550
551 template <typename T>
552 void invalidateTracksForAudioSession_l(audio_session_t sessionId,
553 const T& tracks) const {
554 for (size_t i = 0; i < tracks.size(); ++i) {
555 const sp<TrackBase>& track = tracks[i];
556 if (sessionId == track->sessionId()) {
557 track->invalidate();
558 }
559 }
560 }
561
Jasmine Chaeaa10e42021-05-11 10:11:14 +0800562 virtual bool isStreamInitialized() = 0;
563
Eric Laurent81784c32012-11-19 14:55:58 -0800564protected:
565
566 // entry describing an effect being suspended in mSuspendedSessions keyed vector
567 class SuspendedSessionDesc : public RefBase {
568 public:
569 SuspendedSessionDesc() : mRefCount(0) {}
570
571 int mRefCount; // number of active suspend requests
572 effect_uuid_t mType; // effect type UUID
573 };
574
Andy Hungdae27702016-10-31 14:01:16 -0700575 void acquireWakeLock();
576 virtual void acquireWakeLock_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800577 void releaseWakeLock();
578 void releaseWakeLock_l();
Andy Hungd01b0f12016-11-07 16:10:30 -0800579 void updateWakeLockUids_l(const SortedVector<uid_t> &uids);
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800580 void getPowerManager_l();
Eric Laurentd8365c52017-07-16 15:27:05 -0700581 // suspend or restore effects of the specified type (or all if type is NULL)
582 // on a given session. The number of suspend requests is counted and restore
583 // occurs when all suspend requests are cancelled.
Eric Laurent81784c32012-11-19 14:55:58 -0800584 void setEffectSuspended_l(const effect_uuid_t *type,
585 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -0800586 audio_session_t sessionId);
Eric Laurentd8365c52017-07-16 15:27:05 -0700587 // updated mSuspendedSessions when an effect is suspended or restored
Eric Laurent81784c32012-11-19 14:55:58 -0800588 void updateSuspendedSessions_l(const effect_uuid_t *type,
589 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -0800590 audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800591 // check if some effects must be suspended when an effect chain is added
592 void checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain);
593
Kevin Rocard069c2712018-03-29 19:09:14 -0700594 // sends the metadata of the active tracks to the HAL
595 virtual void updateMetadata_l() = 0;
596
Narayan Kamath014e7fa2013-10-14 15:03:38 +0100597 String16 getWakeLockTag();
598
Eric Laurent81784c32012-11-19 14:55:58 -0800599 virtual void preExit() { }
Andy Hung2ddee192015-12-18 17:34:44 -0800600 virtual void setMasterMono_l(bool mono __unused) { }
601 virtual bool requireMonoBlend() { return false; }
Eric Laurent81784c32012-11-19 14:55:58 -0800602
Andy Hung1c86ebe2018-05-29 20:29:08 -0700603 // called within the threadLoop to obtain timestamp from the HAL.
604 virtual status_t threadloop_getHalTimestamp_l(
605 ExtendedTimestamp *timestamp __unused) const {
606 return INVALID_OPERATION;
607 }
608
Eric Laurentd66d7a12021-07-13 13:35:32 +0200609 product_strategy_t getStrategyForStream(audio_stream_type_t stream) const;
610
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700611 virtual void dumpInternals_l(int fd __unused, const Vector<String16>& args __unused)
612 { }
613 virtual void dumpTracks_l(int fd __unused, const Vector<String16>& args __unused) { }
614
615
Eric Laurent81784c32012-11-19 14:55:58 -0800616 friend class AudioFlinger; // for mEffectChains
617
618 const type_t mType;
619
620 // Used by parameters, config events, addTrack_l, exit
621 Condition mWaitWorkCV;
622
623 const sp<AudioFlinger> mAudioFlinger;
Andy Hungcf10d742020-04-28 15:38:24 -0700624 ThreadMetrics mThreadMetrics;
625 const bool mIsOut;
Glenn Kasten9b58f632013-07-16 11:37:48 -0700626
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800627 // updated by PlaybackThread::readOutputParameters_l() or
628 // RecordThread::readInputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -0800629 uint32_t mSampleRate;
630 size_t mFrameCount; // output HAL, direct output, record
Eric Laurent81784c32012-11-19 14:55:58 -0800631 audio_channel_mask_t mChannelMask;
Glenn Kastenf6ed4232013-07-16 11:16:27 -0700632 uint32_t mChannelCount;
Eric Laurent81784c32012-11-19 14:55:58 -0800633 size_t mFrameSize;
Glenn Kasten97b7b752014-09-28 13:04:24 -0700634 // not HAL frame size, this is for output sink (to pipe to fast mixer)
Andy Hung463be252014-07-10 16:56:07 -0700635 audio_format_t mFormat; // Source format for Recording and
636 // Sink format for Playback.
637 // Sink format may be different than
638 // HAL format if Fastmixer is used.
639 audio_format_t mHALFormat;
Glenn Kasten70949c42013-08-06 07:40:12 -0700640 size_t mBufferSize; // HAL buffer size for read() or write()
jiabinc52b1ff2019-10-31 17:20:42 -0700641 AudioDeviceTypeAddrVector mOutDeviceTypeAddrs; // output device types and addresses
642 AudioDeviceTypeAddr mInDeviceTypeAddr; // input device type and address
Eric Laurent10351942014-05-08 18:49:52 -0700643 Vector< sp<ConfigEvent> > mConfigEvents;
Eric Laurent72e3f392015-05-20 14:43:50 -0700644 Vector< sp<ConfigEvent> > mPendingConfigEvents; // events awaiting system ready
Eric Laurent81784c32012-11-19 14:55:58 -0800645
646 // These fields are written and read by thread itself without lock or barrier,
jiabinc52b1ff2019-10-31 17:20:42 -0700647 // and read by other threads without lock or barrier via standby(), outDeviceTypes()
648 // and inDeviceType().
Eric Laurent81784c32012-11-19 14:55:58 -0800649 // Because of the absence of a lock or barrier, any other thread that reads
650 // these fields must use the information in isolation, or be prepared to deal
651 // with possibility that it might be inconsistent with other information.
Glenn Kasten4944acb2013-08-19 08:39:20 -0700652 bool mStandby; // Whether thread is currently in standby.
jiabinc52b1ff2019-10-31 17:20:42 -0700653
Eric Laurent296fb132015-05-01 11:38:42 -0700654 struct audio_patch mPatch;
jiabinc52b1ff2019-10-31 17:20:42 -0700655
Glenn Kastenf59497b2015-01-26 16:35:47 -0800656 audio_source_t mAudioSource;
Eric Laurent81784c32012-11-19 14:55:58 -0800657
658 const audio_io_handle_t mId;
659 Vector< sp<EffectChain> > mEffectChains;
660
Glenn Kastend7dca052015-03-05 16:05:54 -0800661 static const int kThreadNameLength = 16; // prctl(PR_SET_NAME) limit
662 char mThreadName[kThreadNameLength]; // guaranteed NUL-terminated
Chris Ye6597d732020-02-28 22:38:25 -0800663 sp<os::IPowerManager> mPowerManager;
Eric Laurent81784c32012-11-19 14:55:58 -0800664 sp<IBinder> mWakeLockToken;
665 const sp<PMDeathRecipient> mDeathRecipient;
Glenn Kastend848eb42016-03-08 13:42:11 -0800666 // list of suspended effects per session and per type. The first (outer) vector is
667 // keyed by session ID, the second (inner) by type UUID timeLow field
Eric Laurentd8365c52017-07-16 15:27:05 -0700668 // Updated by updateSuspendedSessions_l() only.
Glenn Kastend848eb42016-03-08 13:42:11 -0800669 KeyedVector< audio_session_t, KeyedVector< int, sp<SuspendedSessionDesc> > >
Eric Laurent81784c32012-11-19 14:55:58 -0800670 mSuspendedSessions;
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -0700671 // TODO: add comment and adjust size as needed
Glenn Kastenab7d72f2013-02-27 09:05:28 -0800672 static const size_t kLogSize = 4 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -0800673 sp<NBLog::Writer> mNBLogWriter;
Eric Laurent72e3f392015-05-20 14:43:50 -0700674 bool mSystemReady;
Andy Hung818e7a32016-02-16 18:08:07 -0800675 ExtendedTimestamp mTimestamp;
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700676 TimestampVerifier< // For timestamp statistics.
677 int64_t /* frame count */, int64_t /* time ns */> mTimestampVerifier;
Dean Wheatley12473e92021-03-18 23:00:55 +1100678 // DIRECT and OFFLOAD threads should reset frame count to zero on stop/flush
679 // TODO: add confirmation checks:
680 // 1) DIRECT threads and linear PCM format really resets to 0?
681 // 2) Is frame count really valid if not linear pcm?
682 // 3) Are all 64 bits of position returned, not just lowest 32 bits?
jiabinc52b1ff2019-10-31 17:20:42 -0700683 // Timestamp corrected device should be a single device.
684 audio_devices_t mTimestampCorrectedDevice = AUDIO_DEVICE_NONE;
Andy Hung446f4df2019-02-21 12:26:41 -0800685
686 // ThreadLoop statistics per iteration.
687 int64_t mLastIoBeginNs = -1;
688 int64_t mLastIoEndNs = -1;
689
Andy Hung44d648b2022-04-08 17:33:40 -0700690 // ThreadSnapshot is thread-safe (internally locked)
691 mediautils::ThreadSnapshot mThreadSnapshot;
692
Andy Hung446f4df2019-02-21 12:26:41 -0800693 // This should be read under ThreadBase lock (if not on the threadLoop thread).
694 audio_utils::Statistics<double> mIoJitterMs{0.995 /* alpha */};
695 audio_utils::Statistics<double> mProcessTimeMs{0.995 /* alpha */};
Andy Hunge6c37112019-02-26 17:38:10 -0800696 audio_utils::Statistics<double> mLatencyMs{0.995 /* alpha */};
Robert Wu06db0a32021-08-10 19:05:34 +0000697 audio_utils::Statistics<double> mMonopipePipeDepthStats{0.999 /* alpha */};
Andy Hung446f4df2019-02-21 12:26:41 -0800698
Andy Hungd0979812019-02-21 15:51:44 -0800699 // Save the last count when we delivered statistics to mediametrics.
700 int64_t mLastRecordedTimestampVerifierN = 0;
701 int64_t mLastRecordedTimeNs = 0; // BOOTTIME to include suspend.
702
Andy Hungc8fddf32018-08-08 18:32:37 -0700703 bool mIsMsdDevice = false;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800704 // A condition that must be evaluated by the thread loop has changed and
705 // we must not wait for async write callback in the thread loop before evaluating it
706 bool mSignalPending;
Andy Hungdae27702016-10-31 14:01:16 -0700707
Andy Hung8946a282018-04-19 20:04:56 -0700708#ifdef TEE_SINK
709 NBAIO_Tee mTee;
710#endif
Andy Hungdae27702016-10-31 14:01:16 -0700711 // ActiveTracks is a sorted vector of track type T representing the
712 // active tracks of threadLoop() to be considered by the locked prepare portion.
713 // ActiveTracks should be accessed with the ThreadBase lock held.
714 //
715 // During processing and I/O, the threadLoop does not hold the lock;
716 // hence it does not directly use ActiveTracks. Care should be taken
717 // to hold local strong references or defer removal of tracks
718 // if the threadLoop may still be accessing those tracks due to mix, etc.
719 //
720 // This class updates power information appropriately.
721 //
722
723 template <typename T>
724 class ActiveTracks {
725 public:
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700726 explicit ActiveTracks(SimpleLog *localLog = nullptr)
Andy Hungdae27702016-10-31 14:01:16 -0700727 : mActiveTracksGeneration(0)
728 , mLastActiveTracksGeneration(0)
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700729 , mLocalLog(localLog)
Andy Hungdae27702016-10-31 14:01:16 -0700730 { }
731
732 ~ActiveTracks() {
733 ALOGW_IF(!mActiveTracks.isEmpty(),
734 "ActiveTracks should be empty in destructor");
735 }
736 // returns the last track added (even though it may have been
737 // subsequently removed from ActiveTracks).
738 //
739 // Used for DirectOutputThread to ensure a flush is called when transitioning
740 // to a new track (even though it may be on the same session).
741 // Used for OffloadThread to ensure that volume and mixer state is
742 // taken from the latest track added.
743 //
744 // The latest track is saved with a weak pointer to prevent keeping an
745 // otherwise useless track alive. Thus the function will return nullptr
746 // if the latest track has subsequently been removed and destroyed.
747 sp<T> getLatest() {
748 return mLatestActiveTrack.promote();
749 }
750
751 // SortedVector methods
752 ssize_t add(const sp<T> &track);
753 ssize_t remove(const sp<T> &track);
754 size_t size() const {
755 return mActiveTracks.size();
756 }
Eric Tan39ec8d62018-07-24 09:49:29 -0700757 bool isEmpty() const {
758 return mActiveTracks.isEmpty();
759 }
Andy Hungdae27702016-10-31 14:01:16 -0700760 ssize_t indexOf(const sp<T>& item) {
761 return mActiveTracks.indexOf(item);
762 }
763 sp<T> operator[](size_t index) const {
764 return mActiveTracks[index];
765 }
766 typename SortedVector<sp<T>>::iterator begin() {
767 return mActiveTracks.begin();
768 }
769 typename SortedVector<sp<T>>::iterator end() {
770 return mActiveTracks.end();
771 }
772
773 // Due to Binder recursion optimization, clear() and updatePowerState()
774 // cannot be called from a Binder thread because they may call back into
775 // the original calling process (system server) for BatteryNotifier
776 // (which requires a Java environment that may not be present).
777 // Hence, call clear() and updatePowerState() only from the
778 // ThreadBase thread.
779 void clear();
780 // periodically called in the threadLoop() to update power state uids.
781 void updatePowerState(sp<ThreadBase> thread, bool force = false);
782
Kevin Rocardc86a7f72018-04-03 09:00:09 -0700783 /** @return true if one or move active tracks was added or removed since the
Jasmine Chaeaa10e42021-05-11 10:11:14 +0800784 * last time this function was called or the vector was created.
785 * true if volume of one of active tracks was changed.
786 */
Kevin Rocard069c2712018-03-29 19:09:14 -0700787 bool readAndClearHasChanged();
788
Eric Laurentdda206a2022-07-08 17:28:35 +0200789 /** Force updating track metadata to audio HAL stream next time
790 * readAndClearHasChanged() is called.
791 */
792 void setHasChanged() { mHasChanged = true; }
793
Andy Hungdae27702016-10-31 14:01:16 -0700794 private:
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700795 void logTrack(const char *funcName, const sp<T> &track) const;
796
Andy Hungd01b0f12016-11-07 16:10:30 -0800797 SortedVector<uid_t> getWakeLockUids() {
798 SortedVector<uid_t> wakeLockUids;
Andy Hungdae27702016-10-31 14:01:16 -0700799 for (const sp<T> &track : mActiveTracks) {
800 wakeLockUids.add(track->uid());
801 }
802 return wakeLockUids; // moved by underlying SharedBuffer
803 }
804
805 std::map<uid_t, std::pair<ssize_t /* previous */, ssize_t /* current */>>
806 mBatteryCounter;
807 SortedVector<sp<T>> mActiveTracks;
808 int mActiveTracksGeneration;
809 int mLastActiveTracksGeneration;
810 wp<T> mLatestActiveTrack; // latest track added to ActiveTracks
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700811 SimpleLog * const mLocalLog;
Kevin Rocardc86a7f72018-04-03 09:00:09 -0700812 // If the vector has changed since last call to readAndClearHasChanged
Kevin Rocard069c2712018-03-29 19:09:14 -0700813 bool mHasChanged = false;
Andy Hungdae27702016-10-31 14:01:16 -0700814 };
Andy Hung293558a2017-03-21 12:19:20 -0700815
816 SimpleLog mLocalLog;
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700817
818private:
819 void dumpBase_l(int fd, const Vector<String16>& args);
820 void dumpEffectChains_l(int fd, const Vector<String16>& args);
Eric Laurent81784c32012-11-19 14:55:58 -0800821};
822
Eric Laurent6acd1d42017-01-04 14:23:29 -0800823class VolumeInterface {
824 public:
825
826 virtual ~VolumeInterface() {}
827
828 virtual void setMasterVolume(float value) = 0;
829 virtual void setMasterMute(bool muted) = 0;
830 virtual void setStreamVolume(audio_stream_type_t stream, float value) = 0;
831 virtual void setStreamMute(audio_stream_type_t stream, bool muted) = 0;
832 virtual float streamVolume(audio_stream_type_t stream) const = 0;
833
834};
835
Eric Laurent81784c32012-11-19 14:55:58 -0800836// --- PlaybackThread ---
Eric Laurent6acd1d42017-01-04 14:23:29 -0800837class PlaybackThread : public ThreadBase, public StreamOutHalInterfaceCallback,
jiabinf6eb4c32020-02-25 14:06:25 -0800838 public VolumeInterface, public StreamOutHalInterfaceEventCallback {
Eric Laurent81784c32012-11-19 14:55:58 -0800839public:
840
841#include "PlaybackTracks.h"
842
843 enum mixer_state {
844 MIXER_IDLE, // no active tracks
845 MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready
Eric Laurentbfb1b832013-01-07 09:53:42 -0800846 MIXER_TRACKS_READY, // at least one active track, and at least one track has data
847 MIXER_DRAIN_TRACK, // drain currently playing track
848 MIXER_DRAIN_ALL, // fully drain the hardware
Eric Laurent81784c32012-11-19 14:55:58 -0800849 // standby mode does not have an enum value
850 // suspend by audio policy manager is orthogonal to mixer state
851 };
852
Eric Laurente93cc032016-05-05 10:15:10 -0700853 // retry count before removing active track in case of underrun on offloaded thread:
854 // we need to make sure that AudioTrack client has enough time to send large buffers
855 //FIXME may be more appropriate if expressed in time units. Need to revise how underrun is
856 // handled for offloaded tracks
857 static const int8_t kMaxTrackRetriesOffload = 20;
858 static const int8_t kMaxTrackStartupRetriesOffload = 100;
859 static const int8_t kMaxTrackStopRetriesOffload = 2;
Andy Hung8ed196a2018-01-05 13:21:11 -0800860 static constexpr uint32_t kMaxTracksPerUid = 40;
Andy Hung1bc088a2018-02-09 15:57:31 -0800861 static constexpr size_t kMaxTracks = 256;
Eric Laurente93cc032016-05-05 10:15:10 -0700862
rago1bb90822017-05-02 18:31:48 -0700863 // Maximum delay (in nanoseconds) for upcoming buffers in suspend mode, otherwise
864 // if delay is greater, the estimated time for timeLoopNextNs is reset.
865 // This allows for catch-up to be done for small delays, while resetting the estimate
866 // for initial conditions or large delays.
867 static const nsecs_t kMaxNextBufferDelayNs = 100000000;
868
Eric Laurent81784c32012-11-19 14:55:58 -0800869 PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurentf1f22e72021-07-13 14:04:14 +0200870 audio_io_handle_t id, type_t type, bool systemReady,
871 audio_config_base_t *mixerConfig = nullptr);
Eric Laurent81784c32012-11-19 14:55:58 -0800872 virtual ~PlaybackThread();
873
Eric Laurent81784c32012-11-19 14:55:58 -0800874 // Thread virtuals
Eric Laurent81784c32012-11-19 14:55:58 -0800875 virtual bool threadLoop();
876
877 // RefBase
878 virtual void onFirstRef();
879
Eric Laurent4c415062016-06-17 16:14:16 -0700880 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
881 audio_session_t sessionId);
882
Eric Laurent81784c32012-11-19 14:55:58 -0800883protected:
884 // Code snippets that were lifted up out of threadLoop()
885 virtual void threadLoop_mix() = 0;
886 virtual void threadLoop_sleepTime() = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800887 virtual ssize_t threadLoop_write();
888 virtual void threadLoop_drain();
Eric Laurent81784c32012-11-19 14:55:58 -0800889 virtual void threadLoop_standby();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800890 virtual void threadLoop_exit();
Eric Laurent81784c32012-11-19 14:55:58 -0800891 virtual void threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove);
892
893 // prepareTracks_l reads and writes mActiveTracks, and returns
894 // the pending set of tracks to remove via Vector 'tracksToRemove'. The caller
895 // is responsible for clearing or destroying this Vector later on, when it
896 // is safe to do so. That will drop the final ref count and destroy the tracks.
897 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove) = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800898 void removeTracks_l(const Vector< sp<Track> >& tracksToRemove);
Eric Laurenteab90452019-06-24 15:17:46 -0700899 status_t handleVoipVolume_l(float *volume);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800900
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700901 // StreamOutHalInterfaceCallback implementation
902 virtual void onWriteReady();
903 virtual void onDrainReady();
904 virtual void onError();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800905
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700906 void resetWriteBlocked(uint32_t sequence);
907 void resetDraining(uint32_t sequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800908
909 virtual bool waitingAsyncCallback();
910 virtual bool waitingAsyncCallback_l();
911 virtual bool shouldStandby_l();
Haynes Mathew George4c6a4332014-01-15 12:31:39 -0800912 virtual void onAddNewTrack_l();
Haynes Mathew George4527b9e2016-07-07 19:54:17 -0700913 void onAsyncError(); // error reported by AsyncCallbackThread
Eric Laurent81784c32012-11-19 14:55:58 -0800914
jiabinf6eb4c32020-02-25 14:06:25 -0800915 // StreamHalInterfaceCodecFormatCallback implementation
916 void onCodecFormatChanged(
917 const std::basic_string<uint8_t>& metadataBs) override;
918
Eric Laurent81784c32012-11-19 14:55:58 -0800919 // ThreadBase virtuals
920 virtual void preExit();
921
Eric Laurent64667972016-03-30 18:19:46 -0700922 virtual bool keepWakeLock() const { return true; }
Andy Hungdae27702016-10-31 14:01:16 -0700923 virtual void acquireWakeLock_l() {
924 ThreadBase::acquireWakeLock_l();
925 mActiveTracks.updatePowerState(this, true /* force */);
926 }
Eric Laurent64667972016-03-30 18:19:46 -0700927
Eric Laurentb3f315a2021-07-13 15:09:05 +0200928 virtual void checkOutputStageEffects() {}
929
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700930 void dumpInternals_l(int fd, const Vector<String16>& args) override;
931 void dumpTracks_l(int fd, const Vector<String16>& args) override;
932
Eric Laurent81784c32012-11-19 14:55:58 -0800933public:
934
935 virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; }
936
937 // return estimated latency in milliseconds, as reported by HAL
938 uint32_t latency() const;
939 // same, but lock must already be held
Eric Laurent6b446ce2019-12-13 10:56:31 -0800940 uint32_t latency_l() const override;
Eric Laurent81784c32012-11-19 14:55:58 -0800941
Eric Laurent6acd1d42017-01-04 14:23:29 -0800942 // VolumeInterface
943 virtual void setMasterVolume(float value);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +0100944 virtual void setMasterBalance(float balance);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800945 virtual void setMasterMute(bool muted);
946 virtual void setStreamVolume(audio_stream_type_t stream, float value);
947 virtual void setStreamMute(audio_stream_type_t stream, bool muted);
948 virtual float streamVolume(audio_stream_type_t stream) const;
Eric Laurent81784c32012-11-19 14:55:58 -0800949
Eric Laurent6b446ce2019-12-13 10:56:31 -0800950 void setVolumeForOutput_l(float left, float right) const override;
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +0900951
Eric Laurent81784c32012-11-19 14:55:58 -0800952 sp<Track> createTrack_l(
953 const sp<AudioFlinger::Client>& client,
954 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700955 const audio_attributes_t& attr,
Eric Laurent21da6472017-11-09 16:29:26 -0800956 uint32_t *sampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -0800957 audio_format_t format,
958 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -0800959 size_t *pFrameCount,
Eric Laurent21da6472017-11-09 16:29:26 -0800960 size_t *pNotificationFrameCount,
961 uint32_t notificationsPerBuffer,
962 float speed,
Eric Laurent81784c32012-11-19 14:55:58 -0800963 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -0800964 audio_session_t sessionId,
Eric Laurent05067782016-06-01 18:27:28 -0700965 audio_output_flags_t *flags,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700966 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +0000967 const AttributionSourceState& attributionSource,
Eric Laurent81784c32012-11-19 14:55:58 -0800968 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800969 status_t *status /*non-NULL*/,
jiabinf6eb4c32020-02-25 14:06:25 -0800970 audio_port_handle_t portId,
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200971 const sp<media::IAudioTrackCallback>& callback,
972 bool isSpatialized);
Eric Laurent81784c32012-11-19 14:55:58 -0800973
974 AudioStreamOut* getOutput() const;
975 AudioStreamOut* clearOutput();
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700976 virtual sp<StreamHalInterface> stream() const;
Eric Laurent81784c32012-11-19 14:55:58 -0800977
978 // a very large number of suspend() will eventually wraparound, but unlikely
979 void suspend() { (void) android_atomic_inc(&mSuspended); }
980 void restore()
981 {
982 // if restore() is done without suspend(), get back into
983 // range so that the next suspend() will operate correctly
984 if (android_atomic_dec(&mSuspended) <= 0) {
985 android_atomic_release_store(0, &mSuspended);
986 }
987 }
988 bool isSuspended() const
989 { return android_atomic_acquire_load(&mSuspended) > 0; }
990
991 virtual String8 getParameters(const String8& keys);
Mikhail Naganov88536df2021-07-26 17:30:29 -0700992 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700993 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000994 status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames);
Andy Hung010a1a12014-03-13 13:57:33 -0700995 // Consider also removing and passing an explicit mMainBuffer initialization
996 // parameter to AF::PlaybackThread::Track::Track().
rago94a1ee82017-07-21 15:11:02 -0700997 effect_buffer_t *sinkBuffer() const {
998 return reinterpret_cast<effect_buffer_t *>(mSinkBuffer); };
Eric Laurent81784c32012-11-19 14:55:58 -0800999
1000 virtual void detachAuxEffect_l(int effectId);
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001001 status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track>& track,
Eric Laurent81784c32012-11-19 14:55:58 -08001002 int EffectId);
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001003 status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track>& track,
Eric Laurent81784c32012-11-19 14:55:58 -08001004 int EffectId);
1005
1006 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
1007 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
Andy Hungc3d62f92019-03-14 13:38:51 -07001008 uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
1009 return ThreadBase::hasAudioSession_l(sessionId, mTracks);
1010 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001011 virtual product_strategy_t getStrategyForSession_l(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -08001012
1013
1014 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
1015 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const;
Glenn Kastenfb1fdc92013-07-10 17:03:19 -07001016
1017 // called with AudioFlinger lock held
Eric Laurent13084622016-05-17 10:51:49 -07001018 bool invalidateTracks_l(audio_stream_type_t streamType);
Haynes Mathew George05317d22016-05-03 16:34:26 -07001019 virtual void invalidateTracks(audio_stream_type_t streamType);
Eric Laurent81784c32012-11-19 14:55:58 -08001020
Glenn Kasten9b58f632013-07-16 11:37:48 -07001021 virtual size_t frameCount() const { return mNormalFrameCount; }
1022
Eric Laurentf1f22e72021-07-13 14:04:14 +02001023 audio_channel_mask_t mixerChannelMask() const override {
1024 return mMixerChannelMask;
1025 }
1026
Eric Laurent83b88082014-06-20 18:31:16 -07001027 status_t getTimestamp_l(AudioTimestamp& timestamp);
1028
1029 void addPatchTrack(const sp<PatchTrack>& track);
1030 void deletePatchTrack(const sp<PatchTrack>& track);
1031
Mikhail Naganovdc769682018-05-04 15:34:08 -07001032 virtual void toAudioPortConfig(struct audio_port_config *config);
Eric Laurentaccc1472013-09-20 09:36:34 -07001033
Andy Hung10cbff12017-02-21 17:30:14 -08001034 // Return the asynchronous signal wait time.
1035 virtual int64_t computeWaitTimeNs_l() const { return INT64_MAX; }
Andy Hung1bc088a2018-02-09 15:57:31 -08001036 // returns true if the track is allowed to be added to the thread.
1037 virtual bool isTrackAllowed_l(
1038 audio_channel_mask_t channelMask __unused,
1039 audio_format_t format __unused,
1040 audio_session_t sessionId __unused,
1041 uid_t uid) const {
1042 return trackCountForUid_l(uid) < PlaybackThread::kMaxTracksPerUid
1043 && mTracks.size() < PlaybackThread::kMaxTracks;
1044 }
1045
Andy Hungc8fddf32018-08-08 18:32:37 -07001046 bool isTimestampCorrectionEnabled() const override {
jiabinc52b1ff2019-10-31 17:20:42 -07001047 return audio_is_output_devices(mTimestampCorrectedDevice)
1048 && outDeviceTypes().count(mTimestampCorrectedDevice) != 0;
Andy Hungc8fddf32018-08-08 18:32:37 -07001049 }
jiabinc52b1ff2019-10-31 17:20:42 -07001050
Jasmine Chaeaa10e42021-05-11 10:11:14 +08001051 virtual bool isStreamInitialized() {
1052 return !(mOutput == nullptr || mOutput->stream == nullptr);
1053 }
1054
jiabineb3bda02020-06-30 14:07:03 -07001055 audio_channel_mask_t hapticChannelMask() const override {
1056 return mHapticChannelMask;
1057 }
1058 bool supportsHapticPlayback() const {
1059 return (mHapticChannelMask & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE;
1060 }
1061
Eric Laurent74c38dc2020-12-23 18:19:44 +01001062 void setDownStreamPatch(const struct audio_patch *patch) {
1063 Mutex::Autolock _l(mLock);
1064 mDownStreamPatch = *patch;
1065 }
1066
jiabinf042b9b2021-05-07 23:46:28 +00001067 PlaybackThread::Track* getTrackById_l(audio_port_handle_t trackId);
1068
Eric Laurentb3f315a2021-07-13 15:09:05 +02001069 bool hasMixer() const {
Eric Laurent1c5e2e32021-08-18 18:50:28 +02001070 return mType == MIXER || mType == DUPLICATING || mType == SPATIALIZER;
Eric Laurentb3f315a2021-07-13 15:09:05 +02001071 }
Eric Laurent81784c32012-11-19 14:55:58 -08001072protected:
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001073 // updated by readOutputParameters_l()
Glenn Kasten9b58f632013-07-16 11:37:48 -07001074 size_t mNormalFrameCount; // normal mixer and effects
1075
Andy Hung08fb1742015-05-31 23:22:10 -07001076 bool mThreadThrottle; // throttle the thread processing
Andy Hung40eb1a12015-06-18 13:42:02 -07001077 uint32_t mThreadThrottleTimeMs; // throttle time for MIXER threads
1078 uint32_t mThreadThrottleEndMs; // notify once per throttling
Andy Hung08fb1742015-05-31 23:22:10 -07001079 uint32_t mHalfBufferMs; // half the buffer size in milliseconds
1080
Andy Hung010a1a12014-03-13 13:57:33 -07001081 void* mSinkBuffer; // frame size aligned sink buffer
Eric Laurent81784c32012-11-19 14:55:58 -08001082
Andy Hung98ef9782014-03-04 14:46:50 -08001083 // TODO:
1084 // Rearrange the buffer info into a struct/class with
1085 // clear, copy, construction, destruction methods.
1086 //
1087 // mSinkBuffer also has associated with it:
1088 //
1089 // mSinkBufferSize: Sink Buffer Size
1090 // mFormat: Sink Buffer Format
1091
Andy Hung69aed5f2014-02-25 17:24:40 -08001092 // Mixer Buffer (mMixerBuffer*)
1093 //
1094 // In the case of floating point or multichannel data, which is not in the
1095 // sink format, it is required to accumulate in a higher precision or greater channel count
1096 // buffer before downmixing or data conversion to the sink buffer.
1097
1098 // Set to "true" to enable the Mixer Buffer otherwise mixer output goes to sink buffer.
1099 bool mMixerBufferEnabled;
1100
1101 // Storage, 32 byte aligned (may make this alignment a requirement later).
1102 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
1103 void* mMixerBuffer;
1104
1105 // Size of mMixerBuffer in bytes: mNormalFrameCount * #channels * sampsize.
1106 size_t mMixerBufferSize;
1107
1108 // The audio format of mMixerBuffer. Set to AUDIO_FORMAT_PCM_(FLOAT|16_BIT) only.
1109 audio_format_t mMixerBufferFormat;
1110
1111 // An internal flag set to true by MixerThread::prepareTracks_l()
1112 // when mMixerBuffer contains valid data after mixing.
1113 bool mMixerBufferValid;
1114
Andy Hung98ef9782014-03-04 14:46:50 -08001115 // Effects Buffer (mEffectsBuffer*)
1116 //
1117 // In the case of effects data, which is not in the sink format,
1118 // it is required to accumulate in a different buffer before data conversion
1119 // to the sink buffer.
1120
1121 // Set to "true" to enable the Effects Buffer otherwise effects output goes to sink buffer.
1122 bool mEffectBufferEnabled;
1123
1124 // Storage, 32 byte aligned (may make this alignment a requirement later).
1125 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
1126 void* mEffectBuffer;
1127
1128 // Size of mEffectsBuffer in bytes: mNormalFrameCount * #channels * sampsize.
1129 size_t mEffectBufferSize;
1130
1131 // The audio format of mEffectsBuffer. Set to AUDIO_FORMAT_PCM_16_BIT only.
1132 audio_format_t mEffectBufferFormat;
1133
1134 // An internal flag set to true by MixerThread::prepareTracks_l()
1135 // when mEffectsBuffer contains valid data after mixing.
1136 //
1137 // When this is set, all mixer data is routed into the effects buffer
1138 // for any processing (including output processing).
1139 bool mEffectBufferValid;
1140
Eric Laurentb62d0362021-10-26 17:40:18 +02001141 // Frame size aligned buffer used as input and output to all post processing effects
1142 // except the Spatializer in a SPATIALIZER thread. Non spatialized tracks are mixed into
1143 // this buffer so that post processing effects can be applied.
1144 void* mPostSpatializerBuffer = nullptr;
1145
1146 // Size of mPostSpatializerBuffer in bytes
1147 size_t mPostSpatializerBufferSize;
Eric Laurent39095982021-08-24 18:29:27 +02001148
1149
Eric Laurent81784c32012-11-19 14:55:58 -08001150 // suspend count, > 0 means suspended. While suspended, the thread continues to pull from
1151 // tracks and mix, but doesn't write to HAL. A2DP and SCO HAL implementations can't handle
1152 // concurrent use of both of them, so Audio Policy Service suspends one of the threads to
1153 // workaround that restriction.
1154 // 'volatile' means accessed via atomic operations and no lock.
1155 volatile int32_t mSuspended;
1156
Andy Hung818e7a32016-02-16 18:08:07 -08001157 int64_t mBytesWritten;
Andy Hungc54b1ff2016-02-23 14:07:07 -08001158 int64_t mFramesWritten; // not reset on standby
Dean Wheatley12473e92021-03-18 23:00:55 +11001159 int64_t mLastFramesWritten = -1; // track changes in timestamp
1160 // server frames written.
Andy Hung238fa3d2016-07-28 10:53:22 -07001161 int64_t mSuspendedFrames; // not reset on standby
jiabin245cdd92018-12-07 17:55:15 -08001162
1163 // mHapticChannelMask and mHapticChannelCount will only be valid when the thread support
1164 // haptic playback.
1165 audio_channel_mask_t mHapticChannelMask = AUDIO_CHANNEL_NONE;
1166 uint32_t mHapticChannelCount = 0;
Eric Laurentf1f22e72021-07-13 14:04:14 +02001167
1168 audio_channel_mask_t mMixerChannelMask = AUDIO_CHANNEL_NONE;
1169
Eric Laurent81784c32012-11-19 14:55:58 -08001170private:
1171 // mMasterMute is in both PlaybackThread and in AudioFlinger. When a
1172 // PlaybackThread needs to find out if master-muted, it checks it's local
1173 // copy rather than the one in AudioFlinger. This optimization saves a lock.
1174 bool mMasterMute;
1175 void setMasterMute_l(bool muted) { mMasterMute = muted; }
Dean Wheatley12473e92021-03-18 23:00:55 +11001176
1177 auto discontinuityForStandbyOrFlush() const { // call on threadLoop or with lock.
1178 return ((mType == DIRECT && !audio_is_linear_pcm(mFormat))
1179 || mType == OFFLOAD)
1180 ? mTimestampVerifier.DISCONTINUITY_MODE_ZERO
1181 : mTimestampVerifier.DISCONTINUITY_MODE_CONTINUOUS;
1182 }
1183
Eric Laurent81784c32012-11-19 14:55:58 -08001184protected:
Andy Hungdae27702016-10-31 14:01:16 -07001185 ActiveTracks<Track> mActiveTracks;
Eric Laurent81784c32012-11-19 14:55:58 -08001186
Eric Laurent81784c32012-11-19 14:55:58 -08001187 // Time to sleep between cycles when:
1188 virtual uint32_t activeSleepTimeUs() const; // mixer state MIXER_TRACKS_ENABLED
1189 virtual uint32_t idleSleepTimeUs() const = 0; // mixer state MIXER_IDLE
1190 virtual uint32_t suspendSleepTimeUs() const = 0; // audio policy manager suspended us
1191 // No sleep when mixer state == MIXER_TRACKS_READY; relies on audio HAL stream->write()
1192 // No sleep in standby mode; waits on a condition
1193
1194 // Code snippets that are temporarily lifted up out of threadLoop() until the merge
1195 void checkSilentMode_l();
1196
1197 // Non-trivial for DUPLICATING only
1198 virtual void saveOutputTracks() { }
1199 virtual void clearOutputTracks() { }
1200
1201 // Cache various calculated values, at threadLoop() entry and after a parameter change
1202 virtual void cacheParameters_l();
Eric Laurentb3f315a2021-07-13 15:09:05 +02001203 void setCheckOutputStageEffects() override {
1204 mCheckOutputStageEffects.store(true);
1205 }
Eric Laurent81784c32012-11-19 14:55:58 -08001206
1207 virtual uint32_t correctLatency_l(uint32_t latency) const;
1208
Eric Laurent1c333e22014-05-20 10:48:17 -07001209 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1210 audio_patch_handle_t *handle);
1211 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
1212
Phil Burk6fc2a7c2015-04-30 16:08:10 -07001213 bool usesHwAvSync() const { return (mType == DIRECT) && (mOutput != NULL)
1214 && mHwSupportsPause
1215 && (mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC); }
Eric Laurent0f7b5f22014-12-19 10:43:21 -08001216
Andy Hung1bc088a2018-02-09 15:57:31 -08001217 uint32_t trackCountForUid_l(uid_t uid) const;
Eric Laurentad7dd962016-09-22 12:38:37 -07001218
jiabineb3bda02020-06-30 14:07:03 -07001219 void invalidateTracksForAudioSession_l(
1220 audio_session_t sessionId) const override {
1221 ThreadBase::invalidateTracksForAudioSession_l(sessionId, mTracks);
1222 }
1223
Eric Laurent81784c32012-11-19 14:55:58 -08001224private:
1225
1226 friend class AudioFlinger; // for numerous
1227
Mikhail Naganovbf493082017-04-17 17:37:12 -07001228 DISALLOW_COPY_AND_ASSIGN(PlaybackThread);
Eric Laurent81784c32012-11-19 14:55:58 -08001229
1230 status_t addTrack_l(const sp<Track>& track);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001231 bool destroyTrack_l(const sp<Track>& track);
Eric Laurent81784c32012-11-19 14:55:58 -08001232 void removeTrack_l(const sp<Track>& track);
1233
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001234 void readOutputParameters_l();
Kevin Rocardc86a7f72018-04-03 09:00:09 -07001235 void updateMetadata_l() final;
1236 virtual void sendMetadataToBackend_l(const StreamOutHalInterface::SourceMetadata& metadata);
Eric Laurent81784c32012-11-19 14:55:58 -08001237
Dean Wheatley12473e92021-03-18 23:00:55 +11001238 void collectTimestamps_l();
1239
Andy Hungc0691382018-09-12 18:01:57 -07001240 // The Tracks class manages tracks added and removed from the Thread.
Andy Hung1bc088a2018-02-09 15:57:31 -08001241 template <typename T>
1242 class Tracks {
1243 public:
Andy Hungc0691382018-09-12 18:01:57 -07001244 Tracks(bool saveDeletedTrackIds) :
1245 mSaveDeletedTrackIds(saveDeletedTrackIds) { }
Andy Hung1bc088a2018-02-09 15:57:31 -08001246
1247 // SortedVector methods
Andy Hungc0691382018-09-12 18:01:57 -07001248 ssize_t add(const sp<T> &track) {
1249 const ssize_t index = mTracks.add(track);
1250 LOG_ALWAYS_FATAL_IF(index < 0, "cannot add track");
1251 return index;
1252 }
Andy Hung1bc088a2018-02-09 15:57:31 -08001253 ssize_t remove(const sp<T> &track);
1254 size_t size() const {
1255 return mTracks.size();
1256 }
1257 bool isEmpty() const {
1258 return mTracks.isEmpty();
1259 }
1260 ssize_t indexOf(const sp<T> &item) {
1261 return mTracks.indexOf(item);
1262 }
1263 sp<T> operator[](size_t index) const {
1264 return mTracks[index];
1265 }
1266 typename SortedVector<sp<T>>::iterator begin() {
1267 return mTracks.begin();
1268 }
1269 typename SortedVector<sp<T>>::iterator end() {
1270 return mTracks.end();
1271 }
1272
Andy Hungc0691382018-09-12 18:01:57 -07001273 size_t processDeletedTrackIds(std::function<void(int)> f) {
1274 for (const int trackId : mDeletedTrackIds) {
1275 f(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08001276 }
Andy Hungc0691382018-09-12 18:01:57 -07001277 return mDeletedTrackIds.size();
Andy Hung1bc088a2018-02-09 15:57:31 -08001278 }
1279
Andy Hungc0691382018-09-12 18:01:57 -07001280 void clearDeletedTrackIds() { mDeletedTrackIds.clear(); }
Andy Hung1bc088a2018-02-09 15:57:31 -08001281
1282 private:
Andy Hungc0691382018-09-12 18:01:57 -07001283 // Tracks pending deletion for MIXER type threads
1284 const bool mSaveDeletedTrackIds; // true to enable tracking
1285 std::set<int> mDeletedTrackIds;
Andy Hung1bc088a2018-02-09 15:57:31 -08001286
1287 SortedVector<sp<T>> mTracks; // wrapped SortedVector.
1288 };
1289
1290 Tracks<Track> mTracks;
1291
Eric Laurent223fd5c2014-11-11 13:43:36 -08001292 stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
Eric Laurent81784c32012-11-19 14:55:58 -08001293 AudioStreamOut *mOutput;
1294
1295 float mMasterVolume;
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001296 std::atomic<float> mMasterBalance{};
1297 audio_utils::Balance mBalance;
Eric Laurent81784c32012-11-19 14:55:58 -08001298 int mNumWrites;
1299 int mNumDelayedWrites;
1300 bool mInWrite;
1301
1302 // FIXME rename these former local variables of threadLoop to standard "m" names
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001303 nsecs_t mStandbyTimeNs;
Andy Hung25c2dac2014-02-27 14:56:00 -08001304 size_t mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -08001305
1306 // cached copies of activeSleepTimeUs() and idleSleepTimeUs() made by cacheParameters_l()
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001307 uint32_t mActiveSleepTimeUs;
1308 uint32_t mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08001309
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001310 uint32_t mSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08001311
1312 // mixer status returned by prepareTracks_l()
1313 mixer_state mMixerStatus; // current cycle
1314 // previous cycle when in prepareTracks_l()
1315 mixer_state mMixerStatusIgnoringFastTracks;
1316 // FIXME or a separate ready state per track
1317
1318 // FIXME move these declarations into the specific sub-class that needs them
1319 // MIXER only
1320 uint32_t sleepTimeShift;
1321
1322 // same as AudioFlinger::mStandbyTimeInNsecs except for DIRECT which uses a shorter value
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001323 nsecs_t mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08001324
1325 // MIXER only
1326 nsecs_t maxPeriod;
1327
1328 // DUPLICATING only
1329 uint32_t writeFrames;
1330
Eric Laurentbfb1b832013-01-07 09:53:42 -08001331 size_t mBytesRemaining;
1332 size_t mCurrentWriteLength;
1333 bool mUseAsyncWrite;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001334 // mWriteAckSequence contains current write sequence on bits 31-1. The write sequence is
1335 // incremented each time a write(), a flush() or a standby() occurs.
1336 // Bit 0 is set when a write blocks and indicates a callback is expected.
1337 // Bit 0 is reset by the async callback thread calling resetWriteBlocked(). Out of sequence
1338 // callbacks are ignored.
1339 uint32_t mWriteAckSequence;
1340 // mDrainSequence contains current drain sequence on bits 31-1. The drain sequence is
1341 // incremented each time a drain is requested or a flush() or standby() occurs.
1342 // Bit 0 is set when the drain() command is called at the HAL and indicates a callback is
1343 // expected.
1344 // Bit 0 is reset by the async callback thread calling resetDraining(). Out of sequence
1345 // callbacks are ignored.
1346 uint32_t mDrainSequence;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001347 sp<AsyncCallbackThread> mCallbackThread;
1348
jiabinf6eb4c32020-02-25 14:06:25 -08001349 Mutex mAudioTrackCbLock;
1350 // Record of IAudioTrackCallback
jiabin18a4b1c2020-09-17 11:40:42 -07001351 std::map<sp<Track>, sp<media::IAudioTrackCallback>> mAudioTrackCallbacks;
jiabinf6eb4c32020-02-25 14:06:25 -08001352
Eric Laurent81784c32012-11-19 14:55:58 -08001353private:
1354 // The HAL output sink is treated as non-blocking, but current implementation is blocking
1355 sp<NBAIO_Sink> mOutputSink;
1356 // If a fast mixer is present, the blocking pipe sink, otherwise clear
1357 sp<NBAIO_Sink> mPipeSink;
1358 // The current sink for the normal mixer to write it's (sub)mix, mOutputSink or mPipeSink
1359 sp<NBAIO_Sink> mNormalSink;
Eric Laurent81784c32012-11-19 14:55:58 -08001360 uint32_t mScreenState; // cached copy of gScreenState
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07001361 // TODO: add comment and adjust size as needed
Glenn Kasteneef598c2017-04-03 14:41:13 -07001362 static const size_t kFastMixerLogSize = 8 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -08001363 sp<NBLog::Writer> mFastMixerNBLogWriter;
Andy Hung2148bf02016-11-28 19:01:02 -08001364
Dean Wheatley30d28422018-11-06 10:27:40 +11001365 // Downstream patch latency, available if mDownstreamLatencyStatMs.getN() > 0.
1366 audio_utils::Statistics<double> mDownstreamLatencyStatMs{0.999};
Andy Hung2148bf02016-11-28 19:01:02 -08001367
Eric Laurent81784c32012-11-19 14:55:58 -08001368public:
1369 virtual bool hasFastMixer() const = 0;
Glenn Kasten0f11b512014-01-31 16:18:54 -08001370 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex __unused) const
Eric Laurent81784c32012-11-19 14:55:58 -08001371 { FastTrackUnderruns dummy; return dummy; }
1372
1373protected:
1374 // accessed by both binder threads and within threadLoop(), lock on mutex needed
1375 unsigned mFastTrackAvailMask; // bit i set if fast track [i] is available
Eric Laurentd1f69b02014-12-15 14:33:13 -08001376 bool mHwSupportsPause;
1377 bool mHwPaused;
1378 bool mFlushPending;
Eric Laurent7c29ec92017-09-20 17:54:22 -07001379 // volumes last sent to audio HAL with stream->setVolume()
1380 float mLeftVolFloat;
1381 float mRightVolFloat;
Eric Laurent74c38dc2020-12-23 18:19:44 +01001382
1383 // audio patch used by the downstream software patch.
1384 // Only used if ThreadBase::mIsMsdDevice is true.
1385 struct audio_patch mDownStreamPatch;
Eric Laurentb3f315a2021-07-13 15:09:05 +02001386
1387 std::atomic_bool mCheckOutputStageEffects{};
ziyangch8f194f12021-12-01 13:48:04 -08001388
1389 // A differential check on the timestamps to see if there is a change in the
1390 // timestamp frame position between the last call to checkRunningTimestamp.
1391 uint64_t mLastCheckedTimestampPosition = ~0LL;
1392
1393 bool checkRunningTimestamp();
1394
1395 virtual void flushHw_l() { mLastCheckedTimestampPosition = ~0LL; }
Eric Laurent81784c32012-11-19 14:55:58 -08001396};
1397
1398class MixerThread : public PlaybackThread {
1399public:
1400 MixerThread(const sp<AudioFlinger>& audioFlinger,
1401 AudioStreamOut* output,
1402 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07001403 bool systemReady,
Eric Laurentf1f22e72021-07-13 14:04:14 +02001404 type_t type = MIXER,
1405 audio_config_base_t *mixerConfig = nullptr);
Eric Laurent81784c32012-11-19 14:55:58 -08001406 virtual ~MixerThread();
1407
1408 // Thread virtuals
1409
Eric Laurent10351942014-05-08 18:49:52 -07001410 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1411 status_t& status);
Eric Laurent81784c32012-11-19 14:55:58 -08001412
Andy Hung1bc088a2018-02-09 15:57:31 -08001413 virtual bool isTrackAllowed_l(
1414 audio_channel_mask_t channelMask, audio_format_t format,
1415 audio_session_t sessionId, uid_t uid) const override;
Eric Laurent81784c32012-11-19 14:55:58 -08001416protected:
1417 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08001418 virtual uint32_t idleSleepTimeUs() const;
1419 virtual uint32_t suspendSleepTimeUs() const;
1420 virtual void cacheParameters_l();
1421
Andy Hungdae27702016-10-31 14:01:16 -07001422 virtual void acquireWakeLock_l() {
1423 PlaybackThread::acquireWakeLock_l();
Andy Hung818e7a32016-02-16 18:08:07 -08001424 if (hasFastMixer()) {
1425 mFastMixer->setBoottimeOffset(
1426 mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME]);
1427 }
1428 }
1429
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001430 void dumpInternals_l(int fd, const Vector<String16>& args) override;
1431
Eric Laurent81784c32012-11-19 14:55:58 -08001432 // threadLoop snippets
Eric Laurentbfb1b832013-01-07 09:53:42 -08001433 virtual ssize_t threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08001434 virtual void threadLoop_standby();
1435 virtual void threadLoop_mix();
1436 virtual void threadLoop_sleepTime();
Eric Laurent81784c32012-11-19 14:55:58 -08001437 virtual uint32_t correctLatency_l(uint32_t latency) const;
1438
Eric Laurent054d9d32015-04-24 08:48:48 -07001439 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1440 audio_patch_handle_t *handle);
1441 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
1442
Eric Laurent81784c32012-11-19 14:55:58 -08001443 AudioMixer* mAudioMixer; // normal mixer
1444private:
1445 // one-time initialization, no locks required
Glenn Kasten4d23ca32014-05-13 10:39:51 -07001446 sp<FastMixer> mFastMixer; // non-0 if there is also a fast mixer
Eric Laurent81784c32012-11-19 14:55:58 -08001447 sp<AudioWatchdog> mAudioWatchdog; // non-0 if there is an audio watchdog thread
1448
1449 // contents are not guaranteed to be consistent, no locks required
1450 FastMixerDumpState mFastMixerDumpState;
1451#ifdef STATE_QUEUE_DUMP
1452 StateQueueObserverDump mStateQueueObserverDump;
1453 StateQueueMutatorDump mStateQueueMutatorDump;
1454#endif
1455 AudioWatchdogDump mAudioWatchdogDump;
1456
1457 // accessible only within the threadLoop(), no locks required
1458 // mFastMixer->sq() // for mutating and pushing state
1459 int32_t mFastMixerFutex; // for cold idle
1460
Andy Hung2ddee192015-12-18 17:34:44 -08001461 std::atomic_bool mMasterMono;
Eric Laurent81784c32012-11-19 14:55:58 -08001462public:
Glenn Kasten4d23ca32014-05-13 10:39:51 -07001463 virtual bool hasFastMixer() const { return mFastMixer != 0; }
Eric Laurent81784c32012-11-19 14:55:58 -08001464 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const {
Glenn Kastendc2c50b2016-04-21 08:13:14 -07001465 ALOG_ASSERT(fastIndex < FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08001466 return mFastMixerDumpState.mTracks[fastIndex].mUnderruns;
1467 }
Eric Laurent83b88082014-06-20 18:31:16 -07001468
Andy Hung1c86ebe2018-05-29 20:29:08 -07001469 status_t threadloop_getHalTimestamp_l(
1470 ExtendedTimestamp *timestamp) const override {
1471 if (mNormalSink.get() != nullptr) {
1472 return mNormalSink->getTimestamp(*timestamp);
1473 }
1474 return INVALID_OPERATION;
1475 }
1476
Andy Hung2ddee192015-12-18 17:34:44 -08001477protected:
1478 virtual void setMasterMono_l(bool mono) {
1479 mMasterMono.store(mono);
1480 if (mFastMixer != nullptr) { /* hasFastMixer() */
1481 mFastMixer->setMasterMono(mMasterMono);
1482 }
1483 }
1484 // the FastMixer performs mono blend if it exists.
Glenn Kasten03c48d52016-01-27 17:25:17 -08001485 // Blending with limiter is not idempotent,
1486 // and blending without limiter is idempotent but inefficient to do twice.
Andy Hung2ddee192015-12-18 17:34:44 -08001487 virtual bool requireMonoBlend() { return mMasterMono.load() && !hasFastMixer(); }
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001488
1489 void setMasterBalance(float balance) override {
1490 mMasterBalance.store(balance);
1491 if (hasFastMixer()) {
1492 mFastMixer->setMasterBalance(balance);
1493 }
1494 }
Eric Laurent81784c32012-11-19 14:55:58 -08001495};
1496
1497class DirectOutputThread : public PlaybackThread {
1498public:
1499
1500 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
jiabinc52b1ff2019-10-31 17:20:42 -07001501 audio_io_handle_t id, bool systemReady)
1502 : DirectOutputThread(audioFlinger, output, id, DIRECT, systemReady) { }
Andy Hung48f59ed2019-01-28 15:06:59 -08001503
Eric Laurent81784c32012-11-19 14:55:58 -08001504 virtual ~DirectOutputThread();
1505
Mikhail Naganovac917ac2018-11-28 14:03:52 -08001506 status_t selectPresentation(int presentationId, int programId);
1507
Eric Laurent81784c32012-11-19 14:55:58 -08001508 // Thread virtuals
1509
Eric Laurent10351942014-05-08 18:49:52 -07001510 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1511 status_t& status);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001512
ziyangch8f194f12021-12-01 13:48:04 -08001513 void flushHw_l() override;
Eric Laurent81784c32012-11-19 14:55:58 -08001514
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001515 void setMasterBalance(float balance) override;
1516
Eric Laurent81784c32012-11-19 14:55:58 -08001517protected:
Eric Laurent81784c32012-11-19 14:55:58 -08001518 virtual uint32_t activeSleepTimeUs() const;
1519 virtual uint32_t idleSleepTimeUs() const;
1520 virtual uint32_t suspendSleepTimeUs() const;
1521 virtual void cacheParameters_l();
1522
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001523 void dumpInternals_l(int fd, const Vector<String16>& args) override;
1524
Eric Laurent81784c32012-11-19 14:55:58 -08001525 // threadLoop snippets
1526 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
1527 virtual void threadLoop_mix();
1528 virtual void threadLoop_sleepTime();
Eric Laurentd1f69b02014-12-15 14:33:13 -08001529 virtual void threadLoop_exit();
1530 virtual bool shouldStandby_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001531
Phil Burk43b4dcc2015-06-09 16:53:44 -07001532 virtual void onAddNewTrack_l();
1533
Andy Hung48f59ed2019-01-28 15:06:59 -08001534 bool mVolumeShaperActive = false;
Eric Laurent81784c32012-11-19 14:55:58 -08001535
Eric Laurentbfb1b832013-01-07 09:53:42 -08001536 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
jiabinc52b1ff2019-10-31 17:20:42 -07001537 audio_io_handle_t id, ThreadBase::type_t type, bool systemReady);
Eric Laurent5850c4c2016-11-10 13:04:31 -08001538 void processVolume_l(Track *track, bool lastTrack);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001539
Eric Laurent81784c32012-11-19 14:55:58 -08001540 // prepareTracks_l() tells threadLoop_mix() the name of the single active track
1541 sp<Track> mActiveTrack;
Phil Burk43b4dcc2015-06-09 16:53:44 -07001542
1543 wp<Track> mPreviousTrack; // used to detect track switch
1544
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001545 // This must be initialized for initial condition of mMasterBalance = 0 (disabled).
1546 float mMasterBalanceLeft = 1.f;
1547 float mMasterBalanceRight = 1.f;
1548
Eric Laurent81784c32012-11-19 14:55:58 -08001549public:
1550 virtual bool hasFastMixer() const { return false; }
Andy Hung10cbff12017-02-21 17:30:14 -08001551
1552 virtual int64_t computeWaitTimeNs_l() const override;
Andy Hungf3234512018-07-03 14:51:47 -07001553
1554 status_t threadloop_getHalTimestamp_l(ExtendedTimestamp *timestamp) const override {
1555 // For DIRECT and OFFLOAD threads, query the output sink directly.
1556 if (mOutput != nullptr) {
1557 uint64_t uposition64;
1558 struct timespec time;
1559 if (mOutput->getPresentationPosition(
1560 &uposition64, &time) == OK) {
1561 timestamp->mPosition[ExtendedTimestamp::LOCATION_KERNEL]
1562 = (int64_t)uposition64;
1563 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]
1564 = audio_utils_ns_from_timespec(&time);
1565 return NO_ERROR;
1566 }
1567 }
1568 return INVALID_OPERATION;
1569 }
Eric Laurent81784c32012-11-19 14:55:58 -08001570};
1571
Eric Laurentbfb1b832013-01-07 09:53:42 -08001572class OffloadThread : public DirectOutputThread {
1573public:
1574
1575 OffloadThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
jiabinc52b1ff2019-10-31 17:20:42 -07001576 audio_io_handle_t id, bool systemReady);
Eric Laurent6a51d7e2013-10-17 18:59:26 -07001577 virtual ~OffloadThread() {};
ziyangch8f194f12021-12-01 13:48:04 -08001578 void flushHw_l() override;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001579
1580protected:
1581 // threadLoop snippets
1582 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
1583 virtual void threadLoop_exit();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001584
1585 virtual bool waitingAsyncCallback();
1586 virtual bool waitingAsyncCallback_l();
Haynes Mathew George05317d22016-05-03 16:34:26 -07001587 virtual void invalidateTracks(audio_stream_type_t streamType);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001588
Eric Laurentde0613d2016-07-22 18:19:11 -07001589 virtual bool keepWakeLock() const { return (mKeepWakeLock || (mDrainSequence & 1)); }
Eric Laurent64667972016-03-30 18:19:46 -07001590
Eric Laurentbfb1b832013-01-07 09:53:42 -08001591private:
Eric Laurentbfb1b832013-01-07 09:53:42 -08001592 size_t mPausedWriteLength; // length in bytes of write interrupted by pause
1593 size_t mPausedBytesRemaining; // bytes still waiting in mixbuffer after resume
Eric Laurent64667972016-03-30 18:19:46 -07001594 bool mKeepWakeLock; // keep wake lock while waiting for write callback
Eric Laurentbfb1b832013-01-07 09:53:42 -08001595};
1596
1597class AsyncCallbackThread : public Thread {
1598public:
1599
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001600 explicit AsyncCallbackThread(const wp<PlaybackThread>& playbackThread);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001601
1602 virtual ~AsyncCallbackThread();
1603
1604 // Thread virtuals
1605 virtual bool threadLoop();
1606
1607 // RefBase
1608 virtual void onFirstRef();
1609
1610 void exit();
Eric Laurent3b4529e2013-09-05 18:09:19 -07001611 void setWriteBlocked(uint32_t sequence);
1612 void resetWriteBlocked();
1613 void setDraining(uint32_t sequence);
1614 void resetDraining();
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07001615 void setAsyncError();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001616
1617private:
Eric Laurent4de95592013-09-26 15:28:21 -07001618 const wp<PlaybackThread> mPlaybackThread;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001619 // mWriteAckSequence corresponds to the last write sequence passed by the offload thread via
1620 // setWriteBlocked(). The sequence is shifted one bit to the left and the lsb is used
1621 // to indicate that the callback has been received via resetWriteBlocked()
Eric Laurent4de95592013-09-26 15:28:21 -07001622 uint32_t mWriteAckSequence;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001623 // mDrainSequence corresponds to the last drain sequence passed by the offload thread via
1624 // setDraining(). The sequence is shifted one bit to the left and the lsb is used
1625 // to indicate that the callback has been received via resetDraining()
Eric Laurent4de95592013-09-26 15:28:21 -07001626 uint32_t mDrainSequence;
1627 Condition mWaitWorkCV;
1628 Mutex mLock;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07001629 bool mAsyncError;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001630};
1631
Eric Laurent81784c32012-11-19 14:55:58 -08001632class DuplicatingThread : public MixerThread {
1633public:
1634 DuplicatingThread(const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread,
Eric Laurent72e3f392015-05-20 14:43:50 -07001635 audio_io_handle_t id, bool systemReady);
Eric Laurent81784c32012-11-19 14:55:58 -08001636 virtual ~DuplicatingThread();
1637
1638 // Thread virtuals
1639 void addOutputTrack(MixerThread* thread);
1640 void removeOutputTrack(MixerThread* thread);
1641 uint32_t waitTimeMs() const { return mWaitTimeMs; }
Kevin Rocard069c2712018-03-29 19:09:14 -07001642
Kevin Rocardc86a7f72018-04-03 09:00:09 -07001643 void sendMetadataToBackend_l(
1644 const StreamOutHalInterface::SourceMetadata& metadata) override;
Eric Laurent81784c32012-11-19 14:55:58 -08001645protected:
1646 virtual uint32_t activeSleepTimeUs() const;
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001647 void dumpInternals_l(int fd, const Vector<String16>& args) override;
Eric Laurent81784c32012-11-19 14:55:58 -08001648
1649private:
1650 bool outputsReady(const SortedVector< sp<OutputTrack> > &outputTracks);
1651protected:
1652 // threadLoop snippets
1653 virtual void threadLoop_mix();
1654 virtual void threadLoop_sleepTime();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001655 virtual ssize_t threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08001656 virtual void threadLoop_standby();
1657 virtual void cacheParameters_l();
1658
1659private:
1660 // called from threadLoop, addOutputTrack, removeOutputTrack
1661 virtual void updateWaitTime_l();
1662protected:
1663 virtual void saveOutputTracks();
1664 virtual void clearOutputTracks();
1665private:
1666
1667 uint32_t mWaitTimeMs;
1668 SortedVector < sp<OutputTrack> > outputTracks;
1669 SortedVector < sp<OutputTrack> > mOutputTracks;
1670public:
1671 virtual bool hasFastMixer() const { return false; }
Andy Hung1c86ebe2018-05-29 20:29:08 -07001672 status_t threadloop_getHalTimestamp_l(
1673 ExtendedTimestamp *timestamp) const override {
1674 if (mOutputTracks.size() > 0) {
1675 // forward the first OutputTrack's kernel information for timestamp.
1676 const ExtendedTimestamp trackTimestamp =
1677 mOutputTracks[0]->getClientProxyTimestamp();
1678 if (trackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0) {
1679 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] =
1680 trackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
1681 timestamp->mPosition[ExtendedTimestamp::LOCATION_KERNEL] =
1682 trackTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
1683 return OK; // discard server timestamp - that's ignored.
1684 }
1685 }
1686 return INVALID_OPERATION;
1687 }
Eric Laurent81784c32012-11-19 14:55:58 -08001688};
1689
Eric Laurentfa0f6742021-08-17 18:39:44 +02001690class SpatializerThread : public MixerThread {
Eric Laurentb3f315a2021-07-13 15:09:05 +02001691public:
Eric Laurentfa0f6742021-08-17 18:39:44 +02001692 SpatializerThread(const sp<AudioFlinger>& audioFlinger,
Eric Laurentb3f315a2021-07-13 15:09:05 +02001693 AudioStreamOut* output,
1694 audio_io_handle_t id,
1695 bool systemReady,
1696 audio_config_base_t *mixerConfig);
Eric Laurentfa0f6742021-08-17 18:39:44 +02001697 ~SpatializerThread() override {}
Eric Laurentb3f315a2021-07-13 15:09:05 +02001698
1699 bool hasFastMixer() const override { return false; }
1700
1701protected:
1702 void checkOutputStageEffects() override;
1703
1704private:
1705 sp<EffectHandle> mFinalDownMixer;
1706};
1707
Eric Laurent81784c32012-11-19 14:55:58 -08001708// record thread
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001709class RecordThread : public ThreadBase
Eric Laurent81784c32012-11-19 14:55:58 -08001710{
1711public:
1712
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001713 class RecordTrack;
Andy Hung73c02e42015-03-29 01:13:58 -07001714
1715 /* The ResamplerBufferProvider is used to retrieve recorded input data from the
1716 * RecordThread. It maintains local state on the relative position of the read
1717 * position of the RecordTrack compared with the RecordThread.
1718 */
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001719 class ResamplerBufferProvider : public AudioBufferProvider
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001720 {
1721 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001722 explicit ResamplerBufferProvider(RecordTrack* recordTrack) :
Andy Hung73c02e42015-03-29 01:13:58 -07001723 mRecordTrack(recordTrack),
1724 mRsmpInUnrel(0), mRsmpInFront(0) { }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001725 virtual ~ResamplerBufferProvider() { }
Andy Hung73c02e42015-03-29 01:13:58 -07001726
1727 // called to set the ResamplerBufferProvider to head of the RecordThread data buffer,
1728 // skipping any previous data read from the hal.
1729 virtual void reset();
1730
1731 /* Synchronizes RecordTrack position with the RecordThread.
1732 * Calculates available frames and handle overruns if the RecordThread
1733 * has advanced faster than the ResamplerBufferProvider has retrieved data.
1734 * TODO: why not do this for every getNextBuffer?
1735 *
1736 * Parameters
1737 * framesAvailable: pointer to optional output size_t to store record track
1738 * frames available.
1739 * hasOverrun: pointer to optional boolean, returns true if track has overrun.
1740 */
1741
1742 virtual void sync(size_t *framesAvailable = NULL, bool *hasOverrun = NULL);
1743
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001744 // AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -08001745 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001746 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
Eric Laurentec376dc2021-04-08 20:41:22 +02001747
1748 int32_t getFront() const { return mRsmpInFront; }
1749 void setFront(int32_t front) { mRsmpInFront = front; }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001750 private:
1751 RecordTrack * const mRecordTrack;
Andy Hung73c02e42015-03-29 01:13:58 -07001752 size_t mRsmpInUnrel; // unreleased frames remaining from
1753 // most recent getNextBuffer
1754 // for debug only
1755 int32_t mRsmpInFront; // next available frame
1756 // rolling counter that is never cleared
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001757 };
1758
Eric Laurent81784c32012-11-19 14:55:58 -08001759#include "RecordTracks.h"
1760
1761 RecordThread(const sp<AudioFlinger>& audioFlinger,
1762 AudioStreamIn *input,
Eric Laurent81784c32012-11-19 14:55:58 -08001763 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07001764 bool systemReady
Glenn Kasten46909e72013-02-26 09:20:22 -08001765 );
Eric Laurent81784c32012-11-19 14:55:58 -08001766 virtual ~RecordThread();
1767
1768 // no addTrack_l ?
1769 void destroyTrack_l(const sp<RecordTrack>& track);
1770 void removeTrack_l(const sp<RecordTrack>& track);
1771
Eric Laurent81784c32012-11-19 14:55:58 -08001772 // Thread virtuals
1773 virtual bool threadLoop();
Eric Laurent555530a2017-02-07 18:17:24 -08001774 virtual void preExit();
Eric Laurent81784c32012-11-19 14:55:58 -08001775
1776 // RefBase
1777 virtual void onFirstRef();
1778
1779 virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; }
Glenn Kastene198c362013-08-13 09:13:36 -07001780
Glenn Kastenb880f5e2014-05-07 08:43:45 -07001781 virtual sp<MemoryDealer> readOnlyHeap() const { return mReadOnlyHeap; }
1782
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001783 virtual sp<IMemory> pipeMemory() const { return mPipeMemory; }
1784
Eric Laurent81784c32012-11-19 14:55:58 -08001785 sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l(
1786 const sp<AudioFlinger::Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001787 const audio_attributes_t& attr,
Eric Laurentf14db3c2017-12-08 14:20:36 -08001788 uint32_t *pSampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -08001789 audio_format_t format,
1790 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08001791 size_t *pFrameCount,
Glenn Kastend848eb42016-03-08 13:42:11 -08001792 audio_session_t sessionId,
Eric Laurentf14db3c2017-12-08 14:20:36 -08001793 size_t *pNotificationFrameCount,
Eric Laurent09f1ed22019-04-24 17:45:17 -07001794 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00001795 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -07001796 audio_input_flags_t *flags,
Eric Laurent81784c32012-11-19 14:55:58 -08001797 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001798 status_t *status /*non-NULL*/,
Eric Laurentec376dc2021-04-08 20:41:22 +02001799 audio_port_handle_t portId,
1800 int32_t maxSharedAudioHistoryMs);
Eric Laurent81784c32012-11-19 14:55:58 -08001801
1802 status_t start(RecordTrack* recordTrack,
1803 AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08001804 audio_session_t triggerSession);
Eric Laurent81784c32012-11-19 14:55:58 -08001805
1806 // ask the thread to stop the specified track, and
1807 // return true if the caller should then do it's part of the stopping process
Glenn Kastena8356f62013-07-25 14:37:52 -07001808 bool stop(RecordTrack* recordTrack);
Eric Laurent81784c32012-11-19 14:55:58 -08001809
Eric Laurent81784c32012-11-19 14:55:58 -08001810 AudioStreamIn* clearInput();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07001811 virtual sp<StreamHalInterface> stream() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001812
Eric Laurent81784c32012-11-19 14:55:58 -08001813
Eric Laurent10351942014-05-08 18:49:52 -07001814 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1815 status_t& status);
1816 virtual void cacheParameters_l() {}
Eric Laurent81784c32012-11-19 14:55:58 -08001817 virtual String8 getParameters(const String8& keys);
Mikhail Naganov88536df2021-07-26 17:30:29 -07001818 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -07001819 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Eric Laurent1c333e22014-05-20 10:48:17 -07001820 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1821 audio_patch_handle_t *handle);
1822 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
jiabinc52b1ff2019-10-31 17:20:42 -07001823 void updateOutDevices(const DeviceDescriptorBaseVector& outDevices) override;
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02001824 void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs) override;
Eric Laurent83b88082014-06-20 18:31:16 -07001825
Mikhail Naganov444ecc32018-05-01 17:40:05 -07001826 void addPatchTrack(const sp<PatchRecord>& record);
1827 void deletePatchTrack(const sp<PatchRecord>& record);
Eric Laurent83b88082014-06-20 18:31:16 -07001828
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001829 void readInputParameters_l();
Glenn Kasten5f972c02014-01-13 09:59:31 -08001830 virtual uint32_t getInputFramesLost();
Eric Laurent81784c32012-11-19 14:55:58 -08001831
1832 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
1833 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
Andy Hungc3d62f92019-03-14 13:38:51 -07001834 uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
1835 return ThreadBase::hasAudioSession_l(sessionId, mTracks);
1836 }
Eric Laurent81784c32012-11-19 14:55:58 -08001837
1838 // Return the set of unique session IDs across all tracks.
1839 // The keys are the session IDs, and the associated values are meaningless.
1840 // FIXME replace by Set [and implement Bag/Multiset for other uses].
Glenn Kastend848eb42016-03-08 13:42:11 -08001841 KeyedVector<audio_session_t, bool> sessionIds() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001842
1843 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
1844 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const;
1845
1846 static void syncStartEventCallback(const wp<SyncEvent>& event);
Eric Laurent81784c32012-11-19 14:55:58 -08001847
Glenn Kasten9b58f632013-07-16 11:37:48 -07001848 virtual size_t frameCount() const { return mFrameCount; }
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001849 bool hasFastCapture() const { return mFastCapture != 0; }
Mikhail Naganovdc769682018-05-04 15:34:08 -07001850 virtual void toAudioPortConfig(struct audio_port_config *config);
Glenn Kasten9b58f632013-07-16 11:37:48 -07001851
Eric Laurent4c415062016-06-17 16:14:16 -07001852 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
1853 audio_session_t sessionId);
1854
Andy Hungdae27702016-10-31 14:01:16 -07001855 virtual void acquireWakeLock_l() {
1856 ThreadBase::acquireWakeLock_l();
1857 mActiveTracks.updatePowerState(this, true /* force */);
1858 }
1859
Eric Laurentd8365c52017-07-16 15:27:05 -07001860 void checkBtNrec();
1861
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001862 // Sets the UID records silence
Eric Laurent5ada82e2019-08-29 17:53:54 -07001863 void setRecordSilenced(audio_port_handle_t portId, bool silenced);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001864
jiabin653cc0a2018-01-17 17:54:10 -08001865 status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
1866
Paul McLean12340082019-03-19 09:35:05 -06001867 status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
1868 status_t setPreferredMicrophoneFieldDimension(float zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07001869
Kevin Rocard069c2712018-03-29 19:09:14 -07001870 void updateMetadata_l() override;
1871
jiabin01c8f562018-07-19 17:47:28 -07001872 bool fastTrackAvailable() const { return mFastTrackAvail; }
1873
Andy Hungc8fddf32018-08-08 18:32:37 -07001874 bool isTimestampCorrectionEnabled() const override {
1875 // checks popcount for exactly one device.
Atneya Nair497fff12022-01-18 16:23:04 -05001876 // Is currently disabled. Before enabling,
1877 // verify compressed record timestamps.
jiabinc52b1ff2019-10-31 17:20:42 -07001878 return audio_is_input_device(mTimestampCorrectedDevice)
1879 && inDeviceType() == mTimestampCorrectedDevice;
Andy Hungc8fddf32018-08-08 18:32:37 -07001880 }
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001881
Eric Laurentec376dc2021-04-08 20:41:22 +02001882 status_t shareAudioHistory(const std::string& sharedAudioPackageName,
1883 audio_session_t sharedSessionId = AUDIO_SESSION_NONE,
1884 int64_t sharedAudioStartMs = -1);
1885 status_t shareAudioHistory_l(const std::string& sharedAudioPackageName,
1886 audio_session_t sharedSessionId = AUDIO_SESSION_NONE,
1887 int64_t sharedAudioStartMs = -1);
Eric Laurent92d0a322021-07-16 15:32:33 +02001888 void resetAudioHistory_l();
Eric Laurentec376dc2021-04-08 20:41:22 +02001889
Jasmine Chaeaa10e42021-05-11 10:11:14 +08001890 virtual bool isStreamInitialized() {
1891 return !(mInput == nullptr || mInput->stream == nullptr);
1892 }
1893
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001894protected:
1895 void dumpInternals_l(int fd, const Vector<String16>& args) override;
1896 void dumpTracks_l(int fd, const Vector<String16>& args) override;
1897
Eric Laurent81784c32012-11-19 14:55:58 -08001898private:
Eric Laurent81784c32012-11-19 14:55:58 -08001899 // Enter standby if not already in standby, and set mStandby flag
Glenn Kasten93e471f2013-08-19 08:40:07 -07001900 void standbyIfNotAlreadyInStandby();
Eric Laurent81784c32012-11-19 14:55:58 -08001901
1902 // Call the HAL standby method unconditionally, and don't change mStandby flag
Glenn Kastene198c362013-08-13 09:13:36 -07001903 void inputStandBy();
Eric Laurent81784c32012-11-19 14:55:58 -08001904
Eric Laurentd8365c52017-07-16 15:27:05 -07001905 void checkBtNrec_l();
1906
Eric Laurentec376dc2021-04-08 20:41:22 +02001907 int32_t getOldestFront_l();
1908 void updateFronts_l(int32_t offset);
1909
Eric Laurent81784c32012-11-19 14:55:58 -08001910 AudioStreamIn *mInput;
Mikhail Naganov2534b382019-09-25 13:05:02 -07001911 Source *mSource;
Eric Laurent81784c32012-11-19 14:55:58 -08001912 SortedVector < sp<RecordTrack> > mTracks;
Glenn Kasten2b806402013-11-20 16:37:38 -08001913 // mActiveTracks has dual roles: it indicates the current active track(s), and
Eric Laurent81784c32012-11-19 14:55:58 -08001914 // is used together with mStartStopCond to indicate start()/stop() progress
Andy Hungdae27702016-10-31 14:01:16 -07001915 ActiveTracks<RecordTrack> mActiveTracks;
1916
Eric Laurent81784c32012-11-19 14:55:58 -08001917 Condition mStartStopCond;
Glenn Kasten9b58f632013-07-16 11:37:48 -07001918
Glenn Kasten85948432013-08-19 12:09:05 -07001919 // resampler converts input at HAL Hz to output at AudioRecord client Hz
Glenn Kasten1b291842016-07-18 14:55:21 -07001920 void *mRsmpInBuffer; // size = mRsmpInFramesOA
Glenn Kasten85948432013-08-19 12:09:05 -07001921 size_t mRsmpInFrames; // size of resampler input in frames
1922 size_t mRsmpInFramesP2;// size rounded up to a power-of-2
Glenn Kasten1b291842016-07-18 14:55:21 -07001923 size_t mRsmpInFramesOA;// mRsmpInFramesP2 + over-allocation
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001924
1925 // rolling index that is never cleared
Glenn Kasten85948432013-08-19 12:09:05 -07001926 int32_t mRsmpInRear; // last filled frame + 1
Glenn Kasten85948432013-08-19 12:09:05 -07001927
Eric Laurent81784c32012-11-19 14:55:58 -08001928 // For dumpsys
Glenn Kastenb880f5e2014-05-07 08:43:45 -07001929 const sp<MemoryDealer> mReadOnlyHeap;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001930
1931 // one-time initialization, no locks required
Glenn Kastenb187de12014-12-30 08:18:15 -08001932 sp<FastCapture> mFastCapture; // non-0 if there is also
1933 // a fast capture
Eric Laurent72e3f392015-05-20 14:43:50 -07001934
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001935 // FIXME audio watchdog thread
1936
1937 // contents are not guaranteed to be consistent, no locks required
1938 FastCaptureDumpState mFastCaptureDumpState;
1939#ifdef STATE_QUEUE_DUMP
1940 // FIXME StateQueue observer and mutator dump fields
1941#endif
1942 // FIXME audio watchdog dump
1943
1944 // accessible only within the threadLoop(), no locks required
1945 // mFastCapture->sq() // for mutating and pushing state
1946 int32_t mFastCaptureFutex; // for cold idle
1947
1948 // The HAL input source is treated as non-blocking,
1949 // but current implementation is blocking
1950 sp<NBAIO_Source> mInputSource;
1951 // The source for the normal capture thread to read from: mInputSource or mPipeSource
1952 sp<NBAIO_Source> mNormalSource;
1953 // If a fast capture is present, the non-blocking pipe sink written to by fast capture,
1954 // otherwise clear
1955 sp<NBAIO_Sink> mPipeSink;
1956 // If a fast capture is present, the non-blocking pipe source read by normal thread,
1957 // otherwise clear
1958 sp<NBAIO_Source> mPipeSource;
1959 // Depth of pipe from fast capture to normal thread and fast clients, always power of 2
1960 size_t mPipeFramesP2;
1961 // If a fast capture is present, the Pipe as IMemory, otherwise clear
1962 sp<IMemory> mPipeMemory;
1963
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07001964 // TODO: add comment and adjust size as needed
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001965 static const size_t kFastCaptureLogSize = 4 * 1024;
1966 sp<NBLog::Writer> mFastCaptureNBLogWriter;
1967
1968 bool mFastTrackAvail; // true if fast track available
Eric Laurentd8365c52017-07-16 15:27:05 -07001969 // common state to all record threads
1970 std::atomic_bool mBtNrecSuspended;
Andy Hung6427e442018-08-09 12:51:02 -07001971
1972 int64_t mFramesRead = 0; // continuous running counter.
jiabinc52b1ff2019-10-31 17:20:42 -07001973
1974 DeviceDescriptorBaseVector mOutDevices;
Eric Laurentec376dc2021-04-08 20:41:22 +02001975
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02001976 int32_t mMaxSharedAudioHistoryMs = 0;
Eric Laurentec376dc2021-04-08 20:41:22 +02001977 std::string mSharedAudioPackageName = {};
Eric Laurent2407ce32021-04-26 14:56:03 +02001978 int32_t mSharedAudioStartFrames = -1;
Eric Laurentec376dc2021-04-08 20:41:22 +02001979 audio_session_t mSharedAudioSessionId = AUDIO_SESSION_NONE;
Eric Laurent81784c32012-11-19 14:55:58 -08001980};
Eric Laurent6acd1d42017-01-04 14:23:29 -08001981
1982class MmapThread : public ThreadBase
1983{
1984 public:
1985
1986#include "MmapTracks.h"
1987
1988 MmapThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hungcf10d742020-04-28 15:38:24 -07001989 AudioHwDevice *hwDev, sp<StreamHalInterface> stream, bool systemReady,
1990 bool isOut);
Eric Laurent6acd1d42017-01-04 14:23:29 -08001991 virtual ~MmapThread();
1992
1993 virtual void configure(const audio_attributes_t *attr,
1994 audio_stream_type_t streamType,
1995 audio_session_t sessionId,
1996 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07001997 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08001998 audio_port_handle_t portId);
1999
2000 void disconnect();
2001
2002 // MmapStreamInterface
2003 status_t createMmapBuffer(int32_t minSizeFrames,
2004 struct audio_mmap_buffer_info *info);
2005 status_t getMmapPosition(struct audio_mmap_position *position);
jiabind1f1cb62020-03-24 11:57:57 -07002006 status_t start(const AudioClient& client,
2007 const audio_attributes_t *attr,
2008 audio_port_handle_t *handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002009 status_t stop(audio_port_handle_t handle);
Eric Laurent18b57012017-02-13 16:23:52 -08002010 status_t standby();
jiabinb7d8c5a2020-08-26 17:24:52 -07002011 virtual status_t getExternalPosition(uint64_t *position, int64_t *timeNaos) = 0;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002012
2013 // RefBase
2014 virtual void onFirstRef();
2015
2016 // Thread virtuals
2017 virtual bool threadLoop();
2018
2019 virtual void threadLoop_exit();
2020 virtual void threadLoop_standby();
Eric Laurent18b57012017-02-13 16:23:52 -08002021 virtual bool shouldStandby_l() { return false; }
Eric Laurentdda206a2022-07-08 17:28:35 +02002022 virtual status_t exitStandby_l() REQUIRES(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002023
2024 virtual status_t initCheck() const { return (mHalStream == 0) ? NO_INIT : NO_ERROR; }
2025 virtual size_t frameCount() const { return mFrameCount; }
2026 virtual bool checkForNewParameter_l(const String8& keyValuePair,
2027 status_t& status);
2028 virtual String8 getParameters(const String8& keys);
Mikhail Naganov88536df2021-07-26 17:30:29 -07002029 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002030 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002031 void readHalParameters_l();
2032 virtual void cacheParameters_l() {}
2033 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
2034 audio_patch_handle_t *handle);
2035 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
Mikhail Naganovdc769682018-05-04 15:34:08 -07002036 virtual void toAudioPortConfig(struct audio_port_config *config);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002037
2038 virtual sp<StreamHalInterface> stream() const { return mHalStream; }
2039 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
2040 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
2041 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
2042 audio_session_t sessionId);
2043
Andy Hungc3d62f92019-03-14 13:38:51 -07002044 uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
2045 // Note: using mActiveTracks as no mTracks here.
2046 return ThreadBase::hasAudioSession_l(sessionId, mActiveTracks);
2047 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08002048 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
2049 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const;
2050
2051 virtual void checkSilentMode_l() {}
2052 virtual void processVolume_l() {}
2053 void checkInvalidTracks_l();
2054
2055 virtual audio_stream_type_t streamType() { return AUDIO_STREAM_DEFAULT; }
2056
2057 virtual void invalidateTracks(audio_stream_type_t streamType __unused) {}
2058
Eric Laurent331679c2018-04-16 17:03:16 -07002059 // Sets the UID records silence
Eric Laurent5ada82e2019-08-29 17:53:54 -07002060 virtual void setRecordSilenced(audio_port_handle_t portId __unused,
2061 bool silenced __unused) {}
Eric Laurent331679c2018-04-16 17:03:16 -07002062
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002063 virtual bool isStreamInitialized() { return false; }
2064
jiabin09609032022-06-15 19:26:01 +00002065 void setClientSilencedState_l(audio_port_handle_t portId, bool silenced) {
2066 mClientSilencedStates[portId] = silenced;
2067 }
2068
2069 size_t eraseClientSilencedState_l(audio_port_handle_t portId) {
2070 return mClientSilencedStates.erase(portId);
2071 }
2072
2073 bool isClientSilenced_l(audio_port_handle_t portId) const {
2074 const auto it = mClientSilencedStates.find(portId);
2075 return it != mClientSilencedStates.end() ? it->second : false;
2076 }
2077
2078 void setClientSilencedIfExists_l(audio_port_handle_t portId, bool silenced) {
2079 const auto it = mClientSilencedStates.find(portId);
2080 if (it != mClientSilencedStates.end()) {
2081 it->second = silenced;
2082 }
2083 }
2084
Eric Laurent6acd1d42017-01-04 14:23:29 -08002085 protected:
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002086 void dumpInternals_l(int fd, const Vector<String16>& args) override;
2087 void dumpTracks_l(int fd, const Vector<String16>& args) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002088
jiabinc52b1ff2019-10-31 17:20:42 -07002089 /**
2090 * @brief mDeviceId current device port unique identifier
2091 */
2092 audio_port_handle_t mDeviceId = AUDIO_PORT_HANDLE_NONE;
2093
Eric Laurent6acd1d42017-01-04 14:23:29 -08002094 audio_attributes_t mAttr;
2095 audio_session_t mSessionId;
2096 audio_port_handle_t mPortId;
2097
Phil Burk7f6b40d2017-02-09 13:18:38 -08002098 wp<MmapStreamCallback> mCallback;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002099 sp<StreamHalInterface> mHalStream;
2100 sp<DeviceHalInterface> mHalDevice;
2101 AudioHwDevice* const mAudioHwDev;
2102 ActiveTracks<MmapTrack> mActiveTracks;
Eric Laurent67f97292018-04-20 18:05:41 -07002103 float mHalVolFloat;
jiabin09609032022-06-15 19:26:01 +00002104 std::map<audio_port_handle_t, bool> mClientSilencedStates;
Eric Laurent331679c2018-04-16 17:03:16 -07002105
2106 int32_t mNoCallbackWarningCount;
2107 static constexpr int32_t kMaxNoCallbackWarnings = 5;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002108};
2109
2110class MmapPlaybackThread : public MmapThread, public VolumeInterface
2111{
2112
2113public:
2114 MmapPlaybackThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabinc52b1ff2019-10-31 17:20:42 -07002115 AudioHwDevice *hwDev, AudioStreamOut *output, bool systemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002116 virtual ~MmapPlaybackThread() {}
2117
2118 virtual void configure(const audio_attributes_t *attr,
2119 audio_stream_type_t streamType,
2120 audio_session_t sessionId,
2121 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07002122 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002123 audio_port_handle_t portId);
2124
2125 AudioStreamOut* clearOutput();
2126
2127 // VolumeInterface
2128 virtual void setMasterVolume(float value);
2129 virtual void setMasterMute(bool muted);
2130 virtual void setStreamVolume(audio_stream_type_t stream, float value);
2131 virtual void setStreamMute(audio_stream_type_t stream, bool muted);
2132 virtual float streamVolume(audio_stream_type_t stream) const;
2133
2134 void setMasterMute_l(bool muted) { mMasterMute = muted; }
2135
2136 virtual void invalidateTracks(audio_stream_type_t streamType);
2137
2138 virtual audio_stream_type_t streamType() { return mStreamType; }
2139 virtual void checkSilentMode_l();
Eric Laurent331679c2018-04-16 17:03:16 -07002140 void processVolume_l() override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002141
Kevin Rocard069c2712018-03-29 19:09:14 -07002142 void updateMetadata_l() override;
2143
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07002144 virtual void toAudioPortConfig(struct audio_port_config *config);
2145
jiabinb7d8c5a2020-08-26 17:24:52 -07002146 status_t getExternalPosition(uint64_t *position, int64_t *timeNanos) override;
2147
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002148 virtual bool isStreamInitialized() {
2149 return !(mOutput == nullptr || mOutput->stream == nullptr);
2150 }
2151
Eric Laurent6acd1d42017-01-04 14:23:29 -08002152protected:
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002153 void dumpInternals_l(int fd, const Vector<String16>& args) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002154
2155 audio_stream_type_t mStreamType;
2156 float mMasterVolume;
2157 float mStreamVolume;
2158 bool mMasterMute;
2159 bool mStreamMute;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002160 AudioStreamOut* mOutput;
2161};
2162
2163class MmapCaptureThread : public MmapThread
2164{
2165
2166public:
2167 MmapCaptureThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabinc52b1ff2019-10-31 17:20:42 -07002168 AudioHwDevice *hwDev, AudioStreamIn *input, bool systemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002169 virtual ~MmapCaptureThread() {}
2170
2171 AudioStreamIn* clearInput();
2172
Eric Laurentdda206a2022-07-08 17:28:35 +02002173 status_t exitStandby_l() REQUIRES(mLock) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002174
Kevin Rocard069c2712018-03-29 19:09:14 -07002175 void updateMetadata_l() override;
Eric Laurent331679c2018-04-16 17:03:16 -07002176 void processVolume_l() override;
Eric Laurent5ada82e2019-08-29 17:53:54 -07002177 void setRecordSilenced(audio_port_handle_t portId,
2178 bool silenced) override;
Kevin Rocard069c2712018-03-29 19:09:14 -07002179
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07002180 virtual void toAudioPortConfig(struct audio_port_config *config);
2181
jiabinb7d8c5a2020-08-26 17:24:52 -07002182 status_t getExternalPosition(uint64_t *position, int64_t *timeNanos) override;
2183
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002184 virtual bool isStreamInitialized() {
2185 return !(mInput == nullptr || mInput->stream == nullptr);
2186 }
2187
Eric Laurent6acd1d42017-01-04 14:23:29 -08002188protected:
2189
2190 AudioStreamIn* mInput;
2191};