1 /*
2  * Copyright (C) 2024 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 <functional>
20 #include <sstream>
21 #include <string>
22 
23 #include "../Utils.h"
24 #include "DisplayContextProvider.h"
25 
26 namespace android::hardware::graphics::composer {
27 
28 enum class VrrControllerEventType {
29     kGeneralEventMask = 0x10000000,
30     // kSystemRenderingTimeout is responsible for managing present timeout according to the
31     // configuration specified in the system HAL API.
32     kSystemRenderingTimeout = kGeneralEventMask + (1 << 0),
33     // kVendorRenderingTimeoutInit is responsible for initializing vendor's timeout
34     // configurations and kicking off subsequent handling
35     kVendorRenderingTimeoutInit = kGeneralEventMask + (1 << 1),
36     // kVendorRenderingTimeoutPost is responsible for handling the timeout event
37     // per config after initialization
38     kVendorRenderingTimeoutPost = kGeneralEventMask + (1 << 2),
39     kHibernateTimeout = kGeneralEventMask + (1 << 3),
40     kNotifyExpectedPresentConfig = kGeneralEventMask + (1 << 4),
41     kTestEvent = kGeneralEventMask + (1 << 5),
42     kUpdateDbiFrameRate = kGeneralEventMask + (1 << 6),
43     kGeneralEventMax = kGeneralEventMask + (1 << 27),
44     // General callback events.
45     kCallbackEventMask = 0x20000000,
46     kRefreshRateCalculatorUpdateMask = kCallbackEventMask,
47     kInstantRefreshRateCalculatorUpdate = kCallbackEventMask + (1 << 0),
48     kPeriodRefreshRateCalculatorUpdate = kCallbackEventMask + (1 << 1),
49     kVideoFrameRateCalculatorUpdate = kCallbackEventMask + (1 << 2),
50     kCombinedRefreshRateCalculatorUpdate = kCallbackEventMask + (1 << 3),
51     kAodRefreshRateCalculatorUpdate = kCallbackEventMask + (1 << 4),
52     kExitIdleRefreshRateCalculatorUpdate = kCallbackEventMask + (1 << 5),
53     kStaticticUpdate = kCallbackEventMask + (1 << 6),
54     kCallbackEventMax = kCallbackEventMask + (1 << 27),
55     // Minimum refresh rate control events.
56     kMinimumRefreshRateControlEventMask = 0x40000000,
57     kMinimumRefreshRateWaitForConfigTimeout = kMinimumRefreshRateControlEventMask + (1 << 0),
58     kMinimumRefreshRateAlignWithPresent = kMinimumRefreshRateControlEventMask + (1 << 1),
59     kMinLockTimeForPeakRefreshRate =
60             ((kMinimumRefreshRateControlEventMask + (1 << 2)) | kCallbackEventMask),
61     // Sensors, outer events...
62 };
63 
64 struct TimedEvent {
TimedEventTimedEvent65     explicit TimedEvent(const std::string& name) : mEventName(std::move(name)) {}
66 
TimedEventTimedEvent67     TimedEvent(const std::string& name, int64_t whenNs) : mEventName(name), mWhenNs(whenNs) {}
68 
TimedEventTimedEvent69     TimedEvent(std::string& name, int64_t whenNs) : mEventName(name), mWhenNs(whenNs) {}
70 
71     bool operator<(const TimedEvent& b) const { return mWhenNs > b.mWhenNs; }
72 
73     std::string mEventName;
74     std::function<int()> mFunctor;
75     bool mIsRelativeTime = true;
76     int64_t mWhenNs = 0;
77 };
78 
79 struct VrrControllerEvent {
80     bool operator<(const VrrControllerEvent& b) const { return mWhenNs > b.mWhenNs; }
getNameVrrControllerEvent81     std::string getName() const {
82         switch (mEventType) {
83             case VrrControllerEventType::kSystemRenderingTimeout:
84                 return "kSystemRenderingTimeout";
85             case VrrControllerEventType::kExitIdleRefreshRateCalculatorUpdate:
86                 return "kExitIdleRefreshRateCalculatorUpdate";
87             case VrrControllerEventType::kVendorRenderingTimeoutInit:
88                 return "kVendorRenderingTimeoutInit";
89             case VrrControllerEventType::kVendorRenderingTimeoutPost:
90                 return "kVendorRenderingTimeoutPost";
91             case VrrControllerEventType::kHibernateTimeout:
92                 return "kHibernateTimeout";
93             case VrrControllerEventType::kNotifyExpectedPresentConfig:
94                 return "kNotifyExpectedPresentConfig";
95             case VrrControllerEventType::kInstantRefreshRateCalculatorUpdate:
96                 return "kInstantRefreshRateCalculatorUpdate";
97             case VrrControllerEventType::kPeriodRefreshRateCalculatorUpdate:
98                 return "kPeriodRefreshRateCalculatorUpdate";
99             case VrrControllerEventType::kVideoFrameRateCalculatorUpdate:
100                 return "kVideoFrameRateCalculatorUpdate";
101             case VrrControllerEventType::kCombinedRefreshRateCalculatorUpdate:
102                 return "kCombinedRefreshRateCalculatorUpdate";
103             case VrrControllerEventType::kAodRefreshRateCalculatorUpdate:
104                 return "kAodRefreshRateCalculatorUpdate";
105             case VrrControllerEventType::kStaticticUpdate:
106                 return "kStaticticUpdate";
107             case VrrControllerEventType::kMinLockTimeForPeakRefreshRate:
108                 return "kMinLockTimeForPeakRefreshRate";
109             default:
110                 return "Unknown";
111         }
112     }
113 
toStringVrrControllerEvent114     std::string toString() const {
115         std::ostringstream os;
116         os << "Vrr event: [";
117         os << "type = " << getName() << ", ";
118         os << "when = " << mWhenNs << "ns]";
119         return os.str();
120     }
121     int64_t mDisplay;
122     VrrControllerEventType mEventType;
123     int64_t mWhenNs;
124     std::function<int()> mFunctor;
125     int64_t mPeriodNs = -1;
126 };
127 
128 class ExternalEventHandler {
129 public:
130     virtual ~ExternalEventHandler() = default;
131 
132     virtual std::vector<TimedEvent> getHandleEvents() = 0;
133 
134     virtual std::function<int()> getHandleFunction() = 0;
135 
136     virtual int64_t getPresentTimeoutNs() = 0;
137 };
138 
139 } // namespace android::hardware::graphics::composer
140 
141 typedef android::hardware::graphics::composer::ExternalEventHandler* (
142         *createExternalEventHandler_t)(void* interface, void* host, const char* panelName);
143 
144 typedef void (*destroyExternalEventHandler_t)(
145         android::hardware::graphics::composer::ExternalEventHandler* handler);
146