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