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     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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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, &ltrnum), 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  */
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  */
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  */
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 
315 /**
316  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0026
317  * @tc.name      : 能力查询是否支持LTRH265
318  * @tc.desc      : function test
319  */
320 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0026, TestSize.Level1)
321 {
322     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
323     if (!access("/system/lib64/media/", 0)) {
324         ASSERT_EQ(true, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
325     } else {
326         ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
327     }
328 }
329 
330 /**
331  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0027
332  * @tc.name      : 能力查询是否支持LTRH265
333  * @tc.desc      : function test
334  */
335 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0027, TestSize.Level1)
336 {
337     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
338     ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
339 }
340 /**
341  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0028
342  * @tc.name      : 能力查询是否支持低时延H265
343  * @tc.desc      : function test
344  */
345 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0028, TestSize.Level1)
346 {
347     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
348     if (!access("/system/lib64/media/", 0)) {
349         ASSERT_EQ(true, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
350     } else {
351         ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
352     }
353 }
354 
355 /**
356  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0029
357  * @tc.name      : 能力查询是否支持低时延H265
358  * @tc.desc      : function test
359  */
360 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0029, TestSize.Level1)
361 {
362     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
363     if (!access("/system/lib64/media/", 0)) {
364         ASSERT_EQ(true, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
365     } else {
366         ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
367     }
368 }
369 /**
370  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0030
371  * @tc.name      : 能力查询是否支持分层编码H265
372  * @tc.desc      : function test
373  */
374 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0030, TestSize.Level1)
375 {
376     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
377     if (!access("/system/lib64/media/", 0)) {
378         ASSERT_EQ(true, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
379     } else {
380         ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
381     }
382 }
383 
384 /**
385  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0031
386  * @tc.name      : 能力查询是否支持分层编码H265
387  * @tc.desc      : function test
388  */
389 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0031, TestSize.Level1)
390 {
391     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
392     ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
393 }
394 /**
395  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0032
396  * @tc.name      : 编码,查询低时延的能力值H265
397  * @tc.desc      : api test
398  */
399 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0032, TestSize.Level1)
400 {
401     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
402     ASSERT_NE(nullptr, capability);
403     ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_LOW_LATENCY));
404 }
405 /**
406  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0033
407  * @tc.name      : 解码,查询低时延的能力值H265
408  * @tc.desc      : api test
409  */
410 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0033, TestSize.Level1)
411 {
412     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
413     ASSERT_NE(nullptr, capability);
414     ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_LOW_LATENCY));
415 }
416 /**
417  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0034
418  * @tc.name      : 解码，查询分层编码的能力值H265
419  * @tc.desc      : api test
420  */
421 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0034, TestSize.Level2)
422 {
423     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
424     ASSERT_NE(nullptr, capability);
425     ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
426 }
427 
428 /**
429  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0035
430  * @tc.name      : 编码，查询分层编码的能力值H265
431  * @tc.desc      : api test
432  */
433 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0035, TestSize.Level1)
434 {
435     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
436     ASSERT_NE(nullptr, capability);
437     ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
438 }
439 /**
440  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0036
441  * @tc.name      : 解码，查询LTR能力值H265
442  * @tc.desc      : api test
443  */
444 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0036, TestSize.Level2)
445 {
446     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
447     ASSERT_NE(nullptr, capability);
448     ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
449 }
450 
451 /**
452  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0037
453  * @tc.name      : 编码，查询LTR的能力值H265
454  * @tc.desc      : api test
455  */
456 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0037, TestSize.Level1)
457 {
458     if (!access("/system/lib64/media/", 0)) {
459         OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC,
460          true, HARDWARE);
461         ASSERT_NE(nullptr, capability);
462         format = OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE);
463         ASSERT_NE(nullptr, format);
464         int ltrnum = 0;
465         EXPECT_EQ(OH_AVFormat_GetIntValue(
466             format, OH_FEATURE_PROPERTY_KEY_VIDEO_ENCODER_MAX_LTR_FRAME_COUNT, &ltrnum), true);
467         EXPECT_EQ(ltrnum, 10);
468     } else {
469         OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC,
470          true, HARDWARE);
471         ASSERT_NE(nullptr, capability);
472         ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
473     }
474 }
475 
476 /**
477  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0038
478  * @tc.name      : 能力查询是否支持LTRH266
479  * @tc.desc      : function test
480  */
481 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0038, TestSize.Level1)
482 {
483     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_VVC, false, HARDWARE);
484     if (capability != nullptr) {
485         ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
486     }
487 }
488 
489 /**
490  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0039
491  * @tc.name      : 能力查询是否支持低时延H266
492  * @tc.desc      : function test
493  */
494 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0039, TestSize.Level1)
495 {
496     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_VVC, false, HARDWARE);
497     if (capability != nullptr) {
498         if (!access("/system/lib64/media/", 0)) {
499             ASSERT_EQ(true, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
500         } else {
501             ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
502         }
503     }
504 }
505 
506 /**
507  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0040
508  * @tc.name      : 能力查询是否支持分层编码H266
509  * @tc.desc      : function test
510  */
511 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0040, TestSize.Level1)
512 {
513     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_VVC, false, HARDWARE);
514     if (capability != nullptr) {
515         ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
516     }
517 }
518 
519 /**
520  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0041
521  * @tc.name      : 解码，查询LTR能力值H266
522  * @tc.desc      : api test
523  */
524 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0041, TestSize.Level1)
525 {
526     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_VVC, false, HARDWARE);
527     if (capability != nullptr) {
528         ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE));
529     }
530 }
531 
532 /**
533  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0042
534  * @tc.name      : 解码,查询低时延的能力值H266
535  * @tc.desc      : api test
536  */
537 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0042, TestSize.Level1)
538 {
539     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_VVC, false, HARDWARE);
540     if (capability != nullptr) {
541         ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_LOW_LATENCY));
542     }
543 }
544 
545 /**
546  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0043
547  * @tc.name      : 解码，查询分层编码的能力值H266
548  * @tc.desc      : api test
549  */
550 HWTEST_F(HwCapabilityNdkTest, VIDEO_TEMPORAL_ENCODE_API_0043, TestSize.Level1)
551 {
552     OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_VVC, false, HARDWARE);
553     if (capability != nullptr) {
554         ASSERT_EQ(nullptr, OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
555     }
556 }
557 } // namespace