1 /*
2  * Copyright (c) 2021 Shenzhen Kaihong DID 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 <OMX_Component.h>
17 #include <OMX_Core.h>
18 #include <OMX_Video.h>
19 #include <OMX_VideoExt.h>
20 #include <ashmem.h>
21 #include <buffer_handle.h>
22 #include <gtest/gtest.h>
23 #include <hdf_log.h>
24 #include <osal_mem.h>
25 #include <securec.h>
26 #include <servmgr_hdi.h>
27 #include "codec_callback_if.h"
28 #include "codec_component_manager.h"
29 #include "codec_component_type.h"
30 #include "codec_omx_ext.h"
31 #include "hdf_io_service_if.h"
32 #include "v1_0/display_composer_type.h"
33 #include "v1_0/display_buffer_type.h"
34 #include "v1_0/include/idisplay_buffer.h"
35 #define HDF_LOG_TAG codec_hdi_test
36 
37 using namespace std;
38 using namespace testing::ext;
39 using namespace OHOS::HDI::Display::Buffer::V1_0;
40 using namespace OHOS::HDI::Display::Composer::V1_0;
41 namespace {
42 constexpr int32_t WIDTH = 640;
43 #ifdef SUPPORT_OMX
44 constexpr uint32_t MAX_ROLE_INDEX = 1000;
45 constexpr int32_t ROLE_LEN = 240;
46 #endif
47 constexpr int32_t HEIGHT = 480;
48 constexpr int32_t BUFFER_SIZE = WIDTH * HEIGHT * 3;
49 constexpr int32_t FRAMERATE = 30 << 16;
50 constexpr uint32_t BUFFER_ID_ERROR = 65000;
51 constexpr uint32_t WAIT_TIME = 1000;
52 constexpr uint32_t MAX_WAIT = 50;
53 constexpr uint32_t ERROR_FENCEFD = 1;
54 constexpr uint32_t BUFFER_LEN = 1024;
55 static IDisplayBuffer *gralloc_ = nullptr;
56 
InitCodecBuffer(OmxCodecBuffer & buffer,CodecBufferType type,OMX_VERSIONTYPE & version)57 static void InitCodecBuffer(OmxCodecBuffer& buffer, CodecBufferType type, OMX_VERSIONTYPE& version)
58 {
59     buffer.bufferType = type;
60     buffer.fenceFd = -1;
61     buffer.version = version;
62     buffer.allocLen = BUFFER_SIZE;
63     buffer.buffer = 0;
64     buffer.bufferLen = 0;
65     buffer.pts = 0;
66     buffer.flag = 0;
67     buffer.type = READ_WRITE_TYPE;
68 }
69 
70 class CodecHdiOmxTest : public testing::Test {
71 public:
72     enum class PortIndex { PORT_INDEX_INPUT = 0, PORT_INDEX_OUTPUT = 1 };
73     struct BufferInfo {
74         std::shared_ptr<OmxCodecBuffer> omxBuffer;
75         std::shared_ptr<OHOS::Ashmem> sharedMem;
76         BufferHandle *bufferHandle;
BufferInfo__anonde5717a10110::CodecHdiOmxTest::BufferInfo77         BufferInfo()
78         {
79             omxBuffer = nullptr;
80             sharedMem = nullptr;
81             bufferHandle = nullptr;
82         }
~BufferInfo__anonde5717a10110::CodecHdiOmxTest::BufferInfo83         ~BufferInfo()
84         {
85             omxBuffer = nullptr;
86             if (sharedMem != nullptr) {
87                 sharedMem->UnmapAshmem();
88                 sharedMem->CloseAshmem();
89                 sharedMem = nullptr;
90             }
91             if (bufferHandle != nullptr && gralloc_ != nullptr) {
92                 gralloc_->FreeMem(*bufferHandle);
93                 bufferHandle = nullptr;
94             }
95         }
96     };
97     template <typename T>
InitParam(T & param)98     void InitParam(T &param)
99     {
100         int32_t ret = memset_s(&param, sizeof(param), 0x0, sizeof(param));
101         ASSERT_EQ(ret, EOK);
102         param.nSize = sizeof(param);
103         param.nVersion = version_;
104     }
105 
106     template <typename T>
InitExtParam(T & param)107     void InitExtParam(T &param)
108     {
109         int32_t ret = memset_s(&param, sizeof(param), 0x0, sizeof(param));
110         ASSERT_EQ(ret, EOK);
111         param.size = sizeof(param);
112         param.version = version_;
113     }
114 
InitCodecBufferWithAshMem(enum PortIndex portIndex,int bufferSize,shared_ptr<OmxCodecBuffer> omxBuffer,shared_ptr<OHOS::Ashmem> sharedMem)115     void InitCodecBufferWithAshMem(enum PortIndex portIndex, int bufferSize, shared_ptr<OmxCodecBuffer> omxBuffer,
116                                    shared_ptr<OHOS::Ashmem> sharedMem)
117     {
118         omxBuffer->size = sizeof(OmxCodecBuffer);
119         omxBuffer->version = version_;
120         omxBuffer->bufferType = CODEC_BUFFER_TYPE_AVSHARE_MEM_FD;
121         omxBuffer->bufferLen = sizeof(int);
122         omxBuffer->buffer = (uint8_t *)(uintptr_t)sharedMem->GetAshmemFd();
123         omxBuffer->allocLen = bufferSize;
124         omxBuffer->fenceFd = -1;
125         omxBuffer->pts = 0;
126         omxBuffer->flag = 0;
127         if (portIndex == PortIndex::PORT_INDEX_INPUT) {
128             omxBuffer->type = READ_ONLY_TYPE;
129             sharedMem->MapReadAndWriteAshmem();
130         } else {
131             omxBuffer->type = READ_WRITE_TYPE;
132             sharedMem->MapReadOnlyAshmem();
133         }
134     }
135 
UseBufferOnPort(enum PortIndex portIndex,int32_t bufferCount,int32_t bufferSize)136     bool UseBufferOnPort(enum PortIndex portIndex, int32_t bufferCount, int32_t bufferSize)
137     {
138         for (int i = 0; i < bufferCount; i++) {
139             std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
140             if (omxBuffer == nullptr) {
141                 return false;
142             }
143 
144             int fd = OHOS::AshmemCreate(0, bufferSize);
145             shared_ptr<OHOS::Ashmem> sharedMem = make_shared<OHOS::Ashmem>(fd, bufferSize);
146             if (sharedMem == nullptr) {
147                 if (fd >= 0) {
148                     close(fd);
149                     fd = -1;
150                 }
151                 return false;
152             }
153             InitCodecBufferWithAshMem(portIndex, bufferSize, omxBuffer, sharedMem);
154             auto err = component_->UseBuffer(component_, static_cast<uint32_t>(portIndex), omxBuffer.get());
155             if (err != HDF_SUCCESS) {
156                 sharedMem->UnmapAshmem();
157                 sharedMem->CloseAshmem();
158                 sharedMem = nullptr;
159                 omxBuffer = nullptr;
160                 return false;
161             }
162             omxBuffer->bufferLen = 0;
163             std::shared_ptr<BufferInfo> bufferInfo = std::make_shared<BufferInfo>();
164             bufferInfo->omxBuffer = omxBuffer;
165             bufferInfo->sharedMem = sharedMem;
166             if (portIndex == PortIndex::PORT_INDEX_INPUT) {
167                 inputBuffers_.emplace(std::make_pair(omxBuffer->bufferId, bufferInfo));
168             } else {
169                 outputBuffers_.emplace(std::make_pair(omxBuffer->bufferId, bufferInfo));
170             }
171         }
172         return true;
173     }
174 
FreeBufferOnPort(enum PortIndex portIndex)175     bool FreeBufferOnPort(enum PortIndex portIndex)
176     {
177         std::map<int32_t, std::shared_ptr<BufferInfo>> &buffer = inputBuffers_;
178         if (portIndex == PortIndex::PORT_INDEX_OUTPUT) {
179             buffer = outputBuffers_;
180         }
181         for (auto [bufferId, bufferInfo] : buffer) {
182             auto ret = component_->FreeBuffer(component_, static_cast<uint32_t>(portIndex),
183                 bufferInfo->omxBuffer.get());
184             if (ret != HDF_SUCCESS) {
185                 return false;
186             }
187         }
188         buffer.clear();
189         return true;
190     }
191 
waitState(OMX_STATETYPE objState)192     void waitState(OMX_STATETYPE objState)
193     {
194         OMX_STATETYPE state = OMX_StateInvalid;
195         uint32_t count = 0;
196         do {
197             usleep(WAIT_TIME);
198             auto ret = component_->GetState(component_, &state);
199             ASSERT_EQ(ret, HDF_SUCCESS);
200             count++;
201         } while (state != objState && count <= MAX_WAIT);
202     }
203 
InitBufferHandle(std::shared_ptr<OmxCodecBuffer> & omxBuffer,BufferHandle ** bufferHandle)204     void InitBufferHandle(std::shared_ptr<OmxCodecBuffer> &omxBuffer, BufferHandle **bufferHandle)
205     {
206         ASSERT_TRUE(gralloc_ != nullptr);
207         AllocInfo alloc = {.width = WIDTH,
208             .height = HEIGHT,
209             .usage = HBM_USE_CPU_READ | HBM_USE_CPU_WRITE | HBM_USE_MEM_DMA,
210             .format = PIXEL_FMT_YCBCR_420_SP};
211 
212         auto err = gralloc_->AllocMem(alloc, *bufferHandle);
213         ASSERT_EQ(err, DISPLAY_SUCCESS);
214 
215         omxBuffer->size = static_cast<uint32_t>(sizeof(OmxCodecBuffer));
216         omxBuffer->version = version_;
217         omxBuffer->bufferLen = static_cast<uint32_t>(sizeof(BufferHandle));
218         omxBuffer->buffer = reinterpret_cast<uint8_t *>(*bufferHandle);
219         omxBuffer->allocLen = static_cast<uint32_t>(sizeof(BufferHandle));
220         omxBuffer->fenceFd = -1;
221         omxBuffer->pts = 0;
222         omxBuffer->flag = 0;
223     }
224 
SetUpTestCase()225     static void SetUpTestCase()
226     {
227         manager_ = GetCodecComponentManager();
228         gralloc_ = IDisplayBuffer::Get();
229         if (manager_ == nullptr) {
230             std::cout<<"GetCodecComponentManager ret nullptr"<<std::endl;
231             return;
232         }
233         auto count = manager_->GetComponentNum();
234         if (count > 0) {
235             CodecCompCapability *capList = reinterpret_cast<CodecCompCapability *>
236                 (OsalMemAlloc(sizeof(CodecCompCapability) * count));
237             ASSERT_TRUE(capList != nullptr);
238             auto err = manager_->GetComponentCapabilityList(capList, count);
239             ASSERT_TRUE(err == HDF_SUCCESS);
240             compName_ = capList[0].compName;
241             OsalMemFree(capList);
242             capList = nullptr;
243         }
244     }
TearDownTestCase()245     static void TearDownTestCase()
246     {
247         CodecComponentManagerRelease();
248         manager_ = nullptr;
249     }
SetUp()250     void SetUp()
251     {
252         if (manager_ == nullptr) {
253             return;
254         }
255         callback_ = CodecCallbackTypeGet(nullptr);
256         if (callback_ == nullptr) {
257             return;
258         }
259         if (compName_.empty()) {
260             return;
261         }
262 
263         auto ret = manager_->CreateComponent(&component_, &componentId_, compName_.data(),
264                                              reinterpret_cast<int64_t>(this), callback_);
265         if (ret != HDF_SUCCESS) {
266             return;
267         }
268         struct CompVerInfo verInfo;
269         ret = component_->GetComponentVersion(component_, &verInfo);
270         if (ret != HDF_SUCCESS) {
271             return;
272         }
273         version_ = verInfo.compVersion;
274     }
TearDown()275     void TearDown()
276     {
277         if (manager_ != nullptr && component_ != nullptr) {
278             manager_->DestroyComponent(componentId_);
279             CodecComponentTypeRelease(component_);
280         }
281         if (callback_ != nullptr) {
282             CodecCallbackTypeRelease(callback_);
283             callback_ = nullptr;
284         }
285     }
286 
287 public:
288     struct CodecComponentType *component_ = nullptr;
289     uint32_t componentId_ = 0;
290     struct CodecCallbackType *callback_ = nullptr;
291 
292     static inline struct CodecComponentManager *manager_ = nullptr;
293     static inline std::string compName_ = "";
294     union OMX_VERSIONTYPE version_;
295     std::map<int32_t, std::shared_ptr<BufferInfo>> inputBuffers_;
296     std::map<int32_t, std::shared_ptr<BufferInfo>> outputBuffers_;
297 };
298 
299 // Test GetComponentVersion
300 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetVersionTest_001, TestSize.Level1)
301 {
302     ASSERT_TRUE(component_ != nullptr);
303     struct CompVerInfo verInfo;
304     auto ret = component_->GetComponentVersion(component_, &verInfo);
305     ASSERT_EQ(ret, HDF_SUCCESS);
306 }
307 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetVersionTest_002, TestSize.Level1)
308 {
309     ASSERT_TRUE(component_ != nullptr);
310     auto ret = component_->GetComponentVersion(component_, nullptr);
311     ASSERT_NE(ret, HDF_SUCCESS);
312 }
313 
314 #ifdef SUPPORT_OMX
315 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetParameterTest_001, TestSize.Level1)
316 {
317     ASSERT_TRUE(component_ != nullptr);
318     CodecVideoPortFormatParam pixFormat;
319     InitExtParam(pixFormat);
320     pixFormat.portIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT);
321     pixFormat.codecColorIndex = 0;
322     auto ret = component_->GetParameter(component_, OMX_IndexCodecVideoPortFormat,
323                                         reinterpret_cast<int8_t *>(&pixFormat), sizeof(pixFormat));
324     ASSERT_EQ(ret, HDF_SUCCESS);
325 }
326 
327 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetParameterTest_002, TestSize.Level1)
328 {
329     ASSERT_TRUE(component_ != nullptr);
330     CodecVideoPortFormatParam pixFormat;
331     InitExtParam(pixFormat);
332     pixFormat.portIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT);
333     pixFormat.codecColorIndex = 0;
334     auto ret = component_->GetParameter(component_, OMX_IndexCodecVideoPortFormat,
335                                         reinterpret_cast<int8_t *>(&pixFormat), sizeof(pixFormat));
336     ASSERT_EQ(ret, HDF_SUCCESS);
337 }
338 #endif
339 
340 // Test GetParameter
341 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetParameterTest_003, TestSize.Level1)
342 {
343     ASSERT_TRUE(component_ != nullptr);
344     auto ret = component_->GetParameter(component_, OMX_IndexParamVideoPortFormat, nullptr, 0);
345     ASSERT_NE(ret, HDF_SUCCESS);
346 }
347 
348 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetParameterTest_004, TestSize.Level1)
349 {
350     ASSERT_TRUE(component_ != nullptr);
351     OMX_VIDEO_PARAM_PORTFORMATTYPE param;
352     InitParam(param);
353     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT);
354     param.eCompressionFormat = OMX_VIDEO_CodingAVC;
355     auto ret = component_->GetParameter(component_, OMX_IndexParamVideoPortFormat, reinterpret_cast<int8_t *>(&param),
356                                         sizeof(param));
357     ASSERT_EQ(ret, HDF_SUCCESS);
358 }
359 
360 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetParameterTest_005, TestSize.Level1)
361 {
362     ASSERT_TRUE(component_ != nullptr);
363     OMX_VIDEO_PARAM_PORTFORMATTYPE param;
364     int32_t ret = memset_s(&param, sizeof(param), 0, sizeof(param));
365     ASSERT_EQ(ret, EOK);
366     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT);
367     param.eCompressionFormat = OMX_VIDEO_CodingAVC;
368     ret = component_->GetParameter(component_, OMX_IndexParamVideoPortFormat, reinterpret_cast<int8_t *>(&param),
369                                         sizeof(param));
370     ASSERT_NE(ret, HDF_SUCCESS);
371 }
372 
373 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetParameterTest_006, TestSize.Level1)
374 {
375     ASSERT_TRUE(component_ != nullptr);
376     OMX_VIDEO_CONFIG_BITRATETYPE param;
377     InitParam(param);
378     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT);
379     auto ret = component_->GetParameter(component_, OMX_IndexParamVideoPortFormat, reinterpret_cast<int8_t *>(&param),
380                                         sizeof(param));
381     ASSERT_NE(ret, HDF_SUCCESS);
382 }
383 
384 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetParameterTest_007, TestSize.Level1)
385 {
386     ASSERT_TRUE(component_ != nullptr);
387     OMX_VIDEO_CONFIG_BITRATETYPE param;
388     InitParam(param);
389     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT);
390     auto ret = component_->GetParameter(component_, OMX_IndexVideoStartUnused, reinterpret_cast<int8_t *>(&param),
391                                         sizeof(param));
392     ASSERT_NE(ret, HDF_SUCCESS);
393 }
394 
395 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetParameterTest_001, TestSize.Level1)
396 {
397     ASSERT_TRUE(component_ != nullptr);
398     OMX_VIDEO_PARAM_PORTFORMATTYPE param;
399     InitParam(param);
400     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT);
401     auto ret = component_->SetParameter(component_, OMX_IndexParamVideoPortFormat, reinterpret_cast<int8_t *>(&param),
402                                         sizeof(param));
403     ASSERT_EQ(ret, HDF_SUCCESS);
404 }
405 
406 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetParameterTest_002, TestSize.Level1)
407 {
408     ASSERT_TRUE(component_ != nullptr);
409     OMX_VIDEO_PARAM_PORTFORMATTYPE param;
410     int32_t ret = memset_s(&param, sizeof(param), 0, sizeof(param));
411     ASSERT_EQ(ret, EOK);
412     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT);
413     ret = component_->SetParameter(component_, OMX_IndexParamVideoPortFormat, reinterpret_cast<int8_t *>(&param),
414                                         sizeof(param));
415     ASSERT_NE(ret, HDF_SUCCESS);
416 }
417 
418 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetParameterTest_003, TestSize.Level1)
419 {
420     ASSERT_TRUE(component_ != nullptr);
421     auto ret = component_->SetParameter(component_, OMX_IndexParamVideoPortFormat, nullptr, 0);
422     ASSERT_NE(ret, HDF_SUCCESS);
423 }
424 
425 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetParameterTest_004, TestSize.Level1)
426 {
427     ASSERT_TRUE(component_ != nullptr);
428     OMX_VIDEO_CONFIG_BITRATETYPE param;
429     InitParam(param);
430     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT);
431     auto ret = component_->SetParameter(component_, OMX_IndexParamVideoPortFormat, reinterpret_cast<int8_t *>(&param),
432                                         sizeof(param));
433     ASSERT_NE(ret, HDF_SUCCESS);
434 }
435 
436 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetParameterTest_005, TestSize.Level1)
437 {
438     ASSERT_TRUE(component_ != nullptr);
439     OMX_VIDEO_PARAM_PORTFORMATTYPE param;
440     InitParam(param);
441     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT);
442     auto ret = component_->SetParameter(component_, OMX_IndexVideoStartUnused, reinterpret_cast<int8_t *>(&param),
443                                         sizeof(param));
444     ASSERT_NE(ret, HDF_SUCCESS);
445 }
446 
447 #ifdef SUPPORT_OMX
448 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetParameterTest_006, TestSize.Level1)
449 {
450     ASSERT_TRUE(component_ != nullptr);
451     CodecVideoPortFormatParam pixFormat;
452     InitExtParam(pixFormat);
453     pixFormat.portIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT);
454     pixFormat.codecColorIndex = 0;
455     auto ret = component_->GetParameter(component_, OMX_IndexCodecVideoPortFormat,
456                                         reinterpret_cast<int8_t *>(&pixFormat), sizeof(pixFormat));
457     ASSERT_EQ(ret, HDF_SUCCESS);
458     pixFormat.codecColorFormat = PIXEL_FMT_RGB_555;
459     ret = component_->SetParameter(component_, OMX_IndexCodecVideoPortFormat, reinterpret_cast<int8_t *>(&pixFormat),
460                                    sizeof(pixFormat));
461     ASSERT_EQ(ret, HDF_SUCCESS);
462 }
463 #endif
464 
465 // Test GetConfig
466 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetConfigTest_001, TestSize.Level1)
467 {
468     ASSERT_TRUE(component_ != nullptr);
469     OMX_VIDEO_CONFIG_BITRATETYPE param;
470     InitParam(param);
471     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT);
472     auto ret = component_->GetConfig(component_, OMX_IndexConfigVideoBitrate, reinterpret_cast<int8_t *>(&param),
473                                      sizeof(param));
474     ASSERT_EQ(ret, HDF_SUCCESS);
475 }
476 
477 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetConfigTest_002, TestSize.Level1)
478 {
479     ASSERT_TRUE(component_ != nullptr);
480     OMX_VIDEO_CONFIG_BITRATETYPE param;
481     InitParam(param);
482     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT);
483     auto ret = component_->GetConfig(component_, OMX_IndexConfigVideoBitrate, reinterpret_cast<int8_t *>(&param),
484                                      sizeof(param));
485     ASSERT_NE(ret, HDF_SUCCESS);
486 }
487 
488 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetConfigTest_003, TestSize.Level1)
489 {
490     ASSERT_TRUE(component_ != nullptr);
491     auto ret = component_->GetConfig(component_, OMX_IndexConfigVideoBitrate, nullptr, 0);
492     ASSERT_NE(ret, HDF_SUCCESS);
493 }
494 
495 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetConfigTest_004, TestSize.Level1)
496 {
497     ASSERT_TRUE(component_ != nullptr);
498     OMX_VIDEO_CONFIG_BITRATETYPE param;
499     InitParam(param);
500     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT);
501     auto ret = component_->GetConfig(component_, OMX_IndexVideoStartUnused,
502         reinterpret_cast<int8_t *>(&param), sizeof(param));
503     ASSERT_NE(ret, HDF_SUCCESS);
504 }
505 
506 // Test SetConfig
507 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetConfigTest_001, TestSize.Level1)
508 {
509     ASSERT_TRUE(component_ != nullptr);
510     OMX_VIDEO_CONFIG_BITRATETYPE param;
511     InitParam(param);
512     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT);
513     param.nEncodeBitrate = FRAMERATE;
514     auto ret = component_->SetConfig(component_, OMX_IndexConfigVideoBitrate, reinterpret_cast<int8_t *>(&param),
515                                      sizeof(param));
516     ASSERT_EQ(ret, HDF_SUCCESS);
517 }
518 
519 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetConfigTest_002, TestSize.Level1)
520 {
521     ASSERT_TRUE(component_ != nullptr);
522     OMX_VIDEO_CONFIG_BITRATETYPE param;
523     InitParam(param);
524     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT);
525     param.nEncodeBitrate = FRAMERATE;
526     auto ret = component_->SetConfig(component_, OMX_IndexConfigVideoBitrate, reinterpret_cast<int8_t *>(&param),
527                                      sizeof(param));
528     ASSERT_NE(ret, HDF_SUCCESS);
529 }
530 
531 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetConfigTest_003, TestSize.Level1)
532 {
533     ASSERT_TRUE(component_ != nullptr);
534     auto ret = component_->SetConfig(component_, OMX_IndexConfigVideoBitrate, nullptr, 0);
535     ASSERT_NE(ret, HDF_SUCCESS);
536 }
537 
538 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetConfigTest_004, TestSize.Level1)
539 {
540     ASSERT_TRUE(component_ != nullptr);
541     OMX_VIDEO_CONFIG_BITRATETYPE param;
542     InitParam(param);
543     param.nPortIndex = static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT);
544     auto ret = component_->SetConfig(component_, OMX_IndexVideoStartUnused,
545         reinterpret_cast<int8_t *>(&param), sizeof(param));
546     ASSERT_NE(ret, HDF_SUCCESS);
547 }
548 
549 #ifdef SUPPORT_OMX
550 // Test GetExtensionIndex
551 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetExtensionIndexTest_001, TestSize.Level1)
552 {
553     ASSERT_TRUE(component_ != nullptr);
554     OMX_INDEXTYPE indexType;
555     auto ret = component_->GetExtensionIndex(component_, "OMX.Topaz.index.param.extended_video",
556         reinterpret_cast<uint32_t *>(&indexType));
557     ASSERT_EQ(ret, HDF_SUCCESS);
558 }
559 #endif
560 
561 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetExtensionIndexTest_002, TestSize.Level1)
562 {
563     ASSERT_TRUE(component_ != nullptr);
564     OMX_INDEXTYPE indexType;
565     auto ret = component_->GetExtensionIndex(component_, nullptr, reinterpret_cast<uint32_t *>(&indexType));
566     ASSERT_NE(ret, HDF_SUCCESS);
567 }
568 
569 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetExtensionIndexTest_003, TestSize.Level1)
570 {
571     ASSERT_TRUE(component_ != nullptr);
572     OMX_INDEXTYPE indexType;
573     auto ret = component_->GetExtensionIndex(component_, "OMX.Topaz.index.param.extended_test",
574         reinterpret_cast<uint32_t *>(&indexType));
575     ASSERT_NE(ret, HDF_SUCCESS);
576 }
577 
578 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetExtensionIndexTest_004, TestSize.Level1)
579 {
580     ASSERT_TRUE(component_ != nullptr);
581     auto ret = component_->GetExtensionIndex(component_, "OMX.Topaz.index.param.extended_video", nullptr);
582     ASSERT_NE(ret, HDF_SUCCESS);
583 }
584 
585 // Test GetState
586 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetStateTest_001, TestSize.Level1)
587 {
588     ASSERT_TRUE(component_ != nullptr);
589     OMX_STATETYPE state;
590     auto ret = component_->GetState(component_, &state);
591     ASSERT_EQ(state, OMX_StateLoaded);
592     ASSERT_EQ(ret, HDF_SUCCESS);
593 }
594 
595 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetStateTest_002, TestSize.Level1)
596 {
597     ASSERT_TRUE(component_ != nullptr);
598     auto ret = component_->GetState(component_, nullptr);
599     ASSERT_NE(ret, HDF_SUCCESS);
600 }
601 
602 #ifdef SUPPORT_OMX
603 // Test ComponentTunnelRequest
604 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiTunnelRequestTest_001, TestSize.Level1)
605 {
606     ASSERT_TRUE(component_ != nullptr);
607     const int32_t tunneledComp = 1002;
608     const uint32_t tunneledPort = 101;
609     OMX_TUNNELSETUPTYPE tunnelSetup;
610     tunnelSetup.eSupplier = OMX_BufferSupplyInput;
611 
612     auto ret = component_->ComponentTunnelRequest(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT),
613         tunneledComp, tunneledPort, &tunnelSetup);
614     ASSERT_NE(ret, HDF_SUCCESS);
615 }
616 #endif
617 
618 // Test SendCommand
619 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiLoadedToExecutingTest_001, TestSize.Level1)
620 {
621     ASSERT_TRUE(component_ != nullptr);
622     auto ret = component_->SendCommand(component_, OMX_CommandStateSet, OMX_StateExecuting, nullptr, 0);
623     ASSERT_EQ(ret, HDF_SUCCESS);
624 }
625 
626 struct OmxCodecBuffer allocBuffer;
627 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiAllocateBufferTest_001, TestSize.Level1)
628 {
629     ASSERT_TRUE(component_ != nullptr);
630     InitCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_INVALID, version_);
631     auto ret = component_->AllocateBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT),
632         &allocBuffer);
633     ASSERT_NE(ret, HDF_SUCCESS);
634 }
635 
636 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiAllocateBufferTest_002, TestSize.Level1)
637 {
638     ASSERT_TRUE(component_ != nullptr);
639     InitCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_VIRTUAL_ADDR, version_);
640     auto ret = component_->AllocateBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT),
641         &allocBuffer);
642     ASSERT_NE(ret, HDF_SUCCESS);
643 }
644 
645 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiAllocateBufferTest_003, TestSize.Level1)
646 {
647     ASSERT_TRUE(component_ != nullptr);
648     InitCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_INVALID, version_);
649     auto ret = component_->AllocateBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT),
650         &allocBuffer);
651     ASSERT_NE(ret, HDF_SUCCESS);
652 }
653 
654 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiAllocateBufferTest_004, TestSize.Level1)
655 {
656     ASSERT_TRUE(component_ != nullptr);
657     InitCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_VIRTUAL_ADDR, version_);
658     auto ret = component_->AllocateBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT),
659         &allocBuffer);
660     ASSERT_NE(ret, HDF_SUCCESS);
661 }
662 
663 // Test UseBuffer
664 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_001, TestSize.Level1)
665 {
666     ASSERT_TRUE(component_ != nullptr);
667     std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
668     ASSERT_TRUE(omxBuffer != nullptr);
669     omxBuffer->size = sizeof(OmxCodecBuffer);
670     omxBuffer->version = version_;
671     omxBuffer->bufferType = CODEC_BUFFER_TYPE_INVALID;
672     omxBuffer->bufferLen = 0;
673     omxBuffer->buffer = nullptr;
674     omxBuffer->allocLen = 0;
675     omxBuffer->fenceFd = -1;
676     omxBuffer->pts = 0;
677     omxBuffer->flag = 0;
678 
679     auto err = component_->UseBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT), omxBuffer.get());
680     ASSERT_NE(err, HDF_SUCCESS);
681 }
682 
683 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_002, TestSize.Level1)
684 {
685     ASSERT_TRUE(component_ != nullptr);
686     std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
687     ASSERT_TRUE(omxBuffer != nullptr);
688     omxBuffer->size = sizeof(OmxCodecBuffer);
689     omxBuffer->version = version_;
690     omxBuffer->bufferType = CODEC_BUFFER_TYPE_INVALID;
691     omxBuffer->bufferLen = 0;
692     omxBuffer->buffer = nullptr;
693     omxBuffer->allocLen = 0;
694     omxBuffer->fenceFd = -1;
695     omxBuffer->pts = 0;
696     omxBuffer->flag = 0;
697 
698     auto err = component_->UseBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT), omxBuffer.get());
699     ASSERT_NE(err, HDF_SUCCESS);
700 }
701 
702 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_003, TestSize.Level1)
703 {
704     ASSERT_TRUE(component_ != nullptr);
705     std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
706     ASSERT_TRUE(omxBuffer != nullptr);
707     omxBuffer->size = sizeof(OmxCodecBuffer);
708     omxBuffer->version = version_;
709     omxBuffer->bufferType = CODEC_BUFFER_TYPE_VIRTUAL_ADDR;
710     omxBuffer->bufferLen = 0;
711     omxBuffer->buffer = nullptr;
712     omxBuffer->allocLen = 0;
713     omxBuffer->fenceFd = -1;
714     omxBuffer->pts = 0;
715     omxBuffer->flag = 0;
716 
717     auto err = component_->UseBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT), omxBuffer.get());
718     ASSERT_NE(err, HDF_SUCCESS);
719 }
720 
721 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_004, TestSize.Level1)
722 {
723     ASSERT_TRUE(component_ != nullptr);
724     std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
725     ASSERT_TRUE(omxBuffer != nullptr);
726     omxBuffer->size = sizeof(OmxCodecBuffer);
727     omxBuffer->version = version_;
728     omxBuffer->bufferType = CODEC_BUFFER_TYPE_VIRTUAL_ADDR;
729     omxBuffer->bufferLen = 0;
730     omxBuffer->buffer = nullptr;
731     omxBuffer->allocLen = 0;
732     omxBuffer->fenceFd = -1;
733     omxBuffer->pts = 0;
734     omxBuffer->flag = 0;
735 
736     auto err = component_->UseBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT), omxBuffer.get());
737     ASSERT_NE(err, HDF_SUCCESS);
738 }
739 
740 #ifdef SUPPORT_OMX
741 // Use buffer on input index
742 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_005, TestSize.Level1)
743 {
744     ASSERT_TRUE(component_ != nullptr);
745     OMX_PARAM_PORTDEFINITIONTYPE param;
746     InitParam(param);
747     param.nPortIndex = static_cast<OMX_U32>(PortIndex::PORT_INDEX_INPUT);
748     auto err = component_->GetParameter(component_, OMX_IndexParamPortDefinition, reinterpret_cast<int8_t *>(&param),
749         sizeof(param));
750     ASSERT_EQ(err, HDF_SUCCESS);
751 
752     int32_t bufferSize = param.nBufferSize;
753     int32_t bufferCount = param.nBufferCountActual;
754     auto ret = UseBufferOnPort(PortIndex::PORT_INDEX_INPUT, bufferCount, bufferSize);
755     ASSERT_TRUE(ret);
756     FreeBufferOnPort(PortIndex::PORT_INDEX_INPUT);
757 }
758 
759 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_006, TestSize.Level1)
760 {
761     ASSERT_TRUE(component_ != nullptr);
762     auto err = component_->SendCommand(component_, OMX_CommandStateSet, OMX_StateIdle, NULL, 0);
763     ASSERT_EQ(err, HDF_SUCCESS);
764 
765     std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
766     ASSERT_TRUE(omxBuffer != nullptr);
767     BufferHandle *bufferHandle = nullptr;
768     InitBufferHandle(omxBuffer, &bufferHandle);
769     omxBuffer->bufferType = CODEC_BUFFER_TYPE_HANDLE;
770 
771     err = component_->UseBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT), omxBuffer.get());
772     if (err != HDF_SUCCESS) {
773         HDF_LOGE("%{public}s failed to UseBuffer with  input port", __func__);
774         omxBuffer = nullptr;
775     }
776     ASSERT_EQ(err, HDF_SUCCESS);
777     omxBuffer->bufferLen = 0;
778     std::shared_ptr<BufferInfo> bufferInfo = std::make_shared<BufferInfo>();
779     ASSERT_TRUE(bufferInfo != nullptr);
780     bufferInfo->omxBuffer = omxBuffer;
781     bufferInfo->bufferHandle = bufferHandle;
782     inputBuffers_.emplace(std::make_pair(omxBuffer->bufferId, bufferInfo));
783     FreeBufferOnPort(PortIndex::PORT_INDEX_INPUT);
784 }
785 
786 // Use Buffer on output index
787 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_007, TestSize.Level1)
788 {
789     ASSERT_TRUE(component_ != nullptr);
790     OMX_PARAM_PORTDEFINITIONTYPE param;
791     InitParam(param);
792     param.nPortIndex = static_cast<OMX_U32>(PortIndex::PORT_INDEX_OUTPUT);
793     auto err = component_->GetParameter(component_, OMX_IndexParamPortDefinition, reinterpret_cast<int8_t *>(&param),
794         sizeof(param));
795     ASSERT_EQ(err, HDF_SUCCESS);
796 
797     int32_t bufferSize = param.nBufferSize;
798     int32_t bufferCount = param.nBufferCountActual;
799     bool ret = UseBufferOnPort(PortIndex::PORT_INDEX_OUTPUT, bufferCount, bufferSize);
800     ASSERT_TRUE(ret);
801     ret = FreeBufferOnPort(PortIndex::PORT_INDEX_OUTPUT);
802     ASSERT_TRUE(ret);
803 }
804 
805 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_008, TestSize.Level1)
806 {
807     ASSERT_TRUE(component_ != nullptr);
808     auto err = component_->SendCommand(component_, OMX_CommandStateSet, OMX_StateIdle, NULL, 0);
809     ASSERT_EQ(err, HDF_SUCCESS);
810     std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
811     ASSERT_TRUE(omxBuffer != nullptr);
812     omxBuffer->size = sizeof(OmxCodecBuffer);
813     omxBuffer->version = version_;
814     omxBuffer->bufferType = CODEC_BUFFER_TYPE_DYNAMIC_HANDLE;
815     omxBuffer->bufferLen = 0;
816     omxBuffer->buffer = nullptr;
817     omxBuffer->allocLen = 0;
818     omxBuffer->fenceFd = -1;
819     omxBuffer->pts = 0;
820     omxBuffer->flag = 0;
821 
822     err = component_->UseBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT), omxBuffer.get());
823     if (err != HDF_SUCCESS) {
824         HDF_LOGE("%{public}s failed to UseBuffer with  input port", __func__);
825         omxBuffer = nullptr;
826     }
827     ASSERT_EQ(err, HDF_SUCCESS);
828     omxBuffer->bufferLen = 0;
829     std::shared_ptr<BufferInfo> bufferInfo = std::make_shared<BufferInfo>();
830     ASSERT_TRUE(bufferInfo != nullptr);
831     bufferInfo->omxBuffer = omxBuffer;
832     outputBuffers_.emplace(std::make_pair(omxBuffer->bufferId, bufferInfo));
833     FreeBufferOnPort(PortIndex::PORT_INDEX_OUTPUT);
834 }
835 
836 // Use buffer on input index error when OMX_ErrorInsufficientResources
837 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_009, TestSize.Level1)
838 {
839     ASSERT_TRUE(component_ != nullptr);
840     OMX_PARAM_PORTDEFINITIONTYPE param;
841     InitParam(param);
842     param.nPortIndex = static_cast<OMX_U32>(PortIndex::PORT_INDEX_INPUT);
843     auto err = component_->GetParameter(component_, OMX_IndexParamPortDefinition, reinterpret_cast<int8_t *>(&param),
844         sizeof(param));
845     ASSERT_EQ(err, HDF_SUCCESS);
846 
847     bool ret = UseBufferOnPort(PortIndex::PORT_INDEX_INPUT, param.nBufferCountActual, param.nBufferSize);
848     ASSERT_TRUE(ret);
849     ret = UseBufferOnPort(PortIndex::PORT_INDEX_INPUT, 1, param.nBufferSize);
850     FreeBufferOnPort(PortIndex::PORT_INDEX_INPUT);
851     ASSERT_FALSE(ret);
852 }
853 // Use buffer on output index error when OMX_ErrorInsufficientResources
854 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_010, TestSize.Level1)
855 {
856     ASSERT_TRUE(component_ != nullptr);
857     OMX_PARAM_PORTDEFINITIONTYPE param;
858     InitParam(param);
859     param.nPortIndex = static_cast<OMX_U32>(PortIndex::PORT_INDEX_OUTPUT);
860     auto err = component_->GetParameter(component_, OMX_IndexParamPortDefinition, reinterpret_cast<int8_t *>(&param),
861         sizeof(param));
862     ASSERT_EQ(err, HDF_SUCCESS);
863     bool ret = UseBufferOnPort(PortIndex::PORT_INDEX_OUTPUT, param.nBufferCountActual, param.nBufferSize);
864     ASSERT_TRUE(ret);
865     ret = UseBufferOnPort(PortIndex::PORT_INDEX_OUTPUT, 1, param.nBufferSize);
866     FreeBufferOnPort(PortIndex::PORT_INDEX_OUTPUT);
867     ASSERT_FALSE(ret);
868 }
869 
870 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiAllocateBufferTest_005, TestSize.Level1)
871 {
872     ASSERT_TRUE(component_ != nullptr);
873     auto err = component_->SendCommand(component_, OMX_CommandStateSet, OMX_StateIdle, NULL, 0);
874     ASSERT_EQ(err, HDF_SUCCESS);
875     InitCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD, version_);
876     err = component_->AllocateBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT), &allocBuffer);
877     ASSERT_EQ(err, HDF_SUCCESS);
878     err = component_->FreeBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT), &allocBuffer);
879     ASSERT_EQ(err, HDF_SUCCESS);
880 }
881 
882 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiAllocateBufferTest_006, TestSize.Level1)
883 {
884     ASSERT_TRUE(component_ != nullptr);
885     auto err = component_->SendCommand(component_, OMX_CommandStateSet, OMX_StateIdle, NULL, 0);
886     ASSERT_EQ(err, HDF_SUCCESS);
887     InitCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD, version_);
888     allocBuffer.type = READ_WRITE_TYPE;
889     err = component_->AllocateBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT), &allocBuffer);
890     ASSERT_EQ(err, HDF_SUCCESS);
891     err = component_->FreeBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT), &allocBuffer);
892     ASSERT_EQ(err, HDF_SUCCESS);
893 }
894 #endif
895 
896 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_011, TestSize.Level1)
897 {
898     ASSERT_TRUE(component_ != nullptr);
899     std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
900     ASSERT_TRUE(omxBuffer != nullptr);
901     BufferHandle *bufferHandle = nullptr;
902     InitBufferHandle(omxBuffer, &bufferHandle);
903     omxBuffer->bufferType = CODEC_BUFFER_TYPE_INVALID;
904     auto err = component_->UseBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT), omxBuffer.get());
905     ASSERT_NE(err, HDF_SUCCESS);
906 }
907 
908 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_012, TestSize.Level1)
909 {
910     ASSERT_TRUE(component_ != nullptr);
911     std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
912     ASSERT_TRUE(omxBuffer != nullptr);
913     BufferHandle *bufferHandle = nullptr;
914     InitBufferHandle(omxBuffer, &bufferHandle);
915     omxBuffer->bufferType = CODEC_BUFFER_TYPE_DYNAMIC_HANDLE;
916     omxBuffer->fenceFd = ERROR_FENCEFD;
917     auto err = component_->UseBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT), omxBuffer.get());
918     ASSERT_NE(err, HDF_SUCCESS);
919 }
920 
921 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_013, TestSize.Level1)
922 {
923     ASSERT_TRUE(component_ != nullptr);
924     std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
925     ASSERT_TRUE(omxBuffer != nullptr);
926     auto err = component_->UseBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT), omxBuffer.get());
927     ASSERT_NE(err, HDF_SUCCESS);
928 
929     omxBuffer->bufferType = CODEC_BUFFER_TYPE_DYNAMIC_HANDLE;
930     err = component_->UseBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT), omxBuffer.get());
931     ASSERT_NE(err, HDF_SUCCESS);
932 
933     omxBuffer->bufferLen = BUFFER_LEN;
934     err = component_->UseBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT), omxBuffer.get());
935     ASSERT_NE(err, HDF_SUCCESS);
936 
937     omxBuffer->fenceFd = ERROR_FENCEFD;
938     err = component_->UseBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT), omxBuffer.get());
939     ASSERT_NE(err, HDF_SUCCESS);
940 }
941 
942 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseEglImageTest_001, TestSize.Level1)
943 {
944     ASSERT_TRUE(component_ != nullptr);
945     struct OmxCodecBuffer buffer;
946     buffer.fenceFd = -1;
947     buffer.version = version_;
948     buffer.bufferType = CODEC_BUFFER_TYPE_AVSHARE_MEM_FD;
949     buffer.allocLen = BUFFER_SIZE;
950     buffer.buffer = 0;
951     buffer.bufferLen = 0;
952     buffer.pts = 0;
953     buffer.flag = 0;
954     buffer.type = READ_ONLY_TYPE;
955     auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
956     ASSERT_TRUE(eglImage != nullptr);
957     auto ret = component_->UseEglImage(component_, &buffer, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT),
958         eglImage.get(), BUFFER_SIZE);
959     ASSERT_NE(ret, HDF_SUCCESS);
960     eglImage = nullptr;
961 }
962 
963 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiBufferFillAndEmptyTest_001, TestSize.Level1)
964 {
965     ASSERT_TRUE(component_ != nullptr);
966     auto err = component_->SendCommand(component_, OMX_CommandStateSet, OMX_StateIdle, NULL, 0);
967     ASSERT_EQ(err, HDF_SUCCESS);
968     OMX_PARAM_PORTDEFINITIONTYPE param;
969     InitParam(param);
970     param.nPortIndex = static_cast<OMX_U32>(PortIndex::PORT_INDEX_INPUT);
971     err = component_->GetParameter(component_, OMX_IndexParamPortDefinition, reinterpret_cast<int8_t *>(&param),
972         sizeof(param));
973     ASSERT_EQ(err, HDF_SUCCESS);
974 
975     bool ret = UseBufferOnPort(PortIndex::PORT_INDEX_INPUT, param.nBufferCountActual, param.nBufferSize);
976     ASSERT_TRUE(ret);
977     InitParam(param);
978     param.nPortIndex = static_cast<OMX_U32>(PortIndex::PORT_INDEX_OUTPUT);
979     err = component_->GetParameter(component_, OMX_IndexParamPortDefinition, reinterpret_cast<int8_t *>(&param),
980         sizeof(param));
981     ASSERT_EQ(err, HDF_SUCCESS);
982     ret = UseBufferOnPort(PortIndex::PORT_INDEX_OUTPUT, param.nBufferCountActual, param.nBufferSize);
983     ASSERT_TRUE(ret);
984     err = component_->SendCommand(component_, OMX_CommandStateSet, OMX_StateExecuting, NULL, 0);
985 
986     waitState(OMX_StateExecuting);
987     auto iter = outputBuffers_.begin();
988     if (iter != outputBuffers_.end()) {
989         auto ret = component_->FillThisBuffer(component_, iter->second->omxBuffer.get());
990         ASSERT_EQ(ret, HDF_SUCCESS);
991     }
992     iter = inputBuffers_.begin();
993     if (iter != inputBuffers_.end()) {
994         auto ret = component_->EmptyThisBuffer(component_, iter->second->omxBuffer.get());
995         ASSERT_EQ(ret, HDF_SUCCESS);
996     }
997 
998     err = component_->SendCommand(component_, OMX_CommandStateSet, OMX_StateIdle, nullptr, 0);
999     waitState(OMX_StateIdle);
1000 
1001     err = component_->SendCommand(component_, OMX_CommandStateSet, OMX_StateLoaded, nullptr, 0);
1002     FreeBufferOnPort(PortIndex::PORT_INDEX_INPUT);
1003     FreeBufferOnPort(PortIndex::PORT_INDEX_OUTPUT);
1004 
1005     waitState(OMX_StateLoaded);
1006 }
1007 
1008 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiFillThisBufferTest_002, TestSize.Level1)
1009 {
1010     ASSERT_TRUE(component_ != nullptr);
1011     allocBuffer.bufferType = CODEC_BUFFER_TYPE_AVSHARE_MEM_FD;
1012     allocBuffer.fenceFd = -1;
1013     allocBuffer.version = version_;
1014     allocBuffer.allocLen = BUFFER_SIZE;
1015     allocBuffer.buffer = 0;
1016     allocBuffer.bufferLen = 0;
1017     allocBuffer.pts = 0;
1018     allocBuffer.flag = 0;
1019     allocBuffer.type = READ_ONLY_TYPE;
1020     allocBuffer.bufferId = BUFFER_ID_ERROR;
1021     auto ret = component_->FillThisBuffer(component_, &allocBuffer);
1022     ASSERT_NE(ret, HDF_SUCCESS);
1023 }
1024 
1025 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiEmptyThisBufferTest_002, TestSize.Level1)
1026 {
1027     ASSERT_TRUE(component_ != nullptr);
1028     allocBuffer.bufferType = CODEC_BUFFER_TYPE_AVSHARE_MEM_FD;
1029     allocBuffer.fenceFd = -1;
1030     allocBuffer.version = version_;
1031     allocBuffer.allocLen = BUFFER_SIZE;
1032     allocBuffer.buffer = 0;
1033     allocBuffer.bufferLen = 0;
1034     allocBuffer.pts = 0;
1035     allocBuffer.flag = 0;
1036     allocBuffer.type = READ_ONLY_TYPE;
1037     allocBuffer.bufferId = BUFFER_ID_ERROR;
1038     auto ret = component_->EmptyThisBuffer(component_, &allocBuffer);
1039     ASSERT_NE(ret, HDF_SUCCESS);
1040 }
1041 
1042 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetCallbackTest_001, TestSize.Level1)
1043 {
1044     ASSERT_TRUE(component_ != nullptr);
1045     if (callback_ != nullptr) {
1046         CodecCallbackTypeRelease(callback_);
1047     }
1048     callback_ = CodecCallbackTypeGet(nullptr);
1049     ASSERT_TRUE(callback_ != nullptr);
1050     auto ret = component_->SetCallbacks(component_, callback_, (int64_t)this);
1051     ASSERT_EQ(ret, HDF_SUCCESS);
1052 }
1053 
1054 #ifdef SUPPORT_OMX
1055 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiRoleEnumTest_001, TestSize.Level1)
1056 {
1057     ASSERT_TRUE(component_ != nullptr);
1058     uint8_t role[ROLE_LEN] = {0};
1059     auto ret = component_->ComponentRoleEnum(component_, role, ROLE_LEN, 0);
1060     ASSERT_EQ(ret, HDF_SUCCESS);
1061 }
1062 #endif
1063 
1064 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiRoleEnumTest_002, TestSize.Level1)
1065 {
1066     ASSERT_TRUE(component_ != nullptr);
1067     auto ret = component_->ComponentRoleEnum(component_, nullptr, 0, 0);
1068     ASSERT_NE(ret, HDF_SUCCESS);
1069 }
1070 
1071 #ifdef SUPPORT_OMX
1072 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiRoleEnumTest_003, TestSize.Level1)
1073 {
1074     ASSERT_TRUE(component_ != nullptr);
1075     uint8_t role[ROLE_LEN] = {0};
1076     auto ret = component_->ComponentRoleEnum(component_, role, ROLE_LEN, MAX_ROLE_INDEX);
1077     ASSERT_NE(ret, HDF_SUCCESS);
1078 }
1079 
1080 // Executing to Idle
1081 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiExecutingToIdleTest_001, TestSize.Level1)
1082 {
1083     ASSERT_TRUE(component_ != nullptr);
1084     auto ret = component_->SendCommand(component_, OMX_CommandStateSet, OMX_StateIdle, nullptr, 0);
1085     ASSERT_EQ(ret, HDF_SUCCESS);
1086 }
1087 #endif
1088 
1089 // Release input buffer
1090 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiFreeBufferTest_001, TestSize.Level1)
1091 {
1092     ASSERT_TRUE(component_ != nullptr);
1093     allocBuffer.bufferType = CODEC_BUFFER_TYPE_AVSHARE_MEM_FD;
1094     allocBuffer.fenceFd = -1;
1095     allocBuffer.version = version_;
1096     allocBuffer.allocLen = BUFFER_SIZE;
1097     allocBuffer.buffer = 0;
1098     allocBuffer.bufferLen = 0;
1099     allocBuffer.pts = 0;
1100     allocBuffer.flag = 0;
1101     allocBuffer.type = READ_ONLY_TYPE;
1102     allocBuffer.bufferId = BUFFER_ID_ERROR;
1103     auto ret = component_->FreeBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT), &allocBuffer);
1104     ASSERT_NE(ret, HDF_SUCCESS);
1105 }
1106 
1107 #ifdef SUPPORT_OMX
1108 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiFreeBufferTest_002, TestSize.Level1)
1109 {
1110     ASSERT_TRUE(component_ != nullptr);
1111     OMX_PARAM_PORTDEFINITIONTYPE param;
1112     InitParam(param);
1113     param.nPortIndex = static_cast<OMX_U32>(PortIndex::PORT_INDEX_OUTPUT);
1114     auto err = component_->GetParameter(component_, OMX_IndexParamPortDefinition, reinterpret_cast<int8_t *>(&param),
1115         sizeof(param));
1116     ASSERT_EQ(err, HDF_SUCCESS);
1117 
1118     int32_t bufferSize = param.nBufferSize;
1119     int32_t bufferCount = param.nBufferCountActual;
1120     auto ret = UseBufferOnPort(PortIndex::PORT_INDEX_OUTPUT, bufferCount, bufferSize);
1121     ASSERT_TRUE(ret);
1122     ret = FreeBufferOnPort(PortIndex::PORT_INDEX_OUTPUT);
1123     ASSERT_TRUE(ret);
1124 }
1125 #endif
1126 
1127 // Release input buffer
1128 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiFreeBufferTest_003, TestSize.Level1)
1129 {
1130     ASSERT_TRUE(component_ != nullptr);
1131     allocBuffer.bufferType = CODEC_BUFFER_TYPE_AVSHARE_MEM_FD;
1132     allocBuffer.fenceFd = -1;
1133     allocBuffer.version = version_;
1134     allocBuffer.allocLen = BUFFER_SIZE;
1135     allocBuffer.buffer = 0;
1136     allocBuffer.bufferLen = 0;
1137     allocBuffer.pts = 0;
1138     allocBuffer.flag = 0;
1139     allocBuffer.type = READ_ONLY_TYPE;
1140     allocBuffer.bufferId = BUFFER_ID_ERROR;
1141     auto ret = component_->FreeBuffer(component_, static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT), &allocBuffer);
1142     ASSERT_NE(ret, HDF_SUCCESS);
1143 }
1144 
1145 #ifdef SUPPORT_OMX
1146 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiFreeBufferTest_004, TestSize.Level1)
1147 {
1148     ASSERT_TRUE(component_ != nullptr);
1149     OMX_PARAM_PORTDEFINITIONTYPE param;
1150     InitParam(param);
1151     param.nPortIndex = static_cast<OMX_U32>(PortIndex::PORT_INDEX_INPUT);
1152     auto err = component_->GetParameter(component_, OMX_IndexParamPortDefinition, reinterpret_cast<int8_t *>(&param),
1153         sizeof(param));
1154     ASSERT_EQ(err, HDF_SUCCESS);
1155 
1156     int32_t bufferSize = param.nBufferSize;
1157     int32_t bufferCount = param.nBufferCountActual;
1158     auto ret = UseBufferOnPort(PortIndex::PORT_INDEX_INPUT, bufferCount, bufferSize);
1159     ASSERT_TRUE(ret);
1160     ret = FreeBufferOnPort(PortIndex::PORT_INDEX_INPUT);
1161     ASSERT_TRUE(ret);
1162 }
1163 
1164 // When ComponentDeInit, must change to Loaded State
1165 HWTEST_F(CodecHdiOmxTest, HdfCodecHdiDeInitTest_001, TestSize.Level1)
1166 {
1167     ASSERT_TRUE(component_ != nullptr);
1168     auto ret = component_->SendCommand(component_, OMX_CommandStateSet, OMX_StateLoaded, nullptr, 0);
1169     ASSERT_EQ(ret, HDF_SUCCESS);
1170     // State changed OMX_StateIdle when release all this buffer
1171     OMX_STATETYPE state = OMX_StateInvalid;
1172     do {
1173         usleep(100);
1174         ret = component_->GetState(component_, &state);
1175         ASSERT_EQ(ret, HDF_SUCCESS);
1176     } while (state != OMX_StateLoaded);
1177     ret = component_->ComponentDeInit(component_);
1178     ASSERT_EQ(ret, HDF_SUCCESS);
1179 }
1180 #endif
1181 
1182 }  // namespace
1183