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 <limits>
17 #include "gtest/gtest.h"
18 #include "native_avcodec_videoencoder.h"
19 #include "native_averrors.h"
20 #include "videoenc_api11_sample.h"
21 #include "native_avcodec_base.h"
22 #include "avcodec_codec_name.h"
23 #include "native_avcapability.h"
24 namespace {
25 OH_AVCodec *venc_ = NULL;
26 OH_AVFormat *format;
27 OH_AVCapability *cap = nullptr;
28 OH_AVCapability *cap_hevc = nullptr;
29 constexpr uint32_t CODEC_NAME_SIZE = 128;
30 constexpr uint32_t DEFAULT_BITRATE = 1000000;
31 char g_codecName[CODEC_NAME_SIZE] = {};
32 char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
33 constexpr uint32_t DEFAULT_WIDTH = 1280;
34 constexpr uint32_t DEFAULT_HEIGHT = 720;
35 } // namespace
36 namespace OHOS {
37 namespace Media {
38 class HwEncConfigureNdkTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp() override;
43 void TearDown() override;
44 void InputFunc();
45 void OutputFunc();
46 void Release();
47 int32_t Stop();
48 };
49 } // namespace Media
50 } // namespace OHOS
51
52 using namespace std;
53 using namespace OHOS;
54 using namespace OHOS::Media;
55 using namespace testing::ext;
56
SetUpTestCase()57 void HwEncConfigureNdkTest::SetUpTestCase()
58 {
59 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
60 const char *tmpCodecName = OH_AVCapability_GetName(cap);
61 if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
62 cout << "memcpy failed" << endl;
63 cout << "codecname: " << g_codecName << endl;
64 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
65 const char *tmpCodecNameHevc = OH_AVCapability_GetName(cap_hevc);
66 if (memcpy_s(g_codecNameHEVC, sizeof(g_codecNameHEVC), tmpCodecNameHevc, strlen(tmpCodecNameHevc)) != 0)
67 cout << "memcpy failed" << endl;
68 cout << "codecname_hevc: " << g_codecNameHEVC << endl;
69 }
TearDownTestCase()70 void HwEncConfigureNdkTest::TearDownTestCase() {}
SetUp()71 void HwEncConfigureNdkTest::SetUp() {}
TearDown()72 void HwEncConfigureNdkTest::TearDown()
73 {
74 if (venc_ != NULL) {
75 OH_VideoEncoder_Destroy(venc_);
76 venc_ = nullptr;
77 }
78 if (format != nullptr) {
79 OH_AVFormat_Destroy(format);
80 format = nullptr;
81 }
82 }
83 namespace {
84
85 /**
86 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1800
87 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
88 * @tc.desc : api test
89 */
90 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1800, TestSize.Level2)
91 {
92 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
93 if (cap) {
94 OH_AVErrCode ret = AV_ERR_OK;
95 OH_AVRange range;
96 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
97 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
98 ASSERT_NE(nullptr, capability);
99 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
100 ASSERT_EQ(AV_ERR_OK, ret);
101 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
102 ASSERT_NE(nullptr, venc_);
103 format = OH_AVFormat_Create();
104 ASSERT_NE(nullptr, format);
105 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
106 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
107 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
108 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
109 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
110 OH_VideoEncoder_Destroy(venc_);
111 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
112 ASSERT_NE(nullptr, venc_);
113 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
114 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
115 } else {
116 return;
117 }
118 }
119
120 /**
121 * @tc.number : VIDEO_ENCODE_CAPABILITY_4000
122 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
123 * @tc.desc : api test
124 */
125 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_4000, TestSize.Level2)
126 {
127 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
128 if (cap) {
129 OH_AVErrCode ret = AV_ERR_OK;
130 OH_AVRange range;
131 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
132 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
133 ASSERT_NE(nullptr, capability);
134 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
135 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
136 ASSERT_EQ(AV_ERR_OK, ret);
137 ASSERT_GE(range.minVal, 0);
138 ASSERT_GT(range.maxVal, 0);
139 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
140 ASSERT_NE(nullptr, venc_);
141 format = OH_AVFormat_Create();
142 ASSERT_NE(nullptr, format);
143 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
144 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
145 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
146 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
147 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
148 OH_VideoEncoder_Destroy(venc_);
149 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
150 ASSERT_NE(nullptr, venc_);
151 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
152 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
153 } else {
154 return;
155 }
156 }
157
158 /**
159 * @tc.number : VIDEO_ENCODE_CAPABILITY_4400
160 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
161 * @tc.desc : api test
162 */
163 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_4400, TestSize.Level2)
164 {
165 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
166 if (cap) {
167 OH_AVErrCode ret = AV_ERR_OK;
168 OH_AVRange range;
169 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
170 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
171 ASSERT_NE(nullptr, capability);
172 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
173 ASSERT_EQ(AV_ERR_OK, ret);
174 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
175 ASSERT_GE(range.minVal, 0);
176 ASSERT_GT(range.maxVal, 0);
177 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
178 ASSERT_NE(nullptr, venc_);
179 format = OH_AVFormat_Create();
180 ASSERT_NE(nullptr, format);
181 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
182 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
183 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
184 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
185 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
186 OH_VideoEncoder_Destroy(venc_);
187 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
188 ASSERT_NE(nullptr, venc_);
189 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
190 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
191 } else {
192 return;
193 }
194 }
195
196 /**
197 * @tc.number : VIDEO_ENCODE_CAPABILITY_4410
198 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
199 * @tc.desc : api test
200 */
201 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_4410, TestSize.Level2)
202 {
203 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
204 if (cap) {
205 OH_AVErrCode ret = AV_ERR_OK;
206 OH_AVRange range;
207 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
208 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
209 ASSERT_NE(nullptr, capability);
210 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
211 ASSERT_EQ(AV_ERR_OK, ret);
212 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
213 ASSERT_GE(range.minVal, 0);
214 ASSERT_GT(range.maxVal, 0);
215 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
216 ASSERT_NE(nullptr, venc_);
217 format = OH_AVFormat_Create();
218 ASSERT_NE(nullptr, format);
219 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
220 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
221 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
222 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
223 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
224 OH_VideoEncoder_Destroy(venc_);
225 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
226 ASSERT_NE(nullptr, venc_);
227 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
228 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
229 } else {
230 return;
231 }
232 }
233
234 /**
235 * @tc.number : VIDEO_ENCODE_CAPABILITY_4700
236 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
237 * @tc.desc : api test
238 */
239 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_4700, TestSize.Level2)
240 {
241 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
242 if (cap) {
243 OH_AVErrCode ret = AV_ERR_OK;
244 OH_AVRange range;
245 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
246 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
247 ASSERT_NE(nullptr, capability);
248 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
249 ASSERT_EQ(AV_ERR_OK, ret);
250 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
251 ASSERT_GE(range.minVal, 0);
252 ASSERT_GT(range.maxVal, 0);
253 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
254 ASSERT_NE(nullptr, venc_);
255 format = OH_AVFormat_Create();
256 ASSERT_NE(nullptr, format);
257 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
258 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
259 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
260 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
261 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
262 OH_VideoEncoder_Destroy(venc_);
263 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
264 ASSERT_NE(nullptr, venc_);
265 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
266 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
267 } else {
268 return;
269 }
270 }
271
272 /**
273 * @tc.number : VIDEO_ENCODE_CAPABILITY_4710
274 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
275 * @tc.desc : api test
276 */
277 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_4710, TestSize.Level2)
278 {
279 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
280 if (cap) {
281 OH_AVErrCode ret = AV_ERR_OK;
282 OH_AVRange range;
283 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
284 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
285 ASSERT_NE(nullptr, capability);
286 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
287 ASSERT_EQ(AV_ERR_OK, ret);
288 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
289 ASSERT_GE(range.minVal, 0);
290 ASSERT_GT(range.maxVal, 0);
291 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
292 ASSERT_NE(nullptr, venc_);
293 format = OH_AVFormat_Create();
294 ASSERT_NE(nullptr, format);
295 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
296 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
297 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
298 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
299 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
300 OH_VideoEncoder_Destroy(venc_);
301 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
302 ASSERT_NE(nullptr, venc_);
303 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
304 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
305 } else {
306 return;
307 }
308 }
309
310 /**
311 * @tc.number : VIDEO_ENCODE_CAPABILITY_5000
312 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
313 * @tc.desc : api test
314 */
315 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_5000, TestSize.Level2)
316 {
317 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
318 if (cap) {
319 OH_AVErrCode ret = AV_ERR_OK;
320 OH_AVRange range;
321 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
322 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
323 ASSERT_NE(nullptr, capability);
324 ret = OH_AVCapability_GetVideoHeightRange(capability, &range);
325 ASSERT_EQ(AV_ERR_OK, ret);
326 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
327 ASSERT_GE(range.minVal, 0);
328 ASSERT_GT(range.maxVal, 0);
329 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
330 ASSERT_NE(nullptr, venc_);
331 format = OH_AVFormat_Create();
332 ASSERT_NE(nullptr, format);
333 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
334 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
335 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
336 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
337 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
338 OH_VideoEncoder_Destroy(venc_);
339 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
340 ASSERT_NE(nullptr, venc_);
341 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
342 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
343 } else {
344 return;
345 }
346 }
347 /**
348 * @tc.number : VIDEO_ENCODE_CAPABILITY_5010
349 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
350 * @tc.desc : api test
351 */
352 HWTEST_F(HwEncConfigureNdkTest, VIDEO_ENCODE_CAPABILITY_5010, TestSize.Level2)
353 {
354 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
355 if (cap) {
356 OH_AVErrCode ret = AV_ERR_OK;
357 OH_AVRange range;
358 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
359 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
360 ASSERT_NE(nullptr, capability);
361 ret = OH_AVCapability_GetVideoHeightRange(capability, &range);
362 ASSERT_EQ(AV_ERR_OK, ret);
363 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
364 ASSERT_GE(range.minVal, 0);
365 ASSERT_GT(range.maxVal, 0);
366 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
367 ASSERT_NE(nullptr, venc_);
368 format = OH_AVFormat_Create();
369 ASSERT_NE(nullptr, format);
370 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
371 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
372 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
373 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
374 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
375 OH_VideoEncoder_Destroy(venc_);
376 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
377 ASSERT_NE(nullptr, venc_);
378 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
379 EXPECT_NE(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
380 } else {
381 return;
382 }
383 }
384 }