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 audio_session_t sessionId, 35 int uid, 36 audio_output_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 audio_session_t triggerSession = AUDIO_SESSION_NONE); 46 virtual void stop(); 47 void pause(); 48 49 void flush(); 50 void destroy(); 51 int name() const { return mName; } 52 53 virtual uint32_t sampleRate() const; 54 55 audio_stream_type_t streamType() const { 56 return mStreamType; 57 } 58 bool isOffloaded() const 59 { return (mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0; } 60 bool isDirect() const { return (mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0; } 61 status_t setParameters(const String8& keyValuePairs); 62 status_t attachAuxEffect(int EffectId); 63 void setAuxBuffer(int EffectId, int32_t *buffer); 64 int32_t *auxBuffer() const { return mAuxBuffer; } 65 void setMainBuffer(int16_t *buffer) { mMainBuffer = buffer; } 66 int16_t *mainBuffer() const { return mMainBuffer; } 67 int auxEffectId() const { return mAuxEffectId; } 68 virtual status_t getTimestamp(AudioTimestamp& timestamp); 69 void signal(); 70 71 // implement FastMixerState::VolumeProvider interface 72 virtual gain_minifloat_packed_t getVolumeLR(); 73 74 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 75 76 virtual bool isFastTrack() const { return (mFlags & AUDIO_OUTPUT_FLAG_FAST) != 0; } 77 78 protected: 79 // for numerous 80 friend class PlaybackThread; 81 friend class MixerThread; 82 friend class DirectOutputThread; 83 friend class OffloadThread; 84 85 Track(const Track&); 86 Track& operator = (const Track&); 87 88 // AudioBufferProvider interface 89 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 90 // releaseBuffer() not overridden 91 92 // ExtendedAudioBufferProvider interface 93 virtual size_t framesReady() const; 94 virtual int64_t framesReleased() const; 95 virtual void onTimestamp(const ExtendedTimestamp ×tamp); 96 97 bool isPausing() const { return mState == PAUSING; } 98 bool isPaused() const { return mState == PAUSED; } 99 bool isResuming() const { return mState == RESUMING; } 100 bool isReady() const; 101 void setPaused() { mState = PAUSED; } 102 void reset(); 103 bool isFlushPending() const { return mFlushHwPending; } 104 void flushAck(); 105 bool isResumePending(); 106 void resumeAck(); 107 void updateTrackFrameInfo(int64_t trackFramesReleased, int64_t sinkFramesWritten, 108 const ExtendedTimestamp &timeStamp); 109 110 sp<IMemory> sharedBuffer() const { return mSharedBuffer; } 111 112 // framesWritten is cumulative, never reset, and is shared all tracks 113 // audioHalFrames is derived from output latency 114 // FIXME parameters not needed, could get them from the thread 115 bool presentationComplete(int64_t framesWritten, size_t audioHalFrames); 116 void signalClientFlag(int32_t flag); 117 118 public: 119 void triggerEvents(AudioSystem::sync_event_t type); 120 void invalidate(); 121 void disable(); 122 123 bool isInvalid() const { return mIsInvalid; } 124 int fastIndex() const { return mFastIndex; } 125 126 protected: 127 128 // FILLED state is used for suppressing volume ramp at begin of playing 129 enum {FS_INVALID, FS_FILLING, FS_FILLED, FS_ACTIVE}; 130 mutable uint8_t mFillingUpStatus; 131 int8_t mRetryCount; 132 133 // see comment at AudioFlinger::PlaybackThread::Track::~Track for why this can't be const 134 sp<IMemory> mSharedBuffer; 135 136 bool mResetDone; 137 const audio_stream_type_t mStreamType; 138 int mName; // track name on the normal mixer, 139 // allocated statically at track creation time, 140 // and is even allocated (though unused) for fast tracks 141 // FIXME don't allocate track name for fast tracks 142 int16_t *mMainBuffer; 143 int32_t *mAuxBuffer; 144 int mAuxEffectId; 145 bool mHasVolumeController; 146 size_t mPresentationCompleteFrames; // number of frames written to the 147 // audio HAL when this track will be fully rendered 148 // zero means not monitoring 149 150 // access these three variables only when holding thread lock. 151 LinearMap<int64_t> mFrameMap; // track frame to server frame mapping 152 153 ExtendedTimestamp mSinkTimestamp; 154 155 private: 156 // The following fields are only for fast tracks, and should be in a subclass 157 int mFastIndex; // index within FastMixerState::mFastTracks[]; 158 // either mFastIndex == -1 if not isFastTrack() 159 // or 0 < mFastIndex < FastMixerState::kMaxFast because 160 // index 0 is reserved for normal mixer's submix; 161 // index is allocated statically at track creation time 162 // but the slot is only used if track is active 163 FastTrackUnderruns mObservedUnderruns; // Most recently observed value of 164 // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns 165 volatile float mCachedVolume; // combined master volume and stream type volume; 166 // 'volatile' means accessed without lock or 167 // barrier, but is read/written atomically 168 bool mIsInvalid; // non-resettable latch, set by invalidate() 169 AudioTrackServerProxy* mAudioTrackServerProxy; 170 bool mResumeToStopping; // track was paused in stopping state. 171 bool mFlushHwPending; // track requests for thread flush 172 audio_output_flags_t mFlags; 173 }; // end of Track 174 175 176 // playback track, used by DuplicatingThread 177 class OutputTrack : public Track { 178 public: 179 180 class Buffer : public AudioBufferProvider::Buffer { 181 public: 182 void *mBuffer; 183 }; 184 185 OutputTrack(PlaybackThread *thread, 186 DuplicatingThread *sourceThread, 187 uint32_t sampleRate, 188 audio_format_t format, 189 audio_channel_mask_t channelMask, 190 size_t frameCount, 191 int uid); 192 virtual ~OutputTrack(); 193 194 virtual status_t start(AudioSystem::sync_event_t event = 195 AudioSystem::SYNC_EVENT_NONE, 196 audio_session_t triggerSession = AUDIO_SESSION_NONE); 197 virtual void stop(); 198 bool write(void* data, uint32_t frames); 199 bool bufferQueueEmpty() const { return mBufferQueue.size() == 0; } 200 bool isActive() const { return mActive; } 201 const wp<ThreadBase>& thread() const { return mThread; } 202 203 private: 204 205 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer, 206 uint32_t waitTimeMs); 207 void clearBufferQueue(); 208 209 void restartIfDisabled(); 210 211 // Maximum number of pending buffers allocated by OutputTrack::write() 212 static const uint8_t kMaxOverFlowBuffers = 10; 213 214 Vector < Buffer* > mBufferQueue; 215 AudioBufferProvider::Buffer mOutBuffer; 216 bool mActive; 217 DuplicatingThread* const mSourceThread; // for waitTimeMs() in write() 218 AudioTrackClientProxy* mClientProxy; 219 }; // end of OutputTrack 220 221 // playback track, used by PatchPanel 222 class PatchTrack : public Track, public PatchProxyBufferProvider { 223 public: 224 225 PatchTrack(PlaybackThread *playbackThread, 226 audio_stream_type_t streamType, 227 uint32_t sampleRate, 228 audio_channel_mask_t channelMask, 229 audio_format_t format, 230 size_t frameCount, 231 void *buffer, 232 audio_output_flags_t flags); 233 virtual ~PatchTrack(); 234 235 virtual status_t start(AudioSystem::sync_event_t event = 236 AudioSystem::SYNC_EVENT_NONE, 237 audio_session_t triggerSession = AUDIO_SESSION_NONE); 238 239 // AudioBufferProvider interface 240 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 241 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 242 243 // PatchProxyBufferProvider interface 244 virtual status_t obtainBuffer(Proxy::Buffer* buffer, 245 const struct timespec *timeOut = NULL); 246 virtual void releaseBuffer(Proxy::Buffer* buffer); 247 248 void setPeerProxy(PatchProxyBufferProvider *proxy) { mPeerProxy = proxy; } 249 250 private: 251 void restartIfDisabled(); 252 253 sp<ClientProxy> mProxy; 254 PatchProxyBufferProvider* mPeerProxy; 255 struct timespec mPeerTimeout; 256 }; // end of PatchTrack 257
