blob: 8b420c03fc207eadda22a513c36f591880acecfb [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 Hung116bc262023-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 {
24public:
25
26#include "TrackBase.h"
27
28 enum type_t {
29 MIXER, // Thread class is MixerThread
30 DIRECT, // Thread class is DirectOutputThread
31 DUPLICATING, // Thread class is DuplicatingThread
Eric Laurentbfb1b832013-01-07 09:53:42 -080032 RECORD, // Thread class is RecordThread
Eric Laurent6acd1d42017-01-04 14:23:29 -080033 OFFLOAD, // Thread class is OffloadThread
Andy Hungea840382020-05-05 21:50:17 -070034 MMAP_PLAYBACK, // Thread class for MMAP playback stream
35 MMAP_CAPTURE, // Thread class for MMAP capture stream
Eric Laurent1c5e2e32021-08-18 18:50:28 +020036 SPATIALIZER, //
jiabinc658e452022-10-21 20:52:21 +000037 BIT_PERFECT, // Thread class for BitPerfectThread
Glenn Kasten1bfe09a2017-02-21 13:05:56 -080038 // If you add any values here, also update ThreadBase::threadTypeToString()
Eric Laurent81784c32012-11-19 14:55:58 -080039 };
40
Glenn Kasten97b7b752014-09-28 13:04:24 -070041 static const char *threadTypeToString(type_t type);
42
Eric Laurent81784c32012-11-19 14:55:58 -080043 ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hungcf10d742020-04-28 15:38:24 -070044 type_t type, bool systemReady, bool isOut);
Eric Laurent81784c32012-11-19 14:55:58 -080045 virtual ~ThreadBase();
46
Glenn Kastencf04c2c2013-08-06 07:41:16 -070047 virtual status_t readyToRun();
48
Eric Laurent81784c32012-11-19 14:55:58 -080049 void clearPowerManager();
50
51 // base for record and playback
52 enum {
53 CFG_EVENT_IO,
Eric Laurent10351942014-05-08 18:49:52 -070054 CFG_EVENT_PRIO,
55 CFG_EVENT_SET_PARAMETER,
Eric Laurent1c333e22014-05-20 10:48:17 -070056 CFG_EVENT_CREATE_AUDIO_PATCH,
57 CFG_EVENT_RELEASE_AUDIO_PATCH,
jiabinc52b1ff2019-10-31 17:20:42 -070058 CFG_EVENT_UPDATE_OUT_DEVICE,
Eric Laurentb3f315a2021-07-13 15:09:05 +020059 CFG_EVENT_RESIZE_BUFFER,
Eric Laurent68a40a82022-05-03 18:15:04 +020060 CFG_EVENT_CHECK_OUTPUT_STAGE_EFFECTS,
61 CFG_EVENT_HAL_LATENCY_MODES_CHANGED,
Eric Laurent81784c32012-11-19 14:55:58 -080062 };
63
Eric Laurent10351942014-05-08 18:49:52 -070064 class ConfigEventData: public RefBase {
Eric Laurent81784c32012-11-19 14:55:58 -080065 public:
Eric Laurent10351942014-05-08 18:49:52 -070066 virtual ~ConfigEventData() {}
Eric Laurent81784c32012-11-19 14:55:58 -080067
68 virtual void dump(char *buffer, size_t size) = 0;
Eric Laurent10351942014-05-08 18:49:52 -070069 protected:
70 ConfigEventData() {}
Eric Laurent81784c32012-11-19 14:55:58 -080071 };
72
Eric Laurent10351942014-05-08 18:49:52 -070073 // Config event sequence by client if status needed (e.g binder thread calling setParameters()):
74 // 1. create SetParameterConfigEvent. This sets mWaitStatus in config event
75 // 2. Lock mLock
76 // 3. Call sendConfigEvent_l(): Append to mConfigEvents and mWaitWorkCV.signal
77 // 4. sendConfigEvent_l() reads status from event->mStatus;
78 // 5. sendConfigEvent_l() returns status
79 // 6. Unlock
80 //
81 // Parameter sequence by server: threadLoop calling processConfigEvents_l():
82 // 1. Lock mLock
83 // 2. If there is an entry in mConfigEvents proceed ...
84 // 3. Read first entry in mConfigEvents
85 // 4. Remove first entry from mConfigEvents
86 // 5. Process
87 // 6. Set event->mStatus
88 // 7. event->mCond.signal
89 // 8. Unlock
Eric Laurent81784c32012-11-19 14:55:58 -080090
Eric Laurent10351942014-05-08 18:49:52 -070091 class ConfigEvent: public RefBase {
92 public:
93 virtual ~ConfigEvent() {}
94
Eric Laurentb3f315a2021-07-13 15:09:05 +020095 void dump(char *buffer, size_t size) {
96 snprintf(buffer, size, "Event type: %d\n", mType);
97 if (mData != nullptr) {
98 snprintf(buffer, size, "Data:\n");
99 mData->dump(buffer, size);
100 }
101 }
Eric Laurent10351942014-05-08 18:49:52 -0700102
103 const int mType; // event type e.g. CFG_EVENT_IO
104 Mutex mLock; // mutex associated with mCond
105 Condition mCond; // condition for status return
106 status_t mStatus; // status communicated to sender
107 bool mWaitStatus; // true if sender is waiting for status
Eric Laurent72e3f392015-05-20 14:43:50 -0700108 bool mRequiresSystemReady; // true if must wait for system ready to enter event queue
Eric Laurent10351942014-05-08 18:49:52 -0700109 sp<ConfigEventData> mData; // event specific parameter data
110
111 protected:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700112 explicit ConfigEvent(int type, bool requiresSystemReady = false) :
Eric Laurent72e3f392015-05-20 14:43:50 -0700113 mType(type), mStatus(NO_ERROR), mWaitStatus(false),
114 mRequiresSystemReady(requiresSystemReady), mData(NULL) {}
Eric Laurent10351942014-05-08 18:49:52 -0700115 };
116
117 class IoConfigEventData : public ConfigEventData {
118 public:
Mikhail Naganov88536df2021-07-26 17:30:29 -0700119 IoConfigEventData(audio_io_config_event_t event, pid_t pid,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700120 audio_port_handle_t portId) :
121 mEvent(event), mPid(pid), mPortId(portId) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800122
123 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200124 snprintf(buffer, size, "- IO event: event %d\n", mEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800125 }
126
Mikhail Naganov88536df2021-07-26 17:30:29 -0700127 const audio_io_config_event_t mEvent;
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700128 const pid_t mPid;
Eric Laurent09f1ed22019-04-24 17:45:17 -0700129 const audio_port_handle_t mPortId;
Eric Laurent81784c32012-11-19 14:55:58 -0800130 };
131
Eric Laurent10351942014-05-08 18:49:52 -0700132 class IoConfigEvent : public ConfigEvent {
Eric Laurent81784c32012-11-19 14:55:58 -0800133 public:
Mikhail Naganov88536df2021-07-26 17:30:29 -0700134 IoConfigEvent(audio_io_config_event_t event, pid_t pid, audio_port_handle_t portId) :
Eric Laurent10351942014-05-08 18:49:52 -0700135 ConfigEvent(CFG_EVENT_IO) {
Eric Laurent09f1ed22019-04-24 17:45:17 -0700136 mData = new IoConfigEventData(event, pid, portId);
Eric Laurent10351942014-05-08 18:49:52 -0700137 }
138 virtual ~IoConfigEvent() {}
139 };
Eric Laurent81784c32012-11-19 14:55:58 -0800140
Eric Laurent10351942014-05-08 18:49:52 -0700141 class PrioConfigEventData : public ConfigEventData {
142 public:
Mikhail Naganov83f04272017-02-07 10:45:09 -0800143 PrioConfigEventData(pid_t pid, pid_t tid, int32_t prio, bool forApp) :
144 mPid(pid), mTid(tid), mPrio(prio), mForApp(forApp) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800145
146 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200147 snprintf(buffer, size, "- Prio event: pid %d, tid %d, prio %d, for app? %d\n",
Mikhail Naganov83f04272017-02-07 10:45:09 -0800148 mPid, mTid, mPrio, mForApp);
Eric Laurent81784c32012-11-19 14:55:58 -0800149 }
150
Eric Laurent81784c32012-11-19 14:55:58 -0800151 const pid_t mPid;
152 const pid_t mTid;
153 const int32_t mPrio;
Mikhail Naganov83f04272017-02-07 10:45:09 -0800154 const bool mForApp;
Eric Laurent81784c32012-11-19 14:55:58 -0800155 };
156
Eric Laurent10351942014-05-08 18:49:52 -0700157 class PrioConfigEvent : public ConfigEvent {
158 public:
Mikhail Naganov83f04272017-02-07 10:45:09 -0800159 PrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp) :
Eric Laurent72e3f392015-05-20 14:43:50 -0700160 ConfigEvent(CFG_EVENT_PRIO, true) {
Mikhail Naganov83f04272017-02-07 10:45:09 -0800161 mData = new PrioConfigEventData(pid, tid, prio, forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700162 }
163 virtual ~PrioConfigEvent() {}
164 };
165
166 class SetParameterConfigEventData : public ConfigEventData {
167 public:
Andy Hung920f6572022-10-06 12:09:49 -0700168 explicit SetParameterConfigEventData(const String8& keyValuePairs) :
Eric Laurent10351942014-05-08 18:49:52 -0700169 mKeyValuePairs(keyValuePairs) {}
170
171 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200172 snprintf(buffer, size, "- KeyValue: %s\n", mKeyValuePairs.string());
Eric Laurent10351942014-05-08 18:49:52 -0700173 }
174
175 const String8 mKeyValuePairs;
176 };
177
178 class SetParameterConfigEvent : public ConfigEvent {
179 public:
Andy Hung920f6572022-10-06 12:09:49 -0700180 explicit SetParameterConfigEvent(const String8& keyValuePairs) :
Eric Laurent10351942014-05-08 18:49:52 -0700181 ConfigEvent(CFG_EVENT_SET_PARAMETER) {
182 mData = new SetParameterConfigEventData(keyValuePairs);
183 mWaitStatus = true;
184 }
185 virtual ~SetParameterConfigEvent() {}
186 };
187
Eric Laurent1c333e22014-05-20 10:48:17 -0700188 class CreateAudioPatchConfigEventData : public ConfigEventData {
189 public:
190 CreateAudioPatchConfigEventData(const struct audio_patch patch,
191 audio_patch_handle_t handle) :
192 mPatch(patch), mHandle(handle) {}
193
194 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200195 snprintf(buffer, size, "- Patch handle: %u\n", mHandle);
Eric Laurent1c333e22014-05-20 10:48:17 -0700196 }
197
198 const struct audio_patch mPatch;
199 audio_patch_handle_t mHandle;
200 };
201
202 class CreateAudioPatchConfigEvent : public ConfigEvent {
203 public:
204 CreateAudioPatchConfigEvent(const struct audio_patch patch,
205 audio_patch_handle_t handle) :
206 ConfigEvent(CFG_EVENT_CREATE_AUDIO_PATCH) {
207 mData = new CreateAudioPatchConfigEventData(patch, handle);
208 mWaitStatus = true;
209 }
210 virtual ~CreateAudioPatchConfigEvent() {}
211 };
212
213 class ReleaseAudioPatchConfigEventData : public ConfigEventData {
214 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700215 explicit ReleaseAudioPatchConfigEventData(const audio_patch_handle_t handle) :
Eric Laurent1c333e22014-05-20 10:48:17 -0700216 mHandle(handle) {}
217
218 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200219 snprintf(buffer, size, "- Patch handle: %u\n", mHandle);
Eric Laurent1c333e22014-05-20 10:48:17 -0700220 }
221
222 audio_patch_handle_t mHandle;
223 };
224
225 class ReleaseAudioPatchConfigEvent : public ConfigEvent {
226 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700227 explicit ReleaseAudioPatchConfigEvent(const audio_patch_handle_t handle) :
Eric Laurent1c333e22014-05-20 10:48:17 -0700228 ConfigEvent(CFG_EVENT_RELEASE_AUDIO_PATCH) {
229 mData = new ReleaseAudioPatchConfigEventData(handle);
230 mWaitStatus = true;
231 }
232 virtual ~ReleaseAudioPatchConfigEvent() {}
233 };
Eric Laurent81784c32012-11-19 14:55:58 -0800234
jiabinc52b1ff2019-10-31 17:20:42 -0700235 class UpdateOutDevicesConfigEventData : public ConfigEventData {
236 public:
237 explicit UpdateOutDevicesConfigEventData(const DeviceDescriptorBaseVector& outDevices) :
238 mOutDevices(outDevices) {}
239
240 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200241 snprintf(buffer, size, "- Devices: %s", android::toString(mOutDevices).c_str());
jiabinc52b1ff2019-10-31 17:20:42 -0700242 }
243
244 DeviceDescriptorBaseVector mOutDevices;
245 };
246
247 class UpdateOutDevicesConfigEvent : public ConfigEvent {
248 public:
249 explicit UpdateOutDevicesConfigEvent(const DeviceDescriptorBaseVector& outDevices) :
250 ConfigEvent(CFG_EVENT_UPDATE_OUT_DEVICE) {
251 mData = new UpdateOutDevicesConfigEventData(outDevices);
252 }
253
254 virtual ~UpdateOutDevicesConfigEvent();
255 };
256
Eric Laurentec376dc2021-04-08 20:41:22 +0200257 class ResizeBufferConfigEventData : public ConfigEventData {
258 public:
259 explicit ResizeBufferConfigEventData(int32_t maxSharedAudioHistoryMs) :
260 mMaxSharedAudioHistoryMs(maxSharedAudioHistoryMs) {}
261
262 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200263 snprintf(buffer, size, "- mMaxSharedAudioHistoryMs: %d", mMaxSharedAudioHistoryMs);
Eric Laurentec376dc2021-04-08 20:41:22 +0200264 }
265
266 int32_t mMaxSharedAudioHistoryMs;
267 };
268
269 class ResizeBufferConfigEvent : public ConfigEvent {
270 public:
271 explicit ResizeBufferConfigEvent(int32_t maxSharedAudioHistoryMs) :
272 ConfigEvent(CFG_EVENT_RESIZE_BUFFER) {
273 mData = new ResizeBufferConfigEventData(maxSharedAudioHistoryMs);
274 }
275
276 virtual ~ResizeBufferConfigEvent() {}
277 };
278
Eric Laurentb3f315a2021-07-13 15:09:05 +0200279 class CheckOutputStageEffectsEvent : public ConfigEvent {
280 public:
281 CheckOutputStageEffectsEvent() :
282 ConfigEvent(CFG_EVENT_CHECK_OUTPUT_STAGE_EFFECTS) {
283 }
284
285 virtual ~CheckOutputStageEffectsEvent() {}
286 };
287
Eric Laurent68a40a82022-05-03 18:15:04 +0200288 class HalLatencyModesChangedEvent : public ConfigEvent {
289 public:
290 HalLatencyModesChangedEvent() :
291 ConfigEvent(CFG_EVENT_HAL_LATENCY_MODES_CHANGED) {
292 }
293
294 virtual ~HalLatencyModesChangedEvent() {}
295 };
296
Eric Laurentb3f315a2021-07-13 15:09:05 +0200297
Eric Laurent81784c32012-11-19 14:55:58 -0800298 class PMDeathRecipient : public IBinder::DeathRecipient {
299 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700300 explicit PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800301 virtual ~PMDeathRecipient() {}
302
303 // IBinder::DeathRecipient
304 virtual void binderDied(const wp<IBinder>& who);
305
306 private:
Mikhail Naganovbf493082017-04-17 17:37:12 -0700307 DISALLOW_COPY_AND_ASSIGN(PMDeathRecipient);
Eric Laurent81784c32012-11-19 14:55:58 -0800308
309 wp<ThreadBase> mThread;
310 };
311
312 virtual status_t initCheck() const = 0;
313
314 // static externally-visible
315 type_t type() const { return mType; }
Eric Laurentf6870ae2015-05-08 10:50:03 -0700316 bool isDuplicating() const { return (mType == DUPLICATING); }
317
Eric Laurent81784c32012-11-19 14:55:58 -0800318 audio_io_handle_t id() const { return mId;}
319
320 // dynamic externally-visible
321 uint32_t sampleRate() const { return mSampleRate; }
Eric Laurent81784c32012-11-19 14:55:58 -0800322 audio_channel_mask_t channelMask() const { return mChannelMask; }
Eric Laurentf1f22e72021-07-13 14:04:14 +0200323 virtual audio_channel_mask_t mixerChannelMask() const { return mChannelMask; }
324
Andy Hung463be252014-07-10 16:56:07 -0700325 audio_format_t format() const { return mHALFormat; }
Eric Laurent83b88082014-06-20 18:31:16 -0700326 uint32_t channelCount() const { return mChannelCount; }
Eric Laurentf1f22e72021-07-13 14:04:14 +0200327
Eric Laurent81784c32012-11-19 14:55:58 -0800328 // Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects,
Glenn Kasten9b58f632013-07-16 11:37:48 -0700329 // and returns the [normal mix] buffer's frame count.
330 virtual size_t frameCount() const = 0;
jiabineb3bda02020-06-30 14:07:03 -0700331 virtual audio_channel_mask_t hapticChannelMask() const { return AUDIO_CHANNEL_NONE; }
Eric Laurent6b446ce2019-12-13 10:56:31 -0800332 virtual uint32_t latency_l() const { return 0; }
333 virtual void setVolumeForOutput_l(float left __unused, float right __unused) const {}
Glenn Kasten4a8308b2016-04-18 14:10:01 -0700334
335 // Return's the HAL's frame count i.e. fast mixer buffer size.
336 size_t frameCountHAL() const { return mFrameCount; }
337
Eric Laurentbfb1b832013-01-07 09:53:42 -0800338 size_t frameSize() const { return mFrameSize; }
Eric Laurent81784c32012-11-19 14:55:58 -0800339
340 // Should be "virtual status_t requestExitAndWait()" and override same
341 // method in Thread, but Thread::requestExitAndWait() is not yet virtual.
342 void exit();
Eric Laurent10351942014-05-08 18:49:52 -0700343 virtual bool checkForNewParameter_l(const String8& keyValuePair,
344 status_t& status) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800345 virtual status_t setParameters(const String8& keyValuePairs);
346 virtual String8 getParameters(const String8& keys) = 0;
Mikhail Naganov88536df2021-07-26 17:30:29 -0700347 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700348 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) = 0;
Eric Laurent10351942014-05-08 18:49:52 -0700349 // sendConfigEvent_l() must be called with ThreadBase::mLock held
350 // Can temporarily release the lock if waiting for a reply from
351 // processConfigEvents_l().
352 status_t sendConfigEvent_l(sp<ConfigEvent>& event);
Mikhail Naganov88536df2021-07-26 17:30:29 -0700353 void sendIoConfigEvent(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700354 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Mikhail Naganov88536df2021-07-26 17:30:29 -0700355 void sendIoConfigEvent_l(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700356 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Mikhail Naganov83f04272017-02-07 10:45:09 -0800357 void sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp);
358 void sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio, bool forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700359 status_t sendSetParameterConfigEvent_l(const String8& keyValuePair);
Eric Laurent1c333e22014-05-20 10:48:17 -0700360 status_t sendCreateAudioPatchConfigEvent(const struct audio_patch *patch,
361 audio_patch_handle_t *handle);
362 status_t sendReleaseAudioPatchConfigEvent(audio_patch_handle_t handle);
jiabinc52b1ff2019-10-31 17:20:42 -0700363 status_t sendUpdateOutDeviceConfigEvent(
364 const DeviceDescriptorBaseVector& outDevices);
Eric Laurentec376dc2021-04-08 20:41:22 +0200365 void sendResizeBufferConfigEvent_l(int32_t maxSharedAudioHistoryMs);
Eric Laurentb3f315a2021-07-13 15:09:05 +0200366 void sendCheckOutputStageEffectsEvent();
367 void sendCheckOutputStageEffectsEvent_l();
Eric Laurent68a40a82022-05-03 18:15:04 +0200368 void sendHalLatencyModesChangedEvent_l();
Eric Laurentb3f315a2021-07-13 15:09:05 +0200369
Eric Laurent021cf962014-05-13 10:18:14 -0700370 void processConfigEvents_l();
Eric Laurentb3f315a2021-07-13 15:09:05 +0200371 virtual void setCheckOutputStageEffects() {}
Eric Laurent10351942014-05-08 18:49:52 -0700372 virtual void cacheParameters_l() = 0;
Eric Laurent1c333e22014-05-20 10:48:17 -0700373 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
374 audio_patch_handle_t *handle) = 0;
375 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle) = 0;
jiabinc52b1ff2019-10-31 17:20:42 -0700376 virtual void updateOutDevices(const DeviceDescriptorBaseVector& outDevices);
Mikhail Naganovdc769682018-05-04 15:34:08 -0700377 virtual void toAudioPortConfig(struct audio_port_config *config) = 0;
Eric Laurent1c333e22014-05-20 10:48:17 -0700378
Eric Laurent5f0fd7b2021-05-07 16:33:26 +0200379 virtual void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs);
Eric Laurent81784c32012-11-19 14:55:58 -0800380
381 // see note at declaration of mStandby, mOutDevice and mInDevice
382 bool standby() const { return mStandby; }
jiabinc52b1ff2019-10-31 17:20:42 -0700383 const DeviceTypeSet outDeviceTypes() const {
384 return getAudioDeviceTypes(mOutDeviceTypeAddrs);
385 }
386 audio_devices_t inDeviceType() const { return mInDeviceTypeAddr.mType; }
387 DeviceTypeSet getDeviceTypes() const {
388 return isOutput() ? outDeviceTypes() : DeviceTypeSet({inDeviceType()});
389 }
Andy Hung293558a2017-03-21 12:19:20 -0700390
jiabin8f278ee2019-11-11 12:16:27 -0800391 const AudioDeviceTypeAddrVector& outDeviceTypeAddrs() const {
392 return mOutDeviceTypeAddrs;
393 }
394 const AudioDeviceTypeAddr& inDeviceTypeAddr() const {
395 return mInDeviceTypeAddr;
396 }
397
Andy Hungcf10d742020-04-28 15:38:24 -0700398 bool isOutput() const { return mIsOut; }
Eric Laurent81784c32012-11-19 14:55:58 -0800399
Andy Hungea840382020-05-05 21:50:17 -0700400 bool isOffloadOrMmap() const {
401 switch (mType) {
402 case OFFLOAD:
403 case MMAP_PLAYBACK:
404 case MMAP_CAPTURE:
405 return true;
406 default:
407 return false;
408 }
409 }
410
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700411 virtual sp<StreamHalInterface> stream() const = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800412
Andy Hung116bc262023-06-20 18:56:17 -0700413 sp<IAfEffectHandle> createEffect_l(
Andy Hung88035ac2023-06-27 17:05:02 -0700414 const sp<Client>& client,
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700415 const sp<media::IEffectClient>& effectClient,
Eric Laurent81784c32012-11-19 14:55:58 -0800416 int32_t priority,
Glenn Kastend848eb42016-03-08 13:42:11 -0800417 audio_session_t sessionId,
Eric Laurent81784c32012-11-19 14:55:58 -0800418 effect_descriptor_t *desc,
419 int *enabled,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800420 status_t *status /*non-NULL*/,
Eric Laurent2fe0acd2020-03-13 14:30:46 -0700421 bool pinned,
Eric Laurentde8caf42021-08-11 17:19:25 +0200422 bool probe,
423 bool notifyFramesProcessed);
Eric Laurent81784c32012-11-19 14:55:58 -0800424
425 // return values for hasAudioSession (bit field)
426 enum effect_state {
427 EFFECT_SESSION = 0x1, // the audio session corresponds to at least one
428 // effect
Eric Laurent4c415062016-06-17 16:14:16 -0700429 TRACK_SESSION = 0x2, // the audio session corresponds to at least one
Eric Laurent81784c32012-11-19 14:55:58 -0800430 // track
Eric Laurentb62d0362021-10-26 17:40:18 +0200431 FAST_SESSION = 0x4, // the audio session corresponds to at least one
Eric Laurent4c415062016-06-17 16:14:16 -0700432 // fast track
jiabinc658e452022-10-21 20:52:21 +0000433 SPATIALIZED_SESSION = 0x8, // the audio session corresponds to at least one
434 // spatialized track
435 BIT_PERFECT_SESSION = 0x10 // the audio session corresponds to at least one
436 // bit-perfect track
Eric Laurent81784c32012-11-19 14:55:58 -0800437 };
438
439 // get effect chain corresponding to session Id.
Andy Hung116bc262023-06-20 18:56:17 -0700440 sp<IAfEffectChain> getEffectChain(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800441 // same as getEffectChain() but must be called with ThreadBase mutex locked
Andy Hung116bc262023-06-20 18:56:17 -0700442 sp<IAfEffectChain> getEffectChain_l(audio_session_t sessionId) const;
Eric Laurent6c796322019-04-09 14:13:17 -0700443 std::vector<int> getEffectIds_l(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800444 // add an effect chain to the chain list (mEffectChains)
Andy Hung116bc262023-06-20 18:56:17 -0700445 virtual status_t addEffectChain_l(const sp<IAfEffectChain>& chain) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800446 // remove an effect chain from the chain list (mEffectChains)
Andy Hung116bc262023-06-20 18:56:17 -0700447 virtual size_t removeEffectChain_l(const sp<IAfEffectChain>& chain) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800448 // lock all effect chains Mutexes. Must be called before releasing the
449 // ThreadBase mutex before processing the mixer and effects. This guarantees the
450 // integrity of the chains during the process.
451 // Also sets the parameter 'effectChains' to current value of mEffectChains.
Andy Hung116bc262023-06-20 18:56:17 -0700452 void lockEffectChains_l(Vector<sp<IAfEffectChain>>& effectChains);
Eric Laurent81784c32012-11-19 14:55:58 -0800453 // unlock effect chains after process
Andy Hung116bc262023-06-20 18:56:17 -0700454 void unlockEffectChains(const Vector<sp<IAfEffectChain>>& effectChains);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800455 // get a copy of mEffectChains vector
Andy Hung116bc262023-06-20 18:56:17 -0700456 Vector<sp<IAfEffectChain>> getEffectChains_l() const { return mEffectChains; };
Eric Laurent81784c32012-11-19 14:55:58 -0800457 // set audio mode to all effect chains
458 void setMode(audio_mode_t mode);
459 // get effect module with corresponding ID on specified audio session
Andy Hung116bc262023-06-20 18:56:17 -0700460 sp<IAfEffectModule> getEffect(audio_session_t sessionId, int effectId);
461 sp<IAfEffectModule> getEffect_l(audio_session_t sessionId, int effectId);
Eric Laurent81784c32012-11-19 14:55:58 -0800462 // add and effect module. Also creates the effect chain is none exists for
Eric Laurent6c796322019-04-09 14:13:17 -0700463 // the effects audio session. Only called in a context of moving an effect
464 // from one thread to another
Andy Hung116bc262023-06-20 18:56:17 -0700465 status_t addEffect_l(const sp<IAfEffectModule>& effect);
Eric Laurent81784c32012-11-19 14:55:58 -0800466 // remove and effect module. Also removes the effect chain is this was the last
467 // effect
Andy Hung116bc262023-06-20 18:56:17 -0700468 void removeEffect_l(const sp<IAfEffectModule>& effect, bool release = false);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800469 // disconnect an effect handle from module and destroy module if last handle
Andy Hung116bc262023-06-20 18:56:17 -0700470 void disconnectEffectHandle(IAfEffectHandle *handle, bool unpinIfLast);
Eric Laurent81784c32012-11-19 14:55:58 -0800471 // detach all tracks connected to an auxiliary effect
Glenn Kasten0f11b512014-01-31 16:18:54 -0800472 virtual void detachAuxEffect_l(int effectId __unused) {}
Eric Laurent4c415062016-06-17 16:14:16 -0700473 // returns a combination of:
474 // - EFFECT_SESSION if effects on this audio session exist in one chain
475 // - TRACK_SESSION if tracks on this audio session exist
476 // - FAST_SESSION if fast tracks on this audio session exist
Eric Laurentb62d0362021-10-26 17:40:18 +0200477 // - SPATIALIZED_SESSION if spatialized tracks on this audio session exist
Eric Laurent4c415062016-06-17 16:14:16 -0700478 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const = 0;
479 uint32_t hasAudioSession(audio_session_t sessionId) const {
480 Mutex::Autolock _l(mLock);
481 return hasAudioSession_l(sessionId);
482 }
483
Andy Hungc3d62f92019-03-14 13:38:51 -0700484 template <typename T>
485 uint32_t hasAudioSession_l(audio_session_t sessionId, const T& tracks) const {
486 uint32_t result = 0;
487 if (getEffectChain_l(sessionId) != 0) {
488 result = EFFECT_SESSION;
489 }
490 for (size_t i = 0; i < tracks.size(); ++i) {
491 const sp<TrackBase>& track = tracks[i];
492 if (sessionId == track->sessionId()
493 && !track->isInvalid() // not yet removed from tracks.
494 && !track->isTerminated()) {
495 result |= TRACK_SESSION;
496 if (track->isFastTrack()) {
497 result |= FAST_SESSION; // caution, only represents first track.
498 }
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200499 if (track->isSpatialized()) {
Eric Laurentb62d0362021-10-26 17:40:18 +0200500 result |= SPATIALIZED_SESSION; // caution, only first track.
501 }
jiabinc658e452022-10-21 20:52:21 +0000502 if (track->isBitPerfect()) {
503 result |= BIT_PERFECT_SESSION;
504 }
Andy Hungc3d62f92019-03-14 13:38:51 -0700505 break;
506 }
507 }
508 return result;
509 }
510
Eric Laurent81784c32012-11-19 14:55:58 -0800511 // the value returned by default implementation is not important as the
512 // strategy is only meaningful for PlaybackThread which implements this method
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800513 virtual product_strategy_t getStrategyForSession_l(
514 audio_session_t sessionId __unused) {
515 return static_cast<product_strategy_t>(0);
516 }
Eric Laurent81784c32012-11-19 14:55:58 -0800517
Eric Laurent81784c32012-11-19 14:55:58 -0800518 // check if some effects must be suspended/restored when an effect is enabled
519 // or disabled
Eric Laurent6b446ce2019-12-13 10:56:31 -0800520 void checkSuspendOnEffectEnabled(bool enabled,
521 audio_session_t sessionId,
522 bool threadLocked);
Eric Laurent81784c32012-11-19 14:55:58 -0800523
Andy Hung068e08e2023-05-15 19:02:55 -0700524 virtual status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) = 0;
525 virtual bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800526
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700527 // Return a reference to a per-thread heap which can be used to allocate IMemory
528 // objects that will be read-only to client processes, read/write to mediaserver,
529 // and shared by all client processes of the thread.
530 // The heap is per-thread rather than common across all threads, because
531 // clients can't be trusted not to modify the offset of the IMemory they receive.
532 // If a thread does not have such a heap, this method returns 0.
533 virtual sp<MemoryDealer> readOnlyHeap() const { return 0; }
Eric Laurent81784c32012-11-19 14:55:58 -0800534
Glenn Kasten6181ffd2014-05-13 10:41:52 -0700535 virtual sp<IMemory> pipeMemory() const { return 0; }
536
Eric Laurent72e3f392015-05-20 14:43:50 -0700537 void systemReady();
538
Eric Laurent4c415062016-06-17 16:14:16 -0700539 // checkEffectCompatibility_l() must be called with ThreadBase::mLock held
540 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
541 audio_session_t sessionId) = 0;
542
Eric Laurent6acd1d42017-01-04 14:23:29 -0800543 void broadcast_l();
544
Andy Hungc8fddf32018-08-08 18:32:37 -0700545 virtual bool isTimestampCorrectionEnabled() const { return false; }
546
547 bool isMsdDevice() const { return mIsMsdDevice; }
548
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700549 void dump(int fd, const Vector<String16>& args);
Andy Hungdc099c22018-09-18 13:46:39 -0700550
Andy Hungd0979812019-02-21 15:51:44 -0800551 // deliver stats to mediametrics.
552 void sendStatistics(bool force);
553
Eric Laurent81784c32012-11-19 14:55:58 -0800554 mutable Mutex mLock;
555
Andy Hung116bc262023-06-20 18:56:17 -0700556 void onEffectEnable(const sp<IAfEffectModule>& effect);
Eric Laurent6b446ce2019-12-13 10:56:31 -0800557 void onEffectDisable();
558
jiabineb3bda02020-06-30 14:07:03 -0700559 // invalidateTracksForAudioSession_l must be called with holding mLock.
560 virtual void invalidateTracksForAudioSession_l(audio_session_t sessionId __unused) const { }
561 // Invalidate all the tracks with the given audio session.
562 void invalidateTracksForAudioSession(audio_session_t sessionId) const {
563 Mutex::Autolock _l(mLock);
564 invalidateTracksForAudioSession_l(sessionId);
565 }
566
567 template <typename T>
568 void invalidateTracksForAudioSession_l(audio_session_t sessionId,
569 const T& tracks) const {
570 for (size_t i = 0; i < tracks.size(); ++i) {
571 const sp<TrackBase>& track = tracks[i];
572 if (sessionId == track->sessionId()) {
573 track->invalidate();
574 }
575 }
576 }
577
Jasmine Chaeaa10e42021-05-11 10:11:14 +0800578 virtual bool isStreamInitialized() = 0;
579
Vlad Popa6fbbfbf2023-02-22 15:05:43 +0100580 virtual void startMelComputation_l(const sp<audio_utils::MelProcessor>& processor);
581 virtual void stopMelComputation_l();
582
Eric Laurent81784c32012-11-19 14:55:58 -0800583protected:
584
585 // entry describing an effect being suspended in mSuspendedSessions keyed vector
586 class SuspendedSessionDesc : public RefBase {
587 public:
588 SuspendedSessionDesc() : mRefCount(0) {}
589
590 int mRefCount; // number of active suspend requests
591 effect_uuid_t mType; // effect type UUID
592 };
593
Andy Hungdae27702016-10-31 14:01:16 -0700594 void acquireWakeLock();
595 virtual void acquireWakeLock_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800596 void releaseWakeLock();
597 void releaseWakeLock_l();
Andy Hungd01b0f12016-11-07 16:10:30 -0800598 void updateWakeLockUids_l(const SortedVector<uid_t> &uids);
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800599 void getPowerManager_l();
Eric Laurentd8365c52017-07-16 15:27:05 -0700600 // suspend or restore effects of the specified type (or all if type is NULL)
601 // on a given session. The number of suspend requests is counted and restore
602 // occurs when all suspend requests are cancelled.
Eric Laurent81784c32012-11-19 14:55:58 -0800603 void setEffectSuspended_l(const effect_uuid_t *type,
604 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -0800605 audio_session_t sessionId);
Eric Laurentd8365c52017-07-16 15:27:05 -0700606 // updated mSuspendedSessions when an effect is suspended or restored
Eric Laurent81784c32012-11-19 14:55:58 -0800607 void updateSuspendedSessions_l(const effect_uuid_t *type,
608 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -0800609 audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800610 // check if some effects must be suspended when an effect chain is added
Andy Hung116bc262023-06-20 18:56:17 -0700611 void checkSuspendOnAddEffectChain_l(const sp<IAfEffectChain>& chain);
Eric Laurent81784c32012-11-19 14:55:58 -0800612
Kevin Rocard069c2712018-03-29 19:09:14 -0700613 // sends the metadata of the active tracks to the HAL
Vlad Popa7e81cea2023-01-19 16:34:16 +0100614 struct MetadataUpdate {
615 std::vector<playback_track_metadata_v7_t> playbackMetadataUpdate;
616 std::vector<record_track_metadata_v7_t> recordMetadataUpdate;
617 };
618 virtual MetadataUpdate updateMetadata_l() = 0;
Kevin Rocard069c2712018-03-29 19:09:14 -0700619
Narayan Kamath014e7fa2013-10-14 15:03:38 +0100620 String16 getWakeLockTag();
621
Eric Laurent81784c32012-11-19 14:55:58 -0800622 virtual void preExit() { }
Andy Hung2ddee192015-12-18 17:34:44 -0800623 virtual void setMasterMono_l(bool mono __unused) { }
624 virtual bool requireMonoBlend() { return false; }
Eric Laurent81784c32012-11-19 14:55:58 -0800625
Andy Hung1c86ebe2018-05-29 20:29:08 -0700626 // called within the threadLoop to obtain timestamp from the HAL.
627 virtual status_t threadloop_getHalTimestamp_l(
628 ExtendedTimestamp *timestamp __unused) const {
629 return INVALID_OPERATION;
630 }
Andy Hung116bc262023-06-20 18:56:17 -0700631public:
632// TODO(b/288339104) organize with publics
Eric Laurentd66d7a12021-07-13 13:35:32 +0200633 product_strategy_t getStrategyForStream(audio_stream_type_t stream) const;
Andy Hung116bc262023-06-20 18:56:17 -0700634protected:
Eric Laurentd66d7a12021-07-13 13:35:32 +0200635
Eric Laurentb0463942022-12-20 16:31:10 +0100636 virtual void onHalLatencyModesChanged_l() {}
637
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700638 virtual void dumpInternals_l(int fd __unused, const Vector<String16>& args __unused)
639 { }
640 virtual void dumpTracks_l(int fd __unused, const Vector<String16>& args __unused) { }
641
642
Vlad Popae8d99472022-06-30 16:02:48 +0200643 friend class AudioFlinger; // for mEffectChains and mAudioManager
Eric Laurent81784c32012-11-19 14:55:58 -0800644
645 const type_t mType;
646
647 // Used by parameters, config events, addTrack_l, exit
648 Condition mWaitWorkCV;
649
650 const sp<AudioFlinger> mAudioFlinger;
Andy Hungcf10d742020-04-28 15:38:24 -0700651 ThreadMetrics mThreadMetrics;
652 const bool mIsOut;
Glenn Kasten9b58f632013-07-16 11:37:48 -0700653
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800654 // updated by PlaybackThread::readOutputParameters_l() or
655 // RecordThread::readInputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -0800656 uint32_t mSampleRate;
657 size_t mFrameCount; // output HAL, direct output, record
Eric Laurent81784c32012-11-19 14:55:58 -0800658 audio_channel_mask_t mChannelMask;
Glenn Kastenf6ed4232013-07-16 11:16:27 -0700659 uint32_t mChannelCount;
Eric Laurent81784c32012-11-19 14:55:58 -0800660 size_t mFrameSize;
Glenn Kasten97b7b752014-09-28 13:04:24 -0700661 // not HAL frame size, this is for output sink (to pipe to fast mixer)
Andy Hung463be252014-07-10 16:56:07 -0700662 audio_format_t mFormat; // Source format for Recording and
663 // Sink format for Playback.
664 // Sink format may be different than
665 // HAL format if Fastmixer is used.
666 audio_format_t mHALFormat;
Glenn Kasten70949c42013-08-06 07:40:12 -0700667 size_t mBufferSize; // HAL buffer size for read() or write()
jiabinc52b1ff2019-10-31 17:20:42 -0700668 AudioDeviceTypeAddrVector mOutDeviceTypeAddrs; // output device types and addresses
669 AudioDeviceTypeAddr mInDeviceTypeAddr; // input device type and address
Eric Laurent10351942014-05-08 18:49:52 -0700670 Vector< sp<ConfigEvent> > mConfigEvents;
Eric Laurent72e3f392015-05-20 14:43:50 -0700671 Vector< sp<ConfigEvent> > mPendingConfigEvents; // events awaiting system ready
Eric Laurent81784c32012-11-19 14:55:58 -0800672
673 // These fields are written and read by thread itself without lock or barrier,
jiabinc52b1ff2019-10-31 17:20:42 -0700674 // and read by other threads without lock or barrier via standby(), outDeviceTypes()
675 // and inDeviceType().
Eric Laurent81784c32012-11-19 14:55:58 -0800676 // Because of the absence of a lock or barrier, any other thread that reads
677 // these fields must use the information in isolation, or be prepared to deal
678 // with possibility that it might be inconsistent with other information.
Glenn Kasten4944acb2013-08-19 08:39:20 -0700679 bool mStandby; // Whether thread is currently in standby.
jiabinc52b1ff2019-10-31 17:20:42 -0700680
Eric Laurent296fb132015-05-01 11:38:42 -0700681 struct audio_patch mPatch;
jiabinc52b1ff2019-10-31 17:20:42 -0700682
Glenn Kastenf59497b2015-01-26 16:35:47 -0800683 audio_source_t mAudioSource;
Eric Laurent81784c32012-11-19 14:55:58 -0800684
685 const audio_io_handle_t mId;
Andy Hung116bc262023-06-20 18:56:17 -0700686 Vector<sp<IAfEffectChain>> mEffectChains;
Eric Laurent81784c32012-11-19 14:55:58 -0800687
Glenn Kastend7dca052015-03-05 16:05:54 -0800688 static const int kThreadNameLength = 16; // prctl(PR_SET_NAME) limit
689 char mThreadName[kThreadNameLength]; // guaranteed NUL-terminated
Chris Ye6597d732020-02-28 22:38:25 -0800690 sp<os::IPowerManager> mPowerManager;
Eric Laurent81784c32012-11-19 14:55:58 -0800691 sp<IBinder> mWakeLockToken;
692 const sp<PMDeathRecipient> mDeathRecipient;
Glenn Kastend848eb42016-03-08 13:42:11 -0800693 // list of suspended effects per session and per type. The first (outer) vector is
694 // keyed by session ID, the second (inner) by type UUID timeLow field
Eric Laurentd8365c52017-07-16 15:27:05 -0700695 // Updated by updateSuspendedSessions_l() only.
Glenn Kastend848eb42016-03-08 13:42:11 -0800696 KeyedVector< audio_session_t, KeyedVector< int, sp<SuspendedSessionDesc> > >
Eric Laurent81784c32012-11-19 14:55:58 -0800697 mSuspendedSessions;
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -0700698 // TODO: add comment and adjust size as needed
Glenn Kastenab7d72f2013-02-27 09:05:28 -0800699 static const size_t kLogSize = 4 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -0800700 sp<NBLog::Writer> mNBLogWriter;
Eric Laurent72e3f392015-05-20 14:43:50 -0700701 bool mSystemReady;
Andy Hung818e7a32016-02-16 18:08:07 -0800702 ExtendedTimestamp mTimestamp;
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700703 TimestampVerifier< // For timestamp statistics.
704 int64_t /* frame count */, int64_t /* time ns */> mTimestampVerifier;
Dean Wheatley12473e92021-03-18 23:00:55 +1100705 // DIRECT and OFFLOAD threads should reset frame count to zero on stop/flush
706 // TODO: add confirmation checks:
707 // 1) DIRECT threads and linear PCM format really resets to 0?
708 // 2) Is frame count really valid if not linear pcm?
709 // 3) Are all 64 bits of position returned, not just lowest 32 bits?
jiabinc52b1ff2019-10-31 17:20:42 -0700710 // Timestamp corrected device should be a single device.
711 audio_devices_t mTimestampCorrectedDevice = AUDIO_DEVICE_NONE;
Andy Hung446f4df2019-02-21 12:26:41 -0800712
713 // ThreadLoop statistics per iteration.
714 int64_t mLastIoBeginNs = -1;
715 int64_t mLastIoEndNs = -1;
716
Andy Hung44d648b2022-04-08 17:33:40 -0700717 // ThreadSnapshot is thread-safe (internally locked)
718 mediautils::ThreadSnapshot mThreadSnapshot;
719
Andy Hung446f4df2019-02-21 12:26:41 -0800720 // This should be read under ThreadBase lock (if not on the threadLoop thread).
721 audio_utils::Statistics<double> mIoJitterMs{0.995 /* alpha */};
722 audio_utils::Statistics<double> mProcessTimeMs{0.995 /* alpha */};
Andy Hunge6c37112019-02-26 17:38:10 -0800723 audio_utils::Statistics<double> mLatencyMs{0.995 /* alpha */};
Robert Wu06db0a32021-08-10 19:05:34 +0000724 audio_utils::Statistics<double> mMonopipePipeDepthStats{0.999 /* alpha */};
Andy Hung446f4df2019-02-21 12:26:41 -0800725
Andy Hungd0979812019-02-21 15:51:44 -0800726 // Save the last count when we delivered statistics to mediametrics.
727 int64_t mLastRecordedTimestampVerifierN = 0;
728 int64_t mLastRecordedTimeNs = 0; // BOOTTIME to include suspend.
729
Andy Hungc8fddf32018-08-08 18:32:37 -0700730 bool mIsMsdDevice = false;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800731 // A condition that must be evaluated by the thread loop has changed and
732 // we must not wait for async write callback in the thread loop before evaluating it
733 bool mSignalPending;
Andy Hungdae27702016-10-31 14:01:16 -0700734
Andy Hung8946a282018-04-19 20:04:56 -0700735#ifdef TEE_SINK
736 NBAIO_Tee mTee;
737#endif
Andy Hungdae27702016-10-31 14:01:16 -0700738 // ActiveTracks is a sorted vector of track type T representing the
739 // active tracks of threadLoop() to be considered by the locked prepare portion.
740 // ActiveTracks should be accessed with the ThreadBase lock held.
741 //
742 // During processing and I/O, the threadLoop does not hold the lock;
743 // hence it does not directly use ActiveTracks. Care should be taken
744 // to hold local strong references or defer removal of tracks
745 // if the threadLoop may still be accessing those tracks due to mix, etc.
746 //
747 // This class updates power information appropriately.
748 //
749
750 template <typename T>
751 class ActiveTracks {
752 public:
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700753 explicit ActiveTracks(SimpleLog *localLog = nullptr)
Andy Hungdae27702016-10-31 14:01:16 -0700754 : mActiveTracksGeneration(0)
755 , mLastActiveTracksGeneration(0)
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700756 , mLocalLog(localLog)
Andy Hungdae27702016-10-31 14:01:16 -0700757 { }
758
759 ~ActiveTracks() {
760 ALOGW_IF(!mActiveTracks.isEmpty(),
761 "ActiveTracks should be empty in destructor");
762 }
763 // returns the last track added (even though it may have been
764 // subsequently removed from ActiveTracks).
765 //
766 // Used for DirectOutputThread to ensure a flush is called when transitioning
767 // to a new track (even though it may be on the same session).
768 // Used for OffloadThread to ensure that volume and mixer state is
769 // taken from the latest track added.
770 //
771 // The latest track is saved with a weak pointer to prevent keeping an
772 // otherwise useless track alive. Thus the function will return nullptr
773 // if the latest track has subsequently been removed and destroyed.
774 sp<T> getLatest() {
775 return mLatestActiveTrack.promote();
776 }
777
778 // SortedVector methods
779 ssize_t add(const sp<T> &track);
780 ssize_t remove(const sp<T> &track);
781 size_t size() const {
782 return mActiveTracks.size();
783 }
Eric Tan39ec8d62018-07-24 09:49:29 -0700784 bool isEmpty() const {
785 return mActiveTracks.isEmpty();
786 }
Andy Hungdae27702016-10-31 14:01:16 -0700787 ssize_t indexOf(const sp<T>& item) {
788 return mActiveTracks.indexOf(item);
789 }
790 sp<T> operator[](size_t index) const {
791 return mActiveTracks[index];
792 }
793 typename SortedVector<sp<T>>::iterator begin() {
794 return mActiveTracks.begin();
795 }
796 typename SortedVector<sp<T>>::iterator end() {
797 return mActiveTracks.end();
798 }
799
800 // Due to Binder recursion optimization, clear() and updatePowerState()
801 // cannot be called from a Binder thread because they may call back into
802 // the original calling process (system server) for BatteryNotifier
803 // (which requires a Java environment that may not be present).
804 // Hence, call clear() and updatePowerState() only from the
805 // ThreadBase thread.
806 void clear();
807 // periodically called in the threadLoop() to update power state uids.
Andy Hung920f6572022-10-06 12:09:49 -0700808 void updatePowerState(const sp<ThreadBase>& thread, bool force = false);
Andy Hungdae27702016-10-31 14:01:16 -0700809
Kevin Rocardc86a7f72018-04-03 09:00:09 -0700810 /** @return true if one or move active tracks was added or removed since the
Jasmine Chaeaa10e42021-05-11 10:11:14 +0800811 * last time this function was called or the vector was created.
812 * true if volume of one of active tracks was changed.
813 */
Kevin Rocard069c2712018-03-29 19:09:14 -0700814 bool readAndClearHasChanged();
815
Eric Laurentdda206a2022-07-08 17:28:35 +0200816 /** Force updating track metadata to audio HAL stream next time
817 * readAndClearHasChanged() is called.
818 */
819 void setHasChanged() { mHasChanged = true; }
820
Andy Hungdae27702016-10-31 14:01:16 -0700821 private:
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700822 void logTrack(const char *funcName, const sp<T> &track) const;
823
Andy Hungd01b0f12016-11-07 16:10:30 -0800824 SortedVector<uid_t> getWakeLockUids() {
825 SortedVector<uid_t> wakeLockUids;
Andy Hungdae27702016-10-31 14:01:16 -0700826 for (const sp<T> &track : mActiveTracks) {
827 wakeLockUids.add(track->uid());
828 }
829 return wakeLockUids; // moved by underlying SharedBuffer
830 }
831
Andy Hungdae27702016-10-31 14:01:16 -0700832 SortedVector<sp<T>> mActiveTracks;
833 int mActiveTracksGeneration;
834 int mLastActiveTracksGeneration;
835 wp<T> mLatestActiveTrack; // latest track added to ActiveTracks
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700836 SimpleLog * const mLocalLog;
Kevin Rocardc86a7f72018-04-03 09:00:09 -0700837 // If the vector has changed since last call to readAndClearHasChanged
Kevin Rocard069c2712018-03-29 19:09:14 -0700838 bool mHasChanged = false;
Andy Hungdae27702016-10-31 14:01:16 -0700839 };
Andy Hung293558a2017-03-21 12:19:20 -0700840
841 SimpleLog mLocalLog;
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700842
843private:
844 void dumpBase_l(int fd, const Vector<String16>& args);
845 void dumpEffectChains_l(int fd, const Vector<String16>& args);
Eric Laurent81784c32012-11-19 14:55:58 -0800846};
847
Eric Laurent6acd1d42017-01-04 14:23:29 -0800848class VolumeInterface {
849 public:
850
851 virtual ~VolumeInterface() {}
852
853 virtual void setMasterVolume(float value) = 0;
854 virtual void setMasterMute(bool muted) = 0;
855 virtual void setStreamVolume(audio_stream_type_t stream, float value) = 0;
856 virtual void setStreamMute(audio_stream_type_t stream, bool muted) = 0;
857 virtual float streamVolume(audio_stream_type_t stream) const = 0;
858
859};
860
Eric Laurent81784c32012-11-19 14:55:58 -0800861// --- PlaybackThread ---
Eric Laurent6acd1d42017-01-04 14:23:29 -0800862class PlaybackThread : public ThreadBase, public StreamOutHalInterfaceCallback,
jiabinf6eb4c32020-02-25 14:06:25 -0800863 public VolumeInterface, public StreamOutHalInterfaceEventCallback {
Eric Laurent81784c32012-11-19 14:55:58 -0800864public:
865
866#include "PlaybackTracks.h"
867
868 enum mixer_state {
869 MIXER_IDLE, // no active tracks
870 MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready
Eric Laurentbfb1b832013-01-07 09:53:42 -0800871 MIXER_TRACKS_READY, // at least one active track, and at least one track has data
872 MIXER_DRAIN_TRACK, // drain currently playing track
873 MIXER_DRAIN_ALL, // fully drain the hardware
Eric Laurent81784c32012-11-19 14:55:58 -0800874 // standby mode does not have an enum value
875 // suspend by audio policy manager is orthogonal to mixer state
876 };
877
Eric Laurente93cc032016-05-05 10:15:10 -0700878 // retry count before removing active track in case of underrun on offloaded thread:
879 // we need to make sure that AudioTrack client has enough time to send large buffers
880 //FIXME may be more appropriate if expressed in time units. Need to revise how underrun is
881 // handled for offloaded tracks
882 static const int8_t kMaxTrackRetriesOffload = 20;
883 static const int8_t kMaxTrackStartupRetriesOffload = 100;
884 static const int8_t kMaxTrackStopRetriesOffload = 2;
Andy Hung8ed196a2018-01-05 13:21:11 -0800885 static constexpr uint32_t kMaxTracksPerUid = 40;
Andy Hung1bc088a2018-02-09 15:57:31 -0800886 static constexpr size_t kMaxTracks = 256;
Eric Laurente93cc032016-05-05 10:15:10 -0700887
rago1bb90822017-05-02 18:31:48 -0700888 // Maximum delay (in nanoseconds) for upcoming buffers in suspend mode, otherwise
889 // if delay is greater, the estimated time for timeLoopNextNs is reset.
890 // This allows for catch-up to be done for small delays, while resetting the estimate
891 // for initial conditions or large delays.
892 static const nsecs_t kMaxNextBufferDelayNs = 100000000;
893
Eric Laurent81784c32012-11-19 14:55:58 -0800894 PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurentf1f22e72021-07-13 14:04:14 +0200895 audio_io_handle_t id, type_t type, bool systemReady,
896 audio_config_base_t *mixerConfig = nullptr);
Eric Laurent81784c32012-11-19 14:55:58 -0800897 virtual ~PlaybackThread();
898
Eric Laurent81784c32012-11-19 14:55:58 -0800899 // Thread virtuals
Eric Laurent81784c32012-11-19 14:55:58 -0800900 virtual bool threadLoop();
901
902 // RefBase
903 virtual void onFirstRef();
904
Eric Laurent4c415062016-06-17 16:14:16 -0700905 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
906 audio_session_t sessionId);
907
Eric Laurent81784c32012-11-19 14:55:58 -0800908protected:
909 // Code snippets that were lifted up out of threadLoop()
910 virtual void threadLoop_mix() = 0;
911 virtual void threadLoop_sleepTime() = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800912 virtual ssize_t threadLoop_write();
913 virtual void threadLoop_drain();
Eric Laurent81784c32012-11-19 14:55:58 -0800914 virtual void threadLoop_standby();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800915 virtual void threadLoop_exit();
Eric Laurent81784c32012-11-19 14:55:58 -0800916 virtual void threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove);
917
918 // prepareTracks_l reads and writes mActiveTracks, and returns
919 // the pending set of tracks to remove via Vector 'tracksToRemove'. The caller
920 // is responsible for clearing or destroying this Vector later on, when it
921 // is safe to do so. That will drop the final ref count and destroy the tracks.
922 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove) = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800923 void removeTracks_l(const Vector< sp<Track> >& tracksToRemove);
Eric Laurenteab90452019-06-24 15:17:46 -0700924 status_t handleVoipVolume_l(float *volume);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800925
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700926 // StreamOutHalInterfaceCallback implementation
927 virtual void onWriteReady();
928 virtual void onDrainReady();
929 virtual void onError();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800930
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700931 void resetWriteBlocked(uint32_t sequence);
932 void resetDraining(uint32_t sequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800933
934 virtual bool waitingAsyncCallback();
935 virtual bool waitingAsyncCallback_l();
936 virtual bool shouldStandby_l();
Haynes Mathew George4c6a4332014-01-15 12:31:39 -0800937 virtual void onAddNewTrack_l();
Haynes Mathew George4527b9e2016-07-07 19:54:17 -0700938 void onAsyncError(); // error reported by AsyncCallbackThread
Eric Laurent81784c32012-11-19 14:55:58 -0800939
jiabinf6eb4c32020-02-25 14:06:25 -0800940 // StreamHalInterfaceCodecFormatCallback implementation
941 void onCodecFormatChanged(
942 const std::basic_string<uint8_t>& metadataBs) override;
943
Eric Laurent81784c32012-11-19 14:55:58 -0800944 // ThreadBase virtuals
945 virtual void preExit();
946
Eric Laurent64667972016-03-30 18:19:46 -0700947 virtual bool keepWakeLock() const { return true; }
Andy Hungdae27702016-10-31 14:01:16 -0700948 virtual void acquireWakeLock_l() {
949 ThreadBase::acquireWakeLock_l();
950 mActiveTracks.updatePowerState(this, true /* force */);
951 }
Eric Laurent64667972016-03-30 18:19:46 -0700952
Eric Laurentb3f315a2021-07-13 15:09:05 +0200953 virtual void checkOutputStageEffects() {}
Eric Laurent68a40a82022-05-03 18:15:04 +0200954 virtual void setHalLatencyMode_l() {}
955
Eric Laurentb3f315a2021-07-13 15:09:05 +0200956
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700957 void dumpInternals_l(int fd, const Vector<String16>& args) override;
958 void dumpTracks_l(int fd, const Vector<String16>& args) override;
959
Eric Laurent81784c32012-11-19 14:55:58 -0800960public:
961
962 virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; }
963
964 // return estimated latency in milliseconds, as reported by HAL
965 uint32_t latency() const;
966 // same, but lock must already be held
Eric Laurent6b446ce2019-12-13 10:56:31 -0800967 uint32_t latency_l() const override;
Eric Laurent81784c32012-11-19 14:55:58 -0800968
Eric Laurent6acd1d42017-01-04 14:23:29 -0800969 // VolumeInterface
970 virtual void setMasterVolume(float value);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +0100971 virtual void setMasterBalance(float balance);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800972 virtual void setMasterMute(bool muted);
973 virtual void setStreamVolume(audio_stream_type_t stream, float value);
974 virtual void setStreamMute(audio_stream_type_t stream, bool muted);
975 virtual float streamVolume(audio_stream_type_t stream) const;
Eric Laurent81784c32012-11-19 14:55:58 -0800976
Eric Laurent6b446ce2019-12-13 10:56:31 -0800977 void setVolumeForOutput_l(float left, float right) const override;
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +0900978
Eric Laurent81784c32012-11-19 14:55:58 -0800979 sp<Track> createTrack_l(
Andy Hung88035ac2023-06-27 17:05:02 -0700980 const sp<Client>& client,
Eric Laurent81784c32012-11-19 14:55:58 -0800981 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700982 const audio_attributes_t& attr,
Eric Laurent21da6472017-11-09 16:29:26 -0800983 uint32_t *sampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -0800984 audio_format_t format,
985 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -0800986 size_t *pFrameCount,
Eric Laurent21da6472017-11-09 16:29:26 -0800987 size_t *pNotificationFrameCount,
988 uint32_t notificationsPerBuffer,
989 float speed,
Eric Laurent81784c32012-11-19 14:55:58 -0800990 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -0800991 audio_session_t sessionId,
Eric Laurent05067782016-06-01 18:27:28 -0700992 audio_output_flags_t *flags,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700993 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +0000994 const AttributionSourceState& attributionSource,
Eric Laurent81784c32012-11-19 14:55:58 -0800995 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800996 status_t *status /*non-NULL*/,
jiabinf6eb4c32020-02-25 14:06:25 -0800997 audio_port_handle_t portId,
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200998 const sp<media::IAudioTrackCallback>& callback,
jiabinc658e452022-10-21 20:52:21 +0000999 bool isSpatialized,
1000 bool isBitPerfect);
Eric Laurent81784c32012-11-19 14:55:58 -08001001
1002 AudioStreamOut* getOutput() const;
1003 AudioStreamOut* clearOutput();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07001004 virtual sp<StreamHalInterface> stream() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001005
1006 // a very large number of suspend() will eventually wraparound, but unlikely
1007 void suspend() { (void) android_atomic_inc(&mSuspended); }
1008 void restore()
1009 {
1010 // if restore() is done without suspend(), get back into
1011 // range so that the next suspend() will operate correctly
1012 if (android_atomic_dec(&mSuspended) <= 0) {
1013 android_atomic_release_store(0, &mSuspended);
1014 }
1015 }
1016 bool isSuspended() const
1017 { return android_atomic_acquire_load(&mSuspended) > 0; }
1018
1019 virtual String8 getParameters(const String8& keys);
Mikhail Naganov88536df2021-07-26 17:30:29 -07001020 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -07001021 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Kévin PETIT377b2ec2014-02-03 12:35:36 +00001022 status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames);
Andy Hung010a1a12014-03-13 13:57:33 -07001023 // Consider also removing and passing an explicit mMainBuffer initialization
1024 // parameter to AF::PlaybackThread::Track::Track().
Andy Hung319587b2023-05-23 14:01:03 -07001025 float *sinkBuffer() const {
1026 return reinterpret_cast<float *>(mSinkBuffer); };
Eric Laurent81784c32012-11-19 14:55:58 -08001027
1028 virtual void detachAuxEffect_l(int effectId);
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001029 status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track>& track,
Eric Laurent81784c32012-11-19 14:55:58 -08001030 int EffectId);
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001031 status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track>& track,
Eric Laurent81784c32012-11-19 14:55:58 -08001032 int EffectId);
1033
Andy Hung116bc262023-06-20 18:56:17 -07001034 virtual status_t addEffectChain_l(const sp<IAfEffectChain>& chain);
1035 virtual size_t removeEffectChain_l(const sp<IAfEffectChain>& chain);
Andy Hungc3d62f92019-03-14 13:38:51 -07001036 uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
1037 return ThreadBase::hasAudioSession_l(sessionId, mTracks);
1038 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001039 virtual product_strategy_t getStrategyForSession_l(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -08001040
1041
Andy Hung068e08e2023-05-15 19:02:55 -07001042 status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) override;
1043 bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const override;
Glenn Kastenfb1fdc92013-07-10 17:03:19 -07001044
1045 // called with AudioFlinger lock held
Eric Laurent13084622016-05-17 10:51:49 -07001046 bool invalidateTracks_l(audio_stream_type_t streamType);
jiabinc44b3462022-12-08 12:52:31 -08001047 bool invalidateTracks_l(std::set<audio_port_handle_t>& portIds);
Haynes Mathew George05317d22016-05-03 16:34:26 -07001048 virtual void invalidateTracks(audio_stream_type_t streamType);
jiabinc44b3462022-12-08 12:52:31 -08001049 // Invalidate tracks by a set of port ids. The port id will be removed from
1050 // the given set if the corresponding track is found and invalidated.
1051 virtual void invalidateTracks(std::set<audio_port_handle_t>& portIds);
Eric Laurent81784c32012-11-19 14:55:58 -08001052
Glenn Kasten9b58f632013-07-16 11:37:48 -07001053 virtual size_t frameCount() const { return mNormalFrameCount; }
1054
Eric Laurentf1f22e72021-07-13 14:04:14 +02001055 audio_channel_mask_t mixerChannelMask() const override {
1056 return mMixerChannelMask;
1057 }
1058
Eric Laurent83b88082014-06-20 18:31:16 -07001059 status_t getTimestamp_l(AudioTimestamp& timestamp);
1060
1061 void addPatchTrack(const sp<PatchTrack>& track);
1062 void deletePatchTrack(const sp<PatchTrack>& track);
1063
Mikhail Naganovdc769682018-05-04 15:34:08 -07001064 virtual void toAudioPortConfig(struct audio_port_config *config);
Eric Laurentaccc1472013-09-20 09:36:34 -07001065
Andy Hung10cbff12017-02-21 17:30:14 -08001066 // Return the asynchronous signal wait time.
1067 virtual int64_t computeWaitTimeNs_l() const { return INT64_MAX; }
Andy Hung1bc088a2018-02-09 15:57:31 -08001068 // returns true if the track is allowed to be added to the thread.
1069 virtual bool isTrackAllowed_l(
1070 audio_channel_mask_t channelMask __unused,
1071 audio_format_t format __unused,
1072 audio_session_t sessionId __unused,
1073 uid_t uid) const {
1074 return trackCountForUid_l(uid) < PlaybackThread::kMaxTracksPerUid
1075 && mTracks.size() < PlaybackThread::kMaxTracks;
1076 }
1077
Andy Hungc8fddf32018-08-08 18:32:37 -07001078 bool isTimestampCorrectionEnabled() const override {
jiabinc52b1ff2019-10-31 17:20:42 -07001079 return audio_is_output_devices(mTimestampCorrectedDevice)
1080 && outDeviceTypes().count(mTimestampCorrectedDevice) != 0;
Andy Hungc8fddf32018-08-08 18:32:37 -07001081 }
jiabinc52b1ff2019-10-31 17:20:42 -07001082
Jasmine Chaeaa10e42021-05-11 10:11:14 +08001083 virtual bool isStreamInitialized() {
1084 return !(mOutput == nullptr || mOutput->stream == nullptr);
1085 }
1086
jiabineb3bda02020-06-30 14:07:03 -07001087 audio_channel_mask_t hapticChannelMask() const override {
1088 return mHapticChannelMask;
1089 }
1090 bool supportsHapticPlayback() const {
1091 return (mHapticChannelMask & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE;
1092 }
1093
Eric Laurent74c38dc2020-12-23 18:19:44 +01001094 void setDownStreamPatch(const struct audio_patch *patch) {
1095 Mutex::Autolock _l(mLock);
1096 mDownStreamPatch = *patch;
1097 }
1098
jiabinf042b9b2021-05-07 23:46:28 +00001099 PlaybackThread::Track* getTrackById_l(audio_port_handle_t trackId);
1100
Eric Laurentb3f315a2021-07-13 15:09:05 +02001101 bool hasMixer() const {
Eric Laurent1c5e2e32021-08-18 18:50:28 +02001102 return mType == MIXER || mType == DUPLICATING || mType == SPATIALIZER;
Eric Laurentb3f315a2021-07-13 15:09:05 +02001103 }
Eric Laurent68a40a82022-05-03 18:15:04 +02001104
1105 virtual status_t setRequestedLatencyMode(
1106 audio_latency_mode_t mode __unused) { return INVALID_OPERATION; }
1107
1108 virtual status_t getSupportedLatencyModes(
1109 std::vector<audio_latency_mode_t>* modes __unused) {
1110 return INVALID_OPERATION;
1111 }
1112
Eric Laurentb0463942022-12-20 16:31:10 +01001113 virtual status_t setBluetoothVariableLatencyEnabled(bool enabled __unused) {
1114 return INVALID_OPERATION;
1115 }
Eric Laurent52057642022-12-16 11:45:07 +01001116
Vlad Popa6fbbfbf2023-02-22 15:05:43 +01001117 void startMelComputation_l(const sp<audio_utils::MelProcessor>& processor) override;
1118 void stopMelComputation_l() override;
Vlad Popab042ee62022-10-20 18:05:00 +02001119
Eric Laurent19952e12023-04-20 10:08:29 +02001120 void setStandby() {
1121 Mutex::Autolock _l(mLock);
1122 setStandby_l();
1123 }
1124
1125 void setStandby_l() {
1126 mStandby = true;
1127 mHalStarted = false;
1128 mKernelPositionOnStandby =
1129 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
1130 }
1131
1132 bool waitForHalStart() {
1133 Mutex::Autolock _l(mLock);
1134 static const nsecs_t kWaitHalTimeoutNs = seconds(2);
1135 nsecs_t endWaitTimetNs = systemTime() + kWaitHalTimeoutNs;
1136 while (!mHalStarted) {
1137 nsecs_t timeNs = systemTime();
1138 if (timeNs >= endWaitTimetNs) {
1139 break;
1140 }
1141 nsecs_t waitTimeLeftNs = endWaitTimetNs - timeNs;
1142 mWaitHalStartCV.waitRelative(mLock, waitTimeLeftNs);
1143 }
1144 return mHalStarted;
1145 }
Eric Laurent81784c32012-11-19 14:55:58 -08001146protected:
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001147 // updated by readOutputParameters_l()
Glenn Kasten9b58f632013-07-16 11:37:48 -07001148 size_t mNormalFrameCount; // normal mixer and effects
1149
Andy Hung08fb1742015-05-31 23:22:10 -07001150 bool mThreadThrottle; // throttle the thread processing
Andy Hung40eb1a12015-06-18 13:42:02 -07001151 uint32_t mThreadThrottleTimeMs; // throttle time for MIXER threads
1152 uint32_t mThreadThrottleEndMs; // notify once per throttling
Andy Hung08fb1742015-05-31 23:22:10 -07001153 uint32_t mHalfBufferMs; // half the buffer size in milliseconds
1154
Andy Hung010a1a12014-03-13 13:57:33 -07001155 void* mSinkBuffer; // frame size aligned sink buffer
Eric Laurent81784c32012-11-19 14:55:58 -08001156
Andy Hung98ef9782014-03-04 14:46:50 -08001157 // TODO:
1158 // Rearrange the buffer info into a struct/class with
1159 // clear, copy, construction, destruction methods.
1160 //
1161 // mSinkBuffer also has associated with it:
1162 //
1163 // mSinkBufferSize: Sink Buffer Size
1164 // mFormat: Sink Buffer Format
1165
Andy Hung69aed5f2014-02-25 17:24:40 -08001166 // Mixer Buffer (mMixerBuffer*)
1167 //
1168 // In the case of floating point or multichannel data, which is not in the
1169 // sink format, it is required to accumulate in a higher precision or greater channel count
1170 // buffer before downmixing or data conversion to the sink buffer.
1171
1172 // Set to "true" to enable the Mixer Buffer otherwise mixer output goes to sink buffer.
1173 bool mMixerBufferEnabled;
1174
1175 // Storage, 32 byte aligned (may make this alignment a requirement later).
1176 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
1177 void* mMixerBuffer;
1178
1179 // Size of mMixerBuffer in bytes: mNormalFrameCount * #channels * sampsize.
1180 size_t mMixerBufferSize;
1181
1182 // The audio format of mMixerBuffer. Set to AUDIO_FORMAT_PCM_(FLOAT|16_BIT) only.
1183 audio_format_t mMixerBufferFormat;
1184
1185 // An internal flag set to true by MixerThread::prepareTracks_l()
1186 // when mMixerBuffer contains valid data after mixing.
1187 bool mMixerBufferValid;
1188
Andy Hung98ef9782014-03-04 14:46:50 -08001189 // Effects Buffer (mEffectsBuffer*)
1190 //
1191 // In the case of effects data, which is not in the sink format,
1192 // it is required to accumulate in a different buffer before data conversion
1193 // to the sink buffer.
1194
1195 // Set to "true" to enable the Effects Buffer otherwise effects output goes to sink buffer.
1196 bool mEffectBufferEnabled;
1197
1198 // Storage, 32 byte aligned (may make this alignment a requirement later).
1199 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
1200 void* mEffectBuffer;
1201
1202 // Size of mEffectsBuffer in bytes: mNormalFrameCount * #channels * sampsize.
1203 size_t mEffectBufferSize;
1204
1205 // The audio format of mEffectsBuffer. Set to AUDIO_FORMAT_PCM_16_BIT only.
1206 audio_format_t mEffectBufferFormat;
1207
1208 // An internal flag set to true by MixerThread::prepareTracks_l()
1209 // when mEffectsBuffer contains valid data after mixing.
1210 //
1211 // When this is set, all mixer data is routed into the effects buffer
1212 // for any processing (including output processing).
1213 bool mEffectBufferValid;
1214
jiabinc658e452022-10-21 20:52:21 +00001215 // Set to "true" to enable when data has already copied to sink
1216 bool mHasDataCopiedToSinkBuffer = false;
1217
Eric Laurentb62d0362021-10-26 17:40:18 +02001218 // Frame size aligned buffer used as input and output to all post processing effects
1219 // except the Spatializer in a SPATIALIZER thread. Non spatialized tracks are mixed into
1220 // this buffer so that post processing effects can be applied.
1221 void* mPostSpatializerBuffer = nullptr;
1222
1223 // Size of mPostSpatializerBuffer in bytes
1224 size_t mPostSpatializerBufferSize;
Eric Laurent39095982021-08-24 18:29:27 +02001225
1226
Eric Laurent81784c32012-11-19 14:55:58 -08001227 // suspend count, > 0 means suspended. While suspended, the thread continues to pull from
1228 // tracks and mix, but doesn't write to HAL. A2DP and SCO HAL implementations can't handle
1229 // concurrent use of both of them, so Audio Policy Service suspends one of the threads to
1230 // workaround that restriction.
1231 // 'volatile' means accessed via atomic operations and no lock.
1232 volatile int32_t mSuspended;
1233
Andy Hung818e7a32016-02-16 18:08:07 -08001234 int64_t mBytesWritten;
yucliu6cfb5932022-07-20 17:40:39 -07001235 std::atomic<int64_t> mFramesWritten; // not reset on standby
Dean Wheatley12473e92021-03-18 23:00:55 +11001236 int64_t mLastFramesWritten = -1; // track changes in timestamp
1237 // server frames written.
Andy Hung238fa3d2016-07-28 10:53:22 -07001238 int64_t mSuspendedFrames; // not reset on standby
jiabin245cdd92018-12-07 17:55:15 -08001239
1240 // mHapticChannelMask and mHapticChannelCount will only be valid when the thread support
1241 // haptic playback.
1242 audio_channel_mask_t mHapticChannelMask = AUDIO_CHANNEL_NONE;
1243 uint32_t mHapticChannelCount = 0;
Eric Laurentf1f22e72021-07-13 14:04:14 +02001244
1245 audio_channel_mask_t mMixerChannelMask = AUDIO_CHANNEL_NONE;
1246
Eric Laurent81784c32012-11-19 14:55:58 -08001247private:
1248 // mMasterMute is in both PlaybackThread and in AudioFlinger. When a
1249 // PlaybackThread needs to find out if master-muted, it checks it's local
1250 // copy rather than the one in AudioFlinger. This optimization saves a lock.
1251 bool mMasterMute;
1252 void setMasterMute_l(bool muted) { mMasterMute = muted; }
Dean Wheatley12473e92021-03-18 23:00:55 +11001253
1254 auto discontinuityForStandbyOrFlush() const { // call on threadLoop or with lock.
1255 return ((mType == DIRECT && !audio_is_linear_pcm(mFormat))
1256 || mType == OFFLOAD)
1257 ? mTimestampVerifier.DISCONTINUITY_MODE_ZERO
1258 : mTimestampVerifier.DISCONTINUITY_MODE_CONTINUOUS;
1259 }
1260
Eric Laurent81784c32012-11-19 14:55:58 -08001261protected:
Andy Hungdae27702016-10-31 14:01:16 -07001262 ActiveTracks<Track> mActiveTracks;
Eric Laurent81784c32012-11-19 14:55:58 -08001263
Eric Laurent81784c32012-11-19 14:55:58 -08001264 // Time to sleep between cycles when:
1265 virtual uint32_t activeSleepTimeUs() const; // mixer state MIXER_TRACKS_ENABLED
1266 virtual uint32_t idleSleepTimeUs() const = 0; // mixer state MIXER_IDLE
1267 virtual uint32_t suspendSleepTimeUs() const = 0; // audio policy manager suspended us
1268 // No sleep when mixer state == MIXER_TRACKS_READY; relies on audio HAL stream->write()
1269 // No sleep in standby mode; waits on a condition
1270
1271 // Code snippets that are temporarily lifted up out of threadLoop() until the merge
1272 void checkSilentMode_l();
1273
1274 // Non-trivial for DUPLICATING only
1275 virtual void saveOutputTracks() { }
1276 virtual void clearOutputTracks() { }
1277
1278 // Cache various calculated values, at threadLoop() entry and after a parameter change
1279 virtual void cacheParameters_l();
Eric Laurentb3f315a2021-07-13 15:09:05 +02001280 void setCheckOutputStageEffects() override {
1281 mCheckOutputStageEffects.store(true);
1282 }
Eric Laurent81784c32012-11-19 14:55:58 -08001283
1284 virtual uint32_t correctLatency_l(uint32_t latency) const;
1285
Eric Laurent1c333e22014-05-20 10:48:17 -07001286 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1287 audio_patch_handle_t *handle);
1288 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
1289
Phil Burk6fc2a7c2015-04-30 16:08:10 -07001290 bool usesHwAvSync() const { return (mType == DIRECT) && (mOutput != NULL)
1291 && mHwSupportsPause
1292 && (mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC); }
Eric Laurent0f7b5f22014-12-19 10:43:21 -08001293
Andy Hung1bc088a2018-02-09 15:57:31 -08001294 uint32_t trackCountForUid_l(uid_t uid) const;
Eric Laurentad7dd962016-09-22 12:38:37 -07001295
jiabineb3bda02020-06-30 14:07:03 -07001296 void invalidateTracksForAudioSession_l(
1297 audio_session_t sessionId) const override {
1298 ThreadBase::invalidateTracksForAudioSession_l(sessionId, mTracks);
1299 }
1300
Eric Laurent81784c32012-11-19 14:55:58 -08001301private:
1302
1303 friend class AudioFlinger; // for numerous
1304
Mikhail Naganovbf493082017-04-17 17:37:12 -07001305 DISALLOW_COPY_AND_ASSIGN(PlaybackThread);
Eric Laurent81784c32012-11-19 14:55:58 -08001306
1307 status_t addTrack_l(const sp<Track>& track);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001308 bool destroyTrack_l(const sp<Track>& track);
Eric Laurent81784c32012-11-19 14:55:58 -08001309 void removeTrack_l(const sp<Track>& track);
1310
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001311 void readOutputParameters_l();
Vlad Popa7e81cea2023-01-19 16:34:16 +01001312 MetadataUpdate updateMetadata_l() final;
Kevin Rocardc86a7f72018-04-03 09:00:09 -07001313 virtual void sendMetadataToBackend_l(const StreamOutHalInterface::SourceMetadata& metadata);
Eric Laurent81784c32012-11-19 14:55:58 -08001314
Dean Wheatley12473e92021-03-18 23:00:55 +11001315 void collectTimestamps_l();
1316
Andy Hungc0691382018-09-12 18:01:57 -07001317 // The Tracks class manages tracks added and removed from the Thread.
Andy Hung1bc088a2018-02-09 15:57:31 -08001318 template <typename T>
1319 class Tracks {
1320 public:
Andy Hung920f6572022-10-06 12:09:49 -07001321 explicit Tracks(bool saveDeletedTrackIds) :
Andy Hungc0691382018-09-12 18:01:57 -07001322 mSaveDeletedTrackIds(saveDeletedTrackIds) { }
Andy Hung1bc088a2018-02-09 15:57:31 -08001323
1324 // SortedVector methods
Andy Hungc0691382018-09-12 18:01:57 -07001325 ssize_t add(const sp<T> &track) {
1326 const ssize_t index = mTracks.add(track);
1327 LOG_ALWAYS_FATAL_IF(index < 0, "cannot add track");
1328 return index;
1329 }
Andy Hung1bc088a2018-02-09 15:57:31 -08001330 ssize_t remove(const sp<T> &track);
1331 size_t size() const {
1332 return mTracks.size();
1333 }
1334 bool isEmpty() const {
1335 return mTracks.isEmpty();
1336 }
1337 ssize_t indexOf(const sp<T> &item) {
1338 return mTracks.indexOf(item);
1339 }
1340 sp<T> operator[](size_t index) const {
1341 return mTracks[index];
1342 }
1343 typename SortedVector<sp<T>>::iterator begin() {
1344 return mTracks.begin();
1345 }
1346 typename SortedVector<sp<T>>::iterator end() {
1347 return mTracks.end();
1348 }
1349
Andy Hung920f6572022-10-06 12:09:49 -07001350 size_t processDeletedTrackIds(const std::function<void(int)>& f) {
Andy Hungc0691382018-09-12 18:01:57 -07001351 for (const int trackId : mDeletedTrackIds) {
1352 f(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08001353 }
Andy Hungc0691382018-09-12 18:01:57 -07001354 return mDeletedTrackIds.size();
Andy Hung1bc088a2018-02-09 15:57:31 -08001355 }
1356
Andy Hungc0691382018-09-12 18:01:57 -07001357 void clearDeletedTrackIds() { mDeletedTrackIds.clear(); }
Andy Hung1bc088a2018-02-09 15:57:31 -08001358
1359 private:
Andy Hungc0691382018-09-12 18:01:57 -07001360 // Tracks pending deletion for MIXER type threads
1361 const bool mSaveDeletedTrackIds; // true to enable tracking
1362 std::set<int> mDeletedTrackIds;
Andy Hung1bc088a2018-02-09 15:57:31 -08001363
1364 SortedVector<sp<T>> mTracks; // wrapped SortedVector.
1365 };
1366
1367 Tracks<Track> mTracks;
1368
Eric Laurent223fd5c2014-11-11 13:43:36 -08001369 stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
Eric Laurent81784c32012-11-19 14:55:58 -08001370 AudioStreamOut *mOutput;
1371
1372 float mMasterVolume;
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001373 std::atomic<float> mMasterBalance{};
1374 audio_utils::Balance mBalance;
Eric Laurent81784c32012-11-19 14:55:58 -08001375 int mNumWrites;
1376 int mNumDelayedWrites;
1377 bool mInWrite;
1378
1379 // FIXME rename these former local variables of threadLoop to standard "m" names
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001380 nsecs_t mStandbyTimeNs;
Andy Hung25c2dac2014-02-27 14:56:00 -08001381 size_t mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -08001382
1383 // cached copies of activeSleepTimeUs() and idleSleepTimeUs() made by cacheParameters_l()
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001384 uint32_t mActiveSleepTimeUs;
1385 uint32_t mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08001386
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001387 uint32_t mSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08001388
1389 // mixer status returned by prepareTracks_l()
1390 mixer_state mMixerStatus; // current cycle
1391 // previous cycle when in prepareTracks_l()
1392 mixer_state mMixerStatusIgnoringFastTracks;
1393 // FIXME or a separate ready state per track
1394
1395 // FIXME move these declarations into the specific sub-class that needs them
1396 // MIXER only
1397 uint32_t sleepTimeShift;
1398
1399 // same as AudioFlinger::mStandbyTimeInNsecs except for DIRECT which uses a shorter value
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001400 nsecs_t mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08001401
1402 // MIXER only
1403 nsecs_t maxPeriod;
1404
1405 // DUPLICATING only
1406 uint32_t writeFrames;
1407
Eric Laurentbfb1b832013-01-07 09:53:42 -08001408 size_t mBytesRemaining;
1409 size_t mCurrentWriteLength;
1410 bool mUseAsyncWrite;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001411 // mWriteAckSequence contains current write sequence on bits 31-1. The write sequence is
1412 // incremented each time a write(), a flush() or a standby() occurs.
1413 // Bit 0 is set when a write blocks and indicates a callback is expected.
1414 // Bit 0 is reset by the async callback thread calling resetWriteBlocked(). Out of sequence
1415 // callbacks are ignored.
1416 uint32_t mWriteAckSequence;
1417 // mDrainSequence contains current drain sequence on bits 31-1. The drain sequence is
1418 // incremented each time a drain is requested or a flush() or standby() occurs.
1419 // Bit 0 is set when the drain() command is called at the HAL and indicates a callback is
1420 // expected.
1421 // Bit 0 is reset by the async callback thread calling resetDraining(). Out of sequence
1422 // callbacks are ignored.
1423 uint32_t mDrainSequence;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001424 sp<AsyncCallbackThread> mCallbackThread;
1425
jiabinf6eb4c32020-02-25 14:06:25 -08001426 Mutex mAudioTrackCbLock;
1427 // Record of IAudioTrackCallback
jiabin18a4b1c2020-09-17 11:40:42 -07001428 std::map<sp<Track>, sp<media::IAudioTrackCallback>> mAudioTrackCallbacks;
jiabinf6eb4c32020-02-25 14:06:25 -08001429
Eric Laurent81784c32012-11-19 14:55:58 -08001430private:
1431 // The HAL output sink is treated as non-blocking, but current implementation is blocking
1432 sp<NBAIO_Sink> mOutputSink;
1433 // If a fast mixer is present, the blocking pipe sink, otherwise clear
1434 sp<NBAIO_Sink> mPipeSink;
1435 // The current sink for the normal mixer to write it's (sub)mix, mOutputSink or mPipeSink
1436 sp<NBAIO_Sink> mNormalSink;
Eric Laurent81784c32012-11-19 14:55:58 -08001437 uint32_t mScreenState; // cached copy of gScreenState
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07001438 // TODO: add comment and adjust size as needed
Glenn Kasteneef598c2017-04-03 14:41:13 -07001439 static const size_t kFastMixerLogSize = 8 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -08001440 sp<NBLog::Writer> mFastMixerNBLogWriter;
Andy Hung2148bf02016-11-28 19:01:02 -08001441
Dean Wheatley30d28422018-11-06 10:27:40 +11001442 // Downstream patch latency, available if mDownstreamLatencyStatMs.getN() > 0.
1443 audio_utils::Statistics<double> mDownstreamLatencyStatMs{0.999};
Andy Hung2148bf02016-11-28 19:01:02 -08001444
Eric Laurent19952e12023-04-20 10:08:29 +02001445 // output stream start detection based on render position returned by the kernel
1446 // condition signalled when the output stream has started
1447 Condition mWaitHalStartCV;
1448 // true when the output stream render position has moved, reset to false in standby
1449 bool mHalStarted = false;
1450 // last kernel render position saved when entering standby
1451 int64_t mKernelPositionOnStandby = 0;
1452
Eric Laurent81784c32012-11-19 14:55:58 -08001453public:
1454 virtual bool hasFastMixer() const = 0;
Glenn Kasten0f11b512014-01-31 16:18:54 -08001455 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex __unused) const
Eric Laurent81784c32012-11-19 14:55:58 -08001456 { FastTrackUnderruns dummy; return dummy; }
yucliu6cfb5932022-07-20 17:40:39 -07001457 const std::atomic<int64_t>& framesWritten() const { return mFramesWritten; }
Eric Laurent81784c32012-11-19 14:55:58 -08001458
1459protected:
1460 // accessed by both binder threads and within threadLoop(), lock on mutex needed
1461 unsigned mFastTrackAvailMask; // bit i set if fast track [i] is available
Eric Laurentd1f69b02014-12-15 14:33:13 -08001462 bool mHwSupportsPause;
1463 bool mHwPaused;
1464 bool mFlushPending;
Eric Laurent7c29ec92017-09-20 17:54:22 -07001465 // volumes last sent to audio HAL with stream->setVolume()
1466 float mLeftVolFloat;
1467 float mRightVolFloat;
Eric Laurent74c38dc2020-12-23 18:19:44 +01001468
1469 // audio patch used by the downstream software patch.
1470 // Only used if ThreadBase::mIsMsdDevice is true.
1471 struct audio_patch mDownStreamPatch;
Eric Laurentb3f315a2021-07-13 15:09:05 +02001472
1473 std::atomic_bool mCheckOutputStageEffects{};
ziyangch8f194f12021-12-01 13:48:04 -08001474
ziyangch8f194f12021-12-01 13:48:04 -08001475
Brian Lindahl65e90012022-07-27 18:01:07 +02001476 // Provides periodic checking for timestamp advancement for underrun detection.
1477 class IsTimestampAdvancing {
1478 public:
1479 // The timestamp will not be checked any faster than the specified time.
Andy Hung920f6572022-10-06 12:09:49 -07001480 explicit IsTimestampAdvancing(nsecs_t minimumTimeBetweenChecksNs)
Brian Lindahl65e90012022-07-27 18:01:07 +02001481 : mMinimumTimeBetweenChecksNs(minimumTimeBetweenChecksNs)
1482 {
1483 clear();
1484 }
1485 // Check if the presentation position has advanced in the last periodic time.
1486 bool check(AudioStreamOut * output);
1487 // Clear the internal state when the playback state changes for the output
1488 // stream.
1489 void clear();
1490 private:
1491 // The minimum time between timestamp checks.
1492 const nsecs_t mMinimumTimeBetweenChecksNs;
1493 // Add differential check on the timestamps to see if there is a change in the
1494 // timestamp frame position between the last call to check.
1495 uint64_t mPreviousPosition;
1496 // The time at which the last check occurred, to ensure we don't check too
1497 // frequently, giving the Audio HAL enough time to update its timestamps.
1498 nsecs_t mPreviousNs;
1499 // The valued is latched so we don't check timestamps too frequently.
1500 bool mLatchedValue;
1501 };
1502 IsTimestampAdvancing mIsTimestampAdvancing;
ziyangch8f194f12021-12-01 13:48:04 -08001503
Brian Lindahl65e90012022-07-27 18:01:07 +02001504 virtual void flushHw_l() {
1505 mIsTimestampAdvancing.clear();
1506 }
Eric Laurent81784c32012-11-19 14:55:58 -08001507};
1508
Eric Laurentb0463942022-12-20 16:31:10 +01001509class MixerThread : public PlaybackThread,
1510 public StreamOutHalInterfaceLatencyModeCallback {
Eric Laurent81784c32012-11-19 14:55:58 -08001511public:
1512 MixerThread(const sp<AudioFlinger>& audioFlinger,
1513 AudioStreamOut* output,
1514 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07001515 bool systemReady,
Eric Laurentf1f22e72021-07-13 14:04:14 +02001516 type_t type = MIXER,
1517 audio_config_base_t *mixerConfig = nullptr);
Eric Laurent81784c32012-11-19 14:55:58 -08001518 virtual ~MixerThread();
1519
Eric Laurentb0463942022-12-20 16:31:10 +01001520 // RefBase
1521 virtual void onFirstRef();
1522
1523 // StreamOutHalInterfaceLatencyModeCallback
1524 void onRecommendedLatencyModeChanged(
1525 std::vector<audio_latency_mode_t> modes) override;
1526
Eric Laurent81784c32012-11-19 14:55:58 -08001527 // Thread virtuals
1528
Eric Laurent10351942014-05-08 18:49:52 -07001529 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1530 status_t& status);
Eric Laurent81784c32012-11-19 14:55:58 -08001531
Andy Hung1bc088a2018-02-09 15:57:31 -08001532 virtual bool isTrackAllowed_l(
1533 audio_channel_mask_t channelMask, audio_format_t format,
1534 audio_session_t sessionId, uid_t uid) const override;
Eric Laurent81784c32012-11-19 14:55:58 -08001535protected:
1536 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08001537 virtual uint32_t idleSleepTimeUs() const;
1538 virtual uint32_t suspendSleepTimeUs() const;
1539 virtual void cacheParameters_l();
1540
Andy Hungdae27702016-10-31 14:01:16 -07001541 virtual void acquireWakeLock_l() {
1542 PlaybackThread::acquireWakeLock_l();
Andy Hung818e7a32016-02-16 18:08:07 -08001543 if (hasFastMixer()) {
1544 mFastMixer->setBoottimeOffset(
1545 mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME]);
1546 }
1547 }
1548
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001549 void dumpInternals_l(int fd, const Vector<String16>& args) override;
1550
Eric Laurent81784c32012-11-19 14:55:58 -08001551 // threadLoop snippets
Eric Laurentbfb1b832013-01-07 09:53:42 -08001552 virtual ssize_t threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08001553 virtual void threadLoop_standby();
1554 virtual void threadLoop_mix();
1555 virtual void threadLoop_sleepTime();
Eric Laurent81784c32012-11-19 14:55:58 -08001556 virtual uint32_t correctLatency_l(uint32_t latency) const;
1557
Eric Laurent054d9d32015-04-24 08:48:48 -07001558 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1559 audio_patch_handle_t *handle);
1560 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
1561
Eric Laurent81784c32012-11-19 14:55:58 -08001562 AudioMixer* mAudioMixer; // normal mixer
Eric Laurentb0463942022-12-20 16:31:10 +01001563
1564 // Support low latency mode by default as unless explicitly indicated by the audio HAL
1565 // we assume the audio path is compatible with the head tracking latency requirements
1566 std::vector<audio_latency_mode_t> mSupportedLatencyModes = {AUDIO_LATENCY_MODE_LOW};
1567 // default to invalid value to force first update to the audio HAL
1568 audio_latency_mode_t mSetLatencyMode =
1569 (audio_latency_mode_t)AUDIO_LATENCY_MODE_INVALID;
1570
1571 // Bluetooth Variable latency control logic is enabled or disabled for this thread
1572 std::atomic_bool mBluetoothLatencyModesEnabled;
1573
Eric Laurent81784c32012-11-19 14:55:58 -08001574private:
1575 // one-time initialization, no locks required
Glenn Kasten4d23ca32014-05-13 10:39:51 -07001576 sp<FastMixer> mFastMixer; // non-0 if there is also a fast mixer
Eric Laurent81784c32012-11-19 14:55:58 -08001577 sp<AudioWatchdog> mAudioWatchdog; // non-0 if there is an audio watchdog thread
1578
1579 // contents are not guaranteed to be consistent, no locks required
1580 FastMixerDumpState mFastMixerDumpState;
1581#ifdef STATE_QUEUE_DUMP
1582 StateQueueObserverDump mStateQueueObserverDump;
1583 StateQueueMutatorDump mStateQueueMutatorDump;
1584#endif
1585 AudioWatchdogDump mAudioWatchdogDump;
1586
1587 // accessible only within the threadLoop(), no locks required
1588 // mFastMixer->sq() // for mutating and pushing state
1589 int32_t mFastMixerFutex; // for cold idle
1590
Andy Hung2ddee192015-12-18 17:34:44 -08001591 std::atomic_bool mMasterMono;
Eric Laurent81784c32012-11-19 14:55:58 -08001592public:
Glenn Kasten4d23ca32014-05-13 10:39:51 -07001593 virtual bool hasFastMixer() const { return mFastMixer != 0; }
Eric Laurent81784c32012-11-19 14:55:58 -08001594 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const {
Glenn Kastendc2c50b2016-04-21 08:13:14 -07001595 ALOG_ASSERT(fastIndex < FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08001596 return mFastMixerDumpState.mTracks[fastIndex].mUnderruns;
1597 }
Eric Laurent83b88082014-06-20 18:31:16 -07001598
Andy Hung1c86ebe2018-05-29 20:29:08 -07001599 status_t threadloop_getHalTimestamp_l(
1600 ExtendedTimestamp *timestamp) const override {
1601 if (mNormalSink.get() != nullptr) {
1602 return mNormalSink->getTimestamp(*timestamp);
1603 }
1604 return INVALID_OPERATION;
1605 }
1606
Eric Laurentb0463942022-12-20 16:31:10 +01001607 status_t getSupportedLatencyModes(
1608 std::vector<audio_latency_mode_t>* modes) override;
1609
1610 status_t setBluetoothVariableLatencyEnabled(bool enabled) override;
1611
Andy Hung2ddee192015-12-18 17:34:44 -08001612protected:
1613 virtual void setMasterMono_l(bool mono) {
1614 mMasterMono.store(mono);
1615 if (mFastMixer != nullptr) { /* hasFastMixer() */
1616 mFastMixer->setMasterMono(mMasterMono);
1617 }
1618 }
1619 // the FastMixer performs mono blend if it exists.
Glenn Kasten03c48d52016-01-27 17:25:17 -08001620 // Blending with limiter is not idempotent,
1621 // and blending without limiter is idempotent but inefficient to do twice.
Andy Hung2ddee192015-12-18 17:34:44 -08001622 virtual bool requireMonoBlend() { return mMasterMono.load() && !hasFastMixer(); }
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001623
1624 void setMasterBalance(float balance) override {
1625 mMasterBalance.store(balance);
1626 if (hasFastMixer()) {
1627 mFastMixer->setMasterBalance(balance);
1628 }
1629 }
Eric Laurentb0463942022-12-20 16:31:10 +01001630
1631 void updateHalSupportedLatencyModes_l();
1632 void onHalLatencyModesChanged_l() override;
1633 void setHalLatencyMode_l() override;
Eric Laurent81784c32012-11-19 14:55:58 -08001634};
1635
1636class DirectOutputThread : public PlaybackThread {
1637public:
1638
1639 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Gareth Fennb18c1a32022-10-05 13:42:36 -07001640 audio_io_handle_t id, bool systemReady,
1641 const audio_offload_info_t& offloadInfo)
1642 : DirectOutputThread(audioFlinger, output, id, DIRECT, systemReady, offloadInfo) { }
Andy Hung48f59ed2019-01-28 15:06:59 -08001643
Eric Laurent81784c32012-11-19 14:55:58 -08001644 virtual ~DirectOutputThread();
1645
Mikhail Naganovac917ac2018-11-28 14:03:52 -08001646 status_t selectPresentation(int presentationId, int programId);
1647
Eric Laurent81784c32012-11-19 14:55:58 -08001648 // Thread virtuals
1649
Eric Laurent10351942014-05-08 18:49:52 -07001650 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1651 status_t& status);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001652
ziyangch8f194f12021-12-01 13:48:04 -08001653 void flushHw_l() override;
Eric Laurent81784c32012-11-19 14:55:58 -08001654
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001655 void setMasterBalance(float balance) override;
1656
Eric Laurent81784c32012-11-19 14:55:58 -08001657protected:
Eric Laurent81784c32012-11-19 14:55:58 -08001658 virtual uint32_t activeSleepTimeUs() const;
1659 virtual uint32_t idleSleepTimeUs() const;
1660 virtual uint32_t suspendSleepTimeUs() const;
1661 virtual void cacheParameters_l();
1662
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001663 void dumpInternals_l(int fd, const Vector<String16>& args) override;
1664
Eric Laurent81784c32012-11-19 14:55:58 -08001665 // threadLoop snippets
1666 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
1667 virtual void threadLoop_mix();
1668 virtual void threadLoop_sleepTime();
Eric Laurentd1f69b02014-12-15 14:33:13 -08001669 virtual void threadLoop_exit();
1670 virtual bool shouldStandby_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001671
Phil Burk43b4dcc2015-06-09 16:53:44 -07001672 virtual void onAddNewTrack_l();
1673
Gareth Fennb18c1a32022-10-05 13:42:36 -07001674 const audio_offload_info_t mOffloadInfo;
Andy Hung398ffa22022-12-13 19:19:53 -08001675
1676 audioflinger::MonotonicFrameCounter mMonotonicFrameCounter; // for VolumeShaper
Andy Hung48f59ed2019-01-28 15:06:59 -08001677 bool mVolumeShaperActive = false;
Eric Laurent81784c32012-11-19 14:55:58 -08001678
Eric Laurentbfb1b832013-01-07 09:53:42 -08001679 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Gareth Fennb18c1a32022-10-05 13:42:36 -07001680 audio_io_handle_t id, ThreadBase::type_t type, bool systemReady,
1681 const audio_offload_info_t& offloadInfo);
Eric Laurent5850c4c2016-11-10 13:04:31 -08001682 void processVolume_l(Track *track, bool lastTrack);
Gareth Fennb18c1a32022-10-05 13:42:36 -07001683 bool isTunerStream() const { return (mOffloadInfo.content_id > 0); }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001684
Eric Laurent81784c32012-11-19 14:55:58 -08001685 // prepareTracks_l() tells threadLoop_mix() the name of the single active track
1686 sp<Track> mActiveTrack;
Phil Burk43b4dcc2015-06-09 16:53:44 -07001687
1688 wp<Track> mPreviousTrack; // used to detect track switch
1689
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001690 // This must be initialized for initial condition of mMasterBalance = 0 (disabled).
1691 float mMasterBalanceLeft = 1.f;
1692 float mMasterBalanceRight = 1.f;
1693
Eric Laurent81784c32012-11-19 14:55:58 -08001694public:
1695 virtual bool hasFastMixer() const { return false; }
Andy Hung10cbff12017-02-21 17:30:14 -08001696
1697 virtual int64_t computeWaitTimeNs_l() const override;
Andy Hungf3234512018-07-03 14:51:47 -07001698
1699 status_t threadloop_getHalTimestamp_l(ExtendedTimestamp *timestamp) const override {
1700 // For DIRECT and OFFLOAD threads, query the output sink directly.
1701 if (mOutput != nullptr) {
1702 uint64_t uposition64;
1703 struct timespec time;
1704 if (mOutput->getPresentationPosition(
1705 &uposition64, &time) == OK) {
1706 timestamp->mPosition[ExtendedTimestamp::LOCATION_KERNEL]
1707 = (int64_t)uposition64;
1708 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]
1709 = audio_utils_ns_from_timespec(&time);
1710 return NO_ERROR;
1711 }
1712 }
1713 return INVALID_OPERATION;
1714 }
Eric Laurent81784c32012-11-19 14:55:58 -08001715};
1716
Eric Laurentbfb1b832013-01-07 09:53:42 -08001717class OffloadThread : public DirectOutputThread {
1718public:
1719
1720 OffloadThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Gareth Fennb18c1a32022-10-05 13:42:36 -07001721 audio_io_handle_t id, bool systemReady,
1722 const audio_offload_info_t& offloadInfo);
Eric Laurent6a51d7e2013-10-17 18:59:26 -07001723 virtual ~OffloadThread() {};
ziyangch8f194f12021-12-01 13:48:04 -08001724 void flushHw_l() override;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001725
1726protected:
1727 // threadLoop snippets
1728 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
1729 virtual void threadLoop_exit();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001730
1731 virtual bool waitingAsyncCallback();
1732 virtual bool waitingAsyncCallback_l();
Haynes Mathew George05317d22016-05-03 16:34:26 -07001733 virtual void invalidateTracks(audio_stream_type_t streamType);
jiabinc44b3462022-12-08 12:52:31 -08001734 void invalidateTracks(std::set<audio_port_handle_t>& portIds) override;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001735
Eric Laurentde0613d2016-07-22 18:19:11 -07001736 virtual bool keepWakeLock() const { return (mKeepWakeLock || (mDrainSequence & 1)); }
Eric Laurent64667972016-03-30 18:19:46 -07001737
Eric Laurentbfb1b832013-01-07 09:53:42 -08001738private:
Eric Laurentbfb1b832013-01-07 09:53:42 -08001739 size_t mPausedWriteLength; // length in bytes of write interrupted by pause
1740 size_t mPausedBytesRemaining; // bytes still waiting in mixbuffer after resume
Eric Laurent64667972016-03-30 18:19:46 -07001741 bool mKeepWakeLock; // keep wake lock while waiting for write callback
Eric Laurentbfb1b832013-01-07 09:53:42 -08001742};
1743
1744class AsyncCallbackThread : public Thread {
1745public:
1746
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001747 explicit AsyncCallbackThread(const wp<PlaybackThread>& playbackThread);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001748
1749 virtual ~AsyncCallbackThread();
1750
1751 // Thread virtuals
1752 virtual bool threadLoop();
1753
1754 // RefBase
1755 virtual void onFirstRef();
1756
1757 void exit();
Eric Laurent3b4529e2013-09-05 18:09:19 -07001758 void setWriteBlocked(uint32_t sequence);
1759 void resetWriteBlocked();
1760 void setDraining(uint32_t sequence);
1761 void resetDraining();
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07001762 void setAsyncError();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001763
1764private:
Eric Laurent4de95592013-09-26 15:28:21 -07001765 const wp<PlaybackThread> mPlaybackThread;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001766 // mWriteAckSequence corresponds to the last write sequence passed by the offload thread via
1767 // setWriteBlocked(). The sequence is shifted one bit to the left and the lsb is used
1768 // to indicate that the callback has been received via resetWriteBlocked()
Eric Laurent4de95592013-09-26 15:28:21 -07001769 uint32_t mWriteAckSequence;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001770 // mDrainSequence corresponds to the last drain sequence passed by the offload thread via
1771 // setDraining(). The sequence is shifted one bit to the left and the lsb is used
1772 // to indicate that the callback has been received via resetDraining()
Eric Laurent4de95592013-09-26 15:28:21 -07001773 uint32_t mDrainSequence;
1774 Condition mWaitWorkCV;
1775 Mutex mLock;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07001776 bool mAsyncError;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001777};
1778
Eric Laurent81784c32012-11-19 14:55:58 -08001779class DuplicatingThread : public MixerThread {
1780public:
1781 DuplicatingThread(const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread,
Eric Laurent72e3f392015-05-20 14:43:50 -07001782 audio_io_handle_t id, bool systemReady);
Eric Laurent81784c32012-11-19 14:55:58 -08001783 virtual ~DuplicatingThread();
1784
1785 // Thread virtuals
1786 void addOutputTrack(MixerThread* thread);
1787 void removeOutputTrack(MixerThread* thread);
1788 uint32_t waitTimeMs() const { return mWaitTimeMs; }
Kevin Rocard069c2712018-03-29 19:09:14 -07001789
Kevin Rocardc86a7f72018-04-03 09:00:09 -07001790 void sendMetadataToBackend_l(
1791 const StreamOutHalInterface::SourceMetadata& metadata) override;
Eric Laurent81784c32012-11-19 14:55:58 -08001792protected:
1793 virtual uint32_t activeSleepTimeUs() const;
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001794 void dumpInternals_l(int fd, const Vector<String16>& args) override;
Eric Laurent81784c32012-11-19 14:55:58 -08001795
1796private:
Andy Hung920f6572022-10-06 12:09:49 -07001797 bool outputsReady();
Eric Laurent81784c32012-11-19 14:55:58 -08001798protected:
1799 // threadLoop snippets
1800 virtual void threadLoop_mix();
1801 virtual void threadLoop_sleepTime();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001802 virtual ssize_t threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08001803 virtual void threadLoop_standby();
1804 virtual void cacheParameters_l();
1805
1806private:
1807 // called from threadLoop, addOutputTrack, removeOutputTrack
1808 virtual void updateWaitTime_l();
1809protected:
1810 virtual void saveOutputTracks();
1811 virtual void clearOutputTracks();
1812private:
1813
1814 uint32_t mWaitTimeMs;
1815 SortedVector < sp<OutputTrack> > outputTracks;
1816 SortedVector < sp<OutputTrack> > mOutputTracks;
1817public:
1818 virtual bool hasFastMixer() const { return false; }
Andy Hung1c86ebe2018-05-29 20:29:08 -07001819 status_t threadloop_getHalTimestamp_l(
1820 ExtendedTimestamp *timestamp) const override {
1821 if (mOutputTracks.size() > 0) {
1822 // forward the first OutputTrack's kernel information for timestamp.
1823 const ExtendedTimestamp trackTimestamp =
1824 mOutputTracks[0]->getClientProxyTimestamp();
1825 if (trackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0) {
1826 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] =
1827 trackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
1828 timestamp->mPosition[ExtendedTimestamp::LOCATION_KERNEL] =
1829 trackTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
1830 return OK; // discard server timestamp - that's ignored.
1831 }
1832 }
1833 return INVALID_OPERATION;
1834 }
Eric Laurent81784c32012-11-19 14:55:58 -08001835};
1836
Eric Laurentb0463942022-12-20 16:31:10 +01001837class SpatializerThread : public MixerThread {
Eric Laurentb3f315a2021-07-13 15:09:05 +02001838public:
Eric Laurentfa0f6742021-08-17 18:39:44 +02001839 SpatializerThread(const sp<AudioFlinger>& audioFlinger,
Eric Laurentb3f315a2021-07-13 15:09:05 +02001840 AudioStreamOut* output,
1841 audio_io_handle_t id,
1842 bool systemReady,
1843 audio_config_base_t *mixerConfig);
Eric Laurentfa0f6742021-08-17 18:39:44 +02001844 ~SpatializerThread() override {}
Eric Laurentb3f315a2021-07-13 15:09:05 +02001845
1846 bool hasFastMixer() const override { return false; }
1847
Eric Laurent68a40a82022-05-03 18:15:04 +02001848 // RefBase
1849 virtual void onFirstRef();
1850
Eric Laurent68a40a82022-05-03 18:15:04 +02001851 status_t setRequestedLatencyMode(audio_latency_mode_t mode) override;
Eric Laurent68a40a82022-05-03 18:15:04 +02001852
Eric Laurentb3f315a2021-07-13 15:09:05 +02001853protected:
1854 void checkOutputStageEffects() override;
Eric Laurent68a40a82022-05-03 18:15:04 +02001855 void setHalLatencyMode_l() override;
Eric Laurentb3f315a2021-07-13 15:09:05 +02001856
1857private:
Eric Laurent68a40a82022-05-03 18:15:04 +02001858 // Do not request a specific mode by default
1859 audio_latency_mode_t mRequestedLatencyMode = AUDIO_LATENCY_MODE_FREE;
1860
Andy Hung116bc262023-06-20 18:56:17 -07001861 sp<IAfEffectHandle> mFinalDownMixer;
Eric Laurentb3f315a2021-07-13 15:09:05 +02001862};
1863
Eric Laurent81784c32012-11-19 14:55:58 -08001864// record thread
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001865class RecordThread : public ThreadBase
Eric Laurent81784c32012-11-19 14:55:58 -08001866{
1867public:
1868
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001869 class RecordTrack;
Andy Hung73c02e42015-03-29 01:13:58 -07001870
1871 /* The ResamplerBufferProvider is used to retrieve recorded input data from the
1872 * RecordThread. It maintains local state on the relative position of the read
1873 * position of the RecordTrack compared with the RecordThread.
1874 */
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001875 class ResamplerBufferProvider : public AudioBufferProvider
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001876 {
1877 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001878 explicit ResamplerBufferProvider(RecordTrack* recordTrack) :
Andy Hung73c02e42015-03-29 01:13:58 -07001879 mRecordTrack(recordTrack),
1880 mRsmpInUnrel(0), mRsmpInFront(0) { }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001881 virtual ~ResamplerBufferProvider() { }
Andy Hung73c02e42015-03-29 01:13:58 -07001882
1883 // called to set the ResamplerBufferProvider to head of the RecordThread data buffer,
1884 // skipping any previous data read from the hal.
1885 virtual void reset();
1886
1887 /* Synchronizes RecordTrack position with the RecordThread.
1888 * Calculates available frames and handle overruns if the RecordThread
1889 * has advanced faster than the ResamplerBufferProvider has retrieved data.
1890 * TODO: why not do this for every getNextBuffer?
1891 *
1892 * Parameters
1893 * framesAvailable: pointer to optional output size_t to store record track
1894 * frames available.
1895 * hasOverrun: pointer to optional boolean, returns true if track has overrun.
1896 */
1897
1898 virtual void sync(size_t *framesAvailable = NULL, bool *hasOverrun = NULL);
1899
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001900 // AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -08001901 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001902 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
Eric Laurentec376dc2021-04-08 20:41:22 +02001903
1904 int32_t getFront() const { return mRsmpInFront; }
1905 void setFront(int32_t front) { mRsmpInFront = front; }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001906 private:
1907 RecordTrack * const mRecordTrack;
Andy Hung73c02e42015-03-29 01:13:58 -07001908 size_t mRsmpInUnrel; // unreleased frames remaining from
1909 // most recent getNextBuffer
1910 // for debug only
1911 int32_t mRsmpInFront; // next available frame
1912 // rolling counter that is never cleared
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001913 };
1914
Eric Laurent81784c32012-11-19 14:55:58 -08001915#include "RecordTracks.h"
1916
1917 RecordThread(const sp<AudioFlinger>& audioFlinger,
1918 AudioStreamIn *input,
Eric Laurent81784c32012-11-19 14:55:58 -08001919 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07001920 bool systemReady
Glenn Kasten46909e72013-02-26 09:20:22 -08001921 );
Eric Laurent81784c32012-11-19 14:55:58 -08001922 virtual ~RecordThread();
1923
1924 // no addTrack_l ?
1925 void destroyTrack_l(const sp<RecordTrack>& track);
1926 void removeTrack_l(const sp<RecordTrack>& track);
1927
Eric Laurent81784c32012-11-19 14:55:58 -08001928 // Thread virtuals
1929 virtual bool threadLoop();
Eric Laurent555530a2017-02-07 18:17:24 -08001930 virtual void preExit();
Eric Laurent81784c32012-11-19 14:55:58 -08001931
1932 // RefBase
1933 virtual void onFirstRef();
1934
1935 virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; }
Glenn Kastene198c362013-08-13 09:13:36 -07001936
Glenn Kastenb880f5e2014-05-07 08:43:45 -07001937 virtual sp<MemoryDealer> readOnlyHeap() const { return mReadOnlyHeap; }
1938
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001939 virtual sp<IMemory> pipeMemory() const { return mPipeMemory; }
1940
Eric Laurent81784c32012-11-19 14:55:58 -08001941 sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l(
Andy Hung88035ac2023-06-27 17:05:02 -07001942 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001943 const audio_attributes_t& attr,
Eric Laurentf14db3c2017-12-08 14:20:36 -08001944 uint32_t *pSampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -08001945 audio_format_t format,
1946 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08001947 size_t *pFrameCount,
Glenn Kastend848eb42016-03-08 13:42:11 -08001948 audio_session_t sessionId,
Eric Laurentf14db3c2017-12-08 14:20:36 -08001949 size_t *pNotificationFrameCount,
Eric Laurent09f1ed22019-04-24 17:45:17 -07001950 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00001951 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -07001952 audio_input_flags_t *flags,
Eric Laurent81784c32012-11-19 14:55:58 -08001953 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001954 status_t *status /*non-NULL*/,
Eric Laurentec376dc2021-04-08 20:41:22 +02001955 audio_port_handle_t portId,
1956 int32_t maxSharedAudioHistoryMs);
Eric Laurent81784c32012-11-19 14:55:58 -08001957
1958 status_t start(RecordTrack* recordTrack,
1959 AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08001960 audio_session_t triggerSession);
Eric Laurent81784c32012-11-19 14:55:58 -08001961
1962 // ask the thread to stop the specified track, and
1963 // return true if the caller should then do it's part of the stopping process
Glenn Kastena8356f62013-07-25 14:37:52 -07001964 bool stop(RecordTrack* recordTrack);
Eric Laurent81784c32012-11-19 14:55:58 -08001965
Eric Laurent81784c32012-11-19 14:55:58 -08001966 AudioStreamIn* clearInput();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07001967 virtual sp<StreamHalInterface> stream() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001968
Eric Laurent81784c32012-11-19 14:55:58 -08001969
Eric Laurent10351942014-05-08 18:49:52 -07001970 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1971 status_t& status);
1972 virtual void cacheParameters_l() {}
Eric Laurent81784c32012-11-19 14:55:58 -08001973 virtual String8 getParameters(const String8& keys);
Mikhail Naganov88536df2021-07-26 17:30:29 -07001974 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -07001975 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Eric Laurent1c333e22014-05-20 10:48:17 -07001976 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1977 audio_patch_handle_t *handle);
1978 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
jiabinc52b1ff2019-10-31 17:20:42 -07001979 void updateOutDevices(const DeviceDescriptorBaseVector& outDevices) override;
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02001980 void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs) override;
Eric Laurent83b88082014-06-20 18:31:16 -07001981
Mikhail Naganov444ecc32018-05-01 17:40:05 -07001982 void addPatchTrack(const sp<PatchRecord>& record);
1983 void deletePatchTrack(const sp<PatchRecord>& record);
Eric Laurent83b88082014-06-20 18:31:16 -07001984
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001985 void readInputParameters_l();
Glenn Kasten5f972c02014-01-13 09:59:31 -08001986 virtual uint32_t getInputFramesLost();
Eric Laurent81784c32012-11-19 14:55:58 -08001987
Andy Hung116bc262023-06-20 18:56:17 -07001988 virtual status_t addEffectChain_l(const sp<IAfEffectChain>& chain);
1989 virtual size_t removeEffectChain_l(const sp<IAfEffectChain>& chain);
Andy Hungc3d62f92019-03-14 13:38:51 -07001990 uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
1991 return ThreadBase::hasAudioSession_l(sessionId, mTracks);
1992 }
Eric Laurent81784c32012-11-19 14:55:58 -08001993
1994 // Return the set of unique session IDs across all tracks.
1995 // The keys are the session IDs, and the associated values are meaningless.
1996 // FIXME replace by Set [and implement Bag/Multiset for other uses].
Glenn Kastend848eb42016-03-08 13:42:11 -08001997 KeyedVector<audio_session_t, bool> sessionIds() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001998
Andy Hung068e08e2023-05-15 19:02:55 -07001999 status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) override;
2000 bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const override;
Eric Laurent81784c32012-11-19 14:55:58 -08002001
Andy Hung068e08e2023-05-15 19:02:55 -07002002 static void syncStartEventCallback(const wp<audioflinger::SyncEvent>& event);
Eric Laurent81784c32012-11-19 14:55:58 -08002003
Glenn Kasten9b58f632013-07-16 11:37:48 -07002004 virtual size_t frameCount() const { return mFrameCount; }
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07002005 bool hasFastCapture() const { return mFastCapture != 0; }
Mikhail Naganovdc769682018-05-04 15:34:08 -07002006 virtual void toAudioPortConfig(struct audio_port_config *config);
Glenn Kasten9b58f632013-07-16 11:37:48 -07002007
Eric Laurent4c415062016-06-17 16:14:16 -07002008 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
2009 audio_session_t sessionId);
2010
Andy Hungdae27702016-10-31 14:01:16 -07002011 virtual void acquireWakeLock_l() {
2012 ThreadBase::acquireWakeLock_l();
2013 mActiveTracks.updatePowerState(this, true /* force */);
2014 }
2015
Eric Laurentd8365c52017-07-16 15:27:05 -07002016 void checkBtNrec();
2017
Svet Ganovf4ddfef2018-01-16 07:37:58 -08002018 // Sets the UID records silence
Eric Laurent5ada82e2019-08-29 17:53:54 -07002019 void setRecordSilenced(audio_port_handle_t portId, bool silenced);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08002020
Mikhail Naganovd5d9de72023-02-13 11:45:03 -08002021 status_t getActiveMicrophones(
2022 std::vector<media::MicrophoneInfoFw>* activeMicrophones);
jiabin653cc0a2018-01-17 17:54:10 -08002023
Paul McLean12340082019-03-19 09:35:05 -06002024 status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
2025 status_t setPreferredMicrophoneFieldDimension(float zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07002026
Vlad Popa7e81cea2023-01-19 16:34:16 +01002027 MetadataUpdate updateMetadata_l() override;
Kevin Rocard069c2712018-03-29 19:09:14 -07002028
jiabin01c8f562018-07-19 17:47:28 -07002029 bool fastTrackAvailable() const { return mFastTrackAvail; }
2030
Andy Hungc8fddf32018-08-08 18:32:37 -07002031 bool isTimestampCorrectionEnabled() const override {
2032 // checks popcount for exactly one device.
Atneya Nair497fff12022-01-18 16:23:04 -05002033 // Is currently disabled. Before enabling,
2034 // verify compressed record timestamps.
jiabinc52b1ff2019-10-31 17:20:42 -07002035 return audio_is_input_device(mTimestampCorrectedDevice)
2036 && inDeviceType() == mTimestampCorrectedDevice;
Andy Hungc8fddf32018-08-08 18:32:37 -07002037 }
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002038
Eric Laurentec376dc2021-04-08 20:41:22 +02002039 status_t shareAudioHistory(const std::string& sharedAudioPackageName,
2040 audio_session_t sharedSessionId = AUDIO_SESSION_NONE,
2041 int64_t sharedAudioStartMs = -1);
2042 status_t shareAudioHistory_l(const std::string& sharedAudioPackageName,
2043 audio_session_t sharedSessionId = AUDIO_SESSION_NONE,
2044 int64_t sharedAudioStartMs = -1);
Eric Laurent92d0a322021-07-16 15:32:33 +02002045 void resetAudioHistory_l();
Eric Laurentec376dc2021-04-08 20:41:22 +02002046
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002047 virtual bool isStreamInitialized() {
2048 return !(mInput == nullptr || mInput->stream == nullptr);
2049 }
2050
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002051protected:
2052 void dumpInternals_l(int fd, const Vector<String16>& args) override;
2053 void dumpTracks_l(int fd, const Vector<String16>& args) override;
2054
Eric Laurent81784c32012-11-19 14:55:58 -08002055private:
Eric Laurent81784c32012-11-19 14:55:58 -08002056 // Enter standby if not already in standby, and set mStandby flag
Glenn Kasten93e471f2013-08-19 08:40:07 -07002057 void standbyIfNotAlreadyInStandby();
Eric Laurent81784c32012-11-19 14:55:58 -08002058
2059 // Call the HAL standby method unconditionally, and don't change mStandby flag
Glenn Kastene198c362013-08-13 09:13:36 -07002060 void inputStandBy();
Eric Laurent81784c32012-11-19 14:55:58 -08002061
Eric Laurentd8365c52017-07-16 15:27:05 -07002062 void checkBtNrec_l();
2063
Eric Laurentec376dc2021-04-08 20:41:22 +02002064 int32_t getOldestFront_l();
2065 void updateFronts_l(int32_t offset);
2066
Eric Laurent81784c32012-11-19 14:55:58 -08002067 AudioStreamIn *mInput;
Mikhail Naganov2534b382019-09-25 13:05:02 -07002068 Source *mSource;
Eric Laurent81784c32012-11-19 14:55:58 -08002069 SortedVector < sp<RecordTrack> > mTracks;
Glenn Kasten2b806402013-11-20 16:37:38 -08002070 // mActiveTracks has dual roles: it indicates the current active track(s), and
Eric Laurent81784c32012-11-19 14:55:58 -08002071 // is used together with mStartStopCond to indicate start()/stop() progress
Andy Hungdae27702016-10-31 14:01:16 -07002072 ActiveTracks<RecordTrack> mActiveTracks;
2073
Eric Laurent81784c32012-11-19 14:55:58 -08002074 Condition mStartStopCond;
Glenn Kasten9b58f632013-07-16 11:37:48 -07002075
Glenn Kasten85948432013-08-19 12:09:05 -07002076 // resampler converts input at HAL Hz to output at AudioRecord client Hz
Glenn Kasten1b291842016-07-18 14:55:21 -07002077 void *mRsmpInBuffer; // size = mRsmpInFramesOA
Glenn Kasten85948432013-08-19 12:09:05 -07002078 size_t mRsmpInFrames; // size of resampler input in frames
2079 size_t mRsmpInFramesP2;// size rounded up to a power-of-2
Glenn Kasten1b291842016-07-18 14:55:21 -07002080 size_t mRsmpInFramesOA;// mRsmpInFramesP2 + over-allocation
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002081
2082 // rolling index that is never cleared
Glenn Kasten85948432013-08-19 12:09:05 -07002083 int32_t mRsmpInRear; // last filled frame + 1
Glenn Kasten85948432013-08-19 12:09:05 -07002084
Eric Laurent81784c32012-11-19 14:55:58 -08002085 // For dumpsys
Glenn Kastenb880f5e2014-05-07 08:43:45 -07002086 const sp<MemoryDealer> mReadOnlyHeap;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07002087
2088 // one-time initialization, no locks required
Glenn Kastenb187de12014-12-30 08:18:15 -08002089 sp<FastCapture> mFastCapture; // non-0 if there is also
2090 // a fast capture
Eric Laurent72e3f392015-05-20 14:43:50 -07002091
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07002092 // FIXME audio watchdog thread
2093
2094 // contents are not guaranteed to be consistent, no locks required
2095 FastCaptureDumpState mFastCaptureDumpState;
2096#ifdef STATE_QUEUE_DUMP
2097 // FIXME StateQueue observer and mutator dump fields
2098#endif
2099 // FIXME audio watchdog dump
2100
2101 // accessible only within the threadLoop(), no locks required
2102 // mFastCapture->sq() // for mutating and pushing state
2103 int32_t mFastCaptureFutex; // for cold idle
2104
2105 // The HAL input source is treated as non-blocking,
2106 // but current implementation is blocking
2107 sp<NBAIO_Source> mInputSource;
2108 // The source for the normal capture thread to read from: mInputSource or mPipeSource
2109 sp<NBAIO_Source> mNormalSource;
2110 // If a fast capture is present, the non-blocking pipe sink written to by fast capture,
2111 // otherwise clear
2112 sp<NBAIO_Sink> mPipeSink;
2113 // If a fast capture is present, the non-blocking pipe source read by normal thread,
2114 // otherwise clear
2115 sp<NBAIO_Source> mPipeSource;
2116 // Depth of pipe from fast capture to normal thread and fast clients, always power of 2
2117 size_t mPipeFramesP2;
2118 // If a fast capture is present, the Pipe as IMemory, otherwise clear
2119 sp<IMemory> mPipeMemory;
2120
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07002121 // TODO: add comment and adjust size as needed
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07002122 static const size_t kFastCaptureLogSize = 4 * 1024;
2123 sp<NBLog::Writer> mFastCaptureNBLogWriter;
2124
2125 bool mFastTrackAvail; // true if fast track available
Eric Laurentd8365c52017-07-16 15:27:05 -07002126 // common state to all record threads
2127 std::atomic_bool mBtNrecSuspended;
Andy Hung6427e442018-08-09 12:51:02 -07002128
2129 int64_t mFramesRead = 0; // continuous running counter.
jiabinc52b1ff2019-10-31 17:20:42 -07002130
2131 DeviceDescriptorBaseVector mOutDevices;
Eric Laurentec376dc2021-04-08 20:41:22 +02002132
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02002133 int32_t mMaxSharedAudioHistoryMs = 0;
Eric Laurentec376dc2021-04-08 20:41:22 +02002134 std::string mSharedAudioPackageName = {};
Eric Laurent2407ce32021-04-26 14:56:03 +02002135 int32_t mSharedAudioStartFrames = -1;
Eric Laurentec376dc2021-04-08 20:41:22 +02002136 audio_session_t mSharedAudioSessionId = AUDIO_SESSION_NONE;
Eric Laurent81784c32012-11-19 14:55:58 -08002137};
Eric Laurent6acd1d42017-01-04 14:23:29 -08002138
2139class MmapThread : public ThreadBase
2140{
2141 public:
2142
2143#include "MmapTracks.h"
2144
2145 MmapThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hung920f6572022-10-06 12:09:49 -07002146 AudioHwDevice *hwDev, const sp<StreamHalInterface>& stream, bool systemReady,
Andy Hungcf10d742020-04-28 15:38:24 -07002147 bool isOut);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002148 virtual ~MmapThread();
2149
2150 virtual void configure(const audio_attributes_t *attr,
2151 audio_stream_type_t streamType,
2152 audio_session_t sessionId,
2153 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07002154 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002155 audio_port_handle_t portId);
2156
2157 void disconnect();
2158
2159 // MmapStreamInterface
2160 status_t createMmapBuffer(int32_t minSizeFrames,
2161 struct audio_mmap_buffer_info *info);
2162 status_t getMmapPosition(struct audio_mmap_position *position);
jiabind1f1cb62020-03-24 11:57:57 -07002163 status_t start(const AudioClient& client,
2164 const audio_attributes_t *attr,
2165 audio_port_handle_t *handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002166 status_t stop(audio_port_handle_t handle);
Eric Laurent18b57012017-02-13 16:23:52 -08002167 status_t standby();
jiabinb7d8c5a2020-08-26 17:24:52 -07002168 virtual status_t getExternalPosition(uint64_t *position, int64_t *timeNaos) = 0;
jiabinfc791ee2023-02-15 19:43:40 +00002169 virtual status_t reportData(const void* buffer, size_t frameCount);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002170
2171 // RefBase
2172 virtual void onFirstRef();
2173
2174 // Thread virtuals
2175 virtual bool threadLoop();
2176
2177 virtual void threadLoop_exit();
2178 virtual void threadLoop_standby();
Eric Laurent18b57012017-02-13 16:23:52 -08002179 virtual bool shouldStandby_l() { return false; }
Eric Laurentdda206a2022-07-08 17:28:35 +02002180 virtual status_t exitStandby_l() REQUIRES(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002181
2182 virtual status_t initCheck() const { return (mHalStream == 0) ? NO_INIT : NO_ERROR; }
2183 virtual size_t frameCount() const { return mFrameCount; }
2184 virtual bool checkForNewParameter_l(const String8& keyValuePair,
2185 status_t& status);
2186 virtual String8 getParameters(const String8& keys);
Mikhail Naganov88536df2021-07-26 17:30:29 -07002187 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002188 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002189 void readHalParameters_l();
2190 virtual void cacheParameters_l() {}
2191 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
2192 audio_patch_handle_t *handle);
2193 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
Mikhail Naganovdc769682018-05-04 15:34:08 -07002194 virtual void toAudioPortConfig(struct audio_port_config *config);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002195
2196 virtual sp<StreamHalInterface> stream() const { return mHalStream; }
Andy Hung116bc262023-06-20 18:56:17 -07002197 virtual status_t addEffectChain_l(const sp<IAfEffectChain>& chain);
2198 virtual size_t removeEffectChain_l(const sp<IAfEffectChain>& chain);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002199 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
2200 audio_session_t sessionId);
2201
Andy Hungc3d62f92019-03-14 13:38:51 -07002202 uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
2203 // Note: using mActiveTracks as no mTracks here.
2204 return ThreadBase::hasAudioSession_l(sessionId, mActiveTracks);
2205 }
Andy Hung068e08e2023-05-15 19:02:55 -07002206 virtual status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event);
2207 virtual bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002208
2209 virtual void checkSilentMode_l() {}
2210 virtual void processVolume_l() {}
2211 void checkInvalidTracks_l();
2212
2213 virtual audio_stream_type_t streamType() { return AUDIO_STREAM_DEFAULT; }
2214
2215 virtual void invalidateTracks(audio_stream_type_t streamType __unused) {}
jiabinc44b3462022-12-08 12:52:31 -08002216 virtual void invalidateTracks(std::set<audio_port_handle_t>& portIds __unused) {}
Eric Laurent6acd1d42017-01-04 14:23:29 -08002217
Eric Laurent331679c2018-04-16 17:03:16 -07002218 // Sets the UID records silence
Eric Laurent5ada82e2019-08-29 17:53:54 -07002219 virtual void setRecordSilenced(audio_port_handle_t portId __unused,
2220 bool silenced __unused) {}
Eric Laurent331679c2018-04-16 17:03:16 -07002221
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002222 virtual bool isStreamInitialized() { return false; }
2223
jiabin09609032022-06-15 19:26:01 +00002224 void setClientSilencedState_l(audio_port_handle_t portId, bool silenced) {
2225 mClientSilencedStates[portId] = silenced;
2226 }
2227
2228 size_t eraseClientSilencedState_l(audio_port_handle_t portId) {
2229 return mClientSilencedStates.erase(portId);
2230 }
2231
2232 bool isClientSilenced_l(audio_port_handle_t portId) const {
2233 const auto it = mClientSilencedStates.find(portId);
2234 return it != mClientSilencedStates.end() ? it->second : false;
2235 }
2236
2237 void setClientSilencedIfExists_l(audio_port_handle_t portId, bool silenced) {
2238 const auto it = mClientSilencedStates.find(portId);
2239 if (it != mClientSilencedStates.end()) {
2240 it->second = silenced;
2241 }
2242 }
2243
Eric Laurent6acd1d42017-01-04 14:23:29 -08002244 protected:
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002245 void dumpInternals_l(int fd, const Vector<String16>& args) override;
2246 void dumpTracks_l(int fd, const Vector<String16>& args) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002247
jiabinc52b1ff2019-10-31 17:20:42 -07002248 /**
2249 * @brief mDeviceId current device port unique identifier
2250 */
2251 audio_port_handle_t mDeviceId = AUDIO_PORT_HANDLE_NONE;
2252
Eric Laurent6acd1d42017-01-04 14:23:29 -08002253 audio_attributes_t mAttr;
2254 audio_session_t mSessionId;
2255 audio_port_handle_t mPortId;
2256
Phil Burk7f6b40d2017-02-09 13:18:38 -08002257 wp<MmapStreamCallback> mCallback;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002258 sp<StreamHalInterface> mHalStream;
2259 sp<DeviceHalInterface> mHalDevice;
2260 AudioHwDevice* const mAudioHwDev;
2261 ActiveTracks<MmapTrack> mActiveTracks;
Eric Laurent67f97292018-04-20 18:05:41 -07002262 float mHalVolFloat;
jiabin09609032022-06-15 19:26:01 +00002263 std::map<audio_port_handle_t, bool> mClientSilencedStates;
Eric Laurent331679c2018-04-16 17:03:16 -07002264
2265 int32_t mNoCallbackWarningCount;
2266 static constexpr int32_t kMaxNoCallbackWarnings = 5;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002267};
2268
2269class MmapPlaybackThread : public MmapThread, public VolumeInterface
2270{
2271
2272public:
2273 MmapPlaybackThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabinc52b1ff2019-10-31 17:20:42 -07002274 AudioHwDevice *hwDev, AudioStreamOut *output, bool systemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002275 virtual ~MmapPlaybackThread() {}
2276
2277 virtual void configure(const audio_attributes_t *attr,
2278 audio_stream_type_t streamType,
2279 audio_session_t sessionId,
2280 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07002281 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002282 audio_port_handle_t portId);
2283
2284 AudioStreamOut* clearOutput();
2285
2286 // VolumeInterface
2287 virtual void setMasterVolume(float value);
2288 virtual void setMasterMute(bool muted);
2289 virtual void setStreamVolume(audio_stream_type_t stream, float value);
2290 virtual void setStreamMute(audio_stream_type_t stream, bool muted);
2291 virtual float streamVolume(audio_stream_type_t stream) const;
2292
2293 void setMasterMute_l(bool muted) { mMasterMute = muted; }
2294
2295 virtual void invalidateTracks(audio_stream_type_t streamType);
jiabinc44b3462022-12-08 12:52:31 -08002296 void invalidateTracks(std::set<audio_port_handle_t>& portIds) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002297
2298 virtual audio_stream_type_t streamType() { return mStreamType; }
2299 virtual void checkSilentMode_l();
Eric Laurent331679c2018-04-16 17:03:16 -07002300 void processVolume_l() override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002301
Vlad Popa7e81cea2023-01-19 16:34:16 +01002302 MetadataUpdate updateMetadata_l() override;
Kevin Rocard069c2712018-03-29 19:09:14 -07002303
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07002304 virtual void toAudioPortConfig(struct audio_port_config *config);
2305
jiabinb7d8c5a2020-08-26 17:24:52 -07002306 status_t getExternalPosition(uint64_t *position, int64_t *timeNanos) override;
2307
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002308 virtual bool isStreamInitialized() {
2309 return !(mOutput == nullptr || mOutput->stream == nullptr);
2310 }
2311
jiabinfc791ee2023-02-15 19:43:40 +00002312 status_t reportData(const void* buffer, size_t frameCount) override;
2313
Vlad Popa6fbbfbf2023-02-22 15:05:43 +01002314 void startMelComputation_l(const sp<audio_utils::MelProcessor>& processor) override;
2315 void stopMelComputation_l() override;
2316
Eric Laurent6acd1d42017-01-04 14:23:29 -08002317protected:
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002318 void dumpInternals_l(int fd, const Vector<String16>& args) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002319
2320 audio_stream_type_t mStreamType;
2321 float mMasterVolume;
2322 float mStreamVolume;
2323 bool mMasterMute;
2324 bool mStreamMute;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002325 AudioStreamOut* mOutput;
Vlad Popa6fbbfbf2023-02-22 15:05:43 +01002326
2327 mediautils::atomic_sp<audio_utils::MelProcessor> mMelProcessor;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002328};
2329
2330class MmapCaptureThread : public MmapThread
2331{
2332
2333public:
2334 MmapCaptureThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabinc52b1ff2019-10-31 17:20:42 -07002335 AudioHwDevice *hwDev, AudioStreamIn *input, bool systemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002336 virtual ~MmapCaptureThread() {}
2337
2338 AudioStreamIn* clearInput();
2339
Eric Laurentdda206a2022-07-08 17:28:35 +02002340 status_t exitStandby_l() REQUIRES(mLock) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002341
Vlad Popa7e81cea2023-01-19 16:34:16 +01002342 MetadataUpdate updateMetadata_l() override;
Eric Laurent331679c2018-04-16 17:03:16 -07002343 void processVolume_l() override;
Eric Laurent5ada82e2019-08-29 17:53:54 -07002344 void setRecordSilenced(audio_port_handle_t portId,
2345 bool silenced) override;
Kevin Rocard069c2712018-03-29 19:09:14 -07002346
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07002347 virtual void toAudioPortConfig(struct audio_port_config *config);
2348
jiabinb7d8c5a2020-08-26 17:24:52 -07002349 status_t getExternalPosition(uint64_t *position, int64_t *timeNanos) override;
2350
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002351 virtual bool isStreamInitialized() {
2352 return !(mInput == nullptr || mInput->stream == nullptr);
2353 }
2354
Eric Laurent6acd1d42017-01-04 14:23:29 -08002355protected:
2356
2357 AudioStreamIn* mInput;
2358};
jiabinc658e452022-10-21 20:52:21 +00002359
2360class BitPerfectThread : public MixerThread {
2361public:
2362 BitPerfectThread(const sp<AudioFlinger>& audioflinger, AudioStreamOut *output,
2363 audio_io_handle_t id, bool systemReady);
2364
2365protected:
2366 mixer_state prepareTracks_l(Vector<sp<Track>> *tracksToRemove) override;
2367 void threadLoop_mix() override;
2368
2369private:
2370 bool mIsBitPerfect;
jiabin76d94692022-12-15 21:51:21 +00002371 float mVolumeLeft = 0.f;
2372 float mVolumeRight = 0.f;
jiabinc658e452022-10-21 20:52:21 +00002373};
Andy Hunga5a7fc92023-06-23 19:27:19 -07002374
2375private: