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