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 "Transform.h"
21
22#include <stdlib.h>
23#include <unordered_map>
24
25#include <math/mat4.h>
26
27#include <binder/IBinder.h>
28#include <gui/ISurfaceComposer.h>
29#include <hardware/hwcomposer_defs.h>
30#include <ui/GraphicTypes.h>
31#include <ui/HdrCapabilities.h>
32#include <ui/Region.h>
33#include <utils/RefBase.h>
34#include <utils/Mutex.h>
35#include <utils/String8.h>
36#include <utils/Timers.h>
37
38#include "RenderArea.h"
39#include "RenderEngine/Surface.h"
40
41#include <memory>
42
43struct ANativeWindow;
44
45namespace android {
46
47struct DisplayInfo;
48class DisplaySurface;
49class Fence;
50class IGraphicBufferProducer;
51class Layer;
52class SurfaceFlinger;
53class HWComposer;
54
55class DisplayDevice : public LightRefBase<DisplayDevice>
56{
57public:
58    constexpr static float sDefaultMinLumiance = 0.0;
59    constexpr static float sDefaultMaxLumiance = 500.0;
60
61    // region in layer-stack space
62    mutable Region dirtyRegion;
63    // region in screen space
64    Region undefinedRegion;
65    bool lastCompositionHadVisibleLayers;
66
67    enum DisplayType {
68        DISPLAY_ID_INVALID = -1,
69        DISPLAY_PRIMARY     = HWC_DISPLAY_PRIMARY,
70        DISPLAY_EXTERNAL    = HWC_DISPLAY_EXTERNAL,
71        DISPLAY_VIRTUAL     = HWC_DISPLAY_VIRTUAL,
72        NUM_BUILTIN_DISPLAY_TYPES = HWC_NUM_PHYSICAL_DISPLAY_TYPES,
73    };
74
75    enum {
76        NO_LAYER_STACK = 0xFFFFFFFF,
77    };
78
79    // clang-format off
80    DisplayDevice(
81            const sp<SurfaceFlinger>& flinger,
82            DisplayType type,
83            int32_t hwcId,
84            bool isSecure,
85            const wp<IBinder>& displayToken,
86            const sp<ANativeWindow>& nativeWindow,
87            const sp<DisplaySurface>& displaySurface,
88            std::unique_ptr<RE::Surface> renderSurface,
89            int displayWidth,
90            int displayHeight,
91            bool hasWideColorGamut,
92            const HdrCapabilities& hdrCapabilities,
93            const int32_t supportedPerFrameMetadata,
94            const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>& hwcColorModes,
95            int initialPowerMode);
96    // clang-format on
97
98    ~DisplayDevice();
99
100    // whether this is a valid object. An invalid DisplayDevice is returned
101    // when an non existing id is requested
102    bool isValid() const;
103
104    // isSecure indicates whether this display can be trusted to display
105    // secure surfaces.
106    bool isSecure() const { return mIsSecure; }
107
108    // Flip the front and back buffers if the back buffer is "dirty".  Might
109    // be instantaneous, might involve copying the frame buffer around.
110    void flip() const;
111
112    int         getWidth() const;
113    int         getHeight() const;
114
115    void                    setVisibleLayersSortedByZ(const Vector< sp<Layer> >& layers);
116    const Vector< sp<Layer> >& getVisibleLayersSortedByZ() const;
117    void                    setLayersNeedingFences(const Vector< sp<Layer> >& layers);
118    const Vector< sp<Layer> >& getLayersNeedingFences() const;
119    Region                  getDirtyRegion(bool repaintEverything) const;
120
121    void                    setLayerStack(uint32_t stack);
122    void                    setDisplaySize(const int newWidth, const int newHeight);
123    void                    setProjection(int orientation, const Rect& viewport, const Rect& frame);
124
125    int                     getOrientation() const { return mOrientation; }
126    uint32_t                getOrientationTransform() const;
127    static uint32_t         getPrimaryDisplayOrientationTransform();
128    const Transform&        getTransform() const { return mGlobalTransform; }
129    const Rect              getViewport() const { return mViewport; }
130    const Rect              getFrame() const { return mFrame; }
131    const Rect&             getScissor() const { return mScissor; }
132    bool                    needsFiltering() const { return mNeedsFiltering; }
133
134    uint32_t                getLayerStack() const { return mLayerStack; }
135    int32_t                 getDisplayType() const { return mType; }
136    bool                    isPrimary() const { return mType == DISPLAY_PRIMARY; }
137    int32_t                 getHwcDisplayId() const { return mHwcDisplayId; }
138    const wp<IBinder>&      getDisplayToken() const { return mDisplayToken; }
139
140    int32_t getSupportedPerFrameMetadata() const { return mSupportedPerFrameMetadata; }
141
142    // We pass in mustRecompose so we can keep VirtualDisplaySurface's state
143    // machine happy without actually queueing a buffer if nothing has changed
144    status_t beginFrame(bool mustRecompose) const;
145    status_t prepareFrame(HWComposer& hwc);
146
147    bool hasWideColorGamut() const { return mHasWideColorGamut; }
148    // Whether h/w composer has native support for specific HDR type.
149    bool hasHDR10Support() const { return mHasHdr10; }
150    bool hasHLGSupport() const { return mHasHLG; }
151    bool hasDolbyVisionSupport() const { return mHasDolbyVision; }
152
153    // Return true if the HDR dataspace is supported but
154    // there is no corresponding color mode.
155    bool hasLegacyHdrSupport(ui::Dataspace dataspace) const;
156
157    // The returned HdrCapabilities is the combination of HDR capabilities from
158    // hardware composer and RenderEngine. When the DisplayDevice supports wide
159    // color gamut, RenderEngine is able to simulate HDR support in Display P3
160    // color space for both PQ and HLG HDR contents. The minimum and maximum
161    // luminance will be set to sDefaultMinLumiance and sDefaultMaxLumiance
162    // respectively if hardware composer doesn't return meaningful values.
163    const HdrCapabilities& getHdrCapabilities() const { return mHdrCapabilities; }
164
165    // Return true if intent is supported by the display.
166    bool hasRenderIntent(ui::RenderIntent intent) const;
167
168    void getBestColorMode(ui::Dataspace dataspace, ui::RenderIntent intent,
169                          ui::Dataspace* outDataspace, ui::ColorMode* outMode,
170                          ui::RenderIntent* outIntent) const;
171
172    void swapBuffers(HWComposer& hwc) const;
173
174    // called after h/w composer has completed its set() call
175    void onSwapBuffersCompleted() const;
176
177    Rect getBounds() const {
178        return Rect(mDisplayWidth, mDisplayHeight);
179    }
180    inline Rect bounds() const { return getBounds(); }
181
182    void setDisplayName(const String8& displayName);
183    const String8& getDisplayName() const { return mDisplayName; }
184
185    bool makeCurrent() const;
186    void setViewportAndProjection() const;
187
188    const sp<Fence>& getClientTargetAcquireFence() const;
189
190    /* ------------------------------------------------------------------------
191     * Display power mode management.
192     */
193    int getPowerMode() const;
194    void setPowerMode(int mode);
195    bool isDisplayOn() const;
196
197    ui::ColorMode getActiveColorMode() const;
198    void setActiveColorMode(ui::ColorMode mode);
199    ui::RenderIntent getActiveRenderIntent() const;
200    void setActiveRenderIntent(ui::RenderIntent renderIntent);
201    android_color_transform_t getColorTransform() const;
202    void setColorTransform(const mat4& transform);
203    void setCompositionDataSpace(ui::Dataspace dataspace);
204    ui::Dataspace getCompositionDataSpace() const;
205
206    /* ------------------------------------------------------------------------
207     * Display active config management.
208     */
209    int getActiveConfig() const;
210    void setActiveConfig(int mode);
211
212    // release HWC resources (if any) for removable displays
213    void disconnect(HWComposer& hwc);
214
215    /* ------------------------------------------------------------------------
216     * Debugging
217     */
218    uint32_t getPageFlipCount() const;
219    void dump(String8& result) const;
220
221private:
222    /*
223     *  Constants, set during initialization
224     */
225    sp<SurfaceFlinger> mFlinger;
226    DisplayType mType;
227    int32_t mHwcDisplayId;
228    wp<IBinder> mDisplayToken;
229
230    // ANativeWindow this display is rendering into
231    sp<ANativeWindow> mNativeWindow;
232    sp<DisplaySurface> mDisplaySurface;
233
234    std::unique_ptr<RE::Surface> mSurface;
235    int             mDisplayWidth;
236    int             mDisplayHeight;
237    mutable uint32_t mPageFlipCount;
238    String8         mDisplayName;
239    bool            mIsSecure;
240
241    /*
242     * Can only accessed from the main thread, these members
243     * don't need synchronization.
244     */
245
246    // list of visible layers on that display
247    Vector< sp<Layer> > mVisibleLayersSortedByZ;
248    // list of layers needing fences
249    Vector< sp<Layer> > mLayersNeedingFences;
250
251    /*
252     * Transaction state
253     */
254    static status_t orientationToTransfrom(int orientation,
255            int w, int h, Transform* tr);
256
257    // The identifier of the active layer stack for this display. Several displays
258    // can use the same layer stack: A z-ordered group of layers (sometimes called
259    // "surfaces"). Any given layer can only be on a single layer stack.
260    uint32_t mLayerStack;
261
262    int mOrientation;
263    static uint32_t sPrimaryDisplayOrientation;
264    // user-provided visible area of the layer stack
265    Rect mViewport;
266    // user-provided rectangle where mViewport gets mapped to
267    Rect mFrame;
268    // pre-computed scissor to apply to the display
269    Rect mScissor;
270    Transform mGlobalTransform;
271    bool mNeedsFiltering;
272    // Current power mode
273    int mPowerMode;
274    // Current active config
275    int mActiveConfig;
276    // current active color mode
277    ui::ColorMode mActiveColorMode = ui::ColorMode::NATIVE;
278    // Current active render intent.
279    ui::RenderIntent mActiveRenderIntent = ui::RenderIntent::COLORIMETRIC;
280    ui::Dataspace mCompositionDataSpace = ui::Dataspace::UNKNOWN;
281    // Current color transform
282    android_color_transform_t mColorTransform;
283
284    // Need to know if display is wide-color capable or not.
285    // Initialized by SurfaceFlinger when the DisplayDevice is created.
286    // Fed to RenderEngine during composition.
287    bool mHasWideColorGamut;
288    bool mHasHdr10;
289    bool mHasHLG;
290    bool mHasDolbyVision;
291    HdrCapabilities mHdrCapabilities;
292    const int32_t mSupportedPerFrameMetadata;
293
294    // Mappings from desired Dataspace/RenderIntent to the supported
295    // Dataspace/ColorMode/RenderIntent.
296    using ColorModeKey = uint64_t;
297    struct ColorModeValue {
298        ui::Dataspace dataspace;
299        ui::ColorMode colorMode;
300        ui::RenderIntent renderIntent;
301    };
302
303    static ColorModeKey getColorModeKey(ui::Dataspace dataspace, ui::RenderIntent intent) {
304        return (static_cast<uint64_t>(dataspace) << 32) | static_cast<uint32_t>(intent);
305    }
306    void populateColorModes(
307            const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>& hwcColorModes);
308    void addColorMode(
309            const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>& hwcColorModes,
310            const ui::ColorMode mode, const ui::RenderIntent intent);
311
312    std::unordered_map<ColorModeKey, ColorModeValue> mColorModes;
313};
314
315struct DisplayDeviceState {
316    DisplayDeviceState() = default;
317    DisplayDeviceState(DisplayDevice::DisplayType type, bool isSecure);
318
319    bool isValid() const { return type >= 0; }
320    bool isMainDisplay() const { return type == DisplayDevice::DISPLAY_PRIMARY; }
321    bool isVirtualDisplay() const { return type >= DisplayDevice::DISPLAY_VIRTUAL; }
322
323    static std::atomic<int32_t> nextDisplayId;
324    int32_t displayId = nextDisplayId++;
325    DisplayDevice::DisplayType type = DisplayDevice::DISPLAY_ID_INVALID;
326    sp<IGraphicBufferProducer> surface;
327    uint32_t layerStack = DisplayDevice::NO_LAYER_STACK;
328    Rect viewport;
329    Rect frame;
330    uint8_t orientation = 0;
331    uint32_t width = 0;
332    uint32_t height = 0;
333    String8 displayName;
334    bool isSecure = false;
335};
336
337class DisplayRenderArea : public RenderArea {
338public:
339    DisplayRenderArea(const sp<const DisplayDevice> device,
340                      ISurfaceComposer::Rotation rotation = ISurfaceComposer::eRotateNone)
341          : DisplayRenderArea(device, device->getBounds(), device->getHeight(), device->getWidth(),
342                              rotation) {}
343    DisplayRenderArea(const sp<const DisplayDevice> device, Rect sourceCrop, uint32_t reqHeight,
344                      uint32_t reqWidth, ISurfaceComposer::Rotation rotation)
345          : RenderArea(reqHeight, reqWidth, CaptureFill::OPAQUE, rotation), mDevice(device),
346                              mSourceCrop(sourceCrop) {}
347
348    const Transform& getTransform() const override { return mDevice->getTransform(); }
349    Rect getBounds() const override { return mDevice->getBounds(); }
350    int getHeight() const override { return mDevice->getHeight(); }
351    int getWidth() const override { return mDevice->getWidth(); }
352    bool isSecure() const override { return mDevice->isSecure(); }
353    bool needsFiltering() const override { return mDevice->needsFiltering(); }
354    Rect getSourceCrop() const override { return mSourceCrop; }
355
356private:
357    const sp<const DisplayDevice> mDevice;
358    const Rect mSourceCrop;
359};
360
361}; // namespace android
362
363#endif // ANDROID_DISPLAY_DEVICE_H
364