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