blob: b86553bebe58a774399758ade72ed988d4839d1e [file] [log] [blame]
Mathias Agopiand0566bc2011-11-17 17:49:17 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Lloyd Pique46a46b32018-01-31 19:01:18 -080017#pragma once
Mathias Agopiand0566bc2011-11-17 17:49:17 -080018
Alec Mouri717bcb62020-02-10 17:07:19 -080019#include <android-base/thread_annotations.h>
Huihong Luo6fac5232021-11-22 16:05:23 -080020#include <android/gui/BnDisplayEventConnection.h>
Alec Mouri717bcb62020-02-10 17:07:19 -080021#include <gui/DisplayEventReceiver.h>
Alec Mouri717bcb62020-02-10 17:07:19 -080022#include <private/gui/BitTube.h>
Mathias Agopiand0566bc2011-11-17 17:49:17 -080023#include <sys/types.h>
Alec Mouri717bcb62020-02-10 17:07:19 -080024#include <utils/Errors.h>
Dominik Laskowski00a6fa22018-06-06 16:42:02 -070025
Leon Scroggins III31d41412022-11-18 16:42:53 -050026#include <scheduler/Fps.h>
Ady Abraham67434eb2022-12-01 17:48:12 -080027#include <scheduler/FrameRateMode.h>
Lloyd Pique46a46b32018-01-31 19:01:18 -080028#include <condition_variable>
Dominik Laskowski00a6fa22018-06-06 16:42:02 -070029#include <cstdint>
Dominik Laskowskid9e4de62019-01-21 14:23:01 -080030#include <deque>
Lloyd Pique46a46b32018-01-31 19:01:18 -080031#include <mutex>
Dominik Laskowski1eba0202019-01-24 09:14:40 -080032#include <optional>
Lloyd Pique46a46b32018-01-31 19:01:18 -080033#include <thread>
Chia-I Wu98cd38f2018-09-14 11:53:25 -070034#include <vector>
Lloyd Pique46a46b32018-01-31 19:01:18 -080035
Marin Shalamanov23c44202020-12-22 19:09:20 +010036#include "DisplayHardware/DisplayMode.h"
Ady Abraham011f8ba2022-11-22 15:09:07 -080037#include "TracedOrdinal.h"
38#include "VSyncDispatch.h"
39#include "VsyncSchedule.h"
Mathias Agopiand0566bc2011-11-17 17:49:17 -080040
41// ---------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -080042namespace android {
Mathias Agopiand0566bc2011-11-17 17:49:17 -080043// ---------------------------------------------------------------------------
44
Ana Krulec85c39af2018-12-26 17:29:57 -080045class EventThread;
Lloyd Pique24b0a482018-03-09 18:52:26 -080046class EventThreadTest;
Mathias Agopiand0566bc2011-11-17 17:49:17 -080047class SurfaceFlinger;
Mathias Agopiand0566bc2011-11-17 17:49:17 -080048
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -070049namespace frametimeline {
50class TokenManager;
51} // namespace frametimeline
52
Rachel Leeb9c5a772022-02-04 21:17:37 -080053using gui::ParcelableVsyncEventData;
Rachel Leeef2e21f2022-02-01 14:51:34 -080054using gui::VsyncEventData;
55
Mathias Agopiand0566bc2011-11-17 17:49:17 -080056// ---------------------------------------------------------------------------
57
Dominik Laskowskif654d572018-12-20 11:03:06 -080058using ResyncCallback = std::function<void()>;
Ady Abraham62f216c2020-10-13 19:07:23 -070059using FrameRateOverride = DisplayEventReceiver::Event::FrameRateOverride;
Dominik Laskowskif654d572018-12-20 11:03:06 -080060
Dominik Laskowskid9e4de62019-01-21 14:23:01 -080061enum class VSyncRequest {
Tim Murrayb5daa912020-09-09 21:29:13 +000062 None = -2,
63 // Single wakes up for the next two frames to avoid scheduler overhead
64 Single = -1,
65 // SingleSuppressCallback only wakes up for the next frame
66 SingleSuppressCallback = 0,
Dominik Laskowskid9e4de62019-01-21 14:23:01 -080067 Periodic = 1,
68 // Subsequent values are periods.
69};
70
Leon Scroggins III31d41412022-11-18 16:42:53 -050071class IEventThreadCallback {
72public:
73 virtual ~IEventThreadCallback() = default;
74
75 virtual bool isVsyncTargetForUid(TimePoint expectedVsyncTime, uid_t uid) const = 0;
76
77 virtual Fps getLeaderRenderFrameRate(uid_t uid) const = 0;
78};
79
Huihong Luo6fac5232021-11-22 16:05:23 -080080class EventThreadConnection : public gui::BnDisplayEventConnection {
Ana Krulec85c39af2018-12-26 17:29:57 -080081public:
Ady Abraham0bb6a472020-10-12 10:22:13 -070082 EventThreadConnection(EventThread*, uid_t callingUid, ResyncCallback,
Huihong Luo1b0c49f2022-03-15 19:18:21 -070083 EventRegistrationFlags eventRegistration = {});
Ana Krulec85c39af2018-12-26 17:29:57 -080084 virtual ~EventThreadConnection();
85
86 virtual status_t postEvent(const DisplayEventReceiver::Event& event);
87
Huihong Luo6fac5232021-11-22 16:05:23 -080088 binder::Status stealReceiveChannel(gui::BitTube* outChannel) override;
89 binder::Status setVsyncRate(int rate) override;
90 binder::Status requestNextVsync() override; // asynchronous
Rachel Leeb9c5a772022-02-04 21:17:37 -080091 binder::Status getLatestVsyncEventData(ParcelableVsyncEventData* outVsyncEventData) override;
Ana Krulec85c39af2018-12-26 17:29:57 -080092
Dominik Laskowskif654d572018-12-20 11:03:06 -080093 // Called in response to requestNextVsync.
94 const ResyncCallback resyncCallback;
95
Dominik Laskowskid9e4de62019-01-21 14:23:01 -080096 VSyncRequest vsyncRequest = VSyncRequest::None;
Ady Abraham0bb6a472020-10-12 10:22:13 -070097 const uid_t mOwnerUid;
Huihong Luo1b0c49f2022-03-15 19:18:21 -070098 const EventRegistrationFlags mEventRegistration;
Ady Abraham0bb6a472020-10-12 10:22:13 -070099
Ana Krulec85c39af2018-12-26 17:29:57 -0800100private:
101 virtual void onFirstRef();
102 EventThread* const mEventThread;
Ady Abraham899e8cd2022-06-06 15:16:06 -0700103 std::mutex mLock;
104 gui::BitTube mChannel GUARDED_BY(mLock);
Ady Abraham62f216c2020-10-13 19:07:23 -0700105
106 std::vector<DisplayEventReceiver::Event> mPendingEvents;
Ana Krulec85c39af2018-12-26 17:29:57 -0800107};
108
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800109class EventThread {
110public:
111 virtual ~EventThread();
112
Ady Abraham0f4a1b12019-06-04 16:04:04 -0700113 virtual sp<EventThreadConnection> createEventConnection(
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700114 ResyncCallback, EventRegistrationFlags eventRegistration = {}) const = 0;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800115
116 // called before the screen is turned off from main thread
117 virtual void onScreenReleased() = 0;
118
119 // called after the screen is turned on from main thread
120 virtual void onScreenAcquired() = 0;
121
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800122 virtual void onHotplugReceived(PhysicalDisplayId displayId, bool connected) = 0;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800123
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100124 // called when SF changes the active mode and apps needs to be notified about the change
Ady Abraham67434eb2022-12-01 17:48:12 -0800125 virtual void onModeChanged(const scheduler::FrameRateMode&) = 0;
Ady Abraham447052e2019-02-13 16:07:27 -0800126
Ady Abraham62f216c2020-10-13 19:07:23 -0700127 // called when SF updates the Frame Rate Override list
128 virtual void onFrameRateOverridesChanged(PhysicalDisplayId displayId,
129 std::vector<FrameRateOverride> overrides) = 0;
130
Yiwei Zhang5434a782018-12-05 18:06:32 -0800131 virtual void dump(std::string& result) const = 0;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800132
Ady Abraham9c53ee72020-07-22 21:16:18 -0700133 virtual void setDuration(std::chrono::nanoseconds workDuration,
134 std::chrono::nanoseconds readyDuration) = 0;
Ana Krulec85c39af2018-12-26 17:29:57 -0800135
136 virtual status_t registerDisplayEventConnection(
137 const sp<EventThreadConnection>& connection) = 0;
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800138 virtual void setVsyncRate(uint32_t rate, const sp<EventThreadConnection>& connection) = 0;
Ana Krulec7d1d6832018-12-27 11:10:09 -0800139 // Requests the next vsync. If resetIdleTimer is set to true, it resets the idle timer.
Ady Abraham8532d012019-05-08 14:50:56 -0700140 virtual void requestNextVsync(const sp<EventThreadConnection>& connection) = 0;
Rachel Leeef2e21f2022-02-01 14:51:34 -0800141 virtual VsyncEventData getLatestVsyncEventData(
142 const sp<EventThreadConnection>& connection) const = 0;
Alec Mouri717bcb62020-02-10 17:07:19 -0800143
144 // Retrieves the number of event connections tracked by this EventThread.
145 virtual size_t getEventThreadConnectionCount() = 0;
Leon Scroggins III31d41412022-11-18 16:42:53 -0500146
147 virtual void onNewVsyncSchedule(std::shared_ptr<scheduler::VsyncSchedule>) = 0;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800148};
149
150namespace impl {
151
Ady Abraham011f8ba2022-11-22 15:09:07 -0800152class EventThread : public android::EventThread {
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800153public:
Leon Scroggins III31d41412022-11-18 16:42:53 -0500154 EventThread(const char* name, std::shared_ptr<scheduler::VsyncSchedule>, IEventThreadCallback&,
155 frametimeline::TokenManager*, std::chrono::nanoseconds workDuration,
156 std::chrono::nanoseconds readyDuration);
Lloyd Pique46a46b32018-01-31 19:01:18 -0800157 ~EventThread();
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800158
Ady Abraham0f4a1b12019-06-04 16:04:04 -0700159 sp<EventThreadConnection> createEventConnection(
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700160 ResyncCallback, EventRegistrationFlags eventRegistration = {}) const override;
Mathias Agopian8aedd472012-01-24 16:39:14 -0800161
Ana Krulec85c39af2018-12-26 17:29:57 -0800162 status_t registerDisplayEventConnection(const sp<EventThreadConnection>& connection) override;
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800163 void setVsyncRate(uint32_t rate, const sp<EventThreadConnection>& connection) override;
Ady Abraham8532d012019-05-08 14:50:56 -0700164 void requestNextVsync(const sp<EventThreadConnection>& connection) override;
Rachel Leeef2e21f2022-02-01 14:51:34 -0800165 VsyncEventData getLatestVsyncEventData(
166 const sp<EventThreadConnection>& connection) const override;
Mathias Agopian478ae5e2011-12-06 17:22:19 -0800167
Mathias Agopian22ffb112012-04-10 21:04:02 -0700168 // called before the screen is turned off from main thread
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800169 void onScreenReleased() override;
Mathias Agopian22ffb112012-04-10 21:04:02 -0700170
171 // called after the screen is turned on from main thread
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800172 void onScreenAcquired() override;
Mathias Agopian8aedd472012-01-24 16:39:14 -0800173
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800174 void onHotplugReceived(PhysicalDisplayId displayId, bool connected) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700175
Ady Abraham67434eb2022-12-01 17:48:12 -0800176 void onModeChanged(const scheduler::FrameRateMode&) override;
Ady Abraham447052e2019-02-13 16:07:27 -0800177
Ady Abraham62f216c2020-10-13 19:07:23 -0700178 void onFrameRateOverridesChanged(PhysicalDisplayId displayId,
179 std::vector<FrameRateOverride> overrides) override;
180
Yiwei Zhang5434a782018-12-05 18:06:32 -0800181 void dump(std::string& result) const override;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800182
Ady Abraham9c53ee72020-07-22 21:16:18 -0700183 void setDuration(std::chrono::nanoseconds workDuration,
184 std::chrono::nanoseconds readyDuration) override;
Dan Stozadb4ac3c2015-04-14 11:34:01 -0700185
Alec Mouri717bcb62020-02-10 17:07:19 -0800186 size_t getEventThreadConnectionCount() override;
187
Leon Scroggins III31d41412022-11-18 16:42:53 -0500188 void onNewVsyncSchedule(std::shared_ptr<scheduler::VsyncSchedule>) override;
189
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800190private:
Lloyd Pique24b0a482018-03-09 18:52:26 -0800191 friend EventThreadTest;
192
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800193 using DisplayEventConsumers = std::vector<sp<EventThreadConnection>>;
194
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800195 void threadMain(std::unique_lock<std::mutex>& lock) REQUIRES(mMutex);
Chia-I Wu98cd38f2018-09-14 11:53:25 -0700196
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800197 bool shouldConsumeEvent(const DisplayEventReceiver::Event& event,
198 const sp<EventThreadConnection>& connection) const REQUIRES(mMutex);
199 void dispatchEvent(const DisplayEventReceiver::Event& event,
200 const DisplayEventConsumers& consumers) REQUIRES(mMutex);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700201
Ana Krulec85c39af2018-12-26 17:29:57 -0800202 void removeDisplayEventConnectionLocked(const wp<EventThreadConnection>& connection)
203 REQUIRES(mMutex);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800204
Ady Abraham011f8ba2022-11-22 15:09:07 -0800205 void onVsync(nsecs_t vsyncTime, nsecs_t wakeupTime, nsecs_t readyTime);
Mathias Agopian23748662011-12-05 14:33:34 -0800206
Rachel Lee8d0c6102021-11-03 22:00:25 +0000207 int64_t generateToken(nsecs_t timestamp, nsecs_t deadlineTimestamp,
Rachel Leeb9c5a772022-02-04 21:17:37 -0800208 nsecs_t expectedPresentationTime) const;
209 void generateFrameTimeline(VsyncEventData& outVsyncEventData, nsecs_t frameInterval,
210 nsecs_t timestamp, nsecs_t preferredExpectedPresentationTime,
211 nsecs_t preferredDeadlineTimestamp) const;
Rachel Lee3f028662021-11-04 19:32:24 +0000212
Leon Scroggins III31d41412022-11-18 16:42:53 -0500213 scheduler::VSyncDispatch::Callback createDispatchCallback();
214
Ady Abraham011f8ba2022-11-22 15:09:07 -0800215 const char* const mThreadName;
216 TracedOrdinal<int> mVsyncTracer;
217 TracedOrdinal<std::chrono::nanoseconds> mWorkDuration GUARDED_BY(mMutex);
218 std::chrono::nanoseconds mReadyDuration GUARDED_BY(mMutex);
Leon Scroggins III31d41412022-11-18 16:42:53 -0500219 std::shared_ptr<scheduler::VsyncSchedule> mVsyncSchedule;
Ady Abraham011f8ba2022-11-22 15:09:07 -0800220 TimePoint mLastVsyncCallbackTime GUARDED_BY(mMutex) = TimePoint::now();
221 scheduler::VSyncCallbackRegistration mVsyncRegistration GUARDED_BY(mMutex);
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700222 frametimeline::TokenManager* const mTokenManager;
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800223
Leon Scroggins III31d41412022-11-18 16:42:53 -0500224 // mEventThreadCallback will outlive the EventThread.
225 IEventThreadCallback& mEventThreadCallback;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800226
Lloyd Pique46a46b32018-01-31 19:01:18 -0800227 std::thread mThread;
228 mutable std::mutex mMutex;
229 mutable std::condition_variable mCondition;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800230
Ana Krulec85c39af2018-12-26 17:29:57 -0800231 std::vector<wp<EventThreadConnection>> mDisplayEventConnections GUARDED_BY(mMutex);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800232 std::deque<DisplayEventReceiver::Event> mPendingEvents GUARDED_BY(mMutex);
Dominik Laskowski23b867a2019-01-22 12:44:53 -0800233
234 // VSYNC state of connected display.
235 struct VSyncState {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800236 explicit VSyncState(PhysicalDisplayId displayId) : displayId(displayId) {}
Dominik Laskowski1eba0202019-01-24 09:14:40 -0800237
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800238 const PhysicalDisplayId displayId;
Dominik Laskowski23b867a2019-01-22 12:44:53 -0800239
240 // Number of VSYNC events since display was connected.
241 uint32_t count = 0;
242
243 // True if VSYNC should be faked, e.g. when display is off.
244 bool synthetic = false;
245 };
246
Dominik Laskowski1eba0202019-01-24 09:14:40 -0800247 // TODO(b/74619554): Create per-display threads waiting on respective VSYNC signals,
248 // and support headless mode by injecting a fake display with synthetic VSYNC.
249 std::optional<VSyncState> mVSyncState GUARDED_BY(mMutex);
Dominik Laskowski23b867a2019-01-22 12:44:53 -0800250
Dominik Laskowski029cc122019-01-23 19:52:06 -0800251 // State machine for event loop.
252 enum class State {
253 Idle,
254 Quit,
255 SyntheticVSync,
256 VSync,
257 };
Mathias Agopiane2c4f4e2012-04-10 18:25:31 -0700258
Dominik Laskowski029cc122019-01-23 19:52:06 -0800259 State mState GUARDED_BY(mMutex) = State::Idle;
260
261 static const char* toCString(State);
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800262};
263
264// ---------------------------------------------------------------------------
265
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800266} // namespace impl
267} // namespace android