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 "avcodec_common.h"
21 #include "meta/format.h"
22 #include "avcodec_video_encoder.h"
23 #include "videoenc_inner_sample.h"
24 #include "native_avcapability.h"
25
26 using namespace std;
27 using namespace OHOS;
28 using namespace OHOS::MediaAVCodec;
29 using namespace testing::ext;
30
31 namespace {
32 class HwEncInnerApiNdkTest : public testing::Test {
33 public:
34 // SetUpTestCase: Called before all test cases
35 static void SetUpTestCase(void);
36 // TearDownTestCase: Called after all test case
37 static void TearDownTestCase(void);
38 // SetUp: Called before each test cases
39 void SetUp() override;
40 // TearDown: Called after each test cases
41 void TearDown() override;
42 };
43
44 constexpr uint32_t DEFAULT_WIDTH = 1920;
45 constexpr uint32_t DEFAULT_HEIGHT = 1080;
46 std::string g_codecMime = "video/avc";
47 std::string g_codecName = "";
48 OH_AVCapability *cap = nullptr;
49 std::shared_ptr<AVCodecVideoEncoder> venc_ = nullptr;
50 std::shared_ptr<VEncInnerSignal> signal_ = nullptr;
51
SetUpTestCase()52 void HwEncInnerApiNdkTest::SetUpTestCase()
53 {
54 cap = OH_AVCodec_GetCapabilityByCategory(g_codecMime.c_str(), true, HARDWARE);
55 const char *tmpCodecName = OH_AVCapability_GetName(cap);
56 g_codecName = tmpCodecName;
57 cout << "g_codecName: " << g_codecName << endl;
58 }
59
TearDownTestCase()60 void HwEncInnerApiNdkTest::TearDownTestCase() {}
61
SetUp()62 void HwEncInnerApiNdkTest::SetUp()
63 {
64 signal_ = make_shared<VEncInnerSignal>();
65 }
66
TearDown()67 void HwEncInnerApiNdkTest::TearDown()
68 {
69 if (venc_ != nullptr) {
70 venc_->Release();
71 venc_ = nullptr;
72 }
73
74 if (signal_) {
75 signal_ = nullptr;
76 }
77 }
78 } // namespace
79
80 namespace {
81 /**
82 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0100
83 * @tc.name : CreateByMime para1 error
84 * @tc.desc : param test
85 */
86 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0100, TestSize.Level2)
87 {
88 venc_ = VideoEncoderFactory::CreateByMime("");
89 ASSERT_EQ(nullptr, venc_);
90 }
91
92 /**
93 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0200
94 * @tc.name : CreateByMime para2 error
95 * @tc.desc : param test
96 */
97 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0200, TestSize.Level2)
98 {
99 venc_ = VideoEncoderFactory::CreateByMime("");
100 ASSERT_EQ(nullptr, venc_);
101 }
102
103 /**
104 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0300
105 * @tc.name : CreateByName para1 error
106 * @tc.desc : param test
107 */
108 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0300, TestSize.Level2)
109 {
110 venc_ = VideoEncoderFactory::CreateByName("");
111 ASSERT_EQ(nullptr, venc_);
112 }
113
114 /**
115 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0400
116 * @tc.name : CreateByName para2 error
117 * @tc.desc : param test
118 */
119 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0400, TestSize.Level2)
120 {
121 venc_ = VideoEncoderFactory::CreateByName("");
122 ASSERT_EQ(nullptr, venc_);
123 }
124
125 /**
126 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0500
127 * @tc.name : SetCallback para error
128 * @tc.desc : param test
129 */
130 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0500, TestSize.Level2)
131 {
132 venc_ = VideoEncoderFactory::CreateByMime(g_codecMime);
133 ASSERT_NE(nullptr, venc_);
134
135 std::shared_ptr<VEncInnerCallback> cb_ = make_shared<VEncInnerCallback>(nullptr);
136 int32_t ret = venc_->SetCallback(cb_);
137 ASSERT_EQ(AVCS_ERR_OK, ret);
138 }
139
140 /**
141 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0600
142 * @tc.name : Configure para not enough
143 * @tc.desc : param test
144 */
145 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0600, TestSize.Level2)
146 {
147 venc_ = VideoEncoderFactory::CreateByMime(g_codecMime);
148 ASSERT_NE(nullptr, venc_);
149
150 Format format;
151 format.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, 100000);
152 int32_t ret = venc_->Configure(format);
153 ASSERT_EQ(ret, AVCS_ERR_INVALID_VAL);
154 }
155
156 /**
157 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0700
158 * @tc.name : ReleaseOutputBuffer para error
159 * @tc.desc : param test
160 */
161 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0700, TestSize.Level2)
162 {
163 venc_ = VideoEncoderFactory::CreateByMime(g_codecMime);
164 ASSERT_NE(nullptr, venc_);
165
166 Format format;
167 format.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, 1080);
168 format.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, 1080);
169 format.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(VideoPixelFormat::YUVI420));
170
171 ASSERT_EQ(AVCS_ERR_OK, venc_->Configure(format));
172 ASSERT_EQ(AVCS_ERR_OK, venc_->Start());
173 usleep(1000000);
174 ASSERT_EQ(AVCS_ERR_INVALID_STATE, venc_->ReleaseOutputBuffer(9999999));
175 }
176
177 /**
178 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0800
179 * @tc.name : QueueInputBuffer para error
180 * @tc.desc : param test
181 */
182 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0800, TestSize.Level2)
183 {
184 venc_ = VideoEncoderFactory::CreateByMime(g_codecMime);
185 ASSERT_NE(nullptr, venc_);
186
187 AVCodecBufferInfo info;
188 info.presentationTimeUs = -1;
189 info.size = -1;
190 info.offset = 0;
191 AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_EOS;
192 ASSERT_EQ(AVCS_ERR_INVALID_STATE, venc_->QueueInputBuffer(0, info, flag));
193 }
194
195 /**
196 * @tc.number : VIDEO_ENCODE_API_0100
197 * @tc.name : CreateByName CreateByName
198 * @tc.desc : api test
199 */
200 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_API_0100, TestSize.Level2)
201 {
202 venc_ = VideoEncoderFactory::CreateByName(g_codecName);
203 ASSERT_NE(nullptr, venc_);
204
205 std::shared_ptr<AVCodecVideoEncoder> venc2_ = VideoEncoderFactory::CreateByName(g_codecName);
206 ASSERT_NE(nullptr, venc_);
207 ASSERT_EQ(AVCS_ERR_OK, venc2_->Release());
208 venc2_ = nullptr;
209 }
210
211 /**
212 * @tc.number : VIDEO_ENCODE_API_0200
213 * @tc.name : CreateByName configure configure
214 * @tc.desc : api test
215 */
216 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_API_0200, TestSize.Level2)
217 {
218 venc_ = VideoEncoderFactory::CreateByName(g_codecName);
219 ASSERT_NE(nullptr, venc_);
220
221 Format format;
222 format.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
223 format.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_HEIGHT);
224 format.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(VideoPixelFormat::NV12));
225
226 ASSERT_EQ(AVCS_ERR_OK, venc_->Configure(format));
227 ASSERT_EQ(AVCS_ERR_INVALID_STATE, venc_->Configure(format));
228 }
229
230 /**
231 * @tc.number : VIDEO_ENCODE_API_0300
232 * @tc.name : CreateByName configure start start
233 * @tc.desc : api test
234 */
235 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_API_0300, TestSize.Level2)
236 {
237 venc_ = VideoEncoderFactory::CreateByName(g_codecName);
238 ASSERT_NE(nullptr, venc_);
239
240 Format format;
241 format.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
242 format.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_HEIGHT);
243 format.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(VideoPixelFormat::NV12));
244
245 ASSERT_EQ(AVCS_ERR_OK, venc_->Configure(format));
246 ASSERT_EQ(AVCS_ERR_OK, venc_->Start());
247 ASSERT_EQ(AVCS_ERR_INVALID_STATE, venc_->Start());
248 }
249
250 /**
251 * @tc.number : VIDEO_ENCODE_API_0400
252 * @tc.name : CreateByName configure start stop stop
253 * @tc.desc : api test
254 */
255 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_API_0400, TestSize.Level2)
256 {
257 venc_ = VideoEncoderFactory::CreateByName(g_codecName);
258 ASSERT_NE(nullptr, venc_);
259
260 Format format;
261 format.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
262 format.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_HEIGHT);
263 format.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(VideoPixelFormat::NV12));
264
265 ASSERT_EQ(AVCS_ERR_OK, venc_->Configure(format));
266 ASSERT_EQ(AVCS_ERR_OK, venc_->Start());
267 ASSERT_EQ(AVCS_ERR_OK, venc_->Stop());
268 ASSERT_EQ(AVCS_ERR_OK, venc_->Stop());
269 }
270
271 /**
272 * @tc.number : VIDEO_ENCODE_API_0500
273 * @tc.name : CreateByName configure start stop reset reset
274 * @tc.desc : api test
275 */
276 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_API_0500, TestSize.Level2)
277 {
278 venc_ = VideoEncoderFactory::CreateByName(g_codecName);
279 ASSERT_NE(nullptr, venc_);
280
281 Format format;
282 format.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
283 format.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_HEIGHT);
284 format.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(VideoPixelFormat::NV12));
285
286 ASSERT_EQ(AVCS_ERR_OK, venc_->Configure(format));
287 ASSERT_EQ(AVCS_ERR_OK, venc_->Start());
288 ASSERT_EQ(AVCS_ERR_OK, venc_->Stop());
289 ASSERT_EQ(AVCS_ERR_OK, venc_->Reset());
290 ASSERT_EQ(AVCS_ERR_OK, venc_->Reset());
291 }
292
293 /**
294 * @tc.number : VIDEO_ENCODE_API_0600
295 * @tc.name : CreateByName configure start EOS EOS
296 * @tc.desc : api test
297 */
298 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_API_0600, TestSize.Level2)
299 {
300 venc_ = VideoEncoderFactory::CreateByName(g_codecName);
301 ASSERT_NE(nullptr, venc_);
302
303 Format format;
304 format.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
305 format.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_HEIGHT);
306 format.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(VideoPixelFormat::NV12));
307 ASSERT_EQ(AVCS_ERR_OK, venc_->Configure(format));
308
309 std::shared_ptr<VEncInnerCallback> cb_ = make_shared<VEncInnerCallback>(signal_);
310 ASSERT_EQ(AVCS_ERR_OK, venc_->SetCallback(cb_));
311 ASSERT_EQ(AVCS_ERR_OK, venc_->Start());
312
313 unique_lock<mutex> lock(signal_->inMutex_);
__anon7471254a0302null314 signal_->inCond_.wait(lock, [] { return signal_->inIdxQueue_.size() > 1; });
315 uint32_t index = signal_->inIdxQueue_.front();
316 AVCodecBufferInfo info;
317 info.presentationTimeUs = 0;
318 info.size = 0;
319 info.offset = 0;
320 AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_EOS;
321
322 ASSERT_EQ(AVCS_ERR_OK, venc_->QueueInputBuffer(index, info, flag));
323 signal_->inIdxQueue_.pop();
324 index = signal_->inIdxQueue_.front();
325 ASSERT_EQ(AVCS_ERR_INVALID_STATE, venc_->QueueInputBuffer(index, info, flag));
326 signal_->inIdxQueue_.pop();
327 }
328
329 /**
330 * @tc.number : VIDEO_ENCODE_API_0700
331 * @tc.name : CreateByName configure start flush flush
332 * @tc.desc : api test
333 */
334 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_API_0700, TestSize.Level2)
335 {
336 venc_ = VideoEncoderFactory::CreateByName(g_codecName);
337 ASSERT_NE(nullptr, venc_);
338
339 Format format;
340 format.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
341 format.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_HEIGHT);
342 format.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(VideoPixelFormat::NV12));
343
344 ASSERT_EQ(AVCS_ERR_OK, venc_->Configure(format));
345 ASSERT_EQ(AVCS_ERR_OK, venc_->Start());
346 ASSERT_EQ(AVCS_ERR_OK, venc_->Flush());
347 ASSERT_EQ(AVCS_ERR_OK, venc_->Flush());
348 }
349
350 /**
351 * @tc.number : VIDEO_ENCODE_API_0800
352 * @tc.name : CreateByName configure start stop release
353 * @tc.desc : api test
354 */
355 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_API_0800, TestSize.Level2)
356 {
357 venc_ = VideoEncoderFactory::CreateByName(g_codecName);
358 ASSERT_NE(nullptr, venc_);
359
360 Format format;
361 format.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
362 format.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_HEIGHT);
363 format.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(VideoPixelFormat::NV12));
364
365 ASSERT_EQ(AVCS_ERR_OK, venc_->Configure(format));
366 ASSERT_EQ(AVCS_ERR_OK, venc_->Start());
367 ASSERT_EQ(AVCS_ERR_OK, venc_->Stop());
368 ASSERT_EQ(AVCS_ERR_OK, venc_->Release());
369 venc_ = nullptr;
370 }
371
372 /**
373 * @tc.number : VIDEO_ENCODE_API_0900
374 * @tc.name : CreateByMime CreateByMime
375 * @tc.desc : api test
376 */
377 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_API_0900, TestSize.Level2)
378 {
379 venc_ = VideoEncoderFactory::CreateByMime(g_codecMime);
380 ASSERT_NE(nullptr, venc_);
381
382 std::shared_ptr<AVCodecVideoEncoder> venc2_ = VideoEncoderFactory::CreateByMime(g_codecMime);
383 ASSERT_NE(nullptr, venc_);
384
385 ASSERT_EQ(AVCS_ERR_OK, venc2_->Release());
386 venc2_ = nullptr;
387 }
388
389 /**
390 * @tc.number : VIDEO_ENCODE_API_1000
391 * @tc.name : repeat SetCallback
392 * @tc.desc : api test
393 */
394 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_API_1000, TestSize.Level2)
395 {
396 venc_ = VideoEncoderFactory::CreateByName(g_codecName);
397 ASSERT_NE(nullptr, venc_);
398
399 std::shared_ptr<VEncInnerCallback> cb_ = make_shared<VEncInnerCallback>(nullptr);
400 ASSERT_EQ(AVCS_ERR_OK, venc_->SetCallback(cb_));
401 ASSERT_EQ(AVCS_ERR_OK, venc_->SetCallback(cb_));
402 }
403
404 /**
405 * @tc.number : VIDEO_ENCODE_API_1100
406 * @tc.name : repeat GetOutputFormat
407 * @tc.desc : api test
408 */
409 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_API_1100, TestSize.Level2)
410 {
411 venc_ = VideoEncoderFactory::CreateByName(g_codecName);
412 ASSERT_NE(nullptr, venc_);
413
414 Format format;
415 ASSERT_EQ(AVCS_ERR_OK, venc_->GetOutputFormat(format));
416 ASSERT_EQ(AVCS_ERR_OK, venc_->GetOutputFormat(format));
417 }
418
419 /**
420 * @tc.number : VIDEO_ENCODE_API_1200
421 * @tc.name : repeat SetParameter
422 * @tc.desc : api test
423 */
424 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_API_1200, TestSize.Level2)
425 {
426 venc_ = VideoEncoderFactory::CreateByName(g_codecName);
427 ASSERT_NE(nullptr, venc_);
428
429 Format format;
430 format.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
431 format.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_HEIGHT);
432 format.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(VideoPixelFormat::NV12));
433
434 ASSERT_EQ(AVCS_ERR_INVALID_STATE, venc_->SetParameter(format));
435 ASSERT_EQ(AVCS_ERR_INVALID_STATE, venc_->SetParameter(format));
436 }
437
438 /**
439 * @tc.number : VIDEO_ENCODE_API_1300
440 * @tc.name : repeat GetInputFormat
441 * @tc.desc : api test
442 */
443 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_API_1300, TestSize.Level2)
444 {
445 venc_ = VideoEncoderFactory::CreateByName(g_codecName);
446 ASSERT_NE(nullptr, venc_);
447
448 Format format;
449 int32_t ret = venc_->GetInputFormat(format);
450 ASSERT_EQ(AVCS_ERR_OK, ret);
451
452 ret = venc_->GetInputFormat(format);
453 ASSERT_EQ(AVCS_ERR_OK, ret);
454 }
455
456 /**
457 * @tc.number : VIDEO_ENCODE_INNER_REPEAT_0100
458 * @tc.name : set frame after 0
459 * @tc.desc : api test
460 */
461 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_REPEAT_0100, TestSize.Level0)
462 {
463 if (cap != nullptr) {
464 auto vEncInnerSample = make_unique<VEncNdkInnerSample>();
465 vEncInnerSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
466 vEncInnerSample->DEFAULT_WIDTH = 1280;
467 vEncInnerSample->DEFAULT_HEIGHT = 720;
468 vEncInnerSample->DEFAULT_BITRATE_MODE = CBR;
469 vEncInnerSample->surfaceInput = true;
470 vEncInnerSample->enableRepeat = true;
471 vEncInnerSample->setMaxCount = true;
472 vEncInnerSample->DEFAULT_FRAME_AFTER = 0;
473 vEncInnerSample->DEFAULT_MAX_COUNT = -1;
474 ASSERT_EQ(AVCS_ERR_OK, vEncInnerSample->CreateByName(g_codecName));
475 ASSERT_EQ(AVCS_ERR_OK, vEncInnerSample->SetCallback());
476 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncInnerSample->Configure());
477 }
478 }
479
480 /**
481 * @tc.number : VIDEO_ENCODE_INNER_REPEAT_0200
482 * @tc.name : set frame after -1
483 * @tc.desc : api test
484 */
485 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_REPEAT_0200, TestSize.Level1)
486 {
487 if (cap != nullptr) {
488 auto vEncInnerSample = make_unique<VEncNdkInnerSample>();
489 vEncInnerSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
490 vEncInnerSample->DEFAULT_WIDTH = 1280;
491 vEncInnerSample->DEFAULT_HEIGHT = 720;
492 vEncInnerSample->DEFAULT_BITRATE_MODE = CBR;
493 vEncInnerSample->surfaceInput = true;
494 vEncInnerSample->enableRepeat = true;
495 vEncInnerSample->setMaxCount = true;
496 vEncInnerSample->DEFAULT_FRAME_AFTER = -1;
497 vEncInnerSample->DEFAULT_MAX_COUNT = -1;
498 ASSERT_EQ(AVCS_ERR_OK, vEncInnerSample->CreateByName(g_codecName));
499 ASSERT_EQ(AVCS_ERR_OK, vEncInnerSample->SetCallback());
500 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncInnerSample->Configure());
501 }
502 }
503
504 /**
505 * @tc.number : VIDEO_ENCODE_INNER_REPEAT_0300
506 * @tc.name : set max count 0
507 * @tc.desc : api test
508 */
509 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_REPEAT_0300, TestSize.Level1)
510 {
511 if (cap != nullptr) {
512 auto vEncInnerSample = make_unique<VEncNdkInnerSample>();
513 vEncInnerSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
514 vEncInnerSample->DEFAULT_WIDTH = 1280;
515 vEncInnerSample->DEFAULT_HEIGHT = 720;
516 vEncInnerSample->DEFAULT_BITRATE_MODE = CBR;
517 vEncInnerSample->surfaceInput = true;
518 vEncInnerSample->enableRepeat = true;
519 vEncInnerSample->setMaxCount = true;
520 vEncInnerSample->DEFAULT_FRAME_AFTER = 1;
521 vEncInnerSample->DEFAULT_MAX_COUNT = 0;
522 ASSERT_EQ(AVCS_ERR_OK, vEncInnerSample->CreateByName(g_codecName));
523 ASSERT_EQ(AVCS_ERR_OK, vEncInnerSample->SetCallback());
524 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncInnerSample->Configure());
525 }
526 }
527
528 /**
529 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0010
530 * @tc.name : set width of bufferConfig less than 0
531 * @tc.desc : api test
532 */
533 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0010, TestSize.Level1)
534 {
535 auto vEncSample = make_unique<VEncNdkInnerSample>();
536 BufferRequestConfig bufferConfig = {
537 .width = -1,
538 .height = 400,
539 .strideAlignment = 0x8,
540 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
541 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
542 .timeout = 0,
543 };
544 vEncSample->surfaceInput = true;
545 vEncSample->enableWaterMark = true;
546 vEncSample->videoCoordinateX = 100;
547 vEncSample->videoCoordinateY = 100;
548 vEncSample->videoCoordinateWidth = bufferConfig.width;
549 vEncSample->videoCoordinateHeight = bufferConfig.height;
550
551 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
552 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
553 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
554 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
555 }
556
557 /**
558 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0020
559 * @tc.name : set width of bufferConfig be equal to 0
560 * @tc.desc : api test
561 */
562 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0020, TestSize.Level1)
563 {
564 auto vEncSample = make_unique<VEncNdkInnerSample>();
565 BufferRequestConfig bufferConfig = {
566 .width = 0,
567 .height = 400,
568 .strideAlignment = 0x8,
569 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
570 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
571 .timeout = 0,
572 };
573 vEncSample->surfaceInput = true;
574
575 vEncSample->enableWaterMark = true;
576 vEncSample->videoCoordinateX = 100;
577 vEncSample->videoCoordinateY = 100;
578 vEncSample->videoCoordinateWidth = bufferConfig.width;
579 vEncSample->videoCoordinateHeight = bufferConfig.height;
580
581 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
582 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
583 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
584 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
585 }
586
587 /**
588 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0030
589 * @tc.name : set width of bufferConfig be greater than video width
590 * @tc.desc : api test
591 */
592 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0030, TestSize.Level1)
593 {
594 auto vEncSample = make_unique<VEncNdkInnerSample>();
595 BufferRequestConfig bufferConfig = {
596 .width = vEncSample->DEFAULT_WIDTH,
597 .height = 400,
598 .strideAlignment = 0x8,
599 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
600 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
601 .timeout = 0,
602 };
603 vEncSample->surfaceInput = true;
604 vEncSample->enableWaterMark = true;
605 vEncSample->videoCoordinateX = 100;
606 vEncSample->videoCoordinateY = 100;
607 vEncSample->videoCoordinateWidth = vEncSample->DEFAULT_WIDTH + 1;
608 vEncSample->videoCoordinateHeight = bufferConfig.height;
609
610 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
611 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
612 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
613 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
614 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
615 } else {
616 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
617 }
618 }
619
620 /**
621 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0040
622 * @tc.name : set height of bufferConfig less than 0
623 * @tc.desc : api test
624 */
625 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0040, TestSize.Level1)
626 {
627 auto vEncSample = make_unique<VEncNdkInnerSample>();
628 BufferRequestConfig bufferConfig = {
629 .width = 400,
630 .height = -1,
631 .strideAlignment = 0x8,
632 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
633 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
634 .timeout = 0,
635 };
636 vEncSample->surfaceInput = true;
637
638 vEncSample->enableWaterMark = true;
639 vEncSample->videoCoordinateX = 100;
640 vEncSample->videoCoordinateY = 100;
641 vEncSample->videoCoordinateWidth = bufferConfig.width;
642 vEncSample->videoCoordinateHeight = bufferConfig.height;
643
644 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
645 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
646 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
647 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
648 }
649
650 /**
651 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0050
652 * @tc.name : set height of bufferConfig be equal to 0
653 * @tc.desc : api test
654 */
655 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0050, TestSize.Level1)
656 {
657 auto vEncSample = make_unique<VEncNdkInnerSample>();
658 BufferRequestConfig bufferConfig = {
659 .width = 400,
660 .height = 0,
661 .strideAlignment = 0x8,
662 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
663 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
664 .timeout = 0,
665 };
666 vEncSample->surfaceInput = true;
667
668 vEncSample->enableWaterMark = true;
669 vEncSample->videoCoordinateX = 100;
670 vEncSample->videoCoordinateY = 100;
671 vEncSample->videoCoordinateWidth = bufferConfig.width;
672 vEncSample->videoCoordinateHeight = bufferConfig.height;
673
674 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
675 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
676 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
677 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
678 }
679
680 /**
681 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0060
682 * @tc.name : set height of bufferConfig be greater than video height
683 * @tc.desc : api test
684 */
685 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0060, TestSize.Level1)
686 {
687 auto vEncSample = make_unique<VEncNdkInnerSample>();
688 BufferRequestConfig bufferConfig = {
689 .width = 400,
690 .height = vEncSample->DEFAULT_HEIGHT,
691 .strideAlignment = 0x8,
692 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
693 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
694 .timeout = 0,
695 };
696 vEncSample->surfaceInput = true;
697
698 vEncSample->enableWaterMark = true;
699 vEncSample->videoCoordinateX = 100;
700 vEncSample->videoCoordinateY = 100;
701 vEncSample->videoCoordinateWidth = bufferConfig.width;
702 vEncSample->videoCoordinateHeight = vEncSample->DEFAULT_HEIGHT + 1;
703
704 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
705 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
706 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
707 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
708 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
709 } else {
710 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
711 }
712 }
713
714 /**
715 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0070
716 * @tc.name : set format of bufferConfig is GRAPHIC_PIXEL_FMT_YCBCR_420_P
717 * @tc.desc : api test
718 */
719 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0070, TestSize.Level1)
720 {
721 auto vEncSample = make_unique<VEncNdkInnerSample>();
722 BufferRequestConfig bufferConfig = {
723 .width = 400,
724 .height = 400,
725 .strideAlignment = 0x8,
726 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCBCR_420_P,
727 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
728 .timeout = 0,
729 };
730 vEncSample->surfaceInput = true;
731
732 vEncSample->enableWaterMark = true;
733 vEncSample->videoCoordinateX = 100;
734 vEncSample->videoCoordinateY = 100;
735 vEncSample->videoCoordinateWidth = bufferConfig.width;
736 vEncSample->videoCoordinateHeight = bufferConfig.height;
737
738 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
739 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
740 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
741 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
742 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
743 } else {
744 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
745 }
746 }
747
748 /**
749 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0080
750 * @tc.name : set format of bufferConfig is GRAPHIC_PIXEL_FMT_YCBCR_420_SP
751 * @tc.desc : api test
752 */
753 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0080, TestSize.Level1)
754 {
755 auto vEncSample = make_unique<VEncNdkInnerSample>();
756 BufferRequestConfig bufferConfig = {
757 .width = 400,
758 .height = 400,
759 .strideAlignment = 0x8,
760 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCBCR_420_SP,
761 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
762 .timeout = 0,
763 };
764 vEncSample->surfaceInput = true;
765
766 vEncSample->enableWaterMark = true;
767 vEncSample->videoCoordinateX = 100;
768 vEncSample->videoCoordinateY = 100;
769 vEncSample->videoCoordinateWidth = bufferConfig.width;
770 vEncSample->videoCoordinateHeight = bufferConfig.height;
771
772 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
773 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
774 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
775 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
776 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
777 } else {
778 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
779 }
780 }
781
782 /**
783 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0090
784 * @tc.name : set format of bufferConfig is GRAPHIC_PIXEL_FMT_YCRCB_420_SP
785 * @tc.desc : api test
786 */
787 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0090, TestSize.Level1)
788 {
789 auto vEncSample = make_unique<VEncNdkInnerSample>();
790 BufferRequestConfig bufferConfig = {
791 .width = 400,
792 .height = 400,
793 .strideAlignment = 0x8,
794 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCRCB_420_SP,
795 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
796 .timeout = 0,
797 };
798 vEncSample->surfaceInput = true;
799
800 vEncSample->enableWaterMark = true;
801 vEncSample->videoCoordinateX = 100;
802 vEncSample->videoCoordinateY = 100;
803 vEncSample->videoCoordinateWidth = bufferConfig.width;
804 vEncSample->videoCoordinateHeight = bufferConfig.height;
805
806 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
807 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
808 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
809 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
810 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
811 } else {
812 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
813 }
814 }
815
816 /**
817 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0100
818 * @tc.name : set format of bufferConfig is GRAPHIC_PIXEL_FMT_BUTT
819 * @tc.desc : api test
820 */
821 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0100, TestSize.Level1)
822 {
823 auto vEncSample = make_unique<VEncNdkInnerSample>();
824 BufferRequestConfig bufferConfig = {
825 .width = 400,
826 .height = 400,
827 .strideAlignment = 0x8,
828 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_BUTT,
829 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
830 .timeout = 0,
831 };
832 vEncSample->surfaceInput = true;
833 vEncSample->enableWaterMark = true;
834 vEncSample->videoCoordinateX = 100;
835 vEncSample->videoCoordinateY = 100;
836 vEncSample->videoCoordinateWidth = bufferConfig.width;
837 vEncSample->videoCoordinateHeight = bufferConfig.height;
838
839 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
840 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
841 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
842 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
843 }
844
845 /**
846 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0110
847 * @tc.name : set VIDEO_COORDINATE_X of format less than 0
848 * @tc.desc : api test
849 */
850 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0110, TestSize.Level1)
851 {
852 auto vEncSample = make_unique<VEncNdkInnerSample>();
853 BufferRequestConfig bufferConfig = {
854 .width = 400,
855 .height = 400,
856 .strideAlignment = 0x8,
857 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
858 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
859 .timeout = 0,
860 };
861 vEncSample->surfaceInput = true;
862 vEncSample->enableWaterMark = true;
863 vEncSample->videoCoordinateX = -1;
864 vEncSample->videoCoordinateY = 100;
865 vEncSample->videoCoordinateWidth = bufferConfig.width;
866 vEncSample->videoCoordinateHeight = bufferConfig.height;
867
868 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
869 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
870 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
871 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
872 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
873 } else {
874 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
875 }
876 }
877
878 /**
879 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0120
880 * @tc.name : set VIDEO_COORDINATE_X of format greater than video width
881 * @tc.desc : api test
882 */
883 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0120, TestSize.Level1)
884 {
885 auto vEncSample = make_unique<VEncNdkInnerSample>();
886 BufferRequestConfig bufferConfig = {
887 .width = 400,
888 .height = 400,
889 .strideAlignment = 0x8,
890 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
891 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
892 .timeout = 0,
893 };
894 vEncSample->surfaceInput = true;
895 vEncSample->enableWaterMark = true;
896 vEncSample->videoCoordinateX = vEncSample->DEFAULT_WIDTH + 1;
897 vEncSample->videoCoordinateY = 100;
898 vEncSample->videoCoordinateWidth = bufferConfig.width;
899 vEncSample->videoCoordinateHeight = bufferConfig.height;
900 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
901 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
902 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
903 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
904 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
905 } else {
906 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
907 }
908 }
909
910 /**
911 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0130
912 * @tc.name : set VIDEO_COORDINATE_X of format add waterMark width greater than video width
913 * @tc.desc : api test
914 */
915 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0130, TestSize.Level1)
916 {
917 auto vEncSample = make_unique<VEncNdkInnerSample>();
918 BufferRequestConfig bufferConfig = {
919 .width = 400,
920 .height = 400,
921 .strideAlignment = 0x8,
922 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
923 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
924 .timeout = 0,
925 };
926 vEncSample->surfaceInput = true;
927 vEncSample->enableWaterMark = true;
928 vEncSample->videoCoordinateX = 100;
929 vEncSample->videoCoordinateY = vEncSample->DEFAULT_HEIGHT - 100;
930 vEncSample->videoCoordinateWidth = bufferConfig.width;
931 vEncSample->videoCoordinateHeight = bufferConfig.height;
932
933 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
934 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
935 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
936 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
937 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
938 } else {
939 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
940 }
941 }
942
943 /**
944 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0140
945 * @tc.name : set VIDEO_COORDINATE_Y of format less than 0
946 * @tc.desc : api test
947 */
948 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0140, TestSize.Level1)
949 {
950 auto vEncSample = make_unique<VEncNdkInnerSample>();
951 BufferRequestConfig bufferConfig = {
952 .width = 400,
953 .height = 400,
954 .strideAlignment = 0x8,
955 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
956 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
957 .timeout = 0,
958 };
959 vEncSample->surfaceInput = true;
960 vEncSample->enableWaterMark = true;
961 vEncSample->videoCoordinateX = 100;
962 vEncSample->videoCoordinateY = -1;
963 vEncSample->videoCoordinateWidth = bufferConfig.width;
964 vEncSample->videoCoordinateHeight = bufferConfig.height;
965
966 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
967 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
968 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
969 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
970 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
971 } else {
972 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
973 }
974 }
975
976 /**
977 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0150
978 * @tc.name : set VIDEO_COORDINATE_Y of format greater than video height
979 * @tc.desc : api test
980 */
981 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0150, TestSize.Level1)
982 {
983 auto vEncSample = make_unique<VEncNdkInnerSample>();
984 BufferRequestConfig bufferConfig = {
985 .width = 400,
986 .height = 400,
987 .strideAlignment = 0x8,
988 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
989 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
990 .timeout = 0,
991 };
992 vEncSample->surfaceInput = true;
993 vEncSample->enableWaterMark = true;
994 vEncSample->videoCoordinateX = 100;
995 vEncSample->videoCoordinateY = vEncSample->DEFAULT_HEIGHT + 1;
996 vEncSample->videoCoordinateWidth = bufferConfig.width;
997 vEncSample->videoCoordinateHeight = bufferConfig.height;
998
999 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
1000 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
1001 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
1002 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
1003 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
1004 } else {
1005 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
1006 }
1007 }
1008
1009 /**
1010 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0160
1011 * @tc.name : set VIDEO_COORDINATE_Y of format add waterMark height greater than video height
1012 * @tc.desc : api test
1013 */
1014 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0160, TestSize.Level1)
1015 {
1016 auto vEncSample = make_unique<VEncNdkInnerSample>();
1017 BufferRequestConfig bufferConfig = {
1018 .width = 400,
1019 .height = 400,
1020 .strideAlignment = 0x8,
1021 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
1022 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1023 .timeout = 0,
1024 };
1025 vEncSample->surfaceInput = true;
1026 vEncSample->enableWaterMark = true;
1027 vEncSample->videoCoordinateX = 100;
1028 vEncSample->videoCoordinateY = vEncSample->DEFAULT_HEIGHT - 100;
1029 vEncSample->videoCoordinateWidth = bufferConfig.width;
1030 vEncSample->videoCoordinateHeight = bufferConfig.height;
1031
1032 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
1033 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
1034 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
1035 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
1036 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
1037 } else {
1038 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
1039 }
1040 }
1041
1042 /**
1043 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0170
1044 * @tc.name : set VIDEO_COORDINATE_W of format less than 0
1045 * @tc.desc : api test
1046 */
1047 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0170, TestSize.Level1)
1048 {
1049 auto vEncSample = make_unique<VEncNdkInnerSample>();
1050 BufferRequestConfig bufferConfig = {
1051 .width = 400,
1052 .height = 400,
1053 .strideAlignment = 0x8,
1054 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
1055 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1056 .timeout = 0,
1057 };
1058 vEncSample->surfaceInput = true;
1059 vEncSample->enableWaterMark = true;
1060 vEncSample->videoCoordinateX = 100;
1061 vEncSample->videoCoordinateY = 100;
1062 vEncSample->videoCoordinateWidth = -1;
1063 vEncSample->videoCoordinateHeight = bufferConfig.height;
1064
1065 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
1066 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
1067 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
1068 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
1069 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
1070 } else {
1071 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
1072 }
1073 }
1074
1075 /**
1076 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0180
1077 * @tc.name : set VIDEO_COORDINATE_W of format greater than video width
1078 * @tc.desc : api test
1079 */
1080 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0180, TestSize.Level1)
1081 {
1082 auto vEncSample = make_unique<VEncNdkInnerSample>();
1083 BufferRequestConfig bufferConfig = {
1084 .width = 400,
1085 .height = 400,
1086 .strideAlignment = 0x8,
1087 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
1088 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1089 .timeout = 0,
1090 };
1091 vEncSample->surfaceInput = true;
1092 vEncSample->enableWaterMark = true;
1093 vEncSample->videoCoordinateX = 100;
1094 vEncSample->videoCoordinateY = 100;
1095 vEncSample->videoCoordinateWidth = -1;
1096 vEncSample->videoCoordinateHeight = bufferConfig.height;
1097
1098 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
1099 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
1100 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
1101 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
1102 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
1103 } else {
1104 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
1105 }
1106 }
1107
1108 /**
1109 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0190
1110 * @tc.name : set VIDEO_COORDINATE_W of format be equal to 0
1111 * @tc.desc : api test
1112 */
1113 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0190, TestSize.Level1)
1114 {
1115 auto vEncSample = make_unique<VEncNdkInnerSample>();
1116 BufferRequestConfig bufferConfig = {
1117 .width = 400,
1118 .height = 400,
1119 .strideAlignment = 0x8,
1120 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
1121 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1122 .timeout = 0,
1123 };
1124 vEncSample->surfaceInput = true;
1125 vEncSample->enableWaterMark = true;
1126 vEncSample->videoCoordinateX = 100;
1127 vEncSample->videoCoordinateY = 100;
1128 vEncSample->videoCoordinateWidth = 0;
1129 vEncSample->videoCoordinateHeight = bufferConfig.height;
1130
1131 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
1132 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
1133 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
1134 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
1135 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
1136 } else {
1137 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
1138 }
1139 }
1140
1141 /**
1142 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0200
1143 * @tc.name : set VIDEO_COORDINATE_H of format less than 0
1144 * @tc.desc : api test
1145 */
1146 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0200, TestSize.Level1)
1147 {
1148 auto vEncSample = make_unique<VEncNdkInnerSample>();
1149 BufferRequestConfig bufferConfig = {
1150 .width = 400,
1151 .height = 400,
1152 .strideAlignment = 0x8,
1153 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
1154 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1155 .timeout = 0,
1156 };
1157 vEncSample->surfaceInput = true;
1158 vEncSample->enableWaterMark = true;
1159 vEncSample->videoCoordinateX = 100;
1160 vEncSample->videoCoordinateY = 100;
1161 vEncSample->videoCoordinateWidth = bufferConfig.width;
1162 vEncSample->videoCoordinateHeight = -1;
1163
1164 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
1165 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
1166 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
1167 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
1168 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
1169 } else {
1170 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
1171 }
1172 }
1173
1174 /**
1175 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0210
1176 * @tc.name : set VIDEO_COORDINATE_H of format greater than video height
1177 * @tc.desc : api test
1178 */
1179 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0210, TestSize.Level1)
1180 {
1181 auto vEncSample = make_unique<VEncNdkInnerSample>();
1182 BufferRequestConfig bufferConfig = {
1183 .width = 400,
1184 .height = 400,
1185 .strideAlignment = 0x8,
1186 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
1187 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1188 .timeout = 0,
1189 };
1190 vEncSample->surfaceInput = true;
1191 vEncSample->enableWaterMark = true;
1192 vEncSample->videoCoordinateX = 100;
1193 vEncSample->videoCoordinateY = 100;
1194 vEncSample->videoCoordinateWidth = bufferConfig.width;
1195 vEncSample->videoCoordinateHeight = bufferConfig.height - 1;
1196
1197 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
1198 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
1199 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
1200 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
1201 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
1202 } else {
1203 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
1204 }
1205 }
1206
1207 /**
1208 * @tc.number : VIDEO_ENCODE_INNER_WATERMARK_API_0220
1209 * @tc.name : set VIDEO_COORDINATE_H of format be equal to 0
1210 * @tc.desc : api test
1211 */
1212 HWTEST_F(HwEncInnerApiNdkTest, VIDEO_ENCODE_INNER_WATERMARK_API_0220, TestSize.Level1)
1213 {
1214 auto vEncSample = make_unique<VEncNdkInnerSample>();
1215 BufferRequestConfig bufferConfig = {
1216 .width = 400,
1217 .height = 400,
1218 .strideAlignment = 0x8,
1219 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
1220 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
1221 .timeout = 0,
1222 };
1223 vEncSample->surfaceInput = true;
1224 vEncSample->enableWaterMark = true;
1225 vEncSample->videoCoordinateX = 100;
1226 vEncSample->videoCoordinateY = 100;
1227 vEncSample->videoCoordinateWidth = bufferConfig.width;
1228 vEncSample->videoCoordinateHeight = 0;
1229
1230 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateByName(g_codecName));
1231 ASSERT_EQ(AV_ERR_OK, vEncSample->SetCallback());
1232 ASSERT_EQ(AV_ERR_OK, vEncSample->Configure());
1233 if (!vEncSample->GetWaterMarkCapability(g_codecMime)) {
1234 ASSERT_EQ(AVCS_ERR_UNSUPPORT, vEncSample->SetCustomBuffer(bufferConfig));
1235 } else {
1236 ASSERT_EQ(AVCS_ERR_INVALID_VAL, vEncSample->SetCustomBuffer(bufferConfig));
1237 }
1238 }
1239 } // namespace