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