1 /*
2  * Copyright (C) 2024 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 
16 #include <iostream>
17 #include <cstdio>
18 #include <atomic>
19 #include <fstream>
20 #include <thread>
21 #include <mutex>
22 #include <queue>
23 #include <string>
24 #include "gtest/gtest.h"
25 #include "native_avcodec_videodecoder.h"
26 #include "videodec_api11_sample.h"
27 #include "native_avcodec_base.h"
28 #include "videodec_sample.h"
29 #include "native_avcapability.h"
30 
31 using namespace std;
32 using namespace OHOS;
33 using namespace OHOS::Media;
34 using namespace testing::ext;
35 
36 namespace OHOS {
37 namespace Media {
38 class HevcSwdecReliNdkTest : public testing::Test {
39 public:
40     static void SetUpTestCase();    // 第一个测试用例执行前
41     static void TearDownTestCase(); // 最后一个测试用例执行后
42     void SetUp() override;          // 每个测试用例执行前
43     void TearDown() override;       // 每个测试用例执行后
44     void Release();
45     int32_t Stop();
46 
47 protected:
48     OH_AVCodec *vdec_;
49     const char *INP_DIR_1080_30 = "/data/test/media/1920_1080_30.h265";
50     const char *INP_DIR_144 = "/data/test/media/176_144_Main10.h265";
51     const char *INP_DIR_720 = "/data/test/media/1280_720_Main_svc.h265";
52     const char *INP_DIR_64 = "/data/test/media/64_64_Main.h265";
53     const char *inpDir1080Array[16] = {
54         "/data/test/media/1920_1080_30.h265",    "/data/test/media/1920_1080_30_1.h265",
55         "/data/test/media/1920_1080_30_2.h265",  "/data/test/media/1920_1080_30_3.h265",
56         "/data/test/media/1920_1080_30_4.h265",  "/data/test/media/1920_1080_30_5.h265",
57         "/data/test/media/1920_1080_30_6.h265",  "/data/test/media/1920_1080_30_7.h265",
58         "/data/test/media/1920_1080_30_8.h265",  "/data/test/media/1920_1080_30_9.h265",
59         "/data/test/media/1920_1080_30_10.h265", "/data/test/media/1920_1080_30_11.h265",
60         "/data/test/media/1920_1080_30_12.h265",  "/data/test/media/1920_1080_30_13.h265",
61         "/data/test/media/1920_1080_30_14.h265", "/data/test/media/1920_1080_30_15.h265"};
62 };
63 } // namespace Media
64 } // namespace OHOS
65 
66 static string g_codecName_hevc = "";
67 static string g_codecName_hisi = "";
68 int32_t reli_count = 16;
69 int32_t reli_count_1000 = 1000;
SetUpTestCase()70 void HevcSwdecReliNdkTest::SetUpTestCase()
71 {
72     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(
73         OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
74     g_codecName_hevc = OH_AVCapability_GetName(cap);
75     cout << "g_codecName_hevc: " << g_codecName_hevc << endl;
76 
77     OH_AVCapability *cap2 = OH_AVCodec_GetCapabilityByCategory(
78         OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
79     g_codecName_hisi = OH_AVCapability_GetName(cap2);
80     cout << "g_codecName_hisi: " << g_codecName_hisi  << endl;
81 }
82 
TearDownTestCase()83 void HevcSwdecReliNdkTest::TearDownTestCase() {}
SetUp()84 void HevcSwdecReliNdkTest::SetUp() {}
TearDown()85 void HevcSwdecReliNdkTest::TearDown() {}
86 
87 namespace {
88 /**
89  * @tc.number    : VIDEO_SWDEC_STABILITY_0010
90  * @tc.name      : h265 soft decode successively 16 times
91  * @tc.desc      : reli test
92  */
HWTEST_F(HevcSwdecReliNdkTest, VIDEO_SWDEC_STABILITY_0010, TestSize.Level3)93 HWTEST_F(HevcSwdecReliNdkTest, VIDEO_SWDEC_STABILITY_0010, TestSize.Level3)
94 {
95     if (!access("/system/lib64/media/", 0)) {
96         for (int i = 0; i < reli_count; i++) {
97             auto vDecSample = make_shared<VDecNdkSample>();
98             vDecSample->SF_OUTPUT = false;
99             vDecSample->INP_DIR = INP_DIR_1080_30;
100             vDecSample->DEFAULT_WIDTH = 1920;
101             vDecSample->DEFAULT_HEIGHT = 1080;
102             vDecSample->DEFAULT_FRAME_RATE = 30;
103             vDecSample->sleepOnFPS = true;
104             ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName_hevc.c_str()));
105             ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
106             ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
107             ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
108             vDecSample->WaitForEOS();
109             ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
110         }
111     }
112 }
113 
114 /**
115  * @tc.number    : VIDEO_SWDEC_STABILITY_0020
116  * @tc.name      : h265 soft decode 16 times successively with Surface change fastly
117  * @tc.desc      : reli test
118  */
HWTEST_F(HevcSwdecReliNdkTest, VIDEO_SWDEC_STABILITY_0020, TestSize.Level3)119 HWTEST_F(HevcSwdecReliNdkTest, VIDEO_SWDEC_STABILITY_0020, TestSize.Level3)
120 {
121     if (!access("/system/lib64/media/", 0)) {
122         for (int i = 0; i < reli_count; i++) {
123             auto vDecSample = make_shared<VDecNdkSample>();
124             vDecSample->INP_DIR = INP_DIR_1080_30;
125             vDecSample->DEFAULT_WIDTH = 1920;
126             vDecSample->DEFAULT_HEIGHT = 1080;
127             vDecSample->DEFAULT_FRAME_RATE = 30;
128             vDecSample->sleepOnFPS = true;
129             vDecSample->autoSwitchSurface = true;
130             vDecSample->SF_OUTPUT = true;
131             ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName_hevc));
132             ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
133             vDecSample->WaitForEOS();
134         }
135     }
136 }
137 
138 /**
139  * @tc.number    : VIDEO_SWDEC_STABLITY_0030
140  * @tc.name      : 16 Multiple instances h265 soft decode with Surface mode
141  * @tc.desc      : reli test
142  */
HWTEST_F(HevcSwdecReliNdkTest, VIDEO_SWDEC_STABILITY_0030, TestSize.Level3)143 HWTEST_F(HevcSwdecReliNdkTest, VIDEO_SWDEC_STABILITY_0030, TestSize.Level3)
144 {
145     if (!access("/system/lib64/media/", 0)) {
146         vector<shared_ptr<VDecNdkSample>> decVec;
147         for (int i = 0; i < reli_count; i++) {
148             auto vDecSample = make_shared<VDecNdkSample>();
149             decVec.push_back(vDecSample);
150             vDecSample->INP_DIR = inpDir1080Array[i];
151             vDecSample->DEFAULT_WIDTH = 1920;
152             vDecSample->DEFAULT_HEIGHT = 1080;
153             vDecSample->DEFAULT_FRAME_RATE = 30;
154             vDecSample->autoSwitchSurface = false;
155             vDecSample->sleepOnFPS = true;
156             ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName_hevc));
157         }
158         uint32_t errorCount = 0;
159         for_each(decVec.begin(), decVec.end(), [&errorCount](auto sample) {
160             sample->WaitForEOS();
161             errorCount += sample->errCount;
162         });
163         decVec.clear();
164     }
165 }
166 
167 /**
168  * @tc.number    : VIDEO_SWDEC_STABILITY_0040
169  * @tc.name      : 16 Multiple instances h265 soft decode with buffer mode
170  * @tc.desc      : reli test
171  */
HWTEST_F(HevcSwdecReliNdkTest, VIDEO_SWDEC_STABILITY_0040, TestSize.Level3)172 HWTEST_F(HevcSwdecReliNdkTest, VIDEO_SWDEC_STABILITY_0040, TestSize.Level3)
173 {
174     if (!access("/system/lib64/media/", 0)) {
175         vector<shared_ptr<VDecNdkSample>> decVec;
176         for (int i = 0; i < reli_count; i++) {
177             auto vDecSample = make_shared<VDecNdkSample>();
178             decVec.push_back(vDecSample);
179             vDecSample->INP_DIR = inpDir1080Array[i];
180             vDecSample->DEFAULT_WIDTH = 1920;
181             vDecSample->DEFAULT_HEIGHT = 1080;
182             vDecSample->DEFAULT_FRAME_RATE = 30;
183             vDecSample->autoSwitchSurface = false;
184             vDecSample->sleepOnFPS = true;
185             ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName_hevc.c_str()));
186         }
187         uint32_t errorCount = 0;
188         for_each(decVec.begin(), decVec.end(), [&errorCount](auto sample) {
189             sample->WaitForEOS();
190             errorCount += sample->errCount;
191         });
192         decVec.clear();
193     }
194 }
195 
196 /**
197  * @tc.number    : VIDEO_SWDEC_STABILITY_0050
198  * @tc.name      : repeat start before eos 1000 times
199  * @tc.desc      : reli test
200  */
HWTEST_F(HevcSwdecReliNdkTest, VIDEO_SWDEC_STABILITY_0050, TestSize.Level3)201 HWTEST_F(HevcSwdecReliNdkTest, VIDEO_SWDEC_STABILITY_0050, TestSize.Level3)
202 {
203     if (!access("/system/lib64/media/", 0)) {
204         auto vDecSample = make_shared<VDecNdkSample>();
205         vDecSample->INP_DIR = INP_DIR_1080_30;
206         vDecSample->DEFAULT_WIDTH = 1920;
207         vDecSample->DEFAULT_HEIGHT = 1080;
208         vDecSample->DEFAULT_FRAME_RATE = 30;
209         vDecSample->SF_OUTPUT = false;
210         vDecSample->REPEAT_START_STOP_BEFORE_EOS = 1000;
211         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName_hevc.c_str()));
212         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
213         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
214         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
215         vDecSample->WaitForEOS();
216         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
217     }
218 }
219 
220 /**
221  * @tc.number    : VIDEO_SWDEC_STABILITY_0060
222  * @tc.name      : repeat start flush before eos 1000 time
223  * @tc.desc      : reli test
224  */
HWTEST_F(HevcSwdecReliNdkTest, VIDEO_SWDEC_STABILITY_0060, TestSize.Level3)225 HWTEST_F(HevcSwdecReliNdkTest, VIDEO_SWDEC_STABILITY_0060, TestSize.Level3)
226 {
227     if (!access("/system/lib64/media/", 0)) {
228         auto vDecSample = make_shared<VDecNdkSample>();
229         vDecSample->INP_DIR = INP_DIR_1080_30;
230         vDecSample->DEFAULT_WIDTH = 1920;
231         vDecSample->DEFAULT_HEIGHT = 1080;
232         vDecSample->DEFAULT_FRAME_RATE = 30;
233         vDecSample->SF_OUTPUT = false;
234         vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 1000;
235         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName_hevc));
236         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
237         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
238         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
239         vDecSample->WaitForEOS();
240     }
241 }
242 
243 /**
244  * @tc.number    : API11_VIDEO_SWDEC_STABILITY_0010
245  * @tc.name      : h265 soft decode 16 times successively
246  * @tc.desc      : reli test
247  */
HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0010, TestSize.Level3)248 HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0010, TestSize.Level3)
249 {
250     if (!access("/system/lib64/media/", 0)) {
251         for (int i = 0; i < reli_count; i++) {
252             auto vDecSample = make_shared<VDecAPI11Sample>();
253             vDecSample->SF_OUTPUT = false;
254             vDecSample->INP_DIR = INP_DIR_1080_30;
255             vDecSample->DEFAULT_WIDTH = 1920;
256             vDecSample->DEFAULT_HEIGHT = 1080;
257             vDecSample->DEFAULT_FRAME_RATE = 30;
258             vDecSample->sleepOnFPS = true;
259             ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName_hevc));
260             ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
261             ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
262             ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
263             vDecSample->WaitForEOS();
264             ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
265         }
266     }
267 }
268 
269 /**
270  * @tc.number    : API11_VIDEO_SWDEC_STABILITY_0020
271  * @tc.name      : h265 soft decode 16 time successively with Surface change fastly
272  * @tc.desc      : reli test
273  */
HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0020, TestSize.Level3)274 HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0020, TestSize.Level3)
275 {
276     if (!access("/system/lib64/media/", 0)) {
277         for (int i = 0; i < reli_count; i++) {
278             auto vDecSample = make_shared<VDecAPI11Sample>();
279             vDecSample->INP_DIR = INP_DIR_1080_30;
280             vDecSample->DEFAULT_WIDTH = 1920;
281             vDecSample->DEFAULT_HEIGHT = 1080;
282             vDecSample->DEFAULT_FRAME_RATE = 30;
283             vDecSample->SF_OUTPUT = true;
284             vDecSample->autoSwitchSurface = true;
285             vDecSample->sleepOnFPS = true;
286             ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName_hevc));
287             ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
288             vDecSample->WaitForEOS();
289         }
290     }
291 }
292 /**
293  * @tc.number    : API11_VIDEO_SWDEC_STABILITY_0030
294  * @tc.name      : 16 Multiple instances h265 soft decode with Surface mode
295  * @tc.desc      : reli test
296  */
HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0030, TestSize.Level3)297 HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0030, TestSize.Level3)
298 {
299     if (!access("/system/lib64/media/", 0)) {
300         vector<shared_ptr<VDecAPI11Sample>> decVec;
301         for (int i = 0; i < reli_count; i++) {
302             auto vDecSample = make_shared<VDecAPI11Sample>();
303             decVec.push_back(vDecSample);
304             vDecSample->INP_DIR = inpDir1080Array[i];
305             vDecSample->DEFAULT_WIDTH = 1920;
306             vDecSample->DEFAULT_HEIGHT = 1080;
307             vDecSample->DEFAULT_FRAME_RATE = 30;
308             vDecSample->SF_OUTPUT = true;
309             vDecSample->autoSwitchSurface = false;
310             vDecSample->sleepOnFPS = true;
311             ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName_hevc));
312         }
313         uint32_t errorCount = 0;
314         for_each(decVec.begin(), decVec.end(), [&errorCount](auto sample) {
315             sample->WaitForEOS();
316             errorCount += sample->errCount;
317         });
318         decVec.clear();
319     }
320 }
321 
322 /**
323  * @tc.number    : API11_VIDEO_SWDEC_STABILITY_0040
324  * @tc.name      : 16 Multiple instances h265 soft decode with buffer mode
325  * @tc.desc      : reli test
326  */
HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0040, TestSize.Level3)327 HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0040, TestSize.Level3)
328 {
329     if (!access("/system/lib64/media/", 0)) {
330         vector<shared_ptr<VDecAPI11Sample>> decVec;
331         for (int i = 0; i < reli_count; i++) {
332             auto vDecSample = make_shared<VDecAPI11Sample>();
333             decVec.push_back(vDecSample);
334             vDecSample->SF_OUTPUT = false;
335             vDecSample->INP_DIR = INP_DIR_1080_30;
336             vDecSample->DEFAULT_WIDTH = 1920;
337             vDecSample->DEFAULT_HEIGHT = 1080;
338             vDecSample->DEFAULT_FRAME_RATE = 30;
339             vDecSample->sleepOnFPS = true;
340             ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName_hevc));
341             ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
342             ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
343             ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
344         }
345         uint32_t errorCount = 0;
346         for_each(decVec.begin(), decVec.end(), [&errorCount](auto sample) {
347             sample->WaitForEOS();
348             errorCount += sample->errCount;
349         });
350         decVec.clear();
351     }
352 }
353 
354 /**
355  * @tc.number    : API11_VIDEO_SWDEC_STABILITY_0050
356  * @tc.name      : 16 Multiple instances h265 soft decode with buffer mode × 5 LOOP
357  * @tc.desc      : reli test
358  */
HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0050, TestSize.Level3)359 HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0050, TestSize.Level3)
360 {
361     if (!access("/system/lib64/media/", 0)) {
362         for (int j = 0; j < 5; j++) {
363             vector<shared_ptr<VDecAPI11Sample>> decVec;
364             for (int i = 0; i < reli_count; i++) {
365                 auto vDecSample = make_shared<VDecAPI11Sample>();
366                 decVec.push_back(vDecSample);
367                 vDecSample->SF_OUTPUT = false;
368                 vDecSample->INP_DIR = INP_DIR_1080_30;
369                 vDecSample->DEFAULT_WIDTH = 1920;
370                 vDecSample->DEFAULT_HEIGHT = 1080;
371                 vDecSample->DEFAULT_FRAME_RATE = 30;
372                 vDecSample->sleepOnFPS = true;
373                 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName_hevc));
374                 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
375                 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
376                 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
377             }
378             uint32_t errorCount = 0;
379             for_each(decVec.begin(), decVec.end(), [&errorCount](auto sample) {
380                 sample->WaitForEOS();
381                 errorCount += sample->errCount;
382             });
383             decVec.clear();
384         }
385     }
386 }
387 
388 /**
389  * @tc.number    : API11_VIDEO_SWDEC_STABILITY_0070
390  * @tc.name      : repeat start and stop 1000 times before EOS
391  * @tc.desc      : reli test
392  */
HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0070, TestSize.Level2)393 HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0070, TestSize.Level2)
394 {
395     if (!access("/system/lib64/media/", 0)) {
396         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
397         vDecSample->INP_DIR = INP_DIR_1080_30;
398         vDecSample->DEFAULT_WIDTH = 1920;
399         vDecSample->DEFAULT_HEIGHT = 1080;
400         vDecSample->DEFAULT_FRAME_RATE = 30;
401         vDecSample->SF_OUTPUT = false;
402         vDecSample->REPEAT_START_STOP_BEFORE_EOS = 1000;
403         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName_hevc));
404         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
405         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
406         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
407         vDecSample->WaitForEOS();
408         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
409     }
410 }
411 
412 /**
413  * @tc.number    : API11_VIDEO_SWDEC_STABILITY_0080
414  * @tc.name      : repeat start and flush 1000 times before EOS
415  * @tc.desc      : reli test
416  */
HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0080, TestSize.Level2)417 HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0080, TestSize.Level2)
418 {
419     if (!access("/system/lib64/media/", 0)) {
420         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
421         vDecSample->INP_DIR = INP_DIR_1080_30;
422         vDecSample->DEFAULT_WIDTH = 1920;
423         vDecSample->DEFAULT_HEIGHT = 1080;
424         vDecSample->DEFAULT_FRAME_RATE = 30;
425         vDecSample->SF_OUTPUT = false;
426         vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 1000;
427         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName_hevc));
428         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
429         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
430         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
431         vDecSample->WaitForEOS();
432     }
433 }
434 
435 /**
436  * @tc.number    : API11_VIDEO_SWDEC_STABILITY_0090
437  * @tc.name      : SVC stream and common stream decode simultaneously
438  * @tc.desc      : reli test
439  */
HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0090, TestSize.Level0)440 HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0090, TestSize.Level0)
441 {
442     if (!access("/system/lib64/media/", 0)) {
443         for (int i = 0; i < reli_count; i++) {
444             shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
445             vDecSample->INP_DIR = INP_DIR_1080_30;
446             vDecSample->DEFAULT_WIDTH = 1920;
447             vDecSample->DEFAULT_HEIGHT = 1080;
448             vDecSample->DEFAULT_FRAME_RATE = 30;
449             vDecSample->sleepOnFPS = true;
450             ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName_hevc));
451             vDecSample->WaitForEOS();
452             ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
453 
454             shared_ptr<VDecAPI11Sample> vDecSample1 = make_shared<VDecAPI11Sample>();
455             vDecSample1->INP_DIR = INP_DIR_720;
456             vDecSample1->DEFAULT_WIDTH = 1280;
457             vDecSample1->DEFAULT_HEIGHT = 720;
458             vDecSample1->DEFAULT_FRAME_RATE = 30;
459             vDecSample1->sleepOnFPS = true;
460             ASSERT_EQ(AV_ERR_OK, vDecSample1->RunVideoDec(g_codecName_hevc));
461             vDecSample1->WaitForEOS();
462             ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
463         }
464     }
465 }
466 
467 /**
468  * @tc.number    : API11_VIDEO_SWDEC_STABILITY_0100
469  * @tc.name      : 10bit stream and 8bit stream decode simultaneously
470  * @tc.desc      : reli test
471  */
HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0100, TestSize.Level0)472 HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0100, TestSize.Level0)
473 {
474     if (!access("/system/lib64/media/", 0)) {
475         for (int i = 0; i < reli_count; i++) {
476             shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
477             vDecSample->INP_DIR = INP_DIR_144;
478             vDecSample->DEFAULT_WIDTH = 176;
479             vDecSample->DEFAULT_HEIGHT = 144;
480             vDecSample->DEFAULT_FRAME_RATE = 30;
481             vDecSample->SF_OUTPUT = false;
482             ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName_hevc));
483             vDecSample->WaitForEOS();
484 
485             shared_ptr<VDecAPI11Sample> vDecSample1 = make_shared<VDecAPI11Sample>();
486             vDecSample1->INP_DIR = INP_DIR_1080_30;
487             vDecSample1->DEFAULT_WIDTH = 1920;
488             vDecSample1->DEFAULT_HEIGHT = 1080;
489             vDecSample1->DEFAULT_FRAME_RATE = 30;
490             vDecSample1->SF_OUTPUT = true;
491             ASSERT_EQ(AV_ERR_OK, vDecSample1->RunVideoDec_Surface(g_codecName_hevc));
492             vDecSample1->WaitForEOS();
493         }
494     }
495 }
496 
497 /**
498  * @tc.number    : API11_VIDEO_SWDEC_STABLITY_0110
499  * @tc.name      : rand high and whith (1920 * 1080)
500  * @tc.desc      : reli test
501  */
HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABLITY_0110, TestSize.Level0)502 HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABLITY_0110, TestSize.Level0)
503 {
504     if (!access("/system/lib64/media/", 0)) {
505         for (int i = 0; i < reli_count; i++) {
506             shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
507             vDecSample->INP_DIR = INP_DIR_1080_30;
508             vDecSample->DEFAULT_WIDTH = WidthRand();
509             cout << "rand width is: " << vDecSample->DEFAULT_WIDTH << endl;
510             vDecSample->DEFAULT_HEIGHT = HighRand();
511             cout << "rand high is" << vDecSample->DEFAULT_HEIGHT << endl;
512             vDecSample->DEFAULT_FRAME_RATE = 30;
513             vDecSample->SF_OUTPUT = false;
514             ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName_hevc));
515             ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
516             ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
517             ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
518             vDecSample->WaitForEOS();
519             ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
520         }
521     }
522 }
523 
524 /**
525  * @tc.number    : API11_VIDEO_SWDEC_STABLITY_0120
526  * @tc.name      : rand high and whith (64 * 64)
527  * @tc.desc      : reli test
528  */
HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABLITY_0120, TestSize.Level0)529 HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABLITY_0120, TestSize.Level0)
530 {
531     if (!access("/system/lib64/media/", 0)) {
532         for (int i = 0; i < reli_count; i++) {
533             shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
534             vDecSample->INP_DIR = INP_DIR_64;
535             vDecSample->DEFAULT_WIDTH = WidthRand();
536             cout << "rand width is: " << vDecSample->DEFAULT_WIDTH << endl;
537             vDecSample->DEFAULT_HEIGHT = HighRand();
538             cout << "rand high is" << vDecSample->DEFAULT_HEIGHT << endl;
539             vDecSample->DEFAULT_FRAME_RATE = 30;
540             vDecSample->SF_OUTPUT = false;
541             ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName_hevc));
542             ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
543             ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
544             ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
545             vDecSample->WaitForEOS();
546             ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
547         }
548     }
549 }
550 
551 /**
552  * @tc.number    : API11_VIDEO_SWDEC_STABLITY_FUNC_0130
553  * @tc.name      : rand and whith (176 * 144)
554  * @tc.desc      : reli test
555  */
HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABLITY_FUNC_0130, TestSize.Level0)556 HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABLITY_FUNC_0130, TestSize.Level0)
557 {
558     if (!access("/system/lib64/media/", 0)) {
559         for (int i = 0; i < reli_count; i++) {
560             shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
561             vDecSample->INP_DIR = INP_DIR_144;
562             vDecSample->DEFAULT_WIDTH = WidthRand();
563             cout << "rand width is: " << vDecSample->DEFAULT_WIDTH << endl;
564             vDecSample->DEFAULT_HEIGHT = HighRand();
565             cout << "rand high is" << vDecSample->DEFAULT_HEIGHT << endl;
566             vDecSample->DEFAULT_FRAME_RATE = 30;
567             vDecSample->SF_OUTPUT = false;
568             ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName_hevc));
569             ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
570             ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
571             ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
572             vDecSample->WaitForEOS();
573         }
574     }
575 }
576 
577 /**
578  * @tc.number    : API11_VIDEO_SWDEC_STABILITY_0060
579  * @tc.name      : SVC stream and common stream decode simultaneously
580  * @tc.desc      : reli test
581  */
HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0060, TestSize.Level0)582 HWTEST_F(HevcSwdecReliNdkTest, API11_VIDEO_SWDEC_STABILITY_0060, TestSize.Level0)
583 {
584     if (!access("/system/lib64/media/", 0)) {
585         for (int i = 0; i < reli_count; i++) {
586             shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
587             vDecSample->INP_DIR = INP_DIR_1080_30;
588             vDecSample->DEFAULT_WIDTH = 1920;
589             vDecSample->DEFAULT_HEIGHT = 1080;
590             vDecSample->DEFAULT_FRAME_RATE = 30;
591             vDecSample->SF_OUTPUT = false;
592             ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName_hevc));
593             vDecSample->WaitForEOS();
594 
595             shared_ptr<VDecAPI11Sample> vDecSample1 = make_shared<VDecAPI11Sample>();
596             vDecSample1->INP_DIR = INP_DIR_1080_30;
597             vDecSample1->DEFAULT_WIDTH = 1920;
598             vDecSample1->DEFAULT_HEIGHT = 1080;
599             vDecSample1->DEFAULT_FRAME_RATE = 30;
600             vDecSample1->SF_OUTPUT = false;
601             ASSERT_EQ(AV_ERR_OK, vDecSample1->RunVideoDec(g_codecName_hisi));
602             vDecSample1->WaitForEOS();
603 
604             shared_ptr<VDecAPI11Sample> vDecSample2 = make_shared<VDecAPI11Sample>();
605             vDecSample2->INP_DIR = INP_DIR_1080_30;
606             vDecSample2->DEFAULT_WIDTH = 1920;
607             vDecSample2->DEFAULT_HEIGHT = 1080;
608             vDecSample2->DEFAULT_FRAME_RATE = 30;
609             vDecSample2->SF_OUTPUT = false;
610             ASSERT_EQ(AV_ERR_OK, vDecSample2->RunVideoDec_Surface(g_codecName_hevc));
611             vDecSample2->WaitForEOS();
612         }
613     }
614 }
615 } // namespace