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 */
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 if (capability) {
90 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, static_cast<OH_AVCapabilityFeature>(4)));
91 }
92 }
93
94 /**
95 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0011
96 * @tc.name : 解码，是否支持分层编码
97 * @tc.desc : api test
98 */
99 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0011, TestSize.Level2)
100 {
101 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
102 ASSERT_NE(nullptr, capability);
103 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
104 }
105
106 /**
107 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0012
108 * @tc.name : 编码，是否支持分层编码
109 * @tc.desc : api test
110 */
111 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0012, TestSize.Level1)
112 {
113 if (!access("/system/lib64/media/", 0)) {
114 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
115 if (capability) {
116 ASSERT_EQ(true, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
117 }
118 } else {
119 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
120 if (capability) {
121 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
122 }
123 }
124 }
125
126 /**
127 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0013
128 * @tc.name : 解码，是否支持LTR
129 * @tc.desc : api test
130 */
131 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0013, TestSize.Level2)
132 {
133 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
134 ASSERT_NE(nullptr, capability);
135 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
136 }
137
138 /**
139 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0014
140 * @tc.name : 编码，是否支持LTR
141 * @tc.desc : api test
142 */
143 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0014, TestSize.Level1)
144 {
145 if (!access("/system/lib64/media/", 0)) {
146 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
147 if (capability) {
148 ASSERT_EQ(true, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
149 }
150 } else {
151 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
152 if (capability) {
153 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
154 }
155 }
156 }
157
158 /**
159 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0015
160 * @tc.name : 软解，是否支持低时延
161 * @tc.desc : api test
162 */
163 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0015, TestSize.Level2)
164 {
165 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
166 if (capability) {
167 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
168 }
169 }
170
171 /**
172 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0016
173 * @tc.name : 硬解，是否支持低时延
174 * @tc.desc : api test
175 */
176 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0016, TestSize.Level2)
177 {
178 if (!access("/system/lib64/media/", 0)) {
179 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
180 OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
181 if (capability) {
182 bool isLowLatencySupported = OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY);
183 ASSERT_NE(nullptr, &isLowLatencySupported);
184 }
185 } else {
186 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
187 OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
188 if (capability) {
189 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
190 }
191 }
192 }
193
194 /**
195 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0017
196 * @tc.name : 编码，是否支持低时延
197 * @tc.desc : api test
198 */
199 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0017, TestSize.Level1)
200 {
201 if (!access("/system/lib64/media/", 0)) {
202 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
203 if (capability) {
204 ASSERT_EQ(true, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
205 }
206 } else {
207 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
208 if (capability) {
209 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
210 }
211 }
212 }
213
214 /**
215 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0018
216 * @tc.name : OH_AVCapability_GetFeatureProperties para error
217 * @tc.desc : api test
218 */
219 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0018, TestSize.Level2)
220 {
221 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
222 if (capability) {
223 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, static_cast<OH_AVCapabilityFeature>(4)));
224
225 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, static_cast<OH_AVCapabilityFeature>(-1)));
226 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, static_cast<OH_AVCapabilityFeature>(100)));
227
228 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
229 }
230 }
231
232 /**
233 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0019
234 * @tc.name : 解码，查询分层编码的能力值
235 * @tc.desc : api test
236 */
237 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0019, TestSize.Level2)
238 {
239 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, 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_0020
246 * @tc.name : 编码，查询分层编码的能力值
247 * @tc.desc : api test
248 */
249 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0020, TestSize.Level1)
250 {
251 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
252 if (capability) {
253 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
254 }
255 }
256
257 /**
258 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0021
259 * @tc.name : 解码，查询LTR能力值
260 * @tc.desc : api test
261 */
262 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0021, TestSize.Level2)
263 {
264 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
265 ASSERT_NE(nullptr, capability);
266 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
267 }
268
269 /**
270 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0022
271 * @tc.name : 编码，查询LTR的能力值
272 * @tc.desc : api test
273 */
274 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0022, TestSize.Level1)
275 {
276 if (!access("/system/lib64/media/", 0)) {
277 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
278 if (capability) {
279 format = OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE);
280 ASSERT_NE(nullptr, format);
281 int ltrnum = 0;
282 EXPECT_EQ(OH_AVFormat_GetIntValue(
283 format, OH_FEATURE_PROPERTY_KEY_VIDEO_ENCODER_MAX_LTR_FRAME_COUNT, <rnum), true);
284 EXPECT_EQ(ltrnum, 10);
285 }
286 } else {
287 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
288 if (capability) {
289 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
290 }
291 }
292 }
293
294 /**
295 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0023
296 * @tc.name : 软解，查询低时延的能力值
297 * @tc.desc : api test
298 */
299 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0023, TestSize.Level2)
300 {
301 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
302 if (capability) {
303 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_LOW_LATENCY));
304 }
305 }
306
307 /**
308 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0024
309 * @tc.name : 硬解，查询低时延的能力值
310 * @tc.desc : api test
311 */
312 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0024, TestSize.Level2)
313 {
314 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
315 ASSERT_NE(nullptr, capability);
316 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_LOW_LATENCY));
317 }
318
319 /**
320 * @tc.number : VIDEO_TEMPORAL_ENCODE_API_0025
321 * @tc.name : 编码，查询低时延的能力值
322 * @tc.desc : api test
323 */
324 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0025, TestSize.Level1)
325 {
326 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
327 if (capability) {
328 ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_LOW_LATENCY));
329 }
330 }
331 } // namespace