blob: 6a2887deefa556da7feea7779e2d59ab041a9152 [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;
192 void setTeePatchesToUpdate_l(const void* teePatchesToUpdate) final {
Andy Hung8d31fd22023-06-26 19:20:57 -0700193 setTeePatchesToUpdate_l( // TODO(b/288339104) void*
194 *reinterpret_cast<const AudioFlinger::TeePatches*>(teePatchesToUpdate));
Andy Hungd29af632023-06-23 19:27:19 -0700195 }
Andy Hung8d31fd22023-06-26 19:20:57 -0700196 void setTeePatchesToUpdate_l(AudioFlinger::TeePatches teePatchesToUpdate);
Kevin Rocard153f92d2018-12-18 18:33:28 -0800197
Andy Hungd29af632023-06-23 19:27:19 -0700198 void tallyUnderrunFrames(size_t frames) final {
Andy Hungc2b11cb2020-04-22 09:04:01 -0700199 if (isOut()) { // we expect this from output tracks only
200 mAudioTrackServerProxy->tallyUnderrunFrames(frames);
201 // Fetch absolute numbers from AudioTrackShared as it counts
202 // contiguous underruns as a one -- we want a consistent number.
203 // TODO: isolate this counting into a class.
204 mTrackMetrics.logUnderruns(mAudioTrackServerProxy->getUnderrunCount(),
205 mAudioTrackServerProxy->getUnderrunFrames());
206 }
207 }
jiabinf042b9b2021-05-07 23:46:28 +0000208
Andy Hungd29af632023-06-23 19:27:19 -0700209 audio_output_flags_t getOutputFlags() const final { return mFlags; }
210 float getSpeed() const final { return mSpeed; }
211 bool isSpatialized() const final { return mIsSpatialized; }
212 bool isBitPerfect() const final { return mIsBitPerfect; }
Eric Laurent39095982021-08-24 18:29:27 +0200213
Vlad Popae8d99472022-06-30 16:02:48 +0200214 /**
215 * Updates the mute state and notifies the audio service. Call this only when holding player
216 * thread lock.
217 */
Andy Hungd29af632023-06-23 19:27:19 -0700218 void processMuteEvent_l(const sp<IAudioManager>& audioManager, mute_state_t muteState) final;
Vlad Popae8d99472022-06-30 16:02:48 +0200219
Eric Laurent81784c32012-11-19 14:55:58 -0800220protected:
221 // for numerous
222 friend class PlaybackThread;
223 friend class MixerThread;
224 friend class DirectOutputThread;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800225 friend class OffloadThread;
Eric Laurent81784c32012-11-19 14:55:58 -0800226
Mikhail Naganovbf493082017-04-17 17:37:12 -0700227 DISALLOW_COPY_AND_ASSIGN(Track);
Eric Laurent81784c32012-11-19 14:55:58 -0800228
229 // AudioBufferProvider interface
Kevin Rocard153f92d2018-12-18 18:33:28 -0800230 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override;
231 void releaseBuffer(AudioBufferProvider::Buffer* buffer) override;
Eric Laurent81784c32012-11-19 14:55:58 -0800232
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700233 // ExtendedAudioBufferProvider interface
Andy Hungd29af632023-06-23 19:27:19 -0700234 size_t framesReady() const override;
235 int64_t framesReleased() const override;
236 void onTimestamp(const ExtendedTimestamp &timestamp) override;
Eric Laurent81784c32012-11-19 14:55:58 -0800237
Andy Hung8d31fd22023-06-26 19:20:57 -0700238 // Used by thread
239 bool isPausing() const final { return mState == PAUSING; }
240 bool isPaused() const final { return mState == PAUSED; }
241 bool isResuming() const final { return mState == RESUMING; }
242 bool isReady() const final;
243 void setPaused() final { mState = PAUSED; }
244 void reset() final;
245 bool isFlushPending() const final { return mFlushHwPending; }
246 void flushAck() final;
247 bool isResumePending() const final;
248 void resumeAck() final;
Kuowei Li23666472021-01-20 10:23:25 +0800249 // For direct or offloaded tracks ensure that the pause state is acknowledged
250 // by the playback thread in case of an immediate flush.
Andy Hung8d31fd22023-06-26 19:20:57 -0700251 bool isPausePending() const final { return mPauseHwPending; }
252 void pauseAck() final;
Andy Hung818e7a32016-02-16 18:08:07 -0800253 void updateTrackFrameInfo(int64_t trackFramesReleased, int64_t sinkFramesWritten,
Andy Hung8d31fd22023-06-26 19:20:57 -0700254 uint32_t halSampleRate, const ExtendedTimestamp& timeStamp) final;
Eric Laurent81784c32012-11-19 14:55:58 -0800255
Andy Hung8d31fd22023-06-26 19:20:57 -0700256 sp<IMemory> sharedBuffer() const final { return mSharedBuffer; }
Eric Laurent81784c32012-11-19 14:55:58 -0800257
Andy Hung59de4262021-06-14 10:53:54 -0700258 // presentationComplete checked by frames. (Mixed Tracks).
Eric Laurent81784c32012-11-19 14:55:58 -0800259 // framesWritten is cumulative, never reset, and is shared all tracks
260 // audioHalFrames is derived from output latency
Andy Hung8d31fd22023-06-26 19:20:57 -0700261 bool presentationComplete(int64_t framesWritten, size_t audioHalFrames) final;
Andy Hung59de4262021-06-14 10:53:54 -0700262
263 // presentationComplete checked by time. (Direct Tracks).
Andy Hung8d31fd22023-06-26 19:20:57 -0700264 bool presentationComplete(uint32_t latencyMs) final;
Andy Hung59de4262021-06-14 10:53:54 -0700265
Andy Hung8d31fd22023-06-26 19:20:57 -0700266 void resetPresentationComplete() final {
Andy Hung59de4262021-06-14 10:53:54 -0700267 mPresentationCompleteFrames = 0;
268 mPresentationCompleteTimeNs = 0;
269 }
270
271 // notifyPresentationComplete is called when presentationComplete() detects
272 // that the track is finished stopping.
273 void notifyPresentationComplete();
274
Eric Laurent4d231dc2016-03-11 18:38:23 -0800275 void signalClientFlag(int32_t flag);
Eric Laurent81784c32012-11-19 14:55:58 -0800276
Andy Hungd29af632023-06-23 19:27:19 -0700277 void triggerEvents(AudioSystem::sync_event_t type) final;
278 void invalidate() final;
279 void disable() final;
280 int& fastIndex() final { return mFastIndex; }
281 bool isPlaybackRestricted() const final {
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700282 // The monitor is only created for tracks that can be silenced.
283 return mOpPlayAudioMonitor ? !mOpPlayAudioMonitor->hasOpPlayAudio() : false; }
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800284
Andy Hung8d31fd22023-06-26 19:20:57 -0700285 const sp<AudioTrackServerProxy>& audioTrackServerProxy() const final {
286 return mAudioTrackServerProxy;
287 }
288 bool hasVolumeController() const final { return mHasVolumeController; }
289 void setHasVolumeController(bool hasVolumeController) final {
290 mHasVolumeController = hasVolumeController;
291 }
292 void setCachedVolume(float volume) final {
293 mCachedVolume = volume;
294 }
295 void setResetDone(bool resetDone) final {
296 mResetDone = resetDone;
297 }
298 ExtendedAudioBufferProvider* asExtendedAudioBufferProvider() final {
299 return this;
300 }
301 VolumeProvider* asVolumeProvider() final {
302 return this;
303 }
Eric Laurent81784c32012-11-19 14:55:58 -0800304
Andy Hung8d31fd22023-06-26 19:20:57 -0700305 FillingStatus& fillingStatus() final { return mFillingStatus; }
306 int8_t& retryCount() final { return mRetryCount; }
307 FastTrackUnderruns& fastTrackUnderruns() final { return mObservedUnderruns; }
308
309protected:
310 mutable FillingStatus mFillingStatus;
Eric Laurent81784c32012-11-19 14:55:58 -0800311 int8_t mRetryCount;
Glenn Kasten0c72b242013-09-11 09:14:16 -0700312
Andy Hung87c693c2023-07-06 20:56:16 -0700313 // see comment at ~Track for why this can't be const
Glenn Kasten0c72b242013-09-11 09:14:16 -0700314 sp<IMemory> mSharedBuffer;
315
Eric Laurent81784c32012-11-19 14:55:58 -0800316 bool mResetDone;
317 const audio_stream_type_t mStreamType;
Andy Hung319587b2023-05-23 14:01:03 -0700318 float *mMainBuffer;
rago94a1ee82017-07-21 15:11:02 -0700319
Eric Laurent81784c32012-11-19 14:55:58 -0800320 int32_t *mAuxBuffer;
321 int mAuxEffectId;
322 bool mHasVolumeController;
Andy Hunge10393e2015-06-12 13:59:33 -0700323
324 // access these three variables only when holding thread lock.
Andy Hung818e7a32016-02-16 18:08:07 -0800325 LinearMap<int64_t> mFrameMap; // track frame to server frame mapping
326
327 ExtendedTimestamp mSinkTimestamp;
Andy Hunge10393e2015-06-12 13:59:33 -0700328
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700329 sp<media::VolumeHandler> mVolumeHandler; // handles multiple VolumeShaper configs and operations
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800330
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800331 sp<OpPlayAudioMonitor> mOpPlayAudioMonitor;
332
jiabin245cdd92018-12-07 17:55:15 -0800333 bool mHapticPlaybackEnabled = false; // indicates haptic playback enabled or not
jiabin77270b82018-12-18 15:41:29 -0800334 // intensity to play haptic data
jiabine70bc7f2020-06-30 22:07:55 -0700335 os::HapticScale mHapticIntensity = os::HapticScale::MUTE;
Lais Andradebc3f37a2021-07-02 00:13:19 +0100336 // max amplitude allowed for haptic data
337 float mHapticMaxAmplitude = NAN;
jiabin57303cc2018-12-18 15:45:57 -0800338 class AudioVibrationController : public os::BnExternalVibrationController {
339 public:
340 explicit AudioVibrationController(Track* track) : mTrack(track) {}
341 binder::Status mute(/*out*/ bool *ret) override;
342 binder::Status unmute(/*out*/ bool *ret) override;
343 private:
344 Track* const mTrack;
SPeak Shenc19aa9e2022-11-11 00:28:50 +0800345 bool setMute(bool muted);
jiabin57303cc2018-12-18 15:45:57 -0800346 };
347 sp<AudioVibrationController> mAudioVibrationController;
348 sp<os::ExternalVibration> mExternalVibration;
jiabin245cdd92018-12-07 17:55:15 -0800349
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800350 audio_dual_mono_mode_t mDualMonoMode = AUDIO_DUAL_MONO_MODE_OFF;
351 float mAudioDescriptionMixLevel = -std::numeric_limits<float>::infinity();
352 audio_playback_rate_t mPlaybackRateParameters = AUDIO_PLAYBACK_RATE_INITIALIZER;
353
Eric Laurent81784c32012-11-19 14:55:58 -0800354private:
Kevin Rocard153f92d2018-12-18 18:33:28 -0800355 void interceptBuffer(const AudioBufferProvider::Buffer& buffer);
jiabin7434e812023-06-27 18:22:35 +0000356 // Must hold thread lock to access tee patches
Kevin Rocardc43ea142019-01-31 18:17:37 -0800357 template <class F>
jiabin7434e812023-06-27 18:22:35 +0000358 void forEachTeePatchTrack_l(F f) {
Kevin Rocardc43ea142019-01-31 18:17:37 -0800359 for (auto& tp : mTeePatches) { f(tp.patchTrack); }
360 };
Kevin Rocard153f92d2018-12-18 18:33:28 -0800361
Andy Hung59de4262021-06-14 10:53:54 -0700362 size_t mPresentationCompleteFrames = 0; // (Used for Mixed tracks)
363 // The number of frames written to the
364 // audio HAL when this track is considered fully rendered.
365 // Zero means not monitoring.
366 int64_t mPresentationCompleteTimeNs = 0; // (Used for Direct tracks)
367 // The time when this track is considered fully rendered.
368 // Zero means not monitoring.
369
Eric Laurent81784c32012-11-19 14:55:58 -0800370 // The following fields are only for fast tracks, and should be in a subclass
371 int mFastIndex; // index within FastMixerState::mFastTracks[];
372 // either mFastIndex == -1 if not isFastTrack()
373 // or 0 < mFastIndex < FastMixerState::kMaxFast because
374 // index 0 is reserved for normal mixer's submix;
375 // index is allocated statically at track creation time
376 // but the slot is only used if track is active
377 FastTrackUnderruns mObservedUnderruns; // Most recently observed value of
378 // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns
Eric Laurent81784c32012-11-19 14:55:58 -0800379 volatile float mCachedVolume; // combined master volume and stream type volume;
380 // 'volatile' means accessed without lock or
381 // barrier, but is read/written atomically
Kevin Rocard12381092018-04-11 09:19:59 -0700382 float mFinalVolume; // combine master volume, stream type volume and track volume
jiabin76d94692022-12-15 21:51:21 +0000383 float mFinalVolumeLeft; // combine master volume, stream type volume and track
384 // volume
385 float mFinalVolumeRight; // combine master volume, stream type volume and track
386 // volume
Eric Laurent5bba2f62016-03-18 11:14:14 -0700387 sp<AudioTrackServerProxy> mAudioTrackServerProxy;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800388 bool mResumeToStopping; // track was paused in stopping state.
Haynes Mathew George7844f672014-01-15 12:32:55 -0800389 bool mFlushHwPending; // track requests for thread flush
Kuowei Li23666472021-01-20 10:23:25 +0800390 bool mPauseHwPending = false; // direct/offload track request for thread pause
Eric Laurent05067782016-06-01 18:27:28 -0700391 audio_output_flags_t mFlags;
Andy Hung8d31fd22023-06-26 19:20:57 -0700392 AudioFlinger::TeePatches mTeePatches;
393 std::optional<AudioFlinger::TeePatches> mTeePatchesToUpdate;
jiabinf042b9b2021-05-07 23:46:28 +0000394 const float mSpeed;
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200395 const bool mIsSpatialized;
jiabinc658e452022-10-21 20:52:21 +0000396 const bool mIsBitPerfect;
Vlad Popae8d99472022-06-30 16:02:48 +0200397
398 // TODO: replace PersistableBundle with own struct
399 // access these two variables only when holding player thread lock.
400 std::unique_ptr<os::PersistableBundle> mMuteEventExtras;
401 mute_state_t mMuteState;
Eric Laurent81784c32012-11-19 14:55:58 -0800402}; // end of Track
403
Eric Laurent81784c32012-11-19 14:55:58 -0800404
405// playback track, used by DuplicatingThread
Andy Hungd29af632023-06-23 19:27:19 -0700406class OutputTrack : public Track, public IAfOutputTrack {
Eric Laurent81784c32012-11-19 14:55:58 -0800407public:
408
409 class Buffer : public AudioBufferProvider::Buffer {
410 public:
Andy Hungc25b84a2015-01-14 19:04:10 -0800411 void *mBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -0800412 };
413
Andy Hung87c693c2023-07-06 20:56:16 -0700414 OutputTrack(IAfPlaybackThread* thread,
415 IAfDuplicatingThread* sourceThread,
Eric Laurent81784c32012-11-19 14:55:58 -0800416 uint32_t sampleRate,
417 audio_format_t format,
418 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800419 size_t frameCount,
Svet Ganov33761132021-05-13 22:51:08 +0000420 const AttributionSourceState& attributionSource);
Andy Hungd29af632023-06-23 19:27:19 -0700421 ~OutputTrack() override;
Eric Laurent81784c32012-11-19 14:55:58 -0800422
Andy Hungd29af632023-06-23 19:27:19 -0700423 status_t start(AudioSystem::sync_event_t event =
Eric Laurent81784c32012-11-19 14:55:58 -0800424 AudioSystem::SYNC_EVENT_NONE,
Andy Hungd29af632023-06-23 19:27:19 -0700425 audio_session_t triggerSession = AUDIO_SESSION_NONE) final;
426 void stop() final;
427 ssize_t write(void* data, uint32_t frames) final;
428 bool bufferQueueEmpty() const final { return mBufferQueue.size() == 0; }
429 bool isActive() const final { return mActive; }
Eric Laurent81784c32012-11-19 14:55:58 -0800430
Andy Hungd29af632023-06-23 19:27:19 -0700431 void copyMetadataTo(MetadataInserter& backInserter) const final;
Kevin Rocard12381092018-04-11 09:19:59 -0700432 /** Set the metadatas of the upstream tracks. Thread safe. */
Andy Hungd29af632023-06-23 19:27:19 -0700433 void setMetadatas(const SourceMetadatas& metadatas) final;
Andy Hung1c86ebe2018-05-29 20:29:08 -0700434 /** returns client timestamp to the upstream duplicating thread. */
Andy Hungd29af632023-06-23 19:27:19 -0700435 ExtendedTimestamp getClientProxyTimestamp() const final {
Andy Hung1c86ebe2018-05-29 20:29:08 -0700436 // server - kernel difference is not true latency when drained
437 // i.e. mServerProxy->isDrained().
438 ExtendedTimestamp timestamp;
439 (void) mClientProxy->getTimestamp(&timestamp);
440 // On success, the timestamp LOCATION_SERVER and LOCATION_KERNEL
441 // entries will be properly filled. If getTimestamp()
442 // is unsuccessful, then a default initialized timestamp
443 // (with mTimeNs[] filled with -1's) is returned.
444 return timestamp;
445 }
Kevin Rocard12381092018-04-11 09:19:59 -0700446private:
Eric Laurent81784c32012-11-19 14:55:58 -0800447 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer,
448 uint32_t waitTimeMs);
Eric Laurent19952e12023-04-20 10:08:29 +0200449 void queueBuffer(Buffer& inBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -0800450 void clearBufferQueue();
451
Eric Laurent4d231dc2016-03-11 18:38:23 -0800452 void restartIfDisabled();
453
Eric Laurent81784c32012-11-19 14:55:58 -0800454 // Maximum number of pending buffers allocated by OutputTrack::write()
455 static const uint8_t kMaxOverFlowBuffers = 10;
456
457 Vector < Buffer* > mBufferQueue;
458 AudioBufferProvider::Buffer mOutBuffer;
459 bool mActive;
Andy Hung87c693c2023-07-06 20:56:16 -0700460 IAfDuplicatingThread* const mSourceThread; // for waitTimeMs() in write()
Eric Laurent5bba2f62016-03-18 11:14:14 -0700461 sp<AudioTrackClientProxy> mClientProxy;
Andy Hung1c86ebe2018-05-29 20:29:08 -0700462
Kevin Rocard12381092018-04-11 09:19:59 -0700463 /** Attributes of the source tracks.
464 *
465 * This member must be accessed with mTrackMetadatasMutex taken.
466 * There is one writer (duplicating thread) and one reader (downstream mixer).
467 *
468 * That means that the duplicating thread can block the downstream mixer
469 * thread and vice versa for the time of the copy.
470 * If this becomes an issue, the metadata could be stored in an atomic raw pointer,
471 * and a exchange with nullptr and delete can be used.
472 * Alternatively a read-copy-update might be implemented.
473 */
474 SourceMetadatas mTrackMetadatas;
475 /** Protects mTrackMetadatas against concurrent access. */
476 mutable std::mutex mTrackMetadatasMutex;
Eric Laurent81784c32012-11-19 14:55:58 -0800477}; // end of OutputTrack
Eric Laurent83b88082014-06-20 18:31:16 -0700478
479// playback track, used by PatchPanel
Andy Hungca9be052023-06-26 19:20:57 -0700480class PatchTrack : public Track, public PatchTrackBase, public IAfPatchTrack {
Eric Laurent83b88082014-06-20 18:31:16 -0700481public:
Andy Hung87c693c2023-07-06 20:56:16 -0700482 PatchTrack(IAfPlaybackThread* playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -0700483 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -0700484 uint32_t sampleRate,
485 audio_channel_mask_t channelMask,
486 audio_format_t format,
487 size_t frameCount,
488 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700489 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -0800490 audio_output_flags_t flags,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +0100491 const Timeout& timeout = {},
492 size_t frameCountToBeReady = 1 /** Default behaviour is to start
493 * as soon as possible to have
494 * the lowest possible latency
495 * even if it might glitch. */);
Andy Hungd29af632023-06-23 19:27:19 -0700496 ~PatchTrack() override;
Eric Laurent83b88082014-06-20 18:31:16 -0700497
Andy Hungd29af632023-06-23 19:27:19 -0700498 size_t framesReady() const final;
Mikhail Naganovcaf59942019-09-25 14:05:29 -0700499
Andy Hungd29af632023-06-23 19:27:19 -0700500 status_t start(AudioSystem::sync_event_t event =
Eric Laurent4d231dc2016-03-11 18:38:23 -0800501 AudioSystem::SYNC_EVENT_NONE,
Andy Hungd29af632023-06-23 19:27:19 -0700502 audio_session_t triggerSession = AUDIO_SESSION_NONE) final;
Eric Laurent4d231dc2016-03-11 18:38:23 -0800503
Eric Laurent83b88082014-06-20 18:31:16 -0700504 // AudioBufferProvider interface
Andy Hungd29af632023-06-23 19:27:19 -0700505 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) final;
506 void releaseBuffer(AudioBufferProvider::Buffer* buffer) final;
Eric Laurent83b88082014-06-20 18:31:16 -0700507
508 // PatchProxyBufferProvider interface
Andy Hungd29af632023-06-23 19:27:19 -0700509 status_t obtainBuffer(Proxy::Buffer* buffer, const struct timespec* timeOut = nullptr) final;
510 void releaseBuffer(Proxy::Buffer* buffer) final;
Eric Laurent83b88082014-06-20 18:31:16 -0700511
Eric Laurent83b88082014-06-20 18:31:16 -0700512private:
Eric Laurent4d231dc2016-03-11 18:38:23 -0800513 void restartIfDisabled();
Eric Laurent83b88082014-06-20 18:31:16 -0700514}; // end of PatchTrack
Andy Hung8d31fd22023-06-26 19:20:57 -0700515
516} // namespace android