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