perf(desktop): 回放合并改用 xstack 一次合成 + 硬件编码(含自动兜底)

合成(ComposeAsync):
- 链式 overlay 在 1080p 画布上要走 N-1 遍整帧混合,改成一条 xstack 一次合成;
  画布比矩形并集大就 pad 补黑,越界摆位就 crop 裁掉(等价于原来叠在黑画布上)
- 实测(本机 i5-12400 + UHD 730):60s x 4 路 24.7s -> 16.1s(libx264)、
  26.5s -> 16.5s(qsv);120s 片段走 ComposeAsync 实路径 36.3s -> 25.2s
- 输出与旧实现逐像素一致(PSNR inf):标准 2x2、混合尺寸、留空、越界裁剪四种布局;
  矩形重叠时 z-order 与 overlay 一致

编码器(新增 FfmpegVideoEncoder):
- 优先 h264_qsv / h264_nvenc / h264_amf,都没有或跑不起来回落 libx264
- 探测 = 拿 0.2 秒黑场真编一帧(看 -encoders 列表不够:装 nvenc 没 N 卡也在列表里),
  结果缓存在进程内;QSV 探测约 1 秒,驱动缺失的候选 0.05 秒,单个候选上限 4 秒
- 硬件编码失败(非 0 退出 / 退出码 0 但没写出成片)自动用 libx264 重试一次
- 质量档位对齐原 crf23:qsv gq26(PSNR 持平,体积 +7%)、nvenc/amf qp26
- 排障:YUNCANG_COMPOSE_ENCODER 可跳过探测强制指定,写错名字按 libx264 处理

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
liufumingren 2026-11-17 01:20:33 +08:00
parent 18f258014f
commit 2a81047f81
4 changed files with 319 additions and 33 deletions

View File

