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