blob: c3b9129744c07000eb874b6e9e11d465eb6f0002 [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
Lloyd Pique46a46b32018-01-31 19:01:18 -080026#include <condition_variable>
Dominik Laskowski00a6fa22018-06-06 16:42:02 -070027#include <cstdint>
Dominik Laskowskid9e4de62019-01-21 14:23:01 -080028#include <deque>
Lloyd Pique46a46b32018-01-31 19:01:18 -080029#include <mutex>
Dominik Laskowski1eba0202019-01-24 09:14:40 -080030#include <optional>
Lloyd Pique46a46b32018-01-31 19:01:18 -080031#include <thread>
Chia-I Wu98cd38f2018-09-14 11:53:25 -070032#include <vector>
Lloyd Pique46a46b32018-01-31 19:01:18 -080033
Marin Shalamanov23c44202020-12-22 19:09:20 +010034#include "DisplayHardware/DisplayMode.h"
Mathias Agopiand0566bc2011-11-17 17:49:17 -080035
36// ---------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -080037namespace android {
Mathias Agopiand0566bc2011-11-17 17:49:17 -080038// ---------------------------------------------------------------------------
39
Ana Krulec85c39af2018-12-26 17:29:57 -080040class EventThread;
Lloyd Pique24b0a482018-03-09 18:52:26 -080041class EventThreadTest;
Mathias Agopiand0566bc2011-11-17 17:49:17 -080042class SurfaceFlinger;
Mathias Agopiand0566bc2011-11-17 17:49:17 -080043
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -070044namespace frametimeline {
45class TokenManager;
46} // namespace frametimeline
47
Mathias Agopiand0566bc2011-11-17 17:49:17 -080048// ---------------------------------------------------------------------------
49
Dominik Laskowskif654d572018-12-20 11:03:06 -080050using ResyncCallback = std::function<void()>;
Ady Abraham62f216c2020-10-13 19:07:23 -070051using FrameRateOverride = DisplayEventReceiver::Event::FrameRateOverride;
Dominik Laskowskif654d572018-12-20 11:03:06 -080052
Dominik Laskowskid9e4de62019-01-21 14:23:01 -080053enum class VSyncRequest {
Tim Murrayb5daa912020-09-09 21:29:13 +000054 None = -2,
55 // Single wakes up for the next two frames to avoid scheduler overhead
56 Single = -1,
57 // SingleSuppressCallback only wakes up for the next frame
58 SingleSuppressCallback = 0,
Dominik Laskowskid9e4de62019-01-21 14:23:01 -080059 Periodic = 1,
60 // Subsequent values are periods.
61};
62
Lloyd Piquee83f9312018-02-01 12:53:17 -080063class VSyncSource {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070064public:
Rachel Leef16da3c2022-01-20 13:57:18 -080065 class VSyncData {
66 public:
67 nsecs_t expectedVSyncTimestamp;
68 nsecs_t deadlineTimestamp;
69 };
70
Lloyd Piquee83f9312018-02-01 12:53:17 -080071 class Callback {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070072 public:
73 virtual ~Callback() {}
Rachel Leef16da3c2022-01-20 13:57:18 -080074 virtual void onVSyncEvent(nsecs_t when, VSyncData vsyncData) = 0;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070075 };
76
77 virtual ~VSyncSource() {}
Dominik Laskowski6505f792019-09-18 11:10:05 -070078
79 virtual const char* getName() const = 0;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070080 virtual void setVSyncEnabled(bool enable) = 0;
Lloyd Piquee83f9312018-02-01 12:53:17 -080081 virtual void setCallback(Callback* callback) = 0;
Ady Abraham9c53ee72020-07-22 21:16:18 -070082 virtual void setDuration(std::chrono::nanoseconds workDuration,
83 std::chrono::nanoseconds readyDuration) = 0;
Ady Abraham5e7371c2020-03-24 14:47:24 -070084
85 virtual void dump(std::string& result) const = 0;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070086};
87
Huihong Luo6fac5232021-11-22 16:05:23 -080088class EventThreadConnection : public gui::BnDisplayEventConnection {
Ana Krulec85c39af2018-12-26 17:29:57 -080089public:
Ady Abraham0bb6a472020-10-12 10:22:13 -070090 EventThreadConnection(EventThread*, uid_t callingUid, ResyncCallback,
Ady Abraham62f216c2020-10-13 19:07:23 -070091 ISurfaceComposer::EventRegistrationFlags eventRegistration = {});
Ana Krulec85c39af2018-12-26 17:29:57 -080092 virtual ~EventThreadConnection();
93
94 virtual status_t postEvent(const DisplayEventReceiver::Event& event);
95
Huihong Luo6fac5232021-11-22 16:05:23 -080096 binder::Status stealReceiveChannel(gui::BitTube* outChannel) override;
97 binder::Status setVsyncRate(int rate) override;
98 binder::Status requestNextVsync() override; // asynchronous
Ana Krulec85c39af2018-12-26 17:29:57 -080099
Dominik Laskowskif654d572018-12-20 11:03:06 -0800100 // Called in response to requestNextVsync.
101 const ResyncCallback resyncCallback;
102
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800103 VSyncRequest vsyncRequest = VSyncRequest::None;
Ady Abraham0bb6a472020-10-12 10:22:13 -0700104 const uid_t mOwnerUid;
Ady Abraham62f216c2020-10-13 19:07:23 -0700105 const ISurfaceComposer::EventRegistrationFlags mEventRegistration;
Ady Abraham0bb6a472020-10-12 10:22:13 -0700106
Ana Krulec85c39af2018-12-26 17:29:57 -0800107private:
108 virtual void onFirstRef();
109 EventThread* const mEventThread;
110 gui::BitTube mChannel;
Ady Abraham62f216c2020-10-13 19:07:23 -0700111
112 std::vector<DisplayEventReceiver::Event> mPendingEvents;
Ana Krulec85c39af2018-12-26 17:29:57 -0800113};
114
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800115class EventThread {
116public:
117 virtual ~EventThread();
118
Ady Abraham0f4a1b12019-06-04 16:04:04 -0700119 virtual sp<EventThreadConnection> createEventConnection(
Ady Abraham62f216c2020-10-13 19:07:23 -0700120 ResyncCallback,
121 ISurfaceComposer::EventRegistrationFlags eventRegistration = {}) const = 0;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800122
123 // called before the screen is turned off from main thread
124 virtual void onScreenReleased() = 0;
125
126 // called after the screen is turned on from main thread
127 virtual void onScreenAcquired() = 0;
128
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800129 virtual void onHotplugReceived(PhysicalDisplayId displayId, bool connected) = 0;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800130
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100131 // called when SF changes the active mode and apps needs to be notified about the change
Ady Abraham690f4612021-07-01 23:24:03 -0700132 virtual void onModeChanged(DisplayModePtr) = 0;
Ady Abraham447052e2019-02-13 16:07:27 -0800133
Ady Abraham62f216c2020-10-13 19:07:23 -0700134 // called when SF updates the Frame Rate Override list
135 virtual void onFrameRateOverridesChanged(PhysicalDisplayId displayId,
136 std::vector<FrameRateOverride> overrides) = 0;
137
Yiwei Zhang5434a782018-12-05 18:06:32 -0800138 virtual void dump(std::string& result) const = 0;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800139
Ady Abraham9c53ee72020-07-22 21:16:18 -0700140 virtual void setDuration(std::chrono::nanoseconds workDuration,
141 std::chrono::nanoseconds readyDuration) = 0;
Ana Krulec85c39af2018-12-26 17:29:57 -0800142
143 virtual status_t registerDisplayEventConnection(
144 const sp<EventThreadConnection>& connection) = 0;
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800145 virtual void setVsyncRate(uint32_t rate, const sp<EventThreadConnection>& connection) = 0;
Ana Krulec7d1d6832018-12-27 11:10:09 -0800146 // Requests the next vsync. If resetIdleTimer is set to true, it resets the idle timer.
Ady Abraham8532d012019-05-08 14:50:56 -0700147 virtual void requestNextVsync(const sp<EventThreadConnection>& connection) = 0;
Alec Mouri717bcb62020-02-10 17:07:19 -0800148
149 // Retrieves the number of event connections tracked by this EventThread.
150 virtual size_t getEventThreadConnectionCount() = 0;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800151};
152
153namespace impl {
154
155class EventThread : public android::EventThread, private VSyncSource::Callback {
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800156public:
Lloyd Pique24b0a482018-03-09 18:52:26 -0800157 using InterceptVSyncsCallback = std::function<void(nsecs_t)>;
Ady Abraham0bb6a472020-10-12 10:22:13 -0700158 using ThrottleVsyncCallback = std::function<bool(nsecs_t, uid_t)>;
Jorim Jaggic0086af2021-02-12 18:18:11 +0100159 using GetVsyncPeriodFunction = std::function<nsecs_t(uid_t)>;
Lloyd Pique24b0a482018-03-09 18:52:26 -0800160
Ady Abraham0bb6a472020-10-12 10:22:13 -0700161 EventThread(std::unique_ptr<VSyncSource>, frametimeline::TokenManager*, InterceptVSyncsCallback,
Jorim Jaggic0086af2021-02-12 18:18:11 +0100162 ThrottleVsyncCallback, GetVsyncPeriodFunction);
Lloyd Pique46a46b32018-01-31 19:01:18 -0800163 ~EventThread();
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800164
Ady Abraham0f4a1b12019-06-04 16:04:04 -0700165 sp<EventThreadConnection> createEventConnection(
Ady Abraham62f216c2020-10-13 19:07:23 -0700166 ResyncCallback,
167 ISurfaceComposer::EventRegistrationFlags eventRegistration = {}) const override;
Mathias Agopian8aedd472012-01-24 16:39:14 -0800168
Ana Krulec85c39af2018-12-26 17:29:57 -0800169 status_t registerDisplayEventConnection(const sp<EventThreadConnection>& connection) override;
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800170 void setVsyncRate(uint32_t rate, const sp<EventThreadConnection>& connection) override;
Ady Abraham8532d012019-05-08 14:50:56 -0700171 void requestNextVsync(const sp<EventThreadConnection>& connection) override;
Mathias Agopian478ae5e2011-12-06 17:22:19 -0800172
Mathias Agopian22ffb112012-04-10 21:04:02 -0700173 // called before the screen is turned off from main thread
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800174 void onScreenReleased() override;
Mathias Agopian22ffb112012-04-10 21:04:02 -0700175
176 // called after the screen is turned on from main thread
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800177 void onScreenAcquired() override;
Mathias Agopian8aedd472012-01-24 16:39:14 -0800178
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800179 void onHotplugReceived(PhysicalDisplayId displayId, bool connected) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700180
Ady Abraham690f4612021-07-01 23:24:03 -0700181 void onModeChanged(DisplayModePtr) override;
Ady Abraham447052e2019-02-13 16:07:27 -0800182
Ady Abraham62f216c2020-10-13 19:07:23 -0700183 void onFrameRateOverridesChanged(PhysicalDisplayId displayId,
184 std::vector<FrameRateOverride> overrides) override;
185
Yiwei Zhang5434a782018-12-05 18:06:32 -0800186 void dump(std::string& result) const override;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800187
Ady Abraham9c53ee72020-07-22 21:16:18 -0700188 void setDuration(std::chrono::nanoseconds workDuration,
189 std::chrono::nanoseconds readyDuration) override;
Dan Stozadb4ac3c2015-04-14 11:34:01 -0700190
Alec Mouri717bcb62020-02-10 17:07:19 -0800191 size_t getEventThreadConnectionCount() override;
192
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800193private:
Lloyd Pique24b0a482018-03-09 18:52:26 -0800194 friend EventThreadTest;
195
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800196 using DisplayEventConsumers = std::vector<sp<EventThreadConnection>>;
197
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800198 void threadMain(std::unique_lock<std::mutex>& lock) REQUIRES(mMutex);
Chia-I Wu98cd38f2018-09-14 11:53:25 -0700199
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800200 bool shouldConsumeEvent(const DisplayEventReceiver::Event& event,
201 const sp<EventThreadConnection>& connection) const REQUIRES(mMutex);
202 void dispatchEvent(const DisplayEventReceiver::Event& event,
203 const DisplayEventConsumers& consumers) REQUIRES(mMutex);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700204
Ana Krulec85c39af2018-12-26 17:29:57 -0800205 void removeDisplayEventConnectionLocked(const wp<EventThreadConnection>& connection)
206 REQUIRES(mMutex);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800207
Lloyd Pique46a46b32018-01-31 19:01:18 -0800208 // Implements VSyncSource::Callback
Rachel Leef16da3c2022-01-20 13:57:18 -0800209 void onVSyncEvent(nsecs_t timestamp, VSyncSource::VSyncData vsyncData) override;
Mathias Agopian23748662011-12-05 14:33:34 -0800210
Rachel Lee8d0c6102021-11-03 22:00:25 +0000211 int64_t generateToken(nsecs_t timestamp, nsecs_t deadlineTimestamp,
212 nsecs_t expectedVSyncTimestamp) const;
Rachel Lee3f028662021-11-04 19:32:24 +0000213 void generateFrameTimeline(DisplayEventReceiver::Event& event) const;
214
Dominik Laskowski6505f792019-09-18 11:10:05 -0700215 const std::unique_ptr<VSyncSource> mVSyncSource GUARDED_BY(mMutex);
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700216 frametimeline::TokenManager* const mTokenManager;
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800217
Lloyd Pique24b0a482018-03-09 18:52:26 -0800218 const InterceptVSyncsCallback mInterceptVSyncsCallback;
Ady Abraham0bb6a472020-10-12 10:22:13 -0700219 const ThrottleVsyncCallback mThrottleVsyncCallback;
Jorim Jaggic0086af2021-02-12 18:18:11 +0100220 const GetVsyncPeriodFunction mGetVsyncPeriodFunction;
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800221 const char* const mThreadName;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800222
Lloyd Pique46a46b32018-01-31 19:01:18 -0800223 std::thread mThread;
224 mutable std::mutex mMutex;
225 mutable std::condition_variable mCondition;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800226
Ana Krulec85c39af2018-12-26 17:29:57 -0800227 std::vector<wp<EventThreadConnection>> mDisplayEventConnections GUARDED_BY(mMutex);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800228 std::deque<DisplayEventReceiver::Event> mPendingEvents GUARDED_BY(mMutex);
Dominik Laskowski23b867a2019-01-22 12:44:53 -0800229
230 // VSYNC state of connected display.
231 struct VSyncState {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800232 explicit VSyncState(PhysicalDisplayId displayId) : displayId(displayId) {}
Dominik Laskowski1eba0202019-01-24 09:14:40 -0800233
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800234 const PhysicalDisplayId displayId;
Dominik Laskowski23b867a2019-01-22 12:44:53 -0800235
236 // Number of VSYNC events since display was connected.
237 uint32_t count = 0;
238
239 // True if VSYNC should be faked, e.g. when display is off.
240 bool synthetic = false;
241 };
242
Dominik Laskowski1eba0202019-01-24 09:14:40 -0800243 // TODO(b/74619554): Create per-display threads waiting on respective VSYNC signals,
244 // and support headless mode by injecting a fake display with synthetic VSYNC.
245 std::optional<VSyncState> mVSyncState GUARDED_BY(mMutex);
Dominik Laskowski23b867a2019-01-22 12:44:53 -0800246
Dominik Laskowski029cc122019-01-23 19:52:06 -0800247 // State machine for event loop.
248 enum class State {
249 Idle,
250 Quit,
251 SyntheticVSync,
252 VSync,
253 };
Mathias Agopiane2c4f4e2012-04-10 18:25:31 -0700254
Dominik Laskowski029cc122019-01-23 19:52:06 -0800255 State mState GUARDED_BY(mMutex) = State::Idle;
256
257 static const char* toCString(State);
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800258};
259
260// ---------------------------------------------------------------------------
261
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800262} // namespace impl
263} // namespace android