blob: 1d50621d18f6dd7797b172b76e2cadedb6042865 [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
Andy Hung8d31fd22023-06-26 19:20:57 -070018#pragma once
Lais Andradebc3f37a2021-07-02 00:13:19 +010019#include <math.h>
Vlad Popa9d7c6f82023-07-10 20:27:41 -070020#include <sys/types.h>
Lais Andradebc3f37a2021-07-02 00:13:19 +010021
Andy Hung8d31fd22023-06-26 19:20:57 -070022namespace android {
23
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080024// Checks and monitors OP_PLAY_AUDIO
25class OpPlayAudioMonitor : public RefBase {
Vlad Popa9d7c6f82023-07-10 20:27:41 -070026 friend class sp<OpPlayAudioMonitor>;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080027public:
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080028 ~OpPlayAudioMonitor() override;
29 bool hasOpPlayAudio() const;
30
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070031 static sp<OpPlayAudioMonitor> createIfNeeded(
Andy Hung87c693c2023-07-06 20:56:16 -070032 IAfThreadBase* thread,
Svet Ganov33761132021-05-13 22:51:08 +000033 const AttributionSourceState& attributionSource,
Philip P. Moltmannbda45752020-07-17 16:41:18 -070034 const audio_attributes_t& attr, int id,
35 audio_stream_type_t streamType);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070036
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080037private:
Andy Hung87c693c2023-07-06 20:56:16 -070038 OpPlayAudioMonitor(IAfThreadBase* thread,
Vlad Popa9d7c6f82023-07-10 20:27:41 -070039 const AttributionSourceState& attributionSource,
40 audio_usage_t usage, int id, uid_t uid);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070041 void onFirstRef() override;
Eric Laurent9066ad32019-05-20 14:40:10 -070042 static void getPackagesForUid(uid_t uid, Vector<String16>& packages);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070043
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080044 AppOpsManager mAppOpsManager;
45
46 class PlayAudioOpCallback : public BnAppOpsCallback {
47 public:
48 explicit PlayAudioOpCallback(const wp<OpPlayAudioMonitor>& monitor);
49 void opChanged(int32_t op, const String16& packageName) override;
50
51 private:
52 const wp<OpPlayAudioMonitor> mMonitor;
53 };
54
55 sp<PlayAudioOpCallback> mOpCallback;
56 // called by PlayAudioOpCallback when OP_PLAY_AUDIO is updated in AppOp callback
57 void checkPlayAudioForUsage();
58
Andy Hung87c693c2023-07-06 20:56:16 -070059 wp<IAfThreadBase> mThread;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080060 std::atomic_bool mHasOpPlayAudio;
Svet Ganov33761132021-05-13 22:51:08 +000061 const AttributionSourceState mAttributionSource;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080062 const int32_t mUsage; // on purpose not audio_usage_t because always checked in appOps as int32_t
63 const int mId; // for logging purposes only
Vlad Popa9d7c6f82023-07-10 20:27:41 -070064 const uid_t mUid;
65 const String16 mPackageName;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080066};
67
Eric Laurent81784c32012-11-19 14:55:58 -080068// playback track
Andy Hungd29af632023-06-23 19:27:19 -070069class Track : public TrackBase, public virtual IAfTrack, public VolumeProvider {
Eric Laurent81784c32012-11-19 14:55:58 -080070public:
Andy Hung87c693c2023-07-06 20:56:16 -070071 Track(IAfPlaybackThread* thread,
Eric Laurent81784c32012-11-19 14:55:58 -080072 const sp<Client>& client,
73 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -070074 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -080075 uint32_t sampleRate,
76 audio_format_t format,
77 audio_channel_mask_t channelMask,
78 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -070079 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -070080 size_t bufferSize,
Eric Laurent81784c32012-11-19 14:55:58 -080081 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -080082 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -070083 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +000084 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -070085 audio_output_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -080086 track_type type,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +010087 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE,
88 /** default behaviour is to start when there are as many frames
89 * ready as possible (aka. Buffer is full). */
jiabinf042b9b2021-05-07 23:46:28 +000090 size_t frameCountToBeReady = SIZE_MAX,
Eric Laurentb0a7bc92022-04-05 15:06:08 +020091 float speed = 1.0f,
jiabinc658e452022-10-21 20:52:21 +000092 bool isSpatialized = false,
93 bool isBitPerfect = false);
Andy Hungd29af632023-06-23 19:27:19 -070094 ~Track() override;
95 status_t initCheck() const final;
96 void appendDumpHeader(String8& result) const final;
97 void appendDump(String8& result, bool active) const final;
98 status_t start(AudioSystem::sync_event_t event = AudioSystem::SYNC_EVENT_NONE,
99 audio_session_t triggerSession = AUDIO_SESSION_NONE) override;
100 void stop() override;
101 void pause() final;
102 void flush() final;
103 void destroy() final;
104 uint32_t sampleRate() const final;
105 audio_stream_type_t streamType() const final {
Eric Laurent81784c32012-11-19 14:55:58 -0800106 return mStreamType;
107 }
Andy Hungd29af632023-06-23 19:27:19 -0700108 bool isOffloaded() const final
Eric Laurent05067782016-06-01 18:27:28 -0700109 { return (mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0; }
Andy Hungd29af632023-06-23 19:27:19 -0700110 bool isDirect() const final
Mikhail Naganov7c6ae982018-06-14 12:33:38 -0700111 { return (mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0; }
Andy Hungd29af632023-06-23 19:27:19 -0700112 bool isOffloadedOrDirect() const final { return (mFlags
Andy Hung10cbff12017-02-21 17:30:14 -0800113 & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD
114 | AUDIO_OUTPUT_FLAG_DIRECT)) != 0; }
Andy Hungd29af632023-06-23 19:27:19 -0700115 bool isStatic() const final { return mSharedBuffer.get() != nullptr; }
Andy Hung10cbff12017-02-21 17:30:14 -0800116
Andy Hungd29af632023-06-23 19:27:19 -0700117 status_t setParameters(const String8& keyValuePairs) final;
118 status_t selectPresentation(int presentationId, int programId) final;
119 status_t attachAuxEffect(int EffectId) final;
120 void setAuxBuffer(int EffectId, int32_t* buffer) final;
121 int32_t* auxBuffer() const final { return mAuxBuffer; }
122 void setMainBuffer(float* buffer) final { mMainBuffer = buffer; }
123 float* mainBuffer() const final { return mMainBuffer; }
124 int auxEffectId() const final { return mAuxEffectId; }
125 status_t getTimestamp(AudioTimestamp& timestamp) final;
126 void signal() final;
127 status_t getDualMonoMode(audio_dual_mono_mode_t* mode) const final;
128 status_t setDualMonoMode(audio_dual_mono_mode_t mode) final;
129 status_t getAudioDescriptionMixLevel(float* leveldB) const final;
130 status_t setAudioDescriptionMixLevel(float leveldB) final;
131 status_t getPlaybackRateParameters(audio_playback_rate_t* playbackRate) const final;
132 status_t setPlaybackRateParameters(const audio_playback_rate_t& playbackRate) final;
Eric Laurent81784c32012-11-19 14:55:58 -0800133
Andy Hungd29af632023-06-23 19:27:19 -0700134 // implement FastMixerState::VolumeProvider interface
135 gain_minifloat_packed_t getVolumeLR() const final;
Eric Laurent81784c32012-11-19 14:55:58 -0800136
Andy Hungd29af632023-06-23 19:27:19 -0700137 status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) final;
138 bool isFastTrack() const final { return (mFlags & AUDIO_OUTPUT_FLAG_FAST) != 0; }
139 double bufferLatencyMs() const final {
Andy Hungcef2daa2018-06-01 15:31:49 -0700140 return isStatic() ? 0. : TrackBase::bufferLatencyMs();
141 }
Andy Hungf6ab58d2018-05-25 12:50:39 -0700142
Andy Hungd29af632023-06-23 19:27:19 -0700143 // implement volume handling.
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700144 media::VolumeShaper::Status applyVolumeShaper(
145 const sp<media::VolumeShaper::Configuration>& configuration,
146 const sp<media::VolumeShaper::Operation>& operation);
Andy Hungd29af632023-06-23 19:27:19 -0700147 sp<media::VolumeShaper::State> getVolumeShaperState(int id) const final;
148 sp<media::VolumeHandler> getVolumeHandler() const final{ return mVolumeHandler; }
Kevin Rocard12381092018-04-11 09:19:59 -0700149 /** Set the computed normalized final volume of the track.
150 * !masterMute * masterVolume * streamVolume * averageLRVolume */
Andy Hungd29af632023-06-23 19:27:19 -0700151 void setFinalVolume(float volumeLeft, float volumeRight) final;
152 float getFinalVolume() const final { return mFinalVolume; }
153 void getFinalVolume(float* left, float* right) const final {
jiabin76d94692022-12-15 21:51:21 +0000154 *left = mFinalVolumeLeft;
155 *right = mFinalVolumeRight;
156 }
Kevin Rocard12381092018-04-11 09:19:59 -0700157
Eric Laurent94579172020-11-20 18:41:04 +0100158 using SourceMetadatas = std::vector<playback_track_metadata_v7_t>;
Kevin Rocard12381092018-04-11 09:19:59 -0700159 using MetadataInserter = std::back_insert_iterator<SourceMetadatas>;
160 /** Copy the track metadata in the provided iterator. Thread safe. */
Andy Hungd29af632023-06-23 19:27:19 -0700161 void copyMetadataTo(MetadataInserter& backInserter) const override;
162
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800163
jiabin245cdd92018-12-07 17:55:15 -0800164 /** Return haptic playback of the track is enabled or not, used in mixer. */
Andy Hungd29af632023-06-23 19:27:19 -0700165 bool getHapticPlaybackEnabled() const final { return mHapticPlaybackEnabled; }
jiabin245cdd92018-12-07 17:55:15 -0800166 /** Set haptic playback of the track is enabled or not, should be
167 * set after query or get callback from vibrator service */
Andy Hungd29af632023-06-23 19:27:19 -0700168 void setHapticPlaybackEnabled(bool hapticPlaybackEnabled) final {
jiabin245cdd92018-12-07 17:55:15 -0800169 mHapticPlaybackEnabled = hapticPlaybackEnabled;
170 }
jiabin77270b82018-12-18 15:41:29 -0800171 /** Return at what intensity to play haptics, used in mixer. */
Andy Hungd29af632023-06-23 19:27:19 -0700172 os::HapticScale getHapticIntensity() const final { return mHapticIntensity; }
Lais Andradebc3f37a2021-07-02 00:13:19 +0100173 /** Return the maximum amplitude allowed for haptics data, used in mixer. */
Andy Hungd29af632023-06-23 19:27:19 -0700174 float getHapticMaxAmplitude() const final { return mHapticMaxAmplitude; }
jiabin77270b82018-12-18 15:41:29 -0800175 /** Set intensity of haptic playback, should be set after querying vibrator service. */
Andy Hungd29af632023-06-23 19:27:19 -0700176 void setHapticIntensity(os::HapticScale hapticIntensity) final {
jiabine70bc7f2020-06-30 22:07:55 -0700177 if (os::isValidHapticScale(hapticIntensity)) {
jiabin77270b82018-12-18 15:41:29 -0800178 mHapticIntensity = hapticIntensity;
jiabine70bc7f2020-06-30 22:07:55 -0700179 setHapticPlaybackEnabled(mHapticIntensity != os::HapticScale::MUTE);
jiabin77270b82018-12-18 15:41:29 -0800180 }
181 }
Lais Andradebc3f37a2021-07-02 00:13:19 +0100182 /** Set maximum amplitude allowed for haptic data, should be set after querying
183 * vibrator service.
184 */
Andy Hungd29af632023-06-23 19:27:19 -0700185 void setHapticMaxAmplitude(float maxAmplitude) final {
Lais Andradebc3f37a2021-07-02 00:13:19 +0100186 mHapticMaxAmplitude = maxAmplitude;
187 }
Andy Hungd29af632023-06-23 19:27:19 -0700188 sp<os::ExternalVibration> getExternalVibration() const final { return mExternalVibration; }
jiabin245cdd92018-12-07 17:55:15 -0800189
Jiabin Huangfb476842022-12-06 03:18:10 +0000190 // This function should be called with holding thread lock.
Andy Hungd29af632023-06-23 19:27:19 -0700191 void updateTeePatches_l() final;
Andy Hung16ed0da2023-07-14 11:45:38 -0700192 void setTeePatchesToUpdate_l(TeePatches teePatchesToUpdate) final;
Kevin Rocard153f92d2018-12-18 18:33:28 -0800193
Andy Hungd29af632023-06-23 19:27:19 -0700194 void tallyUnderrunFrames(size_t frames) final {
Andy Hungc2b11cb2020-04-22 09:04:01 -0700195 if (isOut()) { // we expect this from output tracks only
196 mAudioTrackServerProxy->tallyUnderrunFrames(frames);
197 // Fetch absolute numbers from AudioTrackShared as it counts
198 // contiguous underruns as a one -- we want a consistent number.
199 // TODO: isolate this counting into a class.
200 mTrackMetrics.logUnderruns(mAudioTrackServerProxy->getUnderrunCount(),
201 mAudioTrackServerProxy->getUnderrunFrames());
202 }
203 }
jiabinf042b9b2021-05-07 23:46:28 +0000204
Andy Hungd29af632023-06-23 19:27:19 -0700205 audio_output_flags_t getOutputFlags() const final { return mFlags; }
206 float getSpeed() const final { return mSpeed; }
207 bool isSpatialized() const final { return mIsSpatialized; }
208 bool isBitPerfect() const final { return mIsBitPerfect; }
Eric Laurent39095982021-08-24 18:29:27 +0200209
Vlad Popae8d99472022-06-30 16:02:48 +0200210 /**
211 * Updates the mute state and notifies the audio service. Call this only when holding player
212 * thread lock.
213 */
Andy Hungd29af632023-06-23 19:27:19 -0700214 void processMuteEvent_l(const sp<IAudioManager>& audioManager, mute_state_t muteState) final;
Vlad Popae8d99472022-06-30 16:02:48 +0200215
Eric Laurent81784c32012-11-19 14:55:58 -0800216protected:
Eric Laurent81784c32012-11-19 14:55:58 -0800217
Mikhail Naganovbf493082017-04-17 17:37:12 -0700218 DISALLOW_COPY_AND_ASSIGN(Track);
Eric Laurent81784c32012-11-19 14:55:58 -0800219
220 // AudioBufferProvider interface
Kevin Rocard153f92d2018-12-18 18:33:28 -0800221 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override;
222 void releaseBuffer(AudioBufferProvider::Buffer* buffer) override;
Eric Laurent81784c32012-11-19 14:55:58 -0800223
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700224 // ExtendedAudioBufferProvider interface
Andy Hungd29af632023-06-23 19:27:19 -0700225 size_t framesReady() const override;
226 int64_t framesReleased() const override;
227 void onTimestamp(const ExtendedTimestamp &timestamp) override;
Eric Laurent81784c32012-11-19 14:55:58 -0800228
Andy Hung8d31fd22023-06-26 19:20:57 -0700229 // Used by thread
230 bool isPausing() const final { return mState == PAUSING; }
231 bool isPaused() const final { return mState == PAUSED; }
232 bool isResuming() const final { return mState == RESUMING; }
233 bool isReady() const final;
234 void setPaused() final { mState = PAUSED; }
235 void reset() final;
236 bool isFlushPending() const final { return mFlushHwPending; }
237 void flushAck() final;
238 bool isResumePending() const final;
239 void resumeAck() final;
Kuowei Li23666472021-01-20 10:23:25 +0800240 // For direct or offloaded tracks ensure that the pause state is acknowledged
241 // by the playback thread in case of an immediate flush.
Andy Hung8d31fd22023-06-26 19:20:57 -0700242 bool isPausePending() const final { return mPauseHwPending; }
243 void pauseAck() final;
Andy Hung818e7a32016-02-16 18:08:07 -0800244 void updateTrackFrameInfo(int64_t trackFramesReleased, int64_t sinkFramesWritten,
Andy Hung8d31fd22023-06-26 19:20:57 -0700245 uint32_t halSampleRate, const ExtendedTimestamp& timeStamp) final;
Eric Laurent81784c32012-11-19 14:55:58 -0800246
Andy Hung8d31fd22023-06-26 19:20:57 -0700247 sp<IMemory> sharedBuffer() const final { return mSharedBuffer; }
Eric Laurent81784c32012-11-19 14:55:58 -0800248
Andy Hung59de4262021-06-14 10:53:54 -0700249 // presentationComplete checked by frames. (Mixed Tracks).
Eric Laurent81784c32012-11-19 14:55:58 -0800250 // framesWritten is cumulative, never reset, and is shared all tracks
251 // audioHalFrames is derived from output latency
Andy Hung8d31fd22023-06-26 19:20:57 -0700252 bool presentationComplete(int64_t framesWritten, size_t audioHalFrames) final;
Andy Hung59de4262021-06-14 10:53:54 -0700253
254 // presentationComplete checked by time. (Direct Tracks).
Andy Hung8d31fd22023-06-26 19:20:57 -0700255 bool presentationComplete(uint32_t latencyMs) final;
Andy Hung59de4262021-06-14 10:53:54 -0700256
Andy Hung8d31fd22023-06-26 19:20:57 -0700257 void resetPresentationComplete() final {
Andy Hung59de4262021-06-14 10:53:54 -0700258 mPresentationCompleteFrames = 0;
259 mPresentationCompleteTimeNs = 0;
260 }
261
262 // notifyPresentationComplete is called when presentationComplete() detects
263 // that the track is finished stopping.
264 void notifyPresentationComplete();
265
Eric Laurent4d231dc2016-03-11 18:38:23 -0800266 void signalClientFlag(int32_t flag);
Eric Laurent81784c32012-11-19 14:55:58 -0800267
Andy Hungd29af632023-06-23 19:27:19 -0700268 void triggerEvents(AudioSystem::sync_event_t type) final;
269 void invalidate() final;
270 void disable() final;
271 int& fastIndex() final { return mFastIndex; }
272 bool isPlaybackRestricted() const final {
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700273 // The monitor is only created for tracks that can be silenced.
274 return mOpPlayAudioMonitor ? !mOpPlayAudioMonitor->hasOpPlayAudio() : false; }
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800275
Andy Hung8d31fd22023-06-26 19:20:57 -0700276 const sp<AudioTrackServerProxy>& audioTrackServerProxy() const final {
277 return mAudioTrackServerProxy;
278 }
279 bool hasVolumeController() const final { return mHasVolumeController; }
280 void setHasVolumeController(bool hasVolumeController) final {
281 mHasVolumeController = hasVolumeController;
282 }
283 void setCachedVolume(float volume) final {
284 mCachedVolume = volume;
285 }
286 void setResetDone(bool resetDone) final {
287 mResetDone = resetDone;
288 }
289 ExtendedAudioBufferProvider* asExtendedAudioBufferProvider() final {
290 return this;
291 }
292 VolumeProvider* asVolumeProvider() final {
293 return this;
294 }
Eric Laurent81784c32012-11-19 14:55:58 -0800295
Andy Hung8d31fd22023-06-26 19:20:57 -0700296 FillingStatus& fillingStatus() final { return mFillingStatus; }
297 int8_t& retryCount() final { return mRetryCount; }
298 FastTrackUnderruns& fastTrackUnderruns() final { return mObservedUnderruns; }
299
300protected:
301 mutable FillingStatus mFillingStatus;
Eric Laurent81784c32012-11-19 14:55:58 -0800302 int8_t mRetryCount;
Glenn Kasten0c72b242013-09-11 09:14:16 -0700303
Andy Hung87c693c2023-07-06 20:56:16 -0700304 // see comment at ~Track for why this can't be const
Glenn Kasten0c72b242013-09-11 09:14:16 -0700305 sp<IMemory> mSharedBuffer;
306
Eric Laurent81784c32012-11-19 14:55:58 -0800307 bool mResetDone;
308 const audio_stream_type_t mStreamType;
Andy Hung319587b2023-05-23 14:01:03 -0700309 float *mMainBuffer;
rago94a1ee82017-07-21 15:11:02 -0700310
Eric Laurent81784c32012-11-19 14:55:58 -0800311 int32_t *mAuxBuffer;
312 int mAuxEffectId;
313 bool mHasVolumeController;
Andy Hunge10393e2015-06-12 13:59:33 -0700314
315 // access these three variables only when holding thread lock.
Andy Hung818e7a32016-02-16 18:08:07 -0800316 LinearMap<int64_t> mFrameMap; // track frame to server frame mapping
317
318 ExtendedTimestamp mSinkTimestamp;
Andy Hunge10393e2015-06-12 13:59:33 -0700319
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700320 sp<media::VolumeHandler> mVolumeHandler; // handles multiple VolumeShaper configs and operations
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800321
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800322 sp<OpPlayAudioMonitor> mOpPlayAudioMonitor;
323
jiabin245cdd92018-12-07 17:55:15 -0800324 bool mHapticPlaybackEnabled = false; // indicates haptic playback enabled or not
jiabin77270b82018-12-18 15:41:29 -0800325 // intensity to play haptic data
jiabine70bc7f2020-06-30 22:07:55 -0700326 os::HapticScale mHapticIntensity = os::HapticScale::MUTE;
Lais Andradebc3f37a2021-07-02 00:13:19 +0100327 // max amplitude allowed for haptic data
328 float mHapticMaxAmplitude = NAN;
jiabin57303cc2018-12-18 15:45:57 -0800329 class AudioVibrationController : public os::BnExternalVibrationController {
330 public:
331 explicit AudioVibrationController(Track* track) : mTrack(track) {}
332 binder::Status mute(/*out*/ bool *ret) override;
333 binder::Status unmute(/*out*/ bool *ret) override;
334 private:
335 Track* const mTrack;
SPeak Shenc19aa9e2022-11-11 00:28:50 +0800336 bool setMute(bool muted);
jiabin57303cc2018-12-18 15:45:57 -0800337 };
338 sp<AudioVibrationController> mAudioVibrationController;
339 sp<os::ExternalVibration> mExternalVibration;
jiabin245cdd92018-12-07 17:55:15 -0800340
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800341 audio_dual_mono_mode_t mDualMonoMode = AUDIO_DUAL_MONO_MODE_OFF;
342 float mAudioDescriptionMixLevel = -std::numeric_limits<float>::infinity();
343 audio_playback_rate_t mPlaybackRateParameters = AUDIO_PLAYBACK_RATE_INITIALIZER;
344
Eric Laurent81784c32012-11-19 14:55:58 -0800345private:
Kevin Rocard153f92d2018-12-18 18:33:28 -0800346 void interceptBuffer(const AudioBufferProvider::Buffer& buffer);
jiabin7434e812023-06-27 18:22:35 +0000347 // Must hold thread lock to access tee patches
Kevin Rocardc43ea142019-01-31 18:17:37 -0800348 template <class F>
jiabin7434e812023-06-27 18:22:35 +0000349 void forEachTeePatchTrack_l(F f) {
Kevin Rocardc43ea142019-01-31 18:17:37 -0800350 for (auto& tp : mTeePatches) { f(tp.patchTrack); }
351 };
Kevin Rocard153f92d2018-12-18 18:33:28 -0800352
Andy Hung59de4262021-06-14 10:53:54 -0700353 size_t mPresentationCompleteFrames = 0; // (Used for Mixed tracks)
354 // The number of frames written to the
355 // audio HAL when this track is considered fully rendered.
356 // Zero means not monitoring.
357 int64_t mPresentationCompleteTimeNs = 0; // (Used for Direct tracks)
358 // The time when this track is considered fully rendered.
359 // Zero means not monitoring.
360
Eric Laurent81784c32012-11-19 14:55:58 -0800361 // The following fields are only for fast tracks, and should be in a subclass
362 int mFastIndex; // index within FastMixerState::mFastTracks[];
363 // either mFastIndex == -1 if not isFastTrack()
364 // or 0 < mFastIndex < FastMixerState::kMaxFast because
365 // index 0 is reserved for normal mixer's submix;
366 // index is allocated statically at track creation time
367 // but the slot is only used if track is active
368 FastTrackUnderruns mObservedUnderruns; // Most recently observed value of
369 // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns
Eric Laurent81784c32012-11-19 14:55:58 -0800370 volatile float mCachedVolume; // combined master volume and stream type volume;
371 // 'volatile' means accessed without lock or
372 // barrier, but is read/written atomically
Kevin Rocard12381092018-04-11 09:19:59 -0700373 float mFinalVolume; // combine master volume, stream type volume and track volume
jiabin76d94692022-12-15 21:51:21 +0000374 float mFinalVolumeLeft; // combine master volume, stream type volume and track
375 // volume
376 float mFinalVolumeRight; // combine master volume, stream type volume and track
377 // volume
Eric Laurent5bba2f62016-03-18 11:14:14 -0700378 sp<AudioTrackServerProxy> mAudioTrackServerProxy;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800379 bool mResumeToStopping; // track was paused in stopping state.
Haynes Mathew George7844f672014-01-15 12:32:55 -0800380 bool mFlushHwPending; // track requests for thread flush
Kuowei Li23666472021-01-20 10:23:25 +0800381 bool mPauseHwPending = false; // direct/offload track request for thread pause
Eric Laurent05067782016-06-01 18:27:28 -0700382 audio_output_flags_t mFlags;
Andy Hung16ed0da2023-07-14 11:45:38 -0700383 TeePatches mTeePatches;
384 std::optional<TeePatches> mTeePatchesToUpdate;
jiabinf042b9b2021-05-07 23:46:28 +0000385 const float mSpeed;
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200386 const bool mIsSpatialized;
jiabinc658e452022-10-21 20:52:21 +0000387 const bool mIsBitPerfect;
Vlad Popae8d99472022-06-30 16:02:48 +0200388
389 // TODO: replace PersistableBundle with own struct
390 // access these two variables only when holding player thread lock.
391 std::unique_ptr<os::PersistableBundle> mMuteEventExtras;
392 mute_state_t mMuteState;
Eric Laurent81784c32012-11-19 14:55:58 -0800393}; // end of Track
394
Eric Laurent81784c32012-11-19 14:55:58 -0800395
396// playback track, used by DuplicatingThread
Andy Hungd29af632023-06-23 19:27:19 -0700397class OutputTrack : public Track, public IAfOutputTrack {
Eric Laurent81784c32012-11-19 14:55:58 -0800398public:
399
400 class Buffer : public AudioBufferProvider::Buffer {
401 public:
Andy Hungc25b84a2015-01-14 19:04:10 -0800402 void *mBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -0800403 };
404
Andy Hung87c693c2023-07-06 20:56:16 -0700405 OutputTrack(IAfPlaybackThread* thread,
406 IAfDuplicatingThread* sourceThread,
Eric Laurent81784c32012-11-19 14:55:58 -0800407 uint32_t sampleRate,
408 audio_format_t format,
409 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800410 size_t frameCount,
Svet Ganov33761132021-05-13 22:51:08 +0000411 const AttributionSourceState& attributionSource);
Andy Hungd29af632023-06-23 19:27:19 -0700412 ~OutputTrack() override;
Eric Laurent81784c32012-11-19 14:55:58 -0800413
Andy Hungd29af632023-06-23 19:27:19 -0700414 status_t start(AudioSystem::sync_event_t event =
Eric Laurent81784c32012-11-19 14:55:58 -0800415 AudioSystem::SYNC_EVENT_NONE,
Andy Hungd29af632023-06-23 19:27:19 -0700416 audio_session_t triggerSession = AUDIO_SESSION_NONE) final;
417 void stop() final;
418 ssize_t write(void* data, uint32_t frames) final;
419 bool bufferQueueEmpty() const final { return mBufferQueue.size() == 0; }
420 bool isActive() const final { return mActive; }
Eric Laurent81784c32012-11-19 14:55:58 -0800421
Andy Hungd29af632023-06-23 19:27:19 -0700422 void copyMetadataTo(MetadataInserter& backInserter) const final;
Kevin Rocard12381092018-04-11 09:19:59 -0700423 /** Set the metadatas of the upstream tracks. Thread safe. */
Andy Hungd29af632023-06-23 19:27:19 -0700424 void setMetadatas(const SourceMetadatas& metadatas) final;
Andy Hung1c86ebe2018-05-29 20:29:08 -0700425 /** returns client timestamp to the upstream duplicating thread. */
Andy Hungd29af632023-06-23 19:27:19 -0700426 ExtendedTimestamp getClientProxyTimestamp() const final {
Andy Hung1c86ebe2018-05-29 20:29:08 -0700427 // server - kernel difference is not true latency when drained
428 // i.e. mServerProxy->isDrained().
429 ExtendedTimestamp timestamp;
430 (void) mClientProxy->getTimestamp(&timestamp);
431 // On success, the timestamp LOCATION_SERVER and LOCATION_KERNEL
432 // entries will be properly filled. If getTimestamp()
433 // is unsuccessful, then a default initialized timestamp
434 // (with mTimeNs[] filled with -1's) is returned.
435 return timestamp;
436 }
Kevin Rocard12381092018-04-11 09:19:59 -0700437private:
Eric Laurent81784c32012-11-19 14:55:58 -0800438 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer,
439 uint32_t waitTimeMs);
Eric Laurent19952e12023-04-20 10:08:29 +0200440 void queueBuffer(Buffer& inBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -0800441 void clearBufferQueue();
442
Eric Laurent4d231dc2016-03-11 18:38:23 -0800443 void restartIfDisabled();
444
Eric Laurent81784c32012-11-19 14:55:58 -0800445 // Maximum number of pending buffers allocated by OutputTrack::write()
446 static const uint8_t kMaxOverFlowBuffers = 10;
447
448 Vector < Buffer* > mBufferQueue;
449 AudioBufferProvider::Buffer mOutBuffer;
450 bool mActive;
Andy Hung87c693c2023-07-06 20:56:16 -0700451 IAfDuplicatingThread* const mSourceThread; // for waitTimeMs() in write()
Eric Laurent5bba2f62016-03-18 11:14:14 -0700452 sp<AudioTrackClientProxy> mClientProxy;
Andy Hung1c86ebe2018-05-29 20:29:08 -0700453
Kevin Rocard12381092018-04-11 09:19:59 -0700454 /** Attributes of the source tracks.
455 *
456 * This member must be accessed with mTrackMetadatasMutex taken.
457 * There is one writer (duplicating thread) and one reader (downstream mixer).
458 *
459 * That means that the duplicating thread can block the downstream mixer
460 * thread and vice versa for the time of the copy.
461 * If this becomes an issue, the metadata could be stored in an atomic raw pointer,
462 * and a exchange with nullptr and delete can be used.
463 * Alternatively a read-copy-update might be implemented.
464 */
465 SourceMetadatas mTrackMetadatas;
466 /** Protects mTrackMetadatas against concurrent access. */
467 mutable std::mutex mTrackMetadatasMutex;
Eric Laurent81784c32012-11-19 14:55:58 -0800468}; // end of OutputTrack
Eric Laurent83b88082014-06-20 18:31:16 -0700469
470// playback track, used by PatchPanel
Andy Hungca9be052023-06-26 19:20:57 -0700471class PatchTrack : public Track, public PatchTrackBase, public IAfPatchTrack {
Eric Laurent83b88082014-06-20 18:31:16 -0700472public:
Andy Hung87c693c2023-07-06 20:56:16 -0700473 PatchTrack(IAfPlaybackThread* playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -0700474 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -0700475 uint32_t sampleRate,
476 audio_channel_mask_t channelMask,
477 audio_format_t format,
478 size_t frameCount,
479 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700480 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -0800481 audio_output_flags_t flags,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +0100482 const Timeout& timeout = {},
483 size_t frameCountToBeReady = 1 /** Default behaviour is to start
484 * as soon as possible to have
485 * the lowest possible latency
486 * even if it might glitch. */);
Andy Hungd29af632023-06-23 19:27:19 -0700487 ~PatchTrack() override;
Eric Laurent83b88082014-06-20 18:31:16 -0700488
Andy Hungd29af632023-06-23 19:27:19 -0700489 size_t framesReady() const final;
Mikhail Naganovcaf59942019-09-25 14:05:29 -0700490
Andy Hungd29af632023-06-23 19:27:19 -0700491 status_t start(AudioSystem::sync_event_t event =
Eric Laurent4d231dc2016-03-11 18:38:23 -0800492 AudioSystem::SYNC_EVENT_NONE,
Andy Hungd29af632023-06-23 19:27:19 -0700493 audio_session_t triggerSession = AUDIO_SESSION_NONE) final;
Eric Laurent4d231dc2016-03-11 18:38:23 -0800494
Eric Laurent83b88082014-06-20 18:31:16 -0700495 // AudioBufferProvider interface
Andy Hungd29af632023-06-23 19:27:19 -0700496 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) final;
497 void releaseBuffer(AudioBufferProvider::Buffer* buffer) final;
Eric Laurent83b88082014-06-20 18:31:16 -0700498
499 // PatchProxyBufferProvider interface
Andy Hungd29af632023-06-23 19:27:19 -0700500 status_t obtainBuffer(Proxy::Buffer* buffer, const struct timespec* timeOut = nullptr) final;
501 void releaseBuffer(Proxy::Buffer* buffer) final;
Eric Laurent83b88082014-06-20 18:31:16 -0700502
Eric Laurent83b88082014-06-20 18:31:16 -0700503private:
Eric Laurent4d231dc2016-03-11 18:38:23 -0800504 void restartIfDisabled();
Eric Laurent83b88082014-06-20 18:31:16 -0700505}; // end of PatchTrack
Andy Hung8d31fd22023-06-26 19:20:57 -0700506
507} // namespace android