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