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_TIMED, 54 TYPE_OUTPUT, 55 TYPE_PATCH, 56 }; 57 58 TrackBase(ThreadBase *thread, 59 const sp<Client>& client, 60 uint32_t sampleRate, 61 audio_format_t format, 62 audio_channel_mask_t channelMask, 63 size_t frameCount, 64 void *buffer, 65 int sessionId, 66 int uid, 67 IAudioFlinger::track_flags_t flags, 68 bool isOut, 69 alloc_type alloc = ALLOC_CBLK, 70 track_type type = TYPE_DEFAULT); 71 virtual ~TrackBase(); 72 virtual status_t initCheck() const; 73 74 virtual status_t start(AudioSystem::sync_event_t event, 75 int triggerSession) = 0; 76 virtual void stop() = 0; getCblk()77 sp<IMemory> getCblk() const { return mCblkMemory; } cblk()78 audio_track_cblk_t* cblk() const { return mCblk; } sessionId()79 int sessionId() const { return mSessionId; } uid()80 int uid() const { return mUid; } 81 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 82 getBuffers()83 sp<IMemory> getBuffers() const { return mBufferMemory; } buffer()84 void* buffer() const { return mBuffer; } isFastTrack()85 bool isFastTrack() const { return (mFlags & IAudioFlinger::TRACK_FAST) != 0; } isTimedTrack()86 bool isTimedTrack() const { return (mType == TYPE_TIMED); } isOutputTrack()87 bool isOutputTrack() const { return (mType == TYPE_OUTPUT); } isPatchTrack()88 bool isPatchTrack() const { return (mType == TYPE_PATCH); } isExternalTrack()89 bool isExternalTrack() const { return !isOutputTrack() && !isPatchTrack(); } 90 91 protected: 92 TrackBase(const TrackBase&); 93 TrackBase& operator = (const TrackBase&); 94 95 // AudioBufferProvider interface 96 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts) = 0; 97 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 98 99 // ExtendedAudioBufferProvider interface is only needed for Track, 100 // but putting it in TrackBase avoids the complexity of virtual inheritance framesReady()101 virtual size_t framesReady() const { return SIZE_MAX; } 102 format()103 audio_format_t format() const { return mFormat; } 104 channelCount()105 uint32_t channelCount() const { return mChannelCount; } 106 channelMask()107 audio_channel_mask_t channelMask() const { return mChannelMask; } 108 sampleRate()109 virtual uint32_t sampleRate() const { return mSampleRate; } 110 isStopped()111 bool isStopped() const { 112 return (mState == STOPPED || mState == FLUSHED); 113 } 114 115 // for fast tracks and offloaded tracks only isStopping()116 bool isStopping() const { 117 return mState == STOPPING_1 || mState == STOPPING_2; 118 } isStopping_1()119 bool isStopping_1() const { 120 return mState == STOPPING_1; 121 } isStopping_2()122 bool isStopping_2() const { 123 return mState == STOPPING_2; 124 } 125 isTerminated()126 bool isTerminated() const { 127 return mTerminated; 128 } 129 terminate()130 void terminate() { 131 mTerminated = true; 132 } 133 isOut()134 bool isOut() const { return mIsOut; } 135 // true for Track and TimedTrack, false for RecordTrack, 136 // this could be a track type if needed later 137 138 const wp<ThreadBase> mThread; 139 /*const*/ sp<Client> mClient; // see explanation at ~TrackBase() why not const 140 sp<IMemory> mCblkMemory; 141 audio_track_cblk_t* mCblk; 142 sp<IMemory> mBufferMemory; // currently non-0 for fast RecordTrack only 143 void* mBuffer; // start of track buffer, typically in shared memory 144 // except for OutputTrack when it is in local memory 145 // we don't really need a lock for these 146 track_state mState; 147 const uint32_t mSampleRate; // initial sample rate only; for tracks which 148 // support dynamic rates, the current value is in control block 149 const audio_format_t mFormat; 150 const audio_channel_mask_t mChannelMask; 151 const uint32_t mChannelCount; 152 const size_t mFrameSize; // AudioFlinger's view of frame size in shared memory, 153 // where for AudioTrack (but not AudioRecord), 154 // 8-bit PCM samples are stored as 16-bit 155 const size_t mFrameCount;// size of track buffer given at createTrack() or 156 // openRecord(), and then adjusted as needed 157 158 const int mSessionId; 159 int mUid; 160 Vector < sp<SyncEvent> >mSyncEvents; 161 const IAudioFlinger::track_flags_t mFlags; 162 const bool mIsOut; 163 ServerProxy* mServerProxy; 164 const int mId; 165 sp<NBAIO_Sink> mTeeSink; 166 sp<NBAIO_Source> mTeeSource; 167 bool mTerminated; 168 track_type mType; // must be one of TYPE_DEFAULT, TYPE_OUTPUT, TYPE_PATCH ... 169 audio_io_handle_t mThreadIoHandle; // I/O handle of the thread the track is attached to 170 }; 171 172 // PatchProxyBufferProvider interface is implemented by PatchTrack and PatchRecord. 173 // it provides buffer access methods that map those of a ClientProxy (see AudioTrackShared.h) 174 class PatchProxyBufferProvider 175 { 176 public: 177 ~PatchProxyBufferProvider()178 virtual ~PatchProxyBufferProvider() {} 179 180 virtual status_t obtainBuffer(Proxy::Buffer* buffer, 181 const struct timespec *requested = NULL) = 0; 182 virtual void releaseBuffer(Proxy::Buffer* buffer) = 0; 183 }; 184