blob: bb97f8d3f089dd7853c01b71d337d0650c7a27c0 [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
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080022// Checks and monitors OP_PLAY_AUDIO
23class OpPlayAudioMonitor : public RefBase {
24public:
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080025 ~OpPlayAudioMonitor() override;
26 bool hasOpPlayAudio() const;
27
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070028 static sp<OpPlayAudioMonitor> createIfNeeded(
29 uid_t uid, audio_usage_t usage, int id, audio_stream_type_t streamType);
30
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080031private:
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -070032 OpPlayAudioMonitor(uid_t uid, audio_usage_t usage, int id);
33 void onFirstRef() override;
34
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -080035 AppOpsManager mAppOpsManager;
36
37 class PlayAudioOpCallback : public BnAppOpsCallback {
38 public:
39 explicit PlayAudioOpCallback(const wp<OpPlayAudioMonitor>& monitor);
40 void opChanged(int32_t op, const String16& packageName) override;
41
42 private:
43 const wp<OpPlayAudioMonitor> mMonitor;
44 };
45
46 sp<PlayAudioOpCallback> mOpCallback;
47 // called by PlayAudioOpCallback when OP_PLAY_AUDIO is updated in AppOp callback
48 void checkPlayAudioForUsage();
49
50 std::atomic_bool mHasOpPlayAudio;
51 Vector<String16> mPackages;
52 const uid_t mUid;
53 const int32_t mUsage; // on purpose not audio_usage_t because always checked in appOps as int32_t
54 const int mId; // for logging purposes only
55};
56
Eric Laurent81784c32012-11-19 14:55:58 -080057// playback track
58class Track : public TrackBase, public VolumeProvider {
59public:
60 Track( PlaybackThread *thread,
61 const sp<Client>& client,
62 audio_stream_type_t streamType,
Kevin Rocard1f564ac2018-03-29 13:53:10 -070063 const audio_attributes_t& attr,
Eric Laurent81784c32012-11-19 14:55:58 -080064 uint32_t sampleRate,
65 audio_format_t format,
66 audio_channel_mask_t channelMask,
67 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -070068 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -070069 size_t bufferSize,
Eric Laurent81784c32012-11-19 14:55:58 -080070 const sp<IMemory>& sharedBuffer,
Glenn Kastend848eb42016-03-08 13:42:11 -080071 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -070072 pid_t creatorPid,
Andy Hung1f12a8a2016-11-07 16:10:30 -080073 uid_t uid,
Eric Laurent05067782016-06-01 18:27:28 -070074 audio_output_flags_t flags,
Eric Laurent20b9ef02016-12-05 11:03:16 -080075 track_type type,
76 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
Eric Laurent81784c32012-11-19 14:55:58 -080077 virtual ~Track();
Glenn Kasten03003332013-08-06 15:40:54 -070078 virtual status_t initCheck() const;
Eric Laurent81784c32012-11-19 14:55:58 -080079
Andy Hungf6ab58d2018-05-25 12:50:39 -070080 void appendDumpHeader(String8& result);
Andy Hung2c6c3bb2017-06-16 14:01:45 -070081 void appendDump(String8& result, bool active);
Kevin Rocard153f92d2018-12-18 18:33:28 -080082 virtual status_t start(AudioSystem::sync_event_t event = AudioSystem::SYNC_EVENT_NONE,
83 audio_session_t triggerSession = AUDIO_SESSION_NONE);
Eric Laurent81784c32012-11-19 14:55:58 -080084 virtual void stop();
85 void pause();
86
87 void flush();
88 void destroy();
Eric Laurent81784c32012-11-19 14:55:58 -080089
Glenn Kasten9f80dd22012-12-18 15:57:32 -080090 virtual uint32_t sampleRate() const;
91
Eric Laurent81784c32012-11-19 14:55:58 -080092 audio_stream_type_t streamType() const {
93 return mStreamType;
94 }
Eric Laurent05067782016-06-01 18:27:28 -070095 bool isOffloaded() const
96 { return (mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0; }
Mikhail Naganov7c6ae982018-06-14 12:33:38 -070097 bool isDirect() const override
98 { return (mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0; }
Andy Hung10cbff12017-02-21 17:30:14 -080099 bool isOffloadedOrDirect() const { return (mFlags
100 & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD
101 | AUDIO_OUTPUT_FLAG_DIRECT)) != 0; }
Andy Hungf6ab58d2018-05-25 12:50:39 -0700102 bool isStatic() const { return mSharedBuffer.get() != nullptr; }
Andy Hung10cbff12017-02-21 17:30:14 -0800103
Eric Laurentbfb1b832013-01-07 09:53:42 -0800104 status_t setParameters(const String8& keyValuePairs);
Mikhail Naganovac917ac2018-11-28 14:03:52 -0800105 status_t selectPresentation(int presentationId, int programId);
Eric Laurent81784c32012-11-19 14:55:58 -0800106 status_t attachAuxEffect(int EffectId);
107 void setAuxBuffer(int EffectId, int32_t *buffer);
108 int32_t *auxBuffer() const { return mAuxBuffer; }
rago94a1ee82017-07-21 15:11:02 -0700109 void setMainBuffer(effect_buffer_t *buffer) { mMainBuffer = buffer; }
110 effect_buffer_t *mainBuffer() const { return mMainBuffer; }
Eric Laurent81784c32012-11-19 14:55:58 -0800111 int auxEffectId() const { return mAuxEffectId; }
Glenn Kasten573d80a2013-08-26 09:36:23 -0700112 virtual status_t getTimestamp(AudioTimestamp& timestamp);
Eric Laurent59fe0102013-09-27 18:48:26 -0700113 void signal();
Eric Laurent81784c32012-11-19 14:55:58 -0800114
115// implement FastMixerState::VolumeProvider interface
Glenn Kastenc56f3422014-03-21 17:53:17 -0700116 virtual gain_minifloat_packed_t getVolumeLR();
Eric Laurent81784c32012-11-19 14:55:58 -0800117
118 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
119
Eric Laurent05067782016-06-01 18:27:28 -0700120 virtual bool isFastTrack() const { return (mFlags & AUDIO_OUTPUT_FLAG_FAST) != 0; }
121
Andy Hungcef2daa2018-06-01 15:31:49 -0700122 double bufferLatencyMs() const override {
123 return isStatic() ? 0. : TrackBase::bufferLatencyMs();
124 }
Andy Hungf6ab58d2018-05-25 12:50:39 -0700125
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800126// implement volume handling.
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700127 media::VolumeShaper::Status applyVolumeShaper(
128 const sp<media::VolumeShaper::Configuration>& configuration,
129 const sp<media::VolumeShaper::Operation>& operation);
130 sp<media::VolumeShaper::State> getVolumeShaperState(int id);
131 sp<media::VolumeHandler> getVolumeHandler() { return mVolumeHandler; }
Kevin Rocard12381092018-04-11 09:19:59 -0700132 /** Set the computed normalized final volume of the track.
133 * !masterMute * masterVolume * streamVolume * averageLRVolume */
134 void setFinalVolume(float volume);
135 float getFinalVolume() const { return mFinalVolume; }
136
137 /** @return true if the track has changed (metadata or volume) since
138 * the last time this function was called,
139 * true if this function was never called since the track creation,
140 * false otherwise.
141 * Thread safe.
142 */
143 bool readAndClearHasChanged() { return !mChangeNotified.test_and_set(); }
144
145 using SourceMetadatas = std::vector<playback_track_metadata_t>;
146 using MetadataInserter = std::back_insert_iterator<SourceMetadatas>;
147 /** Copy the track metadata in the provided iterator. Thread safe. */
148 virtual void copyMetadataTo(MetadataInserter& backInserter) const;
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800149
jiabin245cdd92018-12-07 17:55:15 -0800150 /** Return haptic playback of the track is enabled or not, used in mixer. */
151 bool getHapticPlaybackEnabled() const { return mHapticPlaybackEnabled; }
152 /** Set haptic playback of the track is enabled or not, should be
153 * set after query or get callback from vibrator service */
154 void setHapticPlaybackEnabled(bool hapticPlaybackEnabled) {
155 mHapticPlaybackEnabled = hapticPlaybackEnabled;
156 }
jiabin77270b82018-12-18 15:41:29 -0800157 /** Return at what intensity to play haptics, used in mixer. */
158 AudioMixer::haptic_intensity_t getHapticIntensity() const { return mHapticIntensity; }
159 /** Set intensity of haptic playback, should be set after querying vibrator service. */
160 void setHapticIntensity(AudioMixer::haptic_intensity_t hapticIntensity) {
161 if (AudioMixer::isValidHapticIntensity(hapticIntensity)) {
162 mHapticIntensity = hapticIntensity;
jiabinbf6b0ec2019-02-12 12:30:12 -0800163 setHapticPlaybackEnabled(mHapticIntensity != AudioMixer::HAPTIC_SCALE_MUTE);
jiabin77270b82018-12-18 15:41:29 -0800164 }
165 }
jiabin57303cc2018-12-18 15:45:57 -0800166 sp<os::ExternalVibration> getExternalVibration() const { return mExternalVibration; }
jiabin245cdd92018-12-07 17:55:15 -0800167
Kevin Rocard153f92d2018-12-18 18:33:28 -0800168 void setTeePatches(TeePatches teePatches);
169
Eric Laurent81784c32012-11-19 14:55:58 -0800170protected:
171 // for numerous
172 friend class PlaybackThread;
173 friend class MixerThread;
174 friend class DirectOutputThread;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800175 friend class OffloadThread;
Eric Laurent81784c32012-11-19 14:55:58 -0800176
Mikhail Naganovbf493082017-04-17 17:37:12 -0700177 DISALLOW_COPY_AND_ASSIGN(Track);
Eric Laurent81784c32012-11-19 14:55:58 -0800178
179 // AudioBufferProvider interface
Kevin Rocard153f92d2018-12-18 18:33:28 -0800180 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override;
181 void releaseBuffer(AudioBufferProvider::Buffer* buffer) override;
Eric Laurent81784c32012-11-19 14:55:58 -0800182
Glenn Kasten6466c9e2013-08-23 10:54:07 -0700183 // ExtendedAudioBufferProvider interface
Eric Laurent81784c32012-11-19 14:55:58 -0800184 virtual size_t framesReady() const;
Andy Hung818e7a32016-02-16 18:08:07 -0800185 virtual int64_t framesReleased() const;
186 virtual void onTimestamp(const ExtendedTimestamp &timestamp);
Eric Laurent81784c32012-11-19 14:55:58 -0800187
Glenn Kastenc9b2e202013-02-26 11:32:32 -0800188 bool isPausing() const { return mState == PAUSING; }
189 bool isPaused() const { return mState == PAUSED; }
190 bool isResuming() const { return mState == RESUMING; }
Eric Laurent81784c32012-11-19 14:55:58 -0800191 bool isReady() const;
192 void setPaused() { mState = PAUSED; }
193 void reset();
Haynes Mathew George7844f672014-01-15 12:32:55 -0800194 bool isFlushPending() const { return mFlushHwPending; }
195 void flushAck();
Krishnankutty Kolathappilly8d6c2922014-02-04 16:23:42 -0800196 bool isResumePending();
197 void resumeAck();
Andy Hung818e7a32016-02-16 18:08:07 -0800198 void updateTrackFrameInfo(int64_t trackFramesReleased, int64_t sinkFramesWritten,
Andy Hungcef2daa2018-06-01 15:31:49 -0700199 uint32_t halSampleRate, const ExtendedTimestamp &timeStamp);
Eric Laurent81784c32012-11-19 14:55:58 -0800200
Eric Laurent81784c32012-11-19 14:55:58 -0800201 sp<IMemory> sharedBuffer() const { return mSharedBuffer; }
202
203 // framesWritten is cumulative, never reset, and is shared all tracks
204 // audioHalFrames is derived from output latency
205 // FIXME parameters not needed, could get them from the thread
Andy Hung818e7a32016-02-16 18:08:07 -0800206 bool presentationComplete(int64_t framesWritten, size_t audioHalFrames);
Eric Laurent4d231dc2016-03-11 18:38:23 -0800207 void signalClientFlag(int32_t flag);
Eric Laurent81784c32012-11-19 14:55:58 -0800208
Kevin Rocard12381092018-04-11 09:19:59 -0700209 /** Set that a metadata has changed and needs to be notified to backend. Thread safe. */
210 void setMetadataHasChanged() { mChangeNotified.clear(); }
Eric Laurent81784c32012-11-19 14:55:58 -0800211public:
212 void triggerEvents(AudioSystem::sync_event_t type);
Eric Laurent6acd1d42017-01-04 14:23:29 -0800213 virtual void invalidate();
Eric Laurent4d231dc2016-03-11 18:38:23 -0800214 void disable();
215
Glenn Kastend054c322013-07-12 12:59:20 -0700216 int fastIndex() const { return mFastIndex; }
Eric Laurent81784c32012-11-19 14:55:58 -0800217
Mikhail Naganovf7e3a3a2019-04-22 16:43:26 -0700218 bool isPlaybackRestricted() const {
219 // The monitor is only created for tracks that can be silenced.
220 return mOpPlayAudioMonitor ? !mOpPlayAudioMonitor->hasOpPlayAudio() : false; }
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800221
Eric Laurent81784c32012-11-19 14:55:58 -0800222protected:
223
Eric Laurent81784c32012-11-19 14:55:58 -0800224 // FILLED state is used for suppressing volume ramp at begin of playing
225 enum {FS_INVALID, FS_FILLING, FS_FILLED, FS_ACTIVE};
226 mutable uint8_t mFillingUpStatus;
227 int8_t mRetryCount;
Glenn Kasten0c72b242013-09-11 09:14:16 -0700228
229 // see comment at AudioFlinger::PlaybackThread::Track::~Track for why this can't be const
230 sp<IMemory> mSharedBuffer;
231
Eric Laurent81784c32012-11-19 14:55:58 -0800232 bool mResetDone;
233 const audio_stream_type_t mStreamType;
rago94a1ee82017-07-21 15:11:02 -0700234 effect_buffer_t *mMainBuffer;
235
Eric Laurent81784c32012-11-19 14:55:58 -0800236 int32_t *mAuxBuffer;
237 int mAuxEffectId;
238 bool mHasVolumeController;
239 size_t mPresentationCompleteFrames; // number of frames written to the
240 // audio HAL when this track will be fully rendered
241 // zero means not monitoring
Andy Hunge10393e2015-06-12 13:59:33 -0700242
243 // access these three variables only when holding thread lock.
Andy Hung818e7a32016-02-16 18:08:07 -0800244 LinearMap<int64_t> mFrameMap; // track frame to server frame mapping
245
246 ExtendedTimestamp mSinkTimestamp;
Andy Hunge10393e2015-06-12 13:59:33 -0700247
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700248 sp<media::VolumeHandler> mVolumeHandler; // handles multiple VolumeShaper configs and operations
Andy Hung9fc8b5c2017-01-24 13:36:48 -0800249
Jean-Michel Trivi74e01fa2019-02-25 12:18:09 -0800250 sp<OpPlayAudioMonitor> mOpPlayAudioMonitor;
251
jiabin245cdd92018-12-07 17:55:15 -0800252 bool mHapticPlaybackEnabled = false; // indicates haptic playback enabled or not
jiabin77270b82018-12-18 15:41:29 -0800253 // intensity to play haptic data
jiabinbf6b0ec2019-02-12 12:30:12 -0800254 AudioMixer::haptic_intensity_t mHapticIntensity = AudioMixer::HAPTIC_SCALE_MUTE;
jiabin57303cc2018-12-18 15:45:57 -0800255 class AudioVibrationController : public os::BnExternalVibrationController {
256 public:
257 explicit AudioVibrationController(Track* track) : mTrack(track) {}
258 binder::Status mute(/*out*/ bool *ret) override;
259 binder::Status unmute(/*out*/ bool *ret) override;
260 private:
261 Track* const mTrack;
262 };
263 sp<AudioVibrationController> mAudioVibrationController;
264 sp<os::ExternalVibration> mExternalVibration;
jiabin245cdd92018-12-07 17:55:15 -0800265
Eric Laurent81784c32012-11-19 14:55:58 -0800266private:
Kevin Rocard153f92d2018-12-18 18:33:28 -0800267 void interceptBuffer(const AudioBufferProvider::Buffer& buffer);
Kevin Rocarda134b002019-02-07 18:05:31 -0800268 /** Write the source data in the buffer provider. @return written frame count. */
269 size_t writeFrames(AudioBufferProvider* dest, const void* src, size_t frameCount);
Kevin Rocardc43ea142019-01-31 18:17:37 -0800270 template <class F>
271 void forEachTeePatchTrack(F f) {
272 for (auto& tp : mTeePatches) { f(tp.patchTrack); }
273 };
Kevin Rocard153f92d2018-12-18 18:33:28 -0800274
Eric Laurent81784c32012-11-19 14:55:58 -0800275 // The following fields are only for fast tracks, and should be in a subclass
276 int mFastIndex; // index within FastMixerState::mFastTracks[];
277 // either mFastIndex == -1 if not isFastTrack()
278 // or 0 < mFastIndex < FastMixerState::kMaxFast because
279 // index 0 is reserved for normal mixer's submix;
280 // index is allocated statically at track creation time
281 // but the slot is only used if track is active
282 FastTrackUnderruns mObservedUnderruns; // Most recently observed value of
283 // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns
Eric Laurent81784c32012-11-19 14:55:58 -0800284 volatile float mCachedVolume; // combined master volume and stream type volume;
285 // 'volatile' means accessed without lock or
286 // barrier, but is read/written atomically
Kevin Rocard12381092018-04-11 09:19:59 -0700287 float mFinalVolume; // combine master volume, stream type volume and track volume
Eric Laurent5bba2f62016-03-18 11:14:14 -0700288 sp<AudioTrackServerProxy> mAudioTrackServerProxy;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800289 bool mResumeToStopping; // track was paused in stopping state.
Haynes Mathew George7844f672014-01-15 12:32:55 -0800290 bool mFlushHwPending; // track requests for thread flush
Eric Laurent05067782016-06-01 18:27:28 -0700291 audio_output_flags_t mFlags;
Kevin Rocard12381092018-04-11 09:19:59 -0700292 // If the last track change was notified to the client with readAndClearHasChanged
293 std::atomic_flag mChangeNotified = ATOMIC_FLAG_INIT;
Kevin Rocard153f92d2018-12-18 18:33:28 -0800294 TeePatches mTeePatches;
Eric Laurent81784c32012-11-19 14:55:58 -0800295}; // end of Track
296
Eric Laurent81784c32012-11-19 14:55:58 -0800297
298// playback track, used by DuplicatingThread
299class OutputTrack : public Track {
300public:
301
302 class Buffer : public AudioBufferProvider::Buffer {
303 public:
Andy Hungc25b84a2015-01-14 19:04:10 -0800304 void *mBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -0800305 };
306
307 OutputTrack(PlaybackThread *thread,
308 DuplicatingThread *sourceThread,
309 uint32_t sampleRate,
310 audio_format_t format,
311 audio_channel_mask_t channelMask,
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800312 size_t frameCount,
Andy Hung1f12a8a2016-11-07 16:10:30 -0800313 uid_t uid);
Eric Laurent81784c32012-11-19 14:55:58 -0800314 virtual ~OutputTrack();
315
316 virtual status_t start(AudioSystem::sync_event_t event =
317 AudioSystem::SYNC_EVENT_NONE,
Glenn Kastend848eb42016-03-08 13:42:11 -0800318 audio_session_t triggerSession = AUDIO_SESSION_NONE);
Eric Laurent81784c32012-11-19 14:55:58 -0800319 virtual void stop();
Andy Hung1c86ebe2018-05-29 20:29:08 -0700320 ssize_t write(void* data, uint32_t frames);
Eric Laurent81784c32012-11-19 14:55:58 -0800321 bool bufferQueueEmpty() const { return mBufferQueue.size() == 0; }
322 bool isActive() const { return mActive; }
323 const wp<ThreadBase>& thread() const { return mThread; }
324
Kevin Rocard12381092018-04-11 09:19:59 -0700325 void copyMetadataTo(MetadataInserter& backInserter) const override;
326 /** Set the metadatas of the upstream tracks. Thread safe. */
327 void setMetadatas(const SourceMetadatas& metadatas);
Andy Hung1c86ebe2018-05-29 20:29:08 -0700328 /** returns client timestamp to the upstream duplicating thread. */
329 ExtendedTimestamp getClientProxyTimestamp() const {
330 // server - kernel difference is not true latency when drained
331 // i.e. mServerProxy->isDrained().
332 ExtendedTimestamp timestamp;
333 (void) mClientProxy->getTimestamp(&timestamp);
334 // On success, the timestamp LOCATION_SERVER and LOCATION_KERNEL
335 // entries will be properly filled. If getTimestamp()
336 // is unsuccessful, then a default initialized timestamp
337 // (with mTimeNs[] filled with -1's) is returned.
338 return timestamp;
339 }
Kevin Rocard80ee2722018-04-11 15:53:48 +0000340
Kevin Rocard12381092018-04-11 09:19:59 -0700341private:
Eric Laurent81784c32012-11-19 14:55:58 -0800342 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer,
343 uint32_t waitTimeMs);
344 void clearBufferQueue();
345
Eric Laurent4d231dc2016-03-11 18:38:23 -0800346 void restartIfDisabled();
347
Eric Laurent81784c32012-11-19 14:55:58 -0800348 // Maximum number of pending buffers allocated by OutputTrack::write()
349 static const uint8_t kMaxOverFlowBuffers = 10;
350
351 Vector < Buffer* > mBufferQueue;
352 AudioBufferProvider::Buffer mOutBuffer;
353 bool mActive;
Eric Laurent5bba2f62016-03-18 11:14:14 -0700354 DuplicatingThread* const mSourceThread; // for waitTimeMs() in write()
355 sp<AudioTrackClientProxy> mClientProxy;
Andy Hung1c86ebe2018-05-29 20:29:08 -0700356
Kevin Rocard12381092018-04-11 09:19:59 -0700357 /** Attributes of the source tracks.
358 *
359 * This member must be accessed with mTrackMetadatasMutex taken.
360 * There is one writer (duplicating thread) and one reader (downstream mixer).
361 *
362 * That means that the duplicating thread can block the downstream mixer
363 * thread and vice versa for the time of the copy.
364 * If this becomes an issue, the metadata could be stored in an atomic raw pointer,
365 * and a exchange with nullptr and delete can be used.
366 * Alternatively a read-copy-update might be implemented.
367 */
368 SourceMetadatas mTrackMetadatas;
369 /** Protects mTrackMetadatas against concurrent access. */
370 mutable std::mutex mTrackMetadatasMutex;
Eric Laurent81784c32012-11-19 14:55:58 -0800371}; // end of OutputTrack
Eric Laurent83b88082014-06-20 18:31:16 -0700372
373// playback track, used by PatchPanel
Kevin Rocard45986c72018-12-18 18:22:59 -0800374class PatchTrack : public Track, public PatchTrackBase {
Eric Laurent83b88082014-06-20 18:31:16 -0700375public:
376
377 PatchTrack(PlaybackThread *playbackThread,
Eric Laurent3bcf8592015-04-03 12:13:24 -0700378 audio_stream_type_t streamType,
Eric Laurent83b88082014-06-20 18:31:16 -0700379 uint32_t sampleRate,
380 audio_channel_mask_t channelMask,
381 audio_format_t format,
382 size_t frameCount,
383 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -0700384 size_t bufferSize,
Kevin Rocard45986c72018-12-18 18:22:59 -0800385 audio_output_flags_t flags,
386 const Timeout& timeout = {});
Eric Laurent83b88082014-06-20 18:31:16 -0700387 virtual ~PatchTrack();
388
Eric Laurent4d231dc2016-03-11 18:38:23 -0800389 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 Laurent4d231dc2016-03-11 18:38:23 -0800392
Eric Laurent83b88082014-06-20 18:31:16 -0700393 // AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -0800394 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
Eric Laurent83b88082014-06-20 18:31:16 -0700395 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
396
397 // PatchProxyBufferProvider interface
398 virtual status_t obtainBuffer(Proxy::Buffer* buffer,
399 const struct timespec *timeOut = NULL);
400 virtual void releaseBuffer(Proxy::Buffer* buffer);
401
Eric Laurent83b88082014-06-20 18:31:16 -0700402private:
Eric Laurent4d231dc2016-03-11 18:38:23 -0800403 void restartIfDisabled();
404
Eric Laurent83b88082014-06-20 18:31:16 -0700405}; // end of PatchTrack