1 /*
2 * Copyright (C) 2025 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 <iostream>
16 #include <cstdio>
17 #include <string>
18
19 #include "gtest/gtest.h"
20 #include "native_avcodec_base.h"
21 #include "native_avformat.h"
22 #include "native_avcodec_videoencoder.h"
23 #include "VideoencApi11Sample.h"
24 #include "native_avcapability.h"
25 using namespace std;
26 using namespace OHOS;
27 using namespace OHOS::Media;
28 using namespace testing::ext;
29 namespace {
30 OH_AVCodec* gVenc = nullptr;
31 OH_AVCapability* g_capEnc = nullptr;
32 const char* CODEC_NAME = "";
33 OH_AVFormat* gFormat = nullptr;
34 } // namespace
35
36 namespace OHOS {
37 namespace Media {
38 class HwEncBFuncTest : public testing::Test {
39 public:
40 // SetUpTestCase: Called before all test cases
41 static void SetUpTestCase(void);
42 // TearDownTestCase: Called after all test case
43 static void TearDownTestCase(void);
44 // SetUp: Called before each test cases
45 void SetUp(void);
46 // TearDown: Called after each test cases
47 void TearDown(void);
48
49 protected:
50 const char* INP_DIR_1080_30 = "/data/test/media/1080_1920_nv12.yuv";
51 const char* INP_DIR_720_30 = "/data/test/media/1280_720_yuv420p_01.yuv";
52 };
53
SetUpTestCase()54 void HwEncBFuncTest::SetUpTestCase()
55 {
56 g_capEnc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
57 CODEC_NAME = OH_AVCapability_GetName(g_capEnc);
58 cout << "g_codecname: " << CODEC_NAME << endl;
59 }
TearDownTestCase()60 void HwEncBFuncTest::TearDownTestCase() {}
SetUp()61 void HwEncBFuncTest::SetUp() {}
TearDown()62 void HwEncBFuncTest::TearDown()
63 {
64 if (gVenc != NULL) {
65 OH_VideoEncoder_Destroy(gVenc);
66 gVenc = nullptr;
67 }
68 if (gFormat != nullptr) {
69 OH_AVFormat_Destroy(gFormat);
70 gFormat = nullptr;
71 }
72 }
73 } // namespace Media
74 } // namespace OHOS
75
76 namespace {
77 /**
78 * @tc.number : VIDEO_HW_ENCODE_B_FUNC_001
79 * @tc.name : VIDEO_HW_ENCODE_B_FUNC_001
80 * @tc.desc : test
81 */
82 HWTEST_F(HwEncBFuncTest, VIDEO_HW_ENCODE_B_FUNC_001, TestSize.Level2)
83 {
84 bool bsupport = OH_AVCapability_IsFeatureSupported(g_capEnc, OH_AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
85 if (!bsupport) {
86 return;
87 }
88 auto vEncSample = make_unique<VEncAPI11Sample>();
89 vEncSample->DEFAULT_WIDTH = 1280;
90 vEncSample->DEFAULT_HEIGHT = 720;
91 vEncSample->OUT_DIR = "/data/test/media/1280_720_YUV420_01.h265";
92 vEncSample->MODE_ENABLE = true;
93 vEncSample->B_ENABLE = true;
94 vEncSample->DEFAULT_BITRATE_MODE = CBR;
95 vEncSample->DEFAULT_BFRAME = 0;
96 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_YUVI420;
97 vEncSample->INP_DIR = INP_DIR_720_30;
98 gFormat = OH_AVCapability_GetFeatureProperties(g_capEnc, OH_AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
99 ASSERT_NE(NULL, gFormat);
100 int32_t ret_1 = vEncSample->GetBframes(gFormat);
101 ASSERT_GT(ret_1, 0);
102 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
103 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
104 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
105 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
106 vEncSample->WaitForEOS();
107 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
108 }
109
110 /**
111 * @tc.number : VIDEO_HW_ENCODE_B_FUNC_002
112 * @tc.name : VIDEO_HW_ENCODE_B_FUNC_002
113 * @tc.desc : function test
114 */
115 HWTEST_F(HwEncBFuncTest, VIDEO_HW_ENCODE_B_FUNC_002, TestSize.Level2)
116 {
117 bool bsupport = OH_AVCapability_IsFeatureSupported(g_capEnc, OH_AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
118 if (!bsupport) {
119 return;
120 }
121 auto vEncSample = make_unique<VEncAPI11Sample>();
122 vEncSample->DEFAULT_WIDTH = 1280;
123 vEncSample->DEFAULT_HEIGHT = 720;
124 vEncSample->OUT_DIR = "/data/test/media/1280_720_YUV420_02.h265";
125 vEncSample->MODE_ENABLE = true;
126 vEncSample->B_ENABLE = true;
127 vEncSample->DEFAULT_BITRATE_MODE = CBR;
128 vEncSample->DEFAULT_BFRAME = 1;
129 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_YUVI420;
130 vEncSample->INP_DIR = INP_DIR_720_30;
131 gFormat = OH_AVCapability_GetFeatureProperties(g_capEnc, OH_AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
132 ASSERT_NE(NULL, gFormat);
133 int32_t ret_1 = vEncSample->GetBframes(gFormat);
134 ASSERT_GT(ret_1, 0);
135 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
136 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
137 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
138 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
139 vEncSample->WaitForEOS();
140 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
141 }
142
143 /**
144 * @tc.number : VIDEO_HW_ENCODE_B_FUNC_003
145 * @tc.name : VIDEO_HW_ENCODE_B_FUNC_003
146 * @tc.desc : function test
147 */
148 HWTEST_F(HwEncBFuncTest, VIDEO_HW_ENCODE_B_FUNC_003, TestSize.Level2)
149 {
150 bool bsupport = OH_AVCapability_IsFeatureSupported(g_capEnc, OH_AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
151 if (!bsupport) {
152 return;
153 }
154 auto vEncSample = make_unique<VEncAPI11Sample>();
155 vEncSample->DEFAULT_WIDTH = 1280;
156 vEncSample->DEFAULT_HEIGHT = 720;
157 vEncSample->OUT_DIR = "/data/test/media/1280_720_YUV420_03.h265";
158 vEncSample->MODE_ENABLE = true;
159 vEncSample->B_ENABLE = true;
160 vEncSample->DEFAULT_BITRATE_MODE = CBR;
161 vEncSample->DEFAULT_BFRAME = 0;
162 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_YUVI420;
163 vEncSample->INP_DIR = INP_DIR_720_30;
164 gFormat = OH_AVCapability_GetFeatureProperties(g_capEnc, OH_AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
165 ASSERT_NE(NULL, gFormat);
166 int32_t ret_1 = vEncSample->GetBframes(gFormat);
167 ASSERT_GT(ret_1, 0);
168 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
169 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
170 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
171 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
172 vEncSample->WaitForEOS();
173 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
174 }
175
176 /**
177 * @tc.number : VIDEO_HW_ENCODE_B_FUNC_004
178 * @tc.name : VIDEO_HW_ENCODE_B_FUNC_004
179 * @tc.desc : function test
180 */
181 HWTEST_F(HwEncBFuncTest, VIDEO_HW_ENCODE_B_FUNC_004, TestSize.Level2)
182 {
183 bool bsupport = OH_AVCapability_IsFeatureSupported(g_capEnc, OH_AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
184 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
185 if (!isSupported || !bsupport) {
186 return;
187 }
188 auto vEncSample = make_unique<VEncAPI11Sample>();
189 vEncSample->DEFAULT_WIDTH = 1080;
190 vEncSample->DEFAULT_HEIGHT = 1920;
191 vEncSample->OUT_DIR = "/data/test/media/1080_1920_nv12_03.h265";
192 vEncSample->SURF_INPUT = true;
193 vEncSample->B_ENABLE = true;
194 vEncSample->MODE_ENABLE = true;
195 vEncSample->DEFAULT_BITRATE_MODE = SQR;
196 vEncSample->DEFAULT_BFRAME = 1;
197 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
198 vEncSample->INP_DIR = INP_DIR_1080_30;
199 gFormat = OH_AVCapability_GetFeatureProperties(g_capEnc, OH_AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
200 ASSERT_NE(NULL, gFormat);
201 int32_t ret_1 = vEncSample->GetBframes(gFormat);
202 ASSERT_GT(ret_1, 0);
203 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
204 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
205 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
206 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
207 vEncSample->WaitForEOS();
208 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
209 }
210
211 /**
212 * @tc.number : VIDEO_HW_ENCODE_B_FUNC_005
213 * @tc.name : VIDEO_HW_ENCODE_B_FUNC_005
214 * @tc.desc : function test
215 */
216 HWTEST_F(HwEncBFuncTest, VIDEO_HW_ENCODE_B_FUNC_005, TestSize.Level2)
217 {
218 bool bsupport = OH_AVCapability_IsFeatureSupported(g_capEnc, OH_AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
219 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
220 if (!isSupported || !bsupport) {
221 return;
222 }
223 auto vEncSample = make_unique<VEncAPI11Sample>();
224 vEncSample->DEFAULT_WIDTH = 1080;
225 vEncSample->DEFAULT_HEIGHT = 1920;
226 vEncSample->OUT_DIR = "/data/test/media/1080_1920_nv12_03.h265";
227 vEncSample->MODE_ENABLE = true;
228 vEncSample->B_ENABLE = true;
229 vEncSample->SURF_INPUT = true;
230 vEncSample->DEFAULT_BITRATE_MODE = SQR;
231 vEncSample->DEFAULT_BFRAME = -1;
232 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
233 vEncSample->INP_DIR = INP_DIR_1080_30;
234 gFormat = OH_AVCapability_GetFeatureProperties(g_capEnc, OH_AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
235 ASSERT_NE(NULL, gFormat);
236 int32_t ret_1 = vEncSample->GetBframes(gFormat);
237 ASSERT_GT(ret_1, 0);
238 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
239 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
240 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
241 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
242 vEncSample->WaitForEOS();
243 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
244 }
245
246 /**
247 * @tc.number : VIDEO_HW_ENCODE_B_FUNC_006
248 * @tc.name : VIDEO_HW_ENCODE_B_FUNC_006
249 * @tc.desc : function test
250 */
251 HWTEST_F(HwEncBFuncTest, VIDEO_HW_ENCODE_B_FUNC_006, TestSize.Level2)
252 {
253 bool bsupport = OH_AVCapability_IsFeatureSupported(g_capEnc, OH_AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
254 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
255 if (!isSupported || !bsupport) {
256 return;
257 }
258 auto vEncSample = make_unique<VEncAPI11Sample>();
259 vEncSample->DEFAULT_WIDTH = 1080;
260 vEncSample->DEFAULT_HEIGHT = 1920;
261 vEncSample->OUT_DIR = "/data/test/media/1080_1920_nv12_04.h265";
262 vEncSample->MODE_ENABLE = true;
263 vEncSample->B_ENABLE = true;
264 vEncSample->SURF_INPUT = true;
265 vEncSample->DEFAULT_BITRATE_MODE = SQR;
266 vEncSample->DEFAULT_BFRAME = 100;
267 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
268 vEncSample->INP_DIR = INP_DIR_1080_30;
269 gFormat = OH_AVCapability_GetFeatureProperties(g_capEnc, OH_AVCapabilityFeature::VIDEO_ENCODER_B_FRAME);
270 ASSERT_NE(NULL, gFormat);
271 int32_t ret_1 = vEncSample->GetBframes(gFormat);
272 ASSERT_GT(ret_1, 0);
273 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
274 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
275 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
276 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
277 vEncSample->WaitForEOS();
278 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
279 }
280 } // namespace