• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
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
23 class TrackBase : public ExtendedAudioBufferProvider, public RefBase {
24 
25 public:
26     enum track_state {
27         IDLE,
28         FLUSHED,        // for PlaybackTracks only
29         STOPPED,
30         // next 2 states are currently used for fast tracks
31         // and offloaded tracks only
32         STOPPING_1,     // waiting for first underrun
33         STOPPING_2,     // waiting for presentation complete
34         RESUMING,       // for PlaybackTracks only
35         ACTIVE,
36         PAUSING,
37         PAUSED,
38         STARTING_1,     // for RecordTrack only
39         STARTING_2,     // for RecordTrack only
40     };
41 
42     // 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
47         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,
53         TYPE_OUTPUT,
54         TYPE_PATCH,
55     };
56 
57                         TrackBase(ThreadBase *thread,
58                                 const sp<Client>& client,
59                                 const audio_attributes_t& mAttr,
60                                 uint32_t sampleRate,
61                                 audio_format_t format,
62                                 audio_channel_mask_t channelMask,
63                                 size_t frameCount,
64                                 void *buffer,
65                                 size_t bufferSize,
66                                 audio_session_t sessionId,
67                                 pid_t creatorPid,
68                                 uid_t uid,
69                                 bool isOut,
70                                 alloc_type alloc = ALLOC_CBLK,
71                                 track_type type = TYPE_DEFAULT,
72                                 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
73     virtual             ~TrackBase();
74     virtual status_t    initCheck() const;
75 
76     virtual status_t    start(AudioSystem::sync_event_t event,
77                              audio_session_t triggerSession) = 0;
78     virtual void        stop() = 0;
getCblk()79             sp<IMemory> getCblk() const { return mCblkMemory; }
cblk()80             audio_track_cblk_t* cblk() const { return mCblk; }
sessionId()81             audio_session_t sessionId() const { return mSessionId; }
uid()82             uid_t       uid() const { return mUid; }
creatorPid()83             pid_t       creatorPid() const { return mCreatorPid; }
84 
portId()85             audio_port_handle_t portId() const { return mPortId; }
86     virtual status_t    setSyncEvent(const sp<SyncEvent>& event);
87 
getBuffers()88             sp<IMemory> getBuffers() const { return mBufferMemory; }
buffer()89             void*       buffer() const { return mBuffer; }
bufferSize()90             size_t      bufferSize() const { return mBufferSize; }
91     virtual bool        isFastTrack() const = 0;
92     virtual bool        isDirect() const = 0;
isOutputTrack()93             bool        isOutputTrack() const { return (mType == TYPE_OUTPUT); }
isPatchTrack()94             bool        isPatchTrack() const { return (mType == TYPE_PATCH); }
isExternalTrack()95             bool        isExternalTrack() const { return !isOutputTrack() && !isPatchTrack(); }
96 
invalidate()97     virtual void        invalidate() { mIsInvalid = true; }
isInvalid()98             bool        isInvalid() const { return mIsInvalid; }
99 
terminate()100             void        terminate() { mTerminated = true; }
isTerminated()101             bool        isTerminated() const { return mTerminated; }
102 
attributes()103     audio_attributes_t  attributes() const { return mAttr; }
104 
105 #ifdef TEE_SINK
dumpTee(int fd,const std::string & reason)106            void         dumpTee(int fd, const std::string &reason) const {
107                                 mTee.dump(fd, reason);
108                         }
109 #endif
110 
111             /** returns the buffer contents size converted to time in milliseconds
112              * for PCM Playback or Record streaming tracks. The return value is zero for
113              * PCM static tracks and not defined for non-PCM tracks.
114              *
115              * This may be called without the thread lock.
116              */
bufferLatencyMs()117     virtual double      bufferLatencyMs() const {
118                             return mServerProxy->framesReadySafe() * 1000 / sampleRate();
119                         }
120 
121             /** returns whether the track supports server latency computation.
122              * This is set in the constructor and constant throughout the track lifetime.
123              */
124 
isServerLatencySupported()125             bool        isServerLatencySupported() const { return mServerLatencySupported; }
126 
127             /** computes the server latency for PCM Playback or Record track
128              * to the device sink/source.  This is the time for the next frame in the track buffer
129              * written or read from the server thread to the device source or sink.
130              *
131              * This may be called without the thread lock, but latencyMs and fromTrack
132              * may be not be synchronized. For example PatchPanel may not obtain the
133              * thread lock before calling.
134              *
135              * \param latencyMs on success is set to the latency in milliseconds of the
136              *        next frame written/read by the server thread to/from the track buffer
137              *        from the device source/sink.
138              * \param fromTrack on success is set to true if latency was computed directly
139              *        from the track timestamp; otherwise set to false if latency was
140              *        estimated from the server timestamp.
141              *        fromTrack may be nullptr or omitted if not required.
142              *
143              * \returns OK or INVALID_OPERATION on failure.
144              */
145             status_t    getServerLatencyMs(double *latencyMs, bool *fromTrack = nullptr) const {
146                             if (!isServerLatencySupported()) {
147                                 return INVALID_OPERATION;
148                             }
149 
150                             // if no thread lock is acquired, these atomics are not
151                             // synchronized with each other, considered a benign race.
152 
153                             const double serverLatencyMs = mServerLatencyMs.load();
154                             if (serverLatencyMs == 0.) {
155                                 return INVALID_OPERATION;
156                             }
157                             if (fromTrack != nullptr) {
158                                 *fromTrack = mServerLatencyFromTrack.load();
159                             }
160                             *latencyMs = serverLatencyMs;
161                             return OK;
162                         }
163 
164             /** computes the total client latency for PCM Playback or Record tracks
165              * for the next client app access to the device sink/source; i.e. the
166              * server latency plus the buffer latency.
167              *
168              * This may be called without the thread lock, but latencyMs and fromTrack
169              * may be not be synchronized. For example PatchPanel may not obtain the
170              * thread lock before calling.
171              *
172              * \param latencyMs on success is set to the latency in milliseconds of the
173              *        next frame written/read by the client app to/from the track buffer
174              *        from the device sink/source.
175              * \param fromTrack on success is set to true if latency was computed directly
176              *        from the track timestamp; otherwise set to false if latency was
177              *        estimated from the server timestamp.
178              *        fromTrack may be nullptr or omitted if not required.
179              *
180              * \returns OK or INVALID_OPERATION on failure.
181              */
182             status_t    getTrackLatencyMs(double *latencyMs, bool *fromTrack = nullptr) const {
183                             double serverLatencyMs;
184                             status_t status = getServerLatencyMs(&serverLatencyMs, fromTrack);
185                             if (status == OK) {
186                                 *latencyMs = serverLatencyMs + bufferLatencyMs();
187                             }
188                             return status;
189                         }
190 
191            // TODO: Consider making this external.
192            struct FrameTime {
193                int64_t frames;
194                int64_t timeNs;
195            };
196 
197            // KernelFrameTime is updated per "mix" period even for non-pcm tracks.
getKernelFrameTime(FrameTime * ft)198            void         getKernelFrameTime(FrameTime *ft) const {
199                            *ft = mKernelFrameTime.load();
200                         }
201 
format()202            audio_format_t format() const { return mFormat; }
id()203            int id() const { return mId; }
204 
205 protected:
206     DISALLOW_COPY_AND_ASSIGN(TrackBase);
207 
208     // AudioBufferProvider interface
209     virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0;
210     virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
211 
212     // ExtendedAudioBufferProvider interface is only needed for Track,
213     // but putting it in TrackBase avoids the complexity of virtual inheritance
framesReady()214     virtual size_t  framesReady() const { return SIZE_MAX; }
215 
channelCount()216     uint32_t channelCount() const { return mChannelCount; }
217 
frameSize()218     size_t frameSize() const { return mFrameSize; }
219 
channelMask()220     audio_channel_mask_t channelMask() const { return mChannelMask; }
221 
sampleRate()222     virtual uint32_t sampleRate() const { return mSampleRate; }
223 
isStopped()224     bool isStopped() const {
225         return (mState == STOPPED || mState == FLUSHED);
226     }
227 
228     // for fast tracks and offloaded tracks only
isStopping()229     bool isStopping() const {
230         return mState == STOPPING_1 || mState == STOPPING_2;
231     }
isStopping_1()232     bool isStopping_1() const {
233         return mState == STOPPING_1;
234     }
isStopping_2()235     bool isStopping_2() const {
236         return mState == STOPPING_2;
237     }
238 
239     // Upper case characters are final states.
240     // Lower case characters are transitory.
getTrackStateString()241     const char *getTrackStateString() const {
242         if (isTerminated()) {
243             return "T ";
244         }
245         switch (mState) {
246         case IDLE:
247             return "I ";
248         case STOPPING_1: // for Fast and Offload
249             return "s1";
250         case STOPPING_2: // for Fast and Offload
251             return "s2";
252         case STOPPED:
253             return "S ";
254         case RESUMING:
255             return "r ";
256         case ACTIVE:
257             return "A ";
258         case PAUSING:
259             return "p ";
260         case PAUSED:
261             return "P ";
262         case FLUSHED:
263             return "F ";
264         case STARTING_1: // for RecordTrack
265             return "r1";
266         case STARTING_2: // for RecordTrack
267             return "r2";
268         default:
269             return "? ";
270         }
271     }
272 
isOut()273     bool isOut() const { return mIsOut; }
274                                     // true for Track, false for RecordTrack,
275                                     // this could be a track type if needed later
276 
277     const wp<ThreadBase> mThread;
278     /*const*/ sp<Client> mClient;   // see explanation at ~TrackBase() why not const
279     sp<IMemory>         mCblkMemory;
280     audio_track_cblk_t* mCblk;
281     sp<IMemory>         mBufferMemory;  // currently non-0 for fast RecordTrack only
282     void*               mBuffer;    // start of track buffer, typically in shared memory
283                                     // except for OutputTrack when it is in local memory
284     size_t              mBufferSize; // size of mBuffer in bytes
285     // we don't really need a lock for these
286     track_state         mState;
287     const audio_attributes_t mAttr;
288     const uint32_t      mSampleRate;    // initial sample rate only; for tracks which
289                         // support dynamic rates, the current value is in control block
290     const audio_format_t mFormat;
291     const audio_channel_mask_t mChannelMask;
292     const uint32_t      mChannelCount;
293     const size_t        mFrameSize; // AudioFlinger's view of frame size in shared memory,
294                                     // where for AudioTrack (but not AudioRecord),
295                                     // 8-bit PCM samples are stored as 16-bit
296     const size_t        mFrameCount;// size of track buffer given at createTrack() or
297                                     // createRecord(), and then adjusted as needed
298 
299     const audio_session_t mSessionId;
300     uid_t               mUid;
301     Vector < sp<SyncEvent> >mSyncEvents;
302     const bool          mIsOut;
303     sp<ServerProxy>     mServerProxy;
304     const int           mId;
305 #ifdef TEE_SINK
306     NBAIO_Tee           mTee;
307 #endif
308     bool                mTerminated;
309     track_type          mType;      // must be one of TYPE_DEFAULT, TYPE_OUTPUT, TYPE_PATCH ...
310     audio_io_handle_t   mThreadIoHandle; // I/O handle of the thread the track is attached to
311     audio_port_handle_t mPortId; // unique ID for this track used by audio policy
312     bool                mIsInvalid; // non-resettable latch, set by invalidate()
313 
314     bool                mServerLatencySupported = false;
315     std::atomic<bool>   mServerLatencyFromTrack{}; // latency from track or server timestamp.
316     std::atomic<double> mServerLatencyMs{};        // last latency pushed from server thread.
317     std::atomic<FrameTime> mKernelFrameTime{};     // last frame time on kernel side.
318     const pid_t         mCreatorPid;  // can be different from mclient->pid() for instance
319                                       // when created by NuPlayer on behalf of a client
320 };
321 
322 // PatchProxyBufferProvider interface is implemented by PatchTrack and PatchRecord.
323 // it provides buffer access methods that map those of a ClientProxy (see AudioTrackShared.h)
324 class PatchProxyBufferProvider
325 {
326 public:
327 
~PatchProxyBufferProvider()328     virtual ~PatchProxyBufferProvider() {}
329 
330     virtual status_t    obtainBuffer(Proxy::Buffer* buffer,
331                                      const struct timespec *requested = NULL) = 0;
332     virtual void        releaseBuffer(Proxy::Buffer* buffer) = 0;
333 };
334 
335 class PatchTrackBase : public PatchProxyBufferProvider
336 {
337 public:
338     using Timeout = std::optional<std::chrono::nanoseconds>;
339                         PatchTrackBase(sp<ClientProxy> proxy, const ThreadBase& thread,
340                                        const Timeout& timeout);
341             void        setPeerTimeout(std::chrono::nanoseconds timeout);
342             template <typename T>
setPeerProxy(const sp<T> & proxy,bool holdReference)343             void        setPeerProxy(const sp<T> &proxy, bool holdReference) {
344                             mPeerReferenceHold = holdReference ? proxy : nullptr;
345                             mPeerProxy = proxy.get();
346                         }
clearPeerProxy()347             void        clearPeerProxy() {
348                             mPeerReferenceHold.clear();
349                             mPeerProxy = nullptr;
350                         }
351 
352 protected:
353     const sp<ClientProxy>       mProxy;
354     sp<RefBase>                 mPeerReferenceHold;   // keeps mPeerProxy alive during access.
355     PatchProxyBufferProvider*   mPeerProxy = nullptr;
356     struct timespec             mPeerTimeout{};
357 
358 };
359