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