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
24namespace {
25OH_AVCodec *venc_ = NULL;
26OH_AVCapability *cap = nullptr;
27OH_AVCapability *cap_hevc = nullptr;
28constexpr uint32_t CODEC_NAME_SIZE = 128;
29char g_codecName[CODEC_NAME_SIZE] = {};
30char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
31OH_AVFormat *format;
32} // namespace
33namespace OHOS {
34namespace Media {
35class HwCapabilityNdkTest : public testing::Test {
36public:
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
49using namespace std;
50using namespace OHOS;
51using namespace OHOS::Media;
52using namespace testing::ext;
53
54void 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}
67void HwCapabilityNdkTest::TearDownTestCase() {}
68void HwCapabilityNdkTest::SetUp() {}
69void 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}
80namespace {
81/**
82 * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0010
83 * @tc.name      : OH_AVCapability_IsFeatureSupported para error
84 * @tc.desc      : api test
85 */
86HWTEST_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 */
98HWTEST_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 */
110HWTEST_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 */
128HWTEST_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 */
140HWTEST_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 */
158HWTEST_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 */
170HWTEST_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 */
190HWTEST_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 */
208HWTEST_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 */
225HWTEST_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 */
237HWTEST_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 */
249HWTEST_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 */
261HWTEST_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 */
284HWTEST_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 */
296HWTEST_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 */
308HWTEST_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 */
320HWTEST_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 */
335HWTEST_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 */
345HWTEST_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 */
360HWTEST_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 */
374HWTEST_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 */
389HWTEST_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 */
399HWTEST_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 */
410HWTEST_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 */
421HWTEST_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 */
433HWTEST_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 */
444HWTEST_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 */
456HWTEST_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} // namespace