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