1 /* 2 * Copyright (c) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by 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 <gtest/gtest.h> 17 #include <securec.h> 18 #include <servmgr_hdi.h> 19 #include <vector> 20 #include "codec_function_utils.h" 21 #include "v1_0/codec_callback_service.h" 22 23 using namespace std; 24 using namespace testing::ext; 25 using OHOS::sptr; 26 using OHOS::HDI::Base::NativeBuffer; 27 using namespace OHOS::HDI::Codec::V1_0; 28 using namespace OHOS::HDI::Display::Buffer::V1_0; 29 using namespace OHOS::HDI::Display::Composer::V1_0; 30 31 namespace { 32 constexpr CodecType TYPE = CodecType::VIDEO_ENCODER; 33 constexpr AvCodecRole ROLE = MEDIA_ROLETYPE_VIDEO_AVC; 34 static sptr<ICodecComponent> g_component = nullptr; 35 static sptr<ICodecCallback> g_callback = nullptr; 36 static sptr<ICodecComponentManager> g_manager = nullptr; 37 static OHOS::HDI::Codec::V1_0::CodecVersionType g_version; 38 static std::string g_compName = ""; 39 40 class CodecHdiOmxEncTest : public testing::Test { 41 public: SetUpTestCase()42 static void SetUpTestCase() 43 { 44 g_manager = ICodecComponentManager::Get(); 45 int32_t count = 0; 46 auto ret = g_manager->GetComponentNum(count); 47 ASSERT_EQ(ret, HDF_SUCCESS); 48 if (count <= 0) { 49 return; 50 } 51 52 std::vector<CodecCompCapability> capList; 53 auto err = g_manager->GetComponentCapabilityList(capList, count); 54 ASSERT_TRUE(err == HDF_SUCCESS); 55 for (auto cap : capList) { 56 if (cap.type == TYPE && cap.role == ROLE) { 57 g_compName = cap.compName; 58 break; 59 } 60 } 61 } 62 TearDownTestCase()63 static void TearDownTestCase() 64 { 65 g_manager = nullptr; 66 } 67 SetUp()68 void SetUp() 69 { 70 ASSERT_TRUE(g_manager != nullptr && !g_compName.empty()); 71 g_callback = new CodecCallbackService(); 72 ASSERT_TRUE(g_callback != nullptr); 73 auto ret = g_manager->CreateComponent(g_component, componentId_, g_compName.data(), APP_DATA, g_callback); 74 ASSERT_EQ(ret, HDF_SUCCESS); 75 76 struct CompVerInfo verInfo; 77 ret = g_component->GetComponentVersion(verInfo); 78 ASSERT_EQ(ret, HDF_SUCCESS); 79 g_version = verInfo.compVersion; 80 81 func_ = new FunctionUtil(g_version); 82 ASSERT_TRUE(func_ != nullptr); 83 } 84 TearDown()85 void TearDown() 86 { 87 std::vector<int8_t> cmdData; 88 if (g_component != nullptr) { 89 g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_LOADED, cmdData); 90 } 91 if (g_manager != nullptr && g_component != nullptr) { 92 g_manager->DestroyComponent(componentId_); 93 } 94 g_component = nullptr; 95 g_callback = nullptr; 96 func_ = nullptr; 97 } 98 99 public: 100 uint32_t componentId_ = 0; 101 sptr<FunctionUtil> func_ = nullptr; 102 const static uint32_t inputIndex = static_cast<uint32_t>(PortIndex::INDEX_INPUT); 103 const static uint32_t outputIndex = static_cast<uint32_t>(PortIndex::INDEX_OUTPUT); 104 }; 105 106 // Test GetComponentVersion 107 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetVersionTest_001, TestSize.Level1) 108 { 109 ASSERT_TRUE(g_component != nullptr); 110 struct CompVerInfo verInfo; 111 auto ret = g_component->GetComponentVersion(verInfo); 112 ASSERT_EQ(ret, HDF_SUCCESS); 113 } 114 115 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetParameterTest_001, TestSize.Level1) 116 { 117 ASSERT_TRUE(g_component != nullptr); 118 CodecVideoPortFormatParam pixFormat; 119 func_->InitExtParam(pixFormat); 120 pixFormat.portIndex = outputIndex; 121 pixFormat.codecColorIndex = 0; 122 123 std::vector<int8_t> inParam; 124 func_->ObjectToVector(pixFormat, inParam); 125 126 std::vector<int8_t> outParam; 127 auto ret = g_component->GetParameter(OMX_IndexCodecVideoPortFormat, inParam, outParam); 128 ASSERT_EQ(ret, HDF_SUCCESS); 129 } 130 131 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetParameterTest_002, TestSize.Level1) 132 { 133 ASSERT_TRUE(g_component != nullptr); 134 CodecVideoPortFormatParam pixFormat; 135 func_->InitExtParam(pixFormat); 136 pixFormat.portIndex = inputIndex; 137 pixFormat.codecColorIndex = 0; 138 139 std::vector<int8_t> inParam; 140 func_->ObjectToVector(pixFormat, inParam); 141 142 std::vector<int8_t> outParam; 143 auto ret = g_component->GetParameter(OMX_IndexCodecVideoPortFormat, inParam, outParam); 144 ASSERT_EQ(ret, HDF_SUCCESS); 145 } 146 147 // Test GetParameter 148 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetParameterTest_003, TestSize.Level1) 149 { 150 ASSERT_TRUE(g_component != nullptr); 151 std::vector<int8_t> inParam; 152 std::vector <int8_t> outParam; 153 auto ret = g_component->GetParameter(OMX_IndexParamVideoPortFormat, inParam, outParam); 154 ASSERT_NE(ret, HDF_SUCCESS); 155 } 156 157 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetParameterTest_004, TestSize.Level1) 158 { 159 ASSERT_TRUE(g_component != nullptr); 160 OMX_VIDEO_PARAM_PORTFORMATTYPE param; 161 func_->InitParam(param); 162 param.nPortIndex = inputIndex; 163 param.eCompressionFormat = OMX_VIDEO_CodingAVC; 164 std::vector<int8_t> inParam; 165 func_->ObjectToVector(param, inParam); 166 167 std::vector<int8_t> outParam; 168 auto ret = g_component->GetParameter(OMX_IndexCodecVideoPortFormat, inParam, outParam); 169 ASSERT_EQ(ret, HDF_SUCCESS); 170 } 171 172 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetParameterTest_005, TestSize.Level1) 173 { 174 ASSERT_TRUE(g_component != nullptr); 175 OMX_VIDEO_PARAM_PORTFORMATTYPE param; 176 int32_t ret = memset_s(¶m, sizeof(param), 0, sizeof(param)); 177 ASSERT_EQ(ret, EOK); 178 param.nPortIndex = inputIndex; 179 param.eCompressionFormat = OMX_VIDEO_CodingAVC; 180 std::vector<int8_t> inParam; 181 func_->ObjectToVector(param, inParam); 182 183 std::vector<int8_t> outParam; 184 ret = g_component->GetParameter(OMX_IndexCodecVideoPortFormat, inParam, outParam); 185 ASSERT_NE(ret, HDF_SUCCESS); 186 } 187 188 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetParameterTest_006, TestSize.Level1) 189 { 190 ASSERT_TRUE(g_component != nullptr); 191 OMX_VIDEO_CONFIG_BITRATETYPE param; 192 func_->InitParam(param); 193 param.nPortIndex = inputIndex; 194 std::vector<int8_t> inParam; 195 func_->ObjectToVector(param, inParam); 196 197 std::vector<int8_t> outParam; 198 auto ret = g_component->GetParameter(OMX_IndexCodecVideoPortFormat, inParam, outParam); 199 ASSERT_NE(ret, HDF_SUCCESS); 200 } 201 202 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetParameterTest_007, TestSize.Level1) 203 { 204 ASSERT_TRUE(g_component != nullptr); 205 OMX_VIDEO_CONFIG_BITRATETYPE param; 206 func_->InitParam(param); 207 param.nPortIndex = inputIndex; 208 std::vector<int8_t> inParam; 209 func_->ObjectToVector(param, inParam); 210 211 std::vector<int8_t> outParam; 212 auto ret = g_component->GetParameter(OMX_IndexVideoStartUnused, inParam, outParam); 213 ASSERT_NE(ret, HDF_SUCCESS); 214 } 215 216 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiSetParameterTest_001, TestSize.Level1) 217 { 218 ASSERT_TRUE(g_component != nullptr); 219 OMX_VIDEO_PARAM_PORTFORMATTYPE param; 220 func_->InitParam(param); 221 param.nPortIndex = inputIndex; 222 std::vector<int8_t> paramVec; 223 func_->ObjectToVector(param, paramVec); 224 auto ret = g_component->SetParameter(OMX_IndexParamVideoPortFormat, paramVec); 225 ASSERT_EQ(ret, HDF_SUCCESS); 226 } 227 228 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiSetParameterTest_002, TestSize.Level1) 229 { 230 ASSERT_TRUE(g_component != nullptr); 231 OMX_VIDEO_PARAM_PORTFORMATTYPE param; 232 int32_t ret = memset_s(¶m, sizeof(param), 0, sizeof(param)); 233 ASSERT_EQ(ret, EOK); 234 param.nPortIndex = inputIndex; 235 std::vector<int8_t> paramVec; 236 func_->ObjectToVector(param, paramVec); 237 ret = g_component->SetParameter(OMX_IndexParamVideoPortFormat, paramVec); 238 ASSERT_NE(ret, HDF_SUCCESS); 239 } 240 241 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiSetParameterTest_003, TestSize.Level1) 242 { 243 ASSERT_TRUE(g_component != nullptr); 244 std::vector<int8_t> paramVec; 245 auto ret = g_component->SetParameter(OMX_IndexParamVideoPortFormat, paramVec); 246 ASSERT_NE(ret, HDF_SUCCESS); 247 } 248 249 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiSetParameterTest_004, TestSize.Level1) 250 { 251 ASSERT_TRUE(g_component != nullptr); 252 OMX_VIDEO_CONFIG_BITRATETYPE param; 253 func_->InitParam(param); 254 param.nPortIndex = inputIndex; 255 std::vector<int8_t> paramVec; 256 func_->ObjectToVector(param, paramVec); 257 auto ret = g_component->SetParameter(OMX_IndexParamVideoPortFormat, paramVec); 258 ASSERT_NE(ret, HDF_SUCCESS); 259 } 260 261 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiSetParameterTest_005, TestSize.Level1) 262 { 263 ASSERT_TRUE(g_component != nullptr); 264 OMX_VIDEO_PARAM_PORTFORMATTYPE param; 265 func_->InitParam(param); 266 param.nPortIndex = inputIndex; 267 std::vector<int8_t> paramVec; 268 func_->ObjectToVector(param, paramVec); 269 auto ret = g_component->SetParameter(OMX_IndexVideoStartUnused, paramVec); 270 ASSERT_NE(ret, HDF_SUCCESS); 271 } 272 273 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiSetParameterTest_006, TestSize.Level1) 274 { 275 ASSERT_TRUE(g_component != nullptr); 276 CodecVideoPortFormatParam pixFormat; 277 func_->InitExtParam(pixFormat); 278 pixFormat.portIndex = inputIndex; 279 pixFormat.codecColorIndex = 0; 280 std::vector<int8_t> inParam; 281 func_->ObjectToVector(pixFormat, inParam); 282 283 std::vector<int8_t> outParam; 284 auto ret = g_component->GetParameter(OMX_IndexCodecVideoPortFormat, inParam, outParam); 285 ASSERT_EQ(ret, HDF_SUCCESS); 286 287 pixFormat.codecColorFormat = PIXEL_FMT_YCBCR_420_SP; 288 std::vector<int8_t> paramVec; 289 func_->ObjectToVector(pixFormat, paramVec); 290 ret = g_component->SetParameter(OMX_IndexCodecVideoPortFormat, paramVec); 291 ASSERT_EQ(ret, HDF_SUCCESS); 292 } 293 294 // Test GetConfig 295 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetConfigTest_001, TestSize.Level1) 296 { 297 ASSERT_TRUE(g_component != nullptr); 298 OMX_VIDEO_CONFIG_BITRATETYPE param; 299 func_->InitParam(param); 300 param.nPortIndex = outputIndex; 301 302 std::vector<int8_t> inParam; 303 func_->ObjectToVector(param, inParam); 304 std::vector<int8_t> outParam; 305 auto ret = g_component->GetConfig(OMX_IndexConfigVideoBitrate, inParam, outParam); 306 ASSERT_EQ(ret, HDF_SUCCESS); 307 } 308 309 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetConfigTest_002, TestSize.Level1) 310 { 311 ASSERT_TRUE(g_component != nullptr); 312 OMX_VIDEO_CONFIG_BITRATETYPE param; 313 func_->InitParam(param); 314 param.nPortIndex = inputIndex; 315 316 std::vector<int8_t> inParam; 317 func_->ObjectToVector(param, inParam); 318 std::vector<int8_t> outParam; 319 auto ret = g_component->GetConfig(OMX_IndexConfigVideoBitrate, inParam, outParam); 320 ASSERT_NE(ret, HDF_SUCCESS); 321 } 322 323 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetConfigTest_003, TestSize.Level1) 324 { 325 ASSERT_TRUE(g_component != nullptr); 326 std::vector<int8_t> inParam; 327 std::vector<int8_t> outParam; 328 auto ret = g_component->GetConfig(OMX_IndexConfigVideoBitrate, inParam, outParam); 329 ASSERT_NE(ret, HDF_SUCCESS); 330 } 331 332 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetConfigTest_004, TestSize.Level1) 333 { 334 ASSERT_TRUE(g_component != nullptr); 335 OMX_VIDEO_CONFIG_BITRATETYPE param; 336 func_->InitParam(param); 337 param.nPortIndex = outputIndex; 338 339 std::vector<int8_t> inParam; 340 func_->ObjectToVector(param, inParam); 341 std::vector<int8_t> outParam; 342 auto ret = g_component->GetConfig(OMX_IndexVideoStartUnused, inParam, outParam); 343 ASSERT_NE(ret, HDF_SUCCESS); 344 } 345 346 // Test SetConfig 347 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiSetConfigTest_001, TestSize.Level1) 348 { 349 ASSERT_TRUE(g_component != nullptr); 350 OMX_VIDEO_CONFIG_BITRATETYPE param; 351 func_->InitParam(param); 352 param.nPortIndex = outputIndex; 353 param.nEncodeBitrate = FRAMERATE; 354 355 std::vector<int8_t> inParam; 356 func_->ObjectToVector(param, inParam); 357 auto ret = g_component->SetConfig(OMX_IndexConfigVideoBitrate, inParam); 358 ASSERT_EQ(ret, HDF_SUCCESS); 359 } 360 361 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiSetConfigTest_002, TestSize.Level1) 362 { 363 ASSERT_TRUE(g_component != nullptr); 364 OMX_VIDEO_CONFIG_BITRATETYPE param; 365 func_->InitParam(param); 366 param.nPortIndex = inputIndex; 367 param.nEncodeBitrate = FRAMERATE; 368 369 std::vector<int8_t> inParam; 370 func_->ObjectToVector(param, inParam); 371 auto ret = g_component->SetConfig(OMX_IndexConfigVideoBitrate, inParam); 372 ASSERT_NE(ret, HDF_SUCCESS); 373 } 374 375 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiSetConfigTest_003, TestSize.Level1) 376 { 377 ASSERT_TRUE(g_component != nullptr); 378 std::vector<int8_t> inParam; 379 auto ret = g_component->SetConfig(OMX_IndexConfigVideoBitrate, inParam); 380 ASSERT_NE(ret, HDF_SUCCESS); 381 } 382 383 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiSetConfigTest_004, TestSize.Level1) 384 { 385 ASSERT_TRUE(g_component != nullptr); 386 OMX_VIDEO_CONFIG_BITRATETYPE param; 387 func_->InitParam(param); 388 param.nPortIndex = outputIndex; 389 390 std::vector<int8_t> inParam; 391 func_->ObjectToVector(param, inParam); 392 auto ret = g_component->SetConfig(OMX_IndexVideoStartUnused, inParam); 393 ASSERT_NE(ret, HDF_SUCCESS); 394 } 395 396 #ifdef SUPPORT_OMX_EXTEND 397 // Test GetExtensionIndex 398 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetExtensionIndexTest_001, TestSize.Level1) 399 { 400 ASSERT_TRUE(g_component != nullptr); 401 uint32_t indexType = 0; 402 auto ret = g_component->GetExtensionIndex("OMX.Topaz.index.param.extended_video", indexType); 403 ASSERT_EQ(ret, HDF_SUCCESS); 404 } 405 #endif 406 407 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetExtensionIndexTest_002, TestSize.Level1) 408 { 409 ASSERT_TRUE(g_component != nullptr); 410 uint32_t indexType = 0; 411 auto ret = g_component->GetExtensionIndex("OMX.Topaz.index.param.extended_test", indexType); 412 ASSERT_NE(ret, HDF_SUCCESS); 413 } 414 415 416 // Test GetState 417 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiGetStateTest_001, TestSize.Level1) 418 { 419 ASSERT_TRUE(g_component != nullptr); 420 CodecStateType state = CODEC_STATE_INVALID; 421 int32_t ret = g_component->GetState(state); 422 ASSERT_EQ(state, CODEC_STATE_LOADED); 423 ASSERT_EQ(ret, HDF_SUCCESS); 424 } 425 426 #ifdef SUPPORT_OMX_EXTEND 427 // Test ComponentTunnelRequest 428 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiTunnelRequestTest_001, TestSize.Level1) 429 { 430 ASSERT_TRUE(g_component != nullptr); 431 const int32_t tunneledComp = 1002; 432 const uint32_t tunneledPort = 101; 433 OHOS::HDI::Codec::V1_0::CodecTunnelSetupType tunnelSetup; 434 tunnelSetup.supplier = OHOS::HDI::Codec::V1_0::CODEC_BUFFER_SUPPLY_INPUT; 435 436 auto ret = g_component->ComponentTunnelRequest(outputIndex, tunneledComp, tunneledPort, 437 tunnelSetup, tunnelSetup); 438 ASSERT_NE(ret, HDF_SUCCESS); 439 } 440 #endif 441 442 #ifdef SUPPORT_OMX_EXTEND 443 // Test SendCommand 444 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiLoadedToIdleTest_001, TestSize.Level1) 445 { 446 ASSERT_TRUE(g_component != nullptr); 447 std::vector<int8_t> cmdData; 448 auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 449 ASSERT_EQ(ret, HDF_SUCCESS); 450 } 451 #endif 452 453 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiAllocateBufferTest_001, TestSize.Level1) 454 { 455 ASSERT_TRUE(g_component != nullptr); 456 struct OmxCodecBuffer allocBuffer; 457 func_->InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_INVALID); 458 struct OmxCodecBuffer outBuffer; 459 auto ret = g_component->AllocateBuffer(inputIndex, allocBuffer, outBuffer); 460 ASSERT_NE(ret, HDF_SUCCESS); 461 } 462 463 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiAllocateBufferTest_002, TestSize.Level1) 464 { 465 ASSERT_TRUE(g_component != nullptr); 466 struct OmxCodecBuffer allocBuffer; 467 func_->InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_VIRTUAL_ADDR); 468 struct OmxCodecBuffer outBuffer; 469 auto ret = g_component->AllocateBuffer(inputIndex, allocBuffer, outBuffer); 470 ASSERT_NE(ret, HDF_SUCCESS); 471 } 472 473 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiAllocateBufferTest_003, TestSize.Level1) 474 { 475 ASSERT_TRUE(g_component != nullptr); 476 struct OmxCodecBuffer allocBuffer; 477 func_->InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_INVALID); 478 struct OmxCodecBuffer outBuffer; 479 auto ret = g_component->AllocateBuffer(inputIndex, allocBuffer, outBuffer); 480 ASSERT_NE(ret, HDF_SUCCESS); 481 } 482 483 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiAllocateBufferTest_004, TestSize.Level1) 484 { 485 ASSERT_TRUE(g_component != nullptr); 486 struct OmxCodecBuffer allocBuffer; 487 func_->InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_VIRTUAL_ADDR); 488 struct OmxCodecBuffer outBuffer; 489 auto ret = g_component->AllocateBuffer(inputIndex, allocBuffer, outBuffer); 490 ASSERT_NE(ret, HDF_SUCCESS); 491 } 492 493 #ifdef SUPPORT_OMX_EXTEND 494 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiAllocateBufferAndFreeBufferTest_001, TestSize.Level1) 495 { 496 ASSERT_TRUE(g_component != nullptr); 497 std::vector<int8_t> cmdData; 498 auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 499 ASSERT_EQ(err, HDF_SUCCESS); 500 501 struct OmxCodecBuffer allocBuffer; 502 func_->InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD); 503 struct OmxCodecBuffer outBuffer; 504 err = g_component->AllocateBuffer(inputIndex, allocBuffer, outBuffer); 505 ASSERT_EQ(err, HDF_SUCCESS); 506 507 err = g_component->FreeBuffer(inputIndex, outBuffer); 508 ASSERT_EQ(err, HDF_SUCCESS); 509 } 510 511 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiAllocateBufferTest_006, TestSize.Level1) 512 { 513 ASSERT_TRUE(g_component != nullptr); 514 std::vector<int8_t> cmdData; 515 auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 516 ASSERT_EQ(err, HDF_SUCCESS); 517 518 struct OmxCodecBuffer allocBuffer; 519 func_->InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD); 520 allocBuffer.type = READ_WRITE_TYPE; 521 struct OmxCodecBuffer outBuffer; 522 err = g_component->AllocateBuffer(outputIndex, allocBuffer, outBuffer); 523 ASSERT_EQ(err, HDF_SUCCESS); 524 525 err = g_component->FreeBuffer(outputIndex, outBuffer); 526 ASSERT_EQ(err, HDF_SUCCESS); 527 } 528 #endif 529 530 // Test UseBuffer 531 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiUseBufferTest_001, TestSize.Level1) 532 { 533 ASSERT_TRUE(g_component != nullptr); 534 struct OmxCodecBuffer omxBuffer; 535 func_->InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_INVALID); 536 struct OmxCodecBuffer outBuffer; 537 auto ret = g_component->UseBuffer(inputIndex, omxBuffer, outBuffer); 538 ASSERT_NE(ret, HDF_SUCCESS); 539 } 540 541 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiUseBufferTest_002, TestSize.Level1) 542 { 543 ASSERT_TRUE(g_component != nullptr); 544 struct OmxCodecBuffer omxBuffer; 545 func_->InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_INVALID); 546 struct OmxCodecBuffer outBuffer; 547 auto ret = g_component->UseBuffer(outputIndex, omxBuffer, outBuffer); 548 ASSERT_NE(ret, HDF_SUCCESS); 549 } 550 551 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiUseBufferTest_003, TestSize.Level1) 552 { 553 ASSERT_TRUE(g_component != nullptr); 554 struct OmxCodecBuffer omxBuffer; 555 func_->InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_VIRTUAL_ADDR); 556 struct OmxCodecBuffer outBuffer; 557 auto ret = g_component->UseBuffer(inputIndex, omxBuffer, outBuffer); 558 ASSERT_NE(ret, HDF_SUCCESS); 559 } 560 561 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiUseBufferTest_004, TestSize.Level1) 562 { 563 ASSERT_TRUE(g_component != nullptr); 564 struct OmxCodecBuffer omxBuffer; 565 func_->InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_VIRTUAL_ADDR); 566 struct OmxCodecBuffer outBuffer; 567 auto ret = g_component->UseBuffer(outputIndex, omxBuffer, outBuffer); 568 ASSERT_NE(ret, HDF_SUCCESS); 569 } 570 571 #ifdef SUPPORT_OMX_EXTEND 572 // Use buffer on input index 573 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiUseBufferAndFreeBufferTest_001, TestSize.Level1) 574 { 575 ASSERT_TRUE(g_component != nullptr); 576 std::vector<int8_t> cmdData; 577 auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 578 ASSERT_EQ(ret, HDF_SUCCESS); 579 580 OMX_PARAM_PORTDEFINITIONTYPE param; 581 ret = func_->GetPortParameter(g_component, PortIndex::INDEX_INPUT, param); 582 ASSERT_EQ(ret, HDF_SUCCESS); 583 584 auto err = func_->UseBufferOnPort(g_component, PortIndex::INDEX_INPUT, param.nBufferCountActual, 585 param.nBufferSize); 586 ASSERT_TRUE(err); 587 err = func_->FreeBufferOnPort(g_component, PortIndex::INDEX_INPUT); 588 ASSERT_TRUE(err); 589 } 590 591 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiUseBufferAndFreeBufferTest_002, TestSize.Level1) 592 { 593 ASSERT_TRUE(g_component != nullptr); 594 std::vector<int8_t> cmdData; 595 auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 596 ASSERT_EQ(ret, HDF_SUCCESS); 597 598 std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>(); 599 func_->InitOmxCodecBuffer(*omxBuffer.get(), CODEC_BUFFER_TYPE_HANDLE); 600 auto err = func_->FillCodecBufferWithBufferHandle(omxBuffer); 601 ASSERT_TRUE(err); 602 603 OmxCodecBuffer outBuffer; 604 ret = g_component->UseBuffer(inputIndex, *omxBuffer.get(), outBuffer); 605 omxBuffer->bufferId = outBuffer.bufferId; 606 ASSERT_EQ(ret, HDF_SUCCESS); 607 ret = g_component->FreeBuffer(inputIndex, outBuffer); 608 ASSERT_EQ(ret, HDF_SUCCESS); 609 } 610 611 // Use Buffer on output index 612 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiUseBufferAndFreeBufferTest_003, TestSize.Level1) 613 { 614 ASSERT_TRUE(g_component != nullptr); 615 std::vector<int8_t> cmdData; 616 auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 617 ASSERT_EQ(ret, HDF_SUCCESS); 618 619 OMX_PARAM_PORTDEFINITIONTYPE param; 620 func_->GetPortParameter(g_component, PortIndex::INDEX_OUTPUT, param); 621 622 auto err = func_->UseBufferOnPort(g_component, PortIndex::INDEX_OUTPUT, param.nBufferCountActual, 623 param.nBufferSize); 624 ASSERT_TRUE(err); 625 err = func_->FreeBufferOnPort(g_component, PortIndex::INDEX_OUTPUT); 626 ASSERT_TRUE(err); 627 } 628 629 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiUseBufferAndFreeBufferTest_004, TestSize.Level1) 630 { 631 ASSERT_TRUE(g_component != nullptr); 632 std::vector<int8_t> cmdData; 633 auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 634 ASSERT_EQ(ret, HDF_SUCCESS); 635 std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>(); 636 func_->InitOmxCodecBuffer(*omxBuffer.get(), CODEC_BUFFER_TYPE_DYNAMIC_HANDLE); 637 638 OmxCodecBuffer outBuffer; 639 ret = g_component->UseBuffer(outputIndex, *omxBuffer.get(), outBuffer); 640 ASSERT_EQ(ret, HDF_SUCCESS); 641 ret = g_component->FreeBuffer(outputIndex, outBuffer); 642 ASSERT_EQ(ret, HDF_SUCCESS); 643 } 644 645 // Use buffer on input index error when OMX_ErrorInsufficientResources 646 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiUseBufferAndFreeBufferTest_005, TestSize.Level1) 647 { 648 ASSERT_TRUE(g_component != nullptr); 649 std::vector<int8_t> cmdData; 650 auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 651 ASSERT_EQ(ret, HDF_SUCCESS); 652 653 OMX_PARAM_PORTDEFINITIONTYPE param; 654 func_->GetPortParameter(g_component, PortIndex::INDEX_INPUT, param); 655 656 auto err = func_->UseBufferOnPort(g_component, PortIndex::INDEX_INPUT, param.nBufferCountActual, 657 param.nBufferSize); 658 ASSERT_TRUE(err); 659 err = func_->UseBufferOnPort(g_component, PortIndex::INDEX_INPUT, 1, param.nBufferSize); 660 ASSERT_FALSE(err); 661 err = func_->FreeBufferOnPort(g_component, PortIndex::INDEX_INPUT); 662 ASSERT_TRUE(err); 663 } 664 665 // Use buffer on output index error when OMX_ErrorInsufficientResources 666 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiUseBufferAndFreeBufferTest_006, TestSize.Level1) 667 { 668 ASSERT_TRUE(g_component != nullptr); 669 std::vector<int8_t> cmdData; 670 auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 671 ASSERT_EQ(ret, HDF_SUCCESS); 672 673 OMX_PARAM_PORTDEFINITIONTYPE param; 674 func_->GetPortParameter(g_component, PortIndex::INDEX_OUTPUT, param); 675 676 auto err = func_->UseBufferOnPort(g_component, PortIndex::INDEX_OUTPUT, param.nBufferCountActual, 677 param.nBufferSize); 678 ASSERT_TRUE(err); 679 err = func_->UseBufferOnPort(g_component, PortIndex::INDEX_OUTPUT, 1, param.nBufferSize); 680 ASSERT_FALSE(err); 681 err = func_->FreeBufferOnPort(g_component, PortIndex::INDEX_OUTPUT); 682 ASSERT_TRUE(err); 683 } 684 #endif 685 686 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiEmptyAndFillBufferTest_001, TestSize.Level1) 687 { 688 ASSERT_TRUE(g_component != nullptr); 689 std::vector<int8_t> cmdData; 690 auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 691 ASSERT_EQ(ret, HDF_SUCCESS); 692 693 OMX_PARAM_PORTDEFINITIONTYPE param; 694 ret = func_->GetPortParameter(g_component, PortIndex::INDEX_INPUT, param); 695 ASSERT_EQ(ret, HDF_SUCCESS); 696 auto err = func_->UseBufferOnPort(g_component, PortIndex::INDEX_INPUT, param.nBufferCountActual, 697 param.nBufferSize); 698 ASSERT_TRUE(err); 699 700 ret = func_->GetPortParameter(g_component, PortIndex::INDEX_OUTPUT, param); 701 ASSERT_EQ(ret, HDF_SUCCESS); 702 err = func_->UseBufferOnPort(g_component, PortIndex::INDEX_OUTPUT, param.nBufferCountActual, param.nBufferSize); 703 ASSERT_TRUE(err); 704 705 ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_EXECUTING, cmdData); 706 ASSERT_EQ(ret, HDF_SUCCESS); 707 err = func_->WaitState(g_component, CODEC_STATE_EXECUTING); 708 ASSERT_TRUE(err); 709 err = func_->FillAndEmptyAllBuffer(g_component, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD); 710 ASSERT_TRUE(err); 711 712 ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 713 ASSERT_EQ(ret, HDF_SUCCESS); 714 err = func_->WaitState(g_component, CODEC_STATE_IDLE); 715 ASSERT_TRUE(err); 716 ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_LOADED, cmdData); 717 ASSERT_EQ(ret, HDF_SUCCESS); 718 err = func_->WaitState(g_component, CODEC_STATE_IDLE); 719 ASSERT_TRUE(err); 720 721 err = func_->FreeBufferOnPort(g_component, PortIndex::INDEX_INPUT); 722 ASSERT_TRUE(err); 723 err = func_->FreeBufferOnPort(g_component, PortIndex::INDEX_OUTPUT); 724 ASSERT_TRUE(err); 725 err = func_->WaitState(g_component, CODEC_STATE_LOADED); 726 ASSERT_TRUE(err); 727 } 728 729 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiEmptyAndFillBufferTest_002, TestSize.Level1) 730 { 731 ASSERT_TRUE(g_component != nullptr); 732 std::vector<int8_t> cmdData; 733 auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 734 ASSERT_EQ(ret, HDF_SUCCESS); 735 736 OMX_PARAM_PORTDEFINITIONTYPE param; 737 auto err = func_->InitBufferHandleParameter(g_component, param, inputIndex, CODEC_BUFFER_TYPE_DYNAMIC_HANDLE); 738 ASSERT_TRUE(err); 739 ret = func_->GetPortParameter(g_component, PortIndex::INDEX_INPUT, param); 740 ASSERT_EQ(ret, HDF_SUCCESS); 741 err = func_->UseDynaBuffer(g_component, PortIndex::INDEX_INPUT, param.nBufferCountActual, param.nBufferSize); 742 ASSERT_TRUE(err); 743 744 ret = func_->GetPortParameter(g_component, PortIndex::INDEX_OUTPUT, param); 745 ASSERT_EQ(ret, HDF_SUCCESS); 746 err = func_->UseBufferOnPort(g_component, PortIndex::INDEX_OUTPUT, param.nBufferCountActual, param.nBufferSize); 747 ASSERT_TRUE(err); 748 749 ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_EXECUTING, cmdData); 750 ASSERT_EQ(ret, HDF_SUCCESS); 751 err = func_->WaitState(g_component, CODEC_STATE_EXECUTING); 752 ASSERT_TRUE(err); 753 err = func_->FillAndEmptyAllBuffer(g_component, CODEC_BUFFER_TYPE_DYNAMIC_HANDLE); 754 ASSERT_TRUE(err); 755 756 ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 757 ASSERT_EQ(ret, HDF_SUCCESS); 758 err = func_->WaitState(g_component, CODEC_STATE_IDLE); 759 ASSERT_TRUE(err); 760 ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_LOADED, cmdData); 761 ASSERT_EQ(ret, HDF_SUCCESS); 762 err = func_->WaitState(g_component, CODEC_STATE_IDLE); 763 ASSERT_TRUE(err); 764 765 err = func_->FreeBufferOnPort(g_component, PortIndex::INDEX_INPUT); 766 ASSERT_TRUE(err); 767 err = func_->FreeBufferOnPort(g_component, PortIndex::INDEX_OUTPUT); 768 ASSERT_TRUE(err); 769 err = func_->WaitState(g_component, CODEC_STATE_LOADED); 770 ASSERT_TRUE(err); 771 } 772 773 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiEmptyAndFillBufferTest_003, TestSize.Level1) 774 { 775 ASSERT_TRUE(g_component != nullptr); 776 std::vector<int8_t> cmdData; 777 auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 778 ASSERT_EQ(ret, HDF_SUCCESS); 779 780 OMX_PARAM_PORTDEFINITIONTYPE param; 781 ret = func_->GetPortParameter(g_component, PortIndex::INDEX_INPUT, param); 782 ASSERT_EQ(ret, HDF_SUCCESS); 783 auto err = func_->AllocateBufferOnPort(g_component, PortIndex::INDEX_INPUT, param.nBufferCountActual, 784 param.nBufferSize); 785 ASSERT_TRUE(err); 786 787 ret = func_->GetPortParameter(g_component, PortIndex::INDEX_OUTPUT, param); 788 ASSERT_EQ(ret, HDF_SUCCESS); 789 err = func_->AllocateBufferOnPort(g_component, PortIndex::INDEX_OUTPUT, param.nBufferCountActual, 790 param.nBufferSize); 791 ASSERT_TRUE(err); 792 793 ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_EXECUTING, cmdData); 794 ASSERT_EQ(ret, HDF_SUCCESS); 795 err = func_->WaitState(g_component, CODEC_STATE_EXECUTING); 796 ASSERT_TRUE(err); 797 err = func_->FillAndEmptyAllBuffer(g_component, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD); 798 ASSERT_TRUE(err); 799 800 ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 801 ASSERT_EQ(ret, HDF_SUCCESS); 802 err = func_->WaitState(g_component, CODEC_STATE_IDLE); 803 ASSERT_TRUE(err); 804 ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_LOADED, cmdData); 805 ASSERT_EQ(ret, HDF_SUCCESS); 806 err = func_->WaitState(g_component, CODEC_STATE_IDLE); 807 ASSERT_TRUE(err); 808 809 err = func_->FreeBufferOnPort(g_component, PortIndex::INDEX_INPUT); 810 ASSERT_TRUE(err); 811 err = func_->FreeBufferOnPort(g_component, PortIndex::INDEX_OUTPUT); 812 ASSERT_TRUE(err); 813 err = func_->WaitState(g_component, CODEC_STATE_LOADED); 814 ASSERT_TRUE(err); 815 } 816 817 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiUseEglImageTest_001, TestSize.Level1) 818 { 819 ASSERT_TRUE(g_component != nullptr); 820 struct OmxCodecBuffer omxBuffer; 821 func_->InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD); 822 auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE); 823 ASSERT_TRUE(eglImage != nullptr); 824 std::vector<int8_t> eglImageVec; 825 eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE); 826 struct OmxCodecBuffer outbuffer; 827 int32_t ret = g_component->UseEglImage(inputIndex, omxBuffer, outbuffer, eglImageVec); 828 ASSERT_NE(ret, HDF_SUCCESS); 829 eglImage = nullptr; 830 } 831 832 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiFillThisBufferTest_001, TestSize.Level1) 833 { 834 ASSERT_TRUE(g_component != nullptr); 835 struct OmxCodecBuffer omxBuffer; 836 func_->InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD); 837 omxBuffer.bufferId = BUFFER_ID_ERROR; 838 auto ret = g_component->FillThisBuffer(omxBuffer); 839 ASSERT_NE(ret, HDF_SUCCESS); 840 } 841 842 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiEmptyThisBufferTest_001, TestSize.Level1) 843 { 844 ASSERT_TRUE(g_component != nullptr); 845 struct OmxCodecBuffer omxBuffer; 846 func_->InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD); 847 omxBuffer.bufferId = BUFFER_ID_ERROR; 848 auto ret = g_component->EmptyThisBuffer(omxBuffer); 849 ASSERT_NE(ret, HDF_SUCCESS); 850 } 851 852 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiSetCallbackTest_001, TestSize.Level1) 853 { 854 ASSERT_TRUE(g_component != nullptr); 855 g_callback = new CodecCallbackService(); 856 ASSERT_TRUE(g_callback != nullptr); 857 auto ret = g_component->SetCallbacks(g_callback, APP_DATA); 858 ASSERT_EQ(ret, HDF_SUCCESS); 859 } 860 861 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiSetCallbackTest_002, TestSize.Level1) 862 { 863 ASSERT_TRUE(g_component != nullptr); 864 auto ret = g_component->SetCallbacks(nullptr, APP_DATA); 865 ASSERT_NE(ret, HDF_SUCCESS); 866 } 867 868 #ifdef SUPPORT_OMX_EXTEND 869 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiRoleEnumTest_001, TestSize.Level1) 870 { 871 ASSERT_TRUE(g_component != nullptr); 872 std::vector<uint8_t> role; 873 auto ret = g_component->ComponentRoleEnum(role, 0); 874 ASSERT_EQ(ret, HDF_SUCCESS); 875 } 876 #endif 877 878 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiRoleEnumTest_002, TestSize.Level1) 879 { 880 ASSERT_TRUE(g_component != nullptr); 881 std::vector<uint8_t> role; 882 auto ret = g_component->ComponentRoleEnum(role, MAX_ROLE_INDEX); 883 ASSERT_NE(ret, HDF_SUCCESS); 884 } 885 886 // Release input buffer 887 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiFreeBufferTest_001, TestSize.Level1) 888 { 889 ASSERT_TRUE(g_component != nullptr); 890 struct OmxCodecBuffer omxBuffer; 891 func_->InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD); 892 omxBuffer.bufferId = BUFFER_ID_ERROR; 893 auto ret = g_component->FreeBuffer(outputIndex, omxBuffer); 894 ASSERT_NE(ret, HDF_SUCCESS); 895 } 896 897 // Release input buffer 898 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiFreeBufferTest_002, TestSize.Level1) 899 { 900 ASSERT_TRUE(g_component != nullptr); 901 struct OmxCodecBuffer omxBuffer; 902 func_->InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD); 903 omxBuffer.bufferId = BUFFER_ID_ERROR; 904 auto ret = g_component->FreeBuffer(inputIndex, omxBuffer); 905 ASSERT_NE(ret, HDF_SUCCESS); 906 } 907 908 #ifdef SUPPORT_OMX_EXTEND 909 // When ComponentDeInit, must change to Loaded State 910 HWTEST_F(CodecHdiOmxEncTest, HdfCodecHdiDeInitTest_001, TestSize.Level1) 911 { 912 ASSERT_TRUE(g_component != nullptr); 913 auto ret = g_component->ComponentDeInit(); 914 ASSERT_EQ(ret, HDF_SUCCESS); 915 } 916 #endif 917 918 } // namespace 919