• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2015 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 #ifndef ANDROID_SF_HWC2_H
18 #define ANDROID_SF_HWC2_H
19 
20 #define HWC2_INCLUDE_STRINGIFICATION
21 #define HWC2_USE_CPP11
22 #include <hardware/hwcomposer2.h>
23 #undef HWC2_INCLUDE_STRINGIFICATION
24 #undef HWC2_USE_CPP11
25 
26 #include <ui/HdrCapabilities.h>
27 #include <ui/mat4.h>
28 
29 #include <utils/Log.h>
30 #include <utils/StrongPointer.h>
31 #include <utils/Timers.h>
32 
33 #include <functional>
34 #include <string>
35 #include <unordered_map>
36 #include <vector>
37 
38 namespace android {
39     class Fence;
40     class FloatRect;
41     class GraphicBuffer;
42     class Rect;
43     class Region;
44 }
45 
46 namespace HWC2 {
47 
48 class Display;
49 class Layer;
50 
51 typedef std::function<void(std::shared_ptr<Display>, Connection)>
52         HotplugCallback;
53 typedef std::function<void(std::shared_ptr<Display>)> RefreshCallback;
54 typedef std::function<void(std::shared_ptr<Display>, nsecs_t)> VsyncCallback;
55 
56 class Device
57 {
58 public:
59     Device(hwc2_device_t* device);
60     ~Device();
61 
62     friend class HWC2::Display;
63     friend class HWC2::Layer;
64 
65     // Required by HWC2
66 
67     std::string dump() const;
68 
getCapabilities()69     const std::vector<Capability>& getCapabilities() const {
70         return mCapabilities;
71     };
72 
73     uint32_t getMaxVirtualDisplayCount() const;
74     Error createVirtualDisplay(uint32_t width, uint32_t height,
75             android_pixel_format_t* format,
76             std::shared_ptr<Display>* outDisplay);
77 
78     void registerHotplugCallback(HotplugCallback hotplug);
79     void registerRefreshCallback(RefreshCallback refresh);
80     void registerVsyncCallback(VsyncCallback vsync);
81 
82     // For use by callbacks
83 
84     void callHotplug(std::shared_ptr<Display> display, Connection connected);
85     void callRefresh(std::shared_ptr<Display> display);
86     void callVsync(std::shared_ptr<Display> display, nsecs_t timestamp);
87 
88     // Other Device methods
89 
90     // This will create a Display if one is not found, but it will not be marked
91     // as connected
92     std::shared_ptr<Display> getDisplayById(hwc2_display_t id);
93 
94     bool hasCapability(HWC2::Capability capability) const;
95 
96 private:
97     // Initialization methods
98 
99     template <typename PFN>
loadFunctionPointer(FunctionDescriptor desc,PFN & outPFN)100     [[clang::warn_unused_result]] bool loadFunctionPointer(
101             FunctionDescriptor desc, PFN& outPFN) {
102         auto intDesc = static_cast<int32_t>(desc);
103         auto pfn = mHwcDevice->getFunction(mHwcDevice, intDesc);
104         if (pfn != nullptr) {
105             outPFN = reinterpret_cast<PFN>(pfn);
106             return true;
107         } else {
108             ALOGE("Failed to load function %s", to_string(desc).c_str());
109             return false;
110         }
111     }
112 
113     template <typename PFN, typename HOOK>
registerCallback(Callback callback,HOOK hook)114     void registerCallback(Callback callback, HOOK hook) {
115         static_assert(std::is_same<PFN, HOOK>::value,
116                 "Incompatible function pointer");
117         auto intCallback = static_cast<int32_t>(callback);
118         auto callbackData = static_cast<hwc2_callback_data_t>(this);
119         auto pfn = reinterpret_cast<hwc2_function_pointer_t>(hook);
120         mRegisterCallback(mHwcDevice, intCallback, callbackData, pfn);
121     }
122 
123     void loadCapabilities();
124     void loadFunctionPointers();
125     void registerCallbacks();
126 
127     // For use by Display
128 
129     void destroyVirtualDisplay(hwc2_display_t display);
130 
131     // Member variables
132 
133     hwc2_device_t* mHwcDevice;
134 
135     // Device function pointers
136     HWC2_PFN_CREATE_VIRTUAL_DISPLAY mCreateVirtualDisplay;
137     HWC2_PFN_DESTROY_VIRTUAL_DISPLAY mDestroyVirtualDisplay;
138     HWC2_PFN_DUMP mDump;
139     HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT mGetMaxVirtualDisplayCount;
140     HWC2_PFN_REGISTER_CALLBACK mRegisterCallback;
141 
142     // Display function pointers
143     HWC2_PFN_ACCEPT_DISPLAY_CHANGES mAcceptDisplayChanges;
144     HWC2_PFN_CREATE_LAYER mCreateLayer;
145     HWC2_PFN_DESTROY_LAYER mDestroyLayer;
146     HWC2_PFN_GET_ACTIVE_CONFIG mGetActiveConfig;
147     HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES mGetChangedCompositionTypes;
148     HWC2_PFN_GET_COLOR_MODES mGetColorModes;
149     HWC2_PFN_GET_DISPLAY_ATTRIBUTE mGetDisplayAttribute;
150     HWC2_PFN_GET_DISPLAY_CONFIGS mGetDisplayConfigs;
151     HWC2_PFN_GET_DISPLAY_NAME mGetDisplayName;
152     HWC2_PFN_GET_DISPLAY_REQUESTS mGetDisplayRequests;
153     HWC2_PFN_GET_DISPLAY_TYPE mGetDisplayType;
154     HWC2_PFN_GET_DOZE_SUPPORT mGetDozeSupport;
155     HWC2_PFN_GET_HDR_CAPABILITIES mGetHdrCapabilities;
156     HWC2_PFN_GET_RELEASE_FENCES mGetReleaseFences;
157     HWC2_PFN_PRESENT_DISPLAY mPresentDisplay;
158     HWC2_PFN_SET_ACTIVE_CONFIG mSetActiveConfig;
159     HWC2_PFN_SET_CLIENT_TARGET mSetClientTarget;
160     HWC2_PFN_SET_COLOR_MODE mSetColorMode;
161     HWC2_PFN_SET_COLOR_TRANSFORM mSetColorTransform;
162     HWC2_PFN_SET_OUTPUT_BUFFER mSetOutputBuffer;
163     HWC2_PFN_SET_POWER_MODE mSetPowerMode;
164     HWC2_PFN_SET_VSYNC_ENABLED mSetVsyncEnabled;
165     HWC2_PFN_VALIDATE_DISPLAY mValidateDisplay;
166 
167     // Layer function pointers
168     HWC2_PFN_SET_CURSOR_POSITION mSetCursorPosition;
169     HWC2_PFN_SET_LAYER_BUFFER mSetLayerBuffer;
170     HWC2_PFN_SET_LAYER_SURFACE_DAMAGE mSetLayerSurfaceDamage;
171     HWC2_PFN_SET_LAYER_BLEND_MODE mSetLayerBlendMode;
172     HWC2_PFN_SET_LAYER_COLOR mSetLayerColor;
173     HWC2_PFN_SET_LAYER_COMPOSITION_TYPE mSetLayerCompositionType;
174     HWC2_PFN_SET_LAYER_DATASPACE mSetLayerDataspace;
175     HWC2_PFN_SET_LAYER_DISPLAY_FRAME mSetLayerDisplayFrame;
176     HWC2_PFN_SET_LAYER_PLANE_ALPHA mSetLayerPlaneAlpha;
177     HWC2_PFN_SET_LAYER_SIDEBAND_STREAM mSetLayerSidebandStream;
178     HWC2_PFN_SET_LAYER_SOURCE_CROP mSetLayerSourceCrop;
179     HWC2_PFN_SET_LAYER_TRANSFORM mSetLayerTransform;
180     HWC2_PFN_SET_LAYER_VISIBLE_REGION mSetLayerVisibleRegion;
181     HWC2_PFN_SET_LAYER_Z_ORDER mSetLayerZOrder;
182 
183     std::vector<Capability> mCapabilities;
184     std::unordered_map<hwc2_display_t, std::shared_ptr<Display>> mDisplays;
185 
186     HotplugCallback mHotplug;
187     std::vector<std::pair<std::shared_ptr<Display>, Connection>>
188             mPendingHotplugs;
189     RefreshCallback mRefresh;
190     std::vector<std::shared_ptr<Display>> mPendingRefreshes;
191     VsyncCallback mVsync;
192     std::vector<std::pair<std::shared_ptr<Display>, nsecs_t>> mPendingVsyncs;
193 };
194 
195 class Display : public std::enable_shared_from_this<Display>
196 {
197 public:
198     Display(Device& device, hwc2_display_t id);
199     ~Display();
200 
201     friend class HWC2::Device;
202     friend class HWC2::Layer;
203 
204     class Config
205     {
206     public:
207         class Builder
208         {
209         public:
210             Builder(Display& display, hwc2_config_t id);
211 
build()212             std::shared_ptr<const Config> build() {
213                 return std::const_pointer_cast<const Config>(
214                         std::move(mConfig));
215             }
216 
setWidth(int32_t width)217             Builder& setWidth(int32_t width) {
218                 mConfig->mWidth = width;
219                 return *this;
220             }
setHeight(int32_t height)221             Builder& setHeight(int32_t height) {
222                 mConfig->mHeight = height;
223                 return *this;
224             }
setVsyncPeriod(int32_t vsyncPeriod)225             Builder& setVsyncPeriod(int32_t vsyncPeriod) {
226                 mConfig->mVsyncPeriod = vsyncPeriod;
227                 return *this;
228             }
setDpiX(int32_t dpiX)229             Builder& setDpiX(int32_t dpiX) {
230                 if (dpiX == -1) {
231                     mConfig->mDpiX = getDefaultDensity();
232                 } else {
233                     mConfig->mDpiX = dpiX / 1000.0f;
234                 }
235                 return *this;
236             }
setDpiY(int32_t dpiY)237             Builder& setDpiY(int32_t dpiY) {
238                 if (dpiY == -1) {
239                     mConfig->mDpiY = getDefaultDensity();
240                 } else {
241                     mConfig->mDpiY = dpiY / 1000.0f;
242                 }
243                 return *this;
244             }
245 
246         private:
247             float getDefaultDensity();
248             std::shared_ptr<Config> mConfig;
249         };
250 
getDisplayId()251         hwc2_display_t getDisplayId() const { return mDisplay.getId(); }
getId()252         hwc2_config_t getId() const { return mId; }
253 
getWidth()254         int32_t getWidth() const { return mWidth; }
getHeight()255         int32_t getHeight() const { return mHeight; }
getVsyncPeriod()256         nsecs_t getVsyncPeriod() const { return mVsyncPeriod; }
getDpiX()257         float getDpiX() const { return mDpiX; }
getDpiY()258         float getDpiY() const { return mDpiY; }
259 
260     private:
261         Config(Display& display, hwc2_config_t id);
262 
263         Display& mDisplay;
264         hwc2_config_t mId;
265 
266         int32_t mWidth;
267         int32_t mHeight;
268         nsecs_t mVsyncPeriod;
269         float mDpiX;
270         float mDpiY;
271     };
272 
273     // Required by HWC2
274 
275     [[clang::warn_unused_result]] Error acceptChanges();
276     [[clang::warn_unused_result]] Error createLayer(
277             std::shared_ptr<Layer>* outLayer);
278     [[clang::warn_unused_result]] Error getActiveConfig(
279             std::shared_ptr<const Config>* outConfig) const;
280     [[clang::warn_unused_result]] Error getChangedCompositionTypes(
281             std::unordered_map<std::shared_ptr<Layer>, Composition>* outTypes);
282     [[clang::warn_unused_result]] Error getColorModes(
283             std::vector<int32_t>* outModes) const;
284 
285     // Doesn't call into the HWC2 device, so no errors are possible
286     std::vector<std::shared_ptr<const Config>> getConfigs() const;
287 
288     [[clang::warn_unused_result]] Error getName(std::string* outName) const;
289     [[clang::warn_unused_result]] Error getRequests(
290             DisplayRequest* outDisplayRequests,
291             std::unordered_map<std::shared_ptr<Layer>, LayerRequest>*
292                     outLayerRequests);
293     [[clang::warn_unused_result]] Error getType(DisplayType* outType) const;
294     [[clang::warn_unused_result]] Error supportsDoze(bool* outSupport) const;
295     [[clang::warn_unused_result]] Error getHdrCapabilities(
296             std::unique_ptr<android::HdrCapabilities>* outCapabilities) const;
297     [[clang::warn_unused_result]] Error getReleaseFences(
298             std::unordered_map<std::shared_ptr<Layer>,
299                     android::sp<android::Fence>>* outFences) const;
300     [[clang::warn_unused_result]] Error present(
301             android::sp<android::Fence>* outRetireFence);
302     [[clang::warn_unused_result]] Error setActiveConfig(
303             const std::shared_ptr<const Config>& config);
304     [[clang::warn_unused_result]] Error setClientTarget(
305             buffer_handle_t target,
306             const android::sp<android::Fence>& acquireFence,
307             android_dataspace_t dataspace);
308     [[clang::warn_unused_result]] Error setColorMode(int32_t mode);
309     [[clang::warn_unused_result]] Error setColorTransform(
310             const android::mat4& matrix, android_color_transform_t hint);
311     [[clang::warn_unused_result]] Error setOutputBuffer(
312             const android::sp<android::GraphicBuffer>& buffer,
313             const android::sp<android::Fence>& releaseFence);
314     [[clang::warn_unused_result]] Error setPowerMode(PowerMode mode);
315     [[clang::warn_unused_result]] Error setVsyncEnabled(Vsync enabled);
316     [[clang::warn_unused_result]] Error validate(uint32_t* outNumTypes,
317             uint32_t* outNumRequests);
318 
319     // Other Display methods
320 
getDevice()321     Device& getDevice() const { return mDevice; }
getId()322     hwc2_display_t getId() const { return mId; }
isConnected()323     bool isConnected() const { return mIsConnected; }
324 
325 private:
326     // For use by Device
327 
328     // Virtual displays are always connected
setVirtual()329     void setVirtual() {
330         mIsVirtual = true;
331         mIsConnected = true;
332     }
333 
setConnected(bool connected)334     void setConnected(bool connected) { mIsConnected = connected; }
335     int32_t getAttribute(hwc2_config_t configId, Attribute attribute);
336     void loadConfig(hwc2_config_t configId);
337     void loadConfigs();
338 
339     // For use by Layer
340     void destroyLayer(hwc2_layer_t layerId);
341 
342     // This may fail (and return a null pointer) if no layer with this ID exists
343     // on this display
344     std::shared_ptr<Layer> getLayerById(hwc2_layer_t id) const;
345 
346     // Member variables
347 
348     Device& mDevice;
349     hwc2_display_t mId;
350     bool mIsConnected;
351     bool mIsVirtual;
352     std::unordered_map<hwc2_layer_t, std::weak_ptr<Layer>> mLayers;
353     std::unordered_map<hwc2_config_t, std::shared_ptr<const Config>> mConfigs;
354 };
355 
356 class Layer
357 {
358 public:
359     Layer(const std::shared_ptr<Display>& display, hwc2_layer_t id);
360     ~Layer();
361 
isAbandoned()362     bool isAbandoned() const { return mDisplay.expired(); }
getId()363     hwc2_layer_t getId() const { return mId; }
364 
365     [[clang::warn_unused_result]] Error setCursorPosition(int32_t x, int32_t y);
366     [[clang::warn_unused_result]] Error setBuffer(buffer_handle_t buffer,
367             const android::sp<android::Fence>& acquireFence);
368     [[clang::warn_unused_result]] Error setSurfaceDamage(
369             const android::Region& damage);
370 
371     [[clang::warn_unused_result]] Error setBlendMode(BlendMode mode);
372     [[clang::warn_unused_result]] Error setColor(hwc_color_t color);
373     [[clang::warn_unused_result]] Error setCompositionType(Composition type);
374     [[clang::warn_unused_result]] Error setDataspace(
375             android_dataspace_t dataspace);
376     [[clang::warn_unused_result]] Error setDisplayFrame(
377             const android::Rect& frame);
378     [[clang::warn_unused_result]] Error setPlaneAlpha(float alpha);
379     [[clang::warn_unused_result]] Error setSidebandStream(
380             const native_handle_t* stream);
381     [[clang::warn_unused_result]] Error setSourceCrop(
382             const android::FloatRect& crop);
383     [[clang::warn_unused_result]] Error setTransform(Transform transform);
384     [[clang::warn_unused_result]] Error setVisibleRegion(
385             const android::Region& region);
386     [[clang::warn_unused_result]] Error setZOrder(uint32_t z);
387 
388 private:
389     std::weak_ptr<Display> mDisplay;
390     hwc2_display_t mDisplayId;
391     Device& mDevice;
392     hwc2_layer_t mId;
393 };
394 
395 } // namespace HWC2
396 
397 #endif // ANDROID_SF_HWC2_H
398