blob: 6b5a8b715d7e4ebd5df59b32ac20e265dc94de3d [file] [log] [blame]
Ana Krulec98b5b242018-08-10 15:03:23 -07001/*
2 * Copyright 2018 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
17#pragma once
18
19#include <cstdint>
Kevin DuBois413287f2019-02-25 08:46:47 -080020#include <functional>
Ana Krulec98b5b242018-08-10 15:03:23 -070021#include <memory>
22
Ana Krulece588e312018-09-18 12:32:24 -070023#include <ui/DisplayStatInfo.h>
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -080024#include <ui/GraphicTypes.h>
Ana Krulec98b5b242018-08-10 15:03:23 -070025
26#include "DispSync.h"
Ana Krulece588e312018-09-18 12:32:24 -070027#include "EventControlThread.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070028#include "EventThread.h"
Ana Krulecfb772822018-11-30 10:44:07 +010029#include "IdleTimer.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070030#include "InjectVSyncSource.h"
Ana Krulec3084c052018-11-21 20:27:17 +010031#include "LayerHistory.h"
Ana Krulec8d3e4f32019-03-05 10:40:33 -080032#include "RefreshRateConfigs.h"
Ana Krulec434c22d2018-11-28 13:48:36 +010033#include "SchedulerUtils.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070034
35namespace android {
36
Ana Krulece588e312018-09-18 12:32:24 -070037class EventControlThread;
38
Ana Krulec98b5b242018-08-10 15:03:23 -070039class Scheduler {
40public:
Ana Krulec8d3e4f32019-03-05 10:40:33 -080041 // Enum to keep track of whether we trigger event to notify choreographer of config changes.
42 enum class ConfigEvent { None, Changed };
43
44 // logical or operator with the semantics of at least one of the events is Changed
45 friend ConfigEvent operator|(const ConfigEvent& first, const ConfigEvent& second) {
46 if (first == ConfigEvent::Changed) return ConfigEvent::Changed;
47 if (second == ConfigEvent::Changed) return ConfigEvent::Changed;
48 return ConfigEvent::None;
49 }
50
51 using RefreshRateType = scheduler::RefreshRateConfigs::RefreshRateType;
52 using ChangeRefreshRateCallback = std::function<void(RefreshRateType, ConfigEvent)>;
Ana Krulecc2870422019-01-29 19:00:58 -080053 using GetVsyncPeriod = std::function<nsecs_t()>;
Ana Krulec7d1d6832018-12-27 11:10:09 -080054
Ana Krulec7ecce8c2018-10-12 13:44:41 -070055 // Enum to indicate whether to start the transaction early, or at vsync time.
56 enum class TransactionStart { EARLY, NORMAL };
57
Ana Krulec98b5b242018-08-10 15:03:23 -070058 /* The scheduler handle is a BBinder object passed to the client from which we can extract
59 * an ID for subsequent operations.
60 */
61 class ConnectionHandle : public BBinder {
62 public:
63 ConnectionHandle(int64_t id) : id(id) {}
Ana Krulece588e312018-09-18 12:32:24 -070064
Ana Krulec98b5b242018-08-10 15:03:23 -070065 ~ConnectionHandle() = default;
Ana Krulece588e312018-09-18 12:32:24 -070066
Ana Krulec98b5b242018-08-10 15:03:23 -070067 const int64_t id;
68 };
69
70 class Connection {
71 public:
Ana Krulec85c39af2018-12-26 17:29:57 -080072 Connection(sp<ConnectionHandle> handle, sp<EventThreadConnection> eventConnection,
Ana Krulec98b5b242018-08-10 15:03:23 -070073 std::unique_ptr<EventThread> eventThread)
74 : handle(handle), eventConnection(eventConnection), thread(std::move(eventThread)) {}
Ana Krulece588e312018-09-18 12:32:24 -070075
Ana Krulec98b5b242018-08-10 15:03:23 -070076 ~Connection() = default;
77
78 sp<ConnectionHandle> handle;
Ana Krulec85c39af2018-12-26 17:29:57 -080079 sp<EventThreadConnection> eventConnection;
Ana Krulec98b5b242018-08-10 15:03:23 -070080 const std::unique_ptr<EventThread> thread;
81 };
82
Ana Krulecc2870422019-01-29 19:00:58 -080083 // Stores per-display state about VSYNC.
84 struct VsyncState {
85 explicit VsyncState(Scheduler& scheduler) : scheduler(scheduler) {}
86
87 void resync(const GetVsyncPeriod&);
88
89 Scheduler& scheduler;
90 std::atomic<nsecs_t> lastResyncTime = 0;
91 };
92
Ady Abraham09bd3922019-04-08 10:44:56 -070093 explicit Scheduler(impl::EventControlThread::SetVSyncEnabledFunction function,
94 const scheduler::RefreshRateConfigs& refreshRateConfig);
Ana Krulece588e312018-09-18 12:32:24 -070095
Ana Krulec0c8cd522018-08-31 12:27:28 -070096 virtual ~Scheduler();
Ana Krulec98b5b242018-08-10 15:03:23 -070097
98 /** Creates an EventThread connection. */
Dominik Laskowskiccf37d72019-02-01 16:47:58 -080099 sp<ConnectionHandle> createConnection(const char* connectionName, int64_t phaseOffsetNs,
Ady Abrahama1a49af2019-02-07 14:36:55 -0800100 ResyncCallback,
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800101 impl::EventThread::InterceptVSyncsCallback);
Ana Krulece588e312018-09-18 12:32:24 -0700102
Ady Abraham0f4a1b12019-06-04 16:04:04 -0700103 sp<IDisplayEventConnection> createDisplayEventConnection(
104 const sp<ConnectionHandle>& handle, ResyncCallback,
105 ISurfaceComposer::ConfigChanged configChanged);
Ana Krulec98b5b242018-08-10 15:03:23 -0700106
107 // Getter methods.
108 EventThread* getEventThread(const sp<ConnectionHandle>& handle);
Ana Krulece588e312018-09-18 12:32:24 -0700109
Kevin DuBois413287f2019-02-25 08:46:47 -0800110 // Provides access to the DispSync object for the primary display.
111 void withPrimaryDispSync(std::function<void(DispSync&)> const& fn);
112
Ana Krulec85c39af2018-12-26 17:29:57 -0800113 sp<EventThreadConnection> getEventConnection(const sp<ConnectionHandle>& handle);
Ana Krulec98b5b242018-08-10 15:03:23 -0700114
115 // Should be called when receiving a hotplug event.
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800116 void hotplugReceived(const sp<ConnectionHandle>& handle, PhysicalDisplayId displayId,
Ana Krulec98b5b242018-08-10 15:03:23 -0700117 bool connected);
Ana Krulece588e312018-09-18 12:32:24 -0700118
Ana Krulec98b5b242018-08-10 15:03:23 -0700119 // Should be called after the screen is turned on.
120 void onScreenAcquired(const sp<ConnectionHandle>& handle);
Ana Krulece588e312018-09-18 12:32:24 -0700121
Ana Krulec98b5b242018-08-10 15:03:23 -0700122 // Should be called before the screen is turned off.
123 void onScreenReleased(const sp<ConnectionHandle>& handle);
Ana Krulece588e312018-09-18 12:32:24 -0700124
Ady Abraham447052e2019-02-13 16:07:27 -0800125 // Should be called when display config changed
126 void onConfigChanged(const sp<ConnectionHandle>& handle, PhysicalDisplayId displayId,
127 int32_t configId);
128
Ana Krulec98b5b242018-08-10 15:03:23 -0700129 // Should be called when dumpsys command is received.
Yiwei Zhang5434a782018-12-05 18:06:32 -0800130 void dump(const sp<ConnectionHandle>& handle, std::string& result) const;
Ana Krulece588e312018-09-18 12:32:24 -0700131
Ana Krulec98b5b242018-08-10 15:03:23 -0700132 // Offers ability to modify phase offset in the event thread.
133 void setPhaseOffset(const sp<ConnectionHandle>& handle, nsecs_t phaseOffset);
134
Ana Krulece588e312018-09-18 12:32:24 -0700135 void getDisplayStatInfo(DisplayStatInfo* stats);
136
137 void enableHardwareVsync();
138 void disableHardwareVsync(bool makeUnavailable);
Alec Mourif8e689c2019-05-20 18:32:22 -0700139 // Resyncs the scheduler to hardware vsync.
140 // If makeAvailable is true, then hardware vsync will be turned on.
141 // Otherwise, if hardware vsync is not already enabled then this method will
142 // no-op.
143 // The period is the vsync period from the current display configuration.
Ana Krulecc2870422019-01-29 19:00:58 -0800144 void resyncToHardwareVsync(bool makeAvailable, nsecs_t period);
145 // Creates a callback for resyncing.
146 ResyncCallback makeResyncCallback(GetVsyncPeriod&& getVsyncPeriod);
147 void setRefreshSkipCount(int count);
Alec Mourif8e689c2019-05-20 18:32:22 -0700148 // Passes a vsync sample to DispSync. periodFlushed will be true if
149 // DispSync detected that the vsync period changed, and false otherwise.
150 void addResyncSample(const nsecs_t timestamp, bool* periodFlushed);
Ana Krulece588e312018-09-18 12:32:24 -0700151 void addPresentFence(const std::shared_ptr<FenceTime>& fenceTime);
152 void setIgnorePresentFences(bool ignore);
Ady Abrahamc3e21312019-02-07 14:30:23 -0800153 nsecs_t expectedPresentTime();
Ady Abraham09bd3922019-04-08 10:44:56 -0700154 // Registers the layer in the scheduler, and returns the handle for future references.
Ady Abraham8f1ee7f2019-04-05 10:32:50 -0700155 std::unique_ptr<scheduler::LayerHistory::LayerHandle> registerLayer(std::string const& name,
156 int windowType);
157
Ady Abraham09bd3922019-04-08 10:44:56 -0700158 // Stores present time for a layer.
Ady Abrahama315ce72019-04-24 14:35:20 -0700159 void addLayerPresentTimeAndHDR(
Ady Abraham09bd3922019-04-08 10:44:56 -0700160 const std::unique_ptr<scheduler::LayerHistory::LayerHandle>& layerHandle,
Ady Abrahama315ce72019-04-24 14:35:20 -0700161 nsecs_t presentTime, bool isHDR);
162 // Stores visibility for a layer.
163 void setLayerVisibility(
164 const std::unique_ptr<scheduler::LayerHistory::LayerHandle>& layerHandle, bool visible);
Ady Abraham09bd3922019-04-08 10:44:56 -0700165 // Updates FPS based on the most content presented.
166 void updateFpsBasedOnContent();
Ana Krulec8d3e4f32019-03-05 10:40:33 -0800167 // Callback that gets invoked when Scheduler wants to change the refresh rate.
168 void setChangeRefreshRateCallback(const ChangeRefreshRateCallback& changeRefreshRateCallback);
Alec Mouridc28b372019-04-18 21:17:13 -0700169 void setGetVsyncPeriodCallback(const GetVsyncPeriod&& getVsyncPeriod);
Ady Abraham97d04232019-03-05 19:48:12 -0800170
171 // Returns whether idle timer is enabled or not
172 bool isIdleTimerEnabled() { return mSetIdleTimerMs > 0; }
Ady Abraham09bd3922019-04-08 10:44:56 -0700173
Ady Abraham8532d012019-05-08 14:50:56 -0700174 // Function that resets the idle timer.
175 void resetIdleTimer();
176
177 // Function that resets the touch timer.
178 void notifyTouchEvent();
179
Ana Krulecb43429d2019-01-09 14:28:51 -0800180 // Returns relevant information about Scheduler for dumpsys purposes.
181 std::string doDump();
Ana Krulece588e312018-09-18 12:32:24 -0700182
Ady Abraham3aff9172019-02-07 19:10:26 -0800183 // calls DispSync::dump() on primary disp sync
184 void dumpPrimaryDispSync(std::string& result) const;
185
Ana Krulec0c8cd522018-08-31 12:27:28 -0700186protected:
187 virtual std::unique_ptr<EventThread> makeEventThread(
Dominik Laskowskibd52c842019-01-28 18:11:23 -0800188 const char* connectionName, DispSync* dispSync, int64_t phaseOffsetNs,
Ana Krulec0c8cd522018-08-31 12:27:28 -0700189 impl::EventThread::InterceptVSyncsCallback interceptCallback);
190
Ana Krulec98b5b242018-08-10 15:03:23 -0700191private:
Ana Krulecafb45842019-02-13 13:33:03 -0800192 friend class TestableScheduler;
193
Ana Krulecfefd6ae2019-02-13 17:53:08 -0800194 // In order to make sure that the features don't override themselves, we need a state machine
195 // to keep track which feature requested the config change.
Ady Abraham09bd3922019-04-08 10:44:56 -0700196 enum class ContentFeatureState { CONTENT_DETECTION_ON, CONTENT_DETECTION_OFF };
Ana Krulecfefd6ae2019-02-13 17:53:08 -0800197 enum class IdleTimerState { EXPIRED, RESET };
Ady Abraham8532d012019-05-08 14:50:56 -0700198 enum class TouchState { INACTIVE, ACTIVE };
Ana Krulecfefd6ae2019-02-13 17:53:08 -0800199
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800200 // Creates a connection on the given EventThread and forwards the given callbacks.
Ady Abraham0f4a1b12019-06-04 16:04:04 -0700201 sp<EventThreadConnection> createConnectionInternal(EventThread*, ResyncCallback&&,
202 ISurfaceComposer::ConfigChanged);
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800203
Ana Krulec7ab56032018-11-02 20:51:06 +0100204 nsecs_t calculateAverage() const;
205 void updateFrameSkipping(const int64_t skipCount);
Ady Abraham8532d012019-05-08 14:50:56 -0700206
Ady Abrahama1a49af2019-02-07 14:36:55 -0800207 // Function that is called when the timer resets.
208 void resetTimerCallback();
Ana Krulecfb772822018-11-30 10:44:07 +0100209 // Function that is called when the timer expires.
210 void expiredTimerCallback();
Alec Mouridc28b372019-04-18 21:17:13 -0700211 // Function that is called when the timer resets when paired with a display
212 // driver timeout in the kernel. This enables hardware vsync when we move
213 // out from idle.
214 void resetKernelTimerCallback();
215 // Function that is called when the timer expires when paired with a display
216 // driver timeout in the kernel. This disables hardware vsync when we move
217 // into idle.
218 void expiredKernelTimerCallback();
Ady Abraham8532d012019-05-08 14:50:56 -0700219 // Function that is called when the touch timer resets.
220 void resetTouchTimerCallback();
221 // Function that is called when the touch timer expires.
222 void expiredTouchTimerCallback();
Ana Krulecc2870422019-01-29 19:00:58 -0800223 // Sets vsync period.
224 void setVsyncPeriod(const nsecs_t period);
Ana Krulecfefd6ae2019-02-13 17:53:08 -0800225 // Idle timer feature's function to change the refresh rate.
226 void timerChangeRefreshRate(IdleTimerState idleTimerState);
Ady Abraham8532d012019-05-08 14:50:56 -0700227 // Touch timer feature's function to change the refresh rate.
228 void touchChangeRefreshRate(TouchState touchState);
Ady Abraham09bd3922019-04-08 10:44:56 -0700229 // Calculate the new refresh rate type
230 RefreshRateType calculateRefreshRateType() REQUIRES(mFeatureStateLock);
Ana Krulecfefd6ae2019-02-13 17:53:08 -0800231 // Acquires a lock and calls the ChangeRefreshRateCallback() with given parameters.
232 void changeRefreshRate(RefreshRateType refreshRateType, ConfigEvent configEvent);
Ana Krulec7ab56032018-11-02 20:51:06 +0100233
Ady Abraham09bd3922019-04-08 10:44:56 -0700234 // Helper function to calculate error frames
235 float getErrorFrames(float contentFps, float configFps);
236
Ana Krulece588e312018-09-18 12:32:24 -0700237 // If fences from sync Framework are supported.
238 const bool mHasSyncFramework;
239
240 // The offset in nanoseconds to use, when DispSync timestamps present fence
241 // signaling time.
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900242 nsecs_t mDispSyncPresentTimeOffset;
Ana Krulece588e312018-09-18 12:32:24 -0700243
244 // Each connection has it's own ID. This variable keeps track of the count.
Ana Krulec98b5b242018-08-10 15:03:23 -0700245 static std::atomic<int64_t> sNextId;
Ana Krulece588e312018-09-18 12:32:24 -0700246
247 // Connections are stored in a map <connection ID, connection> for easy retrieval.
Ana Krulec98b5b242018-08-10 15:03:23 -0700248 std::unordered_map<int64_t, std::unique_ptr<Connection>> mConnections;
Ana Krulece588e312018-09-18 12:32:24 -0700249
250 std::mutex mHWVsyncLock;
251 bool mPrimaryHWVsyncEnabled GUARDED_BY(mHWVsyncLock);
252 bool mHWVsyncAvailable GUARDED_BY(mHWVsyncLock);
Ana Krulecc2870422019-01-29 19:00:58 -0800253 const std::shared_ptr<VsyncState> mPrimaryVsyncState{std::make_shared<VsyncState>(*this)};
Ana Krulece588e312018-09-18 12:32:24 -0700254
255 std::unique_ptr<DispSync> mPrimaryDispSync;
256 std::unique_ptr<EventControlThread> mEventControlThread;
Ana Krulec7ab56032018-11-02 20:51:06 +0100257
258 // TODO(b/113612090): The following set of variables needs to be revised. For now, this is
259 // a proof of concept. We turn on frame skipping if the difference between the timestamps
260 // is between 32 and 34ms. We expect this currently for 30fps videos, so we render them at 30Hz.
261 nsecs_t mPreviousFrameTimestamp = 0;
262 // Keeping track of whether we are skipping the refresh count. If we want to
263 // simulate 30Hz rendering, we skip every other frame, and this variable is set
264 // to 1.
265 int64_t mSkipCount = 0;
Ana Krulec434c22d2018-11-28 13:48:36 +0100266 std::array<int64_t, scheduler::ARRAY_SIZE> mTimeDifferences{};
Ana Krulec7ab56032018-11-02 20:51:06 +0100267 size_t mCounter = 0;
Ana Krulec3084c052018-11-21 20:27:17 +0100268
Ady Abraham09bd3922019-04-08 10:44:56 -0700269 // Historical information about individual layers. Used for predicting the refresh rate.
270 scheduler::LayerHistory mLayerHistory;
Ana Krulecfb772822018-11-30 10:44:07 +0100271
272 // Timer that records time between requests for next vsync. If the time is higher than a given
273 // interval, a callback is fired. Set this variable to >0 to use this feature.
274 int64_t mSetIdleTimerMs = 0;
275 std::unique_ptr<scheduler::IdleTimer> mIdleTimer;
Alec Mouridc28b372019-04-18 21:17:13 -0700276 // Enables whether to use idle timer callbacks that support the kernel
277 // timer.
278 bool mSupportKernelTimer;
Ana Krulec7d1d6832018-12-27 11:10:09 -0800279
Ady Abraham8532d012019-05-08 14:50:56 -0700280 // Timer used to monitor touch events.
281 int64_t mSetTouchTimerMs = 0;
282 std::unique_ptr<scheduler::IdleTimer> mTouchTimer;
283
Ana Krulec7d1d6832018-12-27 11:10:09 -0800284 std::mutex mCallbackLock;
Ana Krulec8d3e4f32019-03-05 10:40:33 -0800285 ChangeRefreshRateCallback mChangeRefreshRateCallback GUARDED_BY(mCallbackLock);
Alec Mouridc28b372019-04-18 21:17:13 -0700286 GetVsyncPeriod mGetVsyncPeriod GUARDED_BY(mCallbackLock);
Ana Krulecfefd6ae2019-02-13 17:53:08 -0800287
288 // In order to make sure that the features don't override themselves, we need a state machine
289 // to keep track which feature requested the config change.
290 std::mutex mFeatureStateLock;
Ady Abraham09bd3922019-04-08 10:44:56 -0700291 ContentFeatureState mCurrentContentFeatureState GUARDED_BY(mFeatureStateLock) =
292 ContentFeatureState::CONTENT_DETECTION_OFF;
Ana Krulecfefd6ae2019-02-13 17:53:08 -0800293 IdleTimerState mCurrentIdleTimerState GUARDED_BY(mFeatureStateLock) = IdleTimerState::RESET;
Ady Abraham8532d012019-05-08 14:50:56 -0700294 TouchState mCurrentTouchState GUARDED_BY(mFeatureStateLock) = TouchState::INACTIVE;
Ady Abraham6398a0a2019-04-18 19:30:44 -0700295 uint32_t mContentRefreshRate GUARDED_BY(mFeatureStateLock);
296 RefreshRateType mRefreshRateType GUARDED_BY(mFeatureStateLock);
Ady Abrahama315ce72019-04-24 14:35:20 -0700297 bool mIsHDRContent GUARDED_BY(mFeatureStateLock) = false;
Ady Abraham09bd3922019-04-08 10:44:56 -0700298
299 const scheduler::RefreshRateConfigs& mRefreshRateConfigs;
Ady Abrahama315ce72019-04-24 14:35:20 -0700300
301 // Global config to force HDR content to work on DEFAULT refreshRate
302 static constexpr bool mForceHDRContentToDefaultRefreshRate = true;
Ana Krulec98b5b242018-08-10 15:03:23 -0700303};
304
Ana Krulec7ab56032018-11-02 20:51:06 +0100305} // namespace android