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 <securec.h>
17 #include "gtest/gtest.h"
18 #include "native_avcodec_videoencoder.h"
19 #include "native_averrors.h"
20 #include "native_avcodec_base.h"
21 #include "avcodec_codec_name.h"
22 #include "native_avcapability.h"
23
24 namespace {
25 OH_AVCodec *venc_ = NULL;
26 OH_AVCapability *cap = nullptr;
27 OH_AVCapability *cap_hevc = nullptr;
28 constexpr uint32_t CODEC_NAME_SIZE = 128;
29 char g_codecName[CODEC_NAME_SIZE] = {};
30 char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
31 OH_AVFormat *format;
32 } // namespace
33 namespace OHOS {
34 namespace Media {
35 class HwCapabilityNdkTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp() override;
40 void TearDown() override;
41 void InputFunc();
42 void OutputFunc();
43 void Release();
44 int32_t Stop();
45 };
46 } // namespace Media
47 } // namespace OHOS
48
49 using namespace std;
50 using namespace OHOS;
51 using namespace OHOS::Media;
52 using namespace testing::ext;
53
SetUpTestCase()54 void HwCapabilityNdkTest::SetUpTestCase()
55 {
56 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
57 const char *tmpCodecName = OH_AVCapability_GetName(cap);
58 if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
59 cout << "memcpy failed" << endl;
60 cout << "codecname: " << g_codecName << endl;
61 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
62 const char *tmpCodecNameHevc = OH_AVCapability_GetName(cap_hevc);
63 if (memcpy_s(g_codecNameHEVC, sizeof(g_codecNameHEVC), tmpCodecNameHevc, strlen(tmpCodecNameHevc)) != 0)
64 cout << "memcpy failed" << endl;
65 cout << "codecname_hevc: " << g_codecNameHEVC << endl;
66 }
TearDownTestCase()67 void HwCapabilityNdkTest::TearDownTestCase() {}
SetUp()68 void HwCapabilityNdkTest::SetUp() {}
TearDown()69 void HwCapabilityNdkTest::TearDown()
70 {
71 if (venc_ != NULL) {
72 OH_VideoEncoder_Destroy(venc_);
73 venc_ = nullptr;
74 }
75 if (format != nullptr) {
76 OH_AVFormat_Destroy(format);
77 format = nullptr;
78 }
79 }
80 namespace {
81 /**
82 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0010
83 * @tc.name : OH_AVCapability_IsFeatureSupported para error
84 * @tc.desc : api test
85 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0010, TestSize.Level2)86 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0010, TestSize.Level2)
87 {
88 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
89 ASSERT_NE(nullptr, capability);
90 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, static_cast<OH_AVCapabilityFeature>(4)));
91 }
92
93 /**
94 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0011
95 * @tc.name : 解码，是否支持分层编码
96 * @tc.desc : api test
97 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0011, TestSize.Level2)98 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0011, TestSize.Level2)
99 {
100 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
101 ASSERT_NE(nullptr, capability);
102 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
103 }
104
105 /**
106 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0012
107 * @tc.name : 编码，是否支持分层编码
108 * @tc.desc : api test
109 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0012, TestSize.Level1)110 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0012, TestSize.Level1)
111 {
112 if (!access("/system/lib64/media/", 0)) {
113 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
114 ASSERT_NE(nullptr, capability);
115 ASSERT_EQ(true, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
116 } else {
117 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
118 ASSERT_NE(nullptr, capability);
119 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
120 }
121 }
122
123 /**
124 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0013
125 * @tc.name : 解码，是否支持LTR
126 * @tc.desc : api test
127 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0013, TestSize.Level2)128 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0013, TestSize.Level2)
129 {
130 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
131 ASSERT_NE(nullptr, capability);
132 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
133 }
134
135 /**
136 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0014
137 * @tc.name : 编码，是否支持LTR
138 * @tc.desc : api test
139 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0014, TestSize.Level1)140 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0014, TestSize.Level1)
141 {
142 if (!access("/system/lib64/media/", 0)) {
143 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
144 ASSERT_NE(nullptr, capability);
145 ASSERT_EQ(true, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
146 } else {
147 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
148 ASSERT_NE(nullptr, capability);
149 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
150 }
151 }
152
153 /**
154 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0015
155 * @tc.name : 软解，是否支持低时延
156 * @tc.desc : api test
157 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0015, TestSize.Level2)158 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0015, TestSize.Level2)
159 {
160 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
161 ASSERT_NE(nullptr, capability);
162 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
163 }
164
165 /**
166 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0016
167 * @tc.name : 硬解，是否支持低时延
168 * @tc.desc : api test
169 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0016, TestSize.Level2)170 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0016, TestSize.Level2)
171 {
172 if (!access("/system/lib64/media/", 0)) {
173 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
174 OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
175 ASSERT_NE(nullptr, capability);
176 ASSERT_EQ(true, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
177 } else {
178 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
179 OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
180 ASSERT_NE(nullptr, capability);
181 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
182 }
183 }
184
185 /**
186 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0017
187 * @tc.name : 编码，是否支持低时延
188 * @tc.desc : api test
189 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0017, TestSize.Level1)190 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0017, TestSize.Level1)
191 {
192 if (!access("/system/lib64/media/", 0)) {
193 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
194 ASSERT_NE(nullptr, capability);
195 ASSERT_EQ(true, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
196 } else {
197 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
198 ASSERT_NE(nullptr, capability);
199 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
200 }
201 }
202
203 /**
204 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0018
205 * @tc.name : OH_AVCapability_GetFeatureProperties para error
206 * @tc.desc : api test
207 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0018, TestSize.Level2)208 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0018, TestSize.Level2)
209 {
210 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
211 ASSERT_NE(nullptr, capability);
212 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, static_cast<OH_AVCapabilityFeature>(4)));
213
214 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, static_cast<OH_AVCapabilityFeature>(-1)));
215 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, static_cast<OH_AVCapabilityFeature>(100)));
216
217 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
218 }
219
220 /**
221 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0019
222 * @tc.name : 解码，查询分层编码的能力值
223 * @tc.desc : api test
224 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0019, TestSize.Level2)225 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0019, TestSize.Level2)
226 {
227 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
228 ASSERT_NE(nullptr, capability);
229 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
230 }
231
232 /**
233 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0020
234 * @tc.name : 编码，查询分层编码的能力值
235 * @tc.desc : api test
236 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0020, TestSize.Level1)237 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0020, TestSize.Level1)
238 {
239 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
240 ASSERT_NE(nullptr, capability);
241 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
242 }
243
244 /**
245 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0021
246 * @tc.name : 解码，查询LTR能力值
247 * @tc.desc : api test
248 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0021, TestSize.Level2)249 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0021, TestSize.Level2)
250 {
251 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
252 ASSERT_NE(nullptr, capability);
253 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
254 }
255
256 /**
257 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0022
258 * @tc.name : 编码，查询LTR的能力值
259 * @tc.desc : api test
260 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0022, TestSize.Level1)261 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0022, TestSize.Level1)
262 {
263 if (!access("/system/lib64/media/", 0)) {
264 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
265 ASSERT_NE(nullptr, capability);
266 format = OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE);
267 ASSERT_NE(nullptr, format);
268 int ltrnum = 0;
269 EXPECT_EQ(OH_AVFormat_GetIntValue(
270 format, OH_FEATURE_PROPERTY_KEY_VIDEO_ENCODER_MAX_LTR_FRAME_COUNT, <rnum), true);
271 EXPECT_EQ(ltrnum, 10);
272 } else {
273 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
274 ASSERT_NE(nullptr, capability);
275 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
276 }
277 }
278
279 /**
280 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0023
281 * @tc.name : 软解，查询低时延的能力值
282 * @tc.desc : api test
283 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0023, TestSize.Level2)284 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0023, TestSize.Level2)
285 {
286 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
287 ASSERT_NE(nullptr, capability);
288 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_LOW_LATENCY));
289 }
290
291 /**
292 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0024
293 * @tc.name : 硬解，查询低时延的能力值
294 * @tc.desc : api test
295 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0024, TestSize.Level2)296 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0024, TestSize.Level2)
297 {
298 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
299 ASSERT_NE(nullptr, capability);
300 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_LOW_LATENCY));
301 }
302
303 /**
304 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0025
305 * @tc.name : 编码，查询低时延的能力值
306 * @tc.desc : api test
307 */
HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0025, TestSize.Level1)308 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0025, TestSize.Level1)
309 {
310 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
311 ASSERT_NE(nullptr, capability);
312 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_LOW_LATENCY));
313 }
314 } // namespace