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 #include "avcodec_info.h"
24 #include "avcodec_list.h"
25 #include "meta/meta_key.h"
26 #include "meta/format.h"
27 #include "avcodec_errors.h"
28 #include "av_common.h"
29 #include <typeinfo>
30 
31 namespace {
32 OH_AVCodec *venc_ = NULL;
33 constexpr uint32_t CODEC_NAME_SIZE = 128;
34 char g_codecName[CODEC_NAME_SIZE] = {};
35 char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
36 OH_AVFormat *format;
37 } // namespace
38 namespace OHOS {
39 namespace Media {
40 class HwCapabilityInnerNdkTest : public testing::Test {
41 public:
42     static void SetUpTestCase();
43     static void TearDownTestCase();
44     void SetUp() override;
45     void TearDown() override;
46     void InputFunc();
47     void OutputFunc();
48     void Release();
49     int32_t Stop();
50 };
51 } // namespace Media
52 } // namespace OHOS
53 
54 using namespace std;
55 using namespace OHOS;
56 using namespace OHOS::Media;
57 using namespace testing::ext;
58 using namespace OHOS::MediaAVCodec;
59 
SetUpTestCase()60 void HwCapabilityInnerNdkTest::SetUpTestCase()
61 {
62     auto codeclist = AVCodecListFactory::CreateAVCodecList();
63     if (codeclist != nullptr) {
64         CapabilityData *cap = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
65             true, AVCodecCategory::AVCODEC_HARDWARE);
66         if (cap != nullptr) {
67             const std::string &name = cap->codecName;
68             const char *tmpCodecName = name.data();
69             if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
70                 cout << "memcpy failed" << endl;
71             cout << "codecname: " << g_codecName << endl;
72         }
73         CapabilityData *cap_hevc = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
74             true, AVCodecCategory::AVCODEC_HARDWARE);
75         if (cap_hevc != nullptr) {
76             const std::string &name = cap_hevc->codecName;
77             const char *tmpCodecNameHevc = name.data();
78             if (memcpy_s(g_codecNameHEVC, sizeof(g_codecNameHEVC), tmpCodecNameHevc, strlen(tmpCodecNameHevc)) != 0)
79             cout << "memcpy failed" << endl;
80             cout << "codecname_hevc: " << g_codecNameHEVC << endl;
81         }
82     }
83 }
TearDownTestCase()84 void HwCapabilityInnerNdkTest::TearDownTestCase() {}
SetUp()85 void HwCapabilityInnerNdkTest::SetUp() {}
TearDown()86 void HwCapabilityInnerNdkTest::TearDown()
87 {
88     if (venc_ != NULL) {
89         OH_VideoEncoder_Destroy(venc_);
90         venc_ = nullptr;
91     }
92     if (format != nullptr) {
93         OH_AVFormat_Destroy(format);
94         format = nullptr;
95     }
96 }
97 namespace {
98 /**
99  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0010
100  * @tc.name      : IsFeatureSupported para error
101  * @tc.desc      : api test
102  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0010, TestSize.Level2)103 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0010, TestSize.Level2)
104 {
105     auto codeclist = AVCodecListFactory::CreateAVCodecList();
106     ASSERT_NE(nullptr, codeclist);
107     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
108         true, AVCodecCategory::AVCODEC_HARDWARE);
109     ASSERT_NE(nullptr, capabilityData);
110     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
111     ASSERT_EQ(false, codecInfo->IsFeatureSupported(static_cast<AVCapabilityFeature>(4)));
112 }
113 
114 /**
115  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0011
116  * @tc.name      : 解码，是否支持分层编码
117  * @tc.desc      : api test
118  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0011, TestSize.Level2)119 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0011, TestSize.Level2)
120 {
121     auto codeclist = AVCodecListFactory::CreateAVCodecList();
122     ASSERT_NE(nullptr, codeclist);
123     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
124         false, AVCodecCategory::AVCODEC_HARDWARE);
125     ASSERT_NE(nullptr, capabilityData);
126     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
127     ASSERT_EQ(false, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY));
128 }
129 
130 /**
131  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0012
132  * @tc.name      : 编码，是否支持分层编码
133  * @tc.desc      : api test
134  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0012, TestSize.Level1)135 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0012, TestSize.Level1)
136 {
137     auto codeclist = AVCodecListFactory::CreateAVCodecList();
138     ASSERT_NE(nullptr, codeclist);
139     if (!access("/system/lib64/media/", 0)) {
140         CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
141             true, AVCodecCategory::AVCODEC_HARDWARE);
142         ASSERT_NE(nullptr, capabilityData);
143         std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
144         ASSERT_EQ(true, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY));
145     } else {
146         CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
147             true, AVCodecCategory::AVCODEC_HARDWARE);
148         ASSERT_NE(nullptr, capabilityData);
149         std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
150         ASSERT_EQ(false, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY));
151     }
152 }
153 
154 /**
155  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0013
156  * @tc.name      : 解码，是否支持LTR
157  * @tc.desc      : api test
158  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0013, TestSize.Level2)159 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0013, TestSize.Level2)
160 {
161     auto codeclist = AVCodecListFactory::CreateAVCodecList();
162     ASSERT_NE(nullptr, codeclist);
163     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
164         false, AVCodecCategory::AVCODEC_HARDWARE);
165     ASSERT_NE(nullptr, capabilityData);
166     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
167     ASSERT_EQ(false, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_LONG_TERM_REFERENCE));
168 }
169 
170 /**
171  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0014
172  * @tc.name      : 编码，是否支持LTR
173  * @tc.desc      : api test
174  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0014, TestSize.Level1)175 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0014, TestSize.Level1)
176 {
177     auto codeclist = AVCodecListFactory::CreateAVCodecList();
178     ASSERT_NE(nullptr, codeclist);
179     if (!access("/system/lib64/media/", 0)) {
180         CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
181             true, AVCodecCategory::AVCODEC_HARDWARE);
182         ASSERT_NE(nullptr, capabilityData);
183         std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
184         ASSERT_EQ(true, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_LONG_TERM_REFERENCE));
185     } else {
186         CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
187             true, AVCodecCategory::AVCODEC_HARDWARE);
188         ASSERT_NE(nullptr, capabilityData);
189         std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
190         ASSERT_EQ(false, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_LONG_TERM_REFERENCE));
191     }
192 }
193 
194 /**
195  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0015
196  * @tc.name      : 软解，是否支持低时延
197  * @tc.desc      : api test
198  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0015, TestSize.Level2)199 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0015, TestSize.Level2)
200 {
201     auto codeclist = AVCodecListFactory::CreateAVCodecList();
202     ASSERT_NE(nullptr, codeclist);
203     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
204         false, AVCodecCategory::AVCODEC_SOFTWARE);
205     ASSERT_NE(nullptr, capabilityData);
206     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
207     ASSERT_EQ(false, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_LOW_LATENCY));
208 }
209 
210 /**
211  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0016
212  * @tc.name      : 硬解，是否支持低时延
213  * @tc.desc      : api test
214  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0016, TestSize.Level2)215 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0016, TestSize.Level2)
216 {
217     auto codeclist = AVCodecListFactory::CreateAVCodecList();
218     ASSERT_NE(nullptr, codeclist);
219     if (!access("/system/lib64/media/", 0)) {
220         CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
221             false, AVCodecCategory::AVCODEC_HARDWARE);
222         ASSERT_NE(nullptr, capabilityData);
223         std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
224         ASSERT_EQ(true, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_LOW_LATENCY));
225     } else {
226         CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
227             false, AVCodecCategory::AVCODEC_HARDWARE);
228         ASSERT_NE(nullptr, capabilityData);
229         std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
230         ASSERT_EQ(false, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_LOW_LATENCY));
231     }
232 }
233 
234 /**
235  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0017
236  * @tc.name      : 编码，是否支持低时延
237  * @tc.desc      : api test
238  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0017, TestSize.Level1)239 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0017, TestSize.Level1)
240 {
241     auto codeclist = AVCodecListFactory::CreateAVCodecList();
242     ASSERT_NE(nullptr, codeclist);
243     if (!access("/system/lib64/media/", 0)) {
244         CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
245             true, AVCodecCategory::AVCODEC_HARDWARE);
246         ASSERT_NE(nullptr, capabilityData);
247         std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
248         ASSERT_EQ(true, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_LOW_LATENCY));
249     } else {
250         CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
251             true, AVCodecCategory::AVCODEC_HARDWARE);
252         ASSERT_NE(nullptr, capabilityData);
253         std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
254         ASSERT_EQ(false, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_LOW_LATENCY));
255     }
256 }
257 
258 /**
259  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0018
260  * @tc.name      : GetFeatureProperties para error
261  * @tc.desc      : api test
262  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0018, TestSize.Level2)263 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0018, TestSize.Level2)
264 {
265     Format featureFormat;
266     auto codeclist = AVCodecListFactory::CreateAVCodecList();
267     ASSERT_NE(nullptr, codeclist);
268     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
269         true, AVCodecCategory::AVCODEC_HARDWARE);
270     ASSERT_NE(nullptr, capabilityData);
271     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
272     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, codecInfo->GetFeatureProperties(static_cast<AVCapabilityFeature>(4),
273         featureFormat));
274     ASSERT_EQ(AVCS_ERR_INVALID_VAL, codecInfo->GetFeatureProperties(static_cast<AVCapabilityFeature>(-1),
275         featureFormat));
276     ASSERT_EQ(AVCS_ERR_INVALID_VAL, codecInfo->GetFeatureProperties(static_cast<AVCapabilityFeature>(100),
277         featureFormat));
278     if (!access("/system/lib64/media/", 0)) {
279         ASSERT_EQ(AVCS_ERR_OK, codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY,
280             featureFormat));
281     } else {
282         ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
283             codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY, featureFormat));
284     }
285 }
286 
287 /**
288  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0019
289  * @tc.name      : 解码，查询分层编码的能力值
290  * @tc.desc      : api test
291  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0019, TestSize.Level2)292 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0019, TestSize.Level2)
293 {
294     Format featureFormat;
295     auto codeclist = AVCodecListFactory::CreateAVCodecList();
296     ASSERT_NE(nullptr, codeclist);
297     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
298         false, AVCodecCategory::AVCODEC_HARDWARE);
299     ASSERT_NE(nullptr, capabilityData);
300     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
301     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
302         codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY, featureFormat));
303 }
304 
305 /**
306  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0020
307  * @tc.name      : 编码，查询分层编码的能力值
308  * @tc.desc      : api test
309  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0020, TestSize.Level1)310 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0020, TestSize.Level1)
311 {
312     Format featureFormat;
313     auto codeclist = AVCodecListFactory::CreateAVCodecList();
314     ASSERT_NE(nullptr, codeclist);
315     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
316         true, AVCodecCategory::AVCODEC_HARDWARE);
317     ASSERT_NE(nullptr, capabilityData);
318     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
319     if (!access("/system/lib64/media/", 0)) {
320         ASSERT_EQ(AVCS_ERR_OK, codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY,
321             featureFormat));
322     } else {
323         ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
324             codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY, featureFormat));
325     }
326 }
327 
328 /**
329  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0021
330  * @tc.name      : 解码，查询LTR能力值
331  * @tc.desc      : api test
332  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0021, TestSize.Level2)333 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0021, TestSize.Level2)
334 {
335     Format featureFormat;
336     auto codeclist = AVCodecListFactory::CreateAVCodecList();
337     ASSERT_NE(nullptr, codeclist);
338     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
339         false, AVCodecCategory::AVCODEC_HARDWARE);
340     ASSERT_NE(nullptr, capabilityData);
341     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
342     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
343         codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY, featureFormat));
344 }
345 
346 /**
347  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0022
348  * @tc.name      : 编码，查询LTR的能力值
349  * @tc.desc      : api test
350  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0022, TestSize.Level1)351 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0022, TestSize.Level1)
352 {
353     Format featureFormat;
354     auto codeclist = AVCodecListFactory::CreateAVCodecList();
355     ASSERT_NE(nullptr, codeclist);
356     if (!access("/system/lib64/media/", 0)) {
357         CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
358             true, AVCodecCategory::AVCODEC_HARDWARE);
359         ASSERT_NE(nullptr, capabilityData);
360         std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
361         ASSERT_EQ(AVCS_ERR_OK, codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_LONG_TERM_REFERENCE,
362             featureFormat));
363         int ltrnum = 0;
364         EXPECT_EQ(featureFormat.GetIntValue(OH_FEATURE_PROPERTY_KEY_VIDEO_ENCODER_MAX_LTR_FRAME_COUNT, ltrnum), true);
365         EXPECT_EQ(ltrnum, 10);
366     } else {
367         CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
368             true, AVCodecCategory::AVCODEC_HARDWARE);
369         ASSERT_NE(nullptr, capabilityData);
370         std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
371         ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
372             codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_LONG_TERM_REFERENCE, featureFormat));
373     }
374 }
375 
376 /**
377  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0023
378  * @tc.name      : 软解，查询低时延的能力值
379  * @tc.desc      : api test
380  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0023, TestSize.Level2)381 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0023, TestSize.Level2)
382 {
383     Format featureFormat;
384     auto codeclist = AVCodecListFactory::CreateAVCodecList();
385     ASSERT_NE(nullptr, codeclist);
386     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
387         false, AVCodecCategory::AVCODEC_SOFTWARE);
388     ASSERT_NE(nullptr, capabilityData);
389     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
390     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
391         codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY, featureFormat));
392 }
393 
394 /**
395  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0024
396  * @tc.name      : 硬解，查询低时延的能力值
397  * @tc.desc      : api test
398  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0024, TestSize.Level2)399 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0024, TestSize.Level2)
400 {
401     Format featureFormat;
402     auto codeclist = AVCodecListFactory::CreateAVCodecList();
403     ASSERT_NE(nullptr, codeclist);
404     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
405         false, AVCodecCategory::AVCODEC_HARDWARE);
406     ASSERT_NE(nullptr, capabilityData);
407     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
408     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
409         codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY, featureFormat));
410 }
411 
412 /**
413  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0025
414  * @tc.name      : 编码，查询低时延的能力值
415  * @tc.desc      : api test
416  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0025, TestSize.Level1)417 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0025, TestSize.Level1)
418 {
419     Format featureFormat;
420     auto codeclist = AVCodecListFactory::CreateAVCodecList();
421     ASSERT_NE(nullptr, codeclist);
422     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_AVC),
423         true, AVCodecCategory::AVCODEC_HARDWARE);
424     ASSERT_NE(nullptr, capabilityData);
425     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
426     if (!access("/system/lib64/media/", 0)) {
427         ASSERT_EQ(AVCS_ERR_OK, codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY,
428             featureFormat));
429     } else {
430         ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
431             codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY, featureFormat));
432     }
433 }
434 
435 /**
436  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0026
437  * @tc.name      : 能力查询是否支持LTRH265
438  * @tc.desc      : function test
439  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0026, TestSize.Level1)440 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0026, TestSize.Level1)
441 {
442     auto codeclist = AVCodecListFactory::CreateAVCodecList();
443     ASSERT_NE(nullptr, codeclist);
444     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
445         true, AVCodecCategory::AVCODEC_HARDWARE);
446     ASSERT_NE(nullptr, capabilityData);
447     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
448     if (!access("/system/lib64/media/", 0)) {
449         ASSERT_EQ(true, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_LONG_TERM_REFERENCE));
450     } else {
451         ASSERT_EQ(false, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_LONG_TERM_REFERENCE));
452     }
453 }
454 
455 /**
456  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0027
457  * @tc.name      : 能力查询是否支持LTRH265
458  * @tc.desc      : function test
459  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0027, TestSize.Level1)460 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0027, TestSize.Level1)
461 {
462     auto codeclist = AVCodecListFactory::CreateAVCodecList();
463     ASSERT_NE(nullptr, codeclist);
464     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
465         false, AVCodecCategory::AVCODEC_HARDWARE);
466     ASSERT_NE(nullptr, capabilityData);
467     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
468     ASSERT_EQ(false, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_LONG_TERM_REFERENCE));
469 }
470 
471 /**
472  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0028
473  * @tc.name      : 能力查询是否支持低时延H265
474  * @tc.desc      : function test
475  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0028, TestSize.Level1)476 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0028, TestSize.Level1)
477 {
478     auto codeclist = AVCodecListFactory::CreateAVCodecList();
479     ASSERT_NE(nullptr, codeclist);
480     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
481         true, AVCodecCategory::AVCODEC_HARDWARE);
482     ASSERT_NE(nullptr, capabilityData);
483     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
484     if (!access("/system/lib64/media/", 0)) {
485         ASSERT_EQ(true, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_LOW_LATENCY));
486     } else {
487         ASSERT_EQ(false, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_LOW_LATENCY));
488     }
489 }
490 
491 /**
492  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0029
493  * @tc.name      : 能力查询是否支持低时延H265
494  * @tc.desc      : function test
495  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0029, TestSize.Level1)496 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0029, TestSize.Level1)
497 {
498     auto codeclist = AVCodecListFactory::CreateAVCodecList();
499     ASSERT_NE(nullptr, codeclist);
500     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
501         false, AVCodecCategory::AVCODEC_HARDWARE);
502     ASSERT_NE(nullptr, capabilityData);
503     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
504     if (!access("/system/lib64/media/", 0)) {
505         ASSERT_EQ(true, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_LOW_LATENCY));
506     } else {
507         ASSERT_EQ(false, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_LOW_LATENCY));
508     }
509 }
510 
511 /**
512  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0030
513  * @tc.name      : 能力查询是否支持分层编码H265
514  * @tc.desc      : function test
515  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0030, TestSize.Level1)516 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0030, TestSize.Level1)
517 {
518     auto codeclist = AVCodecListFactory::CreateAVCodecList();
519     ASSERT_NE(nullptr, codeclist);
520     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
521         true, AVCodecCategory::AVCODEC_HARDWARE);
522     ASSERT_NE(nullptr, capabilityData);
523     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
524     if (!access("/system/lib64/media/", 0)) {
525         ASSERT_EQ(true, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY));
526     } else {
527         ASSERT_EQ(false, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY));
528     }
529 }
530 
531 /**
532  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0031
533  * @tc.name      : 能力查询是否支持分层编码H265
534  * @tc.desc      : function test
535  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0031, TestSize.Level1)536 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0031, TestSize.Level1)
537 {
538     auto codeclist = AVCodecListFactory::CreateAVCodecList();
539     ASSERT_NE(nullptr, codeclist);
540     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
541         false, AVCodecCategory::AVCODEC_HARDWARE);
542     ASSERT_NE(nullptr, capabilityData);
543     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
544     ASSERT_EQ(false, codecInfo->IsFeatureSupported(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY));
545 }
546 
547 /**
548  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0032
549  * @tc.name      : 编码,查询低时延的能力值H265
550  * @tc.desc      : api test
551  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0032, TestSize.Level1)552 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0032, TestSize.Level1)
553 {
554     Format featureFormat;
555     auto codeclist = AVCodecListFactory::CreateAVCodecList();
556     ASSERT_NE(nullptr, codeclist);
557     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
558         true, AVCodecCategory::AVCODEC_HARDWARE);
559     ASSERT_NE(nullptr, capabilityData);
560     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
561     if (!access("/system/lib64/media/", 0)) {
562         ASSERT_EQ(AVCS_ERR_OK, codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY,
563             featureFormat));
564     } else {
565         ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
566             codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY, featureFormat));
567     }
568 }
569 
570 /**
571  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0033
572  * @tc.name      : 解码,查询低时延的能力值H265
573  * @tc.desc      : api test
574  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0033, TestSize.Level1)575 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0033, TestSize.Level1)
576 {
577     Format featureFormat;
578     auto codeclist = AVCodecListFactory::CreateAVCodecList();
579     ASSERT_NE(nullptr, codeclist);
580     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
581         false, AVCodecCategory::AVCODEC_HARDWARE);
582     ASSERT_NE(nullptr, capabilityData);
583     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
584     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
585         codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY, featureFormat));
586 }
587 
588 /**
589  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0034
590  * @tc.name      : 解码，查询分层编码的能力值H265
591  * @tc.desc      : api test
592  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0034, TestSize.Level2)593 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0034, TestSize.Level2)
594 {
595     Format featureFormat;
596     auto codeclist = AVCodecListFactory::CreateAVCodecList();
597     ASSERT_NE(nullptr, codeclist);
598     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
599         false, AVCodecCategory::AVCODEC_HARDWARE);
600     ASSERT_NE(nullptr, capabilityData);
601     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
602     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
603         codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY, featureFormat));
604 }
605 
606 /**
607  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0035
608  * @tc.name      : 编码，查询分层编码的能力值H265
609  * @tc.desc      : api test
610  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0035, TestSize.Level1)611 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0035, TestSize.Level1)
612 {
613     Format featureFormat;
614     auto codeclist = AVCodecListFactory::CreateAVCodecList();
615     ASSERT_NE(nullptr, codeclist);
616     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
617         true, AVCodecCategory::AVCODEC_HARDWARE);
618     ASSERT_NE(nullptr, capabilityData);
619     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
620     if (!access("/system/lib64/media/", 0)) {
621         ASSERT_EQ(AVCS_ERR_OK, codecInfo->GetFeatureProperties(
622             AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY, featureFormat));
623     } else {
624         ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
625             codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY, featureFormat));
626     }
627 }
628 
629 /**
630  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0036
631  * @tc.name      : 解码，查询LTR能力值H265
632  * @tc.desc      : api test
633  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0036, TestSize.Level2)634 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0036, TestSize.Level2)
635 {
636     Format featureFormat;
637     auto codeclist = AVCodecListFactory::CreateAVCodecList();
638     ASSERT_NE(nullptr, codeclist);
639     CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
640         false, AVCodecCategory::AVCODEC_HARDWARE);
641     ASSERT_NE(nullptr, capabilityData);
642     std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
643     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
644         codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY, featureFormat));
645 }
646 
647 /**
648  * @tc.number    : VIDEO_TEMPORAL_ENCODE_INNER_API_0037
649  * @tc.name      : 编码，查询LTR的能力值H265
650  * @tc.desc      : api test
651  */
HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0037, TestSize.Level1)652 HWTEST_F(HwCapabilityInnerNdkTest, VIDEO_TEMPORAL_ENCODE_INNER_API_0037, TestSize.Level1)
653 {
654     Format featureFormat;
655     auto codeclist = AVCodecListFactory::CreateAVCodecList();
656     ASSERT_NE(nullptr, codeclist);
657     if (!access("/system/lib64/media/", 0)) {
658         CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
659             true, AVCodecCategory::AVCODEC_HARDWARE);
660         ASSERT_NE(nullptr, capabilityData);
661         std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
662         ASSERT_EQ(AVCS_ERR_OK,
663             codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_LONG_TERM_REFERENCE, featureFormat));
664         int ltrnum = 0;
665         EXPECT_EQ(featureFormat.GetIntValue(OH_FEATURE_PROPERTY_KEY_VIDEO_ENCODER_MAX_LTR_FRAME_COUNT, ltrnum), true);
666         EXPECT_EQ(ltrnum, 10);
667     } else {
668         CapabilityData *capabilityData = codeclist->GetCapability(string(CodecMimeType::VIDEO_HEVC),
669             true, AVCodecCategory::AVCODEC_HARDWARE);
670         ASSERT_NE(nullptr, capabilityData);
671         std::shared_ptr<AVCodecInfo> codecInfo = std::make_shared<AVCodecInfo>(capabilityData);
672         ASSERT_EQ(AVCS_ERR_INVALID_OPERATION,
673             codecInfo->GetFeatureProperties(AVCapabilityFeature::VIDEO_ENCODER_LONG_TERM_REFERENCE, featureFormat));
674     }
675 }
676 } // namespace