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_sample.h"
20 #include "videodec_api11_sample.h"
21 #include "native_avcodec_base.h"
22 #include "avcodec_codec_name.h"
23 
24 #ifdef SUPPORT_DRM
25 #include "native_mediakeysession.h"
26 #include "native_mediakeysystem.h"
27 #endif
28 
29 #define MAX_THREAD 16
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 SwdecFuncNdkTest : public testing::Test {
39 public:
40     static void SetUpTestCase();
41     static void TearDownTestCase();
42     void SetUp() override;
43     void TearDown() override;
44     void InputFunc();
45     void OutputFunc();
46     void Release();
47     int32_t Stop();
48 
49 protected:
50     const string CODEC_NAME = "video_decoder.avc";
51     const char *INP_DIR_720_30 = "/data/test/media/1280_720_30_10Mb.h264";
52     const char *INP_DIR_1080_30 = "/data/test/media/1920_1080_10_30Mb.h264";
53 };
54 } // namespace Media
55 } // namespace OHOS
56 
SetUpTestCase()57 void SwdecFuncNdkTest::SetUpTestCase() {}
TearDownTestCase()58 void SwdecFuncNdkTest::TearDownTestCase() {}
SetUp()59 void SwdecFuncNdkTest::SetUp() {}
TearDown()60 void SwdecFuncNdkTest::TearDown() {}
61 
62 namespace {
63 /**
64  * @tc.number    : VIDEO_SWDEC_FUNCTION_0200
65  * @tc.name      : create nonexist decoder
66  * @tc.desc      : function test
67  */
68 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0200, TestSize.Level1)
69 {
70     OH_AVCodec *vdec_ = OH_VideoDecoder_CreateByName("OMX.h264.decode.111.222.333");
71     ASSERT_EQ(nullptr, vdec_);
72 }
73 
74 /**
75  * @tc.number    : VIDEO_SWDEC_FUNCTION_0300
76  * @tc.name      : test h264  decode buffer
77  * @tc.desc      : function test
78  */
79 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0300, TestSize.Level0)
80 {
81     auto vDecSample = make_shared<VDecNdkSample>();
82     vDecSample->INP_DIR = INP_DIR_1080_30;
83     vDecSample->DEFAULT_WIDTH = 1920;
84     vDecSample->DEFAULT_HEIGHT = 1080;
85     vDecSample->DEFAULT_FRAME_RATE = 30;
86     vDecSample->SURFACE_OUTPUT = false;
87     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec("OH.Media.Codec.Decoder.Video.AVC"));
88     vDecSample->WaitForEOS();
89     ASSERT_EQ(0, vDecSample->errCount);
90 }
91 
92 /**
93  * @tc.number    : VIDEO_SWDEC_FUNCTION_0400
94  * @tc.name      : test h264  decode surface
95  * @tc.desc      : function test
96  */
97 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0400, TestSize.Level0)
98 {
99     auto vDecSample = make_shared<VDecNdkSample>();
100     vDecSample->INP_DIR = INP_DIR_1080_30;
101     vDecSample->SURFACE_OUTPUT = true;
102     vDecSample->DEFAULT_WIDTH = 1920;
103     vDecSample->DEFAULT_HEIGHT = 1080;
104     vDecSample->DEFAULT_FRAME_RATE = 30;
105     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
106     vDecSample->WaitForEOS();
107     bool isVaild = false;
108     OH_VideoDecoder_IsValid(vDecSample->vdec_, &isVaild);
109     ASSERT_EQ(false, isVaild);
110     ASSERT_EQ(0, vDecSample->errCount);
111 }
112 
113 /**
114  * @tc.number    : VIDEO_SWDEC_FUNCTION_0700
115  * @tc.name      : test set EOS when last frame
116  * @tc.desc      : function test
117  */
118 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0700, TestSize.Level1)
119 {
120     auto vDecSample = make_shared<VDecNdkSample>();
121     vDecSample->INP_DIR = INP_DIR_1080_30;
122     vDecSample->DEFAULT_WIDTH = 1920;
123     vDecSample->DEFAULT_HEIGHT = 1080;
124     vDecSample->DEFAULT_FRAME_RATE = 30;
125     vDecSample->SURFACE_OUTPUT = false;
126     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
127     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
128     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
129     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
130     vDecSample->WaitForEOS();
131     ASSERT_EQ(0, vDecSample->errCount);
132 }
133 
134 /**
135  * @tc.number    : VIDEO_SWDEC_FUNCTION_0800
136  * @tc.name      : test set EOS before last frame then stop
137  * @tc.desc      : function test
138  */
139 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0800, TestSize.Level1)
140 {
141     auto vDecSample = make_shared<VDecNdkSample>();
142     vDecSample->INP_DIR = INP_DIR_1080_30;
143     vDecSample->DEFAULT_WIDTH = 1920;
144     vDecSample->DEFAULT_HEIGHT = 1080;
145     vDecSample->DEFAULT_FRAME_RATE = 30;
146     vDecSample->SURFACE_OUTPUT = false;
147     vDecSample->BEFORE_EOS_INPUT = true;
148     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
149     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
150     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
151     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
152     vDecSample->WaitForEOS();
153     ASSERT_EQ(0, vDecSample->errCount);
154 }
155 /**
156  * @tc.number    : VIDEO_SWDEC_FUNCTION_4000
157  * @tc.name      : test set EOS before last frame then stop surface
158  * @tc.desc      : function test
159  */
160 
161 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_4000, TestSize.Level1)
162 {
163     auto vDecSample = make_shared<VDecNdkSample>();
164     vDecSample->INP_DIR = INP_DIR_1080_30;
165     vDecSample->DEFAULT_WIDTH = 1920;
166     vDecSample->DEFAULT_HEIGHT = 1080;
167     vDecSample->DEFAULT_FRAME_RATE = 30;
168     vDecSample->SURFACE_OUTPUT = true;
169     vDecSample->BEFORE_EOS_INPUT = true;
170     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
171     vDecSample->WaitForEOS();
172     ASSERT_EQ(0, vDecSample->errCount);
173 }
174 
175 /**
176  * @tc.number    : VIDEO_SWDEC_FUNCTION_1000
177  * @tc.name      : test reconfigure for new file with one decoder
178  * @tc.desc      : function test
179  */
180 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1000, TestSize.Level1)
181 {
182     auto vDecSample = make_shared<VDecNdkSample>();
183     vDecSample->INP_DIR = INP_DIR_1080_30;
184     vDecSample->DEFAULT_WIDTH = 1920;
185     vDecSample->DEFAULT_HEIGHT = 1080;
186     vDecSample->DEFAULT_FRAME_RATE = 30;
187     vDecSample->SURFACE_OUTPUT = false;
188     vDecSample->AFTER_EOS_DESTORY_CODEC = false;
189     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
190     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
191     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
192     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
193     vDecSample->WaitForEOS();
194     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
195     ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
196     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
197     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
198     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
199     vDecSample->WaitForEOS();
200     ASSERT_EQ(0, vDecSample->errCount);
201 }
202 
203 /**
204  * @tc.number    : VIDEO_SWDEC_FUNCTION_1100
205  * @tc.name      : test reconfigure for new file with the recreated decoder
206  * @tc.desc      : function test
207  */
208 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1100, TestSize.Level1)
209 {
210     auto vDecSample = make_shared<VDecNdkSample>();
211     vDecSample->INP_DIR = INP_DIR_1080_30;
212     vDecSample->DEFAULT_WIDTH = 1920;
213     vDecSample->DEFAULT_HEIGHT = 1080;
214     vDecSample->DEFAULT_FRAME_RATE = 30;
215     vDecSample->SURFACE_OUTPUT = false;
216     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
217     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
218     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
219     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
220     vDecSample->WaitForEOS();
221     ASSERT_EQ(0, vDecSample->errCount);
222     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
223     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
224     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
225     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
226     vDecSample->WaitForEOS();
227     ASSERT_EQ(0, vDecSample->errCount);
228 }
229 
230 /**
231  * @tc.number    : VIDEO_SWDEC_FUNCTION_1200
232  * @tc.name      : repeat start and stop 5 times before EOS
233  * @tc.desc      : function test
234  */
235 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1200, TestSize.Level2)
236 {
237     auto vDecSample = make_shared<VDecNdkSample>();
238     vDecSample->INP_DIR = INP_DIR_1080_30;
239     vDecSample->DEFAULT_WIDTH = 1920;
240     vDecSample->DEFAULT_HEIGHT = 1080;
241     vDecSample->DEFAULT_FRAME_RATE = 30;
242     vDecSample->SURFACE_OUTPUT = false;
243     vDecSample->REPEAT_START_STOP_BEFORE_EOS = 5;
244     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
245     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
246     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
247     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
248     vDecSample->WaitForEOS();
249     ASSERT_EQ(0, vDecSample->errCount);
250 }
251 
252 /**
253  * @tc.number    : VIDEO_SWDEC_FUNCTION_1300
254  * @tc.name      : repeat start and flush 5 times before EOS
255  * @tc.desc      : function test
256  */
257 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1300, TestSize.Level2)
258 {
259     auto vDecSample = make_shared<VDecNdkSample>();
260     vDecSample->INP_DIR = INP_DIR_1080_30;
261     vDecSample->DEFAULT_WIDTH = 1920;
262     vDecSample->DEFAULT_HEIGHT = 1080;
263     vDecSample->DEFAULT_FRAME_RATE = 30;
264     vDecSample->SURFACE_OUTPUT = false;
265     vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 5;
266     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
267     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
268     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
269     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
270     vDecSample->WaitForEOS();
271     ASSERT_EQ(0, vDecSample->errCount);
272 }
273 
274 /**
275  * @tc.number    : VIDEO_SWDEC_FUNCTION_1400
276  * @tc.name      : set larger width and height
277  * @tc.desc      : function test
278  */
279 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1400, TestSize.Level2)
280 {
281     auto vDecSample = make_shared<VDecNdkSample>();
282     vDecSample->INP_DIR = INP_DIR_720_30;
283     vDecSample->DEFAULT_WIDTH = 1920;
284     vDecSample->DEFAULT_HEIGHT = 1080;
285     vDecSample->DEFAULT_FRAME_RATE = 30;
286     vDecSample->SURFACE_OUTPUT = false;
287     vDecSample->checkOutPut = false;
288     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
289     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
290     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
291     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
292     vDecSample->WaitForEOS();
293     ASSERT_EQ(0, vDecSample->errCount);
294 }
295 
296 /**
297  * @tc.number    : VIDEO_SWDEC_FUNCTION_1500
298  * @tc.name      : set the width and height to a samller value
299  * @tc.desc      : function test
300  */
301 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1500, TestSize.Level2)
302 {
303     auto vDecSample = make_shared<VDecNdkSample>();
304     vDecSample->INP_DIR = INP_DIR_1080_30;
305     vDecSample->DEFAULT_WIDTH = 1280;
306     vDecSample->DEFAULT_HEIGHT = 720;
307     vDecSample->DEFAULT_FRAME_RATE = 30;
308     vDecSample->SURFACE_OUTPUT = false;
309     vDecSample->checkOutPut = false;
310     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
311     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
312     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
313     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
314     vDecSample->WaitForEOS();
315     ASSERT_EQ(0, vDecSample->errCount);
316 }
317 
318 /**
319  * @tc.number    : VIDEO_SWDEC_FUNCTION_1600
320  * @tc.name      : resolution change
321  * @tc.desc      : function test
322  */
323 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1600, TestSize.Level2)
324 {
325     auto vDecSample = make_shared<VDecNdkSample>();
326     vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
327     vDecSample->DEFAULT_WIDTH = 1104;
328     vDecSample->DEFAULT_HEIGHT = 622;
329     vDecSample->DEFAULT_FRAME_RATE = 30;
330     vDecSample->SURFACE_OUTPUT = false;
331     vDecSample->checkOutPut = false;
332     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
333     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
334     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
335     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
336     vDecSample->WaitForEOS();
337     ASSERT_EQ(0, vDecSample->errCount);
338 }
339 
340 /**
341  * @tc.number    : VIDEO_SWDEC_FUNCTION_1700
342  * @tc.name      : decode h264 stream ,output pixel format is nv21
343  * @tc.desc      : function test
344  */
345 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1700, TestSize.Level2)
346 {
347     auto vDecSample = make_shared<VDecNdkSample>();
348     vDecSample->INP_DIR = INP_DIR_1080_30;
349     vDecSample->DEFAULT_WIDTH = 1920;
350     vDecSample->DEFAULT_HEIGHT = 1080;
351     vDecSample->DEFAULT_FRAME_RATE = 30;
352     vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV21;
353     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec("OH.Media.Codec.Decoder.Video.AVC"));
354     vDecSample->WaitForEOS();
355     ASSERT_EQ(0, vDecSample->errCount);
356 }
357 
358 /**
359  * @tc.number    : VIDEO_SWDEC_FUNCTION_1800
360  * @tc.name      : decode h264 stream ,output pixel format is rgba
361  * @tc.desc      : function test
362  */
363 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1800, TestSize.Level2)
364 {
365     auto vDecSample = make_shared<VDecNdkSample>();
366     vDecSample->INP_DIR = INP_DIR_1080_30;
367     vDecSample->DEFAULT_WIDTH = 1920;
368     vDecSample->DEFAULT_HEIGHT = 1080;
369     vDecSample->DEFAULT_FRAME_RATE = 30;
370     vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_RGBA;
371     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec("OH.Media.Codec.Decoder.Video.AVC"));
372     vDecSample->WaitForEOS();
373     ASSERT_EQ(0, vDecSample->errCount);
374 }
375 
376 /**
377  * @tc.number    : VIDEO_SWDEC_FUNCTION_ATTIME_0010
378  * @tc.name      : test h264 asyn decode surface,use at time
379  * @tc.desc      : function test
380  */
381 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_ATTIME_0010, TestSize.Level0)
382 {
383     auto vDecSample = make_shared<VDecAPI11Sample>();
384     vDecSample->INP_DIR = INP_DIR_720_30;
385     vDecSample->DEFAULT_WIDTH = 1280;
386     vDecSample->DEFAULT_HEIGHT = 720;
387     vDecSample->DEFAULT_FRAME_RATE = 30;
388     vDecSample->SURFACE_OUTPUT = true;
389     vDecSample->rsAtTime = true;
390     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
391     vDecSample->WaitForEOS();
392     ASSERT_EQ(0, vDecSample->errCount);
393 }
394 } // namespace