1 /*
2  * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef RS_SCREEN
17 #define RS_SCREEN
18 
19 #include <memory>
20 #include <mutex>
21 #include <optional>
22 #include <unordered_set>
23 
24 #include <surface_type.h>
25 #include <hdi_output.h>
26 #include <hdi_screen.h>
27 #include <hdi_display_type.h>
28 #include <screen_manager/screen_types.h>
29 
30 namespace OHOS {
31 namespace Rosen {
32 struct VirtualScreenConfigs {
33     ScreenId id = INVALID_SCREEN_ID;
34     ScreenId mirrorId = INVALID_SCREEN_ID;
35     std::string name;
36     uint32_t width = 0;
37     uint32_t height = 0;
38     sptr<Surface> surface = nullptr;
39     GraphicPixelFormat pixelFormat = GRAPHIC_PIXEL_FMT_RGBA_8888;
40     int32_t flags = 0; // reserve flag.
41     std::unordered_set<uint64_t> whiteList = {};
42     std::unordered_set<uint64_t> blackListSet = {};
43 };
44 
45 class RSScreen {
46 public:
47     RSScreen() = default;
48     virtual ~RSScreen() noexcept = default;
49 
50     virtual ScreenId Id() const = 0;
51     virtual ScreenId MirrorId() const = 0;
52     virtual void SetMirror(ScreenId mirrorId) = 0;
53     virtual const std::string& Name() const = 0;
54     virtual uint32_t Width() const = 0;
55     virtual uint32_t Height() const = 0;
56     virtual uint32_t PhyWidth() const = 0;
57     virtual uint32_t PhyHeight() const = 0;
58     virtual bool IsEnable() const = 0;
59     virtual bool IsVirtual() const = 0;
60     virtual void SetActiveMode(uint32_t modeId) = 0;
61     virtual void SetResolution(uint32_t width, uint32_t height) = 0;
62     virtual void SetRogResolution(uint32_t width, uint32_t height) = 0;
63     virtual void SetPowerStatus(uint32_t powerStatus) = 0;
64     virtual std::optional<GraphicDisplayModeInfo> GetActiveMode() const = 0;
65     virtual const std::vector<GraphicDisplayModeInfo>& GetSupportedModes() const = 0;
66     virtual const GraphicDisplayCapability& GetCapability() const = 0;
67     virtual uint32_t GetPowerStatus() const = 0;
68     virtual std::shared_ptr<HdiOutput> GetOutput() const = 0;
69     virtual sptr<Surface> GetProducerSurface() const = 0;
70     virtual void SetProducerSurface(sptr<Surface> producerSurface) = 0;
71     virtual bool GetAndResetVirtualSurfaceUpdateFlag() = 0;
72     virtual void DisplayDump(int32_t screenIndex, std::string& dumpString) = 0;
73     virtual void SurfaceDump(int32_t screenIndex, std::string& dumpString) = 0;
74     virtual void FpsDump(int32_t screenIndex, std::string& dumpString, std::string& arg) = 0;
75     virtual void ClearFpsDump(int32_t screenIndex, std::string& dumpString, std::string& arg) = 0;
76     virtual void HitchsDump(int32_t screenIndex, std::string& dumpString, std::string& arg) = 0;
77     virtual void SetScreenBacklight(uint32_t level) = 0;
78     virtual int32_t GetScreenBacklight() const = 0;
79     virtual void ResizeVirtualScreen(uint32_t width, uint32_t height) = 0;
80     virtual int32_t GetScreenSupportedColorGamuts(std::vector<ScreenColorGamut> &mode) const = 0;
81     virtual int32_t GetScreenSupportedMetaDataKeys(std::vector<ScreenHDRMetadataKey> &keys) const = 0;
82     virtual bool GetCanvasRotation() const = 0;
83     virtual ScreenScaleMode GetScaleMode() const = 0;
84     virtual int32_t GetScreenColorGamut(ScreenColorGamut &mode) const = 0;
85     virtual int32_t SetScreenColorGamut(int32_t modeIdx) = 0;
86     virtual int32_t SetScreenGamutMap(ScreenGamutMap mode) = 0;
87     virtual ScreenRotation GetScreenCorrection() const = 0;
88     virtual int32_t GetScreenGamutMap(ScreenGamutMap &mode) const = 0;
89     virtual int32_t GetActiveModePosByModeId(int32_t modeId) const = 0;
90     virtual const GraphicHDRCapability& GetHDRCapability() = 0;
91     virtual const RSScreenType& GetScreenType() const = 0;
92     virtual void SetScreenCorrection(ScreenRotation screenRotation) = 0;
93     virtual void SetScreenSkipFrameInterval(uint32_t skipFrameInterval) = 0;
94     virtual uint32_t GetScreenSkipFrameInterval() const = 0;
95     virtual void SetScreenExpectedRefreshRate(uint32_t expectedRefreshRate) = 0;
96     virtual uint32_t GetScreenExpectedRefreshRate() const = 0;
97     virtual SkipFrameStrategy GetScreenSkipFrameStrategy() const = 0;
98     virtual void SetEqualVsyncPeriod(bool isEqualVsyncPeriod) = 0;
99     virtual bool GetEqualVsyncPeriod() const = 0;
100     virtual void SetScreenVsyncEnabled(bool enabled) const = 0;
101     virtual bool SetVirtualMirrorScreenCanvasRotation(bool canvasRotation) = 0;
102     virtual bool SetVirtualMirrorScreenScaleMode(ScreenScaleMode scaleMode) = 0;
103     virtual int32_t GetScreenSupportedHDRFormats(std::vector<ScreenHDRFormat>& hdrFormats) const = 0;
104     virtual int32_t GetScreenHDRFormat(ScreenHDRFormat& hdrFormat) const = 0;
105     virtual int32_t SetScreenHDRFormat(int32_t modeIdx) = 0;
106     virtual int32_t GetPixelFormat(GraphicPixelFormat& pixelFormat) const = 0;
107     virtual int32_t SetPixelFormat(GraphicPixelFormat pixelFormat) = 0;
108     virtual int32_t GetScreenSupportedColorSpaces(std::vector<GraphicCM_ColorSpaceType>& colorSpaces) const = 0;
109     virtual int32_t GetScreenColorSpace(GraphicCM_ColorSpaceType& colorSpace) const = 0;
110     virtual int32_t SetScreenColorSpace(GraphicCM_ColorSpaceType colorSpace) = 0;
111     virtual const std::unordered_set<uint64_t>& GetWhiteList() const = 0;
112     virtual int32_t SetScreenConstraint(uint64_t frameId, uint64_t timestamp, ScreenConstraintType type) = 0;
113     virtual void SetBlackList(const std::unordered_set<uint64_t>& blackList) = 0;
114     virtual void AddBlackList(const std::vector<uint64_t>& blackList) = 0;
115     virtual void RemoveBlackList(const std::vector<uint64_t>& blackList) = 0;
116     virtual void SetCastScreenEnableSkipWindow(bool enable) = 0;
117     virtual const std::unordered_set<uint64_t>& GetBlackList() const = 0;
118     virtual bool GetCastScreenEnableSkipWindow() = 0;
119     virtual bool GetDisplayPropertyForHardCursor() = 0;
120     virtual void SetDisplayPropertyForHardCursor() = 0;
121     virtual void SetSecurityExemptionList(const std::vector<uint64_t>& securityExemptionList) = 0;
122     virtual const std::vector<uint64_t>& GetSecurityExemptionList() const = 0;
123 };
124 
125 namespace impl {
126 class RSScreen : public OHOS::Rosen::RSScreen {
127 public:
128     RSScreen(
129         ScreenId id,
130         bool isVirtual,
131         std::shared_ptr<HdiOutput> output,
132         sptr<Surface> surface);
133     RSScreen(const VirtualScreenConfigs &configs);
134     ~RSScreen() noexcept override;
135 
136     RSScreen(const RSScreen &) = delete;
137     RSScreen &operator=(const RSScreen &) = delete;
138 
139     ScreenId Id() const override;
140     ScreenId MirrorId() const override;
141     void SetMirror(ScreenId mirrorId) override;
142     const std::string& Name() const override;
143     // render resolution
144     uint32_t Width() const override;
145     uint32_t Height() const override;
146     // physical screen resolution
147     uint32_t PhyWidth() const override;
148     uint32_t PhyHeight() const override;
149     bool IsEnable() const override;
150     bool IsVirtual() const override;
151     void SetActiveMode(uint32_t modeId) override;
152     void SetResolution(uint32_t width, uint32_t height) override;
153     void SetRogResolution(uint32_t width, uint32_t height) override;
154     void SetPowerStatus(uint32_t powerStatus) override;
155     std::optional<GraphicDisplayModeInfo> GetActiveMode() const override;
156     const std::vector<GraphicDisplayModeInfo>& GetSupportedModes() const override;
157     const GraphicDisplayCapability& GetCapability() const override;
158     uint32_t GetPowerStatus() const override;
159     std::shared_ptr<HdiOutput> GetOutput() const override;
160     sptr<Surface> GetProducerSurface() const override;
161     void SetProducerSurface(sptr<Surface> producerSurface) override;
162     bool GetAndResetVirtualSurfaceUpdateFlag() override;
163     void DisplayDump(int32_t screenIndex, std::string& dumpString) override;
164     void SurfaceDump(int32_t screenIndex, std::string& dumpString) override;
165     void FpsDump(int32_t screenIndex, std::string& dumpString, std::string& arg) override;
166     void ClearFpsDump(int32_t screenIndex, std::string& dumpString, std::string& arg) override;
167     void HitchsDump(int32_t screenIndex, std::string& dumpString, std::string& arg) override;
168     void ResizeVirtualScreen(uint32_t width, uint32_t height) override;
169     void SetScreenBacklight(uint32_t level) override;
170     int32_t GetScreenBacklight() const override;
171     int32_t GetScreenSupportedColorGamuts(std::vector<ScreenColorGamut> &mode) const override;
172     int32_t GetScreenSupportedMetaDataKeys(std::vector<ScreenHDRMetadataKey> &keys) const override;
173     bool GetCanvasRotation() const override;
174     ScreenScaleMode GetScaleMode() const override;
175     int32_t GetScreenColorGamut(ScreenColorGamut &mode) const override;
176     int32_t SetScreenColorGamut(int32_t modeIdx) override;
177     int32_t SetScreenGamutMap(ScreenGamutMap mode) override;
178     void SetScreenCorrection(ScreenRotation screenRotation) override;
179     ScreenRotation GetScreenCorrection() const override;
180     int32_t GetScreenGamutMap(ScreenGamutMap &mode) const override;
181     int32_t GetActiveModePosByModeId(int32_t modeId) const override;
182     const GraphicHDRCapability& GetHDRCapability() override;
183     const RSScreenType& GetScreenType() const override;
184     void SetScreenSkipFrameInterval(uint32_t skipFrameInterval) override;
185     uint32_t GetScreenSkipFrameInterval() const override;
186     void SetScreenExpectedRefreshRate(uint32_t expectedRefreshRate) override;
187     uint32_t GetScreenExpectedRefreshRate() const override;
188     SkipFrameStrategy GetScreenSkipFrameStrategy() const override;
189     void SetEqualVsyncPeriod(bool isEqualVsyncPeriod) override;
190     bool GetEqualVsyncPeriod() const override;
191     void SetScreenVsyncEnabled(bool enabled) const override;
192     bool SetVirtualMirrorScreenCanvasRotation(bool canvasRotation) override;
193     bool SetVirtualMirrorScreenScaleMode(ScreenScaleMode scaleMode) override;
194     int32_t GetScreenSupportedHDRFormats(std::vector<ScreenHDRFormat>& hdrFormats) const override;
195     int32_t GetScreenHDRFormat(ScreenHDRFormat& hdrFormat) const override;
196     int32_t SetScreenHDRFormat(int32_t modeIdx) override;
197     int32_t GetPixelFormat(GraphicPixelFormat& pixelFormat) const override;
198     int32_t SetPixelFormat(GraphicPixelFormat pixelFormat) override;
199     int32_t GetScreenSupportedColorSpaces(std::vector<GraphicCM_ColorSpaceType>& colorSpaces) const override;
200     int32_t GetScreenColorSpace(GraphicCM_ColorSpaceType& colorSpace) const override;
201     int32_t SetScreenColorSpace(GraphicCM_ColorSpaceType colorSpace) override;
202     const std::unordered_set<uint64_t>& GetWhiteList() const override;
203     void SetBlackList(const std::unordered_set<uint64_t>& blackListSet) override;
204     void AddBlackList(const std::vector<uint64_t>& blackList) override;
205     void RemoveBlackList(const std::vector<uint64_t>& blackList) override;
206     void SetCastScreenEnableSkipWindow(bool enable) override;
207     const std::unordered_set<uint64_t>& GetBlackList() const override;
208     bool GetCastScreenEnableSkipWindow() override;
209     int32_t SetScreenConstraint(uint64_t frameId, uint64_t timestamp, ScreenConstraintType type) override;
210     bool GetDisplayPropertyForHardCursor() override;
211     void SetDisplayPropertyForHardCursor() override;
212     void SetSecurityExemptionList(const std::vector<uint64_t>& securityExemptionList) override;
213     const std::vector<uint64_t>& GetSecurityExemptionList() const override;
214 
215 private:
216     // create hdiScreen and get some information from drivers.
217     void PhysicalScreenInit() noexcept;
218     void ScreenCapabilityInit() noexcept;
219 
220     void VirtualScreenInit() noexcept;
221     void ModeInfoDump(std::string& dumpString);
222     void CapabilityDump(std::string& dumpString);
223     void PropDump(std::string& dumpString);
224     void PowerStatusDump(std::string& dumpString);
225     void CapabilityTypeDump(GraphicInterfaceType capabilityType, std::string& dumpString);
226     void ScreenTypeDump(std::string& dumpString);
227 
228     // ScreenId for this screen.
229     ScreenId id_ = INVALID_SCREEN_ID;
230     // If this screen is the mirror of other screen, this member would be a valid id.
231     ScreenId mirrorId_ = INVALID_SCREEN_ID;
232 
233     std::string name_;
234 
235     uint32_t width_ = 0;
236     uint32_t height_ = 0;
237     uint32_t phyWidth_ = 0;
238     uint32_t phyHeight_ = 0;
239     int32_t screenBacklightLevel_ = INVALID_BACKLIGHT_VALUE;
240 
241     bool isVirtual_ = true;
242     bool isVirtualSurfaceUpdateFlag_ = false;
243     std::shared_ptr<HdiOutput> hdiOutput_ = nullptr; // has value if the screen is physical
244     std::unique_ptr<HdiScreen> hdiScreen_ = nullptr; // has value if the screen is physical
245     std::vector<GraphicDisplayModeInfo> supportedModes_;
246     GraphicDisplayCapability capability_ = {"test1", GRAPHIC_DISP_INTF_HDMI, 1921, 1081, 0, 0, true, 0};
247     GraphicHDRCapability hdrCapability_;
248     sptr<Surface> producerSurface_ = nullptr;  // has value if the screen is virtual
249     GraphicDispPowerStatus powerStatus_ = GraphicDispPowerStatus::GRAPHIC_POWER_STATUS_ON;
250     GraphicPixelFormat pixelFormat_;
251 
252     std::vector<ScreenColorGamut> supportedVirtualColorGamuts_ = {
253         COLOR_GAMUT_SRGB,
254         COLOR_GAMUT_DCI_P3,
255         COLOR_GAMUT_ADOBE_RGB };
256     std::vector<ScreenColorGamut> supportedPhysicalColorGamuts_;
257     int32_t currentVirtualColorGamutIdx_ = 0;
258     int32_t currentPhysicalColorGamutIdx_ = 0;
259     ScreenGamutMap currentVirtualGamutMap_ = GAMUT_MAP_CONSTANT;
260     int32_t currentVirtualHDRFormatIdx_ = 0;
261     int32_t currentPhysicalHDRFormatIdx_ = 0;
262     std::vector<ScreenHDRFormat> supportedVirtualHDRFormats_ = {
263         NOT_SUPPORT_HDR };
264     std::vector<ScreenHDRFormat> supportedPhysicalHDRFormats_;
265     RSScreenType screenType_ = RSScreenType::UNKNOWN_TYPE_SCREEN;
266     uint32_t skipFrameInterval_ = DEFAULT_SKIP_FRAME_INTERVAL;
267     uint32_t expectedRefreshRate_ = INVALID_EXPECTED_REFRESH_RATE;
268     SkipFrameStrategy skipFrameStrategy_ = SKIP_FRAME_BY_INTERVAL;
269     bool isEqualVsyncPeriod_ = true;
270     ScreenRotation screenRotation_ = ScreenRotation::ROTATION_0;
271     bool canvasRotation_ = false; // just for virtual screen to use
272     ScreenScaleMode scaleMode_ = ScreenScaleMode::UNISCALE_MODE; // just for virtual screen to use
273     static std::map<GraphicColorGamut, GraphicCM_ColorSpaceType> RS_TO_COMMON_COLOR_SPACE_TYPE_MAP;
274     static std::map<GraphicCM_ColorSpaceType, GraphicColorGamut> COMMON_COLOR_SPACE_TYPE_TO_RS_MAP;
275     static std::map<GraphicHDRFormat, ScreenHDRFormat> HDI_HDR_FORMAT_TO_RS_MAP;
276     static std::map<ScreenHDRFormat, GraphicHDRFormat> RS_TO_HDI_HDR_FORMAT_MAP;
277     std::unordered_set<uint64_t> whiteList_ = {};
278     std::unordered_set<uint64_t> blackList_ = {};
279     std::vector<uint64_t> securityExemptionList_ = {};
280     std::atomic<bool> skipWindow_ = false;
281     mutable std::mutex skipFrameMutex_;
282     bool isHardCursorSupport_ = false;
283 };
284 } // namespace impl
285 } // namespace Rosen
286 } // namespace OHOS
287 
288 #endif // RS_SCREEN
289