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 "display_engine/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 getSdrDisplayNits_ = nullptr;
59 getDisplayNits_ = nullptr;
60 getNonlinearRatio_ = nullptr;
61 calScaler_ = nullptr;
62 isHdrPictureOn_ = nullptr;
63 isCloseHardwareHdr_ = nullptr;
64 isForceCloseHdr_ = nullptr;
65 forceCloseHdr_ = nullptr;
66 }
67
Init()68 void RSLuminanceControl::Init()
69 {
70 initStatus_ = LoadLibrary();
71 if (!initStatus_) {
72 CloseLibrary();
73 }
74 }
75
LoadLibrary()76 bool RSLuminanceControl::LoadLibrary()
77 {
78 if (UNLIKELY(extLibHandle_ != nullptr)) {
79 return false;
80 }
81 bool loadResult{true};
82 extLibHandle_ = dlopen(EXT_LIB_PATH.data(), RTLD_NOW);
83 if (extLibHandle_ == nullptr) {
84 RS_LOGI("LumCtr dlopen error:%{public}s", dlerror());
85 loadResult = false;
86 }
87 if (loadResult && !LoadStatusControl()) {
88 CloseLibrary();
89 loadResult = false;
90 }
91 if (loadResult && !LoadLumControl()) {
92 CloseLibrary();
93 loadResult = false;
94 }
95 if (loadResult && !LoadTmoControl()) {
96 CloseLibrary();
97 loadResult = false;
98 }
99 RS_LOGI("LumCtr init status:%{public}d", loadResult);
100 return loadResult;
101 }
102
LoadStatusControl()103 bool RSLuminanceControl::LoadStatusControl()
104 {
105 if (UNLIKELY(extLibHandle_ == nullptr)) {
106 return false;
107 }
108 setHdrStatus_ = reinterpret_cast<SetHdrStatusFunc>(dlsym(extLibHandle_, "SetHdrStatus"));
109 if (setHdrStatus_ == nullptr) {
110 RS_LOGE("LumCtr link SetHdrStatusFunc error!");
111 return false;
112 }
113 isHdrOn_ = reinterpret_cast<IsHdrOnFunc>(dlsym(extLibHandle_, "IsHdrOn"));
114 if (isHdrOn_ == nullptr) {
115 RS_LOGE("LumCtr link IsHdrOn error!");
116 return false;
117 }
118 isDimmingOn_ = reinterpret_cast<IsDimmingOnFunc>(dlsym(extLibHandle_, "IsDimmingOn"));
119 if (isDimmingOn_ == nullptr) {
120 RS_LOGE("LumCtr link IsDimmingOn error!");
121 return false;
122 }
123 dimmingIncrease_ = reinterpret_cast<DimmingIncreaseFunc>(dlsym(extLibHandle_, "DimmingIncrease"));
124 if (dimmingIncrease_ == nullptr) {
125 RS_LOGE("LumCtr link IsDimmingOn error!");
126 return false;
127 }
128 isHdrPictureOn_ = reinterpret_cast<IsHdrPictureOnFunc>(dlsym(extLibHandle_, "IsHdrPictureOn"));
129 if (isHdrPictureOn_ == nullptr) {
130 RS_LOGE("LumCtr link IsHdrPictureOn error!");
131 return false;
132 }
133 isForceCloseHdr_ = reinterpret_cast<IsForceCloseHdrFunc>(dlsym(extLibHandle_, "IsForceCloseHdr"));
134 if (isForceCloseHdr_ == nullptr) {
135 RS_LOGE("LumCtr link IsForceCloseHdr error!");
136 return false;
137 }
138 forceCloseHdr_ = reinterpret_cast<ForceCloseHdrFunc>(dlsym(extLibHandle_, "ForceCloseHdr"));
139 if (forceCloseHdr_ == nullptr) {
140 RS_LOGE("LumCtr link ForceCloseHdr error!");
141 return false;
142 }
143 isCloseHardwareHdr_ = reinterpret_cast<IsCloseHardwareHdrFunc>(dlsym(extLibHandle_,
144 "IsCloseHardwareHdr"));
145 if (isCloseHardwareHdr_ == nullptr) {
146 RS_LOGE("LumCtr link IsCloseHardwareHdr error!");
147 return false;
148 }
149 return true;
150 }
151
LoadLumControl()152 bool RSLuminanceControl::LoadLumControl()
153 {
154 if (UNLIKELY(extLibHandle_ == nullptr)) {
155 return false;
156 }
157 setSdrLuminance_ = reinterpret_cast<SetSdrLuminanceFunc>(dlsym(extLibHandle_, "SetSdrLuminance"));
158 if (setSdrLuminance_ == nullptr) {
159 RS_LOGE("LumCtr link SetSdrLuminance error!");
160 return false;
161 }
162 getNewHdrLuminance_ = reinterpret_cast<GetNewHdrLuminanceFunc>(dlsym(extLibHandle_, "GetNewHdrLuminance"));
163 if (getNewHdrLuminance_ == nullptr) {
164 RS_LOGE("LumCtr link GetNewHdrLuminance error!");
165 return false;
166 }
167 setNowHdrLuminance_ = reinterpret_cast<SetNowHdrLuminanceFunc>(dlsym(extLibHandle_, "SetNowHdrLuminance"));
168 if (setNowHdrLuminance_ == nullptr) {
169 RS_LOGE("LumCtr link SetNowHdrLuminance error!");
170 return false;
171 }
172 isNeedUpdateLuminance_ = reinterpret_cast<IsNeedUpdateLuminanceFunc>(dlsym(extLibHandle_, "IsNeedUpdateLuminance"));
173 if (isNeedUpdateLuminance_ == nullptr) {
174 RS_LOGE("LumCtr link IsNeedUpdateLuminance error!");
175 return false;
176 }
177 return true;
178 }
179
LoadTmoControl()180 bool RSLuminanceControl::LoadTmoControl()
181 {
182 if (UNLIKELY(extLibHandle_ == nullptr)) {
183 return false;
184 }
185 getSdrDisplayNits_ = reinterpret_cast<GetSdrDisplayNitsFunc>(dlsym(extLibHandle_, "GetSdrDisplayNits"));
186 if (getSdrDisplayNits_ == nullptr) {
187 RS_LOGE("LumCtr link GetSdrDisplayNits 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,HdrStatus hdrstatus)208 bool RSLuminanceControl::SetHdrStatus(ScreenId screenId, HdrStatus hdrstatus)
209 {
210 return (initStatus_ && setHdrStatus_ != nullptr) ? setHdrStatus_(screenId, hdrstatus) : 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
GetSdrDisplayNits(ScreenId screenId)254 float RSLuminanceControl::GetSdrDisplayNits(ScreenId screenId)
255 {
256 return (initStatus_ && getSdrDisplayNits_ != nullptr) ? getSdrDisplayNits_(screenId) : HDR_DEFAULT_TMO_NIT;
257 }
258
GetDisplayNits(ScreenId screenId)259 float RSLuminanceControl::GetDisplayNits(ScreenId screenId)
260 {
261 return (initStatus_ && getDisplayNits_ != nullptr) ? getDisplayNits_(screenId) : HDR_DEFAULT_TMO_NIT;
262 }
263
GetHdrBrightnessRatio(ScreenId screenId,int32_t mode)264 double RSLuminanceControl::GetHdrBrightnessRatio(ScreenId screenId, int32_t mode)
265 {
266 return (initStatus_ && getNonlinearRatio_ != nullptr) ? getNonlinearRatio_(screenId, mode) : 1.0;
267 }
268
CalScaler(const float & maxContentLightLevel,int32_t dynamicMetadataSize,const float & ratio)269 float RSLuminanceControl::CalScaler(const float& maxContentLightLevel, int32_t dynamicMetadataSize, const float& ratio)
270 {
271 return (initStatus_ && calScaler_ != nullptr) ? calScaler_(maxContentLightLevel, dynamicMetadataSize, ratio) :
272 HDR_DEFAULT_SCALER * ratio;
273 }
274
IsHdrPictureOn()275 bool RSLuminanceControl::IsHdrPictureOn()
276 {
277 return (initStatus_ && isHdrPictureOn_ != nullptr) ? isHdrPictureOn_() : false;
278 }
279
IsForceCloseHdr()280 bool RSLuminanceControl::IsForceCloseHdr()
281 {
282 return (initStatus_ && isForceCloseHdr_ != nullptr) ? isForceCloseHdr_() : false;
283 }
284
ForceCloseHdr(uint32_t closeHdrSceneId,bool forceCloseHdr)285 void RSLuminanceControl::ForceCloseHdr(uint32_t closeHdrSceneId, bool forceCloseHdr)
286 {
287 if (initStatus_ && forceCloseHdr_ != nullptr) {
288 forceCloseHdr_(closeHdrSceneId, forceCloseHdr);
289 }
290 }
291
IsCloseHardwareHdr()292 bool RSLuminanceControl::IsCloseHardwareHdr()
293 {
294 return (initStatus_ && isCloseHardwareHdr_ != nullptr) ?
295 isCloseHardwareHdr_() : false;
296 }
297 } // namespace Rosen
298 } // namespace OHOS
299