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