1 /*
2 * Copyright (C) 2023 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 <string>
16 #include "gtest/gtest.h"
17 #include "native_avcodec_videodecoder.h"
18 #include "native_averrors.h"
19 #include "videodec_ndk_sample.h"
20 #include "native_avcodec_base.h"
21 #include "avcodec_codec_name.h"
22
23 #ifdef SUPPORT_DRM
24 #include "native_mediakeysession.h"
25 #include "native_mediakeysystem.h"
26 #endif
27
28 #define MAX_THREAD 16
29
30 using namespace std;
31 using namespace OHOS;
32 using namespace OHOS::Media;
33 using namespace testing::ext;
34
35 namespace OHOS {
36 namespace Media {
37 class SwdecFuncNdkTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp() override;
42 void TearDown() override;
43 void InputFunc();
44 void OutputFunc();
45 void Release();
46 int32_t Stop();
47
48 protected:
49 const string CODEC_NAME = "video_decoder.avc";
50 const char *INP_DIR_720_30 = "/data/test/media/1280_720_30_10Mb.h264";
51 const char *INP_DIR_1080_30 = "/data/test/media/1920_1080_10_30Mb.h264";
52 };
53 } // namespace Media
54 } // namespace OHOS
55
SetUpTestCase()56 void SwdecFuncNdkTest::SetUpTestCase() {}
TearDownTestCase()57 void SwdecFuncNdkTest::TearDownTestCase() {}
SetUp()58 void SwdecFuncNdkTest::SetUp() {}
TearDown()59 void SwdecFuncNdkTest::TearDown() {}
60
61 namespace {
62 /**
63 * @tc.number : VIDEO_SWDEC_FUNCTION_0200
64 * @tc.name : create nonexist decoder
65 * @tc.desc : function test
66 */
67 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0200, TestSize.Level1)
68 {
69 OH_AVCodec *vdec_ = OH_VideoDecoder_CreateByName("OMX.h264.decode.111.222.333");
70 ASSERT_EQ(nullptr, vdec_);
71 }
72
73 /**
74 * @tc.number : VIDEO_SWDEC_FUNCTION_0300
75 * @tc.name : test h264 decode buffer
76 * @tc.desc : function test
77 */
78 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0300, TestSize.Level0)
79 {
80 auto vDecSample = make_shared<VDecNdkSample>();
81 vDecSample->INP_DIR = INP_DIR_1080_30;
82 vDecSample->DEFAULT_WIDTH = 1920;
83 vDecSample->DEFAULT_HEIGHT = 1080;
84 vDecSample->DEFAULT_FRAME_RATE = 30;
85 vDecSample->SURFACE_OUTPUT = false;
86 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec("OH.Media.Codec.Decoder.Video.AVC"));
87 vDecSample->WaitForEOS();
88 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
89 }
90
91 /**
92 * @tc.number : VIDEO_SWDEC_FUNCTION_0400
93 * @tc.name : test h264 decode surface
94 * @tc.desc : function test
95 */
96 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0400, TestSize.Level0)
97 {
98 auto vDecSample = make_shared<VDecNdkSample>();
99 vDecSample->INP_DIR = INP_DIR_1080_30;
100 vDecSample->SURFACE_OUTPUT = true;
101 vDecSample->DEFAULT_WIDTH = 1920;
102 vDecSample->DEFAULT_HEIGHT = 1080;
103 vDecSample->DEFAULT_FRAME_RATE = 30;
104 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
105 vDecSample->WaitForEOS();
106 bool isVaild = false;
107 OH_VideoDecoder_IsValid(vDecSample->vdec_, &isVaild);
108 ASSERT_EQ(false, isVaild);
109 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
110 }
111
112 /**
113 * @tc.number : VIDEO_SWDEC_FUNCTION_0500
114 * @tc.name : test h264 decode surface
115 * @tc.desc : function test
116 */
117 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0500, TestSize.Level2)
118 {
119 uint32_t errNo = DRM_ERR_OK;
120 #ifdef SUPPORT_DRM
121 std::string uuid;
122 if (OH_MediaKeySystem_IsSupported("com.clearplay.drm")) {
123 uuid.assign("com.clearplay.drm");
124 } else if (OH_MediaKeySystem_IsSupported("com.wiseplay.drm")) {
125 uuid.assign("com.wiseplay.drm");
126 }
127 errNo = DRM_ERR_INVALID_VAL;
128 MediaKeySystem *system = nullptr;
129 errNo = OH_MediaKeySystem_Create((const char *)uuid.c_str(), &system);
130 EXPECT_NE(system, nullptr);
131 EXPECT_EQ(errNo, DRM_ERR_OK);
132 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
133 MediaKeySession *session = nullptr;
134 errNo = OH_MediaKeySystem_CreateMediaKeySession(system, &contentProtectionLevel, &session);
135 EXPECT_NE(session, nullptr);
136 EXPECT_EQ(errNo, DRM_ERR_OK);
137
138 OH_AVCodec *vdec = OH_VideoDecoder_CreateByName("OH.Media.Codec.Decoder.Video.AVC");
139 errNo = OH_VideoDecoder_SetDecryptionConfig(vdec, session, false);
140 #endif
141 EXPECT_EQ(errNo, DRM_ERR_OK);
142 }
143
144 /**
145 * @tc.number : VIDEO_SWDEC_FUNCTION_0700
146 * @tc.name : test set EOS when last frame
147 * @tc.desc : function test
148 */
149 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0700, TestSize.Level1)
150 {
151 auto vDecSample = make_shared<VDecNdkSample>();
152 vDecSample->INP_DIR = INP_DIR_1080_30;
153 vDecSample->DEFAULT_WIDTH = 1920;
154 vDecSample->DEFAULT_HEIGHT = 1080;
155 vDecSample->DEFAULT_FRAME_RATE = 30;
156 vDecSample->SURFACE_OUTPUT = false;
157 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
158 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
159 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
160 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
161 vDecSample->WaitForEOS();
162 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
163 }
164
165 /**
166 * @tc.number : VIDEO_SWDEC_FUNCTION_0800
167 * @tc.name : test set EOS before last frame then stop
168 * @tc.desc : function test
169 */
170 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0800, TestSize.Level1)
171 {
172 auto vDecSample = make_shared<VDecNdkSample>();
173 vDecSample->INP_DIR = INP_DIR_1080_30;
174 vDecSample->DEFAULT_WIDTH = 1920;
175 vDecSample->DEFAULT_HEIGHT = 1080;
176 vDecSample->DEFAULT_FRAME_RATE = 30;
177 vDecSample->SURFACE_OUTPUT = false;
178 vDecSample->BEFORE_EOS_INPUT = true;
179 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
180 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
181 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
182 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
183 vDecSample->WaitForEOS();
184 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
185 }
186 /**
187 * @tc.number : VIDEO_SWDEC_FUNCTION_4000
188 * @tc.name : test set EOS before last frame then stop surface
189 * @tc.desc : function test
190 */
191
192 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_4000, TestSize.Level1)
193 {
194 auto vDecSample = make_shared<VDecNdkSample>();
195 vDecSample->INP_DIR = INP_DIR_1080_30;
196 vDecSample->DEFAULT_WIDTH = 1920;
197 vDecSample->DEFAULT_HEIGHT = 1080;
198 vDecSample->DEFAULT_FRAME_RATE = 30;
199 vDecSample->SURFACE_OUTPUT = true;
200 vDecSample->BEFORE_EOS_INPUT = true;
201 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
202 vDecSample->WaitForEOS();
203 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
204 }
205
206 /**
207 * @tc.number : VIDEO_SWDEC_FUNCTION_1000
208 * @tc.name : test reconfigure for new file with one decoder
209 * @tc.desc : function test
210 */
211 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1000, TestSize.Level1)
212 {
213 auto vDecSample = make_shared<VDecNdkSample>();
214 vDecSample->INP_DIR = INP_DIR_1080_30;
215 vDecSample->DEFAULT_WIDTH = 1920;
216 vDecSample->DEFAULT_HEIGHT = 1080;
217 vDecSample->DEFAULT_FRAME_RATE = 30;
218 vDecSample->SURFACE_OUTPUT = false;
219 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
220 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
221 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
222 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
223 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
224 vDecSample->WaitForEOS();
225 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
226 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
227 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
228 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
229 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
230 vDecSample->WaitForEOS();
231 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
232 }
233
234 /**
235 * @tc.number : VIDEO_SWDEC_FUNCTION_1100
236 * @tc.name : test reconfigure for new file with the recreated decoder
237 * @tc.desc : function test
238 */
239 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1100, TestSize.Level1)
240 {
241 auto vDecSample = make_shared<VDecNdkSample>();
242 vDecSample->INP_DIR = INP_DIR_1080_30;
243 vDecSample->DEFAULT_WIDTH = 1920;
244 vDecSample->DEFAULT_HEIGHT = 1080;
245 vDecSample->DEFAULT_FRAME_RATE = 30;
246 vDecSample->SURFACE_OUTPUT = false;
247 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
248 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
249 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
250 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
251 vDecSample->WaitForEOS();
252 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
253 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
254 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
255 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
256 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
257 vDecSample->WaitForEOS();
258 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
259 }
260
261 /**
262 * @tc.number : VIDEO_SWDEC_FUNCTION_1200
263 * @tc.name : repeat start and stop 5 times before EOS
264 * @tc.desc : function test
265 */
266 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1200, TestSize.Level2)
267 {
268 auto vDecSample = make_shared<VDecNdkSample>();
269 vDecSample->INP_DIR = INP_DIR_1080_30;
270 vDecSample->DEFAULT_WIDTH = 1920;
271 vDecSample->DEFAULT_HEIGHT = 1080;
272 vDecSample->DEFAULT_FRAME_RATE = 30;
273 vDecSample->SURFACE_OUTPUT = false;
274 vDecSample->REPEAT_START_STOP_BEFORE_EOS = 5;
275 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
276 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
277 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
278 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
279 vDecSample->WaitForEOS();
280 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
281 }
282
283 /**
284 * @tc.number : VIDEO_SWDEC_FUNCTION_1300
285 * @tc.name : repeat start and flush 5 times before EOS
286 * @tc.desc : function test
287 */
288 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1300, TestSize.Level2)
289 {
290 auto vDecSample = make_shared<VDecNdkSample>();
291 vDecSample->INP_DIR = INP_DIR_1080_30;
292 vDecSample->DEFAULT_WIDTH = 1920;
293 vDecSample->DEFAULT_HEIGHT = 1080;
294 vDecSample->DEFAULT_FRAME_RATE = 30;
295 vDecSample->SURFACE_OUTPUT = false;
296 vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 5;
297 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
298 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
299 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
300 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
301 vDecSample->WaitForEOS();
302 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
303 }
304
305 /**
306 * @tc.number : VIDEO_SWDEC_FUNCTION_1400
307 * @tc.name : set larger width and height
308 * @tc.desc : function test
309 */
310 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1400, TestSize.Level2)
311 {
312 auto vDecSample = make_shared<VDecNdkSample>();
313 vDecSample->INP_DIR = INP_DIR_720_30;
314 vDecSample->DEFAULT_WIDTH = 1920;
315 vDecSample->DEFAULT_HEIGHT = 1080;
316 vDecSample->DEFAULT_FRAME_RATE = 30;
317 vDecSample->SURFACE_OUTPUT = false;
318 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
319 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
320 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
321 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
322 vDecSample->WaitForEOS();
323 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
324 }
325
326 /**
327 * @tc.number : VIDEO_SWDEC_FUNCTION_1500
328 * @tc.name : set the width and height to a samller value
329 * @tc.desc : function test
330 */
331 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1500, TestSize.Level2)
332 {
333 auto vDecSample = make_shared<VDecNdkSample>();
334 vDecSample->INP_DIR = INP_DIR_1080_30;
335 vDecSample->DEFAULT_WIDTH = 1280;
336 vDecSample->DEFAULT_HEIGHT = 720;
337 vDecSample->DEFAULT_FRAME_RATE = 30;
338 vDecSample->SURFACE_OUTPUT = false;
339 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
340 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
341 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
342 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
343 vDecSample->WaitForEOS();
344 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
345 }
346
347 /**
348 * @tc.number : VIDEO_SWDEC_FUNCTION_1600
349 * @tc.name : resolution change
350 * @tc.desc : function test
351 */
352 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1600, TestSize.Level2)
353 {
354 auto vDecSample = make_shared<VDecNdkSample>();
355 vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
356 vDecSample->DEFAULT_WIDTH = 1104;
357 vDecSample->DEFAULT_HEIGHT = 622;
358 vDecSample->DEFAULT_FRAME_RATE = 30;
359 vDecSample->SURFACE_OUTPUT = false;
360 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
361 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
362 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
363 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
364 vDecSample->WaitForEOS();
365 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
366 }
367 } // namespace