1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <iostream>
17 #include <gtest/gtest.h>
18 #include "avc_encoder.h"
19 #include "avc_encoder_util.h"
20 #include "surface/window.h"
21
22 using namespace std;
23 using namespace OHOS;
24 using namespace OHOS::Media;
25 using namespace OHOS::MediaAVCodec;
26 using namespace OHOS::MediaAVCodec::Codec;
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace {
31 constexpr int32_t VIDEO_MAX_WIDTH_SIZE = 2560;
32 constexpr int32_t VIDEO_MAX_HEIGHT_SIZE = 2560;
33 constexpr int32_t DEFAULT_VIDEO_WIDTH = 1920;
34 constexpr int32_t DEFAULT_VIDEO_HEIGHT = 1080;
35 constexpr int32_t VIDEO_BITRATE_MAX_SIZE = 240000000;
36 constexpr int32_t DEFAULT_VIDEO_BITRATE = 20000000;
37 constexpr int32_t VIDEO_FRAMERATE_MAX_SIZE = 60;
38 constexpr int32_t DEFAULT_VIDEO_FRAMERATE = 30;
39 constexpr double DEFAULT_VIDEO_FRAMERATE_DOUBLE = 30.0;
40 constexpr int32_t VIDEO_QUALITY_DEFAULT = 80;
41 constexpr int32_t VIDEO_QP_MAX = 51;
42 constexpr int32_t VIDEO_QP_MIN = 4;
43 constexpr int32_t VIDEO_IFRAME_INTERVAL_MIN_TIME = 1000;
44 constexpr int32_t VIDEO_IFRAME_INTERVAL_MAX_TIME = 3600000;
45 constexpr int32_t MOCK_ENCODE_TIEMSTAMPS = 0;
46 constexpr int32_t MOCK_ENCODE_BYTES = 100;
47 constexpr int32_t MOCK_ENCODE_FRAMETYPE = 3;
48 constexpr int32_t FAKE_PTR = 0x1234;
49 constexpr int32_t RGBA_BUFFER_SIZE = 4;
50 constexpr int32_t YUV_BUFFER_SIZE = 3;
51 constexpr int32_t CONVERT_WIDTH = 10;
52 constexpr int32_t CONVERT_HEIGHT = 10;
53
54
55 class AvcCodecCallback : public MediaCodecCallback {
56 public:
AvcCodecCallback(std::shared_ptr<Codec::AvcEncoder> codec)57 explicit AvcCodecCallback(std::shared_ptr<Codec::AvcEncoder> codec)
58 : encoder_(codec)
59 {
60 }
61
62 ~AvcCodecCallback() override = default;
63
OnError(AVCodecErrorType errorType,int32_t errorCode)64 void OnError(AVCodecErrorType errorType, int32_t errorCode) override
65 {
66 cout << "AvcCodecCallback OnError" << endl;
67 }
68
OnOutputFormatChanged(const Format & format)69 void OnOutputFormatChanged(const Format &format) override
70 {
71 cout << "AvcCodecCallback OnOutputFormatChanged" << endl;
72 }
73
OnInputBufferAvailable(uint32_t index,std::shared_ptr<OHOS::Media::AVBuffer> buffer)74 void OnInputBufferAvailable(uint32_t index, std::shared_ptr<OHOS::Media::AVBuffer> buffer) override
75 {
76 if (auto codec = encoder_.lock()) {
77 if (codec->state_ == Codec::AvcEncoder::State::CONFIGURED) {
78 codec->state_ = Codec::AvcEncoder::State::RUNNING;
79 }
80 if (buffer->memory_ != nullptr) {
81 buffer->memory_->SetSize(DEFAULT_VIDEO_WIDTH * DEFAULT_VIDEO_HEIGHT * RGBA_BUFFER_SIZE);
82 }
83
84 buffer->meta_ = std::make_shared<Meta>();
85 if (setDiscardBufferFlag) {
86 buffer->meta_->SetData(OHOS::Media::Tag::VIDEO_ENCODER_PER_FRAME_DISCARD, true);
87 }
88 codec->QueueInputBuffer(index);
89 } else {
90 cout << "AvcCodecCallback OnInputBufferAvailable null encoder" << endl;
91 }
92 }
93
OnOutputBufferAvailable(uint32_t index,std::shared_ptr<OHOS::Media::AVBuffer> buffer)94 void OnOutputBufferAvailable(uint32_t index, std::shared_ptr<OHOS::Media::AVBuffer> buffer) override
95 {
96 if (auto codec = encoder_.lock()) {
97 codec->ReleaseOutputBuffer(index);
98 } else {
99 cout << "AvcCodecCallback OnOutputBufferAvailable null encoder" << endl;
100 }
101 }
102 public:
103 bool setDiscardBufferFlag = false;
104 private:
105 std::weak_ptr<Codec::AvcEncoder> encoder_;
106 };
107
EncoderCreate(AVC_ENC_HANDLE * phEncoder,AVC_ENC_INIT_PARAM * pstInitParam)108 static uint32_t EncoderCreate(AVC_ENC_HANDLE *phEncoder, AVC_ENC_INIT_PARAM *pstInitParam)
109 {
110 *phEncoder = reinterpret_cast<AVC_ENC_HANDLE>(FAKE_PTR);
111 std::string str = "EncoderCreate";
112 pstInitParam->logFxn(0, IHW264VIDEO_ALG_LOG_LEVEL::IHW264VIDEO_ALG_LOG_DEBUG, (uint8_t *)(str.c_str()));
113 pstInitParam->logFxn(0, IHW264VIDEO_ALG_LOG_LEVEL::IHW264VIDEO_ALG_LOG_INFO, (uint8_t *)(str.c_str()));
114 return 0;
115 }
116
EncoderProcess(AVC_ENC_HANDLE phEncoder,AVC_ENC_INARGS * pstInArgs,AVC_ENC_OUTARGS * pstOutArgs)117 static uint32_t EncoderProcess(AVC_ENC_HANDLE phEncoder, AVC_ENC_INARGS *pstInArgs, AVC_ENC_OUTARGS *pstOutArgs)
118 {
119 (void)phEncoder;
120 (void)pstInArgs;
121 pstOutArgs->bytes = MOCK_ENCODE_BYTES;
122 pstOutArgs->timestamp = MOCK_ENCODE_TIEMSTAMPS;
123 pstOutArgs->encodedFrameType = MOCK_ENCODE_FRAMETYPE;
124 return 0;
125 }
126
EncoderDelete(AVC_ENC_HANDLE phEncoder)127 static uint32_t EncoderDelete(AVC_ENC_HANDLE phEncoder)
128 {
129 (void)phEncoder;
130 return 0;
131 }
132
EncoderCreateError(AVC_ENC_HANDLE * phEncoder,AVC_ENC_INIT_PARAM * pstInitParam)133 static uint32_t EncoderCreateError(AVC_ENC_HANDLE *phEncoder, AVC_ENC_INIT_PARAM *pstInitParam)
134 {
135 *phEncoder = reinterpret_cast<AVC_ENC_HANDLE>(FAKE_PTR);
136 std::string str = "EncoderCreate";
137 pstInitParam->logFxn(0, IHW264VIDEO_ALG_LOG_LEVEL::IHW264VIDEO_ALG_LOG_WARNING, (uint8_t *)(str.c_str()));
138 pstInitParam->logFxn(0, IHW264VIDEO_ALG_LOG_LEVEL::IHW264VIDEO_ALG_LOG_ERROR, (uint8_t *)(str.c_str()));
139 return 1;
140 }
141
EncoderProcessError(AVC_ENC_HANDLE phEncoder,AVC_ENC_INARGS * pstInArgs,AVC_ENC_OUTARGS * pstOutArgs)142 static uint32_t EncoderProcessError(AVC_ENC_HANDLE phEncoder, AVC_ENC_INARGS *pstInArgs, AVC_ENC_OUTARGS *pstOutArgs)
143 {
144 (void)phEncoder;
145 (void)pstInArgs;
146 pstOutArgs->bytes = MOCK_ENCODE_BYTES;
147 pstOutArgs->timestamp = MOCK_ENCODE_TIEMSTAMPS;
148 pstOutArgs->encodedFrameType = MOCK_ENCODE_FRAMETYPE;
149 return 1;
150 }
151
EncoderDeleteError(AVC_ENC_HANDLE phEncoder)152 static uint32_t EncoderDeleteError(AVC_ENC_HANDLE phEncoder)
153 {
154 (void)phEncoder;
155 return 1;
156 }
157
158 class AvcCodecCoverageUnitTest : public testing::Test {
159 public:
160 static void SetUpTestCase(void);
161 static void TearDownTestCase(void);
162 void SetUp(void);
163 void TearDown(void);
164
165 std::shared_ptr<Codec::AvcEncoder> avcEncoder_ = nullptr;
166 std::shared_ptr<AvcCodecCallback> avcCallback_ = nullptr;
167 private:
168 OHNativeWindow* CreateWindow(sptr<Surface> surface);
169 void FlushWindow(OHNativeWindow* nativeWindow);
170 Format format_;
171 };
172
SetUpTestCase(void)173 void AvcCodecCoverageUnitTest::SetUpTestCase(void)
174 {}
175
TearDownTestCase(void)176 void AvcCodecCoverageUnitTest::TearDownTestCase(void)
177 {}
178
SetUp(void)179 void AvcCodecCoverageUnitTest::SetUp(void)
180 {
181 avcEncoder_ = std::make_shared<Codec::AvcEncoder>("OH.Media.Codec.Encoder.Video.AVC");
182 EXPECT_NE(avcEncoder_, nullptr);
183 avcCallback_ = std::make_shared<AvcCodecCallback>(avcEncoder_);
184 EXPECT_NE(avcCallback_, nullptr);
185 avcEncoder_->SetCallback(avcCallback_);
186 }
187
TearDown(void)188 void AvcCodecCoverageUnitTest::TearDown(void)
189 {
190 avcEncoder_ = nullptr;
191 avcCallback_ = nullptr;
192 }
193
CreateWindow(sptr<Surface> surface)194 OHNativeWindow* AvcCodecCoverageUnitTest::CreateWindow(sptr<Surface> surface)
195 {
196 OHNativeWindow* nativeWindow = CreateNativeWindowFromSurface(&surface);
197 if (nativeWindow == nullptr) {
198 cout << "CreateNativeWindowFromSurface failed!" << endl;
199 return nullptr;
200 }
201 int32_t ret = OH_NativeWindow_NativeWindowHandleOpt(
202 nativeWindow, SET_FORMAT, GRAPHIC_PIXEL_FMT_YCBCR_420_SP);
203 if (ret != AVCS_ERR_OK) {
204 cout << "NativeWindowHandleOpt SET_FORMAT fail" << endl;
205 return nullptr;
206 }
207 ret = OH_NativeWindow_NativeWindowHandleOpt(
208 nativeWindow, SET_BUFFER_GEOMETRY, DEFAULT_VIDEO_WIDTH, DEFAULT_VIDEO_HEIGHT);
209 if (ret != AVCS_ERR_OK) {
210 cout << "NativeWindowHandleOpt SET_BUFFER_GEOMETRY fail" << endl;
211 return nullptr;
212 }
213 return nativeWindow;
214 }
215
FlushWindow(OHNativeWindow * nativeWindow)216 void AvcCodecCoverageUnitTest::FlushWindow(OHNativeWindow* nativeWindow)
217 {
218 if (nativeWindow == nullptr) {
219 return;
220 }
221
222 int fenceFd = -1;
223 OHNativeWindowBuffer* ohNativeWindowBuffer = nullptr;
224 int32_t err = OH_NativeWindow_NativeWindowRequestBuffer(
225 nativeWindow, &ohNativeWindowBuffer, &fenceFd);
226 if (err != 0) {
227 cout << "RequestBuffer failed " << endl;
228 }
229
230 Region region{nullptr, 0};
231 err = OH_NativeWindow_NativeWindowFlushBuffer(
232 nativeWindow, ohNativeWindowBuffer, fenceFd, region);
233 if (err != 0) {
234 cout << "flush failed " << err << endl;
235 }
236 return;
237 }
238
239 /**
240 * @tc.name: Test_Codec_Config_001
241 * @tc.desc: codec Configure
242 */
243 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Config_001, TestSize.Level1)
244 {
245 format_ = Format();
246 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
247 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
248 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
249 static_cast<int32_t>(VideoPixelFormat::NV21));
250 format_.PutIntValue(MediaDescriptionKey::MD_KEY_I_FRAME_INTERVAL, VIDEO_IFRAME_INTERVAL_MIN_TIME);
251
252 // CQ & Quality & qp
253 format_.PutIntValue(MediaDescriptionKey::MD_KEY_VIDEO_ENCODE_BITRATE_MODE,
254 static_cast<int32_t>(VideoEncodeBitrateMode::CQ));
255 format_.PutIntValue(MediaDescriptionKey::MD_KEY_QUALITY, VIDEO_QUALITY_DEFAULT);
256 format_.PutIntValue(OHOS::Media::Tag::VIDEO_ENCODER_QP_MIN, VIDEO_QP_MIN);
257 format_.PutIntValue(OHOS::Media::Tag::VIDEO_ENCODER_QP_MAX, VIDEO_QP_MAX);
258
259 // profile & level
260 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PROFILE, 0);
261 format_.PutIntValue(MediaDescriptionKey::MD_KEY_LEVEL, 0);
262
263 format_.PutDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE_DOUBLE);
264 format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
265
266 format_.PutIntValue(MediaDescriptionKey::MD_KEY_MAX_OUTPUT_BUFFER_COUNT, 1);
267 format_.PutIntValue(MediaDescriptionKey::MD_KEY_MAX_INPUT_BUFFER_COUNT, 1);
268
269 format_.PutIntValue(MediaDescriptionKey::MD_KEY_RANGE_FLAG, 1);
270 format_.PutIntValue(MediaDescriptionKey::MD_KEY_COLOR_PRIMARIES, 1);
271 format_.PutIntValue(MediaDescriptionKey::MD_KEY_TRANSFER_CHARACTERISTICS, 1);
272 format_.PutIntValue(MediaDescriptionKey::MD_KEY_MATRIX_COEFFICIENTS, 1);
273
274 // callback
275 format_.PutIntValue(OHOS::Media::Tag::VIDEO_ENCODER_ENABLE_SURFACE_INPUT_CALLBACK, 0);
276
277 int32_t ret = avcEncoder_->Configure(format_);
278 EXPECT_EQ(ret, AVCS_ERR_OK);
279 }
280
281 /**
282 * @tc.name: Test_Codec_Config_002
283 * @tc.desc: codec Configure Framerate Bitrate .. Error
284 */
285 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Config_002, TestSize.Level1)
286 {
287 format_ = Format();
288 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
289 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
290 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
291 static_cast<int32_t>(VideoPixelFormat::NV21));
292 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, VIDEO_BITRATE_MAX_SIZE + 1);
293 format_.PutDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE,
294 static_cast<double>(VIDEO_FRAMERATE_MAX_SIZE + 1));
295 format_.PutIntValue(MediaDescriptionKey::MD_KEY_I_FRAME_INTERVAL, VIDEO_IFRAME_INTERVAL_MAX_TIME + 1);
296 format_.PutIntValue(MediaDescriptionKey::MD_KEY_VIDEO_ENCODE_BITRATE_MODE,
297 static_cast<int32_t>(VideoEncodeBitrateMode::CBR));
298
299 format_.PutIntValue(MediaDescriptionKey::MD_KEY_RANGE_FLAG, -1);
300 format_.PutIntValue(MediaDescriptionKey::MD_KEY_COLOR_PRIMARIES, -1);
301 format_.PutIntValue(MediaDescriptionKey::MD_KEY_TRANSFER_CHARACTERISTICS, -1);
302 format_.PutIntValue(MediaDescriptionKey::MD_KEY_MATRIX_COEFFICIENTS, -1);
303
304 int32_t ret = avcEncoder_->Configure(format_);
305 EXPECT_EQ(ret, AVCS_ERR_OK);
306 }
307
308 /**
309 * @tc.name: Test_Codec_Config_003
310 * @tc.desc: codec Configure Width Error
311 */
312 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Config_003, TestSize.Level1)
313 {
314 format_ = Format();
315 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, VIDEO_MAX_WIDTH_SIZE + 1);
316 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
317 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
318 static_cast<int32_t>(VideoPixelFormat::NV21));
319 format_.PutIntValue(MediaDescriptionKey::MD_KEY_VIDEO_ENCODE_BITRATE_MODE,
320 static_cast<int32_t>(VideoEncodeBitrateMode::VBR));
321 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
322 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
323
324 int32_t ret = avcEncoder_->Configure(format_);
325 EXPECT_EQ(ret, AVCS_ERR_INVALID_VAL);
326 }
327
328 /**
329 * @tc.name: Test_Codec_Config_004
330 * @tc.desc: codec Configure Height Error
331 */
332 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Config_004, TestSize.Level1)
333 {
334 format_ = Format();
335 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
336 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, VIDEO_MAX_HEIGHT_SIZE + 1);
337 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
338 static_cast<int32_t>(VideoPixelFormat::NV21));
339 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
340 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
341
342 int32_t ret = avcEncoder_->Configure(format_);
343 EXPECT_EQ(ret, AVCS_ERR_INVALID_VAL);
344 }
345
346 /**
347 * @tc.name: Test_Codec_Config_005
348 * @tc.desc: codec Configure PixelFormat Error
349 */
350 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Config_005, TestSize.Level1)
351 {
352 format_ = Format();
353 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
354 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
355 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
356 static_cast<int32_t>(VideoPixelFormat::SURFACE_FORMAT));
357 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
358 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
359
360 int32_t ret = avcEncoder_->Configure(format_);
361 EXPECT_EQ(ret, AVCS_ERR_OK);
362 }
363
364 /**
365 * @tc.name: Test_Codec_Config_006
366 * @tc.desc: codec input buffer count error
367 */
368 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Config_006, TestSize.Level1)
369 {
370 format_ = Format();
371 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
372 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
373 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
374 static_cast<int32_t>(VideoPixelFormat::NV21));
375 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
376 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
377
378 int32_t ret = avcEncoder_->Configure(format_);
379 EXPECT_EQ(ret, AVCS_ERR_OK);
380
381 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
382 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
383 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
384 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
385
386 avcEncoder_->format_.PutIntValue(MediaDescriptionKey::MD_KEY_MAX_OUTPUT_BUFFER_COUNT, 1);
387 avcEncoder_->format_.PutIntValue(MediaDescriptionKey::MD_KEY_MAX_INPUT_BUFFER_COUNT, 1);
388
389 ret = avcEncoder_->Start();
390 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
391 }
392
393 /**
394 * @tc.name: Test_Codec_Config_007
395 * @tc.desc: codec output buffer count error
396 */
397 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Config_007, TestSize.Level1)
398 {
399 format_ = Format();
400 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
401 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
402 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
403 static_cast<int32_t>(VideoPixelFormat::NV21));
404 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
405 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
406
407 int32_t ret = avcEncoder_->Configure(format_);
408 EXPECT_EQ(ret, AVCS_ERR_OK);
409
410 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
411 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
412 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
413 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
414
415 avcEncoder_->format_.PutIntValue(MediaDescriptionKey::MD_KEY_MAX_OUTPUT_BUFFER_COUNT, 1);
416
417 ret = avcEncoder_->Start();
418 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
419 }
420
421 /**
422 * @tc.name: Test_Codec_Encode_NV21_001
423 * @tc.desc: codec NV21 encode
424 */
425 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Encode_NV21_001, TestSize.Level1)
426 {
427 format_ = Format();
428 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
429 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
430 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
431 static_cast<int32_t>(VideoPixelFormat::NV21));
432 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
433 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
434
435 int32_t ret = avcEncoder_->Configure(format_);
436 EXPECT_EQ(ret, AVCS_ERR_OK);
437
438 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
439 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
440 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
441 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
442 ret = avcEncoder_->Start();
443 EXPECT_EQ(ret, AVCS_ERR_OK);
444 sleep(1);
445 ret = avcEncoder_->Flush();
446 EXPECT_EQ(ret, AVCS_ERR_OK);
447 ret = avcEncoder_->Stop();
448 EXPECT_EQ(ret, AVCS_ERR_OK);
449 ret = avcEncoder_->Release();
450 EXPECT_EQ(ret, AVCS_ERR_OK);
451 }
452
453 /**
454 * @tc.name: Test_Codec_Encode_NV12_001
455 * @tc.desc: codec NV12 encode
456 */
457 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Encode_NV12_001, TestSize.Level1)
458 {
459 format_ = Format();
460 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
461 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
462 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
463 static_cast<int32_t>(VideoPixelFormat::NV12));
464 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
465 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
466
467 int32_t ret = avcEncoder_->Configure(format_);
468 EXPECT_EQ(ret, AVCS_ERR_OK);
469
470 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
471 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
472 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
473 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
474 ret = avcEncoder_->Start();
475 EXPECT_EQ(ret, AVCS_ERR_OK);
476 sleep(1);
477 ret = avcEncoder_->Flush();
478 EXPECT_EQ(ret, AVCS_ERR_OK);
479 ret = avcEncoder_->Stop();
480 EXPECT_EQ(ret, AVCS_ERR_OK);
481 ret = avcEncoder_->Release();
482 EXPECT_EQ(ret, AVCS_ERR_OK);
483 }
484
485 /**
486 * @tc.name: Test_Codec_Encode_YUV_001
487 * @tc.desc: codec yuv420 encode
488 */
489 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Encode_YUV_001, TestSize.Level1)
490 {
491 format_ = Format();
492 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
493 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
494 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
495 static_cast<int32_t>(VideoPixelFormat::YUVI420));
496 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
497 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
498
499 int32_t ret = avcEncoder_->Configure(format_);
500 EXPECT_EQ(ret, AVCS_ERR_OK);
501
502 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
503 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
504 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
505 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
506 ret = avcEncoder_->Start();
507 EXPECT_EQ(ret, AVCS_ERR_OK);
508 sleep(1);
509 ret = avcEncoder_->Flush();
510 EXPECT_EQ(ret, AVCS_ERR_OK);
511 ret = avcEncoder_->Stop();
512 EXPECT_EQ(ret, AVCS_ERR_OK);
513 ret = avcEncoder_->Release();
514 EXPECT_EQ(ret, AVCS_ERR_OK);
515 }
516
517 /**
518 * @tc.name: Test_Codec_Encode_RGBA_001
519 * @tc.desc: codec rgba encode
520 */
521 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Encode_RGBA_001, TestSize.Level1)
522 {
523 format_ = Format();
524 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
525 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
526 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
527 static_cast<int32_t>(VideoPixelFormat::RGBA));
528 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
529 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
530
531 int32_t ret = avcEncoder_->Configure(format_);
532 EXPECT_EQ(ret, AVCS_ERR_OK);
533
534 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
535 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
536 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
537 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
538 ret = avcEncoder_->Start();
539 EXPECT_EQ(ret, AVCS_ERR_OK);
540 sleep(1);
541 ret = avcEncoder_->Flush();
542 EXPECT_EQ(ret, AVCS_ERR_OK);
543 ret = avcEncoder_->Stop();
544 EXPECT_EQ(ret, AVCS_ERR_OK);
545 ret = avcEncoder_->Release();
546 EXPECT_EQ(ret, AVCS_ERR_OK);
547 }
548
549 /**
550 * @tc.name: Test_Codec_Format_Error_001
551 * @tc.desc: codec rgba encode
552 */
553 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Format_Error_001, TestSize.Level1)
554 {
555 format_ = Format();
556 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
557 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
558 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
559 static_cast<int32_t>(VideoPixelFormat::RGBA));
560 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
561 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
562
563 int32_t ret = avcEncoder_->Configure(format_);
564 EXPECT_EQ(ret, AVCS_ERR_OK);
565
566 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
567 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
568 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
569 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
570 avcEncoder_->srcPixelFmt_ = VideoPixelFormat::UNKNOWN;
571 ret = avcEncoder_->Start();
572 EXPECT_EQ(ret, AVCS_ERR_OK);
573 sleep(1);
574 ret = avcEncoder_->Stop();
575 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE);
576 ret = avcEncoder_->Release();
577 EXPECT_EQ(ret, AVCS_ERR_OK);
578 }
579
580 /**
581 * @tc.name: Test_Codec_Start_001
582 * @tc.desc: codec Start Error
583 */
584 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Start_001, TestSize.Level1)
585 {
586 format_ = Format();
587 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
588 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
589 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
590 static_cast<int32_t>(VideoPixelFormat::NV21));
591 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
592 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
593
594 int32_t ret = avcEncoder_->Configure(format_);
595 EXPECT_EQ(ret, AVCS_ERR_OK);
596
597 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
598 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
599 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
600 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
601 avcEncoder_->callback_ = nullptr;
602 ret = avcEncoder_->Start();
603 EXPECT_EQ(ret, AVCS_ERR_INVALID_OPERATION);
604 }
605
606 /**
607 * @tc.name: Test_Codec_Start_002
608 * @tc.desc: codec Start Error
609 */
610 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Start_002, TestSize.Level1)
611 {
612 int32_t ret = avcEncoder_->Start();
613 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE);
614 }
615
616 /**
617 * @tc.name: Test_Codec_Reset_001
618 * @tc.desc: codec Reset
619 */
620 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Reset_001, TestSize.Level1)
621 {
622 int32_t ret = avcEncoder_->Reset();
623 EXPECT_EQ(ret, AVCS_ERR_OK);
624 }
625
626 /**
627 * @tc.name: Test_Codec_Flush_001.
628 * @tc.desc: codec Flush Error
629 */
630 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Flush_001, TestSize.Level1)
631 {
632 int32_t ret = avcEncoder_->Flush();
633 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE);
634 }
635
636 /**
637 * @tc.name: Test_Codec_Start_Stop_Stop_001
638 * @tc.desc: codec Start Stop Stop
639 */
640 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Start_Stop_Stop_001, TestSize.Level1)
641 {
642 format_ = Format();
643 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
644 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
645 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
646 static_cast<int32_t>(VideoPixelFormat::NV21));
647 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
648 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
649
650 int32_t ret = avcEncoder_->Configure(format_);
651 EXPECT_EQ(ret, AVCS_ERR_OK);
652
653 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
654 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
655 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
656 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
657 ret = avcEncoder_->Start();
658 EXPECT_EQ(ret, AVCS_ERR_OK);
659 sleep(1);
660 ret = avcEncoder_->Stop();
661 EXPECT_EQ(ret, AVCS_ERR_OK);
662 ret = avcEncoder_->Stop();
663 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE);
664 ret = avcEncoder_->Release();
665 EXPECT_EQ(ret, AVCS_ERR_OK);
666 }
667
668 /**
669 * @tc.name: Test_Codec_Create_Error_001
670 * @tc.desc: codec Create Error
671 */
672 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Create_Error_001, TestSize.Level1)
673 {
674 format_ = Format();
675 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
676 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
677 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
678 static_cast<int32_t>(VideoPixelFormat::NV21));
679 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
680 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
681
682 int32_t ret = avcEncoder_->Configure(format_);
683 EXPECT_EQ(ret, AVCS_ERR_OK);
684
685 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreateError;
686 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
687 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
688 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
689 ret = avcEncoder_->Start();
690 EXPECT_EQ(ret, AVCS_ERR_INVALID_OPERATION);
691 }
692
693 /**
694 * @tc.name: Test_Codec_Process_Error_001
695 * @tc.desc: codec Process Error
696 */
697 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Process_Error_001, TestSize.Level1)
698 {
699 format_ = Format();
700 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
701 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
702 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
703 static_cast<int32_t>(VideoPixelFormat::NV21));
704 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
705 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
706
707 int32_t ret = avcEncoder_->Configure(format_);
708 EXPECT_EQ(ret, AVCS_ERR_OK);
709
710 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
711 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcessError;
712 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
713 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
714 ret = avcEncoder_->Start();
715 EXPECT_EQ(ret, AVCS_ERR_OK);
716 sleep(1);
717 ret = avcEncoder_->Stop();
718 EXPECT_EQ(ret, AVCS_ERR_OK);
719 ret = avcEncoder_->Release();
720 EXPECT_EQ(ret, AVCS_ERR_OK);
721 }
722
723 /**
724 * @tc.name: Test_Codec_Process_Error_002
725 * @tc.desc: codec Process Error
726 */
727 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Process_Error_002, TestSize.Level1)
728 {
729 format_ = Format();
730 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
731 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
732 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
733 static_cast<int32_t>(VideoPixelFormat::NV21));
734 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
735 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
736
737 int32_t ret = avcEncoder_->Configure(format_);
738 EXPECT_EQ(ret, AVCS_ERR_OK);
739
740 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
741 avcEncoder_->avcEncoderFrameFunc_ = nullptr;
742 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
743 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
744 ret = avcEncoder_->Start();
745 EXPECT_EQ(ret, AVCS_ERR_OK);
746 sleep(1);
747 ret = avcEncoder_->Stop();
748 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE);
749 ret = avcEncoder_->Release();
750 EXPECT_EQ(ret, AVCS_ERR_OK);
751 }
752
753 /**
754 * @tc.name: Test_Codec_Delete_Error_001
755 * @tc.desc: codec Delete Error
756 */
757 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Delete_Error_001, TestSize.Level1)
758 {
759 format_ = Format();
760 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
761 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
762 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
763 static_cast<int32_t>(VideoPixelFormat::NV21));
764 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
765 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
766
767 int32_t ret = avcEncoder_->Configure(format_);
768 EXPECT_EQ(ret, AVCS_ERR_OK);
769
770 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
771 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
772 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDeleteError;
773 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
774 ret = avcEncoder_->Start();
775 EXPECT_EQ(ret, AVCS_ERR_OK);
776 sleep(1);
777 ret = avcEncoder_->Stop();
778 EXPECT_EQ(ret, AVCS_ERR_OK);
779 ret = avcEncoder_->Release();
780 EXPECT_EQ(ret, AVCS_ERR_OK);
781 }
782
783 /**
784 * @tc.name: Test_Codec_Delete_Error_002
785 * @tc.desc: codec Delete Error
786 */
787 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_Delete_Error_002, TestSize.Level1)
788 {
789 format_ = Format();
790 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
791 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
792 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
793 static_cast<int32_t>(VideoPixelFormat::NV21));
794 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
795 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
796
797 int32_t ret = avcEncoder_->Configure(format_);
798 EXPECT_EQ(ret, AVCS_ERR_OK);
799
800 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
801 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
802 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDeleteError;
803 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
804 ret = avcEncoder_->Start();
805 EXPECT_EQ(ret, AVCS_ERR_OK);
806 sleep(1);
807 ret = avcEncoder_->Release();
808 EXPECT_EQ(ret, AVCS_ERR_OK);
809 }
810
811 /**
812 * @tc.name: Test_Codec_GetOutFormat_001
813 * @tc.desc: codec Delete Error
814 */
815 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_GetOutFormat_001, TestSize.Level1)
816 {
817 format_ = Format();
818 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
819 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
820 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
821 static_cast<int32_t>(VideoPixelFormat::NV21));
822 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
823 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
824
825 int32_t ret = avcEncoder_->Configure(format_);
826 EXPECT_EQ(ret, AVCS_ERR_OK);
827
828 Format outFormat;
829 ret = avcEncoder_->GetOutputFormat(outFormat);
830 EXPECT_EQ(ret, AVCS_ERR_OK);
831 }
832
833 /**
834 * @tc.name: Test_Codec_GetInFormat_001
835 * @tc.desc: codec get in format
836 */
837 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_GetInFormat_001, TestSize.Level1)
838 {
839 format_ = Format();
840 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
841 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
842 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
843 static_cast<int32_t>(VideoPixelFormat::NV21));
844 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
845 format_.PutIntValue(MediaDescriptionKey::MD_KEY_REQUEST_I_FRAME, 1);
846 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
847
848 int32_t ret = avcEncoder_->SetParameter(format_);
849 EXPECT_EQ(ret, AVCS_ERR_OK);
850
851 Format inFormat;
852 ret = avcEncoder_->GetInputFormat(inFormat);
853 EXPECT_EQ(ret, AVCS_ERR_OK);
854
855 avcEncoder_->srcPixelFmt_ = VideoPixelFormat::RGBA;
856 ret = avcEncoder_->GetInputFormat(inFormat);
857 EXPECT_EQ(ret, AVCS_ERR_OK);
858 }
859
860 /**
861 * @tc.name: Test_Codec_GetCapability_001
862 * @tc.desc: codec get capability
863 */
864 HWTEST_F(AvcCodecCoverageUnitTest, Test_Codec_GetCapability_001, TestSize.Level1)
865 {
866 std::vector<CapabilityData> capaArray;
867 CapabilityData capsData;
868 avcEncoder_->GetCapabilityData(capsData, 0);
869 EXPECT_EQ(capsData.isVendor, false);
870 int32_t ret = avcEncoder_->GetCodecCapability(capaArray);
871 EXPECT_EQ(ret, AVCS_ERR_UNSUPPORT);
872 }
873
874 /**
875 * @tc.name: Test_Encoder_Surface_Mod_001
876 * @tc.desc: encoder Surface mod, not create window
877 */
878 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Surface_Mod_001, TestSize.Level1)
879 {
880 format_ = Format();
881 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
882 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
883 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
884 static_cast<int32_t>(VideoPixelFormat::NV21));
885 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
886 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
887
888 sptr<Surface> surface = avcEncoder_->CreateInputSurface();
889 EXPECT_NE(surface, nullptr);
890
891 int32_t ret = avcEncoder_->Configure(format_);
892 EXPECT_EQ(ret, AVCS_ERR_OK);
893
894 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
895 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
896 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
897 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
898
899 ret = avcEncoder_->SetOutputSurface(nullptr);
900 EXPECT_EQ(ret, AVCS_ERR_OK);
901 ret = avcEncoder_->RenderOutputBuffer(0);
902 EXPECT_EQ(ret, AVCS_ERR_OK);
903
904 ret = avcEncoder_->Start();
905 EXPECT_EQ(ret, AVCS_ERR_OK);
906
907 ret = avcEncoder_->NotifyEos();
908 EXPECT_EQ(ret, AVCS_ERR_OK);
909
910 ret = avcEncoder_->Stop();
911 EXPECT_EQ(ret, AVCS_ERR_OK);
912
913 ret = avcEncoder_->Release();
914 EXPECT_EQ(ret, AVCS_ERR_OK);
915 }
916
917 /**
918 * @tc.name: Test_Encoder_Surface_Mod_002
919 * @tc.desc: encoder Surface mod, nv21 create window
920 */
921 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Surface_Mod_002, TestSize.Level1)
922 {
923 format_ = Format();
924 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
925 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
926 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
927 static_cast<int32_t>(VideoPixelFormat::NV21));
928 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
929 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
930
931 sptr<Surface> surface = avcEncoder_->CreateInputSurface();
932 EXPECT_NE(surface, nullptr);
933 OHNativeWindow* nativeWindow = CreateWindow(surface);
934
935 int32_t ret = avcEncoder_->Configure(format_);
936 EXPECT_EQ(ret, AVCS_ERR_OK);
937
938 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
939 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
940 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
941 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
942
943 ret = avcEncoder_->Start();
944 EXPECT_EQ(ret, AVCS_ERR_OK);
945 FlushWindow(nativeWindow);
946 sleep(1);
947 ret = avcEncoder_->NotifyEos();
948 EXPECT_EQ(ret, AVCS_ERR_OK);
949 sleep(1);
950 ret = avcEncoder_->Stop();
951 EXPECT_EQ(ret, AVCS_ERR_OK);
952
953 ret = avcEncoder_->Release();
954 EXPECT_EQ(ret, AVCS_ERR_OK);
955 }
956
957 /**
958 * @tc.name: Test_Encoder_Surface_Mod_003
959 * @tc.desc: encoder Surface mod, nv12 create window
960 */
961 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Surface_Mod_003, TestSize.Level1)
962 {
963 format_ = Format();
964 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
965 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
966 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
967 static_cast<int32_t>(VideoPixelFormat::NV12));
968 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
969 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
970 format_.PutIntValue(OHOS::Media::Tag::VIDEO_ENCODER_ENABLE_SURFACE_INPUT_CALLBACK, 1);
971
972 sptr<Surface> surface = avcEncoder_->CreateInputSurface();
973 EXPECT_NE(surface, nullptr);
974 OHNativeWindow* nativeWindow = CreateWindow(surface);
975
976 int32_t ret = avcEncoder_->Configure(format_);
977 EXPECT_EQ(ret, AVCS_ERR_OK);
978
979 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
980 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
981 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
982 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
983
984 ret = avcEncoder_->Start();
985 EXPECT_EQ(ret, AVCS_ERR_OK);
986 FlushWindow(nativeWindow);
987 sleep(1);
988 ret = avcEncoder_->NotifyEos();
989 EXPECT_EQ(ret, AVCS_ERR_OK);
990 sleep(1);
991 ret = avcEncoder_->Stop();
992 EXPECT_EQ(ret, AVCS_ERR_OK);
993
994 ret = avcEncoder_->Release();
995 EXPECT_EQ(ret, AVCS_ERR_OK);
996 }
997
998 /**
999 * @tc.name: Test_Encoder_Surface_Mod_004
1000 * @tc.desc: encoder Surface mod, rgba create window
1001 */
1002 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Surface_Mod_004, TestSize.Level1)
1003 {
1004 format_ = Format();
1005 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
1006 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
1007 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
1008 static_cast<int32_t>(VideoPixelFormat::RGBA));
1009 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
1010 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
1011 format_.PutIntValue(OHOS::Media::Tag::VIDEO_ENCODER_ENABLE_SURFACE_INPUT_CALLBACK, 1);
1012
1013 sptr<Surface> surface = avcEncoder_->CreateInputSurface();
1014 EXPECT_NE(surface, nullptr);
1015 OHNativeWindow* nativeWindow = CreateWindow(surface);
1016
1017 int32_t ret = avcEncoder_->Configure(format_);
1018 EXPECT_EQ(ret, AVCS_ERR_OK);
1019
1020 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
1021 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
1022 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
1023 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
1024
1025 ret = avcEncoder_->Start();
1026 EXPECT_EQ(ret, AVCS_ERR_OK);
1027 FlushWindow(nativeWindow);
1028 sleep(1);
1029 ret = avcEncoder_->NotifyEos();
1030 EXPECT_EQ(ret, AVCS_ERR_OK);
1031 sleep(1);
1032 ret = avcEncoder_->Stop();
1033 EXPECT_EQ(ret, AVCS_ERR_OK);
1034
1035 ret = avcEncoder_->Release();
1036 EXPECT_EQ(ret, AVCS_ERR_OK);
1037 }
1038
1039 /**
1040 * @tc.name: Test_Encoder_Surface_Mod_005
1041 * @tc.desc: encoder Surface mod, set discard buffer flag
1042 */
1043 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Surface_Mod_005, TestSize.Level1)
1044 {
1045 format_ = Format();
1046 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
1047 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
1048 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT,
1049 static_cast<int32_t>(VideoPixelFormat::NV21));
1050 format_.PutIntValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, DEFAULT_VIDEO_FRAMERATE);
1051 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_VIDEO_BITRATE);
1052 format_.PutIntValue(OHOS::Media::Tag::VIDEO_ENCODER_ENABLE_SURFACE_INPUT_CALLBACK, 1);
1053
1054 avcCallback_->setDiscardBufferFlag = true;
1055 sptr<Surface> surface = avcEncoder_->CreateInputSurface();
1056 EXPECT_NE(surface, nullptr);
1057 OHNativeWindow* nativeWindow = CreateWindow(surface);
1058
1059 int32_t ret = avcEncoder_->Configure(format_);
1060 EXPECT_EQ(ret, AVCS_ERR_OK);
1061
1062 avcEncoder_->avcEncoderCreateFunc_ = &EncoderCreate;
1063 avcEncoder_->avcEncoderFrameFunc_ = &EncoderProcess;
1064 avcEncoder_->avcEncoderDeleteFunc_ = &EncoderDelete;
1065 avcEncoder_->handle_ = reinterpret_cast<void *>(FAKE_PTR);
1066
1067 ret = avcEncoder_->Start();
1068 EXPECT_EQ(ret, AVCS_ERR_OK);
1069 FlushWindow(nativeWindow);
1070 sleep(1);
1071 ret = avcEncoder_->NotifyEos();
1072 EXPECT_EQ(ret, AVCS_ERR_OK);
1073 sleep(1);
1074 ret = avcEncoder_->Stop();
1075 EXPECT_EQ(ret, AVCS_ERR_OK);
1076
1077 ret = avcEncoder_->Release();
1078 EXPECT_EQ(ret, AVCS_ERR_OK);
1079 }
1080
1081 /**
1082 * @tc.name: Test_Encoder_Create_Surface_001
1083 * @tc.desc: encoder create & get surface
1084 */
1085 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Create_Surface_001, TestSize.Level1)
1086 {
1087 sptr<Surface> surface = avcEncoder_->CreateInputSurface();
1088 EXPECT_NE(surface, nullptr);
1089 sptr<Surface> surface2 = avcEncoder_->CreateInputSurface();
1090 EXPECT_EQ(surface2, nullptr);
1091 int32_t ret = avcEncoder_->SetInputSurface(surface);
1092 EXPECT_EQ(ret, AVCS_ERR_INVALID_VAL);
1093 ret = avcEncoder_->SetInputSurface(nullptr);
1094 EXPECT_EQ(ret, AVCS_ERR_INVALID_VAL);
1095 sptr<Surface> surface3 = avcEncoder_->inputSurface_;
1096 ret = avcEncoder_->SetInputSurface(surface3);
1097 EXPECT_EQ(ret, AVCS_ERR_OK);
1098 }
1099
1100 /**
1101 * @tc.name: Test_Encoder_QueueInputBuffer_001
1102 * @tc.desc: encoder QueueInputBuffer error
1103 */
1104 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_QueueInputBuffer_001, TestSize.Level1)
1105 {
1106 sptr<Surface> surface = avcEncoder_->CreateInputSurface();
1107 EXPECT_NE(surface, nullptr);
1108 int32_t ret = avcEncoder_->QueueInputBuffer(0);
1109 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE);
1110 }
1111
1112 /**
1113 * @tc.name: Test_Encoder_CheckBufferSize_001
1114 * @tc.desc: encoder CheckBufferSize error
1115 */
1116 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_CheckBufferSize_001, TestSize.Level1)
1117 {
1118 int32_t ret = avcEncoder_->CheckBufferSize(0, 1, 1, VideoPixelFormat::RGBA);
1119 EXPECT_EQ(ret, AVCS_ERR_UNSUPPORT_SOURCE);
1120 }
1121
1122 /**
1123 * @tc.name: Test_Encoder_Utils_001
1124 * @tc.desc: encoder utils coverage
1125 */
1126 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Utils_001, TestSize.Level1)
1127 {
1128 int32_t flag = AvcFrameTypeToBufferFlag(1);
1129 EXPECT_EQ(flag, AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_PARTIAL_FRAME);
1130 flag = AvcFrameTypeToBufferFlag(0);
1131 EXPECT_EQ(flag, AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_CODEC_DATA);
1132 }
1133
1134 /**
1135 * @tc.name: Test_Encoder_Utils_002
1136 * @tc.desc: encoder utils coverage
1137 */
1138 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Utils_002, TestSize.Level1)
1139 {
1140 VideoPixelFormat fmt = TranslateVideoPixelFormat(GRAPHIC_PIXEL_FMT_YCBCR_420_P);
1141 EXPECT_EQ(fmt, VideoPixelFormat::YUVI420);
1142 COLOR_FORMAT clr_fmt = TranslateVideoFormatToAvc(fmt);
1143 EXPECT_EQ(clr_fmt, COLOR_FORMAT::YUV_420P);
1144
1145 fmt = TranslateVideoPixelFormat(GRAPHIC_PIXEL_FMT_RGBA_8888);
1146 EXPECT_EQ(fmt, VideoPixelFormat::RGBA);
1147 clr_fmt = TranslateVideoFormatToAvc(fmt);
1148 EXPECT_EQ(clr_fmt, COLOR_FORMAT::YUV_420SP_VU);
1149
1150 fmt = TranslateVideoPixelFormat(GRAPHIC_PIXEL_FMT_YCRCB_420_SP);
1151 EXPECT_EQ(fmt, VideoPixelFormat::NV21);
1152 clr_fmt = TranslateVideoFormatToAvc(fmt);
1153 EXPECT_EQ(clr_fmt, COLOR_FORMAT::YUV_420SP_VU);
1154
1155 fmt = TranslateVideoPixelFormat(GRAPHIC_PIXEL_FMT_YCBCR_420_SP);
1156 EXPECT_EQ(fmt, VideoPixelFormat::NV12);
1157 clr_fmt = TranslateVideoFormatToAvc(fmt);
1158 EXPECT_EQ(clr_fmt, COLOR_FORMAT::YUV_420SP_UV);
1159
1160 fmt = TranslateVideoPixelFormat(GRAPHIC_PIXEL_FMT_BUTT);
1161 EXPECT_EQ(fmt, VideoPixelFormat::UNKNOWN);
1162 clr_fmt = TranslateVideoFormatToAvc(fmt);
1163 EXPECT_EQ(clr_fmt, COLOR_FORMAT::YUV_420P);
1164 }
1165
1166 /**
1167 * @tc.name: Test_Encoder_Utils_003
1168 * @tc.desc: encoder utils coverage
1169 */
1170 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Utils_003, TestSize.Level1)
1171 {
1172 COLOR_MATRIX matrix = TranslateMatrix(MatrixCoefficient::MATRIX_COEFFICIENT_BT709);
1173 EXPECT_EQ(matrix, COLOR_MATRIX::MATRIX_BT709);
1174 matrix = TranslateMatrix(MatrixCoefficient::MATRIX_COEFFICIENT_FCC);
1175 EXPECT_EQ(matrix, COLOR_MATRIX::MATRIX_FCC47_73_682);
1176 matrix = TranslateMatrix(MatrixCoefficient::MATRIX_COEFFICIENT_BT601_525);
1177 EXPECT_EQ(matrix, COLOR_MATRIX::MATRIX_BT601);
1178 matrix = TranslateMatrix(MatrixCoefficient::MATRIX_COEFFICIENT_SMPTE_ST240);
1179 EXPECT_EQ(matrix, COLOR_MATRIX::MATRIX_240M);
1180 matrix = TranslateMatrix(MatrixCoefficient::MATRIX_COEFFICIENT_BT2020_NCL);
1181 EXPECT_EQ(matrix, COLOR_MATRIX::MATRIX_BT2020);
1182 matrix = TranslateMatrix(MatrixCoefficient::MATRIX_COEFFICIENT_BT2020_CL);
1183 EXPECT_EQ(matrix, COLOR_MATRIX::MATRIX_BT2020_CONSTANT);
1184 matrix = TranslateMatrix(MatrixCoefficient::MATRIX_COEFFICIENT_ICTCP);
1185 EXPECT_EQ(matrix, COLOR_MATRIX::MATRIX_UNSPECIFIED);
1186 }
1187
1188 /**
1189 * @tc.name: Test_Encoder_Utils_004
1190 * @tc.desc: encoder utils coverage
1191 */
1192 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Utils_004, TestSize.Level1)
1193 {
1194 COLOR_RANGE range = TranslateRange(0);
1195 EXPECT_EQ(range, COLOR_RANGE::RANGE_FULL);
1196 range = TranslateRange(1);
1197 EXPECT_EQ(range, COLOR_RANGE::RANGE_LIMITED);
1198 range = TranslateRange(2);
1199 EXPECT_EQ(range, COLOR_RANGE::RANGE_UNSPECIFIED);
1200 }
1201
1202 /**
1203 * @tc.name: Test_Encoder_Utils_005
1204 * @tc.desc: encoder utils coverage
1205 */
1206 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Utils_005, TestSize.Level1)
1207 {
1208 ENC_PROFILE profile = TranslateEncProfile(AVCProfile::AVC_PROFILE_BASELINE);
1209 EXPECT_EQ(profile, ENC_PROFILE::PROFILE_BASE);
1210 profile = TranslateEncProfile(AVCProfile::AVC_PROFILE_HIGH);
1211 EXPECT_EQ(profile, ENC_PROFILE::PROFILE_HIGH);
1212 profile = TranslateEncProfile(AVCProfile::AVC_PROFILE_CONSTRAINED_HIGH);
1213 EXPECT_EQ(profile, ENC_PROFILE::PROFILE_HIGH);
1214 profile = TranslateEncProfile(AVCProfile::AVC_PROFILE_EXTENDED);
1215 EXPECT_EQ(profile, ENC_PROFILE::PROFILE_HIGH);
1216 profile = TranslateEncProfile(AVCProfile::AVC_PROFILE_HIGH_10);
1217 EXPECT_EQ(profile, ENC_PROFILE::PROFILE_HIGH);
1218 profile = TranslateEncProfile(AVCProfile::AVC_PROFILE_HIGH_422);
1219 EXPECT_EQ(profile, ENC_PROFILE::PROFILE_HIGH);
1220 profile = TranslateEncProfile(AVCProfile::AVC_PROFILE_HIGH_444);
1221 EXPECT_EQ(profile, ENC_PROFILE::PROFILE_HIGH);
1222 profile = TranslateEncProfile(AVCProfile::AVC_PROFILE_MAIN);
1223 EXPECT_EQ(profile, ENC_PROFILE::PROFILE_MAIN);
1224 }
1225
1226 /**
1227 * @tc.name: Test_Encoder_Utils_006
1228 * @tc.desc: encoder utils coverage
1229 */
1230 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Utils_006, TestSize.Level1)
1231 {
1232 ENC_MODE mode = TranslateEncMode(VideoEncodeBitrateMode::CBR);
1233 EXPECT_EQ(mode, ENC_MODE::MODE_CBR);
1234 mode = TranslateEncMode(VideoEncodeBitrateMode::VBR);
1235 EXPECT_EQ(mode, ENC_MODE::MODE_VBR);
1236 mode = TranslateEncMode(VideoEncodeBitrateMode::CQ);
1237 EXPECT_EQ(mode, ENC_MODE::MODE_CQP);
1238 }
1239
1240 /**
1241 * @tc.name: Test_Encoder_Convert_001
1242 * @tc.desc: encoder convert coverage
1243 */
1244 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Convert_001, TestSize.Level1)
1245 {
1246 int32_t width = CONVERT_WIDTH;
1247 int32_t height = CONVERT_HEIGHT;
1248 int32_t dstBufferSize = width * height * YUV_BUFFER_SIZE / 2;
1249 uint8_t *dst = (uint8_t *)malloc(dstBufferSize);
1250 uint8_t *src = (uint8_t *)malloc(width * height * RGBA_BUFFER_SIZE);
1251 RgbImageData data = {
1252 .data = src,
1253 .stride = width,
1254 .matrix = COLOR_MATRIX::MATRIX_BT709,
1255 .range = COLOR_RANGE::RANGE_FULL,
1256 .bytesPerPixel = RGBA_BUFFER_SIZE,
1257 };
1258 int32_t ret = ConvertRgbToYuv420(dst, width, height, dstBufferSize, data);
1259 EXPECT_EQ(ret, AVCS_ERR_OK);
1260
1261 ret = ConvertRgbToYuv420(dst, width, height, dstBufferSize - 1, data);
1262 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
1263
1264 ret = ConvertRgbToYuv420(nullptr, width, height, dstBufferSize, data);
1265 EXPECT_EQ(ret, AVCS_ERR_INVALID_VAL);
1266
1267 #if defined(ARMV8)
1268 ret = ConvertRgbToYuv420Neon(dst, width, height, dstBufferSize, data);
1269 EXPECT_EQ(ret, AVCS_ERR_OK);
1270
1271 ret = ConvertRgbToYuv420Neon(dst, width, height, dstBufferSize - 1, data);
1272 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
1273
1274 ret = ConvertRgbToYuv420Neon(nullptr, width, height, dstBufferSize, data);
1275 EXPECT_EQ(ret, AVCS_ERR_INVALID_VAL);
1276 #endif
1277 }
1278
1279 /**
1280 * @tc.name: Test_Encoder_Convert_002
1281 * @tc.desc: encoder convert coverage
1282 */
1283 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Convert_002, TestSize.Level1)
1284 {
1285 int32_t width = CONVERT_WIDTH;
1286 int32_t height = CONVERT_HEIGHT;
1287 int32_t dstBufferSize = width * height * YUV_BUFFER_SIZE / 2;
1288 uint8_t *dst = (uint8_t *)malloc(dstBufferSize);
1289 uint8_t *src = (uint8_t *)malloc(dstBufferSize);
1290 YuvImageData data = {
1291 .data = src,
1292 .stride = width,
1293 .uvOffset = 0,
1294 };
1295 int32_t ret = ConvertNv12ToYuv420(dst, width, height, dstBufferSize, data);
1296 EXPECT_EQ(ret, AVCS_ERR_OK);
1297
1298 ret = ConvertNv12ToYuv420(dst, width, height, dstBufferSize - 1, data);
1299 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
1300 }
1301
1302 /**
1303 * @tc.name: Test_Encoder_Convert_003
1304 * @tc.desc: encoder convert coverage
1305 */
1306 HWTEST_F(AvcCodecCoverageUnitTest, Test_Encoder_Convert_003, TestSize.Level1)
1307 {
1308 int32_t width = CONVERT_WIDTH;
1309 int32_t height = CONVERT_HEIGHT;
1310 int32_t dstBufferSize = width * height * YUV_BUFFER_SIZE / 2;
1311 uint8_t *dst = (uint8_t *)malloc(dstBufferSize);
1312 uint8_t *src = (uint8_t *)malloc(dstBufferSize);
1313 YuvImageData data = {
1314 .data = src,
1315 .stride = width,
1316 .uvOffset = 0,
1317 };
1318 int32_t ret = ConvertNv21ToYuv420(dst, width, height, dstBufferSize, data);
1319 EXPECT_EQ(ret, AVCS_ERR_OK);
1320
1321 ret = ConvertNv21ToYuv420(dst, width, height, dstBufferSize - 1, data);
1322 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
1323 }
1324 } // namespace