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 // Checks and monitors OP_PLAY_AUDIO 23 class OpPlayAudioMonitor : public RefBase { 24 public: 25 ~OpPlayAudioMonitor() override; 26 bool hasOpPlayAudio() const; 27 28 static sp<OpPlayAudioMonitor> createIfNeeded( 29 uid_t uid, const audio_attributes_t& attr, int id, audio_stream_type_t streamType); 30 31 private: 32 OpPlayAudioMonitor(uid_t uid, audio_usage_t usage, int id); 33 void onFirstRef() override; 34 static void getPackagesForUid(uid_t uid, Vector<String16>& packages); 35 36 AppOpsManager mAppOpsManager; 37 38 class PlayAudioOpCallback : public BnAppOpsCallback { 39 public: 40 explicit PlayAudioOpCallback(const wp<OpPlayAudioMonitor>& monitor); 41 void opChanged(int32_t op, const String16& packageName) override; 42 43 private: 44 const wp<OpPlayAudioMonitor> mMonitor; 45 }; 46 47 sp<PlayAudioOpCallback> mOpCallback; 48 // called by PlayAudioOpCallback when OP_PLAY_AUDIO is updated in AppOp callback 49 void checkPlayAudioForUsage(); 50 51 std::atomic_bool mHasOpPlayAudio; 52 Vector<String16> mPackages; 53 const uid_t mUid; 54 const int32_t mUsage; // on purpose not audio_usage_t because always checked in appOps as int32_t 55 const int mId; // for logging purposes only 56 }; 57 58 // playback track 59 class Track : public TrackBase, public VolumeProvider { 60 public: 61 Track( PlaybackThread *thread, 62 const sp<Client>& client, 63 audio_stream_type_t streamType, 64 const audio_attributes_t& attr, 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 const sp<IMemory>& sharedBuffer, 72 audio_session_t sessionId, 73 pid_t creatorPid, 74 uid_t uid, 75 audio_output_flags_t flags, 76 track_type type, 77 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE, 78 /** default behaviour is to start when there are as many frames 79 * ready as possible (aka. Buffer is full). */ 80 size_t frameCountToBeReady = SIZE_MAX); 81 virtual ~Track(); 82 virtual status_t initCheck() const; 83 84 void appendDumpHeader(String8& result); 85 void appendDump(String8& result, bool active); 86 virtual status_t start(AudioSystem::sync_event_t event = AudioSystem::SYNC_EVENT_NONE, 87 audio_session_t triggerSession = AUDIO_SESSION_NONE); 88 virtual void stop(); 89 void pause(); 90 91 void flush(); 92 void destroy(); 93 94 virtual uint32_t sampleRate() const; 95 streamType()96 audio_stream_type_t streamType() const { 97 return mStreamType; 98 } isOffloaded()99 bool isOffloaded() const 100 { return (mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0; } isDirect()101 bool isDirect() const override 102 { return (mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0; } isOffloadedOrDirect()103 bool isOffloadedOrDirect() const { return (mFlags 104 & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD 105 | AUDIO_OUTPUT_FLAG_DIRECT)) != 0; } isStatic()106 bool isStatic() const { return mSharedBuffer.get() != nullptr; } 107 108 status_t setParameters(const String8& keyValuePairs); 109 status_t selectPresentation(int presentationId, int programId); 110 status_t attachAuxEffect(int EffectId); 111 void setAuxBuffer(int EffectId, int32_t *buffer); auxBuffer()112 int32_t *auxBuffer() const { return mAuxBuffer; } setMainBuffer(effect_buffer_t * buffer)113 void setMainBuffer(effect_buffer_t *buffer) { mMainBuffer = buffer; } mainBuffer()114 effect_buffer_t *mainBuffer() const { return mMainBuffer; } auxEffectId()115 int auxEffectId() const { return mAuxEffectId; } 116 virtual status_t getTimestamp(AudioTimestamp& timestamp); 117 void signal(); 118 119 // implement FastMixerState::VolumeProvider interface 120 virtual gain_minifloat_packed_t getVolumeLR(); 121 122 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 123 isFastTrack()124 virtual bool isFastTrack() const { return (mFlags & AUDIO_OUTPUT_FLAG_FAST) != 0; } 125 bufferLatencyMs()126 double bufferLatencyMs() const override { 127 return isStatic() ? 0. : TrackBase::bufferLatencyMs(); 128 } 129 130 // implement volume handling. 131 media::VolumeShaper::Status applyVolumeShaper( 132 const sp<media::VolumeShaper::Configuration>& configuration, 133 const sp<media::VolumeShaper::Operation>& operation); 134 sp<media::VolumeShaper::State> getVolumeShaperState(int id); getVolumeHandler()135 sp<media::VolumeHandler> getVolumeHandler() { return mVolumeHandler; } 136 /** Set the computed normalized final volume of the track. 137 * !masterMute * masterVolume * streamVolume * averageLRVolume */ 138 void setFinalVolume(float volume); getFinalVolume()139 float getFinalVolume() const { return mFinalVolume; } 140 141 /** @return true if the track has changed (metadata or volume) since 142 * the last time this function was called, 143 * true if this function was never called since the track creation, 144 * false otherwise. 145 * Thread safe. 146 */ readAndClearHasChanged()147 bool readAndClearHasChanged() { return !mChangeNotified.test_and_set(); } 148 149 using SourceMetadatas = std::vector<playback_track_metadata_t>; 150 using MetadataInserter = std::back_insert_iterator<SourceMetadatas>; 151 /** Copy the track metadata in the provided iterator. Thread safe. */ 152 virtual void copyMetadataTo(MetadataInserter& backInserter) const; 153 154 /** Return haptic playback of the track is enabled or not, used in mixer. */ getHapticPlaybackEnabled()155 bool getHapticPlaybackEnabled() const { return mHapticPlaybackEnabled; } 156 /** Set haptic playback of the track is enabled or not, should be 157 * set after query or get callback from vibrator service */ setHapticPlaybackEnabled(bool hapticPlaybackEnabled)158 void setHapticPlaybackEnabled(bool hapticPlaybackEnabled) { 159 mHapticPlaybackEnabled = hapticPlaybackEnabled; 160 } 161 /** Return at what intensity to play haptics, used in mixer. */ getHapticIntensity()162 AudioMixer::haptic_intensity_t getHapticIntensity() const { return mHapticIntensity; } 163 /** Set intensity of haptic playback, should be set after querying vibrator service. */ setHapticIntensity(AudioMixer::haptic_intensity_t hapticIntensity)164 void setHapticIntensity(AudioMixer::haptic_intensity_t hapticIntensity) { 165 if (AudioMixer::isValidHapticIntensity(hapticIntensity)) { 166 mHapticIntensity = hapticIntensity; 167 setHapticPlaybackEnabled(mHapticIntensity != AudioMixer::HAPTIC_SCALE_MUTE); 168 } 169 } getExternalVibration()170 sp<os::ExternalVibration> getExternalVibration() const { return mExternalVibration; } 171 172 void setTeePatches(TeePatches teePatches); 173 tallyUnderrunFrames(size_t frames)174 void tallyUnderrunFrames(size_t frames) override { 175 if (isOut()) { // we expect this from output tracks only 176 mAudioTrackServerProxy->tallyUnderrunFrames(frames); 177 // Fetch absolute numbers from AudioTrackShared as it counts 178 // contiguous underruns as a one -- we want a consistent number. 179 // TODO: isolate this counting into a class. 180 mTrackMetrics.logUnderruns(mAudioTrackServerProxy->getUnderrunCount(), 181 mAudioTrackServerProxy->getUnderrunFrames()); 182 } 183 } 184 protected: 185 // for numerous 186 friend class PlaybackThread; 187 friend class MixerThread; 188 friend class DirectOutputThread; 189 friend class OffloadThread; 190 191 DISALLOW_COPY_AND_ASSIGN(Track); 192 193 // AudioBufferProvider interface 194 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override; 195 void releaseBuffer(AudioBufferProvider::Buffer* buffer) override; 196 197 // ExtendedAudioBufferProvider interface 198 virtual size_t framesReady() const; 199 virtual int64_t framesReleased() const; 200 virtual void onTimestamp(const ExtendedTimestamp ×tamp); 201 isPausing()202 bool isPausing() const { return mState == PAUSING; } isPaused()203 bool isPaused() const { return mState == PAUSED; } isResuming()204 bool isResuming() const { return mState == RESUMING; } 205 bool isReady() const; setPaused()206 void setPaused() { mState = PAUSED; } 207 void reset(); isFlushPending()208 bool isFlushPending() const { return mFlushHwPending; } 209 void flushAck(); 210 bool isResumePending(); 211 void resumeAck(); 212 void updateTrackFrameInfo(int64_t trackFramesReleased, int64_t sinkFramesWritten, 213 uint32_t halSampleRate, const ExtendedTimestamp &timeStamp); 214 sharedBuffer()215 sp<IMemory> sharedBuffer() const { return mSharedBuffer; } 216 217 // framesWritten is cumulative, never reset, and is shared all tracks 218 // audioHalFrames is derived from output latency 219 // FIXME parameters not needed, could get them from the thread 220 bool presentationComplete(int64_t framesWritten, size_t audioHalFrames); 221 void signalClientFlag(int32_t flag); 222 223 /** Set that a metadata has changed and needs to be notified to backend. Thread safe. */ setMetadataHasChanged()224 void setMetadataHasChanged() { mChangeNotified.clear(); } 225 public: 226 void triggerEvents(AudioSystem::sync_event_t type); 227 virtual void invalidate(); 228 void disable(); 229 fastIndex()230 int fastIndex() const { return mFastIndex; } 231 isPlaybackRestricted()232 bool isPlaybackRestricted() const { 233 // The monitor is only created for tracks that can be silenced. 234 return mOpPlayAudioMonitor ? !mOpPlayAudioMonitor->hasOpPlayAudio() : false; } 235 236 protected: 237 238 // FILLED state is used for suppressing volume ramp at begin of playing 239 enum {FS_INVALID, FS_FILLING, FS_FILLED, FS_ACTIVE}; 240 mutable uint8_t mFillingUpStatus; 241 int8_t mRetryCount; 242 243 // see comment at AudioFlinger::PlaybackThread::Track::~Track for why this can't be const 244 sp<IMemory> mSharedBuffer; 245 246 bool mResetDone; 247 const audio_stream_type_t mStreamType; 248 effect_buffer_t *mMainBuffer; 249 250 int32_t *mAuxBuffer; 251 int mAuxEffectId; 252 bool mHasVolumeController; 253 size_t mPresentationCompleteFrames; // number of frames written to the 254 // audio HAL when this track will be fully rendered 255 // zero means not monitoring 256 257 // access these three variables only when holding thread lock. 258 LinearMap<int64_t> mFrameMap; // track frame to server frame mapping 259 260 ExtendedTimestamp mSinkTimestamp; 261 262 sp<media::VolumeHandler> mVolumeHandler; // handles multiple VolumeShaper configs and operations 263 264 sp<OpPlayAudioMonitor> mOpPlayAudioMonitor; 265 266 bool mHapticPlaybackEnabled = false; // indicates haptic playback enabled or not 267 // intensity to play haptic data 268 AudioMixer::haptic_intensity_t mHapticIntensity = AudioMixer::HAPTIC_SCALE_MUTE; 269 class AudioVibrationController : public os::BnExternalVibrationController { 270 public: AudioVibrationController(Track * track)271 explicit AudioVibrationController(Track* track) : mTrack(track) {} 272 binder::Status mute(/*out*/ bool *ret) override; 273 binder::Status unmute(/*out*/ bool *ret) override; 274 private: 275 Track* const mTrack; 276 }; 277 sp<AudioVibrationController> mAudioVibrationController; 278 sp<os::ExternalVibration> mExternalVibration; 279 /** How many frames should be in the buffer before the track is considered ready */ 280 const size_t mFrameCountToBeReady; 281 282 private: 283 void interceptBuffer(const AudioBufferProvider::Buffer& buffer); 284 template <class F> forEachTeePatchTrack(F f)285 void forEachTeePatchTrack(F f) { 286 for (auto& tp : mTeePatches) { f(tp.patchTrack); } 287 }; 288 289 // The following fields are only for fast tracks, and should be in a subclass 290 int mFastIndex; // index within FastMixerState::mFastTracks[]; 291 // either mFastIndex == -1 if not isFastTrack() 292 // or 0 < mFastIndex < FastMixerState::kMaxFast because 293 // index 0 is reserved for normal mixer's submix; 294 // index is allocated statically at track creation time 295 // but the slot is only used if track is active 296 FastTrackUnderruns mObservedUnderruns; // Most recently observed value of 297 // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns 298 volatile float mCachedVolume; // combined master volume and stream type volume; 299 // 'volatile' means accessed without lock or 300 // barrier, but is read/written atomically 301 float mFinalVolume; // combine master volume, stream type volume and track volume 302 sp<AudioTrackServerProxy> mAudioTrackServerProxy; 303 bool mResumeToStopping; // track was paused in stopping state. 304 bool mFlushHwPending; // track requests for thread flush 305 audio_output_flags_t mFlags; 306 // If the last track change was notified to the client with readAndClearHasChanged 307 std::atomic_flag mChangeNotified = ATOMIC_FLAG_INIT; 308 TeePatches mTeePatches; 309 }; // end of Track 310 311 312 // playback track, used by DuplicatingThread 313 class OutputTrack : public Track { 314 public: 315 316 class Buffer : public AudioBufferProvider::Buffer { 317 public: 318 void *mBuffer; 319 }; 320 321 OutputTrack(PlaybackThread *thread, 322 DuplicatingThread *sourceThread, 323 uint32_t sampleRate, 324 audio_format_t format, 325 audio_channel_mask_t channelMask, 326 size_t frameCount, 327 uid_t uid); 328 virtual ~OutputTrack(); 329 330 virtual status_t start(AudioSystem::sync_event_t event = 331 AudioSystem::SYNC_EVENT_NONE, 332 audio_session_t triggerSession = AUDIO_SESSION_NONE); 333 virtual void stop(); 334 ssize_t write(void* data, uint32_t frames); bufferQueueEmpty()335 bool bufferQueueEmpty() const { return mBufferQueue.size() == 0; } isActive()336 bool isActive() const { return mActive; } thread()337 const wp<ThreadBase>& thread() const { return mThread; } 338 339 void copyMetadataTo(MetadataInserter& backInserter) const override; 340 /** Set the metadatas of the upstream tracks. Thread safe. */ 341 void setMetadatas(const SourceMetadatas& metadatas); 342 /** returns client timestamp to the upstream duplicating thread. */ getClientProxyTimestamp()343 ExtendedTimestamp getClientProxyTimestamp() const { 344 // server - kernel difference is not true latency when drained 345 // i.e. mServerProxy->isDrained(). 346 ExtendedTimestamp timestamp; 347 (void) mClientProxy->getTimestamp(×tamp); 348 // On success, the timestamp LOCATION_SERVER and LOCATION_KERNEL 349 // entries will be properly filled. If getTimestamp() 350 // is unsuccessful, then a default initialized timestamp 351 // (with mTimeNs[] filled with -1's) is returned. 352 return timestamp; 353 } 354 355 private: 356 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer, 357 uint32_t waitTimeMs); 358 void clearBufferQueue(); 359 360 void restartIfDisabled(); 361 362 // Maximum number of pending buffers allocated by OutputTrack::write() 363 static const uint8_t kMaxOverFlowBuffers = 10; 364 365 Vector < Buffer* > mBufferQueue; 366 AudioBufferProvider::Buffer mOutBuffer; 367 bool mActive; 368 DuplicatingThread* const mSourceThread; // for waitTimeMs() in write() 369 sp<AudioTrackClientProxy> mClientProxy; 370 371 /** Attributes of the source tracks. 372 * 373 * This member must be accessed with mTrackMetadatasMutex taken. 374 * There is one writer (duplicating thread) and one reader (downstream mixer). 375 * 376 * That means that the duplicating thread can block the downstream mixer 377 * thread and vice versa for the time of the copy. 378 * If this becomes an issue, the metadata could be stored in an atomic raw pointer, 379 * and a exchange with nullptr and delete can be used. 380 * Alternatively a read-copy-update might be implemented. 381 */ 382 SourceMetadatas mTrackMetadatas; 383 /** Protects mTrackMetadatas against concurrent access. */ 384 mutable std::mutex mTrackMetadatasMutex; 385 }; // end of OutputTrack 386 387 // playback track, used by PatchPanel 388 class PatchTrack : public Track, public PatchTrackBase { 389 public: 390 391 PatchTrack(PlaybackThread *playbackThread, 392 audio_stream_type_t streamType, 393 uint32_t sampleRate, 394 audio_channel_mask_t channelMask, 395 audio_format_t format, 396 size_t frameCount, 397 void *buffer, 398 size_t bufferSize, 399 audio_output_flags_t flags, 400 const Timeout& timeout = {}, 401 size_t frameCountToBeReady = 1 /** Default behaviour is to start 402 * as soon as possible to have 403 * the lowest possible latency 404 * even if it might glitch. */); 405 virtual ~PatchTrack(); 406 407 size_t framesReady() const override; 408 409 virtual status_t start(AudioSystem::sync_event_t event = 410 AudioSystem::SYNC_EVENT_NONE, 411 audio_session_t triggerSession = AUDIO_SESSION_NONE); 412 413 // AudioBufferProvider interface 414 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 415 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 416 417 // PatchProxyBufferProvider interface 418 virtual status_t obtainBuffer(Proxy::Buffer* buffer, 419 const struct timespec *timeOut = NULL); 420 virtual void releaseBuffer(Proxy::Buffer* buffer); 421 422 private: 423 void restartIfDisabled(); 424 }; // end of PatchTrack 425