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 }; 39 40 TrackBase(ThreadBase *thread, 41 const sp<Client>& client, 42 uint32_t sampleRate, 43 audio_format_t format, 44 audio_channel_mask_t channelMask, 45 size_t frameCount, 46 const sp<IMemory>& sharedBuffer, 47 int sessionId, 48 int uid, 49 bool isOut); 50 virtual ~TrackBase(); 51 52 virtual status_t start(AudioSystem::sync_event_t event, 53 int triggerSession) = 0; 54 virtual void stop() = 0; getCblk()55 sp<IMemory> getCblk() const { return mCblkMemory; } cblk()56 audio_track_cblk_t* cblk() const { return mCblk; } sessionId()57 int sessionId() const { return mSessionId; } uid()58 int uid() const { return mUid; } 59 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 60 61 protected: 62 TrackBase(const TrackBase&); 63 TrackBase& operator = (const TrackBase&); 64 65 // AudioBufferProvider interface 66 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts) = 0; 67 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 68 69 // ExtendedAudioBufferProvider interface is only needed for Track, 70 // but putting it in TrackBase avoids the complexity of virtual inheritance framesReady()71 virtual size_t framesReady() const { return SIZE_MAX; } 72 format()73 audio_format_t format() const { return mFormat; } 74 channelCount()75 uint32_t channelCount() const { return mChannelCount; } 76 channelMask()77 audio_channel_mask_t channelMask() const { return mChannelMask; } 78 sampleRate()79 virtual uint32_t sampleRate() const { return mSampleRate; } 80 81 // Return a pointer to the start of a contiguous slice of the track buffer. 82 // Parameter 'offset' is the requested start position, expressed in 83 // monotonically increasing frame units relative to the track epoch. 84 // Parameter 'frames' is the requested length, also in frame units. 85 // Always returns non-NULL. It is the caller's responsibility to 86 // verify that this will be successful; the result of calling this 87 // function with invalid 'offset' or 'frames' is undefined. 88 void* getBuffer(uint32_t offset, uint32_t frames) const; 89 isStopped()90 bool isStopped() const { 91 return (mState == STOPPED || mState == FLUSHED); 92 } 93 94 // for fast tracks and offloaded tracks only isStopping()95 bool isStopping() const { 96 return mState == STOPPING_1 || mState == STOPPING_2; 97 } isStopping_1()98 bool isStopping_1() const { 99 return mState == STOPPING_1; 100 } isStopping_2()101 bool isStopping_2() const { 102 return mState == STOPPING_2; 103 } 104 isTerminated()105 bool isTerminated() const { 106 return mTerminated; 107 } 108 terminate()109 void terminate() { 110 mTerminated = true; 111 } 112 isOut()113 bool isOut() const { return mIsOut; } 114 // true for Track and TimedTrack, false for RecordTrack, 115 // this could be a track type if needed later 116 117 const wp<ThreadBase> mThread; 118 /*const*/ sp<Client> mClient; // see explanation at ~TrackBase() why not const 119 sp<IMemory> mCblkMemory; 120 audio_track_cblk_t* mCblk; 121 void* mBuffer; // start of track buffer, typically in shared memory 122 // except for OutputTrack when it is in local memory 123 // we don't really need a lock for these 124 track_state mState; 125 const uint32_t mSampleRate; // initial sample rate only; for tracks which 126 // support dynamic rates, the current value is in control block 127 const audio_format_t mFormat; 128 const audio_channel_mask_t mChannelMask; 129 const uint32_t mChannelCount; 130 const size_t mFrameSize; // AudioFlinger's view of frame size in shared memory, 131 // where for AudioTrack (but not AudioRecord), 132 // 8-bit PCM samples are stored as 16-bit 133 const size_t mFrameCount;// size of track buffer given at createTrack() or 134 // openRecord(), and then adjusted as needed 135 136 const int mSessionId; 137 int mUid; 138 Vector < sp<SyncEvent> >mSyncEvents; 139 const bool mIsOut; 140 ServerProxy* mServerProxy; 141 const int mId; 142 sp<NBAIO_Sink> mTeeSink; 143 sp<NBAIO_Source> mTeeSource; 144 bool mTerminated; 145 }; 146