1 /*
2 * Copyright (C) 2023 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 "videoenc_sample.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 *venc_ = NULL;
31 constexpr uint32_t DEFAULT_WIDTH = 1920;
32 constexpr uint32_t DEFAULT_HEIGHT = 1080;
33 constexpr uint32_t CODEC_NAME_SIZE = 128;
34 char g_codecName[CODEC_NAME_SIZE] = {};
35 OH_AVCapability *cap = nullptr;
36 OHOS::Media::VEncSignal *signal_ = nullptr;
37 OH_AVFormat *format;
onError(OH_AVCodec *codec, int32_t errorCode, void *userData)38 void onError(OH_AVCodec *codec, int32_t errorCode, void *userData)
39 {
40 cout << "Error errorCode=" << errorCode << endl;
41 };
42
onStreamChanged(OH_AVCodec *codec, OH_AVFormat *fmt, void *userData)43 void onStreamChanged(OH_AVCodec *codec, OH_AVFormat *fmt, void *userData)
44 {
45 cout << "stream Changed" << endl;
46 };
47
onNeedInputData(OH_AVCodec *codec, uint32_t index, OH_AVMemory *data, void *userData)48 void onNeedInputData(OH_AVCodec *codec, uint32_t index, OH_AVMemory *data, void *userData)
49 {
50 VEncSignal *signal = static_cast<VEncSignal *>(userData);
51 if (signal == nullptr) {
52 return;
53 }
54 unique_lock<mutex> lock(signal->inMutex_);
55 signal->inIdxQueue_.push(index);
56 signal->inBufferQueue_.push(data);
57 signal->inCond_.notify_all();
58 cout << "need input data" << endl;
59 };
60
onNewOutputData(OH_AVCodec *codec, uint32_t index, OH_AVMemory *data, OH_AVCodecBufferAttr *attr, void *userData)61 void onNewOutputData(OH_AVCodec *codec, uint32_t index, OH_AVMemory *data, OH_AVCodecBufferAttr *attr, void *userData)
62 {
63 cout << "output data" << endl;
64 VEncSignal *signal = static_cast<VEncSignal *>(userData);
65 if (signal == nullptr) {
66 return;
67 }
68 unique_lock<mutex> lock(signal->outMutex_);
69 signal->outIdxQueue_.push(index);
70 signal->attrQueue_.push(*attr);
71 signal->outBufferQueue_.push(data);
72 signal->outCond_.notify_all();
73 };
74 } // namespace
75
76 namespace OHOS {
77 namespace Media {
78 class HwEncApiNdkTest : public testing::Test {
79 public:
80 // SetUpTestCase: Called before all test cases
81 static void SetUpTestCase(void);
82 // TearDownTestCase: Called after all test case
83 static void TearDownTestCase(void);
84 // SetUp: Called before each test cases
85 void SetUp(void);
86 // TearDown: Called after each test cases
87 void TearDown(void);
88 };
89
SetUpTestCase()90 void HwEncApiNdkTest::SetUpTestCase()
91 {
92 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
93 const char *TMP_CODEC_NAME = OH_AVCapability_GetName(cap);
94 if (memcpy_s(g_codecName, sizeof(g_codecName), TMP_CODEC_NAME, strlen(TMP_CODEC_NAME)) != 0) {
95 cout << "memcpy failed" << endl;
96 }
97 cout << "codecname: " << g_codecName << endl;
98 }
TearDownTestCase()99 void HwEncApiNdkTest::TearDownTestCase() {}
SetUp()100 void HwEncApiNdkTest::SetUp()
101 {
102 signal_ = new VEncSignal();
103 }
TearDown()104 void HwEncApiNdkTest::TearDown()
105 {
106 if (format != nullptr) {
107 OH_AVFormat_Destroy(format);
108 format = nullptr;
109 }
110 if (venc_ != NULL) {
111 OH_VideoEncoder_Destroy(venc_);
112 venc_ = nullptr;
113 }
114 if (signal_) {
115 delete signal_;
116 signal_ = nullptr;
117 }
118 }
119 } // namespace Media
120 } // namespace OHOS
121
122 namespace {
123 /**
124 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0100
125 * @tc.name : OH_VideoEncoder_CreateByMime para1 error
126 * @tc.desc : api test
127 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0100, TestSize.Level2)128 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0100, TestSize.Level2)
129 {
130 venc_ = OH_VideoEncoder_CreateByMime(nullptr);
131 ASSERT_EQ(nullptr, venc_);
132 }
133
134 /**
135 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0200
136 * @tc.name : OH_VideoEncoder_CreateByMime para2 error
137 * @tc.desc : api test
138 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0200, TestSize.Level2)139 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0200, TestSize.Level2)
140 {
141 venc_ = OH_VideoEncoder_CreateByMime("");
142 ASSERT_EQ(nullptr, venc_);
143 }
144
145 /**
146 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0300
147 * @tc.name : OH_VideoEncoder_CreateByMime para error
148 * @tc.desc : api test
149 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0300, TestSize.Level2)150 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0300, TestSize.Level2)
151 {
152 venc_ = OH_VideoEncoder_CreateByName(nullptr);
153 ASSERT_EQ(nullptr, venc_);
154 }
155
156 /**
157 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0400
158 * @tc.name : OH_VideoEncoder_CreateByMime para error
159 * @tc.desc : api test
160 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0400, TestSize.Level2)161 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0400, TestSize.Level2)
162 {
163 venc_ = OH_VideoEncoder_CreateByName("");
164 ASSERT_EQ(nullptr, venc_);
165 }
166
167 /**
168 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0500
169 * @tc.name : OH_VideoEncoder_CreateByMime para error
170 * @tc.desc : api test
171 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0500, TestSize.Level2)172 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0500, TestSize.Level2)
173 {
174 OH_AVErrCode ret = AV_ERR_OK;
175 ret = OH_VideoEncoder_Destroy(nullptr);
176 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
177 }
178
179 /**
180 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0600
181 * @tc.name : OH_VideoEncoder_SetCallback para error
182 * @tc.desc : api test
183 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0600, TestSize.Level2)184 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0600, TestSize.Level2)
185 {
186 OH_AVCodecAsyncCallback cb_;
187 cb_.onError = onError;
188 cb_.onStreamChanged = onStreamChanged;
189 cb_.onNeedInputData = onNeedInputData;
190 cb_.onNeedOutputData = onNewOutputData;
191
192 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_SetCallback(NULL, cb_, static_cast<void *>(signal_)));
193 }
194
195 /**
196 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0700
197 * @tc.name : OH_VideoEncoder_SetCallback para error
198 * @tc.desc : api test
199 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0700, TestSize.Level2)200 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0700, TestSize.Level2)
201 {
202 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
203 ASSERT_NE(NULL, venc_);
204
205 OH_AVCodecAsyncCallback cb2_;
206 cb2_.onError = NULL;
207 cb2_.onStreamChanged = NULL;
208 cb2_.onNeedInputData = NULL;
209 cb2_.onNeedOutputData = NULL;
210 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_SetCallback(venc_, cb2_, static_cast<void *>(signal_)));
211 }
212
213 /**
214 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0800
215 * @tc.name : OH_VideoEncoder_SetCallback para error
216 * @tc.desc : api test
217 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0800, TestSize.Level2)218 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0800, TestSize.Level2)
219 {
220 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
221 OH_AVCodecAsyncCallback cb_;
222 cb_.onError = onError;
223 cb_.onStreamChanged = onStreamChanged;
224 cb_.onNeedInputData = onNeedInputData;
225 cb_.onNeedOutputData = onNewOutputData;
226 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_SetCallback(venc_, cb_, NULL));
227 }
228
229 /**
230 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0900
231 * @tc.name : OH_VideoEncoder_Configure para error
232 * @tc.desc : api test
233 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0900, TestSize.Level2)234 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0900, TestSize.Level2)
235 {
236 OH_AVErrCode ret = AV_ERR_OK;
237 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
238 ASSERT_NE(nullptr, venc_);
239 ret = OH_VideoEncoder_Configure(venc_, nullptr);
240 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
241 }
242
243 /**
244 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1100
245 * @tc.name : OH_VideoEncoder_Configure para not enough
246 * @tc.desc : api test
247 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1100, TestSize.Level2)248 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1100, TestSize.Level2)
249 {
250 OH_AVErrCode ret = AV_ERR_OK;
251 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
252 ASSERT_NE(nullptr, venc_);
253 format = OH_AVFormat_Create();
254 ASSERT_NE(nullptr, format);
255 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITRATE, 100000);
256 ret = OH_VideoEncoder_Configure(venc_, format);
257 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
258 }
259
260 /**
261 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1400
262 * @tc.name : OH_VideoEncoder_Start para error
263 * @tc.desc : api test
264 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1400, TestSize.Level2)265 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1400, TestSize.Level2)
266 {
267 OH_AVErrCode ret = AV_ERR_OK;
268 ret = OH_VideoEncoder_Start(nullptr);
269 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
270 }
271
272 /**
273 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1500
274 * @tc.name : OH_VideoEncoder_Stop para error
275 * @tc.desc : api test
276 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1500, TestSize.Level2)277 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1500, TestSize.Level2)
278 {
279 OH_AVErrCode ret = AV_ERR_OK;
280 ret = OH_VideoEncoder_Stop(nullptr);
281 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
282 }
283
284 /**
285 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1600
286 * @tc.name : OH_VideoEncoder_Flush para error
287 * @tc.desc : api test
288 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1600, TestSize.Level2)289 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1600, TestSize.Level2)
290 {
291 OH_AVErrCode ret = AV_ERR_OK;
292 ret = OH_VideoEncoder_Flush(nullptr);
293 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
294 }
295
296 /**
297 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1700
298 * @tc.name : OH_VideoEncoder_Reset para error
299 * @tc.desc : api test
300 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1700, TestSize.Level2)301 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1700, TestSize.Level2)
302 {
303 OH_AVErrCode ret = AV_ERR_OK;
304 ret = OH_VideoEncoder_Reset(nullptr);
305 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
306 }
307
308 /**
309 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1800
310 * @tc.name : OH_VideoEncoder_Reset para error
311 * @tc.desc : api test
312 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1800, TestSize.Level2)313 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1800, TestSize.Level2)
314 {
315 format = OH_VideoEncoder_GetOutputDescription(nullptr);
316 ASSERT_EQ(format, nullptr);
317 }
318
319 /**
320 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1900
321 * @tc.name : OH_VideoEncoder_SetParameter para error
322 * @tc.desc : api test
323 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1900, TestSize.Level2)324 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1900, TestSize.Level2)
325 {
326 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
327 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_SetParameter(venc_, nullptr));
328 }
329
330 /**
331 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2000
332 * @tc.name : OH_VideoEncoder_SetParameter para error
333 * @tc.desc : api test
334 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2000, TestSize.Level2)335 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2000, TestSize.Level2)
336 {
337 format = OH_AVFormat_Create();
338 ASSERT_NE(NULL, format);
339 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
340 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_SetParameter(NULL, format));
341 }
342
343 /**
344 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2100
345 * @tc.name : OH_VideoEncoder_GetSurface para error
346 * @tc.desc : api test
347 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2100, TestSize.Level2)348 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2100, TestSize.Level2)
349 {
350 OH_AVErrCode ret = AV_ERR_OK;
351 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
352 ASSERT_NE(nullptr, venc_);
353 ret = OH_VideoEncoder_GetSurface(venc_, nullptr);
354 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
355 }
356
357 /**
358 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2200
359 * @tc.name : OH_VideoEncoder_FreeOutputData para error
360 * @tc.desc : api test
361 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2200, TestSize.Level2)362 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2200, TestSize.Level2)
363 {
364 OH_AVErrCode ret = AV_ERR_OK;
365 ret = OH_VideoEncoder_FreeOutputData(nullptr, 0);
366 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
367 }
368
369 /**
370 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2300
371 * @tc.name : OH_VideoEncoder_FreeOutputData para error
372 * @tc.desc : api test
373 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2300, TestSize.Level2)374 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2300, TestSize.Level2)
375 {
376 OH_AVErrCode ret = AV_ERR_OK;
377 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
378 ASSERT_NE(nullptr, venc_);
379 format = OH_AVFormat_Create();
380 ASSERT_NE(nullptr, format);
381 OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
382 OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_HEIGHT);
383 OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
384
385 ret = OH_VideoEncoder_Configure(venc_, format);
386 ASSERT_EQ(ret, AV_ERR_OK);
387 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
388 usleep(1000000);
389 ret = OH_VideoEncoder_FreeOutputData(venc_, 9999999);
390 ASSERT_EQ(ret, AV_ERR_INVALID_STATE);
391 }
392
393 /**
394 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2400
395 * @tc.name : OH_VideoEncoder_NotifyEndOfStream para error
396 * @tc.desc : api test
397 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2400, TestSize.Level2)398 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2400, TestSize.Level2)
399 {
400 OH_AVErrCode ret = AV_ERR_OK;
401 ret = OH_VideoEncoder_NotifyEndOfStream(nullptr);
402 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
403 }
404 /**
405 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2500
406 * @tc.name : OH_VideoEncoder_NotifyEndOfStream para error
407 * @tc.desc : api test
408 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2500, TestSize.Level2)409 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2500, TestSize.Level2)
410 {
411 OH_AVErrCode ret = AV_ERR_OK;
412 ret = OH_VideoEncoder_NotifyEndOfStream(nullptr);
413 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
414 }
415
416 /**
417 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2600
418 * @tc.name : OH_VideoEncoder_PushInputData para error
419 * @tc.desc : api test
420 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2600, TestSize.Level2)421 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2600, TestSize.Level2)
422 {
423 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
424 ASSERT_NE(nullptr, venc_);
425 OH_AVCodecBufferAttr attr;
426 attr.pts = -1;
427 attr.size = -1;
428 attr.offset = 0;
429 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
430
431 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_PushInputData(venc_, 0, attr));
432 }
433
434 /**
435 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2700
436 * @tc.name : OH_VideoEncoder_PushInputData para error
437 * @tc.desc : api test
438 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2700, TestSize.Level2)439 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2700, TestSize.Level2)
440 {
441 OH_AVCodecBufferAttr attr;
442 attr.pts = 0;
443 attr.size = 0;
444 attr.offset = 0;
445 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
446 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_PushInputData(NULL, 0, attr));
447 }
448
449 /**
450 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2800
451 * @tc.name : OH_VideoEncoder_PushInputData para error
452 * @tc.desc : api test
453 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2800, TestSize.Level2)454 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2800, TestSize.Level2)
455 {
456 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
457 ASSERT_NE(nullptr, venc_);
458 OH_AVCodecBufferAttr attr;
459 attr.pts = 0;
460 attr.size = 0;
461 attr.offset = 0;
462 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
463 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_PushInputData(NULL, 99999, attr));
464 }
465
466 /**
467 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2900
468 * @tc.name : OH_VideoEncoder_GetInputDescription para error
469 * * @tc.desc : api test
470 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2900, TestSize.Level2)471 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2900, TestSize.Level2)
472 {
473 ASSERT_EQ(nullptr, OH_VideoEncoder_GetInputDescription(nullptr));
474 }
475
476 /**
477 * @tc.number : VIDEO_ENCODE_API_0100
478 * @tc.name : create create
479 * @tc.desc : function test
480 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0100, TestSize.Level2)481 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0100, TestSize.Level2)
482 {
483 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
484 ASSERT_NE(venc_, NULL);
485 OH_AVCodec *venc_2 = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
486 ASSERT_NE(venc_2, NULL);
487 OH_VideoEncoder_Destroy(venc_2);
488 venc_2 = nullptr;
489 }
490
491 /**
492 * @tc.number : VIDEO_ENCODE_API_3100
493 * @tc.name : create create
494 * @tc.desc : function test
495 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_3100, TestSize.Level2)496 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_3100, TestSize.Level2)
497 {
498 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
499 ASSERT_NE(venc_, NULL);
500 OH_AVCodec *venc_2 = OH_VideoEncoder_CreateByName(g_codecName);
501 ASSERT_NE(venc_2, NULL);
502 OH_VideoEncoder_Destroy(venc_2);
503 venc_2 = nullptr;
504 }
505
506 /**
507 * @tc.number : VIDEO_ENCODE_API_0200
508 * @tc.name : create configure configure
509 * @tc.desc : function test
510 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0200, TestSize.Level2)511 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0200, TestSize.Level2)
512 {
513 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
514 ASSERT_NE(NULL, venc_);
515
516 format = OH_AVFormat_Create();
517 ASSERT_NE(NULL, format);
518
519 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
520 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
521 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
522
523 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
524 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_Configure(venc_, format));
525 }
526
527 /**
528 * @tc.number : VIDEO_ENCODE_API_0300
529 * @tc.name : create configure start start
530 * @tc.desc : function test
531 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0300, TestSize.Level2)532 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0300, TestSize.Level2)
533 {
534 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
535 ASSERT_NE(NULL, venc_);
536
537 format = OH_AVFormat_Create();
538 ASSERT_NE(NULL, format);
539
540 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
541 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
542 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
543 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
544 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
545 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_Start(venc_));
546 }
547
548 /**
549 * @tc.number : VIDEO_ENCODE_API_0400
550 * @tc.name : create configure start stop stop
551 * @tc.desc : function test
552 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0400, TestSize.Level2)553 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0400, TestSize.Level2)
554 {
555 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
556 ASSERT_NE(NULL, venc_);
557
558 format = OH_AVFormat_Create();
559 ASSERT_NE(NULL, format);
560
561 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
562 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
563 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
564
565 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
566 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
567 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Stop(venc_));
568 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_Stop(venc_));
569 }
570
571 /**
572 * @tc.number : VIDEO_ENCODE_API_0500
573 * @tc.name : create configure start stop reset reset
574 * @tc.desc : function test
575 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0500, TestSize.Level2)576 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0500, TestSize.Level2)
577 {
578 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
579 ASSERT_NE(NULL, venc_);
580
581 format = OH_AVFormat_Create();
582 ASSERT_NE(NULL, format);
583 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
584 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
585 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
586
587 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
588 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
589 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Stop(venc_));
590 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Reset(venc_));
591 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Reset(venc_));
592 }
593
594 /**
595 * @tc.number : VIDEO_ENCODE_API_0600
596 * @tc.name : create configure start EOS EOS
597 * @tc.desc : function test
598 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0600, TestSize.Level2)599 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0600, TestSize.Level2)
600 {
601 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
602 ASSERT_NE(NULL, venc_);
603 format = OH_AVFormat_Create();
604 ASSERT_NE(NULL, format);
605 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
606 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
607 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
608 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
609 OH_AVCodecAsyncCallback cb_;
610 cb_.onError = onError;
611 cb_.onStreamChanged = onStreamChanged;
612 cb_.onNeedInputData = onNeedInputData;
613 cb_.onNeedOutputData = onNewOutputData;
614 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_SetCallback(venc_, cb_, static_cast<void *>(signal_)));
615
616 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
617 unique_lock<mutex> lock(signal_->inMutex_);
618 signal_->inCond_.wait(lock, [] { return signal_->inIdxQueue_.size() > 1; });
619 uint32_t index = signal_->inIdxQueue_.front();
620 OH_AVCodecBufferAttr attr;
621 attr.pts = 0;
622 attr.size = 0;
623 attr.offset = 0;
624 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
625
626 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_PushInputData(venc_, index, attr));
627 signal_->inIdxQueue_.pop();
628 index = signal_->inIdxQueue_.front();
629 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_PushInputData(venc_, index, attr));
630 signal_->inIdxQueue_.pop();
631 }
632
633 /**
634 * @tc.number : VIDEO_ENCODE_API_0700
635 * @tc.name : create configure start flush flush
636 * @tc.desc : function test
637 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0700, TestSize.Level2)638 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0700, TestSize.Level2)
639 {
640 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
641 ASSERT_NE(NULL, venc_);
642 format = OH_AVFormat_Create();
643 ASSERT_NE(NULL, format);
644 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
645 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
646 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
647 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
648 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
649 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Flush(venc_));
650 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_Flush(venc_));
651 }
652
653 /**
654 * @tc.number : VIDEO_ENCODE_API_0800
655 * @tc.name : create configure start stop release release
656 * @tc.desc : function test
657 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0800, TestSize.Level2)658 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0800, TestSize.Level2)
659 {
660 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
661 ASSERT_NE(NULL, venc_);
662
663 format = OH_AVFormat_Create();
664 ASSERT_NE(NULL, format);
665
666 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
667 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
668 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
669
670 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
671 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
672 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Stop(venc_));
673 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Destroy(venc_));
674 venc_ = nullptr;
675 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Destroy(venc_));
676 }
677
678 /**
679 * @tc.number : VIDEO_ENCODE_API_0900
680 * @tc.name : create create
681 * @tc.desc : function test
682 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0900, TestSize.Level2)683 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0900, TestSize.Level2)
684 {
685 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
686 ASSERT_NE(venc_, NULL);
687 OH_AVCodec *venc_2 = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
688 ASSERT_NE(venc_2, NULL);
689 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Destroy(venc_2));
690 venc_2 = nullptr;
691 }
692
693 /**
694 * @tc.number : VIDEO_ENCODE_API_1000
695 * @tc.name : repeat OH_VideoEncoder_SetCallback
696 * @tc.desc : function test
697 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1000, TestSize.Level2)698 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1000, TestSize.Level2)
699 {
700 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
701 ASSERT_NE(venc_, NULL);
702 OH_AVCodecAsyncCallback cb_;
703 cb_.onError = onError;
704 cb_.onStreamChanged = onStreamChanged;
705 cb_.onNeedInputData = onNeedInputData;
706 cb_.onNeedOutputData = onNewOutputData;
707 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_SetCallback(venc_, cb_, NULL));
708 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_SetCallback(venc_, cb_, NULL));
709 }
710
711 /**
712 * @tc.number : VIDEO_ENCODE_API_1100
713 * @tc.name : repeat OH_VideoEncoder_GetOutputDescription
714 * @tc.desc : function test
715 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1100, TestSize.Level2)716 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1100, TestSize.Level2)
717 {
718 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
719 ASSERT_NE(venc_, NULL);
720 format = OH_VideoEncoder_GetOutputDescription(venc_);
721 ASSERT_NE(NULL, format);
722 OH_AVFormat_Destroy(format);
723 format = OH_VideoEncoder_GetOutputDescription(venc_);
724 ASSERT_NE(NULL, format);
725 }
726
727 /**
728 * @tc.number : VIDEO_ENCODE_API_1200
729 * @tc.name : repeat OH_VideoEncoder_SetParameter
730 * @tc.desc : function test
731 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1200, TestSize.Level2)732 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1200, TestSize.Level2)
733 {
734 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
735 ASSERT_NE(NULL, venc_);
736
737 format = OH_AVFormat_Create();
738 ASSERT_NE(NULL, format);
739
740 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
741 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
742 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
743
744 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_SetParameter(venc_, format));
745 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_SetParameter(venc_, format));
746 }
747
748 /**
749 * @tc.number : VIDEO_ENCODE_API_1200
750 * @tc.name : repeat OH_VideoEncoder_GetInputDescription
751 * @tc.desc : function test
752 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1300, TestSize.Level2)753 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1300, TestSize.Level2)
754 {
755 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
756 ASSERT_NE(NULL, venc_);
757 format = OH_VideoEncoder_GetInputDescription(venc_);
758 ASSERT_NE(NULL, format);
759 OH_AVFormat_Destroy(format);
760 format = OH_VideoEncoder_GetInputDescription(venc_);
761 ASSERT_NE(NULL, format);
762 }
763
764 /**
765 * @tc.number : VIDEO_ENCODE_API_1400
766 * @tc.name : set quality with illegal value
767 * @tc.desc : function test
768 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1400, TestSize.Level2)769 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1400, TestSize.Level2)
770 {
771 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
772 ASSERT_NE(nullptr, venc_);
773 format = OH_AVFormat_Create();
774 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, CQ));
775 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_QUALITY, 101));
776 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
777 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
778 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
779 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
780 }
781
782 /**
783 * @tc.number : VIDEO_ENCODE_API_1410
784 * @tc.name : set quality with illegal value
785 * @tc.desc : function test
786 */
HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1410, TestSize.Level2)787 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1410, TestSize.Level2)
788 {
789 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
790 ASSERT_NE(nullptr, venc_);
791 format = OH_AVFormat_Create();
792 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, CQ));
793 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_QUALITY, -1));
794 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
795 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
796 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
797 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
798 }
799 } // namespace