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 <dlfcn.h>
17 #include "lpp_log.h"
18 #include "lpp_sync_manager_adapter.h"
19
20 namespace OHOS {
21 namespace HDI {
22 namespace LowPowerPlayer {
23 namespace V1_0 {
24
25 static std::mutex mutex_;
26 static std::shared_ptr<void> libHandle_ = nullptr;
27 static CreateLowPowerPlayerVdiFunc createVdi_ = nullptr;
28 static DestroyLowPowerPlayerVdiFunc destroyVdi_ = nullptr;
29
~LppSyncManagerAdapter()30 LppSyncManagerAdapter::~LppSyncManagerAdapter()
31 {
32 std::lock_guard<std::mutex> lock(mutex_);
33 if (vdiImpl_ != nullptr) {
34 destroyVdi_(vdiImpl_);
35 vdiImpl_ = nullptr;
36 }
37 }
38
LoadVendorLib()39 int32_t LppSyncManagerAdapter::LoadVendorLib()
40 {
41 if (libHandle_ == nullptr) {
42 void* handle = dlopen(LOW_POWER_PLAYER_VDI_LIBRARY, RTLD_LAZY);
43 CHECK_TRUE_RETURN_RET_LOG(handle == NULL, HDF_FAILURE, "dlopen failed, %{public}s", dlerror());
44 libHandle_ = std::shared_ptr<void>(handle, dlclose);
45 }
46
47 if (createVdi_ == nullptr) {
48 createVdi_ = reinterpret_cast<CreateLowPowerPlayerVdiFunc>(dlsym(libHandle_.get(), "CreateLowPowerPlayerVdi"));
49 CHECK_TRUE_RETURN_RET_LOG(createVdi_ == NULL, HDF_FAILURE, "createVdi_ dlsym failed, %{public}s", dlerror());
50 }
51
52 if (destroyVdi_ == nullptr) {
53 destroyVdi_ =
54 reinterpret_cast<DestroyLowPowerPlayerVdiFunc>(dlsym(libHandle_.get(), "DestroyLowPowerPlayerVdi"));
55 CHECK_TRUE_RETURN_RET_LOG(destroyVdi_ == NULL, HDF_FAILURE, "destroyVdi_ dlsym failed, %{public}s", dlerror());
56 }
57 return HDF_SUCCESS;
58 }
59
Init()60 int32_t LppSyncManagerAdapter::Init()
61 {
62 std::lock_guard<std::mutex> lock(mutex_);
63 int32_t ret = LoadVendorLib();
64 CHECK_TRUE_RETURN_RET_LOG(ret != HDF_SUCCESS, HDF_FAILURE, "load vdi failed");
65
66 vdiImpl_ = createVdi_();
67 CHECK_TRUE_RETURN_RET_LOG(vdiImpl_ == NULL, HDF_FAILURE, "createVdi_ failed");
68
69 ret = vdiImpl_->Init();
70 CHECK_TRUE_RETURN_RET_LOG(ret != HDF_SUCCESS, HDF_FAILURE, "Init failed");
71 return HDF_SUCCESS;
72 }
73
SetVideoChannelId(uint32_t channelId)74 int32_t LppSyncManagerAdapter::SetVideoChannelId(uint32_t channelId)
75 {
76 int32_t ret = vdiImpl_->SetVideoChannelId(channelId);
77 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "SetVideoChannelId failed.");
78 return ret;
79 }
80
StartRender()81 int32_t LppSyncManagerAdapter::StartRender()
82 {
83 int32_t ret = vdiImpl_->StartRender();
84 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "StartRender failed.");
85 return ret;
86 }
87
RenderNextFrame()88 int32_t LppSyncManagerAdapter::RenderNextFrame()
89 {
90 int32_t ret = vdiImpl_->RenderNextFrame();
91 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "RenderNextFrame failed.");
92 return ret;
93 }
94
Pause()95 int32_t LppSyncManagerAdapter::Pause()
96 {
97 int32_t ret = vdiImpl_->Pause();
98 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "Pause failed.");
99 return ret;
100 }
101
Resume()102 int32_t LppSyncManagerAdapter::Resume()
103 {
104 int32_t ret = vdiImpl_->Resume();
105 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "Resume failed.");
106 return ret;
107 }
108
Flush()109 int32_t LppSyncManagerAdapter::Flush()
110 {
111 int32_t ret = vdiImpl_->Flush();
112 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "Flush failed.");
113 return ret;
114 }
115
Stop()116 int32_t LppSyncManagerAdapter::Stop()
117 {
118 int32_t ret = vdiImpl_->Stop();
119 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "Stop failed.");
120 return ret;
121 }
122
Reset()123 int32_t LppSyncManagerAdapter::Reset()
124 {
125 int32_t ret = vdiImpl_->Reset();
126 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "Reset failed.");
127 return ret;
128 }
129
Release()130 int32_t LppSyncManagerAdapter::Release()
131 {
132 int32_t ret = vdiImpl_->Release();
133 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "Release failed.");
134 return ret;
135 }
136
137
SetTunnelId(uint64_t tunnelId)138 int32_t LppSyncManagerAdapter::SetTunnelId(uint64_t tunnelId)
139 {
140 int32_t ret = vdiImpl_->SetTunnelId(tunnelId);
141 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "SetTunnelId failed.");
142 return ret;
143 }
144
SetTargetStartFrame(int64_t framePts,uint32_t timeoutMs)145 int32_t LppSyncManagerAdapter::SetTargetStartFrame(int64_t framePts, uint32_t timeoutMs)
146 {
147 int32_t ret = vdiImpl_->SetTargetStartFrame(framePts, timeoutMs);
148 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "SetTargetStartFrame failed.");
149 return ret;
150 }
151
SetPlaybackSpeed(float mode)152 int32_t LppSyncManagerAdapter::SetPlaybackSpeed(float mode)
153 {
154 int32_t ret = vdiImpl_->SetPlaybackSpeed(mode);
155 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "SetPlaybackSpeed failed.");
156 return ret;
157 }
158
RegisterCallback(const sptr<ILppSyncManagerCallback> & syncCallback)159 int32_t LppSyncManagerAdapter::RegisterCallback(const sptr<ILppSyncManagerCallback>& syncCallback)
160 {
161 int32_t ret = vdiImpl_->RegisterCallback(syncCallback);
162 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "RegisterCallback failed.");
163 return ret;
164 }
165
GetParameter(std::map<std::string,std::string> & parameter)166 int32_t LppSyncManagerAdapter::GetParameter(std::map<std::string, std::string>& parameter)
167 {
168 int32_t ret = vdiImpl_->GetParameter(parameter);
169 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "GetParameter failed.");
170 return ret;
171 }
172
GetShareBuffer(int32_t & fd)173 int32_t LppSyncManagerAdapter::GetShareBuffer(int32_t& fd)
174 {
175 int32_t ret = vdiImpl_->GetShareBuffer(fd);
176 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "GetShareBuffer failed.");
177 return ret;
178 }
179
SetParameter(const std::map<std::string,std::string> & parameter)180 int32_t LppSyncManagerAdapter::SetParameter(const std::map<std::string, std::string>& parameter)
181 {
182 int32_t ret = vdiImpl_->SetParameter(parameter);
183 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "SetParameter failed.");
184 return ret;
185 }
186
UpdateTimeAnchor(int64_t anchorPts,uint64_t anchorClk)187 int32_t LppSyncManagerAdapter::UpdateTimeAnchor(int64_t anchorPts, uint64_t anchorClk)
188 {
189 int32_t ret = vdiImpl_->UpdateTimeAnchor(anchorPts, anchorClk);
190 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "UpdateTimeAnchor failed.");
191 return ret;
192 }
193
BindOutputBuffers(const std::map<uint32_t,sptr<NativeBuffer>> & outputBuffers)194 int32_t LppSyncManagerAdapter::BindOutputBuffers(const std::map<uint32_t, sptr<NativeBuffer>>& outputBuffers)
195 {
196 int32_t ret = vdiImpl_->BindOutputBuffers(outputBuffers);
197 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "BindOutputBuffers failed.");
198 return ret;
199 }
200
UnbindOutputBuffers()201 int32_t LppSyncManagerAdapter::UnbindOutputBuffers()
202 {
203 int32_t ret = vdiImpl_->UnbindOutputBuffers();
204 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "UnbindOutputBuffers failed.");
205 return ret;
206 }
207
GetLatestPts(int64_t & pts)208 int32_t LppSyncManagerAdapter::GetLatestPts(int64_t& pts)
209 {
210 int32_t ret = vdiImpl_->GetLatestPts(pts);
211 CHECK_TRUE_RETURN_RET_LOG(HDF_SUCCESS != ret, HDF_FAILURE, "GetLatestPts failed.");
212 return ret;
213 }
214
215 }
216 }
217 }
218 }