1 /*
2 * Copyright (C) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <iostream>
16 #include <chrono>
17 #include "gtest/gtest.h"
18 #include "video_processing.h"
19 #include "video_sample.h"
20 using namespace std;
21 using namespace OHOS;
22 using namespace testing::ext;
23 namespace {
24 bool g_isHardware = true;
25 class VpeVideoFuncTest : public testing::Test {
26 public:
27 // SetUpTestCase: Called before all test cases
28 static void SetUpTestCase(void);
29 // TearDownTestCase: Called after all test case
30 static void TearDownTestCase(void);
31 // SetUp: Called before each test cases
32 void SetUp(void);
33 // TearDown: Called after each test cases
34 void TearDown(void);
35 };
36
SetUpTestCase()37 void VpeVideoFuncTest::SetUpTestCase()
38 {
39 OH_VideoProcessing_InitializeEnvironment();
40 if (!access("/vendor/bin/himediacomm_bak", 0)) {
41 g_isHardware = false;
42 }
43 }
TearDownTestCase()44 void VpeVideoFuncTest::TearDownTestCase()
45 {
46 OH_VideoProcessing_DeinitializeEnvironment();
47 }
SetUp()48 void VpeVideoFuncTest::SetUp()
49 {
50 }
TearDown()51 void VpeVideoFuncTest::TearDown()
52 {
53 }
54 }
55
56 namespace {
57 #ifdef ENABLE_ALL_PROCESS
58 /**
59 * @tc.number : VPE_VIDEO_FUNC_TEST_0010
60 * @tc.name : test HDRVivid2SDR ,src colorspace PQ@10bit NV12,convert to BT709@NV12
61 * @tc.desc : function test
62 */
63 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0010, TestSize.Level0)
64 {
65 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
66 sample->inputFilePath = "/data/test/media/vivid_pq_nv12.yuv";
67 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
68 sample->outputFilePath = "/data/test/media/vivid_pq_nv12_out_bt709_nv12.yuv";
69 sample->isHDRVivid = true;
70 sample->defaultPixelFormat = "nv12";
71 sample->convertType = "hdr2sdr_nv12_nv12";
72 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
73 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT709_LIMIT};
74 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
75 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
76
77 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
78 sample->StartProcess();
79 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
80 ASSERT_TRUE(sample->md5Equal);
81 }
82
83 /**
84 * @tc.number : VPE_VIDEO_FUNC_TEST_0020
85 * @tc.name : test HDRVivid2SDR ,src colorspace PQ@10bit NV12,convert to BT709@NV21
86 * @tc.desc : function test
87 */
88 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0020, TestSize.Level0)
89 {
90 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
91 sample->inputFilePath = "/data/test/media/vivid_pq_nv12.yuv";
92 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
93 sample->outputFilePath = "/data/test/media/vivid_pq_nv12_out_bt709_nv21.yuv";
94 sample->isHDRVivid = true;
95 sample->defaultPixelFormat = "nv12";
96 sample->convertType = "hdr2sdr_nv12_nv21";
97 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
98 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT709_LIMIT};
99 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
100 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
101
102 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
103 sample->StartProcess();
104 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
105 ASSERT_TRUE(sample->md5Equal);
106 }
107
108 /**
109 * @tc.number : VPE_VIDEO_FUNC_TEST_0030
110 * @tc.name : test HDRVivid2SDR ,src colorspace PQ@10bit NV12,convert to BT709@RGBA8888
111 * @tc.desc : function test
112 */
113 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0030, TestSize.Level0)
114 {
115 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
116 sample->inputFilePath = "/data/test/media/vivid_pq_nv12.yuv";
117 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
118 sample->outputFilePath = "/data/test/media/vivid_pq_nv12_out_bt709_rgba8888.yuv";
119 sample->isHDRVivid = true;
120 sample->defaultPixelFormat = "nv12";
121 sample->convertType = "hdr2sdr_nv12_rgba8888";
122 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
123 NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT709_LIMIT};
124 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
125 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
126 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
127 sample->StartProcess();
128 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
129 ASSERT_TRUE(sample->md5Equal);
130 }
131
132 /**
133 * @tc.number : VPE_VIDEO_FUNC_TEST_0040
134 * @tc.name : test HDRVivid2SDR ,src colorspace PQ@10bit NV21,convert to BT709@NV12
135 * @tc.desc : function test
136 */
137 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0040, TestSize.Level0)
138 {
139 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
140 sample->inputFilePath = "/data/test/media/vivid_pq_nv21.yuv";
141 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
142 sample->outputFilePath = "/data/test/media/vivid_pq_nv21_out_bt709_nv12.yuv";
143 sample->isHDRVivid = true;
144 sample->defaultPixelFormat = "nv21";
145 sample->convertType = "hdr2sdr_nv21_nv12";
146 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
147 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT709_LIMIT};
148 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
149 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
150 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
151 sample->StartProcess();
152 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
153 ASSERT_TRUE(sample->md5Equal);
154 }
155
156 /**
157 * @tc.number : VPE_VIDEO_FUNC_TEST_0050
158 * @tc.name : test HDRVivid2SDR ,src colorspace PQ@10bit NV21,convert to BT709@NV21
159 * @tc.desc : function test
160 */
161 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0050, TestSize.Level0)
162 {
163
164 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
165 sample->inputFilePath = "/data/test/media/vivid_pq_nv21.yuv";
166 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
167 sample->outputFilePath = "/data/test/media/vivid_pq_nv21_out_bt709_nv21.yuv";
168 sample->isHDRVivid = true;
169 sample->defaultPixelFormat = "nv21";
170 sample->convertType = "hdr2sdr_nv21_nv21";
171 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
172 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT709_LIMIT};
173 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
174 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
175 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
176 sample->StartProcess();
177 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
178 ASSERT_TRUE(sample->md5Equal);
179 }
180
181 /**
182 * @tc.number : VPE_VIDEO_FUNC_TEST_0060
183 * @tc.name : test HDRVivid2SDR ,src colorspace PQ@10bit NV21,convert to BT709@RGBA8888
184 * @tc.desc : function test
185 */
186 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0060, TestSize.Level0)
187 {
188 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
189 sample->inputFilePath = "/data/test/media/vivid_pq_nv21.yuv";
190 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
191 sample->outputFilePath = "/data/test/media/vivid_pq_nv21_out_bt709_rgba8888.yuv";
192 sample->isHDRVivid = true;
193 sample->defaultPixelFormat = "nv21";
194 sample->convertType = "hdr2sdr_nv21_rgba8888";
195 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
196 NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT709_LIMIT};
197 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
198 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
199 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
200 sample->StartProcess();
201 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
202 ASSERT_TRUE(sample->md5Equal);
203 }
204
205 /**
206 * @tc.number : VPE_VIDEO_FUNC_TEST_0070
207 * @tc.name : test HDRVivid2SDR ,src colorspace PQ@10bit RGBA,convert to BT709@NV12
208 * @tc.desc : function test
209 */
210 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0070, TestSize.Level0)
211 {
212 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
213 sample->inputFilePath = "/data/test/media/vivid_pq_rgba.yuv";
214 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
215 sample->outputFilePath = "/data/test/media/vivid_pq_rgba_out_bt709_nv12.yuv";
216 sample->isHDRVivid = true;
217 sample->defaultPixelFormat = "rgba";
218 sample->convertType = "hdr2sdr_rgba_nv12";
219 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_PQ_LIMIT,
220 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT709_LIMIT};
221 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
222 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
223
224 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
225 sample->StartProcess();
226 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
227 ASSERT_TRUE(sample->md5Equal);
228 }
229
230 /**
231 * @tc.number : VPE_VIDEO_FUNC_TEST_0080
232 * @tc.name : test HDRVivid2SDR ,src colorspace PQ@10bit RGBA,convert to BT709@NV21
233 * @tc.desc : function test
234 */
235 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0080, TestSize.Level0)
236 {
237 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
238 sample->inputFilePath = "/data/test/media/vivid_pq_rgba.yuv";
239 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
240 sample->outputFilePath = "/data/test/media/vivid_pq_rgba_out_bt709_nv21.yuv";
241 sample->isHDRVivid = true;
242 sample->defaultPixelFormat = "rgba";
243 sample->convertType = "hdr2sdr_rgba_nv21";
244 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_PQ_LIMIT,
245 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT709_LIMIT};
246 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
247 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
248
249 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
250 sample->StartProcess();
251 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
252 ASSERT_TRUE(sample->md5Equal);
253 }
254
255 /**
256 * @tc.number : VPE_VIDEO_FUNC_TEST_0090
257 * @tc.name : test HDRVivid2SDR ,src colorspace PQ@10bit RGBA,convert to BT709@RGBA8888
258 * @tc.desc : function test
259 */
260 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0090, TestSize.Level0)
261 {
262 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
263 sample->isHDRVivid = true;
264 sample->inputFilePath = "/data/test/media/vivid_pq_rgba.yuv";
265 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
266 sample->outputFilePath = "/data/test/media/vivid_pq_rgba_out_bt709_rgba8888.yuv";
267 sample->defaultPixelFormat = "rgba";
268 sample->convertType = "hdr2sdr_rgba_rgba8888";
269 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT,
270 NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT709_LIMIT};
271 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
272 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
273 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
274 sample->StartProcess();
275 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
276 ASSERT_TRUE(sample->md5Equal);
277 }
278
279 /**
280 * @tc.number : VPE_VIDEO_FUNC_TEST_0100
281 * @tc.name : test HDRVivid2SDR ,src colorspace HLG@10bit NV12,convert to BT709@NV12
282 * @tc.desc : function test
283 */
284 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0100, TestSize.Level0)
285 {
286 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
287 sample->isHDRVivid = true;
288 sample->inputFilePath = "/data/test/media/vivid_hlg_nv12.yuv";
289 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
290 sample->outputFilePath = "/data/test/media/vivid_hlg_nv12_out_bt709_nv12.yuv";
291 sample->defaultPixelFormat = "nv12";
292 if (g_isHardware) {
293 sample->convertType = "hdr2sdr_nv12_nv12";
294 } else {
295 sample->convertType = "hdr2sdr_nv12_nv12_sw";
296 }
297 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
298 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT709_LIMIT};
299 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
300 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
301 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
302 sample->StartProcess();
303 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
304 ASSERT_TRUE(sample->md5Equal);
305 }
306
307 /**
308 * @tc.number : VPE_VIDEO_FUNC_TEST_0110
309 * @tc.name : test HDRVivid2SDR ,src colorspace HLG@10bit NV12,convert to BT709@NV21
310 * @tc.desc : function test
311 */
312 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0110, TestSize.Level0)
313 {
314 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
315 sample->isHDRVivid = true;
316 sample->inputFilePath = "/data/test/media/vivid_hlg_nv12.yuv";
317 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
318 sample->outputFilePath = "/data/test/media/vivid_hlg_nv12_out_bt709_nv21.yuv";
319 sample->defaultPixelFormat = "nv12";
320 if (g_isHardware) {
321 sample->convertType = "hdr2sdr_nv12_nv21";
322 } else {
323 sample->convertType = "hdr2sdr_nv12_nv21_sw";
324 }
325 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
326 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT709_LIMIT};
327 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
328 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
329 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
330 sample->StartProcess();
331 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
332 ASSERT_TRUE(sample->md5Equal);
333 }
334
335 /**
336 * @tc.number : VPE_VIDEO_FUNC_TEST_0120
337 * @tc.name : test HDRVivid2SDR ,src colorspace HLG@10bit NV12,convert to BT709@RGBA8888
338 * @tc.desc : function test
339 */
340 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0120, TestSize.Level0)
341 {
342 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
343 sample->isHDRVivid = true;
344 sample->inputFilePath = "/data/test/media/vivid_hlg_nv12.yuv";
345 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
346 sample->outputFilePath = "/data/test/media/vivid_hlg_nv12_out_bt709_rgba8888.yuv";
347 sample->defaultPixelFormat = "nv12";
348 if (g_isHardware) {
349 sample->convertType = "hdr2sdr_nv12_rgba8888";
350 } else {
351 sample->convertType = "hdr2sdr_nv12_rgba8888_sw";
352 }
353 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
354 NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT709_LIMIT};
355 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
356 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
357 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
358 sample->StartProcess();
359 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
360 ASSERT_TRUE(sample->md5Equal);
361 }
362
363 /**
364 * @tc.number : VPE_VIDEO_FUNC_TEST_0130
365 * @tc.name : test HDRVivid2SDR ,src colorspace HLG@10bit NV21,convert to BT709@NV12
366 * @tc.desc : function test
367 */
368 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0130, TestSize.Level0)
369 {
370 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
371 sample->isHDRVivid = true;
372 sample->inputFilePath = "/data/test/media/vivid_hlg_nv21.yuv";
373 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
374 sample->outputFilePath = "/data/test/media/vivid_hlg_nv21_out_bt709_nv12.yuv";
375 sample->defaultPixelFormat = "nv21";
376 if (g_isHardware) {
377 sample->convertType = "hdr2sdr_nv21_nv12";
378 } else {
379 sample->convertType = "hdr2sdr_nv21_nv12_sw";
380 }
381 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
382 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT709_LIMIT};
383 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
384 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
385 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
386 sample->StartProcess();
387 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
388 ASSERT_TRUE(sample->md5Equal);
389 }
390
391 /**
392 * @tc.number : VPE_VIDEO_FUNC_TEST_0140
393 * @tc.name : test HDRVivid2SDR ,src colorspace HLG@10bit NV21,convert to BT709@NV21
394 * @tc.desc : function test
395 */
396 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0140, TestSize.Level0)
397 {
398 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
399 sample->isHDRVivid = true;
400 sample->inputFilePath = "/data/test/media/vivid_hlg_nv21.yuv";
401 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
402 sample->outputFilePath = "/data/test/media/vivid_hlg_nv21_out_bt709_nv21.yuv";
403 sample->defaultPixelFormat = "nv21";
404 if (g_isHardware) {
405 sample->convertType = "hdr2sdr_nv21_nv21";
406 } else {
407 sample->convertType = "hdr2sdr_nv21_nv21_sw";
408 }
409 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
410 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT709_LIMIT};
411 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
412 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
413 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
414 sample->StartProcess();
415 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
416 ASSERT_TRUE(sample->md5Equal);
417 }
418
419 /**
420 * @tc.number : VPE_VIDEO_FUNC_TEST_0150
421 * @tc.name : test HDRVivid2SDR ,src colorspace HLG@10bit NV21,convert to BT709@RGBA8888
422 * @tc.desc : function test
423 */
424 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0150, TestSize.Level0)
425 {
426 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
427 sample->isHDRVivid = true;
428 sample->inputFilePath = "/data/test/media/vivid_hlg_nv21.yuv";
429 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
430 sample->outputFilePath = "/data/test/media/vivid_hlg_nv21_out_bt709_rgba8888.yuv";
431 sample->defaultPixelFormat = "nv21";
432 if (g_isHardware) {
433 sample->convertType = "hdr2sdr_nv21_rgba8888";
434 } else {
435 sample->convertType = "hdr2sdr_nv21_rgba8888_sw";
436 }
437 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
438 NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT709_LIMIT};
439 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
440 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
441 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
442 sample->StartProcess();
443 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
444 ASSERT_TRUE(sample->md5Equal);
445 }
446
447 /**
448 * @tc.number : VPE_VIDEO_FUNC_TEST_0160
449 * @tc.name : test HDRVivid2SDR ,src colorspace HLG@10bit RGBA,convert to BT709@NV12
450 * @tc.desc : function test
451 */
452 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0160, TestSize.Level0)
453 {
454 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
455 sample->isHDRVivid = true;
456 sample->inputFilePath = "/data/test/media/vivid_hlg_rgba.yuv";
457 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
458 sample->outputFilePath = "/data/test/media/vivid_hlg_rgba_out_bt709_nv12.yuv";
459 sample->defaultPixelFormat = "rgba";
460 if (g_isHardware) {
461 sample->convertType = "hdr2sdr_rgba_nv12";
462 } else {
463 sample->convertType = "hdr2sdr_rgba_nv12_sw";
464 }
465 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT,
466 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT709_LIMIT};
467 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
468 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
469 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
470 sample->StartProcess();
471 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
472 ASSERT_TRUE(sample->md5Equal);
473 }
474
475 /**
476 * @tc.number : VPE_VIDEO_FUNC_TEST_0170
477 * @tc.name : test HDRVivid2SDR ,src colorspace HLG@10bit RGBA,convert to BT709@NV21
478 * @tc.desc : function test
479 */
480 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0170, TestSize.Level0)
481 {
482 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
483 sample->isHDRVivid = true;
484 sample->inputFilePath = "/data/test/media/vivid_hlg_rgba.yuv";
485 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
486 sample->outputFilePath = "/data/test/media/vivid_hlg_rgba_out_bt709_nv21.yuv";
487 sample->defaultPixelFormat = "rgba";
488 if (g_isHardware) {
489 sample->convertType = "hdr2sdr_rgba_nv21";
490 } else {
491 sample->convertType = "hdr2sdr_rgba_nv21_sw";
492 }
493 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT,
494 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT709_LIMIT};
495 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
496 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
497 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
498 sample->StartProcess();
499 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
500 ASSERT_TRUE(sample->md5Equal);
501 }
502
503 /**
504 * @tc.number : VPE_VIDEO_FUNC_TEST_0180
505 * @tc.name : test HDRVivid2SDR ,src colorspace HLG@10bit RGBA,convert to BT709@RGBA8888
506 * @tc.desc : function test
507 */
508 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0180, TestSize.Level0)
509 {
510 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
511 sample->isHDRVivid = true;
512 sample->inputFilePath = "/data/test/media/vivid_hlg_rgba.yuv";
513 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
514 sample->outputFilePath = "/data/test/media/vivid_hlg_rgba_out_bt709_rgba8888.yuv";
515 sample->defaultPixelFormat = "rgba";
516 if (g_isHardware) {
517 sample->convertType = "hdr2sdr_rgba_rgba8888";
518 } else {
519 sample->convertType = "hdr2sdr_rgba_rgba8888_sw";
520 }
521 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT,
522 NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT709_LIMIT};
523 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
524 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
525 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
526 sample->StartProcess();
527 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
528 ASSERT_TRUE(sample->md5Equal);
529 }
530
531 /**
532 * @tc.number : VPE_VIDEO_FUNC_TEST_0190
533 * @tc.name : test SDR2SDR ,src colorspace EBU@NV12,convert to BT709@NV12
534 * @tc.desc : function test
535 */
536 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0190, TestSize.Level0)
537 {
538 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
539 sample->inputFilePath = "/data/test/media/ebu_nv12.yuv";
540 sample->outputFilePath = "/data/test/media/ebu_nv12_out_bt709_nv12.yuv";
541 sample->defaultPixelFormat = "nv12";
542 sample->convertType = "sdr2sdr_nv12_nv12";
543 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT601_EBU_LIMIT,
544 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT709_LIMIT};
545 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
546 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
547 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
548 sample->StartProcess();
549 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
550 ASSERT_TRUE(sample->md5Equal);
551 }
552
553 /**
554 * @tc.number : VPE_VIDEO_FUNC_TEST_0200
555 * @tc.name : test SDR2SDR ,src colorspace EBU@NV12,convert to BT709@NV21
556 * @tc.desc : function test
557 */
558 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0200, TestSize.Level0)
559 {
560 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
561 sample->inputFilePath = "/data/test/media/ebu_nv12.yuv";
562 sample->outputFilePath = "/data/test/media/ebu_nv12_out_bt709_nv21.yuv";
563 sample->defaultPixelFormat = "nv12";
564 sample->convertType = "sdr2sdr_nv12_nv21";
565 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT601_EBU_LIMIT,
566 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT709_LIMIT};
567 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
568 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
569 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
570 sample->StartProcess();
571 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
572 ASSERT_TRUE(sample->md5Equal);
573 }
574
575 /**
576 * @tc.number : VPE_VIDEO_FUNC_TEST_0210
577 * @tc.name : test SDR2SDR ,src colorspace EBU@NV12,convert to BT709@RGBA
578 * @tc.desc : function test
579 */
580 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0210, TestSize.Level0)
581 {
582 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
583 sample->inputFilePath = "/data/test/media/ebu_nv12.yuv";
584 sample->outputFilePath = "/data/test/media/ebu_nv12_out_bt709_rgba.yuv";
585 sample->defaultPixelFormat = "nv12";
586 sample->convertType = "sdr2sdr_nv12_rgba";
587 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT601_EBU_LIMIT,
588 NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT709_LIMIT};
589 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
590 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
591 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
592 sample->StartProcess();
593 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
594 ASSERT_TRUE(sample->md5Equal);
595 }
596
597 /**
598 * @tc.number : VPE_VIDEO_FUNC_TEST_0220
599 * @tc.name : test SDR2SDR ,src colorspace EBU@NV21,convert to BT709@NV12
600 * @tc.desc : function test
601 */
602 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0220, TestSize.Level0)
603 {
604 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
605 sample->inputFilePath = "/data/test/media/ebu_nv21.yuv";
606 sample->outputFilePath = "/data/test/media/ebu_nv21_out_bt709_nv12.yuv";
607 sample->defaultPixelFormat = "nv21";
608 sample->convertType = "sdr2sdr_nv21_nv12";
609 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT601_EBU_LIMIT,
610 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT709_LIMIT};
611 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
612 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
613 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
614 sample->StartProcess();
615 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
616 ASSERT_TRUE(sample->md5Equal);
617 }
618
619 /**
620 * @tc.number : VPE_VIDEO_FUNC_TEST_0230
621 * @tc.name : test SDR2SDR ,src colorspace EBU@NV21,convert to BT709@NV21
622 * @tc.desc : function test
623 */
624 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0230, TestSize.Level0)
625 {
626 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
627 sample->inputFilePath = "/data/test/media/ebu_nv21.yuv";
628 sample->outputFilePath = "/data/test/media/ebu_nv21_out_bt709_nv21.yuv";
629 sample->defaultPixelFormat = "nv21";
630 sample->convertType = "sdr2sdr_nv21_nv21";
631 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT601_EBU_LIMIT,
632 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT709_LIMIT};
633 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
634 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
635 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
636 sample->StartProcess();
637 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
638 ASSERT_TRUE(sample->md5Equal);
639 }
640
641 /**
642 * @tc.number : VPE_VIDEO_FUNC_TEST_0240
643 * @tc.name : test SDR2SDR ,src colorspace EBU@NV21,convert to BT709@RGBA
644 * @tc.desc : function test
645 */
646 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0240, TestSize.Level0)
647 {
648 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
649 sample->inputFilePath = "/data/test/media/ebu_nv21.yuv";
650 sample->outputFilePath = "/data/test/media/ebu_nv21_out_bt709_rgba.yuv";
651 sample->defaultPixelFormat = "nv21";
652 sample->convertType = "sdr2sdr_nv21_rgba";
653 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT601_EBU_LIMIT,
654 NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT709_LIMIT};
655 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
656 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
657 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
658 sample->StartProcess();
659 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
660 ASSERT_TRUE(sample->md5Equal);
661 }
662
663 /**
664 * @tc.number : VPE_VIDEO_FUNC_TEST_0250
665 * @tc.name : test SDR2SDR ,src colorspace EBU@RGBA,convert to BT709@NV12
666 * @tc.desc : function test
667 */
668 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0250, TestSize.Level0)
669 {
670 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
671 sample->inputFilePath = "/data/test/media/ebu_rgba.yuv";
672 sample->outputFilePath = "/data/test/media/ebu_rgba_out_bt709_nv12.yuv";
673 sample->defaultPixelFormat = "rgba";
674 sample->convertType = "sdr2sdr_rgba_nv12";
675 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT601_EBU_LIMIT,
676 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT709_LIMIT};
677 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
678 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
679 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
680 sample->StartProcess();
681 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
682 ASSERT_TRUE(sample->md5Equal);
683 }
684
685 /**
686 * @tc.number : VPE_VIDEO_FUNC_TEST_0260
687 * @tc.name : test SDR2SDR ,src colorspace EBU@RGBA,convert to BT709@NV21
688 * @tc.desc : function test
689 */
690 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0260, TestSize.Level0)
691 {
692 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
693 sample->inputFilePath = "/data/test/media/ebu_rgba.yuv";
694 sample->outputFilePath = "/data/test/media/ebu_rgba_out_bt709_nv21.yuv";
695 sample->defaultPixelFormat = "rgba";
696 sample->convertType = "sdr2sdr_rgba_nv21";
697 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT601_EBU_LIMIT,
698 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT709_LIMIT};
699 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
700 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
701 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
702 sample->StartProcess();
703 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
704 ASSERT_TRUE(sample->md5Equal);
705 }
706
707 /**
708 * @tc.number : VPE_VIDEO_FUNC_TEST_0270
709 * @tc.name : test SDR2SDR ,src colorspace EBU@RGBA,convert to BT709@RGBA
710 * @tc.desc : function test
711 */
712 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0270, TestSize.Level0)
713 {
714 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
715 sample->inputFilePath = "/data/test/media/ebu_rgba.yuv";
716 sample->outputFilePath = "/data/test/media/ebu_rgba_out_bt709_rgba.yuv";
717 sample->defaultPixelFormat = "rgba";
718 sample->convertType = "sdr2sdr_rgba_rgba";
719 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT601_EBU_LIMIT,
720 NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT709_LIMIT};
721 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
722 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
723 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
724 sample->StartProcess();
725 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
726 ASSERT_TRUE(sample->md5Equal);
727 }
728
729 /**
730 * @tc.number : VPE_VIDEO_FUNC_TEST_0280
731 * @tc.name : test SDR2SDR ,src colorspace SMPTEC@NV12,convert to BT709@NV12
732 * @tc.desc : function test
733 */
734 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0280, TestSize.Level0)
735 {
736 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
737 sample->inputFilePath = "/data/test/media/smptec_nv12.yuv";
738 sample->outputFilePath = "/data/test/media/smptec_nv12_out_bt709_nv12.yuv";
739 sample->defaultPixelFormat = "nv12";
740 sample->convertType = "sdr2sdr_nv12_nv12";
741 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT601_SMPTE_C_LIMIT,
742 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT709_LIMIT};
743 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
744 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
745 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
746 sample->StartProcess();
747 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
748 ASSERT_TRUE(sample->md5Equal);
749 }
750
751 /**
752 * @tc.number : VPE_VIDEO_FUNC_TEST_0290
753 * @tc.name : test SDR2SDR ,src colorspace SMPTEC@NV12,convert to BT709@NV21
754 * @tc.desc : function test
755 */
756 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0290, TestSize.Level0)
757 {
758 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
759 sample->inputFilePath = "/data/test/media/smptec_nv12.yuv";
760 sample->outputFilePath = "/data/test/media/smptec_nv12_out_bt709_nv21.yuv";
761 sample->defaultPixelFormat = "nv12";
762 sample->convertType = "sdr2sdr_nv12_nv21";
763 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT601_SMPTE_C_LIMIT,
764 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT709_LIMIT};
765 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
766 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
767 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
768 sample->StartProcess();
769 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
770 ASSERT_TRUE(sample->md5Equal);
771 }
772
773 /**
774 * @tc.number : VPE_VIDEO_FUNC_TEST_0300
775 * @tc.name : test SDR2SDR ,src colorspace SMPTEC@NV12,convert to BT709@RGBA
776 * @tc.desc : function test
777 */
778 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0300, TestSize.Level0)
779 {
780 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
781 sample->inputFilePath = "/data/test/media/smptec_nv12.yuv";
782 sample->outputFilePath = "/data/test/media/smptec_nv12_out_bt709_rgba.yuv";
783 sample->defaultPixelFormat = "nv12";
784 sample->convertType = "sdr2sdr_nv12_rgba";
785 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT601_SMPTE_C_LIMIT,
786 NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT709_LIMIT};
787 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
788 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
789 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
790 sample->StartProcess();
791 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
792 ASSERT_TRUE(sample->md5Equal);
793 }
794
795 /**
796 * @tc.number : VPE_VIDEO_FUNC_TEST_0310
797 * @tc.name : test SDR2SDR ,src colorspace SMPTEC@NV21,convert to BT709@NV12
798 * @tc.desc : function test
799 */
800 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0310, TestSize.Level0)
801 {
802 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
803 sample->inputFilePath = "/data/test/media/smptec_nv21.yuv";
804 sample->outputFilePath = "/data/test/media/smptec_nv21_out_bt709_nv12.yuv";
805 sample->defaultPixelFormat = "nv21";
806 sample->convertType = "sdr2sdr_nv21_nv12";
807 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT601_SMPTE_C_LIMIT,
808 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT709_LIMIT};
809 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
810 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
811 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
812 sample->StartProcess();
813 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
814 ASSERT_TRUE(sample->md5Equal);
815 }
816
817 /**
818 * @tc.number : VPE_VIDEO_FUNC_TEST_0320
819 * @tc.name : test SDR2SDR ,src colorspace SMPTEC@NV21,convert to BT709@NV21
820 * @tc.desc : function test
821 */
822 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0320, TestSize.Level0)
823 {
824 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
825 sample->inputFilePath = "/data/test/media/smptec_nv21.yuv";
826 sample->outputFilePath = "/data/test/media/smptec_nv21_out_bt709_nv21.yuv";
827 sample->defaultPixelFormat = "nv21";
828 sample->convertType = "sdr2sdr_nv21_nv21";
829 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT601_SMPTE_C_LIMIT,
830 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT709_LIMIT};
831 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
832 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
833 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
834 sample->StartProcess();
835 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
836 ASSERT_TRUE(sample->md5Equal);
837 }
838
839 /**
840 * @tc.number : VPE_VIDEO_FUNC_TEST_0330
841 * @tc.name : test SDR2SDR ,src colorspace SMPTEC@NV21,convert to BT709@RGBA
842 * @tc.desc : function test
843 */
844 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0330, TestSize.Level0)
845 {
846 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
847 sample->inputFilePath = "/data/test/media/smptec_nv21.yuv";
848 sample->outputFilePath = "/data/test/media/smptec_nv21_out_bt709_rgba.yuv";
849 sample->defaultPixelFormat = "nv21";
850 sample->convertType = "sdr2sdr_nv21_rgba";
851 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT601_SMPTE_C_LIMIT,
852 NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT709_LIMIT};
853 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
854 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
855 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
856 sample->StartProcess();
857 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
858 ASSERT_TRUE(sample->md5Equal);
859 }
860
861 /**
862 * @tc.number : VPE_VIDEO_FUNC_TEST_0340
863 * @tc.name : test SDR2SDR ,src colorspace SMPTEC@RGBA,convert to BT709@NV12
864 * @tc.desc : function test
865 */
866 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0340, TestSize.Level0)
867 {
868 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
869 sample->inputFilePath = "/data/test/media/smptec_rgba.yuv";
870 sample->outputFilePath = "/data/test/media/smptec_rgba_out_bt709_nv12.yuv";
871 sample->defaultPixelFormat = "rgba";
872 sample->convertType = "sdr2sdr_rgba_nv12";
873 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT601_SMPTE_C_LIMIT,
874 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, OH_COLORSPACE_BT709_LIMIT};
875 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
876 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
877 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
878 sample->StartProcess();
879 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
880 ASSERT_TRUE(sample->md5Equal);
881 }
882
883 /**
884 * @tc.number : VPE_VIDEO_FUNC_TEST_0350
885 * @tc.name : test SDR2SDR ,src colorspace SMPTEC@RGBA,convert to BT709@NV21
886 * @tc.desc : function test
887 */
888 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0350, TestSize.Level0)
889 {
890 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
891 sample->inputFilePath = "/data/test/media/smptec_rgba.yuv";
892 sample->outputFilePath = "/data/test/media/smptec_rgba_out_bt709_nv21.yuv";
893 sample->defaultPixelFormat = "rgba";
894 sample->convertType = "sdr2sdr_rgba_nv21";
895 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT601_SMPTE_C_LIMIT,
896 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, OH_COLORSPACE_BT709_LIMIT};
897 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
898 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
899 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
900 sample->StartProcess();
901 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
902 ASSERT_TRUE(sample->md5Equal);
903 }
904
905 /**
906 * @tc.number : VPE_VIDEO_FUNC_TEST_0360
907 * @tc.name : test SDR2SDR ,src colorspace SMPTEC@RGBA,convert to BT709@RGBA
908 * @tc.desc : function test
909 */
910 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0360, TestSize.Level0)
911 {
912 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
913 sample->inputFilePath = "/data/test/media/smptec_rgba.yuv";
914 sample->outputFilePath = "/data/test/media/smptec_rgba_out_bt709_rgba.yuv";
915 sample->defaultPixelFormat = "rgba";
916 sample->convertType = "sdr2sdr_rgba_rgba";
917 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT601_SMPTE_C_LIMIT,
918 NATIVEBUFFER_PIXEL_FMT_RGBA_8888, OH_COLORSPACE_BT709_LIMIT};
919 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
920 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
921 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
922 sample->StartProcess();
923 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
924 ASSERT_TRUE(sample->md5Equal);
925 }
926
927 /**
928 * @tc.number : VPE_VIDEO_FUNC_TEST_0370
929 * @tc.name : test HDR2HDR ,src colorspace PQ@NV12,convert to HLG@NV12
930 * @tc.desc : function test
931 */
932 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0370, TestSize.Level0)
933 {
934 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
935 sample->inputFilePath = "/data/test/media/pq_nv12.yuv";
936 sample->outputFilePath = "/data/test/media/pq_nv12_out_hlg_nv12.yuv";
937 sample->defaultPixelFormat = "nv12";
938 sample->convertType = "hdr2hdr_nv12_nv12";
939 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
940 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
941 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
942 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
943 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
944 sample->StartProcess();
945 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
946 ASSERT_TRUE(sample->md5Equal);
947 }
948
949 /**
950 * @tc.number : VPE_VIDEO_FUNC_TEST_0380
951 * @tc.name : test HDR2HDR ,src colorspace PQ@NV12,convert to HLG@NV21
952 * @tc.desc : function test
953 */
954 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0380, TestSize.Level0)
955 {
956 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
957 sample->inputFilePath = "/data/test/media/pq_nv12.yuv";
958 sample->outputFilePath = "/data/test/media/pq_nv12_out_hlg_nv21.yuv";
959 sample->defaultPixelFormat = "nv12";
960 sample->convertType = "hdr2hdr_nv12_nv21";
961 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
962 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
963 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
964 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
965 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
966 sample->StartProcess();
967 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
968 ASSERT_TRUE(sample->md5Equal);
969 }
970
971 /**
972 * @tc.number : VPE_VIDEO_FUNC_TEST_0390
973 * @tc.name : test HDR2HDR ,src colorspace PQ@NV12,convert to HLG@RGBA
974 * @tc.desc : function test
975 */
976 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0390, TestSize.Level0)
977 {
978 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
979 sample->inputFilePath = "/data/test/media/pq_nv12.yuv";
980 sample->outputFilePath = "/data/test/media/pq_nv12_out_hlg_rgba.yuv";
981 sample->defaultPixelFormat = "nv12";
982 sample->convertType = "hdr2hdr_nv12_rgba";
983 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
984 NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT};
985 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
986 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
987 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
988 sample->StartProcess();
989 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
990 ASSERT_TRUE(sample->md5Equal);
991 }
992
993 /**
994 * @tc.number : VPE_VIDEO_FUNC_TEST_0400
995 * @tc.name : test HDR2HDR ,src colorspace PQ@NV21,convert to HLG@NV12
996 * @tc.desc : function test
997 */
998 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0400, TestSize.Level0)
999 {
1000 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1001 sample->inputFilePath = "/data/test/media/pq_nv21.yuv";
1002 sample->outputFilePath = "/data/test/media/pq_nv21_out_hlg_nv12.yuv";
1003 sample->defaultPixelFormat = "nv21";
1004 sample->convertType = "hdr2hdr_nv21_nv12";
1005 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
1006 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
1007 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1008 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1009 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1010 sample->StartProcess();
1011 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1012 ASSERT_TRUE(sample->md5Equal);
1013 }
1014
1015 /**
1016 * @tc.number : VPE_VIDEO_FUNC_TEST_0410
1017 * @tc.name : test HDR2HDR ,src colorspace PQ@NV21,convert to HLG@NV21
1018 * @tc.desc : function test
1019 */
1020 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0410, TestSize.Level0)
1021 {
1022 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1023 sample->inputFilePath = "/data/test/media/pq_nv21.yuv";
1024 sample->outputFilePath = "/data/test/media/pq_nv21_out_hlg_nv21.yuv";
1025 sample->defaultPixelFormat = "nv21";
1026 sample->convertType = "hdr2hdr_nv21_nv21";
1027 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
1028 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
1029 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1030 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1031 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1032 sample->StartProcess();
1033 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1034 ASSERT_TRUE(sample->md5Equal);
1035 }
1036
1037 /**
1038 * @tc.number : VPE_VIDEO_FUNC_TEST_0420
1039 * @tc.name : test HDR2HDR ,src colorspace PQ@NV21,convert to HLG@RGBA
1040 * @tc.desc : function test
1041 */
1042 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0420, TestSize.Level0)
1043 {
1044 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1045 sample->inputFilePath = "/data/test/media/pq_nv21.yuv";
1046 sample->outputFilePath = "/data/test/media/pq_nv21_out_hlg_rgba.yuv";
1047 sample->defaultPixelFormat = "nv21";
1048 sample->convertType = "hdr2hdr_nv21_rgba";
1049 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
1050 NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT};
1051 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1052 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1053 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1054 sample->StartProcess();
1055 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1056 ASSERT_TRUE(sample->md5Equal);
1057 }
1058
1059 /**
1060 * @tc.number : VPE_VIDEO_FUNC_TEST_0430
1061 * @tc.name : test HDR2HDR ,src colorspace PQ@RGBA,convert to HLG@NV12
1062 * @tc.desc : function test
1063 */
1064 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0430, TestSize.Level0)
1065 {
1066 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1067 sample->inputFilePath = "/data/test/media/pq_rgba.yuv";
1068 sample->outputFilePath = "/data/test/media/pq_rgba_out_hlg_nv12.yuv";
1069 sample->defaultPixelFormat = "rgba";
1070 sample->convertType = "hdr2hdr_rgba_nv12";
1071 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_PQ_LIMIT,
1072 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
1073 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1074 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1075 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1076 sample->StartProcess();
1077 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1078 ASSERT_TRUE(sample->md5Equal);
1079 }
1080
1081 /**
1082 * @tc.number : VPE_VIDEO_FUNC_TEST_0440
1083 * @tc.name : test HDR2HDR ,src colorspace PQ@RGBA,convert to HLG@NV21
1084 * @tc.desc : function test
1085 */
1086 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0440, TestSize.Level0)
1087 {
1088 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1089 sample->inputFilePath = "/data/test/media/pq_rgba.yuv";
1090 sample->outputFilePath = "/data/test/media/pq_rgba_out_hlg_nv21.yuv";
1091 sample->defaultPixelFormat = "rgba";
1092 sample->convertType = "hdr2hdr_rgba_nv21";
1093 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_PQ_LIMIT,
1094 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
1095 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1096 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1097 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1098 sample->StartProcess();
1099 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1100 ASSERT_TRUE(sample->md5Equal);
1101 }
1102
1103
1104 /**
1105 * @tc.number : VPE_VIDEO_FUNC_TEST_0450
1106 * @tc.name : test HDR2HDR ,src colorspace PQ@RGBA,convert to HLG@RGBA
1107 * @tc.desc : function test
1108 */
1109 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0450, TestSize.Level0)
1110 {
1111 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1112 sample->inputFilePath = "/data/test/media/pq_rgba.yuv";
1113 sample->outputFilePath = "/data/test/media/pq_rgba_out_hlg_rgba.yuv";
1114 sample->defaultPixelFormat = "rgba";
1115 sample->convertType = "hdr2hdr_rgba_rgba";
1116 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_PQ_LIMIT,
1117 NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT};
1118 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1119 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1120 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1121 sample->StartProcess();
1122 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1123 ASSERT_TRUE(sample->md5Equal);
1124 }
1125
1126 /**
1127 * @tc.number : VPE_VIDEO_FUNC_TEST_0460
1128 * @tc.name : test HDR2HDR ,src colorspace Vivid PQ@NV12,convert to Vivid HLG@NV12
1129 * @tc.desc : function test
1130 */
1131 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0460, TestSize.Level0)
1132 {
1133 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1134 sample->inputFilePath = "/data/test/media/vivid_pq_nv12.yuv";
1135 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
1136 sample->outputFilePath = "/data/test/media/vivid_pq_nv12_out_hlg_nv12.yuv";
1137 sample->isHDRVivid = true;
1138 sample->isHDRVividOut = true;
1139 sample->defaultPixelFormat = "nv12";
1140 sample->convertType = "hdr2hdr_nv12_nv12";
1141 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
1142 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
1143 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1144 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1145 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1146 sample->StartProcess();
1147 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1148 ASSERT_TRUE(sample->md5Equal);
1149 }
1150
1151 /**
1152 * @tc.number : VPE_VIDEO_FUNC_TEST_0470
1153 * @tc.name : test HDR2HDR ,src colorspace Vivid PQ@NV12,convert to Vivid HLG@NV21
1154 * @tc.desc : function test
1155 */
1156 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0470, TestSize.Level0)
1157 {
1158 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1159 sample->inputFilePath = "/data/test/media/vivid_pq_nv12.yuv";
1160 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
1161 sample->outputFilePath = "/data/test/media/vivid_pq_nv12_out_hlg_nv21.yuv";
1162 sample->isHDRVivid = true;
1163 sample->isHDRVividOut = true;
1164 sample->defaultPixelFormat = "nv12";
1165 sample->convertType = "hdr2hdr_nv12_nv21";
1166 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
1167 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
1168 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1169 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1170 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1171 sample->StartProcess();
1172 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1173 ASSERT_TRUE(sample->md5Equal);
1174 }
1175
1176 /**
1177 * @tc.number : VPE_VIDEO_FUNC_TEST_0480
1178 * @tc.name : test HDR2HDR ,src colorspace Vivid PQ@NV12,convert to Vivid HLG@RGBA
1179 * @tc.desc : function test
1180 */
1181 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0480, TestSize.Level0)
1182 {
1183 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1184 sample->inputFilePath = "/data/test/media/vivid_pq_nv12.yuv";
1185 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
1186 sample->outputFilePath = "/data/test/media/vivid_pq_nv12_out_hlg_rgba.yuv";
1187 sample->isHDRVivid = true;
1188 sample->isHDRVividOut = true;
1189 sample->defaultPixelFormat = "nv12";
1190 sample->convertType = "hdr2hdr_nv12_rgba";
1191 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
1192 NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT};
1193 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1194 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1195 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1196 sample->StartProcess();
1197 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1198 ASSERT_TRUE(sample->md5Equal);
1199 }
1200
1201 /**
1202 * @tc.number : VPE_VIDEO_FUNC_TEST_0490
1203 * @tc.name : test HDR2HDR ,src colorspace Vivid PQ@NV21,convert to Vivid HLG@NV12
1204 * @tc.desc : function test
1205 */
1206 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0490, TestSize.Level0)
1207 {
1208 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1209 sample->inputFilePath = "/data/test/media/vivid_pq_nv21.yuv";
1210 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
1211 sample->outputFilePath = "/data/test/media/vivid_pq_nv21_out_hlg_nv12.yuv";
1212 sample->isHDRVivid = true;
1213 sample->isHDRVividOut = true;
1214 sample->defaultPixelFormat = "nv21";
1215 sample->convertType = "hdr2hdr_nv21_nv12";
1216 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
1217 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
1218 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1219 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1220 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1221 sample->StartProcess();
1222 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1223 ASSERT_TRUE(sample->md5Equal);
1224 }
1225
1226 /**
1227 * @tc.number : VPE_VIDEO_FUNC_TEST_0500
1228 * @tc.name : test HDR2HDR ,src colorspace Vivid PQ@NV21,convert to Vivid HLG@NV21
1229 * @tc.desc : function test
1230 */
1231 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0500, TestSize.Level0)
1232 {
1233 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1234 sample->inputFilePath = "/data/test/media/vivid_pq_nv21.yuv";
1235 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
1236 sample->outputFilePath = "/data/test/media/vivid_pq_nv21_out_hlg_nv21.yuv";
1237 sample->isHDRVivid = true;
1238 sample->isHDRVividOut = true;
1239 sample->defaultPixelFormat = "nv21";
1240 sample->convertType = "hdr2hdr_nv21_nv21";
1241 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
1242 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
1243 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1244 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1245 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1246 sample->StartProcess();
1247 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1248 ASSERT_TRUE(sample->md5Equal);
1249 }
1250
1251 /**
1252 * @tc.number : VPE_VIDEO_FUNC_TEST_0510
1253 * @tc.name : test HDR2HDR ,src colorspace Vivid PQ@NV21,convert to Vivid HLG@RGBA
1254 * @tc.desc : function test
1255 */
1256 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0510, TestSize.Level0)
1257 {
1258 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1259 sample->inputFilePath = "/data/test/media/vivid_pq_nv21.yuv";
1260 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
1261 sample->outputFilePath = "/data/test/media/vivid_pq_nv21_out_hlg_rgba.yuv";
1262 sample->isHDRVivid = true;
1263 sample->isHDRVividOut = true;
1264 sample->defaultPixelFormat = "nv21";
1265 sample->convertType = "hdr2hdr_nv21_rgba";
1266 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
1267 NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT};
1268 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1269 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1270 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1271 sample->StartProcess();
1272 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1273 ASSERT_TRUE(sample->md5Equal);
1274 }
1275
1276 /**
1277 * @tc.number : VPE_VIDEO_FUNC_TEST_0520
1278 * @tc.name : test HDR2HDR ,src colorspace Vivid PQ@RGBA,convert to Vivid HLG@NV12
1279 * @tc.desc : function test
1280 */
1281 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0520, TestSize.Level0)
1282 {
1283 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1284 sample->inputFilePath = "/data/test/media/vivid_pq_rgba.yuv";
1285 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
1286 sample->outputFilePath = "/data/test/media/vivid_pq_rgba_out_hlg_nv12.yuv";
1287 sample->isHDRVivid = true;
1288 sample->isHDRVividOut = true;
1289 sample->defaultPixelFormat = "rgba";
1290 sample->convertType = "hdr2hdr_rgba_nv12";
1291 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_PQ_LIMIT,
1292 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
1293 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1294 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1295 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1296 sample->StartProcess();
1297 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1298 ASSERT_TRUE(sample->md5Equal);
1299 }
1300
1301 /**
1302 * @tc.number : VPE_VIDEO_FUNC_TEST_0530
1303 * @tc.name : test HDR2HDR ,src colorspace Vivid PQ@RGBA,convert to Vivid HLG@NV21
1304 * @tc.desc : function test
1305 */
1306 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0530, TestSize.Level0)
1307 {
1308 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1309 sample->inputFilePath = "/data/test/media/vivid_pq_rgba.yuv";
1310 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
1311 sample->outputFilePath = "/data/test/media/vivid_pq_rgba_out_hlg_nv21.yuv";
1312 sample->isHDRVivid = true;
1313 sample->isHDRVividOut = true;
1314 sample->defaultPixelFormat = "rgba";
1315 sample->convertType = "hdr2hdr_rgba_nv21";
1316 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_PQ_LIMIT,
1317 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
1318 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1319 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1320 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1321 sample->StartProcess();
1322 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1323 ASSERT_TRUE(sample->md5Equal);
1324 }
1325
1326 /**
1327 * @tc.number : VPE_VIDEO_FUNC_TEST_0540
1328 * @tc.name : test HDR2HDR ,src colorspace Vivid PQ@RGBA,convert to Vivid HLG@RGBA
1329 * @tc.desc : function test
1330 */
1331 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0540, TestSize.Level0)
1332 {
1333 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1334 sample->inputFilePath = "/data/test/media/vivid_pq_rgba.yuv";
1335 sample->inputMetaPath = "/data/test/media/vivid_pq.bin";
1336 sample->outputFilePath = "/data/test/media/vivid_pq_rgba_out_hlg_rgba.yuv";
1337 sample->isHDRVivid = true;
1338 sample->isHDRVividOut = true;
1339 sample->defaultPixelFormat = "rgba";
1340 sample->convertType = "hdr2hdr_rgba_rgba";
1341 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_PQ_LIMIT,
1342 NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT};
1343 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1344 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1345 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1346 sample->StartProcess();
1347 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1348 ASSERT_TRUE(sample->md5Equal);
1349 }
1350
1351 /**
1352 * @tc.number : VPE_VIDEO_FUNC_TEST_0550
1353 * @tc.name : test HDR2HDR ,src colorspace Vivid HLG@NV12,convert to Vivid PQ@NV12
1354 * @tc.desc : function test
1355 */
1356 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0550, TestSize.Level0)
1357 {
1358 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1359 sample->inputFilePath = "/data/test/media/vivid_hlg_nv12.yuv";
1360 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
1361 sample->outputFilePath = "/data/test/media/vivid_hlg_nv12_out_pq_nv12.yuv";
1362 sample->isHDRVivid = true;
1363 sample->isHDRVividOut = true;
1364 sample->defaultPixelFormat = "nv12";
1365 sample->convertType = "hdr2hdr_nv12_nv12";
1366 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
1367 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT};
1368 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1369 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1370 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1371 sample->StartProcess();
1372 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1373 ASSERT_TRUE(sample->md5Equal);
1374 }
1375
1376 /**
1377 * @tc.number : VPE_VIDEO_FUNC_TEST_0560
1378 * @tc.name : test HDR2HDR ,src colorspace Vivid HLG@NV12,convert to Vivid PQ@NV21
1379 * @tc.desc : function test
1380 */
1381 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0560, TestSize.Level0)
1382 {
1383 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1384 sample->inputFilePath = "/data/test/media/vivid_hlg_nv12.yuv";
1385 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
1386 sample->outputFilePath = "/data/test/media/vivid_hlg_nv12_out_pq_nv21.yuv";
1387 sample->isHDRVivid = true;
1388 sample->isHDRVividOut = true;
1389 sample->defaultPixelFormat = "nv12";
1390 sample->convertType = "hdr2hdr_nv12_nv21";
1391 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
1392 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT};
1393 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1394 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1395 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1396 sample->StartProcess();
1397 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1398 ASSERT_TRUE(sample->md5Equal);
1399 }
1400
1401 /**
1402 * @tc.number : VPE_VIDEO_FUNC_TEST_0570
1403 * @tc.name : test HDR2HDR ,src colorspace Vivid HLG@NV12,convert to Vivid PQ@RGBA
1404 * @tc.desc : function test
1405 */
1406 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0570, TestSize.Level0)
1407 {
1408 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1409 sample->inputFilePath = "/data/test/media/vivid_hlg_nv12.yuv";
1410 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
1411 sample->outputFilePath = "/data/test/media/vivid_hlg_nv12_out_pq_rgba.yuv";
1412 sample->isHDRVivid = true;
1413 sample->isHDRVividOut = true;
1414 sample->defaultPixelFormat = "nv12";
1415 sample->convertType = "hdr2hdr_nv12_rgba";
1416 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
1417 NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_PQ_LIMIT};
1418 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1419 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1420 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1421 sample->StartProcess();
1422 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1423 ASSERT_TRUE(sample->md5Equal);
1424 }
1425
1426 /**
1427 * @tc.number : VPE_VIDEO_FUNC_TEST_0580
1428 * @tc.name : test HDR2HDR ,src colorspace Vivid HLG@NV21,convert to Vivid PQ@NV12
1429 * @tc.desc : function test
1430 */
1431 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0580, TestSize.Level0)
1432 {
1433 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1434 sample->inputFilePath = "/data/test/media/vivid_hlg_nv21.yuv";
1435 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
1436 sample->outputFilePath = "/data/test/media/vivid_hlg_nv21_out_pq_nv12.yuv";
1437 sample->isHDRVivid = true;
1438 sample->isHDRVividOut = true;
1439 sample->defaultPixelFormat = "nv21";
1440 sample->convertType = "hdr2hdr_nv21_nv12";
1441 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
1442 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT};
1443 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1444 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1445 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1446 sample->StartProcess();
1447 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1448 ASSERT_TRUE(sample->md5Equal);
1449 }
1450
1451 /**
1452 * @tc.number : VPE_VIDEO_FUNC_TEST_0590
1453 * @tc.name : test HDR2HDR ,src colorspace Vivid HLG@NV21,convert to Vivid PQ@NV21
1454 * @tc.desc : function test
1455 */
1456 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0590, TestSize.Level0)
1457 {
1458 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1459 sample->inputFilePath = "/data/test/media/vivid_hlg_nv21.yuv";
1460 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
1461 sample->outputFilePath = "/data/test/media/vivid_hlg_nv21_out_pq_nv21.yuv";
1462 sample->isHDRVivid = true;
1463 sample->isHDRVividOut = true;
1464 sample->defaultPixelFormat = "nv21";
1465 sample->convertType = "hdr2hdr_nv21_nv21";
1466 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
1467 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT};
1468 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1469 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1470 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1471 sample->StartProcess();
1472 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1473 ASSERT_TRUE(sample->md5Equal);
1474 }
1475
1476
1477 /**
1478 * @tc.number : VPE_VIDEO_FUNC_TEST_0600
1479 * @tc.name : test HDR2HDR ,src colorspace Vivid HLG@NV21,convert to Vivid PQ@RGBA
1480 * @tc.desc : function test
1481 */
1482 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0600, TestSize.Level0)
1483 {
1484 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1485 sample->inputFilePath = "/data/test/media/vivid_hlg_nv21.yuv";
1486 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
1487 sample->outputFilePath = "/data/test/media/vivid_hlg_nv21_out_pq_rgba.yuv";
1488 sample->isHDRVivid = true;
1489 sample->isHDRVividOut = true;
1490 sample->defaultPixelFormat = "nv21";
1491 sample->convertType = "hdr2hdr_nv21_rgba";
1492 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
1493 NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_PQ_LIMIT};
1494 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1495 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1496 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1497 sample->StartProcess();
1498 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1499 ASSERT_TRUE(sample->md5Equal);
1500 }
1501
1502 /**
1503 * @tc.number : VPE_VIDEO_FUNC_TEST_0610
1504 * @tc.name : test HDR2HDR ,src colorspace Vivid HLG@RGBA,convert to Vivid PQ@NV12
1505 * @tc.desc : function test
1506 */
1507 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0610, TestSize.Level0)
1508 {
1509 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1510 sample->inputFilePath = "/data/test/media/vivid_hlg_rgba.yuv";
1511 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
1512 sample->outputFilePath = "/data/test/media/vivid_hlg_rgba_out_pq_nv12.yuv";
1513 sample->isHDRVivid = true;
1514 sample->isHDRVividOut = true;
1515 sample->defaultPixelFormat = "rgba";
1516 sample->convertType = "hdr2hdr_rgba_nv12";
1517 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT,
1518 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT};
1519 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1520 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1521 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1522 sample->StartProcess();
1523 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1524 ASSERT_TRUE(sample->md5Equal);
1525 }
1526
1527 /**
1528 * @tc.number : VPE_VIDEO_FUNC_TEST_0620
1529 * @tc.name : test HDR2HDR ,src colorspace Vivid HLG@RGBA,convert to Vivid PQ@NV21
1530 * @tc.desc : function test
1531 */
1532 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0620, TestSize.Level0)
1533 {
1534 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1535 sample->inputFilePath = "/data/test/media/vivid_hlg_rgba.yuv";
1536 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
1537 sample->outputFilePath = "/data/test/media/vivid_hlg_rgba_out_pq_nv21.yuv";
1538 sample->isHDRVivid = true;
1539 sample->isHDRVividOut = true;
1540 sample->defaultPixelFormat = "rgba";
1541 sample->convertType = "hdr2hdr_rgba_nv21";
1542 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT,
1543 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT};
1544 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1545 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1546 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1547 sample->StartProcess();
1548 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1549 ASSERT_TRUE(sample->md5Equal);
1550 }
1551
1552 /**
1553 * @tc.number : VPE_VIDEO_FUNC_TEST_0630
1554 * @tc.name : test HDR2HDR ,src colorspace Vivid HLG@RGBA,convert to Vivid PQ@RGBA
1555 * @tc.desc : function test
1556 */
1557 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0630, TestSize.Level0)
1558 {
1559 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1560 sample->inputFilePath = "/data/test/media/vivid_hlg_rgba.yuv";
1561 sample->inputMetaPath = "/data/test/media/vivid_hlg.bin";
1562 sample->outputFilePath = "/data/test/media/vivid_hlg_rgba_out_pq_rgba.yuv";
1563 sample->isHDRVivid = true;
1564 sample->isHDRVividOut = true;
1565 sample->defaultPixelFormat = "rgba";
1566 sample->convertType = "hdr2hdr_rgba_rgba";
1567 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT,
1568 NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_PQ_LIMIT};
1569 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION,
1570 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1571 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1572 sample->StartProcess();
1573 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1574 ASSERT_TRUE(sample->md5Equal);
1575 }
1576
1577 /**
1578 * @tc.number : VPE_VIDEO_FUNC_TEST_0640
1579 * @tc.name : test metadata Generate, input PQ NV12
1580 * @tc.desc : function test
1581 */
1582 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0640, TestSize.Level0)
1583 {
1584 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1585 sample->inputFilePath = "/data/test/media/pq_nv12.yuv";
1586 sample->outputMetaPath = "/data/test/media/pq_nv12_out.bin";
1587 sample->defaultPixelFormat = "nv12";
1588 sample->convertType = "metadata_generate";
1589 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
1590 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_PQ_LIMIT};
1591 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_METADATA_GENERATION,
1592 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1593 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1594 sample->StartProcess();
1595 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1596 ASSERT_TRUE(sample->md5Equal);
1597 }
1598
1599 /**
1600 * @tc.number : VPE_VIDEO_FUNC_TEST_0650
1601 * @tc.name : test metadata Generate, input PQ NV21
1602 * @tc.desc : function test
1603 */
1604 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0650, TestSize.Level0)
1605 {
1606 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1607 sample->inputFilePath = "/data/test/media/pq_nv21.yuv";
1608 sample->outputMetaPath = "/data/test/media/pq_nv21_out.bin";
1609 sample->defaultPixelFormat = "nv21";
1610 sample->convertType = "metadata_generate";
1611 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT,
1612 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_PQ_LIMIT};
1613 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_METADATA_GENERATION,
1614 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1615 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1616 sample->StartProcess();
1617 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1618 ASSERT_TRUE(sample->md5Equal);
1619 }
1620 /**
1621 * @tc.number : VPE_VIDEO_FUNC_TEST_0660
1622 * @tc.name : test metadata Generate, input PQ RGBA
1623 * @tc.desc : function test
1624 */
1625 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0660, TestSize.Level0)
1626 {
1627 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1628 sample->inputFilePath = "/data/test/media/pq_rgba.yuv";
1629 sample->outputMetaPath = "/data/test/media/pq_rgba_out.bin";
1630 sample->defaultPixelFormat = "rgba";
1631 sample->convertType = "metadata_generate";
1632 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_PQ_LIMIT,
1633 NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_PQ_LIMIT};
1634 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_METADATA_GENERATION,
1635 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1636 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1637 sample->StartProcess();
1638 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1639 ASSERT_TRUE(sample->md5Equal);
1640 }
1641 /**
1642 * @tc.number : VPE_VIDEO_FUNC_TEST_0670
1643 * @tc.name : test metadata Generate, input HLG NV12
1644 * @tc.desc : function test
1645 */
1646 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0670, TestSize.Level0)
1647 {
1648 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1649 sample->inputFilePath = "/data/test/media/hlg_nv12.yuv";
1650 sample->outputMetaPath = "/data/test/media/hlg_nv12_out.bin";
1651 sample->defaultPixelFormat = "nv12";
1652 sample->convertType = "metadata_generate";
1653 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
1654 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
1655 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_METADATA_GENERATION,
1656 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1657 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1658 sample->StartProcess();
1659 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1660 ASSERT_TRUE(sample->md5Equal);
1661 }
1662 /**
1663 * @tc.number : VPE_VIDEO_FUNC_TEST_0680
1664 * @tc.name : test metadata Generate, input HLG NV21
1665 * @tc.desc : function test
1666 */
1667 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0680, TestSize.Level0)
1668 {
1669 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1670 sample->inputFilePath = "/data/test/media/hlg_nv21.yuv";
1671 sample->outputMetaPath = "/data/test/media/hlg_nv21_out.bin";
1672 sample->defaultPixelFormat = "nv21";
1673 sample->convertType = "metadata_generate";
1674 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT,
1675 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, OH_COLORSPACE_BT2020_HLG_LIMIT};
1676 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_METADATA_GENERATION,
1677 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1678 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1679 sample->StartProcess();
1680 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1681 ASSERT_TRUE(sample->md5Equal);
1682 }
1683 /**
1684 * @tc.number : VPE_VIDEO_FUNC_TEST_0690
1685 * @tc.name : test metadata Generate, input HLG RGBA
1686 * @tc.desc : function test
1687 */
1688 HWTEST_F(VpeVideoFuncTest, VPE_VIDEO_FUNC_TEST_0690, TestSize.Level0)
1689 {
1690 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1691 sample->inputFilePath = "/data/test/media/hlg_rgba.yuv";
1692 sample->outputMetaPath = "/data/test/media/hlg_rgba_out.bin";
1693 sample->defaultPixelFormat = "rgba";
1694 sample->convertType = "metadata_generate";
1695 VideoProcessParam param = {NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT,
1696 NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, OH_COLORSPACE_BT2020_HLG_LIMIT};
1697 int32_t ret = sample->InitVideoSample(VIDEO_PROCESSING_TYPE_METADATA_GENERATION,
1698 DEFAULT_WIDTH, DEFAULT_HEIGHT, param);
1699 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1700 sample->StartProcess();
1701 ASSERT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1702 ASSERT_TRUE(sample->md5Equal);
1703 }
1704
1705 #endif
1706 }