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