1 /*
2  * Copyright (c) 2024 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 applicable 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 "luminance/rs_luminance_control.h"
17 
18 #include <dlfcn.h>
19 #include <string_view>
20 
21 #include "common/rs_common_def.h"
22 #include "platform/common/rs_log.h"
23 
24 namespace {
25 constexpr float HDR_DEFAULT_TMO_NIT = 1000.0f;
26 constexpr float HDR_DEFAULT_SCALER = 1000.0f / 203.0f;
27 constexpr int32_t DEFAULT_LEVEL = 255;
28 constexpr std::string_view EXT_LIB_PATH = "system/lib64/libluminance_ext.z.so";
29 }
30 
31 namespace OHOS {
32 namespace Rosen {
Get()33 RSLuminanceControl& RSLuminanceControl::Get()
34 {
35     static RSLuminanceControl instance;
36     return instance;
37 }
38 
~RSLuminanceControl()39 RSLuminanceControl::~RSLuminanceControl()
40 {
41     CloseLibrary();
42 }
43 
CloseLibrary()44 void RSLuminanceControl::CloseLibrary()
45 {
46     if (extLibHandle_ != nullptr) {
47         dlclose(extLibHandle_);
48         extLibHandle_ = nullptr;
49     }
50     setHdrStatus_ = nullptr;
51     isHdrOn_ = nullptr;
52     isDimmingOn_ = nullptr;
53     dimmingIncrease_ = nullptr;
54     setSdrLuminance_ = nullptr;
55     getNewHdrLuminance_ = nullptr;
56     setNowHdrLuminance_ = nullptr;
57     isNeedUpdateLuminance_ = nullptr;
58     getHdrTmoNits_ = nullptr;
59     getSdrDisplayNits_ = nullptr;
60     getHdrDisplayNits_ = nullptr;
61     getDisplayNits_ = nullptr;
62     getNonlinearRatio_ = nullptr;
63     calScaler_ = nullptr;
64     isHdrPictureOn_ = nullptr;
65 }
66 
Init()67 void RSLuminanceControl::Init()
68 {
69     initStatus_ = LoadLibrary();
70 }
71 
LoadLibrary()72 bool RSLuminanceControl::LoadLibrary()
73 {
74     if (UNLIKELY(extLibHandle_ != nullptr)) {
75         return false;
76     }
77     bool loadResult{true};
78     extLibHandle_ = dlopen(EXT_LIB_PATH.data(), RTLD_NOW);
79     if (extLibHandle_ == nullptr) {
80         RS_LOGI("LumCtr dlopen error:%{public}s", dlerror());
81         loadResult = false;
82     }
83     if (loadResult && !LoadStatusControl()) {
84         CloseLibrary();
85         loadResult = false;
86     }
87     if (loadResult && !LoadLumControl()) {
88         CloseLibrary();
89         loadResult = false;
90     }
91     if (loadResult && !LoadTmoControl()) {
92         CloseLibrary();
93         loadResult = false;
94     }
95     RS_LOGI("LumCtr init status:%{public}d", loadResult);
96     return loadResult;
97 }
98 
LoadStatusControl()99 bool RSLuminanceControl::LoadStatusControl()
100 {
101     if (UNLIKELY(extLibHandle_ == nullptr)) {
102         return false;
103     }
104     setHdrStatus_ = reinterpret_cast<SetHdrStatusFunc>(dlsym(extLibHandle_, "SetHdrStatus"));
105     if (setHdrStatus_ == nullptr) {
106         RS_LOGE("LumCtr link SetHdrStatusFunc error!");
107         return false;
108     }
109     isHdrOn_ = reinterpret_cast<IsHdrOnFunc>(dlsym(extLibHandle_, "IsHdrOn"));
110     if (isHdrOn_ == nullptr) {
111         RS_LOGE("LumCtr link IsHdrOn error!");
112         return false;
113     }
114     isDimmingOn_ = reinterpret_cast<IsDimmingOnFunc>(dlsym(extLibHandle_, "IsDimmingOn"));
115     if (isDimmingOn_ == nullptr) {
116         RS_LOGE("LumCtr link IsDimmingOn error!");
117         return false;
118     }
119     dimmingIncrease_ = reinterpret_cast<DimmingIncreaseFunc>(dlsym(extLibHandle_, "DimmingIncrease"));
120     if (dimmingIncrease_ == nullptr) {
121         RS_LOGE("LumCtr link IsDimmingOn error!");
122         return false;
123     }
124     isHdrPictureOn_ = reinterpret_cast<IsHdrPictureOnFunc>(dlsym(extLibHandle_, "IsHdrPictureOn"));
125     if (isHdrPictureOn_ == nullptr) {
126         RS_LOGE("LumCtr link IsHdrPictureOn error!");
127         return false;
128     }
129     isForceCloseHdr_ = reinterpret_cast<IsForceCloseHdrFunc>(dlsym(extLibHandle_, "IsForceCloseHdr"));
130     if (isForceCloseHdr_ == nullptr) {
131         RS_LOGE("LumCtr link IsForceCloseHdr error!");
132         return false;
133     }
134     forceCloseHdr_ = reinterpret_cast<ForceCloseHdrFunc>(dlsym(extLibHandle_, "ForceCloseHdr"));
135     if (forceCloseHdr_ == nullptr) {
136         RS_LOGE("LumCtr link ForceCloseHdr error!");
137         return false;
138     }
139     return true;
140 }
141 
LoadLumControl()142 bool RSLuminanceControl::LoadLumControl()
143 {
144     if (UNLIKELY(extLibHandle_ == nullptr)) {
145         return false;
146     }
147     setSdrLuminance_ = reinterpret_cast<SetSdrLuminanceFunc>(dlsym(extLibHandle_, "SetSdrLuminance"));
148     if (setSdrLuminance_ == nullptr) {
149         RS_LOGE("LumCtr link SetSdrLuminance error!");
150         return false;
151     }
152     getNewHdrLuminance_ = reinterpret_cast<GetNewHdrLuminanceFunc>(dlsym(extLibHandle_, "GetNewHdrLuminance"));
153     if (getNewHdrLuminance_ == nullptr) {
154         RS_LOGE("LumCtr link GetNewHdrLuminance error!");
155         return false;
156     }
157     setNowHdrLuminance_ = reinterpret_cast<SetNowHdrLuminanceFunc>(dlsym(extLibHandle_, "SetNowHdrLuminance"));
158     if (setNowHdrLuminance_ == nullptr) {
159         RS_LOGE("LumCtr link SetNowHdrLuminance error!");
160         return false;
161     }
162     isNeedUpdateLuminance_ = reinterpret_cast<IsNeedUpdateLuminanceFunc>(dlsym(extLibHandle_, "IsNeedUpdateLuminance"));
163     if (isNeedUpdateLuminance_ == nullptr) {
164         RS_LOGE("LumCtr link IsNeedUpdateLuminance error!");
165         return false;
166     }
167     return true;
168 }
169 
LoadTmoControl()170 bool RSLuminanceControl::LoadTmoControl()
171 {
172     if (UNLIKELY(extLibHandle_ == nullptr)) {
173         return false;
174     }
175     getHdrTmoNits_ = reinterpret_cast<GetHdrTmoNitsFunc>(dlsym(extLibHandle_, "GetHdrTmoNits"));
176     if (getHdrTmoNits_ == nullptr) {
177         RS_LOGE("LumCtr link GetHdrTmoNits error!");
178         return false;
179     }
180     getSdrDisplayNits_ = reinterpret_cast<GetSdrDisplayNitsFunc>(dlsym(extLibHandle_, "GetSdrDisplayNits"));
181     if (getSdrDisplayNits_ == nullptr) {
182         RS_LOGE("LumCtr link GetSdrDisplayNits error!");
183         return false;
184     }
185     getHdrDisplayNits_ = reinterpret_cast<GetHdrDisplayNitsFunc>(dlsym(extLibHandle_, "GetHdrDisplayNits"));
186     if (getHdrDisplayNits_ == nullptr) {
187         RS_LOGE("LumCtr link GetHdrDisplayNits error!");
188         return false;
189     }
190     getDisplayNits_ = reinterpret_cast<GetDisplayNitsFunc>(dlsym(extLibHandle_, "GetDisplayNits"));
191     if (getDisplayNits_ == nullptr) {
192         RS_LOGE("LumCtr link GetDisplayNits error!");
193         return false;
194     }
195     getNonlinearRatio_ = reinterpret_cast<GetNonlinearRatioFunc>(dlsym(extLibHandle_, "GetNonlinearRatio"));
196     if (getNonlinearRatio_ == nullptr) {
197         RS_LOGE("LumCtr link GetHdrBrightnessRatio error!");
198         return false;
199     }
200     calScaler_ = reinterpret_cast<CalScalerFunc>(dlsym(extLibHandle_, "CalScaler"));
201     if (calScaler_ == nullptr) {
202         RS_LOGE("LumCtr link CalScaler error!");
203         return false;
204     }
205     return true;
206 }
207 
SetHdrStatus(ScreenId screenId,bool isHdrOn,int32_t type)208 bool RSLuminanceControl::SetHdrStatus(ScreenId screenId, bool isHdrOn, int32_t type)
209 {
210     return (initStatus_ && setHdrStatus_ != nullptr) ? setHdrStatus_(screenId, isHdrOn, type) : false;
211 }
212 
IsHdrOn(ScreenId screenId)213 bool RSLuminanceControl::IsHdrOn(ScreenId screenId)
214 {
215     return (initStatus_ && isHdrOn_ != nullptr) ? isHdrOn_(screenId) : false;
216 }
217 
IsDimmingOn(ScreenId screenId)218 bool RSLuminanceControl::IsDimmingOn(ScreenId screenId)
219 {
220     return (initStatus_ && isDimmingOn_ != nullptr) ? isDimmingOn_(screenId) : false;
221 }
222 
DimmingIncrease(ScreenId screenId)223 void RSLuminanceControl::DimmingIncrease(ScreenId screenId)
224 {
225     if (initStatus_ && dimmingIncrease_ != nullptr) {
226         dimmingIncrease_(screenId);
227     }
228 }
229 
SetSdrLuminance(ScreenId screenId,uint32_t level)230 void RSLuminanceControl::SetSdrLuminance(ScreenId screenId, uint32_t level)
231 {
232     if (initStatus_ && setSdrLuminance_ != nullptr) {
233         setSdrLuminance_(screenId, level);
234     }
235 }
236 
GetNewHdrLuminance(ScreenId screenId)237 uint32_t RSLuminanceControl::GetNewHdrLuminance(ScreenId screenId)
238 {
239     return (initStatus_ && getNewHdrLuminance_ != nullptr) ? getNewHdrLuminance_(screenId) : DEFAULT_LEVEL;
240 }
241 
SetNowHdrLuminance(ScreenId screenId,uint32_t level)242 void RSLuminanceControl::SetNowHdrLuminance(ScreenId screenId, uint32_t level)
243 {
244     if (initStatus_ && setNowHdrLuminance_ != nullptr) {
245         setNowHdrLuminance_(screenId, level);
246     }
247 }
248 
IsNeedUpdateLuminance(ScreenId screenId)249 bool RSLuminanceControl::IsNeedUpdateLuminance(ScreenId screenId)
250 {
251     return (initStatus_ && isNeedUpdateLuminance_ != nullptr) ? isNeedUpdateLuminance_(screenId) : false;
252 }
253 
GetHdrTmoNits(ScreenId screenId,int32_t mode)254 float RSLuminanceControl::GetHdrTmoNits(ScreenId screenId, int32_t mode)
255 {
256     return (initStatus_ && getHdrTmoNits_ != nullptr) ? getHdrTmoNits_(screenId, mode) : HDR_DEFAULT_TMO_NIT;
257 }
258 
GetSdrDisplayNits(ScreenId screenId)259 float RSLuminanceControl::GetSdrDisplayNits(ScreenId screenId)
260 {
261     return (initStatus_ && getSdrDisplayNits_ != nullptr) ? getSdrDisplayNits_(screenId) : HDR_DEFAULT_TMO_NIT;
262 }
263 
GetHdrDisplayNits(ScreenId screenId)264 float RSLuminanceControl::GetHdrDisplayNits(ScreenId screenId)
265 {
266     return (initStatus_ && getHdrDisplayNits_ != nullptr) ? getHdrDisplayNits_(screenId) : HDR_DEFAULT_TMO_NIT;
267 }
268 
GetDisplayNits(ScreenId screenId)269 float RSLuminanceControl::GetDisplayNits(ScreenId screenId)
270 {
271     return (initStatus_ && getDisplayNits_ != nullptr) ? getDisplayNits_(screenId) : HDR_DEFAULT_TMO_NIT;
272 }
273 
GetHdrBrightnessRatio(ScreenId screenId,int32_t mode)274 double RSLuminanceControl::GetHdrBrightnessRatio(ScreenId screenId, int32_t mode)
275 {
276     return (initStatus_ && getNonlinearRatio_ != nullptr) ? getNonlinearRatio_(screenId, mode) : 1.0;
277 }
278 
CalScaler(const float & maxContentLightLevel,const float & ratio)279 float RSLuminanceControl::CalScaler(const float& maxContentLightLevel, const float& ratio)
280 {
281     return (initStatus_ && calScaler_ != nullptr) ? calScaler_(maxContentLightLevel, ratio) :
282         HDR_DEFAULT_SCALER * ratio;
283 }
284 
IsHdrPictureOn()285 bool RSLuminanceControl::IsHdrPictureOn()
286 {
287     return (initStatus_ && isHdrPictureOn_ != nullptr) ? isHdrPictureOn_() : false;
288 }
289 
IsForceCloseHdr()290 bool RSLuminanceControl::IsForceCloseHdr()
291 {
292     return (initStatus_ && isForceCloseHdr_ != nullptr) ? isForceCloseHdr_() : false;
293 }
294 
ForceCloseHdr(uint32_t closeHdrSceneId,bool forceCloseHdr)295 void RSLuminanceControl::ForceCloseHdr(uint32_t closeHdrSceneId, bool forceCloseHdr)
296 {
297     if (initStatus_ && forceCloseHdr_ != nullptr) {
298         forceCloseHdr_(closeHdrSceneId, forceCloseHdr);
299     }
300 }
301 } // namespace Rosen
302 } // namespace OHOS
303