Transaction& Transaction::setBackgroundBlurRadius(
        const sp<SurfaceControl>& sc, int backgroundBlurRadius) {
    layer_state_t* s = getLayerState(sc);
    s->what |= layer_state_t::eBackgroundBlurRadiusChanged;  // 标记变更 bit
    s->backgroundBlurRadius = backgroundBlurRadius;
    return *this;
}

eBackgroundBlurRadiusChanged = 0x80'00000000,
eBlurRegionsChanged          = 0x800'00000000,

if (forceUpdate ||
    snapshot.clientChanges &
            (layer_state_t::eBackgroundBlurRadiusChanged | layer_state_t::eBlurRegionsChanged |
             layer_state_t::eAlphaChanged)) {
    // 关键：模糊半径乘以父 Layer 的 alpha（透明度影响模糊强度）
    snapshot.backgroundBlurRadius = args.supportsBlur
            ? static_cast<int>(parentSnapshot.color.a * (float)requested.backgroundBlurRadius)
            : 0;  // 硬件不支持直接清零
    snapshot.blurRegions = requested.blurRegions;
    for (auto& region : snapshot.blurRegions) {
        region.alpha = region.alpha * snapshot.color.a;  // blurRegions 也继承 alpha
    }
}

.supportsBlur = mSupportsBlur,  // ro.surface_flinger.supports_background_blur

property_get("ro.surface_flinger.supports_background_blur", value, "0");
mSupportsBlur = atoi(value);

// COMPOSITION_EFFECTS 包含 eBackgroundBlurRadiusChanged
// 任何带 COMPOSITION_EFFECTS 的 Layer 强制降级为 CLIENT 合成
static constexpr uint64_t COMPOSITION_EFFECTS = ...
        | eBackgroundBlurRadiusChanged | eBlurRegionsChanged | ...;

// 第一步：扫描全部 Layer，定位最上面的 blur 层
mLayerRequestingBackgroundBlur = findLayerRequestingBackgroundComposition();

// 第二步：只要存在 blur 层，就开启强制 GPU 标志
bool forceClientComposition = mLayerRequestingBackgroundBlur != nullptr;

// 第三步：按 Z 序遍历所有 Layer，逐一下压强制标志
for (auto* layer : getOutputLayersOrderedByZ()) {
    layer->updateCompositionState(...,
            forceClientComposition,  // blur 层下方的所有 Layer 全部强制 GPU
            ...);

    // ★ 到达 blur 层本身时，立即关掉标志
    // blur 层上方的 Layer 恢复正常 HWC/GPU 决策，不受影响
    if (mLayerRequestingBackgroundBlur == layer) {
        forceClientComposition = false;
    }
}

compositionengine::OutputLayer* Output::findLayerRequestingBackgroundComposition() const {
    compositionengine::OutputLayer* layerRequestingBgComposition = nullptr;
    for (auto* layer : getOutputLayersOrderedByZ()) {
        const auto* compState = layer->getLayerFE().getCompositionState();

        // sideband stream（视频解码器直通）存在 → 立即放弃整个 blur 特性
        if (compState->sidebandStream != nullptr) return nullptr;

        // 完全不透明的 Layer 跳过（blur 被其完全遮住，无意义）
        if (compState->isOpaque) continue;

        if (compState->backgroundBlurRadius > 0 || compState->blurRegions.size() > 0) {
            layerRequestingBgComposition = layer;  // 保留最上面那个 blur 层
        }
    }
    return layerRequestingBgComposition;
}

// activeSurface 此时已包含 blur 层下方所有窗口的像素
// （壁纸 + 后台 App + Launcher + 状态栏 + ... 全部叠加其上）
blurInput = activeSurface->makeTemporaryImage();

// 对这张"所有下方窗口合并"的图像执行 Kawase 模糊
auto blurredImage = mBlurFilter->generate(context,
        layer.backgroundBlurRadius, blurInput, blurRect);

const bool expensiveBlurs = mLayerRequestingBackgroundBlur != nullptr;
if (expensiveRenderingExpected) {
    setExpensiveRenderingExpected(true);  // 通知 SF 提升 GPU 运行频率
}

enum class BlurSetting {
    Disabled,           // 关闭
    BackgroundBlurOnly, // 仅背景整体模糊
    BlurRegionsOnly,    // 仅区域模糊（BlurRegion）
    Enabled             // 两种都生效
};

switch (targetSettings.blurSetting) {
    case LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled:
        layerSettings.backgroundBlurRadius = mSnapshot->backgroundBlurRadius;
        layerSettings.blurRegions = mSnapshot->blurRegions;
        layerSettings.blurRegionTransform = mSnapshot->localTransformInverse.asMatrix4();
        break;
    case LayerFE::ClientCompositionTargetSettings::BlurSetting::BackgroundBlurOnly:
        layerSettings.backgroundBlurRadius = mSnapshot->backgroundBlurRadius;
        break;
    ...
}

