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