| /* |
| * Copyright 2022 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 ATRACE_TAG ATRACE_TAG_GRAPHICS |
| #undef LOG_TAG |
| #define LOG_TAG "SurfaceFlinger" |
| |
| #include "LayerSnapshot.h" |
| #include "Layer.h" |
| |
| namespace android::surfaceflinger::frontend { |
| |
| using namespace ftl::flag_operators; |
| |
| namespace { |
| |
| void updateSurfaceDamage(const RequestedLayerState& requested, bool hasReadyFrame, |
| bool forceFullDamage, Region& outSurfaceDamageRegion) { |
| if (!hasReadyFrame) { |
| outSurfaceDamageRegion.clear(); |
| return; |
| } |
| if (forceFullDamage) { |
| outSurfaceDamageRegion = Region::INVALID_REGION; |
| } else { |
| outSurfaceDamageRegion = requested.surfaceDamageRegion; |
| } |
| } |
| |
| std::ostream& operator<<(std::ostream& os, const ui::Transform& transform) { |
| const uint32_t type = transform.getType(); |
| const uint32_t orientation = transform.getOrientation(); |
| if (type == ui::Transform::IDENTITY) { |
| return os; |
| } |
| |
| if (type & ui::Transform::UNKNOWN) { |
| std::string out; |
| transform.dump(out, "", ""); |
| os << out; |
| return os; |
| } |
| |
| if (type & ui::Transform::ROTATE) { |
| switch (orientation) { |
| case ui::Transform::ROT_0: |
| os << "ROT_0"; |
| break; |
| case ui::Transform::FLIP_H: |
| os << "FLIP_H"; |
| break; |
| case ui::Transform::FLIP_V: |
| os << "FLIP_V"; |
| break; |
| case ui::Transform::ROT_90: |
| os << "ROT_90"; |
| break; |
| case ui::Transform::ROT_180: |
| os << "ROT_180"; |
| break; |
| case ui::Transform::ROT_270: |
| os << "ROT_270"; |
| break; |
| case ui::Transform::ROT_INVALID: |
| default: |
| os << "ROT_INVALID"; |
| break; |
| } |
| } |
| |
| if (type & ui::Transform::SCALE) { |
| std::string out; |
| android::base::StringAppendF(&out, " scale x=%.4f y=%.4f ", transform.getScaleX(), |
| transform.getScaleY()); |
| os << out; |
| } |
| |
| if (type & ui::Transform::TRANSLATE) { |
| std::string out; |
| android::base::StringAppendF(&out, " tx=%.4f ty=%.4f ", transform.tx(), transform.ty()); |
| os << out; |
| } |
| |
| return os; |
| } |
| |
| } // namespace |
| |
| LayerSnapshot::LayerSnapshot(const RequestedLayerState& state, |
| const LayerHierarchy::TraversalPath& path) |
| : path(path) { |
| // Provide a unique id for all snapshots. |
| // A front end layer can generate multiple snapshots if its mirrored. |
| // Additionally, if the layer is not reachable, we may choose to destroy |
| // and recreate the snapshot in which case the unique sequence id will |
| // change. The consumer shouldn't tie any lifetimes to this unique id but |
| // register a LayerLifecycleManager::ILifecycleListener or get a list of |
| // destroyed layers from LayerLifecycleManager. |
| if (path.isClone()) { |
| uniqueSequence = |
| LayerCreationArgs::getInternalLayerId(LayerCreationArgs::sInternalSequence++); |
| } else { |
| uniqueSequence = state.id; |
| } |
| sequence = static_cast<int32_t>(state.id); |
| name = state.name; |
| debugName = state.debugName; |
| premultipliedAlpha = state.premultipliedAlpha; |
| inputInfo.name = state.name; |
| inputInfo.id = static_cast<int32_t>(uniqueSequence); |
| inputInfo.ownerUid = gui::Uid{state.ownerUid}; |
| inputInfo.ownerPid = gui::Pid{state.ownerPid}; |
| uid = state.ownerUid; |
| pid = state.ownerPid; |
| changes = RequestedLayerState::Changes::Created; |
| clientChanges = 0; |
| mirrorRootPath = path.variant == LayerHierarchy::Variant::Mirror |
| ? path |
| : LayerHierarchy::TraversalPath::ROOT; |
| reachablilty = LayerSnapshot::Reachablilty::Unreachable; |
| frameRateSelectionPriority = state.frameRateSelectionPriority; |
| layerMetadata = state.metadata; |
| } |
| |
| // As documented in libhardware header, formats in the range |
| // 0x100 - 0x1FF are specific to the HAL implementation, and |
| // are known to have no alpha channel |
| // TODO: move definition for device-specific range into |
| // hardware.h, instead of using hard-coded values here. |
| #define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF) |
| |
| bool LayerSnapshot::isOpaqueFormat(PixelFormat format) { |
| if (HARDWARE_IS_DEVICE_FORMAT(format)) { |
| return true; |
| } |
| switch (format) { |
| case PIXEL_FORMAT_RGBA_8888: |
| case PIXEL_FORMAT_BGRA_8888: |
| case PIXEL_FORMAT_RGBA_FP16: |
| case PIXEL_FORMAT_RGBA_1010102: |
| case PIXEL_FORMAT_R_8: |
| return false; |
| } |
| // in all other case, we have no blending (also for unknown formats) |
| return true; |
| } |
| |
| bool LayerSnapshot::hasBufferOrSidebandStream() const { |
| return ((sidebandStream != nullptr) || (externalTexture != nullptr)); |
| } |
| |
| bool LayerSnapshot::drawShadows() const { |
| return shadowSettings.length > 0.f; |
| } |
| |
| bool LayerSnapshot::fillsColor() const { |
| return !hasBufferOrSidebandStream() && color.r >= 0.0_hf && color.g >= 0.0_hf && |
| color.b >= 0.0_hf; |
| } |
| |
| bool LayerSnapshot::hasBlur() const { |
| return backgroundBlurRadius > 0 || blurRegions.size() > 0; |
| } |
| |
| bool LayerSnapshot::hasEffect() const { |
| return fillsColor() || drawShadows() || hasBlur(); |
| } |
| |
| bool LayerSnapshot::hasSomethingToDraw() const { |
| return hasEffect() || hasBufferOrSidebandStream(); |
| } |
| |
| bool LayerSnapshot::isContentOpaque() const { |
| // if we don't have a buffer or sidebandStream yet, we're translucent regardless of the |
| // layer's opaque flag. |
| if (!hasSomethingToDraw()) { |
| return false; |
| } |
| |
| // if the layer has the opaque flag, then we're always opaque |
| if (layerOpaqueFlagSet) { |
| return true; |
| } |
| |
| // If the buffer has no alpha channel, then we are opaque |
| if (hasBufferOrSidebandStream() && |
| isOpaqueFormat(externalTexture ? externalTexture->getPixelFormat() : PIXEL_FORMAT_NONE)) { |
| return true; |
| } |
| |
| // Lastly consider the layer opaque if drawing a color with alpha == 1.0 |
| return fillsColor() && color.a == 1.0_hf; |
| } |
| |
| bool LayerSnapshot::isHiddenByPolicy() const { |
| return invalidTransform || isHiddenByPolicyFromParent || isHiddenByPolicyFromRelativeParent; |
| } |
| |
| bool LayerSnapshot::getIsVisible() const { |
| if (reachablilty != LayerSnapshot::Reachablilty::Reachable) { |
| return false; |
| } |
| |
| if (handleSkipScreenshotFlag & outputFilter.toInternalDisplay) { |
| return false; |
| } |
| |
| if (!hasSomethingToDraw()) { |
| return false; |
| } |
| |
| if (isHiddenByPolicy()) { |
| return false; |
| } |
| |
| return color.a > 0.0f || hasBlur(); |
| } |
| |
| std::string LayerSnapshot::getIsVisibleReason() const { |
| // not visible |
| if (reachablilty == LayerSnapshot::Reachablilty::Unreachable) |
| return "layer not reachable from root"; |
| if (reachablilty == LayerSnapshot::Reachablilty::ReachableByRelativeParent) |
| return "layer only reachable via relative parent"; |
| if (isHiddenByPolicyFromParent) return "hidden by parent or layer flag"; |
| if (isHiddenByPolicyFromRelativeParent) return "hidden by relative parent"; |
| if (handleSkipScreenshotFlag & outputFilter.toInternalDisplay) return "eLayerSkipScreenshot"; |
| if (invalidTransform) return "invalidTransform"; |
| if (color.a == 0.0f && !hasBlur()) return "alpha = 0 and no blur"; |
| if (!hasSomethingToDraw()) return "nothing to draw"; |
| |
| // visible |
| std::stringstream reason; |
| if (sidebandStream != nullptr) reason << " sidebandStream"; |
| if (externalTexture != nullptr) |
| reason << " buffer=" << externalTexture->getId() << " frame=" << frameNumber; |
| if (fillsColor() || color.a > 0.0f) reason << " color{" << color << "}"; |
| if (drawShadows()) reason << " shadowSettings.length=" << shadowSettings.length; |
| if (backgroundBlurRadius > 0) reason << " backgroundBlurRadius=" << backgroundBlurRadius; |
| if (blurRegions.size() > 0) reason << " blurRegions.size()=" << blurRegions.size(); |
| return reason.str(); |
| } |
| |
| bool LayerSnapshot::canReceiveInput() const { |
| return !isHiddenByPolicy() && (!hasBufferOrSidebandStream() || color.a > 0.0f); |
| } |
| |
| bool LayerSnapshot::isTransformValid(const ui::Transform& t) { |
| float transformDet = t.det(); |
| return transformDet != 0 && !isinf(transformDet) && !isnan(transformDet); |
| } |
| |
| bool LayerSnapshot::hasInputInfo() const { |
| return (inputInfo.token != nullptr || |
| inputInfo.inputConfig.test(gui::WindowInfo::InputConfig::NO_INPUT_CHANNEL)) && |
| reachablilty == Reachablilty::Reachable; |
| } |
| |
| std::string LayerSnapshot::getDebugString() const { |
| std::stringstream debug; |
| debug << "Snapshot{" << path.toString() << name << " isVisible=" << isVisible << " {" |
| << getIsVisibleReason() << "} changes=" << changes.string() |
| << " layerStack=" << outputFilter.layerStack.id << " geomLayerBounds={" |
| << geomLayerBounds.left << "," << geomLayerBounds.top << "," << geomLayerBounds.bottom |
| << "," << geomLayerBounds.right << "}" |
| << " geomLayerTransform={tx=" << geomLayerTransform.tx() |
| << ",ty=" << geomLayerTransform.ty() << "}" |
| << "}"; |
| if (hasInputInfo()) { |
| debug << " input{" |
| << "(" << inputInfo.inputConfig.string() << ")"; |
| if (touchCropId != UNASSIGNED_LAYER_ID) debug << " touchCropId=" << touchCropId; |
| if (inputInfo.replaceTouchableRegionWithCrop) debug << " replaceTouchableRegionWithCrop"; |
| auto touchableRegion = inputInfo.touchableRegion.getBounds(); |
| debug << " touchableRegion={" << touchableRegion.left << "," << touchableRegion.top << "," |
| << touchableRegion.bottom << "," << touchableRegion.right << "}" |
| << "}"; |
| } |
| return debug.str(); |
| } |
| |
| std::ostream& operator<<(std::ostream& out, const LayerSnapshot& obj) { |
| out << "Layer [" << obj.path.id; |
| if (!obj.path.mirrorRootIds.empty()) { |
| out << " mirrored from "; |
| for (auto rootId : obj.path.mirrorRootIds) { |
| out << rootId << ","; |
| } |
| } |
| out << "] " << obj.name << "\n " << (obj.isVisible ? "visible" : "invisible") |
| << " reason=" << obj.getIsVisibleReason(); |
| |
| if (!obj.geomLayerBounds.isEmpty()) { |
| out << "\n bounds={" << obj.transformedBounds.left << "," << obj.transformedBounds.top |
| << "," << obj.transformedBounds.bottom << "," << obj.transformedBounds.right << "}"; |
| } |
| |
| if (obj.geomLayerTransform.getType() != ui::Transform::IDENTITY) { |
| out << " toDisplayTransform={" << obj.geomLayerTransform << "}"; |
| } |
| |
| if (obj.hasInputInfo()) { |
| out << "\n input{" |
| << "(" << obj.inputInfo.inputConfig.string() << ")"; |
| if (obj.touchCropId != UNASSIGNED_LAYER_ID) out << " touchCropId=" << obj.touchCropId; |
| if (obj.inputInfo.replaceTouchableRegionWithCrop) out << " replaceTouchableRegionWithCrop"; |
| auto touchableRegion = obj.inputInfo.touchableRegion.getBounds(); |
| out << " touchableRegion={" << touchableRegion.left << "," << touchableRegion.top << "," |
| << touchableRegion.bottom << "," << touchableRegion.right << "}" |
| << "}"; |
| } |
| return out; |
| } |
| |
| FloatRect LayerSnapshot::sourceBounds() const { |
| if (!externalTexture) { |
| return geomLayerBounds; |
| } |
| return geomBufferSize.toFloatRect(); |
| } |
| |
| bool LayerSnapshot::isFrontBuffered() const { |
| if (!externalTexture) { |
| return false; |
| } |
| |
| return externalTexture->getUsage() & AHARDWAREBUFFER_USAGE_FRONT_BUFFER; |
| } |
| |
| Hwc2::IComposerClient::BlendMode LayerSnapshot::getBlendMode( |
| const RequestedLayerState& requested) const { |
| auto blendMode = Hwc2::IComposerClient::BlendMode::NONE; |
| if (alpha != 1.0f || !contentOpaque) { |
| blendMode = requested.premultipliedAlpha ? Hwc2::IComposerClient::BlendMode::PREMULTIPLIED |
| : Hwc2::IComposerClient::BlendMode::COVERAGE; |
| } |
| return blendMode; |
| } |
| |
| void LayerSnapshot::merge(const RequestedLayerState& requested, bool forceUpdate, |
| bool displayChanges, bool forceFullDamage, |
| uint32_t displayRotationFlags) { |
| clientChanges = requested.what; |
| changes = requested.changes; |
| contentDirty = requested.what & layer_state_t::CONTENT_DIRTY; |
| hasReadyFrame = requested.autoRefresh; |
| sidebandStreamHasFrame = requested.hasSidebandStreamFrame(); |
| updateSurfaceDamage(requested, requested.hasReadyFrame(), forceFullDamage, surfaceDamage); |
| |
| if (forceUpdate || requested.what & layer_state_t::eTransparentRegionChanged) { |
| transparentRegionHint = requested.transparentRegion; |
| } |
| if (forceUpdate || requested.what & layer_state_t::eFlagsChanged) { |
| layerOpaqueFlagSet = |
| (requested.flags & layer_state_t::eLayerOpaque) == layer_state_t::eLayerOpaque; |
| } |
| if (forceUpdate || requested.what & layer_state_t::eBufferTransformChanged) { |
| geomBufferTransform = requested.bufferTransform; |
| } |
| if (forceUpdate || requested.what & layer_state_t::eTransformToDisplayInverseChanged) { |
| geomBufferUsesDisplayInverseTransform = requested.transformToDisplayInverse; |
| } |
| if (forceUpdate || requested.what & layer_state_t::eDataspaceChanged) { |
| dataspace = Layer::translateDataspace(requested.dataspace); |
| } |
| if (forceUpdate || requested.what & layer_state_t::eExtendedRangeBrightnessChanged) { |
| currentHdrSdrRatio = requested.currentHdrSdrRatio; |
| desiredHdrSdrRatio = requested.desiredHdrSdrRatio; |
| } |
| if (forceUpdate || requested.what & layer_state_t::eCachingHintChanged) { |
| cachingHint = requested.cachingHint; |
| } |
| if (forceUpdate || requested.what & layer_state_t::eHdrMetadataChanged) { |
| hdrMetadata = requested.hdrMetadata; |
| } |
| if (forceUpdate || requested.what & layer_state_t::eSidebandStreamChanged) { |
| sidebandStream = requested.sidebandStream; |
| } |
| if (forceUpdate || requested.what & layer_state_t::eShadowRadiusChanged) { |
| shadowSettings.length = requested.shadowRadius; |
| } |
| if (forceUpdate || requested.what & layer_state_t::eFrameRateSelectionPriority) { |
| frameRateSelectionPriority = requested.frameRateSelectionPriority; |
| } |
| if (forceUpdate || requested.what & layer_state_t::eColorSpaceAgnosticChanged) { |
| isColorspaceAgnostic = requested.colorSpaceAgnostic; |
| } |
| if (forceUpdate || requested.what & layer_state_t::eDimmingEnabledChanged) { |
| dimmingEnabled = requested.dimmingEnabled; |
| } |
| if (forceUpdate || requested.what & layer_state_t::eCropChanged) { |
| geomCrop = requested.crop; |
| } |
| |
| if (forceUpdate || requested.what & layer_state_t::eDefaultFrameRateCompatibilityChanged) { |
| const auto compatibility = |
| Layer::FrameRate::convertCompatibility(requested.defaultFrameRateCompatibility); |
| if (defaultFrameRateCompatibility != compatibility) { |
| clientChanges |= layer_state_t::eDefaultFrameRateCompatibilityChanged; |
| } |
| defaultFrameRateCompatibility = compatibility; |
| } |
| |
| if (forceUpdate || |
| requested.what & |
| (layer_state_t::eFlagsChanged | layer_state_t::eBufferChanged | |
| layer_state_t::eSidebandStreamChanged)) { |
| compositionType = requested.getCompositionType(); |
| } |
| |
| if (forceUpdate || requested.what & layer_state_t::eInputInfoChanged) { |
| if (requested.windowInfoHandle) { |
| inputInfo = *requested.windowInfoHandle->getInfo(); |
| } else { |
| inputInfo = {}; |
| // b/271132344 revisit this and see if we can always use the layers uid/pid |
| inputInfo.name = requested.name; |
| inputInfo.ownerUid = requested.ownerUid; |
| inputInfo.ownerPid = requested.ownerPid; |
| } |
| inputInfo.id = static_cast<int32_t>(uniqueSequence); |
| touchCropId = requested.touchCropId; |
| } |
| |
| if (forceUpdate || |
| requested.what & |
| (layer_state_t::eColorChanged | layer_state_t::eBufferChanged | |
| layer_state_t::eSidebandStreamChanged)) { |
| color.rgb = requested.getColor().rgb; |
| } |
| |
| if (forceUpdate || requested.what & layer_state_t::eBufferChanged) { |
| acquireFence = |
| (requested.externalTexture && |
| requested.bufferData->flags.test(BufferData::BufferDataChange::fenceChanged)) |
| ? requested.bufferData->acquireFence |
| : Fence::NO_FENCE; |
| buffer = requested.externalTexture ? requested.externalTexture->getBuffer() : nullptr; |
| externalTexture = requested.externalTexture; |
| frameNumber = (requested.bufferData) ? requested.bufferData->frameNumber : 0; |
| hasProtectedContent = requested.externalTexture && |
| requested.externalTexture->getUsage() & GRALLOC_USAGE_PROTECTED; |
| geomUsesSourceCrop = hasBufferOrSidebandStream(); |
| } |
| |
| if (forceUpdate || |
| requested.what & |
| (layer_state_t::eCropChanged | layer_state_t::eBufferCropChanged | |
| layer_state_t::eBufferTransformChanged | |
| layer_state_t::eTransformToDisplayInverseChanged) || |
| requested.changes.test(RequestedLayerState::Changes::BufferSize) || displayChanges) { |
| bufferSize = requested.getBufferSize(displayRotationFlags); |
| geomBufferSize = bufferSize; |
| croppedBufferSize = requested.getCroppedBufferSize(bufferSize); |
| geomContentCrop = requested.getBufferCrop(); |
| } |
| |
| if (forceUpdate || |
| requested.what & |
| (layer_state_t::eFlagsChanged | layer_state_t::eDestinationFrameChanged | |
| layer_state_t::ePositionChanged | layer_state_t::eMatrixChanged | |
| layer_state_t::eBufferTransformChanged | |
| layer_state_t::eTransformToDisplayInverseChanged) || |
| requested.changes.test(RequestedLayerState::Changes::BufferSize) || displayChanges) { |
| localTransform = requested.getTransform(displayRotationFlags); |
| localTransformInverse = localTransform.inverse(); |
| } |
| |
| if (forceUpdate || requested.what & (layer_state_t::eColorChanged) || |
| requested.changes.test(RequestedLayerState::Changes::BufferSize)) { |
| color.rgb = requested.getColor().rgb; |
| } |
| |
| if (forceUpdate || |
| requested.what & |
| (layer_state_t::eBufferChanged | layer_state_t::eDataspaceChanged | |
| layer_state_t::eApiChanged | layer_state_t::eShadowRadiusChanged | |
| layer_state_t::eBlurRegionsChanged | layer_state_t::eStretchChanged)) { |
| forceClientComposition = shadowSettings.length > 0 || stretchEffect.hasEffect(); |
| } |
| |
| if (forceUpdate || |
| requested.what & |
| (layer_state_t::eColorChanged | layer_state_t::eShadowRadiusChanged | |
| layer_state_t::eBlurRegionsChanged | layer_state_t::eBackgroundBlurRadiusChanged | |
| layer_state_t::eCornerRadiusChanged | layer_state_t::eAlphaChanged | |
| layer_state_t::eFlagsChanged | layer_state_t::eBufferChanged | |
| layer_state_t::eSidebandStreamChanged)) { |
| contentOpaque = isContentOpaque(); |
| isOpaque = contentOpaque && !roundedCorner.hasRoundedCorners() && color.a == 1.f; |
| blendMode = getBlendMode(requested); |
| } |
| } |
| |
| } // namespace android::surfaceflinger::frontend |