// 默认选 Kawase：速度快，视觉效果接近高斯
renderengine::RenderEngine::BlurAlgorithm chooseBlurAlgorithm(bool supportsBlur) {
    if (!supportsBlur) return BlurAlgorithm::NONE;
    // 优先 KAWASE_DUAL_FILTER，其次 KAWASE，最后 GAUSSIAN
    ...
}

switch (blurAlgorithm) {
    case BlurAlgorithm::GAUSSIAN:        mBlurFilter = new GaussianBlurFilter(); break;
    case BlurAlgorithm::KAWASE:          mBlurFilter = new KawaseBlurFilter(); break;
    case BlurAlgorithm::KAWASE_DUAL_FILTER: mBlurFilter = new KawaseBlurDualFilter(); break;
    default: mBlurFilter = nullptr; break;
}

static inline bool layerHasBlur(const LayerSettings& layer, bool colorTransformModifiesAlpha) {
    if (layer.backgroundBlurRadius > 0 || layer.blurRegions.size()) {
        const bool opaqueContent = !layer.source.buffer.buffer || layer.source.buffer.isOpaque;
        const bool opaqueAlpha = layer.alpha == 1.0f && !colorTransformModifiesAlpha;
        // 如果内容完全不透明，后面看不到，不需要模糊
        return layer.skipContentDraw || !(opaqueContent && opaqueAlpha);
    }
    return false;
}

// 遍历所有 layer，找到第一个需要 crossFade 的模糊层
for (const auto& layer : layers) {
    if (!layerHasBlur(layer, ctModifiesAlpha)) continue;
    if (layer.backgroundBlurRadius > 0 &&
        layer.backgroundBlurRadius < mBlurFilter->getMaxCrossFadeRadius()) {
        requiresCompositionLayer = true;  // 小半径需要 crossfade，必须离屏
    }
    if (requiresCompositionLayer) {
        // 创建与 dstSurface 同尺寸的离屏 SkSurface
        activeSurface = dstSurface->makeSurface(dstSurface->imageInfo());
        blurCompositionLayer = &layer;  // 记录触发离屏的 layer
        break;
    }
}

if (mBlurFilter && layerHasBlur(layer, ctModifiesAlpha)) {
    // 计算 blurRect（裁剪到屏幕范围，避免超大 Layer 分配巨量 buffer）
    SkRect blurRect = canvas->getTotalMatrix().mapRect(bounds.rect());
    blurRect.intersect(SkRect::Make(canvas->getDeviceClipBounds()));

    if (layer.backgroundBlurRadius > 0) {
        SFTRACE_NAME("BackgroundBlur");
        // 1. generate：0.25x 降采样 → Kawase 多 Pass 模糊 → 返回模糊纹理
        auto blurredImage = mBlurFilter->generate(context,
                layer.backgroundBlurRadius, blurInput, blurRect);
        // 2. drawBlurRegion：将模糊结果写回 canvas（带 crossfade）
        mBlurFilter->drawBlurRegion(canvas, bounds, layer.backgroundBlurRadius,
                1.0f, blurRect, blurredImage, blurInput);
    }
    // BlurRegion（区域模糊）类似，支持多个区域缓存复用
    for (auto region : layer.blurRegions) {
        if (cachedBlurs[region.blurRadius] == nullptr) {
            cachedBlurs[region.blurRadius] =
                    mBlurFilter->generate(context, region.blurRadius, blurInput, blurRect);
        }
        mBlurFilter->drawBlurRegion(canvas, getBlurRRect(region), region.blurRadius,
                region.alpha, blurRect, cachedBlurs[region.blurRadius], blurInput);
    }
}

float tmpRadius = (float)blurRadius / 2.0f;
uint32_t numberOfPasses = std::min(kMaxPasses, (uint32_t)ceil(tmpRadius));
float radiusByPasses = tmpRadius / (float)numberOfPasses;

// 第 1 Pass：原图 → 0.25x 降采样 + 模糊
SkImageInfo scaledInfo = input->imageInfo().makeWH(
    blurRect.width() * kInputScale,   // kInputScale = 0.25
    blurRect.height() * kInputScale);

// 后续 Pass：Ping-Pong 在两个 SkSurface 之间交替（节省分配）
for (auto i = 1; i < numberOfPasses; i++) {
    blurBuilder.uniform("in_blurOffset") = (float) i * radiusByPasses * kInputScale;
    tmpBlur = makeImage(surfaceTwo.get(), &blurBuilder);
    swap(surface, surfaceTwo);
}