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, 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, 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 enum { 58 TRACK_NAME_PENDING = -1, 59 TRACK_NAME_FAILURE = -2, 60 }; 61 62 TrackBase(ThreadBase *thread, 63 const sp<Client>& client, 64 const audio_attributes_t& mAttr, 65 uint32_t sampleRate, 66 audio_format_t format, 67 audio_channel_mask_t channelMask, 68 size_t frameCount, 69 void *buffer, 70 size_t bufferSize, 71 audio_session_t sessionId, 72 uid_t uid, 73 bool isOut, 74 alloc_type alloc = ALLOC_CBLK, 75 track_type type = TYPE_DEFAULT, 76 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE); 77 virtual ~TrackBase(); 78 virtual status_t initCheck() const; 79 80 virtual status_t start(AudioSystem::sync_event_t event, 81 audio_session_t triggerSession) = 0; 82 virtual void stop() = 0; getCblk()83 sp<IMemory> getCblk() const { return mCblkMemory; } cblk()84 audio_track_cblk_t* cblk() const { return mCblk; } sessionId()85 audio_session_t sessionId() const { return mSessionId; } uid()86 uid_t uid() const { return mUid; } portId()87 audio_port_handle_t portId() const { return mPortId; } 88 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 89 getBuffers()90 sp<IMemory> getBuffers() const { return mBufferMemory; } buffer()91 void* buffer() const { return mBuffer; } bufferSize()92 size_t bufferSize() const { return mBufferSize; } 93 virtual bool isFastTrack() const = 0; isOutputTrack()94 bool isOutputTrack() const { return (mType == TYPE_OUTPUT); } isPatchTrack()95 bool isPatchTrack() const { return (mType == TYPE_PATCH); } isExternalTrack()96 bool isExternalTrack() const { return !isOutputTrack() && !isPatchTrack(); } 97 invalidate()98 virtual void invalidate() { mIsInvalid = true; } isInvalid()99 bool isInvalid() const { return mIsInvalid; } 100 attributes()101 audio_attributes_t attributes() const { return mAttr; } 102 103 protected: 104 DISALLOW_COPY_AND_ASSIGN(TrackBase); 105 106 // AudioBufferProvider interface 107 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0; 108 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 109 110 // ExtendedAudioBufferProvider interface is only needed for Track, 111 // but putting it in TrackBase avoids the complexity of virtual inheritance framesReady()112 virtual size_t framesReady() const { return SIZE_MAX; } 113 format()114 audio_format_t format() const { return mFormat; } 115 channelCount()116 uint32_t channelCount() const { return mChannelCount; } 117 frameSize()118 size_t frameSize() const { return mFrameSize; } 119 channelMask()120 audio_channel_mask_t channelMask() const { return mChannelMask; } 121 sampleRate()122 virtual uint32_t sampleRate() const { return mSampleRate; } 123 isStopped()124 bool isStopped() const { 125 return (mState == STOPPED || mState == FLUSHED); 126 } 127 128 // for fast tracks and offloaded tracks only isStopping()129 bool isStopping() const { 130 return mState == STOPPING_1 || mState == STOPPING_2; 131 } isStopping_1()132 bool isStopping_1() const { 133 return mState == STOPPING_1; 134 } isStopping_2()135 bool isStopping_2() const { 136 return mState == STOPPING_2; 137 } 138 isTerminated()139 bool isTerminated() const { 140 return mTerminated; 141 } 142 terminate()143 void terminate() { 144 mTerminated = true; 145 } 146 147 // Upper case characters are final states. 148 // Lower case characters are transitory. getTrackStateString()149 const char *getTrackStateString() const { 150 if (isTerminated()) { 151 return "T "; 152 } 153 switch (mState) { 154 case IDLE: 155 return "I "; 156 case STOPPING_1: // for Fast and Offload 157 return "s1"; 158 case STOPPING_2: // for Fast and Offload 159 return "s2"; 160 case STOPPED: 161 return "S "; 162 case RESUMING: 163 return "r "; 164 case ACTIVE: 165 return "A "; 166 case PAUSING: 167 return "p "; 168 case PAUSED: 169 return "P "; 170 case FLUSHED: 171 return "F "; 172 case STARTING_1: // for RecordTrack 173 return "r1"; 174 case STARTING_2: // for RecordTrack 175 return "r2"; 176 default: 177 return "? "; 178 } 179 } 180 isOut()181 bool isOut() const { return mIsOut; } 182 // true for Track, false for RecordTrack, 183 // this could be a track type if needed later 184 185 const wp<ThreadBase> mThread; 186 /*const*/ sp<Client> mClient; // see explanation at ~TrackBase() why not const 187 sp<IMemory> mCblkMemory; 188 audio_track_cblk_t* mCblk; 189 sp<IMemory> mBufferMemory; // currently non-0 for fast RecordTrack only 190 void* mBuffer; // start of track buffer, typically in shared memory 191 // except for OutputTrack when it is in local memory 192 size_t mBufferSize; // size of mBuffer in bytes 193 // we don't really need a lock for these 194 track_state mState; 195 const audio_attributes_t mAttr; 196 const uint32_t mSampleRate; // initial sample rate only; for tracks which 197 // support dynamic rates, the current value is in control block 198 const audio_format_t mFormat; 199 const audio_channel_mask_t mChannelMask; 200 const uint32_t mChannelCount; 201 const size_t mFrameSize; // AudioFlinger's view of frame size in shared memory, 202 // where for AudioTrack (but not AudioRecord), 203 // 8-bit PCM samples are stored as 16-bit 204 const size_t mFrameCount;// size of track buffer given at createTrack() or 205 // createRecord(), and then adjusted as needed 206 207 const audio_session_t mSessionId; 208 uid_t mUid; 209 Vector < sp<SyncEvent> >mSyncEvents; 210 const bool mIsOut; 211 sp<ServerProxy> mServerProxy; 212 const int mId; 213 sp<NBAIO_Sink> mTeeSink; 214 sp<NBAIO_Source> mTeeSource; 215 bool mTerminated; 216 track_type mType; // must be one of TYPE_DEFAULT, TYPE_OUTPUT, TYPE_PATCH ... 217 audio_io_handle_t mThreadIoHandle; // I/O handle of the thread the track is attached to 218 audio_port_handle_t mPortId; // unique ID for this track used by audio policy 219 bool mIsInvalid; // non-resettable latch, set by invalidate() 220 }; 221 222 // PatchProxyBufferProvider interface is implemented by PatchTrack and PatchRecord. 223 // it provides buffer access methods that map those of a ClientProxy (see AudioTrackShared.h) 224 class PatchProxyBufferProvider 225 { 226 public: 227 ~PatchProxyBufferProvider()228 virtual ~PatchProxyBufferProvider() {} 229 230 virtual status_t obtainBuffer(Proxy::Buffer* buffer, 231 const struct timespec *requested = NULL) = 0; 232 virtual void releaseBuffer(Proxy::Buffer* buffer) = 0; 233 }; 234