blob: f305aa8c4068c8a8db034b7ee0c2c1eef35a327f [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
22// base for record and playback
23class TrackBase : public ExtendedAudioBufferProvider, public RefBase {
24
25public:
Andy Hung959b5b82021-09-24 10:46:20 -070026 enum track_state : int32_t {
Eric Laurent81784c32012-11-19 14:55:58 -080027 IDLE,
Andy Hungce685402018-10-05 17:23:27 -070028 FLUSHED, // for PlaybackTracks only
Eric Laurent81784c32012-11-19 14:55:58 -080029 STOPPED,
Eric Laurentbfb1b832013-01-07 09:53:42 -080030 // next 2 states are currently used for fast tracks
31 // and offloaded tracks only
Eric Laurent81784c32012-11-19 14:55:58 -080032 STOPPING_1, // waiting for first underrun
33 STOPPING_2, // waiting for presentation complete
Andy Hungce685402018-10-05 17:23:27 -070034 RESUMING, // for PlaybackTracks only
Eric Laurent81784c32012-11-19 14:55:58 -080035 ACTIVE,
36 PAUSING,
Glenn Kasten6dd62fb2013-12-05 16:35:58 -080037 PAUSED,
38 STARTING_1, // for RecordTrack only
39 STARTING_2, // for RecordTrack only
Eric Laurent81784c32012-11-19 14:55:58 -080040 };
41
Glenn Kasten6181ffd2014-05-13 10:41:52 -070042 // where to allocate the data buffer
43 enum alloc_type {
44 ALLOC_CBLK, // allocate immediately after control block
45 ALLOC_READONLY, // allocate from a separate read-only heap per thread
46 ALLOC_PIPE, // do not allocate; use the pipe buffer
Eric Laurent83b88082014-06-20 18:31:16 -070047 ALLOC_LOCAL, // allocate a local buffer
48 ALLOC_NONE, // do not allocate:use the buffer passed to TrackBase constructor
49 };
50
51 enum track_type {
52 TYPE_DEFAULT,
Eric Laurent83b88082014-06-20 18:31:16 -070053 TYPE_OUTPUT,
54 TYPE_PATCH,
Glenn Kasten6181ffd2014-05-13 10:41:52 -070055 };
56
Eric Laurent81784c32012-11-19 14:55:58 -080057 TrackBase(ThreadBase *thread,
58 const sp<Client>& client,
Kevin Rocard1f564ac2018-03-29 13:53:10 -070059 const audio_attributes_t& mAttr,
Eric Laurent81784c32012-11-19 14:55:58 -080060 uint32_t sampleRate,
61 audio_format_t format,
62 audio_channel_mask_t channelMask,
63 size_t frameCount,
Eric Laurent83b88082014-06-20 18:31:16 -070064 void *buffer,
Andy Hung8fe68032017-06-05 16:17:51 -070065 size_t bufferSize,
Glenn Kastend848eb42016-03-08 13:42:11 -080066 audio_session_t sessionId,
Eric Laurent09f1ed22019-04-24 17:45:17 -070067 pid_t creatorPid,
Andy Hung1f12a8a2016-11-07 16:10:30 -080068 uid_t uid,
Glenn Kastend776ac62014-05-07 09:16:09 -070069 bool isOut,
Eric Laurent83b88082014-06-20 18:31:16 -070070 alloc_type alloc = ALLOC_CBLK,
Eric Laurent20b9ef02016-12-05 11:03:16 -080071 track_type type = TYPE_DEFAULT,
Andy Hungb68f5eb2019-12-03 16:49:17 -080072 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE,
73 std::string metricsId = {});
Eric Laurent81784c32012-11-19 14:55:58 -080074 virtual ~TrackBase();
Eric Laurent83b88082014-06-20 18:31:16 -070075 virtual status_t initCheck() const;
Eric Laurent81784c32012-11-19 14:55:58 -080076
77 virtual status_t start(AudioSystem::sync_event_t event,
Glenn Kastend848eb42016-03-08 13:42:11 -080078 audio_session_t triggerSession) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -080079 virtual void stop() = 0;
80 sp<IMemory> getCblk() const { return mCblkMemory; }
81 audio_track_cblk_t* cblk() const { return mCblk; }
Glenn Kastend848eb42016-03-08 13:42:11 -080082 audio_session_t sessionId() const { return mSessionId; }
Andy Hung1f12a8a2016-11-07 16:10:30 -080083 uid_t uid() const { return mUid; }
Eric Laurent09f1ed22019-04-24 17:45:17 -070084 pid_t creatorPid() const { return mCreatorPid; }
85
Eric Laurent6acd1d42017-01-04 14:23:29 -080086 audio_port_handle_t portId() const { return mPortId; }
Eric Laurent81784c32012-11-19 14:55:58 -080087 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
88
Glenn Kastend776ac62014-05-07 09:16:09 -070089 sp<IMemory> getBuffers() const { return mBufferMemory; }
Eric Laurent83b88082014-06-20 18:31:16 -070090 void* buffer() const { return mBuffer; }
Andy Hung8fe68032017-06-05 16:17:51 -070091 size_t bufferSize() const { return mBufferSize; }
Eric Laurent05067782016-06-01 18:27:28 -070092 virtual bool isFastTrack() const = 0;
Mikhail Naganov7c6ae982018-06-14 12:33:38 -070093 virtual bool isDirect() const = 0;
Eric Laurent83b88082014-06-20 18:31:16 -070094 bool isOutputTrack() const { return (mType == TYPE_OUTPUT); }
95 bool isPatchTrack() const { return (mType == TYPE_PATCH); }
96 bool isExternalTrack() const { return !isOutputTrack() && !isPatchTrack(); }
Glenn Kastend776ac62014-05-07 09:16:09 -070097
Andy Hungb68f5eb2019-12-03 16:49:17 -080098 virtual void invalidate() {
99 if (mIsInvalid) return;
Andy Hungc2b11cb2020-04-22 09:04:01 -0700100 mTrackMetrics.logInvalidate();
Andy Hungb68f5eb2019-12-03 16:49:17 -0800101 mIsInvalid = true;
102 }
Eric Laurent6acd1d42017-01-04 14:23:29 -0800103 bool isInvalid() const { return mIsInvalid; }
104
Andy Hungc3d62f92019-03-14 13:38:51 -0700105 void terminate() { mTerminated = true; }
106 bool isTerminated() const { return mTerminated; }
107
Kevin Rocard069c2712018-03-29 19:09:14 -0700108 audio_attributes_t attributes() const { return mAttr; }
Eric Laurent6acd1d42017-01-04 14:23:29 -0800109
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200110 virtual bool isSpatialized() const { return false; }
Eric Laurentb62d0362021-10-26 17:40:18 +0200111
jiabinc658e452022-10-21 20:52:21 +0000112 virtual bool isBitPerfect() const { return false; }
113
Andy Hung8946a282018-04-19 20:04:56 -0700114#ifdef TEE_SINK
115 void dumpTee(int fd, const std::string &reason) const {
116 mTee.dump(fd, reason);
117 }
118#endif
119
Andy Hungcef2daa2018-06-01 15:31:49 -0700120 /** returns the buffer contents size converted to time in milliseconds
121 * for PCM Playback or Record streaming tracks. The return value is zero for
122 * PCM static tracks and not defined for non-PCM tracks.
123 *
124 * This may be called without the thread lock.
125 */
126 virtual double bufferLatencyMs() const {
127 return mServerProxy->framesReadySafe() * 1000 / sampleRate();
128 }
129
130 /** returns whether the track supports server latency computation.
131 * This is set in the constructor and constant throughout the track lifetime.
132 */
133
134 bool isServerLatencySupported() const { return mServerLatencySupported; }
135
136 /** computes the server latency for PCM Playback or Record track
137 * to the device sink/source. This is the time for the next frame in the track buffer
138 * written or read from the server thread to the device source or sink.
139 *
140 * This may be called without the thread lock, but latencyMs and fromTrack
141 * may be not be synchronized. For example PatchPanel may not obtain the
142 * thread lock before calling.
143 *
144 * \param latencyMs on success is set to the latency in milliseconds of the
145 * next frame written/read by the server thread to/from the track buffer
146 * from the device source/sink.
147 * \param fromTrack on success is set to true if latency was computed directly
148 * from the track timestamp; otherwise set to false if latency was
149 * estimated from the server timestamp.
150 * fromTrack may be nullptr or omitted if not required.
151 *
152 * \returns OK or INVALID_OPERATION on failure.
153 */
154 status_t getServerLatencyMs(double *latencyMs, bool *fromTrack = nullptr) const {
155 if (!isServerLatencySupported()) {
156 return INVALID_OPERATION;
157 }
158
159 // if no thread lock is acquired, these atomics are not
160 // synchronized with each other, considered a benign race.
161
162 const double serverLatencyMs = mServerLatencyMs.load();
163 if (serverLatencyMs == 0.) {
164 return INVALID_OPERATION;
165 }
166 if (fromTrack != nullptr) {
167 *fromTrack = mServerLatencyFromTrack.load();
168 }
169 *latencyMs = serverLatencyMs;
170 return OK;
171 }
172
173 /** computes the total client latency for PCM Playback or Record tracks
174 * for the next client app access to the device sink/source; i.e. the
175 * server latency plus the buffer latency.
176 *
177 * This may be called without the thread lock, but latencyMs and fromTrack
178 * may be not be synchronized. For example PatchPanel may not obtain the
179 * thread lock before calling.
180 *
181 * \param latencyMs on success is set to the latency in milliseconds of the
182 * next frame written/read by the client app to/from the track buffer
183 * from the device sink/source.
184 * \param fromTrack on success is set to true if latency was computed directly
185 * from the track timestamp; otherwise set to false if latency was
186 * estimated from the server timestamp.
187 * fromTrack may be nullptr or omitted if not required.
188 *
189 * \returns OK or INVALID_OPERATION on failure.
190 */
191 status_t getTrackLatencyMs(double *latencyMs, bool *fromTrack = nullptr) const {
192 double serverLatencyMs;
193 status_t status = getServerLatencyMs(&serverLatencyMs, fromTrack);
194 if (status == OK) {
195 *latencyMs = serverLatencyMs + bufferLatencyMs();
196 }
197 return status;
198 }
199
Andy Hung30282562018-08-08 18:27:03 -0700200 // TODO: Consider making this external.
201 struct FrameTime {
202 int64_t frames;
203 int64_t timeNs;
204 };
205
206 // KernelFrameTime is updated per "mix" period even for non-pcm tracks.
207 void getKernelFrameTime(FrameTime *ft) const {
208 *ft = mKernelFrameTime.load();
209 }
210
211 audio_format_t format() const { return mFormat; }
Andy Hungc0691382018-09-12 18:01:57 -0700212 int id() const { return mId; }
Andy Hung30282562018-08-08 18:27:03 -0700213
Andy Hunge2e830f2019-12-03 12:54:46 -0800214 const char *getTrackStateAsString() const {
215 if (isTerminated()) {
216 return "TERMINATED";
217 }
218 switch (mState) {
219 case IDLE:
220 return "IDLE";
221 case STOPPING_1: // for Fast and Offload
222 return "STOPPING_1";
223 case STOPPING_2: // for Fast and Offload
224 return "STOPPING_2";
225 case STOPPED:
226 return "STOPPED";
227 case RESUMING:
228 return "RESUMING";
229 case ACTIVE:
230 return "ACTIVE";
231 case PAUSING:
232 return "PAUSING";
233 case PAUSED:
234 return "PAUSED";
235 case FLUSHED:
236 return "FLUSHED";
237 case STARTING_1: // for RecordTrack
238 return "STARTING_1";
239 case STARTING_2: // for RecordTrack
240 return "STARTING_2";
241 default:
242 return "UNKNOWN";
243 }
244 }
245
Andy Hungc2b11cb2020-04-22 09:04:01 -0700246 // Called by the PlaybackThread to indicate that the track is becoming active
247 // and a new interval should start with a given device list.
248 void logBeginInterval(const std::string& devices) {
249 mTrackMetrics.logBeginInterval(devices);
250 }
251
252 // Called by the PlaybackThread to indicate the track is no longer active.
253 void logEndInterval() {
254 mTrackMetrics.logEndInterval();
255 }
256
257 // Called to tally underrun frames in playback.
258 virtual void tallyUnderrunFrames(size_t /* frames */) {}
259
Eric Laurent94579172020-11-20 18:41:04 +0100260 audio_channel_mask_t channelMask() const { return mChannelMask; }
261
Jasmine Chaeaa10e42021-05-11 10:11:14 +0800262 /** @return true if the track has changed (metadata or volume) since
263 * the last time this function was called,
264 * true if this function was never called since the track creation,
265 * false otherwise.
266 * Thread safe.
267 */
268 bool readAndClearHasChanged() { return !mChangeNotified.test_and_set(); }
269
270 /** Set that a metadata has changed and needs to be notified to backend. Thread safe. */
271 void setMetadataHasChanged() { mChangeNotified.clear(); }
272
Eric Laurent81784c32012-11-19 14:55:58 -0800273protected:
Mikhail Naganovbf493082017-04-17 17:37:12 -0700274 DISALLOW_COPY_AND_ASSIGN(TrackBase);
Eric Laurent81784c32012-11-19 14:55:58 -0800275
Andy Hung689e82c2019-08-21 17:53:17 -0700276 void releaseCblk() {
277 if (mCblk != nullptr) {
Andy Hung959b5b82021-09-24 10:46:20 -0700278 mState.clear();
Andy Hung689e82c2019-08-21 17:53:17 -0700279 mCblk->~audio_track_cblk_t(); // destroy our shared-structure.
280 if (mClient == 0) {
281 free(mCblk);
282 }
283 mCblk = nullptr;
284 }
285 }
286
Eric Laurent81784c32012-11-19 14:55:58 -0800287 // AudioBufferProvider interface
Glenn Kastend79072e2016-01-06 08:41:20 -0800288 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800289 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
290
291 // ExtendedAudioBufferProvider interface is only needed for Track,
292 // but putting it in TrackBase avoids the complexity of virtual inheritance
293 virtual size_t framesReady() const { return SIZE_MAX; }
294
Eric Laurent81784c32012-11-19 14:55:58 -0800295 uint32_t channelCount() const { return mChannelCount; }
296
Jean-Michel Trividdf87ef2019-08-20 15:42:04 -0700297 size_t frameSize() const { return mFrameSize; }
298
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800299 virtual uint32_t sampleRate() const { return mSampleRate; }
Eric Laurent81784c32012-11-19 14:55:58 -0800300
Eric Laurent81784c32012-11-19 14:55:58 -0800301 bool isStopped() const {
302 return (mState == STOPPED || mState == FLUSHED);
303 }
304
Eric Laurentbfb1b832013-01-07 09:53:42 -0800305 // for fast tracks and offloaded tracks only
Eric Laurent81784c32012-11-19 14:55:58 -0800306 bool isStopping() const {
307 return mState == STOPPING_1 || mState == STOPPING_2;
308 }
309 bool isStopping_1() const {
310 return mState == STOPPING_1;
311 }
312 bool isStopping_2() const {
313 return mState == STOPPING_2;
314 }
315
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700316 // Upper case characters are final states.
317 // Lower case characters are transitory.
Andy Hunge2e830f2019-12-03 12:54:46 -0800318 const char *getTrackStateAsCodedString() const {
Andy Hung2c6c3bb2017-06-16 14:01:45 -0700319 if (isTerminated()) {
320 return "T ";
321 }
322 switch (mState) {
323 case IDLE:
324 return "I ";
325 case STOPPING_1: // for Fast and Offload
326 return "s1";
327 case STOPPING_2: // for Fast and Offload
328 return "s2";
329 case STOPPED:
330 return "S ";
331 case RESUMING:
332 return "r ";
333 case ACTIVE:
334 return "A ";
335 case PAUSING:
336 return "p ";
337 case PAUSED:
338 return "P ";
339 case FLUSHED:
340 return "F ";
341 case STARTING_1: // for RecordTrack
342 return "r1";
343 case STARTING_2: // for RecordTrack
344 return "r2";
345 default:
346 return "? ";
347 }
348 }
349
Glenn Kastene3aa6592012-12-04 12:22:46 -0800350 bool isOut() const { return mIsOut; }
Glenn Kastend79072e2016-01-06 08:41:20 -0800351 // true for Track, false for RecordTrack,
Eric Laurent81784c32012-11-19 14:55:58 -0800352 // this could be a track type if needed later
353
354 const wp<ThreadBase> mThread;
355 /*const*/ sp<Client> mClient; // see explanation at ~TrackBase() why not const
356 sp<IMemory> mCblkMemory;
357 audio_track_cblk_t* mCblk;
Glenn Kastend776ac62014-05-07 09:16:09 -0700358 sp<IMemory> mBufferMemory; // currently non-0 for fast RecordTrack only
Eric Laurent81784c32012-11-19 14:55:58 -0800359 void* mBuffer; // start of track buffer, typically in shared memory
Glenn Kastene3aa6592012-12-04 12:22:46 -0800360 // except for OutputTrack when it is in local memory
Andy Hung8fe68032017-06-05 16:17:51 -0700361 size_t mBufferSize; // size of mBuffer in bytes
Eric Laurent81784c32012-11-19 14:55:58 -0800362 // we don't really need a lock for these
Andy Hung959b5b82021-09-24 10:46:20 -0700363 MirroredVariable<track_state> mState;
Kevin Rocard1f564ac2018-03-29 13:53:10 -0700364 const audio_attributes_t mAttr;
Eric Laurent81784c32012-11-19 14:55:58 -0800365 const uint32_t mSampleRate; // initial sample rate only; for tracks which
366 // support dynamic rates, the current value is in control block
367 const audio_format_t mFormat;
368 const audio_channel_mask_t mChannelMask;
Glenn Kastenf6ed4232013-07-16 11:16:27 -0700369 const uint32_t mChannelCount;
Eric Laurent81784c32012-11-19 14:55:58 -0800370 const size_t mFrameSize; // AudioFlinger's view of frame size in shared memory,
371 // where for AudioTrack (but not AudioRecord),
372 // 8-bit PCM samples are stored as 16-bit
373 const size_t mFrameCount;// size of track buffer given at createTrack() or
Eric Laurentf14db3c2017-12-08 14:20:36 -0800374 // createRecord(), and then adjusted as needed
Eric Laurent81784c32012-11-19 14:55:58 -0800375
Glenn Kastend848eb42016-03-08 13:42:11 -0800376 const audio_session_t mSessionId;
Andy Hung1f12a8a2016-11-07 16:10:30 -0800377 uid_t mUid;
Eric Laurent81784c32012-11-19 14:55:58 -0800378 Vector < sp<SyncEvent> >mSyncEvents;
Glenn Kastene3aa6592012-12-04 12:22:46 -0800379 const bool mIsOut;
Eric Laurent5bba2f62016-03-18 11:14:14 -0700380 sp<ServerProxy> mServerProxy;
Glenn Kastenda6ef132013-01-10 12:31:01 -0800381 const int mId;
Andy Hung8946a282018-04-19 20:04:56 -0700382#ifdef TEE_SINK
383 NBAIO_Tee mTee;
384#endif
Eric Laurentbfb1b832013-01-07 09:53:42 -0800385 bool mTerminated;
Eric Laurent83b88082014-06-20 18:31:16 -0700386 track_type mType; // must be one of TYPE_DEFAULT, TYPE_OUTPUT, TYPE_PATCH ...
Eric Laurentaaa44472014-09-12 17:41:50 -0700387 audio_io_handle_t mThreadIoHandle; // I/O handle of the thread the track is attached to
Eric Laurent20b9ef02016-12-05 11:03:16 -0800388 audio_port_handle_t mPortId; // unique ID for this track used by audio policy
Eric Laurent6acd1d42017-01-04 14:23:29 -0800389 bool mIsInvalid; // non-resettable latch, set by invalidate()
Andy Hungcef2daa2018-06-01 15:31:49 -0700390
Andy Hungb68f5eb2019-12-03 16:49:17 -0800391 // It typically takes 5 threadloop mix iterations for latency to stabilize.
Andy Hung62921122020-05-18 10:47:31 -0700392 // However, this can be 12+ iterations for BT.
393 // To be sure, we wait for latency to dip (it usually increases at the start)
394 // to assess stability and then log to MediaMetrics.
395 // Rapid start / pause calls may cause inaccurate numbers.
396 static inline constexpr int32_t LOG_START_COUNTDOWN = 12;
397 int32_t mLogStartCountdown = 0; // Mixer period countdown
398 int64_t mLogStartTimeNs = 0; // Monotonic time at start()
399 int64_t mLogStartFrames = 0; // Timestamp frames at start()
400 double mLogLatencyMs = 0.; // Track the last log latency
Andy Hungb68f5eb2019-12-03 16:49:17 -0800401
Andy Hunga81a4b42022-05-19 19:24:51 -0700402 bool mLogForceVolumeUpdate = true; // force volume update to TrackMetrics.
403
Andy Hungc2b11cb2020-04-22 09:04:01 -0700404 TrackMetrics mTrackMetrics;
Andy Hungb68f5eb2019-12-03 16:49:17 -0800405
Andy Hungcef2daa2018-06-01 15:31:49 -0700406 bool mServerLatencySupported = false;
407 std::atomic<bool> mServerLatencyFromTrack{}; // latency from track or server timestamp.
408 std::atomic<double> mServerLatencyMs{}; // last latency pushed from server thread.
Andy Hung30282562018-08-08 18:27:03 -0700409 std::atomic<FrameTime> mKernelFrameTime{}; // last frame time on kernel side.
Eric Laurent09f1ed22019-04-24 17:45:17 -0700410 const pid_t mCreatorPid; // can be different from mclient->pid() for instance
411 // when created by NuPlayer on behalf of a client
Jasmine Chaeaa10e42021-05-11 10:11:14 +0800412
413 // If the last track change was notified to the client with readAndClearHasChanged
414 std::atomic_flag mChangeNotified = ATOMIC_FLAG_INIT;
Eric Laurent83b88082014-06-20 18:31:16 -0700415};
416
417// PatchProxyBufferProvider interface is implemented by PatchTrack and PatchRecord.
418// it provides buffer access methods that map those of a ClientProxy (see AudioTrackShared.h)
419class PatchProxyBufferProvider
420{
421public:
422
423 virtual ~PatchProxyBufferProvider() {}
424
Mikhail Naganovcaf59942019-09-25 14:05:29 -0700425 virtual bool producesBufferOnDemand() const = 0;
Eric Laurent83b88082014-06-20 18:31:16 -0700426 virtual status_t obtainBuffer(Proxy::Buffer* buffer,
427 const struct timespec *requested = NULL) = 0;
428 virtual void releaseBuffer(Proxy::Buffer* buffer) = 0;
Eric Laurent81784c32012-11-19 14:55:58 -0800429};
Kevin Rocard45986c72018-12-18 18:22:59 -0800430
431class PatchTrackBase : public PatchProxyBufferProvider
432{
433public:
434 using Timeout = std::optional<std::chrono::nanoseconds>;
435 PatchTrackBase(sp<ClientProxy> proxy, const ThreadBase& thread,
436 const Timeout& timeout);
437 void setPeerTimeout(std::chrono::nanoseconds timeout);
Andy Hungabfab202019-03-07 19:45:54 -0800438 template <typename T>
439 void setPeerProxy(const sp<T> &proxy, bool holdReference) {
440 mPeerReferenceHold = holdReference ? proxy : nullptr;
441 mPeerProxy = proxy.get();
442 }
443 void clearPeerProxy() {
444 mPeerReferenceHold.clear();
445 mPeerProxy = nullptr;
446 }
Kevin Rocard45986c72018-12-18 18:22:59 -0800447
Mikhail Naganovcaf59942019-09-25 14:05:29 -0700448 bool producesBufferOnDemand() const override { return false; }
449
Kevin Rocard45986c72018-12-18 18:22:59 -0800450protected:
451 const sp<ClientProxy> mProxy;
Andy Hungabfab202019-03-07 19:45:54 -0800452 sp<RefBase> mPeerReferenceHold; // keeps mPeerProxy alive during access.
Kevin Rocard45986c72018-12-18 18:22:59 -0800453 PatchProxyBufferProvider* mPeerProxy = nullptr;
454 struct timespec mPeerTimeout{};
455
456};