1 /*
2 * Copyright (c) 2022-2024 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 "distributed_camera_constants.h"
17 #include "distributed_camera_errno.h"
18 #include "distributed_hardware_log.h"
19 #include "scale_convert_process.h"
20 #include "dcamera_frame_info.h"
21
22 namespace OHOS {
23 namespace DistributedHardware {
24
25 const int32_t MAX_IMG_SIZE = 46340;
~ScaleConvertProcess()26 ScaleConvertProcess::~ScaleConvertProcess()
27 {
28 DumpFileUtil::CloseDumpFile(&dumpFile_);
29 if (isScaleConvert_.load()) {
30 DHLOGI("~ScaleConvertProcess : ReleaseProcessNode");
31 ReleaseProcessNode();
32 }
33 }
34
InitNode(const VideoConfigParams & sourceConfig,const VideoConfigParams & targetConfig,VideoConfigParams & processedConfig)35 int32_t ScaleConvertProcess::InitNode(const VideoConfigParams& sourceConfig, const VideoConfigParams& targetConfig,
36 VideoConfigParams& processedConfig)
37 {
38 DHLOGI("ScaleConvertProcess : InitNode.");
39 sourceConfig_ = sourceConfig;
40 targetConfig_ = targetConfig;
41 processedConfig_ = sourceConfig;
42 processedConfig_.SetWidthAndHeight(targetConfig.GetWidth(), targetConfig.GetHeight());
43 processedConfig_.SetVideoformat(targetConfig.GetVideoformat());
44 processedConfig = processedConfig_;
45
46 if (!IsConvertible(sourceConfig, targetConfig)) {
47 DHLOGI("sourceConfig: Videoformat %{public}d Width %{public}d, Height %{public}d, targetConfig: "
48 "Videoformat %{public}d Width %{public}d, Height %{public}d.",
49 sourceConfig.GetVideoformat(), sourceConfig.GetWidth(), sourceConfig.GetHeight(),
50 targetConfig.GetVideoformat(), targetConfig.GetWidth(), targetConfig.GetHeight());
51 isScaleConvert_.store(true);
52 return DCAMERA_OK;
53 }
54
55 int32_t ret = av_image_alloc(srcData_, srcLineSize_, sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
56 GetAVPixelFormat(sourceConfig_.GetVideoformat()), SOURCE_ALIGN);
57 if (ret < DCAMERA_OK) {
58 DHLOGE("Could not allocate source image.");
59 return DCAMERA_BAD_VALUE;
60 }
61
62 dstBuffSize_ = av_image_alloc(dstData_, dstLineSize_, processedConfig_.GetWidth(), processedConfig_.GetHeight(),
63 GetAVPixelFormat(processedConfig_.GetVideoformat()), TARGET_ALIGN);
64 if (dstBuffSize_ < DCAMERA_OK) {
65 DHLOGE("Could not allocate destination image.");
66 return DCAMERA_BAD_VALUE;
67 }
68
69 swsContext_ = sws_getContext(sourceConfig_.GetWidth(), sourceConfig_.GetHeight(),
70 GetAVPixelFormat(sourceConfig_.GetVideoformat()), processedConfig_.GetWidth(), processedConfig_.GetHeight(),
71 GetAVPixelFormat(processedConfig_.GetVideoformat()), SWS_FAST_BILINEAR, nullptr, nullptr, nullptr);
72 if (swsContext_ == nullptr) {
73 DHLOGE("Create SwsContext failed.");
74 return DCAMERA_BAD_VALUE;
75 }
76
77 isScaleConvert_.store(true);
78 return DCAMERA_OK;
79 }
80
IsConvertible(const VideoConfigParams & sourceConfig,const VideoConfigParams & targetConfig)81 bool ScaleConvertProcess::IsConvertible(const VideoConfigParams& sourceConfig, const VideoConfigParams& targetConfig)
82 {
83 return (sourceConfig_.GetWidth() != targetConfig.GetWidth()) ||
84 (sourceConfig_.GetHeight() != targetConfig.GetHeight()) ||
85 (sourceConfig_.GetVideoformat() != targetConfig.GetVideoformat());
86 }
87
ReleaseProcessNode()88 void ScaleConvertProcess::ReleaseProcessNode()
89 {
90 DHLOGI("Start release [%{public}zu] node : ScaleConvertNode.", nodeRank_);
91 isScaleConvert_.store(false);
92
93 {
94 std::lock_guard<std::mutex> autoLock(scaleMutex_);
95 if (swsContext_ != nullptr) {
96 av_freep(&srcData_[0]);
97 av_freep(&dstData_[0]);
98 sws_freeContext(swsContext_);
99 swsContext_ = nullptr;
100 }
101 }
102
103 if (nextDataProcess_ != nullptr) {
104 nextDataProcess_->ReleaseProcessNode();
105 nextDataProcess_ = nullptr;
106 }
107 DHLOGI("Release [%{public}zu] node : ScaleConvertNode end.", nodeRank_);
108 }
109
ProcessData(std::vector<std::shared_ptr<DataBuffer>> & inputBuffers)110 int ScaleConvertProcess::ProcessData(std::vector<std::shared_ptr<DataBuffer>>& inputBuffers)
111 {
112 int64_t startScaleTime = GetNowTimeStampUs();
113 DHLOGD("Process data in ScaleConvertProcess.");
114 if (!isScaleConvert_.load()) {
115 DHLOGE("Scale Convert node occurred error or start release.");
116 return DCAMERA_DISABLE_PROCESS;
117 }
118
119 if (inputBuffers.empty() || inputBuffers[0] == nullptr) {
120 DHLOGE("The input data buffers is empty.");
121 return DCAMERA_BAD_VALUE;
122 }
123 inputBuffers[0]->frameInfo_.timePonit.startScale = startScaleTime;
124 DumpFileUtil::OpenDumpFile(DUMP_SERVER_PARA, DUMP_DCAMERA_AFTER_SCALE_FILENAME, &dumpFile_);
125
126 if (!IsConvertible(sourceConfig_, processedConfig_)) {
127 DHLOGD("The target resolution: %{public}dx%{public}d format: %{public}d is the same as the source "
128 "resolution: %{public}dx%{public}d format: %{public}d",
129 processedConfig_.GetWidth(), processedConfig_.GetHeight(), processedConfig_.GetVideoformat(),
130 sourceConfig_.GetWidth(), sourceConfig_.GetHeight(), sourceConfig_.GetVideoformat());
131 return ConvertDone(inputBuffers);
132 }
133
134 ImageUnitInfo srcImgInfo {Videoformat::YUVI420, 0, 0, 0, 0, 0, 0, nullptr};
135 if ((GetImageUnitInfo(srcImgInfo, inputBuffers[0]) != DCAMERA_OK) || !CheckScaleProcessInputInfo(srcImgInfo)) {
136 DHLOGE("ScaleConvertProcess : srcImgInfo error.");
137 return DCAMERA_BAD_VALUE;
138 }
139
140 std::shared_ptr<DataBuffer> dstBuf = std::make_shared<DataBuffer>(dstBuffSize_);
141 ImageUnitInfo dstImgInfo = { processedConfig_.GetVideoformat(), processedConfig_.GetWidth(),
142 processedConfig_.GetHeight(), processedConfig_.GetWidth(), processedConfig_.GetHeight(),
143 processedConfig_.GetWidth() * processedConfig_.GetHeight(), dstBuf->Size(), dstBuf };
144 if (ScaleConvert(srcImgInfo, dstImgInfo) != DCAMERA_OK) {
145 DHLOGE("ScaleConvertProcess : Scale convert failed.");
146 return DCAMERA_BAD_OPERATE;
147 }
148
149 dstBuf->frameInfo_ = inputBuffers[0]->frameInfo_;
150 dstBuf->SetInt32("Videoformat", static_cast<int32_t>(processedConfig_.GetVideoformat()));
151 dstBuf->SetInt32("alignedWidth", processedConfig_.GetWidth());
152 dstBuf->SetInt32("alignedHeight", processedConfig_.GetHeight());
153 dstBuf->SetInt32("width", processedConfig_.GetWidth());
154 dstBuf->SetInt32("height", processedConfig_.GetHeight());
155
156 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(dstBuf->Data()), dstBuf->Size());
157 std::vector<std::shared_ptr<DataBuffer>> outputBuffers;
158 outputBuffers.push_back(dstBuf);
159 return ConvertDone(outputBuffers);
160 }
161
GetImageUnitInfo(ImageUnitInfo & imgInfo,const std::shared_ptr<DataBuffer> & imgBuf)162 int32_t ScaleConvertProcess::GetImageUnitInfo(ImageUnitInfo& imgInfo, const std::shared_ptr<DataBuffer>& imgBuf)
163 {
164 if (imgBuf == nullptr) {
165 DHLOGE("GetImageUnitInfo failed, imgBuf is nullptr.");
166 return DCAMERA_BAD_VALUE;
167 }
168
169 if (imgInfo.alignedWidth > MAX_IMG_SIZE && imgInfo.alignedHeight > MAX_IMG_SIZE) {
170 DHLOGE("imgInfo aligned width and height out of range");
171 return DCAMERA_BAD_VALUE;
172 }
173
174 bool findErr = true;
175 int32_t colorFormat = 0;
176 findErr = findErr && imgBuf->FindInt32("Videoformat", colorFormat);
177 if (!findErr) {
178 DHLOGE("GetImageUnitInfo failed, Videoformat is null.");
179 return DCAMERA_NOT_FOUND;
180 }
181
182 if (colorFormat != static_cast<int32_t>(Videoformat::YUVI420) &&
183 colorFormat != static_cast<int32_t>(Videoformat::NV12) &&
184 colorFormat != static_cast<int32_t>(Videoformat::NV21)) {
185 DHLOGE("GetImageUnitInfo failed, colorFormat %{public}d are not supported.", colorFormat);
186 return DCAMERA_NOT_FOUND;
187 }
188 imgInfo.colorFormat = static_cast<Videoformat>(colorFormat);
189 findErr = findErr && imgBuf->FindInt32("width", imgInfo.width);
190 findErr = findErr && imgBuf->FindInt32("height", imgInfo.height);
191 findErr = findErr && imgBuf->FindInt32("alignedWidth", imgInfo.alignedWidth);
192 findErr = findErr && imgBuf->FindInt32("alignedHeight", imgInfo.alignedHeight);
193 if (!findErr) {
194 DHLOGE("GetImageUnitInfo failed, width %{public}d, height %{public}d, alignedWidth %{public}d, "
195 "alignedHeight %{public}d.", imgInfo.width, imgInfo.height, imgInfo.alignedWidth, imgInfo.alignedHeight);
196 return DCAMERA_NOT_FOUND;
197 }
198
199 imgInfo.chromaOffset = static_cast<size_t>(imgInfo.alignedWidth * imgInfo.alignedHeight);
200 imgInfo.imgSize = imgBuf->Size();
201 imgInfo.imgData = imgBuf;
202 if (imgInfo.imgData == nullptr) {
203 DHLOGE("Get the imgData of the imgBuf failed.");
204 return DCAMERA_BAD_VALUE;
205 }
206 DHLOGD("ScaleConvertProcess imgBuf info : Videoformat %{public}d, alignedWidth %{public}d, alignedHeight "
207 "%{public}d, width %{public}d, height %{public}d, chromaOffset %{public}zu, imgSize %{public}zu.",
208 imgInfo.colorFormat, imgInfo.alignedWidth, imgInfo.alignedHeight,
209 imgInfo.width, imgInfo.height, imgInfo.chromaOffset, imgInfo.imgSize);
210 return DCAMERA_OK;
211 }
212
CheckScaleProcessInputInfo(const ImageUnitInfo & srcImgInfo)213 bool ScaleConvertProcess::CheckScaleProcessInputInfo(const ImageUnitInfo& srcImgInfo)
214 {
215 return srcImgInfo.colorFormat == sourceConfig_.GetVideoformat() &&
216 srcImgInfo.width == sourceConfig_.GetWidth() &&
217 srcImgInfo.height == sourceConfig_.GetHeight() &&
218 IsCorrectImageUnitInfo(srcImgInfo);
219 }
220
CheckScaleConvertInfo(const ImageUnitInfo & srcImgInfo,const ImageUnitInfo & dstImgInfo)221 bool ScaleConvertProcess::CheckScaleConvertInfo(const ImageUnitInfo& srcImgInfo, const ImageUnitInfo& dstImgInfo)
222 {
223 if (srcImgInfo.imgData == nullptr || dstImgInfo.imgData == nullptr) {
224 DHLOGE("The imgData of srcImgInfo or the imgData of dstImgInfo are null!");
225 return false;
226 }
227
228 if (!IsCorrectImageUnitInfo(srcImgInfo)) {
229 DHLOGE("srcImginfo fail: width %{public}d, height %{public}d, alignedWidth %{public}d, alignedHeight "
230 "%{public}d, chromaOffset %{public}zu, imgSize %{public}zu.", srcImgInfo.width, srcImgInfo.height,
231 srcImgInfo.alignedWidth, srcImgInfo.alignedHeight, srcImgInfo.chromaOffset, srcImgInfo.imgSize);
232 return false;
233 }
234
235 if (!IsCorrectImageUnitInfo(dstImgInfo)) {
236 DHLOGE("dstImginfo fail: width %{public}d, height %{public}d, alignedWidth %{public}d, alignedHeight "
237 "%{public}d, chromaOffset %{public}zu, imgSize %{public}zu.", dstImgInfo.width, dstImgInfo.height,
238 dstImgInfo.alignedWidth, dstImgInfo.alignedHeight, dstImgInfo.chromaOffset, dstImgInfo.imgSize);
239 return false;
240 }
241
242 if ((dstImgInfo.width == srcImgInfo.alignedWidth) && (dstImgInfo.height == srcImgInfo.alignedHeight) &&
243 (dstImgInfo.colorFormat == srcImgInfo.colorFormat)) {
244 DHLOGE("Comparison ImgInfo fail: dstwidth %{public}d, dstheight %{public}d, srcAlignedWidth %{public}d, "
245 "srcAlignedHeight %{public}d.", dstImgInfo.width, dstImgInfo.height, srcImgInfo.alignedWidth,
246 srcImgInfo.alignedHeight);
247 return false;
248 }
249
250 return true;
251 }
252
IsCorrectImageUnitInfo(const ImageUnitInfo & imgInfo)253 bool ScaleConvertProcess::IsCorrectImageUnitInfo(const ImageUnitInfo& imgInfo)
254 {
255 size_t expectedImgSize = static_cast<size_t>(imgInfo.alignedWidth * imgInfo.alignedHeight *
256 YUV_BYTES_PER_PIXEL / Y2UV_RATIO);
257 size_t expectedChromaOffset = static_cast<size_t>(imgInfo.alignedWidth * imgInfo.alignedHeight);
258 return (imgInfo.width <= imgInfo.alignedWidth && imgInfo.height <= imgInfo.alignedHeight &&
259 imgInfo.imgSize >= expectedImgSize && imgInfo.chromaOffset == expectedChromaOffset);
260 }
261
ScaleConvert(ImageUnitInfo & srcImgInfo,ImageUnitInfo & dstImgInfo)262 int32_t ScaleConvertProcess::ScaleConvert(ImageUnitInfo& srcImgInfo, ImageUnitInfo& dstImgInfo)
263 {
264 DHLOGD("ScaleConvertProcess : Scale convert start.");
265 if (!CheckScaleConvertInfo(srcImgInfo, dstImgInfo)) {
266 DHLOGE("ScaleConvertProcess : CheckScaleConvertInfo failed.");
267 return DCAMERA_BAD_VALUE;
268 }
269
270 std::lock_guard<std::mutex> autoLock(scaleMutex_);
271 switch (GetAVPixelFormat(srcImgInfo.colorFormat)) {
272 case AV_PIX_FMT_YUV420P: {
273 int32_t ret = CopyYUV420SrcData(srcImgInfo);
274 if (ret != DCAMERA_OK) {
275 DHLOGE("ScaleConvertProcess::ScaleConvert copy yuv420p src data failed.");
276 return ret;
277 }
278 break;
279 }
280 case AV_PIX_FMT_NV12: {
281 int32_t ret = CopyNV12SrcData(srcImgInfo);
282 if (ret != DCAMERA_OK) {
283 DHLOGE("ScaleConvertProcess::ScaleConvert copy nv12 src data failed.");
284 return ret;
285 }
286 break;
287 }
288 case AV_PIX_FMT_NV21: {
289 int32_t ret = CopyNV21SrcData(srcImgInfo);
290 if (ret != DCAMERA_OK) {
291 DHLOGE("ScaleConvertProcess::ScaleConvert copy nv21 src data failed.");
292 return ret;
293 }
294 break;
295 }
296 default:
297 DHLOGE("Unknown pixel format not support.");
298 return DCAMERA_BAD_VALUE;
299 }
300
301 sws_scale(swsContext_, static_cast<const uint8_t * const *>(srcData_), srcLineSize_, 0, srcImgInfo.height,
302 dstData_, dstLineSize_);
303 int32_t ret = memcpy_s(dstImgInfo.imgData->Data(), dstImgInfo.imgSize, dstData_[0], dstBuffSize_);
304 if (ret != EOK) {
305 DHLOGE("ScaleConvertProcess::ScaleConvert copy dst image info failed, ret = %{public}d", ret);
306 return DCAMERA_MEMORY_OPT_ERROR;
307 }
308 return DCAMERA_OK;
309 }
310
CopyYUV420SrcData(const ImageUnitInfo & srcImgInfo)311 int32_t ScaleConvertProcess::CopyYUV420SrcData(const ImageUnitInfo& srcImgInfo)
312 {
313 CHECK_AND_RETURN_RET_LOG((srcImgInfo.imgData == nullptr), DCAMERA_BAD_VALUE, "Data buffer exists null data");
314 int32_t ret = memcpy_s(srcData_[0], srcImgInfo.width * srcImgInfo.height,
315 srcImgInfo.imgData->Data(), srcImgInfo.width * srcImgInfo.height);
316 if (ret != EOK) {
317 DHLOGE("ScaleConvertProcess::CopyYUV420SrcData memory copy failed, ret = %{public}d", ret);
318 return DCAMERA_MEMORY_OPT_ERROR;
319 }
320
321 ret = memcpy_s(srcData_[1], srcImgInfo.width * srcImgInfo.height / MEMORY_RATIO_YUV,
322 srcImgInfo.imgData->Data() + srcImgInfo.alignedWidth * srcImgInfo.alignedHeight,
323 srcImgInfo.width * srcImgInfo.height / MEMORY_RATIO_YUV);
324 if (ret != EOK) {
325 DHLOGE("ScaleConvertProcess::CopyYUV420SrcData memory copy failed, ret = %{public}d", ret);
326 return DCAMERA_MEMORY_OPT_ERROR;
327 }
328
329 ret = memcpy_s(srcData_[2], srcImgInfo.width * srcImgInfo.height / MEMORY_RATIO_YUV, // 2: v start address
330 srcImgInfo.imgData->Data() + srcImgInfo.alignedWidth * srcImgInfo.alignedHeight +
331 srcImgInfo.alignedWidth * srcImgInfo.alignedHeight / MEMORY_RATIO_YUV,
332 srcImgInfo.width * srcImgInfo.height / MEMORY_RATIO_YUV);
333 if (ret != EOK) {
334 DHLOGE("ScaleConvertProcess::CopyYUV420SrcData memory copy failed, ret = %{public}d", ret);
335 return DCAMERA_MEMORY_OPT_ERROR;
336 }
337 return DCAMERA_OK;
338 }
339
CopyNV12SrcData(const ImageUnitInfo & srcImgInfo)340 int32_t ScaleConvertProcess::CopyNV12SrcData(const ImageUnitInfo& srcImgInfo)
341 {
342 CHECK_AND_RETURN_RET_LOG((srcImgInfo.imgData == nullptr), DCAMERA_BAD_VALUE, "Data buffer exists null data");
343 int32_t ret = memcpy_s(srcData_[0], srcImgInfo.width * srcImgInfo.height,
344 srcImgInfo.imgData->Data(), srcImgInfo.width * srcImgInfo.height);
345 if (ret != EOK) {
346 DHLOGE("ScaleConvertProcess::CopyNV12SrcData memory copy failed, ret = %{public}d", ret);
347 return DCAMERA_MEMORY_OPT_ERROR;
348 }
349
350 ret = memcpy_s(srcData_[1], srcImgInfo.width * srcImgInfo.height / MEMORY_RATIO_NV,
351 srcImgInfo.imgData->Data() + srcImgInfo.alignedWidth * srcImgInfo.alignedHeight,
352 srcImgInfo.width * srcImgInfo.height / MEMORY_RATIO_NV);
353 if (ret != EOK) {
354 DHLOGE("ScaleConvertProcess::CopyNV12SrcData memory copy failed, ret = %{public}d", ret);
355 return DCAMERA_MEMORY_OPT_ERROR;
356 }
357 return DCAMERA_OK;
358 }
359
CopyNV21SrcData(const ImageUnitInfo & srcImgInfo)360 int32_t ScaleConvertProcess::CopyNV21SrcData(const ImageUnitInfo& srcImgInfo)
361 {
362 CHECK_AND_RETURN_RET_LOG((srcImgInfo.imgData == nullptr), DCAMERA_BAD_VALUE, "Data buffer exists null data");
363 int32_t ret = memcpy_s(srcData_[0], srcImgInfo.width * srcImgInfo.height,
364 srcImgInfo.imgData->Data(), srcImgInfo.width * srcImgInfo.height);
365 if (ret != EOK) {
366 DHLOGE("ScaleConvertProcess::CopyNV21SrcData memory copy failed, ret = %{public}d", ret);
367 return DCAMERA_MEMORY_OPT_ERROR;
368 }
369
370 ret = memcpy_s(srcData_[1], srcImgInfo.width * srcImgInfo.height / MEMORY_RATIO_NV,
371 srcImgInfo.imgData->Data() + srcImgInfo.alignedWidth * srcImgInfo.alignedHeight,
372 srcImgInfo.width * srcImgInfo.height / MEMORY_RATIO_NV);
373 if (ret != EOK) {
374 DHLOGE("ScaleConvertProcess::CopyNV21SrcData memory copy failed, ret = %{public}d", ret);
375 return DCAMERA_MEMORY_OPT_ERROR;
376 }
377 return DCAMERA_OK;
378 }
379
ConvertDone(std::vector<std::shared_ptr<DataBuffer>> & outputBuffers)380 int32_t ScaleConvertProcess::ConvertDone(std::vector<std::shared_ptr<DataBuffer>>& outputBuffers)
381 {
382 int64_t finishScaleTime = GetNowTimeStampUs();
383 DHLOGD("ScaleConvertProcess : Convert Done.");
384 if (outputBuffers.empty() || outputBuffers[0] == nullptr) {
385 DHLOGE("The received data buffer is empty.");
386 return DCAMERA_BAD_VALUE;
387 }
388 outputBuffers[0]->frameInfo_.timePonit.finishScale = finishScaleTime;
389
390 if (nextDataProcess_ != nullptr) {
391 DHLOGD("Send to the next node of the scale convert for processing.");
392 int32_t err = nextDataProcess_->ProcessData(outputBuffers);
393 if (err != DCAMERA_OK) {
394 DHLOGE("Some node after the scale convert processes failed.");
395 }
396 return err;
397 }
398
399 DHLOGD("The current node is the last noed, and output the processed video buffer.");
400 std::shared_ptr<DCameraPipelineSource> targetPipelineSource = callbackPipelineSource_.lock();
401 if (targetPipelineSource == nullptr) {
402 DHLOGE("callbackPipelineSource_ is nullptr.");
403 return DCAMERA_BAD_VALUE;
404 }
405 targetPipelineSource->OnProcessedVideoBuffer(outputBuffers[0]);
406 return DCAMERA_OK;
407 }
408
GetAVPixelFormat(Videoformat colorFormat)409 AVPixelFormat ScaleConvertProcess::GetAVPixelFormat(Videoformat colorFormat)
410 {
411 AVPixelFormat format;
412 switch (colorFormat) {
413 case Videoformat::NV12:
414 format = AVPixelFormat::AV_PIX_FMT_NV12;
415 break;
416 case Videoformat::NV21:
417 format = AVPixelFormat::AV_PIX_FMT_NV21;
418 break;
419 case Videoformat::RGBA_8888:
420 format = AVPixelFormat::AV_PIX_FMT_RGBA;
421 break;
422 default:
423 format = AVPixelFormat::AV_PIX_FMT_YUV420P;
424 break;
425 }
426 return format;
427 }
428
GetProperty(const std::string & propertyName,PropertyCarrier & propertyCarrier)429 int32_t ScaleConvertProcess::GetProperty(const std::string& propertyName, PropertyCarrier& propertyCarrier)
430 {
431 return DCAMERA_OK;
432 }
433 } // namespace DistributedHardware
434 } // namespace OHOS
435