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 const audio_attributes_t& attr, 29 uint32_t sampleRate, 30 audio_format_t format, 31 audio_channel_mask_t channelMask, 32 size_t frameCount, 33 void *buffer, 34 size_t bufferSize, 35 const sp<IMemory>& sharedBuffer, 36 audio_session_t sessionId, 37 uid_t uid, 38 audio_output_flags_t flags, 39 track_type type, 40 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE); 41 virtual ~Track(); 42 virtual status_t initCheck() const; 43 44 static void appendDumpHeader(String8& result); 45 void appendDump(String8& result, bool active); 46 virtual status_t start(AudioSystem::sync_event_t event = 47 AudioSystem::SYNC_EVENT_NONE, 48 audio_session_t triggerSession = AUDIO_SESSION_NONE); 49 virtual void stop(); 50 void pause(); 51 52 void flush(); 53 void destroy(); 54 int name() const { return mName; } 55 void setName(int name) { 56 LOG_ALWAYS_FATAL_IF(mName >= 0 && name >= 0, 57 "%s both old name %d and new name %d are valid", __func__, mName, name); 58 mName = name; 59 } 60 61 virtual uint32_t sampleRate() const; 62 63 audio_stream_type_t streamType() const { 64 return mStreamType; 65 } 66 bool isOffloaded() const 67 { return (mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0; } 68 bool isDirect() const { return (mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0; } 69 bool isOffloadedOrDirect() const { return (mFlags 70 & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD 71 | AUDIO_OUTPUT_FLAG_DIRECT)) != 0; } 72 73 status_t setParameters(const String8& keyValuePairs); 74 status_t attachAuxEffect(int EffectId); 75 void setAuxBuffer(int EffectId, int32_t *buffer); 76 int32_t *auxBuffer() const { return mAuxBuffer; } 77 void setMainBuffer(effect_buffer_t *buffer) { mMainBuffer = buffer; } 78 effect_buffer_t *mainBuffer() const { return mMainBuffer; } 79 int auxEffectId() const { return mAuxEffectId; } 80 virtual status_t getTimestamp(AudioTimestamp& timestamp); 81 void signal(); 82 83 // implement FastMixerState::VolumeProvider interface 84 virtual gain_minifloat_packed_t getVolumeLR(); 85 86 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 87 88 virtual bool isFastTrack() const { return (mFlags & AUDIO_OUTPUT_FLAG_FAST) != 0; } 89 90 // implement volume handling. 91 media::VolumeShaper::Status applyVolumeShaper( 92 const sp<media::VolumeShaper::Configuration>& configuration, 93 const sp<media::VolumeShaper::Operation>& operation); 94 sp<media::VolumeShaper::State> getVolumeShaperState(int id); 95 sp<media::VolumeHandler> getVolumeHandler() { return mVolumeHandler; } 96 /** Set the computed normalized final volume of the track. 97 * !masterMute * masterVolume * streamVolume * averageLRVolume */ 98 void setFinalVolume(float volume); 99 float getFinalVolume() const { return mFinalVolume; } 100 101 /** @return true if the track has changed (metadata or volume) since 102 * the last time this function was called, 103 * true if this function was never called since the track creation, 104 * false otherwise. 105 * Thread safe. 106 */ 107 bool readAndClearHasChanged() { return !mChangeNotified.test_and_set(); } 108 109 using SourceMetadatas = std::vector<playback_track_metadata_t>; 110 using MetadataInserter = std::back_insert_iterator<SourceMetadatas>; 111 /** Copy the track metadata in the provided iterator. Thread safe. */ 112 virtual void copyMetadataTo(MetadataInserter& backInserter) const; 113 114 protected: 115 // for numerous 116 friend class PlaybackThread; 117 friend class MixerThread; 118 friend class DirectOutputThread; 119 friend class OffloadThread; 120 121 DISALLOW_COPY_AND_ASSIGN(Track); 122 123 // AudioBufferProvider interface 124 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 125 // releaseBuffer() not overridden 126 127 // ExtendedAudioBufferProvider interface 128 virtual size_t framesReady() const; 129 virtual int64_t framesReleased() const; 130 virtual void onTimestamp(const ExtendedTimestamp ×tamp); 131 132 bool isPausing() const { return mState == PAUSING; } 133 bool isPaused() const { return mState == PAUSED; } 134 bool isResuming() const { return mState == RESUMING; } 135 bool isReady() const; 136 void setPaused() { mState = PAUSED; } 137 void reset(); 138 bool isFlushPending() const { return mFlushHwPending; } 139 void flushAck(); 140 bool isResumePending(); 141 void resumeAck(); 142 void updateTrackFrameInfo(int64_t trackFramesReleased, int64_t sinkFramesWritten, 143 const ExtendedTimestamp &timeStamp); 144 145 sp<IMemory> sharedBuffer() const { return mSharedBuffer; } 146 147 // framesWritten is cumulative, never reset, and is shared all tracks 148 // audioHalFrames is derived from output latency 149 // FIXME parameters not needed, could get them from the thread 150 bool presentationComplete(int64_t framesWritten, size_t audioHalFrames); 151 void signalClientFlag(int32_t flag); 152 153 /** Set that a metadata has changed and needs to be notified to backend. Thread safe. */ 154 void setMetadataHasChanged() { mChangeNotified.clear(); } 155 public: 156 void triggerEvents(AudioSystem::sync_event_t type); 157 virtual void invalidate(); 158 void disable(); 159 160 int fastIndex() const { return mFastIndex; } 161 162 protected: 163 164 // FILLED state is used for suppressing volume ramp at begin of playing 165 enum {FS_INVALID, FS_FILLING, FS_FILLED, FS_ACTIVE}; 166 mutable uint8_t mFillingUpStatus; 167 int8_t mRetryCount; 168 169 // see comment at AudioFlinger::PlaybackThread::Track::~Track for why this can't be const 170 sp<IMemory> mSharedBuffer; 171 172 bool mResetDone; 173 const audio_stream_type_t mStreamType; 174 int mName; 175 effect_buffer_t *mMainBuffer; 176 177 int32_t *mAuxBuffer; 178 int mAuxEffectId; 179 bool mHasVolumeController; 180 size_t mPresentationCompleteFrames; // number of frames written to the 181 // audio HAL when this track will be fully rendered 182 // zero means not monitoring 183 184 // access these three variables only when holding thread lock. 185 LinearMap<int64_t> mFrameMap; // track frame to server frame mapping 186 187 ExtendedTimestamp mSinkTimestamp; 188 189 sp<media::VolumeHandler> mVolumeHandler; // handles multiple VolumeShaper configs and operations 190 191 private: 192 // The following fields are only for fast tracks, and should be in a subclass 193 int mFastIndex; // index within FastMixerState::mFastTracks[]; 194 // either mFastIndex == -1 if not isFastTrack() 195 // or 0 < mFastIndex < FastMixerState::kMaxFast because 196 // index 0 is reserved for normal mixer's submix; 197 // index is allocated statically at track creation time 198 // but the slot is only used if track is active 199 FastTrackUnderruns mObservedUnderruns; // Most recently observed value of 200 // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns 201 volatile float mCachedVolume; // combined master volume and stream type volume; 202 // 'volatile' means accessed without lock or 203 // barrier, but is read/written atomically 204 float mFinalVolume; // combine master volume, stream type volume and track volume 205 sp<AudioTrackServerProxy> mAudioTrackServerProxy; 206 bool mResumeToStopping; // track was paused in stopping state. 207 bool mFlushHwPending; // track requests for thread flush 208 audio_output_flags_t mFlags; 209 // If the last track change was notified to the client with readAndClearHasChanged 210 std::atomic_flag mChangeNotified = ATOMIC_FLAG_INIT; 211 }; // end of Track 212 213 214 // playback track, used by DuplicatingThread 215 class OutputTrack : public Track { 216 public: 217 218 class Buffer : public AudioBufferProvider::Buffer { 219 public: 220 void *mBuffer; 221 }; 222 223 OutputTrack(PlaybackThread *thread, 224 DuplicatingThread *sourceThread, 225 uint32_t sampleRate, 226 audio_format_t format, 227 audio_channel_mask_t channelMask, 228 size_t frameCount, 229 uid_t uid); 230 virtual ~OutputTrack(); 231 232 virtual status_t start(AudioSystem::sync_event_t event = 233 AudioSystem::SYNC_EVENT_NONE, 234 audio_session_t triggerSession = AUDIO_SESSION_NONE); 235 virtual void stop(); 236 bool write(void* data, uint32_t frames); 237 bool bufferQueueEmpty() const { return mBufferQueue.size() == 0; } 238 bool isActive() const { return mActive; } 239 const wp<ThreadBase>& thread() const { return mThread; } 240 241 void copyMetadataTo(MetadataInserter& backInserter) const override; 242 /** Set the metadatas of the upstream tracks. Thread safe. */ 243 void setMetadatas(const SourceMetadatas& metadatas); 244 245 private: 246 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer, 247 uint32_t waitTimeMs); 248 void clearBufferQueue(); 249 250 void restartIfDisabled(); 251 252 // Maximum number of pending buffers allocated by OutputTrack::write() 253 static const uint8_t kMaxOverFlowBuffers = 10; 254 255 Vector < Buffer* > mBufferQueue; 256 AudioBufferProvider::Buffer mOutBuffer; 257 bool mActive; 258 DuplicatingThread* const mSourceThread; // for waitTimeMs() in write() 259 sp<AudioTrackClientProxy> mClientProxy; 260 /** Attributes of the source tracks. 261 * 262 * This member must be accessed with mTrackMetadatasMutex taken. 263 * There is one writer (duplicating thread) and one reader (downstream mixer). 264 * 265 * That means that the duplicating thread can block the downstream mixer 266 * thread and vice versa for the time of the copy. 267 * If this becomes an issue, the metadata could be stored in an atomic raw pointer, 268 * and a exchange with nullptr and delete can be used. 269 * Alternatively a read-copy-update might be implemented. 270 */ 271 SourceMetadatas mTrackMetadatas; 272 /** Protects mTrackMetadatas against concurrent access. */ 273 mutable std::mutex mTrackMetadatasMutex; 274 }; // end of OutputTrack 275 276 // playback track, used by PatchPanel 277 class PatchTrack : public Track, public PatchProxyBufferProvider { 278 public: 279 280 PatchTrack(PlaybackThread *playbackThread, 281 audio_stream_type_t streamType, 282 uint32_t sampleRate, 283 audio_channel_mask_t channelMask, 284 audio_format_t format, 285 size_t frameCount, 286 void *buffer, 287 size_t bufferSize, 288 audio_output_flags_t flags); 289 virtual ~PatchTrack(); 290 291 virtual status_t start(AudioSystem::sync_event_t event = 292 AudioSystem::SYNC_EVENT_NONE, 293 audio_session_t triggerSession = AUDIO_SESSION_NONE); 294 295 // AudioBufferProvider interface 296 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 297 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 298 299 // PatchProxyBufferProvider interface 300 virtual status_t obtainBuffer(Proxy::Buffer* buffer, 301 const struct timespec *timeOut = NULL); 302 virtual void releaseBuffer(Proxy::Buffer* buffer); 303 304 void setPeerProxy(PatchProxyBufferProvider *proxy) { mPeerProxy = proxy; } 305 306 private: 307 void restartIfDisabled(); 308 309 sp<ClientProxy> mProxy; 310 PatchProxyBufferProvider* mPeerProxy; 311 struct timespec mPeerTimeout; 312 }; // end of PatchTrack 313
