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 16 #ifndef RS_SURFACE_CAPTURE_TASK 17 #define RS_SURFACE_CAPTURE_TASK 18 19 #include "common/rs_common_def.h" 20 #ifndef USE_ROSEN_DRAWING 21 #include "include/core/SkCanvas.h" 22 #include "include/core/SkMatrix.h" 23 #include "include/core/SkSurface.h" 24 #else 25 #include "draw/canvas.h" 26 #include "draw/surface.h" 27 #include "utils/matrix.h" 28 #endif 29 #include "pipeline/rs_display_render_node.h" 30 #include "pipeline/rs_effect_render_node.h" 31 #include "pipeline/rs_surface_render_node.h" 32 #include "pixel_map.h" 33 #include "rs_base_render_engine.h" 34 #include "visitor/rs_node_visitor.h" 35 36 namespace OHOS { 37 namespace Rosen { 38 class RSSurfaceCaptureVisitor : public RSNodeVisitor { 39 public: 40 RSSurfaceCaptureVisitor(float scaleX, float scaleY, bool isUniRender); 41 ~RSSurfaceCaptureVisitor() noexcept override = default; PrepareChildren(RSRenderNode & node)42 void PrepareChildren(RSRenderNode& node) override {} PrepareCanvasRenderNode(RSCanvasRenderNode & node)43 void PrepareCanvasRenderNode(RSCanvasRenderNode& node) override {} PrepareDisplayRenderNode(RSDisplayRenderNode & node)44 void PrepareDisplayRenderNode(RSDisplayRenderNode& node) override {} PrepareProxyRenderNode(RSProxyRenderNode & node)45 void PrepareProxyRenderNode(RSProxyRenderNode& node) override {} PrepareRootRenderNode(RSRootRenderNode & node)46 void PrepareRootRenderNode(RSRootRenderNode& node) override {} PrepareSurfaceRenderNode(RSSurfaceRenderNode & node)47 void PrepareSurfaceRenderNode(RSSurfaceRenderNode& node) override {} PrepareEffectRenderNode(RSEffectRenderNode & node)48 void PrepareEffectRenderNode(RSEffectRenderNode& node) override {} 49 50 void ProcessChildren(RSRenderNode& node) override; 51 void ProcessCanvasRenderNode(RSCanvasRenderNode& node) override; 52 void ProcessDisplayRenderNode(RSDisplayRenderNode& node) override; ProcessProxyRenderNode(RSProxyRenderNode & node)53 void ProcessProxyRenderNode(RSProxyRenderNode& node) override {} 54 void ProcessRootRenderNode(RSRootRenderNode& node) override; 55 void ProcessSurfaceRenderNode(RSSurfaceRenderNode& node) override; 56 void ProcessEffectRenderNode(RSEffectRenderNode& node) override; 57 58 #ifndef USE_ROSEN_DRAWING 59 void SetSurface(SkSurface* surface); 60 #else 61 void SetSurface(Drawing::Surface* surface); 62 #endif IsDisplayNode(bool isDisplayNode)63 void IsDisplayNode(bool isDisplayNode) 64 { 65 isDisplayNode_ = isDisplayNode; 66 } 67 IsUniRender()68 bool IsUniRender() const 69 { 70 return isUniRender_; 71 } 72 GetHasingSecurityLayer()73 bool GetHasingSecurityLayer() const 74 { 75 return hasSecurityLayer_; 76 } 77 SetHasingSecurityLayer(const bool & hasSecurityLayer)78 void SetHasingSecurityLayer(const bool &hasSecurityLayer) 79 { 80 hasSecurityLayer_ = hasSecurityLayer; 81 } 82 83 private: 84 void ProcessSurfaceRenderNodeWithUni(RSSurfaceRenderNode& node); 85 void CaptureSingleSurfaceNodeWithUni(RSSurfaceRenderNode& node); 86 void CaptureSurfaceInDisplayWithUni(RSSurfaceRenderNode& node); 87 void ProcessSurfaceRenderNodeWithoutUni(RSSurfaceRenderNode& node); 88 void CaptureSingleSurfaceNodeWithoutUni(RSSurfaceRenderNode& node); 89 void CaptureSurfaceInDisplayWithoutUni(RSSurfaceRenderNode& node); 90 void DrawWatermarkIfNeed(float screenWidth, float screenHeight); 91 void FindHardwareEnabledNodes(); 92 void AdjustZOrderAndDrawSurfaceNode(); 93 std::unique_ptr<RSPaintFilterCanvas> canvas_ = nullptr; 94 bool isDisplayNode_ = false; 95 float scaleX_ = 1.0f; 96 float scaleY_ = 1.0f; 97 bool isUniRender_ = false; 98 bool hasSecurityLayer_ = false; 99 bool isUIFirst_ = false; 100 101 #ifndef USE_ROSEN_DRAWING 102 SkMatrix captureMatrix_ = SkMatrix::I(); 103 #else 104 Drawing::Matrix captureMatrix_ = Drawing::Matrix(); 105 #endif 106 107 std::shared_ptr<RSBaseRenderEngine> renderEngine_; 108 109 std::vector<std::shared_ptr<RSSurfaceRenderNode>> hardwareEnabledNodes_; 110 }; 111 112 class RSSurfaceCaptureTask { 113 public: RSSurfaceCaptureTask(NodeId nodeId,float scaleX,float scaleY)114 explicit RSSurfaceCaptureTask(NodeId nodeId, float scaleX, float scaleY) 115 : nodeId_(nodeId), scaleX_(scaleX), scaleY_(scaleY) {} 116 ~RSSurfaceCaptureTask() = default; 117 118 std::unique_ptr<Media::PixelMap> Run(); 119 120 private: 121 std::shared_ptr<RSSurfaceCaptureVisitor> visitor_ = nullptr; 122 123 #ifndef USE_ROSEN_DRAWING 124 sk_sp<SkSurface> CreateSurface(const std::unique_ptr<Media::PixelMap>& pixelmap); 125 bool CopyDataToPixelMap(sk_sp<SkImage> img, const std::unique_ptr<Media::PixelMap>& pixelmap); 126 #else 127 std::shared_ptr<Drawing::Surface> CreateSurface(const std::unique_ptr<Media::PixelMap>& pixelmap); 128 #endif 129 130 std::unique_ptr<Media::PixelMap> CreatePixelMapBySurfaceNode(std::shared_ptr<RSSurfaceRenderNode> node, 131 bool isUniRender = false); 132 133 std::unique_ptr<Media::PixelMap> CreatePixelMapByDisplayNode(std::shared_ptr<RSDisplayRenderNode> node, 134 bool isUniRender = false, bool hasSecurityLayer = false); 135 136 bool FindSecurityLayer(); 137 138 NodeId nodeId_; 139 140 float scaleX_; 141 142 float scaleY_; 143 }; 144 } // namespace Rosen 145 } // namespace OHOS 146 147 #endif // RS_SURFACE_CAPTURE_TASK 148