1 /*
2  * Copyright (C) 2007 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_DISPLAY_DEVICE_H
18 #define ANDROID_DISPLAY_DEVICE_H
19 
20 #include <stdlib.h>
21 
22 #include <memory>
23 #include <optional>
24 #include <string>
25 #include <unordered_map>
26 
27 #include <android/native_window.h>
28 #include <binder/IBinder.h>
29 #include <gui/LayerState.h>
30 #include <hardware/hwcomposer_defs.h>
31 #include <math/mat4.h>
32 #include <renderengine/RenderEngine.h>
33 #include <system/window.h>
34 #include <ui/GraphicTypes.h>
35 #include <ui/HdrCapabilities.h>
36 #include <ui/Region.h>
37 #include <ui/Transform.h>
38 #include <utils/Mutex.h>
39 #include <utils/RefBase.h>
40 #include <utils/Timers.h>
41 
42 #include "DisplayHardware/DisplayIdentification.h"
43 #include "RenderArea.h"
44 
45 namespace android {
46 
47 class Fence;
48 class HWComposer;
49 class IGraphicBufferProducer;
50 class Layer;
51 class SurfaceFlinger;
52 
53 struct CompositionInfo;
54 struct DisplayDeviceCreationArgs;
55 struct DisplayInfo;
56 
57 namespace compositionengine {
58 class Display;
59 class DisplaySurface;
60 } // namespace compositionengine
61 
62 class DisplayDevice : public LightRefBase<DisplayDevice> {
63 public:
64     constexpr static float sDefaultMinLumiance = 0.0;
65     constexpr static float sDefaultMaxLumiance = 500.0;
66 
67     enum {
68         NO_LAYER_STACK = 0xFFFFFFFF,
69     };
70 
71     explicit DisplayDevice(DisplayDeviceCreationArgs&& args);
72     virtual ~DisplayDevice();
73 
getCompositionDisplay()74     std::shared_ptr<compositionengine::Display> getCompositionDisplay() const {
75         return mCompositionDisplay;
76     }
77 
isVirtual()78     bool isVirtual() const { return mIsVirtual; }
isPrimary()79     bool isPrimary() const { return mIsPrimary; }
80 
81     // isSecure indicates whether this display can be trusted to display
82     // secure surfaces.
83     bool isSecure() const;
84 
85     int         getWidth() const;
86     int         getHeight() const;
getInstallOrientation()87     int         getInstallOrientation() const { return mDisplayInstallOrientation; }
88 
89     void                    setVisibleLayersSortedByZ(const Vector< sp<Layer> >& layers);
90     const Vector< sp<Layer> >& getVisibleLayersSortedByZ() const;
91     void                    setLayersNeedingFences(const Vector< sp<Layer> >& layers);
92     const Vector< sp<Layer> >& getLayersNeedingFences() const;
93 
94     void                    setLayerStack(uint32_t stack);
95     void                    setDisplaySize(const int newWidth, const int newHeight);
96     void                    setProjection(int orientation, const Rect& viewport, const Rect& frame);
97 
getOrientation()98     int                     getOrientation() const { return mOrientation; }
99     static uint32_t         getPrimaryDisplayOrientationTransform();
100     const ui::Transform& getTransform() const;
101     const Rect& getViewport() const;
102     const Rect& getFrame() const;
103     const Rect& getScissor() const;
104     bool needsFiltering() const;
105     uint32_t getLayerStack() const;
106 
107     const std::optional<DisplayId>& getId() const;
getDisplayToken()108     const wp<IBinder>& getDisplayToken() const { return mDisplayToken; }
getSequenceId()109     int32_t getSequenceId() const { return mSequenceId; }
110 
111     const Region& getUndefinedRegion() const;
112 
113     int32_t getSupportedPerFrameMetadata() const;
114 
115     bool hasWideColorGamut() const;
116     // Whether h/w composer has native support for specific HDR type.
117     bool hasHDR10PlusSupport() const;
118     bool hasHDR10Support() const;
119     bool hasHLGSupport() const;
120     bool hasDolbyVisionSupport() const;
121 
122     // The returned HdrCapabilities is the combination of HDR capabilities from
123     // hardware composer and RenderEngine. When the DisplayDevice supports wide
124     // color gamut, RenderEngine is able to simulate HDR support in Display P3
125     // color space for both PQ and HLG HDR contents. The minimum and maximum
126     // luminance will be set to sDefaultMinLumiance and sDefaultMaxLumiance
127     // respectively if hardware composer doesn't return meaningful values.
128     const HdrCapabilities& getHdrCapabilities() const;
129 
130     // Return true if intent is supported by the display.
131     bool hasRenderIntent(ui::RenderIntent intent) const;
132 
133     const Rect& getBounds() const;
bounds()134     const Rect& bounds() const { return getBounds(); }
135 
136     void setDisplayName(const std::string& displayName);
getDisplayName()137     const std::string& getDisplayName() const { return mDisplayName; }
138 
139     /* ------------------------------------------------------------------------
140      * Display power mode management.
141      */
142     int getPowerMode() const;
143     void setPowerMode(int mode);
144     bool isPoweredOn() const;
145 
146     ui::Dataspace getCompositionDataSpace() const;
147 
148     /* ------------------------------------------------------------------------
149      * Display active config management.
150      */
151     int getActiveConfig() const;
152     void setActiveConfig(int mode);
153 
154     // release HWC resources (if any) for removable displays
155     void disconnect();
156 
157     /* ------------------------------------------------------------------------
158      * Debugging
159      */
160     uint32_t getPageFlipCount() const;
161     std::string getDebugName() const;
162     void dump(std::string& result) const;
163 
164 private:
165     /*
166      *  Constants, set during initialization
167      */
168     const sp<SurfaceFlinger> mFlinger;
169     const wp<IBinder> mDisplayToken;
170     const int32_t mSequenceId;
171 
172     const int mDisplayInstallOrientation;
173     const std::shared_ptr<compositionengine::Display> mCompositionDisplay;
174 
175     std::string mDisplayName;
176     const bool mIsVirtual;
177 
178     /*
179      * Can only accessed from the main thread, these members
180      * don't need synchronization.
181      */
182 
183     // list of visible layers on that display
184     Vector< sp<Layer> > mVisibleLayersSortedByZ;
185     // list of layers needing fences
186     Vector< sp<Layer> > mLayersNeedingFences;
187 
188     /*
189      * Transaction state
190      */
191     static uint32_t displayStateOrientationToTransformOrientation(int orientation);
192     static status_t orientationToTransfrom(int orientation,
193                                            int w, int h, ui::Transform* tr);
194 
195     int mOrientation;
196     static uint32_t sPrimaryDisplayOrientation;
197 
198     // Current power mode
199     int mPowerMode;
200     // Current active config
201     int mActiveConfig;
202 
203     // TODO(b/74619554): Remove special cases for primary display.
204     const bool mIsPrimary;
205 };
206 
207 struct DisplayDeviceState {
isVirtualDisplayDeviceState208     bool isVirtual() const { return !displayId.has_value(); }
209 
210     int32_t sequenceId = sNextSequenceId++;
211     std::optional<DisplayId> displayId;
212     sp<IGraphicBufferProducer> surface;
213     uint32_t layerStack = DisplayDevice::NO_LAYER_STACK;
214     Rect viewport;
215     Rect frame;
216     uint8_t orientation = 0;
217     uint32_t width = 0;
218     uint32_t height = 0;
219     std::string displayName;
220     bool isSecure = false;
221 
222 private:
223     static std::atomic<int32_t> sNextSequenceId;
224 };
225 
226 struct DisplayDeviceCreationArgs {
227     // We use a constructor to ensure some of the values are set, without
228     // assuming a default value.
229     DisplayDeviceCreationArgs(const sp<SurfaceFlinger>& flinger, const wp<IBinder>& displayToken,
230                               const std::optional<DisplayId>& displayId);
231 
232     const sp<SurfaceFlinger> flinger;
233     const wp<IBinder> displayToken;
234     const std::optional<DisplayId> displayId;
235 
236     int32_t sequenceId{0};
237     bool isVirtual{false};
238     bool isSecure{false};
239     sp<ANativeWindow> nativeWindow;
240     sp<compositionengine::DisplaySurface> displaySurface;
241     int displayInstallOrientation{DisplayState::eOrientationDefault};
242     bool hasWideColorGamut{false};
243     HdrCapabilities hdrCapabilities;
244     int32_t supportedPerFrameMetadata{0};
245     std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>> hwcColorModes;
246     int initialPowerMode{HWC_POWER_MODE_NORMAL};
247     bool isPrimary{false};
248 };
249 
250 class DisplayRenderArea : public RenderArea {
251 public:
252     DisplayRenderArea(const sp<const DisplayDevice> device,
253                       ui::Transform::orientation_flags rotation = ui::Transform::ROT_0)
254           : DisplayRenderArea(device, device->getBounds(), device->getWidth(), device->getHeight(),
255                               device->getCompositionDataSpace(), rotation) {}
256     DisplayRenderArea(const sp<const DisplayDevice> device, Rect sourceCrop, uint32_t reqWidth,
257                       uint32_t reqHeight, ui::Dataspace reqDataSpace,
258                       ui::Transform::orientation_flags rotation, bool allowSecureLayers = true)
259           : RenderArea(reqWidth, reqHeight, CaptureFill::OPAQUE, reqDataSpace,
260                        getDisplayRotation(rotation, device->getInstallOrientation())),
261             mDevice(device),
262             mSourceCrop(sourceCrop),
263             mAllowSecureLayers(allowSecureLayers) {}
264 
getTransform()265     const ui::Transform& getTransform() const override { return mDevice->getTransform(); }
getBounds()266     Rect getBounds() const override { return mDevice->getBounds(); }
getHeight()267     int getHeight() const override { return mDevice->getHeight(); }
getWidth()268     int getWidth() const override { return mDevice->getWidth(); }
isSecure()269     bool isSecure() const override { return mAllowSecureLayers && mDevice->isSecure(); }
getDisplayDevice()270     const sp<const DisplayDevice> getDisplayDevice() const override { return mDevice; }
271 
needsFiltering()272     bool needsFiltering() const override {
273         // check if the projection from the logical display to the physical
274         // display needs filtering
275         if (mDevice->needsFiltering()) {
276             return true;
277         }
278 
279         // check if the projection from the logical render area (i.e., the
280         // physical display) to the physical render area requires filtering
281         const Rect sourceCrop = getSourceCrop();
282         int width = sourceCrop.width();
283         int height = sourceCrop.height();
284         if (getRotationFlags() & ui::Transform::ROT_90) {
285             std::swap(width, height);
286         }
287         return width != getReqWidth() || height != getReqHeight();
288     }
289 
getSourceCrop()290     Rect getSourceCrop() const override {
291         // use the projected display viewport by default.
292         if (mSourceCrop.isEmpty()) {
293             return mDevice->getScissor();
294         }
295 
296         // Recompute the device transformation for the source crop.
297         ui::Transform rotation;
298         ui::Transform translatePhysical;
299         ui::Transform translateLogical;
300         ui::Transform scale;
301         const Rect& viewport = mDevice->getViewport();
302         const Rect& scissor = mDevice->getScissor();
303         const Rect& frame = mDevice->getFrame();
304 
305         const int orientation = mDevice->getInstallOrientation();
306         // Install orientation is transparent to the callers.  Apply it now.
307         uint32_t flags = 0x00;
308         switch (orientation) {
309             case DisplayState::eOrientation90:
310                 flags = ui::Transform::ROT_90;
311                 break;
312             case DisplayState::eOrientation180:
313                 flags = ui::Transform::ROT_180;
314                 break;
315             case DisplayState::eOrientation270:
316                 flags = ui::Transform::ROT_270;
317                 break;
318             default:
319                 break;
320         }
321         rotation.set(flags, getWidth(), getHeight());
322         translateLogical.set(-viewport.left, -viewport.top);
323         translatePhysical.set(scissor.left, scissor.top);
324         scale.set(frame.getWidth() / float(viewport.getWidth()), 0, 0,
325                   frame.getHeight() / float(viewport.getHeight()));
326         const ui::Transform finalTransform =
327                 rotation * translatePhysical * scale * translateLogical;
328         return finalTransform.transform(mSourceCrop);
329     }
330 
331 private:
332     // Install orientation is transparent to the callers.  We need to cancel
333     // it out by modifying rotation flags.
getDisplayRotation(ui::Transform::orientation_flags rotation,int orientation)334     static ui::Transform::orientation_flags getDisplayRotation(
335             ui::Transform::orientation_flags rotation, int orientation) {
336         if (orientation == DisplayState::eOrientationDefault) {
337             return rotation;
338         }
339 
340         // convert hw orientation into flag presentation
341         // here inverse transform needed
342         uint8_t hw_rot_90 = 0x00;
343         uint8_t hw_flip_hv = 0x00;
344         switch (orientation) {
345             case DisplayState::eOrientation90:
346                 hw_rot_90 = ui::Transform::ROT_90;
347                 hw_flip_hv = ui::Transform::ROT_180;
348                 break;
349             case DisplayState::eOrientation180:
350                 hw_flip_hv = ui::Transform::ROT_180;
351                 break;
352             case DisplayState::eOrientation270:
353                 hw_rot_90 = ui::Transform::ROT_90;
354                 break;
355         }
356 
357         // transform flags operation
358         // 1) flip H V if both have ROT_90 flag
359         // 2) XOR these flags
360         uint8_t rotation_rot_90 = rotation & ui::Transform::ROT_90;
361         uint8_t rotation_flip_hv = rotation & ui::Transform::ROT_180;
362         if (rotation_rot_90 & hw_rot_90) {
363             rotation_flip_hv = (~rotation_flip_hv) & ui::Transform::ROT_180;
364         }
365 
366         return static_cast<ui::Transform::orientation_flags>(
367                 (rotation_rot_90 ^ hw_rot_90) | (rotation_flip_hv ^ hw_flip_hv));
368     }
369 
370     const sp<const DisplayDevice> mDevice;
371     const Rect mSourceCrop;
372     const bool mAllowSecureLayers;
373 };
374 
375 }; // namespace android
376 
377 #endif // ANDROID_DISPLAY_DEVICE_H
378