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_codecNameHEVC = "";
56 constexpr int32_t DEFAULT_WIDTH = 1920;
57 constexpr int32_t DEFAULT_HEIGHT = 1080;
58 constexpr int32_t UHD_RESOLUTION[2] = {3840, 2160};
59 constexpr int32_t HD_RESOLUTION[2] = {1104, 622};
60 } // namespace
61 
SetUpTestCase()62 void HwdecFuncNdkTest::SetUpTestCase()
63 {
64     cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
65     g_codecName = OH_AVCapability_GetName(cap);
66     cout << "codecname: " << g_codecName << endl;
67     cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
68     g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
69     cout << "g_codecNameHEVC: " << g_codecNameHEVC << endl;
70 }
TearDownTestCase()71 void HwdecFuncNdkTest::TearDownTestCase() {}
SetUp()72 void HwdecFuncNdkTest::SetUp() {}
TearDown()73 void HwdecFuncNdkTest::TearDown() {}
74 
75 namespace {
76 /**
77  * @tc.number    : VIDEO_HWDEC_FUNCTION_0200
78  * @tc.name      : create nonexist decoder
79  * @tc.desc      : function test
80  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0200, TestSize.Level1)81 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0200, TestSize.Level1)
82 {
83     OH_AVCodec *vdec_ = OH_VideoDecoder_CreateByName("OMX.h264.decode.111.222.333");
84     ASSERT_EQ(nullptr, vdec_);
85 }
86 
87 /**
88  * @tc.number    : VIDEO_HWDEC_FUNCTION_0300
89  * @tc.name      : test h264 asyn decode buffer
90  * @tc.desc      : function test
91  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0300, TestSize.Level0)92 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0300, TestSize.Level0)
93 {
94     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
95     vDecSample->INP_DIR = INP_DIR_1080_30;
96     vDecSample->DEFAULT_WIDTH = 1920;
97     vDecSample->DEFAULT_HEIGHT = 1080;
98     vDecSample->DEFAULT_FRAME_RATE = 30;
99     vDecSample->SF_OUTPUT = false;
100     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
101     vDecSample->WaitForEOS();
102     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
103 }
104 
105 /**
106  * @tc.number    : VIDEO_HWDEC_FUNCTION_0400
107  * @tc.name      : test h264 asyn decode surface
108  * @tc.desc      : function test
109  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0400, TestSize.Level0)110 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0400, TestSize.Level0)
111 {
112     VDecNdkSample *vDecSample = new VDecNdkSample();
113     vDecSample->INP_DIR = INP_DIR_1080_30;
114     vDecSample->SF_OUTPUT = true;
115     vDecSample->DEFAULT_WIDTH = 1920;
116     vDecSample->DEFAULT_HEIGHT = 1080;
117     vDecSample->DEFAULT_FRAME_RATE = 30;
118     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
119     vDecSample->WaitForEOS();
120     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
121 }
122 
123 /**
124  * @tc.number    : VIDEO_HWDEC_FUNCTION_0700
125  * @tc.name      : test set EOS when last frame
126  * @tc.desc      : function test
127  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0700, TestSize.Level1)128 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0700, TestSize.Level1)
129 {
130     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
131     vDecSample->INP_DIR = INP_DIR_1080_30;
132     vDecSample->DEFAULT_WIDTH = 1920;
133     vDecSample->DEFAULT_HEIGHT = 1080;
134     vDecSample->DEFAULT_FRAME_RATE = 30;
135     vDecSample->SF_OUTPUT = false;
136     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
137     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
138     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
139     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
140     vDecSample->WaitForEOS();
141     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
142 }
143 
144 /**
145  * @tc.number    : VIDEO_HWDEC_FUNCTION_0800
146  * @tc.name      : test set EOS before last frame then stop
147  * @tc.desc      : function test
148  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0800, TestSize.Level1)149 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0800, TestSize.Level1)
150 {
151     shared_ptr<VDecNdkSample> 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->SF_OUTPUT = false;
157     vDecSample->BEFORE_EOS_INPUT = true;
158     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
159     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
160     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
161     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
162     vDecSample->WaitForEOS();
163     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
164 }
165 
166 /**
167  * @tc.number    : VIDEO_HWDEC_FUNCTION_0900
168  * @tc.name      : test set EOS before last frame then input frames
169  * @tc.desc      : function test
170  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0900, TestSize.Level1)171 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0900, TestSize.Level1)
172 {
173     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
174     vDecSample->INP_DIR = INP_DIR_1080_30;
175     vDecSample->DEFAULT_WIDTH = 1920;
176     vDecSample->DEFAULT_HEIGHT = 1080;
177     vDecSample->DEFAULT_FRAME_RATE = 30;
178     vDecSample->SF_OUTPUT = false;
179     vDecSample->BEFORE_EOS_INPUT_INPUT = true;
180     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
181     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
182     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
183     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
184     vDecSample->WaitForEOS();
185     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
186 }
187 
188 /**
189  * @tc.number    : VIDEO_HWDEC_FUNCTION_1000
190  * @tc.name      : test reconfigure for new file with one decoder
191  * @tc.desc      : function test
192  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1000, TestSize.Level1)193 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1000, TestSize.Level1)
194 {
195     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
196     vDecSample->INP_DIR = INP_DIR_1080_30;
197     vDecSample->DEFAULT_WIDTH = 1920;
198     vDecSample->DEFAULT_HEIGHT = 1080;
199     vDecSample->DEFAULT_FRAME_RATE = 30;
200     vDecSample->SF_OUTPUT = false;
201     vDecSample->AFTER_EOS_DESTORY_CODEC = false;
202     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
203     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
204     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
205     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
206     vDecSample->WaitForEOS();
207     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
208     ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
209     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
210     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
211     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
212     vDecSample->WaitForEOS();
213     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
214 }
215 
216 /**
217  * @tc.number    : VIDEO_HWDEC_FUNCTION_1100
218  * @tc.name      : test reconfigure for new file with the recreated decoder
219  * @tc.desc      : function test
220  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1100, TestSize.Level1)221 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1100, TestSize.Level1)
222 {
223     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
224     vDecSample->INP_DIR = INP_DIR_1080_30;
225     vDecSample->DEFAULT_WIDTH = 1920;
226     vDecSample->DEFAULT_HEIGHT = 1080;
227     vDecSample->DEFAULT_FRAME_RATE = 30;
228     vDecSample->SF_OUTPUT = false;
229     vDecSample->AFTER_EOS_DESTORY_CODEC = false;
230     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
231     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
232     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
233     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
234     vDecSample->WaitForEOS();
235     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
236     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
237     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
238     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
239     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
240     vDecSample->WaitForEOS();
241     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
242 }
243 
244 /**
245  * @tc.number    : VIDEO_HWDEC_FUNCTION_1200
246  * @tc.name      : repeat start and stop 5 times before EOS
247  * @tc.desc      : function test
248  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1200, TestSize.Level2)249 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1200, TestSize.Level2)
250 {
251     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
252     vDecSample->INP_DIR = INP_DIR_1080_30;
253     vDecSample->DEFAULT_WIDTH = 1920;
254     vDecSample->DEFAULT_HEIGHT = 1080;
255     vDecSample->DEFAULT_FRAME_RATE = 30;
256     vDecSample->SF_OUTPUT = false;
257     vDecSample->REPEAT_START_STOP_BEFORE_EOS = 5;
258     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
259     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
260     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
261     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
262     vDecSample->WaitForEOS();
263     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
264 }
265 
266 /**
267  * @tc.number    : VIDEO_HWDEC_FUNCTION_1300
268  * @tc.name      : repeat start and flush 5 times before EOS
269  * @tc.desc      : function test
270  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1300, TestSize.Level2)271 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1300, TestSize.Level2)
272 {
273     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
274     vDecSample->INP_DIR = INP_DIR_1080_30;
275     vDecSample->DEFAULT_WIDTH = 1920;
276     vDecSample->DEFAULT_HEIGHT = 1080;
277     vDecSample->DEFAULT_FRAME_RATE = 30;
278     vDecSample->SF_OUTPUT = false;
279     vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 5;
280     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
281     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
282     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
283     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
284     vDecSample->WaitForEOS();
285     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
286 }
287 
288 /**
289  * @tc.number    : VIDEO_HWDEC_FUNCTION_1400
290  * @tc.name      : set larger width and height
291  * @tc.desc      : function test
292  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1400, TestSize.Level2)293 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1400, TestSize.Level2)
294 {
295     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
296     vDecSample->INP_DIR = INP_DIR_720_30;
297     vDecSample->DEFAULT_WIDTH = 1920;
298     vDecSample->DEFAULT_HEIGHT = 1080;
299     vDecSample->DEFAULT_FRAME_RATE = 30;
300     vDecSample->SF_OUTPUT = false;
301     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
302     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
303     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
304     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
305     vDecSample->WaitForEOS();
306     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
307 }
308 
309 /**
310  * @tc.number    : VIDEO_HWDEC_FUNCTION_1600
311  * @tc.name      : 265 decode
312  * @tc.desc      : function test
313  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1600, TestSize.Level2)314 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1600, TestSize.Level2)
315 {
316     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
317     vDecSample->INP_DIR = "/data/test/media/1920_1080_20M_30.h265";
318     vDecSample->DEFAULT_WIDTH = 1920;
319     vDecSample->DEFAULT_HEIGHT = 1080;
320     vDecSample->DEFAULT_FRAME_RATE = 30;
321     vDecSample->SF_OUTPUT = false;
322     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
323     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
324     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
325     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
326     vDecSample->WaitForEOS();
327     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
328 }
329 
330 /**
331  * @tc.number    : VIDEO_HWDEC_FUNCTION_1700
332  * @tc.name      : resolution change
333  * @tc.desc      : function test
334  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1700, TestSize.Level2)335 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1700, TestSize.Level2)
336 {
337     if (g_codecName.find("hisi") != string::npos) {
338         auto vDecSample = make_shared<VDecNdkSample>();
339         vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
340         vDecSample->DEFAULT_WIDTH = 1104;
341         vDecSample->DEFAULT_HEIGHT = 622;
342         vDecSample->DEFAULT_FRAME_RATE = 30;
343         vDecSample->SF_OUTPUT = false;
344         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
345         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
346         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
347         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
348         vDecSample->WaitForEOS();
349         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
350     } else {
351         cout << "hardware encoder is rk,skip." << endl;
352     }
353 }
354 /**
355  * @tc.number    : SURF_CHANGE_FUNC_001
356  * @tc.name      : surf change in normal state
357  * @tc.desc      : function test
358  */
HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_001, TestSize.Level0)359 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_001, TestSize.Level0)
360 {
361     auto vDecSample = make_shared<VDecNdkSample>();
362     vDecSample->INP_DIR = INP_DIR_1080_30;
363     vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
364     vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
365     vDecSample->DEFAULT_FRAME_RATE = 30;
366     vDecSample->SF_OUTPUT = true;
367     vDecSample->autoSwitchSurface = true;
368     vDecSample->AFTER_EOS_DESTORY_CODEC = false;
369     vDecSample->sleepOnFPS = true;
370     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
371     vDecSample->WaitForEOS();
372     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
373     ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
374     ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
375     ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
376 }
377 /**
378  * @tc.number    : SURF_CHANGE_FUNC_002
379  * @tc.name      : surf change in flushed state
380  * @tc.desc      : function test
381  */
HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_002, TestSize.Level0)382 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_002, TestSize.Level0)
383 {
384     auto vDecSample = make_shared<VDecNdkSample>();
385     vDecSample->INP_DIR = INP_DIR_1080_30;
386     vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
387     vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
388     vDecSample->DEFAULT_FRAME_RATE = 30;
389     vDecSample->SF_OUTPUT = true;
390     vDecSample->autoSwitchSurface = true;
391     vDecSample->sleepOnFPS = true;
392     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
393     ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
394     ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
395     ASSERT_EQ(AV_ERR_OK, vDecSample->Stop());
396     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
397 }
398 /**
399  * @tc.number    : SURF_CHANGE_FUNC_003
400  * @tc.name      : surf change in buffer mode
401  * @tc.desc      : function test
402  */
HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_003, TestSize.Level0)403 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_003, TestSize.Level0)
404 {
405     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
406     vDecSample->INP_DIR = INP_DIR_1080_30;
407     vDecSample->DEFAULT_WIDTH = 1920;
408     vDecSample->DEFAULT_HEIGHT = 1080;
409     vDecSample->DEFAULT_FRAME_RATE = 30;
410     vDecSample->SF_OUTPUT = false;
411     vDecSample->CreateSurface();
412     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
413     ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
414     vDecSample->WaitForEOS();
415     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
416 }
417 /**
418  * @tc.number    : SURF_CHANGE_FUNC_004
419  * @tc.name      : repeat call setSurface fastly
420  * @tc.desc      : function test
421  */
HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_004, TestSize.Level0)422 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_004, TestSize.Level0)
423 {
424     auto vDecSample = make_shared<VDecNdkSample>();
425     vDecSample->INP_DIR = INP_DIR_1080_30;
426     vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
427     vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
428     vDecSample->DEFAULT_FRAME_RATE = 30;
429     vDecSample->SF_OUTPUT = true;
430     vDecSample->autoSwitchSurface = true;
431     vDecSample->sleepOnFPS = true;
432     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
433     ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
434     vDecSample->WaitForEOS();
435 }
436 
437 /**
438  * @tc.number    : OUTPUT_DECS_FUNC_001
439  * @tc.name      : get decode output descriptions h264
440  * @tc.desc      : function test
441  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_001, TestSize.Level0)442 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_001, TestSize.Level0)
443 {
444     auto vDecSample = make_shared<VDecNdkSample>();
445     vDecSample->INP_DIR = "/data/test/media/1920x1080.h264";
446     vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
447     vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
448     vDecSample->DEFAULT_FRAME_RATE = 30;
449     vDecSample->needCheckOutputDesc = true;
450     vDecSample->expectCropTop = 0;
451     vDecSample->expectCropBottom = DEFAULT_HEIGHT - 1;
452     vDecSample->expectCropLeft = 0;
453     vDecSample->expectCropRight = DEFAULT_WIDTH - 1;
454 
455     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
456     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
457     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
458     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
459     vDecSample->WaitForEOS();
460     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
461 }
462 /**
463  * @tc.number    : OUTPUT_DECS_FUNC_002
464  * @tc.name      : get decode output descriptions h265
465  * @tc.desc      : function test
466  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_002, TestSize.Level0)467 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_002, TestSize.Level0)
468 {
469     auto vDecSample = make_shared<VDecNdkSample>();
470     vDecSample->INP_DIR = "/data/test/media/1920x1080.h265";
471     vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
472     vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
473     vDecSample->DEFAULT_FRAME_RATE = 30;
474     vDecSample->needCheckOutputDesc = true;
475     vDecSample->expectCropTop = 0;
476     vDecSample->expectCropBottom = DEFAULT_HEIGHT - 1;
477     vDecSample->expectCropLeft = 0;
478     vDecSample->expectCropRight = DEFAULT_WIDTH - 1;
479 
480     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
481     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
482     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
483     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
484     vDecSample->WaitForEOS();
485     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
486 }
487 /**
488  * @tc.number    : OUTPUT_DECS_FUNC_003
489  * @tc.name      : get decode output descriptions h264 ,4k
490  * @tc.desc      : function test
491  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_003, TestSize.Level0)492 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_003, TestSize.Level0)
493 {
494     auto vDecSample = make_shared<VDecNdkSample>();
495     vDecSample->INP_DIR = "/data/test/media/3840x2160.h264";
496     vDecSample->DEFAULT_WIDTH = UHD_RESOLUTION[0];
497     vDecSample->DEFAULT_HEIGHT = UHD_RESOLUTION[1];
498     vDecSample->DEFAULT_FRAME_RATE = 30;
499     vDecSample->needCheckOutputDesc = true;
500     vDecSample->expectCropTop = 0;
501     vDecSample->expectCropBottom = UHD_RESOLUTION[1] - 1;
502     vDecSample->expectCropLeft = 0;
503     vDecSample->expectCropRight = UHD_RESOLUTION[0] - 1;
504 
505     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
506     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
507     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
508     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
509     vDecSample->WaitForEOS();
510     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
511 }
512 /**
513  * @tc.number    : OUTPUT_DECS_FUNC_004
514  * @tc.name      : get decode output descriptions h265 ,4k
515  * @tc.desc      : function test
516  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_004, TestSize.Level0)517 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_004, TestSize.Level0)
518 {
519     auto vDecSample = make_shared<VDecNdkSample>();
520     vDecSample->INP_DIR = "/data/test/media/3840x2160.h265";
521     vDecSample->DEFAULT_WIDTH = UHD_RESOLUTION[0];
522     vDecSample->DEFAULT_HEIGHT = UHD_RESOLUTION[1];
523     vDecSample->DEFAULT_FRAME_RATE = 30;
524     vDecSample->needCheckOutputDesc = true;
525     vDecSample->expectCropTop = 0;
526     vDecSample->expectCropBottom = UHD_RESOLUTION[1] - 1;
527     vDecSample->expectCropLeft = 0;
528     vDecSample->expectCropRight = UHD_RESOLUTION[0] - 1;
529 
530     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
531     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
532     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
533     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
534     vDecSample->WaitForEOS();
535     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
536 }
537 /**
538  * @tc.number    : OUTPUT_DECS_FUNC_005
539  * @tc.name      : get decode output descriptions h264 ,crop size
540  * @tc.desc      : function test
541  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_005, TestSize.Level0)542 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_005, TestSize.Level0)
543 {
544     auto vDecSample = make_shared<VDecNdkSample>();
545     vDecSample->INP_DIR = "/data/test/media/1104x622.h265";
546     vDecSample->DEFAULT_WIDTH = HD_RESOLUTION[0];
547     vDecSample->DEFAULT_HEIGHT = HD_RESOLUTION[1];
548     vDecSample->DEFAULT_FRAME_RATE = 30;
549     vDecSample->needCheckOutputDesc = true;
550     vDecSample->expectCropTop = 0;
551     vDecSample->expectCropBottom = HD_RESOLUTION[1] - 1;
552     vDecSample->expectCropLeft = 0;
553     vDecSample->expectCropRight = HD_RESOLUTION[0] - 1;
554 
555     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
556     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
557     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
558     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
559     vDecSample->WaitForEOS();
560     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
561 }
562 /**
563  * @tc.number    : OUTPUT_DECS_FUNC_006
564  * @tc.name      : get decode output descriptions h265 ,crop size
565  * @tc.desc      : function test
566  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_006, TestSize.Level0)567 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_006, TestSize.Level0)
568 {
569     auto vDecSample = make_shared<VDecNdkSample>();
570     vDecSample->INP_DIR = "/data/test/media/1104x622.h265";
571     vDecSample->DEFAULT_WIDTH = HD_RESOLUTION[0];
572     vDecSample->DEFAULT_HEIGHT = HD_RESOLUTION[1];
573     vDecSample->DEFAULT_FRAME_RATE = 30;
574     vDecSample->needCheckOutputDesc = true;
575     vDecSample->expectCropTop = 0;
576     vDecSample->expectCropBottom = HD_RESOLUTION[1] - 1;
577     vDecSample->expectCropLeft = 0;
578     vDecSample->expectCropRight = HD_RESOLUTION[0] - 1;
579 
580     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
581     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
582     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
583     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
584     vDecSample->WaitForEOS();
585     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
586 }
587 /**
588  * @tc.number    : OUTPUT_DECS_FUNC_007
589  * @tc.name      : get decode output descriptions h265 ,resolution change
590  * @tc.desc      : function test
591  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_007, TestSize.Level0)592 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_007, TestSize.Level0)
593 {
594     if (g_codecName.find("hisi") != string::npos) {
595         auto vDecSample = make_shared<VDecNdkSample>();
596         vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
597         vDecSample->DEFAULT_WIDTH = HD_RESOLUTION[0];
598         vDecSample->DEFAULT_HEIGHT = HD_RESOLUTION[1];
599         vDecSample->DEFAULT_FRAME_RATE = 30;
600         vDecSample->isResChangeStream = true;
601         vDecSample->expectCropTop = 0;
602         vDecSample->expectCropBottom = HD_RESOLUTION[1] - 1;
603         vDecSample->expectCropLeft = 0;
604         vDecSample->expectCropRight = HD_RESOLUTION[0] - 1;
605 
606         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
607         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
608         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
609         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
610         vDecSample->WaitForEOS();
611         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
612     } else {
613         cout << "hardware encoder is rk,skip." << endl;
614     }
615 }
616 } // namespace