• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
default_composition_dataspace(Dataspace defaultValue)198 int64_t default_composition_dataspace(Dataspace defaultValue) {
199     auto temp = SurfaceFlingerProperties::default_composition_dataspace();
200     if (temp.has_value()) {
201         return *temp;
202     }
203     return static_cast<int64_t>(defaultValue);
204 }
205 
default_composition_pixel_format(PixelFormat defaultValue)206 int32_t default_composition_pixel_format(PixelFormat defaultValue) {
207     auto temp = SurfaceFlingerProperties::default_composition_pixel_format();
208     if (temp.has_value()) {
209         return *temp;
210     }
211     return static_cast<int32_t>(defaultValue);
212 }
213 
wcg_composition_dataspace(Dataspace defaultValue)214 int64_t wcg_composition_dataspace(Dataspace defaultValue) {
215     auto temp = SurfaceFlingerProperties::wcg_composition_dataspace();
216     if (temp.has_value()) {
217         return *temp;
218     }
219     return static_cast<int64_t>(defaultValue);
220 }
221 
wcg_composition_pixel_format(PixelFormat defaultValue)222 int32_t wcg_composition_pixel_format(PixelFormat defaultValue) {
223     auto temp = SurfaceFlingerProperties::wcg_composition_pixel_format();
224     if (temp.has_value()) {
225         return *temp;
226     }
227     return static_cast<int32_t>(defaultValue);
228 }
229 
refresh_rate_switching(bool defaultValue)230 bool refresh_rate_switching(bool defaultValue) {
231 #pragma clang diagnostic push
232 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
233     auto temp = SurfaceFlingerProperties::refresh_rate_switching();
234 #pragma clang diagnostic pop
235     if (temp.has_value()) {
236         ALOGW("Using deprecated refresh_rate_switching sysprop. Value: %d", *temp);
237         return *temp;
238     }
239     return defaultValue;
240 }
241 
set_idle_timer_ms(int32_t defaultValue)242 int32_t set_idle_timer_ms(int32_t defaultValue) {
243     auto temp = SurfaceFlingerProperties::set_idle_timer_ms();
244     if (temp.has_value()) {
245         return *temp;
246     }
247     return defaultValue;
248 }
249 
set_touch_timer_ms(int32_t defaultValue)250 int32_t set_touch_timer_ms(int32_t defaultValue) {
251     auto temp = SurfaceFlingerProperties::set_touch_timer_ms();
252     if (temp.has_value()) {
253         return *temp;
254     }
255     return defaultValue;
256 }
257 
set_display_power_timer_ms(int32_t defaultValue)258 int32_t set_display_power_timer_ms(int32_t defaultValue) {
259     auto temp = SurfaceFlingerProperties::set_display_power_timer_ms();
260     if (temp.has_value()) {
261         return *temp;
262     }
263     return defaultValue;
264 }
265 
use_content_detection_for_refresh_rate(bool defaultValue)266 bool use_content_detection_for_refresh_rate(bool defaultValue) {
267 #pragma clang diagnostic push
268 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
269     auto smart_90_deprecated = SurfaceFlingerProperties::use_smart_90_for_video();
270 #pragma clang diagnostic pop
271     if (smart_90_deprecated.has_value()) {
272         ALOGW("Using deprecated use_smart_90_for_video sysprop. Value: %d", *smart_90_deprecated);
273         return *smart_90_deprecated;
274     }
275 
276     auto temp = SurfaceFlingerProperties::use_content_detection_for_refresh_rate();
277     if (temp.has_value()) {
278         return *temp;
279     }
280     return defaultValue;
281 }
282 
enable_protected_contents(bool defaultValue)283 bool enable_protected_contents(bool defaultValue) {
284     auto temp = SurfaceFlingerProperties::enable_protected_contents();
285     if (temp.has_value()) {
286         return *temp;
287     }
288     return defaultValue;
289 }
290 
support_kernel_idle_timer(bool defaultValue)291 bool support_kernel_idle_timer(bool defaultValue) {
292     auto temp = SurfaceFlingerProperties::support_kernel_idle_timer();
293     if (temp.has_value()) {
294         return *temp;
295     }
296     return defaultValue;
297 }
298 
enable_sdr_dimming(bool defaultValue)299 bool enable_sdr_dimming(bool defaultValue) {
300     return SurfaceFlingerProperties::enable_sdr_dimming().value_or(defaultValue);
301 }
302 
display_update_imminent_timeout_ms(int32_t defaultValue)303 int32_t display_update_imminent_timeout_ms(int32_t defaultValue) {
304     auto temp = SurfaceFlingerProperties::display_update_imminent_timeout_ms();
305     if (temp.has_value()) {
306         return *temp;
307     }
308     return defaultValue;
309 }
310 
311 #define DISPLAY_PRIMARY_SIZE 3
312 
313 constexpr float kSrgbRedX = 0.4123f;
314 constexpr float kSrgbRedY = 0.2126f;
315 constexpr float kSrgbRedZ = 0.0193f;
316 constexpr float kSrgbGreenX = 0.3576f;
317 constexpr float kSrgbGreenY = 0.7152f;
318 constexpr float kSrgbGreenZ = 0.1192f;
319 constexpr float kSrgbBlueX = 0.1805f;
320 constexpr float kSrgbBlueY = 0.0722f;
321 constexpr float kSrgbBlueZ = 0.9506f;
322 constexpr float kSrgbWhiteX = 0.9505f;
323 constexpr float kSrgbWhiteY = 1.0000f;
324 constexpr float kSrgbWhiteZ = 1.0891f;
325 
getDisplayNativePrimaries()326 DisplayPrimaries getDisplayNativePrimaries() {
327     auto mDisplay_primary_red = SurfaceFlingerProperties::display_primary_red();
328     auto mDisplay_primary_green = SurfaceFlingerProperties::display_primary_green();
329     auto mDisplay_primary_blue = SurfaceFlingerProperties::display_primary_blue();
330     auto mDisplay_primary_white = SurfaceFlingerProperties::display_primary_white();
331     // To avoid null point exception.
332     mDisplay_primary_red.resize(DISPLAY_PRIMARY_SIZE);
333     mDisplay_primary_green.resize(DISPLAY_PRIMARY_SIZE);
334     mDisplay_primary_blue.resize(DISPLAY_PRIMARY_SIZE);
335     mDisplay_primary_white.resize(DISPLAY_PRIMARY_SIZE);
336     DisplayPrimaries primaries =
337             {{static_cast<float>(mDisplay_primary_red[0].value_or(kSrgbRedX)),
338               static_cast<float>(mDisplay_primary_red[1].value_or(kSrgbRedY)),
339               static_cast<float>(mDisplay_primary_red[2].value_or(kSrgbRedZ))},
340              {static_cast<float>(mDisplay_primary_green[0].value_or(kSrgbGreenX)),
341               static_cast<float>(mDisplay_primary_green[1].value_or(kSrgbGreenY)),
342               static_cast<float>(mDisplay_primary_green[2].value_or(kSrgbGreenZ))},
343              {static_cast<float>(mDisplay_primary_blue[0].value_or(kSrgbBlueX)),
344               static_cast<float>(mDisplay_primary_blue[1].value_or(kSrgbBlueY)),
345               static_cast<float>(mDisplay_primary_blue[2].value_or(kSrgbBlueZ))},
346              {static_cast<float>(mDisplay_primary_white[0].value_or(kSrgbWhiteX)),
347               static_cast<float>(mDisplay_primary_white[1].value_or(kSrgbWhiteY)),
348               static_cast<float>(mDisplay_primary_white[2].value_or(kSrgbWhiteZ))}};
349 
350     return primaries;
351 }
352 
update_device_product_info_on_hotplug_reconnect(bool defaultValue)353 bool update_device_product_info_on_hotplug_reconnect(bool defaultValue) {
354     return SurfaceFlingerProperties::update_device_product_info_on_hotplug_reconnect().value_or(
355             defaultValue);
356 }
357 
enable_frame_rate_override(bool defaultValue)358 bool enable_frame_rate_override(bool defaultValue) {
359     return SurfaceFlingerProperties::enable_frame_rate_override().value_or(defaultValue);
360 }
361 
enable_layer_caching(bool defaultValue)362 bool enable_layer_caching(bool defaultValue) {
363     return SurfaceFlingerProperties::enable_layer_caching().value_or(defaultValue);
364 }
365 
ignore_hdr_camera_layers(bool defaultValue)366 bool ignore_hdr_camera_layers(bool defaultValue) {
367     return SurfaceFlingerProperties::ignore_hdr_camera_layers().value_or(defaultValue);
368 }
369 
clear_slots_with_set_layer_buffer(bool defaultValue)370 bool clear_slots_with_set_layer_buffer(bool defaultValue) {
371     return SurfaceFlingerProperties::clear_slots_with_set_layer_buffer().value_or(defaultValue);
372 }
373 
game_default_frame_rate_override(int32_t defaultValue)374 int32_t game_default_frame_rate_override(int32_t defaultValue) {
375     return SurfaceFlingerProperties::game_default_frame_rate_override().value_or(defaultValue);
376 }
377 
378 } // namespace sysprop
379 } // namespace android
380