1 /*
2 * Copyright (c) 2021 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 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
12 */
13
14 #include "rk_scale_node.h"
15 #include <securec.h>
16
17 namespace OHOS::Camera {
RKScaleNode(const std::string & name,const std::string & type,const std::string & cameraId)18 RKScaleNode::RKScaleNode(const std::string& name, const std::string& type, const std::string &cameraId)
19 : NodeBase(name, type, cameraId)
20 {
21 CAMERA_LOGV("%{public}s enter, type(%{public}s)\n", name_.c_str(), type_.c_str());
22 }
23
~RKScaleNode()24 RKScaleNode::~RKScaleNode()
25 {
26 CAMERA_LOGI("~RKScaleNode Node exit.");
27 }
28
Start(const int32_t streamId)29 RetCode RKScaleNode::Start(const int32_t streamId)
30 {
31 CAMERA_LOGI("RKScaleNode::Start streamId = %{public}d\n", streamId);
32 uint64_t bufferPoolId = 0;
33
34 outPutPorts_ = GetOutPorts();
35 for (auto& out : outPutPorts_) {
36 bufferPoolId = out->format_.bufferPoolId_;
37 }
38
39 BufferManager* bufferManager = Camera::BufferManager::GetInstance();
40 if (bufferManager == nullptr) {
41 CAMERA_LOGE("scale buffer get instance failed");
42 return RC_ERROR;
43 }
44
45 bufferPool_ = bufferManager->GetBufferPool(bufferPoolId);
46 if (bufferPool_ == nullptr) {
47 CAMERA_LOGE("get bufferpool failed: %{public}zu", bufferPoolId);
48 return RC_ERROR;
49 }
50 return RC_OK;
51 }
52
Stop(const int32_t streamId)53 RetCode RKScaleNode::Stop(const int32_t streamId)
54 {
55 CAMERA_LOGI("RKScaleNode::Stop streamId = %{public}d\n", streamId);
56 return RC_OK;
57 }
58
Flush(const int32_t streamId)59 RetCode RKScaleNode::Flush(const int32_t streamId)
60 {
61 CAMERA_LOGI("RKScaleNode::Flush streamId = %{public}d\n", streamId);
62 return RC_OK;
63 }
64
PreviewScaleConver(std::shared_ptr<IBuffer> & buffer)65 void RKScaleNode::PreviewScaleConver(std::shared_ptr<IBuffer>& buffer)
66 {
67 if (buffer == nullptr) {
68 CAMERA_LOGE("RKScaleNode::PreviewScaleConver buffer == nullptr");
69 return;
70 }
71
72 int dma_fd = buffer->GetFileDescriptor();
73 uint8_t* temp = (uint8_t *)buffer->GetVirAddress();
74
75 std::map<int32_t, uint8_t*> sizeVirMap = bufferPool_->getSFBuffer(buffer->GetIndex());
76 if (sizeVirMap.empty()) {
77 return;
78 }
79 uint8_t* virBUffer = sizeVirMap.begin()->second;
80 int32_t virSize = sizeVirMap.begin()->first;
81 buffer->SetVirAddress(virBUffer);
82 buffer->SetSize(virSize);
83
84 RockchipRga rkRga;
85
86 rga_info_t src = {};
87 rga_info_t dst = {};
88
89 src.fd = -1;
90 src.mmuFlag = 1;
91 src.rotation = 0;
92 src.virAddr = (void *)temp;
93
94 dst.fd = dma_fd;
95 dst.mmuFlag = 1;
96 dst.virAddr = 0;
97
98 rga_set_rect(&src.rect, 0, 0, wide_, high_, wide_, high_, RK_FORMAT_YCbCr_420_P);
99 rga_set_rect(&dst.rect, 0, 0, buffer->GetWidth(), buffer->GetHeight(),
100 buffer->GetWidth(), buffer->GetHeight(), RK_FORMAT_YCbCr_420_P);
101
102 rkRga.RkRgaBlit(&src, &dst, NULL);
103 rkRga.RkRgaFlush();
104 }
105
ScaleConver(std::shared_ptr<IBuffer> & buffer)106 void RKScaleNode::ScaleConver(std::shared_ptr<IBuffer>& buffer)
107 {
108 if (buffer == nullptr) {
109 CAMERA_LOGE("RKScaleNode::ScaleConver buffer == nullptr");
110 return;
111 }
112
113 int dma_fd = buffer->GetFileDescriptor();
114
115 std::map<int32_t, uint8_t*> sizeVirMap = bufferPool_->getSFBuffer(bufferPool_->GetForkBufferId());
116 if (sizeVirMap.empty()) {
117 CAMERA_LOGE("RKScaleNode::ScaleConver sizeVirMap buffer == nullptr");
118 return;
119 }
120 uint8_t* temp = sizeVirMap.begin()->second;
121
122 RockchipRga rkRga;
123
124 rga_info_t src = {};
125 rga_info_t dst = {};
126
127 src.fd = -1;
128 src.mmuFlag = 1;
129 src.rotation = 0;
130 src.virAddr = (void *)temp;
131
132 dst.fd = dma_fd;
133 dst.mmuFlag = 1;
134 dst.virAddr = 0;
135
136 rga_set_rect(&src.rect, 0, 0, wide_, high_, wide_, high_, RK_FORMAT_YCbCr_420_P);
137 rga_set_rect(&dst.rect, 0, 0, buffer->GetWidth(), buffer->GetHeight(),
138 buffer->GetWidth(), buffer->GetHeight(), RK_FORMAT_YCbCr_420_P);
139
140 rkRga.RkRgaBlit(&src, &dst, NULL);
141 rkRga.RkRgaFlush();
142 }
143
DeliverBuffer(std::shared_ptr<IBuffer> & buffer)144 void RKScaleNode::DeliverBuffer(std::shared_ptr<IBuffer>& buffer)
145 {
146 if (buffer == nullptr) {
147 CAMERA_LOGE("RKScaleNode::DeliverBuffer frameSpec is null");
148 return;
149 }
150
151 int32_t id = buffer->GetStreamId();
152 CAMERA_LOGI("RKScaleNode::DeliverBuffer StreamId %{public}d", id);
153
154 if (bufferPool_->GetForkBufferId() != -1) {
155 if (bufferPool_->GetIsFork() == true) {
156 ScaleConver(buffer);
157 } else {
158 PreviewScaleConver(buffer);
159 }
160 }
161
162 std::vector<std::shared_ptr<IPort>> outPutPorts_;
163 outPutPorts_ = GetOutPorts();
164 for (auto& it : outPutPorts_) {
165 if (it->format_.streamId_ == id) {
166 it->DeliverBuffer(buffer);
167 CAMERA_LOGI("RKScaleNode deliver buffer streamid = %{public}d", it->format_.streamId_);
168 return;
169 }
170 }
171 }
172
Capture(const int32_t streamId,const int32_t captureId)173 RetCode RKScaleNode::Capture(const int32_t streamId, const int32_t captureId)
174 {
175 CAMERA_LOGV("RKScaleNode::Capture");
176 return RC_OK;
177 }
178
CancelCapture(const int32_t streamId)179 RetCode RKScaleNode::CancelCapture(const int32_t streamId)
180 {
181 CAMERA_LOGI("RKScaleNode::CancelCapture streamid = %{public}d", streamId);
182
183 return RC_OK;
184 }
185
186 REGISTERNODE(RKScaleNode, {"RKScale"})
187 } // namespace OHOS::Camera
188