1 /*
2 * Copyright (C) 2025 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 constexpr uint32_t CODEC_NAME_SIZE = 128;
29 constexpr uint32_t DEFAULT_BITRATE = 1000000;
30 char g_codecName[CODEC_NAME_SIZE] = {};
31 constexpr uint32_t DEFAULT_WIDTH = 1280;
32 constexpr uint32_t DEFAULT_HEIGHT = 720;
33 } // namespace
34 namespace OHOS {
35 namespace Media {
36 class AvcSwEncConfigureNdkTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp() override;
41 void TearDown() override;
42 void InputFunc();
43 void OutputFunc();
44 void Release();
45 int32_t Stop();
46 };
47 } // namespace Media
48 } // namespace OHOS
49
50 using namespace std;
51 using namespace OHOS;
52 using namespace OHOS::Media;
53 using namespace testing::ext;
54
SetUpTestCase()55 void AvcSwEncConfigureNdkTest::SetUpTestCase()
56 {
57 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, SOFTWARE);
58 const char *tmpCodecName = OH_AVCapability_GetName(cap);
59 if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
60 cout << "memcpy failed" << endl;
61 cout << "codecname: " << g_codecName << endl;
62 }
TearDownTestCase()63 void AvcSwEncConfigureNdkTest::TearDownTestCase() {}
SetUp()64 void AvcSwEncConfigureNdkTest::SetUp() {}
TearDown()65 void AvcSwEncConfigureNdkTest::TearDown()
66 {
67 if (venc_ != NULL) {
68 OH_VideoEncoder_Destroy(venc_);
69 venc_ = nullptr;
70 }
71 if (format != nullptr) {
72 OH_AVFormat_Destroy(format);
73 format = nullptr;
74 }
75 }
76 namespace {
77
78
79 /**
80 * @tc.number : VIDEO_ENCODE_CAPABILITY_1000
81 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
82 * @tc.desc : api test
83 */
84 HWTEST_F(AvcSwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_1000, TestSize.Level2)
85 {
86 if (strlen(g_codecName) == 0) {
87 return;
88 }
89 OH_AVErrCode ret = AV_ERR_OK;
90 OH_AVRange range;
91 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
92 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, SOFTWARE);
93 ASSERT_NE(nullptr, capability);
94 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
95 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
96 ASSERT_EQ(AV_ERR_OK, ret);
97 ASSERT_GE(range.minVal, 0);
98 ASSERT_GT(range.maxVal, 0);
99 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
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_CreateByName(g_codecName);
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_2000
117 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
118 * @tc.desc : api test
119 */
120 HWTEST_F(AvcSwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_2000, TestSize.Level2)
121 {
122 if (strlen(g_codecName) == 0) {
123 return;
124 }
125 OH_AVErrCode ret = AV_ERR_OK;
126 OH_AVRange range;
127 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
128 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, SOFTWARE);
129 ASSERT_NE(nullptr, capability);
130 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
131 ASSERT_EQ(AV_ERR_OK, ret);
132 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
133 ASSERT_GE(range.minVal, 0);
134 ASSERT_GT(range.maxVal, 0);
135 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
136 ASSERT_NE(nullptr, venc_);
137 format = OH_AVFormat_Create();
138 ASSERT_NE(nullptr, format);
139 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
140 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
141 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
142 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
143 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
144 OH_VideoEncoder_Destroy(venc_);
145 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
146 ASSERT_NE(nullptr, venc_);
147 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
148 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
149 }
150
151 /**
152 * @tc.number : VIDEO_ENCODE_CAPABILITY_3000
153 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
154 * @tc.desc : api test
155 */
156 HWTEST_F(AvcSwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_3000, TestSize.Level2)
157 {
158 if (strlen(g_codecName) == 0) {
159 return;
160 }
161 OH_AVErrCode ret = AV_ERR_OK;
162 OH_AVRange range;
163 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
164 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, SOFTWARE);
165 ASSERT_NE(nullptr, capability);
166 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
167 ASSERT_EQ(AV_ERR_OK, ret);
168 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
169 ASSERT_GE(range.minVal, 0);
170 ASSERT_GT(range.maxVal, 0);
171 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
172 ASSERT_NE(nullptr, venc_);
173 format = OH_AVFormat_Create();
174 ASSERT_NE(nullptr, format);
175 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
176 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
177 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
178 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
179 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
180 OH_VideoEncoder_Destroy(venc_);
181 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
182 ASSERT_NE(nullptr, venc_);
183 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
184 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
185 }
186
187
188 /**
189 * @tc.number : VIDEO_ENCODE_CAPABILITY_4000
190 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
191 * @tc.desc : api test
192 */
193 HWTEST_F(AvcSwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_4000, TestSize.Level2)
194 {
195 if (strlen(g_codecName) == 0) {
196 return;
197 }
198 OH_AVErrCode ret = AV_ERR_OK;
199 OH_AVRange range;
200 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
201 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, SOFTWARE);
202 ASSERT_NE(nullptr, capability);
203 ret = OH_AVCapability_GetVideoHeightRange(capability, &range);
204 ASSERT_EQ(AV_ERR_OK, ret);
205 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
206 ASSERT_GE(range.minVal, 0);
207 ASSERT_GT(range.maxVal, 0);
208 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
209 ASSERT_NE(nullptr, venc_);
210 format = OH_AVFormat_Create();
211 ASSERT_NE(nullptr, format);
212 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
213 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
214 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
215 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
216 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
217 OH_VideoEncoder_Destroy(venc_);
218 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
219 ASSERT_NE(nullptr, venc_);
220 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
221 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
222 }
223 }