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 // playback track 23 class Track : public TrackBase, public VolumeProvider { 24 public: 25 Track( PlaybackThread *thread, 26 const sp<Client>& client, 27 audio_stream_type_t streamType, 28 uint32_t sampleRate, 29 audio_format_t format, 30 audio_channel_mask_t channelMask, 31 size_t frameCount, 32 void *buffer, 33 const sp<IMemory>& sharedBuffer, 34 int sessionId, 35 int uid, 36 IAudioFlinger::track_flags_t flags, 37 track_type type); 38 virtual ~Track(); 39 virtual status_t initCheck() const; 40 41 static void appendDumpHeader(String8& result); 42 void dump(char* buffer, size_t size, bool active); 43 virtual status_t start(AudioSystem::sync_event_t event = 44 AudioSystem::SYNC_EVENT_NONE, 45 int triggerSession = 0); 46 virtual void stop(); 47 void pause(); 48 49 void flush(); 50 void destroy(); name()51 int name() const { return mName; } 52 53 virtual uint32_t sampleRate() const; 54 streamType()55 audio_stream_type_t streamType() const { 56 return mStreamType; 57 } isOffloaded()58 bool isOffloaded() const { return (mFlags & IAudioFlinger::TRACK_OFFLOAD) != 0; } isDirect()59 bool isDirect() const { return (mFlags & IAudioFlinger::TRACK_DIRECT) != 0; } 60 status_t setParameters(const String8& keyValuePairs); 61 status_t attachAuxEffect(int EffectId); 62 void setAuxBuffer(int EffectId, int32_t *buffer); auxBuffer()63 int32_t *auxBuffer() const { return mAuxBuffer; } setMainBuffer(int16_t * buffer)64 void setMainBuffer(int16_t *buffer) { mMainBuffer = buffer; } mainBuffer()65 int16_t *mainBuffer() const { return mMainBuffer; } auxEffectId()66 int auxEffectId() const { return mAuxEffectId; } 67 virtual status_t getTimestamp(AudioTimestamp& timestamp); 68 void signal(); 69 70 // implement FastMixerState::VolumeProvider interface 71 virtual gain_minifloat_packed_t getVolumeLR(); 72 73 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 74 75 protected: 76 // for numerous 77 friend class PlaybackThread; 78 friend class MixerThread; 79 friend class DirectOutputThread; 80 friend class OffloadThread; 81 82 Track(const Track&); 83 Track& operator = (const Track&); 84 85 // AudioBufferProvider interface 86 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, 87 int64_t pts = kInvalidPTS); 88 // releaseBuffer() not overridden 89 90 // ExtendedAudioBufferProvider interface 91 virtual size_t framesReady() const; 92 virtual size_t framesReleased() const; 93 isPausing()94 bool isPausing() const { return mState == PAUSING; } isPaused()95 bool isPaused() const { return mState == PAUSED; } isResuming()96 bool isResuming() const { return mState == RESUMING; } 97 bool isReady() const; setPaused()98 void setPaused() { mState = PAUSED; } 99 void reset(); isFlushPending()100 bool isFlushPending() const { return mFlushHwPending; } 101 void flushAck(); 102 bool isResumePending(); 103 void resumeAck(); 104 sharedBuffer()105 sp<IMemory> sharedBuffer() const { return mSharedBuffer; } 106 107 // framesWritten is cumulative, never reset, and is shared all tracks 108 // audioHalFrames is derived from output latency 109 // FIXME parameters not needed, could get them from the thread 110 bool presentationComplete(size_t framesWritten, size_t audioHalFrames); 111 112 public: 113 void triggerEvents(AudioSystem::sync_event_t type); 114 void invalidate(); isInvalid()115 bool isInvalid() const { return mIsInvalid; } fastIndex()116 int fastIndex() const { return mFastIndex; } 117 118 protected: 119 120 // FILLED state is used for suppressing volume ramp at begin of playing 121 enum {FS_INVALID, FS_FILLING, FS_FILLED, FS_ACTIVE}; 122 mutable uint8_t mFillingUpStatus; 123 int8_t mRetryCount; 124 125 // see comment at AudioFlinger::PlaybackThread::Track::~Track for why this can't be const 126 sp<IMemory> mSharedBuffer; 127 128 bool mResetDone; 129 const audio_stream_type_t mStreamType; 130 int mName; // track name on the normal mixer, 131 // allocated statically at track creation time, 132 // and is even allocated (though unused) for fast tracks 133 // FIXME don't allocate track name for fast tracks 134 int16_t *mMainBuffer; 135 int32_t *mAuxBuffer; 136 int mAuxEffectId; 137 bool mHasVolumeController; 138 size_t mPresentationCompleteFrames; // number of frames written to the 139 // audio HAL when this track will be fully rendered 140 // zero means not monitoring 141 private: 142 // The following fields are only for fast tracks, and should be in a subclass 143 int mFastIndex; // index within FastMixerState::mFastTracks[]; 144 // either mFastIndex == -1 if not isFastTrack() 145 // or 0 < mFastIndex < FastMixerState::kMaxFast because 146 // index 0 is reserved for normal mixer's submix; 147 // index is allocated statically at track creation time 148 // but the slot is only used if track is active 149 FastTrackUnderruns mObservedUnderruns; // Most recently observed value of 150 // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns 151 volatile float mCachedVolume; // combined master volume and stream type volume; 152 // 'volatile' means accessed without lock or 153 // barrier, but is read/written atomically 154 bool mIsInvalid; // non-resettable latch, set by invalidate() 155 AudioTrackServerProxy* mAudioTrackServerProxy; 156 bool mResumeToStopping; // track was paused in stopping state. 157 bool mFlushHwPending; // track requests for thread flush 158 159 // for last call to getTimestamp 160 bool mPreviousValid; 161 uint32_t mPreviousFramesWritten; 162 AudioTimestamp mPreviousTimestamp; 163 }; // end of Track 164 165 class TimedTrack : public Track { 166 public: 167 static sp<TimedTrack> create(PlaybackThread *thread, 168 const sp<Client>& client, 169 audio_stream_type_t streamType, 170 uint32_t sampleRate, 171 audio_format_t format, 172 audio_channel_mask_t channelMask, 173 size_t frameCount, 174 const sp<IMemory>& sharedBuffer, 175 int sessionId, 176 int uid); 177 virtual ~TimedTrack(); 178 179 class TimedBuffer { 180 public: 181 TimedBuffer(); 182 TimedBuffer(const sp<IMemory>& buffer, int64_t pts); buffer()183 const sp<IMemory>& buffer() const { return mBuffer; } pts()184 int64_t pts() const { return mPTS; } position()185 uint32_t position() const { return mPosition; } setPosition(uint32_t pos)186 void setPosition(uint32_t pos) { mPosition = pos; } 187 private: 188 sp<IMemory> mBuffer; 189 int64_t mPTS; 190 uint32_t mPosition; 191 }; 192 193 // Mixer facing methods. 194 virtual size_t framesReady() const; 195 196 // AudioBufferProvider interface 197 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, 198 int64_t pts); 199 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 200 201 // Client/App facing methods. 202 status_t allocateTimedBuffer(size_t size, 203 sp<IMemory>* buffer); 204 status_t queueTimedBuffer(const sp<IMemory>& buffer, 205 int64_t pts); 206 status_t setMediaTimeTransform(const LinearTransform& xform, 207 TimedAudioTrack::TargetTimeline target); 208 209 private: 210 TimedTrack(PlaybackThread *thread, 211 const sp<Client>& client, 212 audio_stream_type_t streamType, 213 uint32_t sampleRate, 214 audio_format_t format, 215 audio_channel_mask_t channelMask, 216 size_t frameCount, 217 const sp<IMemory>& sharedBuffer, 218 int sessionId, 219 int uid); 220 221 void timedYieldSamples_l(AudioBufferProvider::Buffer* buffer); 222 void timedYieldSilence_l(uint32_t numFrames, 223 AudioBufferProvider::Buffer* buffer); 224 void trimTimedBufferQueue_l(); 225 void trimTimedBufferQueueHead_l(const char* logTag); 226 void updateFramesPendingAfterTrim_l(const TimedBuffer& buf, 227 const char* logTag); 228 229 uint64_t mLocalTimeFreq; 230 LinearTransform mLocalTimeToSampleTransform; 231 LinearTransform mMediaTimeToSampleTransform; 232 sp<MemoryDealer> mTimedMemoryDealer; 233 234 Vector<TimedBuffer> mTimedBufferQueue; 235 bool mQueueHeadInFlight; 236 bool mTrimQueueHeadOnRelease; 237 uint32_t mFramesPendingInQueue; 238 239 uint8_t* mTimedSilenceBuffer; 240 uint32_t mTimedSilenceBufferSize; 241 mutable Mutex mTimedBufferQueueLock; 242 bool mTimedAudioOutputOnTime; 243 CCHelper mCCHelper; 244 245 Mutex mMediaTimeTransformLock; 246 LinearTransform mMediaTimeTransform; 247 bool mMediaTimeTransformValid; 248 TimedAudioTrack::TargetTimeline mMediaTimeTransformTarget; 249 }; 250 251 252 // playback track, used by DuplicatingThread 253 class OutputTrack : public Track { 254 public: 255 256 class Buffer : public AudioBufferProvider::Buffer { 257 public: 258 int16_t *mBuffer; 259 }; 260 261 OutputTrack(PlaybackThread *thread, 262 DuplicatingThread *sourceThread, 263 uint32_t sampleRate, 264 audio_format_t format, 265 audio_channel_mask_t channelMask, 266 size_t frameCount, 267 int uid); 268 virtual ~OutputTrack(); 269 270 virtual status_t start(AudioSystem::sync_event_t event = 271 AudioSystem::SYNC_EVENT_NONE, 272 int triggerSession = 0); 273 virtual void stop(); 274 bool write(int16_t* data, uint32_t frames); bufferQueueEmpty()275 bool bufferQueueEmpty() const { return mBufferQueue.size() == 0; } isActive()276 bool isActive() const { return mActive; } thread()277 const wp<ThreadBase>& thread() const { return mThread; } 278 279 private: 280 281 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer, 282 uint32_t waitTimeMs); 283 void clearBufferQueue(); 284 285 // Maximum number of pending buffers allocated by OutputTrack::write() 286 static const uint8_t kMaxOverFlowBuffers = 10; 287 288 Vector < Buffer* > mBufferQueue; 289 AudioBufferProvider::Buffer mOutBuffer; 290 bool mActive; 291 DuplicatingThread* const mSourceThread; // for waitTimeMs() in write() 292 AudioTrackClientProxy* mClientProxy; 293 }; // end of OutputTrack 294 295 // playback track, used by PatchPanel 296 class PatchTrack : public Track, public PatchProxyBufferProvider { 297 public: 298 299 PatchTrack(PlaybackThread *playbackThread, 300 uint32_t sampleRate, 301 audio_channel_mask_t channelMask, 302 audio_format_t format, 303 size_t frameCount, 304 void *buffer, 305 IAudioFlinger::track_flags_t flags); 306 virtual ~PatchTrack(); 307 308 // AudioBufferProvider interface 309 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, 310 int64_t pts); 311 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 312 313 // PatchProxyBufferProvider interface 314 virtual status_t obtainBuffer(Proxy::Buffer* buffer, 315 const struct timespec *timeOut = NULL); 316 virtual void releaseBuffer(Proxy::Buffer* buffer); 317 setPeerProxy(PatchProxyBufferProvider * proxy)318 void setPeerProxy(PatchProxyBufferProvider *proxy) { mPeerProxy = proxy; } 319 320 private: 321 sp<ClientProxy> mProxy; 322 PatchProxyBufferProvider* mPeerProxy; 323 struct timespec mPeerTimeout; 324 }; // end of PatchTrack 325