1 /*
2  * Copyright (c) 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 RENDER_SERVICE_CORE_PIPELINE_PARALLEL_RENDER_RS_RENDER_TASK_H
17 #define RENDER_SERVICE_CORE_PIPELINE_PARALLEL_RENDER_RS_RENDER_TASK_H
18 
19 #include <cstdint>
20 #include <memory>
21 #include <queue>
22 #include "pipeline/rs_base_render_node.h"
23 #include "pipeline/rs_display_render_node.h"
24 #include "pipeline/rs_paint_filter_canvas.h"
25 #include "pipeline/rs_surface_render_node.h"
26 
27 #include "drawable/rs_render_node_drawable.h"
28 #include "drawable/rs_display_render_node_drawable.h"
29 #include "drawable/rs_surface_render_node_drawable.h"
30 namespace OHOS {
31 namespace Rosen {
32 class RSRenderTaskBase {
33 public:
RSRenderTaskBase(std::shared_ptr<RSBaseRenderNode> node)34     explicit RSRenderTaskBase(std::shared_ptr<RSBaseRenderNode> node) : node_(node), loadId_(node->GetId()) {}
35     virtual ~RSRenderTaskBase() = default;
SetIdx(uint64_t idx)36     void SetIdx(uint64_t idx)
37     {
38         loadId_ = idx;
39     }
GetIdx()40     uint64_t GetIdx() const
41     {
42         return loadId_;
43     }
GetNode()44     std::shared_ptr<RSBaseRenderNode> GetNode() const
45     {
46         return node_;
47     }
48 
49 private:
50     std::shared_ptr<RSBaseRenderNode> node_;
51     uint64_t loadId_ = 0;
52 };
53 
54 class RSRenderTask : public RSRenderTaskBase {
55 public:
56     enum class RenderNodeStage {
57         PREPARE = 0,
58         PROCESS,
59         CACHE,
60         CALC_COST
61     };
RSRenderTask(RSSurfaceRenderNode & node,RenderNodeStage stage)62     explicit RSRenderTask(RSSurfaceRenderNode &node, RenderNodeStage stage)
63         : RSRenderTaskBase(node.shared_from_this()), stage_(stage) {}
~RSRenderTask()64     ~RSRenderTask() override {};
GetNodeStage()65     RenderNodeStage GetNodeStage() const
66     {
67         return stage_;
68     }
69 private:
70     RenderNodeStage stage_ = RenderNodeStage::PREPARE;
71 };
72 
73 class RSSuperRenderTask : public RSRenderTaskBase {
74 public:
RSSuperRenderTask(RSDisplayRenderNode & node)75     explicit RSSuperRenderTask(RSDisplayRenderNode &node)
76         : RSRenderTaskBase(node.shared_from_this()) {}
77     explicit RSSuperRenderTask(std::shared_ptr<RSBaseRenderNode> node, uint64_t frameCount = 0)
78         : RSRenderTaskBase(node), frameCount_(frameCount) {}
79     ~RSSuperRenderTask() override;
80 
81     void AddTask(std::unique_ptr<RSRenderTask> &&task);
82 
GetTaskSize()83     int GetTaskSize() const
84     {
85         return tasks_.size();
86     }
87 
GetFrameCount()88     uint64_t GetFrameCount() const
89     {
90         return frameCount_;
91     }
92 
93     std::shared_ptr<RSBaseRenderNode> GetSurfaceNode();
94     std::unique_ptr<RSRenderTask> GetNextRenderTask();
95 
96 private:
97     std::queue<std::unique_ptr<RSRenderTask>> tasks_;
98     uint64_t frameCount_ = 0;
99 };
100 
101 class RSCompositionTask : public RSRenderTaskBase {
102 public:
RSCompositionTask(std::shared_ptr<RSDisplayRenderNode> node)103     explicit RSCompositionTask(std::shared_ptr<RSDisplayRenderNode> node) : RSRenderTaskBase(node) {}
~RSCompositionTask()104     ~RSCompositionTask() override {};
105 };
106 
107 } // namespace Rosen
108 } // namespace OHOS
109 #endif // RENDER_SERVICE_CORE_PIPELINE_PARALLEL_RENDER_RS_RENDER_TASK_H