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