@ -658,6 +658,69 @@ reg query "HKCU\Software\Classes\yuncang\shell\open\command"
查询日志只记结论(`[pack-query] 运单号 → found=… records=… streams=…`),不再写完整 JSON;
要排查原始数据看后端日志或页面。
### 合成滤镜图:一次 `xstack`,不要链式 `overlay`
各路画面按快照里的矩形摆放时,**用一条 `xstack` 一次合成**(`ComposeAsync`),
不要像以前那样「黑画布 + 逐个 `overlay`」:
```
[v0][v1][v2][v3]xstack=inputs=4:layout=0_0|960_0|0_540|960_540:fill=black,pad=1920:1080:0:0:black[out]
```
链式 overlay 在 1080p 画布上要走 N−1 遍**整帧**混合(4 路就是 3 遍),每遍都要读两帧写一帧;
xstack 只做一遍。实测(本机 i5-12400 + UHD 730,机器同时在跑别的程序,所以按中位数看):
| 场景 | 链式 overlay | 一次 xstack |
| --- | --- | --- |
| 60 s × 4 路,libx264(5 次中位数) | 24.7 s / CPU 88 s | **16.1 s / CPU 74 s** |
| 60 s × 4 路,h264_qsv(5 次中位数) | 26.5 s / CPU 47 s | **16.5 s / CPU 34 s** |
| 120 s × 4 路,`ComposeAsync` 实路径 + libx264 | 37.1 / 35.4 s | **25.3 / 25.1 s** |
| 300 s × 4 路,libx264(2 次,负载高、波动大) | 141.6 / 102.3 s | **67.9 / 62.7 s** |
- 画布比矩形并集大 → `pad` 补黑;比画布大(有越界摆位)→ `crop` 裁掉,与原来叠在黑画布上等价;
- 矩形重叠时 z-order 与 overlay 链一致(后一路在上),已用纯色片源验证;
- 输出与旧实现**逐像素一致**:标准 2×2、混合尺寸 + 留空 + 越界裁剪两种布局,PSNR 都是 `inf`。
> 全 GPU 合成(`vpp_qsv` + `xstack_qsv` + `h264_qsv`,输入 `-hwaccel qsv -hwaccel_output_format qsv`
> + `-init_hw_device qsv=hw -filter_hw_device hw`,注意要加 `-noautoscale`)在本机**能跑通**:
> CPU 再降一半(60 s × 4 路 CPU 34 s → 16 s),但**墙钟反而慢一点**(中位数 11.1 s → 13.2 s)。
> 合并的首要痛点是时长,所以没做成默认;等哪天要求「合并时机器必须近乎空闲」再切过去。
### 合并用的编码器(CPU / 核显)
合并没办法 `-c:v copy`(多路 overlay 要重画每个像素),所以这一步是纯转码,客户机 CPU 一忙整机就卡。
现在会**优先用硬件编码**([FfmpegVideoEncoder](Services/Hik/FfmpegVideoEncoder.cs)):
| 编码器 | 什么时候用 | 300 秒 × 4 路 | 300 秒 × 2 路 |
| --- | --- | --- | --- |
| `h264_qsv` | Intel 核显(优先) | **58.5 s** / CPU 212 s / 148.3 MB | **42.3 s** / CPU 126 s / 74.8 MB |
| `h264_nvenc` | NVIDIA 独显 | 未实测(同档参数 `-qp 26`) | — |
| `h264_amf` | AMD 独显 / APU | 未实测(同档参数 `-qp_i/-qp_p 26`) | — |
| `libx264` | 都没有 / 硬件跑不起来(兜底) | 73.7 s / CPU 420 s / 138.6 MB | 47.6 s / CPU 273 s / 69.1 MB |
(i5-12400 + UHD 730,720p 片源合到 1920×1080@25,只编码不改滤镜链;体积含 `+faststart`)
> ⚠️ **收益随片长变化**:5 分钟这种长片段编码占比高,硬件编码快 **11%~21%**;
> 8 秒这种短片段被进程启动 / 首帧抖动盖住,墙钟几乎一样(3.03 s vs 3.04 s),只省 CPU(11.5 s → 6.6 s)。
> 质量上 `gq 26` 与 `crf 23` 基本持平(PSNR 41.9 dB vs 42.1 dB),体积大 7%;
> 想省体积可按 `YUNCANG_COMPOSE_ENCODER` 之外的参数改成 `gq 28`(40.7 dB,比 crf 23 小 19%,画面会软一点)。
- **探测**:进程内第一次合并时,拿 0.2 秒黑场**真编一帧**(`-f lavfi -i color=… -f null -`),
成功才用 —— 光看 `ffmpeg -encoders` 列表不够(装了 nvenc 但没有 N 卡也照样在列表里)。
结果缓存在进程里(**每次进程启动只付一次**),日志:
`[playback] 合并编码器:h264_qsv(硬件编码,探测用时 1024ms)`。
- **探测开销**:有核显的机器约 **1.0 秒**(QSV 初始化 Media SDK 设备,与探测内容无关);
驱动缺失的候选是 dlopen 立刻失败,**0.04~0.06 秒**(≈ 一次 ffmpeg 启动);全都没有时三个候选合计约 0.1 秒。
单个候选最多等 **4 秒**(驱动卡死时),超时就跳过。
- **兜底**:硬件编码跑到一半失败(驱动被独占 / 参数组合不支持 / 退出码 0 但没写出文件)→ 删掉半成品,
**用 libx264 重来一次**,不让用户白等(日志 `[playback] 合并用 h264_qsv 失败(退出码 …),改用 libx264 重试`)。
软件编码再失败才抛异常,此时调用方保留各路段(另见「合并失败不丢数据」)。
- **质量档位**和原来 `crf 23` 对齐:QSV 用 `-global_quality 26`(`23` 会输出到 5.85 MB,比原来大 57%,
而成片还要上传云端,所以退一档),NVENC 用 `-qp 26`,AMF 用 `-qp_i/-qp_p 26`。
- **排障**:环境变量 `YUNCANG_COMPOSE_ENCODER=libx264`(或 `h264_qsv` 等)可跳过探测强制指定;写错名字按 libx264 处理。
- ⚠️ 只把**编码**交给硬件:解码 / `scale` / `xstack` 仍是 CPU。
全 GPU 那条链(`vpp_qsv` + `xstack_qsv`)实测 CPU 再减半、墙钟略慢,见上一节,暂未启用。
要换成别的数据源,只改 `OrderQueryService.QueryAsync` 一个方法就行(返回 `QueryResult`,
`Data` 是扁平字典即可,前端 `/local` 页也吃这份数据)。

View File

