1 /*
2 * Copyright (c) 2025 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 #include "rs_trace.h"
17 #include "platform/common/rs_log.h"
18 #include "memory/rs_tag_tracker.h"
19 #include "pipeline/main_thread/rs_main_thread.h"
20 #include "pipeline/main_thread/rs_uni_render_listener.h"
21 #include "pipeline/render_thread/rs_uni_render_thread.h"
22 #include "pipeline/render_thread/rs_uni_render_util.h"
23 #include "pipeline/rs_paint_filter_canvas.h"
24 #include "pipeline/rs_surface_handler.h"
25 #include "rs_hetero_hdr_util.h"
26 #ifdef RS_ENABLE_VK
27 #include "platform/ohos/backend/rs_surface_ohos_vulkan.h"
28 #endif
29
30 namespace OHOS::Rosen::DrawableV2 {
RSHDRBUfferLayer(const std::string & name,NodeId layerId)31 RSHDRBUfferLayer::RSHDRBUfferLayer(const std::string& name, NodeId layerId)
32 : surfaceHandler_(std::make_shared<RSSurfaceHandler>(layerId))
33 {
34 layerName_ = name;
35 }
36
~RSHDRBUfferLayer()37 RSHDRBUfferLayer::~RSHDRBUfferLayer()
38 {
39 }
40
PrepareHDRDstBuffer(RSSurfaceRenderParams * surfaceParams,ScreenId screenId)41 sptr<SurfaceBuffer> RSHDRBUfferLayer::PrepareHDRDstBuffer(RSSurfaceRenderParams *surfaceParams, ScreenId screenId)
42 {
43 auto layerTransform = surfaceParams->GetLayerInfo().transformType;
44 int realRotation = RSBaseRenderUtil::RotateEnumToInt(RSBaseRenderUtil::GetRotateTransform(layerTransform));
45 RS_LOGE("Yaolin GetTransform1 %{public}d", realRotation);
46 RS_TRACE_NAME_FMT("Yaolin GetTransform1 [%d]", realRotation);
47
48 ScreenInfo curScreenInfo = CreateOrGetScreenManager()->QueryScreenInfo(screenId);
49
50 BufferRequestConfig config{};
51 const int ROTATION_90 = 90;
52 const int ROTATION_270 = 270;
53 if (realRotation == ROTATION_90 || realRotation == ROTATION_270) {
54 config.width = static_cast<int32_t>(curScreenInfo.height);
55 config.height = static_cast<int32_t>(curScreenInfo.width);
56 } else {
57 config.width = static_cast<int32_t>(curScreenInfo.width);
58 config.height = static_cast<int32_t>(curScreenInfo.height);
59 }
60
61 config.strideAlignment = 0x8;
62 config.colorGamut = GRAPHIC_COLOR_GAMUT_DISPLAY_P3;
63 config.format = GRAPHIC_PIXEL_FMT_RGBA_1010102;
64 config.usage = BUFFER_USAGE_HW_RENDER | BUFFER_USAGE_HW_TEXTURE | BUFFER_USAGE_HW_COMPOSER | BUFFER_USAGE_MEM_DMA;
65 config.timeout = 0;
66
67 int32_t releaseFence = -1;
68 sptr<SurfaceBuffer> dstBuffer = RequestSurfaceBuffer(config, releaseFence);
69 if (!dstBuffer) {
70 RS_LOGE("QM: RS dstSurfaceHandler get buffer failed! ");
71 return nullptr;
72 }
73 return dstBuffer;
74 }
75
ConsumeAndUpdateBuffer()76 void RSHDRBUfferLayer::ConsumeAndUpdateBuffer()
77 {
78 if (surfaceHandler_ == nullptr) {
79 RS_LOGE("QM hdrSurfaceHandler_ is nullptr!");
80 return;
81 }
82 RSBaseRenderUtil::ConsumeAndUpdateBuffer(*surfaceHandler_);
83 RSBaseRenderUtil::ReleaseBuffer(*surfaceHandler_);
84 }
85
RequestSurfaceBuffer(BufferRequestConfig & config,int32_t & releaseFence)86 sptr<SurfaceBuffer> RSHDRBUfferLayer::RequestSurfaceBuffer(
87 BufferRequestConfig& config, int32_t &releaseFence)
88 {
89 if (!surfaceCreated_) {
90 sptr<IBufferConsumerListener> listener = new RSUniRenderListener(surfaceHandler_);
91 RS_TRACE_NAME("XXF: create layer surface");
92 if (!CreateSurface(listener)) {
93 RS_LOGE(" RSRenderLayer::CreateSurface failed");
94 return nullptr;
95 }
96 }
97
98 sptr<SurfaceBuffer> buffer = nullptr;
99 GSError ret = surface_->RequestBuffer(buffer, releaseFence, config);
100 if (ret != GSERROR_OK) {
101 RS_LOGE(" Surface RequestBuffer failed, %{public}s", GSErrorStr(ret).c_str());
102 }
103 if (buffer == nullptr) {
104 RS_LOGE(" RSRenderLayer::RequestBuffer failed");
105 }
106 return buffer;
107 }
108
109 #ifndef ROSEN_CROSS_PLATFORM
110 // reference to RSDisplayRenderNodeDrawable::CreateSurface
CreateSurface(sptr<IBufferConsumerListener> listener)111 bool RSHDRBUfferLayer::CreateSurface(sptr<IBufferConsumerListener> listener)
112 {
113 auto consumer = surfaceHandler_->GetConsumer();
114 if (consumer != nullptr && surface_ != nullptr) {
115 RS_LOGI("RSRenderLayer::CreateSurface already created, return");
116 return true;
117 }
118 consumer = IConsumerSurface::Create(layerName_);
119 if (consumer == nullptr) {
120 RS_LOGE("RSRenderLayer::CreateSurface get consumer surface fail");
121 return false;
122 }
123 SurfaceError ret = consumer->RegisterConsumerListener(listener);
124 if (ret != SURFACE_ERROR_OK) {
125 RS_LOGE("RSRenderLayer::CreateSurface RegisterConsumerListener fail");
126 return false;
127 }
128 auto producer = consumer->GetProducer();
129 surface_ = Surface::CreateSurfaceAsProducer(producer);
130 if (!surface_) {
131 RS_LOGE("RSRenderLayer::CreateSurface CreateSurfaceAsProducer fail");
132 return false;
133 }
134 surface_->SetQueueSize(BUFFER_SIZE);
135 surfaceCreated_ = true;
136 surfaceHandler_->SetConsumer(consumer);
137 return true;
138 }
139 #endif
140
FlushSurfaceBuffer(sptr<SurfaceBuffer> & buffer,int32_t acquireFence,BufferFlushConfig & flushConfig)141 void RSHDRBUfferLayer::FlushSurfaceBuffer(sptr<SurfaceBuffer> &buffer, int32_t acquireFence,
142 BufferFlushConfig &flushConfig)
143 {
144 sptr<SyncFence> acquireFenceSp(new SyncFence(acquireFence));
145 surface_->FlushBuffer(buffer, acquireFenceSp, flushConfig);
146 }
147
FlushHDRDstBuffer(sptr<SurfaceBuffer> dstBuffer)148 void RSHDRBUfferLayer::FlushHDRDstBuffer(sptr<SurfaceBuffer> dstBuffer)
149 {
150 BufferFlushConfig flushConfig;
151 flushConfig.damage = {
152 .x = 0,
153 .y = 0,
154 .w = dstBuffer->GetSurfaceBufferWidth(),
155 .h = dstBuffer->GetSurfaceBufferHeight()
156 };
157 flushConfig.timestamp = 0;
158 FlushSurfaceBuffer(dstBuffer, -1, flushConfig);
159 surfaceHandler_ = GetMutableRSSurfaceHandler();
160 return;
161 }
162 } // OHOS::Rosen
163