summaryrefslogtreecommitdiff
path: root/services/surfaceflinger/SurfaceFlinger.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'services/surfaceflinger/SurfaceFlinger.cpp')
-rw-r--r--services/surfaceflinger/SurfaceFlinger.cpp325
1 files changed, 222 insertions, 103 deletions
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index 60c09049cf..ba13293a8f 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -214,6 +214,16 @@ static constexpr int FOUR_K_HEIGHT = 2160;
// TODO(b/141333600): Consolidate with DisplayMode::Builder::getDefaultDensity.
constexpr float FALLBACK_DENSITY = ACONFIGURATION_DENSITY_TV;
+float getDensityFromProperty(const char* property, bool required) {
+ char value[PROPERTY_VALUE_MAX];
+ const float density = property_get(property, value, nullptr) > 0 ? std::atof(value) : 0.f;
+ if (!density && required) {
+ ALOGE("%s must be defined as a build property", property);
+ return FALLBACK_DENSITY;
+ }
+ return density;
+}
+
// Currently we only support V0_SRGB and DISPLAY_P3 as composition preference.
bool validateCompositionDataspace(Dataspace dataspace) {
return dataspace == Dataspace::V0_SRGB || dataspace == Dataspace::DISPLAY_P3;
@@ -312,6 +322,18 @@ const char* KERNEL_IDLE_TIMER_PROP = "graphics.display.kernel_idle_timer.enabled
static const int MAX_TRACING_MEMORY = 1024 * 1024 * 1024; // 1GB
// ---------------------------------------------------------------------------
+int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
+bool SurfaceFlinger::useHwcForRgbToYuv;
+bool SurfaceFlinger::hasSyncFramework;
+int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
+int64_t SurfaceFlinger::minAcquiredBuffers = 1;
+uint32_t SurfaceFlinger::maxGraphicsWidth;
+uint32_t SurfaceFlinger::maxGraphicsHeight;
+bool SurfaceFlinger::useContextPriority;
+Dataspace SurfaceFlinger::defaultCompositionDataspace = Dataspace::V0_SRGB;
+ui::PixelFormat SurfaceFlinger::defaultCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
+Dataspace SurfaceFlinger::wideColorGamutCompositionDataspace = Dataspace::V0_SRGB;
+ui::PixelFormat SurfaceFlinger::wideColorGamutCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
LatchUnsignaledConfig SurfaceFlinger::enableLatchUnsignaledConfig;
std::string decodeDisplayColorSetting(DisplayColorSetting displayColorSetting) {
@@ -338,35 +360,136 @@ bool callingThreadHasPermission(const String16& permission) {
ui::Transform::RotationFlags SurfaceFlinger::sActiveDisplayRotationFlags = ui::Transform::ROT_0;
-SurfaceFlinger::SurfaceFlinger(surfaceflinger::Config& config)
- : mConfig(&config),
- mDebugFlashDelay(base::GetUintProperty("debug.sf.showupdates"s, 0u)),
+SurfaceFlinger::SurfaceFlinger(Factory& factory, SkipInitializationTag)
+ : mFactory(factory),
+ mPid(getpid()),
mTimeStats(std::make_shared<impl::TimeStats>()),
- mFrameTracer(mConfig->factory->createFrameTracer()),
- mFrameTimeline(mConfig->factory->createFrameTimeline(mTimeStats, mConfig->pid)),
- mCompositionEngine(mConfig->factory->createCompositionEngine()),
+ mFrameTracer(mFactory.createFrameTracer()),
+ mFrameTimeline(mFactory.createFrameTimeline(mTimeStats, mPid)),
+ mCompositionEngine(mFactory.createCompositionEngine()),
+ mHwcServiceName(base::GetProperty("debug.sf.hwc_service_name"s, "default"s)),
mTunnelModeEnabledReporter(sp<TunnelModeEnabledReporter>::make()),
+ mEmulatedDisplayDensity(getDensityFromProperty("qemu.sf.lcd_density", false)),
+ mInternalDisplayDensity(
+ getDensityFromProperty("ro.sf.lcd_density", !mEmulatedDisplayDensity)),
mPowerAdvisor(std::make_unique<Hwc2::impl::PowerAdvisor>(*this)),
mWindowInfosListenerInvoker(sp<WindowInfosListenerInvoker>::make()) {
+ ALOGI("Using HWComposer service: %s", mHwcServiceName.c_str());
+}
+
+SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipInitialization) {
ATRACE_CALL();
- ALOGI("SurfaceFlinger is starting.");
- ALOGI("Using HWComposer service: %s", mConfig->hwcServiceName.c_str());
- ALOGI_IF(mConfig->backpressureGpuComposition, "Enabling backpressure for GPU composition");
- ALOGI_IF(!mConfig->supportsBlur, "Disabling blur effects, they are not supported.");
- ALOGI_IF(mConfig->trebleTestingOverride, "Enabling Treble testing override");
+ ALOGI("SurfaceFlinger is starting");
+
+ hasSyncFramework = running_without_sync_framework(true);
+
+ dispSyncPresentTimeOffset = present_time_offset_from_vsync_ns(0);
+
+ useHwcForRgbToYuv = force_hwc_copy_for_virtual_displays(false);
+
+ maxFrameBufferAcquiredBuffers = max_frame_buffer_acquired_buffers(2);
+ minAcquiredBuffers =
+ SurfaceFlingerProperties::min_acquired_buffers().value_or(minAcquiredBuffers);
+
+ maxGraphicsWidth = std::max(max_graphics_width(0), 0);
+ maxGraphicsHeight = std::max(max_graphics_height(0), 0);
+
+ mSupportsWideColor = has_wide_color_display(false);
+ mDefaultCompositionDataspace =
+ static_cast<ui::Dataspace>(default_composition_dataspace(Dataspace::V0_SRGB));
+ mWideColorGamutCompositionDataspace = static_cast<ui::Dataspace>(wcg_composition_dataspace(
+ mSupportsWideColor ? Dataspace::DISPLAY_P3 : Dataspace::V0_SRGB));
+ defaultCompositionDataspace = mDefaultCompositionDataspace;
+ wideColorGamutCompositionDataspace = mWideColorGamutCompositionDataspace;
+ defaultCompositionPixelFormat = static_cast<ui::PixelFormat>(
+ default_composition_pixel_format(ui::PixelFormat::RGBA_8888));
+ wideColorGamutCompositionPixelFormat =
+ static_cast<ui::PixelFormat>(wcg_composition_pixel_format(ui::PixelFormat::RGBA_8888));
+
+ mColorSpaceAgnosticDataspace =
+ static_cast<ui::Dataspace>(color_space_agnostic_dataspace(Dataspace::UNKNOWN));
+
+ mLayerCachingEnabled = [] {
+ const bool enable =
+ android::sysprop::SurfaceFlingerProperties::enable_layer_caching().value_or(false);
+ return base::GetBoolProperty(std::string("debug.sf.enable_layer_caching"), enable);
+ }();
+
+ useContextPriority = use_context_priority(true);
+
+ mInternalDisplayPrimaries = sysprop::getDisplayNativePrimaries();
- if (mConfig->trebleTestingOverride) {
+ // debugging stuff...
+ char value[PROPERTY_VALUE_MAX];
+
+ property_get("ro.build.type", value, "user");
+ mIsUserBuild = strcmp(value, "user") == 0;
+
+ mDebugFlashDelay = base::GetUintProperty("debug.sf.showupdates"s, 0u);
+
+ mBackpressureGpuComposition = base::GetBoolProperty("debug.sf.enable_gl_backpressure"s, true);
+ ALOGI_IF(mBackpressureGpuComposition, "Enabling backpressure for GPU composition");
+
+ property_get("ro.surface_flinger.supports_background_blur", value, "0");
+ bool supportsBlurs = atoi(value);
+ mSupportsBlur = supportsBlurs;
+ ALOGI_IF(!mSupportsBlur, "Disabling blur effects, they are not supported.");
+
+ const size_t defaultListSize = MAX_LAYERS;
+ auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
+ mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
+ mGraphicBufferProducerListSizeLogThreshold =
+ std::max(static_cast<int>(0.95 *
+ static_cast<double>(mMaxGraphicBufferProducerListSize)),
+ 1);
+
+ property_get("debug.sf.luma_sampling", value, "1");
+ mLumaSampling = atoi(value);
+
+ property_get("debug.sf.disable_client_composition_cache", value, "0");
+ mDisableClientCompositionCache = atoi(value);
+
+ property_get("debug.sf.predict_hwc_composition_strategy", value, "1");
+ mPredictCompositionStrategy = atoi(value);
+
+ property_get("debug.sf.treat_170m_as_sRGB", value, "0");
+ mTreat170mAsSrgb = atoi(value);
+
+ mIgnoreHwcPhysicalDisplayOrientation =
+ base::GetBoolProperty("debug.sf.ignore_hwc_physical_display_orientation"s, false);
+
+ // We should be reading 'persist.sys.sf.color_saturation' here
+ // but since /data may be encrypted, we need to wait until after vold
+ // comes online to attempt to read the property. The property is
+ // instead read after the boot animation
+
+ if (base::GetBoolProperty("debug.sf.treble_testing_override"s, false)) {
// Without the override SurfaceFlinger cannot connect to HIDL
// services that are not listed in the manifests. Considered
// deriving the setting from the set service name, but it
// would be brittle if the name that's not 'default' is used
// for production purposes later on.
+ ALOGI("Enabling Treble testing override");
android::hardware::details::setTrebleTestingOverride(true);
}
- if (!mConfig->isUserBuild && mConfig->enableTransactionTracing) {
+ // TODO (b/270966065) Update the HWC based refresh rate overlay to support spinner
+ mRefreshRateOverlaySpinner = property_get_bool("debug.sf.show_refresh_rate_overlay_spinner", 0);
+ mRefreshRateOverlayRenderRate =
+ property_get_bool("debug.sf.show_refresh_rate_overlay_render_rate", 0);
+ mRefreshRateOverlayShowInMiddle =
+ property_get_bool("debug.sf.show_refresh_rate_overlay_in_middle", 0);
+
+ if (!mIsUserBuild && base::GetBoolProperty("debug.sf.enable_transaction_tracing"s, true)) {
mTransactionTracing.emplace();
}
+
+ mIgnoreHdrCameraLayers = ignore_hdr_camera_layers(false);
+
+ mLayerLifecycleManagerEnabled =
+ base::GetBoolProperty("persist.debug.sf.enable_layer_lifecycle_manager"s, false);
+ mLegacyFrontEndEnabled = !mLayerLifecycleManagerEnabled ||
+ base::GetBoolProperty("persist.debug.sf.enable_legacy_frontend"s, false);
}
LatchUnsignaledConfig SurfaceFlinger::getLatchUnsignaledConfig() {
@@ -693,18 +816,17 @@ void SurfaceFlinger::init() FTL_FAKE_GUARD(kMainThreadContext) {
// Get a RenderEngine for the given display / config (can't fail)
// TODO(b/77156734): We need to stop casting and use HAL types when possible.
// Sending maxFrameBufferAcquiredBuffers as the cache size is tightly tuned to single-display.
- auto builder =
- renderengine::RenderEngineCreationArgs::Builder()
- .setPixelFormat(static_cast<int32_t>(mConfig->defaultCompositionPixelFormat))
- .setImageCacheSize(mConfig->maxFrameBufferAcquiredBuffers)
- .setUseColorManagerment(useColorManagement)
- .setEnableProtectedContext(enable_protected_contents(false))
- .setPrecacheToneMapperShaderOnly(false)
- .setSupportsBackgroundBlur(mConfig->supportsBlur)
- .setContextPriority(
- mConfig->useContextPriority
- ? renderengine::RenderEngine::ContextPriority::REALTIME
- : renderengine::RenderEngine::ContextPriority::MEDIUM);
+ auto builder = renderengine::RenderEngineCreationArgs::Builder()
+ .setPixelFormat(static_cast<int32_t>(defaultCompositionPixelFormat))
+ .setImageCacheSize(maxFrameBufferAcquiredBuffers)
+ .setUseColorManagerment(useColorManagement)
+ .setEnableProtectedContext(enable_protected_contents(false))
+ .setPrecacheToneMapperShaderOnly(false)
+ .setSupportsBackgroundBlur(mSupportsBlur)
+ .setContextPriority(
+ useContextPriority
+ ? renderengine::RenderEngine::ContextPriority::REALTIME
+ : renderengine::RenderEngine::ContextPriority::MEDIUM);
if (auto type = chooseRenderEngineTypeViaSysProp()) {
builder.setRenderEngineType(type.value());
}
@@ -719,7 +841,7 @@ void SurfaceFlinger::init() FTL_FAKE_GUARD(kMainThreadContext) {
}
mCompositionEngine->setTimeStats(mTimeStats);
- mCompositionEngine->setHwComposer(getFactory().createHWComposer(mConfig->hwcServiceName));
+ mCompositionEngine->setHwComposer(getFactory().createHWComposer(mHwcServiceName));
mCompositionEngine->getHwComposer().setCallback(*this);
ClientCache::getInstance().setRenderEngine(&getRenderEngine());
@@ -909,11 +1031,11 @@ status_t SurfaceFlinger::getStaticDisplayInfo(int64_t displayId, ui::StaticDispl
info->connectionType = snapshot.connectionType();
info->deviceProductInfo = snapshot.deviceProductInfo();
- if (mConfig->emulatedDisplayDensity) {
- info->density = mConfig->emulatedDisplayDensity;
+ if (mEmulatedDisplayDensity) {
+ info->density = mEmulatedDisplayDensity;
} else {
info->density = info->connectionType == ui::DisplayConnectionType::Internal
- ? mConfig->internalDisplayDensity
+ ? mInternalDisplayDensity
: FALLBACK_DENSITY;
}
info->density /= ACONFIGURATION_DENSITY_MEDIUM;
@@ -976,7 +1098,7 @@ void SurfaceFlinger::getDynamicDisplayInfoInternal(ui::DynamicDisplayInfo*& info
info->supportedDisplayModes.push_back(outMode);
}
- info->supportedColorModes = snapshot.filterColorModes(mConfig->supportsWideColor);
+ info->supportedColorModes = snapshot.filterColorModes(mSupportsWideColor);
const PhysicalDisplayId displayId = snapshot.displayId();
@@ -1374,7 +1496,7 @@ status_t SurfaceFlinger::getDisplayNativePrimaries(const sp<IBinder>& displayTok
}
// TODO(b/229846990): For now, assume that all internal displays have the same primaries.
- primaries = mConfig->internalDisplayPrimaries;
+ primaries = mInternalDisplayPrimaries;
return NO_ERROR;
}
@@ -1398,7 +1520,7 @@ status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ui:
const auto& [display, snapshotRef] = *displayOpt;
const auto& snapshot = snapshotRef.get();
- const auto modes = snapshot.filterColorModes(mConfig->supportsWideColor);
+ const auto modes = snapshot.filterColorModes(mSupportsWideColor);
const bool exists = std::find(modes.begin(), modes.end(), mode) != modes.end();
if (mode < ui::ColorMode::NATIVE || !exists) {
@@ -1704,7 +1826,7 @@ status_t SurfaceFlinger::isWideColorDisplay(const sp<IBinder>& displayToken,
}
*outIsWideColorDisplay =
- display->isPrimary() ? mConfig->supportsWideColor : display->hasWideColorGamut();
+ display->isPrimary() ? mSupportsWideColor : display->hasWideColorGamut();
return NO_ERROR;
}
@@ -1725,12 +1847,10 @@ status_t SurfaceFlinger::getCompositionPreference(
Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
Dataspace* outWideColorGamutDataspace,
ui::PixelFormat* outWideColorGamutPixelFormat) const {
- *outDataspace =
- mOverrideDefaultCompositionDataspace.value_or(mConfig->defaultCompositionDataspace);
- *outPixelFormat = mConfig->defaultCompositionPixelFormat;
- *outWideColorGamutDataspace = mOverrideWideColorGamutCompositionDataspace.value_or(
- mConfig->wideColorGamutCompositionDataspace);
- *outWideColorGamutPixelFormat = mConfig->wideColorGamutCompositionPixelFormat;
+ *outDataspace = mDefaultCompositionDataspace;
+ *outPixelFormat = defaultCompositionPixelFormat;
+ *outWideColorGamutDataspace = mWideColorGamutCompositionDataspace;
+ *outWideColorGamutPixelFormat = wideColorGamutCompositionPixelFormat;
return NO_ERROR;
}
@@ -2193,7 +2313,7 @@ bool SurfaceFlinger::updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs,
.displays = mFrontEndDisplayInfos,
.displayChanges = mFrontEndDisplayInfosChanged,
.globalShadowSettings = mDrawingState.globalShadowSettings,
- .supportsBlur = mConfig->supportsBlur,
+ .supportsBlur = mSupportsBlur,
.forceFullDamage = mForceFullDamage,
.supportedLayerGenericMetadata =
getHwComposer().getSupportedLayerGenericMetadata(),
@@ -2213,7 +2333,7 @@ bool SurfaceFlinger::updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs,
mustComposite |= mLayerLifecycleManager.getGlobalChanges().get() != 0;
bool newDataLatched = false;
- if (!mConfig->legacyFrontEndEnabled) {
+ if (!mLegacyFrontEndEnabled) {
ATRACE_NAME("DisplayCallbackAndStatsUpdates");
applyTransactions(update.transactions, vsyncId);
const nsecs_t latchTime = systemTime();
@@ -2307,7 +2427,7 @@ bool SurfaceFlinger::commit(const scheduler::FrameTarget& pacesetterFrameTarget)
}
if (pacesetterFrameTarget.isFramePending()) {
- if (mConfig->backpressureGpuComposition || pacesetterFrameTarget.didMissHwcFrame()) {
+ if (mBackpressureGpuComposition || pacesetterFrameTarget.didMissHwcFrame()) {
scheduleCommit(FrameHint::kNone);
return false;
}
@@ -2338,7 +2458,7 @@ bool SurfaceFlinger::commit(const scheduler::FrameTarget& pacesetterFrameTarget)
mPowerAdvisor->updateTargetWorkDuration(idealVsyncPeriod);
}
- if (mConfig->refreshRateOverlay.showSpinner) {
+ if (mRefreshRateOverlaySpinner) {
Mutex::Autolock lock(mStateLock);
if (const auto display = getDefaultDisplayDeviceLocked()) {
display->animateRefreshRateOverlay();
@@ -2354,12 +2474,12 @@ bool SurfaceFlinger::commit(const scheduler::FrameTarget& pacesetterFrameTarget)
const bool flushTransactions = clearTransactionFlags(eTransactionFlushNeeded);
bool transactionsAreEmpty;
- if (mConfig->legacyFrontEndEnabled) {
+ if (mLegacyFrontEndEnabled) {
mustComposite |=
updateLayerSnapshotsLegacy(vsyncId, pacesetterFrameTarget.frameBeginTime().ns(),
flushTransactions, transactionsAreEmpty);
}
- if (mConfig->layerLifecycleManagerEnabled) {
+ if (mLayerLifecycleManagerEnabled) {
mustComposite |=
updateLayerSnapshots(vsyncId, pacesetterFrameTarget.frameBeginTime().ns(),
flushTransactions, transactionsAreEmpty);
@@ -2465,7 +2585,7 @@ CompositeResult SurfaceFlinger::composite(scheduler::FrameTargeter& pacesetterFr
refreshArgs.outputColorSetting = useColorManagement
? mDisplayColorSetting
: compositionengine::OutputColorSetting::kUnmanaged;
- refreshArgs.colorSpaceAgnosticDataspace = mConfig->colorSpaceAgnosticDataspace;
+ refreshArgs.colorSpaceAgnosticDataspace = mColorSpaceAgnosticDataspace;
refreshArgs.forceOutputColorMode = mForceColorMode;
refreshArgs.updatingOutputGeometryThisFrame = mVisibleRegionsDirty;
@@ -2619,7 +2739,7 @@ bool SurfaceFlinger::isHdrLayer(const frontend::LayerSnapshot& snapshot) const {
// Even though the camera layer may be using an HDR transfer function or otherwise be "HDR"
// the device may need to avoid boosting the brightness as a result of these layers to
// reduce power consumption during camera recording
- if (mConfig->ignoreHdrCameraLayers) {
+ if (mIgnoreHdrCameraLayers) {
if (snapshot.externalTexture &&
(snapshot.externalTexture->getUsage() & GRALLOC_USAGE_HW_CAMERA_WRITE) != 0) {
return false;
@@ -2650,7 +2770,7 @@ ui::Rotation SurfaceFlinger::getPhysicalDisplayOrientation(DisplayId displayId,
if (!id) {
return ui::ROTATION_0;
}
- if (!mConfig->ignoreHwcPhysicalDisplayOrientation &&
+ if (!mIgnoreHwcPhysicalDisplayOrientation &&
getHwComposer().getComposer()->isSupported(
Hwc2::Composer::OptionalFeature::PhysicalDisplayOrientation)) {
switch (getHwComposer().getPhysicalDisplayOrientation(*id)) {
@@ -2817,7 +2937,7 @@ void SurfaceFlinger::postComposition(scheduler::FrameTargeter& pacesetterFrameTa
}
};
- if (mConfig->layerLifecycleManagerEnabled) {
+ if (mLayerLifecycleManagerEnabled) {
mLayerSnapshotBuilder.forEachVisibleSnapshot(
[&, compositionDisplay = compositionDisplay](
std::unique_ptr<frontend::LayerSnapshot>& snapshot) {
@@ -2869,7 +2989,7 @@ void SurfaceFlinger::postComposition(scheduler::FrameTargeter& pacesetterFrameTa
const bool isDisplayConnected =
defaultDisplay && getHwComposer().isConnected(defaultDisplay->getPhysicalId());
- if (!mConfig->hasSyncFramework) {
+ if (!hasSyncFramework) {
if (isDisplayConnected && defaultDisplay->isPoweredOn()) {
mScheduler->enableHardwareVsync(defaultDisplay->getPhysicalId());
}
@@ -2910,7 +3030,7 @@ void SurfaceFlinger::postComposition(scheduler::FrameTargeter& pacesetterFrameTa
if (!layer->hasTrustedPresentationListener()) {
return;
}
- const frontend::LayerSnapshot* snapshot = mConfig->layerLifecycleManagerEnabled
+ const frontend::LayerSnapshot* snapshot = mLayerLifecycleManagerEnabled
? mLayerSnapshotBuilder.getSnapshot(layer->sequence)
: layer->getLayerSnapshot();
std::optional<const DisplayDevice*> displayOpt = std::nullopt;
@@ -3305,7 +3425,7 @@ void SurfaceFlinger::processDisplayAdded(const wp<IBinder>& displayToken,
builder.setPowerAdvisor(mPowerAdvisor.get());
builder.setName(state.displayName);
auto compositionDisplay = getCompositionEngine().createDisplay(builder.build());
- compositionDisplay->setLayerCachingEnabled(mConfig->layerCachingEnabled);
+ compositionDisplay->setLayerCachingEnabled(mLayerCachingEnabled);
sp<compositionengine::DisplaySurface> displaySurface;
sp<IGraphicBufferProducer> producer;
@@ -3317,8 +3437,7 @@ void SurfaceFlinger::processDisplayAdded(const wp<IBinder>& displayToken,
const auto displayId = VirtualDisplayId::tryCast(compositionDisplay->getId());
LOG_FATAL_IF(!displayId);
auto surface = sp<VirtualDisplaySurface>::make(getHwComposer(), *displayId, state.surface,
- bqProducer, bqConsumer, state.displayName,
- mConfig->useHwcForRgbToYuv);
+ bqProducer, bqConsumer, state.displayName);
displaySurface = surface;
producer = std::move(surface);
} else {
@@ -3328,11 +3447,10 @@ void SurfaceFlinger::processDisplayAdded(const wp<IBinder>& displayToken,
state.surface.get());
const auto displayId = PhysicalDisplayId::tryCast(compositionDisplay->getId());
LOG_FATAL_IF(!displayId);
- displaySurface = sp<FramebufferSurface>::make(getHwComposer(), *displayId, bqConsumer,
- state.physical->activeMode->getResolution(),
- ui::Size(mConfig->maxGraphicsWidth,
- mConfig->maxGraphicsHeight),
- mConfig->maxFrameBufferAcquiredBuffers);
+ displaySurface =
+ sp<FramebufferSurface>::make(getHwComposer(), *displayId, bqConsumer,
+ state.physical->activeMode->getResolution(),
+ ui::Size(maxGraphicsWidth, maxGraphicsHeight));
producer = bqProducer;
}
@@ -3513,7 +3631,7 @@ void SurfaceFlinger::commitTransactionsLocked(uint32_t transactionFlags) {
// Commit display transactions.
const bool displayTransactionNeeded = transactionFlags & eDisplayTransactionNeeded;
mFrontEndDisplayInfosChanged = displayTransactionNeeded;
- if (displayTransactionNeeded && !mConfig->layerLifecycleManagerEnabled) {
+ if (displayTransactionNeeded && !mLayerLifecycleManagerEnabled) {
processDisplayChangesLocked();
mFrontEndDisplayInfos.clear();
for (const auto& [_, display] : mDisplays) {
@@ -3713,7 +3831,7 @@ void SurfaceFlinger::buildWindowInfos(std::vector<WindowInfo>& outWindowInfos,
outWindowInfos.reserve(sNumWindowInfos);
sNumWindowInfos = 0;
- if (mConfig->layerLifecycleManagerEnabled) {
+ if (mLayerLifecycleManagerEnabled) {
mLayerSnapshotBuilder.forEachInputSnapshot(
[&outWindowInfos](const frontend::LayerSnapshot& snapshot) {
outWindowInfos.push_back(snapshot.inputInfo);
@@ -3837,7 +3955,7 @@ void SurfaceFlinger::initScheduler(const sp<const DisplayDevice>& display) {
if (display->refreshRateSelector().kernelIdleTimerController()) {
features |= Feature::kKernelIdleTimer;
}
- if (mConfig->backpressureGpuComposition) {
+ if (mBackpressureGpuComposition) {
features |= Feature::kBackpressureGpuComposition;
}
@@ -4383,7 +4501,7 @@ TransactionHandler::TransactionReadiness SurfaceFlinger::transactionReadyBufferC
void SurfaceFlinger::addTransactionReadyFilters() {
mTransactionHandler.addTransactionReadyFilter(
std::bind(&SurfaceFlinger::transactionReadyTimelineCheck, this, std::placeholders::_1));
- if (mConfig->layerLifecycleManagerEnabled) {
+ if (mLayerLifecycleManagerEnabled) {
mTransactionHandler.addTransactionReadyFilter(
std::bind(&SurfaceFlinger::transactionReadyBufferCheck, this,
std::placeholders::_1));
@@ -4614,7 +4732,7 @@ bool SurfaceFlinger::applyTransactionState(const FrameTimelineInfo& frameTimelin
const std::vector<ListenerCallbacks>& listenerCallbacks,
int originPid, int originUid, uint64_t transactionId) {
uint32_t transactionFlags = 0;
- if (!mConfig->layerLifecycleManagerEnabled) {
+ if (!mLayerLifecycleManagerEnabled) {
for (DisplayState& display : displays) {
transactionFlags |= setDisplayStateLocked(display);
}
@@ -4629,12 +4747,12 @@ bool SurfaceFlinger::applyTransactionState(const FrameTimelineInfo& frameTimelin
uint32_t clientStateFlags = 0;
for (auto& resolvedState : states) {
- if (mConfig->legacyFrontEndEnabled) {
+ if (mLegacyFrontEndEnabled) {
clientStateFlags |=
setClientStateLocked(frameTimelineInfo, resolvedState, desiredPresentTime,
isAutoTimestamp, postTime, transactionId);
- } else /* mConfig->layerLifecycleManagerEnabled */ {
+ } else /*mLayerLifecycleManagerEnabled*/ {
clientStateFlags |= updateLayerCallbacksAndStats(frameTimelineInfo, resolvedState,
desiredPresentTime, isAutoTimestamp,
postTime, transactionId);
@@ -4708,7 +4826,7 @@ bool SurfaceFlinger::applyAndCommitDisplayTransactionStates(
}
mFrontEndDisplayInfosChanged = mTransactionFlags & eDisplayTransactionNeeded;
- if (mFrontEndDisplayInfosChanged && !mConfig->legacyFrontEndEnabled) {
+ if (mFrontEndDisplayInfosChanged && !mLegacyFrontEndEnabled) {
processDisplayChangesLocked();
mFrontEndDisplayInfos.clear();
for (const auto& [_, display] : mDisplays) {
@@ -4911,7 +5029,7 @@ uint32_t SurfaceFlinger::setClientStateLocked(const FrameTimelineInfo& frameTime
if (layer->setCornerRadius(s.cornerRadius))
flags |= eTraversalNeeded;
}
- if (what & layer_state_t::eBackgroundBlurRadiusChanged && mConfig->supportsBlur) {
+ if (what & layer_state_t::eBackgroundBlurRadiusChanged && mSupportsBlur) {
if (layer->setBackgroundBlurRadius(s.backgroundBlurRadius)) flags |= eTraversalNeeded;
}
if (what & layer_state_t::eBlurRegionsChanged) {
@@ -5315,7 +5433,7 @@ status_t SurfaceFlinger::mirrorDisplay(DisplayId displayId, const LayerCreationA
return result;
}
- if (mConfig->legacyFrontEndEnabled) {
+ if (mLegacyFrontEndEnabled) {
std::scoped_lock<std::mutex> lock(mMirrorDisplayLock);
mMirrorDisplays.emplace_back(layerStack, outResult.handle, args.client);
}
@@ -5422,10 +5540,9 @@ void SurfaceFlinger::initializeDisplays() {
const nsecs_t now = systemTime();
state.desiredPresentTime = now;
state.postTime = now;
- state.originPid = mConfig->pid;
+ state.originPid = mPid;
state.originUid = static_cast<int>(getuid());
- const uint64_t transactionId =
- (static_cast<uint64_t>(mConfig->pid) << 32) | mUniqueTransactionId++;
+ const uint64_t transactionId = (static_cast<uint64_t>(mPid) << 32) | mUniqueTransactionId++;
state.id = transactionId;
// reset screen orientation and use primary layer stack
@@ -5445,7 +5562,7 @@ void SurfaceFlinger::initializeDisplays() {
std::vector<TransactionState> transactions;
transactions.emplace_back(state);
- if (mConfig->legacyFrontEndEnabled) {
+ if (mLegacyFrontEndEnabled) {
applyTransactions(transactions, VsyncId{0});
} else {
applyAndCommitDisplayTransactionStates(transactions);
@@ -5741,13 +5858,13 @@ void SurfaceFlinger::logFrameStats(TimePoint now) {
void SurfaceFlinger::appendSfConfigString(std::string& result) const {
result.append(" [sf");
- StringAppendF(&result, " PRESENT_TIME_OFFSET=%" PRId64, mConfig->dispSyncPresentTimeOffset);
- StringAppendF(&result, " FORCE_HWC_FOR_RBG_TO_YUV=%d", mConfig->useHwcForRgbToYuv);
+ StringAppendF(&result, " PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
+ StringAppendF(&result, " FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
StringAppendF(&result, " MAX_VIRT_DISPLAY_DIM=%zu",
getHwComposer().getMaxVirtualDisplayDimension());
- StringAppendF(&result, " RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !mConfig->hasSyncFramework);
+ StringAppendF(&result, " RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
StringAppendF(&result, " NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
- mConfig->maxFrameBufferAcquiredBuffers);
+ maxFrameBufferAcquiredBuffers);
result.append("]");
}
@@ -5767,7 +5884,7 @@ void SurfaceFlinger::dumpScheduler(std::string& result) const {
StringAppendF(&result,
" present offset: %9" PRId64 " ns\t VSYNC period: %9" PRId64
" ns\n\n",
- mConfig->dispSyncPresentTimeOffset, getVsyncPeriodFromHWC());
+ dispSyncPresentTimeOffset, getVsyncPeriodFromHWC());
}
void SurfaceFlinger::dumpEvents(std::string& result) const {
@@ -5866,7 +5983,7 @@ void SurfaceFlinger::dumpRawDisplayIdentificationData(const DumpArgs& args,
}
void SurfaceFlinger::dumpWideColorInfo(std::string& result) const {
- StringAppendF(&result, "Device supports wide color: %d\n", mConfig->supportsWideColor);
+ StringAppendF(&result, "Device supports wide color: %d\n", mSupportsWideColor);
StringAppendF(&result, "Device uses color management: %d\n", useColorManagement);
StringAppendF(&result, "DisplayColorSetting: %s\n",
decodeDisplayColorSetting(mDisplayColorSetting).c_str());
@@ -5900,7 +6017,7 @@ LayersProto SurfaceFlinger::dumpDrawingStateProto(uint32_t traceFlags) const {
}
}
- if (mConfig->legacyFrontEndEnabled) {
+ if (mLegacyFrontEndEnabled) {
LayersProto layersProto;
for (const sp<Layer>& layer : mDrawingState.layersSortedByZ) {
if (stackIdsToSkip.find(layer->getLayerStack().id) != stackIdsToSkip.end()) {
@@ -6557,7 +6674,7 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r
if (!validateCompositionDataspace(dataspace)) {
return BAD_VALUE;
}
- mOverrideDefaultCompositionDataspace = dataspace;
+ mDefaultCompositionDataspace = dataspace;
}
n = data.readInt32();
if (n) {
@@ -6565,12 +6682,12 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r
if (!validateCompositionDataspace(dataspace)) {
return BAD_VALUE;
}
- mOverrideWideColorGamutCompositionDataspace = dataspace;
+ mWideColorGamutCompositionDataspace = dataspace;
}
} else {
- // Reset data space overrides.
- mOverrideDefaultCompositionDataspace.reset();
- mOverrideWideColorGamutCompositionDataspace.reset();
+ // restore composition data space.
+ mDefaultCompositionDataspace = defaultCompositionDataspace;
+ mWideColorGamutCompositionDataspace = wideColorGamutCompositionDataspace;
}
return NO_ERROR;
}
@@ -6709,10 +6826,10 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r
}
{
Mutex::Autolock lock(mStateLock);
- mConfig->layerCachingEnabled = n != 0;
+ mLayerCachingEnabled = n != 0;
for (const auto& [_, display] : mDisplays) {
if (!inputId || *inputId == display->getPhysicalId()) {
- display->enableLayerCaching(mConfig->layerCachingEnabled);
+ display->enableLayerCaching(mLayerCachingEnabled);
}
}
}
@@ -7037,7 +7154,7 @@ status_t SurfaceFlinger::captureDisplay(const DisplayCaptureArgs& args,
});
GetLayerSnapshotsFunction getLayerSnapshots;
- if (mConfig->layerLifecycleManagerEnabled) {
+ if (mLayerLifecycleManagerEnabled) {
getLayerSnapshots =
getLayerSnapshotsForScreenshots(layerStack, args.uid, std::move(excludeLayerIds));
} else {
@@ -7080,7 +7197,7 @@ status_t SurfaceFlinger::captureDisplay(DisplayId displayId,
});
GetLayerSnapshotsFunction getLayerSnapshots;
- if (mConfig->layerLifecycleManagerEnabled) {
+ if (mLayerLifecycleManagerEnabled) {
getLayerSnapshots = getLayerSnapshotsForScreenshots(layerStack, CaptureArgs::UNSET_UID,
/*snapshotFilterFn=*/nullptr);
} else {
@@ -7176,7 +7293,7 @@ status_t SurfaceFlinger::captureLayers(const LayerCaptureArgs& args,
RenderAreaFuture renderAreaFuture = ftl::defer([=]() -> std::unique_ptr<RenderArea> {
ui::Transform layerTransform;
Rect layerBufferSize;
- if (mConfig->layerLifecycleManagerEnabled) {
+ if (mLayerLifecycleManagerEnabled) {
frontend::LayerSnapshot* snapshot =
mLayerSnapshotBuilder.getSnapshot(parent->getSequence());
if (!snapshot) {
@@ -7196,7 +7313,7 @@ status_t SurfaceFlinger::captureLayers(const LayerCaptureArgs& args,
args.hintForSeamlessTransition);
});
GetLayerSnapshotsFunction getLayerSnapshots;
- if (mConfig->layerLifecycleManagerEnabled) {
+ if (mLayerLifecycleManagerEnabled) {
std::optional<FloatRect> parentCrop = std::nullopt;
if (args.childrenOnly) {
parentCrop = crop.isEmpty() ? FloatRect(0, 0, reqSize.width, reqSize.height)
@@ -7449,7 +7566,7 @@ ftl::SharedFuture<FenceResult> SurfaceFlinger::renderScreenImpl(
layerStack, regionSampling, renderArea = std::move(renderArea),
renderIntent]() -> FenceResult {
std::unique_ptr<compositionengine::CompositionEngine> compositionEngine =
- mConfig->factory->createCompositionEngine();
+ mFactory.createCompositionEngine();
compositionEngine->setRenderEngine(mRenderEngine.get());
compositionengine::Output::ColorProfile colorProfile{.dataspace = dataspace,
@@ -7519,7 +7636,7 @@ ftl::SharedFuture<FenceResult> SurfaceFlinger::renderScreenImpl(
}
void SurfaceFlinger::traverseLegacyLayers(const LayerVector::Visitor& visitor) const {
- if (mConfig->layerLifecycleManagerEnabled) {
+ if (mLayerLifecycleManagerEnabled) {
for (auto& layer : mLegacyLayers) {
visitor(layer.second.get());
}
@@ -7841,7 +7958,9 @@ void SurfaceFlinger::enableRefreshRateOverlay(bool enable) {
}
if (const auto device = getDisplayDeviceLocked(id)) {
- device->enableRefreshRateOverlay(enable, setByHwc);
+ device->enableRefreshRateOverlay(enable, setByHwc, mRefreshRateOverlaySpinner,
+ mRefreshRateOverlayRenderRate,
+ mRefreshRateOverlayShowInMiddle);
}
}
}
@@ -7852,12 +7971,12 @@ int SurfaceFlinger::getGpuContextPriority() {
}
int SurfaceFlinger::calculateMaxAcquiredBufferCount(Fps refreshRate,
- std::chrono::nanoseconds presentLatency) const {
+ std::chrono::nanoseconds presentLatency) {
auto pipelineDepth = presentLatency.count() / refreshRate.getPeriodNsecs();
if (presentLatency.count() % refreshRate.getPeriodNsecs()) {
pipelineDepth++;
}
- return std::max(mConfig->minAcquiredBuffers, static_cast<int64_t>(pipelineDepth - 1));
+ return std::max(minAcquiredBuffers, static_cast<int64_t>(pipelineDepth - 1));
}
status_t SurfaceFlinger::getMaxAcquiredBufferCount(int* buffers) const {
@@ -7939,7 +8058,7 @@ void SurfaceFlinger::handleLayerCreatedLocked(const LayerCreatedState& state, Vs
}
void SurfaceFlinger::sample() {
- if (!mConfig->lumaSampling || !mRegionSamplingThread) {
+ if (!mLumaSampling || !mRegionSamplingThread) {
return;
}
@@ -8131,7 +8250,7 @@ void SurfaceFlinger::updateLayerMetadataSnapshot() {
void SurfaceFlinger::moveSnapshotsFromCompositionArgs(
compositionengine::CompositionRefreshArgs& refreshArgs,
const std::vector<std::pair<Layer*, LayerFE*>>& layers) {
- if (mConfig->layerLifecycleManagerEnabled) {
+ if (mLayerLifecycleManagerEnabled) {
std::vector<std::unique_ptr<frontend::LayerSnapshot>>& snapshots =
mLayerSnapshotBuilder.getSnapshots();
for (auto [_, layerFE] : layers) {
@@ -8139,7 +8258,7 @@ void SurfaceFlinger::moveSnapshotsFromCompositionArgs(
snapshots[i] = std::move(layerFE->mSnapshot);
}
}
- if (mConfig->legacyFrontEndEnabled && !mConfig->layerLifecycleManagerEnabled) {
+ if (mLegacyFrontEndEnabled && !mLayerLifecycleManagerEnabled) {
for (auto [layer, layerFE] : layers) {
layer->updateLayerSnapshot(std::move(layerFE->mSnapshot));
}
@@ -8149,7 +8268,7 @@ void SurfaceFlinger::moveSnapshotsFromCompositionArgs(
std::vector<std::pair<Layer*, LayerFE*>> SurfaceFlinger::moveSnapshotsToCompositionArgs(
compositionengine::CompositionRefreshArgs& refreshArgs, bool cursorOnly) {
std::vector<std::pair<Layer*, LayerFE*>> layers;
- if (mConfig->layerLifecycleManagerEnabled) {
+ if (mLayerLifecycleManagerEnabled) {
nsecs_t currentTime = systemTime();
mLayerSnapshotBuilder.forEachVisibleSnapshot(
[&](std::unique_ptr<frontend::LayerSnapshot>& snapshot) {
@@ -8175,7 +8294,7 @@ std::vector<std::pair<Layer*, LayerFE*>> SurfaceFlinger::moveSnapshotsToComposit
layers.emplace_back(legacyLayer.get(), layerFE.get());
});
}
- if (mConfig->legacyFrontEndEnabled && !mConfig->layerLifecycleManagerEnabled) {
+ if (mLegacyFrontEndEnabled && !mLayerLifecycleManagerEnabled) {
auto moveSnapshots = [&layers, &refreshArgs, cursorOnly](Layer* layer) {
if (const auto& layerFE = layer->getCompositionEngineLayerFE()) {
if (cursorOnly &&
@@ -8267,7 +8386,7 @@ SurfaceFlinger::getLayerSnapshotsForScreenshots(std::optional<ui::LayerStack> la
.displays = mFrontEndDisplayInfos,
.displayChanges = true,
.globalShadowSettings = mDrawingState.globalShadowSettings,
- .supportsBlur = mConfig->supportsBlur,
+ .supportsBlur = mSupportsBlur,
.forceFullDamage = mForceFullDamage,
.excludeLayerIds = std::move(excludeLayerIds),
.supportedLayerGenericMetadata =
@@ -8301,7 +8420,7 @@ SurfaceFlinger::getLayerSnapshotsForScreenshots(uint32_t rootLayerId, uint32_t u
.displays = mFrontEndDisplayInfos,
.displayChanges = true,
.globalShadowSettings = mDrawingState.globalShadowSettings,
- .supportsBlur = mConfig->supportsBlur,
+ .supportsBlur = mSupportsBlur,
.forceFullDamage = mForceFullDamage,
.parentCrop = parentCrop,
.excludeLayerIds = std::move(excludeLayerIds),
generated by cgit v1.2.3-59-g8ed1b (git 2.39.0) at 2025-10-20 20:44:34 +0000