@ -0,0 +1,182 @@
using System;
using System.Diagnostics;
using System.Linq;
using System.Threading;
namespace YuncangTrace.LocalService.Services.Hik;
/// <summary>
/// 合并视频(多路 overlay → 一路)用的 H.264 编码器:**有硬件编码就用,没有/跑不起来回落 libx264**
///
/// 合并没办法 `-c:v copy`(每个像素都要重画),所以这一步是纯转码,客户机 CPU 一忙整机就卡。
/// 实测(i5-12400 + UHD 730,4 路 / 2 路 720p 合到 1920×1080@25,testsrc2 片源):
/// <code>
/// 300s × 4 路 libx264: 73.7s 墙钟 / 420s CPU / 138.6MB
/// h264_qsv(gq26): 58.5s 墙钟 / 212s CPU / 148.3MB ← 快 21%、CPU 减半
/// 300s × 2 路 libx264: 47.6s 墙钟 / 273s CPU / 69.1MB
/// h264_qsv(gq26): 42.3s 墙钟 / 126s CPU / 74.8MB ← 快 11%
/// 8s × 4 路 两者墙钟几乎一样(3.03s vs 3.04s,CPU 11.5s → 6.6s)
/// </code>
///
/// ⚠️ **片越短,硬件编码的墙钟收益越小**:8 秒这种短片段被进程启动 / 首帧抖动盖住,
/// 省到的只有 CPU;5 分钟这种长片段编码占比上来,才有 10~20% 的时长收益。
/// 质量:`gq 26` 的 PSNR 与 `crf 23` 基本持平(41.9dB vs 42.1dB),体积大 7%;
/// 想省体积可以按 `gq 28`(40.7dB,比 crf 23 小 19%),但画面会明显软一点。
///
/// ⚠️ **只把编码交给硬件**:解码 / scale / overlay 仍走 CPU。
/// 实测把解码也丢给核显(`-hwaccel qsv -hwaccel_output_format nv12`)没有收益,
/// 而 overlay_qsv 那条全 GPU 链路在实测机器上 `hwupload` 直接失败(frame pool 建不起来),
/// 不能当默认 —— 客户机型号杂,赌不起。
///
/// 探测开销(每次进程启动只付一次,结果缓存在 <see cref="_picked"/>):QSV 需要初始化
/// Media SDK 设备,实测 **约 1.0 秒**且与探测内容无关(1 帧 64×64 也要 0.98s);
/// 驱动缺失的候选则是 dlopen 立刻失败,**0.04~0.06 秒**(≈ 一次 ffmpeg 启动的开销)。
///
/// 排障:环境变量 `YUNCANG_COMPOSE_ENCODER=libx264|h264_qsv|h264_nvenc|h264_amf` 可跳过探测强制指定。
/// </summary>
internal static class FfmpegVideoEncoder
{
/// <summary>软件编码(兜底,永远可用)</summary>
public const string Software = "libx264";
private const string OverrideVariable = "YUNCANG_COMPOSE_ENCODER";
/// <summary>
/// 按优先级排的候选:Intel 核显 → NVIDIA → AMD → 软件。
///
/// 质量档位刻意和 `libx264 -crf 23` 对齐(QSV 的 `-global_quality` 是 ICQ,NVENC/AMF 用 CQP):
/// 实测同一段片子 `gq=23` 会输出 5.85MB(比 crf23 的 3.72MB 大 57%),
/// **成片还要上传云端**,所以退到 26 —— 4.01MB,和原来基本持平,编码仍然快 37%。
/// </summary>
private static readonly (string Name, string[] Args)[] Candidates =
{
("h264_qsv", new[] { "-c:v", "h264_qsv", "-preset", "veryfast", "-global_quality", "26" }),
("h264_nvenc", new[] { "-c:v", "h264_nvenc", "-preset", "p4", "-rc", "constqp", "-qp", "26" }),
("h264_amf", new[] { "-c:v", "h264_amf", "-quality", "speed", "-rc", "cqp", "-qp_i", "26", "-qp_p", "26" }),
(Software, new[] { "-c:v", Software, "-preset", "veryfast", "-crf", "23" }),
};
private static readonly object Gate = new();
private static string? _picked;
private static long _probeMs;
/// <summary>
/// 这台机器上合并该用哪个编码器(进程内只探测一次)。
/// 探测 = 拿 0.2 秒黑场真编一帧,光看 `-encoders` 列表不够:装了 nvenc 但没 N 卡也一样会失败。
/// </summary>
public static string Resolve(string ffmpeg)
{
lock (Gate)
{
if (_picked is not null) return _picked;
var forced = Environment.GetEnvironmentVariable(OverrideVariable)?.Trim();
if (!string.IsNullOrEmpty(forced))
{
// 只认列出来的这几个:写错名字要是当硬件编码用,会「探测跳过 → 合并失败 → 白重试一轮」
if (!Candidates.Any(item => string.Equals(item.Name, forced, StringComparison.OrdinalIgnoreCase)))
{
AppLog.Write($"[playback] {OverrideVariable}={forced} 不认识,按 libx264 处理(可选:{string.Join('/', Candidates.Select(item => item.Name))})");
_picked = Software;
return _picked;
}
_picked = forced;
AppLog.Write($"[playback] 合并编码器按 {OverrideVariable} 指定:{forced}(不探测)");
return _picked;
}
foreach (var (name, args) in Candidates)
{
if (name == Software) break;
var started = Stopwatch.StartNew();
var usable = Usable(ffmpeg, name, args);
_probeMs += started.ElapsedMilliseconds;
if (!usable) continue;
_picked = name;
AppLog.Write($"[playback] 合并编码器:{name}(硬件编码,探测用时 {_probeMs}ms)");
return _picked;
}
_picked = Software;
AppLog.Write($"[playback] 合并编码器:libx264(没有可用的硬件编码器,探测用时 {_probeMs}ms)");
return _picked;
}
}
/// <summary>该编码器对应的 ffmpeg 参数</summary>
public static string[] EncoderArgs(string encoder)
{
foreach (var (name, args) in Candidates)
{
if (string.Equals(name, encoder, StringComparison.OrdinalIgnoreCase)) return args;
}
return Candidates[^1].Args;
}
/// <summary>是不是软件编码(软件都失败就没得重试了)</summary>
public static bool IsSoftware(string encoder)
{
return string.Equals(encoder, Software, StringComparison.OrdinalIgnoreCase);
}
/// <summary>真编一帧确认能用(驱动缺失 / 被独占 / 参数不支持都会在这里暴露)</summary>
private static bool Usable(string ffmpeg, string name, string[] args)
{
try
{
var psi = new ProcessStartInfo
{
FileName = ffmpeg,
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
};
foreach (var arg in new[]
{
"-hide_banner", "-nostdin", "-loglevel", "error",
"-f", "lavfi", "-i", "color=c=black:s=320x240:r=25:d=0.2",
})
{
psi.ArgumentList.Add(arg);
}
foreach (var arg in args) psi.ArgumentList.Add(arg);
psi.ArgumentList.Add("-f");
psi.ArgumentList.Add("null");
psi.ArgumentList.Add("-");
using var process = Process.Start(psi);
if (process is null) return false;
// 两个流都要读掉,否则管道写满 ffmpeg 会卡住
var stdout = process.StandardOutput.ReadToEndAsync();
var stderr = process.StandardError.ReadToEndAsync();
if (!process.WaitForExit(4000))
{
try { process.Kill(entireProcessTree: true); } catch { /* 已经退了 */ }
AppLog.Write($"[playback] 硬件编码 {name} 探测超时(4s),跳过");
return false;
}
var ok = process.ExitCode == 0;
if (!ok)
{
var firstError = (stderr.Result ?? string.Empty)
.Split('\n')
.Select(line => line.Trim())
.FirstOrDefault(line => line.Length > 0) ?? "未知原因";
AppLog.Write($"[playback] 硬件编码 {name} 不可用:{firstError}");
}
return ok;
}
catch (Exception ex)
{
AppLog.Write($"[playback] 硬件编码 {name} 探测失败:{ex.Message}");
return false;
}
}
}

View File

@ -530,14 +530,18 @@ public sealed class HikPlaybackService : IDisposable
/// <summary>
/// 把多路下载好的片段**按工作台画布布局合并成一个视频**
///
/// 做法:先铺一张黑画布(`color` 虚拟输入),每路 `scale` 到它在快照里的尺寸,
/// 再用 `overlay=x:y` 摆到对应位置 —— 与工作台页面上的画面摆放一致。
/// 做法:每路先 `scale` 到它在快照里的尺寸,再用**一条 `xstack`** 按 `layout=x_y|…`
/// 一次合成(画布不够大就 `pad` 补黑、摆位越界就 `crop` 裁掉)—— 与工作台页面上的画面摆放一致。
///
/// 为什么不用「黑画布 + 逐个 `overlay`」:链式 overlay 在 1080p 上要走 N−1 遍整帧混合,
/// 实测 4 路场景 xstack 快 ~30%(120s 片段:36.3s → 25.2s),输出逐像素一致。
///
/// ⚠️ 踩过的坑:**不要**把每路先 <c>pad</c> 成整张画布再叠加 ——
/// 补边是黑底,叠上去会把下面那路的画面整块盖住(表现是「合成完只剩一个小窗,其余全黑」)。
///
/// 为什么要重新编码:多路叠加没法 `-c:v copy`(要重画每个像素),所以这一步比下载慢,
/// 用 <c>veryfast</c> + <c>crf 23</c> 折中。
/// 为什么要重新编码:多路合成没法 `-c:v copy`(要重画每个像素),所以这一步比下载慢。
/// 编码器由 <see cref="FfmpegVideoEncoder"/> 选:有核显/独显就用硬件编码(`h264_qsv` 等),
/// 没有或跑不起来回落 `libx264 -preset veryfast -crf 23`。
/// </summary>
/// <param name="segments">各路下载好的文件(顺序与 <paramref name="streams"/> 一一对应)</param>
/// <param name="startOffsets">
@ -599,57 +603,92 @@ public sealed class HikPlaybackService : IDisposable
var totalSec = longestSec + Math.Max(maxDelaySec, 0);
var filters = new List<string>();
var layoutParts = new List<string>();
var boxRight = 0;
var boxBottom = 0;
for (var i = 0; i < streams.Count; i++)
{
var stream = streams[i];
var width = stream.Layout.Width > 0 ? stream.Layout.Width : canvasWidth;
var height = stream.Layout.Height > 0 ? stream.Layout.Height : canvasHeight;
var x = Math.Max(stream.Layout.X, 0);
var y = Math.Max(stream.Layout.Y, 0);
// 帧率统一到 25(各路帧率不一样,overlay 会互相等待并对不齐)
filters.Add($"[{i + 1}:v]{TimingFilter(offsets[i])}"
// 帧率统一到 25(各路帧率不一样,合成时会互相等待并对不齐)
filters.Add($"[{i}:v]{TimingFilter(offsets[i])}"
+ $"scale={width}:{height}:force_original_aspect_ratio=decrease,"
+ $"fps=25,format=yuv420p,setsar=1[v{i}]");
layoutParts.Add($"{x}_{y}");
boxRight = Math.Max(boxRight, x + width);
boxBottom = Math.Max(boxBottom, y + height);
}
var current = "[0:v]";
for (var i = 0; i < streams.Count; i++)
{
var label = i == streams.Count - 1 ? "[out]" : $"[c{i}]";
filters.Add($"{current}[v{i}]overlay={streams[i].Layout.X}:{streams[i].Layout.Y}{label}");
current = label;
}
// 一次性合成(`xstack`)替代逐个 `overlay`:
// 4 路 1080p 画布上链式 overlay 要走 3 遍整帧混合,xstack 只做一遍。
// 实测 60s × 4 路:墙钟 24.7s → 16.1s(libx264)、26.5s → 16.5s(qsv),CPU 也降 16%~27%;
// 输出与链式 overlay **逐像素一致**(PSNR inf,含空隙 / 混合尺寸 / 重叠的 z-order)。
filters.Add($"[v0]{(streams.Count > 1 ? string.Concat(Enumerable.Range(1, streams.Count - 1).Select(i => $"[v{i}]")) : string.Empty)}"
+ $"xstack=inputs={streams.Count}:layout={string.Join('|', layoutParts)}:fill=black"
// xstack 的输出只到「矩形并集」那么大:比画布小的补黑,比画布大的裁掉(等价于原来叠在黑画布上)
+ (boxRight < canvasWidth || boxBottom < canvasHeight
? $",pad={canvasWidth}:{canvasHeight}:0:0:black"
: string.Empty)
+ (boxRight > canvasWidth || boxBottom > canvasHeight
? $",crop={canvasWidth}:{canvasHeight}:0:0"
: string.Empty)
+ "[out]");
var args = new List<string>
{
"-hide_banner", "-nostdin", "-loglevel", "error",
// 黑画布当底板(d 与录像时长一致);索引 0,各路视频从 1 开始
"-f", "lavfi", "-i",
$"color=c=black:s={canvasWidth}x{canvasHeight}:r=25:d={totalSec.ToString("0", CultureInfo.InvariantCulture)}",
};
var args = new List<string> { "-hide_banner", "-nostdin", "-loglevel", "error" };
foreach (var segment in segments)
{
args.Add("-i");
args.Add(segment);
}
args.AddRange(new[]
{
"-filter_complex", string.Join(';', filters),
"-map", current,
"-c:v", "libx264", "-preset", "veryfast", "-crf", "23",
"-an", "-movflags", "+faststart",
"-t", totalSec.ToString("0", CultureInfo.InvariantCulture),
"-progress", "pipe:2", "-nostats",
"-y", outputPath,
});
// 编码器:有核显/独显的硬件编码就用(见 FfmpegVideoEncoder),没有就 libx264
var encoder = FfmpegVideoEncoder.Resolve(ffmpeg);
string[] BuildArgs(string name) => args
.Concat(new[] { "-filter_complex", string.Join(';', filters), "-map", "[out]" })
.Concat(FfmpegVideoEncoder.EncoderArgs(name))
.Concat(new[]
{
"-an", "-movflags", "+faststart",
"-t", totalSec.ToString("0", CultureInfo.InvariantCulture),
"-progress", "pipe:2", "-nostats",
"-y", outputPath,
})
.ToArray();
progress?.Report(new PlaybackProgress(0, "正在合并(按工作台布局)…"));
var totalMs = totalSec * 1000;
var exit = await RunAsync(ffmpeg, args.ToArray(),
// 成片是业务交付物:**退出码 0 也不算数**,还得真有像样的文件。
// 少数硬件编码器会「成功退出但没写出来」,不能拿它当成功。
static bool Usable(string path, int exitCode)
{
if (exitCode != 0 || !File.Exists(path)) return false;
return new FileInfo(path).Length >= 16 * 1024;
}
var exit = await RunAsync(ffmpeg, BuildArgs(encoder),
line => ReportProgress(progress, line, totalMs, "合并中"), ct).ConfigureAwait(false);
if (exit != 0 || !File.Exists(outputPath) || new FileInfo(outputPath).Length < 16 * 1024)
// 硬件编码探测过了也可能在长片上翻车(驱动被独占 / 参数组合不支持 / 空输出):
// 直接退回软件编码重来一次,不让用户白等一轮再看到「合并失败」。
if (!Usable(outputPath, exit) && !FfmpegVideoEncoder.IsSoftware(encoder))
{
AppLog.Write($"[playback] 合并用 {encoder} 失败(退出码 {exit}),改用 libx264 重试");
TryDelete(outputPath);
encoder = FfmpegVideoEncoder.Software;
progress?.Report(new PlaybackProgress(0, "正在合并(按工作台布局,软件编码重试)…"));
exit = await RunAsync(ffmpeg, BuildArgs(encoder),
line => ReportProgress(progress, line, totalMs, "合并中"), ct).ConfigureAwait(false);
}
if (!Usable(outputPath, exit))
{
throw new HikException(uint.MaxValue, $"合并失败(ffmpeg 退出码 {exit})");
}

View File

@ -1,7 +1,9 @@
# native\ffmpeg —— 内置 ffmpeg(随安装包一起发)
> **当前内置**:`ffmpeg version 9.0.2-essentials_build`(gyan.dev),100.5 MB,静态单文件,
> 含 `libx264`(合并要重新编码)。安装包里就是这一份,客户机不需要自己装 ffmpeg。
> 含 `libx264`(合并要重新编码),也带 `h264_qsv` / `h264_nvenc` / `h264_amf` 硬件编码器
> (合并时优先用核显/独显编码,见 [../../README.md](../../README.md) 的「合并用的编码器」)。
> 安装包里就是这一份,客户机不需要自己装 ffmpeg。
## 为什么放在这里