1 /*
2 * Copyright 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
18 #include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h>
19 #include <android/hardware/configstore/1.1/types.h>
20 #include <configstore/Utils.h>
21 #include <utils/Log.h>
22
23 #include <log/log.h>
24 #include <cstdlib>
25 #include <tuple>
26
27 #include "SurfaceFlingerProperties.h"
28
29 namespace android {
30 namespace sysprop {
31 using namespace android::hardware::configstore;
32 using namespace android::hardware::configstore::V1_0;
33 using android::hardware::graphics::common::V1_2::Dataspace;
34 using android::hardware::graphics::common::V1_2::PixelFormat;
35 using android::ui::DisplayPrimaries;
36
37 // Keep logic in sync with WindowManagerService functions that query SurfaceFlinger properties.
38 // Consider exposing properties via ISurfaceComposer instead.
vsync_event_phase_offset_ns(int64_t defaultValue)39 int64_t vsync_event_phase_offset_ns(int64_t defaultValue) {
40 auto temp = SurfaceFlingerProperties::vsync_event_phase_offset_ns();
41 if (temp.has_value()) {
42 return *temp;
43 }
44 return getInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::vsyncEventPhaseOffsetNs>(
45 defaultValue);
46 }
47
vsync_sf_event_phase_offset_ns(int64_t defaultValue)48 int64_t vsync_sf_event_phase_offset_ns(int64_t defaultValue) {
49 auto temp = SurfaceFlingerProperties::vsync_sf_event_phase_offset_ns();
50 if (temp.has_value()) {
51 return *temp;
52 }
53 return getInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::vsyncSfEventPhaseOffsetNs>(
54 defaultValue);
55 }
56
use_context_priority(bool defaultValue)57 bool use_context_priority(bool defaultValue) {
58 auto temp = SurfaceFlingerProperties::use_context_priority();
59 if (temp.has_value()) {
60 return *temp;
61 }
62 return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::useContextPriority>(
63 defaultValue);
64 }
65
max_frame_buffer_acquired_buffers(int64_t defaultValue)66 int64_t max_frame_buffer_acquired_buffers(int64_t defaultValue) {
67 auto temp = SurfaceFlingerProperties::max_frame_buffer_acquired_buffers();
68 if (temp.has_value()) {
69 return *temp;
70 }
71 return getInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::maxFrameBufferAcquiredBuffers>(
72 defaultValue);
73 }
74
max_graphics_width(int32_t defaultValue)75 int32_t max_graphics_width(int32_t defaultValue) {
76 auto temp = SurfaceFlingerProperties::max_graphics_width();
77 if (temp.has_value()) {
78 return *temp;
79 }
80 return defaultValue;
81 }
82
max_graphics_height(int32_t defaultValue)83 int32_t max_graphics_height(int32_t defaultValue) {
84 auto temp = SurfaceFlingerProperties::max_graphics_height();
85 if (temp.has_value()) {
86 return *temp;
87 }
88 return defaultValue;
89 }
90
has_wide_color_display(bool defaultValue)91 bool has_wide_color_display(bool defaultValue) {
92 auto temp = SurfaceFlingerProperties::has_wide_color_display();
93 if (temp.has_value()) {
94 return *temp;
95 }
96 return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasWideColorDisplay>(
97 defaultValue);
98 }
99
running_without_sync_framework(bool defaultValue)100 bool running_without_sync_framework(bool defaultValue) {
101 auto temp = SurfaceFlingerProperties::running_without_sync_framework();
102 if (temp.has_value()) {
103 return !(*temp);
104 }
105 return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasSyncFramework>(defaultValue);
106 }
107
has_HDR_display(bool defaultValue)108 bool has_HDR_display(bool defaultValue) {
109 auto temp = SurfaceFlingerProperties::has_HDR_display();
110 if (temp.has_value()) {
111 return *temp;
112 }
113 return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasHDRDisplay>(defaultValue);
114 }
115
present_time_offset_from_vsync_ns(int64_t defaultValue)116 int64_t present_time_offset_from_vsync_ns(int64_t defaultValue) {
117 auto temp = SurfaceFlingerProperties::present_time_offset_from_vsync_ns();
118 if (temp.has_value()) {
119 return *temp;
120 }
121 return getInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::presentTimeOffsetFromVSyncNs>(
122 defaultValue);
123 }
124
force_hwc_copy_for_virtual_displays(bool defaultValue)125 bool force_hwc_copy_for_virtual_displays(bool defaultValue) {
126 auto temp = SurfaceFlingerProperties::force_hwc_copy_for_virtual_displays();
127 if (temp.has_value()) {
128 return *temp;
129 }
130 return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::useHwcForRGBtoYUV>(
131 defaultValue);
132 }
133
max_virtual_display_dimension(int64_t defaultValue)134 int64_t max_virtual_display_dimension(int64_t defaultValue) {
135 auto temp = SurfaceFlingerProperties::max_virtual_display_dimension();
136 if (temp.has_value()) {
137 return *temp;
138 }
139 return getUInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::maxVirtualDisplaySize>(
140 defaultValue);
141 }
142
use_vr_flinger(bool defaultValue)143 bool use_vr_flinger(bool defaultValue) {
144 auto temp = SurfaceFlingerProperties::use_vr_flinger();
145 if (temp.has_value()) {
146 return *temp;
147 }
148 return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::useVrFlinger>(defaultValue);
149 }
150
start_graphics_allocator_service(bool defaultValue)151 bool start_graphics_allocator_service(bool defaultValue) {
152 auto temp = SurfaceFlingerProperties::start_graphics_allocator_service();
153 if (temp.has_value()) {
154 return *temp;
155 }
156 return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::startGraphicsAllocatorService>(
157 defaultValue);
158 }
159
primary_display_orientation(SurfaceFlingerProperties::primary_display_orientation_values defaultValue)160 SurfaceFlingerProperties::primary_display_orientation_values primary_display_orientation(
161 SurfaceFlingerProperties::primary_display_orientation_values defaultValue) {
162 auto temp = SurfaceFlingerProperties::primary_display_orientation();
163 if (temp.has_value()) {
164 return *temp;
165 }
166 auto configDefault = DisplayOrientation::ORIENTATION_0;
167 switch (defaultValue) {
168 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_90:
169 configDefault = DisplayOrientation::ORIENTATION_90;
170 break;
171 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_180:
172 configDefault = DisplayOrientation::ORIENTATION_180;
173 break;
174 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_270:
175 configDefault = DisplayOrientation::ORIENTATION_270;
176 break;
177 default:
178 configDefault = DisplayOrientation::ORIENTATION_0;
179 break;
180 }
181 DisplayOrientation result =
182 getDisplayOrientation<V1_1::ISurfaceFlingerConfigs,
183 &V1_1::ISurfaceFlingerConfigs::primaryDisplayOrientation>(
184 configDefault);
185 switch (result) {
186 case DisplayOrientation::ORIENTATION_90:
187 return SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_90;
188 case DisplayOrientation::ORIENTATION_180:
189 return SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_180;
190 case DisplayOrientation::ORIENTATION_270:
191 return SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_270;
192 default:
193 break;
194 }
195 return SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_0;
196 }
197
use_color_management(bool defaultValue)198 bool use_color_management(bool defaultValue) {
199 auto tmpuseColorManagement = SurfaceFlingerProperties::use_color_management();
200 auto tmpHasHDRDisplayVal = has_HDR_display(defaultValue);
201 auto tmpHasWideColorDisplayVal = has_wide_color_display(defaultValue);
202
203 auto tmpuseColorManagementVal = tmpuseColorManagement.has_value() ? *tmpuseColorManagement :
204 defaultValue;
205
206 return tmpuseColorManagementVal || tmpHasHDRDisplayVal || tmpHasWideColorDisplayVal;
207 }
208
default_composition_dataspace(Dataspace defaultValue)209 int64_t default_composition_dataspace(Dataspace defaultValue) {
210 auto temp = SurfaceFlingerProperties::default_composition_dataspace();
211 if (temp.has_value()) {
212 return *temp;
213 }
214 return static_cast<int64_t>(defaultValue);
215 }
216
default_composition_pixel_format(PixelFormat defaultValue)217 int32_t default_composition_pixel_format(PixelFormat defaultValue) {
218 auto temp = SurfaceFlingerProperties::default_composition_pixel_format();
219 if (temp.has_value()) {
220 return *temp;
221 }
222 return static_cast<int32_t>(defaultValue);
223 }
224
wcg_composition_dataspace(Dataspace defaultValue)225 int64_t wcg_composition_dataspace(Dataspace defaultValue) {
226 auto temp = SurfaceFlingerProperties::wcg_composition_dataspace();
227 if (temp.has_value()) {
228 return *temp;
229 }
230 return static_cast<int64_t>(defaultValue);
231 }
232
wcg_composition_pixel_format(PixelFormat defaultValue)233 int32_t wcg_composition_pixel_format(PixelFormat defaultValue) {
234 auto temp = SurfaceFlingerProperties::wcg_composition_pixel_format();
235 if (temp.has_value()) {
236 return *temp;
237 }
238 return static_cast<int32_t>(defaultValue);
239 }
240
color_space_agnostic_dataspace(Dataspace defaultValue)241 int64_t color_space_agnostic_dataspace(Dataspace defaultValue) {
242 auto temp = SurfaceFlingerProperties::color_space_agnostic_dataspace();
243 if (temp.has_value()) {
244 return *temp;
245 }
246 return static_cast<int64_t>(defaultValue);
247 }
248
refresh_rate_switching(bool defaultValue)249 bool refresh_rate_switching(bool defaultValue) {
250 #pragma clang diagnostic push
251 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
252 auto temp = SurfaceFlingerProperties::refresh_rate_switching();
253 #pragma clang diagnostic pop
254 if (temp.has_value()) {
255 ALOGW("Using deprecated refresh_rate_switching sysprop. Value: %d", *temp);
256 return *temp;
257 }
258 return defaultValue;
259 }
260
set_idle_timer_ms(int32_t defaultValue)261 int32_t set_idle_timer_ms(int32_t defaultValue) {
262 auto temp = SurfaceFlingerProperties::set_idle_timer_ms();
263 if (temp.has_value()) {
264 return *temp;
265 }
266 return defaultValue;
267 }
268
set_touch_timer_ms(int32_t defaultValue)269 int32_t set_touch_timer_ms(int32_t defaultValue) {
270 auto temp = SurfaceFlingerProperties::set_touch_timer_ms();
271 if (temp.has_value()) {
272 return *temp;
273 }
274 return defaultValue;
275 }
276
set_display_power_timer_ms(int32_t defaultValue)277 int32_t set_display_power_timer_ms(int32_t defaultValue) {
278 auto temp = SurfaceFlingerProperties::set_display_power_timer_ms();
279 if (temp.has_value()) {
280 return *temp;
281 }
282 return defaultValue;
283 }
284
use_content_detection_for_refresh_rate(bool defaultValue)285 bool use_content_detection_for_refresh_rate(bool defaultValue) {
286 #pragma clang diagnostic push
287 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
288 auto smart_90_deprecated = SurfaceFlingerProperties::use_smart_90_for_video();
289 #pragma clang diagnostic pop
290 if (smart_90_deprecated.has_value()) {
291 ALOGW("Using deprecated use_smart_90_for_video sysprop. Value: %d", *smart_90_deprecated);
292 return *smart_90_deprecated;
293 }
294
295 auto temp = SurfaceFlingerProperties::use_content_detection_for_refresh_rate();
296 if (temp.has_value()) {
297 return *temp;
298 }
299 return defaultValue;
300 }
301
enable_protected_contents(bool defaultValue)302 bool enable_protected_contents(bool defaultValue) {
303 auto temp = SurfaceFlingerProperties::enable_protected_contents();
304 if (temp.has_value()) {
305 return *temp;
306 }
307 return defaultValue;
308 }
309
support_kernel_idle_timer(bool defaultValue)310 bool support_kernel_idle_timer(bool defaultValue) {
311 auto temp = SurfaceFlingerProperties::support_kernel_idle_timer();
312 if (temp.has_value()) {
313 return *temp;
314 }
315 return defaultValue;
316 }
317
use_frame_rate_api(bool defaultValue)318 bool use_frame_rate_api(bool defaultValue) {
319 auto temp = SurfaceFlingerProperties::use_frame_rate_api();
320 if (temp.has_value()) {
321 return *temp;
322 }
323 return defaultValue;
324 }
325
enable_sdr_dimming(bool defaultValue)326 bool enable_sdr_dimming(bool defaultValue) {
327 return SurfaceFlingerProperties::enable_sdr_dimming().value_or(defaultValue);
328 }
329
display_update_imminent_timeout_ms(int32_t defaultValue)330 int32_t display_update_imminent_timeout_ms(int32_t defaultValue) {
331 auto temp = SurfaceFlingerProperties::display_update_imminent_timeout_ms();
332 if (temp.has_value()) {
333 return *temp;
334 }
335 return defaultValue;
336 }
337
338 #define DISPLAY_PRIMARY_SIZE 3
339
340 constexpr float kSrgbRedX = 0.4123f;
341 constexpr float kSrgbRedY = 0.2126f;
342 constexpr float kSrgbRedZ = 0.0193f;
343 constexpr float kSrgbGreenX = 0.3576f;
344 constexpr float kSrgbGreenY = 0.7152f;
345 constexpr float kSrgbGreenZ = 0.1192f;
346 constexpr float kSrgbBlueX = 0.1805f;
347 constexpr float kSrgbBlueY = 0.0722f;
348 constexpr float kSrgbBlueZ = 0.9506f;
349 constexpr float kSrgbWhiteX = 0.9505f;
350 constexpr float kSrgbWhiteY = 1.0000f;
351 constexpr float kSrgbWhiteZ = 1.0891f;
352
getDisplayNativePrimaries()353 DisplayPrimaries getDisplayNativePrimaries() {
354 auto mDisplay_primary_red = SurfaceFlingerProperties::display_primary_red();
355 auto mDisplay_primary_green = SurfaceFlingerProperties::display_primary_green();
356 auto mDisplay_primary_blue = SurfaceFlingerProperties::display_primary_blue();
357 auto mDisplay_primary_white = SurfaceFlingerProperties::display_primary_white();
358 // To avoid null point exception.
359 mDisplay_primary_red.resize(DISPLAY_PRIMARY_SIZE);
360 mDisplay_primary_green.resize(DISPLAY_PRIMARY_SIZE);
361 mDisplay_primary_blue.resize(DISPLAY_PRIMARY_SIZE);
362 mDisplay_primary_white.resize(DISPLAY_PRIMARY_SIZE);
363 DisplayPrimaries primaries =
364 {{static_cast<float>(mDisplay_primary_red[0].value_or(kSrgbRedX)),
365 static_cast<float>(mDisplay_primary_red[1].value_or(kSrgbRedY)),
366 static_cast<float>(mDisplay_primary_red[2].value_or(kSrgbRedZ))},
367 {static_cast<float>(mDisplay_primary_green[0].value_or(kSrgbGreenX)),
368 static_cast<float>(mDisplay_primary_green[1].value_or(kSrgbGreenY)),
369 static_cast<float>(mDisplay_primary_green[2].value_or(kSrgbGreenZ))},
370 {static_cast<float>(mDisplay_primary_blue[0].value_or(kSrgbBlueX)),
371 static_cast<float>(mDisplay_primary_blue[1].value_or(kSrgbBlueY)),
372 static_cast<float>(mDisplay_primary_blue[2].value_or(kSrgbBlueZ))},
373 {static_cast<float>(mDisplay_primary_white[0].value_or(kSrgbWhiteX)),
374 static_cast<float>(mDisplay_primary_white[1].value_or(kSrgbWhiteY)),
375 static_cast<float>(mDisplay_primary_white[2].value_or(kSrgbWhiteZ))}};
376
377 return primaries;
378 }
379
update_device_product_info_on_hotplug_reconnect(bool defaultValue)380 bool update_device_product_info_on_hotplug_reconnect(bool defaultValue) {
381 return SurfaceFlingerProperties::update_device_product_info_on_hotplug_reconnect().value_or(
382 defaultValue);
383 }
384
enable_frame_rate_override(bool defaultValue)385 bool enable_frame_rate_override(bool defaultValue) {
386 return SurfaceFlingerProperties::enable_frame_rate_override().value_or(defaultValue);
387 }
388
enable_layer_caching(bool defaultValue)389 bool enable_layer_caching(bool defaultValue) {
390 return SurfaceFlingerProperties::enable_layer_caching().value_or(defaultValue);
391 }
392
393 } // namespace sysprop
394 } // namespace android
395