blob: 14d27e6096227e5ba31da4255f065cac21cd3273 [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
Lais Andradebc3f37a2021-07-02 00:13:19 +010022#include <math.h>
23
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080024// Checks and monitors OP_PLAY_AUDIO
25class OpPlayAudioMonitor : public RefBase {
26public:
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080027 ~OpPlayAudioMonitor() override;
28 bool hasOpPlayAudio() const;
29
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070030 static sp<OpPlayAudioMonitor> createIfNeeded(
Svet Ganov33761132021-05-13 22:51:08 +000031 const AttributionSourceState& attributionSource,
Philip P. Moltmannbda45752020-07-17 16:41:18 -070032 const audio_attributes_t& attr, int id,
33 audio_stream_type_t streamType);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070034
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080035private:
Svet Ganov33761132021-05-13 22:51:08 +000036 OpPlayAudioMonitor(const AttributionSourceState& attributionSource,
Philip P. Moltmannbda45752020-07-17 16:41:18 -070037 audio_usage_t usage, int id);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070038 void onFirstRef() override;
Eric Laurent9066ad32019-05-20 14:40:10 -070039 static void getPackagesForUid(uid_t uid, Vector<String16>& packages);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070040
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080041 AppOpsManager mAppOpsManager;
42
43 class PlayAudioOpCallback : public BnAppOpsCallback {
44 public:
45 explicit PlayAudioOpCallback(const wp<OpPlayAudioMonitor>& monitor);
46 void opChanged(int32_t op, const String16& packageName) override;
47
48 private:
49 const wp<OpPlayAudioMonitor> mMonitor;
50 };
51
52 sp<PlayAudioOpCallback> mOpCallback;
53 // called by PlayAudioOpCallback when OP_PLAY_AUDIO is updated in AppOp callback
54 void checkPlayAudioForUsage();
55
56 std::atomic_bool mHasOpPlayAudio;
Svet Ganov33761132021-05-13 22:51:08 +000057 const AttributionSourceState mAttributionSource;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080058 const int32_t mUsage; // on purpose not audio_usage_t because always checked in appOps as int32_t
59 const int mId; // for logging purposes only
60};
61
Eric Laurent81784c32012-11-19 14:55:58 -080062// playback track
Andy Hungd29af632023-06-23 19:27:19 -070063class Track : public TrackBase, public virtual IAfTrack, public VolumeProvider {
Eric Laurent81784c32012-11-19 14:55:58 -080064public:
65 Track( PlaybackThread *thread,
66 const sp<Client>& client,
67 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -070068 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -080069 uint32_t sampleRate,
70 audio_format_t format,
71 audio_channel_mask_t channelMask,
72 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -070073 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -070074 size_t bufferSize,
Eric Laurent81784c32012-11-19 14:55:58 -080075 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -080076 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -070077 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +000078 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -070079 audio_output_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -080080 track_type type,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +010081 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE,
82 /** default behaviour is to start when there are as many frames
83 * ready as possible (aka. Buffer is full). */
jiabinf042b9b2021-05-07 23:46:28 +000084 size_t frameCountToBeReady = SIZE_MAX,
Eric Laurentb0a7bc92022-04-05 15:06:08 +020085 float speed = 1.0f,
jiabinc658e452022-10-21 20:52:21 +000086 bool isSpatialized = false,
87 bool isBitPerfect = false);
Andy Hungd29af632023-06-23 19:27:19 -070088 ~Track() override;
89 status_t initCheck() const final;
90 void appendDumpHeader(String8& result) const final;
91 void appendDump(String8& result, bool active) const final;
92 status_t start(AudioSystem::sync_event_t event = AudioSystem::SYNC_EVENT_NONE,
93 audio_session_t triggerSession = AUDIO_SESSION_NONE) override;
94 void stop() override;
95 void pause() final;
96 void flush() final;
97 void destroy() final;
98 uint32_t sampleRate() const final;
99 audio_stream_type_t streamType() const final {
Eric Laurent81784c32012-11-19 14:55:58 -0800100 return mStreamType;
101 }
Andy Hungd29af632023-06-23 19:27:19 -0700102 bool isOffloaded() const final
Eric Laurent05067782016-06-01 18:27:28 -0700103 { return (mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0; }
Andy Hungd29af632023-06-23 19:27:19 -0700104 bool isDirect() const final
Mikhail Naganov7c6ae982018-06-14 12:33:38 -0700105 { return (mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0; }
Andy Hungd29af632023-06-23 19:27:19 -0700106 bool isOffloadedOrDirect() const final { return (mFlags
Andy Hung10cbff12017-02-21 17:30:14 -0800107 & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD
108 | AUDIO_OUTPUT_FLAG_DIRECT)) != 0; }
Andy Hungd29af632023-06-23 19:27:19 -0700109 bool isStatic() const final { return mSharedBuffer.get() != nullptr; }
Andy Hung10cbff12017-02-21 17:30:14 -0800110
Andy Hungd29af632023-06-23 19:27:19 -0700111 status_t setParameters(const String8& keyValuePairs) final;
112 status_t selectPresentation(int presentationId, int programId) final;
113 status_t attachAuxEffect(int EffectId) final;
114 void setAuxBuffer(int EffectId, int32_t* buffer) final;
115 int32_t* auxBuffer() const final { return mAuxBuffer; }
116 void setMainBuffer(float* buffer) final { mMainBuffer = buffer; }
117 float* mainBuffer() const final { return mMainBuffer; }
118 int auxEffectId() const final { return mAuxEffectId; }
119 status_t getTimestamp(AudioTimestamp& timestamp) final;
120 void signal() final;
121 status_t getDualMonoMode(audio_dual_mono_mode_t* mode) const final;
122 status_t setDualMonoMode(audio_dual_mono_mode_t mode) final;
123 status_t getAudioDescriptionMixLevel(float* leveldB) const final;
124 status_t setAudioDescriptionMixLevel(float leveldB) final;
125 status_t getPlaybackRateParameters(audio_playback_rate_t* playbackRate) const final;
126 status_t setPlaybackRateParameters(const audio_playback_rate_t& playbackRate) final;
Eric Laurent81784c32012-11-19 14:55:58 -0800127
Andy Hungd29af632023-06-23 19:27:19 -0700128 // implement FastMixerState::VolumeProvider interface
129 gain_minifloat_packed_t getVolumeLR() const final;
Eric Laurent81784c32012-11-19 14:55:58 -0800130
Andy Hungd29af632023-06-23 19:27:19 -0700131 status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) final;
132 bool isFastTrack() const final { return (mFlags & AUDIO_OUTPUT_FLAG_FAST) != 0; }
133 double bufferLatencyMs() const final {
Andy Hungcef2daa2018-06-01 15:31:49 -0700134 return isStatic() ? 0. : TrackBase::bufferLatencyMs();
135 }
Andy Hungf6ab58d2018-05-25 12:50:39 -0700136
Andy Hungd29af632023-06-23 19:27:19 -0700137 // implement volume handling.
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700138 media::VolumeShaper::Status applyVolumeShaper(
139 const sp<media::VolumeShaper::Configuration>& configuration,
140 const sp<media::VolumeShaper::Operation>& operation);
Andy Hungd29af632023-06-23 19:27:19 -0700141 sp<media::VolumeShaper::State> getVolumeShaperState(int id) const final;
142 sp<media::VolumeHandler> getVolumeHandler() const final{ return mVolumeHandler; }
Kevin Rocard12381092018-04-11 09:19:59 -0700143 /** Set the computed normalized final volume of the track.
144 * !masterMute * masterVolume * streamVolume * averageLRVolume */
Andy Hungd29af632023-06-23 19:27:19 -0700145 void setFinalVolume(float volumeLeft, float volumeRight) final;
146 float getFinalVolume() const final { return mFinalVolume; }
147 void getFinalVolume(float* left, float* right) const final {
jiabin76d94692022-12-15 21:51:21 +0000148 *left = mFinalVolumeLeft;
149 *right = mFinalVolumeRight;
150 }
Kevin Rocard12381092018-04-11 09:19:59 -0700151
Eric Laurent94579172020-11-20 18:41:04 +0100152 using SourceMetadatas = std::vector<playback_track_metadata_v7_t>;
Kevin Rocard12381092018-04-11 09:19:59 -0700153 using MetadataInserter = std::back_insert_iterator<SourceMetadatas>;
154 /** Copy the track metadata in the provided iterator. Thread safe. */
Andy Hungd29af632023-06-23 19:27:19 -0700155 void copyMetadataTo(MetadataInserter& backInserter) const override;
156
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800157
jiabin245cdd92018-12-07 17:55:15 -0800158 /** Return haptic playback of the track is enabled or not, used in mixer. */
Andy Hungd29af632023-06-23 19:27:19 -0700159 bool getHapticPlaybackEnabled() const final { return mHapticPlaybackEnabled; }
jiabin245cdd92018-12-07 17:55:15 -0800160 /** Set haptic playback of the track is enabled or not, should be
161 * set after query or get callback from vibrator service */
Andy Hungd29af632023-06-23 19:27:19 -0700162 void setHapticPlaybackEnabled(bool hapticPlaybackEnabled) final {
jiabin245cdd92018-12-07 17:55:15 -0800163 mHapticPlaybackEnabled = hapticPlaybackEnabled;
164 }
jiabin77270b82018-12-18 15:41:29 -0800165 /** Return at what intensity to play haptics, used in mixer. */
Andy Hungd29af632023-06-23 19:27:19 -0700166 os::HapticScale getHapticIntensity() const final { return mHapticIntensity; }
Lais Andradebc3f37a2021-07-02 00:13:19 +0100167 /** Return the maximum amplitude allowed for haptics data, used in mixer. */
Andy Hungd29af632023-06-23 19:27:19 -0700168 float getHapticMaxAmplitude() const final { return mHapticMaxAmplitude; }
jiabin77270b82018-12-18 15:41:29 -0800169 /** Set intensity of haptic playback, should be set after querying vibrator service. */
Andy Hungd29af632023-06-23 19:27:19 -0700170 void setHapticIntensity(os::HapticScale hapticIntensity) final {
jiabine70bc7f2020-06-30 22:07:55 -0700171 if (os::isValidHapticScale(hapticIntensity)) {
jiabin77270b82018-12-18 15:41:29 -0800172 mHapticIntensity = hapticIntensity;
jiabine70bc7f2020-06-30 22:07:55 -0700173 setHapticPlaybackEnabled(mHapticIntensity != os::HapticScale::MUTE);
jiabin77270b82018-12-18 15:41:29 -0800174 }
175 }
Lais Andradebc3f37a2021-07-02 00:13:19 +0100176 /** Set maximum amplitude allowed for haptic data, should be set after querying
177 * vibrator service.
178 */
Andy Hungd29af632023-06-23 19:27:19 -0700179 void setHapticMaxAmplitude(float maxAmplitude) final {
Lais Andradebc3f37a2021-07-02 00:13:19 +0100180 mHapticMaxAmplitude = maxAmplitude;
181 }
Andy Hungd29af632023-06-23 19:27:19 -0700182 sp<os::ExternalVibration> getExternalVibration() const final { return mExternalVibration; }
jiabin245cdd92018-12-07 17:55:15 -0800183
Jiabin Huangfb476842022-12-06 03:18:10 +0000184 // This function should be called with holding thread lock.
Andy Hungd29af632023-06-23 19:27:19 -0700185 void updateTeePatches_l() final;
186 void setTeePatchesToUpdate_l(const void* teePatchesToUpdate) final {
187 setTeePatchesToUpdate_l(*reinterpret_cast<const TeePatches*>(teePatchesToUpdate));
188 }
189 void setTeePatchesToUpdate_l(TeePatches teePatchesToUpdate);
Kevin Rocard153f92d2018-12-18 18:33:28 -0800190
Andy Hungd29af632023-06-23 19:27:19 -0700191 void tallyUnderrunFrames(size_t frames) final {
Andy Hungc2b11cb2020-04-22 09:04:01 -0700192 if (isOut()) { // we expect this from output tracks only
193 mAudioTrackServerProxy->tallyUnderrunFrames(frames);
194 // Fetch absolute numbers from AudioTrackShared as it counts
195 // contiguous underruns as a one -- we want a consistent number.
196 // TODO: isolate this counting into a class.
197 mTrackMetrics.logUnderruns(mAudioTrackServerProxy->getUnderrunCount(),
198 mAudioTrackServerProxy->getUnderrunFrames());
199 }
200 }
jiabinf042b9b2021-05-07 23:46:28 +0000201
Andy Hungd29af632023-06-23 19:27:19 -0700202 audio_output_flags_t getOutputFlags() const final { return mFlags; }
203 float getSpeed() const final { return mSpeed; }
204 bool isSpatialized() const final { return mIsSpatialized; }
205 bool isBitPerfect() const final { return mIsBitPerfect; }
Eric Laurent39095982021-08-24 18:29:27 +0200206
Vlad Popae8d99472022-06-30 16:02:48 +0200207 /**
208 * Updates the mute state and notifies the audio service. Call this only when holding player
209 * thread lock.
210 */
Andy Hungd29af632023-06-23 19:27:19 -0700211 void processMuteEvent_l(const sp<IAudioManager>& audioManager, mute_state_t muteState) final;
Vlad Popae8d99472022-06-30 16:02:48 +0200212
Eric Laurent81784c32012-11-19 14:55:58 -0800213protected:
214 // for numerous
215 friend class PlaybackThread;
216 friend class MixerThread;
217 friend class DirectOutputThread;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800218 friend class OffloadThread;
Eric Laurent81784c32012-11-19 14:55:58 -0800219
Mikhail Naganovbf493082017-04-17 17:37:12 -0700220 DISALLOW_COPY_AND_ASSIGN(Track);
Eric Laurent81784c32012-11-19 14:55:58 -0800221
222 // AudioBufferProvider interface
Kevin Rocard153f92d2018-12-18 18:33:28 -0800223 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override;
224 void releaseBuffer(AudioBufferProvider::Buffer* buffer) override;
Eric Laurent81784c32012-11-19 14:55:58 -0800225
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700226 // ExtendedAudioBufferProvider interface
Andy Hungd29af632023-06-23 19:27:19 -0700227 size_t framesReady() const override;
228 int64_t framesReleased() const override;
229 void onTimestamp(const ExtendedTimestamp &timestamp) override;
Eric Laurent81784c32012-11-19 14:55:58 -0800230
Glenn Kastenc9b2e202013-02-26 11:32:32 -0800231 bool isPausing() const { return mState == PAUSING; }
232 bool isPaused() const { return mState == PAUSED; }
233 bool isResuming() const { return mState == RESUMING; }
Eric Laurent81784c32012-11-19 14:55:58 -0800234 bool isReady() const;
235 void setPaused() { mState = PAUSED; }
236 void reset();
Haynes Mathew George7844f672014-01-15 12:32:55 -0800237 bool isFlushPending() const { return mFlushHwPending; }
238 void flushAck();
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -0800239 bool isResumePending();
240 void resumeAck();
Kuowei Li23666472021-01-20 10:23:25 +0800241 // For direct or offloaded tracks ensure that the pause state is acknowledged
242 // by the playback thread in case of an immediate flush.
243 bool isPausePending() const { return mPauseHwPending; }
244 void pauseAck();
Andy Hung818e7a32016-02-16 18:08:07 -0800245 void updateTrackFrameInfo(int64_t trackFramesReleased, int64_t sinkFramesWritten,
Andy Hungcef2daa2018-06-01 15:31:49 -0700246 uint32_t halSampleRate, const ExtendedTimestamp &timeStamp);
Eric Laurent81784c32012-11-19 14:55:58 -0800247
Eric Laurent81784c32012-11-19 14:55:58 -0800248 sp<IMemory> sharedBuffer() const { return mSharedBuffer; }
249
Andy Hung59de4262021-06-14 10:53:54 -0700250 // presentationComplete checked by frames. (Mixed Tracks).
Eric Laurent81784c32012-11-19 14:55:58 -0800251 // framesWritten is cumulative, never reset, and is shared all tracks
252 // audioHalFrames is derived from output latency
Andy Hung818e7a32016-02-16 18:08:07 -0800253 bool presentationComplete(int64_t framesWritten, size_t audioHalFrames);
Andy Hung59de4262021-06-14 10:53:54 -0700254
255 // presentationComplete checked by time. (Direct Tracks).
256 bool presentationComplete(uint32_t latencyMs);
257
258 void resetPresentationComplete() {
259 mPresentationCompleteFrames = 0;
260 mPresentationCompleteTimeNs = 0;
261 }
262
263 // notifyPresentationComplete is called when presentationComplete() detects
264 // that the track is finished stopping.
265 void notifyPresentationComplete();
266
Eric Laurent4d231dc2016-03-11 18:38:23 -0800267 void signalClientFlag(int32_t flag);
Eric Laurent81784c32012-11-19 14:55:58 -0800268
269public:
Andy Hungd29af632023-06-23 19:27:19 -0700270 void triggerEvents(AudioSystem::sync_event_t type) final;
271 void invalidate() final;
272 void disable() final;
273 int& fastIndex() final { return mFastIndex; }
274 bool isPlaybackRestricted() const final {
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700275 // The monitor is only created for tracks that can be silenced.
276 return mOpPlayAudioMonitor ? !mOpPlayAudioMonitor->hasOpPlayAudio() : false; }
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800277
Eric Laurent81784c32012-11-19 14:55:58 -0800278protected:
279
Eric Laurent81784c32012-11-19 14:55:58 -0800280 // FILLED state is used for suppressing volume ramp at begin of playing
281 enum {FS_INVALID, FS_FILLING, FS_FILLED, FS_ACTIVE};
282 mutable uint8_t mFillingUpStatus;
283 int8_t mRetryCount;
Glenn Kasten0c72b242013-09-11 09:14:16 -0700284
285 // see comment at AudioFlinger::PlaybackThread::Track::~Track for why this can't be const
286 sp<IMemory> mSharedBuffer;
287
Eric Laurent81784c32012-11-19 14:55:58 -0800288 bool mResetDone;
289 const audio_stream_type_t mStreamType;
Andy Hung319587b2023-05-23 14:01:03 -0700290 float *mMainBuffer;
rago94a1ee82017-07-21 15:11:02 -0700291
Eric Laurent81784c32012-11-19 14:55:58 -0800292 int32_t *mAuxBuffer;
293 int mAuxEffectId;
294 bool mHasVolumeController;
Andy Hunge10393e2015-06-12 13:59:33 -0700295
296 // access these three variables only when holding thread lock.
Andy Hung818e7a32016-02-16 18:08:07 -0800297 LinearMap<int64_t> mFrameMap; // track frame to server frame mapping
298
299 ExtendedTimestamp mSinkTimestamp;
Andy Hunge10393e2015-06-12 13:59:33 -0700300
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700301 sp<media::VolumeHandler> mVolumeHandler; // handles multiple VolumeShaper configs and operations
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800302
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800303 sp<OpPlayAudioMonitor> mOpPlayAudioMonitor;
304
jiabin245cdd92018-12-07 17:55:15 -0800305 bool mHapticPlaybackEnabled = false; // indicates haptic playback enabled or not
jiabin77270b82018-12-18 15:41:29 -0800306 // intensity to play haptic data
jiabine70bc7f2020-06-30 22:07:55 -0700307 os::HapticScale mHapticIntensity = os::HapticScale::MUTE;
Lais Andradebc3f37a2021-07-02 00:13:19 +0100308 // max amplitude allowed for haptic data
309 float mHapticMaxAmplitude = NAN;
jiabin57303cc2018-12-18 15:45:57 -0800310 class AudioVibrationController : public os::BnExternalVibrationController {
311 public:
312 explicit AudioVibrationController(Track* track) : mTrack(track) {}
313 binder::Status mute(/*out*/ bool *ret) override;
314 binder::Status unmute(/*out*/ bool *ret) override;
315 private:
316 Track* const mTrack;
SPeak Shenc19aa9e2022-11-11 00:28:50 +0800317 bool setMute(bool muted);
jiabin57303cc2018-12-18 15:45:57 -0800318 };
319 sp<AudioVibrationController> mAudioVibrationController;
320 sp<os::ExternalVibration> mExternalVibration;
jiabin245cdd92018-12-07 17:55:15 -0800321
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800322 audio_dual_mono_mode_t mDualMonoMode = AUDIO_DUAL_MONO_MODE_OFF;
323 float mAudioDescriptionMixLevel = -std::numeric_limits<float>::infinity();
324 audio_playback_rate_t mPlaybackRateParameters = AUDIO_PLAYBACK_RATE_INITIALIZER;
325
Eric Laurent81784c32012-11-19 14:55:58 -0800326private:
Kevin Rocard153f92d2018-12-18 18:33:28 -0800327 void interceptBuffer(const AudioBufferProvider::Buffer& buffer);
jiabin7434e812023-06-27 18:22:35 +0000328 // Must hold thread lock to access tee patches
Kevin Rocardc43ea142019-01-31 18:17:37 -0800329 template <class F>
jiabin7434e812023-06-27 18:22:35 +0000330 void forEachTeePatchTrack_l(F f) {
Kevin Rocardc43ea142019-01-31 18:17:37 -0800331 for (auto& tp : mTeePatches) { f(tp.patchTrack); }
332 };
Kevin Rocard153f92d2018-12-18 18:33:28 -0800333
Andy Hung59de4262021-06-14 10:53:54 -0700334 size_t mPresentationCompleteFrames = 0; // (Used for Mixed tracks)
335 // The number of frames written to the
336 // audio HAL when this track is considered fully rendered.
337 // Zero means not monitoring.
338 int64_t mPresentationCompleteTimeNs = 0; // (Used for Direct tracks)
339 // The time when this track is considered fully rendered.
340 // Zero means not monitoring.
341
Eric Laurent81784c32012-11-19 14:55:58 -0800342 // The following fields are only for fast tracks, and should be in a subclass
343 int mFastIndex; // index within FastMixerState::mFastTracks[];
344 // either mFastIndex == -1 if not isFastTrack()
345 // or 0 < mFastIndex < FastMixerState::kMaxFast because
346 // index 0 is reserved for normal mixer's submix;
347 // index is allocated statically at track creation time
348 // but the slot is only used if track is active
349 FastTrackUnderruns mObservedUnderruns; // Most recently observed value of
350 // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns
Eric Laurent81784c32012-11-19 14:55:58 -0800351 volatile float mCachedVolume; // combined master volume and stream type volume;
352 // 'volatile' means accessed without lock or
353 // barrier, but is read/written atomically
Kevin Rocard12381092018-04-11 09:19:59 -0700354 float mFinalVolume; // combine master volume, stream type volume and track volume
jiabin76d94692022-12-15 21:51:21 +0000355 float mFinalVolumeLeft; // combine master volume, stream type volume and track
356 // volume
357 float mFinalVolumeRight; // combine master volume, stream type volume and track
358 // volume
Eric Laurent5bba2f62016-03-18 11:14:14 -0700359 sp<AudioTrackServerProxy> mAudioTrackServerProxy;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800360 bool mResumeToStopping; // track was paused in stopping state.
Haynes Mathew George7844f672014-01-15 12:32:55 -0800361 bool mFlushHwPending; // track requests for thread flush
Kuowei Li23666472021-01-20 10:23:25 +0800362 bool mPauseHwPending = false; // direct/offload track request for thread pause
Eric Laurent05067782016-06-01 18:27:28 -0700363 audio_output_flags_t mFlags;
Kevin Rocard153f92d2018-12-18 18:33:28 -0800364 TeePatches mTeePatches;
Jiabin Huangfb476842022-12-06 03:18:10 +0000365 std::optional<TeePatches> mTeePatchesToUpdate;
jiabinf042b9b2021-05-07 23:46:28 +0000366 const float mSpeed;
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200367 const bool mIsSpatialized;
jiabinc658e452022-10-21 20:52:21 +0000368 const bool mIsBitPerfect;
Vlad Popae8d99472022-06-30 16:02:48 +0200369
370 // TODO: replace PersistableBundle with own struct
371 // access these two variables only when holding player thread lock.
372 std::unique_ptr<os::PersistableBundle> mMuteEventExtras;
373 mute_state_t mMuteState;
Eric Laurent81784c32012-11-19 14:55:58 -0800374}; // end of Track
375
Eric Laurent81784c32012-11-19 14:55:58 -0800376
377// playback track, used by DuplicatingThread
Andy Hungd29af632023-06-23 19:27:19 -0700378class OutputTrack : public Track, public IAfOutputTrack {
Eric Laurent81784c32012-11-19 14:55:58 -0800379public:
380
381 class Buffer : public AudioBufferProvider::Buffer {
382 public:
Andy Hungc25b84a2015-01-14 19:04:10 -0800383 void *mBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -0800384 };
385
386 OutputTrack(PlaybackThread *thread,
387 DuplicatingThread *sourceThread,
388 uint32_t sampleRate,
389 audio_format_t format,
390 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800391 size_t frameCount,
Svet Ganov33761132021-05-13 22:51:08 +0000392 const AttributionSourceState& attributionSource);
Andy Hungd29af632023-06-23 19:27:19 -0700393 ~OutputTrack() override;
Eric Laurent81784c32012-11-19 14:55:58 -0800394
Andy Hungd29af632023-06-23 19:27:19 -0700395 status_t start(AudioSystem::sync_event_t event =
Eric Laurent81784c32012-11-19 14:55:58 -0800396 AudioSystem::SYNC_EVENT_NONE,
Andy Hungd29af632023-06-23 19:27:19 -0700397 audio_session_t triggerSession = AUDIO_SESSION_NONE) final;
398 void stop() final;
399 ssize_t write(void* data, uint32_t frames) final;
400 bool bufferQueueEmpty() const final { return mBufferQueue.size() == 0; }
401 bool isActive() const final { return mActive; }
Eric Laurent81784c32012-11-19 14:55:58 -0800402
Andy Hungd29af632023-06-23 19:27:19 -0700403 void copyMetadataTo(MetadataInserter& backInserter) const final;
Kevin Rocard12381092018-04-11 09:19:59 -0700404 /** Set the metadatas of the upstream tracks. Thread safe. */
Andy Hungd29af632023-06-23 19:27:19 -0700405 void setMetadatas(const SourceMetadatas& metadatas) final;
Andy Hung1c86ebe2018-05-29 20:29:08 -0700406 /** returns client timestamp to the upstream duplicating thread. */
Andy Hungd29af632023-06-23 19:27:19 -0700407 ExtendedTimestamp getClientProxyTimestamp() const final {
Andy Hung1c86ebe2018-05-29 20:29:08 -0700408 // server - kernel difference is not true latency when drained
409 // i.e. mServerProxy->isDrained().
410 ExtendedTimestamp timestamp;
411 (void) mClientProxy->getTimestamp(&timestamp);
412 // On success, the timestamp LOCATION_SERVER and LOCATION_KERNEL
413 // entries will be properly filled. If getTimestamp()
414 // is unsuccessful, then a default initialized timestamp
415 // (with mTimeNs[] filled with -1's) is returned.
416 return timestamp;
417 }
Kevin Rocard12381092018-04-11 09:19:59 -0700418private:
Eric Laurent81784c32012-11-19 14:55:58 -0800419 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer,
420 uint32_t waitTimeMs);
Eric Laurent19952e12023-04-20 10:08:29 +0200421 void queueBuffer(Buffer& inBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -0800422 void clearBufferQueue();
423
Eric Laurent4d231dc2016-03-11 18:38:23 -0800424 void restartIfDisabled();
425
Eric Laurent81784c32012-11-19 14:55:58 -0800426 // Maximum number of pending buffers allocated by OutputTrack::write()
427 static const uint8_t kMaxOverFlowBuffers = 10;
428
429 Vector < Buffer* > mBufferQueue;
430 AudioBufferProvider::Buffer mOutBuffer;
431 bool mActive;
Eric Laurent5bba2f62016-03-18 11:14:14 -0700432 DuplicatingThread* const mSourceThread; // for waitTimeMs() in write()
433 sp<AudioTrackClientProxy> mClientProxy;
Andy Hung1c86ebe2018-05-29 20:29:08 -0700434
Kevin Rocard12381092018-04-11 09:19:59 -0700435 /** Attributes of the source tracks.
436 *
437 * This member must be accessed with mTrackMetadatasMutex taken.
438 * There is one writer (duplicating thread) and one reader (downstream mixer).
439 *
440 * That means that the duplicating thread can block the downstream mixer
441 * thread and vice versa for the time of the copy.
442 * If this becomes an issue, the metadata could be stored in an atomic raw pointer,
443 * and a exchange with nullptr and delete can be used.
444 * Alternatively a read-copy-update might be implemented.
445 */
446 SourceMetadatas mTrackMetadatas;
447 /** Protects mTrackMetadatas against concurrent access. */
448 mutable std::mutex mTrackMetadatasMutex;
Eric Laurent81784c32012-11-19 14:55:58 -0800449}; // end of OutputTrack
Eric Laurent83b88082014-06-20 18:31:16 -0700450
451// playback track, used by PatchPanel
Andy Hungca9be052023-06-26 19:20:57 -0700452class PatchTrack : public Track, public PatchTrackBase, public IAfPatchTrack {
Eric Laurent83b88082014-06-20 18:31:16 -0700453public:
454
455 PatchTrack(PlaybackThread *playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -0700456 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -0700457 uint32_t sampleRate,
458 audio_channel_mask_t channelMask,
459 audio_format_t format,
460 size_t frameCount,
461 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700462 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -0800463 audio_output_flags_t flags,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +0100464 const Timeout& timeout = {},
465 size_t frameCountToBeReady = 1 /** Default behaviour is to start
466 * as soon as possible to have
467 * the lowest possible latency
468 * even if it might glitch. */);
Andy Hungd29af632023-06-23 19:27:19 -0700469 ~PatchTrack() override;
Eric Laurent83b88082014-06-20 18:31:16 -0700470
Andy Hungd29af632023-06-23 19:27:19 -0700471 size_t framesReady() const final;
Mikhail Naganovcaf59942019-09-25 14:05:29 -0700472
Andy Hungd29af632023-06-23 19:27:19 -0700473 status_t start(AudioSystem::sync_event_t event =
Eric Laurent4d231dc2016-03-11 18:38:23 -0800474 AudioSystem::SYNC_EVENT_NONE,
Andy Hungd29af632023-06-23 19:27:19 -0700475 audio_session_t triggerSession = AUDIO_SESSION_NONE) final;
Eric Laurent4d231dc2016-03-11 18:38:23 -0800476
Eric Laurent83b88082014-06-20 18:31:16 -0700477 // AudioBufferProvider interface
Andy Hungd29af632023-06-23 19:27:19 -0700478 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) final;
479 void releaseBuffer(AudioBufferProvider::Buffer* buffer) final;
Eric Laurent83b88082014-06-20 18:31:16 -0700480
481 // PatchProxyBufferProvider interface
Andy Hungd29af632023-06-23 19:27:19 -0700482 status_t obtainBuffer(Proxy::Buffer* buffer, const struct timespec* timeOut = nullptr) final;
483 void releaseBuffer(Proxy::Buffer* buffer) final;
Eric Laurent83b88082014-06-20 18:31:16 -0700484
Eric Laurent83b88082014-06-20 18:31:16 -0700485private:
Eric Laurent4d231dc2016-03-11 18:38:23 -0800486 void restartIfDisabled();
Eric Laurent83b88082014-06-20 18:31:16 -0700487}; // end of PatchTrack