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 #define private public
17 #define protected public
18 #include <filesystem>
19 #include <fstream>
20 #include <gtest/gtest.h>
21 #include <gtest/hwext/gtest-multithread.h>
22 #include <iostream>
23 #include <unistd.h>
24
25 #include "buffer_packer_stream.h"
26 #include "hilog/log.h"
27 #include "hilog/log_cpp.h"
28 #include "image_format_convert.h"
29 #include "image_format_convert_utils.h"
30 #include "image_log.h"
31 #include "image_source.h"
32 #include "image_type.h"
33 #include "image_utils.h"
34 #include "media_errors.h"
35
36 using namespace testing::mt;
37 using namespace testing::ext;
38 namespace OHOS {
39 namespace Media {
40 constexpr int32_t TREE_ORIGINAL_WIDTH = 800;
41 constexpr int32_t TREE_ORIGINAL_HEIGHT = 500;
42 constexpr int32_t ODDTREE_ORIGINAL_WIDTH = 951;
43 constexpr int32_t ODDTREE_ORIGINAL_HEIGHT = 595;
44 constexpr int32_t P010_ORIGINAL_WIDTH = 1920;
45 constexpr int32_t P010_ORIGINAL_HEIGHT = 1080;
46 constexpr uint32_t BYTES_PER_PIXEL_RGB565 = 2;
47 constexpr uint32_t BYTES_PER_PIXEL_RGB = 3;
48 constexpr uint32_t BYTES_PER_PIXEL_RGBA = 4;
49 constexpr uint32_t BYTES_PER_PIXEL_BGRA = 4;
50 constexpr uint32_t EVEN_ODD_DIVISOR = 2;
51 constexpr uint32_t TWO_SLICES = 2;
52 constexpr int32_t NUM_2 = 2;
53 constexpr int32_t NUM_4 = 4;
54
55 struct ImageSize {
56 int32_t width = 0;
57 int32_t height = 0;
58 float dstWidth = 0;
59 float dstHeight = 0;
60 const uint32_t color = 0;
61 uint32_t dst = 0;
62 };
63
64 static const std::string IMAGE_INPUT_JPG_PATH1 = "/data/local/tmp/image/800-500.jpg";
65 static const std::string IMAGE_INPUT_JPG_PATH2 = "/data/local/tmp/image/951-595.jpg";
66 static const std::string IMAGE_OUTPUT_JPG_PATH = "/data/local/tmp/";
67 static const std::string IMAGE_INPUT_YUV_PATH3 = "/data/local/tmp/image/P010.yuv";
68 static const std::string IMAGE_INPUT_RGBA_PATH4 = "/data/local/tmp/image/RGBA1010102.rgba";
69 class ImageFormatConvertTest : public testing::Test {
70 public:
ImageFormatConvertTest()71 ImageFormatConvertTest() {}
~ImageFormatConvertTest()72 ~ImageFormatConvertTest() {}
73 static ConvertFunction TestGetConvertFuncByFormat(PixelFormat srcFormat, PixelFormat destFormat);
74 void WriteToFile(const std::string &outpath, Size &imageSize, const std::string &outname, const uint8_t *data,
75 const uint32_t size);
76 bool ReadFile(void *chOrg, std::string path, int32_t totalsize, int32_t srcNum);
77 void RgbConvertToYuv(PixelFormat &srcFormat, PixelFormat &destFormat, Size &srcSize);
78 void RgbConvertToYuvP010(PixelFormat &srcFormat, PixelFormat &destFormat, Size &srcSize);
79 void Rgba1010102ConvertToYuvP010(PixelFormat &srcFormat, PixelFormat &destFormat, Size &srcSize,
80 uint32_t destBuffersize);
81 void YuvConvertToRgb(PixelFormat &srcFormat, PixelFormat &destFormat, Size &srcSize, uint32_t destBuffersize);
82 void YuvP010ConvertToRgb(PixelFormat &srcFormat, PixelFormat &destFormat, Size &srcSize, uint32_t destBuffersize);
83 void RgbConvertToYuvByPixelMap(PixelFormat &tempFormat, PixelFormat &srcFormat,
84 PixelFormat &destFormat, Size &srcSize);
85 void RgbConvertToYuvP010ByPixelMap(PixelFormat &tempFormat, PixelFormat &srcFormat,
86 PixelFormat &destFormat, Size &srcSize);
87 void *GetOrignData(PixelFormat srcFormat, Size imageSize);
88 void PixelMapFormatConvert(PixelFormat &srcFormat, PixelFormat &destFormat, Size &srcSize,
89 uint32_t destBuffersize);
90 void PixelMap10bitConvert(PixelFormat &srcFormat, PixelFormat &destFormat, Size &srcSize,
91 uint32_t destBuffersize);
92 void RGBConvertToYUVByUnique(PixelFormat &srcFormat, PixelFormat &desFormat,
93 AllocatorType allocType = AllocatorType::DEFAULT);
94 uint32_t YUVConvertToSameYUV(PixelFormat &srcFormat, PixelFormat &desFormat);
95 void YUVConvertToRGBByDataInfo(PixelFormat &srcFormat, PixelFormat &desFormat);
96 uint32_t RGBConvertToSameRGB(PixelFormat &srcFormat, PixelFormat &desFormat);
97 };
98
TestGetConvertFuncByFormat(PixelFormat srcFormat,PixelFormat destFormat)99 ConvertFunction ImageFormatConvertTest::TestGetConvertFuncByFormat(PixelFormat srcFormat, PixelFormat destFormat)
100 {
101 return ImageFormatConvert::GetConvertFuncByFormat(srcFormat, destFormat);
102 }
103
GetNamedPixelFormat(const PixelFormat pixelFormat)104 static const string GetNamedPixelFormat(const PixelFormat pixelFormat)
105 {
106 switch (pixelFormat) {
107 case PixelFormat::UNKNOWN:
108 return "UNKNOWN";
109 case PixelFormat::RGB_565:
110 return "RGB_565";
111 case PixelFormat::RGB_888:
112 return "RGB_888";
113 case PixelFormat::NV21:
114 return "NV21";
115 case PixelFormat::NV12:
116 return "NV12";
117 case PixelFormat::RGBA_8888:
118 return "RGBA_8888";
119 case PixelFormat::BGRA_8888:
120 return "BGRA_8888";
121 case PixelFormat::RGBA_F16:
122 return "RGBA_F16";
123 case PixelFormat::RGBA_1010102:
124 return "RGBA_1010102";
125 case PixelFormat::YCBCR_P010:
126 return "YCBCR_P010";
127 case PixelFormat::YCRCB_P010:
128 return "YCRCB_P010";
129 default:
130 return "UNKNOWN";
131 }
132 return "UNKNOWN";
133 }
134
WriteToFile(const std::string & outpath,Size & imageSize,const std::string & outname,const uint8_t * data,const uint32_t size)135 void ImageFormatConvertTest::WriteToFile(const std::string &outpath, Size &imageSize, const std::string &outname,
136 const uint8_t *data, const uint32_t size)
137 {
138 std::filesystem::path dir(outpath);
139 if (!std::filesystem::exists(dir)) {
140 std::filesystem::create_directory(dir);
141 }
142
143 std::string filepath =
144 outpath + "/" + std::to_string(imageSize.width) + "-" + std::to_string(imageSize.height) + "-" + outname;
145
146 std::ofstream outfile(filepath, std::ios::out | std::ios::binary);
147 if (outfile.is_open()) {
148 outfile.write(reinterpret_cast<const char *>(data), size);
149 outfile.close();
150 } else {
151 ASSERT_TRUE(false);
152 }
153 }
154
RgbConvertToYuv(PixelFormat & srcFormat,PixelFormat & destFormat,Size & srcSize)155 void ImageFormatConvertTest::RgbConvertToYuv(PixelFormat &srcFormat, PixelFormat &destFormat, Size &srcSize)
156 {
157 uint32_t errorCode = 0;
158 SourceOptions opts;
159 opts.formatHint = "image/jpeg";
160 std::string jpgPath = srcSize.width % EVEN_ODD_DIVISOR == 0 ? IMAGE_INPUT_JPG_PATH1 : IMAGE_INPUT_JPG_PATH2;
161 std::shared_ptr<ImageSource> rImageSource = ImageSource::CreateImageSource(jpgPath, opts, errorCode);
162 ASSERT_EQ(errorCode, SUCCESS);
163 ASSERT_NE(rImageSource.get(), nullptr);
164
165 DecodeOptions decodeOpts;
166 decodeOpts.desiredPixelFormat = srcFormat;
167 decodeOpts.desiredSize.width = srcSize.width;
168 decodeOpts.desiredSize.height = srcSize.height;
169 std::shared_ptr<PixelMap> srcPixelMap = rImageSource->CreatePixelMap(decodeOpts, errorCode);
170 ASSERT_EQ(errorCode, SUCCESS);
171 ASSERT_NE(srcPixelMap.get(), nullptr);
172
173 auto yuvDataInfoTemp = srcPixelMap->yuvDataInfo_;
174 auto imageInfoTemp = srcPixelMap->imageInfo_;
175 srcPixelMap->yuvDataInfo_.yWidth = 0;
176 srcPixelMap->imageInfo_.size.width = 0;
177 uint32_t ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
178 ASSERT_NE(ret, SUCCESS);
179
180 srcPixelMap->yuvDataInfo_.yWidth = 1;
181 srcPixelMap->yuvDataInfo_.yHeight = 0;
182 ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
183 ASSERT_NE(ret, SUCCESS);
184
185 srcPixelMap->yuvDataInfo_.yHeight= PIXEL_MAP_MAX_RAM_SIZE;
186 srcPixelMap->yuvDataInfo_.yWidth = 2; // 2:Special case, anomalous branching
187 ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
188 ASSERT_NE(ret, SUCCESS);
189
190 srcPixelMap->yuvDataInfo_ = yuvDataInfoTemp;
191 srcPixelMap->imageInfo_ = imageInfoTemp;
192 ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
193 ASSERT_EQ(ret, SUCCESS);
194 uint8_t *data = const_cast<uint8_t *>(srcPixelMap->GetPixels());
195 ASSERT_NE(data, nullptr);
196
197 ImageInfo destImageInfo;
198 srcPixelMap->GetImageInfo(destImageInfo);
199 uint32_t buffersize = static_cast<size_t>(destImageInfo.size.width * destImageInfo.size.height +
200 ((destImageInfo.size.width + 1) / TWO_SLICES) * ((destImageInfo.size.height + 1) / TWO_SLICES) * TWO_SLICES);
201 ASSERT_EQ(srcPixelMap->GetPixelFormat(), destFormat);
202
203 Size size = destImageInfo.size;
204 std::string formatName = GetNamedPixelFormat(srcFormat) + "To" + GetNamedPixelFormat(destFormat) + ".yuv";
205 std::string outname = size.width % EVEN_ODD_DIVISOR == 0 ? "Tree_" + formatName : "Odd_" + formatName;
206 std::string outpath = IMAGE_OUTPUT_JPG_PATH + "RGBToYUV/";
207 WriteToFile(outpath, size, outname, data, buffersize);
208 }
209
YuvConvertToRgb(PixelFormat & srcFormat,PixelFormat & destFormat,Size & srcSize,uint32_t destBuffersize)210 void ImageFormatConvertTest::YuvConvertToRgb(PixelFormat &srcFormat, PixelFormat &destFormat, Size &srcSize,
211 uint32_t destBuffersize)
212 {
213 uint32_t errorCode = 0;
214 SourceOptions opts;
215 opts.formatHint = "image/jpeg";
216 std::string jpgPath = srcSize.width % EVEN_ODD_DIVISOR == 0 ? IMAGE_INPUT_JPG_PATH1 : IMAGE_INPUT_JPG_PATH2;
217 std::shared_ptr<ImageSource> rImageSource = ImageSource::CreateImageSource(jpgPath, opts, errorCode);
218 ASSERT_EQ(errorCode, SUCCESS);
219 ASSERT_NE(rImageSource.get(), nullptr);
220
221 DecodeOptions decodeOpts;
222 decodeOpts.desiredPixelFormat = srcFormat;
223 decodeOpts.desiredSize.width = srcSize.width;
224 decodeOpts.desiredSize.height = srcSize.height;
225 std::shared_ptr<PixelMap> srcPixelMap = rImageSource->CreatePixelMap(decodeOpts, errorCode);
226 ASSERT_EQ(errorCode, SUCCESS);
227 ASSERT_NE(srcPixelMap.get(), nullptr);
228
229 uint32_t ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
230 ASSERT_EQ(ret, SUCCESS);
231 uint8_t *data = const_cast<uint8_t *>(srcPixelMap->GetPixels());
232 ASSERT_NE(data, nullptr);
233 ASSERT_EQ(srcPixelMap->GetPixelFormat(), destFormat);
234
235 Size size;
236 size.width = srcPixelMap->GetWidth();
237 size.height = srcPixelMap->GetHeight();
238 std::string formatName = GetNamedPixelFormat(srcFormat) + "To" + GetNamedPixelFormat(destFormat) + ".rgb";
239 std::string outname = size.width % EVEN_ODD_DIVISOR == 0 ? "Tree_" + formatName : "Odd_" + formatName;
240 std::string outpath = IMAGE_OUTPUT_JPG_PATH + "YUVToRGB/";
241 WriteToFile(outpath, size, outname, data, destBuffersize);
242 }
243
ReadFile(void * chOrg,std::string path,int32_t totalsize,int32_t srcNum)244 bool ImageFormatConvertTest::ReadFile(void *chOrg, std::string path, int32_t totalsize, int32_t srcNum)
245 {
246 FILE* const fileOrg = fopen(path.c_str(), "rb");
247 if (fileOrg == nullptr) {
248 GTEST_LOG_(INFO) << "Cannot open" << path.c_str();
249 GTEST_LOG_(INFO) << "fopen";
250 return false;
251 }
252
253 bool result = true;
254 if (srcNum == 0) {
255 size_t bytesOrg = fread(chOrg, sizeof(uint8_t), static_cast<size_t>(totalsize), fileOrg);
256 if (bytesOrg < static_cast<size_t>(totalsize)) {
257 GTEST_LOG_(INFO) << "Read fail";
258 result = false;
259 }
260 } else {
261 size_t bytesOrg = fread(chOrg, sizeof(uint16_t), static_cast<size_t>(totalsize), fileOrg);
262 if (bytesOrg < static_cast<size_t>(totalsize)) {
263 GTEST_LOG_(INFO) << "Read fail " << bytesOrg << " totalsize " << totalsize;
264 result = false;
265 }
266 }
267
268 if (fclose(fileOrg) == EOF) {
269 GTEST_LOG_(INFO) << "fclose failed";
270 result = false;
271 }
272 return result;
273 }
274
YuvP010ConvertToRgb(PixelFormat & srcFormat,PixelFormat & destFormat,Size & srcSize,uint32_t destBuffersize)275 void ImageFormatConvertTest::YuvP010ConvertToRgb(PixelFormat &srcFormat, PixelFormat &destFormat, Size &srcSize,
276 uint32_t destBuffersize)
277 {
278 ImageSize imageSize;
279 imageSize.width = srcSize.width;
280 imageSize.height = srcSize.height;
281 int32_t ySize = imageSize.width * imageSize.height;
282 int32_t uvSize = ((imageSize.width + 1) / NUM_2) * ((imageSize.height + 1) / NUM_2);
283 const size_t totalSize = (ySize + NUM_2 * uvSize);
284 uint16_t* const chOrg = new uint16_t[totalSize];
285 bool result = ReadFile(chOrg, IMAGE_INPUT_YUV_PATH3, totalSize, 1);
286 ASSERT_EQ(result, true);
287
288 const uint32_t dataLength = totalSize * NUM_2;
289 uint32_t *data = reinterpret_cast<uint32_t *>(chOrg);
290 InitializationOptions opts;
291 opts.srcPixelFormat = srcFormat;
292 opts.pixelFormat = srcFormat;
293 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
294 opts.size.width = imageSize.width;
295 opts.size.height = imageSize.height;
296 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(data, dataLength, opts);
297 ASSERT_NE(pixelMap.get(), nullptr);
298
299 std::shared_ptr<PixelMap> srcPixelMap = std::move(pixelMap);
300 uint32_t ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
301 ASSERT_EQ(ret, SUCCESS);
302 ASSERT_EQ(srcPixelMap->GetPixelFormat(), destFormat);
303
304 Size size;
305 size.width = srcPixelMap->GetWidth();
306 size.height = srcPixelMap->GetHeight();
307
308 std::string formatName = GetNamedPixelFormat(srcFormat) + "To" + GetNamedPixelFormat(destFormat) + ".yuv";
309 std::string outname = size.width % EVEN_ODD_DIVISOR == 0 ? "Tree_" + formatName : "Odd_" + formatName;
310 std::string outpath = IMAGE_OUTPUT_JPG_PATH + "P010ToRgba1010102/";
311 uint8_t *data8 = const_cast<uint8_t *>(srcPixelMap->GetPixels());
312 ASSERT_NE(data8, nullptr);
313 WriteToFile(outpath, size, outname, data8, destBuffersize);
314 }
315
Rgba1010102ConvertToYuvP010(PixelFormat & srcFormat,PixelFormat & destFormat,Size & srcSize,uint32_t destBuffersize)316 void ImageFormatConvertTest::Rgba1010102ConvertToYuvP010(PixelFormat &srcFormat, PixelFormat &destFormat, Size &srcSize,
317 uint32_t destBuffersize)
318 {
319 ImageSize imageSize;
320 imageSize.width = srcSize.width;
321 imageSize.height = srcSize.height;
322 int32_t ySize = imageSize.width * imageSize.height;
323 const size_t totalSize = ySize * NUM_4;
324 uint8_t* const chOrg = new uint8_t[totalSize];
325 bool result = ReadFile(chOrg, IMAGE_INPUT_RGBA_PATH4, totalSize, 0);
326 ASSERT_EQ(result, true);
327
328 const uint32_t dataLength = totalSize;
329 uint32_t *data = reinterpret_cast<uint32_t *>(chOrg);
330 InitializationOptions opts;
331 opts.srcPixelFormat = srcFormat;
332 opts.pixelFormat = srcFormat;
333 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_PREMUL;
334 opts.size.width = imageSize.width;
335 opts.size.height = imageSize.height;
336 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(data, dataLength, opts);
337 ASSERT_NE(pixelMap.get(), nullptr);
338 std::shared_ptr<PixelMap> srcPixelMap = std::move(pixelMap);
339
340 uint32_t ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
341 ASSERT_EQ(ret, SUCCESS);
342 ASSERT_EQ(srcPixelMap->GetPixelFormat(), destFormat);
343
344 Size size;
345 size.width = srcPixelMap->GetWidth();
346 size.height = srcPixelMap->GetHeight();
347
348 std::string formatName = GetNamedPixelFormat(srcFormat) + "To" + GetNamedPixelFormat(destFormat) + ".yuv";
349 std::string outname = size.width % EVEN_ODD_DIVISOR == 0 ? "Tree_" + formatName : "Odd_" + formatName;
350 std::string outpath = IMAGE_OUTPUT_JPG_PATH + "Rgba1010102ToP010/";
351 uint8_t *data8 = const_cast<uint8_t *>(srcPixelMap->GetPixels());
352 ASSERT_NE(data8, nullptr);
353 WriteToFile(outpath, size, outname, data8, destBuffersize);
354 }
355
RgbConvertToYuvByPixelMap(PixelFormat & tempFormat,PixelFormat & srcFormat,PixelFormat & destFormat,Size & srcSize)356 void ImageFormatConvertTest::RgbConvertToYuvByPixelMap(PixelFormat &tempFormat, PixelFormat &srcFormat,
357 PixelFormat &destFormat, Size &srcSize)
358 {
359 uint32_t errorCode = 0;
360 SourceOptions opts;
361 opts.formatHint = "image/jpeg";
362 std::string jpgPath = srcSize.width % EVEN_ODD_DIVISOR == 0 ? IMAGE_INPUT_JPG_PATH1 : IMAGE_INPUT_JPG_PATH2;
363 auto rImageSource = ImageSource::CreateImageSource(jpgPath, opts, errorCode);
364 ASSERT_EQ(errorCode, SUCCESS);
365 ASSERT_NE(rImageSource.get(), nullptr);
366
367 DecodeOptions decodeOpts;
368 decodeOpts.desiredPixelFormat = tempFormat;
369 decodeOpts.desiredSize.width = srcSize.width;
370 decodeOpts.desiredSize.height = srcSize.height;
371 std::shared_ptr<PixelMap> srcPixelMap = nullptr;
372 srcPixelMap = rImageSource->CreatePixelMap(decodeOpts, errorCode);
373 ASSERT_EQ(errorCode, SUCCESS);
374 ASSERT_NE(srcPixelMap.get(), nullptr);
375
376 auto yuvDataInfoTemp = srcPixelMap->yuvDataInfo_;
377 auto imageInfoTemp = srcPixelMap->imageInfo_;
378 srcPixelMap->yuvDataInfo_.yWidth = 0;
379 srcPixelMap->imageInfo_.size.width = 0;
380 uint32_t tmpRet = ImageFormatConvert::ConvertImageFormat(srcPixelMap, srcFormat);
381 ASSERT_NE(tmpRet, SUCCESS);
382
383 srcPixelMap->yuvDataInfo_.yWidth = 1;
384 srcPixelMap->yuvDataInfo_.yHeight = 0;
385 tmpRet = ImageFormatConvert::ConvertImageFormat(srcPixelMap, srcFormat);
386 ASSERT_NE(tmpRet, SUCCESS);
387
388 srcPixelMap->yuvDataInfo_.yHeight= PIXEL_MAP_MAX_RAM_SIZE;
389 srcPixelMap->yuvDataInfo_.yWidth = 2; // 2:Special case, anomalous branching
390 tmpRet = ImageFormatConvert::ConvertImageFormat(srcPixelMap, srcFormat);
391 ASSERT_NE(tmpRet, SUCCESS);
392
393 srcPixelMap->yuvDataInfo_ = yuvDataInfoTemp;
394 srcPixelMap->imageInfo_ = imageInfoTemp;
395 tmpRet = ImageFormatConvert::ConvertImageFormat(srcPixelMap, srcFormat);
396 ASSERT_EQ(tmpRet, SUCCESS);
397 ASSERT_EQ(srcPixelMap->GetPixelFormat(), srcFormat);
398
399 uint32_t ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
400 ASSERT_EQ(ret, SUCCESS);
401 ASSERT_EQ(srcPixelMap->GetPixelFormat(), destFormat);
402 uint8_t *data = const_cast<uint8_t *>(srcPixelMap->GetPixels());
403 ASSERT_NE(data, nullptr);
404
405 ImageInfo destImageInfo;
406 srcPixelMap->GetImageInfo(destImageInfo);
407 uint32_t buffersize = static_cast<size_t>(destImageInfo.size.width * destImageInfo.size.height +
408 ((destImageInfo.size.width + 1) / TWO_SLICES) * ((destImageInfo.size.height + 1) / TWO_SLICES) * TWO_SLICES);
409
410 Size size = destImageInfo.size;
411 std::string formatName = GetNamedPixelFormat(srcFormat) + "To" + GetNamedPixelFormat(destFormat) + ".yuv";
412 std::string outname = size.width % EVEN_ODD_DIVISOR == 0 ? "Tree_" + formatName : "Odd_" + formatName;
413 std::string outpath = IMAGE_OUTPUT_JPG_PATH + "RGBToYUV/";
414 WriteToFile(outpath, size, outname, data, buffersize);
415 }
416
RgbConvertToYuvP010ByPixelMap(PixelFormat & tempFormat,PixelFormat & srcFormat,PixelFormat & destFormat,Size & srcSize)417 void ImageFormatConvertTest::RgbConvertToYuvP010ByPixelMap(PixelFormat &tempFormat, PixelFormat &srcFormat,
418 PixelFormat &destFormat, Size &srcSize)
419 {
420 uint32_t errorCode = 0;
421 SourceOptions opts;
422 opts.formatHint = "image/jpeg";
423 std::string jpgPath = srcSize.width % EVEN_ODD_DIVISOR == 0 ? IMAGE_INPUT_JPG_PATH1 : IMAGE_INPUT_JPG_PATH2;
424 auto rImageSource = ImageSource::CreateImageSource(jpgPath, opts, errorCode);
425 ASSERT_EQ(errorCode, SUCCESS);
426 ASSERT_NE(rImageSource.get(), nullptr);
427
428 DecodeOptions decodeOpts;
429 decodeOpts.desiredPixelFormat = tempFormat;
430 decodeOpts.desiredSize.width = srcSize.width;
431 decodeOpts.desiredSize.height = srcSize.height;
432 std::shared_ptr<PixelMap> srcPixelMap = nullptr;
433 srcPixelMap = rImageSource->CreatePixelMap(decodeOpts, errorCode);
434 ASSERT_EQ(errorCode, SUCCESS);
435 ASSERT_NE(srcPixelMap.get(), nullptr);
436
437 uint32_t tmpRet = ImageFormatConvert::ConvertImageFormat(srcPixelMap, srcFormat);
438 ASSERT_EQ(tmpRet, SUCCESS);
439 ASSERT_EQ(srcPixelMap->GetPixelFormat(), srcFormat);
440
441 uint32_t ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
442 ASSERT_EQ(ret, SUCCESS);
443 ASSERT_EQ(srcPixelMap->GetPixelFormat(), destFormat);
444 uint8_t *data = const_cast<uint8_t *>(srcPixelMap->GetPixels());
445 ASSERT_NE(data, nullptr);
446
447 ImageInfo destImageInfo;
448 srcPixelMap->GetImageInfo(destImageInfo);
449 uint32_t buffersize = static_cast<size_t>((destImageInfo.size.width * destImageInfo.size.height +
450 ((destImageInfo.size.width + 1) / TWO_SLICES) * ((destImageInfo.size.height + 1) / TWO_SLICES)
451 * TWO_SLICES) * TWO_SLICES);
452 Size size = destImageInfo.size;
453 std::string formatName = GetNamedPixelFormat(srcFormat) + "To" + GetNamedPixelFormat(destFormat) + "P010.yuv";
454 std::string outname = size.width % EVEN_ODD_DIVISOR == 0 ? "Tree_" + formatName : "Odd_" + formatName;
455 std::string outpath = IMAGE_OUTPUT_JPG_PATH + "RGBToYUVP010/";
456 WriteToFile(outpath, size, outname, data, buffersize);
457 }
458
RgbConvertToYuvP010(PixelFormat & srcFormat,PixelFormat & destFormat,Size & srcSize)459 void ImageFormatConvertTest::RgbConvertToYuvP010(PixelFormat &srcFormat, PixelFormat &destFormat, Size &srcSize)
460 {
461 uint32_t errorCode = 0;
462 SourceOptions opts;
463 opts.formatHint = "image/jpeg";
464 std::string jpgPath = srcSize.width % EVEN_ODD_DIVISOR == 0 ? IMAGE_INPUT_JPG_PATH1 : IMAGE_INPUT_JPG_PATH2;
465 std::shared_ptr<ImageSource> rImageSource = ImageSource::CreateImageSource(jpgPath, opts, errorCode);
466 ASSERT_EQ(errorCode, SUCCESS);
467 ASSERT_NE(rImageSource.get(), nullptr);
468
469 DecodeOptions decodeOpts;
470 decodeOpts.desiredPixelFormat = srcFormat;
471 decodeOpts.desiredSize.width = srcSize.width;
472 decodeOpts.desiredSize.height = srcSize.height;
473 std::shared_ptr<PixelMap> srcPixelMap = rImageSource->CreatePixelMap(decodeOpts, errorCode);
474 ASSERT_EQ(errorCode, SUCCESS);
475 ASSERT_NE(srcPixelMap.get(), nullptr);
476
477 uint32_t ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
478 ASSERT_EQ(ret, SUCCESS);
479 uint8_t *data = const_cast<uint8_t *>(srcPixelMap->GetPixels());
480 ASSERT_NE(data, nullptr);
481
482 ImageInfo destImageInfo;
483 srcPixelMap->GetImageInfo(destImageInfo);
484 uint32_t buffersize = static_cast<size_t>((destImageInfo.size.width * destImageInfo.size.height +
485 ((destImageInfo.size.width + 1) / TWO_SLICES) * ((destImageInfo.size.height + 1) / TWO_SLICES)
486 * TWO_SLICES) * TWO_SLICES);
487 ASSERT_EQ(srcPixelMap->GetPixelFormat(), destFormat);
488
489 Size size = destImageInfo.size;
490 std::string formatName = GetNamedPixelFormat(srcFormat) + "To" + GetNamedPixelFormat(destFormat) + "P010.yuv";
491 std::string outname = size.width % EVEN_ODD_DIVISOR == 0 ? "Tree_" + formatName : "Odd_" + formatName;
492 std::string outpath = IMAGE_OUTPUT_JPG_PATH + "RGBToYUVP010/";
493 WriteToFile(outpath, size, outname, data, buffersize);
494 }
495
GetOrignData(PixelFormat srcFormat,Size imageSize)496 void *ImageFormatConvertTest::GetOrignData(PixelFormat srcFormat, Size imageSize)
497 {
498 if (srcFormat == PixelFormat::YCBCR_P010 ||
499 srcFormat == PixelFormat::YCRCB_P010) {
500 int32_t ySize = imageSize.width * imageSize.height;
501 int32_t uvSize = ((imageSize.width + 1) / NUM_2) * ((imageSize.height + 1) / NUM_2);
502 const size_t totalSize = (ySize + NUM_2 * uvSize);
503 uint16_t* const chOrg = new uint16_t[totalSize];
504 bool result = ReadFile(chOrg, IMAGE_INPUT_YUV_PATH3, totalSize, 1);
505 return result == true ? chOrg : nullptr;
506 } else if (srcFormat == PixelFormat::RGBA_1010102) {
507 int32_t ySize = imageSize.width * imageSize.height;
508 const size_t totalSize = ySize * NUM_4;
509 uint8_t* const chOrg = new uint8_t[totalSize];
510 bool result = ReadFile(chOrg, IMAGE_INPUT_RGBA_PATH4, totalSize, 0);
511 return result == true ? chOrg : nullptr;
512 } else {
513 return nullptr;
514 }
515 }
516
PixelMapFormatConvert(PixelFormat & srcFormat,PixelFormat & destFormat,Size & srcSize,uint32_t destBuffersize)517 void ImageFormatConvertTest::PixelMapFormatConvert(PixelFormat &srcFormat, PixelFormat &destFormat,
518 Size &srcSize, uint32_t destBuffersize)
519 {
520 uint32_t errorCode = 0;
521 SourceOptions srcopts;
522 srcopts.formatHint = "image/jpeg";
523 std::string jpgPath = srcSize.width % EVEN_ODD_DIVISOR == 0 ? IMAGE_INPUT_JPG_PATH1 : IMAGE_INPUT_JPG_PATH2;
524 std::shared_ptr<ImageSource> rImageSource = ImageSource::CreateImageSource(jpgPath, srcopts, errorCode);
525 ASSERT_EQ(errorCode, SUCCESS);
526 ASSERT_NE(rImageSource.get(), nullptr);
527
528 DecodeOptions decodeOpts;
529 decodeOpts.desiredPixelFormat = srcFormat;
530 decodeOpts.desiredSize.width = srcSize.width;
531 decodeOpts.desiredSize.height = srcSize.height;
532 std::shared_ptr<PixelMap> srcPixelMap = rImageSource->CreatePixelMap(decodeOpts, errorCode);
533 ASSERT_EQ(errorCode, SUCCESS);
534 ASSERT_NE(srcPixelMap.get(), nullptr);
535
536 uint32_t *data = (uint32_t *)srcPixelMap->GetPixels();
537 const uint32_t dataLength = srcPixelMap->GetByteCount();
538 InitializationOptions opts;
539 opts.srcPixelFormat = srcFormat;
540 opts.pixelFormat = destFormat;
541 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_PREMUL;
542 opts.size.width = srcSize.width;
543 opts.size.height = srcSize.height;
544
545 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(data, dataLength, opts);
546 ASSERT_NE(pixelMap.get(), nullptr);
547
548 Size size;
549 size.width = pixelMap->GetWidth();
550 size.height = pixelMap->GetHeight();
551 std::string formatName = GetNamedPixelFormat(srcFormat) + "To" + GetNamedPixelFormat(destFormat) + ".yuv";
552 std::string outname = size.width % EVEN_ODD_DIVISOR == 0 ? "Tree_" + formatName : "Odd_" + formatName;
553 std::string outpath = IMAGE_OUTPUT_JPG_PATH + "PixelConvert/";
554 uint8_t *data8 = const_cast<uint8_t *>(pixelMap->GetPixels());
555 ASSERT_NE(data8, nullptr);
556 WriteToFile(outpath, size, outname, data8, destBuffersize);
557 }
558
PixelMap10bitConvert(PixelFormat & srcFormat,PixelFormat & destFormat,Size & srcSize,uint32_t destBuffersize)559 void ImageFormatConvertTest::PixelMap10bitConvert(PixelFormat &srcFormat, PixelFormat &destFormat, Size &srcSize,
560 uint32_t destBuffersize)
561 {
562 uint32_t *data = (uint32_t *)GetOrignData(srcFormat, srcSize);
563 const uint32_t dataLength = ImageFormatConvert::GetBufferSizeByFormat(srcFormat, srcSize);
564 InitializationOptions opts;
565 opts.srcPixelFormat = srcFormat;
566 opts.pixelFormat = destFormat;
567 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_PREMUL;
568 opts.size.width = srcSize.width;
569 opts.size.height = srcSize.height;
570
571 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(data, dataLength, opts);
572 ASSERT_NE(pixelMap.get(), nullptr);
573 Size size;
574 size.width = pixelMap->GetWidth();
575 size.height = pixelMap->GetHeight();
576
577 std::string formatName = GetNamedPixelFormat(srcFormat) + "To" + GetNamedPixelFormat(destFormat) + ".yuv";
578 std::string outname = size.width % EVEN_ODD_DIVISOR == 0 ? "Tree_" + formatName : "Odd_" + formatName;
579 std::string outpath = IMAGE_OUTPUT_JPG_PATH + "PixelConvert/";
580 uint8_t *data8 = const_cast<uint8_t *>(pixelMap->GetPixels());
581 ASSERT_NE(data8, nullptr);
582 WriteToFile(outpath, size, outname, data8, destBuffersize);
583 }
584
RGBConvertToYUVByUnique(PixelFormat & srcFormat,PixelFormat & destFormat,AllocatorType allocType)585 void ImageFormatConvertTest::RGBConvertToYUVByUnique(PixelFormat &srcFormat, PixelFormat &destFormat,
586 AllocatorType allocType)
587 {
588 uint32_t errorCode = 0;
589 SourceOptions opts;
590 opts.formatHint = "image/jpeg";
591 std::shared_ptr<ImageSource> rImageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPG_PATH1, opts, errorCode);
592 ASSERT_EQ(errorCode, SUCCESS);
593 ASSERT_NE(rImageSource.get(), nullptr);
594 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
595 DecodeOptions decodeOpts;
596 decodeOpts.desiredPixelFormat = srcFormat;
597 decodeOpts.desiredSize.width = srcSize.width;
598 decodeOpts.desiredSize.height = srcSize.height;
599 decodeOpts.allocatorType = allocType;
600 std::unique_ptr<PixelMap> srcPixelMap = rImageSource->CreatePixelMap(decodeOpts, errorCode);
601 ASSERT_EQ(errorCode, SUCCESS);
602 ASSERT_NE(srcPixelMap.get(), nullptr);
603 errorCode = ImageFormatConvert::RGBConvertImageFormatOptionUnique(srcPixelMap, srcFormat, destFormat);
604 ASSERT_EQ(errorCode, SUCCESS);
605 }
606
607 HWTEST_F(ImageFormatConvertTest, RGBAF16ToNV21_001, TestSize.Level3)
608 {
609 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV21_001: start";
610 PixelFormat tempFormat = PixelFormat::NV12;
611 PixelFormat srcFormat = PixelFormat::RGBA_F16;
612 PixelFormat destFormat = PixelFormat::NV21;
613 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
614 RgbConvertToYuvByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
615 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV21_001: end";
616 }
617
618 HWTEST_F(ImageFormatConvertTest, RGBAF16ToNV21_002, TestSize.Level3)
619 {
620 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV21_002: start";
621 PixelFormat tempFormat = PixelFormat::NV12;
622 PixelFormat srcFormat = PixelFormat::RGBA_F16;
623 PixelFormat destFormat = PixelFormat::NV21;
624 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
625 RgbConvertToYuvByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
626 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV21_002: end";
627 }
628
629 HWTEST_F(ImageFormatConvertTest, RGBAF16ToNV12_001, TestSize.Level3)
630 {
631 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV12_001: start";
632 PixelFormat tempFormat = PixelFormat::NV21;
633 PixelFormat srcFormat = PixelFormat::RGBA_F16;
634 PixelFormat destFormat = PixelFormat::NV12;
635 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
636 RgbConvertToYuvByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
637 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV12_001: end";
638 }
639
640 HWTEST_F(ImageFormatConvertTest, RGBAF16ToNV12_002, TestSize.Level3)
641 {
642 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV12_002: start";
643 PixelFormat tempFormat = PixelFormat::NV21;
644 PixelFormat srcFormat = PixelFormat::RGBA_F16;
645 PixelFormat destFormat = PixelFormat::NV12;
646 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
647 RgbConvertToYuvByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
648 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV12_002: end";
649 }
650
651 HWTEST_F(ImageFormatConvertTest, RGBAToNV21_001, TestSize.Level3)
652 {
653 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAToNV21_001: start";
654 PixelFormat tempFormat = PixelFormat::NV12;
655 PixelFormat srcFormat = PixelFormat::RGBA_8888;
656 PixelFormat destFormat = PixelFormat::NV21;
657 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
658 RgbConvertToYuvByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
659 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV21_001: end";
660 }
661
662 HWTEST_F(ImageFormatConvertTest, RGBAToNV21_002, TestSize.Level3)
663 {
664 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAToNV21_002: start";
665 PixelFormat tempFormat = PixelFormat::NV12;
666 PixelFormat srcFormat = PixelFormat::RGBA_8888;
667 PixelFormat destFormat = PixelFormat::NV21;
668 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
669 RgbConvertToYuvByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
670 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV21_002: end";
671 }
672
673 HWTEST_F(ImageFormatConvertTest, RGBAToNV12_001, TestSize.Level3)
674 {
675 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAToNV12_001: start";
676 PixelFormat tempFormat = PixelFormat::NV21;
677 PixelFormat srcFormat = PixelFormat::RGBA_8888;
678 PixelFormat destFormat = PixelFormat::NV12;
679 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
680 RgbConvertToYuvByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
681 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAToNV12_001: end";
682 }
683
684 HWTEST_F(ImageFormatConvertTest, RGBAToNV12_002, TestSize.Level3)
685 {
686 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAToNV12_002: start";
687 PixelFormat tempFormat = PixelFormat::NV21;
688 PixelFormat srcFormat = PixelFormat::RGBA_8888;
689 PixelFormat destFormat = PixelFormat::NV12;
690 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
691 RgbConvertToYuvByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
692 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAToNV12_002: end";
693 }
694
695 HWTEST_F(ImageFormatConvertTest, RGBToNV21_001, TestSize.Level3)
696 {
697 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV21_001: start";
698 PixelFormat tempFormat = PixelFormat::NV12;
699 PixelFormat srcFormat = PixelFormat::RGB_888;
700 PixelFormat destFormat = PixelFormat::NV21;
701 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
702 RgbConvertToYuvByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
703 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV21_001: end";
704 }
705
706 HWTEST_F(ImageFormatConvertTest, RGBToNV21_002, TestSize.Level1)
707 {
708 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV21_002: start";
709 PixelFormat tempFormat = PixelFormat::NV12;
710 PixelFormat srcFormat = PixelFormat::RGB_888;
711 PixelFormat destFormat = PixelFormat::NV21;
712 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
713 RgbConvertToYuvByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
714 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV21_002: end";
715 }
716
717 HWTEST_F(ImageFormatConvertTest, RGBToNV12_001, TestSize.Level3)
718 {
719 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV12_001: start";
720 PixelFormat tempFormat = PixelFormat::NV21;
721 PixelFormat srcFormat = PixelFormat::RGB_888;
722 PixelFormat destFormat = PixelFormat::NV12;
723 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
724 RgbConvertToYuvByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
725 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV12_001: end";
726 }
727
728 HWTEST_F(ImageFormatConvertTest, RGBToNV12_002, TestSize.Level3)
729 {
730 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV12_002: start";
731 PixelFormat tempFormat = PixelFormat::NV21;
732 PixelFormat srcFormat = PixelFormat::RGB_888;
733 PixelFormat destFormat = PixelFormat::NV12;
734 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
735 RgbConvertToYuvByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
736 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV12_002: end";
737 }
738
739 HWTEST_F(ImageFormatConvertTest, RGB565ToNV12_001, TestSize.Level3)
740 {
741 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV12_001: start";
742 PixelFormat srcFormat = PixelFormat::RGB_565;
743 PixelFormat destFormat = PixelFormat::NV12;
744 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
745 RgbConvertToYuv(srcFormat, destFormat, srcSize);
746 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV12_001: end";
747 }
748
749 HWTEST_F(ImageFormatConvertTest, RGB565ToNV12_002, TestSize.Level3)
750 {
751 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV12_002: start";
752 PixelFormat srcFormat = PixelFormat::RGB_565;
753 PixelFormat destFormat = PixelFormat::NV12;
754 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
755 RgbConvertToYuv(srcFormat, destFormat, srcSize);
756 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV12_002: end";
757 }
758
759 HWTEST_F(ImageFormatConvertTest, RGB565ToNV21_001, TestSize.Level3)
760 {
761 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV21_001: start";
762 PixelFormat srcFormat = PixelFormat::RGB_565;
763 PixelFormat destFormat = PixelFormat::NV21;
764 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
765 RgbConvertToYuv(srcFormat, destFormat, srcSize);
766 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV21_001: end";
767 }
768
769 HWTEST_F(ImageFormatConvertTest, RGB565ToNV21_002, TestSize.Level3)
770 {
771 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV21_002: start";
772 PixelFormat srcFormat = PixelFormat::RGB_565;
773 PixelFormat destFormat = PixelFormat::NV21;
774 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
775 RgbConvertToYuv(srcFormat, destFormat, srcSize);
776 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV21_002: end";
777 }
778
779 HWTEST_F(ImageFormatConvertTest, BGRAToNV21_001, TestSize.Level3)
780 {
781 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV21_001: start";
782 PixelFormat srcFormat = PixelFormat::BGRA_8888;
783 PixelFormat destFormat = PixelFormat::NV21;
784 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
785 RgbConvertToYuv(srcFormat, destFormat, srcSize);
786 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV21_001: end";
787 }
788
789 HWTEST_F(ImageFormatConvertTest, BGRAToNV21_002, TestSize.Level3)
790 {
791 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV21_002: start";
792 PixelFormat srcFormat = PixelFormat::BGRA_8888;
793 PixelFormat destFormat = PixelFormat::NV21;
794 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
795 RgbConvertToYuv(srcFormat, destFormat, srcSize);
796 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV21_002: end";
797 }
798
799 HWTEST_F(ImageFormatConvertTest, BGRAToNV12_001, TestSize.Level3)
800 {
801 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV12_001: start";
802 PixelFormat srcFormat = PixelFormat::BGRA_8888;
803 PixelFormat destFormat = PixelFormat::NV12;
804 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
805 RgbConvertToYuv(srcFormat, destFormat, srcSize);
806 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV12_001: end";
807 }
808
809 HWTEST_F(ImageFormatConvertTest, BGRAToNV12_002, TestSize.Level3)
810 {
811 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV12_002: start";
812 PixelFormat srcFormat = PixelFormat::BGRA_8888;
813 PixelFormat destFormat = PixelFormat::NV12;
814 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
815 RgbConvertToYuv(srcFormat, destFormat, srcSize);
816 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV12_002: end";
817 }
818
819 HWTEST_F(ImageFormatConvertTest, NV21ToRGB_001, TestSize.Level3)
820 {
821 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV12_001: start";
822 PixelFormat srcFormat = PixelFormat::NV21;
823 PixelFormat destFormat = PixelFormat::RGB_888;
824 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
825 uint32_t destBuffersize = TREE_ORIGINAL_WIDTH * TREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_RGB;
826 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
827 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV12_001: end";
828 }
829
830 HWTEST_F(ImageFormatConvertTest, NV21ToRGB_002, TestSize.Level3)
831 {
832 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV12_002: start";
833 PixelFormat srcFormat = PixelFormat::NV21;
834 PixelFormat destFormat = PixelFormat::RGB_888;
835 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
836 uint32_t destBuffersize = ODDTREE_ORIGINAL_WIDTH * ODDTREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_RGB;
837 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
838 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV12_002: end";
839 }
840
841 HWTEST_F(ImageFormatConvertTest, NV21ToRGBA_001, TestSize.Level3)
842 {
843 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV21ToRGBA_001: start";
844 PixelFormat srcFormat = PixelFormat::NV21;
845 PixelFormat destFormat = PixelFormat::RGBA_8888;
846 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
847 uint32_t destBuffersize = TREE_ORIGINAL_WIDTH * TREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_RGBA;
848 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
849 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV21ToRGBA_001: end";
850 }
851
852 HWTEST_F(ImageFormatConvertTest, NV21ToRGBA_002, TestSize.Level3)
853 {
854 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV21ToRGBA_002: start";
855 PixelFormat srcFormat = PixelFormat::NV21;
856 PixelFormat destFormat = PixelFormat::RGBA_8888;
857 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
858 uint32_t destBuffersize = ODDTREE_ORIGINAL_WIDTH * ODDTREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_RGBA;
859 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
860 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV21ToRGBA_002: end";
861 }
862
863 HWTEST_F(ImageFormatConvertTest, NV21ToBGRA_001, TestSize.Level3)
864 {
865 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV21ToBGRA_001: start";
866 PixelFormat srcFormat = PixelFormat::NV21;
867 PixelFormat destFormat = PixelFormat::BGRA_8888;
868 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
869 uint32_t destBuffersize = TREE_ORIGINAL_WIDTH * TREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_BGRA;
870 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
871 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV21ToBGRA_001: end";
872 }
873
874 HWTEST_F(ImageFormatConvertTest, NV21ToBGRA_002, TestSize.Level3)
875 {
876 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV21ToBGRA_002: start";
877 PixelFormat srcFormat = PixelFormat::NV21;
878 PixelFormat destFormat = PixelFormat::BGRA_8888;
879 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
880 uint32_t destBuffersize = ODDTREE_ORIGINAL_WIDTH * ODDTREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_BGRA;
881 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
882 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV21ToBGRA_002: end";
883 }
884
885 HWTEST_F(ImageFormatConvertTest, NV21ToRGB565_001, TestSize.Level3)
886 {
887 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV21ToRGB565_001: start";
888 PixelFormat srcFormat = PixelFormat::NV21;
889 PixelFormat destFormat = PixelFormat::RGB_565;
890 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
891 uint32_t destBuffersize = TREE_ORIGINAL_WIDTH * TREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_RGB565;
892 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
893 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV21ToRGB565_001: end";
894 }
895
896 HWTEST_F(ImageFormatConvertTest, NV21ToRGB565_002, TestSize.Level3)
897 {
898 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV21ToRGB565_002: start";
899 PixelFormat srcFormat = PixelFormat::NV21;
900 PixelFormat destFormat = PixelFormat::RGB_565;
901 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
902 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGB565;
903 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
904 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV21ToRGB565_002: end";
905 }
906
907 HWTEST_F(ImageFormatConvertTest, NV21ToNV12_001, TestSize.Level1)
908 {
909 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToNV12_001 start";
910 PixelFormat srcFormat = PixelFormat::NV21;
911 PixelFormat destFormat = PixelFormat::NV12;
912 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
913 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
914 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
915 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
916 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToNV12_001 end";
917 }
918
919 HWTEST_F(ImageFormatConvertTest, NV21ToNV12_002, TestSize.Level1)
920 {
921 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToNV12_002 start";
922 PixelFormat srcFormat = PixelFormat::NV21;
923 PixelFormat destFormat = PixelFormat::NV12;
924 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
925 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
926 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
927 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
928 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToNV12_002 end";
929 }
930
931 HWTEST_F(ImageFormatConvertTest, NV12ToNV21_001, TestSize.Level1)
932 {
933 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToNV21_001 start";
934 PixelFormat srcFormat = PixelFormat::NV12;
935 PixelFormat destFormat = PixelFormat::NV21;
936 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
937 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
938 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
939 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
940 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToNV21_001 end";
941 }
942
943 HWTEST_F(ImageFormatConvertTest, NV12ToNV21_002, TestSize.Level1)
944 {
945 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToNV21_002 start";
946 PixelFormat srcFormat = PixelFormat::NV12;
947 PixelFormat destFormat = PixelFormat::NV21;
948 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
949 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
950 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
951 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
952 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToNV21_002 end";
953 }
954
955 HWTEST_F(ImageFormatConvertTest, NV12ToRGB565_001, TestSize.Level1)
956 {
957 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGB565_001 start";
958 PixelFormat srcFormat = PixelFormat::NV12;
959 PixelFormat destFormat = PixelFormat::RGB_565;
960 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
961 uint32_t destBuffersize = TREE_ORIGINAL_WIDTH * TREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_RGB565;
962 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
963 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGB565_001 end";
964 }
965
966 HWTEST_F(ImageFormatConvertTest, NV12ToRGB565_002, TestSize.Level1)
967 {
968 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGB565_002 start";
969 PixelFormat srcFormat = PixelFormat::NV12;
970 PixelFormat destFormat = PixelFormat::RGB_565;
971 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
972 uint32_t destBuffersize = ODDTREE_ORIGINAL_WIDTH * ODDTREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_RGB565;
973 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
974 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGB565_002 end";
975 }
976
977 HWTEST_F(ImageFormatConvertTest, NV21ToRGBAF16_001, TestSize.Level1)
978 {
979 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToRGBAF16_Test_001 start";
980 PixelFormat srcFormat = PixelFormat::NV21;
981 PixelFormat destFormat = PixelFormat::RGBA_F16;
982 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
983 uint32_t destBuffersize = TREE_ORIGINAL_WIDTH * TREE_ORIGINAL_HEIGHT * sizeof(uint64_t);
984 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
985 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToRGBAF16_001 end";
986 }
987
988 HWTEST_F(ImageFormatConvertTest, NV21ToRGBAF16_002, TestSize.Level1)
989 {
990 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToRGBAF16_002 start";
991 PixelFormat srcFormat = PixelFormat::NV21;
992 PixelFormat destFormat = PixelFormat::RGBA_F16;
993 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
994 uint32_t destBuffersize = ODDTREE_ORIGINAL_WIDTH * ODDTREE_ORIGINAL_HEIGHT * sizeof(uint64_t);
995 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
996 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToRGBAF16_002 end";
997 }
998 HWTEST_F(ImageFormatConvertTest, NV12ToRGBAF16_001, TestSize.Level1)
999 {
1000 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGBAF16_001 start";
1001 PixelFormat srcFormat = PixelFormat::NV12;
1002 PixelFormat destFormat = PixelFormat::RGBA_F16;
1003 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1004 uint32_t destBuffersize = TREE_ORIGINAL_WIDTH * TREE_ORIGINAL_HEIGHT * sizeof(uint64_t);
1005 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1006 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGBAF16_001 end";
1007 }
1008
1009 HWTEST_F(ImageFormatConvertTest, NV12ToRGBAF16_002, TestSize.Level1)
1010 {
1011 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGBAF16_002 start";
1012 PixelFormat srcFormat = PixelFormat::NV12;
1013 PixelFormat destFormat = PixelFormat::RGBA_F16;
1014 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1015 uint32_t destBuffersize = ODDTREE_ORIGINAL_WIDTH * ODDTREE_ORIGINAL_HEIGHT * sizeof(uint64_t);
1016 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1017 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGBAF16_002 end";
1018 }
1019
1020 HWTEST_F(ImageFormatConvertTest, NV12ToRGBA_001, TestSize.Level1)
1021 {
1022 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGBA_001 start";
1023 PixelFormat srcFormat = PixelFormat::NV12;
1024 PixelFormat destFormat = PixelFormat::RGBA_8888;
1025 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1026 uint32_t destBuffersize = TREE_ORIGINAL_WIDTH * TREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_RGBA;
1027 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1028 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGBA_001 end";
1029 }
1030
1031 HWTEST_F(ImageFormatConvertTest, NV12ToRGBA_002, TestSize.Level1)
1032 {
1033 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGBA_002 start";
1034 PixelFormat srcFormat = PixelFormat::NV12;
1035 PixelFormat destFormat = PixelFormat::RGBA_8888;
1036 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1037 uint32_t destBuffersize = ODDTREE_ORIGINAL_WIDTH * ODDTREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_RGBA;
1038 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1039 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGBA_002 end";
1040 }
1041
1042 HWTEST_F(ImageFormatConvertTest, NV12ToBGRA_001, TestSize.Level1)
1043 {
1044 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToBGRA_001 start";
1045 PixelFormat srcFormat = PixelFormat::NV12;
1046 PixelFormat destFormat = PixelFormat::BGRA_8888;
1047 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1048 uint32_t destBuffersize = TREE_ORIGINAL_WIDTH * TREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_BGRA;
1049 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1050 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToBGRA_001 end";
1051 }
1052
1053 HWTEST_F(ImageFormatConvertTest, NV12ToBGRA_002, TestSize.Level1)
1054 {
1055 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToBGRA_002 start";
1056 PixelFormat srcFormat = PixelFormat::NV12;
1057 PixelFormat destFormat = PixelFormat::BGRA_8888;
1058 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1059 uint32_t destBuffersize = ODDTREE_ORIGINAL_WIDTH * ODDTREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_BGRA;
1060 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1061 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToBGRA_002 end";
1062 }
1063
1064 HWTEST_F(ImageFormatConvertTest, NV12ToRGB_001, TestSize.Level1)
1065 {
1066 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGB_001 start";
1067 PixelFormat srcFormat = PixelFormat::NV12;
1068 PixelFormat destFormat = PixelFormat::RGB_888;
1069 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1070 uint32_t destBuffersize = TREE_ORIGINAL_WIDTH * TREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_RGB;
1071 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1072 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGB_001 end";
1073 }
1074
1075 HWTEST_F(ImageFormatConvertTest, NV12ToRGB_002, TestSize.Level1)
1076 {
1077 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGB_002 start";
1078 PixelFormat srcFormat = PixelFormat::NV12;
1079 PixelFormat destFormat = PixelFormat::RGB_888;
1080 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1081 uint32_t destBuffersize = ODDTREE_ORIGINAL_WIDTH * ODDTREE_ORIGINAL_HEIGHT * BYTES_PER_PIXEL_RGB;
1082 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1083 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToRGB_002 end";
1084 }
1085
1086 HWTEST_F(ImageFormatConvertTest, NV21ToNV12P010_001, TestSize.Level1)
1087 {
1088 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToNV12P010_001 start";
1089 PixelFormat srcFormat = PixelFormat::NV21;
1090 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1091 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1092 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1093 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1094 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1095 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToNV12P010_001 end";
1096 }
1097
1098 HWTEST_F(ImageFormatConvertTest, NV21ToNV12P010_002, TestSize.Level1)
1099 {
1100 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToNV12P010_002 start";
1101 PixelFormat srcFormat = PixelFormat::NV21;
1102 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1103 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1104 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1105 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1106 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1107 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToNV12P010_002 end";
1108 }
1109
1110 HWTEST_F(ImageFormatConvertTest, NV12P010ToNV12_003, TestSize.Level1)
1111 {
1112 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12P010ToNV12_003 start";
1113 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
1114 PixelFormat destFormat = PixelFormat::NV12;
1115 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1116 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1117 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
1118 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1119 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12P010ToNV12_003 end";
1120 }
1121
1122 HWTEST_F(ImageFormatConvertTest, NV12ToNV12P010_001, TestSize.Level1)
1123 {
1124 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToNV12P010_001 start";
1125 PixelFormat srcFormat = PixelFormat::NV12;
1126 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1127 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1128 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1129 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1130 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1131 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToNV12P010_001 end";
1132 }
1133
1134 HWTEST_F(ImageFormatConvertTest, NV12ToNV12P010_002, TestSize.Level1)
1135 {
1136 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToNV12P010_002 start";
1137 PixelFormat srcFormat = PixelFormat::NV12;
1138 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1139 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1140 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1141 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1142 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1143 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToNV12P010_002 end";
1144 }
1145
1146 HWTEST_F(ImageFormatConvertTest, NV12P010ToNV21_003, TestSize.Level1)
1147 {
1148 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12P010ToNV21_003 start";
1149 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
1150 PixelFormat destFormat = PixelFormat::NV21;
1151 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1152 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1153 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
1154 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1155 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12P010ToNV21_003 end";
1156 }
1157
1158 HWTEST_F(ImageFormatConvertTest, NV12P010ToNV21P010_003, TestSize.Level1)
1159 {
1160 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12P010ToNV21P010_003 start";
1161 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
1162 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1163 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1164 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1165 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1166 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1167 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12P010ToNV21P010_003 end";
1168 }
1169
1170 HWTEST_F(ImageFormatConvertTest, NV12P010ToRGB565_003, TestSize.Level3)
1171 {
1172 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV12P010ToRGB565_003: start";
1173 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
1174 PixelFormat destFormat = PixelFormat::RGB_565;
1175 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1176 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGB565;
1177 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1178 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV12P010ToRGB565_003: end";
1179 }
1180
1181 HWTEST_F(ImageFormatConvertTest, NV12P010ToRGBA_003, TestSize.Level3)
1182 {
1183 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV12P010ToRGBA_003: start";
1184 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
1185 PixelFormat destFormat = PixelFormat::RGBA_8888;
1186 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1187 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGBA;
1188 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1189 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV12P010ToRGBA_003: end";
1190 }
1191
1192 HWTEST_F(ImageFormatConvertTest, NV12P010ToBGRA_003, TestSize.Level3)
1193 {
1194 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV12P010ToBGRA_003: start";
1195 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
1196 PixelFormat destFormat = PixelFormat::BGRA_8888;
1197 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1198 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_BGRA;
1199 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1200 GTEST_LOG_(INFO) << "ImageFormatConvertTest.NV12P010ToBGRA_003: end";
1201 }
1202
1203 HWTEST_F(ImageFormatConvertTest, NV12P010ToRGB_003, TestSize.Level1)
1204 {
1205 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12P010ToRGB_003 start";
1206 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
1207 PixelFormat destFormat = PixelFormat::RGB_888;
1208 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1209 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGB;
1210 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1211 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12P010ToRGB_003 end";
1212 }
1213
1214 HWTEST_F(ImageFormatConvertTest, NV12P010ToRGBAF16_003, TestSize.Level1)
1215 {
1216 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12P010ToRGBAF16_003 start";
1217 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
1218 PixelFormat destFormat = PixelFormat::RGBA_F16;
1219 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1220 uint32_t destBuffersize = srcSize.width * srcSize.height * sizeof(uint64_t);
1221 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1222 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12P010ToRGBAF16_003 end";
1223 }
1224
1225 HWTEST_F(ImageFormatConvertTest, NV21ToNV21P010_003, TestSize.Level1)
1226 {
1227 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToNV21P010_003 start";
1228 PixelFormat srcFormat = PixelFormat::NV21;
1229 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1230 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1231 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1232 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1233 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1234 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21ToNV21P010_003 end";
1235 }
1236
1237 HWTEST_F(ImageFormatConvertTest, NV21P010ToNV12_003, TestSize.Level1)
1238 {
1239 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToNV12_003 start";
1240 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1241 PixelFormat destFormat = PixelFormat::NV12;
1242 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1243 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1244 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
1245 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1246 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToNV12_003 end";
1247 }
1248
1249 HWTEST_F(ImageFormatConvertTest, NV12ToNV21P010_003, TestSize.Level1)
1250 {
1251 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToNV21P010_003 start";
1252 PixelFormat srcFormat = PixelFormat::NV12;
1253 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1254 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1255 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1256 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1257 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1258 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12ToNV21P010_003 end";
1259 }
1260
1261 HWTEST_F(ImageFormatConvertTest, NV12ToRGBA1010102_003, TestSize.Level3)
1262 {
1263 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_028: start";
1264 PixelFormat srcFormat = PixelFormat::NV12;
1265 PixelFormat destFormat = PixelFormat::RGBA_1010102;
1266 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1267 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGBA;
1268 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1269 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_028: end";
1270 }
1271
1272 HWTEST_F(ImageFormatConvertTest, NV21ToRGBA1010102_003, TestSize.Level3)
1273 {
1274 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_028: start";
1275 PixelFormat srcFormat = PixelFormat::NV21;
1276 PixelFormat destFormat = PixelFormat::RGBA_1010102;
1277 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1278 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGBA;
1279 YuvConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1280 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_028: end";
1281 }
1282
1283 HWTEST_F(ImageFormatConvertTest, NV21P010ToNV21_003, TestSize.Level1)
1284 {
1285 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToNV21_003 start";
1286 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1287 PixelFormat destFormat = PixelFormat::NV21;
1288 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1289 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1290 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
1291 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1292 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToNV21_003 end";
1293 }
1294
1295 HWTEST_F(ImageFormatConvertTest, NV12P010ToNV12P010_003, TestSize.Level1)
1296 {
1297 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12P010ToNV12P010_003 start";
1298 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1299 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1300 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1301 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1302 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1303 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1304 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV12P010ToNV12P010_003 end";
1305 }
1306
1307 HWTEST_F(ImageFormatConvertTest, NV21P010ToRGB565_003, TestSize.Level3)
1308 {
1309 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToRGB565_003: start";
1310 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1311 PixelFormat destFormat = PixelFormat::RGB_565;
1312 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1313 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGB565;
1314 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1315 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToRGB565_003: end";
1316 }
1317
1318 HWTEST_F(ImageFormatConvertTest, NV21P010ToRGBA_003, TestSize.Level3)
1319 {
1320 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToRGBA_003: start";
1321 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1322 PixelFormat destFormat = PixelFormat::RGBA_8888;
1323 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1324 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGBA;
1325 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1326 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToRGBA_003: end";
1327 }
1328
1329 HWTEST_F(ImageFormatConvertTest, NV21P010ToBGRA_003, TestSize.Level3)
1330 {
1331 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToBGRA_003: start";
1332 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1333 PixelFormat destFormat = PixelFormat::BGRA_8888;
1334 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1335 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_BGRA;
1336 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1337 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToBGRA_003: end";
1338 }
1339
1340 HWTEST_F(ImageFormatConvertTest, NV21P010ToRGB_003, TestSize.Level1)
1341 {
1342 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToRGB_003 start";
1343 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1344 PixelFormat destFormat = PixelFormat::RGB_888;
1345 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1346 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGB;
1347 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1348 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToRGB_003 end";
1349 }
1350
1351 HWTEST_F(ImageFormatConvertTest, NV21P010ToRGBAF16_003, TestSize.Level1)
1352 {
1353 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToRGBAF16_003 start";
1354 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1355 PixelFormat destFormat = PixelFormat::RGBA_F16;
1356 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1357 uint32_t destBuffersize = srcSize.width * srcSize.height * sizeof(uint64_t);
1358 YuvP010ConvertToRgb(srcFormat, destFormat, srcSize, destBuffersize);
1359 GTEST_LOG_(INFO) << "ImageFormatConvertTest: NV21P010ToRGBAF16_003 end";
1360 }
1361
1362 HWTEST_F(ImageFormatConvertTest, RGB565ToNV12P010_001, TestSize.Level3)
1363 {
1364 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV12P010_001: start";
1365 PixelFormat srcFormat = PixelFormat::RGB_565;
1366 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1367 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1368 RgbConvertToYuvP010(srcFormat, destFormat, srcSize);
1369 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV12P010_001: end";
1370 }
1371
1372 HWTEST_F(ImageFormatConvertTest, RGB565ToNV12P010_002, TestSize.Level3)
1373 {
1374 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV12P010_002: start";
1375 PixelFormat srcFormat = PixelFormat::RGB_565;
1376 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1377 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1378 RgbConvertToYuvP010(srcFormat, destFormat, srcSize);
1379 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV12P010_002: end";
1380 }
1381
1382 HWTEST_F(ImageFormatConvertTest, RGB565ToNV21P010_001, TestSize.Level3)
1383 {
1384 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV21P010_001: start";
1385 PixelFormat srcFormat = PixelFormat::RGB_565;
1386 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1387 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1388 RgbConvertToYuvP010(srcFormat, destFormat, srcSize);
1389 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV21P010_001: end";
1390 }
1391
1392 HWTEST_F(ImageFormatConvertTest, RGB565ToNV21P010_002, TestSize.Level3)
1393 {
1394 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV21P010_002: start";
1395 PixelFormat srcFormat = PixelFormat::RGB_565;
1396 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1397 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1398 RgbConvertToYuvP010(srcFormat, destFormat, srcSize);
1399 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGB565ToNV21P010_002: end";
1400 }
1401
1402 HWTEST_F(ImageFormatConvertTest, RGBAToNV12P010_001, TestSize.Level3)
1403 {
1404 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAToNV12P010_001: start";
1405 PixelFormat tempFormat = PixelFormat::NV12;
1406 PixelFormat srcFormat = PixelFormat::RGBA_8888;
1407 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1408 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1409 RgbConvertToYuvP010ByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
1410 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAToNV12P010_001: end";
1411 }
1412
1413 HWTEST_F(ImageFormatConvertTest, RGBAToNV12P010_002, TestSize.Level3)
1414 {
1415 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAToNV21_002: start";
1416 PixelFormat tempFormat = PixelFormat::NV12;
1417 PixelFormat srcFormat = PixelFormat::RGBA_8888;
1418 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1419 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1420 RgbConvertToYuvP010ByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
1421 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV21_002: end";
1422 }
1423
1424 HWTEST_F(ImageFormatConvertTest, RGBAToNV21P010_001, TestSize.Level3)
1425 {
1426 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAToNV21P010_001: start";
1427 PixelFormat tempFormat = PixelFormat::NV21;
1428 PixelFormat srcFormat = PixelFormat::RGBA_8888;
1429 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1430 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1431 RgbConvertToYuvP010ByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
1432 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAToNV21P010_001: end";
1433 }
1434
1435 HWTEST_F(ImageFormatConvertTest, RGBAToNV21P010_002, TestSize.Level3)
1436 {
1437 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAToNV21P010_002: start";
1438 PixelFormat tempFormat = PixelFormat::NV21;
1439 PixelFormat srcFormat = PixelFormat::RGBA_8888;
1440 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1441 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1442 RgbConvertToYuvP010ByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
1443 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAToNV21P010_002: end";
1444 }
1445
1446 HWTEST_F(ImageFormatConvertTest, BGRAToNV12P010_001, TestSize.Level3)
1447 {
1448 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV12P010_001: start";
1449 PixelFormat srcFormat = PixelFormat::BGRA_8888;
1450 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1451 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1452 RgbConvertToYuvP010(srcFormat, destFormat, srcSize);
1453 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV12P010_001: end";
1454 }
1455
1456 HWTEST_F(ImageFormatConvertTest, BGRAToNV12P010_002, TestSize.Level3)
1457 {
1458 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV12P010_002: start";
1459 PixelFormat srcFormat = PixelFormat::BGRA_8888;
1460 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1461 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1462 RgbConvertToYuvP010(srcFormat, destFormat, srcSize);
1463 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV12P010_002: end";
1464 }
1465
1466 HWTEST_F(ImageFormatConvertTest, BGRAToNV21P010_001, TestSize.Level3)
1467 {
1468 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV21P010_001: start";
1469 PixelFormat srcFormat = PixelFormat::BGRA_8888;
1470 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1471 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1472 RgbConvertToYuvP010(srcFormat, destFormat, srcSize);
1473 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV21P010_001: end";
1474 }
1475
1476 HWTEST_F(ImageFormatConvertTest, BGRAToNV21P010_002, TestSize.Level3)
1477 {
1478 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV21P010_002: start";
1479 PixelFormat srcFormat = PixelFormat::BGRA_8888;
1480 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1481 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1482 RgbConvertToYuvP010(srcFormat, destFormat, srcSize);
1483 GTEST_LOG_(INFO) << "ImageFormatConvertTest.BGRAToNV21P010_002: end";
1484 }
1485
1486 HWTEST_F(ImageFormatConvertTest, RGBToNV12P010_001, TestSize.Level3)
1487 {
1488 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV12P010_001: start";
1489 PixelFormat tempFormat = PixelFormat::NV12;
1490 PixelFormat srcFormat = PixelFormat::RGB_888;
1491 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1492 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1493 RgbConvertToYuvP010ByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
1494 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV12P010_001: end";
1495 }
1496
1497 HWTEST_F(ImageFormatConvertTest, RGBToNV12P010_002, TestSize.Level3)
1498 {
1499 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV12P010_002: start";
1500 PixelFormat tempFormat = PixelFormat::NV12;
1501 PixelFormat srcFormat = PixelFormat::RGB_888;
1502 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1503 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1504 RgbConvertToYuvP010ByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
1505 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV12P010_002: end";
1506 }
1507
1508 HWTEST_F(ImageFormatConvertTest, RGBToNV21P010_001, TestSize.Level3)
1509 {
1510 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV21P010_001: start";
1511 PixelFormat tempFormat = PixelFormat::NV21;
1512 PixelFormat srcFormat = PixelFormat::RGB_888;
1513 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1514 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1515 RgbConvertToYuvP010ByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
1516 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV21P010_001: end";
1517 }
1518
1519 HWTEST_F(ImageFormatConvertTest, RGBToNV21P010_002, TestSize.Level3)
1520 {
1521 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV21P010_002: start";
1522 PixelFormat tempFormat = PixelFormat::NV21;
1523 PixelFormat srcFormat = PixelFormat::RGB_888;
1524 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1525 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1526 RgbConvertToYuvP010ByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
1527 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBToNV21P010_002: end";
1528 }
1529
1530 HWTEST_F(ImageFormatConvertTest, RGBAF16ToNV12P010_001, TestSize.Level3)
1531 {
1532 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV12P010_001: start";
1533 PixelFormat tempFormat = PixelFormat::NV12;
1534 PixelFormat srcFormat = PixelFormat::RGBA_F16;
1535 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1536 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1537 RgbConvertToYuvP010ByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
1538 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV12P010_001: end";
1539 }
1540
1541 HWTEST_F(ImageFormatConvertTest, RGBAF16ToNV12P010_002, TestSize.Level3)
1542 {
1543 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV12P010_002: start";
1544 PixelFormat tempFormat = PixelFormat::NV12;
1545 PixelFormat srcFormat = PixelFormat::RGBA_F16;
1546 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1547 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1548 RgbConvertToYuvP010ByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
1549 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV12P010_002: end";
1550 }
1551
1552 HWTEST_F(ImageFormatConvertTest, RGBAF16ToNV21P010_001, TestSize.Level3)
1553 {
1554 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV21P010_001: start";
1555 PixelFormat tempFormat = PixelFormat::NV21;
1556 PixelFormat srcFormat = PixelFormat::RGBA_F16;
1557 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1558 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1559 RgbConvertToYuvP010ByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
1560 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV21P010_001: end";
1561 }
1562
1563 HWTEST_F(ImageFormatConvertTest, RGBAF16ToNV21P010_002, TestSize.Level3)
1564 {
1565 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV21P010_002: start";
1566 PixelFormat tempFormat = PixelFormat::NV21;
1567 PixelFormat srcFormat = PixelFormat::RGBA_F16;
1568 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1569 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1570 RgbConvertToYuvP010ByPixelMap(tempFormat, srcFormat, destFormat, srcSize);
1571 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV21P010_002: end";
1572 }
1573
1574 HWTEST_F(ImageFormatConvertTest, RGBA_1010102ToNV12_003, TestSize.Level3)
1575 {
1576 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBA_1010102ToNV12_003: start";
1577 PixelFormat srcFormat = PixelFormat::RGBA_1010102;
1578 PixelFormat destFormat = PixelFormat::NV12;
1579 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1580 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1581 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
1582 Rgba1010102ConvertToYuvP010(srcFormat, destFormat, srcSize, destBuffersize);
1583 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBA_1010102ToNV12_003: end";
1584 }
1585
1586 HWTEST_F(ImageFormatConvertTest, RGBA_1010102ToNV21_003, TestSize.Level3)
1587 {
1588 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBA_1010102ToNV21_003: start";
1589 PixelFormat srcFormat = PixelFormat::RGBA_1010102;
1590 PixelFormat destFormat = PixelFormat::NV21;
1591 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1592 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1593 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
1594 Rgba1010102ConvertToYuvP010(srcFormat, destFormat, srcSize, destBuffersize);
1595 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBAF16ToNV21P010_003: end";
1596 }
1597
1598 HWTEST_F(ImageFormatConvertTest, RGBA_1010102ToNV12P010_003, TestSize.Level3)
1599 {
1600 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBA_1010102ToNV12P010_003: start";
1601 PixelFormat srcFormat = PixelFormat::RGBA_1010102;
1602 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1603 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1604 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1605 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1606 Rgba1010102ConvertToYuvP010(srcFormat, destFormat, srcSize, destBuffersize);
1607 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBA_1010102ToNV12P010_003: end";
1608 }
1609
1610 HWTEST_F(ImageFormatConvertTest, RGBA_1010102ToNV21P010_003, TestSize.Level3)
1611 {
1612 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBA_1010102ToNV21P010_003: start";
1613 PixelFormat srcFormat = PixelFormat::RGBA_1010102;
1614 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1615 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1616 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1617 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1618 Rgba1010102ConvertToYuvP010(srcFormat, destFormat, srcSize, destBuffersize);
1619 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBA_1010102ToNV21P010_003: end";
1620 }
1621
1622 HWTEST_F(ImageFormatConvertTest, GetConvertFuncByFormat_Test_001, TestSize.Level1)
1623 {
1624 GTEST_LOG_(INFO) << "ImageFormatConvertTest: GetConvertFuncByFormat_Test_001 start";
1625 PixelFormat srcFormat = PixelFormat::RGB_888;
1626 PixelFormat destFormat = PixelFormat::NV12;
1627 ConvertFunction cvtFunc = ImageFormatConvertTest::TestGetConvertFuncByFormat(srcFormat, destFormat);
1628
1629 const_uint8_buffer_type srcBuffer = nullptr;
1630 RGBDataInfo rgbInfo = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1631 ColorSpace colorspace = ColorSpace::UNKNOWN;
1632 DestConvertInfo destInfo = {TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT};
1633
1634 EXPECT_EQ(cvtFunc(srcBuffer, rgbInfo, destInfo, colorspace), false);
1635 GTEST_LOG_(INFO) << "ImageFormatConvertTest: GetConvertFuncByFormat_Test_001 end";
1636 }
1637
1638 HWTEST_F(ImageFormatConvertTest, GetConvertFuncByFormat_Test_002, TestSize.Level1)
1639 {
1640 GTEST_LOG_(INFO) << "ImageFormatConvertTest: GetConvertFuncByFormat_Test_004 start";
1641 PixelFormat srcFormat = PixelFormat::RGB_888;
1642 PixelFormat destFormat = PixelFormat::UNKNOWN;
1643 ConvertFunction cvtFunc = ImageFormatConvertTest::TestGetConvertFuncByFormat(srcFormat, destFormat);
1644
1645 EXPECT_EQ(cvtFunc, nullptr);
1646 GTEST_LOG_(INFO) << "ImageFormatConvertTest: GetConvertFuncByFormat_Test_004 end";
1647 }
1648
1649 HWTEST_F(ImageFormatConvertTest, ConvertImageFormat_Test_001, TestSize.Level1)
1650 {
1651 GTEST_LOG_(INFO) << "ImageFormatConvertTest: ConvertImageFormat_Test_001 start";
1652 PixelFormat destFormat = PixelFormat::NV12;
1653 std::shared_ptr<PixelMap> srcPixelMap = nullptr;
1654
1655 uint32_t ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
1656 EXPECT_EQ(ret, ERR_IMAGE_INVALID_PARAMETER);
1657 GTEST_LOG_(INFO) << "ImageFormatConvertTest: ConvertImageFormat_Test_001 end";
1658 }
1659
1660 HWTEST_F(ImageFormatConvertTest, ConvertImageFormat_Test_002, TestSize.Level1)
1661 {
1662 GTEST_LOG_(INFO) << "ImageFormatConvertTest: ConvertImageFormat_Test_002 start";
1663 PixelFormat destFormat = PixelFormat::UNKNOWN;
1664 std::shared_ptr<PixelMap> srcPixelMap = nullptr;
1665 uint32_t errorCode = 0;
1666 DecodeOptions decodeOpts;
1667
1668 SourceOptions opts;
1669 opts.formatHint = "image/jpeg";
1670 std::shared_ptr<ImageSource> rImageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPG_PATH1, opts, errorCode);
1671 ASSERT_EQ(errorCode, SUCCESS);
1672 ASSERT_NE(rImageSource.get(), nullptr);
1673
1674 srcPixelMap = rImageSource->CreatePixelMap(decodeOpts, errorCode);
1675 ASSERT_EQ(errorCode, SUCCESS);
1676 ASSERT_NE(srcPixelMap.get(), nullptr);
1677
1678 uint32_t ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
1679 EXPECT_EQ(ret, ERR_MEDIA_FORMAT_UNSUPPORT);
1680 GTEST_LOG_(INFO) << "ImageFormatConvertTest: ConvertImageFormat_Test_002 end";
1681 }
1682
1683 HWTEST_F(ImageFormatConvertTest, ConvertImageFormat_Test_003, TestSize.Level1)
1684 {
1685 GTEST_LOG_(INFO) << "ImageFormatConvertTest: ConvertImageFormat_Test_003 start";
1686 PixelFormat destFormat = PixelFormat::RGB_888;
1687 std::shared_ptr<PixelMap> srcPixelMap = nullptr;
1688 uint32_t errorCode = 0;
1689 DecodeOptions decodeOpts;
1690
1691 SourceOptions opts;
1692 opts.formatHint = "image/jpeg";
1693 std::shared_ptr<ImageSource> rImageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPG_PATH1, opts, errorCode);
1694 ASSERT_EQ(errorCode, SUCCESS);
1695 ASSERT_NE(rImageSource.get(), nullptr);
1696
1697 srcPixelMap = rImageSource->CreatePixelMap(decodeOpts, errorCode);
1698 ASSERT_EQ(errorCode, SUCCESS);
1699 ASSERT_NE(srcPixelMap.get(), nullptr);
1700
1701 uint32_t ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
1702 EXPECT_EQ(ret, ERR_IMAGE_INVALID_PARAMETER);
1703 GTEST_LOG_(INFO) << "ImageFormatConvertTest: ConvertImageFormat_Test_003 end";
1704 }
1705
1706 HWTEST_F(ImageFormatConvertTest, CheckConvertDataInfo_Test_001, TestSize.Level1)
1707 {
1708 GTEST_LOG_(INFO) << "ImageFormatConvertTest: CheckConvertDataInfo_Test_001 start";
1709 ConvertDataInfo convertDataInfo;
1710 convertDataInfo.buffer = nullptr;
1711 bool cvtFunc = ImageFormatConvert::CheckConvertDataInfo(convertDataInfo);
1712 EXPECT_EQ(cvtFunc, false);
1713 uint8_t data = 0;
1714 convertDataInfo.buffer = &data;
1715 EXPECT_NE(convertDataInfo.buffer, nullptr);
1716 convertDataInfo.pixelFormat = PixelFormat::UNKNOWN;
1717 cvtFunc = ImageFormatConvert::CheckConvertDataInfo(convertDataInfo);
1718 EXPECT_EQ(cvtFunc, false);
1719 convertDataInfo.pixelFormat = PixelFormat::ARGB_8888;
1720 convertDataInfo.imageSize = {0, 0};
1721 cvtFunc = ImageFormatConvert::CheckConvertDataInfo(convertDataInfo);
1722 EXPECT_EQ(cvtFunc, false);
1723 convertDataInfo.imageSize = {1, 1};
1724 EXPECT_EQ(ImageFormatConvert::GetBufferSizeByFormat(convertDataInfo.pixelFormat, convertDataInfo.imageSize), 4);
1725 convertDataInfo.bufferSize = 1;
1726 cvtFunc = ImageFormatConvert::CheckConvertDataInfo(convertDataInfo);
1727 EXPECT_EQ(cvtFunc, false);
1728 convertDataInfo.bufferSize = 4;
1729 cvtFunc = ImageFormatConvert::CheckConvertDataInfo(convertDataInfo);
1730 EXPECT_EQ(cvtFunc, true);
1731 GTEST_LOG_(INFO) << "ImageFormatConvertTest: CheckConvertDataInfo_Test_001 end";
1732 }
1733
1734 HWTEST_F(ImageFormatConvertTest, GetBufferSizeByFormat_Test_001, TestSize.Level1)
1735 {
1736 GTEST_LOG_(INFO) << "ImageFormatConvertTest: GetBufferSizeByFormat_Test_001 start";
1737 Size size = {1, 1};
1738 EXPECT_EQ(ImageFormatConvert::GetBufferSizeByFormat(PixelFormat::RGB_565, size), 2);
1739 EXPECT_EQ(ImageFormatConvert::GetBufferSizeByFormat(PixelFormat::RGB_888, size), 3);
1740 EXPECT_EQ(ImageFormatConvert::GetBufferSizeByFormat(PixelFormat::ARGB_8888, size), 4);
1741 EXPECT_EQ(ImageFormatConvert::GetBufferSizeByFormat(PixelFormat::RGBA_8888, size), 4);
1742 EXPECT_EQ(ImageFormatConvert::GetBufferSizeByFormat(PixelFormat::BGRA_8888, size), 4);
1743 EXPECT_EQ(ImageFormatConvert::GetBufferSizeByFormat(PixelFormat::RGBA_F16, size), 16);
1744 EXPECT_EQ(ImageFormatConvert::GetBufferSizeByFormat(PixelFormat::NV21, size), 3);
1745 EXPECT_EQ(ImageFormatConvert::GetBufferSizeByFormat(PixelFormat::NV12, size), 3);
1746 EXPECT_EQ(ImageFormatConvert::GetBufferSizeByFormat(PixelFormat::UNKNOWN, size), 0);
1747 GTEST_LOG_(INFO) << "ImageFormatConvertTest: GetBufferSizeByFormat_Test_001 end";
1748 }
1749
1750 HWTEST_F(ImageFormatConvertTest, YUVGetConvertFuncByFormat_Test_001, TestSize.Level1)
1751 {
1752 GTEST_LOG_(INFO) << "ImageFormatConvertTest: YUVGetConvertFuncByFormat_Test_001 start";
1753 PixelFormat srcFormat = PixelFormat::UNKNOWN;
1754 PixelFormat destFormat = PixelFormat::ARGB_8888;
1755 EXPECT_EQ(ImageFormatConvert::YUVGetConvertFuncByFormat(srcFormat, destFormat), nullptr);
1756 GTEST_LOG_(INFO) << "ImageFormatConvertTest: YUVGetConvertFuncByFormat_Test_001 end";
1757 }
1758
1759 HWTEST_F(ImageFormatConvertTest, MakeDestPixelMap_Test_001, TestSize.Level1)
1760 {
1761 GTEST_LOG_(INFO) << "ImageFormatConvertTest: MakeDestPixelMap_Test_001 start";
1762 std::shared_ptr<PixelMap> destPixelMap = nullptr;
1763 ImageInfo info;
1764 info.size = {0, 0};
1765 DestConvertInfo destInfo;
1766 EXPECT_EQ(ImageFormatConvert::MakeDestPixelMap(destPixelMap, info, destInfo, nullptr),
1767 ERR_IMAGE_INVALID_PARAMETER);
1768 GTEST_LOG_(INFO) << "ImageFormatConvertTest: MakeDestPixelMap_Test_001 end";
1769 }
1770
1771 HWTEST_F(ImageFormatConvertTest, YUVConvertImageFormatOption_Test_001, TestSize.Level1)
1772 {
1773 GTEST_LOG_(INFO) << "ImageFormatConvertTest: YUVConvertImageFormatOption_Test_001 start";
1774 std::shared_ptr<PixelMap> srcPiexlMap = std::make_shared<PixelMap>();
1775 PixelFormat srcFormat = PixelFormat::UNKNOWN;
1776 PixelFormat destFormat = PixelFormat::ARGB_8888;
1777 EXPECT_EQ(ImageFormatConvert::YUVConvertImageFormatOption(srcPiexlMap, srcFormat, destFormat),
1778 ERR_IMAGE_INVALID_PARAMETER);
1779 srcFormat = PixelFormat::NV21;
1780 destFormat = PixelFormat::RGB_888;
1781 EXPECT_EQ(ImageFormatConvert::YUVConvertImageFormatOption(srcPiexlMap, srcFormat, destFormat),
1782 ERR_IMAGE_INVALID_PARAMETER);
1783 GTEST_LOG_(INFO) << "ImageFormatConvertTest: YUVConvertImageFormatOption_Test_001 end";
1784 }
1785
1786 HWTEST_F(ImageFormatConvertTest, ConvertImageFormat_Test_004, TestSize.Level1)
1787 {
1788 GTEST_LOG_(INFO) << "ImageFormatConvertTest: ConvertImageFormat_Test_004 start";
1789 std::shared_ptr<PixelMap> srcPixelMap = std::make_shared<PixelMap>();
1790 PixelFormat destFormat = PixelFormat::RGB_888;
1791 srcPixelMap->imageInfo_.pixelFormat = PixelFormat::NV21;
1792 uint32_t ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
1793 EXPECT_EQ(ret, ERR_IMAGE_INVALID_PARAMETER);
1794 srcPixelMap->imageInfo_.pixelFormat = PixelFormat::RGB_565;
1795 destFormat = PixelFormat::NV21;
1796 ret = ImageFormatConvert::ConvertImageFormat(srcPixelMap, destFormat);
1797 EXPECT_EQ(ret, ERR_IMAGE_INVALID_PARAMETER);
1798 GTEST_LOG_(INFO) << "ImageFormatConvertTest: ConvertImageFormat_Test_004 end";
1799 }
1800
1801 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_001, TestSize.Level1)
1802 {
1803 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_001 start";
1804 PixelFormat srcFormat = PixelFormat::NV21;
1805 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1806 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1807 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1808 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1809 PixelMapFormatConvert(srcFormat, destFormat, srcSize, destBuffersize);
1810 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_001 end";
1811 }
1812
1813 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_002, TestSize.Level1)
1814 {
1815 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_002 start";
1816 PixelFormat srcFormat = PixelFormat::NV21;
1817 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1818 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1819 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1820 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1821 PixelMapFormatConvert(srcFormat, destFormat, srcSize, destBuffersize);
1822 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_002 end";
1823 }
1824
1825 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_003, TestSize.Level1)
1826 {
1827 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_003 start";
1828 PixelFormat srcFormat = PixelFormat::NV12;
1829 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1830 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
1831 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1832 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1833 PixelMapFormatConvert(srcFormat, destFormat, srcSize, destBuffersize);
1834 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_003 end";
1835 }
1836
1837 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_004, TestSize.Level1)
1838 {
1839 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_004 start";
1840 PixelFormat srcFormat = PixelFormat::NV12;
1841 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1842 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
1843 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1844 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1845 PixelMapFormatConvert(srcFormat, destFormat, srcSize, destBuffersize);
1846 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_004 end";
1847 }
1848
1849 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_005, TestSize.Level1)
1850 {
1851 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_005 start";
1852 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1853 PixelFormat destFormat = PixelFormat::NV12;
1854 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1855 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1856 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
1857 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
1858 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_005 end";
1859 }
1860
1861 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_006, TestSize.Level1)
1862 {
1863 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_006 start";
1864 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1865 PixelFormat destFormat = PixelFormat::NV21;
1866 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1867 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1868 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
1869 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
1870 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_006 end";
1871 }
1872
1873 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_007, TestSize.Level1)
1874 {
1875 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_007 start";
1876 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
1877 PixelFormat destFormat = PixelFormat::NV12;
1878 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1879 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1880 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
1881 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
1882 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_007 end";
1883 }
1884
1885 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_008, TestSize.Level1)
1886 {
1887 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_008 start";
1888 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
1889 PixelFormat destFormat = PixelFormat::NV21;
1890 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1891 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1892 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
1893 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
1894 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_008 end";
1895 }
1896
1897 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_009, TestSize.Level1)
1898 {
1899 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_009 start";
1900 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1901 PixelFormat destFormat = PixelFormat::YCBCR_P010;
1902 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1903 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1904 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1905 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
1906 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_009 end";
1907 }
1908
1909 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_010, TestSize.Level3)
1910 {
1911 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_010: start";
1912 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1913 PixelFormat destFormat = PixelFormat::RGB_565;
1914 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1915 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGB565;
1916 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
1917 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_010: end";
1918 }
1919
1920 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_011, TestSize.Level3)
1921 {
1922 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_011: start";
1923 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1924 PixelFormat destFormat = PixelFormat::RGBA_8888;
1925 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1926 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGBA;
1927 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
1928 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_011: end";
1929 }
1930
1931 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_012, TestSize.Level3)
1932 {
1933 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_012: start";
1934 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1935 PixelFormat destFormat = PixelFormat::BGRA_8888;
1936 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1937 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_BGRA;
1938 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
1939 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_012: end";
1940 }
1941
1942 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_013, TestSize.Level1)
1943 {
1944 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_013 start";
1945 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1946 PixelFormat destFormat = PixelFormat::RGB_888;
1947 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1948 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGB;
1949 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
1950 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_013 end";
1951 }
1952
1953 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_014, TestSize.Level1)
1954 {
1955 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_014 start";
1956 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1957 PixelFormat destFormat = PixelFormat::RGBA_F16;
1958 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1959 uint32_t destBuffersize = srcSize.width * srcSize.height * sizeof(uint64_t);
1960 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
1961 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_014 end";
1962 }
1963
1964 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_015, TestSize.Level1)
1965 {
1966 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_015 start";
1967 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
1968 PixelFormat destFormat = PixelFormat::RGBA_1010102;
1969 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1970 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGBA;
1971 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
1972 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_015 end";
1973 }
1974
1975 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_016, TestSize.Level1)
1976 {
1977 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_016 start";
1978 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
1979 PixelFormat destFormat = PixelFormat::YCRCB_P010;
1980 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1981 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
1982 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
1983 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
1984 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_016 end";
1985 }
1986
1987 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_017, TestSize.Level3)
1988 {
1989 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_017: start";
1990 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
1991 PixelFormat destFormat = PixelFormat::RGB_565;
1992 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
1993 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGB565;
1994 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
1995 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_017: end";
1996 }
1997
1998 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_018, TestSize.Level3)
1999 {
2000 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_018: start";
2001 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
2002 PixelFormat destFormat = PixelFormat::RGBA_8888;
2003 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
2004 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGBA;
2005 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
2006 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_018: end";
2007 }
2008
2009 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_019, TestSize.Level3)
2010 {
2011 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_019: start";
2012 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
2013 PixelFormat destFormat = PixelFormat::BGRA_8888;
2014 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
2015 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_BGRA;
2016 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
2017 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_019: end";
2018 }
2019
2020 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_020, TestSize.Level1)
2021 {
2022 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_020 start";
2023 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
2024 PixelFormat destFormat = PixelFormat::RGB_888;
2025 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
2026 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGB;
2027 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
2028 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_020 end";
2029 }
2030
2031 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_021, TestSize.Level1)
2032 {
2033 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_021 start";
2034 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
2035 PixelFormat destFormat = PixelFormat::RGBA_F16;
2036 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
2037 uint32_t destBuffersize = srcSize.width * srcSize.height * sizeof(uint64_t);
2038 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
2039 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_021 end";
2040 }
2041
2042 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_022, TestSize.Level1)
2043 {
2044 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_022 start";
2045 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
2046 PixelFormat destFormat = PixelFormat::RGBA_1010102;
2047 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
2048 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGBA;
2049 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
2050 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_022 end";
2051 }
2052
2053
2054 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_023, TestSize.Level3)
2055 {
2056 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_023: start";
2057 PixelFormat srcFormat = PixelFormat::RGB_565;
2058 PixelFormat destFormat = PixelFormat::YCBCR_P010;
2059 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
2060 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
2061 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
2062 PixelMapFormatConvert(srcFormat, destFormat, srcSize, destBuffersize);
2063 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_023: end";
2064 }
2065
2066 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_024, TestSize.Level3)
2067 {
2068 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_024: start";
2069 PixelFormat srcFormat = PixelFormat::BGRA_8888;
2070 PixelFormat destFormat = PixelFormat::YCBCR_P010;
2071 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
2072 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
2073 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
2074 PixelMapFormatConvert(srcFormat, destFormat, srcSize, destBuffersize);
2075 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_024: end";
2076 }
2077
2078 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_025, TestSize.Level3)
2079 {
2080 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_025: start";
2081 PixelFormat srcFormat = PixelFormat::RGBA_1010102;
2082 PixelFormat destFormat = PixelFormat::YCBCR_P010;
2083 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
2084 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
2085 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
2086 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
2087 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_025: end";
2088 }
2089
2090 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_026, TestSize.Level3)
2091 {
2092 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_026: start";
2093 PixelFormat srcFormat = PixelFormat::RGB_565;
2094 PixelFormat destFormat = PixelFormat::YCRCB_P010;
2095 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
2096 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
2097 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
2098 PixelMapFormatConvert(srcFormat, destFormat, srcSize, destBuffersize);
2099 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_026: end";
2100 }
2101
2102 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_027, TestSize.Level3)
2103 {
2104 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_027: start";
2105 PixelFormat srcFormat = PixelFormat::BGRA_8888;
2106 PixelFormat destFormat = PixelFormat::YCRCB_P010;
2107 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
2108 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
2109 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
2110 PixelMapFormatConvert(srcFormat, destFormat, srcSize, destBuffersize);
2111 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_027: end";
2112 }
2113
2114 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_028, TestSize.Level3)
2115 {
2116 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_028: start";
2117 PixelFormat srcFormat = PixelFormat::RGBA_1010102;
2118 PixelFormat destFormat = PixelFormat::YCRCB_P010;
2119 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
2120 uint32_t destBuffersize = (srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
2121 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES) * TWO_SLICES;
2122 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
2123 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_028: end";
2124 }
2125
2126 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_029, TestSize.Level3)
2127 {
2128 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_029: start";
2129 PixelFormat srcFormat = PixelFormat::NV12;
2130 PixelFormat destFormat = PixelFormat::RGBA_1010102;
2131 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
2132 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGBA;
2133 PixelMapFormatConvert(srcFormat, destFormat, srcSize, destBuffersize);
2134 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_029: end";
2135 }
2136
2137 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_030, TestSize.Level3)
2138 {
2139 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_030: start";
2140 PixelFormat srcFormat = PixelFormat::NV21;
2141 PixelFormat destFormat = PixelFormat::RGBA_1010102;
2142 Size srcSize = { TREE_ORIGINAL_WIDTH, TREE_ORIGINAL_HEIGHT };
2143 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGBA;
2144 PixelMapFormatConvert(srcFormat, destFormat, srcSize, destBuffersize);
2145 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_030: end";
2146 }
2147
2148 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_031, TestSize.Level3)
2149 {
2150 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_031: start";
2151 PixelFormat srcFormat = PixelFormat::RGBA_1010102;
2152 PixelFormat destFormat = PixelFormat::NV12;
2153 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
2154 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
2155 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
2156 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
2157 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_031: end";
2158 }
2159
2160 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_032, TestSize.Level3)
2161 {
2162 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_032: start";
2163 PixelFormat srcFormat = PixelFormat::RGBA_1010102;
2164 PixelFormat destFormat = PixelFormat::NV21;
2165 Size srcSize = { P010_ORIGINAL_WIDTH, P010_ORIGINAL_HEIGHT };
2166 uint32_t destBuffersize = srcSize.width * srcSize.height + ((srcSize.width + 1) / EVEN_ODD_DIVISOR) *
2167 ((srcSize.height + 1) / EVEN_ODD_DIVISOR) * TWO_SLICES;
2168 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
2169 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_032: end";
2170 }
2171
2172 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_033, TestSize.Level3)
2173 {
2174 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_033: start";
2175 PixelFormat srcFormat = PixelFormat::YCRCB_P010;
2176 PixelFormat destFormat = PixelFormat::RGB_565;
2177 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
2178 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGB565;
2179 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
2180 GTEST_LOG_(INFO) << "ImageFormatConvertTest: PixelMapFormatConvert_033: end";
2181 }
2182
2183 HWTEST_F(ImageFormatConvertTest, PixelMapFormatConvert_034, TestSize.Level3)
2184 {
2185 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_034: start";
2186 PixelFormat srcFormat = PixelFormat::YCBCR_P010;
2187 PixelFormat destFormat = PixelFormat::RGB_565;
2188 Size srcSize = { ODDTREE_ORIGINAL_WIDTH, ODDTREE_ORIGINAL_HEIGHT };
2189 uint32_t destBuffersize = srcSize.width * srcSize.height * BYTES_PER_PIXEL_RGB565;
2190 PixelMap10bitConvert(srcFormat, destFormat, srcSize, destBuffersize);
2191 GTEST_LOG_(INFO) << "ImageFormatConvertTest.PixelMapFormatConvert_034: end";
2192 }
2193
2194 /**
2195 * @tc.name: RGBConvertImageFormatOptionUnique_001
2196 * @tc.desc: Verify RGB convert image format option using RGBConvertImageFormatOptionUnique.
2197 * @tc.type: FUNC
2198 */
2199 HWTEST_F(ImageFormatConvertTest, RGBConvertImageFormatOptionUnique_001, TestSize.Level3)
2200 {
2201 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBConvertImageFormatOptionUnique_001: start";
2202 PixelFormat srcFormat = PixelFormat::RGBA_8888;
2203 PixelFormat destFormat = PixelFormat::NV12;
2204 RGBConvertToYUVByUnique(srcFormat, destFormat);
2205 GTEST_LOG_(INFO) << "ImageFormatConvertTest.RGBConvertImageFormatOptionUnique_001: end";
2206 }
2207 } // namespace Media
2208 } // namespace OHOS