blob: 47d533339616b921cc8a9845b93c41fd3f3384cd [file] [log] [blame]
Eric Laurent81784c32012-11-19 14:55:58 -08001/*
2**
3** Copyright 2012, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#ifndef INCLUDING_FROM_AUDIOFLINGER_H
19 #error This header file should only be included from AudioFlinger.h
20#endif
21
22class ThreadBase : public Thread {
23public:
24
25#include "TrackBase.h"
26
27 enum type_t {
28 MIXER, // Thread class is MixerThread
29 DIRECT, // Thread class is DirectOutputThread
30 DUPLICATING, // Thread class is DuplicatingThread
Eric Laurentbfb1b832013-01-07 09:53:42 -080031 RECORD, // Thread class is RecordThread
Eric Laurent6acd1d42017-01-04 14:23:29 -080032 OFFLOAD, // Thread class is OffloadThread
Andy Hungea840382020-05-05 21:50:17 -070033 MMAP_PLAYBACK, // Thread class for MMAP playback stream
34 MMAP_CAPTURE, // Thread class for MMAP capture stream
Eric Laurent1c5e2e32021-08-18 18:50:28 +020035 SPATIALIZER, //
jiabinc658e452022-10-21 20:52:21 +000036 BIT_PERFECT, // Thread class for BitPerfectThread
Glenn Kasten1bfe09a2017-02-21 13:05:56 -080037 // If you add any values here, also update ThreadBase::threadTypeToString()
Eric Laurent81784c32012-11-19 14:55:58 -080038 };
39
Glenn Kasten97b7b752014-09-28 13:04:24 -070040 static const char *threadTypeToString(type_t type);
41
Eric Laurent81784c32012-11-19 14:55:58 -080042 ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hungcf10d742020-04-28 15:38:24 -070043 type_t type, bool systemReady, bool isOut);
Eric Laurent81784c32012-11-19 14:55:58 -080044 virtual ~ThreadBase();
45
Glenn Kastencf04c2c2013-08-06 07:41:16 -070046 virtual status_t readyToRun();
47
Eric Laurent81784c32012-11-19 14:55:58 -080048 void clearPowerManager();
49
50 // base for record and playback
51 enum {
52 CFG_EVENT_IO,
Eric Laurent10351942014-05-08 18:49:52 -070053 CFG_EVENT_PRIO,
54 CFG_EVENT_SET_PARAMETER,
Eric Laurent1c333e22014-05-20 10:48:17 -070055 CFG_EVENT_CREATE_AUDIO_PATCH,
56 CFG_EVENT_RELEASE_AUDIO_PATCH,
jiabinc52b1ff2019-10-31 17:20:42 -070057 CFG_EVENT_UPDATE_OUT_DEVICE,
Eric Laurentb3f315a2021-07-13 15:09:05 +020058 CFG_EVENT_RESIZE_BUFFER,
Eric Laurent68a40a82022-05-03 18:15:04 +020059 CFG_EVENT_CHECK_OUTPUT_STAGE_EFFECTS,
60 CFG_EVENT_HAL_LATENCY_MODES_CHANGED,
Eric Laurent81784c32012-11-19 14:55:58 -080061 };
62
Eric Laurent10351942014-05-08 18:49:52 -070063 class ConfigEventData: public RefBase {
Eric Laurent81784c32012-11-19 14:55:58 -080064 public:
Eric Laurent10351942014-05-08 18:49:52 -070065 virtual ~ConfigEventData() {}
Eric Laurent81784c32012-11-19 14:55:58 -080066
67 virtual void dump(char *buffer, size_t size) = 0;
Eric Laurent10351942014-05-08 18:49:52 -070068 protected:
69 ConfigEventData() {}
Eric Laurent81784c32012-11-19 14:55:58 -080070 };
71
Eric Laurent10351942014-05-08 18:49:52 -070072 // Config event sequence by client if status needed (e.g binder thread calling setParameters()):
73 // 1. create SetParameterConfigEvent. This sets mWaitStatus in config event
74 // 2. Lock mLock
75 // 3. Call sendConfigEvent_l(): Append to mConfigEvents and mWaitWorkCV.signal
76 // 4. sendConfigEvent_l() reads status from event->mStatus;
77 // 5. sendConfigEvent_l() returns status
78 // 6. Unlock
79 //
80 // Parameter sequence by server: threadLoop calling processConfigEvents_l():
81 // 1. Lock mLock
82 // 2. If there is an entry in mConfigEvents proceed ...
83 // 3. Read first entry in mConfigEvents
84 // 4. Remove first entry from mConfigEvents
85 // 5. Process
86 // 6. Set event->mStatus
87 // 7. event->mCond.signal
88 // 8. Unlock
Eric Laurent81784c32012-11-19 14:55:58 -080089
Eric Laurent10351942014-05-08 18:49:52 -070090 class ConfigEvent: public RefBase {
91 public:
92 virtual ~ConfigEvent() {}
93
Eric Laurentb3f315a2021-07-13 15:09:05 +020094 void dump(char *buffer, size_t size) {
95 snprintf(buffer, size, "Event type: %d\n", mType);
96 if (mData != nullptr) {
97 snprintf(buffer, size, "Data:\n");
98 mData->dump(buffer, size);
99 }
100 }
Eric Laurent10351942014-05-08 18:49:52 -0700101
102 const int mType; // event type e.g. CFG_EVENT_IO
103 Mutex mLock; // mutex associated with mCond
104 Condition mCond; // condition for status return
105 status_t mStatus; // status communicated to sender
106 bool mWaitStatus; // true if sender is waiting for status
Eric Laurent72e3f392015-05-20 14:43:50 -0700107 bool mRequiresSystemReady; // true if must wait for system ready to enter event queue
Eric Laurent10351942014-05-08 18:49:52 -0700108 sp<ConfigEventData> mData; // event specific parameter data
109
110 protected:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700111 explicit ConfigEvent(int type, bool requiresSystemReady = false) :
Eric Laurent72e3f392015-05-20 14:43:50 -0700112 mType(type), mStatus(NO_ERROR), mWaitStatus(false),
113 mRequiresSystemReady(requiresSystemReady), mData(NULL) {}
Eric Laurent10351942014-05-08 18:49:52 -0700114 };
115
116 class IoConfigEventData : public ConfigEventData {
117 public:
Mikhail Naganov88536df2021-07-26 17:30:29 -0700118 IoConfigEventData(audio_io_config_event_t event, pid_t pid,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700119 audio_port_handle_t portId) :
120 mEvent(event), mPid(pid), mPortId(portId) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800121
122 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200123 snprintf(buffer, size, "- IO event: event %d\n", mEvent);
Eric Laurent81784c32012-11-19 14:55:58 -0800124 }
125
Mikhail Naganov88536df2021-07-26 17:30:29 -0700126 const audio_io_config_event_t mEvent;
Eric Laurent7c1ec5f2015-07-09 14:52:47 -0700127 const pid_t mPid;
Eric Laurent09f1ed22019-04-24 17:45:17 -0700128 const audio_port_handle_t mPortId;
Eric Laurent81784c32012-11-19 14:55:58 -0800129 };
130
Eric Laurent10351942014-05-08 18:49:52 -0700131 class IoConfigEvent : public ConfigEvent {
Eric Laurent81784c32012-11-19 14:55:58 -0800132 public:
Mikhail Naganov88536df2021-07-26 17:30:29 -0700133 IoConfigEvent(audio_io_config_event_t event, pid_t pid, audio_port_handle_t portId) :
Eric Laurent10351942014-05-08 18:49:52 -0700134 ConfigEvent(CFG_EVENT_IO) {
Eric Laurent09f1ed22019-04-24 17:45:17 -0700135 mData = new IoConfigEventData(event, pid, portId);
Eric Laurent10351942014-05-08 18:49:52 -0700136 }
137 virtual ~IoConfigEvent() {}
138 };
Eric Laurent81784c32012-11-19 14:55:58 -0800139
Eric Laurent10351942014-05-08 18:49:52 -0700140 class PrioConfigEventData : public ConfigEventData {
141 public:
Mikhail Naganov83f04272017-02-07 10:45:09 -0800142 PrioConfigEventData(pid_t pid, pid_t tid, int32_t prio, bool forApp) :
143 mPid(pid), mTid(tid), mPrio(prio), mForApp(forApp) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800144
145 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200146 snprintf(buffer, size, "- Prio event: pid %d, tid %d, prio %d, for app? %d\n",
Mikhail Naganov83f04272017-02-07 10:45:09 -0800147 mPid, mTid, mPrio, mForApp);
Eric Laurent81784c32012-11-19 14:55:58 -0800148 }
149
Eric Laurent81784c32012-11-19 14:55:58 -0800150 const pid_t mPid;
151 const pid_t mTid;
152 const int32_t mPrio;
Mikhail Naganov83f04272017-02-07 10:45:09 -0800153 const bool mForApp;
Eric Laurent81784c32012-11-19 14:55:58 -0800154 };
155
Eric Laurent10351942014-05-08 18:49:52 -0700156 class PrioConfigEvent : public ConfigEvent {
157 public:
Mikhail Naganov83f04272017-02-07 10:45:09 -0800158 PrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp) :
Eric Laurent72e3f392015-05-20 14:43:50 -0700159 ConfigEvent(CFG_EVENT_PRIO, true) {
Mikhail Naganov83f04272017-02-07 10:45:09 -0800160 mData = new PrioConfigEventData(pid, tid, prio, forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700161 }
162 virtual ~PrioConfigEvent() {}
163 };
164
165 class SetParameterConfigEventData : public ConfigEventData {
166 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700167 explicit SetParameterConfigEventData(String8 keyValuePairs) :
Eric Laurent10351942014-05-08 18:49:52 -0700168 mKeyValuePairs(keyValuePairs) {}
169
170 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200171 snprintf(buffer, size, "- KeyValue: %s\n", mKeyValuePairs.string());
Eric Laurent10351942014-05-08 18:49:52 -0700172 }
173
174 const String8 mKeyValuePairs;
175 };
176
177 class SetParameterConfigEvent : public ConfigEvent {
178 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700179 explicit SetParameterConfigEvent(String8 keyValuePairs) :
Eric Laurent10351942014-05-08 18:49:52 -0700180 ConfigEvent(CFG_EVENT_SET_PARAMETER) {
181 mData = new SetParameterConfigEventData(keyValuePairs);
182 mWaitStatus = true;
183 }
184 virtual ~SetParameterConfigEvent() {}
185 };
186
Eric Laurent1c333e22014-05-20 10:48:17 -0700187 class CreateAudioPatchConfigEventData : public ConfigEventData {
188 public:
189 CreateAudioPatchConfigEventData(const struct audio_patch patch,
190 audio_patch_handle_t handle) :
191 mPatch(patch), mHandle(handle) {}
192
193 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200194 snprintf(buffer, size, "- Patch handle: %u\n", mHandle);
Eric Laurent1c333e22014-05-20 10:48:17 -0700195 }
196
197 const struct audio_patch mPatch;
198 audio_patch_handle_t mHandle;
199 };
200
201 class CreateAudioPatchConfigEvent : public ConfigEvent {
202 public:
203 CreateAudioPatchConfigEvent(const struct audio_patch patch,
204 audio_patch_handle_t handle) :
205 ConfigEvent(CFG_EVENT_CREATE_AUDIO_PATCH) {
206 mData = new CreateAudioPatchConfigEventData(patch, handle);
207 mWaitStatus = true;
208 }
209 virtual ~CreateAudioPatchConfigEvent() {}
210 };
211
212 class ReleaseAudioPatchConfigEventData : public ConfigEventData {
213 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700214 explicit ReleaseAudioPatchConfigEventData(const audio_patch_handle_t handle) :
Eric Laurent1c333e22014-05-20 10:48:17 -0700215 mHandle(handle) {}
216
217 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200218 snprintf(buffer, size, "- Patch handle: %u\n", mHandle);
Eric Laurent1c333e22014-05-20 10:48:17 -0700219 }
220
221 audio_patch_handle_t mHandle;
222 };
223
224 class ReleaseAudioPatchConfigEvent : public ConfigEvent {
225 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700226 explicit ReleaseAudioPatchConfigEvent(const audio_patch_handle_t handle) :
Eric Laurent1c333e22014-05-20 10:48:17 -0700227 ConfigEvent(CFG_EVENT_RELEASE_AUDIO_PATCH) {
228 mData = new ReleaseAudioPatchConfigEventData(handle);
229 mWaitStatus = true;
230 }
231 virtual ~ReleaseAudioPatchConfigEvent() {}
232 };
Eric Laurent81784c32012-11-19 14:55:58 -0800233
jiabinc52b1ff2019-10-31 17:20:42 -0700234 class UpdateOutDevicesConfigEventData : public ConfigEventData {
235 public:
236 explicit UpdateOutDevicesConfigEventData(const DeviceDescriptorBaseVector& outDevices) :
237 mOutDevices(outDevices) {}
238
239 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200240 snprintf(buffer, size, "- Devices: %s", android::toString(mOutDevices).c_str());
jiabinc52b1ff2019-10-31 17:20:42 -0700241 }
242
243 DeviceDescriptorBaseVector mOutDevices;
244 };
245
246 class UpdateOutDevicesConfigEvent : public ConfigEvent {
247 public:
248 explicit UpdateOutDevicesConfigEvent(const DeviceDescriptorBaseVector& outDevices) :
249 ConfigEvent(CFG_EVENT_UPDATE_OUT_DEVICE) {
250 mData = new UpdateOutDevicesConfigEventData(outDevices);
251 }
252
253 virtual ~UpdateOutDevicesConfigEvent();
254 };
255
Eric Laurentec376dc2021-04-08 20:41:22 +0200256 class ResizeBufferConfigEventData : public ConfigEventData {
257 public:
258 explicit ResizeBufferConfigEventData(int32_t maxSharedAudioHistoryMs) :
259 mMaxSharedAudioHistoryMs(maxSharedAudioHistoryMs) {}
260
261 virtual void dump(char *buffer, size_t size) {
Eric Laurentb3f315a2021-07-13 15:09:05 +0200262 snprintf(buffer, size, "- mMaxSharedAudioHistoryMs: %d", mMaxSharedAudioHistoryMs);
Eric Laurentec376dc2021-04-08 20:41:22 +0200263 }
264
265 int32_t mMaxSharedAudioHistoryMs;
266 };
267
268 class ResizeBufferConfigEvent : public ConfigEvent {
269 public:
270 explicit ResizeBufferConfigEvent(int32_t maxSharedAudioHistoryMs) :
271 ConfigEvent(CFG_EVENT_RESIZE_BUFFER) {
272 mData = new ResizeBufferConfigEventData(maxSharedAudioHistoryMs);
273 }
274
275 virtual ~ResizeBufferConfigEvent() {}
276 };
277
Eric Laurentb3f315a2021-07-13 15:09:05 +0200278 class CheckOutputStageEffectsEvent : public ConfigEvent {
279 public:
280 CheckOutputStageEffectsEvent() :
281 ConfigEvent(CFG_EVENT_CHECK_OUTPUT_STAGE_EFFECTS) {
282 }
283
284 virtual ~CheckOutputStageEffectsEvent() {}
285 };
286
Eric Laurent68a40a82022-05-03 18:15:04 +0200287 class HalLatencyModesChangedEvent : public ConfigEvent {
288 public:
289 HalLatencyModesChangedEvent() :
290 ConfigEvent(CFG_EVENT_HAL_LATENCY_MODES_CHANGED) {
291 }
292
293 virtual ~HalLatencyModesChangedEvent() {}
294 };
295
Eric Laurentb3f315a2021-07-13 15:09:05 +0200296
Eric Laurent81784c32012-11-19 14:55:58 -0800297 class PMDeathRecipient : public IBinder::DeathRecipient {
298 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700299 explicit PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {}
Eric Laurent81784c32012-11-19 14:55:58 -0800300 virtual ~PMDeathRecipient() {}
301
302 // IBinder::DeathRecipient
303 virtual void binderDied(const wp<IBinder>& who);
304
305 private:
Mikhail Naganovbf493082017-04-17 17:37:12 -0700306 DISALLOW_COPY_AND_ASSIGN(PMDeathRecipient);
Eric Laurent81784c32012-11-19 14:55:58 -0800307
308 wp<ThreadBase> mThread;
309 };
310
311 virtual status_t initCheck() const = 0;
312
313 // static externally-visible
314 type_t type() const { return mType; }
Eric Laurentf6870ae2015-05-08 10:50:03 -0700315 bool isDuplicating() const { return (mType == DUPLICATING); }
316
Eric Laurent81784c32012-11-19 14:55:58 -0800317 audio_io_handle_t id() const { return mId;}
318
319 // dynamic externally-visible
320 uint32_t sampleRate() const { return mSampleRate; }
Eric Laurent81784c32012-11-19 14:55:58 -0800321 audio_channel_mask_t channelMask() const { return mChannelMask; }
Eric Laurentf1f22e72021-07-13 14:04:14 +0200322 virtual audio_channel_mask_t mixerChannelMask() const { return mChannelMask; }
323
Andy Hung463be252014-07-10 16:56:07 -0700324 audio_format_t format() const { return mHALFormat; }
Eric Laurent83b88082014-06-20 18:31:16 -0700325 uint32_t channelCount() const { return mChannelCount; }
Eric Laurentf1f22e72021-07-13 14:04:14 +0200326
Eric Laurent81784c32012-11-19 14:55:58 -0800327 // Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects,
Glenn Kasten9b58f632013-07-16 11:37:48 -0700328 // and returns the [normal mix] buffer's frame count.
329 virtual size_t frameCount() const = 0;
jiabineb3bda02020-06-30 14:07:03 -0700330 virtual audio_channel_mask_t hapticChannelMask() const { return AUDIO_CHANNEL_NONE; }
Eric Laurent6b446ce2019-12-13 10:56:31 -0800331 virtual uint32_t latency_l() const { return 0; }
332 virtual void setVolumeForOutput_l(float left __unused, float right __unused) const {}
Glenn Kasten4a8308b2016-04-18 14:10:01 -0700333
334 // Return's the HAL's frame count i.e. fast mixer buffer size.
335 size_t frameCountHAL() const { return mFrameCount; }
336
Eric Laurentbfb1b832013-01-07 09:53:42 -0800337 size_t frameSize() const { return mFrameSize; }
Eric Laurent81784c32012-11-19 14:55:58 -0800338
339 // Should be "virtual status_t requestExitAndWait()" and override same
340 // method in Thread, but Thread::requestExitAndWait() is not yet virtual.
341 void exit();
Eric Laurent10351942014-05-08 18:49:52 -0700342 virtual bool checkForNewParameter_l(const String8& keyValuePair,
343 status_t& status) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800344 virtual status_t setParameters(const String8& keyValuePairs);
345 virtual String8 getParameters(const String8& keys) = 0;
Mikhail Naganov88536df2021-07-26 17:30:29 -0700346 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700347 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) = 0;
Eric Laurent10351942014-05-08 18:49:52 -0700348 // sendConfigEvent_l() must be called with ThreadBase::mLock held
349 // Can temporarily release the lock if waiting for a reply from
350 // processConfigEvents_l().
351 status_t sendConfigEvent_l(sp<ConfigEvent>& event);
Mikhail Naganov88536df2021-07-26 17:30:29 -0700352 void sendIoConfigEvent(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700353 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Mikhail Naganov88536df2021-07-26 17:30:29 -0700354 void sendIoConfigEvent_l(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700355 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Mikhail Naganov83f04272017-02-07 10:45:09 -0800356 void sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp);
357 void sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio, bool forApp);
Eric Laurent10351942014-05-08 18:49:52 -0700358 status_t sendSetParameterConfigEvent_l(const String8& keyValuePair);
Eric Laurent1c333e22014-05-20 10:48:17 -0700359 status_t sendCreateAudioPatchConfigEvent(const struct audio_patch *patch,
360 audio_patch_handle_t *handle);
361 status_t sendReleaseAudioPatchConfigEvent(audio_patch_handle_t handle);
jiabinc52b1ff2019-10-31 17:20:42 -0700362 status_t sendUpdateOutDeviceConfigEvent(
363 const DeviceDescriptorBaseVector& outDevices);
Eric Laurentec376dc2021-04-08 20:41:22 +0200364 void sendResizeBufferConfigEvent_l(int32_t maxSharedAudioHistoryMs);
Eric Laurentb3f315a2021-07-13 15:09:05 +0200365 void sendCheckOutputStageEffectsEvent();
366 void sendCheckOutputStageEffectsEvent_l();
Eric Laurent68a40a82022-05-03 18:15:04 +0200367 void sendHalLatencyModesChangedEvent_l();
Eric Laurentb3f315a2021-07-13 15:09:05 +0200368
Eric Laurent021cf962014-05-13 10:18:14 -0700369 void processConfigEvents_l();
Eric Laurentb3f315a2021-07-13 15:09:05 +0200370 virtual void setCheckOutputStageEffects() {}
Eric Laurent10351942014-05-08 18:49:52 -0700371 virtual void cacheParameters_l() = 0;
Eric Laurent1c333e22014-05-20 10:48:17 -0700372 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
373 audio_patch_handle_t *handle) = 0;
374 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle) = 0;
jiabinc52b1ff2019-10-31 17:20:42 -0700375 virtual void updateOutDevices(const DeviceDescriptorBaseVector& outDevices);
Mikhail Naganovdc769682018-05-04 15:34:08 -0700376 virtual void toAudioPortConfig(struct audio_port_config *config) = 0;
Eric Laurent1c333e22014-05-20 10:48:17 -0700377
Eric Laurent5f0fd7b2021-05-07 16:33:26 +0200378 virtual void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs);
Eric Laurent81784c32012-11-19 14:55:58 -0800379
380 // see note at declaration of mStandby, mOutDevice and mInDevice
381 bool standby() const { return mStandby; }
jiabinc52b1ff2019-10-31 17:20:42 -0700382 const DeviceTypeSet outDeviceTypes() const {
383 return getAudioDeviceTypes(mOutDeviceTypeAddrs);
384 }
385 audio_devices_t inDeviceType() const { return mInDeviceTypeAddr.mType; }
386 DeviceTypeSet getDeviceTypes() const {
387 return isOutput() ? outDeviceTypes() : DeviceTypeSet({inDeviceType()});
388 }
Andy Hung293558a2017-03-21 12:19:20 -0700389
jiabin8f278ee2019-11-11 12:16:27 -0800390 const AudioDeviceTypeAddrVector& outDeviceTypeAddrs() const {
391 return mOutDeviceTypeAddrs;
392 }
393 const AudioDeviceTypeAddr& inDeviceTypeAddr() const {
394 return mInDeviceTypeAddr;
395 }
396
Andy Hungcf10d742020-04-28 15:38:24 -0700397 bool isOutput() const { return mIsOut; }
Eric Laurent81784c32012-11-19 14:55:58 -0800398
Andy Hungea840382020-05-05 21:50:17 -0700399 bool isOffloadOrMmap() const {
400 switch (mType) {
401 case OFFLOAD:
402 case MMAP_PLAYBACK:
403 case MMAP_CAPTURE:
404 return true;
405 default:
406 return false;
407 }
408 }
409
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700410 virtual sp<StreamHalInterface> stream() const = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800411
412 sp<EffectHandle> createEffect_l(
413 const sp<AudioFlinger::Client>& client,
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700414 const sp<media::IEffectClient>& effectClient,
Eric Laurent81784c32012-11-19 14:55:58 -0800415 int32_t priority,
Glenn Kastend848eb42016-03-08 13:42:11 -0800416 audio_session_t sessionId,
Eric Laurent81784c32012-11-19 14:55:58 -0800417 effect_descriptor_t *desc,
418 int *enabled,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800419 status_t *status /*non-NULL*/,
Eric Laurent2fe0acd2020-03-13 14:30:46 -0700420 bool pinned,
Eric Laurentde8caf42021-08-11 17:19:25 +0200421 bool probe,
422 bool notifyFramesProcessed);
Eric Laurent81784c32012-11-19 14:55:58 -0800423
424 // return values for hasAudioSession (bit field)
425 enum effect_state {
426 EFFECT_SESSION = 0x1, // the audio session corresponds to at least one
427 // effect
Eric Laurent4c415062016-06-17 16:14:16 -0700428 TRACK_SESSION = 0x2, // the audio session corresponds to at least one
Eric Laurent81784c32012-11-19 14:55:58 -0800429 // track
Eric Laurentb62d0362021-10-26 17:40:18 +0200430 FAST_SESSION = 0x4, // the audio session corresponds to at least one
Eric Laurent4c415062016-06-17 16:14:16 -0700431 // fast track
jiabinc658e452022-10-21 20:52:21 +0000432 SPATIALIZED_SESSION = 0x8, // the audio session corresponds to at least one
433 // spatialized track
434 BIT_PERFECT_SESSION = 0x10 // the audio session corresponds to at least one
435 // bit-perfect track
Eric Laurent81784c32012-11-19 14:55:58 -0800436 };
437
438 // get effect chain corresponding to session Id.
Glenn Kastend848eb42016-03-08 13:42:11 -0800439 sp<EffectChain> getEffectChain(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800440 // same as getEffectChain() but must be called with ThreadBase mutex locked
Glenn Kastend848eb42016-03-08 13:42:11 -0800441 sp<EffectChain> getEffectChain_l(audio_session_t sessionId) const;
Eric Laurent6c796322019-04-09 14:13:17 -0700442 std::vector<int> getEffectIds_l(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800443 // add an effect chain to the chain list (mEffectChains)
444 virtual status_t addEffectChain_l(const sp<EffectChain>& chain) = 0;
445 // remove an effect chain from the chain list (mEffectChains)
446 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0;
447 // lock all effect chains Mutexes. Must be called before releasing the
448 // ThreadBase mutex before processing the mixer and effects. This guarantees the
449 // integrity of the chains during the process.
450 // Also sets the parameter 'effectChains' to current value of mEffectChains.
451 void lockEffectChains_l(Vector< sp<EffectChain> >& effectChains);
452 // unlock effect chains after process
453 void unlockEffectChains(const Vector< sp<EffectChain> >& effectChains);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800454 // get a copy of mEffectChains vector
455 Vector< sp<EffectChain> > getEffectChains_l() const { return mEffectChains; };
Eric Laurent81784c32012-11-19 14:55:58 -0800456 // set audio mode to all effect chains
457 void setMode(audio_mode_t mode);
458 // get effect module with corresponding ID on specified audio session
Glenn Kastend848eb42016-03-08 13:42:11 -0800459 sp<AudioFlinger::EffectModule> getEffect(audio_session_t sessionId, int effectId);
460 sp<AudioFlinger::EffectModule> getEffect_l(audio_session_t sessionId, int effectId);
Eric Laurent81784c32012-11-19 14:55:58 -0800461 // add and effect module. Also creates the effect chain is none exists for
Eric Laurent6c796322019-04-09 14:13:17 -0700462 // the effects audio session. Only called in a context of moving an effect
463 // from one thread to another
Eric Laurent81784c32012-11-19 14:55:58 -0800464 status_t addEffect_l(const sp< EffectModule>& effect);
465 // remove and effect module. Also removes the effect chain is this was the last
466 // effect
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800467 void removeEffect_l(const sp< EffectModule>& effect, bool release = false);
468 // disconnect an effect handle from module and destroy module if last handle
469 void disconnectEffectHandle(EffectHandle *handle, bool unpinIfLast);
Eric Laurent81784c32012-11-19 14:55:58 -0800470 // detach all tracks connected to an auxiliary effect
Glenn Kasten0f11b512014-01-31 16:18:54 -0800471 virtual void detachAuxEffect_l(int effectId __unused) {}
Eric Laurent4c415062016-06-17 16:14:16 -0700472 // returns a combination of:
473 // - EFFECT_SESSION if effects on this audio session exist in one chain
474 // - TRACK_SESSION if tracks on this audio session exist
475 // - FAST_SESSION if fast tracks on this audio session exist
Eric Laurentb62d0362021-10-26 17:40:18 +0200476 // - SPATIALIZED_SESSION if spatialized tracks on this audio session exist
Eric Laurent4c415062016-06-17 16:14:16 -0700477 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const = 0;
478 uint32_t hasAudioSession(audio_session_t sessionId) const {
479 Mutex::Autolock _l(mLock);
480 return hasAudioSession_l(sessionId);
481 }
482
Andy Hungc3d62f92019-03-14 13:38:51 -0700483 template <typename T>
484 uint32_t hasAudioSession_l(audio_session_t sessionId, const T& tracks) const {
485 uint32_t result = 0;
486 if (getEffectChain_l(sessionId) != 0) {
487 result = EFFECT_SESSION;
488 }
489 for (size_t i = 0; i < tracks.size(); ++i) {
490 const sp<TrackBase>& track = tracks[i];
491 if (sessionId == track->sessionId()
492 && !track->isInvalid() // not yet removed from tracks.
493 && !track->isTerminated()) {
494 result |= TRACK_SESSION;
495 if (track->isFastTrack()) {
496 result |= FAST_SESSION; // caution, only represents first track.
497 }
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200498 if (track->isSpatialized()) {
Eric Laurentb62d0362021-10-26 17:40:18 +0200499 result |= SPATIALIZED_SESSION; // caution, only first track.
500 }
jiabinc658e452022-10-21 20:52:21 +0000501 if (track->isBitPerfect()) {
502 result |= BIT_PERFECT_SESSION;
503 }
Andy Hungc3d62f92019-03-14 13:38:51 -0700504 break;
505 }
506 }
507 return result;
508 }
509
Eric Laurent81784c32012-11-19 14:55:58 -0800510 // the value returned by default implementation is not important as the
511 // strategy is only meaningful for PlaybackThread which implements this method
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800512 virtual product_strategy_t getStrategyForSession_l(
513 audio_session_t sessionId __unused) {
514 return static_cast<product_strategy_t>(0);
515 }
Eric Laurent81784c32012-11-19 14:55:58 -0800516
Eric Laurent81784c32012-11-19 14:55:58 -0800517 // check if some effects must be suspended/restored when an effect is enabled
518 // or disabled
Eric Laurent6b446ce2019-12-13 10:56:31 -0800519 void checkSuspendOnEffectEnabled(bool enabled,
520 audio_session_t sessionId,
521 bool threadLocked);
Eric Laurent81784c32012-11-19 14:55:58 -0800522
523 virtual status_t setSyncEvent(const sp<SyncEvent>& event) = 0;
524 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const = 0;
525
Glenn Kastenb880f5e2014-05-07 08:43:45 -0700526 // Return a reference to a per-thread heap which can be used to allocate IMemory
527 // objects that will be read-only to client processes, read/write to mediaserver,
528 // and shared by all client processes of the thread.
529 // The heap is per-thread rather than common across all threads, because
530 // clients can't be trusted not to modify the offset of the IMemory they receive.
531 // If a thread does not have such a heap, this method returns 0.
532 virtual sp<MemoryDealer> readOnlyHeap() const { return 0; }
Eric Laurent81784c32012-11-19 14:55:58 -0800533
Glenn Kasten6181ffd2014-05-13 10:41:52 -0700534 virtual sp<IMemory> pipeMemory() const { return 0; }
535
Eric Laurent72e3f392015-05-20 14:43:50 -0700536 void systemReady();
537
Eric Laurent4c415062016-06-17 16:14:16 -0700538 // checkEffectCompatibility_l() must be called with ThreadBase::mLock held
539 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
540 audio_session_t sessionId) = 0;
541
Eric Laurent6acd1d42017-01-04 14:23:29 -0800542 void broadcast_l();
543
Andy Hungc8fddf32018-08-08 18:32:37 -0700544 virtual bool isTimestampCorrectionEnabled() const { return false; }
545
546 bool isMsdDevice() const { return mIsMsdDevice; }
547
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700548 void dump(int fd, const Vector<String16>& args);
Andy Hungdc099c22018-09-18 13:46:39 -0700549
Andy Hungd0979812019-02-21 15:51:44 -0800550 // deliver stats to mediametrics.
551 void sendStatistics(bool force);
552
Eric Laurent81784c32012-11-19 14:55:58 -0800553 mutable Mutex mLock;
554
Eric Laurent6b446ce2019-12-13 10:56:31 -0800555 void onEffectEnable(const sp<EffectModule>& effect);
556 void onEffectDisable();
557
jiabineb3bda02020-06-30 14:07:03 -0700558 // invalidateTracksForAudioSession_l must be called with holding mLock.
559 virtual void invalidateTracksForAudioSession_l(audio_session_t sessionId __unused) const { }
560 // Invalidate all the tracks with the given audio session.
561 void invalidateTracksForAudioSession(audio_session_t sessionId) const {
562 Mutex::Autolock _l(mLock);
563 invalidateTracksForAudioSession_l(sessionId);
564 }
565
566 template <typename T>
567 void invalidateTracksForAudioSession_l(audio_session_t sessionId,
568 const T& tracks) const {
569 for (size_t i = 0; i < tracks.size(); ++i) {
570 const sp<TrackBase>& track = tracks[i];
571 if (sessionId == track->sessionId()) {
572 track->invalidate();
573 }
574 }
575 }
576
Jasmine Chaeaa10e42021-05-11 10:11:14 +0800577 virtual bool isStreamInitialized() = 0;
578
Eric Laurent81784c32012-11-19 14:55:58 -0800579protected:
580
581 // entry describing an effect being suspended in mSuspendedSessions keyed vector
582 class SuspendedSessionDesc : public RefBase {
583 public:
584 SuspendedSessionDesc() : mRefCount(0) {}
585
586 int mRefCount; // number of active suspend requests
587 effect_uuid_t mType; // effect type UUID
588 };
589
Andy Hungdae27702016-10-31 14:01:16 -0700590 void acquireWakeLock();
591 virtual void acquireWakeLock_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800592 void releaseWakeLock();
593 void releaseWakeLock_l();
Andy Hungd01b0f12016-11-07 16:10:30 -0800594 void updateWakeLockUids_l(const SortedVector<uid_t> &uids);
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800595 void getPowerManager_l();
Eric Laurentd8365c52017-07-16 15:27:05 -0700596 // suspend or restore effects of the specified type (or all if type is NULL)
597 // on a given session. The number of suspend requests is counted and restore
598 // occurs when all suspend requests are cancelled.
Eric Laurent81784c32012-11-19 14:55:58 -0800599 void setEffectSuspended_l(const effect_uuid_t *type,
600 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -0800601 audio_session_t sessionId);
Eric Laurentd8365c52017-07-16 15:27:05 -0700602 // updated mSuspendedSessions when an effect is suspended or restored
Eric Laurent81784c32012-11-19 14:55:58 -0800603 void updateSuspendedSessions_l(const effect_uuid_t *type,
604 bool suspend,
Glenn Kastend848eb42016-03-08 13:42:11 -0800605 audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800606 // check if some effects must be suspended when an effect chain is added
607 void checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain);
608
Kevin Rocard069c2712018-03-29 19:09:14 -0700609 // sends the metadata of the active tracks to the HAL
Vlad Popa7e81cea2023-01-19 16:34:16 +0100610 struct MetadataUpdate {
611 std::vector<playback_track_metadata_v7_t> playbackMetadataUpdate;
612 std::vector<record_track_metadata_v7_t> recordMetadataUpdate;
613 };
614 virtual MetadataUpdate updateMetadata_l() = 0;
Kevin Rocard069c2712018-03-29 19:09:14 -0700615
Narayan Kamath014e7fa2013-10-14 15:03:38 +0100616 String16 getWakeLockTag();
617
Eric Laurent81784c32012-11-19 14:55:58 -0800618 virtual void preExit() { }
Andy Hung2ddee192015-12-18 17:34:44 -0800619 virtual void setMasterMono_l(bool mono __unused) { }
620 virtual bool requireMonoBlend() { return false; }
Eric Laurent81784c32012-11-19 14:55:58 -0800621
Andy Hung1c86ebe2018-05-29 20:29:08 -0700622 // called within the threadLoop to obtain timestamp from the HAL.
623 virtual status_t threadloop_getHalTimestamp_l(
624 ExtendedTimestamp *timestamp __unused) const {
625 return INVALID_OPERATION;
626 }
627
Eric Laurentd66d7a12021-07-13 13:35:32 +0200628 product_strategy_t getStrategyForStream(audio_stream_type_t stream) const;
629
Eric Laurentb0463942022-12-20 16:31:10 +0100630 virtual void onHalLatencyModesChanged_l() {}
631
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700632 virtual void dumpInternals_l(int fd __unused, const Vector<String16>& args __unused)
633 { }
634 virtual void dumpTracks_l(int fd __unused, const Vector<String16>& args __unused) { }
635
636
Vlad Popae8d99472022-06-30 16:02:48 +0200637 friend class AudioFlinger; // for mEffectChains and mAudioManager
Eric Laurent81784c32012-11-19 14:55:58 -0800638
639 const type_t mType;
640
641 // Used by parameters, config events, addTrack_l, exit
642 Condition mWaitWorkCV;
643
644 const sp<AudioFlinger> mAudioFlinger;
Andy Hungcf10d742020-04-28 15:38:24 -0700645 ThreadMetrics mThreadMetrics;
646 const bool mIsOut;
Glenn Kasten9b58f632013-07-16 11:37:48 -0700647
Glenn Kastendeca2ae2014-02-07 10:25:56 -0800648 // updated by PlaybackThread::readOutputParameters_l() or
649 // RecordThread::readInputParameters_l()
Eric Laurent81784c32012-11-19 14:55:58 -0800650 uint32_t mSampleRate;
651 size_t mFrameCount; // output HAL, direct output, record
Eric Laurent81784c32012-11-19 14:55:58 -0800652 audio_channel_mask_t mChannelMask;
Glenn Kastenf6ed4232013-07-16 11:16:27 -0700653 uint32_t mChannelCount;
Eric Laurent81784c32012-11-19 14:55:58 -0800654 size_t mFrameSize;
Glenn Kasten97b7b752014-09-28 13:04:24 -0700655 // not HAL frame size, this is for output sink (to pipe to fast mixer)
Andy Hung463be252014-07-10 16:56:07 -0700656 audio_format_t mFormat; // Source format for Recording and
657 // Sink format for Playback.
658 // Sink format may be different than
659 // HAL format if Fastmixer is used.
660 audio_format_t mHALFormat;
Glenn Kasten70949c42013-08-06 07:40:12 -0700661 size_t mBufferSize; // HAL buffer size for read() or write()
jiabinc52b1ff2019-10-31 17:20:42 -0700662 AudioDeviceTypeAddrVector mOutDeviceTypeAddrs; // output device types and addresses
663 AudioDeviceTypeAddr mInDeviceTypeAddr; // input device type and address
Eric Laurent10351942014-05-08 18:49:52 -0700664 Vector< sp<ConfigEvent> > mConfigEvents;
Eric Laurent72e3f392015-05-20 14:43:50 -0700665 Vector< sp<ConfigEvent> > mPendingConfigEvents; // events awaiting system ready
Eric Laurent81784c32012-11-19 14:55:58 -0800666
667 // These fields are written and read by thread itself without lock or barrier,
jiabinc52b1ff2019-10-31 17:20:42 -0700668 // and read by other threads without lock or barrier via standby(), outDeviceTypes()
669 // and inDeviceType().
Eric Laurent81784c32012-11-19 14:55:58 -0800670 // Because of the absence of a lock or barrier, any other thread that reads
671 // these fields must use the information in isolation, or be prepared to deal
672 // with possibility that it might be inconsistent with other information.
Glenn Kasten4944acb2013-08-19 08:39:20 -0700673 bool mStandby; // Whether thread is currently in standby.
jiabinc52b1ff2019-10-31 17:20:42 -0700674
Eric Laurent296fb132015-05-01 11:38:42 -0700675 struct audio_patch mPatch;
jiabinc52b1ff2019-10-31 17:20:42 -0700676
Glenn Kastenf59497b2015-01-26 16:35:47 -0800677 audio_source_t mAudioSource;
Eric Laurent81784c32012-11-19 14:55:58 -0800678
679 const audio_io_handle_t mId;
680 Vector< sp<EffectChain> > mEffectChains;
681
Glenn Kastend7dca052015-03-05 16:05:54 -0800682 static const int kThreadNameLength = 16; // prctl(PR_SET_NAME) limit
683 char mThreadName[kThreadNameLength]; // guaranteed NUL-terminated
Chris Ye6597d732020-02-28 22:38:25 -0800684 sp<os::IPowerManager> mPowerManager;
Eric Laurent81784c32012-11-19 14:55:58 -0800685 sp<IBinder> mWakeLockToken;
686 const sp<PMDeathRecipient> mDeathRecipient;
Glenn Kastend848eb42016-03-08 13:42:11 -0800687 // list of suspended effects per session and per type. The first (outer) vector is
688 // keyed by session ID, the second (inner) by type UUID timeLow field
Eric Laurentd8365c52017-07-16 15:27:05 -0700689 // Updated by updateSuspendedSessions_l() only.
Glenn Kastend848eb42016-03-08 13:42:11 -0800690 KeyedVector< audio_session_t, KeyedVector< int, sp<SuspendedSessionDesc> > >
Eric Laurent81784c32012-11-19 14:55:58 -0800691 mSuspendedSessions;
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -0700692 // TODO: add comment and adjust size as needed
Glenn Kastenab7d72f2013-02-27 09:05:28 -0800693 static const size_t kLogSize = 4 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -0800694 sp<NBLog::Writer> mNBLogWriter;
Eric Laurent72e3f392015-05-20 14:43:50 -0700695 bool mSystemReady;
Andy Hung818e7a32016-02-16 18:08:07 -0800696 ExtendedTimestamp mTimestamp;
Andy Hung2e2c0bb2018-06-11 19:13:11 -0700697 TimestampVerifier< // For timestamp statistics.
698 int64_t /* frame count */, int64_t /* time ns */> mTimestampVerifier;
Dean Wheatley12473e92021-03-18 23:00:55 +1100699 // DIRECT and OFFLOAD threads should reset frame count to zero on stop/flush
700 // TODO: add confirmation checks:
701 // 1) DIRECT threads and linear PCM format really resets to 0?
702 // 2) Is frame count really valid if not linear pcm?
703 // 3) Are all 64 bits of position returned, not just lowest 32 bits?
jiabinc52b1ff2019-10-31 17:20:42 -0700704 // Timestamp corrected device should be a single device.
705 audio_devices_t mTimestampCorrectedDevice = AUDIO_DEVICE_NONE;
Andy Hung446f4df2019-02-21 12:26:41 -0800706
707 // ThreadLoop statistics per iteration.
708 int64_t mLastIoBeginNs = -1;
709 int64_t mLastIoEndNs = -1;
710
Andy Hung44d648b2022-04-08 17:33:40 -0700711 // ThreadSnapshot is thread-safe (internally locked)
712 mediautils::ThreadSnapshot mThreadSnapshot;
713
Andy Hung446f4df2019-02-21 12:26:41 -0800714 // This should be read under ThreadBase lock (if not on the threadLoop thread).
715 audio_utils::Statistics<double> mIoJitterMs{0.995 /* alpha */};
716 audio_utils::Statistics<double> mProcessTimeMs{0.995 /* alpha */};
Andy Hunge6c37112019-02-26 17:38:10 -0800717 audio_utils::Statistics<double> mLatencyMs{0.995 /* alpha */};
Robert Wu06db0a32021-08-10 19:05:34 +0000718 audio_utils::Statistics<double> mMonopipePipeDepthStats{0.999 /* alpha */};
Andy Hung446f4df2019-02-21 12:26:41 -0800719
Andy Hungd0979812019-02-21 15:51:44 -0800720 // Save the last count when we delivered statistics to mediametrics.
721 int64_t mLastRecordedTimestampVerifierN = 0;
722 int64_t mLastRecordedTimeNs = 0; // BOOTTIME to include suspend.
723
Andy Hungc8fddf32018-08-08 18:32:37 -0700724 bool mIsMsdDevice = false;
Eric Laurent6acd1d42017-01-04 14:23:29 -0800725 // A condition that must be evaluated by the thread loop has changed and
726 // we must not wait for async write callback in the thread loop before evaluating it
727 bool mSignalPending;
Andy Hungdae27702016-10-31 14:01:16 -0700728
Andy Hung8946a282018-04-19 20:04:56 -0700729#ifdef TEE_SINK
730 NBAIO_Tee mTee;
731#endif
Andy Hungdae27702016-10-31 14:01:16 -0700732 // ActiveTracks is a sorted vector of track type T representing the
733 // active tracks of threadLoop() to be considered by the locked prepare portion.
734 // ActiveTracks should be accessed with the ThreadBase lock held.
735 //
736 // During processing and I/O, the threadLoop does not hold the lock;
737 // hence it does not directly use ActiveTracks. Care should be taken
738 // to hold local strong references or defer removal of tracks
739 // if the threadLoop may still be accessing those tracks due to mix, etc.
740 //
741 // This class updates power information appropriately.
742 //
743
744 template <typename T>
745 class ActiveTracks {
746 public:
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700747 explicit ActiveTracks(SimpleLog *localLog = nullptr)
Andy Hungdae27702016-10-31 14:01:16 -0700748 : mActiveTracksGeneration(0)
749 , mLastActiveTracksGeneration(0)
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700750 , mLocalLog(localLog)
Andy Hungdae27702016-10-31 14:01:16 -0700751 { }
752
753 ~ActiveTracks() {
754 ALOGW_IF(!mActiveTracks.isEmpty(),
755 "ActiveTracks should be empty in destructor");
756 }
757 // returns the last track added (even though it may have been
758 // subsequently removed from ActiveTracks).
759 //
760 // Used for DirectOutputThread to ensure a flush is called when transitioning
761 // to a new track (even though it may be on the same session).
762 // Used for OffloadThread to ensure that volume and mixer state is
763 // taken from the latest track added.
764 //
765 // The latest track is saved with a weak pointer to prevent keeping an
766 // otherwise useless track alive. Thus the function will return nullptr
767 // if the latest track has subsequently been removed and destroyed.
768 sp<T> getLatest() {
769 return mLatestActiveTrack.promote();
770 }
771
772 // SortedVector methods
773 ssize_t add(const sp<T> &track);
774 ssize_t remove(const sp<T> &track);
775 size_t size() const {
776 return mActiveTracks.size();
777 }
Eric Tan39ec8d62018-07-24 09:49:29 -0700778 bool isEmpty() const {
779 return mActiveTracks.isEmpty();
780 }
Andy Hungdae27702016-10-31 14:01:16 -0700781 ssize_t indexOf(const sp<T>& item) {
782 return mActiveTracks.indexOf(item);
783 }
784 sp<T> operator[](size_t index) const {
785 return mActiveTracks[index];
786 }
787 typename SortedVector<sp<T>>::iterator begin() {
788 return mActiveTracks.begin();
789 }
790 typename SortedVector<sp<T>>::iterator end() {
791 return mActiveTracks.end();
792 }
793
794 // Due to Binder recursion optimization, clear() and updatePowerState()
795 // cannot be called from a Binder thread because they may call back into
796 // the original calling process (system server) for BatteryNotifier
797 // (which requires a Java environment that may not be present).
798 // Hence, call clear() and updatePowerState() only from the
799 // ThreadBase thread.
800 void clear();
801 // periodically called in the threadLoop() to update power state uids.
802 void updatePowerState(sp<ThreadBase> thread, bool force = false);
803
Kevin Rocardc86a7f72018-04-03 09:00:09 -0700804 /** @return true if one or move active tracks was added or removed since the
Jasmine Chaeaa10e42021-05-11 10:11:14 +0800805 * last time this function was called or the vector was created.
806 * true if volume of one of active tracks was changed.
807 */
Kevin Rocard069c2712018-03-29 19:09:14 -0700808 bool readAndClearHasChanged();
809
Eric Laurentdda206a2022-07-08 17:28:35 +0200810 /** Force updating track metadata to audio HAL stream next time
811 * readAndClearHasChanged() is called.
812 */
813 void setHasChanged() { mHasChanged = true; }
814
Andy Hungdae27702016-10-31 14:01:16 -0700815 private:
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700816 void logTrack(const char *funcName, const sp<T> &track) const;
817
Andy Hungd01b0f12016-11-07 16:10:30 -0800818 SortedVector<uid_t> getWakeLockUids() {
819 SortedVector<uid_t> wakeLockUids;
Andy Hungdae27702016-10-31 14:01:16 -0700820 for (const sp<T> &track : mActiveTracks) {
821 wakeLockUids.add(track->uid());
822 }
823 return wakeLockUids; // moved by underlying SharedBuffer
824 }
825
826 std::map<uid_t, std::pair<ssize_t /* previous */, ssize_t /* current */>>
827 mBatteryCounter;
828 SortedVector<sp<T>> mActiveTracks;
829 int mActiveTracksGeneration;
830 int mLastActiveTracksGeneration;
831 wp<T> mLatestActiveTrack; // latest track added to ActiveTracks
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700832 SimpleLog * const mLocalLog;
Kevin Rocardc86a7f72018-04-03 09:00:09 -0700833 // If the vector has changed since last call to readAndClearHasChanged
Kevin Rocard069c2712018-03-29 19:09:14 -0700834 bool mHasChanged = false;
Andy Hungdae27702016-10-31 14:01:16 -0700835 };
Andy Hung293558a2017-03-21 12:19:20 -0700836
837 SimpleLog mLocalLog;
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700838
839private:
840 void dumpBase_l(int fd, const Vector<String16>& args);
841 void dumpEffectChains_l(int fd, const Vector<String16>& args);
Eric Laurent81784c32012-11-19 14:55:58 -0800842};
843
Eric Laurent6acd1d42017-01-04 14:23:29 -0800844class VolumeInterface {
845 public:
846
847 virtual ~VolumeInterface() {}
848
849 virtual void setMasterVolume(float value) = 0;
850 virtual void setMasterMute(bool muted) = 0;
851 virtual void setStreamVolume(audio_stream_type_t stream, float value) = 0;
852 virtual void setStreamMute(audio_stream_type_t stream, bool muted) = 0;
853 virtual float streamVolume(audio_stream_type_t stream) const = 0;
854
855};
856
Eric Laurent81784c32012-11-19 14:55:58 -0800857// --- PlaybackThread ---
Eric Laurent6acd1d42017-01-04 14:23:29 -0800858class PlaybackThread : public ThreadBase, public StreamOutHalInterfaceCallback,
jiabinf6eb4c32020-02-25 14:06:25 -0800859 public VolumeInterface, public StreamOutHalInterfaceEventCallback {
Eric Laurent81784c32012-11-19 14:55:58 -0800860public:
861
862#include "PlaybackTracks.h"
863
864 enum mixer_state {
865 MIXER_IDLE, // no active tracks
866 MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready
Eric Laurentbfb1b832013-01-07 09:53:42 -0800867 MIXER_TRACKS_READY, // at least one active track, and at least one track has data
868 MIXER_DRAIN_TRACK, // drain currently playing track
869 MIXER_DRAIN_ALL, // fully drain the hardware
Eric Laurent81784c32012-11-19 14:55:58 -0800870 // standby mode does not have an enum value
871 // suspend by audio policy manager is orthogonal to mixer state
872 };
873
Eric Laurente93cc032016-05-05 10:15:10 -0700874 // retry count before removing active track in case of underrun on offloaded thread:
875 // we need to make sure that AudioTrack client has enough time to send large buffers
876 //FIXME may be more appropriate if expressed in time units. Need to revise how underrun is
877 // handled for offloaded tracks
878 static const int8_t kMaxTrackRetriesOffload = 20;
879 static const int8_t kMaxTrackStartupRetriesOffload = 100;
880 static const int8_t kMaxTrackStopRetriesOffload = 2;
Andy Hung8ed196a2018-01-05 13:21:11 -0800881 static constexpr uint32_t kMaxTracksPerUid = 40;
Andy Hung1bc088a2018-02-09 15:57:31 -0800882 static constexpr size_t kMaxTracks = 256;
Eric Laurente93cc032016-05-05 10:15:10 -0700883
rago1bb90822017-05-02 18:31:48 -0700884 // Maximum delay (in nanoseconds) for upcoming buffers in suspend mode, otherwise
885 // if delay is greater, the estimated time for timeLoopNextNs is reset.
886 // This allows for catch-up to be done for small delays, while resetting the estimate
887 // for initial conditions or large delays.
888 static const nsecs_t kMaxNextBufferDelayNs = 100000000;
889
Eric Laurent81784c32012-11-19 14:55:58 -0800890 PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Eric Laurentf1f22e72021-07-13 14:04:14 +0200891 audio_io_handle_t id, type_t type, bool systemReady,
892 audio_config_base_t *mixerConfig = nullptr);
Eric Laurent81784c32012-11-19 14:55:58 -0800893 virtual ~PlaybackThread();
894
Eric Laurent81784c32012-11-19 14:55:58 -0800895 // Thread virtuals
Eric Laurent81784c32012-11-19 14:55:58 -0800896 virtual bool threadLoop();
897
898 // RefBase
899 virtual void onFirstRef();
900
Eric Laurent4c415062016-06-17 16:14:16 -0700901 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
902 audio_session_t sessionId);
903
Eric Laurent81784c32012-11-19 14:55:58 -0800904protected:
905 // Code snippets that were lifted up out of threadLoop()
906 virtual void threadLoop_mix() = 0;
907 virtual void threadLoop_sleepTime() = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800908 virtual ssize_t threadLoop_write();
909 virtual void threadLoop_drain();
Eric Laurent81784c32012-11-19 14:55:58 -0800910 virtual void threadLoop_standby();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800911 virtual void threadLoop_exit();
Eric Laurent81784c32012-11-19 14:55:58 -0800912 virtual void threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove);
913
914 // prepareTracks_l reads and writes mActiveTracks, and returns
915 // the pending set of tracks to remove via Vector 'tracksToRemove'. The caller
916 // is responsible for clearing or destroying this Vector later on, when it
917 // is safe to do so. That will drop the final ref count and destroy the tracks.
918 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove) = 0;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800919 void removeTracks_l(const Vector< sp<Track> >& tracksToRemove);
Eric Laurenteab90452019-06-24 15:17:46 -0700920 status_t handleVoipVolume_l(float *volume);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800921
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700922 // StreamOutHalInterfaceCallback implementation
923 virtual void onWriteReady();
924 virtual void onDrainReady();
925 virtual void onError();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800926
Mikhail Naganov1dc98672016-08-18 17:50:29 -0700927 void resetWriteBlocked(uint32_t sequence);
928 void resetDraining(uint32_t sequence);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800929
930 virtual bool waitingAsyncCallback();
931 virtual bool waitingAsyncCallback_l();
932 virtual bool shouldStandby_l();
Haynes Mathew George4c6a4332014-01-15 12:31:39 -0800933 virtual void onAddNewTrack_l();
Haynes Mathew George4527b9e2016-07-07 19:54:17 -0700934 void onAsyncError(); // error reported by AsyncCallbackThread
Eric Laurent81784c32012-11-19 14:55:58 -0800935
jiabinf6eb4c32020-02-25 14:06:25 -0800936 // StreamHalInterfaceCodecFormatCallback implementation
937 void onCodecFormatChanged(
938 const std::basic_string<uint8_t>& metadataBs) override;
939
Eric Laurent81784c32012-11-19 14:55:58 -0800940 // ThreadBase virtuals
941 virtual void preExit();
942
Eric Laurent64667972016-03-30 18:19:46 -0700943 virtual bool keepWakeLock() const { return true; }
Andy Hungdae27702016-10-31 14:01:16 -0700944 virtual void acquireWakeLock_l() {
945 ThreadBase::acquireWakeLock_l();
946 mActiveTracks.updatePowerState(this, true /* force */);
947 }
Eric Laurent64667972016-03-30 18:19:46 -0700948
Eric Laurentb3f315a2021-07-13 15:09:05 +0200949 virtual void checkOutputStageEffects() {}
Eric Laurent68a40a82022-05-03 18:15:04 +0200950 virtual void setHalLatencyMode_l() {}
951
Eric Laurentb3f315a2021-07-13 15:09:05 +0200952
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -0700953 void dumpInternals_l(int fd, const Vector<String16>& args) override;
954 void dumpTracks_l(int fd, const Vector<String16>& args) override;
955
Eric Laurent81784c32012-11-19 14:55:58 -0800956public:
957
958 virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; }
959
960 // return estimated latency in milliseconds, as reported by HAL
961 uint32_t latency() const;
962 // same, but lock must already be held
Eric Laurent6b446ce2019-12-13 10:56:31 -0800963 uint32_t latency_l() const override;
Eric Laurent81784c32012-11-19 14:55:58 -0800964
Eric Laurent6acd1d42017-01-04 14:23:29 -0800965 // VolumeInterface
966 virtual void setMasterVolume(float value);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +0100967 virtual void setMasterBalance(float balance);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800968 virtual void setMasterMute(bool muted);
969 virtual void setStreamVolume(audio_stream_type_t stream, float value);
970 virtual void setStreamMute(audio_stream_type_t stream, bool muted);
971 virtual float streamVolume(audio_stream_type_t stream) const;
Eric Laurent81784c32012-11-19 14:55:58 -0800972
Eric Laurent6b446ce2019-12-13 10:56:31 -0800973 void setVolumeForOutput_l(float left, float right) const override;
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +0900974
Eric Laurent81784c32012-11-19 14:55:58 -0800975 sp<Track> createTrack_l(
976 const sp<AudioFlinger::Client>& client,
977 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700978 const audio_attributes_t& attr,
Eric Laurent21da6472017-11-09 16:29:26 -0800979 uint32_t *sampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -0800980 audio_format_t format,
981 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -0800982 size_t *pFrameCount,
Eric Laurent21da6472017-11-09 16:29:26 -0800983 size_t *pNotificationFrameCount,
984 uint32_t notificationsPerBuffer,
985 float speed,
Eric Laurent81784c32012-11-19 14:55:58 -0800986 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -0800987 audio_session_t sessionId,
Eric Laurent05067782016-06-01 18:27:28 -0700988 audio_output_flags_t *flags,
Eric Laurent09f1ed22019-04-24 17:45:17 -0700989 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +0000990 const AttributionSourceState& attributionSource,
Eric Laurent81784c32012-11-19 14:55:58 -0800991 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800992 status_t *status /*non-NULL*/,
jiabinf6eb4c32020-02-25 14:06:25 -0800993 audio_port_handle_t portId,
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200994 const sp<media::IAudioTrackCallback>& callback,
jiabinc658e452022-10-21 20:52:21 +0000995 bool isSpatialized,
996 bool isBitPerfect);
Eric Laurent81784c32012-11-19 14:55:58 -0800997
998 AudioStreamOut* getOutput() const;
999 AudioStreamOut* clearOutput();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07001000 virtual sp<StreamHalInterface> stream() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001001
1002 // a very large number of suspend() will eventually wraparound, but unlikely
1003 void suspend() { (void) android_atomic_inc(&mSuspended); }
1004 void restore()
1005 {
1006 // if restore() is done without suspend(), get back into
1007 // range so that the next suspend() will operate correctly
1008 if (android_atomic_dec(&mSuspended) <= 0) {
1009 android_atomic_release_store(0, &mSuspended);
1010 }
1011 }
1012 bool isSuspended() const
1013 { return android_atomic_acquire_load(&mSuspended) > 0; }
1014
1015 virtual String8 getParameters(const String8& keys);
Mikhail Naganov88536df2021-07-26 17:30:29 -07001016 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -07001017 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Kévin PETIT377b2ec2014-02-03 12:35:36 +00001018 status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames);
Andy Hung010a1a12014-03-13 13:57:33 -07001019 // Consider also removing and passing an explicit mMainBuffer initialization
1020 // parameter to AF::PlaybackThread::Track::Track().
rago94a1ee82017-07-21 15:11:02 -07001021 effect_buffer_t *sinkBuffer() const {
1022 return reinterpret_cast<effect_buffer_t *>(mSinkBuffer); };
Eric Laurent81784c32012-11-19 14:55:58 -08001023
1024 virtual void detachAuxEffect_l(int effectId);
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001025 status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track>& track,
Eric Laurent81784c32012-11-19 14:55:58 -08001026 int EffectId);
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001027 status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track>& track,
Eric Laurent81784c32012-11-19 14:55:58 -08001028 int EffectId);
1029
1030 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
1031 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
Andy Hungc3d62f92019-03-14 13:38:51 -07001032 uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
1033 return ThreadBase::hasAudioSession_l(sessionId, mTracks);
1034 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001035 virtual product_strategy_t getStrategyForSession_l(audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -08001036
1037
1038 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
1039 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const;
Glenn Kastenfb1fdc92013-07-10 17:03:19 -07001040
1041 // called with AudioFlinger lock held
Eric Laurent13084622016-05-17 10:51:49 -07001042 bool invalidateTracks_l(audio_stream_type_t streamType);
jiabinc44b3462022-12-08 12:52:31 -08001043 bool invalidateTracks_l(std::set<audio_port_handle_t>& portIds);
Haynes Mathew George05317d22016-05-03 16:34:26 -07001044 virtual void invalidateTracks(audio_stream_type_t streamType);
jiabinc44b3462022-12-08 12:52:31 -08001045 // Invalidate tracks by a set of port ids. The port id will be removed from
1046 // the given set if the corresponding track is found and invalidated.
1047 virtual void invalidateTracks(std::set<audio_port_handle_t>& portIds);
Eric Laurent81784c32012-11-19 14:55:58 -08001048
Glenn Kasten9b58f632013-07-16 11:37:48 -07001049 virtual size_t frameCount() const { return mNormalFrameCount; }
1050
Eric Laurentf1f22e72021-07-13 14:04:14 +02001051 audio_channel_mask_t mixerChannelMask() const override {
1052 return mMixerChannelMask;
1053 }
1054
Eric Laurent83b88082014-06-20 18:31:16 -07001055 status_t getTimestamp_l(AudioTimestamp& timestamp);
1056
1057 void addPatchTrack(const sp<PatchTrack>& track);
1058 void deletePatchTrack(const sp<PatchTrack>& track);
1059
Mikhail Naganovdc769682018-05-04 15:34:08 -07001060 virtual void toAudioPortConfig(struct audio_port_config *config);
Eric Laurentaccc1472013-09-20 09:36:34 -07001061
Andy Hung10cbff12017-02-21 17:30:14 -08001062 // Return the asynchronous signal wait time.
1063 virtual int64_t computeWaitTimeNs_l() const { return INT64_MAX; }
Andy Hung1bc088a2018-02-09 15:57:31 -08001064 // returns true if the track is allowed to be added to the thread.
1065 virtual bool isTrackAllowed_l(
1066 audio_channel_mask_t channelMask __unused,
1067 audio_format_t format __unused,
1068 audio_session_t sessionId __unused,
1069 uid_t uid) const {
1070 return trackCountForUid_l(uid) < PlaybackThread::kMaxTracksPerUid
1071 && mTracks.size() < PlaybackThread::kMaxTracks;
1072 }
1073
Andy Hungc8fddf32018-08-08 18:32:37 -07001074 bool isTimestampCorrectionEnabled() const override {
jiabinc52b1ff2019-10-31 17:20:42 -07001075 return audio_is_output_devices(mTimestampCorrectedDevice)
1076 && outDeviceTypes().count(mTimestampCorrectedDevice) != 0;
Andy Hungc8fddf32018-08-08 18:32:37 -07001077 }
jiabinc52b1ff2019-10-31 17:20:42 -07001078
Jasmine Chaeaa10e42021-05-11 10:11:14 +08001079 virtual bool isStreamInitialized() {
1080 return !(mOutput == nullptr || mOutput->stream == nullptr);
1081 }
1082
jiabineb3bda02020-06-30 14:07:03 -07001083 audio_channel_mask_t hapticChannelMask() const override {
1084 return mHapticChannelMask;
1085 }
1086 bool supportsHapticPlayback() const {
1087 return (mHapticChannelMask & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE;
1088 }
1089
Eric Laurent74c38dc2020-12-23 18:19:44 +01001090 void setDownStreamPatch(const struct audio_patch *patch) {
1091 Mutex::Autolock _l(mLock);
1092 mDownStreamPatch = *patch;
1093 }
1094
jiabinf042b9b2021-05-07 23:46:28 +00001095 PlaybackThread::Track* getTrackById_l(audio_port_handle_t trackId);
1096
Eric Laurentb3f315a2021-07-13 15:09:05 +02001097 bool hasMixer() const {
Eric Laurent1c5e2e32021-08-18 18:50:28 +02001098 return mType == MIXER || mType == DUPLICATING || mType == SPATIALIZER;
Eric Laurentb3f315a2021-07-13 15:09:05 +02001099 }
Eric Laurent68a40a82022-05-03 18:15:04 +02001100
1101 virtual status_t setRequestedLatencyMode(
1102 audio_latency_mode_t mode __unused) { return INVALID_OPERATION; }
1103
1104 virtual status_t getSupportedLatencyModes(
1105 std::vector<audio_latency_mode_t>* modes __unused) {
1106 return INVALID_OPERATION;
1107 }
1108
Eric Laurentb0463942022-12-20 16:31:10 +01001109 virtual status_t setBluetoothVariableLatencyEnabled(bool enabled __unused) {
1110 return INVALID_OPERATION;
1111 }
Eric Laurent52057642022-12-16 11:45:07 +01001112
Vlad Popaf09e93f2022-10-31 16:27:12 +01001113 void startMelComputation(const sp<audio_utils::MelProcessor>& processor);
Vlad Popab042ee62022-10-20 18:05:00 +02001114 void stopMelComputation();
1115
Eric Laurent81784c32012-11-19 14:55:58 -08001116protected:
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001117 // updated by readOutputParameters_l()
Glenn Kasten9b58f632013-07-16 11:37:48 -07001118 size_t mNormalFrameCount; // normal mixer and effects
1119
Andy Hung08fb1742015-05-31 23:22:10 -07001120 bool mThreadThrottle; // throttle the thread processing
Andy Hung40eb1a12015-06-18 13:42:02 -07001121 uint32_t mThreadThrottleTimeMs; // throttle time for MIXER threads
1122 uint32_t mThreadThrottleEndMs; // notify once per throttling
Andy Hung08fb1742015-05-31 23:22:10 -07001123 uint32_t mHalfBufferMs; // half the buffer size in milliseconds
1124
Andy Hung010a1a12014-03-13 13:57:33 -07001125 void* mSinkBuffer; // frame size aligned sink buffer
Eric Laurent81784c32012-11-19 14:55:58 -08001126
Andy Hung98ef9782014-03-04 14:46:50 -08001127 // TODO:
1128 // Rearrange the buffer info into a struct/class with
1129 // clear, copy, construction, destruction methods.
1130 //
1131 // mSinkBuffer also has associated with it:
1132 //
1133 // mSinkBufferSize: Sink Buffer Size
1134 // mFormat: Sink Buffer Format
1135
Andy Hung69aed5f2014-02-25 17:24:40 -08001136 // Mixer Buffer (mMixerBuffer*)
1137 //
1138 // In the case of floating point or multichannel data, which is not in the
1139 // sink format, it is required to accumulate in a higher precision or greater channel count
1140 // buffer before downmixing or data conversion to the sink buffer.
1141
1142 // Set to "true" to enable the Mixer Buffer otherwise mixer output goes to sink buffer.
1143 bool mMixerBufferEnabled;
1144
1145 // Storage, 32 byte aligned (may make this alignment a requirement later).
1146 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
1147 void* mMixerBuffer;
1148
1149 // Size of mMixerBuffer in bytes: mNormalFrameCount * #channels * sampsize.
1150 size_t mMixerBufferSize;
1151
1152 // The audio format of mMixerBuffer. Set to AUDIO_FORMAT_PCM_(FLOAT|16_BIT) only.
1153 audio_format_t mMixerBufferFormat;
1154
1155 // An internal flag set to true by MixerThread::prepareTracks_l()
1156 // when mMixerBuffer contains valid data after mixing.
1157 bool mMixerBufferValid;
1158
Andy Hung98ef9782014-03-04 14:46:50 -08001159 // Effects Buffer (mEffectsBuffer*)
1160 //
1161 // In the case of effects data, which is not in the sink format,
1162 // it is required to accumulate in a different buffer before data conversion
1163 // to the sink buffer.
1164
1165 // Set to "true" to enable the Effects Buffer otherwise effects output goes to sink buffer.
1166 bool mEffectBufferEnabled;
1167
1168 // Storage, 32 byte aligned (may make this alignment a requirement later).
1169 // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
1170 void* mEffectBuffer;
1171
1172 // Size of mEffectsBuffer in bytes: mNormalFrameCount * #channels * sampsize.
1173 size_t mEffectBufferSize;
1174
1175 // The audio format of mEffectsBuffer. Set to AUDIO_FORMAT_PCM_16_BIT only.
1176 audio_format_t mEffectBufferFormat;
1177
1178 // An internal flag set to true by MixerThread::prepareTracks_l()
1179 // when mEffectsBuffer contains valid data after mixing.
1180 //
1181 // When this is set, all mixer data is routed into the effects buffer
1182 // for any processing (including output processing).
1183 bool mEffectBufferValid;
1184
jiabinc658e452022-10-21 20:52:21 +00001185 // Set to "true" to enable when data has already copied to sink
1186 bool mHasDataCopiedToSinkBuffer = false;
1187
Eric Laurentb62d0362021-10-26 17:40:18 +02001188 // Frame size aligned buffer used as input and output to all post processing effects
1189 // except the Spatializer in a SPATIALIZER thread. Non spatialized tracks are mixed into
1190 // this buffer so that post processing effects can be applied.
1191 void* mPostSpatializerBuffer = nullptr;
1192
1193 // Size of mPostSpatializerBuffer in bytes
1194 size_t mPostSpatializerBufferSize;
Eric Laurent39095982021-08-24 18:29:27 +02001195
1196
Eric Laurent81784c32012-11-19 14:55:58 -08001197 // suspend count, > 0 means suspended. While suspended, the thread continues to pull from
1198 // tracks and mix, but doesn't write to HAL. A2DP and SCO HAL implementations can't handle
1199 // concurrent use of both of them, so Audio Policy Service suspends one of the threads to
1200 // workaround that restriction.
1201 // 'volatile' means accessed via atomic operations and no lock.
1202 volatile int32_t mSuspended;
1203
Andy Hung818e7a32016-02-16 18:08:07 -08001204 int64_t mBytesWritten;
yucliu6cfb5932022-07-20 17:40:39 -07001205 std::atomic<int64_t> mFramesWritten; // not reset on standby
Dean Wheatley12473e92021-03-18 23:00:55 +11001206 int64_t mLastFramesWritten = -1; // track changes in timestamp
1207 // server frames written.
Andy Hung238fa3d2016-07-28 10:53:22 -07001208 int64_t mSuspendedFrames; // not reset on standby
jiabin245cdd92018-12-07 17:55:15 -08001209
1210 // mHapticChannelMask and mHapticChannelCount will only be valid when the thread support
1211 // haptic playback.
1212 audio_channel_mask_t mHapticChannelMask = AUDIO_CHANNEL_NONE;
1213 uint32_t mHapticChannelCount = 0;
Eric Laurentf1f22e72021-07-13 14:04:14 +02001214
1215 audio_channel_mask_t mMixerChannelMask = AUDIO_CHANNEL_NONE;
1216
Eric Laurent81784c32012-11-19 14:55:58 -08001217private:
Vlad Popab042ee62022-10-20 18:05:00 +02001218 mediautils::atomic_sp<audio_utils::MelProcessor> mMelProcessor;
1219
Eric Laurent81784c32012-11-19 14:55:58 -08001220 // mMasterMute is in both PlaybackThread and in AudioFlinger. When a
1221 // PlaybackThread needs to find out if master-muted, it checks it's local
1222 // copy rather than the one in AudioFlinger. This optimization saves a lock.
1223 bool mMasterMute;
1224 void setMasterMute_l(bool muted) { mMasterMute = muted; }
Dean Wheatley12473e92021-03-18 23:00:55 +11001225
1226 auto discontinuityForStandbyOrFlush() const { // call on threadLoop or with lock.
1227 return ((mType == DIRECT && !audio_is_linear_pcm(mFormat))
1228 || mType == OFFLOAD)
1229 ? mTimestampVerifier.DISCONTINUITY_MODE_ZERO
1230 : mTimestampVerifier.DISCONTINUITY_MODE_CONTINUOUS;
1231 }
1232
Eric Laurent81784c32012-11-19 14:55:58 -08001233protected:
Andy Hungdae27702016-10-31 14:01:16 -07001234 ActiveTracks<Track> mActiveTracks;
Eric Laurent81784c32012-11-19 14:55:58 -08001235
Eric Laurent81784c32012-11-19 14:55:58 -08001236 // Time to sleep between cycles when:
1237 virtual uint32_t activeSleepTimeUs() const; // mixer state MIXER_TRACKS_ENABLED
1238 virtual uint32_t idleSleepTimeUs() const = 0; // mixer state MIXER_IDLE
1239 virtual uint32_t suspendSleepTimeUs() const = 0; // audio policy manager suspended us
1240 // No sleep when mixer state == MIXER_TRACKS_READY; relies on audio HAL stream->write()
1241 // No sleep in standby mode; waits on a condition
1242
1243 // Code snippets that are temporarily lifted up out of threadLoop() until the merge
1244 void checkSilentMode_l();
1245
1246 // Non-trivial for DUPLICATING only
1247 virtual void saveOutputTracks() { }
1248 virtual void clearOutputTracks() { }
1249
1250 // Cache various calculated values, at threadLoop() entry and after a parameter change
1251 virtual void cacheParameters_l();
Eric Laurentb3f315a2021-07-13 15:09:05 +02001252 void setCheckOutputStageEffects() override {
1253 mCheckOutputStageEffects.store(true);
1254 }
Eric Laurent81784c32012-11-19 14:55:58 -08001255
1256 virtual uint32_t correctLatency_l(uint32_t latency) const;
1257
Eric Laurent1c333e22014-05-20 10:48:17 -07001258 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1259 audio_patch_handle_t *handle);
1260 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
1261
Phil Burk6fc2a7c2015-04-30 16:08:10 -07001262 bool usesHwAvSync() const { return (mType == DIRECT) && (mOutput != NULL)
1263 && mHwSupportsPause
1264 && (mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC); }
Eric Laurent0f7b5f22014-12-19 10:43:21 -08001265
Andy Hung1bc088a2018-02-09 15:57:31 -08001266 uint32_t trackCountForUid_l(uid_t uid) const;
Eric Laurentad7dd962016-09-22 12:38:37 -07001267
jiabineb3bda02020-06-30 14:07:03 -07001268 void invalidateTracksForAudioSession_l(
1269 audio_session_t sessionId) const override {
1270 ThreadBase::invalidateTracksForAudioSession_l(sessionId, mTracks);
1271 }
1272
Eric Laurent81784c32012-11-19 14:55:58 -08001273private:
1274
1275 friend class AudioFlinger; // for numerous
1276
Mikhail Naganovbf493082017-04-17 17:37:12 -07001277 DISALLOW_COPY_AND_ASSIGN(PlaybackThread);
Eric Laurent81784c32012-11-19 14:55:58 -08001278
1279 status_t addTrack_l(const sp<Track>& track);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001280 bool destroyTrack_l(const sp<Track>& track);
Eric Laurent81784c32012-11-19 14:55:58 -08001281 void removeTrack_l(const sp<Track>& track);
1282
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001283 void readOutputParameters_l();
Vlad Popa7e81cea2023-01-19 16:34:16 +01001284 MetadataUpdate updateMetadata_l() final;
Kevin Rocardc86a7f72018-04-03 09:00:09 -07001285 virtual void sendMetadataToBackend_l(const StreamOutHalInterface::SourceMetadata& metadata);
Eric Laurent81784c32012-11-19 14:55:58 -08001286
Dean Wheatley12473e92021-03-18 23:00:55 +11001287 void collectTimestamps_l();
1288
Andy Hungc0691382018-09-12 18:01:57 -07001289 // The Tracks class manages tracks added and removed from the Thread.
Andy Hung1bc088a2018-02-09 15:57:31 -08001290 template <typename T>
1291 class Tracks {
1292 public:
Andy Hungc0691382018-09-12 18:01:57 -07001293 Tracks(bool saveDeletedTrackIds) :
1294 mSaveDeletedTrackIds(saveDeletedTrackIds) { }
Andy Hung1bc088a2018-02-09 15:57:31 -08001295
1296 // SortedVector methods
Andy Hungc0691382018-09-12 18:01:57 -07001297 ssize_t add(const sp<T> &track) {
1298 const ssize_t index = mTracks.add(track);
1299 LOG_ALWAYS_FATAL_IF(index < 0, "cannot add track");
1300 return index;
1301 }
Andy Hung1bc088a2018-02-09 15:57:31 -08001302 ssize_t remove(const sp<T> &track);
1303 size_t size() const {
1304 return mTracks.size();
1305 }
1306 bool isEmpty() const {
1307 return mTracks.isEmpty();
1308 }
1309 ssize_t indexOf(const sp<T> &item) {
1310 return mTracks.indexOf(item);
1311 }
1312 sp<T> operator[](size_t index) const {
1313 return mTracks[index];
1314 }
1315 typename SortedVector<sp<T>>::iterator begin() {
1316 return mTracks.begin();
1317 }
1318 typename SortedVector<sp<T>>::iterator end() {
1319 return mTracks.end();
1320 }
1321
Andy Hungc0691382018-09-12 18:01:57 -07001322 size_t processDeletedTrackIds(std::function<void(int)> f) {
1323 for (const int trackId : mDeletedTrackIds) {
1324 f(trackId);
Andy Hung1bc088a2018-02-09 15:57:31 -08001325 }
Andy Hungc0691382018-09-12 18:01:57 -07001326 return mDeletedTrackIds.size();
Andy Hung1bc088a2018-02-09 15:57:31 -08001327 }
1328
Andy Hungc0691382018-09-12 18:01:57 -07001329 void clearDeletedTrackIds() { mDeletedTrackIds.clear(); }
Andy Hung1bc088a2018-02-09 15:57:31 -08001330
1331 private:
Andy Hungc0691382018-09-12 18:01:57 -07001332 // Tracks pending deletion for MIXER type threads
1333 const bool mSaveDeletedTrackIds; // true to enable tracking
1334 std::set<int> mDeletedTrackIds;
Andy Hung1bc088a2018-02-09 15:57:31 -08001335
1336 SortedVector<sp<T>> mTracks; // wrapped SortedVector.
1337 };
1338
1339 Tracks<Track> mTracks;
1340
Eric Laurent223fd5c2014-11-11 13:43:36 -08001341 stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
Eric Laurent81784c32012-11-19 14:55:58 -08001342 AudioStreamOut *mOutput;
1343
1344 float mMasterVolume;
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001345 std::atomic<float> mMasterBalance{};
1346 audio_utils::Balance mBalance;
Eric Laurent81784c32012-11-19 14:55:58 -08001347 int mNumWrites;
1348 int mNumDelayedWrites;
1349 bool mInWrite;
1350
1351 // FIXME rename these former local variables of threadLoop to standard "m" names
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001352 nsecs_t mStandbyTimeNs;
Andy Hung25c2dac2014-02-27 14:56:00 -08001353 size_t mSinkBufferSize;
Eric Laurent81784c32012-11-19 14:55:58 -08001354
1355 // cached copies of activeSleepTimeUs() and idleSleepTimeUs() made by cacheParameters_l()
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001356 uint32_t mActiveSleepTimeUs;
1357 uint32_t mIdleSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08001358
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001359 uint32_t mSleepTimeUs;
Eric Laurent81784c32012-11-19 14:55:58 -08001360
1361 // mixer status returned by prepareTracks_l()
1362 mixer_state mMixerStatus; // current cycle
1363 // previous cycle when in prepareTracks_l()
1364 mixer_state mMixerStatusIgnoringFastTracks;
1365 // FIXME or a separate ready state per track
1366
1367 // FIXME move these declarations into the specific sub-class that needs them
1368 // MIXER only
1369 uint32_t sleepTimeShift;
1370
1371 // same as AudioFlinger::mStandbyTimeInNsecs except for DIRECT which uses a shorter value
Eric Laurentad9cb8b2015-05-26 16:38:19 -07001372 nsecs_t mStandbyDelayNs;
Eric Laurent81784c32012-11-19 14:55:58 -08001373
1374 // MIXER only
1375 nsecs_t maxPeriod;
1376
1377 // DUPLICATING only
1378 uint32_t writeFrames;
1379
Eric Laurentbfb1b832013-01-07 09:53:42 -08001380 size_t mBytesRemaining;
1381 size_t mCurrentWriteLength;
1382 bool mUseAsyncWrite;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001383 // mWriteAckSequence contains current write sequence on bits 31-1. The write sequence is
1384 // incremented each time a write(), a flush() or a standby() occurs.
1385 // Bit 0 is set when a write blocks and indicates a callback is expected.
1386 // Bit 0 is reset by the async callback thread calling resetWriteBlocked(). Out of sequence
1387 // callbacks are ignored.
1388 uint32_t mWriteAckSequence;
1389 // mDrainSequence contains current drain sequence on bits 31-1. The drain sequence is
1390 // incremented each time a drain is requested or a flush() or standby() occurs.
1391 // Bit 0 is set when the drain() command is called at the HAL and indicates a callback is
1392 // expected.
1393 // Bit 0 is reset by the async callback thread calling resetDraining(). Out of sequence
1394 // callbacks are ignored.
1395 uint32_t mDrainSequence;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001396 sp<AsyncCallbackThread> mCallbackThread;
1397
jiabinf6eb4c32020-02-25 14:06:25 -08001398 Mutex mAudioTrackCbLock;
1399 // Record of IAudioTrackCallback
jiabin18a4b1c2020-09-17 11:40:42 -07001400 std::map<sp<Track>, sp<media::IAudioTrackCallback>> mAudioTrackCallbacks;
jiabinf6eb4c32020-02-25 14:06:25 -08001401
Eric Laurent81784c32012-11-19 14:55:58 -08001402private:
1403 // The HAL output sink is treated as non-blocking, but current implementation is blocking
1404 sp<NBAIO_Sink> mOutputSink;
1405 // If a fast mixer is present, the blocking pipe sink, otherwise clear
1406 sp<NBAIO_Sink> mPipeSink;
1407 // The current sink for the normal mixer to write it's (sub)mix, mOutputSink or mPipeSink
1408 sp<NBAIO_Sink> mNormalSink;
Eric Laurent81784c32012-11-19 14:55:58 -08001409 uint32_t mScreenState; // cached copy of gScreenState
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07001410 // TODO: add comment and adjust size as needed
Glenn Kasteneef598c2017-04-03 14:41:13 -07001411 static const size_t kFastMixerLogSize = 8 * 1024;
Glenn Kasten9e58b552013-01-18 15:09:48 -08001412 sp<NBLog::Writer> mFastMixerNBLogWriter;
Andy Hung2148bf02016-11-28 19:01:02 -08001413
Dean Wheatley30d28422018-11-06 10:27:40 +11001414 // Downstream patch latency, available if mDownstreamLatencyStatMs.getN() > 0.
1415 audio_utils::Statistics<double> mDownstreamLatencyStatMs{0.999};
Andy Hung2148bf02016-11-28 19:01:02 -08001416
Eric Laurent81784c32012-11-19 14:55:58 -08001417public:
1418 virtual bool hasFastMixer() const = 0;
Glenn Kasten0f11b512014-01-31 16:18:54 -08001419 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex __unused) const
Eric Laurent81784c32012-11-19 14:55:58 -08001420 { FastTrackUnderruns dummy; return dummy; }
yucliu6cfb5932022-07-20 17:40:39 -07001421 const std::atomic<int64_t>& framesWritten() const { return mFramesWritten; }
Eric Laurent81784c32012-11-19 14:55:58 -08001422
1423protected:
1424 // accessed by both binder threads and within threadLoop(), lock on mutex needed
1425 unsigned mFastTrackAvailMask; // bit i set if fast track [i] is available
Eric Laurentd1f69b02014-12-15 14:33:13 -08001426 bool mHwSupportsPause;
1427 bool mHwPaused;
1428 bool mFlushPending;
Eric Laurent7c29ec92017-09-20 17:54:22 -07001429 // volumes last sent to audio HAL with stream->setVolume()
1430 float mLeftVolFloat;
1431 float mRightVolFloat;
Eric Laurent74c38dc2020-12-23 18:19:44 +01001432
1433 // audio patch used by the downstream software patch.
1434 // Only used if ThreadBase::mIsMsdDevice is true.
1435 struct audio_patch mDownStreamPatch;
Eric Laurentb3f315a2021-07-13 15:09:05 +02001436
1437 std::atomic_bool mCheckOutputStageEffects{};
ziyangch8f194f12021-12-01 13:48:04 -08001438
ziyangch8f194f12021-12-01 13:48:04 -08001439
Brian Lindahl65e90012022-07-27 18:01:07 +02001440 // Provides periodic checking for timestamp advancement for underrun detection.
1441 class IsTimestampAdvancing {
1442 public:
1443 // The timestamp will not be checked any faster than the specified time.
1444 IsTimestampAdvancing(nsecs_t minimumTimeBetweenChecksNs)
1445 : mMinimumTimeBetweenChecksNs(minimumTimeBetweenChecksNs)
1446 {
1447 clear();
1448 }
1449 // Check if the presentation position has advanced in the last periodic time.
1450 bool check(AudioStreamOut * output);
1451 // Clear the internal state when the playback state changes for the output
1452 // stream.
1453 void clear();
1454 private:
1455 // The minimum time between timestamp checks.
1456 const nsecs_t mMinimumTimeBetweenChecksNs;
1457 // Add differential check on the timestamps to see if there is a change in the
1458 // timestamp frame position between the last call to check.
1459 uint64_t mPreviousPosition;
1460 // The time at which the last check occurred, to ensure we don't check too
1461 // frequently, giving the Audio HAL enough time to update its timestamps.
1462 nsecs_t mPreviousNs;
1463 // The valued is latched so we don't check timestamps too frequently.
1464 bool mLatchedValue;
1465 };
1466 IsTimestampAdvancing mIsTimestampAdvancing;
ziyangch8f194f12021-12-01 13:48:04 -08001467
Brian Lindahl65e90012022-07-27 18:01:07 +02001468 virtual void flushHw_l() {
1469 mIsTimestampAdvancing.clear();
1470 }
Eric Laurent81784c32012-11-19 14:55:58 -08001471};
1472
Eric Laurentb0463942022-12-20 16:31:10 +01001473class MixerThread : public PlaybackThread,
1474 public StreamOutHalInterfaceLatencyModeCallback {
Eric Laurent81784c32012-11-19 14:55:58 -08001475public:
1476 MixerThread(const sp<AudioFlinger>& audioFlinger,
1477 AudioStreamOut* output,
1478 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07001479 bool systemReady,
Eric Laurentf1f22e72021-07-13 14:04:14 +02001480 type_t type = MIXER,
1481 audio_config_base_t *mixerConfig = nullptr);
Eric Laurent81784c32012-11-19 14:55:58 -08001482 virtual ~MixerThread();
1483
Eric Laurentb0463942022-12-20 16:31:10 +01001484 // RefBase
1485 virtual void onFirstRef();
1486
1487 // StreamOutHalInterfaceLatencyModeCallback
1488 void onRecommendedLatencyModeChanged(
1489 std::vector<audio_latency_mode_t> modes) override;
1490
Eric Laurent81784c32012-11-19 14:55:58 -08001491 // Thread virtuals
1492
Eric Laurent10351942014-05-08 18:49:52 -07001493 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1494 status_t& status);
Eric Laurent81784c32012-11-19 14:55:58 -08001495
Andy Hung1bc088a2018-02-09 15:57:31 -08001496 virtual bool isTrackAllowed_l(
1497 audio_channel_mask_t channelMask, audio_format_t format,
1498 audio_session_t sessionId, uid_t uid) const override;
Eric Laurent81784c32012-11-19 14:55:58 -08001499protected:
1500 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
Eric Laurent81784c32012-11-19 14:55:58 -08001501 virtual uint32_t idleSleepTimeUs() const;
1502 virtual uint32_t suspendSleepTimeUs() const;
1503 virtual void cacheParameters_l();
1504
Andy Hungdae27702016-10-31 14:01:16 -07001505 virtual void acquireWakeLock_l() {
1506 PlaybackThread::acquireWakeLock_l();
Andy Hung818e7a32016-02-16 18:08:07 -08001507 if (hasFastMixer()) {
1508 mFastMixer->setBoottimeOffset(
1509 mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME]);
1510 }
1511 }
1512
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001513 void dumpInternals_l(int fd, const Vector<String16>& args) override;
1514
Eric Laurent81784c32012-11-19 14:55:58 -08001515 // threadLoop snippets
Eric Laurentbfb1b832013-01-07 09:53:42 -08001516 virtual ssize_t threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08001517 virtual void threadLoop_standby();
1518 virtual void threadLoop_mix();
1519 virtual void threadLoop_sleepTime();
Eric Laurent81784c32012-11-19 14:55:58 -08001520 virtual uint32_t correctLatency_l(uint32_t latency) const;
1521
Eric Laurent054d9d32015-04-24 08:48:48 -07001522 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1523 audio_patch_handle_t *handle);
1524 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
1525
Eric Laurent81784c32012-11-19 14:55:58 -08001526 AudioMixer* mAudioMixer; // normal mixer
Eric Laurentb0463942022-12-20 16:31:10 +01001527
1528 // Support low latency mode by default as unless explicitly indicated by the audio HAL
1529 // we assume the audio path is compatible with the head tracking latency requirements
1530 std::vector<audio_latency_mode_t> mSupportedLatencyModes = {AUDIO_LATENCY_MODE_LOW};
1531 // default to invalid value to force first update to the audio HAL
1532 audio_latency_mode_t mSetLatencyMode =
1533 (audio_latency_mode_t)AUDIO_LATENCY_MODE_INVALID;
1534
1535 // Bluetooth Variable latency control logic is enabled or disabled for this thread
1536 std::atomic_bool mBluetoothLatencyModesEnabled;
1537
Eric Laurent81784c32012-11-19 14:55:58 -08001538private:
1539 // one-time initialization, no locks required
Glenn Kasten4d23ca32014-05-13 10:39:51 -07001540 sp<FastMixer> mFastMixer; // non-0 if there is also a fast mixer
Eric Laurent81784c32012-11-19 14:55:58 -08001541 sp<AudioWatchdog> mAudioWatchdog; // non-0 if there is an audio watchdog thread
1542
1543 // contents are not guaranteed to be consistent, no locks required
1544 FastMixerDumpState mFastMixerDumpState;
1545#ifdef STATE_QUEUE_DUMP
1546 StateQueueObserverDump mStateQueueObserverDump;
1547 StateQueueMutatorDump mStateQueueMutatorDump;
1548#endif
1549 AudioWatchdogDump mAudioWatchdogDump;
1550
1551 // accessible only within the threadLoop(), no locks required
1552 // mFastMixer->sq() // for mutating and pushing state
1553 int32_t mFastMixerFutex; // for cold idle
1554
Andy Hung2ddee192015-12-18 17:34:44 -08001555 std::atomic_bool mMasterMono;
Eric Laurent81784c32012-11-19 14:55:58 -08001556public:
Glenn Kasten4d23ca32014-05-13 10:39:51 -07001557 virtual bool hasFastMixer() const { return mFastMixer != 0; }
Eric Laurent81784c32012-11-19 14:55:58 -08001558 virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const {
Glenn Kastendc2c50b2016-04-21 08:13:14 -07001559 ALOG_ASSERT(fastIndex < FastMixerState::sMaxFastTracks);
Eric Laurent81784c32012-11-19 14:55:58 -08001560 return mFastMixerDumpState.mTracks[fastIndex].mUnderruns;
1561 }
Eric Laurent83b88082014-06-20 18:31:16 -07001562
Andy Hung1c86ebe2018-05-29 20:29:08 -07001563 status_t threadloop_getHalTimestamp_l(
1564 ExtendedTimestamp *timestamp) const override {
1565 if (mNormalSink.get() != nullptr) {
1566 return mNormalSink->getTimestamp(*timestamp);
1567 }
1568 return INVALID_OPERATION;
1569 }
1570
Eric Laurentb0463942022-12-20 16:31:10 +01001571 status_t getSupportedLatencyModes(
1572 std::vector<audio_latency_mode_t>* modes) override;
1573
1574 status_t setBluetoothVariableLatencyEnabled(bool enabled) override;
1575
Andy Hung2ddee192015-12-18 17:34:44 -08001576protected:
1577 virtual void setMasterMono_l(bool mono) {
1578 mMasterMono.store(mono);
1579 if (mFastMixer != nullptr) { /* hasFastMixer() */
1580 mFastMixer->setMasterMono(mMasterMono);
1581 }
1582 }
1583 // the FastMixer performs mono blend if it exists.
Glenn Kasten03c48d52016-01-27 17:25:17 -08001584 // Blending with limiter is not idempotent,
1585 // and blending without limiter is idempotent but inefficient to do twice.
Andy Hung2ddee192015-12-18 17:34:44 -08001586 virtual bool requireMonoBlend() { return mMasterMono.load() && !hasFastMixer(); }
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001587
1588 void setMasterBalance(float balance) override {
1589 mMasterBalance.store(balance);
1590 if (hasFastMixer()) {
1591 mFastMixer->setMasterBalance(balance);
1592 }
1593 }
Eric Laurentb0463942022-12-20 16:31:10 +01001594
1595 void updateHalSupportedLatencyModes_l();
1596 void onHalLatencyModesChanged_l() override;
1597 void setHalLatencyMode_l() override;
Eric Laurent81784c32012-11-19 14:55:58 -08001598};
1599
1600class DirectOutputThread : public PlaybackThread {
1601public:
1602
1603 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Gareth Fennb18c1a32022-10-05 13:42:36 -07001604 audio_io_handle_t id, bool systemReady,
1605 const audio_offload_info_t& offloadInfo)
1606 : DirectOutputThread(audioFlinger, output, id, DIRECT, systemReady, offloadInfo) { }
Andy Hung48f59ed2019-01-28 15:06:59 -08001607
Eric Laurent81784c32012-11-19 14:55:58 -08001608 virtual ~DirectOutputThread();
1609
Mikhail Naganovac917ac2018-11-28 14:03:52 -08001610 status_t selectPresentation(int presentationId, int programId);
1611
Eric Laurent81784c32012-11-19 14:55:58 -08001612 // Thread virtuals
1613
Eric Laurent10351942014-05-08 18:49:52 -07001614 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1615 status_t& status);
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001616
ziyangch8f194f12021-12-01 13:48:04 -08001617 void flushHw_l() override;
Eric Laurent81784c32012-11-19 14:55:58 -08001618
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001619 void setMasterBalance(float balance) override;
1620
Eric Laurent81784c32012-11-19 14:55:58 -08001621protected:
Eric Laurent81784c32012-11-19 14:55:58 -08001622 virtual uint32_t activeSleepTimeUs() const;
1623 virtual uint32_t idleSleepTimeUs() const;
1624 virtual uint32_t suspendSleepTimeUs() const;
1625 virtual void cacheParameters_l();
1626
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001627 void dumpInternals_l(int fd, const Vector<String16>& args) override;
1628
Eric Laurent81784c32012-11-19 14:55:58 -08001629 // threadLoop snippets
1630 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
1631 virtual void threadLoop_mix();
1632 virtual void threadLoop_sleepTime();
Eric Laurentd1f69b02014-12-15 14:33:13 -08001633 virtual void threadLoop_exit();
1634 virtual bool shouldStandby_l();
Eric Laurent81784c32012-11-19 14:55:58 -08001635
Phil Burk43b4dcc2015-06-09 16:53:44 -07001636 virtual void onAddNewTrack_l();
1637
Gareth Fennb18c1a32022-10-05 13:42:36 -07001638 const audio_offload_info_t mOffloadInfo;
Andy Hung398ffa22022-12-13 19:19:53 -08001639
1640 audioflinger::MonotonicFrameCounter mMonotonicFrameCounter; // for VolumeShaper
Andy Hung48f59ed2019-01-28 15:06:59 -08001641 bool mVolumeShaperActive = false;
Eric Laurent81784c32012-11-19 14:55:58 -08001642
Eric Laurentbfb1b832013-01-07 09:53:42 -08001643 DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Gareth Fennb18c1a32022-10-05 13:42:36 -07001644 audio_io_handle_t id, ThreadBase::type_t type, bool systemReady,
1645 const audio_offload_info_t& offloadInfo);
Eric Laurent5850c4c2016-11-10 13:04:31 -08001646 void processVolume_l(Track *track, bool lastTrack);
Gareth Fennb18c1a32022-10-05 13:42:36 -07001647 bool isTunerStream() const { return (mOffloadInfo.content_id > 0); }
Eric Laurentbfb1b832013-01-07 09:53:42 -08001648
Eric Laurent81784c32012-11-19 14:55:58 -08001649 // prepareTracks_l() tells threadLoop_mix() the name of the single active track
1650 sp<Track> mActiveTrack;
Phil Burk43b4dcc2015-06-09 16:53:44 -07001651
1652 wp<Track> mPreviousTrack; // used to detect track switch
1653
Richard Folke Tullberg3fae0372017-01-13 09:04:25 +01001654 // This must be initialized for initial condition of mMasterBalance = 0 (disabled).
1655 float mMasterBalanceLeft = 1.f;
1656 float mMasterBalanceRight = 1.f;
1657
Eric Laurent81784c32012-11-19 14:55:58 -08001658public:
1659 virtual bool hasFastMixer() const { return false; }
Andy Hung10cbff12017-02-21 17:30:14 -08001660
1661 virtual int64_t computeWaitTimeNs_l() const override;
Andy Hungf3234512018-07-03 14:51:47 -07001662
1663 status_t threadloop_getHalTimestamp_l(ExtendedTimestamp *timestamp) const override {
1664 // For DIRECT and OFFLOAD threads, query the output sink directly.
1665 if (mOutput != nullptr) {
1666 uint64_t uposition64;
1667 struct timespec time;
1668 if (mOutput->getPresentationPosition(
1669 &uposition64, &time) == OK) {
1670 timestamp->mPosition[ExtendedTimestamp::LOCATION_KERNEL]
1671 = (int64_t)uposition64;
1672 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]
1673 = audio_utils_ns_from_timespec(&time);
1674 return NO_ERROR;
1675 }
1676 }
1677 return INVALID_OPERATION;
1678 }
Eric Laurent81784c32012-11-19 14:55:58 -08001679};
1680
Eric Laurentbfb1b832013-01-07 09:53:42 -08001681class OffloadThread : public DirectOutputThread {
1682public:
1683
1684 OffloadThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Gareth Fennb18c1a32022-10-05 13:42:36 -07001685 audio_io_handle_t id, bool systemReady,
1686 const audio_offload_info_t& offloadInfo);
Eric Laurent6a51d7e2013-10-17 18:59:26 -07001687 virtual ~OffloadThread() {};
ziyangch8f194f12021-12-01 13:48:04 -08001688 void flushHw_l() override;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001689
1690protected:
1691 // threadLoop snippets
1692 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
1693 virtual void threadLoop_exit();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001694
1695 virtual bool waitingAsyncCallback();
1696 virtual bool waitingAsyncCallback_l();
Haynes Mathew George05317d22016-05-03 16:34:26 -07001697 virtual void invalidateTracks(audio_stream_type_t streamType);
jiabinc44b3462022-12-08 12:52:31 -08001698 void invalidateTracks(std::set<audio_port_handle_t>& portIds) override;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001699
Eric Laurentde0613d2016-07-22 18:19:11 -07001700 virtual bool keepWakeLock() const { return (mKeepWakeLock || (mDrainSequence & 1)); }
Eric Laurent64667972016-03-30 18:19:46 -07001701
Eric Laurentbfb1b832013-01-07 09:53:42 -08001702private:
Eric Laurentbfb1b832013-01-07 09:53:42 -08001703 size_t mPausedWriteLength; // length in bytes of write interrupted by pause
1704 size_t mPausedBytesRemaining; // bytes still waiting in mixbuffer after resume
Eric Laurent64667972016-03-30 18:19:46 -07001705 bool mKeepWakeLock; // keep wake lock while waiting for write callback
Eric Laurentbfb1b832013-01-07 09:53:42 -08001706};
1707
1708class AsyncCallbackThread : public Thread {
1709public:
1710
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001711 explicit AsyncCallbackThread(const wp<PlaybackThread>& playbackThread);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001712
1713 virtual ~AsyncCallbackThread();
1714
1715 // Thread virtuals
1716 virtual bool threadLoop();
1717
1718 // RefBase
1719 virtual void onFirstRef();
1720
1721 void exit();
Eric Laurent3b4529e2013-09-05 18:09:19 -07001722 void setWriteBlocked(uint32_t sequence);
1723 void resetWriteBlocked();
1724 void setDraining(uint32_t sequence);
1725 void resetDraining();
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07001726 void setAsyncError();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001727
1728private:
Eric Laurent4de95592013-09-26 15:28:21 -07001729 const wp<PlaybackThread> mPlaybackThread;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001730 // mWriteAckSequence corresponds to the last write sequence passed by the offload thread via
1731 // setWriteBlocked(). The sequence is shifted one bit to the left and the lsb is used
1732 // to indicate that the callback has been received via resetWriteBlocked()
Eric Laurent4de95592013-09-26 15:28:21 -07001733 uint32_t mWriteAckSequence;
Eric Laurent3b4529e2013-09-05 18:09:19 -07001734 // mDrainSequence corresponds to the last drain sequence passed by the offload thread via
1735 // setDraining(). The sequence is shifted one bit to the left and the lsb is used
1736 // to indicate that the callback has been received via resetDraining()
Eric Laurent4de95592013-09-26 15:28:21 -07001737 uint32_t mDrainSequence;
1738 Condition mWaitWorkCV;
1739 Mutex mLock;
Haynes Mathew George4527b9e2016-07-07 19:54:17 -07001740 bool mAsyncError;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001741};
1742
Eric Laurent81784c32012-11-19 14:55:58 -08001743class DuplicatingThread : public MixerThread {
1744public:
1745 DuplicatingThread(const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread,
Eric Laurent72e3f392015-05-20 14:43:50 -07001746 audio_io_handle_t id, bool systemReady);
Eric Laurent81784c32012-11-19 14:55:58 -08001747 virtual ~DuplicatingThread();
1748
1749 // Thread virtuals
1750 void addOutputTrack(MixerThread* thread);
1751 void removeOutputTrack(MixerThread* thread);
1752 uint32_t waitTimeMs() const { return mWaitTimeMs; }
Kevin Rocard069c2712018-03-29 19:09:14 -07001753
Kevin Rocardc86a7f72018-04-03 09:00:09 -07001754 void sendMetadataToBackend_l(
1755 const StreamOutHalInterface::SourceMetadata& metadata) override;
Eric Laurent81784c32012-11-19 14:55:58 -08001756protected:
1757 virtual uint32_t activeSleepTimeUs() const;
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07001758 void dumpInternals_l(int fd, const Vector<String16>& args) override;
Eric Laurent81784c32012-11-19 14:55:58 -08001759
1760private:
1761 bool outputsReady(const SortedVector< sp<OutputTrack> > &outputTracks);
1762protected:
1763 // threadLoop snippets
1764 virtual void threadLoop_mix();
1765 virtual void threadLoop_sleepTime();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001766 virtual ssize_t threadLoop_write();
Eric Laurent81784c32012-11-19 14:55:58 -08001767 virtual void threadLoop_standby();
1768 virtual void cacheParameters_l();
1769
1770private:
1771 // called from threadLoop, addOutputTrack, removeOutputTrack
1772 virtual void updateWaitTime_l();
1773protected:
1774 virtual void saveOutputTracks();
1775 virtual void clearOutputTracks();
1776private:
1777
1778 uint32_t mWaitTimeMs;
1779 SortedVector < sp<OutputTrack> > outputTracks;
1780 SortedVector < sp<OutputTrack> > mOutputTracks;
1781public:
1782 virtual bool hasFastMixer() const { return false; }
Andy Hung1c86ebe2018-05-29 20:29:08 -07001783 status_t threadloop_getHalTimestamp_l(
1784 ExtendedTimestamp *timestamp) const override {
1785 if (mOutputTracks.size() > 0) {
1786 // forward the first OutputTrack's kernel information for timestamp.
1787 const ExtendedTimestamp trackTimestamp =
1788 mOutputTracks[0]->getClientProxyTimestamp();
1789 if (trackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0) {
1790 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] =
1791 trackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
1792 timestamp->mPosition[ExtendedTimestamp::LOCATION_KERNEL] =
1793 trackTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
1794 return OK; // discard server timestamp - that's ignored.
1795 }
1796 }
1797 return INVALID_OPERATION;
1798 }
Eric Laurent81784c32012-11-19 14:55:58 -08001799};
1800
Eric Laurentb0463942022-12-20 16:31:10 +01001801class SpatializerThread : public MixerThread {
Eric Laurentb3f315a2021-07-13 15:09:05 +02001802public:
Eric Laurentfa0f6742021-08-17 18:39:44 +02001803 SpatializerThread(const sp<AudioFlinger>& audioFlinger,
Eric Laurentb3f315a2021-07-13 15:09:05 +02001804 AudioStreamOut* output,
1805 audio_io_handle_t id,
1806 bool systemReady,
1807 audio_config_base_t *mixerConfig);
Eric Laurentfa0f6742021-08-17 18:39:44 +02001808 ~SpatializerThread() override {}
Eric Laurentb3f315a2021-07-13 15:09:05 +02001809
1810 bool hasFastMixer() const override { return false; }
1811
Eric Laurent68a40a82022-05-03 18:15:04 +02001812 // RefBase
1813 virtual void onFirstRef();
1814
Eric Laurent68a40a82022-05-03 18:15:04 +02001815 status_t setRequestedLatencyMode(audio_latency_mode_t mode) override;
Eric Laurent68a40a82022-05-03 18:15:04 +02001816
Eric Laurentb3f315a2021-07-13 15:09:05 +02001817protected:
1818 void checkOutputStageEffects() override;
Eric Laurent68a40a82022-05-03 18:15:04 +02001819 void setHalLatencyMode_l() override;
Eric Laurentb3f315a2021-07-13 15:09:05 +02001820
1821private:
Eric Laurent68a40a82022-05-03 18:15:04 +02001822 // Do not request a specific mode by default
1823 audio_latency_mode_t mRequestedLatencyMode = AUDIO_LATENCY_MODE_FREE;
1824
Eric Laurentb3f315a2021-07-13 15:09:05 +02001825 sp<EffectHandle> mFinalDownMixer;
1826};
1827
Eric Laurent81784c32012-11-19 14:55:58 -08001828// record thread
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001829class RecordThread : public ThreadBase
Eric Laurent81784c32012-11-19 14:55:58 -08001830{
1831public:
1832
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001833 class RecordTrack;
Andy Hung73c02e42015-03-29 01:13:58 -07001834
1835 /* The ResamplerBufferProvider is used to retrieve recorded input data from the
1836 * RecordThread. It maintains local state on the relative position of the read
1837 * position of the RecordTrack compared with the RecordThread.
1838 */
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001839 class ResamplerBufferProvider : public AudioBufferProvider
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001840 {
1841 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001842 explicit ResamplerBufferProvider(RecordTrack* recordTrack) :
Andy Hung73c02e42015-03-29 01:13:58 -07001843 mRecordTrack(recordTrack),
1844 mRsmpInUnrel(0), mRsmpInFront(0) { }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001845 virtual ~ResamplerBufferProvider() { }
Andy Hung73c02e42015-03-29 01:13:58 -07001846
1847 // called to set the ResamplerBufferProvider to head of the RecordThread data buffer,
1848 // skipping any previous data read from the hal.
1849 virtual void reset();
1850
1851 /* Synchronizes RecordTrack position with the RecordThread.
1852 * Calculates available frames and handle overruns if the RecordThread
1853 * has advanced faster than the ResamplerBufferProvider has retrieved data.
1854 * TODO: why not do this for every getNextBuffer?
1855 *
1856 * Parameters
1857 * framesAvailable: pointer to optional output size_t to store record track
1858 * frames available.
1859 * hasOverrun: pointer to optional boolean, returns true if track has overrun.
1860 */
1861
1862 virtual void sync(size_t *framesAvailable = NULL, bool *hasOverrun = NULL);
1863
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001864 // AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -08001865 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001866 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
Eric Laurentec376dc2021-04-08 20:41:22 +02001867
1868 int32_t getFront() const { return mRsmpInFront; }
1869 void setFront(int32_t front) { mRsmpInFront = front; }
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001870 private:
1871 RecordTrack * const mRecordTrack;
Andy Hung73c02e42015-03-29 01:13:58 -07001872 size_t mRsmpInUnrel; // unreleased frames remaining from
1873 // most recent getNextBuffer
1874 // for debug only
1875 int32_t mRsmpInFront; // next available frame
1876 // rolling counter that is never cleared
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08001877 };
1878
Eric Laurent81784c32012-11-19 14:55:58 -08001879#include "RecordTracks.h"
1880
1881 RecordThread(const sp<AudioFlinger>& audioFlinger,
1882 AudioStreamIn *input,
Eric Laurent81784c32012-11-19 14:55:58 -08001883 audio_io_handle_t id,
Eric Laurent72e3f392015-05-20 14:43:50 -07001884 bool systemReady
Glenn Kasten46909e72013-02-26 09:20:22 -08001885 );
Eric Laurent81784c32012-11-19 14:55:58 -08001886 virtual ~RecordThread();
1887
1888 // no addTrack_l ?
1889 void destroyTrack_l(const sp<RecordTrack>& track);
1890 void removeTrack_l(const sp<RecordTrack>& track);
1891
Eric Laurent81784c32012-11-19 14:55:58 -08001892 // Thread virtuals
1893 virtual bool threadLoop();
Eric Laurent555530a2017-02-07 18:17:24 -08001894 virtual void preExit();
Eric Laurent81784c32012-11-19 14:55:58 -08001895
1896 // RefBase
1897 virtual void onFirstRef();
1898
1899 virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; }
Glenn Kastene198c362013-08-13 09:13:36 -07001900
Glenn Kastenb880f5e2014-05-07 08:43:45 -07001901 virtual sp<MemoryDealer> readOnlyHeap() const { return mReadOnlyHeap; }
1902
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001903 virtual sp<IMemory> pipeMemory() const { return mPipeMemory; }
1904
Eric Laurent81784c32012-11-19 14:55:58 -08001905 sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l(
1906 const sp<AudioFlinger::Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -07001907 const audio_attributes_t& attr,
Eric Laurentf14db3c2017-12-08 14:20:36 -08001908 uint32_t *pSampleRate,
Eric Laurent81784c32012-11-19 14:55:58 -08001909 audio_format_t format,
1910 audio_channel_mask_t channelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08001911 size_t *pFrameCount,
Glenn Kastend848eb42016-03-08 13:42:11 -08001912 audio_session_t sessionId,
Eric Laurentf14db3c2017-12-08 14:20:36 -08001913 size_t *pNotificationFrameCount,
Eric Laurent09f1ed22019-04-24 17:45:17 -07001914 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +00001915 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -07001916 audio_input_flags_t *flags,
Eric Laurent81784c32012-11-19 14:55:58 -08001917 pid_t tid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001918 status_t *status /*non-NULL*/,
Eric Laurentec376dc2021-04-08 20:41:22 +02001919 audio_port_handle_t portId,
1920 int32_t maxSharedAudioHistoryMs);
Eric Laurent81784c32012-11-19 14:55:58 -08001921
1922 status_t start(RecordTrack* recordTrack,
1923 AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -08001924 audio_session_t triggerSession);
Eric Laurent81784c32012-11-19 14:55:58 -08001925
1926 // ask the thread to stop the specified track, and
1927 // return true if the caller should then do it's part of the stopping process
Glenn Kastena8356f62013-07-25 14:37:52 -07001928 bool stop(RecordTrack* recordTrack);
Eric Laurent81784c32012-11-19 14:55:58 -08001929
Eric Laurent81784c32012-11-19 14:55:58 -08001930 AudioStreamIn* clearInput();
Mikhail Naganov1dc98672016-08-18 17:50:29 -07001931 virtual sp<StreamHalInterface> stream() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001932
Eric Laurent81784c32012-11-19 14:55:58 -08001933
Eric Laurent10351942014-05-08 18:49:52 -07001934 virtual bool checkForNewParameter_l(const String8& keyValuePair,
1935 status_t& status);
1936 virtual void cacheParameters_l() {}
Eric Laurent81784c32012-11-19 14:55:58 -08001937 virtual String8 getParameters(const String8& keys);
Mikhail Naganov88536df2021-07-26 17:30:29 -07001938 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -07001939 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Eric Laurent1c333e22014-05-20 10:48:17 -07001940 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
1941 audio_patch_handle_t *handle);
1942 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
jiabinc52b1ff2019-10-31 17:20:42 -07001943 void updateOutDevices(const DeviceDescriptorBaseVector& outDevices) override;
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02001944 void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs) override;
Eric Laurent83b88082014-06-20 18:31:16 -07001945
Mikhail Naganov444ecc32018-05-01 17:40:05 -07001946 void addPatchTrack(const sp<PatchRecord>& record);
1947 void deletePatchTrack(const sp<PatchRecord>& record);
Eric Laurent83b88082014-06-20 18:31:16 -07001948
Glenn Kastendeca2ae2014-02-07 10:25:56 -08001949 void readInputParameters_l();
Glenn Kasten5f972c02014-01-13 09:59:31 -08001950 virtual uint32_t getInputFramesLost();
Eric Laurent81784c32012-11-19 14:55:58 -08001951
1952 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
1953 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
Andy Hungc3d62f92019-03-14 13:38:51 -07001954 uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
1955 return ThreadBase::hasAudioSession_l(sessionId, mTracks);
1956 }
Eric Laurent81784c32012-11-19 14:55:58 -08001957
1958 // Return the set of unique session IDs across all tracks.
1959 // The keys are the session IDs, and the associated values are meaningless.
1960 // FIXME replace by Set [and implement Bag/Multiset for other uses].
Glenn Kastend848eb42016-03-08 13:42:11 -08001961 KeyedVector<audio_session_t, bool> sessionIds() const;
Eric Laurent81784c32012-11-19 14:55:58 -08001962
1963 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
1964 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const;
1965
1966 static void syncStartEventCallback(const wp<SyncEvent>& event);
Eric Laurent81784c32012-11-19 14:55:58 -08001967
Glenn Kasten9b58f632013-07-16 11:37:48 -07001968 virtual size_t frameCount() const { return mFrameCount; }
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07001969 bool hasFastCapture() const { return mFastCapture != 0; }
Mikhail Naganovdc769682018-05-04 15:34:08 -07001970 virtual void toAudioPortConfig(struct audio_port_config *config);
Glenn Kasten9b58f632013-07-16 11:37:48 -07001971
Eric Laurent4c415062016-06-17 16:14:16 -07001972 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
1973 audio_session_t sessionId);
1974
Andy Hungdae27702016-10-31 14:01:16 -07001975 virtual void acquireWakeLock_l() {
1976 ThreadBase::acquireWakeLock_l();
1977 mActiveTracks.updatePowerState(this, true /* force */);
1978 }
1979
Eric Laurentd8365c52017-07-16 15:27:05 -07001980 void checkBtNrec();
1981
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001982 // Sets the UID records silence
Eric Laurent5ada82e2019-08-29 17:53:54 -07001983 void setRecordSilenced(audio_port_handle_t portId, bool silenced);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001984
Mikhail Naganovd5d9de72023-02-13 11:45:03 -08001985 status_t getActiveMicrophones(
1986 std::vector<media::MicrophoneInfoFw>* activeMicrophones);
jiabin653cc0a2018-01-17 17:54:10 -08001987
Paul McLean12340082019-03-19 09:35:05 -06001988 status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
1989 status_t setPreferredMicrophoneFieldDimension(float zoom);
Paul McLean03a6e6a2018-12-04 10:54:13 -07001990
Vlad Popa7e81cea2023-01-19 16:34:16 +01001991 MetadataUpdate updateMetadata_l() override;
Kevin Rocard069c2712018-03-29 19:09:14 -07001992
jiabin01c8f562018-07-19 17:47:28 -07001993 bool fastTrackAvailable() const { return mFastTrackAvail; }
1994
Andy Hungc8fddf32018-08-08 18:32:37 -07001995 bool isTimestampCorrectionEnabled() const override {
1996 // checks popcount for exactly one device.
Atneya Nair497fff12022-01-18 16:23:04 -05001997 // Is currently disabled. Before enabling,
1998 // verify compressed record timestamps.
jiabinc52b1ff2019-10-31 17:20:42 -07001999 return audio_is_input_device(mTimestampCorrectedDevice)
2000 && inDeviceType() == mTimestampCorrectedDevice;
Andy Hungc8fddf32018-08-08 18:32:37 -07002001 }
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002002
Eric Laurentec376dc2021-04-08 20:41:22 +02002003 status_t shareAudioHistory(const std::string& sharedAudioPackageName,
2004 audio_session_t sharedSessionId = AUDIO_SESSION_NONE,
2005 int64_t sharedAudioStartMs = -1);
2006 status_t shareAudioHistory_l(const std::string& sharedAudioPackageName,
2007 audio_session_t sharedSessionId = AUDIO_SESSION_NONE,
2008 int64_t sharedAudioStartMs = -1);
Eric Laurent92d0a322021-07-16 15:32:33 +02002009 void resetAudioHistory_l();
Eric Laurentec376dc2021-04-08 20:41:22 +02002010
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002011 virtual bool isStreamInitialized() {
2012 return !(mInput == nullptr || mInput->stream == nullptr);
2013 }
2014
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002015protected:
2016 void dumpInternals_l(int fd, const Vector<String16>& args) override;
2017 void dumpTracks_l(int fd, const Vector<String16>& args) override;
2018
Eric Laurent81784c32012-11-19 14:55:58 -08002019private:
Eric Laurent81784c32012-11-19 14:55:58 -08002020 // Enter standby if not already in standby, and set mStandby flag
Glenn Kasten93e471f2013-08-19 08:40:07 -07002021 void standbyIfNotAlreadyInStandby();
Eric Laurent81784c32012-11-19 14:55:58 -08002022
2023 // Call the HAL standby method unconditionally, and don't change mStandby flag
Glenn Kastene198c362013-08-13 09:13:36 -07002024 void inputStandBy();
Eric Laurent81784c32012-11-19 14:55:58 -08002025
Eric Laurentd8365c52017-07-16 15:27:05 -07002026 void checkBtNrec_l();
2027
Eric Laurentec376dc2021-04-08 20:41:22 +02002028 int32_t getOldestFront_l();
2029 void updateFronts_l(int32_t offset);
2030
Eric Laurent81784c32012-11-19 14:55:58 -08002031 AudioStreamIn *mInput;
Mikhail Naganov2534b382019-09-25 13:05:02 -07002032 Source *mSource;
Eric Laurent81784c32012-11-19 14:55:58 -08002033 SortedVector < sp<RecordTrack> > mTracks;
Glenn Kasten2b806402013-11-20 16:37:38 -08002034 // mActiveTracks has dual roles: it indicates the current active track(s), and
Eric Laurent81784c32012-11-19 14:55:58 -08002035 // is used together with mStartStopCond to indicate start()/stop() progress
Andy Hungdae27702016-10-31 14:01:16 -07002036 ActiveTracks<RecordTrack> mActiveTracks;
2037
Eric Laurent81784c32012-11-19 14:55:58 -08002038 Condition mStartStopCond;
Glenn Kasten9b58f632013-07-16 11:37:48 -07002039
Glenn Kasten85948432013-08-19 12:09:05 -07002040 // resampler converts input at HAL Hz to output at AudioRecord client Hz
Glenn Kasten1b291842016-07-18 14:55:21 -07002041 void *mRsmpInBuffer; // size = mRsmpInFramesOA
Glenn Kasten85948432013-08-19 12:09:05 -07002042 size_t mRsmpInFrames; // size of resampler input in frames
2043 size_t mRsmpInFramesP2;// size rounded up to a power-of-2
Glenn Kasten1b291842016-07-18 14:55:21 -07002044 size_t mRsmpInFramesOA;// mRsmpInFramesP2 + over-allocation
Glenn Kasten6dd62fb2013-12-05 16:35:58 -08002045
2046 // rolling index that is never cleared
Glenn Kasten85948432013-08-19 12:09:05 -07002047 int32_t mRsmpInRear; // last filled frame + 1
Glenn Kasten85948432013-08-19 12:09:05 -07002048
Eric Laurent81784c32012-11-19 14:55:58 -08002049 // For dumpsys
Glenn Kastenb880f5e2014-05-07 08:43:45 -07002050 const sp<MemoryDealer> mReadOnlyHeap;
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07002051
2052 // one-time initialization, no locks required
Glenn Kastenb187de12014-12-30 08:18:15 -08002053 sp<FastCapture> mFastCapture; // non-0 if there is also
2054 // a fast capture
Eric Laurent72e3f392015-05-20 14:43:50 -07002055
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07002056 // FIXME audio watchdog thread
2057
2058 // contents are not guaranteed to be consistent, no locks required
2059 FastCaptureDumpState mFastCaptureDumpState;
2060#ifdef STATE_QUEUE_DUMP
2061 // FIXME StateQueue observer and mutator dump fields
2062#endif
2063 // FIXME audio watchdog dump
2064
2065 // accessible only within the threadLoop(), no locks required
2066 // mFastCapture->sq() // for mutating and pushing state
2067 int32_t mFastCaptureFutex; // for cold idle
2068
2069 // The HAL input source is treated as non-blocking,
2070 // but current implementation is blocking
2071 sp<NBAIO_Source> mInputSource;
2072 // The source for the normal capture thread to read from: mInputSource or mPipeSource
2073 sp<NBAIO_Source> mNormalSource;
2074 // If a fast capture is present, the non-blocking pipe sink written to by fast capture,
2075 // otherwise clear
2076 sp<NBAIO_Sink> mPipeSink;
2077 // If a fast capture is present, the non-blocking pipe source read by normal thread,
2078 // otherwise clear
2079 sp<NBAIO_Source> mPipeSource;
2080 // Depth of pipe from fast capture to normal thread and fast clients, always power of 2
2081 size_t mPipeFramesP2;
2082 // If a fast capture is present, the Pipe as IMemory, otherwise clear
2083 sp<IMemory> mPipeMemory;
2084
Sanna Catherine de Treville Wager2a6a9452017-07-28 11:02:01 -07002085 // TODO: add comment and adjust size as needed
Glenn Kasten6dbb5e32014-05-13 10:38:42 -07002086 static const size_t kFastCaptureLogSize = 4 * 1024;
2087 sp<NBLog::Writer> mFastCaptureNBLogWriter;
2088
2089 bool mFastTrackAvail; // true if fast track available
Eric Laurentd8365c52017-07-16 15:27:05 -07002090 // common state to all record threads
2091 std::atomic_bool mBtNrecSuspended;
Andy Hung6427e442018-08-09 12:51:02 -07002092
2093 int64_t mFramesRead = 0; // continuous running counter.
jiabinc52b1ff2019-10-31 17:20:42 -07002094
2095 DeviceDescriptorBaseVector mOutDevices;
Eric Laurentec376dc2021-04-08 20:41:22 +02002096
Eric Laurent5f0fd7b2021-05-07 16:33:26 +02002097 int32_t mMaxSharedAudioHistoryMs = 0;
Eric Laurentec376dc2021-04-08 20:41:22 +02002098 std::string mSharedAudioPackageName = {};
Eric Laurent2407ce32021-04-26 14:56:03 +02002099 int32_t mSharedAudioStartFrames = -1;
Eric Laurentec376dc2021-04-08 20:41:22 +02002100 audio_session_t mSharedAudioSessionId = AUDIO_SESSION_NONE;
Eric Laurent81784c32012-11-19 14:55:58 -08002101};
Eric Laurent6acd1d42017-01-04 14:23:29 -08002102
2103class MmapThread : public ThreadBase
2104{
2105 public:
2106
2107#include "MmapTracks.h"
2108
2109 MmapThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
Andy Hungcf10d742020-04-28 15:38:24 -07002110 AudioHwDevice *hwDev, sp<StreamHalInterface> stream, bool systemReady,
2111 bool isOut);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002112 virtual ~MmapThread();
2113
2114 virtual void configure(const audio_attributes_t *attr,
2115 audio_stream_type_t streamType,
2116 audio_session_t sessionId,
2117 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07002118 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002119 audio_port_handle_t portId);
2120
2121 void disconnect();
2122
2123 // MmapStreamInterface
2124 status_t createMmapBuffer(int32_t minSizeFrames,
2125 struct audio_mmap_buffer_info *info);
2126 status_t getMmapPosition(struct audio_mmap_position *position);
jiabind1f1cb62020-03-24 11:57:57 -07002127 status_t start(const AudioClient& client,
2128 const audio_attributes_t *attr,
2129 audio_port_handle_t *handle);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002130 status_t stop(audio_port_handle_t handle);
Eric Laurent18b57012017-02-13 16:23:52 -08002131 status_t standby();
jiabinb7d8c5a2020-08-26 17:24:52 -07002132 virtual status_t getExternalPosition(uint64_t *position, int64_t *timeNaos) = 0;
jiabinfc791ee2023-02-15 19:43:40 +00002133 virtual status_t reportData(const void* buffer, size_t frameCount);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002134
2135 // RefBase
2136 virtual void onFirstRef();
2137
2138 // Thread virtuals
2139 virtual bool threadLoop();
2140
2141 virtual void threadLoop_exit();
2142 virtual void threadLoop_standby();
Eric Laurent18b57012017-02-13 16:23:52 -08002143 virtual bool shouldStandby_l() { return false; }
Eric Laurentdda206a2022-07-08 17:28:35 +02002144 virtual status_t exitStandby_l() REQUIRES(mLock);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002145
2146 virtual status_t initCheck() const { return (mHalStream == 0) ? NO_INIT : NO_ERROR; }
2147 virtual size_t frameCount() const { return mFrameCount; }
2148 virtual bool checkForNewParameter_l(const String8& keyValuePair,
2149 status_t& status);
2150 virtual String8 getParameters(const String8& keys);
Mikhail Naganov88536df2021-07-26 17:30:29 -07002151 virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
Eric Laurent09f1ed22019-04-24 17:45:17 -07002152 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002153 void readHalParameters_l();
2154 virtual void cacheParameters_l() {}
2155 virtual status_t createAudioPatch_l(const struct audio_patch *patch,
2156 audio_patch_handle_t *handle);
2157 virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
Mikhail Naganovdc769682018-05-04 15:34:08 -07002158 virtual void toAudioPortConfig(struct audio_port_config *config);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002159
2160 virtual sp<StreamHalInterface> stream() const { return mHalStream; }
2161 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
2162 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
2163 virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
2164 audio_session_t sessionId);
2165
Andy Hungc3d62f92019-03-14 13:38:51 -07002166 uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
2167 // Note: using mActiveTracks as no mTracks here.
2168 return ThreadBase::hasAudioSession_l(sessionId, mActiveTracks);
2169 }
Eric Laurent6acd1d42017-01-04 14:23:29 -08002170 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
2171 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const;
2172
2173 virtual void checkSilentMode_l() {}
2174 virtual void processVolume_l() {}
2175 void checkInvalidTracks_l();
2176
2177 virtual audio_stream_type_t streamType() { return AUDIO_STREAM_DEFAULT; }
2178
2179 virtual void invalidateTracks(audio_stream_type_t streamType __unused) {}
jiabinc44b3462022-12-08 12:52:31 -08002180 virtual void invalidateTracks(std::set<audio_port_handle_t>& portIds __unused) {}
Eric Laurent6acd1d42017-01-04 14:23:29 -08002181
Eric Laurent331679c2018-04-16 17:03:16 -07002182 // Sets the UID records silence
Eric Laurent5ada82e2019-08-29 17:53:54 -07002183 virtual void setRecordSilenced(audio_port_handle_t portId __unused,
2184 bool silenced __unused) {}
Eric Laurent331679c2018-04-16 17:03:16 -07002185
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002186 virtual bool isStreamInitialized() { return false; }
2187
jiabin09609032022-06-15 19:26:01 +00002188 void setClientSilencedState_l(audio_port_handle_t portId, bool silenced) {
2189 mClientSilencedStates[portId] = silenced;
2190 }
2191
2192 size_t eraseClientSilencedState_l(audio_port_handle_t portId) {
2193 return mClientSilencedStates.erase(portId);
2194 }
2195
2196 bool isClientSilenced_l(audio_port_handle_t portId) const {
2197 const auto it = mClientSilencedStates.find(portId);
2198 return it != mClientSilencedStates.end() ? it->second : false;
2199 }
2200
2201 void setClientSilencedIfExists_l(audio_port_handle_t portId, bool silenced) {
2202 const auto it = mClientSilencedStates.find(portId);
2203 if (it != mClientSilencedStates.end()) {
2204 it->second = silenced;
2205 }
2206 }
2207
Eric Laurent6acd1d42017-01-04 14:23:29 -08002208 protected:
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002209 void dumpInternals_l(int fd, const Vector<String16>& args) override;
2210 void dumpTracks_l(int fd, const Vector<String16>& args) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002211
jiabinc52b1ff2019-10-31 17:20:42 -07002212 /**
2213 * @brief mDeviceId current device port unique identifier
2214 */
2215 audio_port_handle_t mDeviceId = AUDIO_PORT_HANDLE_NONE;
2216
Eric Laurent6acd1d42017-01-04 14:23:29 -08002217 audio_attributes_t mAttr;
2218 audio_session_t mSessionId;
2219 audio_port_handle_t mPortId;
2220
Phil Burk7f6b40d2017-02-09 13:18:38 -08002221 wp<MmapStreamCallback> mCallback;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002222 sp<StreamHalInterface> mHalStream;
2223 sp<DeviceHalInterface> mHalDevice;
2224 AudioHwDevice* const mAudioHwDev;
2225 ActiveTracks<MmapTrack> mActiveTracks;
Eric Laurent67f97292018-04-20 18:05:41 -07002226 float mHalVolFloat;
jiabin09609032022-06-15 19:26:01 +00002227 std::map<audio_port_handle_t, bool> mClientSilencedStates;
Eric Laurent331679c2018-04-16 17:03:16 -07002228
2229 int32_t mNoCallbackWarningCount;
2230 static constexpr int32_t kMaxNoCallbackWarnings = 5;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002231};
2232
2233class MmapPlaybackThread : public MmapThread, public VolumeInterface
2234{
2235
2236public:
2237 MmapPlaybackThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabinc52b1ff2019-10-31 17:20:42 -07002238 AudioHwDevice *hwDev, AudioStreamOut *output, bool systemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002239 virtual ~MmapPlaybackThread() {}
2240
2241 virtual void configure(const audio_attributes_t *attr,
2242 audio_stream_type_t streamType,
2243 audio_session_t sessionId,
2244 const sp<MmapStreamCallback>& callback,
Eric Laurent7aa0ccb2017-08-28 11:12:52 -07002245 audio_port_handle_t deviceId,
Eric Laurent6acd1d42017-01-04 14:23:29 -08002246 audio_port_handle_t portId);
2247
2248 AudioStreamOut* clearOutput();
2249
2250 // VolumeInterface
2251 virtual void setMasterVolume(float value);
2252 virtual void setMasterMute(bool muted);
2253 virtual void setStreamVolume(audio_stream_type_t stream, float value);
2254 virtual void setStreamMute(audio_stream_type_t stream, bool muted);
2255 virtual float streamVolume(audio_stream_type_t stream) const;
2256
2257 void setMasterMute_l(bool muted) { mMasterMute = muted; }
2258
2259 virtual void invalidateTracks(audio_stream_type_t streamType);
jiabinc44b3462022-12-08 12:52:31 -08002260 void invalidateTracks(std::set<audio_port_handle_t>& portIds) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002261
2262 virtual audio_stream_type_t streamType() { return mStreamType; }
2263 virtual void checkSilentMode_l();
Eric Laurent331679c2018-04-16 17:03:16 -07002264 void processVolume_l() override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002265
Vlad Popa7e81cea2023-01-19 16:34:16 +01002266 MetadataUpdate updateMetadata_l() override;
Kevin Rocard069c2712018-03-29 19:09:14 -07002267
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07002268 virtual void toAudioPortConfig(struct audio_port_config *config);
2269
jiabinb7d8c5a2020-08-26 17:24:52 -07002270 status_t getExternalPosition(uint64_t *position, int64_t *timeNanos) override;
2271
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002272 virtual bool isStreamInitialized() {
2273 return !(mOutput == nullptr || mOutput->stream == nullptr);
2274 }
2275
jiabinfc791ee2023-02-15 19:43:40 +00002276 status_t reportData(const void* buffer, size_t frameCount) override;
2277
Eric Laurent6acd1d42017-01-04 14:23:29 -08002278protected:
Mikhail Naganov01dc5ca2019-03-29 10:12:12 -07002279 void dumpInternals_l(int fd, const Vector<String16>& args) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002280
2281 audio_stream_type_t mStreamType;
2282 float mMasterVolume;
2283 float mStreamVolume;
2284 bool mMasterMute;
2285 bool mStreamMute;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002286 AudioStreamOut* mOutput;
2287};
2288
2289class MmapCaptureThread : public MmapThread
2290{
2291
2292public:
2293 MmapCaptureThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
jiabinc52b1ff2019-10-31 17:20:42 -07002294 AudioHwDevice *hwDev, AudioStreamIn *input, bool systemReady);
Eric Laurent6acd1d42017-01-04 14:23:29 -08002295 virtual ~MmapCaptureThread() {}
2296
2297 AudioStreamIn* clearInput();
2298
Eric Laurentdda206a2022-07-08 17:28:35 +02002299 status_t exitStandby_l() REQUIRES(mLock) override;
Eric Laurent6acd1d42017-01-04 14:23:29 -08002300
Vlad Popa7e81cea2023-01-19 16:34:16 +01002301 MetadataUpdate updateMetadata_l() override;
Eric Laurent331679c2018-04-16 17:03:16 -07002302 void processVolume_l() override;
Eric Laurent5ada82e2019-08-29 17:53:54 -07002303 void setRecordSilenced(audio_port_handle_t portId,
2304 bool silenced) override;
Kevin Rocard069c2712018-03-29 19:09:14 -07002305
Mikhail Naganov32abc2b2018-05-24 12:57:11 -07002306 virtual void toAudioPortConfig(struct audio_port_config *config);
2307
jiabinb7d8c5a2020-08-26 17:24:52 -07002308 status_t getExternalPosition(uint64_t *position, int64_t *timeNanos) override;
2309
Jasmine Chaeaa10e42021-05-11 10:11:14 +08002310 virtual bool isStreamInitialized() {
2311 return !(mInput == nullptr || mInput->stream == nullptr);
2312 }
2313
Eric Laurent6acd1d42017-01-04 14:23:29 -08002314protected:
2315
2316 AudioStreamIn* mInput;
2317};
jiabinc658e452022-10-21 20:52:21 +00002318
2319class BitPerfectThread : public MixerThread {
2320public:
2321 BitPerfectThread(const sp<AudioFlinger>& audioflinger, AudioStreamOut *output,
2322 audio_io_handle_t id, bool systemReady);
2323
2324protected:
2325 mixer_state prepareTracks_l(Vector<sp<Track>> *tracksToRemove) override;
2326 void threadLoop_mix() override;
2327
2328private:
2329 bool mIsBitPerfect;
jiabin76d94692022-12-15 21:51:21 +00002330 float mVolumeLeft = 0.f;
2331 float mVolumeRight = 0.f;
jiabinc658e452022-10-21 20:52:21 +00002332};