blob: 5925e0222184f92782d5c3fdbc776bf26b2cea9c [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
Andy Hungbd72c542023-06-20 18:56:17 -070022public: // TODO(b/288339104) extract out of AudioFlinger class
Eric Laurent81784c32012-11-19 14:55:58 -080023class ThreadBase : public Thread {
Andy Hung3ff4b552023-06-26 19:20:57 -070024 // TODO(b/288339104) remove friends
25 friend class RecordTrack;
26 friend class Track;
27 friend class TrackBase;
Eric Laurent81784c32012-11-19 14:55:58 -080028public:
Eric Laurent81784c32012-11-19 14:55:58 -080029 enum type_t {
30 MIXER, // Thread class is MixerThread
31 DIRECT, // Thread class is DirectOutputThread
32 DUPLICATING, // Thread class is DuplicatingThread
Eric Laurentbfb1b832013-01-07 09:53:42 -080033 RECORD, // Thread class is RecordThread
Eric Laurent6acd1d42017-01-04 14:23:29 -080034 OFFLOAD, // Thread class is OffloadThread
Andy Hungea840382020-05-05 21:50:17 -070035 MMAP_PLAYBACK, // Thread class for MMAP playback stream
36 MMAP_CAPTURE, // Thread class for MMAP capture stream
Eric Laurent1c5e2e32021-08-18 18:50:28 +020037 SPATIALIZER, //
jiabinc658e452022-10-21 20:52:21 +000038 BIT_PERFECT, // Thread class for BitPerfectThread
Glenn Kasten1bfe09a2017-02-21 13:05:56 -080039 // If you add any values here, also update ThreadBase::threadTypeToString()
Eric Laurent81784c32012-11-19 14:55:58 -080040 };
41
Glenn Kasten97b7b752014-09-28 13:04:24 -070042 static const char *threadTypeToString(type_t type);
43
Eric Laurent81784c32012-11-19 14:55:58 -080044 ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hungcf10d742020-04-28 15:38:24 -070045 type_t type, bool systemReady, bool isOut);
Eric Laurent81784c32012-11-19 14:55:58 -080046 virtual ~ThreadBase();
47
Glenn Kastencf04c2c2013-08-06 07:41:16 -070048 virtual status_t readyToRun();
49
Eric Laurent81784c32012-11-19 14:55:58 -080050 void clearPowerManager();
51
52 // base for record and playback
53 enum {
54 CFG_EVENT_IO,
Eric Laurent10351942014-05-08 18:49:52 -070055 CFG_EVENT_PRIO,
56 CFG_EVENT_SET_PARAMETER,
Eric Laurent1c333e22014-05-20 10:48:17 -070057 CFG_EVENT_CREATE_AUDIO_PATCH,
58 CFG_EVENT_RELEASE_AUDIO_PATCH,
jiabinc52b1ff2019-10-31 17:20:42 -070059 CFG_EVENT_UPDATE_OUT_DEVICE,
Eric Laurentb3f315a2021-07-13 15:09:05 +020060 CFG_EVENT_RESIZE_BUFFER,
Eric Laurent6f9534f2022-05-03 18:15:04 +020061 CFG_EVENT_CHECK_OUTPUT_STAGE_EFFECTS,
62 CFG_EVENT_HAL_LATENCY_MODES_CHANGED,
Eric Laurent81784c32012-11-19 14:55:58 -080063 };
64
Eric Laurent10351942014-05-08 18:49:52 -070065 class ConfigEventData: public RefBase {
Eric Laurent81784c32012-11-19 14:55:58 -080066 public:
Eric Laurent10351942014-05-08 18:49:52 -070067 virtual ~ConfigEventData() {}
Eric Laurent81784c32012-11-19 14:55:58 -080068
69 virtual void dump(char *buffer, size_t size) = 0;
Eric Laurent10351942014-05-08 18:49:52 -070070 protected:
71 ConfigEventData() {}
Eric Laurent81784c32012-11-19 14:55:58 -080072 };
73
Eric Laurent10351942014-05-08 18:49:52 -070074 // Config event sequence by client if status needed (e.g binder thread calling setParameters()):
75 // 1. create SetParameterConfigEvent. This sets mWaitStatus in config event
76 // 2. Lock mLock
77 // 3. Call sendConfigEvent_l(): Append to mConfigEvents and mWaitWorkCV.signal
78 // 4. sendConfigEvent_l() reads status from event->mStatus;
79 // 5. sendConfigEvent_l() returns status
80 // 6. Unlock
81 //
82 // Parameter sequence by server: threadLoop calling processConfigEvents_l():
83 // 1. Lock mLock
84 // 2. If there is an entry in mConfigEvents proceed ...
85 // 3. Read first entry in mConfigEvents
86 // 4. Remove first entry from mConfigEvents
87 // 5. Process
88 // 6. Set event->mStatus
89 // 7. event->mCond.signal
90 // 8. Unlock
Eric Laurent81784c32012-11-19 14:55:58 -080091
Eric Laurent10351942014-05-08 18:49:52 -070092 class ConfigEvent: public RefBase {
93 public:
94 virtual ~ConfigEvent() {}
95
Eric Laurentb3f315a2021-07-13 15:09:05 +020096 void dump(char *buffer, size_t size) {
97 snprintf(buffer, size, "Event type: %d\n", mType);
98 if (mData != nullptr) {
99 snprintf(buffer, size, "Data:\n");
100 mData->dump(buffer, size);
101 }
102 }
Eric Laurent10351942014-05-08 18:49:52 -0700103
104 const int mType; // event type e.g. CFG_EVENT_IO
105 Mutex mLock; // mutex associated with mCond
106 Condition mCond; // condition for status return
107 status_t mStatus; // status communicated to sender
108 bool mWaitStatus; // true if sender is waiting for status
Eric Laurent72e3f392015-05-20 14:43:50 -0700109 bool mRequiresSystemReady; // true if must wait for system ready to enter event queue
Eric Laurent10351942014-05-08 18:49:52 -0700110 sp<ConfigEventData> mData; // event specific parameter data
111
112 protected:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700113 explicit ConfigEvent(int type, bool requiresSystemReady = false) :
Eric Laurent72e3f392015-05-20 14:43:50 -0700114 mType(type), mStatus(NO_ERROR), mWaitStatus(false),
115 mRequiresSystemReady(requiresSystemReady), mData(NULL) {}
Eric Laurent10351942014-05-08 18:49:52 -0700116 };
117
118 class IoConfigEventData : public ConfigEventData {
119 public:
Mikhail Naganov88536df2021-07-26 17:30:29 -0700120 IoConfigEventData(audio_io_config_event_t event, pid_t pid,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700121 audio_port_handle_t portId) :
122 mEvent(event), mPid(pid), mPortId(portId) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800123
124 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200125 snprintf(buffer, size, "- IO event: event %d\n", mEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800126 }
127
Mikhail Naganov88536df2021-07-26 17:30:29 -0700128 const audio_io_config_event_t mEvent;
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700129 const pid_t mPid;
Eric Laurent09f1ed22019-04-24 17:45:17 -0700130 const audio_port_handle_t mPortId;
Eric Laurent81784c32012-11-19 14:55:58 -0800131 };
132
Eric Laurent10351942014-05-08 18:49:52 -0700133 class IoConfigEvent : public ConfigEvent {
Eric Laurent81784c32012-11-19 14:55:58 -0800134 public:
Mikhail Naganov88536df2021-07-26 17:30:29 -0700135 IoConfigEvent(audio_io_config_event_t event, pid_t pid, audio_port_handle_t portId) :
Eric Laurent10351942014-05-08 18:49:52 -0700136 ConfigEvent(CFG_EVENT_IO) {
Eric Laurent09f1ed22019-04-24 17:45:17 -0700137 mData = new IoConfigEventData(event, pid, portId);
Eric Laurent10351942014-05-08 18:49:52 -0700138 }
139 virtual ~IoConfigEvent() {}
140 };
Eric Laurent81784c32012-11-19 14:55:58 -0800141
Eric Laurent10351942014-05-08 18:49:52 -0700142 class PrioConfigEventData : public ConfigEventData {
143 public:
Mikhail Naganov83f04272017-02-07 10:45:09 -0800144 PrioConfigEventData(pid_t pid, pid_t tid, int32_t prio, bool forApp) :
145 mPid(pid), mTid(tid), mPrio(prio), mForApp(forApp) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800146
147 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200148 snprintf(buffer, size, "- Prio event: pid %d, tid %d, prio %d, for app? %d\n",
Mikhail Naganov83f04272017-02-07 10:45:09 -0800149 mPid, mTid, mPrio, mForApp);
Eric Laurent81784c32012-11-19 14:55:58 -0800150 }
151
Eric Laurent81784c32012-11-19 14:55:58 -0800152 const pid_t mPid;
153 const pid_t mTid;
154 const int32_t mPrio;
Mikhail Naganov83f04272017-02-07 10:45:09 -0800155 const bool mForApp;
Eric Laurent81784c32012-11-19 14:55:58 -0800156 };
157
Eric Laurent10351942014-05-08 18:49:52 -0700158 class PrioConfigEvent : public ConfigEvent {
159 public:
Mikhail Naganov83f04272017-02-07 10:45:09 -0800160 PrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp) :
Eric Laurent72e3f392015-05-20 14:43:50 -0700161 ConfigEvent(CFG_EVENT_PRIO, true) {
Mikhail Naganov83f04272017-02-07 10:45:09 -0800162 mData = new PrioConfigEventData(pid, tid, prio, forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700163 }
164 virtual ~PrioConfigEvent() {}
165 };
166
167 class SetParameterConfigEventData : public ConfigEventData {
168 public:
Andy Hung71ba4b32022-10-06 12:09:49 -0700169 explicit SetParameterConfigEventData(const String8& keyValuePairs) :
Eric Laurent10351942014-05-08 18:49:52 -0700170 mKeyValuePairs(keyValuePairs) {}
171
172 virtual void dump(char *buffer, size_t size) {
Tomasz Wasilczyk8f36f6e2023-08-15 20:59:35 +0000173 snprintf(buffer, size, "- KeyValue: %s\n", mKeyValuePairs.c_str());
Eric Laurent10351942014-05-08 18:49:52 -0700174 }
175
176 const String8 mKeyValuePairs;
177 };
178
179 class SetParameterConfigEvent : public ConfigEvent {
180 public:
Andy Hung71ba4b32022-10-06 12:09:49 -0700181 explicit SetParameterConfigEvent(const String8& keyValuePairs) :
Eric Laurent10351942014-05-08 18:49:52 -0700182 ConfigEvent(CFG_EVENT_SET_PARAMETER) {
183 mData = new SetParameterConfigEventData(keyValuePairs);
184 mWaitStatus = true;
185 }
186 virtual ~SetParameterConfigEvent() {}
187 };
188
Eric Laurent1c333e22014-05-20 10:48:17 -0700189 class CreateAudioPatchConfigEventData : public ConfigEventData {
190 public:
191 CreateAudioPatchConfigEventData(const struct audio_patch patch,
192 audio_patch_handle_t handle) :
193 mPatch(patch), mHandle(handle) {}
194
195 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200196 snprintf(buffer, size, "- Patch handle: %u\n", mHandle);
Eric Laurent1c333e22014-05-20 10:48:17 -0700197 }
198
199 const struct audio_patch mPatch;
200 audio_patch_handle_t mHandle;
201 };
202
203 class CreateAudioPatchConfigEvent : public ConfigEvent {
204 public:
205 CreateAudioPatchConfigEvent(const struct audio_patch patch,
206 audio_patch_handle_t handle) :
207 ConfigEvent(CFG_EVENT_CREATE_AUDIO_PATCH) {
208 mData = new CreateAudioPatchConfigEventData(patch, handle);
209 mWaitStatus = true;
210 }
211 virtual ~CreateAudioPatchConfigEvent() {}
212 };
213
214 class ReleaseAudioPatchConfigEventData : public ConfigEventData {
215 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700216 explicit ReleaseAudioPatchConfigEventData(const audio_patch_handle_t handle) :
Eric Laurent1c333e22014-05-20 10:48:17 -0700217 mHandle(handle) {}
218
219 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200220 snprintf(buffer, size, "- Patch handle: %u\n", mHandle);
Eric Laurent1c333e22014-05-20 10:48:17 -0700221 }
222
223 audio_patch_handle_t mHandle;
224 };
225
226 class ReleaseAudioPatchConfigEvent : public ConfigEvent {
227 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700228 explicit ReleaseAudioPatchConfigEvent(const audio_patch_handle_t handle) :
Eric Laurent1c333e22014-05-20 10:48:17 -0700229 ConfigEvent(CFG_EVENT_RELEASE_AUDIO_PATCH) {
230 mData = new ReleaseAudioPatchConfigEventData(handle);
231 mWaitStatus = true;
232 }
233 virtual ~ReleaseAudioPatchConfigEvent() {}
234 };
Eric Laurent81784c32012-11-19 14:55:58 -0800235
jiabinc52b1ff2019-10-31 17:20:42 -0700236 class UpdateOutDevicesConfigEventData : public ConfigEventData {
237 public:
238 explicit UpdateOutDevicesConfigEventData(const DeviceDescriptorBaseVector& outDevices) :
239 mOutDevices(outDevices) {}
240
241 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200242 snprintf(buffer, size, "- Devices: %s", android::toString(mOutDevices).c_str());
jiabinc52b1ff2019-10-31 17:20:42 -0700243 }
244
245 DeviceDescriptorBaseVector mOutDevices;
246 };
247
248 class UpdateOutDevicesConfigEvent : public ConfigEvent {
249 public:
250 explicit UpdateOutDevicesConfigEvent(const DeviceDescriptorBaseVector& outDevices) :
251 ConfigEvent(CFG_EVENT_UPDATE_OUT_DEVICE) {
252 mData = new UpdateOutDevicesConfigEventData(outDevices);
253 }
254
255 virtual ~UpdateOutDevicesConfigEvent();
256 };
257
Eric Laurentec376dc2021-04-08 20:41:22 +0200258 class ResizeBufferConfigEventData : public ConfigEventData {
259 public:
260 explicit ResizeBufferConfigEventData(int32_t maxSharedAudioHistoryMs) :
261 mMaxSharedAudioHistoryMs(maxSharedAudioHistoryMs) {}
262
263 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200264 snprintf(buffer, size, "- mMaxSharedAudioHistoryMs: %d", mMaxSharedAudioHistoryMs);
Eric Laurentec376dc2021-04-08 20:41:22 +0200265 }
266
267 int32_t mMaxSharedAudioHistoryMs;
268 };
269
270 class ResizeBufferConfigEvent : public ConfigEvent {
271 public:
272 explicit ResizeBufferConfigEvent(int32_t maxSharedAudioHistoryMs) :
273 ConfigEvent(CFG_EVENT_RESIZE_BUFFER) {
274 mData = new ResizeBufferConfigEventData(maxSharedAudioHistoryMs);
275 }
276
277 virtual ~ResizeBufferConfigEvent() {}
278 };
279
Eric Laurentb3f315a2021-07-13 15:09:05 +0200280 class CheckOutputStageEffectsEvent : public ConfigEvent {
281 public:
282 CheckOutputStageEffectsEvent() :
283 ConfigEvent(CFG_EVENT_CHECK_OUTPUT_STAGE_EFFECTS) {
284 }
285
286 virtual ~CheckOutputStageEffectsEvent() {}
287 };
288
Eric Laurent6f9534f2022-05-03 18:15:04 +0200289 class HalLatencyModesChangedEvent : public ConfigEvent {
290 public:
291 HalLatencyModesChangedEvent() :
292 ConfigEvent(CFG_EVENT_HAL_LATENCY_MODES_CHANGED) {
293 }
294
295 virtual ~HalLatencyModesChangedEvent() {}
296 };
297
Eric Laurentb3f315a2021-07-13 15:09:05 +0200298
Eric Laurent81784c32012-11-19 14:55:58 -0800299 class PMDeathRecipient : public IBinder::DeathRecipient {
300 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700301 explicit PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800302 virtual ~PMDeathRecipient() {}
303
304 // IBinder::DeathRecipient
305 virtual void binderDied(const wp<IBinder>& who);
306
307 private:
Mikhail Naganovbf493082017-04-17 17:37:12 -0700308 DISALLOW_COPY_AND_ASSIGN(PMDeathRecipient);
Eric Laurent81784c32012-11-19 14:55:58 -0800309
310 wp<ThreadBase> mThread;
311 };
312
313 virtual status_t initCheck() const = 0;
314
315 // static externally-visible
316 type_t type() const { return mType; }
Eric Laurentf6870ae2015-05-08 10:50:03 -0700317 bool isDuplicating() const { return (mType == DUPLICATING); }
318
Eric Laurent81784c32012-11-19 14:55:58 -0800319 audio_io_handle_t id() const { return mId;}
320
321 // dynamic externally-visible
322 uint32_t sampleRate() const { return mSampleRate; }
Eric Laurent81784c32012-11-19 14:55:58 -0800323 audio_channel_mask_t channelMask() const { return mChannelMask; }
Eric Laurentf1f22e72021-07-13 14:04:14 +0200324 virtual audio_channel_mask_t mixerChannelMask() const { return mChannelMask; }
325
Andy Hung463be252014-07-10 16:56:07 -0700326 audio_format_t format() const { return mHALFormat; }
Eric Laurent83b88082014-06-20 18:31:16 -0700327 uint32_t channelCount() const { return mChannelCount; }
Eric Laurentf1f22e72021-07-13 14:04:14 +0200328
Eric Laurent81784c32012-11-19 14:55:58 -0800329 // Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects,
Glenn Kasten9b58f632013-07-16 11:37:48 -0700330 // and returns the [normal mix] buffer's frame count.
331 virtual size_t frameCount() const = 0;
jiabineb3bda02020-06-30 14:07:03 -0700332 virtual audio_channel_mask_t hapticChannelMask() const { return AUDIO_CHANNEL_NONE; }
Eric Laurent6b446ce2019-12-13 10:56:31 -0800333 virtual uint32_t latency_l() const { return 0; }
334 virtual void setVolumeForOutput_l(float left __unused, float right __unused) const {}
Glenn Kasten4a8308b2016-04-18 14:10:01 -0700335
336 // Return's the HAL's frame count i.e. fast mixer buffer size.
337 size_t frameCountHAL() const { return mFrameCount; }
338
Eric Laurentbfb1b832013-01-07 09:53:42 -0800339 size_t frameSize() const { return mFrameSize; }
Eric Laurent81784c32012-11-19 14:55:58 -0800340
341 // Should be "virtual status_t requestExitAndWait()" and override same
342 // method in Thread, but Thread::requestExitAndWait() is not yet virtual.
343 void exit();
Eric Laurent10351942014-05-08 18:49:52 -0700344 virtual bool checkForNewParameter_l(const String8& keyValuePair,
345 status_t& status) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800346 virtual status_t setParameters(const String8& keyValuePairs);
347 virtual String8 getParameters(const String8& keys) = 0;
Mikhail Naganov88536df2021-07-26 17:30:29 -0700348 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700349 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) = 0;
Eric Laurent10351942014-05-08 18:49:52 -0700350 // sendConfigEvent_l() must be called with ThreadBase::mLock held
351 // Can temporarily release the lock if waiting for a reply from
352 // processConfigEvents_l().
353 status_t sendConfigEvent_l(sp<ConfigEvent>& event);
Mikhail Naganov88536df2021-07-26 17:30:29 -0700354 void sendIoConfigEvent(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700355 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Mikhail Naganov88536df2021-07-26 17:30:29 -0700356 void sendIoConfigEvent_l(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700357 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Mikhail Naganov83f04272017-02-07 10:45:09 -0800358 void sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp);
359 void sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio, bool forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700360 status_t sendSetParameterConfigEvent_l(const String8& keyValuePair);
Eric Laurent1c333e22014-05-20 10:48:17 -0700361 status_t sendCreateAudioPatchConfigEvent(const struct audio_patch *patch,
362 audio_patch_handle_t *handle);
363 status_t sendReleaseAudioPatchConfigEvent(audio_patch_handle_t handle);
jiabinc52b1ff2019-10-31 17:20:42 -0700364 status_t sendUpdateOutDeviceConfigEvent(
365 const DeviceDescriptorBaseVector& outDevices);
Eric Laurentec376dc2021-04-08 20:41:22 +0200366 void sendResizeBufferConfigEvent_l(int32_t maxSharedAudioHistoryMs);
Eric Laurentb3f315a2021-07-13 15:09:05 +0200367 void sendCheckOutputStageEffectsEvent();
368 void sendCheckOutputStageEffectsEvent_l();
Eric Laurent6f9534f2022-05-03 18:15:04 +0200369 void sendHalLatencyModesChangedEvent_l();
Eric Laurentb3f315a2021-07-13 15:09:05 +0200370
Eric Laurent021cf962014-05-13 10:18:14 -0700371 void processConfigEvents_l();
Eric Laurentb3f315a2021-07-13 15:09:05 +0200372 virtual void setCheckOutputStageEffects() {}
Eric Laurent10351942014-05-08 18:49:52 -0700373 virtual void cacheParameters_l() = 0;
Eric Laurent1c333e22014-05-20 10:48:17 -0700374 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
375 audio_patch_handle_t *handle) = 0;
376 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle) = 0;
jiabinc52b1ff2019-10-31 17:20:42 -0700377 virtual void updateOutDevices(const DeviceDescriptorBaseVector& outDevices);
Mikhail Naganovdc769682018-05-04 15:34:08 -0700378 virtual void toAudioPortConfig(struct audio_port_config *config) = 0;
Eric Laurent1c333e22014-05-20 10:48:17 -0700379
Eric Laurent5f0fd7b2021-05-07 16:33:26 +0200380 virtual void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs);
Eric Laurent81784c32012-11-19 14:55:58 -0800381
382 // see note at declaration of mStandby, mOutDevice and mInDevice
383 bool standby() const { return mStandby; }
jiabinc52b1ff2019-10-31 17:20:42 -0700384 const DeviceTypeSet outDeviceTypes() const {
385 return getAudioDeviceTypes(mOutDeviceTypeAddrs);
386 }
387 audio_devices_t inDeviceType() const { return mInDeviceTypeAddr.mType; }
388 DeviceTypeSet getDeviceTypes() const {
389 return isOutput() ? outDeviceTypes() : DeviceTypeSet({inDeviceType()});
390 }
Andy Hung293558a2017-03-21 12:19:20 -0700391
jiabin8f278ee2019-11-11 12:16:27 -0800392 const AudioDeviceTypeAddrVector& outDeviceTypeAddrs() const {
393 return mOutDeviceTypeAddrs;
394 }
395 const AudioDeviceTypeAddr& inDeviceTypeAddr() const {
396 return mInDeviceTypeAddr;
397 }
398
Andy Hungcf10d742020-04-28 15:38:24 -0700399 bool isOutput() const { return mIsOut; }
Eric Laurent81784c32012-11-19 14:55:58 -0800400
Andy Hungea840382020-05-05 21:50:17 -0700401 bool isOffloadOrMmap() const {
402 switch (mType) {
403 case OFFLOAD:
404 case MMAP_PLAYBACK:
405 case MMAP_CAPTURE:
406 return true;
407 default:
408 return false;
409 }
410 }
411
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700412 virtual sp<StreamHalInterface> stream() const = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800413
Andy Hungbd72c542023-06-20 18:56:17 -0700414 sp<IAfEffectHandle> createEffect_l(
Andy Hungd65869f2023-06-27 17:05:02 -0700415 const sp<Client>& client,
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700416 const sp<media::IEffectClient>& effectClient,
Eric Laurent81784c32012-11-19 14:55:58 -0800417 int32_t priority,
Glenn Kastend848eb42016-03-08 13:42:11 -0800418 audio_session_t sessionId,
Eric Laurent81784c32012-11-19 14:55:58 -0800419 effect_descriptor_t *desc,
420 int *enabled,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800421 status_t *status /*non-NULL*/,
Eric Laurent2fe0acd2020-03-13 14:30:46 -0700422 bool pinned,
Eric Laurentde8caf42021-08-11 17:19:25 +0200423 bool probe,
424 bool notifyFramesProcessed);
Eric Laurent81784c32012-11-19 14:55:58 -0800425
426 // return values for hasAudioSession (bit field)
427 enum effect_state {
428 EFFECT_SESSION = 0x1, // the audio session corresponds to at least one
429 // effect
Eric Laurent4c415062016-06-17 16:14:16 -0700430 TRACK_SESSION = 0x2, // the audio session corresponds to at least one
Eric Laurent81784c32012-11-19 14:55:58 -0800431 // track
Eric Laurentb62d0362021-10-26 17:40:18 +0200432 FAST_SESSION = 0x4, // the audio session corresponds to at least one
Eric Laurent4c415062016-06-17 16:14:16 -0700433 // fast track
jiabinc658e452022-10-21 20:52:21 +0000434 SPATIALIZED_SESSION = 0x8, // the audio session corresponds to at least one
435 // spatialized track
436 BIT_PERFECT_SESSION = 0x10 // the audio session corresponds to at least one
437 // bit-perfect track
Eric Laurent81784c32012-11-19 14:55:58 -0800438 };
439
440 // get effect chain corresponding to session Id.
Andy Hungbd72c542023-06-20 18:56:17 -0700441 sp<IAfEffectChain> getEffectChain(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800442 // same as getEffectChain() but must be called with ThreadBase mutex locked
Andy Hungbd72c542023-06-20 18:56:17 -0700443 sp<IAfEffectChain> getEffectChain_l(audio_session_t sessionId) const;
Eric Laurent6c796322019-04-09 14:13:17 -0700444 std::vector<int> getEffectIds_l(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800445 // add an effect chain to the chain list (mEffectChains)
Andy Hungbd72c542023-06-20 18:56:17 -0700446 virtual status_t addEffectChain_l(const sp<IAfEffectChain>& chain) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800447 // remove an effect chain from the chain list (mEffectChains)
Andy Hungbd72c542023-06-20 18:56:17 -0700448 virtual size_t removeEffectChain_l(const sp<IAfEffectChain>& chain) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800449 // lock all effect chains Mutexes. Must be called before releasing the
450 // ThreadBase mutex before processing the mixer and effects. This guarantees the
451 // integrity of the chains during the process.
452 // Also sets the parameter 'effectChains' to current value of mEffectChains.
Andy Hungbd72c542023-06-20 18:56:17 -0700453 void lockEffectChains_l(Vector<sp<IAfEffectChain>>& effectChains);
Eric Laurent81784c32012-11-19 14:55:58 -0800454 // unlock effect chains after process
Andy Hungbd72c542023-06-20 18:56:17 -0700455 void unlockEffectChains(const Vector<sp<IAfEffectChain>>& effectChains);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800456 // get a copy of mEffectChains vector
Andy Hungbd72c542023-06-20 18:56:17 -0700457 Vector<sp<IAfEffectChain>> getEffectChains_l() const { return mEffectChains; };
Eric Laurent81784c32012-11-19 14:55:58 -0800458 // set audio mode to all effect chains
459 void setMode(audio_mode_t mode);
460 // get effect module with corresponding ID on specified audio session
Andy Hungbd72c542023-06-20 18:56:17 -0700461 sp<IAfEffectModule> getEffect(audio_session_t sessionId, int effectId);
462 sp<IAfEffectModule> getEffect_l(audio_session_t sessionId, int effectId);
Eric Laurent81784c32012-11-19 14:55:58 -0800463 // add and effect module. Also creates the effect chain is none exists for
Eric Laurent6c796322019-04-09 14:13:17 -0700464 // the effects audio session. Only called in a context of moving an effect
465 // from one thread to another
Andy Hungbd72c542023-06-20 18:56:17 -0700466 status_t addEffect_l(const sp<IAfEffectModule>& effect);
Eric Laurent81784c32012-11-19 14:55:58 -0800467 // remove and effect module. Also removes the effect chain is this was the last
468 // effect
Andy Hungbd72c542023-06-20 18:56:17 -0700469 void removeEffect_l(const sp<IAfEffectModule>& effect, bool release = false);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800470 // disconnect an effect handle from module and destroy module if last handle
Andy Hungbd72c542023-06-20 18:56:17 -0700471 void disconnectEffectHandle(IAfEffectHandle *handle, bool unpinIfLast);
Eric Laurent81784c32012-11-19 14:55:58 -0800472 // detach all tracks connected to an auxiliary effect
Glenn Kasten0f11b512014-01-31 16:18:54 -0800473 virtual void detachAuxEffect_l(int effectId __unused) {}
Eric Laurent4c415062016-06-17 16:14:16 -0700474 // returns a combination of:
475 // - EFFECT_SESSION if effects on this audio session exist in one chain
476 // - TRACK_SESSION if tracks on this audio session exist
477 // - FAST_SESSION if fast tracks on this audio session exist
Eric Laurentb62d0362021-10-26 17:40:18 +0200478 // - SPATIALIZED_SESSION if spatialized tracks on this audio session exist
Eric Laurent4c415062016-06-17 16:14:16 -0700479 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const = 0;
480 uint32_t hasAudioSession(audio_session_t sessionId) const {
481 Mutex::Autolock _l(mLock);
482 return hasAudioSession_l(sessionId);
483 }
484
Andy Hungc3d62f92019-03-14 13:38:51 -0700485 template <typename T>
486 uint32_t hasAudioSession_l(audio_session_t sessionId, const T& tracks) const {
487 uint32_t result = 0;
488 if (getEffectChain_l(sessionId) != 0) {
489 result = EFFECT_SESSION;
490 }
491 for (size_t i = 0; i < tracks.size(); ++i) {
Andy Hung3ff4b552023-06-26 19:20:57 -0700492 const sp<IAfTrackBase>& track = tracks[i];
Andy Hungc3d62f92019-03-14 13:38:51 -0700493 if (sessionId == track->sessionId()
494 && !track->isInvalid() // not yet removed from tracks.
495 && !track->isTerminated()) {
496 result |= TRACK_SESSION;
497 if (track->isFastTrack()) {
498 result |= FAST_SESSION; // caution, only represents first track.
499 }
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200500 if (track->isSpatialized()) {
Eric Laurentb62d0362021-10-26 17:40:18 +0200501 result |= SPATIALIZED_SESSION; // caution, only first track.
502 }
jiabinc658e452022-10-21 20:52:21 +0000503 if (track->isBitPerfect()) {
504 result |= BIT_PERFECT_SESSION;
505 }
Andy Hungc3d62f92019-03-14 13:38:51 -0700506 break;
507 }
508 }
509 return result;
510 }
511
Eric Laurent81784c32012-11-19 14:55:58 -0800512 // the value returned by default implementation is not important as the
513 // strategy is only meaningful for PlaybackThread which implements this method
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800514 virtual product_strategy_t getStrategyForSession_l(
515 audio_session_t sessionId __unused) {
516 return static_cast<product_strategy_t>(0);
517 }
Eric Laurent81784c32012-11-19 14:55:58 -0800518
Eric Laurent81784c32012-11-19 14:55:58 -0800519 // check if some effects must be suspended/restored when an effect is enabled
520 // or disabled
Eric Laurent6b446ce2019-12-13 10:56:31 -0800521 void checkSuspendOnEffectEnabled(bool enabled,
522 audio_session_t sessionId,
523 bool threadLocked);
Eric Laurent81784c32012-11-19 14:55:58 -0800524
Andy Hung068e08e2023-05-15 19:02:55 -0700525 virtual status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) = 0;
526 virtual bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800527
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700528 // Return a reference to a per-thread heap which can be used to allocate IMemory
529 // objects that will be read-only to client processes, read/write to mediaserver,
530 // and shared by all client processes of the thread.
531 // The heap is per-thread rather than common across all threads, because
532 // clients can't be trusted not to modify the offset of the IMemory they receive.
533 // If a thread does not have such a heap, this method returns 0.
534 virtual sp<MemoryDealer> readOnlyHeap() const { return 0; }
Eric Laurent81784c32012-11-19 14:55:58 -0800535
Glenn Kasten6181ffd2014-05-13 10:41:52 -0700536 virtual sp<IMemory> pipeMemory() const { return 0; }
537
Eric Laurent72e3f392015-05-20 14:43:50 -0700538 void systemReady();
539
Eric Laurent4c415062016-06-17 16:14:16 -0700540 // checkEffectCompatibility_l() must be called with ThreadBase::mLock held
541 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
542 audio_session_t sessionId) = 0;
543
Eric Laurent6acd1d42017-01-04 14:23:29 -0800544 void broadcast_l();
545
Andy Hungc8fddf32018-08-08 18:32:37 -0700546 virtual bool isTimestampCorrectionEnabled() const { return false; }
547
548 bool isMsdDevice() const { return mIsMsdDevice; }
549
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700550 void dump(int fd, const Vector<String16>& args);
Andy Hungdc099c22018-09-18 13:46:39 -0700551
Andy Hungd0979812019-02-21 15:51:44 -0800552 // deliver stats to mediametrics.
553 void sendStatistics(bool force);
554
Eric Laurent81784c32012-11-19 14:55:58 -0800555 mutable Mutex mLock;
556
Andy Hungbd72c542023-06-20 18:56:17 -0700557 void onEffectEnable(const sp<IAfEffectModule>& effect);
Eric Laurent6b446ce2019-12-13 10:56:31 -0800558 void onEffectDisable();
559
jiabineb3bda02020-06-30 14:07:03 -0700560 // invalidateTracksForAudioSession_l must be called with holding mLock.
561 virtual void invalidateTracksForAudioSession_l(audio_session_t sessionId __unused) const { }
562 // Invalidate all the tracks with the given audio session.
563 void invalidateTracksForAudioSession(audio_session_t sessionId) const {
564 Mutex::Autolock _l(mLock);
565 invalidateTracksForAudioSession_l(sessionId);
566 }
567
568 template <typename T>
569 void invalidateTracksForAudioSession_l(audio_session_t sessionId,
570 const T& tracks) const {
571 for (size_t i = 0; i < tracks.size(); ++i) {
Andy Hung3ff4b552023-06-26 19:20:57 -0700572 const sp<IAfTrackBase>& track = tracks[i];
jiabineb3bda02020-06-30 14:07:03 -0700573 if (sessionId == track->sessionId()) {
574 track->invalidate();
575 }
576 }
577 }
578
Jasmine Chaeaa10e42021-05-11 10:11:14 +0800579 virtual bool isStreamInitialized() = 0;
580
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100581 virtual void startMelComputation_l(const sp<audio_utils::MelProcessor>& processor);
582 virtual void stopMelComputation_l();
583
Eric Laurent81784c32012-11-19 14:55:58 -0800584protected:
585
586 // entry describing an effect being suspended in mSuspendedSessions keyed vector
587 class SuspendedSessionDesc : public RefBase {
588 public:
589 SuspendedSessionDesc() : mRefCount(0) {}
590
591 int mRefCount; // number of active suspend requests
592 effect_uuid_t mType; // effect type UUID
593 };
594
Andy Hungdae27702016-10-31 14:01:16 -0700595 void acquireWakeLock();
596 virtual void acquireWakeLock_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800597 void releaseWakeLock();
598 void releaseWakeLock_l();
Andy Hungd01b0f12016-11-07 16:10:30 -0800599 void updateWakeLockUids_l(const SortedVector<uid_t> &uids);
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800600 void getPowerManager_l();
Eric Laurentd8365c52017-07-16 15:27:05 -0700601 // suspend or restore effects of the specified type (or all if type is NULL)
602 // on a given session. The number of suspend requests is counted and restore
603 // occurs when all suspend requests are cancelled.
Eric Laurent81784c32012-11-19 14:55:58 -0800604 void setEffectSuspended_l(const effect_uuid_t *type,
605 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -0800606 audio_session_t sessionId);
Eric Laurentd8365c52017-07-16 15:27:05 -0700607 // updated mSuspendedSessions when an effect is suspended or restored
Eric Laurent81784c32012-11-19 14:55:58 -0800608 void updateSuspendedSessions_l(const effect_uuid_t *type,
609 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -0800610 audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800611 // check if some effects must be suspended when an effect chain is added
Andy Hungbd72c542023-06-20 18:56:17 -0700612 void checkSuspendOnAddEffectChain_l(const sp<IAfEffectChain>& chain);
Eric Laurent81784c32012-11-19 14:55:58 -0800613
Kevin Rocard069c2712018-03-29 19:09:14 -0700614 // sends the metadata of the active tracks to the HAL
Vlad Popa7e81cea2023-01-19 16:34:16 +0100615 struct MetadataUpdate {
616 std::vector<playback_track_metadata_v7_t> playbackMetadataUpdate;
617 std::vector<record_track_metadata_v7_t> recordMetadataUpdate;
618 };
619 virtual MetadataUpdate updateMetadata_l() = 0;
Kevin Rocard069c2712018-03-29 19:09:14 -0700620
Narayan Kamath014e7fa2013-10-14 15:03:38 +0100621 String16 getWakeLockTag();
622
Eric Laurent81784c32012-11-19 14:55:58 -0800623 virtual void preExit() { }
Andy Hung2ddee192015-12-18 17:34:44 -0800624 virtual void setMasterMono_l(bool mono __unused) { }
625 virtual bool requireMonoBlend() { return false; }
Eric Laurent81784c32012-11-19 14:55:58 -0800626
Andy Hung1c86ebe2018-05-29 20:29:08 -0700627 // called within the threadLoop to obtain timestamp from the HAL.
628 virtual status_t threadloop_getHalTimestamp_l(
629 ExtendedTimestamp *timestamp __unused) const {
630 return INVALID_OPERATION;
631 }
Andy Hungbd72c542023-06-20 18:56:17 -0700632public:
633// TODO(b/288339104) organize with publics
Eric Laurentd66d7a12021-07-13 13:35:32 +0200634 product_strategy_t getStrategyForStream(audio_stream_type_t stream) const;
Andy Hungbd72c542023-06-20 18:56:17 -0700635protected:
Eric Laurentd66d7a12021-07-13 13:35:32 +0200636
Eric Laurentb0463942022-12-20 16:31:10 +0100637 virtual void onHalLatencyModesChanged_l() {}
638
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700639 virtual void dumpInternals_l(int fd __unused, const Vector<String16>& args __unused)
640 { }
641 virtual void dumpTracks_l(int fd __unused, const Vector<String16>& args __unused) { }
642
643
Vlad Popae8d99472022-06-30 16:02:48 +0200644 friend class AudioFlinger; // for mEffectChains and mAudioManager
Eric Laurent81784c32012-11-19 14:55:58 -0800645
646 const type_t mType;
647
648 // Used by parameters, config events, addTrack_l, exit
649 Condition mWaitWorkCV;
650
651 const sp<AudioFlinger> mAudioFlinger;
Andy Hungcf10d742020-04-28 15:38:24 -0700652 ThreadMetrics mThreadMetrics;
653 const bool mIsOut;
Glenn Kasten9b58f632013-07-16 11:37:48 -0700654
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800655 // updated by PlaybackThread::readOutputParameters_l() or
656 // RecordThread::readInputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -0800657 uint32_t mSampleRate;
658 size_t mFrameCount; // output HAL, direct output, record
Eric Laurent81784c32012-11-19 14:55:58 -0800659 audio_channel_mask_t mChannelMask;
Glenn Kastenf6ed4232013-07-16 11:16:27 -0700660 uint32_t mChannelCount;
Eric Laurent81784c32012-11-19 14:55:58 -0800661 size_t mFrameSize;
Glenn Kasten97b7b752014-09-28 13:04:24 -0700662 // not HAL frame size, this is for output sink (to pipe to fast mixer)
Andy Hung463be252014-07-10 16:56:07 -0700663 audio_format_t mFormat; // Source format for Recording and
664 // Sink format for Playback.
665 // Sink format may be different than
666 // HAL format if Fastmixer is used.
667 audio_format_t mHALFormat;
Glenn Kasten70949c42013-08-06 07:40:12 -0700668 size_t mBufferSize; // HAL buffer size for read() or write()
jiabinc52b1ff2019-10-31 17:20:42 -0700669 AudioDeviceTypeAddrVector mOutDeviceTypeAddrs; // output device types and addresses
670 AudioDeviceTypeAddr mInDeviceTypeAddr; // input device type and address
Eric Laurent10351942014-05-08 18:49:52 -0700671 Vector< sp<ConfigEvent> > mConfigEvents;
Eric Laurent72e3f392015-05-20 14:43:50 -0700672 Vector< sp<ConfigEvent> > mPendingConfigEvents; // events awaiting system ready
Eric Laurent81784c32012-11-19 14:55:58 -0800673
674 // These fields are written and read by thread itself without lock or barrier,
jiabinc52b1ff2019-10-31 17:20:42 -0700675 // and read by other threads without lock or barrier via standby(), outDeviceTypes()
676 // and inDeviceType().
Eric Laurent81784c32012-11-19 14:55:58 -0800677 // Because of the absence of a lock or barrier, any other thread that reads
678 // these fields must use the information in isolation, or be prepared to deal
679 // with possibility that it might be inconsistent with other information.
Glenn Kasten4944acb2013-08-19 08:39:20 -0700680 bool mStandby; // Whether thread is currently in standby.
jiabinc52b1ff2019-10-31 17:20:42 -0700681
Eric Laurent296fb132015-05-01 11:38:42 -0700682 struct audio_patch mPatch;
jiabinc52b1ff2019-10-31 17:20:42 -0700683
Glenn Kastenf59497b2015-01-26 16:35:47 -0800684 audio_source_t mAudioSource;
Eric Laurent81784c32012-11-19 14:55:58 -0800685
686 const audio_io_handle_t mId;
Andy Hungbd72c542023-06-20 18:56:17 -0700687 Vector<sp<IAfEffectChain>> mEffectChains;
Eric Laurent81784c32012-11-19 14:55:58 -0800688
Glenn Kastend7dca052015-03-05 16:05:54 -0800689 static const int kThreadNameLength = 16; // prctl(PR_SET_NAME) limit
690 char mThreadName[kThreadNameLength]; // guaranteed NUL-terminated
Chris Ye6597d732020-02-28 22:38:25 -0800691 sp<os::IPowerManager> mPowerManager;
Eric Laurent81784c32012-11-19 14:55:58 -0800692 sp<IBinder> mWakeLockToken;
693 const sp<PMDeathRecipient> mDeathRecipient;
Glenn Kastend848eb42016-03-08 13:42:11 -0800694 // list of suspended effects per session and per type. The first (outer) vector is
695 // keyed by session ID, the second (inner) by type UUID timeLow field
Eric Laurentd8365c52017-07-16 15:27:05 -0700696 // Updated by updateSuspendedSessions_l() only.
Glenn Kastend848eb42016-03-08 13:42:11 -0800697 KeyedVector< audio_session_t, KeyedVector< int, sp<SuspendedSessionDesc> > >
Eric Laurent81784c32012-11-19 14:55:58 -0800698 mSuspendedSessions;
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -0700699 // TODO: add comment and adjust size as needed
Glenn Kastenab7d72f2013-02-27 09:05:28 -0800700 static const size_t kLogSize = 4 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -0800701 sp<NBLog::Writer> mNBLogWriter;
Eric Laurent72e3f392015-05-20 14:43:50 -0700702 bool mSystemReady;
Andy Hung818e7a32016-02-16 18:08:07 -0800703 ExtendedTimestamp mTimestamp;
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700704 TimestampVerifier< // For timestamp statistics.
705 int64_t /* frame count */, int64_t /* time ns */> mTimestampVerifier;
Dean Wheatley12473e92021-03-18 23:00:55 +1100706 // DIRECT and OFFLOAD threads should reset frame count to zero on stop/flush
707 // TODO: add confirmation checks:
708 // 1) DIRECT threads and linear PCM format really resets to 0?
709 // 2) Is frame count really valid if not linear pcm?
710 // 3) Are all 64 bits of position returned, not just lowest 32 bits?
jiabinc52b1ff2019-10-31 17:20:42 -0700711 // Timestamp corrected device should be a single device.
712 audio_devices_t mTimestampCorrectedDevice = AUDIO_DEVICE_NONE;
Andy Hung446f4df2019-02-21 12:26:41 -0800713
714 // ThreadLoop statistics per iteration.
715 int64_t mLastIoBeginNs = -1;
716 int64_t mLastIoEndNs = -1;
717
Andy Hung44d648b2022-04-08 17:33:40 -0700718 // ThreadSnapshot is thread-safe (internally locked)
719 mediautils::ThreadSnapshot mThreadSnapshot;
720
Andy Hung446f4df2019-02-21 12:26:41 -0800721 // This should be read under ThreadBase lock (if not on the threadLoop thread).
722 audio_utils::Statistics<double> mIoJitterMs{0.995 /* alpha */};
723 audio_utils::Statistics<double> mProcessTimeMs{0.995 /* alpha */};
Andy Hunge6c37112019-02-26 17:38:10 -0800724 audio_utils::Statistics<double> mLatencyMs{0.995 /* alpha */};
Robert Wu06db0a32021-08-10 19:05:34 +0000725 audio_utils::Statistics<double> mMonopipePipeDepthStats{0.999 /* alpha */};
Andy Hung446f4df2019-02-21 12:26:41 -0800726
Andy Hungd0979812019-02-21 15:51:44 -0800727 // Save the last count when we delivered statistics to mediametrics.
728 int64_t mLastRecordedTimestampVerifierN = 0;
729 int64_t mLastRecordedTimeNs = 0; // BOOTTIME to include suspend.
730
Andy Hungc8fddf32018-08-08 18:32:37 -0700731 bool mIsMsdDevice = false;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800732 // A condition that must be evaluated by the thread loop has changed and
733 // we must not wait for async write callback in the thread loop before evaluating it
734 bool mSignalPending;
Andy Hungdae27702016-10-31 14:01:16 -0700735
Andy Hung8946a282018-04-19 20:04:56 -0700736#ifdef TEE_SINK
737 NBAIO_Tee mTee;
738#endif
Andy Hungdae27702016-10-31 14:01:16 -0700739 // ActiveTracks is a sorted vector of track type T representing the
740 // active tracks of threadLoop() to be considered by the locked prepare portion.
741 // ActiveTracks should be accessed with the ThreadBase lock held.
742 //
743 // During processing and I/O, the threadLoop does not hold the lock;
744 // hence it does not directly use ActiveTracks. Care should be taken
745 // to hold local strong references or defer removal of tracks
746 // if the threadLoop may still be accessing those tracks due to mix, etc.
747 //
748 // This class updates power information appropriately.
749 //
750
751 template <typename T>
752 class ActiveTracks {
753 public:
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700754 explicit ActiveTracks(SimpleLog *localLog = nullptr)
Andy Hungdae27702016-10-31 14:01:16 -0700755 : mActiveTracksGeneration(0)
756 , mLastActiveTracksGeneration(0)
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700757 , mLocalLog(localLog)
Andy Hungdae27702016-10-31 14:01:16 -0700758 { }
759
760 ~ActiveTracks() {
761 ALOGW_IF(!mActiveTracks.isEmpty(),
762 "ActiveTracks should be empty in destructor");
763 }
764 // returns the last track added (even though it may have been
765 // subsequently removed from ActiveTracks).
766 //
767 // Used for DirectOutputThread to ensure a flush is called when transitioning
768 // to a new track (even though it may be on the same session).
769 // Used for OffloadThread to ensure that volume and mixer state is
770 // taken from the latest track added.
771 //
772 // The latest track is saved with a weak pointer to prevent keeping an
773 // otherwise useless track alive. Thus the function will return nullptr
774 // if the latest track has subsequently been removed and destroyed.
775 sp<T> getLatest() {
776 return mLatestActiveTrack.promote();
777 }
778
779 // SortedVector methods
780 ssize_t add(const sp<T> &track);
781 ssize_t remove(const sp<T> &track);
782 size_t size() const {
783 return mActiveTracks.size();
784 }
Eric Tan39ec8d62018-07-24 09:49:29 -0700785 bool isEmpty() const {
786 return mActiveTracks.isEmpty();
787 }
Andy Hungdae27702016-10-31 14:01:16 -0700788 ssize_t indexOf(const sp<T>& item) {
789 return mActiveTracks.indexOf(item);
790 }
791 sp<T> operator[](size_t index) const {
792 return mActiveTracks[index];
793 }
794 typename SortedVector<sp<T>>::iterator begin() {
795 return mActiveTracks.begin();
796 }
797 typename SortedVector<sp<T>>::iterator end() {
798 return mActiveTracks.end();
799 }
800
801 // Due to Binder recursion optimization, clear() and updatePowerState()
802 // cannot be called from a Binder thread because they may call back into
803 // the original calling process (system server) for BatteryNotifier
804 // (which requires a Java environment that may not be present).
805 // Hence, call clear() and updatePowerState() only from the
806 // ThreadBase thread.
807 void clear();
808 // periodically called in the threadLoop() to update power state uids.
Andy Hung71ba4b32022-10-06 12:09:49 -0700809 void updatePowerState(const sp<ThreadBase>& thread, bool force = false);
Andy Hungdae27702016-10-31 14:01:16 -0700810
Kevin Rocardc86a7f72018-04-03 09:00:09 -0700811 /** @return true if one or move active tracks was added or removed since the
Jasmine Chaeaa10e42021-05-11 10:11:14 +0800812 * last time this function was called or the vector was created.
813 * true if volume of one of active tracks was changed.
814 */
Kevin Rocard069c2712018-03-29 19:09:14 -0700815 bool readAndClearHasChanged();
816
Eric Laurentdda206a2022-07-08 17:28:35 +0200817 /** Force updating track metadata to audio HAL stream next time
818 * readAndClearHasChanged() is called.
819 */
820 void setHasChanged() { mHasChanged = true; }
821
Andy Hungdae27702016-10-31 14:01:16 -0700822 private:
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700823 void logTrack(const char *funcName, const sp<T> &track) const;
824
Andy Hungd01b0f12016-11-07 16:10:30 -0800825 SortedVector<uid_t> getWakeLockUids() {
826 SortedVector<uid_t> wakeLockUids;
Andy Hungdae27702016-10-31 14:01:16 -0700827 for (const sp<T> &track : mActiveTracks) {
828 wakeLockUids.add(track->uid());
829 }
830 return wakeLockUids; // moved by underlying SharedBuffer
831 }
832
833 std::map<uid_t, std::pair<ssize_t /* previous */, ssize_t /* current */>>
834 mBatteryCounter;
835 SortedVector<sp<T>> mActiveTracks;
836 int mActiveTracksGeneration;
837 int mLastActiveTracksGeneration;
838 wp<T> mLatestActiveTrack; // latest track added to ActiveTracks
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700839 SimpleLog * const mLocalLog;
Kevin Rocardc86a7f72018-04-03 09:00:09 -0700840 // If the vector has changed since last call to readAndClearHasChanged
Kevin Rocard069c2712018-03-29 19:09:14 -0700841 bool mHasChanged = false;
Andy Hungdae27702016-10-31 14:01:16 -0700842 };
Andy Hung293558a2017-03-21 12:19:20 -0700843
844 SimpleLog mLocalLog;
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700845
846private:
847 void dumpBase_l(int fd, const Vector<String16>& args);
848 void dumpEffectChains_l(int fd, const Vector<String16>& args);
Eric Laurent81784c32012-11-19 14:55:58 -0800849};
850
851// --- PlaybackThread ---
Eric Laurent6acd1d42017-01-04 14:23:29 -0800852class PlaybackThread : public ThreadBase, public StreamOutHalInterfaceCallback,
jiabinf6eb4c32020-02-25 14:06:25 -0800853 public VolumeInterface, public StreamOutHalInterfaceEventCallback {
Andy Hung3ff4b552023-06-26 19:20:57 -0700854 // TODO(b/288339104) remove friends
855 friend class OutputTrack;
856 friend class Track;
Eric Laurent81784c32012-11-19 14:55:58 -0800857public:
858
Eric Laurent81784c32012-11-19 14:55:58 -0800859 enum mixer_state {
860 MIXER_IDLE, // no active tracks
861 MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready
Eric Laurentbfb1b832013-01-07 09:53:42 -0800862 MIXER_TRACKS_READY, // at least one active track, and at least one track has data
863 MIXER_DRAIN_TRACK, // drain currently playing track
864 MIXER_DRAIN_ALL, // fully drain the hardware
Eric Laurent81784c32012-11-19 14:55:58 -0800865 // standby mode does not have an enum value
866 // suspend by audio policy manager is orthogonal to mixer state
867 };
868
Eric Laurente93cc032016-05-05 10:15:10 -0700869 // retry count before removing active track in case of underrun on offloaded thread:
870 // we need to make sure that AudioTrack client has enough time to send large buffers
871 //FIXME may be more appropriate if expressed in time units. Need to revise how underrun is
872 // handled for offloaded tracks
873 static const int8_t kMaxTrackRetriesOffload = 20;
874 static const int8_t kMaxTrackStartupRetriesOffload = 100;
875 static const int8_t kMaxTrackStopRetriesOffload = 2;
Andy Hung8ed196a2018-01-05 13:21:11 -0800876 static constexpr uint32_t kMaxTracksPerUid = 40;
Andy Hung1bc088a2018-02-09 15:57:31 -0800877 static constexpr size_t kMaxTracks = 256;
Eric Laurente93cc032016-05-05 10:15:10 -0700878
rago1bb90822017-05-02 18:31:48 -0700879 // Maximum delay (in nanoseconds) for upcoming buffers in suspend mode, otherwise
880 // if delay is greater, the estimated time for timeLoopNextNs is reset.
881 // This allows for catch-up to be done for small delays, while resetting the estimate
882 // for initial conditions or large delays.
883 static const nsecs_t kMaxNextBufferDelayNs = 100000000;
884
Eric Laurent81784c32012-11-19 14:55:58 -0800885 PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurentf1f22e72021-07-13 14:04:14 +0200886 audio_io_handle_t id, type_t type, bool systemReady,
887 audio_config_base_t *mixerConfig = nullptr);
Eric Laurent81784c32012-11-19 14:55:58 -0800888 virtual ~PlaybackThread();
889
Eric Laurent81784c32012-11-19 14:55:58 -0800890 // Thread virtuals
Eric Laurent81784c32012-11-19 14:55:58 -0800891 virtual bool threadLoop();
892
893 // RefBase
894 virtual void onFirstRef();
895
Eric Laurent4c415062016-06-17 16:14:16 -0700896 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
897 audio_session_t sessionId);
898
Eric Laurent81784c32012-11-19 14:55:58 -0800899protected:
900 // Code snippets that were lifted up out of threadLoop()
901 virtual void threadLoop_mix() = 0;
902 virtual void threadLoop_sleepTime() = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800903 virtual ssize_t threadLoop_write();
904 virtual void threadLoop_drain();
Eric Laurent81784c32012-11-19 14:55:58 -0800905 virtual void threadLoop_standby();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800906 virtual void threadLoop_exit();
Andy Hung3ff4b552023-06-26 19:20:57 -0700907 virtual void threadLoop_removeTracks(const Vector<sp<IAfTrack>>& tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -0800908
909 // prepareTracks_l reads and writes mActiveTracks, and returns
910 // the pending set of tracks to remove via Vector 'tracksToRemove'. The caller
911 // is responsible for clearing or destroying this Vector later on, when it
912 // is safe to do so. That will drop the final ref count and destroy the tracks.
Andy Hung3ff4b552023-06-26 19:20:57 -0700913 virtual mixer_state prepareTracks_l(Vector<sp<IAfTrack>>* tracksToRemove) = 0;
914 void removeTracks_l(const Vector<sp<IAfTrack>>& tracksToRemove);
Eric Laurenteab90452019-06-24 15:17:46 -0700915 status_t handleVoipVolume_l(float *volume);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800916
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700917 // StreamOutHalInterfaceCallback implementation
918 virtual void onWriteReady();
919 virtual void onDrainReady();
920 virtual void onError();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800921
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700922 void resetWriteBlocked(uint32_t sequence);
923 void resetDraining(uint32_t sequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800924
925 virtual bool waitingAsyncCallback();
926 virtual bool waitingAsyncCallback_l();
927 virtual bool shouldStandby_l();
Haynes Mathew George4c6a4332014-01-15 12:31:39 -0800928 virtual void onAddNewTrack_l();
Haynes Mathew George4527b9e2016-07-07 19:54:17 -0700929 void onAsyncError(); // error reported by AsyncCallbackThread
Eric Laurent81784c32012-11-19 14:55:58 -0800930
jiabinf6eb4c32020-02-25 14:06:25 -0800931 // StreamHalInterfaceCodecFormatCallback implementation
932 void onCodecFormatChanged(
933 const std::basic_string<uint8_t>& metadataBs) override;
934
Eric Laurent81784c32012-11-19 14:55:58 -0800935 // ThreadBase virtuals
936 virtual void preExit();
937
Eric Laurent64667972016-03-30 18:19:46 -0700938 virtual bool keepWakeLock() const { return true; }
Andy Hungdae27702016-10-31 14:01:16 -0700939 virtual void acquireWakeLock_l() {
940 ThreadBase::acquireWakeLock_l();
941 mActiveTracks.updatePowerState(this, true /* force */);
942 }
Eric Laurent64667972016-03-30 18:19:46 -0700943
Eric Laurentb3f315a2021-07-13 15:09:05 +0200944 virtual void checkOutputStageEffects() {}
Eric Laurent6f9534f2022-05-03 18:15:04 +0200945 virtual void setHalLatencyMode_l() {}
946
Eric Laurentb3f315a2021-07-13 15:09:05 +0200947
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700948 void dumpInternals_l(int fd, const Vector<String16>& args) override;
949 void dumpTracks_l(int fd, const Vector<String16>& args) override;
950
Eric Laurent81784c32012-11-19 14:55:58 -0800951public:
952
953 virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; }
954
955 // return estimated latency in milliseconds, as reported by HAL
956 uint32_t latency() const;
957 // same, but lock must already be held
Eric Laurent6b446ce2019-12-13 10:56:31 -0800958 uint32_t latency_l() const override;
Eric Laurent81784c32012-11-19 14:55:58 -0800959
Eric Laurent6acd1d42017-01-04 14:23:29 -0800960 // VolumeInterface
961 virtual void setMasterVolume(float value);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +0100962 virtual void setMasterBalance(float balance);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800963 virtual void setMasterMute(bool muted);
964 virtual void setStreamVolume(audio_stream_type_t stream, float value);
965 virtual void setStreamMute(audio_stream_type_t stream, bool muted);
966 virtual float streamVolume(audio_stream_type_t stream) const;
Eric Laurent81784c32012-11-19 14:55:58 -0800967
Eric Laurent6b446ce2019-12-13 10:56:31 -0800968 void setVolumeForOutput_l(float left, float right) const override;
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +0900969
Andy Hung3ff4b552023-06-26 19:20:57 -0700970 sp<IAfTrack> createTrack_l(
Andy Hungd65869f2023-06-27 17:05:02 -0700971 const sp<Client>& client,
Eric Laurent81784c32012-11-19 14:55:58 -0800972 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700973 const audio_attributes_t& attr,
Eric Laurent21da6472017-11-09 16:29:26 -0800974 uint32_t *sampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -0800975 audio_format_t format,
976 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -0800977 size_t *pFrameCount,
Eric Laurent21da6472017-11-09 16:29:26 -0800978 size_t *pNotificationFrameCount,
979 uint32_t notificationsPerBuffer,
980 float speed,
Eric Laurent81784c32012-11-19 14:55:58 -0800981 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -0800982 audio_session_t sessionId,
Eric Laurent05067782016-06-01 18:27:28 -0700983 audio_output_flags_t *flags,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700984 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +0000985 const AttributionSourceState& attributionSource,
Eric Laurent81784c32012-11-19 14:55:58 -0800986 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800987 status_t *status /*non-NULL*/,
jiabinf6eb4c32020-02-25 14:06:25 -0800988 audio_port_handle_t portId,
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200989 const sp<media::IAudioTrackCallback>& callback,
jiabinc658e452022-10-21 20:52:21 +0000990 bool isSpatialized,
991 bool isBitPerfect);
Eric Laurent81784c32012-11-19 14:55:58 -0800992
993 AudioStreamOut* getOutput() const;
994 AudioStreamOut* clearOutput();
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700995 virtual sp<StreamHalInterface> stream() const;
Eric Laurent81784c32012-11-19 14:55:58 -0800996
997 // a very large number of suspend() will eventually wraparound, but unlikely
998 void suspend() { (void) android_atomic_inc(&mSuspended); }
999 void restore()
1000 {
1001 // if restore() is done without suspend(), get back into
1002 // range so that the next suspend() will operate correctly
1003 if (android_atomic_dec(&mSuspended) <= 0) {
1004 android_atomic_release_store(0, &mSuspended);
1005 }
1006 }
1007 bool isSuspended() const
1008 { return android_atomic_acquire_load(&mSuspended) > 0; }
1009
1010 virtual String8 getParameters(const String8& keys);
Mikhail Naganov88536df2021-07-26 17:30:29 -07001011 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -07001012 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Kévin PETIT377b2ec2014-02-03 12:35:36 +00001013 status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames);
Andy Hung010a1a12014-03-13 13:57:33 -07001014 // Consider also removing and passing an explicit mMainBuffer initialization
Andy Hung3ff4b552023-06-26 19:20:57 -07001015 // parameter to AF::IAfTrack::Track().
Andy Hung319587b2023-05-23 14:01:03 -07001016 float *sinkBuffer() const {
1017 return reinterpret_cast<float *>(mSinkBuffer); };
Eric Laurent81784c32012-11-19 14:55:58 -08001018
1019 virtual void detachAuxEffect_l(int effectId);
Andy Hung3ff4b552023-06-26 19:20:57 -07001020 status_t attachAuxEffect(const sp<IAfTrack>& track,
Eric Laurent81784c32012-11-19 14:55:58 -08001021 int EffectId);
Andy Hung3ff4b552023-06-26 19:20:57 -07001022 status_t attachAuxEffect_l(const sp<IAfTrack>& track,
Eric Laurent81784c32012-11-19 14:55:58 -08001023 int EffectId);
1024
Andy Hungbd72c542023-06-20 18:56:17 -07001025 virtual status_t addEffectChain_l(const sp<IAfEffectChain>& chain);
1026 virtual size_t removeEffectChain_l(const sp<IAfEffectChain>& chain);
Andy Hungc3d62f92019-03-14 13:38:51 -07001027 uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
1028 return ThreadBase::hasAudioSession_l(sessionId, mTracks);
1029 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001030 virtual product_strategy_t getStrategyForSession_l(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -08001031
1032
Andy Hung068e08e2023-05-15 19:02:55 -07001033 status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) override;
1034 bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const override;
Glenn Kastenfb1fdc92013-07-10 17:03:19 -07001035
1036 // called with AudioFlinger lock held
Eric Laurent13084622016-05-17 10:51:49 -07001037 bool invalidateTracks_l(audio_stream_type_t streamType);
jiabinc44b3462022-12-08 12:52:31 -08001038 bool invalidateTracks_l(std::set<audio_port_handle_t>& portIds);
Haynes Mathew George05317d22016-05-03 16:34:26 -07001039 virtual void invalidateTracks(audio_stream_type_t streamType);
jiabinc44b3462022-12-08 12:52:31 -08001040 // Invalidate tracks by a set of port ids. The port id will be removed from
1041 // the given set if the corresponding track is found and invalidated.
1042 virtual void invalidateTracks(std::set<audio_port_handle_t>& portIds);
Eric Laurent81784c32012-11-19 14:55:58 -08001043
Glenn Kasten9b58f632013-07-16 11:37:48 -07001044 virtual size_t frameCount() const { return mNormalFrameCount; }
1045
Eric Laurentf1f22e72021-07-13 14:04:14 +02001046 audio_channel_mask_t mixerChannelMask() const override {
1047 return mMixerChannelMask;
1048 }
1049
Eric Laurent83b88082014-06-20 18:31:16 -07001050 status_t getTimestamp_l(AudioTimestamp& timestamp);
1051
Andy Hung3ff4b552023-06-26 19:20:57 -07001052 void addPatchTrack(const sp<IAfPatchTrack>& track);
1053 void deletePatchTrack(const sp<IAfPatchTrack>& track);
Eric Laurent83b88082014-06-20 18:31:16 -07001054
Mikhail Naganovdc769682018-05-04 15:34:08 -07001055 virtual void toAudioPortConfig(struct audio_port_config *config);
Eric Laurentaccc1472013-09-20 09:36:34 -07001056
Andy Hung10cbff12017-02-21 17:30:14 -08001057 // Return the asynchronous signal wait time.
1058 virtual int64_t computeWaitTimeNs_l() const { return INT64_MAX; }
Andy Hung1bc088a2018-02-09 15:57:31 -08001059 // returns true if the track is allowed to be added to the thread.
1060 virtual bool isTrackAllowed_l(
1061 audio_channel_mask_t channelMask __unused,
1062 audio_format_t format __unused,
1063 audio_session_t sessionId __unused,
1064 uid_t uid) const {
1065 return trackCountForUid_l(uid) < PlaybackThread::kMaxTracksPerUid
1066 && mTracks.size() < PlaybackThread::kMaxTracks;
1067 }
1068
Andy Hungc8fddf32018-08-08 18:32:37 -07001069 bool isTimestampCorrectionEnabled() const override {
jiabinc52b1ff2019-10-31 17:20:42 -07001070 return audio_is_output_devices(mTimestampCorrectedDevice)
1071 && outDeviceTypes().count(mTimestampCorrectedDevice) != 0;
Andy Hungc8fddf32018-08-08 18:32:37 -07001072 }
jiabinc52b1ff2019-10-31 17:20:42 -07001073
Jasmine Chaeaa10e42021-05-11 10:11:14 +08001074 virtual bool isStreamInitialized() {
1075 return !(mOutput == nullptr || mOutput->stream == nullptr);
1076 }
1077
jiabineb3bda02020-06-30 14:07:03 -07001078 audio_channel_mask_t hapticChannelMask() const override {
1079 return mHapticChannelMask;
1080 }
1081 bool supportsHapticPlayback() const {
1082 return (mHapticChannelMask & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE;
1083 }
1084
Eric Laurent74c38dc2020-12-23 18:19:44 +01001085 void setDownStreamPatch(const struct audio_patch *patch) {
1086 Mutex::Autolock _l(mLock);
1087 mDownStreamPatch = *patch;
1088 }
1089
Andy Hung3ff4b552023-06-26 19:20:57 -07001090 IAfTrack* getTrackById_l(audio_port_handle_t trackId);
jiabinf042b9b2021-05-07 23:46:28 +00001091
Eric Laurentb3f315a2021-07-13 15:09:05 +02001092 bool hasMixer() const {
Eric Laurent1c5e2e32021-08-18 18:50:28 +02001093 return mType == MIXER || mType == DUPLICATING || mType == SPATIALIZER;
Eric Laurentb3f315a2021-07-13 15:09:05 +02001094 }
Eric Laurent6f9534f2022-05-03 18:15:04 +02001095
1096 virtual status_t setRequestedLatencyMode(
1097 audio_latency_mode_t mode __unused) { return INVALID_OPERATION; }
1098
1099 virtual status_t getSupportedLatencyModes(
1100 std::vector<audio_latency_mode_t>* modes __unused) {
1101 return INVALID_OPERATION;
1102 }
1103
Eric Laurentb0463942022-12-20 16:31:10 +01001104 virtual status_t setBluetoothVariableLatencyEnabled(bool enabled __unused) {
1105 return INVALID_OPERATION;
1106 }
Eric Laurent01eb1642022-12-16 11:45:07 +01001107
Vlad Popa6fbbfbf2023-02-22 15:05:43 +01001108 void startMelComputation_l(const sp<audio_utils::MelProcessor>& processor) override;
1109 void stopMelComputation_l() override;
Vlad Popab042ee62022-10-20 18:05:00 +02001110
Eric Laurent19952e12023-04-20 10:08:29 +02001111 void setStandby() {
1112 Mutex::Autolock _l(mLock);
1113 setStandby_l();
1114 }
1115
1116 void setStandby_l() {
1117 mStandby = true;
1118 mHalStarted = false;
1119 mKernelPositionOnStandby =
1120 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
1121 }
1122
1123 bool waitForHalStart() {
1124 Mutex::Autolock _l(mLock);
1125 static const nsecs_t kWaitHalTimeoutNs = seconds(2);
1126 nsecs_t endWaitTimetNs = systemTime() + kWaitHalTimeoutNs;
1127 while (!mHalStarted) {
1128 nsecs_t timeNs = systemTime();
1129 if (timeNs >= endWaitTimetNs) {
1130 break;
1131 }
1132 nsecs_t waitTimeLeftNs = endWaitTimetNs - timeNs;
1133 mWaitHalStartCV.waitRelative(mLock, waitTimeLeftNs);
1134 }
1135 return mHalStarted;
1136 }
Eric Laurent81784c32012-11-19 14:55:58 -08001137protected:
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001138 // updated by readOutputParameters_l()
Glenn Kasten9b58f632013-07-16 11:37:48 -07001139 size_t mNormalFrameCount; // normal mixer and effects
1140
Andy Hung08fb1742015-05-31 23:22:10 -07001141 bool mThreadThrottle; // throttle the thread processing
Andy Hung40eb1a12015-06-18 13:42:02 -07001142 uint32_t mThreadThrottleTimeMs; // throttle time for MIXER threads
1143 uint32_t mThreadThrottleEndMs; // notify once per throttling
Andy Hung08fb1742015-05-31 23:22:10 -07001144 uint32_t mHalfBufferMs; // half the buffer size in milliseconds
1145
Andy Hung010a1a12014-03-13 13:57:33 -07001146 void* mSinkBuffer; // frame size aligned sink buffer
Eric Laurent81784c32012-11-19 14:55:58 -08001147
Andy Hung98ef9782014-03-04 14:46:50 -08001148 // TODO:
1149 // Rearrange the buffer info into a struct/class with
1150 // clear, copy, construction, destruction methods.
1151 //
1152 // mSinkBuffer also has associated with it:
1153 //
1154 // mSinkBufferSize: Sink Buffer Size
1155 // mFormat: Sink Buffer Format
1156
Andy Hung69aed5f2014-02-25 17:24:40 -08001157 // Mixer Buffer (mMixerBuffer*)
1158 //
1159 // In the case of floating point or multichannel data, which is not in the
1160 // sink format, it is required to accumulate in a higher precision or greater channel count
1161 // buffer before downmixing or data conversion to the sink buffer.
1162
1163 // Set to "true" to enable the Mixer Buffer otherwise mixer output goes to sink buffer.
1164 bool mMixerBufferEnabled;
1165
1166 // Storage, 32 byte aligned (may make this alignment a requirement later).
1167 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
1168 void* mMixerBuffer;
1169
1170 // Size of mMixerBuffer in bytes: mNormalFrameCount * #channels * sampsize.
1171 size_t mMixerBufferSize;
1172
1173 // The audio format of mMixerBuffer. Set to AUDIO_FORMAT_PCM_(FLOAT|16_BIT) only.
1174 audio_format_t mMixerBufferFormat;
1175
1176 // An internal flag set to true by MixerThread::prepareTracks_l()
1177 // when mMixerBuffer contains valid data after mixing.
1178 bool mMixerBufferValid;
1179
Andy Hung98ef9782014-03-04 14:46:50 -08001180 // Effects Buffer (mEffectsBuffer*)
1181 //
1182 // In the case of effects data, which is not in the sink format,
1183 // it is required to accumulate in a different buffer before data conversion
1184 // to the sink buffer.
1185
1186 // Set to "true" to enable the Effects Buffer otherwise effects output goes to sink buffer.
1187 bool mEffectBufferEnabled;
1188
1189 // Storage, 32 byte aligned (may make this alignment a requirement later).
1190 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
1191 void* mEffectBuffer;
1192
1193 // Size of mEffectsBuffer in bytes: mNormalFrameCount * #channels * sampsize.
1194 size_t mEffectBufferSize;
1195
1196 // The audio format of mEffectsBuffer. Set to AUDIO_FORMAT_PCM_16_BIT only.
1197 audio_format_t mEffectBufferFormat;
1198
1199 // An internal flag set to true by MixerThread::prepareTracks_l()
1200 // when mEffectsBuffer contains valid data after mixing.
1201 //
1202 // When this is set, all mixer data is routed into the effects buffer
1203 // for any processing (including output processing).
1204 bool mEffectBufferValid;
1205
jiabinc658e452022-10-21 20:52:21 +00001206 // Set to "true" to enable when data has already copied to sink
1207 bool mHasDataCopiedToSinkBuffer = false;
1208
Eric Laurentb62d0362021-10-26 17:40:18 +02001209 // Frame size aligned buffer used as input and output to all post processing effects
1210 // except the Spatializer in a SPATIALIZER thread. Non spatialized tracks are mixed into
1211 // this buffer so that post processing effects can be applied.
1212 void* mPostSpatializerBuffer = nullptr;
1213
1214 // Size of mPostSpatializerBuffer in bytes
1215 size_t mPostSpatializerBufferSize;
Eric Laurent39095982021-08-24 18:29:27 +02001216
1217
Eric Laurent81784c32012-11-19 14:55:58 -08001218 // suspend count, > 0 means suspended. While suspended, the thread continues to pull from
1219 // tracks and mix, but doesn't write to HAL. A2DP and SCO HAL implementations can't handle
1220 // concurrent use of both of them, so Audio Policy Service suspends one of the threads to
1221 // workaround that restriction.
1222 // 'volatile' means accessed via atomic operations and no lock.
1223 volatile int32_t mSuspended;
1224
Andy Hung818e7a32016-02-16 18:08:07 -08001225 int64_t mBytesWritten;
yucliu91503922022-07-20 17:40:39 -07001226 std::atomic<int64_t> mFramesWritten; // not reset on standby
Dean Wheatley12473e92021-03-18 23:00:55 +11001227 int64_t mLastFramesWritten = -1; // track changes in timestamp
1228 // server frames written.
Andy Hung238fa3d2016-07-28 10:53:22 -07001229 int64_t mSuspendedFrames; // not reset on standby
jiabin245cdd92018-12-07 17:55:15 -08001230
1231 // mHapticChannelMask and mHapticChannelCount will only be valid when the thread support
1232 // haptic playback.
1233 audio_channel_mask_t mHapticChannelMask = AUDIO_CHANNEL_NONE;
1234 uint32_t mHapticChannelCount = 0;
Eric Laurentf1f22e72021-07-13 14:04:14 +02001235
1236 audio_channel_mask_t mMixerChannelMask = AUDIO_CHANNEL_NONE;
1237
Eric Laurent81784c32012-11-19 14:55:58 -08001238private:
1239 // mMasterMute is in both PlaybackThread and in AudioFlinger. When a
1240 // PlaybackThread needs to find out if master-muted, it checks it's local
1241 // copy rather than the one in AudioFlinger. This optimization saves a lock.
1242 bool mMasterMute;
1243 void setMasterMute_l(bool muted) { mMasterMute = muted; }
Dean Wheatley12473e92021-03-18 23:00:55 +11001244
1245 auto discontinuityForStandbyOrFlush() const { // call on threadLoop or with lock.
1246 return ((mType == DIRECT && !audio_is_linear_pcm(mFormat))
1247 || mType == OFFLOAD)
1248 ? mTimestampVerifier.DISCONTINUITY_MODE_ZERO
1249 : mTimestampVerifier.DISCONTINUITY_MODE_CONTINUOUS;
1250 }
1251
Eric Laurent81784c32012-11-19 14:55:58 -08001252protected:
Andy Hung3ff4b552023-06-26 19:20:57 -07001253 ActiveTracks<IAfTrack> mActiveTracks;
Eric Laurent81784c32012-11-19 14:55:58 -08001254
Eric Laurent81784c32012-11-19 14:55:58 -08001255 // Time to sleep between cycles when:
1256 virtual uint32_t activeSleepTimeUs() const; // mixer state MIXER_TRACKS_ENABLED
1257 virtual uint32_t idleSleepTimeUs() const = 0; // mixer state MIXER_IDLE
1258 virtual uint32_t suspendSleepTimeUs() const = 0; // audio policy manager suspended us
1259 // No sleep when mixer state == MIXER_TRACKS_READY; relies on audio HAL stream->write()
1260 // No sleep in standby mode; waits on a condition
1261
1262 // Code snippets that are temporarily lifted up out of threadLoop() until the merge
1263 void checkSilentMode_l();
1264
1265 // Non-trivial for DUPLICATING only
1266 virtual void saveOutputTracks() { }
1267 virtual void clearOutputTracks() { }
1268
1269 // Cache various calculated values, at threadLoop() entry and after a parameter change
1270 virtual void cacheParameters_l();
Eric Laurentb3f315a2021-07-13 15:09:05 +02001271 void setCheckOutputStageEffects() override {
1272 mCheckOutputStageEffects.store(true);
1273 }
Eric Laurent81784c32012-11-19 14:55:58 -08001274
1275 virtual uint32_t correctLatency_l(uint32_t latency) const;
1276
Eric Laurent1c333e22014-05-20 10:48:17 -07001277 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1278 audio_patch_handle_t *handle);
1279 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
1280
Phil Burk6fc2a7c2015-04-30 16:08:10 -07001281 bool usesHwAvSync() const { return (mType == DIRECT) && (mOutput != NULL)
1282 && mHwSupportsPause
1283 && (mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC); }
Eric Laurent0f7b5f22014-12-19 10:43:21 -08001284
Andy Hung1bc088a2018-02-09 15:57:31 -08001285 uint32_t trackCountForUid_l(uid_t uid) const;
Eric Laurentad7dd962016-09-22 12:38:37 -07001286
jiabineb3bda02020-06-30 14:07:03 -07001287 void invalidateTracksForAudioSession_l(
1288 audio_session_t sessionId) const override {
1289 ThreadBase::invalidateTracksForAudioSession_l(sessionId, mTracks);
1290 }
1291
Eric Laurent81784c32012-11-19 14:55:58 -08001292private:
1293
1294 friend class AudioFlinger; // for numerous
1295
Mikhail Naganovbf493082017-04-17 17:37:12 -07001296 DISALLOW_COPY_AND_ASSIGN(PlaybackThread);
Eric Laurent81784c32012-11-19 14:55:58 -08001297
Andy Hung3ff4b552023-06-26 19:20:57 -07001298 status_t addTrack_l(const sp<IAfTrack>& track);
1299 bool destroyTrack_l(const sp<IAfTrack>& track);
1300 void removeTrack_l(const sp<IAfTrack>& track);
Eric Laurent81784c32012-11-19 14:55:58 -08001301
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001302 void readOutputParameters_l();
Vlad Popa7e81cea2023-01-19 16:34:16 +01001303 MetadataUpdate updateMetadata_l() final;
Kevin Rocardc86a7f72018-04-03 09:00:09 -07001304 virtual void sendMetadataToBackend_l(const StreamOutHalInterface::SourceMetadata& metadata);
Eric Laurent81784c32012-11-19 14:55:58 -08001305
Dean Wheatley12473e92021-03-18 23:00:55 +11001306 void collectTimestamps_l();
1307
Andy Hungc0691382018-09-12 18:01:57 -07001308 // The Tracks class manages tracks added and removed from the Thread.
Andy Hung1bc088a2018-02-09 15:57:31 -08001309 template <typename T>
1310 class Tracks {
1311 public:
Andy Hung71ba4b32022-10-06 12:09:49 -07001312 explicit Tracks(bool saveDeletedTrackIds) :
Andy Hungc0691382018-09-12 18:01:57 -07001313 mSaveDeletedTrackIds(saveDeletedTrackIds) { }
Andy Hung1bc088a2018-02-09 15:57:31 -08001314
1315 // SortedVector methods
Andy Hungc0691382018-09-12 18:01:57 -07001316 ssize_t add(const sp<T> &track) {
1317 const ssize_t index = mTracks.add(track);
1318 LOG_ALWAYS_FATAL_IF(index < 0, "cannot add track");
1319 return index;
1320 }
Andy Hung1bc088a2018-02-09 15:57:31 -08001321 ssize_t remove(const sp<T> &track);
1322 size_t size() const {
1323 return mTracks.size();
1324 }
1325 bool isEmpty() const {
1326 return mTracks.isEmpty();
1327 }
1328 ssize_t indexOf(const sp<T> &item) {
1329 return mTracks.indexOf(item);
1330 }
1331 sp<T> operator[](size_t index) const {
1332 return mTracks[index];
1333 }
1334 typename SortedVector<sp<T>>::iterator begin() {
1335 return mTracks.begin();
1336 }
1337 typename SortedVector<sp<T>>::iterator end() {
1338 return mTracks.end();
1339 }
1340
Andy Hung71ba4b32022-10-06 12:09:49 -07001341 size_t processDeletedTrackIds(const std::function<void(int)>& f) {
Andy Hungc0691382018-09-12 18:01:57 -07001342 for (const int trackId : mDeletedTrackIds) {
1343 f(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08001344 }
Andy Hungc0691382018-09-12 18:01:57 -07001345 return mDeletedTrackIds.size();
Andy Hung1bc088a2018-02-09 15:57:31 -08001346 }
1347
Andy Hungc0691382018-09-12 18:01:57 -07001348 void clearDeletedTrackIds() { mDeletedTrackIds.clear(); }
Andy Hung1bc088a2018-02-09 15:57:31 -08001349
1350 private:
Andy Hungc0691382018-09-12 18:01:57 -07001351 // Tracks pending deletion for MIXER type threads
1352 const bool mSaveDeletedTrackIds; // true to enable tracking
1353 std::set<int> mDeletedTrackIds;
Andy Hung1bc088a2018-02-09 15:57:31 -08001354
1355 SortedVector<sp<T>> mTracks; // wrapped SortedVector.
1356 };
1357
Andy Hung3ff4b552023-06-26 19:20:57 -07001358 Tracks<IAfTrack> mTracks;
Andy Hung1bc088a2018-02-09 15:57:31 -08001359
Eric Laurent223fd5c2014-11-11 13:43:36 -08001360 stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
Eric Laurent81784c32012-11-19 14:55:58 -08001361 AudioStreamOut *mOutput;
1362
1363 float mMasterVolume;
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001364 std::atomic<float> mMasterBalance{};
1365 audio_utils::Balance mBalance;
Eric Laurent81784c32012-11-19 14:55:58 -08001366 int mNumWrites;
1367 int mNumDelayedWrites;
1368 bool mInWrite;
1369
1370 // FIXME rename these former local variables of threadLoop to standard "m" names
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001371 nsecs_t mStandbyTimeNs;
Andy Hung25c2dac2014-02-27 14:56:00 -08001372 size_t mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -08001373
1374 // cached copies of activeSleepTimeUs() and idleSleepTimeUs() made by cacheParameters_l()
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001375 uint32_t mActiveSleepTimeUs;
1376 uint32_t mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08001377
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001378 uint32_t mSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08001379
1380 // mixer status returned by prepareTracks_l()
1381 mixer_state mMixerStatus; // current cycle
1382 // previous cycle when in prepareTracks_l()
1383 mixer_state mMixerStatusIgnoringFastTracks;
1384 // FIXME or a separate ready state per track
1385
1386 // FIXME move these declarations into the specific sub-class that needs them
1387 // MIXER only
1388 uint32_t sleepTimeShift;
1389
1390 // same as AudioFlinger::mStandbyTimeInNsecs except for DIRECT which uses a shorter value
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001391 nsecs_t mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08001392
1393 // MIXER only
1394 nsecs_t maxPeriod;
1395
1396 // DUPLICATING only
1397 uint32_t writeFrames;
1398
Eric Laurentbfb1b832013-01-07 09:53:42 -08001399 size_t mBytesRemaining;
1400 size_t mCurrentWriteLength;
1401 bool mUseAsyncWrite;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001402 // mWriteAckSequence contains current write sequence on bits 31-1. The write sequence is
1403 // incremented each time a write(), a flush() or a standby() occurs.
1404 // Bit 0 is set when a write blocks and indicates a callback is expected.
1405 // Bit 0 is reset by the async callback thread calling resetWriteBlocked(). Out of sequence
1406 // callbacks are ignored.
1407 uint32_t mWriteAckSequence;
1408 // mDrainSequence contains current drain sequence on bits 31-1. The drain sequence is
1409 // incremented each time a drain is requested or a flush() or standby() occurs.
1410 // Bit 0 is set when the drain() command is called at the HAL and indicates a callback is
1411 // expected.
1412 // Bit 0 is reset by the async callback thread calling resetDraining(). Out of sequence
1413 // callbacks are ignored.
1414 uint32_t mDrainSequence;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001415 sp<AsyncCallbackThread> mCallbackThread;
1416
jiabinf6eb4c32020-02-25 14:06:25 -08001417 Mutex mAudioTrackCbLock;
1418 // Record of IAudioTrackCallback
Andy Hung3ff4b552023-06-26 19:20:57 -07001419 std::map<sp<IAfTrack>, sp<media::IAudioTrackCallback>> mAudioTrackCallbacks;
jiabinf6eb4c32020-02-25 14:06:25 -08001420
Eric Laurent81784c32012-11-19 14:55:58 -08001421private:
1422 // The HAL output sink is treated as non-blocking, but current implementation is blocking
1423 sp<NBAIO_Sink> mOutputSink;
1424 // If a fast mixer is present, the blocking pipe sink, otherwise clear
1425 sp<NBAIO_Sink> mPipeSink;
1426 // The current sink for the normal mixer to write it's (sub)mix, mOutputSink or mPipeSink
1427 sp<NBAIO_Sink> mNormalSink;
Eric Laurent81784c32012-11-19 14:55:58 -08001428 uint32_t mScreenState; // cached copy of gScreenState
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07001429 // TODO: add comment and adjust size as needed
Glenn Kasteneef598c2017-04-03 14:41:13 -07001430 static const size_t kFastMixerLogSize = 8 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -08001431 sp<NBLog::Writer> mFastMixerNBLogWriter;
Andy Hung2148bf02016-11-28 19:01:02 -08001432
Dean Wheatley30d28422018-11-06 10:27:40 +11001433 // Downstream patch latency, available if mDownstreamLatencyStatMs.getN() > 0.
1434 audio_utils::Statistics<double> mDownstreamLatencyStatMs{0.999};
Andy Hung2148bf02016-11-28 19:01:02 -08001435
Eric Laurent19952e12023-04-20 10:08:29 +02001436 // output stream start detection based on render position returned by the kernel
1437 // condition signalled when the output stream has started
1438 Condition mWaitHalStartCV;
1439 // true when the output stream render position has moved, reset to false in standby
1440 bool mHalStarted = false;
1441 // last kernel render position saved when entering standby
1442 int64_t mKernelPositionOnStandby = 0;
1443
Eric Laurent81784c32012-11-19 14:55:58 -08001444public:
1445 virtual bool hasFastMixer() const = 0;
Glenn Kasten0f11b512014-01-31 16:18:54 -08001446 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex __unused) const
Eric Laurent81784c32012-11-19 14:55:58 -08001447 { FastTrackUnderruns dummy; return dummy; }
yucliu91503922022-07-20 17:40:39 -07001448 const std::atomic<int64_t>& framesWritten() const { return mFramesWritten; }
Eric Laurent81784c32012-11-19 14:55:58 -08001449
1450protected:
1451 // accessed by both binder threads and within threadLoop(), lock on mutex needed
1452 unsigned mFastTrackAvailMask; // bit i set if fast track [i] is available
Eric Laurentd1f69b02014-12-15 14:33:13 -08001453 bool mHwSupportsPause;
1454 bool mHwPaused;
1455 bool mFlushPending;
Eric Laurent7c29ec92017-09-20 17:54:22 -07001456 // volumes last sent to audio HAL with stream->setVolume()
1457 float mLeftVolFloat;
1458 float mRightVolFloat;
Eric Laurent74c38dc2020-12-23 18:19:44 +01001459
1460 // audio patch used by the downstream software patch.
1461 // Only used if ThreadBase::mIsMsdDevice is true.
1462 struct audio_patch mDownStreamPatch;
Eric Laurentb3f315a2021-07-13 15:09:05 +02001463
1464 std::atomic_bool mCheckOutputStageEffects{};
ziyangch8f194f12021-12-01 13:48:04 -08001465
ziyangch8f194f12021-12-01 13:48:04 -08001466
Brian Lindahl9e661ad2022-07-27 18:01:07 +02001467 // Provides periodic checking for timestamp advancement for underrun detection.
1468 class IsTimestampAdvancing {
1469 public:
1470 // The timestamp will not be checked any faster than the specified time.
Andy Hung71ba4b32022-10-06 12:09:49 -07001471 explicit IsTimestampAdvancing(nsecs_t minimumTimeBetweenChecksNs)
Brian Lindahl9e661ad2022-07-27 18:01:07 +02001472 : mMinimumTimeBetweenChecksNs(minimumTimeBetweenChecksNs)
1473 {
1474 clear();
1475 }
1476 // Check if the presentation position has advanced in the last periodic time.
1477 bool check(AudioStreamOut * output);
1478 // Clear the internal state when the playback state changes for the output
1479 // stream.
1480 void clear();
1481 private:
1482 // The minimum time between timestamp checks.
1483 const nsecs_t mMinimumTimeBetweenChecksNs;
1484 // Add differential check on the timestamps to see if there is a change in the
1485 // timestamp frame position between the last call to check.
1486 uint64_t mPreviousPosition;
1487 // The time at which the last check occurred, to ensure we don't check too
1488 // frequently, giving the Audio HAL enough time to update its timestamps.
1489 nsecs_t mPreviousNs;
1490 // The valued is latched so we don't check timestamps too frequently.
1491 bool mLatchedValue;
1492 };
1493 IsTimestampAdvancing mIsTimestampAdvancing;
ziyangch8f194f12021-12-01 13:48:04 -08001494
Brian Lindahl9e661ad2022-07-27 18:01:07 +02001495 virtual void flushHw_l() {
1496 mIsTimestampAdvancing.clear();
1497 }
Eric Laurent81784c32012-11-19 14:55:58 -08001498};
1499
Eric Laurentb0463942022-12-20 16:31:10 +01001500class MixerThread : public PlaybackThread,
1501 public StreamOutHalInterfaceLatencyModeCallback {
Eric Laurent81784c32012-11-19 14:55:58 -08001502public:
1503 MixerThread(const sp<AudioFlinger>& audioFlinger,
1504 AudioStreamOut* output,
1505 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07001506 bool systemReady,
Eric Laurentf1f22e72021-07-13 14:04:14 +02001507 type_t type = MIXER,
1508 audio_config_base_t *mixerConfig = nullptr);
Eric Laurent81784c32012-11-19 14:55:58 -08001509 virtual ~MixerThread();
1510
Eric Laurentb0463942022-12-20 16:31:10 +01001511 // RefBase
1512 virtual void onFirstRef();
1513
1514 // StreamOutHalInterfaceLatencyModeCallback
1515 void onRecommendedLatencyModeChanged(
1516 std::vector<audio_latency_mode_t> modes) override;
1517
Eric Laurent81784c32012-11-19 14:55:58 -08001518 // Thread virtuals
1519
Eric Laurent10351942014-05-08 18:49:52 -07001520 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1521 status_t& status);
Eric Laurent81784c32012-11-19 14:55:58 -08001522
Andy Hung1bc088a2018-02-09 15:57:31 -08001523 virtual bool isTrackAllowed_l(
1524 audio_channel_mask_t channelMask, audio_format_t format,
1525 audio_session_t sessionId, uid_t uid) const override;
Eric Laurent81784c32012-11-19 14:55:58 -08001526protected:
Andy Hung3ff4b552023-06-26 19:20:57 -07001527 virtual mixer_state prepareTracks_l(Vector<sp<IAfTrack>>* tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08001528 virtual uint32_t idleSleepTimeUs() const;
1529 virtual uint32_t suspendSleepTimeUs() const;
1530 virtual void cacheParameters_l();
1531
Andy Hungdae27702016-10-31 14:01:16 -07001532 virtual void acquireWakeLock_l() {
1533 PlaybackThread::acquireWakeLock_l();
Andy Hung818e7a32016-02-16 18:08:07 -08001534 if (hasFastMixer()) {
1535 mFastMixer->setBoottimeOffset(
1536 mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME]);
1537 }
1538 }
1539
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001540 void dumpInternals_l(int fd, const Vector<String16>& args) override;
1541
Eric Laurent81784c32012-11-19 14:55:58 -08001542 // threadLoop snippets
Eric Laurentbfb1b832013-01-07 09:53:42 -08001543 virtual ssize_t threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08001544 virtual void threadLoop_standby();
1545 virtual void threadLoop_mix();
1546 virtual void threadLoop_sleepTime();
Eric Laurent81784c32012-11-19 14:55:58 -08001547 virtual uint32_t correctLatency_l(uint32_t latency) const;
1548
Eric Laurent054d9d32015-04-24 08:48:48 -07001549 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1550 audio_patch_handle_t *handle);
1551 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
1552
Eric Laurent81784c32012-11-19 14:55:58 -08001553 AudioMixer* mAudioMixer; // normal mixer
Eric Laurentb0463942022-12-20 16:31:10 +01001554
1555 // Support low latency mode by default as unless explicitly indicated by the audio HAL
1556 // we assume the audio path is compatible with the head tracking latency requirements
1557 std::vector<audio_latency_mode_t> mSupportedLatencyModes = {AUDIO_LATENCY_MODE_LOW};
1558 // default to invalid value to force first update to the audio HAL
1559 audio_latency_mode_t mSetLatencyMode =
1560 (audio_latency_mode_t)AUDIO_LATENCY_MODE_INVALID;
1561
1562 // Bluetooth Variable latency control logic is enabled or disabled for this thread
1563 std::atomic_bool mBluetoothLatencyModesEnabled;
1564
Eric Laurent81784c32012-11-19 14:55:58 -08001565private:
1566 // one-time initialization, no locks required
Glenn Kasten4d23ca32014-05-13 10:39:51 -07001567 sp<FastMixer> mFastMixer; // non-0 if there is also a fast mixer
Eric Laurent81784c32012-11-19 14:55:58 -08001568 sp<AudioWatchdog> mAudioWatchdog; // non-0 if there is an audio watchdog thread
1569
1570 // contents are not guaranteed to be consistent, no locks required
1571 FastMixerDumpState mFastMixerDumpState;
1572#ifdef STATE_QUEUE_DUMP
1573 StateQueueObserverDump mStateQueueObserverDump;
1574 StateQueueMutatorDump mStateQueueMutatorDump;
1575#endif
1576 AudioWatchdogDump mAudioWatchdogDump;
1577
1578 // accessible only within the threadLoop(), no locks required
1579 // mFastMixer->sq() // for mutating and pushing state
1580 int32_t mFastMixerFutex; // for cold idle
1581
Andy Hung2ddee192015-12-18 17:34:44 -08001582 std::atomic_bool mMasterMono;
Eric Laurent81784c32012-11-19 14:55:58 -08001583public:
Glenn Kasten4d23ca32014-05-13 10:39:51 -07001584 virtual bool hasFastMixer() const { return mFastMixer != 0; }
Eric Laurent81784c32012-11-19 14:55:58 -08001585 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const {
Glenn Kastendc2c50b2016-04-21 08:13:14 -07001586 ALOG_ASSERT(fastIndex < FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08001587 return mFastMixerDumpState.mTracks[fastIndex].mUnderruns;
1588 }
Eric Laurent83b88082014-06-20 18:31:16 -07001589
Andy Hung1c86ebe2018-05-29 20:29:08 -07001590 status_t threadloop_getHalTimestamp_l(
1591 ExtendedTimestamp *timestamp) const override {
1592 if (mNormalSink.get() != nullptr) {
1593 return mNormalSink->getTimestamp(*timestamp);
1594 }
1595 return INVALID_OPERATION;
1596 }
1597
Eric Laurentb0463942022-12-20 16:31:10 +01001598 status_t getSupportedLatencyModes(
1599 std::vector<audio_latency_mode_t>* modes) override;
1600
1601 status_t setBluetoothVariableLatencyEnabled(bool enabled) override;
1602
Andy Hung2ddee192015-12-18 17:34:44 -08001603protected:
1604 virtual void setMasterMono_l(bool mono) {
1605 mMasterMono.store(mono);
1606 if (mFastMixer != nullptr) { /* hasFastMixer() */
1607 mFastMixer->setMasterMono(mMasterMono);
1608 }
1609 }
1610 // the FastMixer performs mono blend if it exists.
Glenn Kasten03c48d52016-01-27 17:25:17 -08001611 // Blending with limiter is not idempotent,
1612 // and blending without limiter is idempotent but inefficient to do twice.
Andy Hung2ddee192015-12-18 17:34:44 -08001613 virtual bool requireMonoBlend() { return mMasterMono.load() && !hasFastMixer(); }
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001614
1615 void setMasterBalance(float balance) override {
1616 mMasterBalance.store(balance);
1617 if (hasFastMixer()) {
1618 mFastMixer->setMasterBalance(balance);
1619 }
1620 }
Eric Laurentb0463942022-12-20 16:31:10 +01001621
1622 void updateHalSupportedLatencyModes_l();
1623 void onHalLatencyModesChanged_l() override;
1624 void setHalLatencyMode_l() override;
Eric Laurent81784c32012-11-19 14:55:58 -08001625};
1626
1627class DirectOutputThread : public PlaybackThread {
1628public:
1629
1630 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Gareth Fenn56576722022-10-05 13:42:36 -07001631 audio_io_handle_t id, bool systemReady,
1632 const audio_offload_info_t& offloadInfo)
1633 : DirectOutputThread(audioFlinger, output, id, DIRECT, systemReady, offloadInfo) { }
Andy Hung48f59ed2019-01-28 15:06:59 -08001634
Eric Laurent81784c32012-11-19 14:55:58 -08001635 virtual ~DirectOutputThread();
1636
Mikhail Naganovac917ac2018-11-28 14:03:52 -08001637 status_t selectPresentation(int presentationId, int programId);
1638
Eric Laurent81784c32012-11-19 14:55:58 -08001639 // Thread virtuals
1640
Eric Laurent10351942014-05-08 18:49:52 -07001641 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1642 status_t& status);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001643
ziyangch8f194f12021-12-01 13:48:04 -08001644 void flushHw_l() override;
Eric Laurent81784c32012-11-19 14:55:58 -08001645
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001646 void setMasterBalance(float balance) override;
1647
Eric Laurent81784c32012-11-19 14:55:58 -08001648protected:
Eric Laurent81784c32012-11-19 14:55:58 -08001649 virtual uint32_t activeSleepTimeUs() const;
1650 virtual uint32_t idleSleepTimeUs() const;
1651 virtual uint32_t suspendSleepTimeUs() const;
1652 virtual void cacheParameters_l();
1653
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001654 void dumpInternals_l(int fd, const Vector<String16>& args) override;
1655
Eric Laurent81784c32012-11-19 14:55:58 -08001656 // threadLoop snippets
Andy Hung3ff4b552023-06-26 19:20:57 -07001657 virtual mixer_state prepareTracks_l(Vector<sp<IAfTrack>>* tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08001658 virtual void threadLoop_mix();
1659 virtual void threadLoop_sleepTime();
Eric Laurentd1f69b02014-12-15 14:33:13 -08001660 virtual void threadLoop_exit();
1661 virtual bool shouldStandby_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001662
Phil Burk43b4dcc2015-06-09 16:53:44 -07001663 virtual void onAddNewTrack_l();
1664
Gareth Fenn56576722022-10-05 13:42:36 -07001665 const audio_offload_info_t mOffloadInfo;
Andy Hungee86cee2022-12-13 19:19:53 -08001666
1667 audioflinger::MonotonicFrameCounter mMonotonicFrameCounter; // for VolumeShaper
Andy Hung48f59ed2019-01-28 15:06:59 -08001668 bool mVolumeShaperActive = false;
Eric Laurent81784c32012-11-19 14:55:58 -08001669
Eric Laurentbfb1b832013-01-07 09:53:42 -08001670 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Gareth Fenn56576722022-10-05 13:42:36 -07001671 audio_io_handle_t id, ThreadBase::type_t type, bool systemReady,
1672 const audio_offload_info_t& offloadInfo);
Andy Hung3ff4b552023-06-26 19:20:57 -07001673 void processVolume_l(IAfTrack *track, bool lastTrack);
Gareth Fenn56576722022-10-05 13:42:36 -07001674 bool isTunerStream() const { return (mOffloadInfo.content_id > 0); }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001675
Eric Laurent81784c32012-11-19 14:55:58 -08001676 // prepareTracks_l() tells threadLoop_mix() the name of the single active track
Andy Hung3ff4b552023-06-26 19:20:57 -07001677 sp<IAfTrack> mActiveTrack;
Phil Burk43b4dcc2015-06-09 16:53:44 -07001678
Andy Hung3ff4b552023-06-26 19:20:57 -07001679 wp<IAfTrack> mPreviousTrack; // used to detect track switch
Phil Burk43b4dcc2015-06-09 16:53:44 -07001680
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001681 // This must be initialized for initial condition of mMasterBalance = 0 (disabled).
1682 float mMasterBalanceLeft = 1.f;
1683 float mMasterBalanceRight = 1.f;
1684
Eric Laurent81784c32012-11-19 14:55:58 -08001685public:
1686 virtual bool hasFastMixer() const { return false; }
Andy Hung10cbff12017-02-21 17:30:14 -08001687
1688 virtual int64_t computeWaitTimeNs_l() const override;
Andy Hungf3234512018-07-03 14:51:47 -07001689
1690 status_t threadloop_getHalTimestamp_l(ExtendedTimestamp *timestamp) const override {
1691 // For DIRECT and OFFLOAD threads, query the output sink directly.
1692 if (mOutput != nullptr) {
1693 uint64_t uposition64;
1694 struct timespec time;
1695 if (mOutput->getPresentationPosition(
1696 &uposition64, &time) == OK) {
1697 timestamp->mPosition[ExtendedTimestamp::LOCATION_KERNEL]
1698 = (int64_t)uposition64;
1699 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]
1700 = audio_utils_ns_from_timespec(&time);
1701 return NO_ERROR;
1702 }
1703 }
1704 return INVALID_OPERATION;
1705 }
Eric Laurent81784c32012-11-19 14:55:58 -08001706};
1707
Eric Laurentbfb1b832013-01-07 09:53:42 -08001708class OffloadThread : public DirectOutputThread {
1709public:
1710
1711 OffloadThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Gareth Fenn56576722022-10-05 13:42:36 -07001712 audio_io_handle_t id, bool systemReady,
1713 const audio_offload_info_t& offloadInfo);
Eric Laurent6a51d7e2013-10-17 18:59:26 -07001714 virtual ~OffloadThread() {};
ziyangch8f194f12021-12-01 13:48:04 -08001715 void flushHw_l() override;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001716
1717protected:
1718 // threadLoop snippets
Andy Hung3ff4b552023-06-26 19:20:57 -07001719 virtual mixer_state prepareTracks_l(Vector<sp<IAfTrack>>* tracksToRemove);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001720 virtual void threadLoop_exit();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001721
1722 virtual bool waitingAsyncCallback();
1723 virtual bool waitingAsyncCallback_l();
Haynes Mathew George05317d22016-05-03 16:34:26 -07001724 virtual void invalidateTracks(audio_stream_type_t streamType);
jiabinc44b3462022-12-08 12:52:31 -08001725 void invalidateTracks(std::set<audio_port_handle_t>& portIds) override;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001726
Eric Laurentde0613d2016-07-22 18:19:11 -07001727 virtual bool keepWakeLock() const { return (mKeepWakeLock || (mDrainSequence & 1)); }
Eric Laurent64667972016-03-30 18:19:46 -07001728
Eric Laurentbfb1b832013-01-07 09:53:42 -08001729private:
Eric Laurentbfb1b832013-01-07 09:53:42 -08001730 size_t mPausedWriteLength; // length in bytes of write interrupted by pause
1731 size_t mPausedBytesRemaining; // bytes still waiting in mixbuffer after resume
Eric Laurent64667972016-03-30 18:19:46 -07001732 bool mKeepWakeLock; // keep wake lock while waiting for write callback
Eric Laurentbfb1b832013-01-07 09:53:42 -08001733};
1734
1735class AsyncCallbackThread : public Thread {
1736public:
1737
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001738 explicit AsyncCallbackThread(const wp<PlaybackThread>& playbackThread);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001739
1740 virtual ~AsyncCallbackThread();
1741
1742 // Thread virtuals
1743 virtual bool threadLoop();
1744
1745 // RefBase
1746 virtual void onFirstRef();
1747
1748 void exit();
Eric Laurent3b4529e2013-09-05 18:09:19 -07001749 void setWriteBlocked(uint32_t sequence);
1750 void resetWriteBlocked();
1751 void setDraining(uint32_t sequence);
1752 void resetDraining();
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07001753 void setAsyncError();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001754
1755private:
Eric Laurent4de95592013-09-26 15:28:21 -07001756 const wp<PlaybackThread> mPlaybackThread;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001757 // mWriteAckSequence corresponds to the last write sequence passed by the offload thread via
1758 // setWriteBlocked(). The sequence is shifted one bit to the left and the lsb is used
1759 // to indicate that the callback has been received via resetWriteBlocked()
Eric Laurent4de95592013-09-26 15:28:21 -07001760 uint32_t mWriteAckSequence;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001761 // mDrainSequence corresponds to the last drain sequence passed by the offload thread via
1762 // setDraining(). The sequence is shifted one bit to the left and the lsb is used
1763 // to indicate that the callback has been received via resetDraining()
Eric Laurent4de95592013-09-26 15:28:21 -07001764 uint32_t mDrainSequence;
1765 Condition mWaitWorkCV;
1766 Mutex mLock;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07001767 bool mAsyncError;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001768};
1769
Eric Laurent81784c32012-11-19 14:55:58 -08001770class DuplicatingThread : public MixerThread {
1771public:
1772 DuplicatingThread(const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread,
Eric Laurent72e3f392015-05-20 14:43:50 -07001773 audio_io_handle_t id, bool systemReady);
Eric Laurent81784c32012-11-19 14:55:58 -08001774 virtual ~DuplicatingThread();
1775
1776 // Thread virtuals
1777 void addOutputTrack(MixerThread* thread);
1778 void removeOutputTrack(MixerThread* thread);
1779 uint32_t waitTimeMs() const { return mWaitTimeMs; }
Kevin Rocard069c2712018-03-29 19:09:14 -07001780
Kevin Rocardc86a7f72018-04-03 09:00:09 -07001781 void sendMetadataToBackend_l(
1782 const StreamOutHalInterface::SourceMetadata& metadata) override;
Eric Laurent81784c32012-11-19 14:55:58 -08001783protected:
1784 virtual uint32_t activeSleepTimeUs() const;
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001785 void dumpInternals_l(int fd, const Vector<String16>& args) override;
Eric Laurent81784c32012-11-19 14:55:58 -08001786
1787private:
Andy Hung71ba4b32022-10-06 12:09:49 -07001788 bool outputsReady();
Eric Laurent81784c32012-11-19 14:55:58 -08001789protected:
1790 // threadLoop snippets
1791 virtual void threadLoop_mix();
1792 virtual void threadLoop_sleepTime();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001793 virtual ssize_t threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08001794 virtual void threadLoop_standby();
1795 virtual void cacheParameters_l();
1796
1797private:
1798 // called from threadLoop, addOutputTrack, removeOutputTrack
1799 virtual void updateWaitTime_l();
1800protected:
1801 virtual void saveOutputTracks();
1802 virtual void clearOutputTracks();
1803private:
1804
1805 uint32_t mWaitTimeMs;
Andy Hung3ff4b552023-06-26 19:20:57 -07001806 SortedVector <sp<IAfOutputTrack>> outputTracks;
1807 SortedVector <sp<IAfOutputTrack>> mOutputTracks;
Eric Laurent81784c32012-11-19 14:55:58 -08001808public:
1809 virtual bool hasFastMixer() const { return false; }
Andy Hung1c86ebe2018-05-29 20:29:08 -07001810 status_t threadloop_getHalTimestamp_l(
1811 ExtendedTimestamp *timestamp) const override {
1812 if (mOutputTracks.size() > 0) {
1813 // forward the first OutputTrack's kernel information for timestamp.
1814 const ExtendedTimestamp trackTimestamp =
1815 mOutputTracks[0]->getClientProxyTimestamp();
1816 if (trackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0) {
1817 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] =
1818 trackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
1819 timestamp->mPosition[ExtendedTimestamp::LOCATION_KERNEL] =
1820 trackTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
1821 return OK; // discard server timestamp - that's ignored.
1822 }
1823 }
1824 return INVALID_OPERATION;
1825 }
Eric Laurent81784c32012-11-19 14:55:58 -08001826};
1827
Eric Laurentb0463942022-12-20 16:31:10 +01001828class SpatializerThread : public MixerThread {
Eric Laurentb3f315a2021-07-13 15:09:05 +02001829public:
Eric Laurentfa0f6742021-08-17 18:39:44 +02001830 SpatializerThread(const sp<AudioFlinger>& audioFlinger,
Eric Laurentb3f315a2021-07-13 15:09:05 +02001831 AudioStreamOut* output,
1832 audio_io_handle_t id,
1833 bool systemReady,
1834 audio_config_base_t *mixerConfig);
Eric Laurentfa0f6742021-08-17 18:39:44 +02001835 ~SpatializerThread() override {}
Eric Laurentb3f315a2021-07-13 15:09:05 +02001836
1837 bool hasFastMixer() const override { return false; }
1838
Eric Laurent6f9534f2022-05-03 18:15:04 +02001839 // RefBase
1840 virtual void onFirstRef();
1841
Eric Laurent6f9534f2022-05-03 18:15:04 +02001842 status_t setRequestedLatencyMode(audio_latency_mode_t mode) override;
Eric Laurent6f9534f2022-05-03 18:15:04 +02001843
Eric Laurentb3f315a2021-07-13 15:09:05 +02001844protected:
1845 void checkOutputStageEffects() override;
Eric Laurent6f9534f2022-05-03 18:15:04 +02001846 void setHalLatencyMode_l() override;
Eric Laurentb3f315a2021-07-13 15:09:05 +02001847
1848private:
Eric Laurent6f9534f2022-05-03 18:15:04 +02001849 // Do not request a specific mode by default
1850 audio_latency_mode_t mRequestedLatencyMode = AUDIO_LATENCY_MODE_FREE;
1851
Andy Hungbd72c542023-06-20 18:56:17 -07001852 sp<IAfEffectHandle> mFinalDownMixer;
Eric Laurentb3f315a2021-07-13 15:09:05 +02001853};
1854
Eric Laurent81784c32012-11-19 14:55:58 -08001855// record thread
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001856class RecordThread : public ThreadBase
Eric Laurent81784c32012-11-19 14:55:58 -08001857{
Andy Hung3ff4b552023-06-26 19:20:57 -07001858 // TODO(b/288339104) remove friends
1859 friend class PassthruPatchRecord;
1860 friend class RecordTrack;
1861 friend class ResamplerBufferProvider;
Eric Laurent81784c32012-11-19 14:55:58 -08001862public:
1863
Eric Laurent81784c32012-11-19 14:55:58 -08001864
1865 RecordThread(const sp<AudioFlinger>& audioFlinger,
1866 AudioStreamIn *input,
Eric Laurent81784c32012-11-19 14:55:58 -08001867 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07001868 bool systemReady
Glenn Kasten46909e72013-02-26 09:20:22 -08001869 );
Eric Laurent81784c32012-11-19 14:55:58 -08001870 virtual ~RecordThread();
1871
1872 // no addTrack_l ?
Andy Hung3ff4b552023-06-26 19:20:57 -07001873 void destroyTrack_l(const sp<IAfRecordTrack>& track);
1874 void removeTrack_l(const sp<IAfRecordTrack>& track);
Eric Laurent81784c32012-11-19 14:55:58 -08001875
Eric Laurent81784c32012-11-19 14:55:58 -08001876 // Thread virtuals
1877 virtual bool threadLoop();
Eric Laurent555530a2017-02-07 18:17:24 -08001878 virtual void preExit();
Eric Laurent81784c32012-11-19 14:55:58 -08001879
1880 // RefBase
1881 virtual void onFirstRef();
1882
1883 virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; }
Glenn Kastene198c362013-08-13 09:13:36 -07001884
Glenn Kastenb880f5e2014-05-07 08:43:45 -07001885 virtual sp<MemoryDealer> readOnlyHeap() const { return mReadOnlyHeap; }
1886
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001887 virtual sp<IMemory> pipeMemory() const { return mPipeMemory; }
1888
Andy Hung3ff4b552023-06-26 19:20:57 -07001889 sp<IAfRecordTrack> createRecordTrack_l(
Andy Hungd65869f2023-06-27 17:05:02 -07001890 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001891 const audio_attributes_t& attr,
Eric Laurentf14db3c2017-12-08 14:20:36 -08001892 uint32_t *pSampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -08001893 audio_format_t format,
1894 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08001895 size_t *pFrameCount,
Glenn Kastend848eb42016-03-08 13:42:11 -08001896 audio_session_t sessionId,
Eric Laurentf14db3c2017-12-08 14:20:36 -08001897 size_t *pNotificationFrameCount,
Eric Laurent09f1ed22019-04-24 17:45:17 -07001898 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00001899 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -07001900 audio_input_flags_t *flags,
Eric Laurent81784c32012-11-19 14:55:58 -08001901 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001902 status_t *status /*non-NULL*/,
Eric Laurentec376dc2021-04-08 20:41:22 +02001903 audio_port_handle_t portId,
1904 int32_t maxSharedAudioHistoryMs);
Eric Laurent81784c32012-11-19 14:55:58 -08001905
Andy Hung3ff4b552023-06-26 19:20:57 -07001906 status_t start(IAfRecordTrack* recordTrack,
Eric Laurent81784c32012-11-19 14:55:58 -08001907 AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08001908 audio_session_t triggerSession);
Eric Laurent81784c32012-11-19 14:55:58 -08001909
1910 // ask the thread to stop the specified track, and
1911 // return true if the caller should then do it's part of the stopping process
Andy Hung3ff4b552023-06-26 19:20:57 -07001912 bool stop(IAfRecordTrack* recordTrack);
Eric Laurent81784c32012-11-19 14:55:58 -08001913
Eric Laurent81784c32012-11-19 14:55:58 -08001914 AudioStreamIn* clearInput();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07001915 virtual sp<StreamHalInterface> stream() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001916
Eric Laurent81784c32012-11-19 14:55:58 -08001917
Eric Laurent10351942014-05-08 18:49:52 -07001918 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1919 status_t& status);
1920 virtual void cacheParameters_l() {}
Eric Laurent81784c32012-11-19 14:55:58 -08001921 virtual String8 getParameters(const String8& keys);
Mikhail Naganov88536df2021-07-26 17:30:29 -07001922 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -07001923 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Eric Laurent1c333e22014-05-20 10:48:17 -07001924 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1925 audio_patch_handle_t *handle);
1926 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
jiabinc52b1ff2019-10-31 17:20:42 -07001927 void updateOutDevices(const DeviceDescriptorBaseVector& outDevices) override;
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02001928 void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs) override;
Eric Laurent83b88082014-06-20 18:31:16 -07001929
Andy Hung3ff4b552023-06-26 19:20:57 -07001930 void addPatchTrack(const sp<IAfPatchRecord>& record);
1931 void deletePatchTrack(const sp<IAfPatchRecord>& record);
Eric Laurent83b88082014-06-20 18:31:16 -07001932
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001933 void readInputParameters_l();
Glenn Kasten5f972c02014-01-13 09:59:31 -08001934 virtual uint32_t getInputFramesLost();
Eric Laurent81784c32012-11-19 14:55:58 -08001935
Andy Hungbd72c542023-06-20 18:56:17 -07001936 virtual status_t addEffectChain_l(const sp<IAfEffectChain>& chain);
1937 virtual size_t removeEffectChain_l(const sp<IAfEffectChain>& chain);
Andy Hungc3d62f92019-03-14 13:38:51 -07001938 uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
1939 return ThreadBase::hasAudioSession_l(sessionId, mTracks);
1940 }
Eric Laurent81784c32012-11-19 14:55:58 -08001941
1942 // Return the set of unique session IDs across all tracks.
1943 // The keys are the session IDs, and the associated values are meaningless.
1944 // FIXME replace by Set [and implement Bag/Multiset for other uses].
Glenn Kastend848eb42016-03-08 13:42:11 -08001945 KeyedVector<audio_session_t, bool> sessionIds() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001946
Andy Hung068e08e2023-05-15 19:02:55 -07001947 status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) override;
1948 bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const override;
Eric Laurent81784c32012-11-19 14:55:58 -08001949
Andy Hung068e08e2023-05-15 19:02:55 -07001950 static void syncStartEventCallback(const wp<audioflinger::SyncEvent>& event);
Eric Laurent81784c32012-11-19 14:55:58 -08001951
Glenn Kasten9b58f632013-07-16 11:37:48 -07001952 virtual size_t frameCount() const { return mFrameCount; }
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001953 bool hasFastCapture() const { return mFastCapture != 0; }
Mikhail Naganovdc769682018-05-04 15:34:08 -07001954 virtual void toAudioPortConfig(struct audio_port_config *config);
Glenn Kasten9b58f632013-07-16 11:37:48 -07001955
Eric Laurent4c415062016-06-17 16:14:16 -07001956 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
1957 audio_session_t sessionId);
1958
Andy Hungdae27702016-10-31 14:01:16 -07001959 virtual void acquireWakeLock_l() {
1960 ThreadBase::acquireWakeLock_l();
1961 mActiveTracks.updatePowerState(this, true /* force */);
1962 }
1963
Eric Laurentd8365c52017-07-16 15:27:05 -07001964 void checkBtNrec();
1965
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001966 // Sets the UID records silence
Eric Laurent5ada82e2019-08-29 17:53:54 -07001967 void setRecordSilenced(audio_port_handle_t portId, bool silenced);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001968
Mikhail Naganov2a6a3012023-02-13 11:45:03 -08001969 status_t getActiveMicrophones(
1970 std::vector<media::MicrophoneInfoFw>* activeMicrophones);
jiabin653cc0a2018-01-17 17:54:10 -08001971
Paul McLean12340082019-03-19 09:35:05 -06001972 status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
1973 status_t setPreferredMicrophoneFieldDimension(float zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07001974
Vlad Popa7e81cea2023-01-19 16:34:16 +01001975 MetadataUpdate updateMetadata_l() override;
Kevin Rocard069c2712018-03-29 19:09:14 -07001976
jiabin01c8f562018-07-19 17:47:28 -07001977 bool fastTrackAvailable() const { return mFastTrackAvail; }
1978
Andy Hungc8fddf32018-08-08 18:32:37 -07001979 bool isTimestampCorrectionEnabled() const override {
1980 // checks popcount for exactly one device.
Atneya Nair497fff12022-01-18 16:23:04 -05001981 // Is currently disabled. Before enabling,
1982 // verify compressed record timestamps.
jiabinc52b1ff2019-10-31 17:20:42 -07001983 return audio_is_input_device(mTimestampCorrectedDevice)
1984 && inDeviceType() == mTimestampCorrectedDevice;
Andy Hungc8fddf32018-08-08 18:32:37 -07001985 }
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001986
Eric Laurentec376dc2021-04-08 20:41:22 +02001987 status_t shareAudioHistory(const std::string& sharedAudioPackageName,
1988 audio_session_t sharedSessionId = AUDIO_SESSION_NONE,
1989 int64_t sharedAudioStartMs = -1);
1990 status_t shareAudioHistory_l(const std::string& sharedAudioPackageName,
1991 audio_session_t sharedSessionId = AUDIO_SESSION_NONE,
1992 int64_t sharedAudioStartMs = -1);
Eric Laurent92d0a322021-07-16 15:32:33 +02001993 void resetAudioHistory_l();
Eric Laurentec376dc2021-04-08 20:41:22 +02001994
Jasmine Chaeaa10e42021-05-11 10:11:14 +08001995 virtual bool isStreamInitialized() {
1996 return !(mInput == nullptr || mInput->stream == nullptr);
1997 }
1998
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001999protected:
2000 void dumpInternals_l(int fd, const Vector<String16>& args) override;
2001 void dumpTracks_l(int fd, const Vector<String16>& args) override;
2002
Eric Laurent81784c32012-11-19 14:55:58 -08002003private:
Eric Laurent81784c32012-11-19 14:55:58 -08002004 // Enter standby if not already in standby, and set mStandby flag
Glenn Kasten93e471f2013-08-19 08:40:07 -07002005 void standbyIfNotAlreadyInStandby();
Eric Laurent81784c32012-11-19 14:55:58 -08002006
2007 // Call the HAL standby method unconditionally, and don't change mStandby flag
Glenn Kastene198c362013-08-13 09:13:36 -07002008 void inputStandBy();
Eric Laurent81784c32012-11-19 14:55:58 -08002009
Eric Laurentd8365c52017-07-16 15:27:05 -07002010 void checkBtNrec_l();
2011
Eric Laurentec376dc2021-04-08 20:41:22 +02002012 int32_t getOldestFront_l();
2013 void updateFronts_l(int32_t offset);
2014
Eric Laurent81784c32012-11-19 14:55:58 -08002015 AudioStreamIn *mInput;
Mikhail Naganov2534b382019-09-25 13:05:02 -07002016 Source *mSource;
Andy Hung3ff4b552023-06-26 19:20:57 -07002017 SortedVector <sp<IAfRecordTrack>> mTracks;
Glenn Kasten2b806402013-11-20 16:37:38 -08002018 // mActiveTracks has dual roles: it indicates the current active track(s), and
Eric Laurent81784c32012-11-19 14:55:58 -08002019 // is used together with mStartStopCond to indicate start()/stop() progress
Andy Hung3ff4b552023-06-26 19:20:57 -07002020 ActiveTracks<IAfRecordTrack> mActiveTracks;
Andy Hungdae27702016-10-31 14:01:16 -07002021
Eric Laurent81784c32012-11-19 14:55:58 -08002022 Condition mStartStopCond;
Glenn Kasten9b58f632013-07-16 11:37:48 -07002023
Glenn Kasten85948432013-08-19 12:09:05 -07002024 // resampler converts input at HAL Hz to output at AudioRecord client Hz
Glenn Kasten1b291842016-07-18 14:55:21 -07002025 void *mRsmpInBuffer; // size = mRsmpInFramesOA
Glenn Kasten85948432013-08-19 12:09:05 -07002026 size_t mRsmpInFrames; // size of resampler input in frames
2027 size_t mRsmpInFramesP2;// size rounded up to a power-of-2
Glenn Kasten1b291842016-07-18 14:55:21 -07002028 size_t mRsmpInFramesOA;// mRsmpInFramesP2 + over-allocation
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002029
2030 // rolling index that is never cleared
Glenn Kasten85948432013-08-19 12:09:05 -07002031 int32_t mRsmpInRear; // last filled frame + 1
Glenn Kasten85948432013-08-19 12:09:05 -07002032
Eric Laurent81784c32012-11-19 14:55:58 -08002033 // For dumpsys
Glenn Kastenb880f5e2014-05-07 08:43:45 -07002034 const sp<MemoryDealer> mReadOnlyHeap;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07002035
2036 // one-time initialization, no locks required
Glenn Kastenb187de12014-12-30 08:18:15 -08002037 sp<FastCapture> mFastCapture; // non-0 if there is also
2038 // a fast capture
Eric Laurent72e3f392015-05-20 14:43:50 -07002039
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07002040 // FIXME audio watchdog thread
2041
2042 // contents are not guaranteed to be consistent, no locks required
2043 FastCaptureDumpState mFastCaptureDumpState;
2044#ifdef STATE_QUEUE_DUMP
2045 // FIXME StateQueue observer and mutator dump fields
2046#endif
2047 // FIXME audio watchdog dump
2048
2049 // accessible only within the threadLoop(), no locks required
2050 // mFastCapture->sq() // for mutating and pushing state
2051 int32_t mFastCaptureFutex; // for cold idle
2052
2053 // The HAL input source is treated as non-blocking,
2054 // but current implementation is blocking
2055 sp<NBAIO_Source> mInputSource;
2056 // The source for the normal capture thread to read from: mInputSource or mPipeSource
2057 sp<NBAIO_Source> mNormalSource;
2058 // If a fast capture is present, the non-blocking pipe sink written to by fast capture,
2059 // otherwise clear
2060 sp<NBAIO_Sink> mPipeSink;
2061 // If a fast capture is present, the non-blocking pipe source read by normal thread,
2062 // otherwise clear
2063 sp<NBAIO_Source> mPipeSource;
2064 // Depth of pipe from fast capture to normal thread and fast clients, always power of 2
2065 size_t mPipeFramesP2;
2066 // If a fast capture is present, the Pipe as IMemory, otherwise clear
2067 sp<IMemory> mPipeMemory;
2068
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07002069 // TODO: add comment and adjust size as needed
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07002070 static const size_t kFastCaptureLogSize = 4 * 1024;
2071 sp<NBLog::Writer> mFastCaptureNBLogWriter;
2072
2073 bool mFastTrackAvail; // true if fast track available
Eric Laurentd8365c52017-07-16 15:27:05 -07002074 // common state to all record threads
2075 std::atomic_bool mBtNrecSuspended;
Andy Hung6427e442018-08-09 12:51:02 -07002076
2077 int64_t mFramesRead = 0; // continuous running counter.
jiabinc52b1ff2019-10-31 17:20:42 -07002078
2079 DeviceDescriptorBaseVector mOutDevices;
Eric Laurentec376dc2021-04-08 20:41:22 +02002080
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02002081 int32_t mMaxSharedAudioHistoryMs = 0;
Eric Laurentec376dc2021-04-08 20:41:22 +02002082 std::string mSharedAudioPackageName = {};
Eric Laurent2407ce32021-04-26 14:56:03 +02002083 int32_t mSharedAudioStartFrames = -1;
Eric Laurentec376dc2021-04-08 20:41:22 +02002084 audio_session_t mSharedAudioSessionId = AUDIO_SESSION_NONE;
Eric Laurent81784c32012-11-19 14:55:58 -08002085};
Eric Laurent6acd1d42017-01-04 14:23:29 -08002086
2087class MmapThread : public ThreadBase
2088{
2089 public:
Eric Laurent6acd1d42017-01-04 14:23:29 -08002090 MmapThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hung71ba4b32022-10-06 12:09:49 -07002091 AudioHwDevice *hwDev, const sp<StreamHalInterface>& stream, bool systemReady,
Andy Hungcf10d742020-04-28 15:38:24 -07002092 bool isOut);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002093 virtual ~MmapThread();
2094
2095 virtual void configure(const audio_attributes_t *attr,
2096 audio_stream_type_t streamType,
2097 audio_session_t sessionId,
2098 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07002099 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002100 audio_port_handle_t portId);
2101
2102 void disconnect();
2103
2104 // MmapStreamInterface
2105 status_t createMmapBuffer(int32_t minSizeFrames,
2106 struct audio_mmap_buffer_info *info);
2107 status_t getMmapPosition(struct audio_mmap_position *position);
jiabind1f1cb62020-03-24 11:57:57 -07002108 status_t start(const AudioClient& client,
2109 const audio_attributes_t *attr,
2110 audio_port_handle_t *handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002111 status_t stop(audio_port_handle_t handle);
Eric Laurent18b57012017-02-13 16:23:52 -08002112 status_t standby();
jiabinb7d8c5a2020-08-26 17:24:52 -07002113 virtual status_t getExternalPosition(uint64_t *position, int64_t *timeNaos) = 0;
jiabinfc791ee2023-02-15 19:43:40 +00002114 virtual status_t reportData(const void* buffer, size_t frameCount);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002115
2116 // RefBase
2117 virtual void onFirstRef();
2118
2119 // Thread virtuals
2120 virtual bool threadLoop();
2121
2122 virtual void threadLoop_exit();
2123 virtual void threadLoop_standby();
Eric Laurent18b57012017-02-13 16:23:52 -08002124 virtual bool shouldStandby_l() { return false; }
Eric Laurentdda206a2022-07-08 17:28:35 +02002125 virtual status_t exitStandby_l() REQUIRES(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002126
2127 virtual status_t initCheck() const { return (mHalStream == 0) ? NO_INIT : NO_ERROR; }
2128 virtual size_t frameCount() const { return mFrameCount; }
2129 virtual bool checkForNewParameter_l(const String8& keyValuePair,
2130 status_t& status);
2131 virtual String8 getParameters(const String8& keys);
Mikhail Naganov88536df2021-07-26 17:30:29 -07002132 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002133 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002134 void readHalParameters_l();
2135 virtual void cacheParameters_l() {}
2136 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
2137 audio_patch_handle_t *handle);
2138 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
Mikhail Naganovdc769682018-05-04 15:34:08 -07002139 virtual void toAudioPortConfig(struct audio_port_config *config);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002140
2141 virtual sp<StreamHalInterface> stream() const { return mHalStream; }
Andy Hungbd72c542023-06-20 18:56:17 -07002142 virtual status_t addEffectChain_l(const sp<IAfEffectChain>& chain);
2143 virtual size_t removeEffectChain_l(const sp<IAfEffectChain>& chain);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002144 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
2145 audio_session_t sessionId);
2146
Andy Hungc3d62f92019-03-14 13:38:51 -07002147 uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
2148 // Note: using mActiveTracks as no mTracks here.
2149 return ThreadBase::hasAudioSession_l(sessionId, mActiveTracks);
2150 }
Andy Hung068e08e2023-05-15 19:02:55 -07002151 virtual status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event);
2152 virtual bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002153
2154 virtual void checkSilentMode_l() {}
2155 virtual void processVolume_l() {}
2156 void checkInvalidTracks_l();
2157
2158 virtual audio_stream_type_t streamType() { return AUDIO_STREAM_DEFAULT; }
2159
2160 virtual void invalidateTracks(audio_stream_type_t streamType __unused) {}
jiabinc44b3462022-12-08 12:52:31 -08002161 virtual void invalidateTracks(std::set<audio_port_handle_t>& portIds __unused) {}
Eric Laurent6acd1d42017-01-04 14:23:29 -08002162
Eric Laurent331679c2018-04-16 17:03:16 -07002163 // Sets the UID records silence
Eric Laurent5ada82e2019-08-29 17:53:54 -07002164 virtual void setRecordSilenced(audio_port_handle_t portId __unused,
2165 bool silenced __unused) {}
Eric Laurent331679c2018-04-16 17:03:16 -07002166
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002167 virtual bool isStreamInitialized() { return false; }
2168
jiabincfc10a42022-06-15 19:26:01 +00002169 void setClientSilencedState_l(audio_port_handle_t portId, bool silenced) {
2170 mClientSilencedStates[portId] = silenced;
2171 }
2172
2173 size_t eraseClientSilencedState_l(audio_port_handle_t portId) {
2174 return mClientSilencedStates.erase(portId);
2175 }
2176
2177 bool isClientSilenced_l(audio_port_handle_t portId) const {
2178 const auto it = mClientSilencedStates.find(portId);
2179 return it != mClientSilencedStates.end() ? it->second : false;
2180 }
2181
2182 void setClientSilencedIfExists_l(audio_port_handle_t portId, bool silenced) {
2183 const auto it = mClientSilencedStates.find(portId);
2184 if (it != mClientSilencedStates.end()) {
2185 it->second = silenced;
2186 }
2187 }
2188
Eric Laurent6acd1d42017-01-04 14:23:29 -08002189 protected:
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002190 void dumpInternals_l(int fd, const Vector<String16>& args) override;
2191 void dumpTracks_l(int fd, const Vector<String16>& args) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002192
jiabinc52b1ff2019-10-31 17:20:42 -07002193 /**
2194 * @brief mDeviceId current device port unique identifier
2195 */
2196 audio_port_handle_t mDeviceId = AUDIO_PORT_HANDLE_NONE;
2197
Eric Laurent6acd1d42017-01-04 14:23:29 -08002198 audio_attributes_t mAttr;
2199 audio_session_t mSessionId;
2200 audio_port_handle_t mPortId;
2201
Phil Burk7f6b40d2017-02-09 13:18:38 -08002202 wp<MmapStreamCallback> mCallback;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002203 sp<StreamHalInterface> mHalStream;
2204 sp<DeviceHalInterface> mHalDevice;
2205 AudioHwDevice* const mAudioHwDev;
Andy Hung3ff4b552023-06-26 19:20:57 -07002206 ActiveTracks<IAfMmapTrack> mActiveTracks;
Eric Laurent67f97292018-04-20 18:05:41 -07002207 float mHalVolFloat;
jiabincfc10a42022-06-15 19:26:01 +00002208 std::map<audio_port_handle_t, bool> mClientSilencedStates;
Eric Laurent331679c2018-04-16 17:03:16 -07002209
2210 int32_t mNoCallbackWarningCount;
2211 static constexpr int32_t kMaxNoCallbackWarnings = 5;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002212};
2213
2214class MmapPlaybackThread : public MmapThread, public VolumeInterface
2215{
2216
2217public:
2218 MmapPlaybackThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabinc52b1ff2019-10-31 17:20:42 -07002219 AudioHwDevice *hwDev, AudioStreamOut *output, bool systemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002220 virtual ~MmapPlaybackThread() {}
2221
2222 virtual void configure(const audio_attributes_t *attr,
2223 audio_stream_type_t streamType,
2224 audio_session_t sessionId,
2225 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07002226 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002227 audio_port_handle_t portId);
2228
2229 AudioStreamOut* clearOutput();
2230
2231 // VolumeInterface
2232 virtual void setMasterVolume(float value);
2233 virtual void setMasterMute(bool muted);
2234 virtual void setStreamVolume(audio_stream_type_t stream, float value);
2235 virtual void setStreamMute(audio_stream_type_t stream, bool muted);
2236 virtual float streamVolume(audio_stream_type_t stream) const;
2237
2238 void setMasterMute_l(bool muted) { mMasterMute = muted; }
2239
2240 virtual void invalidateTracks(audio_stream_type_t streamType);
jiabinc44b3462022-12-08 12:52:31 -08002241 void invalidateTracks(std::set<audio_port_handle_t>& portIds) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002242
2243 virtual audio_stream_type_t streamType() { return mStreamType; }
2244 virtual void checkSilentMode_l();
Eric Laurent331679c2018-04-16 17:03:16 -07002245 void processVolume_l() override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002246
Vlad Popa7e81cea2023-01-19 16:34:16 +01002247 MetadataUpdate updateMetadata_l() override;
Kevin Rocard069c2712018-03-29 19:09:14 -07002248
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07002249 virtual void toAudioPortConfig(struct audio_port_config *config);
2250
jiabinb7d8c5a2020-08-26 17:24:52 -07002251 status_t getExternalPosition(uint64_t *position, int64_t *timeNanos) override;
2252
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002253 virtual bool isStreamInitialized() {
2254 return !(mOutput == nullptr || mOutput->stream == nullptr);
2255 }
2256
jiabinfc791ee2023-02-15 19:43:40 +00002257 status_t reportData(const void* buffer, size_t frameCount) override;
2258
Vlad Popa6fbbfbf2023-02-22 15:05:43 +01002259 void startMelComputation_l(const sp<audio_utils::MelProcessor>& processor) override;
2260 void stopMelComputation_l() override;
2261
Eric Laurent6acd1d42017-01-04 14:23:29 -08002262protected:
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002263 void dumpInternals_l(int fd, const Vector<String16>& args) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002264
2265 audio_stream_type_t mStreamType;
2266 float mMasterVolume;
2267 float mStreamVolume;
2268 bool mMasterMute;
2269 bool mStreamMute;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002270 AudioStreamOut* mOutput;
Vlad Popa6fbbfbf2023-02-22 15:05:43 +01002271
2272 mediautils::atomic_sp<audio_utils::MelProcessor> mMelProcessor;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002273};
2274
2275class MmapCaptureThread : public MmapThread
2276{
2277
2278public:
2279 MmapCaptureThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabinc52b1ff2019-10-31 17:20:42 -07002280 AudioHwDevice *hwDev, AudioStreamIn *input, bool systemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002281 virtual ~MmapCaptureThread() {}
2282
2283 AudioStreamIn* clearInput();
2284
Eric Laurentdda206a2022-07-08 17:28:35 +02002285 status_t exitStandby_l() REQUIRES(mLock) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002286
Vlad Popa7e81cea2023-01-19 16:34:16 +01002287 MetadataUpdate updateMetadata_l() override;
Eric Laurent331679c2018-04-16 17:03:16 -07002288 void processVolume_l() override;
Eric Laurent5ada82e2019-08-29 17:53:54 -07002289 void setRecordSilenced(audio_port_handle_t portId,
2290 bool silenced) override;
Kevin Rocard069c2712018-03-29 19:09:14 -07002291
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07002292 virtual void toAudioPortConfig(struct audio_port_config *config);
2293
jiabinb7d8c5a2020-08-26 17:24:52 -07002294 status_t getExternalPosition(uint64_t *position, int64_t *timeNanos) override;
2295
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002296 virtual bool isStreamInitialized() {
2297 return !(mInput == nullptr || mInput->stream == nullptr);
2298 }
2299
Eric Laurent6acd1d42017-01-04 14:23:29 -08002300protected:
2301
2302 AudioStreamIn* mInput;
2303};
jiabinc658e452022-10-21 20:52:21 +00002304
2305class BitPerfectThread : public MixerThread {
2306public:
2307 BitPerfectThread(const sp<AudioFlinger>& audioflinger, AudioStreamOut *output,
2308 audio_io_handle_t id, bool systemReady);
2309
2310protected:
Andy Hung3ff4b552023-06-26 19:20:57 -07002311 mixer_state prepareTracks_l(Vector<sp<IAfTrack>>* tracksToRemove) override;
jiabinc658e452022-10-21 20:52:21 +00002312 void threadLoop_mix() override;
2313
2314private:
2315 bool mIsBitPerfect;
jiabin76d94692022-12-15 21:51:21 +00002316 float mVolumeLeft = 0.f;
2317 float mVolumeRight = 0.f;
jiabinc658e452022-10-21 20:52:21 +00002318};
Andy Hungaaa18282023-06-23 19:27:19 -07002319
Andy Hung3ff4b552023-06-26 19:20:57 -07002320private: