// frameworks/native/libs/renderengine/skia/SkiaRenderEngine.cpp:793~819
sk_sp<SkSurface> activeSurface(dstSurface);  // 初始指向屏幕目标
SkCanvas* canvas = dstCanvas;
const LayerSettings* blurCompositionLayer = nullptr;

if (mBlurFilter) {
    bool requiresCompositionLayer = false;
    for (const auto& layer : layers) {
        if (!layerHasBlur(layer, ctModifiesAlpha)) continue;
        if (layer.backgroundBlurRadius > 0 &&
            layer.backgroundBlurRadius < mBlurFilter->getMaxCrossFadeRadius()) {
            requiresCompositionLayer = true;
        }
        for (auto region : layer.blurRegions) {
            if (region.blurRadius < mBlurFilter->getMaxCrossFadeRadius())
                requiresCompositionLayer = true;
        }
        if (requiresCompositionLayer) {
            // 创建离屏 Surface，背后的 Layer 全画到这里
            activeSurface = dstSurface->makeSurface(dstSurface->imageInfo());
            canvas = mCapture->tryOffscreenCapture(activeSurface.get(), ...);
            blurCompositionLayer = &layer;
            break;
        }
    }
}

// frameworks/native/libs/renderengine/skia/SkiaRenderEngine.cpp:838~871
if (blurCompositionLayer == &layer) {
    // 对离屏 Surface（桌面+壁纸）拍快照，作为模糊原料
    blurInput = activeSurface->makeTemporaryImage();

    // 如果有 blurRegions，先把原始背景整体 blit 到屏幕
    // 原因：blurRegions 只模糊特定区域，其余区域要保持原始背景
    if (layer.blurRegions.size() || FlagManager::getInstance().restore_blur_step()) {
        SkPaint paint;
        paint.setBlendMode(SkBlendMode::kSrc);
        dstCanvas->drawImage(blurInput, 0, 0, SkSamplingOptions(), &paint);
    }

    // 切换回屏幕目标 Surface，后续直接画到屏幕
    canvas = dstCanvas;
    activeSurface = dstSurface;
}

// frameworks/native/libs/renderengine/skia/SkiaRenderEngine.cpp:937~946
if (layer.backgroundBlurRadius > 0) {
    SFTRACE_NAME("BackgroundBlur");
    // 对 blurInput（背后画面快照）执行 KawaseBlur，返回模糊图像
    auto blurredImage = mBlurFilter->generate(
        context, layer.backgroundBlurRadius, blurInput, blurRect);

    cachedBlurs[layer.backgroundBlurRadius] = blurredImage;

    // 将模糊图像画到 dstCanvas 的整个 Layer 矩形范围内
    mBlurFilter->drawBlurRegion(canvas, bounds, layer.backgroundBlurRadius, 1.0f,
                                blurRect, blurredImage, blurInput);
}

// frameworks/native/libs/renderengine/skia/filters/KawaseBlurFilter.cpp:76~135
sk_sp<SkImage> KawaseBlurFilter::generate(SkiaGpuContext* context, const uint32_t blurRadius,
                                          const sk_sp<SkImage> input,
                                          const SkRect& blurRect) const {
    float tmpRadius = (float)blurRadius / 2.0f;
    // 最多 4 次 Pass（kMaxPasses = 4）
    uint32_t numberOfPasses = std::min(kMaxPasses, (uint32_t)ceil(tmpRadius));
    float radiusByPasses = tmpRadius / (float)numberOfPasses;

    // 降采样至 0.25x（kInputScale），减少 GPU 带宽
    SkImageInfo scaledInfo = input->imageInfo().makeWH(
        std::ceil(blurRect.width() * kInputScale),
        std::ceil(blurRect.height() * kInputScale));

    // Pass 1：降采样 + 第一次 Kawase Shader
    SkRuntimeShaderBuilder blurBuilder(mBlurEffect);
    blurBuilder.child("child") = input->makeShader(..., blurMatrix);
    blurBuilder.uniform("in_blurOffset") = radiusByPasses * kInputScale;
    sk_sp<SkSurface> surface = context->createRenderTarget(scaledInfo);
    sk_sp<SkImage> tmpBlur = makeImage(surface.get(), &blurBuilder);

    // Pass 2~N：Ping-Pong 两个 Surface 交替，逐步增大 offset
    for (auto i = 1; i < numberOfPasses; i++) {
        blurBuilder.child("child") = tmpBlur->makeShader(...);
        blurBuilder.uniform("in_blurOffset") = (float)i * radiusByPasses * kInputScale;
        tmpBlur = makeImage(surfaceTwo.get(), &blurBuilder);
        swap(surface, surfaceTwo);
    }
    return tmpBlur;  // 返回降采样后的模糊结果（由 drawBlurRegion 负责还原尺寸）
}

// frameworks/native/libs/renderengine/skia/filters/BlurFilter.cpp:78~123
void BlurFilter::drawBlurRegion(SkCanvas* canvas, const SkRRect& effectRegion,
                                const uint32_t blurRadius, const float blurAlpha,
                                const SkRect& blurRect, sk_sp<SkImage> blurredImage,
                                sk_sp<SkImage> input) {
    SkPaint paint;
    paint.setAlphaf(blurAlpha);

    // 把降采样的模糊图还原回屏幕坐标的 Shader（kInverseInputScale = 4x）
    const auto blurShader = blurredImage->makeShader(
        SkTileMode::kClamp, SkTileMode::kClamp, linearSampling, &blurMatrix);

    if (blurRadius < mMaxCrossFadeRadius) {
        // 小半径：模糊结果与原始背景线性插值（平滑过渡，避免突变）
        SkRuntimeShaderBuilder blurBuilder(mMixEffect);
        blurBuilder.child("blurredInput") = blurShader;
        blurBuilder.child("originalInput") = input->makeShader(...);
        blurBuilder.uniform("mixFactor") = blurRadius / mMaxCrossFadeRadius;
        paint.setShader(blurBuilder.makeShader());
    } else {
        // 大半径：直接用模糊结果
        paint.setShader(blurShader);
    }

    // 将结果画到 effectRegion（矩形或圆角矩形）
    if (effectRegion.isRect()) {
        canvas->drawRect(effectRegion.rect(), paint);
    } else {
        canvas->drawRRect(effectRegion, paint);
    }
}

// frameworks/native/libs/ui/include/ui/BlurRegion.h:27~48
struct BlurRegion {
    uint32_t blurRadius;      // 模糊半径（px）
    float cornerRadiusTL;     // 左上圆角
    float cornerRadiusTR;     // 右上圆角
    float cornerRadiusBL;     // 左下圆角
    float cornerRadiusBR;     // 右下圆角
    float alpha;              // 模糊透明度
    int left;                 // 矩形坐标（Layer 坐标系）
    int top;
    int right;
    int bottom;
};

// frameworks/native/libs/renderengine/skia/SkiaRenderEngine.cpp:948~960
canvas->concat(getSkM44(layer.blurRegionTransform).asM33());
for (auto region : layer.blurRegions) {
    // 相同半径复用，避免重复计算
    if (cachedBlurs[region.blurRadius] == nullptr) {
        SFTRACE_NAME("BlurRegion");
        cachedBlurs[region.blurRadius] =
            mBlurFilter->generate(context, region.blurRadius, blurInput, blurRect);
    }

    // 画到 region 定义的圆角矩形（getBlurRRect 将 BlurRegion 转为 SkRRect）
    mBlurFilter->drawBlurRegion(canvas, getBlurRRect(region), region.blurRadius,
                                region.alpha, blurRect,
                                cachedBlurs[region.blurRadius], blurInput);
}

// frameworks/native/libs/gui/include/gui/LayerState.h:324~328
// Changes that force GPU composition.
static constexpr uint64_t COMPOSITION_EFFECTS =
    layer_state_t::eBackgroundBlurRadiusChanged |
    layer_state_t::eBlurRegionsChanged |
    layer_state_t::eCornerRadiusChanged |
    layer_state_t::eShadowRadiusChanged |
    layer_state_t::eStretchChanged |
    layer_state_t::eBorderSettingsChanged;