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 #include <string>
16 #include <limits>
17 #include "gtest/gtest.h"
18 #include "native_avcodec_videoencoder.h"
19 #include "native_averrors.h"
20 #include "videoenc_api11_sample.h"
21 #include "native_avcodec_base.h"
22 #include "avcodec_codec_name.h"
23 #include "native_avcapability.h"
24 namespace {
25 OH_AVCodec *venc_ = NULL;
26 OH_AVFormat *format;
27 OH_AVCapability *cap = nullptr;
28 OH_AVCapability *cap_hevc = nullptr;
29 constexpr uint32_t CODEC_NAME_SIZE = 128;
30 constexpr uint32_t DEFAULT_BITRATE = 1000000;
31 char g_codecName[CODEC_NAME_SIZE] = {};
32 char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
33 constexpr uint32_t DEFAULT_WIDTH = 1280;
34 constexpr uint32_t DEFAULT_HEIGHT = 720;
35 } // namespace
36 namespace OHOS {
37 namespace Media {
38 class HwEncConfigureNdkTest : 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 } // namespace Media
50 } // namespace OHOS
51 
52 using namespace std;
53 using namespace OHOS;
54 using namespace OHOS::Media;
55 using namespace testing::ext;
56 
SetUpTestCase()57 void HwEncConfigureNdkTest::SetUpTestCase()
58 {
59     cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
60     const char *tmpCodecName = OH_AVCapability_GetName(cap);
61     if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
62         cout << "memcpy failed" << endl;
63     cout << "codecname: " << g_codecName << endl;
64     cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
65     const char *tmpCodecNameHevc = OH_AVCapability_GetName(cap_hevc);
66     if (memcpy_s(g_codecNameHEVC, sizeof(g_codecNameHEVC), tmpCodecNameHevc, strlen(tmpCodecNameHevc)) != 0)
67         cout << "memcpy failed" << endl;
68     cout << "codecname_hevc: " << g_codecNameHEVC << endl;
69 }
TearDownTestCase()70 void HwEncConfigureNdkTest::TearDownTestCase() {}
SetUp()71 void HwEncConfigureNdkTest::SetUp() {}
TearDown()72 void HwEncConfigureNdkTest::TearDown()
73 {
74     if (venc_ != NULL) {
75         OH_VideoEncoder_Destroy(venc_);
76         venc_ = nullptr;
77     }
78     if (format != nullptr) {
79         OH_AVFormat_Destroy(format);
80         format = nullptr;
81     }
82 }
83 namespace {
84 
85 /**
86  * @tc.number    : VIDEO_ENCODE_HEVC_CAPABILITY_1800
87  * @tc.name      : OH_AVCapability_GetVideoWidthRangeForHeight param correct
88  * @tc.desc      : api test
89  */
90 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1800, TestSize.Level2)
91 {
92     OH_AVErrCode ret = AV_ERR_OK;
93     OH_AVRange range;
94     memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
95     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
96     ASSERT_NE(nullptr, capability);
97     ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
98     ASSERT_EQ(AV_ERR_OK, ret);
99     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
100     ASSERT_NE(nullptr, venc_);
101     format = OH_AVFormat_Create();
102     ASSERT_NE(nullptr, format);
103     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
104     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
105     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
106     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
107     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
108     OH_VideoEncoder_Destroy(venc_);
109     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
110     ASSERT_NE(nullptr, venc_);
111     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
112     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
113 }
114 
115 /**
116  * @tc.number    : VIDEO_ENCODE_CAPABILITY_4000
117  * @tc.name      : OH_AVCapability_GetVideoWidthRangeForHeight param correct
118  * @tc.desc      : api test
119  */
120 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_4000, TestSize.Level2)
121 {
122     OH_AVErrCode ret = AV_ERR_OK;
123     OH_AVRange range;
124     memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
125     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
126     ASSERT_NE(nullptr, capability);
127     ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
128     cout << "minval=" << range.minVal << "  maxval=" << range.maxVal << endl;
129     ASSERT_EQ(AV_ERR_OK, ret);
130     ASSERT_GE(range.minVal, 0);
131     ASSERT_GT(range.maxVal, 0);
132     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
133     ASSERT_NE(nullptr, venc_);
134     format = OH_AVFormat_Create();
135     ASSERT_NE(nullptr, format);
136     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
137     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
138     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
139     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
140     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
141     OH_VideoEncoder_Destroy(venc_);
142     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
143     ASSERT_NE(nullptr, venc_);
144     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
145     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
146 }
147 
148 /**
149  * @tc.number    : VIDEO_ENCODE_CAPABILITY_4400
150  * @tc.name      : OH_AVCapability_GetVideoHeightRangeForWidth param correct
151  * @tc.desc      : api test
152  */
153 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_4400, TestSize.Level2)
154 {
155     OH_AVErrCode ret = AV_ERR_OK;
156     OH_AVRange range;
157     memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
158     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
159     ASSERT_NE(nullptr, capability);
160     ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
161     ASSERT_EQ(AV_ERR_OK, ret);
162     cout << "minval=" << range.minVal << "  maxval=" << range.maxVal << endl;
163     ASSERT_GE(range.minVal, 0);
164     ASSERT_GT(range.maxVal, 0);
165     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
166     ASSERT_NE(nullptr, venc_);
167     format = OH_AVFormat_Create();
168     ASSERT_NE(nullptr, format);
169     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
170     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
171     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
172     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
173     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
174     OH_VideoEncoder_Destroy(venc_);
175     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
176     ASSERT_NE(nullptr, venc_);
177     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
178     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
179 }
180 
181 /**
182  * @tc.number    : VIDEO_ENCODE_CAPABILITY_4410
183  * @tc.name      : OH_AVCapability_GetVideoHeightRangeForWidth param correct
184  * @tc.desc      : api test
185  */
186 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_4410, TestSize.Level2)
187 {
188     OH_AVErrCode ret = AV_ERR_OK;
189     OH_AVRange range;
190     memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
191     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
192     ASSERT_NE(nullptr, capability);
193     ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
194     ASSERT_EQ(AV_ERR_OK, ret);
195     cout << "minval=" << range.minVal << "  maxval=" << range.maxVal << endl;
196     ASSERT_GE(range.minVal, 0);
197     ASSERT_GT(range.maxVal, 0);
198     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
199     ASSERT_NE(nullptr, venc_);
200     format = OH_AVFormat_Create();
201     ASSERT_NE(nullptr, format);
202     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
203     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
204     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
205     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
206     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
207     OH_VideoEncoder_Destroy(venc_);
208     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
209     ASSERT_NE(nullptr, venc_);
210     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
211     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
212 }
213 
214 /**
215  * @tc.number    : VIDEO_ENCODE_CAPABILITY_4700
216  * @tc.name      : OH_AVCapability_GetVideoWidthRange param correct
217  * @tc.desc      : api test
218  */
219 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_4700, TestSize.Level2)
220 {
221     OH_AVErrCode ret = AV_ERR_OK;
222     OH_AVRange range;
223     memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
224     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
225     ASSERT_NE(nullptr, capability);
226     ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
227     ASSERT_EQ(AV_ERR_OK, ret);
228     cout << "minval=" << range.minVal << "  maxval=" << range.maxVal << endl;
229     ASSERT_GE(range.minVal, 0);
230     ASSERT_GT(range.maxVal, 0);
231     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
232     ASSERT_NE(nullptr, venc_);
233     format = OH_AVFormat_Create();
234     ASSERT_NE(nullptr, format);
235     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
236     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
237     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
238     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
239     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
240     OH_VideoEncoder_Destroy(venc_);
241     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
242     ASSERT_NE(nullptr, venc_);
243     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
244     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
245 }
246 
247 /**
248  * @tc.number    : VIDEO_ENCODE_CAPABILITY_4710
249  * @tc.name      : OH_AVCapability_GetVideoWidthRange param correct
250  * @tc.desc      : api test
251  */
252 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_4710, TestSize.Level2)
253 {
254     OH_AVErrCode ret = AV_ERR_OK;
255     OH_AVRange range;
256     memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
257     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
258     ASSERT_NE(nullptr, capability);
259     ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
260     ASSERT_EQ(AV_ERR_OK, ret);
261     cout << "minval=" << range.minVal << "  maxval=" << range.maxVal << endl;
262     ASSERT_GE(range.minVal, 0);
263     ASSERT_GT(range.maxVal, 0);
264     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
265     ASSERT_NE(nullptr, venc_);
266     format = OH_AVFormat_Create();
267     ASSERT_NE(nullptr, format);
268     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
269     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
270     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
271     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
272     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
273     OH_VideoEncoder_Destroy(venc_);
274     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
275     ASSERT_NE(nullptr, venc_);
276     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
277     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
278 }
279 
280 /**
281  * @tc.number    : VIDEO_ENCODE_CAPABILITY_5000
282  * @tc.name      : OH_AVCapability_GetVideoHeightRange param correct
283  * @tc.desc      : api test
284  */
285 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_5000, TestSize.Level2)
286 {
287     OH_AVErrCode ret = AV_ERR_OK;
288     OH_AVRange range;
289     memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
290     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
291     ASSERT_NE(nullptr, capability);
292     ret = OH_AVCapability_GetVideoHeightRange(capability, &range);
293     ASSERT_EQ(AV_ERR_OK, ret);
294     cout << "minval=" << range.minVal << "  maxval=" << range.maxVal << endl;
295     ASSERT_GE(range.minVal, 0);
296     ASSERT_GT(range.maxVal, 0);
297     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
298     ASSERT_NE(nullptr, venc_);
299     format = OH_AVFormat_Create();
300     ASSERT_NE(nullptr, format);
301     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
302     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
303     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
304     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
305     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
306     OH_VideoEncoder_Destroy(venc_);
307     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
308     ASSERT_NE(nullptr, venc_);
309     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
310     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
311 }
312 /**
313  * @tc.number    : VIDEO_ENCODE_CAPABILITY_5010
314  * @tc.name      : OH_AVCapability_GetVideoHeightRange param correct
315  * @tc.desc      : api test
316  */
317 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_5010, TestSize.Level2)
318 {
319     OH_AVErrCode ret = AV_ERR_OK;
320     OH_AVRange range;
321     memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
322     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
323     ASSERT_NE(nullptr, capability);
324     ret = OH_AVCapability_GetVideoHeightRange(capability, &range);
325     ASSERT_EQ(AV_ERR_OK, ret);
326     cout << "minval=" << range.minVal << "  maxval=" << range.maxVal << endl;
327     ASSERT_GE(range.minVal, 0);
328     ASSERT_GT(range.maxVal, 0);
329     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
330     ASSERT_NE(nullptr, venc_);
331     format = OH_AVFormat_Create();
332     ASSERT_NE(nullptr, format);
333     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
334     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
335     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
336     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
337     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
338     OH_VideoEncoder_Destroy(venc_);
339     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
340     ASSERT_NE(nullptr, venc_);
341     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
342     EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
343 }
344 }