blob: 341143823a35e4aba7bfce1a2f1dd1ea5c6f725b [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
Mathias Agopiand0566bc2011-11-17 17:49:17 -080019#include <sys/types.h>
Dominik Laskowski00a6fa22018-06-06 16:42:02 -070020
Lloyd Pique46a46b32018-01-31 19:01:18 -080021#include <condition_variable>
Dominik Laskowski00a6fa22018-06-06 16:42:02 -070022#include <cstdint>
Dominik Laskowskid9e4de62019-01-21 14:23:01 -080023#include <deque>
Lloyd Pique46a46b32018-01-31 19:01:18 -080024#include <mutex>
Dominik Laskowski1eba0202019-01-24 09:14:40 -080025#include <optional>
Lloyd Pique46a46b32018-01-31 19:01:18 -080026#include <thread>
Chia-I Wu98cd38f2018-09-14 11:53:25 -070027#include <vector>
Lloyd Pique46a46b32018-01-31 19:01:18 -080028
29#include <android-base/thread_annotations.h>
Mathias Agopiand0566bc2011-11-17 17:49:17 -080030
Mathias Agopiancb9732a2012-04-03 17:48:03 -070031#include <gui/DisplayEventReceiver.h>
Mathias Agopiand0566bc2011-11-17 17:49:17 -080032#include <gui/IDisplayEventConnection.h>
Lloyd Pique78ce4182018-01-31 16:39:51 -080033#include <private/gui/BitTube.h>
Mathias Agopiand0566bc2011-11-17 17:49:17 -080034
35#include <utils/Errors.h>
Mathias Agopiand0566bc2011-11-17 17:49:17 -080036
37// ---------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -080038namespace android {
Mathias Agopiand0566bc2011-11-17 17:49:17 -080039// ---------------------------------------------------------------------------
40
Ana Krulec85c39af2018-12-26 17:29:57 -080041class EventThread;
Lloyd Pique24b0a482018-03-09 18:52:26 -080042class EventThreadTest;
Mathias Agopiand0566bc2011-11-17 17:49:17 -080043class SurfaceFlinger;
Mathias Agopiand0566bc2011-11-17 17:49:17 -080044
45// ---------------------------------------------------------------------------
46
Dominik Laskowskif654d572018-12-20 11:03:06 -080047using ResyncCallback = std::function<void()>;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -080048using ResetIdleTimerCallback = std::function<void()>;
Dominik Laskowskif654d572018-12-20 11:03:06 -080049
Dominik Laskowskid9e4de62019-01-21 14:23:01 -080050enum class VSyncRequest {
51 None = -1,
52 Single = 0,
53 Periodic = 1,
54 // Subsequent values are periods.
55};
56
Lloyd Piquee83f9312018-02-01 12:53:17 -080057class VSyncSource {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070058public:
Lloyd Piquee83f9312018-02-01 12:53:17 -080059 class Callback {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070060 public:
61 virtual ~Callback() {}
62 virtual void onVSyncEvent(nsecs_t when) = 0;
63 };
64
65 virtual ~VSyncSource() {}
66 virtual void setVSyncEnabled(bool enable) = 0;
Lloyd Piquee83f9312018-02-01 12:53:17 -080067 virtual void setCallback(Callback* callback) = 0;
Dan Stozadb4ac3c2015-04-14 11:34:01 -070068 virtual void setPhaseOffset(nsecs_t phaseOffset) = 0;
Ady Abrahamb838aed2019-02-12 15:30:16 -080069
70 // pause/resume vsync callback generation
71 virtual void pauseVsyncCallback(bool pause) = 0;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070072};
73
Ana Krulec85c39af2018-12-26 17:29:57 -080074class EventThreadConnection : public BnDisplayEventConnection {
75public:
Dominik Laskowskiccf37d72019-02-01 16:47:58 -080076 EventThreadConnection(EventThread*, ResyncCallback, ResetIdleTimerCallback);
Ana Krulec85c39af2018-12-26 17:29:57 -080077 virtual ~EventThreadConnection();
78
79 virtual status_t postEvent(const DisplayEventReceiver::Event& event);
80
81 status_t stealReceiveChannel(gui::BitTube* outChannel) override;
Dominik Laskowskid9e4de62019-01-21 14:23:01 -080082 status_t setVsyncRate(uint32_t rate) override;
Ana Krulec85c39af2018-12-26 17:29:57 -080083 void requestNextVsync() override; // asynchronous
Ana Krulec7d1d6832018-12-27 11:10:09 -080084 // Requesting Vsync for HWC does not reset the idle timer, since HWC requires a refresh
85 // in order to update the configs.
86 void requestNextVsyncForHWC();
Ana Krulec85c39af2018-12-26 17:29:57 -080087
Dominik Laskowskif654d572018-12-20 11:03:06 -080088 // Called in response to requestNextVsync.
89 const ResyncCallback resyncCallback;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -080090 const ResetIdleTimerCallback resetIdleTimerCallback;
Dominik Laskowskif654d572018-12-20 11:03:06 -080091
Dominik Laskowskid9e4de62019-01-21 14:23:01 -080092 VSyncRequest vsyncRequest = VSyncRequest::None;
Ana Krulec85c39af2018-12-26 17:29:57 -080093
94private:
95 virtual void onFirstRef();
96 EventThread* const mEventThread;
97 gui::BitTube mChannel;
98};
99
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800100class EventThread {
101public:
102 virtual ~EventThread();
103
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800104 virtual sp<EventThreadConnection> createEventConnection(ResyncCallback,
105 ResetIdleTimerCallback) const = 0;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800106
107 // called before the screen is turned off from main thread
108 virtual void onScreenReleased() = 0;
109
110 // called after the screen is turned on from main thread
111 virtual void onScreenAcquired() = 0;
112
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800113 virtual void onHotplugReceived(PhysicalDisplayId displayId, bool connected) = 0;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800114
Yiwei Zhang5434a782018-12-05 18:06:32 -0800115 virtual void dump(std::string& result) const = 0;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800116
117 virtual void setPhaseOffset(nsecs_t phaseOffset) = 0;
Ana Krulec85c39af2018-12-26 17:29:57 -0800118
119 virtual status_t registerDisplayEventConnection(
120 const sp<EventThreadConnection>& connection) = 0;
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800121 virtual void setVsyncRate(uint32_t rate, const sp<EventThreadConnection>& connection) = 0;
Ana Krulec7d1d6832018-12-27 11:10:09 -0800122 // Requests the next vsync. If resetIdleTimer is set to true, it resets the idle timer.
123 virtual void requestNextVsync(const sp<EventThreadConnection>& connection,
124 bool resetIdleTimer) = 0;
Ady Abrahamb838aed2019-02-12 15:30:16 -0800125
126 virtual void pauseVsyncCallback(bool pause) = 0;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800127};
128
129namespace impl {
130
131class EventThread : public android::EventThread, private VSyncSource::Callback {
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800132public:
Lloyd Pique24b0a482018-03-09 18:52:26 -0800133 using InterceptVSyncsCallback = std::function<void(nsecs_t)>;
134
Ana Krulec98b5b242018-08-10 15:03:23 -0700135 // TODO(b/113612090): Once the Scheduler is complete this constructor will become obsolete.
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800136 EventThread(VSyncSource*, InterceptVSyncsCallback, const char* threadName);
137 EventThread(std::unique_ptr<VSyncSource>, InterceptVSyncsCallback, const char* threadName);
Lloyd Pique46a46b32018-01-31 19:01:18 -0800138 ~EventThread();
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800139
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800140 sp<EventThreadConnection> createEventConnection(ResyncCallback,
141 ResetIdleTimerCallback) const override;
Mathias Agopian8aedd472012-01-24 16:39:14 -0800142
Ana Krulec85c39af2018-12-26 17:29:57 -0800143 status_t registerDisplayEventConnection(const sp<EventThreadConnection>& connection) override;
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800144 void setVsyncRate(uint32_t rate, const sp<EventThreadConnection>& connection) override;
Ana Krulec7d1d6832018-12-27 11:10:09 -0800145 void requestNextVsync(const sp<EventThreadConnection>& connection,
146 bool resetIdleTimer) override;
Mathias Agopian478ae5e2011-12-06 17:22:19 -0800147
Mathias Agopian22ffb112012-04-10 21:04:02 -0700148 // called before the screen is turned off from main thread
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800149 void onScreenReleased() override;
Mathias Agopian22ffb112012-04-10 21:04:02 -0700150
151 // called after the screen is turned on from main thread
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800152 void onScreenAcquired() override;
Mathias Agopian8aedd472012-01-24 16:39:14 -0800153
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800154 void onHotplugReceived(PhysicalDisplayId displayId, bool connected) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700155
Yiwei Zhang5434a782018-12-05 18:06:32 -0800156 void dump(std::string& result) const override;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800157
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800158 void setPhaseOffset(nsecs_t phaseOffset) override;
Dan Stozadb4ac3c2015-04-14 11:34:01 -0700159
Ady Abrahamb838aed2019-02-12 15:30:16 -0800160 void pauseVsyncCallback(bool pause) override;
161
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800162private:
Lloyd Pique24b0a482018-03-09 18:52:26 -0800163 friend EventThreadTest;
164
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800165 using DisplayEventConsumers = std::vector<sp<EventThreadConnection>>;
166
Ana Krulec98b5b242018-08-10 15:03:23 -0700167 // TODO(b/113612090): Once the Scheduler is complete this constructor will become obsolete.
168 EventThread(VSyncSource* src, std::unique_ptr<VSyncSource> uniqueSrc,
Ana Krulec98b5b242018-08-10 15:03:23 -0700169 InterceptVSyncsCallback interceptVSyncsCallback, const char* threadName);
170
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800171 void threadMain(std::unique_lock<std::mutex>& lock) REQUIRES(mMutex);
Chia-I Wu98cd38f2018-09-14 11:53:25 -0700172
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800173 bool shouldConsumeEvent(const DisplayEventReceiver::Event& event,
174 const sp<EventThreadConnection>& connection) const REQUIRES(mMutex);
175 void dispatchEvent(const DisplayEventReceiver::Event& event,
176 const DisplayEventConsumers& consumers) REQUIRES(mMutex);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700177
Ana Krulec85c39af2018-12-26 17:29:57 -0800178 void removeDisplayEventConnectionLocked(const wp<EventThreadConnection>& connection)
179 REQUIRES(mMutex);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800180
Lloyd Pique46a46b32018-01-31 19:01:18 -0800181 // Implements VSyncSource::Callback
182 void onVSyncEvent(nsecs_t timestamp) override;
Mathias Agopian23748662011-12-05 14:33:34 -0800183
Ana Krulec7d1d6832018-12-27 11:10:09 -0800184 // Acquires mutex and requests next vsync.
185 void requestNextVsyncInternal(const sp<EventThreadConnection>& connection) EXCLUDES(mMutex);
186
Ana Krulec98b5b242018-08-10 15:03:23 -0700187 // TODO(b/113612090): Once the Scheduler is complete this pointer will become obsolete.
188 VSyncSource* mVSyncSource GUARDED_BY(mMutex) = nullptr;
189 std::unique_ptr<VSyncSource> mVSyncSourceUnique GUARDED_BY(mMutex) = nullptr;
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800190
Lloyd Pique24b0a482018-03-09 18:52:26 -0800191 const InterceptVSyncsCallback mInterceptVSyncsCallback;
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800192 const char* const mThreadName;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800193
Lloyd Pique46a46b32018-01-31 19:01:18 -0800194 std::thread mThread;
195 mutable std::mutex mMutex;
196 mutable std::condition_variable mCondition;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800197
Ana Krulec85c39af2018-12-26 17:29:57 -0800198 std::vector<wp<EventThreadConnection>> mDisplayEventConnections GUARDED_BY(mMutex);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800199 std::deque<DisplayEventReceiver::Event> mPendingEvents GUARDED_BY(mMutex);
Dominik Laskowski23b867a2019-01-22 12:44:53 -0800200
201 // VSYNC state of connected display.
202 struct VSyncState {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800203 explicit VSyncState(PhysicalDisplayId displayId) : displayId(displayId) {}
Dominik Laskowski1eba0202019-01-24 09:14:40 -0800204
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800205 const PhysicalDisplayId displayId;
Dominik Laskowski23b867a2019-01-22 12:44:53 -0800206
207 // Number of VSYNC events since display was connected.
208 uint32_t count = 0;
209
210 // True if VSYNC should be faked, e.g. when display is off.
211 bool synthetic = false;
212 };
213
Dominik Laskowski1eba0202019-01-24 09:14:40 -0800214 // TODO(b/74619554): Create per-display threads waiting on respective VSYNC signals,
215 // and support headless mode by injecting a fake display with synthetic VSYNC.
216 std::optional<VSyncState> mVSyncState GUARDED_BY(mMutex);
Dominik Laskowski23b867a2019-01-22 12:44:53 -0800217
Dominik Laskowski029cc122019-01-23 19:52:06 -0800218 // State machine for event loop.
219 enum class State {
220 Idle,
221 Quit,
222 SyntheticVSync,
223 VSync,
224 };
Mathias Agopiane2c4f4e2012-04-10 18:25:31 -0700225
Dominik Laskowski029cc122019-01-23 19:52:06 -0800226 State mState GUARDED_BY(mMutex) = State::Idle;
227
228 static const char* toCString(State);
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800229};
230
231// ---------------------------------------------------------------------------
232
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800233} // namespace impl
234} // namespace android