blob: e52d1ee6e46dbae96c4f90ec77ec8f5f6afd439f [file] [log] [blame]
Eric Laurent81784c32012-11-19 14:55:58 -08001/*
2**
3** Copyright 2012, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#ifndef INCLUDING_FROM_AUDIOFLINGER_H
19 #error This header file should only be included from AudioFlinger.h
20#endif
21
Lais Andradebc3f37a2021-07-02 00:13:19 +010022#include <math.h>
23
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080024// Checks and monitors OP_PLAY_AUDIO
25class OpPlayAudioMonitor : public RefBase {
26public:
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080027 ~OpPlayAudioMonitor() override;
28 bool hasOpPlayAudio() const;
29
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070030 static sp<OpPlayAudioMonitor> createIfNeeded(
Svet Ganov33761132021-05-13 22:51:08 +000031 const AttributionSourceState& attributionSource,
Philip P. Moltmannbda45752020-07-17 16:41:18 -070032 const audio_attributes_t& attr, int id,
33 audio_stream_type_t streamType);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070034
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080035private:
Svet Ganov33761132021-05-13 22:51:08 +000036 OpPlayAudioMonitor(const AttributionSourceState& attributionSource,
Philip P. Moltmannbda45752020-07-17 16:41:18 -070037 audio_usage_t usage, int id);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070038 void onFirstRef() override;
Eric Laurent9066ad32019-05-20 14:40:10 -070039 static void getPackagesForUid(uid_t uid, Vector<String16>& packages);
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070040
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080041 AppOpsManager mAppOpsManager;
42
43 class PlayAudioOpCallback : public BnAppOpsCallback {
44 public:
45 explicit PlayAudioOpCallback(const wp<OpPlayAudioMonitor>& monitor);
46 void opChanged(int32_t op, const String16& packageName) override;
47
48 private:
49 const wp<OpPlayAudioMonitor> mMonitor;
50 };
51
52 sp<PlayAudioOpCallback> mOpCallback;
53 // called by PlayAudioOpCallback when OP_PLAY_AUDIO is updated in AppOp callback
54 void checkPlayAudioForUsage();
55
56 std::atomic_bool mHasOpPlayAudio;
Svet Ganov33761132021-05-13 22:51:08 +000057 const AttributionSourceState mAttributionSource;
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080058 const int32_t mUsage; // on purpose not audio_usage_t because always checked in appOps as int32_t
59 const int mId; // for logging purposes only
60};
61
Eric Laurent81784c32012-11-19 14:55:58 -080062// playback track
63class Track : public TrackBase, public VolumeProvider {
64public:
65 Track( PlaybackThread *thread,
66 const sp<Client>& client,
67 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -070068 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -080069 uint32_t sampleRate,
70 audio_format_t format,
71 audio_channel_mask_t channelMask,
72 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -070073 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -070074 size_t bufferSize,
Eric Laurent81784c32012-11-19 14:55:58 -080075 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -080076 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -070077 pid_t creatorPid,
Svet Ganov33761132021-05-13 22:51:08 +000078 const AttributionSourceState& attributionSource,
Eric Laurent05067782016-06-01 18:27:28 -070079 audio_output_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -080080 track_type type,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +010081 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE,
82 /** default behaviour is to start when there are as many frames
83 * ready as possible (aka. Buffer is full). */
jiabinf042b9b2021-05-07 23:46:28 +000084 size_t frameCountToBeReady = SIZE_MAX,
Eric Laurentb0a7bc92022-04-05 15:06:08 +020085 float speed = 1.0f,
86 bool isSpatialized = false);
Eric Laurent81784c32012-11-19 14:55:58 -080087 virtual ~Track();
Glenn Kasten03003332013-08-06 15:40:54 -070088 virtual status_t initCheck() const;
Eric Laurent81784c32012-11-19 14:55:58 -080089
Andy Hungf6ab58d2018-05-25 12:50:39 -070090 void appendDumpHeader(String8& result);
Andy Hung2c6c3bb2017-06-16 14:01:45 -070091 void appendDump(String8& result, bool active);
Kevin Rocard153f92d2018-12-18 18:33:28 -080092 virtual status_t start(AudioSystem::sync_event_t event = AudioSystem::SYNC_EVENT_NONE,
93 audio_session_t triggerSession = AUDIO_SESSION_NONE);
Eric Laurent81784c32012-11-19 14:55:58 -080094 virtual void stop();
95 void pause();
96
97 void flush();
98 void destroy();
Eric Laurent81784c32012-11-19 14:55:58 -080099
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800100 virtual uint32_t sampleRate() const;
101
Eric Laurent81784c32012-11-19 14:55:58 -0800102 audio_stream_type_t streamType() const {
103 return mStreamType;
104 }
Eric Laurent05067782016-06-01 18:27:28 -0700105 bool isOffloaded() const
106 { return (mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0; }
Mikhail Naganov7c6ae982018-06-14 12:33:38 -0700107 bool isDirect() const override
108 { return (mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0; }
Andy Hung10cbff12017-02-21 17:30:14 -0800109 bool isOffloadedOrDirect() const { return (mFlags
110 & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD
111 | AUDIO_OUTPUT_FLAG_DIRECT)) != 0; }
Andy Hungf6ab58d2018-05-25 12:50:39 -0700112 bool isStatic() const { return mSharedBuffer.get() != nullptr; }
Andy Hung10cbff12017-02-21 17:30:14 -0800113
Eric Laurentbfb1b832013-01-07 09:53:42 -0800114 status_t setParameters(const String8& keyValuePairs);
Mikhail Naganovac917ac2018-11-28 14:03:52 -0800115 status_t selectPresentation(int presentationId, int programId);
Eric Laurent81784c32012-11-19 14:55:58 -0800116 status_t attachAuxEffect(int EffectId);
117 void setAuxBuffer(int EffectId, int32_t *buffer);
118 int32_t *auxBuffer() const { return mAuxBuffer; }
rago94a1ee82017-07-21 15:11:02 -0700119 void setMainBuffer(effect_buffer_t *buffer) { mMainBuffer = buffer; }
120 effect_buffer_t *mainBuffer() const { return mMainBuffer; }
Eric Laurent81784c32012-11-19 14:55:58 -0800121 int auxEffectId() const { return mAuxEffectId; }
Glenn Kasten573d80a2013-08-26 09:36:23 -0700122 virtual status_t getTimestamp(AudioTimestamp& timestamp);
Eric Laurent59fe0102013-09-27 18:48:26 -0700123 void signal();
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800124 status_t getDualMonoMode(audio_dual_mono_mode_t* mode);
125 status_t setDualMonoMode(audio_dual_mono_mode_t mode);
126 status_t getAudioDescriptionMixLevel(float* leveldB);
127 status_t setAudioDescriptionMixLevel(float leveldB);
128 status_t getPlaybackRateParameters(audio_playback_rate_t* playbackRate);
129 status_t setPlaybackRateParameters(const audio_playback_rate_t& playbackRate);
Eric Laurent81784c32012-11-19 14:55:58 -0800130
131// implement FastMixerState::VolumeProvider interface
Glenn Kastenc56f3422014-03-21 17:53:17 -0700132 virtual gain_minifloat_packed_t getVolumeLR();
Eric Laurent81784c32012-11-19 14:55:58 -0800133
134 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
135
Eric Laurent05067782016-06-01 18:27:28 -0700136 virtual bool isFastTrack() const { return (mFlags & AUDIO_OUTPUT_FLAG_FAST) != 0; }
137
Andy Hungcef2daa2018-06-01 15:31:49 -0700138 double bufferLatencyMs() const override {
139 return isStatic() ? 0. : TrackBase::bufferLatencyMs();
140 }
Andy Hungf6ab58d2018-05-25 12:50:39 -0700141
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800142// implement volume handling.
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700143 media::VolumeShaper::Status applyVolumeShaper(
144 const sp<media::VolumeShaper::Configuration>& configuration,
145 const sp<media::VolumeShaper::Operation>& operation);
146 sp<media::VolumeShaper::State> getVolumeShaperState(int id);
147 sp<media::VolumeHandler> getVolumeHandler() { return mVolumeHandler; }
Kevin Rocard12381092018-04-11 09:19:59 -0700148 /** Set the computed normalized final volume of the track.
149 * !masterMute * masterVolume * streamVolume * averageLRVolume */
150 void setFinalVolume(float volume);
151 float getFinalVolume() const { return mFinalVolume; }
152
Eric Laurent94579172020-11-20 18:41:04 +0100153 using SourceMetadatas = std::vector<playback_track_metadata_v7_t>;
Kevin Rocard12381092018-04-11 09:19:59 -0700154 using MetadataInserter = std::back_insert_iterator<SourceMetadatas>;
155 /** Copy the track metadata in the provided iterator. Thread safe. */
156 virtual void copyMetadataTo(MetadataInserter& backInserter) const;
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800157
jiabin245cdd92018-12-07 17:55:15 -0800158 /** Return haptic playback of the track is enabled or not, used in mixer. */
159 bool getHapticPlaybackEnabled() const { return mHapticPlaybackEnabled; }
160 /** Set haptic playback of the track is enabled or not, should be
161 * set after query or get callback from vibrator service */
162 void setHapticPlaybackEnabled(bool hapticPlaybackEnabled) {
163 mHapticPlaybackEnabled = hapticPlaybackEnabled;
164 }
jiabin77270b82018-12-18 15:41:29 -0800165 /** Return at what intensity to play haptics, used in mixer. */
jiabine70bc7f2020-06-30 22:07:55 -0700166 os::HapticScale getHapticIntensity() const { return mHapticIntensity; }
Lais Andradebc3f37a2021-07-02 00:13:19 +0100167 /** Return the maximum amplitude allowed for haptics data, used in mixer. */
168 float getHapticMaxAmplitude() const { return mHapticMaxAmplitude; }
jiabin77270b82018-12-18 15:41:29 -0800169 /** Set intensity of haptic playback, should be set after querying vibrator service. */
jiabine70bc7f2020-06-30 22:07:55 -0700170 void setHapticIntensity(os::HapticScale hapticIntensity) {
171 if (os::isValidHapticScale(hapticIntensity)) {
jiabin77270b82018-12-18 15:41:29 -0800172 mHapticIntensity = hapticIntensity;
jiabine70bc7f2020-06-30 22:07:55 -0700173 setHapticPlaybackEnabled(mHapticIntensity != os::HapticScale::MUTE);
jiabin77270b82018-12-18 15:41:29 -0800174 }
175 }
Lais Andradebc3f37a2021-07-02 00:13:19 +0100176 /** Set maximum amplitude allowed for haptic data, should be set after querying
177 * vibrator service.
178 */
179 void setHapticMaxAmplitude(float maxAmplitude) {
180 mHapticMaxAmplitude = maxAmplitude;
181 }
jiabin57303cc2018-12-18 15:45:57 -0800182 sp<os::ExternalVibration> getExternalVibration() const { return mExternalVibration; }
jiabin245cdd92018-12-07 17:55:15 -0800183
Kevin Rocard153f92d2018-12-18 18:33:28 -0800184 void setTeePatches(TeePatches teePatches);
185
Andy Hungc2b11cb2020-04-22 09:04:01 -0700186 void tallyUnderrunFrames(size_t frames) override {
187 if (isOut()) { // we expect this from output tracks only
188 mAudioTrackServerProxy->tallyUnderrunFrames(frames);
189 // Fetch absolute numbers from AudioTrackShared as it counts
190 // contiguous underruns as a one -- we want a consistent number.
191 // TODO: isolate this counting into a class.
192 mTrackMetrics.logUnderruns(mAudioTrackServerProxy->getUnderrunCount(),
193 mAudioTrackServerProxy->getUnderrunFrames());
194 }
195 }
jiabinf042b9b2021-05-07 23:46:28 +0000196
Dean Wheatley7b036912020-06-18 16:22:11 +1000197 static bool checkServerLatencySupported(
198 audio_format_t format, audio_output_flags_t flags) {
199 return audio_is_linear_pcm(format)
200 && (flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) == 0;
201 }
202
jiabinf042b9b2021-05-07 23:46:28 +0000203 audio_output_flags_t getOutputFlags() const { return mFlags; }
204 float getSpeed() const { return mSpeed; }
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200205 bool isSpatialized() const override { return mIsSpatialized; }
Eric Laurent39095982021-08-24 18:29:27 +0200206
Vlad Popae8d99472022-06-30 16:02:48 +0200207 /**
208 * Updates the mute state and notifies the audio service. Call this only when holding player
209 * thread lock.
210 */
211 void processMuteEvent_l(const sp<IAudioManager>& audioManager, mute_state_t muteState);
212
Eric Laurent81784c32012-11-19 14:55:58 -0800213protected:
214 // for numerous
215 friend class PlaybackThread;
216 friend class MixerThread;
217 friend class DirectOutputThread;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800218 friend class OffloadThread;
Eric Laurent81784c32012-11-19 14:55:58 -0800219
Mikhail Naganovbf493082017-04-17 17:37:12 -0700220 DISALLOW_COPY_AND_ASSIGN(Track);
Eric Laurent81784c32012-11-19 14:55:58 -0800221
222 // AudioBufferProvider interface
Kevin Rocard153f92d2018-12-18 18:33:28 -0800223 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override;
224 void releaseBuffer(AudioBufferProvider::Buffer* buffer) override;
Eric Laurent81784c32012-11-19 14:55:58 -0800225
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700226 // ExtendedAudioBufferProvider interface
Eric Laurent81784c32012-11-19 14:55:58 -0800227 virtual size_t framesReady() const;
Andy Hung818e7a32016-02-16 18:08:07 -0800228 virtual int64_t framesReleased() const;
229 virtual void onTimestamp(const ExtendedTimestamp &timestamp);
Eric Laurent81784c32012-11-19 14:55:58 -0800230
Glenn Kastenc9b2e202013-02-26 11:32:32 -0800231 bool isPausing() const { return mState == PAUSING; }
232 bool isPaused() const { return mState == PAUSED; }
233 bool isResuming() const { return mState == RESUMING; }
Eric Laurent81784c32012-11-19 14:55:58 -0800234 bool isReady() const;
235 void setPaused() { mState = PAUSED; }
236 void reset();
Haynes Mathew George7844f672014-01-15 12:32:55 -0800237 bool isFlushPending() const { return mFlushHwPending; }
238 void flushAck();
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -0800239 bool isResumePending();
240 void resumeAck();
Kuowei Li23666472021-01-20 10:23:25 +0800241 // For direct or offloaded tracks ensure that the pause state is acknowledged
242 // by the playback thread in case of an immediate flush.
243 bool isPausePending() const { return mPauseHwPending; }
244 void pauseAck();
Andy Hung818e7a32016-02-16 18:08:07 -0800245 void updateTrackFrameInfo(int64_t trackFramesReleased, int64_t sinkFramesWritten,
Andy Hungcef2daa2018-06-01 15:31:49 -0700246 uint32_t halSampleRate, const ExtendedTimestamp &timeStamp);
Eric Laurent81784c32012-11-19 14:55:58 -0800247
Eric Laurent81784c32012-11-19 14:55:58 -0800248 sp<IMemory> sharedBuffer() const { return mSharedBuffer; }
249
Andy Hung59de4262021-06-14 10:53:54 -0700250 // presentationComplete checked by frames. (Mixed Tracks).
Eric Laurent81784c32012-11-19 14:55:58 -0800251 // framesWritten is cumulative, never reset, and is shared all tracks
252 // audioHalFrames is derived from output latency
Andy Hung818e7a32016-02-16 18:08:07 -0800253 bool presentationComplete(int64_t framesWritten, size_t audioHalFrames);
Andy Hung59de4262021-06-14 10:53:54 -0700254
255 // presentationComplete checked by time. (Direct Tracks).
256 bool presentationComplete(uint32_t latencyMs);
257
258 void resetPresentationComplete() {
259 mPresentationCompleteFrames = 0;
260 mPresentationCompleteTimeNs = 0;
261 }
262
263 // notifyPresentationComplete is called when presentationComplete() detects
264 // that the track is finished stopping.
265 void notifyPresentationComplete();
266
Eric Laurent4d231dc2016-03-11 18:38:23 -0800267 void signalClientFlag(int32_t flag);
Eric Laurent81784c32012-11-19 14:55:58 -0800268
269public:
270 void triggerEvents(AudioSystem::sync_event_t type);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800271 virtual void invalidate();
Eric Laurent4d231dc2016-03-11 18:38:23 -0800272 void disable();
273
Glenn Kastend054c322013-07-12 12:59:20 -0700274 int fastIndex() const { return mFastIndex; }
Eric Laurent81784c32012-11-19 14:55:58 -0800275
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700276 bool isPlaybackRestricted() const {
277 // The monitor is only created for tracks that can be silenced.
278 return mOpPlayAudioMonitor ? !mOpPlayAudioMonitor->hasOpPlayAudio() : false; }
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800279
Eric Laurent81784c32012-11-19 14:55:58 -0800280protected:
281
Eric Laurent81784c32012-11-19 14:55:58 -0800282 // FILLED state is used for suppressing volume ramp at begin of playing
283 enum {FS_INVALID, FS_FILLING, FS_FILLED, FS_ACTIVE};
284 mutable uint8_t mFillingUpStatus;
285 int8_t mRetryCount;
Glenn Kasten0c72b242013-09-11 09:14:16 -0700286
287 // see comment at AudioFlinger::PlaybackThread::Track::~Track for why this can't be const
288 sp<IMemory> mSharedBuffer;
289
Eric Laurent81784c32012-11-19 14:55:58 -0800290 bool mResetDone;
291 const audio_stream_type_t mStreamType;
rago94a1ee82017-07-21 15:11:02 -0700292 effect_buffer_t *mMainBuffer;
293
Eric Laurent81784c32012-11-19 14:55:58 -0800294 int32_t *mAuxBuffer;
295 int mAuxEffectId;
296 bool mHasVolumeController;
Andy Hunge10393e2015-06-12 13:59:33 -0700297
298 // access these three variables only when holding thread lock.
Andy Hung818e7a32016-02-16 18:08:07 -0800299 LinearMap<int64_t> mFrameMap; // track frame to server frame mapping
300
301 ExtendedTimestamp mSinkTimestamp;
Andy Hunge10393e2015-06-12 13:59:33 -0700302
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700303 sp<media::VolumeHandler> mVolumeHandler; // handles multiple VolumeShaper configs and operations
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800304
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800305 sp<OpPlayAudioMonitor> mOpPlayAudioMonitor;
306
jiabin245cdd92018-12-07 17:55:15 -0800307 bool mHapticPlaybackEnabled = false; // indicates haptic playback enabled or not
jiabin77270b82018-12-18 15:41:29 -0800308 // intensity to play haptic data
jiabine70bc7f2020-06-30 22:07:55 -0700309 os::HapticScale mHapticIntensity = os::HapticScale::MUTE;
Lais Andradebc3f37a2021-07-02 00:13:19 +0100310 // max amplitude allowed for haptic data
311 float mHapticMaxAmplitude = NAN;
jiabin57303cc2018-12-18 15:45:57 -0800312 class AudioVibrationController : public os::BnExternalVibrationController {
313 public:
314 explicit AudioVibrationController(Track* track) : mTrack(track) {}
315 binder::Status mute(/*out*/ bool *ret) override;
316 binder::Status unmute(/*out*/ bool *ret) override;
317 private:
318 Track* const mTrack;
319 };
320 sp<AudioVibrationController> mAudioVibrationController;
321 sp<os::ExternalVibration> mExternalVibration;
jiabin245cdd92018-12-07 17:55:15 -0800322
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800323 audio_dual_mono_mode_t mDualMonoMode = AUDIO_DUAL_MONO_MODE_OFF;
324 float mAudioDescriptionMixLevel = -std::numeric_limits<float>::infinity();
325 audio_playback_rate_t mPlaybackRateParameters = AUDIO_PLAYBACK_RATE_INITIALIZER;
326
Eric Laurent81784c32012-11-19 14:55:58 -0800327private:
Kevin Rocard153f92d2018-12-18 18:33:28 -0800328 void interceptBuffer(const AudioBufferProvider::Buffer& buffer);
Kevin Rocardc43ea142019-01-31 18:17:37 -0800329 template <class F>
330 void forEachTeePatchTrack(F f) {
331 for (auto& tp : mTeePatches) { f(tp.patchTrack); }
332 };
Kevin Rocard153f92d2018-12-18 18:33:28 -0800333
Andy Hung59de4262021-06-14 10:53:54 -0700334 size_t mPresentationCompleteFrames = 0; // (Used for Mixed tracks)
335 // The number of frames written to the
336 // audio HAL when this track is considered fully rendered.
337 // Zero means not monitoring.
338 int64_t mPresentationCompleteTimeNs = 0; // (Used for Direct tracks)
339 // The time when this track is considered fully rendered.
340 // Zero means not monitoring.
341
Eric Laurent81784c32012-11-19 14:55:58 -0800342 // The following fields are only for fast tracks, and should be in a subclass
343 int mFastIndex; // index within FastMixerState::mFastTracks[];
344 // either mFastIndex == -1 if not isFastTrack()
345 // or 0 < mFastIndex < FastMixerState::kMaxFast because
346 // index 0 is reserved for normal mixer's submix;
347 // index is allocated statically at track creation time
348 // but the slot is only used if track is active
349 FastTrackUnderruns mObservedUnderruns; // Most recently observed value of
350 // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns
Eric Laurent81784c32012-11-19 14:55:58 -0800351 volatile float mCachedVolume; // combined master volume and stream type volume;
352 // 'volatile' means accessed without lock or
353 // barrier, but is read/written atomically
Kevin Rocard12381092018-04-11 09:19:59 -0700354 float mFinalVolume; // combine master volume, stream type volume and track volume
Eric Laurent5bba2f62016-03-18 11:14:14 -0700355 sp<AudioTrackServerProxy> mAudioTrackServerProxy;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800356 bool mResumeToStopping; // track was paused in stopping state.
Haynes Mathew George7844f672014-01-15 12:32:55 -0800357 bool mFlushHwPending; // track requests for thread flush
Kuowei Li23666472021-01-20 10:23:25 +0800358 bool mPauseHwPending = false; // direct/offload track request for thread pause
Eric Laurent05067782016-06-01 18:27:28 -0700359 audio_output_flags_t mFlags;
Kevin Rocard153f92d2018-12-18 18:33:28 -0800360 TeePatches mTeePatches;
jiabinf042b9b2021-05-07 23:46:28 +0000361 const float mSpeed;
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200362 const bool mIsSpatialized;
Vlad Popae8d99472022-06-30 16:02:48 +0200363
364 // TODO: replace PersistableBundle with own struct
365 // access these two variables only when holding player thread lock.
366 std::unique_ptr<os::PersistableBundle> mMuteEventExtras;
367 mute_state_t mMuteState;
Eric Laurent81784c32012-11-19 14:55:58 -0800368}; // end of Track
369
Eric Laurent81784c32012-11-19 14:55:58 -0800370
371// playback track, used by DuplicatingThread
372class OutputTrack : public Track {
373public:
374
375 class Buffer : public AudioBufferProvider::Buffer {
376 public:
Andy Hungc25b84a2015-01-14 19:04:10 -0800377 void *mBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -0800378 };
379
380 OutputTrack(PlaybackThread *thread,
381 DuplicatingThread *sourceThread,
382 uint32_t sampleRate,
383 audio_format_t format,
384 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800385 size_t frameCount,
Svet Ganov33761132021-05-13 22:51:08 +0000386 const AttributionSourceState& attributionSource);
Eric Laurent81784c32012-11-19 14:55:58 -0800387 virtual ~OutputTrack();
388
389 virtual status_t start(AudioSystem::sync_event_t event =
390 AudioSystem::SYNC_EVENT_NONE,
Glenn Kastend848eb42016-03-08 13:42:11 -0800391 audio_session_t triggerSession = AUDIO_SESSION_NONE);
Eric Laurent81784c32012-11-19 14:55:58 -0800392 virtual void stop();
Andy Hung1c86ebe2018-05-29 20:29:08 -0700393 ssize_t write(void* data, uint32_t frames);
Eric Laurent81784c32012-11-19 14:55:58 -0800394 bool bufferQueueEmpty() const { return mBufferQueue.size() == 0; }
395 bool isActive() const { return mActive; }
396 const wp<ThreadBase>& thread() const { return mThread; }
397
Kevin Rocard12381092018-04-11 09:19:59 -0700398 void copyMetadataTo(MetadataInserter& backInserter) const override;
399 /** Set the metadatas of the upstream tracks. Thread safe. */
400 void setMetadatas(const SourceMetadatas& metadatas);
Andy Hung1c86ebe2018-05-29 20:29:08 -0700401 /** returns client timestamp to the upstream duplicating thread. */
402 ExtendedTimestamp getClientProxyTimestamp() const {
403 // server - kernel difference is not true latency when drained
404 // i.e. mServerProxy->isDrained().
405 ExtendedTimestamp timestamp;
406 (void) mClientProxy->getTimestamp(&timestamp);
407 // On success, the timestamp LOCATION_SERVER and LOCATION_KERNEL
408 // entries will be properly filled. If getTimestamp()
409 // is unsuccessful, then a default initialized timestamp
410 // (with mTimeNs[] filled with -1's) is returned.
411 return timestamp;
412 }
Kevin Rocard80ee2722018-04-11 15:53:48 +0000413
Kevin Rocard12381092018-04-11 09:19:59 -0700414private:
Eric Laurent81784c32012-11-19 14:55:58 -0800415 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer,
416 uint32_t waitTimeMs);
417 void clearBufferQueue();
418
Eric Laurent4d231dc2016-03-11 18:38:23 -0800419 void restartIfDisabled();
420
Eric Laurent81784c32012-11-19 14:55:58 -0800421 // Maximum number of pending buffers allocated by OutputTrack::write()
422 static const uint8_t kMaxOverFlowBuffers = 10;
423
424 Vector < Buffer* > mBufferQueue;
425 AudioBufferProvider::Buffer mOutBuffer;
426 bool mActive;
Eric Laurent5bba2f62016-03-18 11:14:14 -0700427 DuplicatingThread* const mSourceThread; // for waitTimeMs() in write()
428 sp<AudioTrackClientProxy> mClientProxy;
Andy Hung1c86ebe2018-05-29 20:29:08 -0700429
Kevin Rocard12381092018-04-11 09:19:59 -0700430 /** Attributes of the source tracks.
431 *
432 * This member must be accessed with mTrackMetadatasMutex taken.
433 * There is one writer (duplicating thread) and one reader (downstream mixer).
434 *
435 * That means that the duplicating thread can block the downstream mixer
436 * thread and vice versa for the time of the copy.
437 * If this becomes an issue, the metadata could be stored in an atomic raw pointer,
438 * and a exchange with nullptr and delete can be used.
439 * Alternatively a read-copy-update might be implemented.
440 */
441 SourceMetadatas mTrackMetadatas;
442 /** Protects mTrackMetadatas against concurrent access. */
443 mutable std::mutex mTrackMetadatasMutex;
Eric Laurent81784c32012-11-19 14:55:58 -0800444}; // end of OutputTrack
Eric Laurent83b88082014-06-20 18:31:16 -0700445
446// playback track, used by PatchPanel
Kevin Rocard45986c72018-12-18 18:22:59 -0800447class PatchTrack : public Track, public PatchTrackBase {
Eric Laurent83b88082014-06-20 18:31:16 -0700448public:
449
450 PatchTrack(PlaybackThread *playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -0700451 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -0700452 uint32_t sampleRate,
453 audio_channel_mask_t channelMask,
454 audio_format_t format,
455 size_t frameCount,
456 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700457 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -0800458 audio_output_flags_t flags,
Kevin Rocard01c7d9e2019-09-18 11:24:52 +0100459 const Timeout& timeout = {},
460 size_t frameCountToBeReady = 1 /** Default behaviour is to start
461 * as soon as possible to have
462 * the lowest possible latency
463 * even if it might glitch. */);
Eric Laurent83b88082014-06-20 18:31:16 -0700464 virtual ~PatchTrack();
465
Mikhail Naganovcaf59942019-09-25 14:05:29 -0700466 size_t framesReady() const override;
467
Eric Laurent4d231dc2016-03-11 18:38:23 -0800468 virtual status_t start(AudioSystem::sync_event_t event =
469 AudioSystem::SYNC_EVENT_NONE,
Glenn Kastend848eb42016-03-08 13:42:11 -0800470 audio_session_t triggerSession = AUDIO_SESSION_NONE);
Eric Laurent4d231dc2016-03-11 18:38:23 -0800471
Eric Laurent83b88082014-06-20 18:31:16 -0700472 // AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -0800473 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
Eric Laurent83b88082014-06-20 18:31:16 -0700474 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
475
476 // PatchProxyBufferProvider interface
477 virtual status_t obtainBuffer(Proxy::Buffer* buffer,
478 const struct timespec *timeOut = NULL);
479 virtual void releaseBuffer(Proxy::Buffer* buffer);
480
Eric Laurent83b88082014-06-20 18:31:16 -0700481private:
Eric Laurent4d231dc2016-03-11 18:38:23 -0800482 void restartIfDisabled();
Eric Laurent83b88082014-06-20 18:31:16 -0700483}; // end of PatchTrack