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 <hdf_log.h> 18 #include <securec.h> 19 #include <servmgr_hdi.h> 20 #include <vector> 21 #include "codec_function_utils.h" 22 #include "v1_0/codec_callback_service.h" 23 24 using namespace std; 25 using namespace testing::ext; 26 using OHOS::sptr; 27 using OHOS::HDI::Base::NativeBuffer; 28 using namespace OHOS::HDI::Codec::V1_0; 29 using namespace OHOS::HDI::Display::Buffer::V1_0; 30 using namespace OHOS::HDI::Display::Composer::V1_0; 31 32 namespace { 33 constexpr CodecType TYPE = CodecType::VIDEO_DECODER; 34 constexpr AvCodecRole ROLE = MEDIA_ROLETYPE_VIDEO_AVC; 35 static sptr<ICodecComponent> g_component = nullptr; 36 static sptr<ICodecCallback> g_callback = nullptr; 37 static sptr<ICodecComponentManager> g_manager = nullptr; 38 static OHOS::HDI::Codec::V1_0::CodecVersionType g_version; 39 static std::string g_compName = ""; 40 41 class CodecHdiOmxDecTest : public testing::Test { 42 public: SetUpTestCase()43 static void SetUpTestCase() 44 { 45 g_manager = ICodecComponentManager::Get(); 46 int32_t count = 0; 47 auto ret = g_manager->GetComponentNum(count); 48 ASSERT_EQ(ret, HDF_SUCCESS); 49 if (count <= 0) { 50 return; 51 } 52 53 std::vector<CodecCompCapability> capList; 54 auto err = g_manager->GetComponentCapabilityList(capList, count); 55 ASSERT_TRUE(err == HDF_SUCCESS); 56 for (auto cap : capList) { 57 if (cap.type == TYPE && cap.role == ROLE) { 58 g_compName = cap.compName; 59 break; 60 } 61 } 62 } 63 TearDownTestCase()64 static void TearDownTestCase() 65 { 66 g_manager = nullptr; 67 } 68 SetUp()69 void SetUp() 70 { 71 ASSERT_TRUE(g_manager != nullptr && !g_compName.empty()); 72 g_callback = new CodecCallbackService(); 73 ASSERT_TRUE(g_callback != nullptr); 74 auto ret = g_manager->CreateComponent(g_component, componentId_, g_compName.data(), APP_DATA, g_callback); 75 ASSERT_EQ(ret, HDF_SUCCESS); 76 77 struct CompVerInfo verInfo; 78 ret = g_component->GetComponentVersion(verInfo); 79 ASSERT_EQ(ret, HDF_SUCCESS); 80 g_version = verInfo.compVersion; 81 82 func_ = new FunctionUtil(g_version); 83 ASSERT_TRUE(func_ != nullptr); 84 } 85 TearDown()86 void TearDown() 87 { 88 std::vector<int8_t> cmdData; 89 if (g_component != nullptr) { 90 g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_LOADED, cmdData); 91 } 92 if (g_manager != nullptr && g_component != nullptr) { 93 g_manager->DestroyComponent(componentId_); 94 } 95 g_component = nullptr; 96 g_callback = nullptr; 97 func_ = nullptr; 98 } 99 100 public: 101 uint32_t componentId_ = 0; 102 sptr<FunctionUtil> func_ = nullptr; 103 const static uint32_t outputIndex = static_cast<uint32_t>(PortIndex::INDEX_OUTPUT); 104 }; 105 106 HWTEST_F(CodecHdiOmxDecTest, HdfCodecHdiEmptyAndFillBufferTest_001, TestSize.Level1) 107 { 108 ASSERT_TRUE(g_component != nullptr); 109 std::vector<int8_t> cmdData; 110 auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 111 ASSERT_EQ(ret, HDF_SUCCESS); 112 113 OMX_PARAM_PORTDEFINITIONTYPE param; 114 func_->GetPortParameter(g_component, PortIndex::INDEX_INPUT, param); 115 auto err = func_->UseBufferOnPort(g_component, PortIndex::INDEX_INPUT, param.nBufferCountActual, 116 param.nBufferSize); 117 ASSERT_TRUE(err); 118 119 err = func_->InitBufferHandleParameter(g_component, param, outputIndex, CODEC_BUFFER_TYPE_HANDLE); 120 ASSERT_TRUE(err); 121 ret = func_->GetPortParameter(g_component, PortIndex::INDEX_OUTPUT, param); 122 ASSERT_EQ(ret, HDF_SUCCESS); 123 err = func_->UseHandleBuffer(g_component, PortIndex::INDEX_OUTPUT, param.nBufferCountActual, param.nBufferSize); 124 ASSERT_TRUE(err); 125 126 ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_EXECUTING, cmdData); 127 ASSERT_EQ(ret, HDF_SUCCESS); 128 err = func_->WaitState(g_component, CODEC_STATE_EXECUTING); 129 ASSERT_TRUE(err); 130 131 func_->FillAndEmptyAllBuffer(g_component, CODEC_BUFFER_TYPE_HANDLE); 132 ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); 133 ASSERT_EQ(ret, HDF_SUCCESS); 134 err = func_->WaitState(g_component, CODEC_STATE_IDLE); 135 ASSERT_TRUE(err); 136 ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_LOADED, cmdData); 137 ASSERT_EQ(ret, HDF_SUCCESS); 138 err = func_->WaitState(g_component, CODEC_STATE_IDLE); 139 ASSERT_TRUE(err); 140 141 err = func_->FreeBufferOnPort(g_component, PortIndex::INDEX_INPUT); 142 ASSERT_TRUE(err); 143 err = func_->FreeBufferOnPort(g_component, PortIndex::INDEX_OUTPUT); 144 ASSERT_TRUE(err); 145 err = func_->WaitState(g_component, CODEC_STATE_LOADED); 146 ASSERT_TRUE(err); 147 } 148 149 } // namespace 150