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 
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 
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