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 
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 
25 #include "gtest/gtest.h"
26 #include "native_avcodec_videodecoder.h"
27 #include "native_avcodec_base.h"
28 #include "videodec_sample.h"
29 #include "videodec_api11_sample.h"
30 using namespace std;
31 using namespace OHOS;
32 using namespace OHOS::Media;
33 using namespace testing::ext;
34 
35 namespace OHOS {
36 namespace Media {
37 class SwdecReliNdkTest : public testing::Test {
38 public:
39     static void SetUpTestCase();    // 第一个测试用例执行前
40     static void TearDownTestCase(); // 最后一个测试用例执行后
41     void SetUp() override;          // 每个测试用例执行前
42     void TearDown() override;       // 每个测试用例执行后
43     void InputFunc();
44     void OutputFunc();
45     void Release();
46     int32_t Stop();
47 
48 protected:
49     bool createCodecSuccess_ = false;
50     OH_AVCodec *vdec_;
51     const char *INP_DIR_720_30 = "/data/test/media/1280x720_30_10M.h264";
52     const char *INP_DIR_1080_30 = "/data/test/media/1920_1080_10_30Mb.h264";
53     const char *INP_DIR_720_30_ARRAY[16] = {
54         "/data/test/media/1280x720_30_10M.h264",    "/data/test/media/1280x720_30_10M_1.h264",
55         "/data/test/media/1280x720_30_10M_2.h264",  "/data/test/media/1280x720_30_10M_3.h264",
56         "/data/test/media/1280x720_30_10M_8.h264",  "/data/test/media/1280x720_30_10M_12.h264",
57         "/data/test/media/1280x720_30_10M_4.h264",  "/data/test/media/1280x720_30_10M_9.h264",
58         "/data/test/media/1280x720_30_10M_13.h264", "/data/test/media/1280x720_30_10M_5.h264",
59         "/data/test/media/1280x720_30_10M_10.h264", "/data/test/media/1280x720_30_10M_14.h264",
60         "/data/test/media/1280x720_30_10M_6.h264",  "/data/test/media/1280x720_30_10M_11.h264",
61         "/data/test/media/1280x720_30_10M_15.h264", "/data/test/media/1280x720_30_10M_7.h264"};
62 };
63 } // namespace Media
64 } // namespace OHOS
65 
SetUpTestCase()66 void SwdecReliNdkTest::SetUpTestCase() {}
TearDownTestCase()67 void SwdecReliNdkTest::TearDownTestCase() {}
SetUp()68 void SwdecReliNdkTest::SetUp() {}
TearDown()69 void SwdecReliNdkTest::TearDown() {}
70 
71 namespace {
72 constexpr uint32_t MAX_THREAD = 16;
73 /**
74  * @tc.number    : VIDEO_SWDEC_RELI_0200
75  * @tc.name      : confige-start-flush-start-reset 1000 times
76  * @tc.desc      : reliable test
77  */
HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_0200, TestSize.Level4)78 HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_0200, TestSize.Level4)
79 {
80     vdec_ = OH_VideoDecoder_CreateByName("OH.Media.Codec.Decoder.Video.AVC");
81     for (int i = 0; i < 1000; i++) {
82         ASSERT_NE(nullptr, vdec_);
83         OH_AVFormat *format = OH_AVFormat_Create();
84         ASSERT_NE(nullptr, format);
85 
86         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, 1920);
87         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, 1080);
88         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_FRAME_RATE, 30);
89         ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
90         OH_AVFormat_Destroy(format);
91         ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
92         ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
93         ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
94         ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
95     }
96     OH_VideoDecoder_Stop(vdec_);
97     OH_VideoDecoder_Destroy(vdec_);
98 }
99 
100 /**
101  * @tc.number    : VIDEO_SWDEC_RELI_0400
102  * @tc.name      : SetParameter 1000 times
103  * @tc.desc      : reliable test
104  */
HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_0400, TestSize.Level4)105 HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_0400, TestSize.Level4)
106 {
107     vdec_ = OH_VideoDecoder_CreateByName("OH.Media.Codec.Decoder.Video.AVC");
108     ASSERT_NE(nullptr, vdec_);
109     OH_AVFormat *format = OH_AVFormat_Create();
110     ASSERT_NE(nullptr, format);
111     int64_t widht = 1920;
112     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, widht);
113     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, 1080);
114     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_FRAME_RATE, 30);
115     ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
116     ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
117     for (int i = 0; i < 1000; i++) {
118         widht++;
119         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, widht);
120         ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetParameter(vdec_, format));
121     }
122     OH_AVFormat_Destroy(format);
123     OH_VideoDecoder_Destroy(vdec_);
124 }
125 
126 /**
127  * @tc.number    : VIDEO_SWDEC_RELI_WHILE_0100
128  * @tc.name      : 16 instances
129  * @tc.desc      : reliable test
130  */
HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_WHILE_0100, TestSize.Level3)131 HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_WHILE_0100, TestSize.Level3)
132 {
133     for (int i = 0; i < 16; i++) {
134         VDecNdkSample *vDecSample = new VDecNdkSample();
135         vDecSample->SURFACE_OUTPUT = false;
136         vDecSample->INP_DIR = INP_DIR_720_30_ARRAY[i];
137         vDecSample->DEFAULT_WIDTH = 1280;
138         vDecSample->DEFAULT_HEIGHT = 720;
139         vDecSample->DEFAULT_FRAME_RATE = 30;
140         vDecSample->sleepOnFPS = true;
141         vDecSample->repeatRun = true;
142         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
143         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
144         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
145         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
146         if (i == 15) {
147             vDecSample->WaitForEOS();
148             ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
149         }
150     }
151 }
152 
153 /**
154  * @tc.number    : VIDEO_SWDEC_RELI_WHILE_0200
155  * @tc.name      : 16 instances while true
156  * @tc.desc      : reliable test
157  */
HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_WHILE_0200, TestSize.Level3)158 HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_WHILE_0200, TestSize.Level3)
159 {
160     VDecNdkSample *vDecList[16] = {};
161     while (true) {
162         for (int i = 0; i < 16; i++) {
163             VDecNdkSample *vDecSample = new VDecNdkSample();
164             vDecList[i] = vDecSample;
165             vDecSample->SURFACE_OUTPUT = false;
166             vDecSample->INP_DIR = INP_DIR_720_30_ARRAY[i];
167             vDecSample->DEFAULT_WIDTH = 1280;
168             vDecSample->DEFAULT_HEIGHT = 720;
169             vDecSample->DEFAULT_FRAME_RATE = 30;
170             vDecSample->sleepOnFPS = true;
171             ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
172             ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
173             ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
174             ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
175         }
176         for (int i = 0; i < 16; i++) {
177             vDecList[i]->WaitForEOS();
178             ASSERT_EQ(AV_ERR_OK, vDecList[i]->errCount);
179             delete vDecList[i];
180             vDecList[i] = nullptr;
181         }
182         usleep(5000000);
183     }
184 }
185 
186 /**
187  * @tc.number    : VIDEO_SWDEC_RELI_WHILE_0300
188  * @tc.name      : long decode
189  * @tc.desc      : reliable test
190  */
HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_WHILE_0300, TestSize.Level3)191 HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_WHILE_0300, TestSize.Level3)
192 {
193     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
194     vDecSample->SURFACE_OUTPUT = false;
195     vDecSample->INP_DIR = INP_DIR_720_30;
196     vDecSample->DEFAULT_WIDTH = 1280;
197     vDecSample->DEFAULT_HEIGHT = 720;
198     vDecSample->DEFAULT_FRAME_RATE = 30;
199     vDecSample->repeatRun = true;
200     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
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 }
207 
208 /**
209  * @tc.number    : VIDEO_SWDEC_RELI_WHILE_0300
210  * @tc.name      : confige-start-flush-start-reset while true
211  * @tc.desc      : reli test
212  */
HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_WHILE_0400, TestSize.Level3)213 HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_WHILE_0400, TestSize.Level3)
214 {
215     while (true) {
216         auto vDecSample = make_shared<VDecNdkSample>();
217         vDecSample->SURFACE_OUTPUT = false;
218         vDecSample->INP_DIR = INP_DIR_720_30;
219         vDecSample->DEFAULT_WIDTH = 1280;
220         vDecSample->DEFAULT_HEIGHT = 720;
221         vDecSample->DEFAULT_FRAME_RATE = 30;
222         vDecSample->sleepOnFPS = true;
223         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
224         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
225         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
226         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
227         vDecSample->WaitForEOS();
228         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
229     }
230 }
231 
232 /**
233  * @tc.number    : VIDEO_SWDEC_MULTIINSTANCE_0100
234  * @tc.name      : create 16 decoder (320*240)
235  * @tc.desc      : reliable test
236  */
237 
HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_MULTIINSTANCE_0100, TestSize.Level3)238 HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_MULTIINSTANCE_0100, TestSize.Level3)
239 {
240     vector<shared_ptr<VDecNdkSample>> decVec;
241     for (int i = 0; i < MAX_THREAD; i++) {
242         auto vDecSample = make_shared<VDecNdkSample>();
243         decVec.push_back(vDecSample);
244         vDecSample->INP_DIR = INP_DIR_1080_30;
245         vDecSample->DEFAULT_WIDTH = 1920;
246         vDecSample->DEFAULT_HEIGHT = 1080;
247         vDecSample->DEFAULT_FRAME_RATE = 30;
248         vDecSample->SURFACE_OUTPUT = false;
249         cout << i << " ";
250         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
251         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
252         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
253         ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
254     }
255 }
256 
257 /*
258  * @tc.number    : VIDEO_SWDEC_MULTIINSTANCE_0100
259  * @tc.name      : create 17 decoder
260  * @tc.desc      : reliable test
261  */
HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_MULTIINSTANCE_0200, TestSize.Level3)262 HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_MULTIINSTANCE_0200, TestSize.Level3)
263 {
264     vector<shared_ptr<VDecNdkSample>> decVec;
265     for (int i = 0; i < MAX_THREAD; i++) {
266         auto vDecSample = make_shared<VDecNdkSample>();
267         decVec.push_back(vDecSample);
268         vDecSample->INP_DIR = INP_DIR_1080_30;
269         vDecSample->DEFAULT_WIDTH = 1920;
270         vDecSample->DEFAULT_HEIGHT = 1080;
271         vDecSample->DEFAULT_FRAME_RATE = 30;
272         vDecSample->SURFACE_OUTPUT = false;
273         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
274         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
275         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
276         ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
277     }
278     auto vDecSampleExtra = make_shared<VDecNdkSample>();
279     vDecSampleExtra->INP_DIR = INP_DIR_1080_30;
280     vDecSampleExtra->DEFAULT_WIDTH = 1920;
281     vDecSampleExtra->DEFAULT_HEIGHT = 1080;
282     vDecSampleExtra->DEFAULT_FRAME_RATE = 30;
283     vDecSampleExtra->SURFACE_OUTPUT = false;
284     ASSERT_EQ(AV_ERR_UNKNOWN, vDecSampleExtra->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
285 }
286 
287 /**
288  * @tc.number    : VIDEO_SWDEC_RELI_ATTIME_0010
289  * @tc.name      : test h264 asyn decode surface,use at time
290  * @tc.desc      : perf test
291  */
HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_ATTIME_0010, TestSize.Level3)292 HWTEST_F(SwdecReliNdkTest, VIDEO_SWDEC_RELI_ATTIME_0010, TestSize.Level3)
293 {
294     while (true) {
295         auto vDecSample = make_shared<VDecAPI11Sample>();
296         const char *INP_DIR_720_30 = "/data/test/media/1280_720_30_10Mb.h264";
297         vDecSample->INP_DIR = INP_DIR_720_30;
298         vDecSample->DEFAULT_WIDTH = 1280;
299         vDecSample->DEFAULT_HEIGHT = 720;
300         vDecSample->DEFAULT_FRAME_RATE = 30;
301         vDecSample->SURFACE_OUTPUT = true;
302         vDecSample->rsAtTime = true;
303         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
304         vDecSample->WaitForEOS();
305         ASSERT_EQ(0, vDecSample->errCount);
306     }
307 }
308 } // namespace