1 /*
2 * Copyright (c) 2021-2023 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 #ifndef RENDER_SERVICE_CLIENT_CORE_COMMON_RS_COMMON_DEF_H
16 #define RENDER_SERVICE_CLIENT_CORE_COMMON_RS_COMMON_DEF_H
17
18 #include <cmath>
19 #include <functional>
20 #include <limits>
21 #include <memory>
22 #include <string>
23 #include <unordered_map>
24 #include <unordered_set>
25 #include <unistd.h>
26
27 #include "common/rs_macros.h"
28
29 namespace OHOS {
30 class Surface;
31
32 namespace Rosen {
33 using AnimationId = uint64_t;
34 using NodeId = uint64_t;
35 using PropertyId = uint64_t;
36 using FrameRateLinkerId = uint64_t;
37 using SurfaceId = uint64_t;
38 using InteractiveImplictAnimatorId = uint64_t;
39 using LeashPersistentId = uint64_t;
40 constexpr uint32_t UNI_MAIN_THREAD_INDEX = UINT32_MAX;
41 constexpr uint32_t UNI_RENDER_THREAD_INDEX = UNI_MAIN_THREAD_INDEX - 1;
42 constexpr uint64_t INVALID_NODEID = 0;
43 constexpr int32_t INSTANCE_ID_UNDEFINED = -1;
44 constexpr uint32_t RGBA_MAX = 255;
45 constexpr uint64_t INVALID_LEASH_PERSISTENTID = 0;
46
47 // types in the same layer should be 0/1/2/4/8
48 // types for UINode
49 enum class RSUINodeType : uint32_t {
50 UNKNOW = 0x0000u,
51 RS_NODE = 0x0001u,
52 DISPLAY_NODE = 0x0011u,
53 SURFACE_NODE = 0x0021u,
54 PROXY_NODE = 0x0041u,
55 CANVAS_NODE = 0x0081u,
56 EFFECT_NODE = 0x0101u,
57 ROOT_NODE = 0x1081u,
58 CANVAS_DRAWING_NODE = 0x2081u,
59 };
60
61 enum class FollowType : uint8_t {
62 NONE,
63 FOLLOW_TO_PARENT,
64 FOLLOW_TO_SELF,
65 };
66
67 #define LIKELY(exp) (__builtin_expect((exp) != 0, true))
68 #define UNLIKELY(exp) (__builtin_expect((exp) != 0, false))
69
70 // types for RenderNode
71 enum class RSRenderNodeType : uint32_t {
72 UNKNOW = 0x0000u,
73 RS_NODE = 0x0001u,
74 DISPLAY_NODE = 0x0011u,
75 SURFACE_NODE = 0x0021u,
76 PROXY_NODE = 0x0041u,
77 CANVAS_NODE = 0x0081u,
78 EFFECT_NODE = 0x0101u,
79 ROOT_NODE = 0x1081u,
80 CANVAS_DRAWING_NODE = 0x2081u,
81 };
82
83 // types for Processor
84 enum class RSProcessorType : uint32_t {
85 UNKNOW = 0x0000u,
86 RS_PROCESSOR = 0x0001u,
87 PHYSICAL_SCREEN_PROCESSOR = 0x0011u,
88 VIRTUAL_SCREEN_PROCESSOR = 0x0021u,
89 UNIRENDER_PROCESSOR = 0x0041u,
90 UNIRENDER_VIRTUAL_PROCESSOR = 0x0081u,
91 };
92
93 enum RSRenderParamsDirtyType {
94 NO_DIRTY = 0,
95 MATRIX_DIRTY,
96 LAYER_INFO_DIRTY,
97 BUFFER_INFO_DIRTY,
98 DRAWING_CACHE_TYPE_DIRTY,
99 MAX_DIRTY_TYPE,
100 };
101
102 enum class NodeDirtyType : uint32_t {
103 NOT_DIRTY = 0x0000u,
104 GEOMETRY = 0x0001u,
105 BACKGROUND = 0x0002u,
106 CONTENT = 0x0004u,
107 FOREGROUND = 0x0008u,
108 OVERLAY = 0x0010u,
109 APPEARANCE = 0x0020u,
110 };
111
112 enum class CacheType : uint8_t {
113 NONE = 0,
114 CONTENT,
115 ANIMATE_PROPERTY,
116 };
117
118 enum class DrawableCacheType : uint8_t {
119 NONE = 0,
120 CONTENT,
121 };
122
123 enum RSDrawingCacheType : uint8_t {
124 DISABLED_CACHE = 0,
125 FORCED_CACHE, // must-to-do case
126 TARGETED_CACHE, // suggested case which could be disabled by optimized strategy
127 FOREGROUND_FILTER_CACHE // using cache to draw foreground filter
128 };
129
130 enum class FilterCacheType : uint8_t {
131 NONE = 0,
132 SNAPSHOT = 1,
133 FILTERED_SNAPSHOT = 2,
134 BOTH = SNAPSHOT | FILTERED_SNAPSHOT,
135 };
136
137 // opinc state
138 enum NodeCacheState : uint8_t {
139 STATE_INIT = 0,
140 STATE_CHANGE,
141 STATE_UNCHANGE,
142 STATE_DISABLE,
143 };
144
145 enum NodeChangeType : uint8_t {
146 KEEP_UNCHANGE = 0,
147 SELF_DIRTY,
148 };
149
150 // opinc cache state
151 enum NodeStrategyType : uint8_t {
152 CACHE_NONE = 0,
153 DDGR_OPINC_DYNAMIC,
154 OPINC_AUTOCACHE,
155 NODE_GROUP,
156 CACHE_DISABLE,
157 };
158
159 enum NodeRecordState : uint8_t {
160 RECORD_NONE = 0,
161 RECORD_CALCULATE,
162 RECORD_CACHING,
163 RECORD_CACHED,
164 RECORD_DISABLE,
165 };
166
167 enum DrawAreaEnableState : uint8_t {
168 DRAW_AREA_INIT = 0,
169 DRAW_AREA_ENABLE,
170 DRAW_AREA_DISABLE,
171 };
172
173 // priority for node, higher number means lower priority
174 enum class NodePriorityType : uint8_t {
175 MAIN_PRIORITY = 0, // node must render in main thread
176 SUB_FOCUSNODE_PRIORITY, // node render in sub thread with the highest priority
177 SUB_HIGH_PRIORITY, // node render in sub thread with the second priority
178 SUB_LOW_PRIORITY, // node render in sub thread with low priority
179 };
180
181 enum class RSVisibleLevel : uint32_t {
182 RS_ALL_VISIBLE = 0,
183 RS_SEMI_NONDEFAULT_VISIBLE,
184 RS_SEMI_DEFAULT_VISIBLE,
185 RS_INVISIBLE,
186 RS_SYSTEM_ANIMATE_SCENE,
187 RS_UNKNOW_VISIBLE_LEVEL,
188 };
189
190 // status for sub thread node
191 enum class CacheProcessStatus : uint8_t {
192 WAITING = 0, // waiting for process
193 DOING, // processing
194 DONE, // processed
195 SKIPPED, // skip cur process and wait for next new data to process
196 UNKNOWN,
197 };
198
199 // the type of surfaceCapture
200 enum class SurfaceCaptureType : uint8_t {
201 DEFAULT_CAPTURE = 0, // displayNode capture or window capture
202 UICAPTURE,
203 };
204
205 #ifdef TP_FEATURE_ENABLE
206 // the type of TpFeatureConfig
207 enum class TpFeatureConfigType : uint8_t {
208 DEFAULT_TP_FEATURE = 0,
209 AFT_TP_FEATURE,
210 };
211 #endif
212
213 struct RSSurfaceCaptureConfig {
214 float scaleX = 1.0f;
215 float scaleY = 1.0f;
216 bool useDma = false;
217 bool useCurWindow = true;
218 SurfaceCaptureType captureType = SurfaceCaptureType::DEFAULT_CAPTURE;
219 bool isSync = false;
220 };
221
222 struct RSSurfaceCapturePermissions {
223 bool screenCapturePermission = false;
224 bool isSystemCalling = false;
225 bool selfCapture = false;
226 };
227
228 enum class DeviceType : uint8_t {
229 PHONE,
230 PC,
231 TABLET,
232 OTHERS,
233 };
234
235 enum GrallocBufferAttr : uint32_t {
236 // used in set roi region to codec, must be the same as private key in codec
237 GRALLOC_BUFFER_ATTR_BUFFER_ROI_INFO = 2054,
238 };
239
240 // types for PC SystemAnimatedScenes
241 enum class SystemAnimatedScenes : uint32_t {
242 ENTER_MISSION_CENTER, // Enter the mission center
243 EXIT_MISSION_CENTER, // Exit the mission center
244 ENTER_TFS_WINDOW, // Three-finger sliding window recovery
245 EXIT_TFU_WINDOW, // The three-finger up window disappears
246 ENTER_WINDOW_FULL_SCREEN, // Enter the window full screen
247 EXIT_WINDOW_FULL_SCREEN, // Exit the window full screen
248 ENTER_MAX_WINDOW, // Enter the window maximization state
249 EXIT_MAX_WINDOW, // Exit the window maximization state
250 ENTER_SPLIT_SCREEN, // Enter the split screen
251 EXIT_SPLIT_SCREEN, // Exit the split screen
252 ENTER_APP_CENTER, // Enter the app center
253 EXIT_APP_CENTER, // Exit the app center
254 APPEAR_MISSION_CENTER, // A special case scenario that displays the mission center
255 ENTER_WIND_CLEAR, // Enter win+D in clear screen mode
256 ENTER_WIND_RECOVER, // Enter win+D in recover mode
257 ENTER_RECENTS, // Enter recents
258 EXIT_RECENTS, // Exit recents
259 OTHERS, // 1.Default state 2.The state in which the animation ends
260 };
261
262 // types for RSSurfaceRenderNode
263 enum class RSSurfaceNodeType : uint8_t {
264 DEFAULT,
265 APP_WINDOW_NODE, // surfacenode created as app main window
266 STARTING_WINDOW_NODE, // starting window, surfacenode created by wms
267 SELF_DRAWING_WINDOW_NODE, // create by wms, such as pointer window and bootanimation
268 LEASH_WINDOW_NODE, // leashwindow
269 ABILITY_COMPONENT_NODE, // surfacenode created as ability component
270 SELF_DRAWING_NODE, // surfacenode created by arkui component (except ability component)
271 SURFACE_TEXTURE_NODE, // create by video
272 FOREGROUND_SURFACE,
273 SCB_SCREEN_NODE, // surfacenode created as sceneboard
274 UI_EXTENSION_COMMON_NODE, // uiextension node
275 UI_EXTENSION_SECURE_NODE, // uiextension node that requires info callback
276 };
277
278 enum class MultiThreadCacheType : uint8_t {
279 NONE = 0,
280 LEASH_WINDOW,
281 ARKTS_CARD,
282 NONFOCUS_WINDOW,
283 };
284
285 enum class SelfDrawingNodeType : uint8_t {
286 DEFAULT,
287 VIDEO,
288 XCOM,
289 };
290
291 enum class SurfaceWindowType : uint8_t {
292 DEFAULT_WINDOW = 0,
293 SYSTEM_SCB_WINDOW = 1,
294 };
295
296 struct RSSurfaceRenderNodeConfig {
297 NodeId id = 0;
298 std::string name = "SurfaceNode";
299 std::string bundleName = "";
300 RSSurfaceNodeType nodeType = RSSurfaceNodeType::DEFAULT;
301 void* additionalData = nullptr;
302 bool isTextureExportNode = false;
303 bool isSync = false;
304 enum SurfaceWindowType surfaceWindowType = SurfaceWindowType::DEFAULT_WINDOW;
305 };
306
307 // codes for arkui-x start
308 // types for RSSurfaceExt
309 enum class RSSurfaceExtType : uint8_t {
310 NONE,
311 SURFACE_TEXTURE,
312 SURFACE_PLATFORM_TEXTURE,
313 };
314
315 struct RSSurfaceExtConfig {
316 RSSurfaceExtType type = RSSurfaceExtType::NONE;
317 void* additionalData = nullptr;
318 };
319 using RSSurfaceTextureConfig = RSSurfaceExtConfig;
320 using RSSurfaceTextureAttachCallBack = std::function<void(int64_t textureId, bool attach)>;
321 using RSSurfaceTextureUpdateCallBack = std::function<void(std::vector<float>&)>;
322 using RSSurfaceTextureInitTypeCallBack = std::function<void(int32_t&)>;
323 // codes for arkui-x end
324
325 struct RSDisplayNodeConfig {
326 uint64_t screenId = 0;
327 bool isMirrored = false;
328 NodeId mirrorNodeId = 0;
329 bool isSync = false;
330 };
331
332 // ability state of surface node
333 enum class RSSurfaceNodeAbilityState : uint8_t {
334 BACKGROUND,
335 FOREGROUND,
336 };
337
338 struct SubSurfaceCntUpdateInfo {
339 int updateCnt_ = 0;
340 NodeId preParentId_ = INVALID_NODEID;
341 NodeId curParentId_ = INVALID_NODEID;
342 };
343
344 constexpr int64_t NS_TO_S = 1000000000;
345 constexpr int64_t NS_PER_MS = 1000000;
346 constexpr uint32_t SIZE_UPPER_LIMIT = 1000;
347 constexpr uint32_t PARTICLE_EMMITER_UPPER_LIMIT = 2000;
348 constexpr uint32_t PARTICLE_UPPER_LIMIT = 1000000;
349
350 #if defined(M_PI)
351 constexpr float PI = M_PI;
352 #else
353 static const float PI = std::atanf(1.0) * 4;
354 #endif
355
356 template<typename T>
ROSEN_EQ(const T & x,const T & y)357 inline constexpr bool ROSEN_EQ(const T& x, const T& y)
358 {
359 if constexpr (std::is_floating_point<T>::value) {
360 return (std::abs((x) - (y)) <= (std::numeric_limits<T>::epsilon()));
361 } else {
362 return x == y;
363 }
364 }
365
366 template<typename T>
ROSEN_EQ(T x,T y,T epsilon)367 inline bool ROSEN_EQ(T x, T y, T epsilon)
368 {
369 return (std::abs((x) - (y)) <= (epsilon));
370 }
371
372 template<typename T>
ROSEN_EQ(const std::weak_ptr<T> & x,const std::weak_ptr<T> & y)373 inline bool ROSEN_EQ(const std::weak_ptr<T>& x, const std::weak_ptr<T>& y)
374 {
375 return !(x.owner_before(y) || y.owner_before(x));
376 }
377
ROSEN_LNE(float left,float right)378 inline bool ROSEN_LNE(float left, float right) // less not equal
379 {
380 constexpr float epsilon = -0.001f;
381 return (left - right) < epsilon;
382 }
383
ROSEN_GNE(float left,float right)384 inline bool ROSEN_GNE(float left, float right) // great not equal
385 {
386 constexpr float epsilon = 0.001f;
387 return (left - right) > epsilon;
388 }
389
ROSEN_GE(float left,float right)390 inline bool ROSEN_GE(float left, float right) // great or equal
391 {
392 constexpr float epsilon = -0.001f;
393 return (left - right) > epsilon;
394 }
395
ROSEN_LE(float left,float right)396 inline bool ROSEN_LE(float left, float right) // less or equal
397 {
398 constexpr float epsilon = 0.001f;
399 return (left - right) < epsilon;
400 }
401
402 class MemObject {
403 public:
MemObject(size_t size)404 explicit MemObject(size_t size) : size_(size) {}
405 virtual ~MemObject() = default;
406
407 void* operator new(size_t size);
408 void operator delete(void* ptr);
409
410 void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
411 void operator delete(void* ptr, const std::nothrow_t&) noexcept;
412
413 protected:
414 size_t size_;
415 };
416
ExtractPid(uint64_t id)417 inline constexpr pid_t ExtractPid(uint64_t id)
418 {
419 // extract high 32 bits of nodeid/animationId/propertyId as pid
420 return static_cast<pid_t>(id >> 32);
421 }
422
423 template<class Container, class Predicate>
EraseIf(Container & container,Predicate pred)424 inline typename Container::size_type EraseIf(Container& container, Predicate pred)
425 {
426 // erase from container if pred returns true, backport of c++20 std::remove_if
427 typename Container::size_type oldSize = container.size();
428 const typename Container::iterator end = container.end();
429 for (typename Container::iterator iter = container.begin(); iter != end;) {
430 if (pred(*iter)) {
431 iter = container.erase(iter);
432 } else {
433 ++iter;
434 }
435 }
436 return oldSize - container.size();
437 }
438
439 enum class AncoFlags : uint32_t {
440 IS_ANCO_NODE = 0x0001
441 };
442
443 enum class RSInterfaceErrorCode : uint32_t {
444 #undef NO_ERROR
445 NO_ERROR = 0,
446 NONSYSTEM_CALLING,
447 NOT_SELF_CALLING,
448 WRITE_PARCEL_ERROR,
449 UNKNOWN_ERROR,
450 };
451
452 } // namespace Rosen
453 } // namespace OHOS
454 #endif // RENDER_SERVICE_CLIENT_CORE_COMMON_RS_COMMON_DEF_H
455