Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 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 | |
Lais Andrade | bc3f37a | 2021-07-02 00:13:19 +0100 | [diff] [blame] | 22 | #include <math.h> |
| 23 | |
Jean-Michel Trivi | 74e01fa | 2019-02-25 12:18:09 -0800 | [diff] [blame] | 24 | // Checks and monitors OP_PLAY_AUDIO |
| 25 | class OpPlayAudioMonitor : public RefBase { |
| 26 | public: |
Jean-Michel Trivi | 74e01fa | 2019-02-25 12:18:09 -0800 | [diff] [blame] | 27 | ~OpPlayAudioMonitor() override; |
| 28 | bool hasOpPlayAudio() const; |
| 29 | |
Mikhail Naganov | f7e3a3a | 2019-04-22 16:43:26 -0700 | [diff] [blame] | 30 | static sp<OpPlayAudioMonitor> createIfNeeded( |
Svet Ganov | 3376113 | 2021-05-13 22:51:08 +0000 | [diff] [blame] | 31 | const AttributionSourceState& attributionSource, |
Philip P. Moltmann | bda4575 | 2020-07-17 16:41:18 -0700 | [diff] [blame] | 32 | const audio_attributes_t& attr, int id, |
| 33 | audio_stream_type_t streamType); |
Mikhail Naganov | f7e3a3a | 2019-04-22 16:43:26 -0700 | [diff] [blame] | 34 | |
Jean-Michel Trivi | 74e01fa | 2019-02-25 12:18:09 -0800 | [diff] [blame] | 35 | private: |
Svet Ganov | 3376113 | 2021-05-13 22:51:08 +0000 | [diff] [blame] | 36 | OpPlayAudioMonitor(const AttributionSourceState& attributionSource, |
Philip P. Moltmann | bda4575 | 2020-07-17 16:41:18 -0700 | [diff] [blame] | 37 | audio_usage_t usage, int id); |
Mikhail Naganov | f7e3a3a | 2019-04-22 16:43:26 -0700 | [diff] [blame] | 38 | void onFirstRef() override; |
Eric Laurent | 9066ad3 | 2019-05-20 14:40:10 -0700 | [diff] [blame] | 39 | static void getPackagesForUid(uid_t uid, Vector<String16>& packages); |
Mikhail Naganov | f7e3a3a | 2019-04-22 16:43:26 -0700 | [diff] [blame] | 40 | |
Jean-Michel Trivi | 74e01fa | 2019-02-25 12:18:09 -0800 | [diff] [blame] | 41 | AppOpsManager mAppOpsManager; |
| 42 | |
| 43 | class PlayAudioOpCallback : public BnAppOpsCallback { |
| 44 | public: |
| 45 | explicit PlayAudioOpCallback(const wp<OpPlayAudioMonitor>& monitor); |
| 46 | void opChanged(int32_t op, const String16& packageName) override; |
| 47 | |
| 48 | private: |
| 49 | const wp<OpPlayAudioMonitor> mMonitor; |
| 50 | }; |
| 51 | |
| 52 | sp<PlayAudioOpCallback> mOpCallback; |
| 53 | // called by PlayAudioOpCallback when OP_PLAY_AUDIO is updated in AppOp callback |
| 54 | void checkPlayAudioForUsage(); |
| 55 | |
| 56 | std::atomic_bool mHasOpPlayAudio; |
Svet Ganov | 3376113 | 2021-05-13 22:51:08 +0000 | [diff] [blame] | 57 | const AttributionSourceState mAttributionSource; |
Jean-Michel Trivi | 74e01fa | 2019-02-25 12:18:09 -0800 | [diff] [blame] | 58 | const int32_t mUsage; // on purpose not audio_usage_t because always checked in appOps as int32_t |
| 59 | const int mId; // for logging purposes only |
| 60 | }; |
| 61 | |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 62 | // playback track |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 63 | class Track : public TrackBase, public virtual IAfTrack, public VolumeProvider { |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 64 | public: |
| 65 | Track( PlaybackThread *thread, |
| 66 | const sp<Client>& client, |
| 67 | audio_stream_type_t streamType, |
Kevin Rocard | 1f564ac | 2018-03-29 13:53:10 -0700 | [diff] [blame] | 68 | const audio_attributes_t& attr, |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 69 | uint32_t sampleRate, |
| 70 | audio_format_t format, |
| 71 | audio_channel_mask_t channelMask, |
| 72 | size_t frameCount, |
Eric Laurent | 83b8808 | 2014-06-20 18:31:16 -0700 | [diff] [blame] | 73 | void *buffer, |
Andy Hung | 8fe6803 | 2017-06-05 16:17:51 -0700 | [diff] [blame] | 74 | size_t bufferSize, |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 75 | const sp<IMemory>& sharedBuffer, |
Glenn Kasten | d848eb4 | 2016-03-08 13:42:11 -0800 | [diff] [blame] | 76 | audio_session_t sessionId, |
Eric Laurent | 09f1ed2 | 2019-04-24 17:45:17 -0700 | [diff] [blame] | 77 | pid_t creatorPid, |
Svet Ganov | 3376113 | 2021-05-13 22:51:08 +0000 | [diff] [blame] | 78 | const AttributionSourceState& attributionSource, |
Eric Laurent | 0506778 | 2016-06-01 18:27:28 -0700 | [diff] [blame] | 79 | audio_output_flags_t flags, |
Eric Laurent | 20b9ef0 | 2016-12-05 11:03:16 -0800 | [diff] [blame] | 80 | track_type type, |
Kevin Rocard | 01c7d9e | 2019-09-18 11:24:52 +0100 | [diff] [blame] | 81 | audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE, |
| 82 | /** default behaviour is to start when there are as many frames |
| 83 | * ready as possible (aka. Buffer is full). */ |
jiabin | f042b9b | 2021-05-07 23:46:28 +0000 | [diff] [blame] | 84 | size_t frameCountToBeReady = SIZE_MAX, |
Eric Laurent | b0a7bc9 | 2022-04-05 15:06:08 +0200 | [diff] [blame] | 85 | float speed = 1.0f, |
jiabin | c658e45 | 2022-10-21 20:52:21 +0000 | [diff] [blame] | 86 | bool isSpatialized = false, |
| 87 | bool isBitPerfect = false); |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 88 | ~Track() override; |
| 89 | status_t initCheck() const final; |
| 90 | void appendDumpHeader(String8& result) const final; |
| 91 | void appendDump(String8& result, bool active) const final; |
| 92 | status_t start(AudioSystem::sync_event_t event = AudioSystem::SYNC_EVENT_NONE, |
| 93 | audio_session_t triggerSession = AUDIO_SESSION_NONE) override; |
| 94 | void stop() override; |
| 95 | void pause() final; |
| 96 | void flush() final; |
| 97 | void destroy() final; |
| 98 | uint32_t sampleRate() const final; |
| 99 | audio_stream_type_t streamType() const final { |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 100 | return mStreamType; |
| 101 | } |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 102 | bool isOffloaded() const final |
Eric Laurent | 0506778 | 2016-06-01 18:27:28 -0700 | [diff] [blame] | 103 | { return (mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0; } |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 104 | bool isDirect() const final |
Mikhail Naganov | 7c6ae98 | 2018-06-14 12:33:38 -0700 | [diff] [blame] | 105 | { return (mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0; } |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 106 | bool isOffloadedOrDirect() const final { return (mFlags |
Andy Hung | 10cbff1 | 2017-02-21 17:30:14 -0800 | [diff] [blame] | 107 | & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD |
| 108 | | AUDIO_OUTPUT_FLAG_DIRECT)) != 0; } |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 109 | bool isStatic() const final { return mSharedBuffer.get() != nullptr; } |
Andy Hung | 10cbff1 | 2017-02-21 17:30:14 -0800 | [diff] [blame] | 110 | |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 111 | status_t setParameters(const String8& keyValuePairs) final; |
| 112 | status_t selectPresentation(int presentationId, int programId) final; |
| 113 | status_t attachAuxEffect(int EffectId) final; |
| 114 | void setAuxBuffer(int EffectId, int32_t* buffer) final; |
| 115 | int32_t* auxBuffer() const final { return mAuxBuffer; } |
| 116 | void setMainBuffer(float* buffer) final { mMainBuffer = buffer; } |
| 117 | float* mainBuffer() const final { return mMainBuffer; } |
| 118 | int auxEffectId() const final { return mAuxEffectId; } |
| 119 | status_t getTimestamp(AudioTimestamp& timestamp) final; |
| 120 | void signal() final; |
| 121 | status_t getDualMonoMode(audio_dual_mono_mode_t* mode) const final; |
| 122 | status_t setDualMonoMode(audio_dual_mono_mode_t mode) final; |
| 123 | status_t getAudioDescriptionMixLevel(float* leveldB) const final; |
| 124 | status_t setAudioDescriptionMixLevel(float leveldB) final; |
| 125 | status_t getPlaybackRateParameters(audio_playback_rate_t* playbackRate) const final; |
| 126 | status_t setPlaybackRateParameters(const audio_playback_rate_t& playbackRate) final; |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 127 | |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 128 | // implement FastMixerState::VolumeProvider interface |
| 129 | gain_minifloat_packed_t getVolumeLR() const final; |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 130 | |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 131 | status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) final; |
| 132 | bool isFastTrack() const final { return (mFlags & AUDIO_OUTPUT_FLAG_FAST) != 0; } |
| 133 | double bufferLatencyMs() const final { |
Andy Hung | cef2daa | 2018-06-01 15:31:49 -0700 | [diff] [blame] | 134 | return isStatic() ? 0. : TrackBase::bufferLatencyMs(); |
| 135 | } |
Andy Hung | f6ab58d | 2018-05-25 12:50:39 -0700 | [diff] [blame] | 136 | |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 137 | // implement volume handling. |
Ivan Lozano | 8cf3a07 | 2017-08-09 09:01:33 -0700 | [diff] [blame] | 138 | media::VolumeShaper::Status applyVolumeShaper( |
| 139 | const sp<media::VolumeShaper::Configuration>& configuration, |
| 140 | const sp<media::VolumeShaper::Operation>& operation); |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 141 | sp<media::VolumeShaper::State> getVolumeShaperState(int id) const final; |
| 142 | sp<media::VolumeHandler> getVolumeHandler() const final{ return mVolumeHandler; } |
Kevin Rocard | 1238109 | 2018-04-11 09:19:59 -0700 | [diff] [blame] | 143 | /** Set the computed normalized final volume of the track. |
| 144 | * !masterMute * masterVolume * streamVolume * averageLRVolume */ |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 145 | void setFinalVolume(float volumeLeft, float volumeRight) final; |
| 146 | float getFinalVolume() const final { return mFinalVolume; } |
| 147 | void getFinalVolume(float* left, float* right) const final { |
jiabin | 76d9469 | 2022-12-15 21:51:21 +0000 | [diff] [blame] | 148 | *left = mFinalVolumeLeft; |
| 149 | *right = mFinalVolumeRight; |
| 150 | } |
Kevin Rocard | 1238109 | 2018-04-11 09:19:59 -0700 | [diff] [blame] | 151 | |
Eric Laurent | 9457917 | 2020-11-20 18:41:04 +0100 | [diff] [blame] | 152 | using SourceMetadatas = std::vector<playback_track_metadata_v7_t>; |
Kevin Rocard | 1238109 | 2018-04-11 09:19:59 -0700 | [diff] [blame] | 153 | using MetadataInserter = std::back_insert_iterator<SourceMetadatas>; |
| 154 | /** Copy the track metadata in the provided iterator. Thread safe. */ |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 155 | void copyMetadataTo(MetadataInserter& backInserter) const override; |
| 156 | |
Andy Hung | 9fc8b5c | 2017-01-24 13:36:48 -0800 | [diff] [blame] | 157 | |
jiabin | 245cdd9 | 2018-12-07 17:55:15 -0800 | [diff] [blame] | 158 | /** Return haptic playback of the track is enabled or not, used in mixer. */ |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 159 | bool getHapticPlaybackEnabled() const final { return mHapticPlaybackEnabled; } |
jiabin | 245cdd9 | 2018-12-07 17:55:15 -0800 | [diff] [blame] | 160 | /** Set haptic playback of the track is enabled or not, should be |
| 161 | * set after query or get callback from vibrator service */ |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 162 | void setHapticPlaybackEnabled(bool hapticPlaybackEnabled) final { |
jiabin | 245cdd9 | 2018-12-07 17:55:15 -0800 | [diff] [blame] | 163 | mHapticPlaybackEnabled = hapticPlaybackEnabled; |
| 164 | } |
jiabin | 77270b8 | 2018-12-18 15:41:29 -0800 | [diff] [blame] | 165 | /** Return at what intensity to play haptics, used in mixer. */ |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 166 | os::HapticScale getHapticIntensity() const final { return mHapticIntensity; } |
Lais Andrade | bc3f37a | 2021-07-02 00:13:19 +0100 | [diff] [blame] | 167 | /** Return the maximum amplitude allowed for haptics data, used in mixer. */ |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 168 | float getHapticMaxAmplitude() const final { return mHapticMaxAmplitude; } |
jiabin | 77270b8 | 2018-12-18 15:41:29 -0800 | [diff] [blame] | 169 | /** Set intensity of haptic playback, should be set after querying vibrator service. */ |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 170 | void setHapticIntensity(os::HapticScale hapticIntensity) final { |
jiabin | e70bc7f | 2020-06-30 22:07:55 -0700 | [diff] [blame] | 171 | if (os::isValidHapticScale(hapticIntensity)) { |
jiabin | 77270b8 | 2018-12-18 15:41:29 -0800 | [diff] [blame] | 172 | mHapticIntensity = hapticIntensity; |
jiabin | e70bc7f | 2020-06-30 22:07:55 -0700 | [diff] [blame] | 173 | setHapticPlaybackEnabled(mHapticIntensity != os::HapticScale::MUTE); |
jiabin | 77270b8 | 2018-12-18 15:41:29 -0800 | [diff] [blame] | 174 | } |
| 175 | } |
Lais Andrade | bc3f37a | 2021-07-02 00:13:19 +0100 | [diff] [blame] | 176 | /** Set maximum amplitude allowed for haptic data, should be set after querying |
| 177 | * vibrator service. |
| 178 | */ |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 179 | void setHapticMaxAmplitude(float maxAmplitude) final { |
Lais Andrade | bc3f37a | 2021-07-02 00:13:19 +0100 | [diff] [blame] | 180 | mHapticMaxAmplitude = maxAmplitude; |
| 181 | } |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 182 | sp<os::ExternalVibration> getExternalVibration() const final { return mExternalVibration; } |
jiabin | 245cdd9 | 2018-12-07 17:55:15 -0800 | [diff] [blame] | 183 | |
Jiabin Huang | fb47684 | 2022-12-06 03:18:10 +0000 | [diff] [blame] | 184 | // This function should be called with holding thread lock. |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 185 | void updateTeePatches_l() final; |
| 186 | void setTeePatchesToUpdate_l(const void* teePatchesToUpdate) final { |
| 187 | setTeePatchesToUpdate_l(*reinterpret_cast<const TeePatches*>(teePatchesToUpdate)); |
| 188 | } |
| 189 | void setTeePatchesToUpdate_l(TeePatches teePatchesToUpdate); |
Kevin Rocard | 153f92d | 2018-12-18 18:33:28 -0800 | [diff] [blame] | 190 | |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 191 | void tallyUnderrunFrames(size_t frames) final { |
Andy Hung | c2b11cb | 2020-04-22 09:04:01 -0700 | [diff] [blame] | 192 | if (isOut()) { // we expect this from output tracks only |
| 193 | mAudioTrackServerProxy->tallyUnderrunFrames(frames); |
| 194 | // Fetch absolute numbers from AudioTrackShared as it counts |
| 195 | // contiguous underruns as a one -- we want a consistent number. |
| 196 | // TODO: isolate this counting into a class. |
| 197 | mTrackMetrics.logUnderruns(mAudioTrackServerProxy->getUnderrunCount(), |
| 198 | mAudioTrackServerProxy->getUnderrunFrames()); |
| 199 | } |
| 200 | } |
jiabin | f042b9b | 2021-05-07 23:46:28 +0000 | [diff] [blame] | 201 | |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 202 | audio_output_flags_t getOutputFlags() const final { return mFlags; } |
| 203 | float getSpeed() const final { return mSpeed; } |
| 204 | bool isSpatialized() const final { return mIsSpatialized; } |
| 205 | bool isBitPerfect() const final { return mIsBitPerfect; } |
Eric Laurent | 3909598 | 2021-08-24 18:29:27 +0200 | [diff] [blame] | 206 | |
Vlad Popa | e8d9947 | 2022-06-30 16:02:48 +0200 | [diff] [blame] | 207 | /** |
| 208 | * Updates the mute state and notifies the audio service. Call this only when holding player |
| 209 | * thread lock. |
| 210 | */ |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 211 | void processMuteEvent_l(const sp<IAudioManager>& audioManager, mute_state_t muteState) final; |
Vlad Popa | e8d9947 | 2022-06-30 16:02:48 +0200 | [diff] [blame] | 212 | |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 213 | protected: |
| 214 | // for numerous |
| 215 | friend class PlaybackThread; |
| 216 | friend class MixerThread; |
| 217 | friend class DirectOutputThread; |
Eric Laurent | bfb1b83 | 2013-01-07 09:53:42 -0800 | [diff] [blame] | 218 | friend class OffloadThread; |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 219 | |
Mikhail Naganov | bf49308 | 2017-04-17 17:37:12 -0700 | [diff] [blame] | 220 | DISALLOW_COPY_AND_ASSIGN(Track); |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 221 | |
| 222 | // AudioBufferProvider interface |
Kevin Rocard | 153f92d | 2018-12-18 18:33:28 -0800 | [diff] [blame] | 223 | status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override; |
| 224 | void releaseBuffer(AudioBufferProvider::Buffer* buffer) override; |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 225 | |
Glenn Kasten | 6466c9e | 2013-08-23 10:54:07 -0700 | [diff] [blame] | 226 | // ExtendedAudioBufferProvider interface |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 227 | size_t framesReady() const override; |
| 228 | int64_t framesReleased() const override; |
| 229 | void onTimestamp(const ExtendedTimestamp ×tamp) override; |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 230 | |
Glenn Kasten | c9b2e20 | 2013-02-26 11:32:32 -0800 | [diff] [blame] | 231 | bool isPausing() const { return mState == PAUSING; } |
| 232 | bool isPaused() const { return mState == PAUSED; } |
| 233 | bool isResuming() const { return mState == RESUMING; } |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 234 | bool isReady() const; |
| 235 | void setPaused() { mState = PAUSED; } |
| 236 | void reset(); |
Haynes Mathew George | 7844f67 | 2014-01-15 12:32:55 -0800 | [diff] [blame] | 237 | bool isFlushPending() const { return mFlushHwPending; } |
| 238 | void flushAck(); |
Krishnankutty Kolathappilly | 8d6c292 | 2014-02-04 16:23:42 -0800 | [diff] [blame] | 239 | bool isResumePending(); |
| 240 | void resumeAck(); |
Kuowei Li | 2366647 | 2021-01-20 10:23:25 +0800 | [diff] [blame] | 241 | // For direct or offloaded tracks ensure that the pause state is acknowledged |
| 242 | // by the playback thread in case of an immediate flush. |
| 243 | bool isPausePending() const { return mPauseHwPending; } |
| 244 | void pauseAck(); |
Andy Hung | 818e7a3 | 2016-02-16 18:08:07 -0800 | [diff] [blame] | 245 | void updateTrackFrameInfo(int64_t trackFramesReleased, int64_t sinkFramesWritten, |
Andy Hung | cef2daa | 2018-06-01 15:31:49 -0700 | [diff] [blame] | 246 | uint32_t halSampleRate, const ExtendedTimestamp &timeStamp); |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 247 | |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 248 | sp<IMemory> sharedBuffer() const { return mSharedBuffer; } |
| 249 | |
Andy Hung | 59de426 | 2021-06-14 10:53:54 -0700 | [diff] [blame] | 250 | // presentationComplete checked by frames. (Mixed Tracks). |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 251 | // framesWritten is cumulative, never reset, and is shared all tracks |
| 252 | // audioHalFrames is derived from output latency |
Andy Hung | 818e7a3 | 2016-02-16 18:08:07 -0800 | [diff] [blame] | 253 | bool presentationComplete(int64_t framesWritten, size_t audioHalFrames); |
Andy Hung | 59de426 | 2021-06-14 10:53:54 -0700 | [diff] [blame] | 254 | |
| 255 | // presentationComplete checked by time. (Direct Tracks). |
| 256 | bool presentationComplete(uint32_t latencyMs); |
| 257 | |
| 258 | void resetPresentationComplete() { |
| 259 | mPresentationCompleteFrames = 0; |
| 260 | mPresentationCompleteTimeNs = 0; |
| 261 | } |
| 262 | |
| 263 | // notifyPresentationComplete is called when presentationComplete() detects |
| 264 | // that the track is finished stopping. |
| 265 | void notifyPresentationComplete(); |
| 266 | |
Eric Laurent | 4d231dc | 2016-03-11 18:38:23 -0800 | [diff] [blame] | 267 | void signalClientFlag(int32_t flag); |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 268 | |
| 269 | public: |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 270 | void triggerEvents(AudioSystem::sync_event_t type) final; |
| 271 | void invalidate() final; |
| 272 | void disable() final; |
| 273 | int& fastIndex() final { return mFastIndex; } |
| 274 | bool isPlaybackRestricted() const final { |
Mikhail Naganov | f7e3a3a | 2019-04-22 16:43:26 -0700 | [diff] [blame] | 275 | // The monitor is only created for tracks that can be silenced. |
| 276 | return mOpPlayAudioMonitor ? !mOpPlayAudioMonitor->hasOpPlayAudio() : false; } |
Jean-Michel Trivi | 74e01fa | 2019-02-25 12:18:09 -0800 | [diff] [blame] | 277 | |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 278 | protected: |
| 279 | |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 280 | // FILLED state is used for suppressing volume ramp at begin of playing |
| 281 | enum {FS_INVALID, FS_FILLING, FS_FILLED, FS_ACTIVE}; |
| 282 | mutable uint8_t mFillingUpStatus; |
| 283 | int8_t mRetryCount; |
Glenn Kasten | 0c72b24 | 2013-09-11 09:14:16 -0700 | [diff] [blame] | 284 | |
| 285 | // see comment at AudioFlinger::PlaybackThread::Track::~Track for why this can't be const |
| 286 | sp<IMemory> mSharedBuffer; |
| 287 | |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 288 | bool mResetDone; |
| 289 | const audio_stream_type_t mStreamType; |
Andy Hung | 319587b | 2023-05-23 14:01:03 -0700 | [diff] [blame] | 290 | float *mMainBuffer; |
rago | 94a1ee8 | 2017-07-21 15:11:02 -0700 | [diff] [blame] | 291 | |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 292 | int32_t *mAuxBuffer; |
| 293 | int mAuxEffectId; |
| 294 | bool mHasVolumeController; |
Andy Hung | e10393e | 2015-06-12 13:59:33 -0700 | [diff] [blame] | 295 | |
| 296 | // access these three variables only when holding thread lock. |
Andy Hung | 818e7a3 | 2016-02-16 18:08:07 -0800 | [diff] [blame] | 297 | LinearMap<int64_t> mFrameMap; // track frame to server frame mapping |
| 298 | |
| 299 | ExtendedTimestamp mSinkTimestamp; |
Andy Hung | e10393e | 2015-06-12 13:59:33 -0700 | [diff] [blame] | 300 | |
Ivan Lozano | 8cf3a07 | 2017-08-09 09:01:33 -0700 | [diff] [blame] | 301 | sp<media::VolumeHandler> mVolumeHandler; // handles multiple VolumeShaper configs and operations |
Andy Hung | 9fc8b5c | 2017-01-24 13:36:48 -0800 | [diff] [blame] | 302 | |
Jean-Michel Trivi | 74e01fa | 2019-02-25 12:18:09 -0800 | [diff] [blame] | 303 | sp<OpPlayAudioMonitor> mOpPlayAudioMonitor; |
| 304 | |
jiabin | 245cdd9 | 2018-12-07 17:55:15 -0800 | [diff] [blame] | 305 | bool mHapticPlaybackEnabled = false; // indicates haptic playback enabled or not |
jiabin | 77270b8 | 2018-12-18 15:41:29 -0800 | [diff] [blame] | 306 | // intensity to play haptic data |
jiabin | e70bc7f | 2020-06-30 22:07:55 -0700 | [diff] [blame] | 307 | os::HapticScale mHapticIntensity = os::HapticScale::MUTE; |
Lais Andrade | bc3f37a | 2021-07-02 00:13:19 +0100 | [diff] [blame] | 308 | // max amplitude allowed for haptic data |
| 309 | float mHapticMaxAmplitude = NAN; |
jiabin | 57303cc | 2018-12-18 15:45:57 -0800 | [diff] [blame] | 310 | class AudioVibrationController : public os::BnExternalVibrationController { |
| 311 | public: |
| 312 | explicit AudioVibrationController(Track* track) : mTrack(track) {} |
| 313 | binder::Status mute(/*out*/ bool *ret) override; |
| 314 | binder::Status unmute(/*out*/ bool *ret) override; |
| 315 | private: |
| 316 | Track* const mTrack; |
SPeak Shen | c19aa9e | 2022-11-11 00:28:50 +0800 | [diff] [blame] | 317 | bool setMute(bool muted); |
jiabin | 57303cc | 2018-12-18 15:45:57 -0800 | [diff] [blame] | 318 | }; |
| 319 | sp<AudioVibrationController> mAudioVibrationController; |
| 320 | sp<os::ExternalVibration> mExternalVibration; |
jiabin | 245cdd9 | 2018-12-07 17:55:15 -0800 | [diff] [blame] | 321 | |
Kuowei Li | d4adbdb | 2020-08-13 14:44:25 +0800 | [diff] [blame] | 322 | audio_dual_mono_mode_t mDualMonoMode = AUDIO_DUAL_MONO_MODE_OFF; |
| 323 | float mAudioDescriptionMixLevel = -std::numeric_limits<float>::infinity(); |
| 324 | audio_playback_rate_t mPlaybackRateParameters = AUDIO_PLAYBACK_RATE_INITIALIZER; |
| 325 | |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 326 | private: |
Kevin Rocard | 153f92d | 2018-12-18 18:33:28 -0800 | [diff] [blame] | 327 | void interceptBuffer(const AudioBufferProvider::Buffer& buffer); |
jiabin | 7434e81 | 2023-06-27 18:22:35 +0000 | [diff] [blame] | 328 | // Must hold thread lock to access tee patches |
Kevin Rocard | c43ea14 | 2019-01-31 18:17:37 -0800 | [diff] [blame] | 329 | template <class F> |
jiabin | 7434e81 | 2023-06-27 18:22:35 +0000 | [diff] [blame] | 330 | void forEachTeePatchTrack_l(F f) { |
Kevin Rocard | c43ea14 | 2019-01-31 18:17:37 -0800 | [diff] [blame] | 331 | for (auto& tp : mTeePatches) { f(tp.patchTrack); } |
| 332 | }; |
Kevin Rocard | 153f92d | 2018-12-18 18:33:28 -0800 | [diff] [blame] | 333 | |
Andy Hung | 59de426 | 2021-06-14 10:53:54 -0700 | [diff] [blame] | 334 | size_t mPresentationCompleteFrames = 0; // (Used for Mixed tracks) |
| 335 | // The number of frames written to the |
| 336 | // audio HAL when this track is considered fully rendered. |
| 337 | // Zero means not monitoring. |
| 338 | int64_t mPresentationCompleteTimeNs = 0; // (Used for Direct tracks) |
| 339 | // The time when this track is considered fully rendered. |
| 340 | // Zero means not monitoring. |
| 341 | |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 342 | // The following fields are only for fast tracks, and should be in a subclass |
| 343 | int mFastIndex; // index within FastMixerState::mFastTracks[]; |
| 344 | // either mFastIndex == -1 if not isFastTrack() |
| 345 | // or 0 < mFastIndex < FastMixerState::kMaxFast because |
| 346 | // index 0 is reserved for normal mixer's submix; |
| 347 | // index is allocated statically at track creation time |
| 348 | // but the slot is only used if track is active |
| 349 | FastTrackUnderruns mObservedUnderruns; // Most recently observed value of |
| 350 | // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 351 | volatile float mCachedVolume; // combined master volume and stream type volume; |
| 352 | // 'volatile' means accessed without lock or |
| 353 | // barrier, but is read/written atomically |
Kevin Rocard | 1238109 | 2018-04-11 09:19:59 -0700 | [diff] [blame] | 354 | float mFinalVolume; // combine master volume, stream type volume and track volume |
jiabin | 76d9469 | 2022-12-15 21:51:21 +0000 | [diff] [blame] | 355 | float mFinalVolumeLeft; // combine master volume, stream type volume and track |
| 356 | // volume |
| 357 | float mFinalVolumeRight; // combine master volume, stream type volume and track |
| 358 | // volume |
Eric Laurent | 5bba2f6 | 2016-03-18 11:14:14 -0700 | [diff] [blame] | 359 | sp<AudioTrackServerProxy> mAudioTrackServerProxy; |
Eric Laurent | bfb1b83 | 2013-01-07 09:53:42 -0800 | [diff] [blame] | 360 | bool mResumeToStopping; // track was paused in stopping state. |
Haynes Mathew George | 7844f67 | 2014-01-15 12:32:55 -0800 | [diff] [blame] | 361 | bool mFlushHwPending; // track requests for thread flush |
Kuowei Li | 2366647 | 2021-01-20 10:23:25 +0800 | [diff] [blame] | 362 | bool mPauseHwPending = false; // direct/offload track request for thread pause |
Eric Laurent | 0506778 | 2016-06-01 18:27:28 -0700 | [diff] [blame] | 363 | audio_output_flags_t mFlags; |
Kevin Rocard | 153f92d | 2018-12-18 18:33:28 -0800 | [diff] [blame] | 364 | TeePatches mTeePatches; |
Jiabin Huang | fb47684 | 2022-12-06 03:18:10 +0000 | [diff] [blame] | 365 | std::optional<TeePatches> mTeePatchesToUpdate; |
jiabin | f042b9b | 2021-05-07 23:46:28 +0000 | [diff] [blame] | 366 | const float mSpeed; |
Eric Laurent | b0a7bc9 | 2022-04-05 15:06:08 +0200 | [diff] [blame] | 367 | const bool mIsSpatialized; |
jiabin | c658e45 | 2022-10-21 20:52:21 +0000 | [diff] [blame] | 368 | const bool mIsBitPerfect; |
Vlad Popa | e8d9947 | 2022-06-30 16:02:48 +0200 | [diff] [blame] | 369 | |
| 370 | // TODO: replace PersistableBundle with own struct |
| 371 | // access these two variables only when holding player thread lock. |
| 372 | std::unique_ptr<os::PersistableBundle> mMuteEventExtras; |
| 373 | mute_state_t mMuteState; |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 374 | }; // end of Track |
| 375 | |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 376 | |
| 377 | // playback track, used by DuplicatingThread |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 378 | class OutputTrack : public Track, public IAfOutputTrack { |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 379 | public: |
| 380 | |
| 381 | class Buffer : public AudioBufferProvider::Buffer { |
| 382 | public: |
Andy Hung | c25b84a | 2015-01-14 19:04:10 -0800 | [diff] [blame] | 383 | void *mBuffer; |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 384 | }; |
| 385 | |
| 386 | OutputTrack(PlaybackThread *thread, |
| 387 | DuplicatingThread *sourceThread, |
| 388 | uint32_t sampleRate, |
| 389 | audio_format_t format, |
| 390 | audio_channel_mask_t channelMask, |
Marco Nelissen | 462fd2f | 2013-01-14 14:12:05 -0800 | [diff] [blame] | 391 | size_t frameCount, |
Svet Ganov | 3376113 | 2021-05-13 22:51:08 +0000 | [diff] [blame] | 392 | const AttributionSourceState& attributionSource); |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 393 | ~OutputTrack() override; |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 394 | |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 395 | status_t start(AudioSystem::sync_event_t event = |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 396 | AudioSystem::SYNC_EVENT_NONE, |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 397 | audio_session_t triggerSession = AUDIO_SESSION_NONE) final; |
| 398 | void stop() final; |
| 399 | ssize_t write(void* data, uint32_t frames) final; |
| 400 | bool bufferQueueEmpty() const final { return mBufferQueue.size() == 0; } |
| 401 | bool isActive() const final { return mActive; } |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 402 | |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 403 | void copyMetadataTo(MetadataInserter& backInserter) const final; |
Kevin Rocard | 1238109 | 2018-04-11 09:19:59 -0700 | [diff] [blame] | 404 | /** Set the metadatas of the upstream tracks. Thread safe. */ |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 405 | void setMetadatas(const SourceMetadatas& metadatas) final; |
Andy Hung | 1c86ebe | 2018-05-29 20:29:08 -0700 | [diff] [blame] | 406 | /** returns client timestamp to the upstream duplicating thread. */ |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 407 | ExtendedTimestamp getClientProxyTimestamp() const final { |
Andy Hung | 1c86ebe | 2018-05-29 20:29:08 -0700 | [diff] [blame] | 408 | // server - kernel difference is not true latency when drained |
| 409 | // i.e. mServerProxy->isDrained(). |
| 410 | ExtendedTimestamp timestamp; |
| 411 | (void) mClientProxy->getTimestamp(×tamp); |
| 412 | // On success, the timestamp LOCATION_SERVER and LOCATION_KERNEL |
| 413 | // entries will be properly filled. If getTimestamp() |
| 414 | // is unsuccessful, then a default initialized timestamp |
| 415 | // (with mTimeNs[] filled with -1's) is returned. |
| 416 | return timestamp; |
| 417 | } |
Kevin Rocard | 1238109 | 2018-04-11 09:19:59 -0700 | [diff] [blame] | 418 | private: |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 419 | status_t obtainBuffer(AudioBufferProvider::Buffer* buffer, |
| 420 | uint32_t waitTimeMs); |
Eric Laurent | 19952e1 | 2023-04-20 10:08:29 +0200 | [diff] [blame] | 421 | void queueBuffer(Buffer& inBuffer); |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 422 | void clearBufferQueue(); |
| 423 | |
Eric Laurent | 4d231dc | 2016-03-11 18:38:23 -0800 | [diff] [blame] | 424 | void restartIfDisabled(); |
| 425 | |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 426 | // Maximum number of pending buffers allocated by OutputTrack::write() |
| 427 | static const uint8_t kMaxOverFlowBuffers = 10; |
| 428 | |
| 429 | Vector < Buffer* > mBufferQueue; |
| 430 | AudioBufferProvider::Buffer mOutBuffer; |
| 431 | bool mActive; |
Eric Laurent | 5bba2f6 | 2016-03-18 11:14:14 -0700 | [diff] [blame] | 432 | DuplicatingThread* const mSourceThread; // for waitTimeMs() in write() |
| 433 | sp<AudioTrackClientProxy> mClientProxy; |
Andy Hung | 1c86ebe | 2018-05-29 20:29:08 -0700 | [diff] [blame] | 434 | |
Kevin Rocard | 1238109 | 2018-04-11 09:19:59 -0700 | [diff] [blame] | 435 | /** Attributes of the source tracks. |
| 436 | * |
| 437 | * This member must be accessed with mTrackMetadatasMutex taken. |
| 438 | * There is one writer (duplicating thread) and one reader (downstream mixer). |
| 439 | * |
| 440 | * That means that the duplicating thread can block the downstream mixer |
| 441 | * thread and vice versa for the time of the copy. |
| 442 | * If this becomes an issue, the metadata could be stored in an atomic raw pointer, |
| 443 | * and a exchange with nullptr and delete can be used. |
| 444 | * Alternatively a read-copy-update might be implemented. |
| 445 | */ |
| 446 | SourceMetadatas mTrackMetadatas; |
| 447 | /** Protects mTrackMetadatas against concurrent access. */ |
| 448 | mutable std::mutex mTrackMetadatasMutex; |
Eric Laurent | 81784c3 | 2012-11-19 14:55:58 -0800 | [diff] [blame] | 449 | }; // end of OutputTrack |
Eric Laurent | 83b8808 | 2014-06-20 18:31:16 -0700 | [diff] [blame] | 450 | |
| 451 | // playback track, used by PatchPanel |
Andy Hung | ca9be05 | 2023-06-26 19:20:57 -0700 | [diff] [blame^] | 452 | class PatchTrack : public Track, public PatchTrackBase, public IAfPatchTrack { |
Eric Laurent | 83b8808 | 2014-06-20 18:31:16 -0700 | [diff] [blame] | 453 | public: |
| 454 | |
| 455 | PatchTrack(PlaybackThread *playbackThread, |
Eric Laurent | 3bcf859 | 2015-04-03 12:13:24 -0700 | [diff] [blame] | 456 | audio_stream_type_t streamType, |
Eric Laurent | 83b8808 | 2014-06-20 18:31:16 -0700 | [diff] [blame] | 457 | uint32_t sampleRate, |
| 458 | audio_channel_mask_t channelMask, |
| 459 | audio_format_t format, |
| 460 | size_t frameCount, |
| 461 | void *buffer, |
Andy Hung | 8fe6803 | 2017-06-05 16:17:51 -0700 | [diff] [blame] | 462 | size_t bufferSize, |
Kevin Rocard | 45986c7 | 2018-12-18 18:22:59 -0800 | [diff] [blame] | 463 | audio_output_flags_t flags, |
Kevin Rocard | 01c7d9e | 2019-09-18 11:24:52 +0100 | [diff] [blame] | 464 | const Timeout& timeout = {}, |
| 465 | size_t frameCountToBeReady = 1 /** Default behaviour is to start |
| 466 | * as soon as possible to have |
| 467 | * the lowest possible latency |
| 468 | * even if it might glitch. */); |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 469 | ~PatchTrack() override; |
Eric Laurent | 83b8808 | 2014-06-20 18:31:16 -0700 | [diff] [blame] | 470 | |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 471 | size_t framesReady() const final; |
Mikhail Naganov | caf5994 | 2019-09-25 14:05:29 -0700 | [diff] [blame] | 472 | |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 473 | status_t start(AudioSystem::sync_event_t event = |
Eric Laurent | 4d231dc | 2016-03-11 18:38:23 -0800 | [diff] [blame] | 474 | AudioSystem::SYNC_EVENT_NONE, |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 475 | audio_session_t triggerSession = AUDIO_SESSION_NONE) final; |
Eric Laurent | 4d231dc | 2016-03-11 18:38:23 -0800 | [diff] [blame] | 476 | |
Eric Laurent | 83b8808 | 2014-06-20 18:31:16 -0700 | [diff] [blame] | 477 | // AudioBufferProvider interface |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 478 | status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) final; |
| 479 | void releaseBuffer(AudioBufferProvider::Buffer* buffer) final; |
Eric Laurent | 83b8808 | 2014-06-20 18:31:16 -0700 | [diff] [blame] | 480 | |
| 481 | // PatchProxyBufferProvider interface |
Andy Hung | d29af63 | 2023-06-23 19:27:19 -0700 | [diff] [blame] | 482 | status_t obtainBuffer(Proxy::Buffer* buffer, const struct timespec* timeOut = nullptr) final; |
| 483 | void releaseBuffer(Proxy::Buffer* buffer) final; |
Eric Laurent | 83b8808 | 2014-06-20 18:31:16 -0700 | [diff] [blame] | 484 | |
Eric Laurent | 83b8808 | 2014-06-20 18:31:16 -0700 | [diff] [blame] | 485 | private: |
Eric Laurent | 4d231dc | 2016-03-11 18:38:23 -0800 | [diff] [blame] | 486 | void restartIfDisabled(); |
Eric Laurent | 83b8808 | 2014-06-20 18:31:16 -0700 | [diff] [blame] | 487 | }; // end of PatchTrack |