| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| //#define LOG_NDEBUG 0 |
| #define ATRACE_TAG ATRACE_TAG_GRAPHICS |
| |
| #include <sys/types.h> |
| #include <errno.h> |
| #include <dlfcn.h> |
| |
| #include <algorithm> |
| #include <cinttypes> |
| #include <cmath> |
| #include <cstdint> |
| #include <functional> |
| #include <mutex> |
| #include <optional> |
| #include <unordered_map> |
| |
| #include <cutils/properties.h> |
| #include <log/log.h> |
| |
| #include <binder/IPCThreadState.h> |
| #include <binder/IServiceManager.h> |
| #include <binder/PermissionCache.h> |
| |
| #include <compositionengine/CompositionEngine.h> |
| #include <compositionengine/Display.h> |
| #include <compositionengine/DisplayColorProfile.h> |
| #include <compositionengine/Layer.h> |
| #include <compositionengine/OutputLayer.h> |
| #include <compositionengine/RenderSurface.h> |
| #include <compositionengine/impl/LayerCompositionState.h> |
| #include <compositionengine/impl/OutputCompositionState.h> |
| #include <compositionengine/impl/OutputLayerCompositionState.h> |
| #include <dvr/vr_flinger.h> |
| #include <gui/BufferQueue.h> |
| #include <gui/DebugEGLImageTracker.h> |
| |
| #include <gui/GuiConfig.h> |
| #include <gui/IDisplayEventConnection.h> |
| #include <gui/IProducerListener.h> |
| #include <gui/LayerDebugInfo.h> |
| #include <gui/Surface.h> |
| #include <input/IInputFlinger.h> |
| #include <renderengine/RenderEngine.h> |
| #include <ui/ColorSpace.h> |
| #include <ui/DebugUtils.h> |
| #include <ui/DisplayInfo.h> |
| #include <ui/DisplayStatInfo.h> |
| #include <ui/GraphicBufferAllocator.h> |
| #include <ui/PixelFormat.h> |
| #include <ui/UiConfig.h> |
| #include <utils/StopWatch.h> |
| #include <utils/String16.h> |
| #include <utils/String8.h> |
| #include <utils/Timers.h> |
| #include <utils/Trace.h> |
| #include <utils/misc.h> |
| |
| #include <private/android_filesystem_config.h> |
| #include <private/gui/SyncFeatures.h> |
| |
| #include "BufferLayer.h" |
| #include "BufferQueueLayer.h" |
| #include "BufferStateLayer.h" |
| #include "Client.h" |
| #include "ColorLayer.h" |
| #include "Colorizer.h" |
| #include "ContainerLayer.h" |
| #include "DisplayDevice.h" |
| #include "Layer.h" |
| #include "LayerVector.h" |
| #include "MonitoredProducer.h" |
| #include "NativeWindowSurface.h" |
| #include "RefreshRateOverlay.h" |
| #include "StartPropertySetThread.h" |
| #include "SurfaceFlinger.h" |
| #include "SurfaceInterceptor.h" |
| |
| #include "DisplayHardware/ComposerHal.h" |
| #include "DisplayHardware/DisplayIdentification.h" |
| #include "DisplayHardware/FramebufferSurface.h" |
| #include "DisplayHardware/HWComposer.h" |
| #include "DisplayHardware/VirtualDisplaySurface.h" |
| #include "Effects/Daltonizer.h" |
| #include "RegionSamplingThread.h" |
| #include "Scheduler/DispSync.h" |
| #include "Scheduler/DispSyncSource.h" |
| #include "Scheduler/EventControlThread.h" |
| #include "Scheduler/EventThread.h" |
| #include "Scheduler/InjectVSyncSource.h" |
| #include "Scheduler/MessageQueue.h" |
| #include "Scheduler/PhaseOffsets.h" |
| #include "Scheduler/Scheduler.h" |
| #include "TimeStats/TimeStats.h" |
| |
| #include <cutils/compiler.h> |
| |
| #include "android-base/stringprintf.h" |
| |
| #include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h> |
| #include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h> |
| #include <android/hardware/configstore/1.1/types.h> |
| #include <android/hardware/power/1.0/IPower.h> |
| #include <configstore/Utils.h> |
| |
| #include <layerproto/LayerProtoParser.h> |
| #include "SurfaceFlingerProperties.h" |
| |
| namespace android { |
| |
| using namespace android::hardware::configstore; |
| using namespace android::hardware::configstore::V1_0; |
| using namespace android::sysprop; |
| |
| using android::hardware::power::V1_0::PowerHint; |
| using base::StringAppendF; |
| using ui::ColorMode; |
| using ui::Dataspace; |
| using ui::DisplayPrimaries; |
| using ui::Hdr; |
| using ui::RenderIntent; |
| |
| namespace { |
| |
| #pragma clang diagnostic push |
| #pragma clang diagnostic error "-Wswitch-enum" |
| |
| bool isWideColorMode(const ColorMode colorMode) { |
| switch (colorMode) { |
| case ColorMode::DISPLAY_P3: |
| case ColorMode::ADOBE_RGB: |
| case ColorMode::DCI_P3: |
| case ColorMode::BT2020: |
| case ColorMode::DISPLAY_BT2020: |
| case ColorMode::BT2100_PQ: |
| case ColorMode::BT2100_HLG: |
| return true; |
| case ColorMode::NATIVE: |
| case ColorMode::STANDARD_BT601_625: |
| case ColorMode::STANDARD_BT601_625_UNADJUSTED: |
| case ColorMode::STANDARD_BT601_525: |
| case ColorMode::STANDARD_BT601_525_UNADJUSTED: |
| case ColorMode::STANDARD_BT709: |
| case ColorMode::SRGB: |
| return false; |
| } |
| return false; |
| } |
| |
| bool isHdrColorMode(const ColorMode colorMode) { |
| switch (colorMode) { |
| case ColorMode::BT2100_PQ: |
| case ColorMode::BT2100_HLG: |
| return true; |
| case ColorMode::DISPLAY_P3: |
| case ColorMode::ADOBE_RGB: |
| case ColorMode::DCI_P3: |
| case ColorMode::BT2020: |
| case ColorMode::DISPLAY_BT2020: |
| case ColorMode::NATIVE: |
| case ColorMode::STANDARD_BT601_625: |
| case ColorMode::STANDARD_BT601_625_UNADJUSTED: |
| case ColorMode::STANDARD_BT601_525: |
| case ColorMode::STANDARD_BT601_525_UNADJUSTED: |
| case ColorMode::STANDARD_BT709: |
| case ColorMode::SRGB: |
| return false; |
| } |
| return false; |
| } |
| |
| ui::Transform::orientation_flags fromSurfaceComposerRotation(ISurfaceComposer::Rotation rotation) { |
| switch (rotation) { |
| case ISurfaceComposer::eRotateNone: |
| return ui::Transform::ROT_0; |
| case ISurfaceComposer::eRotate90: |
| return ui::Transform::ROT_90; |
| case ISurfaceComposer::eRotate180: |
| return ui::Transform::ROT_180; |
| case ISurfaceComposer::eRotate270: |
| return ui::Transform::ROT_270; |
| } |
| ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation); |
| return ui::Transform::ROT_0; |
| } |
| |
| #pragma clang diagnostic pop |
| |
| class ConditionalLock { |
| public: |
| ConditionalLock(Mutex& mutex, bool lock) : mMutex(mutex), mLocked(lock) { |
| if (lock) { |
| mMutex.lock(); |
| } |
| } |
| ~ConditionalLock() { if (mLocked) mMutex.unlock(); } |
| private: |
| Mutex& mMutex; |
| bool mLocked; |
| }; |
| |
| // 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; |
| } |
| |
| } // namespace anonymous |
| |
| // --------------------------------------------------------------------------- |
| |
| const String16 sHardwareTest("android.permission.HARDWARE_TEST"); |
| const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER"); |
| const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER"); |
| const String16 sDump("android.permission.DUMP"); |
| |
| // --------------------------------------------------------------------------- |
| int64_t SurfaceFlinger::dispSyncPresentTimeOffset; |
| bool SurfaceFlinger::useHwcForRgbToYuv; |
| uint64_t SurfaceFlinger::maxVirtualDisplaySize; |
| bool SurfaceFlinger::hasSyncFramework; |
| bool SurfaceFlinger::useVrFlinger; |
| int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers; |
| bool SurfaceFlinger::hasWideColorDisplay; |
| int SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientationDefault; |
| bool SurfaceFlinger::useColorManagement; |
| 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; |
| |
| std::string getHwcServiceName() { |
| char value[PROPERTY_VALUE_MAX] = {}; |
| property_get("debug.sf.hwc_service_name", value, "default"); |
| ALOGI("Using HWComposer service: '%s'", value); |
| return std::string(value); |
| } |
| |
| bool useTrebleTestingOverride() { |
| char value[PROPERTY_VALUE_MAX] = {}; |
| property_get("debug.sf.treble_testing_override", value, "false"); |
| ALOGI("Treble testing override: '%s'", value); |
| return std::string(value) == "true"; |
| } |
| |
| std::string decodeDisplayColorSetting(DisplayColorSetting displayColorSetting) { |
| switch(displayColorSetting) { |
| case DisplayColorSetting::MANAGED: |
| return std::string("Managed"); |
| case DisplayColorSetting::UNMANAGED: |
| return std::string("Unmanaged"); |
| case DisplayColorSetting::ENHANCED: |
| return std::string("Enhanced"); |
| default: |
| return std::string("Unknown ") + |
| std::to_string(static_cast<int>(displayColorSetting)); |
| } |
| } |
| |
| SurfaceFlingerBE::SurfaceFlingerBE() : mHwcServiceName(getHwcServiceName()) {} |
| |
| SurfaceFlinger::SurfaceFlinger(Factory& factory, SkipInitializationTag) |
| : mFactory(factory), |
| mPhaseOffsets(mFactory.createPhaseOffsets()), |
| mInterceptor(mFactory.createSurfaceInterceptor(this)), |
| mTimeStats(mFactory.createTimeStats()), |
| mEventQueue(mFactory.createMessageQueue()), |
| mCompositionEngine(mFactory.createCompositionEngine()) {} |
| |
| SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipInitialization) { |
| 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); |
| |
| maxVirtualDisplaySize = max_virtual_display_dimension(0); |
| |
| // Vr flinger is only enabled on Daydream ready devices. |
| useVrFlinger = use_vr_flinger(false); |
| |
| maxFrameBufferAcquiredBuffers = max_frame_buffer_acquired_buffers(2); |
| |
| hasWideColorDisplay = has_wide_color_display(false); |
| |
| useColorManagement = use_color_management(false); |
| |
| mDefaultCompositionDataspace = |
| static_cast<ui::Dataspace>(default_composition_dataspace(Dataspace::V0_SRGB)); |
| mWideColorGamutCompositionDataspace = static_cast<ui::Dataspace>(wcg_composition_dataspace( |
| hasWideColorDisplay ? 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)); |
| |
| useContextPriority = use_context_priority(true); |
| |
| auto tmpPrimaryDisplayOrientation = primary_display_orientation( |
| SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_0); |
| switch (tmpPrimaryDisplayOrientation) { |
| case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_90: |
| SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation90; |
| break; |
| case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_180: |
| SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation180; |
| break; |
| case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_270: |
| SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation270; |
| break; |
| default: |
| SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientationDefault; |
| break; |
| } |
| ALOGV("Primary Display Orientation is set to %2d.", SurfaceFlinger::primaryDisplayOrientation); |
| |
| mInternalDisplayPrimaries = sysprop::getDisplayNativePrimaries(); |
| |
| // debugging stuff... |
| char value[PROPERTY_VALUE_MAX]; |
| |
| property_get("ro.bq.gpu_to_cpu_unsupported", value, "0"); |
| mGpuToCpuSupported = !atoi(value); |
| |
| property_get("debug.sf.showupdates", value, "0"); |
| mDebugRegion = atoi(value); |
| |
| ALOGI_IF(mDebugRegion, "showupdates enabled"); |
| |
| // DDMS debugging deprecated (b/120782499) |
| property_get("debug.sf.ddms", value, "0"); |
| int debugDdms = atoi(value); |
| ALOGI_IF(debugDdms, "DDMS debugging not supported"); |
| |
| property_get("debug.sf.disable_backpressure", value, "0"); |
| mPropagateBackpressure = !atoi(value); |
| ALOGI_IF(!mPropagateBackpressure, "Disabling backpressure propagation"); |
| |
| property_get("debug.sf.enable_gl_backpressure", value, "0"); |
| mPropagateBackpressureClientComposition = atoi(value); |
| ALOGI_IF(mPropagateBackpressureClientComposition, |
| "Enabling backpressure propagation for Client Composition"); |
| |
| property_get("debug.sf.enable_hwc_vds", value, "0"); |
| mUseHwcVirtualDisplays = atoi(value); |
| ALOGI_IF(mUseHwcVirtualDisplays, "Enabling HWC virtual displays"); |
| |
| property_get("ro.sf.disable_triple_buffer", value, "0"); |
| mLayerTripleBufferingDisabled = atoi(value); |
| ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering"); |
| |
| 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; |
| |
| mUseSmart90ForVideo = use_smart_90_for_video(false); |
| property_get("debug.sf.use_smart_90_for_video", value, "0"); |
| |
| int int_value = atoi(value); |
| if (int_value) { |
| mUseSmart90ForVideo = true; |
| } |
| |
| property_get("debug.sf.luma_sampling", value, "1"); |
| mLumaSampling = atoi(value); |
| |
| const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets(); |
| mVsyncModulator.setPhaseOffsets(early, gl, late, |
| mPhaseOffsets->getOffsetThresholdForNextVsync()); |
| |
| // 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 (useTrebleTestingOverride()) { |
| // 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. |
| setenv("TREBLE_TESTING_OVERRIDE", "true", true); |
| } |
| } |
| |
| void SurfaceFlinger::onFirstRef() |
| { |
| mEventQueue->init(this); |
| } |
| |
| SurfaceFlinger::~SurfaceFlinger() = default; |
| |
| void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */) |
| { |
| // the window manager died on us. prepare its eulogy. |
| |
| // restore initial conditions (default device unblank, etc) |
| initializeDisplays(); |
| |
| // restart the boot-animation |
| startBootAnim(); |
| } |
| |
| static sp<ISurfaceComposerClient> initClient(const sp<Client>& client) { |
| status_t err = client->initCheck(); |
| if (err == NO_ERROR) { |
| return client; |
| } |
| return nullptr; |
| } |
| |
| sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() { |
| return initClient(new Client(this)); |
| } |
| |
| sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName, |
| bool secure) |
| { |
| class DisplayToken : public BBinder { |
| sp<SurfaceFlinger> flinger; |
| virtual ~DisplayToken() { |
| // no more references, this display must be terminated |
| Mutex::Autolock _l(flinger->mStateLock); |
| flinger->mCurrentState.displays.removeItem(this); |
| flinger->setTransactionFlags(eDisplayTransactionNeeded); |
| } |
| public: |
| explicit DisplayToken(const sp<SurfaceFlinger>& flinger) |
| : flinger(flinger) { |
| } |
| }; |
| |
| sp<BBinder> token = new DisplayToken(this); |
| |
| Mutex::Autolock _l(mStateLock); |
| // Display ID is assigned when virtual display is allocated by HWC. |
| DisplayDeviceState state; |
| state.isSecure = secure; |
| state.displayName = displayName; |
| mCurrentState.displays.add(token, state); |
| mInterceptor->saveDisplayCreation(state); |
| return token; |
| } |
| |
| void SurfaceFlinger::destroyDisplay(const sp<IBinder>& displayToken) { |
| Mutex::Autolock _l(mStateLock); |
| |
| ssize_t index = mCurrentState.displays.indexOfKey(displayToken); |
| if (index < 0) { |
| ALOGE("destroyDisplay: Invalid display token %p", displayToken.get()); |
| return; |
| } |
| |
| const DisplayDeviceState& state = mCurrentState.displays.valueAt(index); |
| if (!state.isVirtual()) { |
| ALOGE("destroyDisplay called for non-virtual display"); |
| return; |
| } |
| mInterceptor->saveDisplayDeletion(state.sequenceId); |
| mCurrentState.displays.removeItemsAt(index); |
| setTransactionFlags(eDisplayTransactionNeeded); |
| } |
| |
| std::vector<PhysicalDisplayId> SurfaceFlinger::getPhysicalDisplayIds() const { |
| Mutex::Autolock lock(mStateLock); |
| |
| const auto internalDisplayId = getInternalDisplayIdLocked(); |
| if (!internalDisplayId) { |
| return {}; |
| } |
| |
| std::vector<PhysicalDisplayId> displayIds; |
| displayIds.reserve(mPhysicalDisplayTokens.size()); |
| displayIds.push_back(internalDisplayId->value); |
| |
| for (const auto& [id, token] : mPhysicalDisplayTokens) { |
| if (id != *internalDisplayId) { |
| displayIds.push_back(id.value); |
| } |
| } |
| |
| return displayIds; |
| } |
| |
| sp<IBinder> SurfaceFlinger::getPhysicalDisplayToken(PhysicalDisplayId displayId) const { |
| Mutex::Autolock lock(mStateLock); |
| return getPhysicalDisplayTokenLocked(DisplayId{displayId}); |
| } |
| |
| status_t SurfaceFlinger::getColorManagement(bool* outGetColorManagement) const { |
| if (!outGetColorManagement) { |
| return BAD_VALUE; |
| } |
| *outGetColorManagement = useColorManagement; |
| return NO_ERROR; |
| } |
| |
| HWComposer& SurfaceFlinger::getHwComposer() const { |
| return mCompositionEngine->getHwComposer(); |
| } |
| |
| renderengine::RenderEngine& SurfaceFlinger::getRenderEngine() const { |
| return mCompositionEngine->getRenderEngine(); |
| } |
| |
| compositionengine::CompositionEngine& SurfaceFlinger::getCompositionEngine() const { |
| return *mCompositionEngine.get(); |
| } |
| |
| void SurfaceFlinger::bootFinished() |
| { |
| if (mStartPropertySetThread->join() != NO_ERROR) { |
| ALOGE("Join StartPropertySetThread failed!"); |
| } |
| const nsecs_t now = systemTime(); |
| const nsecs_t duration = now - mBootTime; |
| ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) ); |
| |
| // wait patiently for the window manager death |
| const String16 name("window"); |
| sp<IBinder> window(defaultServiceManager()->getService(name)); |
| if (window != 0) { |
| window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this)); |
| } |
| sp<IBinder> input(defaultServiceManager()->getService( |
| String16("inputflinger"))); |
| if (input == nullptr) { |
| ALOGE("Failed to link to input service"); |
| } else { |
| mInputFlinger = interface_cast<IInputFlinger>(input); |
| } |
| |
| if (mVrFlinger) { |
| mVrFlinger->OnBootFinished(); |
| } |
| |
| // stop boot animation |
| // formerly we would just kill the process, but we now ask it to exit so it |
| // can choose where to stop the animation. |
| property_set("service.bootanim.exit", "1"); |
| |
| const int LOGTAG_SF_STOP_BOOTANIM = 60110; |
| LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM, |
| ns2ms(systemTime(SYSTEM_TIME_MONOTONIC))); |
| |
| postMessageAsync(new LambdaMessage([this]() NO_THREAD_SAFETY_ANALYSIS { |
| readPersistentProperties(); |
| mBootStage = BootStage::FINISHED; |
| |
| // set the refresh rate according to the policy |
| const auto& performanceRefreshRate = |
| mRefreshRateConfigs.getRefreshRate(RefreshRateType::PERFORMANCE); |
| |
| if (performanceRefreshRate && isDisplayConfigAllowed(performanceRefreshRate->configId)) { |
| setRefreshRateTo(RefreshRateType::PERFORMANCE, Scheduler::ConfigEvent::None); |
| } else { |
| setRefreshRateTo(RefreshRateType::DEFAULT, Scheduler::ConfigEvent::None); |
| } |
| })); |
| } |
| |
| uint32_t SurfaceFlinger::getNewTexture() { |
| { |
| std::lock_guard lock(mTexturePoolMutex); |
| if (!mTexturePool.empty()) { |
| uint32_t name = mTexturePool.back(); |
| mTexturePool.pop_back(); |
| ATRACE_INT("TexturePoolSize", mTexturePool.size()); |
| return name; |
| } |
| |
| // The pool was too small, so increase it for the future |
| ++mTexturePoolSize; |
| } |
| |
| // The pool was empty, so we need to get a new texture name directly using a |
| // blocking call to the main thread |
| uint32_t name = 0; |
| postMessageSync(new LambdaMessage([&]() { getRenderEngine().genTextures(1, &name); })); |
| return name; |
| } |
| |
| void SurfaceFlinger::deleteTextureAsync(uint32_t texture) { |
| std::lock_guard lock(mTexturePoolMutex); |
| // We don't change the pool size, so the fix-up logic in postComposition will decide whether |
| // to actually delete this or not based on mTexturePoolSize |
| mTexturePool.push_back(texture); |
| ATRACE_INT("TexturePoolSize", mTexturePool.size()); |
| } |
| |
| // Do not call property_set on main thread which will be blocked by init |
| // Use StartPropertySetThread instead. |
| void SurfaceFlinger::init() { |
| ALOGI( "SurfaceFlinger's main thread ready to run. " |
| "Initializing graphics H/W..."); |
| |
| ALOGI("Phase offset NS: %" PRId64 "", mPhaseOffsets->getCurrentAppOffset()); |
| |
| Mutex::Autolock _l(mStateLock); |
| // start the EventThread |
| mScheduler = |
| getFactory().createScheduler([this](bool enabled) { setPrimaryVsyncEnabled(enabled); }, |
| mRefreshRateConfigs); |
| auto resyncCallback = |
| mScheduler->makeResyncCallback(std::bind(&SurfaceFlinger::getVsyncPeriod, this)); |
| |
| mAppConnectionHandle = |
| mScheduler->createConnection("app", mVsyncModulator.getOffsets().app, |
| mPhaseOffsets->getOffsetThresholdForNextVsync(), |
| resyncCallback, |
| impl::EventThread::InterceptVSyncsCallback()); |
| mSfConnectionHandle = |
| mScheduler->createConnection("sf", mVsyncModulator.getOffsets().sf, |
| mPhaseOffsets->getOffsetThresholdForNextVsync(), |
| resyncCallback, [this](nsecs_t timestamp) { |
| mInterceptor->saveVSyncEvent(timestamp); |
| }); |
| |
| mEventQueue->setEventConnection(mScheduler->getEventConnection(mSfConnectionHandle)); |
| mVsyncModulator.setSchedulerAndHandles(mScheduler.get(), mAppConnectionHandle.get(), |
| mSfConnectionHandle.get()); |
| |
| mRegionSamplingThread = |
| new RegionSamplingThread(*this, *mScheduler, |
| RegionSamplingThread::EnvironmentTimingTunables()); |
| |
| // Get a RenderEngine for the given display / config (can't fail) |
| int32_t renderEngineFeature = 0; |
| renderEngineFeature |= (useColorManagement ? |
| renderengine::RenderEngine::USE_COLOR_MANAGEMENT : 0); |
| renderEngineFeature |= (useContextPriority ? |
| renderengine::RenderEngine::USE_HIGH_PRIORITY_CONTEXT : 0); |
| renderEngineFeature |= |
| (enable_protected_contents(false) ? renderengine::RenderEngine::ENABLE_PROTECTED_CONTEXT |
| : 0); |
| |
| // 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. |
| mCompositionEngine->setRenderEngine( |
| renderengine::RenderEngine::create(static_cast<int32_t>(defaultCompositionPixelFormat), |
| renderEngineFeature, maxFrameBufferAcquiredBuffers)); |
| |
| LOG_ALWAYS_FATAL_IF(mVrFlingerRequestsDisplay, |
| "Starting with vr flinger active is not currently supported."); |
| mCompositionEngine->setHwComposer(getFactory().createHWComposer(getBE().mHwcServiceName)); |
| mCompositionEngine->getHwComposer().registerCallback(this, getBE().mComposerSequenceId); |
| // Process any initial hotplug and resulting display changes. |
| processDisplayHotplugEventsLocked(); |
| const auto display = getDefaultDisplayDeviceLocked(); |
| LOG_ALWAYS_FATAL_IF(!display, "Missing internal display after registering composer callback."); |
| LOG_ALWAYS_FATAL_IF(!getHwComposer().isConnected(*display->getId()), |
| "Internal display is disconnected."); |
| |
| if (useVrFlinger) { |
| auto vrFlingerRequestDisplayCallback = [this](bool requestDisplay) { |
| // This callback is called from the vr flinger dispatch thread. We |
| // need to call signalTransaction(), which requires holding |
| // mStateLock when we're not on the main thread. Acquiring |
| // mStateLock from the vr flinger dispatch thread might trigger a |
| // deadlock in surface flinger (see b/66916578), so post a message |
| // to be handled on the main thread instead. |
| postMessageAsync(new LambdaMessage([=] { |
| ALOGI("VR request display mode: requestDisplay=%d", requestDisplay); |
| mVrFlingerRequestsDisplay = requestDisplay; |
| signalTransaction(); |
| })); |
| }; |
| mVrFlinger = dvr::VrFlinger::Create(getHwComposer().getComposer(), |
| getHwComposer() |
| .fromPhysicalDisplayId(*display->getId()) |
| .value_or(0), |
| vrFlingerRequestDisplayCallback); |
| if (!mVrFlinger) { |
| ALOGE("Failed to start vrflinger"); |
| } |
| } |
| |
| // initialize our drawing state |
| mDrawingState = mCurrentState; |
| |
| // set initial conditions (e.g. unblank default device) |
| initializeDisplays(); |
| |
| getRenderEngine().primeCache(); |
| |
| // Inform native graphics APIs whether the present timestamp is supported: |
| |
| const bool presentFenceReliable = |
| !getHwComposer().hasCapability(HWC2::Capability::PresentFenceIsNotReliable); |
| mStartPropertySetThread = getFactory().createStartPropertySetThread(presentFenceReliable); |
| |
| if (mStartPropertySetThread->Start() != NO_ERROR) { |
| ALOGE("Run StartPropertySetThread failed!"); |
| } |
| |
| mScheduler->setChangeRefreshRateCallback( |
| [this](RefreshRateType type, Scheduler::ConfigEvent event) { |
| Mutex::Autolock lock(mStateLock); |
| setRefreshRateTo(type, event); |
| }); |
| mScheduler->setGetCurrentRefreshRateTypeCallback([this] { |
| Mutex::Autolock lock(mStateLock); |
| const auto display = getDefaultDisplayDeviceLocked(); |
| if (!display) { |
| // If we don't have a default display the fallback to the default |
| // refresh rate type |
| return RefreshRateType::DEFAULT; |
| } |
| |
| const int configId = display->getActiveConfig(); |
| for (const auto& [type, refresh] : mRefreshRateConfigs.getRefreshRates()) { |
| if (refresh && refresh->configId == configId) { |
| return type; |
| } |
| } |
| // This should never happen, but just gracefully fallback to default. |
| return RefreshRateType::DEFAULT; |
| }); |
| mScheduler->setGetVsyncPeriodCallback([this] { |
| Mutex::Autolock lock(mStateLock); |
| return getVsyncPeriod(); |
| }); |
| |
| mRefreshRateConfigs.populate(getHwComposer().getConfigs(*display->getId())); |
| mRefreshRateStats.setConfigMode(getHwComposer().getActiveConfigIndex(*display->getId())); |
| |
| ALOGV("Done initializing"); |
| } |
| |
| void SurfaceFlinger::readPersistentProperties() { |
| Mutex::Autolock _l(mStateLock); |
| |
| char value[PROPERTY_VALUE_MAX]; |
| |
| property_get("persist.sys.sf.color_saturation", value, "1.0"); |
| mGlobalSaturationFactor = atof(value); |
| updateColorMatrixLocked(); |
| ALOGV("Saturation is set to %.2f", mGlobalSaturationFactor); |
| |
| property_get("persist.sys.sf.native_mode", value, "0"); |
| mDisplayColorSetting = static_cast<DisplayColorSetting>(atoi(value)); |
| |
| property_get("persist.sys.sf.color_mode", value, "0"); |
| mForceColorMode = static_cast<ColorMode>(atoi(value)); |
| } |
| |
| void SurfaceFlinger::startBootAnim() { |
| // Start boot animation service by setting a property mailbox |
| // if property setting thread is already running, Start() will be just a NOP |
| mStartPropertySetThread->Start(); |
| // Wait until property was set |
| if (mStartPropertySetThread->join() != NO_ERROR) { |
| ALOGE("Join StartPropertySetThread failed!"); |
| } |
| } |
| |
| size_t SurfaceFlinger::getMaxTextureSize() const { |
| return getRenderEngine().getMaxTextureSize(); |
| } |
| |
| size_t SurfaceFlinger::getMaxViewportDims() const { |
| return getRenderEngine().getMaxViewportDims(); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| bool SurfaceFlinger::authenticateSurfaceTexture( |
| const sp<IGraphicBufferProducer>& bufferProducer) const { |
| Mutex::Autolock _l(mStateLock); |
| return authenticateSurfaceTextureLocked(bufferProducer); |
| } |
| |
| bool SurfaceFlinger::authenticateSurfaceTextureLocked( |
| const sp<IGraphicBufferProducer>& bufferProducer) const { |
| sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer)); |
| return mGraphicBufferProducerList.count(surfaceTextureBinder.get()) > 0; |
| } |
| |
| status_t SurfaceFlinger::getSupportedFrameTimestamps( |
| std::vector<FrameEvent>* outSupported) const { |
| *outSupported = { |
| FrameEvent::REQUESTED_PRESENT, |
| FrameEvent::ACQUIRE, |
| FrameEvent::LATCH, |
| FrameEvent::FIRST_REFRESH_START, |
| FrameEvent::LAST_REFRESH_START, |
| FrameEvent::GPU_COMPOSITION_DONE, |
| FrameEvent::DEQUEUE_READY, |
| FrameEvent::RELEASE, |
| }; |
| ConditionalLock _l(mStateLock, |
| std::this_thread::get_id() != mMainThreadId); |
| if (!getHwComposer().hasCapability( |
| HWC2::Capability::PresentFenceIsNotReliable)) { |
| outSupported->push_back(FrameEvent::DISPLAY_PRESENT); |
| } |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& displayToken, |
| Vector<DisplayInfo>* configs) { |
| if (!displayToken || !configs) { |
| return BAD_VALUE; |
| } |
| |
| Mutex::Autolock lock(mStateLock); |
| |
| const auto displayId = getPhysicalDisplayIdLocked(displayToken); |
| if (!displayId) { |
| return NAME_NOT_FOUND; |
| } |
| |
| // TODO: Not sure if display density should handled by SF any longer |
| class Density { |
| static float getDensityFromProperty(char const* propName) { |
| char property[PROPERTY_VALUE_MAX]; |
| float density = 0.0f; |
| if (property_get(propName, property, nullptr) > 0) { |
| density = strtof(property, nullptr); |
| } |
| return density; |
| } |
| public: |
| static float getEmuDensity() { |
| return getDensityFromProperty("qemu.sf.lcd_density"); } |
| static float getBuildDensity() { |
| return getDensityFromProperty("ro.sf.lcd_density"); } |
| }; |
| |
| configs->clear(); |
| |
| for (const auto& hwConfig : getHwComposer().getConfigs(*displayId)) { |
| DisplayInfo info = DisplayInfo(); |
| |
| float xdpi = hwConfig->getDpiX(); |
| float ydpi = hwConfig->getDpiY(); |
| |
| info.w = hwConfig->getWidth(); |
| info.h = hwConfig->getHeight(); |
| // Default display viewport to display width and height |
| info.viewportW = info.w; |
| info.viewportH = info.h; |
| |
| if (displayId == getInternalDisplayIdLocked()) { |
| // The density of the device is provided by a build property |
| float density = Density::getBuildDensity() / 160.0f; |
| if (density == 0) { |
| // the build doesn't provide a density -- this is wrong! |
| // use xdpi instead |
| ALOGE("ro.sf.lcd_density must be defined as a build property"); |
| density = xdpi / 160.0f; |
| } |
| if (Density::getEmuDensity()) { |
| // if "qemu.sf.lcd_density" is specified, it overrides everything |
| xdpi = ydpi = density = Density::getEmuDensity(); |
| density /= 160.0f; |
| } |
| info.density = density; |
| |
| // TODO: this needs to go away (currently needed only by webkit) |
| const auto display = getDefaultDisplayDeviceLocked(); |
| info.orientation = display ? display->getOrientation() : 0; |
| |
| // This is for screenrecord |
| const Rect viewport = display->getViewport(); |
| if (viewport.isValid()) { |
| info.viewportW = uint32_t(viewport.getWidth()); |
| info.viewportH = uint32_t(viewport.getHeight()); |
| } |
| } else { |
| // TODO: where should this value come from? |
| static const int TV_DENSITY = 213; |
| info.density = TV_DENSITY / 160.0f; |
| info.orientation = 0; |
| } |
| |
| info.xdpi = xdpi; |
| info.ydpi = ydpi; |
| info.fps = 1e9 / hwConfig->getVsyncPeriod(); |
| const auto refreshRateType = mRefreshRateConfigs.getRefreshRateType(hwConfig->getId()); |
| const auto offset = mPhaseOffsets->getOffsetsForRefreshRate(refreshRateType); |
| info.appVsyncOffset = offset.late.app; |
| |
| // This is how far in advance a buffer must be queued for |
| // presentation at a given time. If you want a buffer to appear |
| // on the screen at time N, you must submit the buffer before |
| // (N - presentationDeadline). |
| // |
| // Normally it's one full refresh period (to give SF a chance to |
| // latch the buffer), but this can be reduced by configuring a |
| // DispSync offset. Any additional delays introduced by the hardware |
| // composer or panel must be accounted for here. |
| // |
| // We add an additional 1ms to allow for processing time and |
| // differences between the ideal and actual refresh rate. |
| info.presentationDeadline = hwConfig->getVsyncPeriod() - offset.late.sf + 1000000; |
| |
| // All non-virtual displays are currently considered secure. |
| info.secure = true; |
| |
| if (displayId == getInternalDisplayIdLocked() && |
| primaryDisplayOrientation & DisplayState::eOrientationSwapMask) { |
| std::swap(info.w, info.h); |
| } |
| |
| configs->push_back(info); |
| } |
| |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>&, DisplayStatInfo* stats) { |
| if (!stats) { |
| return BAD_VALUE; |
| } |
| |
| mScheduler->getDisplayStatInfo(stats); |
| return NO_ERROR; |
| } |
| |
| int SurfaceFlinger::getActiveConfig(const sp<IBinder>& displayToken) { |
| const auto display = getDisplayDevice(displayToken); |
| if (!display) { |
| ALOGE("getActiveConfig: Invalid display token %p", displayToken.get()); |
| return BAD_VALUE; |
| } |
| |
| return display->getActiveConfig(); |
| } |
| |
| void SurfaceFlinger::setDesiredActiveConfig(const ActiveConfigInfo& info) { |
| ATRACE_CALL(); |
| |
| // Don't check against the current mode yet. Worst case we set the desired |
| // config twice. However event generation config might have changed so we need to update it |
| // accordingly |
| std::lock_guard<std::mutex> lock(mActiveConfigLock); |
| const Scheduler::ConfigEvent prevConfig = mDesiredActiveConfig.event; |
| mDesiredActiveConfig = info; |
| mDesiredActiveConfig.event = mDesiredActiveConfig.event | prevConfig; |
| |
| if (!mDesiredActiveConfigChanged) { |
| // This will trigger HWC refresh without resetting the idle timer. |
| repaintEverythingForHWC(); |
| // Start receiving vsync samples now, so that we can detect a period |
| // switch. |
| mScheduler->resyncToHardwareVsync(true, getVsyncPeriod()); |
| // As we called to set period, we will call to onRefreshRateChangeCompleted once |
| // DispSync model is locked. |
| mVsyncModulator.onRefreshRateChangeInitiated(); |
| mPhaseOffsets->setRefreshRateType(info.type); |
| const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets(); |
| mVsyncModulator.setPhaseOffsets(early, gl, late, |
| mPhaseOffsets->getOffsetThresholdForNextVsync()); |
| } |
| mDesiredActiveConfigChanged = true; |
| ATRACE_INT("DesiredActiveConfigChanged", mDesiredActiveConfigChanged); |
| |
| if (mRefreshRateOverlay) { |
| mRefreshRateOverlay->changeRefreshRate(mDesiredActiveConfig.type); |
| } |
| } |
| |
| status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& displayToken, int mode) { |
| ATRACE_CALL(); |
| |
| std::vector<int32_t> allowedConfig; |
| allowedConfig.push_back(mode); |
| |
| return setAllowedDisplayConfigs(displayToken, allowedConfig); |
| } |
| |
| void SurfaceFlinger::setActiveConfigInternal() { |
| ATRACE_CALL(); |
| |
| const auto display = getDefaultDisplayDeviceLocked(); |
| if (!display) { |
| return; |
| } |
| |
| std::lock_guard<std::mutex> lock(mActiveConfigLock); |
| mRefreshRateStats.setConfigMode(mUpcomingActiveConfig.configId); |
| |
| display->setActiveConfig(mUpcomingActiveConfig.configId); |
| |
| mPhaseOffsets->setRefreshRateType(mUpcomingActiveConfig.type); |
| const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets(); |
| mVsyncModulator.setPhaseOffsets(early, gl, late, |
| mPhaseOffsets->getOffsetThresholdForNextVsync()); |
| ATRACE_INT("ActiveConfigMode", mUpcomingActiveConfig.configId); |
| |
| if (mUpcomingActiveConfig.event != Scheduler::ConfigEvent::None) { |
| mScheduler->onConfigChanged(mAppConnectionHandle, display->getId()->value, |
| mUpcomingActiveConfig.configId); |
| } |
| } |
| |
| void SurfaceFlinger::desiredActiveConfigChangeDone() { |
| std::lock_guard<std::mutex> lock(mActiveConfigLock); |
| mDesiredActiveConfig.event = Scheduler::ConfigEvent::None; |
| mDesiredActiveConfigChanged = false; |
| ATRACE_INT("DesiredActiveConfigChanged", mDesiredActiveConfigChanged); |
| |
| mScheduler->resyncToHardwareVsync(true, getVsyncPeriod()); |
| mPhaseOffsets->setRefreshRateType(mUpcomingActiveConfig.type); |
| const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets(); |
| mVsyncModulator.setPhaseOffsets(early, gl, late, |
| mPhaseOffsets->getOffsetThresholdForNextVsync()); |
| } |
| |
| bool SurfaceFlinger::performSetActiveConfig() { |
| ATRACE_CALL(); |
| if (mCheckPendingFence) { |
| if (previousFrameMissed()) { |
| // fence has not signaled yet. wait for the next invalidate |
| mEventQueue->invalidate(); |
| return true; |
| } |
| |
| // We received the present fence from the HWC, so we assume it successfully updated |
| // the config, hence we update SF. |
| mCheckPendingFence = false; |
| setActiveConfigInternal(); |
| } |
| |
| // Store the local variable to release the lock. |
| ActiveConfigInfo desiredActiveConfig; |
| { |
| std::lock_guard<std::mutex> lock(mActiveConfigLock); |
| if (!mDesiredActiveConfigChanged) { |
| return false; |
| } |
| desiredActiveConfig = mDesiredActiveConfig; |
| } |
| |
| const auto display = getDefaultDisplayDeviceLocked(); |
| if (!display || display->getActiveConfig() == desiredActiveConfig.configId) { |
| // display is not valid or we are already in the requested mode |
| // on both cases there is nothing left to do |
| desiredActiveConfigChangeDone(); |
| return false; |
| } |
| |
| // Desired active config was set, it is different than the config currently in use, however |
| // allowed configs might have change by the time we process the refresh. |
| // Make sure the desired config is still allowed |
| if (!isDisplayConfigAllowed(desiredActiveConfig.configId)) { |
| desiredActiveConfigChangeDone(); |
| return false; |
| } |
| |
| mUpcomingActiveConfig = desiredActiveConfig; |
| const auto displayId = display->getId(); |
| LOG_ALWAYS_FATAL_IF(!displayId); |
| |
| ATRACE_INT("ActiveConfigModeHWC", mUpcomingActiveConfig.configId); |
| getHwComposer().setActiveConfig(*displayId, mUpcomingActiveConfig.configId); |
| |
| // we need to submit an empty frame to HWC to start the process |
| mCheckPendingFence = true; |
| mEventQueue->invalidate(); |
| return false; |
| } |
| |
| status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& displayToken, |
| Vector<ColorMode>* outColorModes) { |
| if (!displayToken || !outColorModes) { |
| return BAD_VALUE; |
| } |
| |
| std::vector<ColorMode> modes; |
| bool isInternalDisplay = false; |
| { |
| ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId); |
| |
| const auto displayId = getPhysicalDisplayIdLocked(displayToken); |
| if (!displayId) { |
| return NAME_NOT_FOUND; |
| } |
| |
| modes = getHwComposer().getColorModes(*displayId); |
| isInternalDisplay = displayId == getInternalDisplayIdLocked(); |
| } |
| outColorModes->clear(); |
| |
| // If it's built-in display and the configuration claims it's not wide color capable, |
| // filter out all wide color modes. The typical reason why this happens is that the |
| // hardware is not good enough to support GPU composition of wide color, and thus the |
| // OEMs choose to disable this capability. |
| if (isInternalDisplay && !hasWideColorDisplay) { |
| std::remove_copy_if(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes), |
| isWideColorMode); |
| } else { |
| std::copy(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes)); |
| } |
| |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::getDisplayNativePrimaries(const sp<IBinder>& displayToken, |
| ui::DisplayPrimaries &primaries) { |
| if (!displayToken) { |
| return BAD_VALUE; |
| } |
| |
| // Currently we only support this API for a single internal display. |
| if (getInternalDisplayToken() != displayToken) { |
| return BAD_VALUE; |
| } |
| |
| memcpy(&primaries, &mInternalDisplayPrimaries, sizeof(ui::DisplayPrimaries)); |
| return NO_ERROR; |
| } |
| |
| ColorMode SurfaceFlinger::getActiveColorMode(const sp<IBinder>& displayToken) { |
| if (const auto display = getDisplayDevice(displayToken)) { |
| return display->getCompositionDisplay()->getState().colorMode; |
| } |
| return static_cast<ColorMode>(BAD_VALUE); |
| } |
| |
| status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ColorMode mode) { |
| postMessageSync(new LambdaMessage([&] { |
| Vector<ColorMode> modes; |
| getDisplayColorModes(displayToken, &modes); |
| bool exists = std::find(std::begin(modes), std::end(modes), mode) != std::end(modes); |
| if (mode < ColorMode::NATIVE || !exists) { |
| ALOGE("Attempt to set invalid active color mode %s (%d) for display token %p", |
| decodeColorMode(mode).c_str(), mode, displayToken.get()); |
| return; |
| } |
| const auto display = getDisplayDevice(displayToken); |
| if (!display) { |
| ALOGE("Attempt to set active color mode %s (%d) for invalid display token %p", |
| decodeColorMode(mode).c_str(), mode, displayToken.get()); |
| } else if (display->isVirtual()) { |
| ALOGW("Attempt to set active color mode %s (%d) for virtual display", |
| decodeColorMode(mode).c_str(), mode); |
| } else { |
| display->getCompositionDisplay()->setColorMode(mode, Dataspace::UNKNOWN, |
| RenderIntent::COLORIMETRIC); |
| } |
| })); |
| |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::clearAnimationFrameStats() { |
| Mutex::Autolock _l(mStateLock); |
| mAnimFrameTracker.clearStats(); |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const { |
| Mutex::Autolock _l(mStateLock); |
| mAnimFrameTracker.getStats(outStats); |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& displayToken, |
| HdrCapabilities* outCapabilities) const { |
| Mutex::Autolock _l(mStateLock); |
| |
| const auto display = getDisplayDeviceLocked(displayToken); |
| if (!display) { |
| ALOGE("getHdrCapabilities: Invalid display token %p", displayToken.get()); |
| return BAD_VALUE; |
| } |
| |
| // At this point the DisplayDeivce should already be set up, |
| // meaning the luminance information is already queried from |
| // hardware composer and stored properly. |
| const HdrCapabilities& capabilities = display->getHdrCapabilities(); |
| *outCapabilities = HdrCapabilities(capabilities.getSupportedHdrTypes(), |
| capabilities.getDesiredMaxLuminance(), |
| capabilities.getDesiredMaxAverageLuminance(), |
| capabilities.getDesiredMinLuminance()); |
| |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken, |
| ui::PixelFormat* outFormat, |
| ui::Dataspace* outDataspace, |
| uint8_t* outComponentMask) const { |
| if (!outFormat || !outDataspace || !outComponentMask) { |
| return BAD_VALUE; |
| } |
| const auto display = getDisplayDevice(displayToken); |
| if (!display || !display->getId()) { |
| ALOGE("getDisplayedContentSamplingAttributes: Bad display token: %p", display.get()); |
| return BAD_VALUE; |
| } |
| return getHwComposer().getDisplayedContentSamplingAttributes(*display->getId(), outFormat, |
| outDataspace, outComponentMask); |
| } |
| |
| status_t SurfaceFlinger::setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken, |
| bool enable, uint8_t componentMask, |
| uint64_t maxFrames) const { |
| const auto display = getDisplayDevice(displayToken); |
| if (!display || !display->getId()) { |
| ALOGE("setDisplayContentSamplingEnabled: Bad display token: %p", display.get()); |
| return BAD_VALUE; |
| } |
| |
| return getHwComposer().setDisplayContentSamplingEnabled(*display->getId(), enable, |
| componentMask, maxFrames); |
| } |
| |
| status_t SurfaceFlinger::getDisplayedContentSample(const sp<IBinder>& displayToken, |
| uint64_t maxFrames, uint64_t timestamp, |
| DisplayedFrameStats* outStats) const { |
| const auto display = getDisplayDevice(displayToken); |
| if (!display || !display->getId()) { |
| ALOGE("getDisplayContentSample: Bad display token: %p", displayToken.get()); |
| return BAD_VALUE; |
| } |
| |
| return getHwComposer().getDisplayedContentSample(*display->getId(), maxFrames, timestamp, |
| outStats); |
| } |
| |
| status_t SurfaceFlinger::getProtectedContentSupport(bool* outSupported) const { |
| if (!outSupported) { |
| return BAD_VALUE; |
| } |
| *outSupported = getRenderEngine().supportsProtectedContent(); |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::isWideColorDisplay(const sp<IBinder>& displayToken, |
| bool* outIsWideColorDisplay) const { |
| if (!displayToken || !outIsWideColorDisplay) { |
| return BAD_VALUE; |
| } |
| Mutex::Autolock _l(mStateLock); |
| const auto display = getDisplayDeviceLocked(displayToken); |
| if (!display) { |
| return BAD_VALUE; |
| } |
| |
| // Use hasWideColorDisplay to override built-in display. |
| const auto displayId = display->getId(); |
| if (displayId && displayId == getInternalDisplayIdLocked()) { |
| *outIsWideColorDisplay = hasWideColorDisplay; |
| return NO_ERROR; |
| } |
| *outIsWideColorDisplay = display->hasWideColorGamut(); |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::enableVSyncInjections(bool enable) { |
| postMessageSync(new LambdaMessage([&] { |
| Mutex::Autolock _l(mStateLock); |
| |
| if (mInjectVSyncs == enable) { |
| return; |
| } |
| |
| auto resyncCallback = |
| mScheduler->makeResyncCallback(std::bind(&SurfaceFlinger::getVsyncPeriod, this)); |
| |
| // TODO(b/128863962): Part of the Injector should be refactored, so that it |
| // can be passed to Scheduler. |
| if (enable) { |
| ALOGV("VSync Injections enabled"); |
| if (mVSyncInjector.get() == nullptr) { |
| mVSyncInjector = std::make_unique<InjectVSyncSource>(); |
| mInjectorEventThread = std::make_unique< |
| impl::EventThread>(mVSyncInjector.get(), |
| impl::EventThread::InterceptVSyncsCallback(), |
| "injEventThread"); |
| } |
| mEventQueue->setEventThread(mInjectorEventThread.get(), std::move(resyncCallback)); |
| } else { |
| ALOGV("VSync Injections disabled"); |
| mEventQueue->setEventThread(mScheduler->getEventThread(mSfConnectionHandle), |
| std::move(resyncCallback)); |
| } |
| |
| mInjectVSyncs = enable; |
| })); |
| |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::injectVSync(nsecs_t when) { |
| Mutex::Autolock _l(mStateLock); |
| |
| if (!mInjectVSyncs) { |
| ALOGE("VSync Injections not enabled"); |
| return BAD_VALUE; |
| } |
| if (mInjectVSyncs && mInjectorEventThread.get() != nullptr) { |
| ALOGV("Injecting VSync inside SurfaceFlinger"); |
| mVSyncInjector->onInjectSyncEvent(when); |
| } |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const |
| NO_THREAD_SAFETY_ANALYSIS { |
| // Try to acquire a lock for 1s, fail gracefully |
| const status_t err = mStateLock.timedLock(s2ns(1)); |
| const bool locked = (err == NO_ERROR); |
| if (!locked) { |
| ALOGE("LayerDebugInfo: SurfaceFlinger unresponsive (%s [%d]) - exit", strerror(-err), err); |
| return TIMED_OUT; |
| } |
| |
| outLayers->clear(); |
| mCurrentState.traverseInZOrder([&](Layer* layer) { |
| outLayers->push_back(layer->getLayerDebugInfo()); |
| }); |
| |
| mStateLock.unlock(); |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::getCompositionPreference( |
| Dataspace* outDataspace, ui::PixelFormat* outPixelFormat, |
| Dataspace* outWideColorGamutDataspace, |
| ui::PixelFormat* outWideColorGamutPixelFormat) const { |
| *outDataspace = mDefaultCompositionDataspace; |
| *outPixelFormat = defaultCompositionPixelFormat; |
| *outWideColorGamutDataspace = mWideColorGamutCompositionDataspace; |
| *outWideColorGamutPixelFormat = wideColorGamutCompositionPixelFormat; |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea, |
| const sp<IBinder>& stopLayerHandle, |
| const sp<IRegionSamplingListener>& listener) { |
| if (!listener || samplingArea == Rect::INVALID_RECT) { |
| return BAD_VALUE; |
| } |
| mRegionSamplingThread->addListener(samplingArea, stopLayerHandle, listener); |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) { |
| if (!listener) { |
| return BAD_VALUE; |
| } |
| mRegionSamplingThread->removeListener(listener); |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::getDisplayBrightnessSupport(const sp<IBinder>& displayToken, |
| bool* outSupport) const { |
| if (!displayToken || !outSupport) { |
| return BAD_VALUE; |
| } |
| const auto displayId = getPhysicalDisplayIdLocked(displayToken); |
| if (!displayId) { |
| return NAME_NOT_FOUND; |
| } |
| *outSupport = |
| getHwComposer().hasDisplayCapability(displayId, HWC2::DisplayCapability::Brightness); |
| return NO_ERROR; |
| } |
| |
| status_t SurfaceFlinger::setDisplayBrightness(const sp<IBinder>& displayToken, |
| float brightness) const { |
| if (!displayToken) { |
| return BAD_VALUE; |
| } |
| const auto displayId = getPhysicalDisplayIdLocked(displayToken); |
| if (!displayId) { |
| return NAME_NOT_FOUND; |
| } |
| return getHwComposer().setDisplayBrightness(*displayId, brightness); |
| } |
| |
| status_t SurfaceFlinger::notifyPowerHint(int32_t hintId) { |
| PowerHint powerHint = static_cast<PowerHint>(hintId); |
| |
| if (powerHint == PowerHint::INTERACTION) { |
| mScheduler->notifyTouchEvent(); |
| } |
| |
| return NO_ERROR; |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection( |
| ISurfaceComposer::VsyncSource vsyncSource, ISurfaceComposer::ConfigChanged configChanged) { |
| auto resyncCallback = mScheduler->makeResyncCallback([this] { |
| Mutex::Autolock lock(mStateLock); |
| return getVsyncPeriod(); |
| }); |
| |
| const auto& handle = |
| vsyncSource == eVsyncSourceSurfaceFlinger ? mSfConnectionHandle : mAppConnectionHandle; |
| |
| return mScheduler->createDisplayEventConnection(handle, std::move(resyncCallback), |
| configChanged); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| void SurfaceFlinger::waitForEvent() { |
| mEventQueue->waitMessage(); |
| } |
| |
| void SurfaceFlinger::signalTransaction() { |
| mScheduler->resetIdleTimer(); |
| mEventQueue->invalidate(); |
| } |
| |
| void SurfaceFlinger::signalLayerUpdate() { |
| mScheduler->resetIdleTimer(); |
| mEventQueue->invalidate(); |
| } |
| |
| void SurfaceFlinger::signalRefresh() { |
| mRefreshPending = true; |
| mEventQueue->refresh(); |
| } |
| |
| status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg, |
| nsecs_t reltime, uint32_t /* flags */) { |
| return mEventQueue->postMessage(msg, reltime); |
| } |
| |
| status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg, |
| nsecs_t reltime, uint32_t /* flags */) { |
| status_t res = mEventQueue->postMessage(msg, reltime); |
| if (res == NO_ERROR) { |
| msg->wait(); |
| } |
| return res; |
| } |
| |
| void SurfaceFlinger::run() { |
| do { |
| waitForEvent(); |
| } while (true); |
| } |
| |
| nsecs_t SurfaceFlinger::getVsyncPeriod() const { |
| const auto displayId = getInternalDisplayIdLocked(); |
| if (!displayId || !getHwComposer().isConnected(*displayId)) { |
| return 0; |
| } |
| |
| const auto config = getHwComposer().getActiveConfig(*displayId); |
| return config ? config->getVsyncPeriod() : 0; |
| } |
| |
| void SurfaceFlinger::onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId, |
| int64_t timestamp) { |
| ATRACE_NAME("SF onVsync"); |
| |
| Mutex::Autolock lock(mStateLock); |
| // Ignore any vsyncs from a previous hardware composer. |
| if (sequenceId != getBE().mComposerSequenceId) { |
| return; |
| } |
| |
| if (!getHwComposer().onVsync(hwcDisplayId, timestamp)) { |
| return; |
| } |
| |
| if (hwcDisplayId != getHwComposer().getInternalHwcDisplayId()) { |
| // For now, we don't do anything with external display vsyncs. |
| return; |
| } |
| |
| bool periodFlushed = false; |
| mScheduler->addResyncSample(timestamp, &periodFlushed); |
| if (periodFlushed) { |
| mVsyncModulator.onRefreshRateChangeCompleted(); |
| } |
| } |
| |
| void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) { |
| std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock); |
| *compositorTiming = getBE().mCompositorTiming; |
| } |
| |
| bool SurfaceFlinger::isDisplayConfigAllowed(int32_t configId) { |
| return mAllowedDisplayConfigs.empty() || mAllowedDisplayConfigs.count(configId); |
| } |
| |
| void SurfaceFlinger::setRefreshRateTo(RefreshRateType refreshRate, Scheduler::ConfigEvent event) { |
| const auto display = getDefaultDisplayDeviceLocked(); |
| if (!display || mBootStage != BootStage::FINISHED) { |
| return; |
| } |
| ATRACE_CALL(); |
| |
| // Don't do any updating if the current fps is the same as the new one. |
| const auto& refreshRateConfig = mRefreshRateConfigs.getRefreshRate(refreshRate); |
| if (!refreshRateConfig) { |
| ALOGV("Skipping refresh rate change request for unsupported rate."); |
| return; |
| } |
| |
| const int desiredConfigId = refreshRateConfig->configId; |
| |
| if (!isDisplayConfigAllowed(desiredConfigId)) { |
| ALOGV("Skipping config %d as it is not part of allowed configs", desiredConfigId); |
| return; |
| } |
| |
| setDesiredActiveConfig({refreshRate, desiredConfigId, event}); |
| } |
| |
| void SurfaceFlinger::onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId, |
| HWC2::Connection connection) { |
| ALOGV("%s(%d, %" PRIu64 ", %s)", __FUNCTION__, sequenceId, hwcDisplayId, |
| connection == HWC2::Connection::Connected ? "connected" : "disconnected"); |
| |
| // Ignore events that do not have the right sequenceId. |
| if (sequenceId != getBE().mComposerSequenceId) { |
| return; |
| } |
| |
| // Only lock if we're not on the main thread. This function is normally |
| // called on a hwbinder thread, but for the primary display it's called on |
| // the main thread with the state lock already held, so don't attempt to |
| // acquire it here. |
| ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId); |
| |
| mPendingHotplugEvents.emplace_back(HotplugEvent{hwcDisplayId, connection}); |
| |
| if (std::this_thread::get_id() == mMainThreadId) { |
| // Process all pending hot plug events immediately if we are on the main thread. |
| processDisplayHotplugEventsLocked(); |
| } |
| |
| setTransactionFlags(eDisplayTransactionNeeded); |
| } |
| |
| void SurfaceFlinger::onRefreshReceived(int sequenceId, hwc2_display_t /*hwcDisplayId*/) { |
| Mutex::Autolock lock(mStateLock); |
| if (sequenceId != getBE().mComposerSequenceId) { |
| return; |
| } |
| repaintEverythingForHWC(); |
| } |
| |
| void SurfaceFlinger::setPrimaryVsyncEnabled(bool enabled) { |
| ATRACE_CALL(); |
| |
| // Enable / Disable HWVsync from the main thread to avoid race conditions with |
| // display power state. |
| postMessageAsync(new LambdaMessage( |
| [=]() NO_THREAD_SAFETY_ANALYSIS { setPrimaryVsyncEnabledInternal(enabled); })); |
| } |
| |
| void SurfaceFlinger::setPrimaryVsyncEnabledInternal(bool enabled) { |
| ATRACE_CALL(); |
| |
| mHWCVsyncPendingState = enabled ? HWC2::Vsync::Enable : HWC2::Vsync::Disable; |
| |
| if (const auto displayId = getInternalDisplayIdLocked()) { |
| sp<DisplayDevice> display = getDefaultDisplayDeviceLocked(); |
| if (display && display->isPoweredOn()) { |
| setVsyncEnabledInHWC(*displayId, mHWCVsyncPendingState); |
| } |
| } |
| } |
| |
| // Note: it is assumed the caller holds |mStateLock| when this is called |
| void SurfaceFlinger::resetDisplayState() { |
| mScheduler->disableHardwareVsync(true); |
| // Clear the drawing state so that the logic inside of |
| // handleTransactionLocked will fire. It will determine the delta between |
| // mCurrentState and mDrawingState and re-apply all changes when we make the |
| // transition. |
| mDrawingState.displays.clear(); |
| mDisplays.clear(); |
| } |
| |
| void SurfaceFlinger::updateVrFlinger() { |
| ATRACE_CALL(); |
| if (!mVrFlinger) |
| return; |
| bool vrFlingerRequestsDisplay = mVrFlingerRequestsDisplay; |
| if (vrFlingerRequestsDisplay == getHwComposer().isUsingVrComposer()) { |
| return; |
| } |
| |
| if (vrFlingerRequestsDisplay && !getHwComposer().getComposer()->isRemote()) { |
| ALOGE("Vr flinger is only supported for remote hardware composer" |
| " service connections. Ignoring request to transition to vr" |
| " flinger."); |
| mVrFlingerRequestsDisplay = false; |
| return; |
| } |
| |
| Mutex::Autolock _l(mStateLock); |
| |
| sp<DisplayDevice> display = getDefaultDisplayDeviceLocked(); |
| LOG_ALWAYS_FATAL_IF(!display); |
| |
| const int currentDisplayPowerMode = display->getPowerMode(); |
| |
| // Clear out all the output layers from the composition engine for all |
| // displays before destroying the hardware composer interface. This ensures |
| // any HWC layers are destroyed through that interface before it becomes |
| // invalid. |
| for (const auto& [token, displayDevice] : mDisplays) { |
| displayDevice->getCompositionDisplay()->setOutputLayersOrderedByZ( |
| compositionengine::Output::OutputLayers()); |
| } |
| |
| // This DisplayDevice will no longer be relevant once resetDisplayState() is |
| // called below. Clear the reference now so we don't accidentally use it |
| // later. |
| display.clear(); |
| |
| if (!vrFlingerRequestsDisplay) { |
| mVrFlinger->SeizeDisplayOwnership(); |
| } |
| |
| resetDisplayState(); |
| // Delete the current instance before creating the new one |
| mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>()); |
| mCompositionEngine->setHwComposer(getFactory().createHWComposer( |
| vrFlingerRequestsDisplay ? "vr" : getBE().mHwcServiceName)); |
| getHwComposer().registerCallback(this, ++getBE().mComposerSequenceId); |
| |
| LOG_ALWAYS_FATAL_IF(!getHwComposer().getComposer()->isRemote(), |
| "Switched to non-remote hardware composer"); |
| |
| if (vrFlingerRequestsDisplay) { |
| mVrFlinger->GrantDisplayOwnership(); |
| } |
| |
| mVisibleRegionsDirty = true; |
| invalidateHwcGeometry(); |
| |
| // Re-enable default display. |
| display = getDefaultDisplayDeviceLocked(); |
| LOG_ALWAYS_FATAL_IF(!display); |
| setPowerModeInternal(display, currentDisplayPowerMode); |
| |
| // Reset the timing values to account for the period of the swapped in HWC |
| const nsecs_t vsyncPeriod = getVsyncPeriod(); |
| mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod); |
| |
| // The present fences returned from vr_hwc are not an accurate |
| // representation of vsync times. |
| mScheduler->setIgnorePresentFences(getHwComposer().isUsingVrComposer() || !hasSyncFramework); |
| |
| // Use phase of 0 since phase is not known. |
| // Use latency of 0, which will snap to the ideal latency. |
| DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod}; |
| setCompositorTimingSnapped(stats, 0); |
| |
| mScheduler->resyncToHardwareVsync(false, vsyncPeriod); |
| |
| mRepaintEverything = true; |
| setTransactionFlags(eDisplayTransactionNeeded); |
| } |
| |
| bool SurfaceFlinger::previousFrameMissed() NO_THREAD_SAFETY_ANALYSIS { |
| // We are storing the last 2 present fences. If sf's phase offset is to be |
| // woken up before the actual vsync but targeting the next vsync, we need to check |
| // fence N-2 |
| const sp<Fence>& fence = |
| mVsyncModulator.getOffsets().sf < mPhaseOffsets->getOffsetThresholdForNextVsync() |
| ? mPreviousPresentFences[0] |
| : mPreviousPresentFences[1]; |
| |
| return fence != Fence::NO_FENCE && (fence->getStatus() == Fence::Status::Unsignaled); |
| } |
| |
| void SurfaceFlinger::populateExpectedPresentTime() NO_THREAD_SAFETY_ANALYSIS { |
| DisplayStatInfo stats; |
| mScheduler->getDisplayStatInfo(&stats); |
| const nsecs_t presentTime = mScheduler->getDispSyncExpectedPresentTime(); |
| // Inflate the expected present time if we're targetting the next vsync. |
| mExpectedPresentTime = |
| mVsyncModulator.getOffsets().sf < mPhaseOffsets->getOffsetThresholdForNextVsync() |
| ? presentTime |
| : presentTime + stats.vsyncPeriod; |
| } |
| |
| void SurfaceFlinger::onMessageReceived(int32_t what) NO_THREAD_SAFETY_ANALYSIS { |
| ATRACE_CALL(); |
| switch (what) { |
| case MessageQueue::INVALIDATE: { |
| // calculate the expected present time once and use the cached |
| // value throughout this frame to make sure all layers are |
| // seeing this same value. |
| populateExpectedPresentTime(); |
| |
| bool frameMissed = previousFrameMissed(); |
| bool hwcFrameMissed = mHadDeviceComposition && frameMissed; |
| bool gpuFrameMissed = mHadClientComposition && frameMissed; |
| ATRACE_INT("FrameMissed", static_cast<int>(frameMissed)); |
| ATRACE_INT("HwcFrameMissed", static_cast<int>(hwcFrameMissed)); |
| ATRACE_INT("GpuFrameMissed", static_cast<int>(gpuFrameMissed)); |
| if (frameMissed) { |
| mFrameMissedCount++; |
| mTimeStats->incrementMissedFrames(); |
| } |
| |
| if (hwcFrameMissed) { |
| mHwcFrameMissedCount++; |
| } |
| |
| if (gpuFrameMissed) { |
| mGpuFrameMissedCount++; |
| } |
| |
| if (mUseSmart90ForVideo) { |
| // This call is made each time SF wakes up and creates a new frame. It is part |
| // of video detection feature. |
| mScheduler->updateFpsBasedOnContent(); |
| } |
| |
| if (performSetActiveConfig()) { |
| break; |
| } |
| |
| if (frameMissed && mPropagateBackpressure) { |
| if ((hwcFrameMissed && !gpuFrameMissed) || |
| mPropagateBackpressureClientComposition) { |
| signalLayerUpdate(); |
| break; |
| } |
| } |
| |
| // Now that we're going to make it to the handleMessageTransaction() |
| // call below it's safe to call updateVrFlinger(), which will |
| // potentially trigger a display handoff. |
| updateVrFlinger(); |
| |
| bool refreshNeeded = handleMessageTransaction(); |
| refreshNeeded |= handleMessageInvalidate(); |
| |
| updateCursorAsync(); |
| updateInputFlinger(); |
| |
| refreshNeeded |= mRepaintEverything; |
| if (refreshNeeded && CC_LIKELY(mBootStage != BootStage::BOOTLOADER)) { |
| // Signal a refresh if a transaction modified the window state, |
| // a new buffer was latched, or if HWC has requested a full |
| // repaint |
| signalRefresh(); |
| } |
| break; |
| } |
| case MessageQueue::REFRESH: { |
| handleMessageRefresh(); |
| break; |
| } |
| } |
| } |
| |
| bool SurfaceFlinger::handleMessageTransaction() { |
| ATRACE_CALL(); |
| uint32_t transactionFlags = peekTransactionFlags(); |
| |
| bool flushedATransaction = flushTransactionQueues(); |
| |
| bool runHandleTransaction = transactionFlags && |
| ((transactionFlags != eTransactionFlushNeeded) || flushedATransaction); |
| |
| if (runHandleTransaction) { |
| handleTransaction(eTransactionMask); |
| } else { |
| getTransactionFlags(eTransactionFlushNeeded); |
| } |
| |
| if (transactionFlushNeeded()) { |
| setTransactionFlags(eTransactionFlushNeeded); |
| } |
| |
| return runHandleTransaction; |
| } |
| |
| void SurfaceFlinger::handleMessageRefresh() { |
| ATRACE_CALL(); |
| |
| mRefreshPending = false; |
| |
| const bool repaintEverything = mRepaintEverything.exchange(false); |
| preComposition(); |
| rebuildLayerStacks(); |
| calculateWorkingSet(); |
| for (const auto& [token, display] : mDisplays) { |
| beginFrame(display); |
| prepareFrame(display); |
| doDebugFlashRegions(display, repaintEverything); |
| doComposition(display, repaintEverything); |
| } |
| |
| logLayerStats(); |
| |
| postFrame(); |
| postComposition(); |
| |
| mHadClientComposition = false; |
| mHadDeviceComposition = false; |
| for (const auto& [token, displayDevice] : mDisplays) { |
| auto display = displayDevice->getCompositionDisplay(); |
| const auto displayId = display->getId(); |
| mHadClientComposition = |
| mHadClientComposition || getHwComposer().hasClientComposition(displayId); |
| mHadDeviceComposition = |
| mHadDeviceComposition || getHwComposer().hasDeviceComposition(displayId); |
| } |
| |
| mVsyncModulator.onRefreshed(mHadClientComposition); |
| |
| mLayersWithQueuedFrames.clear(); |
| } |
| |
| |
| bool SurfaceFlinger::handleMessageInvalidate() { |
| ATRACE_CALL(); |
| bool refreshNeeded = handlePageFlip(); |
| |
| if (mVisibleRegionsDirty) { |
| computeLayerBounds(); |
| if (mTracingEnabled) { |
| mTracing.notify("visibleRegionsDirty"); |
| } |
| } |
| |
| for (auto& layer : mLayersPendingRefresh) { |
| Region visibleReg; |
| visibleReg.set(layer->getScreenBounds()); |
| invalidateLayerStack(layer, visibleReg); |
| } |
| mLayersPendingRefresh.clear(); |
| return refreshNeeded; |
| } |
| |
| void SurfaceFlinger::calculateWorkingSet() { |
| ATRACE_CALL(); |
| ALOGV(__FUNCTION__); |
| |
| // build the h/w work list |
| if (CC_UNLIKELY(mGeometryInvalid)) { |
| mGeometryInvalid = false; |
| for (const auto& [token, displayDevice] : mDisplays) { |
| auto display = displayDevice->getCompositionDisplay(); |
| |
| uint32_t zOrder = 0; |
| |
| for (auto& layer : display->getOutputLayersOrderedByZ()) { |
| auto& compositionState = layer->editState(); |
| compositionState.forceClientComposition = false; |
| if (!compositionState.hwc || mDebugDisableHWC || mDebugRegion) { |
| compositionState.forceClientComposition = true; |
| } |
| |
| // The output Z order is set here based on a simple counter. |
| compositionState.z = zOrder++; |
| |
| // Update the display independent composition state. This goes |
| // to the general composition layer state structure. |
| // TODO: Do this once per compositionengine::CompositionLayer. |
| layer->getLayerFE().latchCompositionState(layer->getLayer().editState().frontEnd, |
| true); |
| |
| // Recalculate the geometry state of the output layer. |
| layer->updateCompositionState(true); |
| |
| // Write the updated geometry state to the HWC |
| layer->writeStateToHWC(true); |
| } |
| } |
| } |
| |
| // Set the per-frame data |
| for (const auto& [token, displayDevice] : mDisplays) { |
| auto display = displayDevice->getCompositionDisplay(); |
| const auto displayId = display->getId(); |
| if (!displayId) { |
| continue; |
| } |
| auto* profile = display->getDisplayColorProfile(); |
| |
| if (mDrawingState.colorMatrixChanged) { |
| display->setColorTransform(mDrawingState.colorMatrix); |
| } |
| Dataspace targetDataspace = Dataspace::UNKNOWN; |
| if (useColorManagement) { |
| ColorMode colorMode; |
| RenderIntent renderIntent; |
| pickColorMode(displayDevice, &colorMode, &targetDataspace, &renderIntent); |
| display->setColorMode(colorMode, targetDataspace, renderIntent); |
| |
| if (isHdrColorMode(colorMode)) { |
| targetDataspace = Dataspace::UNKNOWN; |
| } else if (mColorSpaceAgnosticDataspace != Dataspace::UNKNOWN) { |
| targetDataspace = mColorSpaceAgnosticDataspace; |
| } |
| } |
| |
| for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) { |
| if (layer->isHdrY410()) { |
| layer->forceClientComposition(displayDevice); |
| } else if ((layer->getDataSpace() == Dataspace::BT2020_PQ || |
| layer->getDataSpace() == Dataspace::BT2020_ITU_PQ) && |
| !profile->hasHDR10Support()) { |
| layer->forceClientComposition(displayDevice); |
| } else if ((layer->getDataSpace() == Dataspace::BT2020_HLG || |
| layer->getDataSpace() == Dataspace::BT2020_ITU_HLG) && |
| !profile->hasHLGSupport()) { |
| layer->forceClientComposition(displayDevice); |
| } |
| |
| if (layer->getRoundedCornerState().radius > 0.0f) { |
| layer->forceClientComposition(displayDevice); |
| } |
| |
| if (layer->getForceClientComposition(displayDevice)) { |
| ALOGV("[%s] Requesting Client composition", layer->getName().string()); |
| layer->setCompositionType(displayDevice, |
| Hwc2::IComposerClient::Composition::CLIENT); |
| continue; |
| } |
| |
| const auto& displayState = display->getState(); |
| layer->setPerFrameData(displayDevice, displayState.transform, displayState.viewport, |
| displayDevice->getSupportedPerFrameMetadata(), targetDataspace); |
| } |
| } |
| |
| mDrawingState.colorMatrixChanged = false; |
| |
| for (const auto& [token, displayDevice] : mDisplays) { |
| auto display = displayDevice->getCompositionDisplay(); |
| for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) { |
| auto& layerState = layer->getCompositionLayer()->editState().frontEnd; |
| layerState.compositionType = static_cast<Hwc2::IComposerClient::Composition>( |
| layer->getCompositionType(displayDevice)); |
| } |
| } |
| } |
| |
| void SurfaceFlinger::doDebugFlashRegions(const sp<DisplayDevice>& displayDevice, |
| bool repaintEverything) { |
| auto display = displayDevice->getCompositionDisplay(); |
| const auto& displayState = display->getState(); |
| |
| // is debugging enabled |
| if (CC_LIKELY(!mDebugRegion)) |
| return; |
| |
| if (displayState.isEnabled) { |
| // transform the dirty region into this screen's coordinate space |
| const Region dirtyRegion = display->getDirtyRegion(repaintEverything); |
| if (!dirtyRegion.isEmpty()) { |
| base::unique_fd readyFence; |
| // redraw the whole screen |
| doComposeSurfaces(displayDevice, dirtyRegion, &readyFence); |
| |
| display->getRenderSurface()->queueBuffer(std::move(readyFence)); |
| } |
| } |
| |
| postFramebuffer(displayDevice); |
| |
| if (mDebugRegion > 1) { |
| usleep(mDebugRegion * 1000); |
| } |
| |
| prepareFrame(displayDevice); |
| } |
| |
| void SurfaceFlinger::logLayerStats() { |
| ATRACE_CALL(); |
| if (CC_UNLIKELY(mLayerStats.isEnabled())) { |
| for (const auto& [token, display] : mDisplays) { |
| if (display->isPrimary()) { |
| mLayerStats.logLayerStats(dumpVisibleLayersProtoInfo(display)); |
| return; |
| } |
| } |
| |
| ALOGE("logLayerStats: no primary display"); |
| } |
| } |
| |
| void SurfaceFlinger::preComposition() |
| { |
| ATRACE_CALL(); |
| ALOGV("preComposition"); |
| |
| mRefreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC); |
| |
| bool needExtraInvalidate = false; |
| mDrawingState.traverseInZOrder([&](Layer* layer) { |
| if (layer->onPreComposition(mRefreshStartTime)) { |
| needExtraInvalidate = true; |
| } |
| }); |
| |
| if (needExtraInvalidate) { |
| signalLayerUpdate(); |
| } |
| } |
| |
| void SurfaceFlinger::updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime, |
| std::shared_ptr<FenceTime>& presentFenceTime) { |
| // Update queue of past composite+present times and determine the |
| // most recently known composite to present latency. |
| getBE().mCompositePresentTimes.push({compositeTime, presentFenceTime}); |
| nsecs_t compositeToPresentLatency = -1; |
| while (!getBE().mCompositePresentTimes.empty()) { |
| SurfaceFlingerBE::CompositePresentTime& cpt = getBE().mCompositePresentTimes.front(); |
| // Cached values should have been updated before calling this method, |
| // which helps avoid duplicate syscalls. |
| nsecs_t displayTime = cpt.display->getCachedSignalTime(); |
| if (displayTime == Fence::SIGNAL_TIME_PENDING) { |
| break; |
| } |
| compositeToPresentLatency = displayTime - cpt.composite; |
| getBE().mCompositePresentTimes.pop(); |
| } |
| |
| // Don't let mCompositePresentTimes grow unbounded, just in case. |
| while (getBE().mCompositePresentTimes.size() > 16) { |
| getBE().mCompositePresentTimes.pop(); |
| } |
| |
| setCompositorTimingSnapped(stats, compositeToPresentLatency); |
| } |
| |
| void SurfaceFlinger::setCompositorTimingSnapped(const DisplayStatInfo& stats, |
| nsecs_t compositeToPresentLatency) { |
| // Integer division and modulo round toward 0 not -inf, so we need to |
| // treat negative and positive offsets differently. |
| nsecs_t idealLatency = (mPhaseOffsets->getCurrentSfOffset() > 0) |
| ? (stats.vsyncPeriod - (mPhaseOffsets->getCurrentSfOffset() % stats.vsyncPeriod)) |
| : ((-mPhaseOffsets->getCurrentSfOffset()) % stats.vsyncPeriod); |
| |
| // Just in case mPhaseOffsets->getCurrentSfOffset() == -vsyncInterval. |
| if (idealLatency <= 0) { |
| idealLatency = stats.vsyncPeriod; |
| } |
| |
| // Snap the latency to a value that removes scheduling jitter from the |
| // composition and present times, which often have >1ms of jitter. |
| // Reducing jitter is important if an app attempts to extrapolate |
| // something (such as user input) to an accurate diasplay time. |
| // Snapping also allows an app to precisely calculate mPhaseOffsets->getCurrentSfOffset() |
| // with (presentLatency % interval). |
| nsecs_t bias = stats.vsyncPeriod / 2; |
| int64_t extraVsyncs = (compositeToPresentLatency - idealLatency + bias) / stats.vsyncPeriod; |
| nsecs_t snappedCompositeToPresentLatency = |
| (extraVsyncs > 0) ? idealLatency + (extraVsyncs * stats.vsyncPeriod) : idealLatency; |
| |
| std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock); |
| getBE().mCompositorTiming.deadline = stats.vsyncTime - idealLatency; |
| getBE().mCompositorTiming.interval = stats.vsyncPeriod; |
| getBE().mCompositorTiming.presentLatency = snappedCompositeToPresentLatency; |
| } |
| |
| void SurfaceFlinger::postComposition() |
| { |
| ATRACE_CALL(); |
| ALOGV("postComposition"); |
| |
| // Release any buffers which were replaced this frame |
| nsecs_t dequeueReadyTime = systemTime(); |
| for (auto& layer : mLayersWithQueuedFrames) { |
| layer->releasePendingBuffer(dequeueReadyTime); |
| } |
| |
| // |mStateLock| not needed as we are on the main thread |
| const auto displayDevice = getDefaultDisplayDeviceLocked(); |
| |
| getBE().mGlCompositionDoneTimeline.updateSignalTimes(); |
| std::shared_ptr<FenceTime> glCompositionDoneFenceTime; |
| if (displayDevice && getHwComposer().hasClientComposition(displayDevice->getId())) { |
| glCompositionDoneFenceTime = |
| std::make_shared<FenceTime>(displayDevice->getCompositionDisplay() |
| ->getRenderSurface() |
| ->getClientTargetAcquireFence()); |
| getBE().mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime); |
| } else { |
| glCompositionDoneFenceTime = FenceTime::NO_FENCE; |
| } |
| |
| getBE().mDisplayTimeline.updateSignalTimes(); |
| mPreviousPresentFences[1] = mPreviousPresentFences[0]; |
| mPreviousPresentFences[0] = displayDevice |
| ? getHwComposer().getPresentFence(*displayDevice->getId()) |
| : Fence::NO_FENCE; |
| auto presentFenceTime = std::make_shared<FenceTime>(mPreviousPresentFences[0]); |
| getBE().mDisplayTimeline.push(presentFenceTime); |
| |
| DisplayStatInfo stats; |
| mScheduler->getDisplayStatInfo(&stats); |
| |
| // We use the mRefreshStartTime which might be sampled a little later than |
| // when we started doing work for this frame, but that should be okay |
| // since updateCompositorTiming has snapping logic. |
| updateCompositorTiming(stats, mRefreshStartTime, presentFenceTime); |
| CompositorTiming compositorTiming; |
| { |
| std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock); |
| compositorTiming = getBE().mCompositorTiming; |
| } |
| |
| mDrawingState.traverseInZOrder([&](Layer* layer) { |
| bool frameLatched = |
| layer->onPostComposition(displayDevice->getId(), glCompositionDoneFenceTime, |
| presentFenceTime, compositorTiming); |
| if (frameLatched) { |
| recordBufferingStats(layer->getName().string(), |
| layer->getOccupancyHistory(false)); |
| } |
| }); |
| |
| if (presentFenceTime->isValid()) { |
| mScheduler->addPresentFence(presentFenceTime); |
| } |
| |
| if (!hasSyncFramework) { |
| if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) && |
| displayDevice->isPoweredOn()) { |
| mScheduler->enableHardwareVsync(); |
| } |
| } |
| |
| if (mAnimCompositionPending) { |
| mAnimCompositionPending = false; |
| |
| if (presentFenceTime->isValid()) { |
| mAnimFrameTracker.setActualPresentFence( |
| std::move(presentFenceTime)); |
| } else if (displayDevice && getHwComposer().isConnected(*displayDevice->getId())) { |
| // The HWC doesn't support present fences, so use the refresh |
| // timestamp instead. |
| const nsecs_t presentTime = |
| getHwComposer().getRefreshTimestamp(*displayDevice->getId()); |
| mAnimFrameTracker.setActualPresentTime(presentTime); |
| } |
| mAnimFrameTracker.advanceFrame(); |
| } |
| |
| mTimeStats->incrementTotalFrames(); |
| if (mHadClientComposition) { |
| mTimeStats->incrementClientCompositionFrames(); |
| } |
| |
| mTimeStats->setPresentFenceGlobal(presentFenceTime); |
| |
| if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) && |
| !displayDevice->isPoweredOn()) { |
| return; |
| } |
| |
| nsecs_t currentTime = systemTime(); |
| if (mHasPoweredOff) { |
| mHasPoweredOff = false; |
| } else { |
| nsecs_t elapsedTime = currentTime - getBE().mLastSwapTime; |
| size_t numPeriods = static_cast<size_t>(elapsedTime / stats.vsyncPeriod); |
| if (numPeriods < SurfaceFlingerBE::NUM_BUCKETS - 1) { |
| getBE().mFrameBuckets[numPeriods] += elapsedTime; |
| } else { |
| getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] += elapsedTime; |
| } |
| getBE().mTotalTime += elapsedTime; |
| } |
| getBE().mLastSwapTime = currentTime; |
| |
| { |
| std::lock_guard lock(mTexturePoolMutex); |
| if (mTexturePool.size() < mTexturePoolSize) { |
| const size_t refillCount = mTexturePoolSize - mTexturePool.size(); |
| const size_t offset = mTexturePool.size(); |
| mTexturePool.resize(mTexturePoolSize); |
| getRenderEngine().genTextures(refillCount, mTexturePool.data() + offset); |
| ATRACE_INT("TexturePoolSize", mTexturePool.size()); |
| } else if (mTexturePool.size() > mTexturePoolSize) { |
| const size_t deleteCount = mTexturePool.size() - mTexturePoolSize; |
| const size_t offset = mTexturePoolSize; |
| getRenderEngine().deleteTextures(deleteCount, mTexturePool.data() + offset); |
| mTexturePool.resize(mTexturePoolSize); |
| ATRACE_INT("TexturePoolSize", mTexturePool.size()); |
| } |
| } |
| |
| mTransactionCompletedThread.addPresentFence(mPreviousPresentFences[0]); |
| |
| // Lock the mStateLock in case SurfaceFlinger is in the middle of applying a transaction. |
| // If we do not lock here, a callback could be sent without all of its SurfaceControls and |
| // metrics. |
| { |
| Mutex::Autolock _l(mStateLock); |
| mTransactionCompletedThread.sendCallbacks(); |
| } |
| |
| if (mLumaSampling && mRegionSamplingThread) { |
| mRegionSamplingThread->notifyNewContent(); |
| } |
| |
| // Even though ATRACE_INT64 already checks if tracing is enabled, it doesn't prevent the |
| // side-effect of getTotalSize(), so we check that again here |
| if (ATRACE_ENABLED()) { |
| ATRACE_INT64("Total Buffer Size", GraphicBufferAllocator::get().getTotalSize()); |
| } |
| } |
| |
| void SurfaceFlinger::computeLayerBounds() { |
| for (const auto& pair : mDisplays) { |
| const auto& displayDevice = pair.second; |
| const auto display = displayDevice->getCompositionDisplay(); |
| for (const auto& layer : mDrawingState.layersSortedByZ) { |
| // only consider the layers on the given layer stack |
| if (!display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) { |
| continue; |
| } |
| |
| layer->computeBounds(displayDevice->getViewport().toFloatRect(), ui::Transform()); |
| } |
| } |
| } |
| |
| void SurfaceFlinger::rebuildLayerStacks() { |
| ATRACE_CALL(); |
| ALOGV("rebuildLayerStacks"); |
| |
| // rebuild the visible layer list per screen |
| if (CC_UNLIKELY(mVisibleRegionsDirty)) { |
| ATRACE_NAME("rebuildLayerStacks VR Dirty"); |
| mVisibleRegionsDirty = false; |
| invalidateHwcGeometry(); |
| |
| for (const auto& pair : mDisplays) { |
| const auto& displayDevice = pair.second; |
| auto display = displayDevice->getCompositionDisplay(); |
| const auto& displayState = display->getState(); |
| Region opaqueRegion; |
| Region dirtyRegion; |
| compositionengine::Output::OutputLayers layersSortedByZ; |
| Vector<sp<Layer>> deprecated_layersSortedByZ; |
| Vector<sp<Layer>> layersNeedingFences; |
| const ui::Transform& tr = displayState.transform; |
| const Rect bounds = displayState.bounds; |
| if (displayState.isEnabled) { |
| computeVisibleRegions(displayDevice, dirtyRegion, opaqueRegion); |
| |
| mDrawingState.traverseInZOrder([&](Layer* layer) { |
| auto compositionLayer = layer->getCompositionLayer(); |
| if (compositionLayer == nullptr) { |
| return; |
| } |
| |
| const auto displayId = displayDevice->getId(); |
| sp<compositionengine::LayerFE> layerFE = compositionLayer->getLayerFE(); |
| LOG_ALWAYS_FATAL_IF(layerFE.get() == nullptr); |
| |
| bool needsOutputLayer = false; |
| |
| if (display->belongsInOutput(layer->getLayerStack(), |
| layer->getPrimaryDisplayOnly())) { |
| Region drawRegion(tr.transform( |
| layer->visibleNonTransparentRegion)); |
| drawRegion.andSelf(bounds); |
| if (!drawRegion.isEmpty()) { |
| needsOutputLayer = true; |
| } |
| } |
| |
| if (needsOutputLayer) { |
| layersSortedByZ.emplace_back( |
| display->getOrCreateOutputLayer(displayId, compositionLayer, |
| layerFE)); |
| deprecated_layersSortedByZ.add(layer); |
| |
| auto& outputLayerState = layersSortedByZ.back()->editState(); |
| outputLayerState.visibleRegion = |
| tr.transform(layer->visibleRegion.intersect(displayState.viewport)); |
| } else if (displayId) { |
| // For layers that are being removed from a HWC display, |
| // and that have queued frames, add them to a a list of |
| // released layers so we can properly set a fence. |
| bool hasExistingOutputLayer = |
| display->getOutputLayerForLayer(compositionLayer.get()) != nullptr; |
| bool hasQueuedFrames = std::find(mLayersWithQueuedFrames.cbegin(), |
| mLayersWithQueuedFrames.cend(), |
| layer) != mLayersWithQueuedFrames.cend(); |
| |
| if (hasExistingOutputLayer && hasQueuedFrames) { |
| layersNeedingFences.add(layer); |
| } |
| } |
| }); |
| } |
| |
| display->setOutputLayersOrderedByZ(std::move(layersSortedByZ)); |
| |
| displayDevice->setVisibleLayersSortedByZ(deprecated_layersSortedByZ); |
| displayDevice->setLayersNeedingFences(layersNeedingFences); |
| |
| Region undefinedRegion{bounds}; |
| undefinedRegion.subtractSelf(tr.transform(opaqueRegion)); |
| |
| display->editState().undefinedRegion = undefinedRegion; |
| display->editState().dirtyRegion.orSelf(dirtyRegion); |
| } |
| } |
| } |
| |
| // Returns a data space that fits all visible layers. The returned data space |
| // can only be one of |
| // - Dataspace::SRGB (use legacy dataspace and let HWC saturate when colors are enhanced) |
| // - Dataspace::DISPLAY_P3 |
| // - Dataspace::DISPLAY_BT2020 |
| // The returned HDR data space is one of |
| // - Dataspace::UNKNOWN |
| // - Dataspace::BT2020_HLG |
| // - Dataspace::BT2020_PQ |
| Dataspace SurfaceFlinger::getBestDataspace(const sp<DisplayDevice>& display, |
| Dataspace* outHdrDataSpace, |
| bool* outIsHdrClientComposition) const { |
| Dataspace bestDataSpace = Dataspace::V0_SRGB; |
| *outHdrDataSpace = Dataspace::UNKNOWN; |
| |
| for (const auto& layer : display->getVisibleLayersSortedByZ()) { |
| switch (layer->getDataSpace()) { |
| case Dataspace::V0_SCRGB: |
| case Dataspace::V0_SCRGB_LINEAR: |
| case Dataspace::BT2020: |
| case Dataspace::BT2020_ITU: |
| case Dataspace::BT2020_LINEAR: |
| case Dataspace::DISPLAY_BT2020: |
| bestDataSpace = Dataspace::DISPLAY_BT2020; |
| break; |
| case Dataspace::DISPLAY_P3: |
| bestDataSpace = Dataspace::DISPLAY_P3; |
| break; |
| case Dataspace::BT2020_PQ: |
| case Dataspace::BT2020_ITU_PQ: |
| bestDataSpace = Dataspace::DISPLAY_P3; |
| *outHdrDataSpace = Dataspace::BT2020_PQ; |
| *outIsHdrClientComposition = layer->getForceClientComposition(display); |
| break; |
| case Dataspace::BT2020_HLG: |
| case Dataspace::BT2020_ITU_HLG: |
| bestDataSpace = Dataspace::DISPLAY_P3; |
| // When there's mixed PQ content and HLG content, we set the HDR |
| // data space to be BT2020_PQ and convert HLG to PQ. |
| if (*outHdrDataSpace == Dataspace::UNKNOWN) { |
| *outHdrDataSpace = Dataspace::BT2020_HLG; |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| |
| return bestDataSpace; |
| } |
| |
| // Pick the ColorMode / Dataspace for the display device. |
| void SurfaceFlinger::pickColorMode(const sp<DisplayDevice>& display, ColorMode* outMode, |
| Dataspace* outDataSpace, RenderIntent* outRenderIntent) const { |
| if (mDisplayColorSetting == DisplayColorSetting::UNMANAGED) { |
| *outMode = ColorMode::NATIVE; |
| *outDataSpace = Dataspace::UNKNOWN; |
| *outRenderIntent = RenderIntent::COLORIMETRIC; |
| return; |
| } |
| |
| Dataspace hdrDataSpace; |
| bool isHdrClientComposition = false; |
| Dataspace bestDataSpace = getBestDataspace(display, &hdrDataSpace, &isHdrClientComposition); |
| |
| auto* profile = display->getCompositionDisplay()->getDisplayColorProfile(); |
| |
| switch (mForceColorMode) { |
| case ColorMode::SRGB: |
| bestDataSpace = Dataspace::V0_SRGB; |
| break; |
| case ColorMode::DISPLAY_P3: |
| bestDataSpace = Dataspace::DISPLAY_P3; |
| break; |
| default: |
| break; |
| } |
| |
| // respect hdrDataSpace only when there is no legacy HDR support |
| const bool isHdr = hdrDataSpace != Dataspace::UNKNOWN && |
| !profile->hasLegacyHdrSupport(hdrDataSpace) && !isHdrClientComposition; |
| if (isHdr) { |
| bestDataSpace = hdrDataSpace; |
| } |
| |
| RenderIntent intent; |
| switch (mDisplayColorSetting) { |
| case DisplayColorSetting::MANAGED: |
| case DisplayColorSetting::UNMANAGED: |
| intent = isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC; |
| break; |
| case DisplayColorSetting::ENHANCED: |
| intent = isHdr ? RenderIntent::TONE_MAP_ENHANCE : RenderIntent::ENHANCE; |
| break; |
| default: // vendor display color setting |
| intent = static_cast<RenderIntent>(mDisplayColorSetting); |
| break; |
| } |
| |
| profile->getBestColorMode(bestDataSpace, intent, outDataSpace, outMode, outRenderIntent); |
| } |
| |
| void SurfaceFlinger::beginFrame(const sp<DisplayDevice>& displayDevice) { |
| auto display = displayDevice->getCompositionDisplay(); |
| const auto& displayState = display->getState(); |
| |
| bool dirty = !display->getDirtyRegion(false).isEmpty(); |
| bool empty = displayDevice->getVisibleLayersSortedByZ().size() == 0; |
| bool wasEmpty = !displayState.lastCompositionHadVisibleLayers; |
| |
| // If nothing has changed (!dirty), don't recompose. |
| // If something changed, but we don't currently have any visible layers, |
| // and didn't when we last did a composition, then skip it this time. |
| // The second rule does two things: |
| // - When all layers are removed from a display, we'll emit one black |
| // frame, then nothing more until we get new layers. |
| // - When a display is created with a private layer stack, we won't |
| // emit any black frames until a layer is added to the layer stack. |
| bool mustRecompose = dirty && !(empty && wasEmpty); |
| |
| const char flagPrefix[] = {'-', '+'}; |
| static_cast<void>(flagPrefix); |
| ALOGV_IF(displayDevice->isVirtual(), "%s: %s composition for %s (%cdirty %cempty %cwasEmpty)", |
| __FUNCTION__, mustRecompose ? "doing" : "skipping", |
| displayDevice->getDebugName().c_str(), flagPrefix[dirty], flagPrefix[empty], |
| flagPrefix[wasEmpty]); |
| |
| display->getRenderSurface()->beginFrame(mustRecompose); |
| |
| if (mustRecompose) { |
| display->editState().lastCompositionHadVisibleLayers = !empty; |
| } |
| } |
| |
| void SurfaceFlinger::prepareFrame(const sp<DisplayDevice>& displayDevice) { |
| auto display = displayDevice->getCompositionDisplay(); |
| const auto& displayState = display->getState(); |
| |
| if (!displayState.isEnabled) { |
| return; |
| } |
| |
| status_t result = display->getRenderSurface()->prepareFrame(); |
| ALOGE_IF(result != NO_ERROR, "prepareFrame failed for %s: %d (%s)", |
| displayDevice->getDebugName().c_str(), result, strerror(-result)); |
| } |
| |
| void SurfaceFlinger::doComposition(const sp<DisplayDevice>& displayDevice, bool repaintEverything) { |
| ATRACE_CALL(); |
| ALOGV("doComposition"); |
| |
| auto display = displayDevice->getCompositionDisplay(); |
| const auto& displayState = display->getState(); |
| |
| if (displayState.isEnabled) { |
| // transform the dirty region into this screen's coordinate space |
| const Region dirtyRegion = display->getDirtyRegion(repaintEverything); |
| |
| // repaint the framebuffer (if needed) |
| doDisplayComposition(displayDevice, dirtyRegion); |
| |
| display->editState().dirtyRegion.clear(); |
| display->getRenderSurface()->flip(); |
| } |
| postFramebuffer(displayDevice); |
| } |
| |
| void SurfaceFlinger::postFrame() |
| { |
| // |mStateLock| not needed as we are on the main thread |
| const auto display = getDefaultDisplayDeviceLocked(); |
| if (display && getHwComposer().isConnected(*display->getId())) { |
| uint32_t flipCount = display->getPageFlipCount(); |
| if (flipCount % LOG_FRAME_STATS_PERIOD == 0) { |
| logFrameStats(); |
| } |
| } |
| } |
| |
| void SurfaceFlinger::postFramebuffer(const sp<DisplayDevice>& displayDevice) { |
| ATRACE_CALL(); |
| ALOGV("postFramebuffer"); |
| |
| auto display = displayDevice->getCompositionDisplay(); |
| const auto& displayState = display->getState(); |
| const auto displayId = display->getId(); |
| |
| if (displayState.isEnabled) { |
| if (displayId) { |
| getHwComposer().presentAndGetReleaseFences(*displayId); |
| } |
| display->getRenderSurface()->onPresentDisplayCompleted(); |
| for (auto& layer : display->getOutputLayersOrderedByZ()) { |
| sp<Fence> releaseFence = Fence::NO_FENCE; |
| bool usedClientComposition = true; |
| |
| // The layer buffer from the previous frame (if any) is released |
| // by HWC only when the release fence from this frame (if any) is |
| // signaled. Always get the release fence from HWC first. |
| if (layer->getState().hwc) { |
| const auto& hwcState = *layer->getState().hwc; |
| releaseFence = |
| getHwComposer().getLayerReleaseFence(*displayId, hwcState.hwcLayer.get()); |
| usedClientComposition = |
| hwcState.hwcCompositionType == Hwc2::IComposerClient::Composition::CLIENT; |
| } |
| |
| // If the layer was client composited in the previous frame, we |
| // need to merge with the previous client target acquire fence. |
| // Since we do not track that, always merge with the current |
| // client target acquire fence when it is available, even though |
| // this is suboptimal. |
| if (usedClientComposition) { |
| releaseFence = |
| Fence::merge("LayerRelease", releaseFence, |
| display->getRenderSurface()->getClientTargetAcquireFence()); |
| } |
| |
| layer->getLayerFE().onLayerDisplayed(releaseFence); |
| } |
| |
| // We've got a list of layers needing fences, that are disjoint with |
| // display->getVisibleLayersSortedByZ. The best we can do is to |
| // supply them with the present fence. |
| if (!displayDevice->getLayersNeedingFences().isEmpty()) { |
| sp<Fence> presentFence = |
| displayId ? getHwComposer().getPresentFence(*displayId) : Fence::NO_FENCE; |
| for (auto& layer : displayDevice->getLayersNeedingFences()) { |
| layer->getCompositionLayer()->getLayerFE()->onLayerDisplayed(presentFence); |
| } |
| } |
| |
| if (displayId) { |
| getHwComposer().clearReleaseFences(*displayId); |
| } |
| } |
| } |
| |
| void SurfaceFlinger::handleTransaction(uint32_t transactionFlags) |
| { |
| ATRACE_CALL(); |
| |
| // here we keep a copy of the drawing state (that is the state that's |
| // going to be overwritten by handleTransactionLocked()) outside of |
| // mStateLock so that the side-effects of the State assignment |
| // don't happen with mStateLock held (which can cause deadlocks). |
| State drawingState(mDrawingState); |
| |
| Mutex::Autolock _l(mStateLock); |
| mDebugInTransaction = systemTime(); |
| |
| // Here we're guaranteed that some transaction flags are set |
| // so we can call handleTransactionLocked() unconditionally. |
| // We call getTransactionFlags(), which will also clear the flags, |
| // with mStateLock held to guarantee that mCurrentState won't change |
| // until the transaction is committed. |
| |
| mVsyncModulator.onTransactionHandled(); |
| transactionFlags = getTransactionFlags(eTransactionMask); |
| handleTransactionLocked(transactionFlags); |
| |
| mDebugInTransaction = 0; |
| invalidateHwcGeometry(); |
| // here the transaction has been committed |
| } |
| |
| void SurfaceFlinger::processDisplayHotplugEventsLocked() { |
| for (const auto& event : mPendingHotplugEvents) { |
| const std::optional<DisplayIdentificationInfo> info = |
| getHwComposer().onHotplug(event.hwcDisplayId, event.connection); |
| |
| if (!info) { |
| continue; |
| } |
| |
| if (event.connection == HWC2::Connection::Connected) { |
| if (!mPhysicalDisplayTokens.count(info->id)) { |
| ALOGV("Creating display %s", to_string(info->id).c_str()); |
| mPhysicalDisplayTokens[info->id] = new BBinder(); |
| DisplayDeviceState state; |
| state.displayId = info->id; |
| state.isSecure = true; // All physical displays are currently considered secure. |
| state.displayName = info->name; |
| mCurrentState.displays.add(mPhysicalDisplayTokens[info->id], state); |
| mInterceptor->saveDisplayCreation(state); |
| } |
| } else { |
| ALOGV("Removing display %s", to_string(info->id).c_str()); |
| |
| ssize_t index = mCurrentState.displays.indexOfKey(mPhysicalDisplayTokens[info->id]); |
| if (index >= 0) { |
| const DisplayDeviceState& state = mCurrentState.displays.valueAt(index); |
| mInterceptor->saveDisplayDeletion(state.sequenceId); |
| mCurrentState.displays.removeItemsAt(index); |
| } |
| mPhysicalDisplayTokens.erase(info->id); |
| } |
| |
| processDisplayChangesLocked(); |
| } |
| |
| mPendingHotplugEvents.clear(); |
| } |
| |
| void SurfaceFlinger::dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected) { |
| mScheduler->hotplugReceived(mAppConnectionHandle, displayId, connected); |
| mScheduler->hotplugReceived(mSfConnectionHandle, displayId, connected); |
| } |
| |
| sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal( |
| const wp<IBinder>& displayToken, const std::optional<DisplayId>& displayId, |
| const DisplayDeviceState& state, const sp<compositionengine::DisplaySurface>& dispSurface, |
| const sp<IGraphicBufferProducer>& producer) { |
| DisplayDeviceCreationArgs creationArgs(this, displayToken, displayId); |
| creationArgs.sequenceId = state.sequenceId; |
| creationArgs.isVirtual = state.isVirtual(); |
| creationArgs.isSecure = state.isSecure; |
| creationArgs.displaySurface = dispSurface; |
| creationArgs.hasWideColorGamut = false; |
| creationArgs.supportedPerFrameMetadata = 0; |
| |
| const bool isInternalDisplay = displayId && displayId == getInternalDisplayIdLocked(); |
| creationArgs.isPrimary = isInternalDisplay; |
| |
| if (useColorManagement && displayId) { |
| std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId); |
| for (ColorMode colorMode : modes) { |
| if (isWideColorMode(colorMode)) { |
| creationArgs.hasWideColorGamut = true; |
| } |
| |
| std::vector<RenderIntent> renderIntents = |
| getHwComposer().getRenderIntents(*displayId, colorMode); |
| creationArgs.hwcColorModes.emplace(colorMode, renderIntents); |
| } |
| } |
| |
| if (displayId) { |
| getHwComposer().getHdrCapabilities(*displayId, &creationArgs.hdrCapabilities); |
| creationArgs.supportedPerFrameMetadata = |
| getHwComposer().getSupportedPerFrameMetadata(*displayId); |
| } |
| |
| auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer); |
| auto nativeWindow = nativeWindowSurface->getNativeWindow(); |
| creationArgs.nativeWindow = nativeWindow; |
| |
| // Make sure that composition can never be stalled by a virtual display |
| // consumer that isn't processing buffers fast enough. We have to do this |
| // here, in case the display is composed entirely by HWC. |
| if (state.isVirtual()) { |
| nativeWindow->setSwapInterval(nativeWindow.get(), 0); |
| } |
| |
| creationArgs.displayInstallOrientation = |
| isInternalDisplay ? primaryDisplayOrientation : DisplayState::eOrientationDefault; |
| |
| // virtual displays are always considered enabled |
| creationArgs.initialPowerMode = state.isVirtual() ? HWC_POWER_MODE_NORMAL : HWC_POWER_MODE_OFF; |
| |
| sp<DisplayDevice> display = getFactory().createDisplayDevice(std::move(creationArgs)); |
| |
| if (maxFrameBufferAcquiredBuffers >= 3) { |
| nativeWindowSurface->preallocateBuffers(); |
| } |
| |
| ColorMode defaultColorMode = ColorMode::NATIVE; |
| Dataspace defaultDataSpace = Dataspace::UNKNOWN; |
| if (display->hasWideColorGamut()) { |
| defaultColorMode = ColorMode::SRGB; |
| defaultDataSpace = Dataspace::V0_SRGB; |
| } |
| display->getCompositionDisplay()->setColorMode(defaultColorMode, defaultDataSpace, |
| RenderIntent::COLORIMETRIC); |
| if (!state.isVirtual()) { |
| LOG_ALWAYS_FATAL_IF(!displayId); |
| display->setActiveConfig(getHwComposer().getActiveConfigIndex(*displayId)); |
| } |
| |
| display->setLayerStack(state.layerStack); |
| display->setProjection(state.orientation, state.viewport, state.frame); |
| display->setDisplayName(state.displayName); |
| |
| return display; |
| } |
| |
| void SurfaceFlinger::processDisplayChangesLocked() { |
| // here we take advantage of Vector's copy-on-write semantics to |
| // improve performance by skipping the transaction entirely when |
| // know that the lists are identical |
| const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays); |
| const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays); |
| if (!curr.isIdenticalTo(draw)) { |
| mVisibleRegionsDirty = true; |
| const size_t cc = curr.size(); |
| size_t dc = draw.size(); |
| |
| // find the displays that were removed |
| // (ie: in drawing state but not in current state) |
| // also handle displays that changed |
| // (ie: displays that are in both lists) |
| for (size_t i = 0; i < dc;) { |
| const ssize_t j = curr.indexOfKey(draw.keyAt(i)); |
| if (j < 0) { |
| // in drawing state but not in current state |
| if (const auto display = getDisplayDeviceLocked(draw.keyAt(i))) { |
| // Save display ID before disconnecting. |
| const auto displayId = display->getId(); |
| display->disconnect(); |
| |
| if (!display->isVirtual()) { |
| LOG_ALWAYS_FATAL_IF(!displayId); |
| dispatchDisplayHotplugEvent(displayId->value, false); |
| } |
| } |
| |
| mDisplays.erase(draw.keyAt(i)); |
| } else { |
| // this display is in both lists. see if something changed. |
| const DisplayDeviceState& state(curr[j]); |
| const wp<IBinder>& displayToken = curr.keyAt(j); |
| const sp<IBinder> state_binder = IInterface::asBinder(state.surface); |
| const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface); |
| if (state_binder != draw_binder) { |
| // changing the surface is like destroying and |
| // recreating the DisplayDevice, so we just remove it |
| // from the drawing state, so that it get re-added |
| // below. |
| if (const auto display = getDisplayDeviceLocked(displayToken)) { |
| display->disconnect(); |
| } |
| mDisplays.erase(displayToken); |
| mDrawingState.displays.removeItemsAt(i); |
| dc--; |
| // at this point we must loop to the next item |
| continue; |
| } |
| |
| if (const auto display = getDisplayDeviceLocked(displayToken)) { |
| if (state.layerStack != draw[i].layerStack) { |
| display->setLayerStack(state.layerStack); |
| } |
| if ((state.orientation != draw[i].orientation) || |
| (state.viewport != draw[i].viewport) || (state.frame != draw[i].frame)) { |
| display->setProjection(state.orientation, state.viewport, state.frame); |
| } |
| if (state.width != draw[i].width || state.height != draw[i].height) { |
| display->setDisplaySize(state.width, state.height); |
| } |
| } |
| } |
| ++i; |
| } |
| |
| // find displays that were added |
| // (ie: in current state but not in drawing state) |
| for (size_t i = 0; i < cc; i++) { |
| if (draw.indexOfKey(curr.keyAt(i)) < 0) { |
| const DisplayDeviceState& state(curr[i]); |
| |
| sp<compositionengine::DisplaySurface> dispSurface; |
| sp<IGraphicBufferProducer> producer; |
| sp<IGraphicBufferProducer> bqProducer; |
| sp<IGraphicBufferConsumer> bqConsumer; |
| getFactory().createBufferQueue(&bqProducer, &bqConsumer, false); |
| |
| std::optional<DisplayId> displayId; |
| if (state.isVirtual()) { |
| // Virtual displays without a surface are dormant: |
| // they have external state (layer stack, projection, |
| // etc.) but no internal state (i.e. a DisplayDevice). |
| if (state.surface != nullptr) { |
| // Allow VR composer to use virtual displays. |
| if (mUseHwcVirtualDisplays || getHwComposer().isUsingVrComposer()) { |
| int width = 0; |
| int status = state.surface->query(NATIVE_WINDOW_WIDTH, &width); |
| ALOGE_IF(status != NO_ERROR, "Unable to query width (%d)", status); |
| int height = 0; |
| status = state.surface->query(NATIVE_WINDOW_HEIGHT, &height); |
| ALOGE_IF(status != NO_ERROR, "Unable to query height (%d)", status); |
| int intFormat = 0; |
| status = state.surface->query(NATIVE_WINDOW_FORMAT, &intFormat); |
| ALOGE_IF(status != NO_ERROR, "Unable to query format (%d)", status); |
| auto format = static_cast<ui::PixelFormat>(intFormat); |
| |
| displayId = |
| getHwComposer().allocateVirtualDisplay(width, height, &format); |
| } |
| |
| // TODO: Plumb requested format back up to consumer |
| |
| sp<VirtualDisplaySurface> vds = |
| new VirtualDisplaySurface(getHwComposer(), displayId, state.surface, |
| bqProducer, bqConsumer, |
| state.displayName); |
| |
| dispSurface = vds; |
| producer = vds; |
| } |
| } else { |
| ALOGE_IF(state.surface != nullptr, |
| "adding a supported display, but rendering " |
| "surface is provided (%p), ignoring it", |
| state.surface.get()); |
| |
| displayId = state.displayId; |
| LOG_ALWAYS_FATAL_IF(!displayId); |
| dispSurface = new FramebufferSurface(getHwComposer(), *displayId, bqConsumer); |
| producer = bqProducer; |
| } |
| |
| const wp<IBinder>& displayToken = curr.keyAt(i); |
| if (dispSurface != nullptr) { |
| mDisplays.emplace(displayToken, |
| setupNewDisplayDeviceInternal(displayToken, displayId, state, |
| dispSurface, producer)); |
| if (!state.isVirtual()) { |
| LOG_ALWAYS_FATAL_IF(!displayId); |
| dispatchDisplayHotplugEvent(displayId->value, true); |
| } |
| } |
| } |
| } |
| } |
| |
| mDrawingState.displays = mCurrentState.displays; |
| } |
| |
| void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags) |
| { |
| // Notify all layers of available frames |
| mCurrentState.traverseInZOrder([](Layer* layer) { |
| layer->notifyAvailableFrames(); |
| }); |
| |
| /* |
| * Traversal of the children |
| * (perform the transaction for each of them if needed) |
| */ |
| |
| if ((transactionFlags & eTraversalNeeded) || mTraversalNeededMainThread) { |
| mCurrentState.traverseInZOrder([&](Layer* layer) { |
| uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded); |
| if (!trFlags) return; |
| |
| const uint32_t flags = layer->doTransaction(0); |
| if (flags & Layer::eVisibleRegion) |
| mVisibleRegionsDirty = true; |
| |
| if (flags & Layer::eInputInfoChanged) { |
| mInputInfoChanged = true; |
| } |
| }); |
| mTraversalNeededMainThread = false; |
| } |
| |
| /* |
| * Perform display own transactions if needed |
| */ |
| |
| if (transactionFlags & eDisplayTransactionNeeded) { |
| processDisplayChangesLocked(); |
| processDisplayHotplugEventsLocked(); |
| } |
| |
| if (transactionFlags & (eDisplayLayerStackChanged|eDisplayTransactionNeeded)) { |
| // The transform hint might have changed for some layers |
| // (either because a display has changed, or because a layer |
| // as changed). |
| // |
| // Walk through all the layers in currentLayers, |
| // and update their transform hint. |
| // |
| // If a layer is visible only on a single display, then that |
| // display is used to calculate the hint, otherwise we use the |
| // default display. |
| // |
| // NOTE: we do this here, rather than in rebuildLayerStacks() so that |
| // the hint is set before we acquire a buffer from the surface texture. |
| // |
| // NOTE: layer transactions have taken place already, so we use their |
| // drawing state. However, SurfaceFlinger's own transaction has not |
| // happened yet, so we must use the current state layer list |
| // (soon to become the drawing state list). |
|