1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <unistd.h>
17 #include <fstream>
18 #include <gtest/gtest.h>
19 #include <iostream>
20 #include "securec.h"
21 #include <sys/time.h>
22
23 #include "native_avformat.h"
24 #include "native_window.h"
25 #include "surface/window.h"
26 #include "external_window.h"
27 #include "v1_0/cm_color_space.h"
28
29 #include "video_processing.h"
30 #include "video_processing_types.h"
31 #include "metadata_generator_video.h"
32 #include "algorithm_common.h"
33 #include "algorithm_common.h"
34
35 constexpr uint32_t DEFAULT_WIDTH = 1920;
36 constexpr uint32_t DEFAULT_HEIGHT = 1080;
37 constexpr uint32_t DEFAULT_BYTE = 32;
38 using namespace testing::ext;
39 using namespace OHOS;
40 using namespace OHOS::Media;
41 using namespace std;
42 using namespace OHOS::Media::VideoProcessingEngine;
43 using namespace OHOS::HDI::Display::Graphic::Common::V1_0;
44 namespace {
45
46 class MetadataGeneratorVideoNdkImplUnitTest : public testing::Test {
47 public:
SetUpTestCase(void)48 static void SetUpTestCase(void) {};
TearDownTestCase(void)49 static void TearDownTestCase(void) {};
SetUp()50 void SetUp()
51 {
52 requestCfg_.usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE
53 | BUFFER_USAGE_HW_RENDER | BUFFER_USAGE_HW_TEXTURE | BUFFER_USAGE_MEM_MMZ_CACHE;
54 requestCfg_.width = DEFAULT_WIDTH;
55 requestCfg_.height = DEFAULT_HEIGHT;
56 requestCfg_.timeout = 0;
57 requestCfg_.strideAlignment = DEFAULT_BYTE;
58 flushCfg_.damage.x = 0;
59 flushCfg_.damage.y = 0;
60 flushCfg_.damage.w = DEFAULT_WIDTH;
61 flushCfg_.damage.h = DEFAULT_HEIGHT;
62 flushCfg_.timestamp = 0;
63 };
TearDown()64 void TearDown()
65 {
66 };
67
68 BufferFlushConfig flushCfg_{};
69 BufferRequestConfig requestCfg_{};
70 int32_t fence_ = -1;
71 CM_ColorSpaceType inColspc_ = CM_BT2020_PQ_LIMIT;
72 CM_HDR_Metadata_Type inMetaType_ = CM_VIDEO_HDR_VIVID;
73 GraphicPixelFormat surfacePixelFmt_ = GRAPHIC_PIXEL_FMT_YCBCR_P010;
74
75 void SetMeatadata(sptr<SurfaceBuffer> &buffer, uint32_t value);
76 void SetMeatadata(sptr<SurfaceBuffer> &buffer, CM_ColorSpaceInfo &colorspaceInfo);
77 VideoProcessing_ErrorCode Process();
78 };
79
OnError(OH_VideoProcessing * handle,VideoProcessing_ErrorCode errorCode,void * userData)80 void OnError(OH_VideoProcessing *handle, VideoProcessing_ErrorCode errorCode, void* userData)
81 {
82 (void)handle;
83 (void)errorCode;
84 (void)userData;
85 }
OnState(OH_VideoProcessing * handle,VideoProcessing_State state,void * userData)86 void OnState(OH_VideoProcessing *handle, VideoProcessing_State state, void* userData)
87 {
88 (void)handle;
89 (void)state;
90 (void)userData;
91 }
OnNewOutputBuffer(OH_VideoProcessing * handle,uint32_t index,void * userData)92 void OnNewOutputBuffer(OH_VideoProcessing *handle, uint32_t index, void* userData)
93 {
94 (void)handle;
95 (void)index;
96 (void)userData;
97 }
98
SetMeatadata(sptr<SurfaceBuffer> & buffer,uint32_t value)99 void MetadataGeneratorVideoNdkImplUnitTest::SetMeatadata(sptr<SurfaceBuffer> &buffer, uint32_t value)
100 {
101 std::vector<uint8_t> metadata;
102 metadata.resize(sizeof(value));
103 (void)memcpy_s(metadata.data(), metadata.size(), &value, sizeof(value));
104 uint32_t err = buffer->SetMetadata(ATTRKEY_HDR_METADATA_TYPE, metadata);
105 if (err != 0) {
106 printf("Buffer set metadata info, ret: %d\n", err);
107 }
108 }
109
SetMeatadata(sptr<SurfaceBuffer> & buffer,CM_ColorSpaceInfo & colorspaceInfo)110 void MetadataGeneratorVideoNdkImplUnitTest::SetMeatadata(sptr<SurfaceBuffer> &buffer,
111 CM_ColorSpaceInfo &colorspaceInfo)
112 {
113 std::vector<uint8_t> metadata;
114 metadata.resize(sizeof(CM_ColorSpaceInfo));
115 (void)memcpy_s(metadata.data(), metadata.size(), &colorspaceInfo, sizeof(CM_ColorSpaceInfo));
116 uint32_t err = buffer->SetMetadata(ATTRKEY_COLORSPACE_INFO, metadata);
117 if (err != 0) {
118 printf("Buffer set colorspace info, ret: %d\n", err);
119 }
120 }
121
Process()122 VideoProcessing_ErrorCode MetadataGeneratorVideoNdkImplUnitTest::Process()
123 {
124 VideoProcessing_ErrorCode ret = VIDEO_PROCESSING_SUCCESS;
125 sptr<SurfaceBuffer> buffer;
126 CM_ColorSpaceInfo inColspcInfo = {
127 static_cast<CM_ColorPrimaries>((inColspc_ & COLORPRIMARIES_MASK) >> COLORPRIMARIES_OFFSET),
128 static_cast<CM_TransFunc>((inColspc_ & TRANSFUNC_MASK) >> TRANSFUNC_OFFSET),
129 static_cast<CM_Matrix>((inColspc_ & MATRIX_MASK) >> MATRIX_OFFSET),
130 static_cast<CM_Range>((inColspc_ & RANGE_MASK) >> RANGE_OFFSET)
131 };
132 ret = OH_VideoProcessing_InitializeEnvironment();
133 int createType = 0x2;
134 OH_VideoProcessing* instance = nullptr;
135 OH_VideoProcessing* instance2 = nullptr;
136 ret = OH_VideoProcessing_Create(&instance, createType);
137 ret = OH_VideoProcessing_Create(&instance2, createType);
138 VideoProcessing_Callback* callback = nullptr;
139 ret = OH_VideoProcessingCallback_Create(&callback);
140 ret = OH_VideoProcessingCallback_BindOnError(callback, OnError);
141 ret = OH_VideoProcessingCallback_BindOnState(callback, OnState);
142 ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
143 OHNativeWindow* window = nullptr;
144 OHNativeWindow* window2 = nullptr;
145 ret = OH_VideoProcessing_GetSurface(instance, &window);
146 ret = OH_VideoProcessing_GetSurface(instance2, &window2);
147 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
148 ret = OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
149 ret = OH_VideoProcessing_SetSurface(instance, window2);
150 ret = OH_VideoProcessing_Start(instance);
151 if (ret != VIDEO_PROCESSING_SUCCESS) {
152 return ret;
153 }
154 int videoSurfaceBuffNum = 1;
155 int sleepTime = 2;
156 for (int i = 0; i < videoSurfaceBuffNum; i++) {
157 window->surface->RequestBuffer(buffer, fence_, requestCfg_);
158 SetMeatadata(buffer, inColspcInfo);
159 SetMeatadata(buffer, (uint32_t)inMetaType_);
160 window->surface->FlushBuffer(buffer, fence_, flushCfg_);
161 OH_VideoProcessing_SetSurface(instance, window2);
162 sleep(sleepTime);
163 }
164 OH_VideoProcessing_Destroy(instance);
165 OH_VideoProcessing_Destroy(instance2);
166 OH_VideoProcessing_DeinitializeEnvironment();
167 return ret;
168 }
169
170 HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, testVideoProcess_testFunSupportedMetadata, TestSize.Level1)
171 {
172 bool resultSupported = false;
173 resultSupported = OH_VideoProcessing_IsColorSpaceConversionSupported(nullptr, nullptr);
174 EXPECT_EQ(resultSupported, false);
175 resultSupported = OH_VideoProcessing_IsMetadataGenerationSupported(nullptr);
176 EXPECT_EQ(resultSupported, false);
177 const int formatListNum = 3;
178 int formatListHDRNative[formatListNum] = {NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, NATIVEBUFFER_PIXEL_FMT_YCRCB_P010,
179 NATIVEBUFFER_PIXEL_FMT_RGBA_1010102};
180 const int colorMetaMetaListNum = 4;
181 const int colorMetaParaNum = 2;
182 const int colorMetaParaInMetaNum = 0;
183 const int colorMetaParaInColorNum = 1;
184 int colorMetaListSdr2Sdr[colorMetaMetaListNum][colorMetaParaNum] = {
185 {OH_VIDEO_HDR_HDR10, OH_COLORSPACE_BT2020_PQ_LIMIT},
186 {OH_VIDEO_HDR_VIVID, OH_COLORSPACE_BT2020_PQ_LIMIT},
187 {OH_VIDEO_HDR_HLG, OH_COLORSPACE_BT2020_HLG_LIMIT},
188 {OH_VIDEO_HDR_VIVID, OH_COLORSPACE_BT2020_HLG_LIMIT}
189 };
190 VideoProcessing_ColorSpaceInfo sourceVideoInfo = {-1, -1, -1};
191 for (int n = 0; n < colorMetaMetaListNum; n++) {
192 sourceVideoInfo.metadataType = static_cast<int32_t>(colorMetaListSdr2Sdr[n][colorMetaParaInMetaNum]);
193 sourceVideoInfo.colorSpace = static_cast<int32_t>(colorMetaListSdr2Sdr[n][colorMetaParaInColorNum]);
194 for (int i = 0; i < formatListNum; i++) {
195 sourceVideoInfo.pixelFormat = static_cast<int32_t>(formatListHDRNative[i]);
196 resultSupported = OH_VideoProcessing_IsMetadataGenerationSupported(&sourceVideoInfo);
197 EXPECT_EQ(resultSupported, true);
198 }
199 }
200 sourceVideoInfo.metadataType = static_cast<int32_t>(OH_VIDEO_HDR_HLG);
201 sourceVideoInfo.colorSpace = static_cast<int32_t>(OH_COLORSPACE_BT2020_PQ_LIMIT);
202 sourceVideoInfo.pixelFormat = static_cast<int32_t>(NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP);
203 resultSupported = OH_VideoProcessing_IsMetadataGenerationSupported(&sourceVideoInfo);
204 EXPECT_EQ(resultSupported, false);
205 }
206
207 HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, testVideoProcess_testFun, TestSize.Level1)
208 {
209 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
210 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
211 int createType = 0x2;
212 OH_VideoProcessing* instance = nullptr;
213 OH_VideoProcessing* instance2 = nullptr;
214 ret = OH_VideoProcessing_Create(&instance, createType);
215 ret = OH_VideoProcessing_Create(&instance2, createType);
216 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
217 VideoProcessing_Callback* callback = nullptr;
218 ret = OH_VideoProcessingCallback_Create(&callback);
219 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
220 ret = OH_VideoProcessingCallback_BindOnError(callback, OnError);
221 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
222 ret = OH_VideoProcessingCallback_BindOnState(callback, OnState);
223 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
224 ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
225 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
226 OHNativeWindow* window = nullptr;
227 OHNativeWindow* window2 = nullptr;
228 ret = OH_VideoProcessing_GetSurface(instance, &window);
229 ret = OH_VideoProcessing_GetSurface(instance2, &window2);
230 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
231 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
232 ret = OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
233 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
234 OH_AVFormat* parameter = OH_AVFormat_Create();
235 ret = OH_VideoProcessing_SetParameter(instance, parameter);
236 EXPECT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
237 ret = OH_VideoProcessing_GetParameter(instance, parameter);
238 EXPECT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
239 ret = OH_VideoProcessing_SetSurface(instance, window2);
240 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
241 for (int i = 0; i < 2; i++) {
242 ret = OH_VideoProcessing_Start(instance);
243 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
244 ret = OH_VideoProcessing_Stop(instance);
245 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
246 }
247 ret = OH_VideoProcessing_RenderOutputBuffer(instance, 0);
248 EXPECT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
249 ret = OH_VideoProcessingCallback_Destroy(callback);
250 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
251 ret = OH_VideoProcessing_Destroy(instance);
252 ret = OH_VideoProcessing_Destroy(instance2);
253 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
254 ret = OH_VideoProcessing_DeinitializeEnvironment();
255 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
256 }
257
258 HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, testVideoProcess_metadataGen, TestSize.Level1)
259 {
260 const int formatListNum = 3;
261 int formatListHDR[formatListNum] = {GRAPHIC_PIXEL_FMT_YCBCR_P010, GRAPHIC_PIXEL_FMT_YCRCB_P010,
262 GRAPHIC_PIXEL_FMT_RGBA_1010102};
263 const int colorMetaMetaListNum = 4;
264 const int colorMetaParaNum = 2;
265 const int colorMetaParaInMetaNum = 0;
266 const int colorMetaParaInColorNum = 1;
267 int colorMetaList[colorMetaMetaListNum][colorMetaParaNum] = {
268 {CM_VIDEO_HDR10, CM_BT2020_PQ_LIMIT},
269 {CM_VIDEO_HDR_VIVID, CM_BT2020_PQ_LIMIT},
270 {CM_VIDEO_HLG, CM_BT2020_HLG_LIMIT},
271 {CM_VIDEO_HDR_VIVID, CM_BT2020_HLG_LIMIT}
272 };
273 for (int n = 0; n < colorMetaMetaListNum; n++) {
274 inMetaType_ = static_cast<CM_HDR_Metadata_Type>(colorMetaList[n][colorMetaParaInMetaNum]);
275 inColspc_ = static_cast<CM_ColorSpaceType>(colorMetaList[n][colorMetaParaInColorNum]);
276 for (int i = 0; i < formatListNum; i++) {
277 surfacePixelFmt_ = static_cast<GraphicPixelFormat>(formatListHDR[i]);
278 requestCfg_.format = surfacePixelFmt_;
279 VideoProcessing_ErrorCode ret = Process();
280 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
281 }
282 }
283 }
284 }