blob: 89ee5c0909d7f9c0a984227e84a6b63d7b56d3f3 [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
Andy Hung0f725b42023-07-19 11:40:07 -070019
20#include "TrackBase.h"
21
22#include <android/os/BnExternalVibrationController.h>
Andy Hung0169fbc2023-08-28 19:12:14 -070023#include <audio_utils/mutex.h>
Andy Hung0f725b42023-07-19 11:40:07 -070024#include <audio_utils/LinearMap.h>
25#include <binder/AppOpsManager.h>
Jiabin Huang73f97052023-12-12 20:08:03 +000026#include <utils/RWLock.h>
Lais Andradebc3f37a2021-07-02 00:13:19 +010027
Andy Hung8d31fd22023-06-26 19:20:57 -070028namespace android {
29
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080030// Checks and monitors OP_PLAY_AUDIO
31class OpPlayAudioMonitor : public RefBase {
Vlad Popa9d7c6f82023-07-10 20:27:41 -070032 friend class sp<OpPlayAudioMonitor>;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080033public:
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080034 ~OpPlayAudioMonitor() override;
35 bool hasOpPlayAudio() const;
36
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070037 static sp<OpPlayAudioMonitor> createIfNeeded(
Andy Hung87c693c2023-07-06 20:56:16 -070038 IAfThreadBase* thread,
Svet Ganov33761132021-05-13 22:51:08 +000039 const AttributionSourceState& attributionSource,
Philip P. Moltmannbda45752020-07-17 16:41:18 -070040 const audio_attributes_t& attr, int id,
41 audio_stream_type_t streamType);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070042
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080043private:
Andy Hung87c693c2023-07-06 20:56:16 -070044 OpPlayAudioMonitor(IAfThreadBase* thread,
Vlad Popa9d7c6f82023-07-10 20:27:41 -070045 const AttributionSourceState& attributionSource,
46 audio_usage_t usage, int id, uid_t uid);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070047 void onFirstRef() override;
Eric Laurent9066ad32019-05-20 14:40:10 -070048 static void getPackagesForUid(uid_t uid, Vector<String16>& packages);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070049
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080050 AppOpsManager mAppOpsManager;
51
52 class PlayAudioOpCallback : public BnAppOpsCallback {
53 public:
54 explicit PlayAudioOpCallback(const wp<OpPlayAudioMonitor>& monitor);
55 void opChanged(int32_t op, const String16& packageName) override;
56
57 private:
58 const wp<OpPlayAudioMonitor> mMonitor;
59 };
60
61 sp<PlayAudioOpCallback> mOpCallback;
62 // called by PlayAudioOpCallback when OP_PLAY_AUDIO is updated in AppOp callback
Vlad Popad5859592023-08-02 18:36:04 -070063 void checkPlayAudioForUsage(bool doBroadcast);
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080064
Andy Hung87c693c2023-07-06 20:56:16 -070065 wp<IAfThreadBase> mThread;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080066 std::atomic_bool mHasOpPlayAudio;
Shunkai Yaoaf7990a2023-08-18 02:24:01 +000067 const int32_t mUsage; // on purpose not audio_usage_t because always checked in appOps as
68 // int32_t
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080069 const int mId; // for logging purposes only
Vlad Popa9d7c6f82023-07-10 20:27:41 -070070 const uid_t mUid;
71 const String16 mPackageName;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080072};
73
Eric Laurent81784c32012-11-19 14:55:58 -080074// playback track
Andy Hungd29af632023-06-23 19:27:19 -070075class Track : public TrackBase, public virtual IAfTrack, public VolumeProvider {
Eric Laurent81784c32012-11-19 14:55:58 -080076public:
Andy Hung87c693c2023-07-06 20:56:16 -070077 Track(IAfPlaybackThread* thread,
Eric Laurent81784c32012-11-19 14:55:58 -080078 const sp<Client>& client,
79 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -070080 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -080081 uint32_t sampleRate,
82 audio_format_t format,
83 audio_channel_mask_t channelMask,
84 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -070085 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -070086 size_t bufferSize,
Eric Laurent81784c32012-11-19 14:55:58 -080087 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -080088 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -070089 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +000090 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -070091 audio_output_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -080092 track_type type,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +010093 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE,
94 /** default behaviour is to start when there are as many frames
95 * ready as possible (aka. Buffer is full). */
jiabinf042b9b2021-05-07 23:46:28 +000096 size_t frameCountToBeReady = SIZE_MAX,
Eric Laurentb0a7bc92022-04-05 15:06:08 +020097 float speed = 1.0f,
jiabinc658e452022-10-21 20:52:21 +000098 bool isSpatialized = false,
99 bool isBitPerfect = false);
Andy Hungd29af632023-06-23 19:27:19 -0700100 ~Track() override;
101 status_t initCheck() const final;
102 void appendDumpHeader(String8& result) const final;
103 void appendDump(String8& result, bool active) const final;
104 status_t start(AudioSystem::sync_event_t event = AudioSystem::SYNC_EVENT_NONE,
105 audio_session_t triggerSession = AUDIO_SESSION_NONE) override;
106 void stop() override;
107 void pause() final;
108 void flush() final;
109 void destroy() final;
110 uint32_t sampleRate() const final;
111 audio_stream_type_t streamType() const final {
Eric Laurent81784c32012-11-19 14:55:58 -0800112 return mStreamType;
113 }
Andy Hungd29af632023-06-23 19:27:19 -0700114 bool isOffloaded() const final
Eric Laurent05067782016-06-01 18:27:28 -0700115 { return (mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0; }
Andy Hungd29af632023-06-23 19:27:19 -0700116 bool isDirect() const final
Mikhail Naganov7c6ae982018-06-14 12:33:38 -0700117 { return (mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0; }
Andy Hungd29af632023-06-23 19:27:19 -0700118 bool isOffloadedOrDirect() const final { return (mFlags
Andy Hung10cbff12017-02-21 17:30:14 -0800119 & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD
120 | AUDIO_OUTPUT_FLAG_DIRECT)) != 0; }
Andy Hungd29af632023-06-23 19:27:19 -0700121 bool isStatic() const final { return mSharedBuffer.get() != nullptr; }
Andy Hung10cbff12017-02-21 17:30:14 -0800122
Andy Hungd29af632023-06-23 19:27:19 -0700123 status_t setParameters(const String8& keyValuePairs) final;
124 status_t selectPresentation(int presentationId, int programId) final;
125 status_t attachAuxEffect(int EffectId) final;
126 void setAuxBuffer(int EffectId, int32_t* buffer) final;
127 int32_t* auxBuffer() const final { return mAuxBuffer; }
128 void setMainBuffer(float* buffer) final { mMainBuffer = buffer; }
129 float* mainBuffer() const final { return mMainBuffer; }
130 int auxEffectId() const final { return mAuxEffectId; }
131 status_t getTimestamp(AudioTimestamp& timestamp) final;
132 void signal() final;
133 status_t getDualMonoMode(audio_dual_mono_mode_t* mode) const final;
134 status_t setDualMonoMode(audio_dual_mono_mode_t mode) final;
135 status_t getAudioDescriptionMixLevel(float* leveldB) const final;
136 status_t setAudioDescriptionMixLevel(float leveldB) final;
137 status_t getPlaybackRateParameters(audio_playback_rate_t* playbackRate) const final;
138 status_t setPlaybackRateParameters(const audio_playback_rate_t& playbackRate) final;
Eric Laurent81784c32012-11-19 14:55:58 -0800139
Andy Hungd29af632023-06-23 19:27:19 -0700140 // implement FastMixerState::VolumeProvider interface
141 gain_minifloat_packed_t getVolumeLR() const final;
Eric Laurent81784c32012-11-19 14:55:58 -0800142
Andy Hungd29af632023-06-23 19:27:19 -0700143 status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) final;
144 bool isFastTrack() const final { return (mFlags & AUDIO_OUTPUT_FLAG_FAST) != 0; }
145 double bufferLatencyMs() const final {
Andy Hungcef2daa2018-06-01 15:31:49 -0700146 return isStatic() ? 0. : TrackBase::bufferLatencyMs();
147 }
Andy Hungf6ab58d2018-05-25 12:50:39 -0700148
Andy Hungd29af632023-06-23 19:27:19 -0700149 // implement volume handling.
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700150 media::VolumeShaper::Status applyVolumeShaper(
151 const sp<media::VolumeShaper::Configuration>& configuration,
152 const sp<media::VolumeShaper::Operation>& operation);
Andy Hungd29af632023-06-23 19:27:19 -0700153 sp<media::VolumeShaper::State> getVolumeShaperState(int id) const final;
154 sp<media::VolumeHandler> getVolumeHandler() const final{ return mVolumeHandler; }
Kevin Rocard12381092018-04-11 09:19:59 -0700155 /** Set the computed normalized final volume of the track.
156 * !masterMute * masterVolume * streamVolume * averageLRVolume */
Andy Hungd29af632023-06-23 19:27:19 -0700157 void setFinalVolume(float volumeLeft, float volumeRight) final;
158 float getFinalVolume() const final { return mFinalVolume; }
159 void getFinalVolume(float* left, float* right) const final {
jiabin76d94692022-12-15 21:51:21 +0000160 *left = mFinalVolumeLeft;
161 *right = mFinalVolumeRight;
162 }
Kevin Rocard12381092018-04-11 09:19:59 -0700163
Eric Laurent94579172020-11-20 18:41:04 +0100164 using SourceMetadatas = std::vector<playback_track_metadata_v7_t>;
Kevin Rocard12381092018-04-11 09:19:59 -0700165 using MetadataInserter = std::back_insert_iterator<SourceMetadatas>;
166 /** Copy the track metadata in the provided iterator. Thread safe. */
Andy Hungd29af632023-06-23 19:27:19 -0700167 void copyMetadataTo(MetadataInserter& backInserter) const override;
168
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800169
jiabin245cdd92018-12-07 17:55:15 -0800170 /** Return haptic playback of the track is enabled or not, used in mixer. */
Andy Hungd29af632023-06-23 19:27:19 -0700171 bool getHapticPlaybackEnabled() const final { return mHapticPlaybackEnabled; }
jiabin245cdd92018-12-07 17:55:15 -0800172 /** Set haptic playback of the track is enabled or not, should be
173 * set after query or get callback from vibrator service */
Andy Hungd29af632023-06-23 19:27:19 -0700174 void setHapticPlaybackEnabled(bool hapticPlaybackEnabled) final {
jiabin245cdd92018-12-07 17:55:15 -0800175 mHapticPlaybackEnabled = hapticPlaybackEnabled;
176 }
Ahmad Khalil229466a2024-02-05 12:15:30 +0000177 /** Return the haptics scale, used in mixer. */
178 os::HapticScale getHapticScale() const final { return mHapticScale; }
Lais Andradebc3f37a2021-07-02 00:13:19 +0100179 /** Return the maximum amplitude allowed for haptics data, used in mixer. */
Andy Hungd29af632023-06-23 19:27:19 -0700180 float getHapticMaxAmplitude() const final { return mHapticMaxAmplitude; }
jiabin77270b82018-12-18 15:41:29 -0800181 /** Set intensity of haptic playback, should be set after querying vibrator service. */
Ahmad Khalil229466a2024-02-05 12:15:30 +0000182 void setHapticScale(os::HapticScale hapticScale) final {
183 if (os::isValidHapticScale(hapticScale)) {
184 mHapticScale = hapticScale;
185 setHapticPlaybackEnabled(!mHapticScale.isScaleMute());
jiabin77270b82018-12-18 15:41:29 -0800186 }
187 }
Lais Andradebc3f37a2021-07-02 00:13:19 +0100188 /** Set maximum amplitude allowed for haptic data, should be set after querying
189 * vibrator service.
190 */
Andy Hungd29af632023-06-23 19:27:19 -0700191 void setHapticMaxAmplitude(float maxAmplitude) final {
Lais Andradebc3f37a2021-07-02 00:13:19 +0100192 mHapticMaxAmplitude = maxAmplitude;
193 }
Andy Hungd29af632023-06-23 19:27:19 -0700194 sp<os::ExternalVibration> getExternalVibration() const final { return mExternalVibration; }
jiabin245cdd92018-12-07 17:55:15 -0800195
Jiabin Huangfb476842022-12-06 03:18:10 +0000196 // This function should be called with holding thread lock.
Andy Hungf302e812024-01-26 11:55:15 -0800197 void updateTeePatches_l() final REQUIRES(audio_utils::ThreadBase_Mutex)
198 EXCLUDES_BELOW_ThreadBase_Mutex;
Andy Hung16ed0da2023-07-14 11:45:38 -0700199 void setTeePatchesToUpdate_l(TeePatches teePatchesToUpdate) final;
Kevin Rocard153f92d2018-12-18 18:33:28 -0800200
Andy Hungd29af632023-06-23 19:27:19 -0700201 void tallyUnderrunFrames(size_t frames) final {
Andy Hungc2b11cb2020-04-22 09:04:01 -0700202 if (isOut()) { // we expect this from output tracks only
203 mAudioTrackServerProxy->tallyUnderrunFrames(frames);
204 // Fetch absolute numbers from AudioTrackShared as it counts
205 // contiguous underruns as a one -- we want a consistent number.
206 // TODO: isolate this counting into a class.
207 mTrackMetrics.logUnderruns(mAudioTrackServerProxy->getUnderrunCount(),
208 mAudioTrackServerProxy->getUnderrunFrames());
209 }
210 }
jiabinf042b9b2021-05-07 23:46:28 +0000211
Andy Hungd29af632023-06-23 19:27:19 -0700212 audio_output_flags_t getOutputFlags() const final { return mFlags; }
213 float getSpeed() const final { return mSpeed; }
214 bool isSpatialized() const final { return mIsSpatialized; }
215 bool isBitPerfect() const final { return mIsBitPerfect; }
Eric Laurent39095982021-08-24 18:29:27 +0200216
Vlad Popae8d99472022-06-30 16:02:48 +0200217 /**
218 * Updates the mute state and notifies the audio service. Call this only when holding player
219 * thread lock.
220 */
Andy Hungd29af632023-06-23 19:27:19 -0700221 void processMuteEvent_l(const sp<IAudioManager>& audioManager, mute_state_t muteState) final;
Vlad Popae8d99472022-06-30 16:02:48 +0200222
Eric Laurent81784c32012-11-19 14:55:58 -0800223protected:
Eric Laurent81784c32012-11-19 14:55:58 -0800224
Mikhail Naganovbf493082017-04-17 17:37:12 -0700225 DISALLOW_COPY_AND_ASSIGN(Track);
Eric Laurent81784c32012-11-19 14:55:58 -0800226
227 // AudioBufferProvider interface
Kevin Rocard153f92d2018-12-18 18:33:28 -0800228 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override;
229 void releaseBuffer(AudioBufferProvider::Buffer* buffer) override;
Eric Laurent81784c32012-11-19 14:55:58 -0800230
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700231 // ExtendedAudioBufferProvider interface
Andy Hungd29af632023-06-23 19:27:19 -0700232 size_t framesReady() const override;
233 int64_t framesReleased() const override;
234 void onTimestamp(const ExtendedTimestamp &timestamp) override;
Eric Laurent81784c32012-11-19 14:55:58 -0800235
Andy Hung8d31fd22023-06-26 19:20:57 -0700236 // Used by thread
237 bool isPausing() const final { return mState == PAUSING; }
238 bool isPaused() const final { return mState == PAUSED; }
239 bool isResuming() const final { return mState == RESUMING; }
240 bool isReady() const final;
241 void setPaused() final { mState = PAUSED; }
242 void reset() final;
243 bool isFlushPending() const final { return mFlushHwPending; }
244 void flushAck() final;
245 bool isResumePending() const final;
246 void resumeAck() final;
Kuowei Li23666472021-01-20 10:23:25 +0800247 // For direct or offloaded tracks ensure that the pause state is acknowledged
248 // by the playback thread in case of an immediate flush.
Andy Hung8d31fd22023-06-26 19:20:57 -0700249 bool isPausePending() const final { return mPauseHwPending; }
250 void pauseAck() final;
Andy Hung818e7a32016-02-16 18:08:07 -0800251 void updateTrackFrameInfo(int64_t trackFramesReleased, int64_t sinkFramesWritten,
Andy Hung8d31fd22023-06-26 19:20:57 -0700252 uint32_t halSampleRate, const ExtendedTimestamp& timeStamp) final;
Eric Laurent81784c32012-11-19 14:55:58 -0800253
Andy Hung8d31fd22023-06-26 19:20:57 -0700254 sp<IMemory> sharedBuffer() const final { return mSharedBuffer; }
Eric Laurent81784c32012-11-19 14:55:58 -0800255
Andy Hung59de4262021-06-14 10:53:54 -0700256 // presentationComplete checked by frames. (Mixed Tracks).
Eric Laurent81784c32012-11-19 14:55:58 -0800257 // framesWritten is cumulative, never reset, and is shared all tracks
258 // audioHalFrames is derived from output latency
Andy Hung8d31fd22023-06-26 19:20:57 -0700259 bool presentationComplete(int64_t framesWritten, size_t audioHalFrames) final;
Andy Hung59de4262021-06-14 10:53:54 -0700260
261 // presentationComplete checked by time. (Direct Tracks).
Andy Hung8d31fd22023-06-26 19:20:57 -0700262 bool presentationComplete(uint32_t latencyMs) final;
Andy Hung59de4262021-06-14 10:53:54 -0700263
Andy Hung8d31fd22023-06-26 19:20:57 -0700264 void resetPresentationComplete() final {
Andy Hung59de4262021-06-14 10:53:54 -0700265 mPresentationCompleteFrames = 0;
266 mPresentationCompleteTimeNs = 0;
267 }
268
269 // notifyPresentationComplete is called when presentationComplete() detects
270 // that the track is finished stopping.
271 void notifyPresentationComplete();
272
Eric Laurent4d231dc2016-03-11 18:38:23 -0800273 void signalClientFlag(int32_t flag);
Eric Laurent81784c32012-11-19 14:55:58 -0800274
Andy Hungd29af632023-06-23 19:27:19 -0700275 void triggerEvents(AudioSystem::sync_event_t type) final;
276 void invalidate() final;
277 void disable() final;
Eric Laurent022a5132024-04-12 17:02:51 +0000278 bool isDisabled() const final;
279
Andy Hungd29af632023-06-23 19:27:19 -0700280 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
Ahmad Khalil229466a2024-02-05 12:15:30 +0000334 // scale to play haptic data
335 os::HapticScale mHapticScale = 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) {
Jiabin Huang73f97052023-12-12 20:08:03 +0000359 RWLock::AutoRLock readLock(mTeePatchesRWLock);
Kevin Rocardc43ea142019-01-31 18:17:37 -0800360 for (auto& tp : mTeePatches) { f(tp.patchTrack); }
361 };
Kevin Rocard153f92d2018-12-18 18:33:28 -0800362
Andy Hung59de4262021-06-14 10:53:54 -0700363 size_t mPresentationCompleteFrames = 0; // (Used for Mixed tracks)
364 // The number of frames written to the
365 // audio HAL when this track is considered fully rendered.
366 // Zero means not monitoring.
367 int64_t mPresentationCompleteTimeNs = 0; // (Used for Direct tracks)
368 // The time when this track is considered fully rendered.
369 // Zero means not monitoring.
370
Eric Laurent81784c32012-11-19 14:55:58 -0800371 // The following fields are only for fast tracks, and should be in a subclass
372 int mFastIndex; // index within FastMixerState::mFastTracks[];
373 // either mFastIndex == -1 if not isFastTrack()
374 // or 0 < mFastIndex < FastMixerState::kMaxFast because
375 // index 0 is reserved for normal mixer's submix;
376 // index is allocated statically at track creation time
377 // but the slot is only used if track is active
378 FastTrackUnderruns mObservedUnderruns; // Most recently observed value of
379 // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns
Eric Laurent81784c32012-11-19 14:55:58 -0800380 volatile float mCachedVolume; // combined master volume and stream type volume;
381 // 'volatile' means accessed without lock or
382 // barrier, but is read/written atomically
Kevin Rocard12381092018-04-11 09:19:59 -0700383 float mFinalVolume; // combine master volume, stream type volume and track volume
jiabin76d94692022-12-15 21:51:21 +0000384 float mFinalVolumeLeft; // combine master volume, stream type volume and track
385 // volume
386 float mFinalVolumeRight; // combine master volume, stream type volume and track
387 // volume
Eric Laurent5bba2f62016-03-18 11:14:14 -0700388 sp<AudioTrackServerProxy> mAudioTrackServerProxy;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800389 bool mResumeToStopping; // track was paused in stopping state.
Haynes Mathew George7844f672014-01-15 12:32:55 -0800390 bool mFlushHwPending; // track requests for thread flush
Kuowei Li23666472021-01-20 10:23:25 +0800391 bool mPauseHwPending = false; // direct/offload track request for thread pause
Eric Laurent05067782016-06-01 18:27:28 -0700392 audio_output_flags_t mFlags;
Andy Hung16ed0da2023-07-14 11:45:38 -0700393 TeePatches mTeePatches;
394 std::optional<TeePatches> mTeePatchesToUpdate;
Jiabin Huang73f97052023-12-12 20:08:03 +0000395 RWLock mTeePatchesRWLock;
jiabinf042b9b2021-05-07 23:46:28 +0000396 const float mSpeed;
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200397 const bool mIsSpatialized;
jiabinc658e452022-10-21 20:52:21 +0000398 const bool mIsBitPerfect;
Vlad Popae8d99472022-06-30 16:02:48 +0200399
400 // TODO: replace PersistableBundle with own struct
401 // access these two variables only when holding player thread lock.
402 std::unique_ptr<os::PersistableBundle> mMuteEventExtras;
403 mute_state_t mMuteState;
Eric Laurent81784c32012-11-19 14:55:58 -0800404}; // end of Track
405
Eric Laurent81784c32012-11-19 14:55:58 -0800406
407// playback track, used by DuplicatingThread
Andy Hungd29af632023-06-23 19:27:19 -0700408class OutputTrack : public Track, public IAfOutputTrack {
Eric Laurent81784c32012-11-19 14:55:58 -0800409public:
410
411 class Buffer : public AudioBufferProvider::Buffer {
412 public:
Andy Hungc25b84a2015-01-14 19:04:10 -0800413 void *mBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -0800414 };
415
Andy Hung87c693c2023-07-06 20:56:16 -0700416 OutputTrack(IAfPlaybackThread* thread,
417 IAfDuplicatingThread* sourceThread,
Eric Laurent81784c32012-11-19 14:55:58 -0800418 uint32_t sampleRate,
419 audio_format_t format,
420 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800421 size_t frameCount,
Svet Ganov33761132021-05-13 22:51:08 +0000422 const AttributionSourceState& attributionSource);
Andy Hungd29af632023-06-23 19:27:19 -0700423 ~OutputTrack() override;
Eric Laurent81784c32012-11-19 14:55:58 -0800424
Andy Hungd29af632023-06-23 19:27:19 -0700425 status_t start(AudioSystem::sync_event_t event =
Eric Laurent81784c32012-11-19 14:55:58 -0800426 AudioSystem::SYNC_EVENT_NONE,
Andy Hungd29af632023-06-23 19:27:19 -0700427 audio_session_t triggerSession = AUDIO_SESSION_NONE) final;
428 void stop() final;
429 ssize_t write(void* data, uint32_t frames) final;
430 bool bufferQueueEmpty() const final { return mBufferQueue.size() == 0; }
431 bool isActive() const final { return mActive; }
Eric Laurent81784c32012-11-19 14:55:58 -0800432
Andy Hungd29af632023-06-23 19:27:19 -0700433 void copyMetadataTo(MetadataInserter& backInserter) const final;
Kevin Rocard12381092018-04-11 09:19:59 -0700434 /** Set the metadatas of the upstream tracks. Thread safe. */
Andy Hungd29af632023-06-23 19:27:19 -0700435 void setMetadatas(const SourceMetadatas& metadatas) final;
Andy Hung1c86ebe2018-05-29 20:29:08 -0700436 /** returns client timestamp to the upstream duplicating thread. */
Andy Hungd29af632023-06-23 19:27:19 -0700437 ExtendedTimestamp getClientProxyTimestamp() const final {
Andy Hung1c86ebe2018-05-29 20:29:08 -0700438 // server - kernel difference is not true latency when drained
439 // i.e. mServerProxy->isDrained().
440 ExtendedTimestamp timestamp;
441 (void) mClientProxy->getTimestamp(&timestamp);
442 // On success, the timestamp LOCATION_SERVER and LOCATION_KERNEL
443 // entries will be properly filled. If getTimestamp()
444 // is unsuccessful, then a default initialized timestamp
445 // (with mTimeNs[] filled with -1's) is returned.
446 return timestamp;
447 }
Kevin Rocard12381092018-04-11 09:19:59 -0700448private:
Eric Laurent81784c32012-11-19 14:55:58 -0800449 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer,
450 uint32_t waitTimeMs);
Eric Laurent19952e12023-04-20 10:08:29 +0200451 void queueBuffer(Buffer& inBuffer);
Eric Laurent81784c32012-11-19 14:55:58 -0800452 void clearBufferQueue();
453
Eric Laurent4d231dc2016-03-11 18:38:23 -0800454 void restartIfDisabled();
455
Eric Laurent81784c32012-11-19 14:55:58 -0800456 // Maximum number of pending buffers allocated by OutputTrack::write()
457 static const uint8_t kMaxOverFlowBuffers = 10;
458
459 Vector < Buffer* > mBufferQueue;
460 AudioBufferProvider::Buffer mOutBuffer;
461 bool mActive;
Andy Hung87c693c2023-07-06 20:56:16 -0700462 IAfDuplicatingThread* const mSourceThread; // for waitTimeMs() in write()
Eric Laurent5bba2f62016-03-18 11:14:14 -0700463 sp<AudioTrackClientProxy> mClientProxy;
Andy Hung1c86ebe2018-05-29 20:29:08 -0700464
Kevin Rocard12381092018-04-11 09:19:59 -0700465 /** Attributes of the source tracks.
466 *
467 * This member must be accessed with mTrackMetadatasMutex taken.
468 * There is one writer (duplicating thread) and one reader (downstream mixer).
469 *
470 * That means that the duplicating thread can block the downstream mixer
471 * thread and vice versa for the time of the copy.
472 * If this becomes an issue, the metadata could be stored in an atomic raw pointer,
473 * and a exchange with nullptr and delete can be used.
474 * Alternatively a read-copy-update might be implemented.
475 */
476 SourceMetadatas mTrackMetadatas;
477 /** Protects mTrackMetadatas against concurrent access. */
Andy Hungc5007f82023-08-29 14:26:09 -0700478 audio_utils::mutex& trackMetadataMutex() const { return mTrackMetadataMutex; }
Andy Hunga6f1cbb2023-10-12 18:18:13 -0700479 mutable audio_utils::mutex mTrackMetadataMutex{
480 audio_utils::MutexOrder::kOutputTrack_TrackMetadataMutex};
Eric Laurent81784c32012-11-19 14:55:58 -0800481}; // end of OutputTrack
Eric Laurent83b88082014-06-20 18:31:16 -0700482
483// playback track, used by PatchPanel
Andy Hungca9be052023-06-26 19:20:57 -0700484class PatchTrack : public Track, public PatchTrackBase, public IAfPatchTrack {
Eric Laurent83b88082014-06-20 18:31:16 -0700485public:
Andy Hung87c693c2023-07-06 20:56:16 -0700486 PatchTrack(IAfPlaybackThread* playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -0700487 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -0700488 uint32_t sampleRate,
489 audio_channel_mask_t channelMask,
490 audio_format_t format,
491 size_t frameCount,
492 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700493 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -0800494 audio_output_flags_t flags,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +0100495 const Timeout& timeout = {},
496 size_t frameCountToBeReady = 1 /** Default behaviour is to start
497 * as soon as possible to have
498 * the lowest possible latency
499 * even if it might glitch. */);
Andy Hungd29af632023-06-23 19:27:19 -0700500 ~PatchTrack() override;
Eric Laurent83b88082014-06-20 18:31:16 -0700501
Andy Hungd29af632023-06-23 19:27:19 -0700502 size_t framesReady() const final;
Mikhail Naganovcaf59942019-09-25 14:05:29 -0700503
Andy Hungd29af632023-06-23 19:27:19 -0700504 status_t start(AudioSystem::sync_event_t event =
Eric Laurent4d231dc2016-03-11 18:38:23 -0800505 AudioSystem::SYNC_EVENT_NONE,
Andy Hungd29af632023-06-23 19:27:19 -0700506 audio_session_t triggerSession = AUDIO_SESSION_NONE) final;
Eric Laurent4d231dc2016-03-11 18:38:23 -0800507
Eric Laurent83b88082014-06-20 18:31:16 -0700508 // AudioBufferProvider interface
Andy Hungd29af632023-06-23 19:27:19 -0700509 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) final;
510 void releaseBuffer(AudioBufferProvider::Buffer* buffer) final;
Eric Laurent83b88082014-06-20 18:31:16 -0700511
512 // PatchProxyBufferProvider interface
Andy Hungd29af632023-06-23 19:27:19 -0700513 status_t obtainBuffer(Proxy::Buffer* buffer, const struct timespec* timeOut = nullptr) final;
514 void releaseBuffer(Proxy::Buffer* buffer) final;
Eric Laurent83b88082014-06-20 18:31:16 -0700515
Eric Laurent83b88082014-06-20 18:31:16 -0700516private:
Eric Laurent4d231dc2016-03-11 18:38:23 -0800517 void restartIfDisabled();
Eric Laurent83b88082014-06-20 18:31:16 -0700518}; // end of PatchTrack
Andy Hung8d31fd22023-06-26 19:20:57 -0700519
520} // namespace android