packServer/desktop/Services/Hik/HikPlaybackService.cs
liufumingren e8923dbe56 feat(desktop): 多路回放按 OSD 时间对齐,合并时摆回同一时间轴
- 每路下载后读 NET_DVR_GetPlayBackOsdTime 得到真实起播时间,算出相对请求起点的偏移,
  返回 PlaybackClip(Path, StartOffset);合并时按偏移补 -itsoffset,画面不再错位
- 各路都从自己的关键帧起播 → 单路内容多了就裁掉,最后一路固定以收尾时间对齐
- 回放预览改成多路同播:每路独立 FfmpegStream 订阅帧、按第一帧到达时间对齐,
  队列超长时跳到最新帧(追帧),窗口结束即停;去掉「关闭」按钮改由流程自动关闭
- FfmpegStream 支持多订阅者(同一 rtsp 只拉一次),避免多路预览重复解码

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-10-21 00:47:43 +08:00

812 lines
37 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
namespace YuncangTrace.LocalService.Services.Hik;
/// <summary>一次「这个时段到底有没有录像」的探测结果</summary>
/// <param name="HasRecord">拉到数据 = 有录像</param>
/// <param name="Frames">RTSP 模式下解出的帧数(SDK 模式为 -1)</param>
/// <param name="LogicalChannel">换算出来的 RTSP 1 起通道序号(排查用)</param>
/// <param name="Error">失败原因(无录像 / 端口不通 / 密码错)</param>
/// <param name="Source">实际走通的通道:SDK(8000)/ RTSP(554)</param>
public sealed record PlaybackCheck(bool HasRecord, int Frames, int LogicalChannel, string? Error, string Source = "");
/// <summary>下载一路回放的进度</summary>
/// <param name="Percent">0~1(拿不到总时长时为 null,界面显示为不确定进度)</param>
/// <param name="Message">当前状态文案</param>
public sealed record PlaybackProgress(double? Percent, string Message);
/// <summary>下载好的一路回放</summary>
/// <param name="Path">落地文件(mp4;转封装失败时是 .ts/.ps)</param>
/// <param name="StartOffset">
/// 这一路**真实起点**相对请求时间的偏移(零 = 不知道 / 正好对齐)。
/// 多路合并要按它把各路摆回同一时间轴,否则各路的第一个关键帧不一样,画面就错开了。
/// </param>
public sealed record PlaybackClip(string Path, TimeSpan StartOffset);
/// <summary>
/// 海康 **按时间回放**:校验有没有录像 / 拉流预览 / 下载成 mp4
///
/// 两条通道,**优先 8000(SDK 私有协议),不行再走 554(RTSP)**:
///
/// | | SDK(`NET_DVR_GetFileByTime_V40`) | RTSP(`Streaming/tracks/...`) |
/// | --- | --- | --- |
/// | 端口 | 8000(现场基本都开) | 554(可能关/改端口) |
/// | 通道号 | **海康通道号**(34) | **RTSP 序号**(2) |
/// | 落地 | 设备原始封装 PS,需 ffmpeg 转封装 | 直接交给 ffmpeg |
/// | 速度 | 2~5x 实时,带百分比进度 | 约 0.5~3x,靠 ffmpeg 进度 |
///
/// 实测(本项目 NVR):RTSP 的 `tracks/201`(=通道34)能拉到回放,
/// `tracks/3401` 直接 400;空时段会返回 400 而不是空流 —— 两个信号都能用来判「有/无回放」。
/// </summary>
public sealed class HikPlaybackService : IDisposable
{
/// <summary>Hikvision RTSP 默认端口(设备侧可改,用环境变量覆盖)</summary>
private static readonly int RtspPort = ResolveRtspPort();
private static readonly Regex FrameRegex = new(@"frame=\s*(\d+)", RegexOptions.Compiled);
private static readonly Regex OutTimeRegex = new(@"out_time_us=(\d+)", RegexOptions.Compiled);
private static readonly Regex SpeedRegex = new(@"speed=\s*([\d.]+)x", RegexOptions.Compiled);
/// <summary>RTSP socket 读超时(微秒)。回放拉完设备不再推流,靠它让 ffmpeg 收尾退出</summary>
private const string SocketTimeoutUs = "5000000";
private readonly HikDeviceService _device;
/// <summary>
/// 「这台设备的 8000 下载能不能用」缓存(key = host|port|channel)
///
/// 实测:有些固件 <c>NET_DVR_GetFileByTime*</c> 直接不工作(返回句柄但 0 字节),
/// 每路都去试一遍要多等好几秒 → 试过一次就记住,下次直接走 RTSP。
/// </summary>
private readonly ConcurrentDictionary<string, bool> _sdkPlayback = new(StringComparer.OrdinalIgnoreCase);
/// <summary>
/// 「录像机时间 - 本机时间」偏差缓存(key = host|port|user)
///
/// 扫码时间是**本机时钟**打的,回放是按**录像机本地时间**定位的;两边不一致时
/// (现场实测本机慢了 9 秒),短回放窗口会把面单直接截掉。
/// 以录像机时钟为基准做平移,缓存 10 分钟(读不到设备时间时 1 分钟内不重试)。
/// </summary>
private readonly ConcurrentDictionary<string, (TimeSpan Offset, long At, long Ttl)> _clockOffsets =
new(StringComparer.OrdinalIgnoreCase);
private const long ClockOffsetTtlMs = 10 * 60 * 1000;
private const long ClockOffsetFailTtlMs = 60 * 1000;
/// <summary>
/// 「首个数字通道号」缓存(key = host|port|user)
///
/// 每换算一路通道号都要问一次设备;多路回放时逐路问会让**后开的流晚好几秒**,
/// 几路画面就错开了(现场反馈的"两个流加载速度不一样"就是这个)。
/// </summary>
private readonly ConcurrentDictionary<string, (int StartDigital, long At)> _startDigital =
new(StringComparer.OrdinalIgnoreCase);
private const long StartDigitalTtlMs = 30 * 60 * 1000;
public HikPlaybackService(HikDeviceService device)
{
_device = device;
}
/// <summary>ffmpeg 是否可用(没有就既不能校验也不能下载)</summary>
public bool Available => HikFfmpegService.ResolveFfmpeg() is not null;
// ==================== 通道号换算 ====================
/// <summary>
/// 海康通道号 → RTSP 的 1 起序号
///
/// 换算依赖设备的「首个数字通道号」(本项目是 33):
/// <c>logical = channel - startDigital + 1</c>。SDK 不可用时按 33 兜底。
/// </summary>
public int LogicalChannel(string host, int port, string userName, string password, int channel)
{
var startDigital = StartDigitalChannel(host, port, userName, password);
var logical = channel - startDigital + 1;
return logical > 0 ? logical : channel;
}
/// <summary>设备的「首个数字通道号」(带缓存:多路回放时不用每路都问一次设备)</summary>
private int StartDigitalChannel(string host, int port, string userName, string password)
{
var key = $"{host}|{port}|{userName}";
if (_startDigital.TryGetValue(key, out var hit) && Environment.TickCount64 - hit.At < StartDigitalTtlMs)
{
return hit.StartDigital;
}
var startDigital = 33;
try
{
var start = _device.GetStartDigitalChannel(host, port, userName, password);
if (start > 0) startDigital = start;
}
catch (Exception ex)
{
AppLog.Write($"[playback] 取起始数字通道号失败,按 {startDigital} 兜底:{ex.Message}");
}
_startDigital[key] = (startDigital, Environment.TickCount64);
return startDigital;
}
/// <summary>
/// 生成回放 RTSP 地址
///
/// ⚠️ **时间语义实测结论(重要)**:海康 RTSP 的 <c>starttime</c> 按**设备本地时间**解析,
/// 结尾那个 <c>Z</c> 只是格式后缀、**不代表 UTC**。
/// 实测同一时间点:
/// - 传 <c>20261018T131550Z</c>(UTC 写法)→ 画面 OSD 是 **13:15:49**(2号工作台,无任务)
/// - 传 <c>20261018T211550Z</c>(本地写法)→ 画面 OSD 是 **21:15:49**(1号工作台,波次B…)
/// 也就是按 UTC 传会整整差一个时区(本机 +08:00 差 8 小时)。
///
/// 默认按本地时间拼;万一遇到严格按 UTC 解析的固件,用环境变量 <c>YUNCANG_RTSP_TIME=utc</c> 切回去。
/// </summary>
/// <param name="streamType">0 主码流 / 1 子码流(回放路径里是 01 / 02)</param>
public static string BuildRtspUrl(string host, string userName, string password, int logicalChannel,
DateTimeOffset start, DateTimeOffset end, int streamType = 0, int rtspPort = 0)
{
var port = rtspPort > 0 ? rtspPort : RtspPort;
var startText = FormatTime(start);
var endText = FormatTime(end);
var streamNo = streamType == 1 ? "02" : "01";
return $"rtsp://{Uri.EscapeDataString(userName)}:{Uri.EscapeDataString(password)}@{host}:{port}"
+ $"/Streaming/tracks/{logicalChannel}{streamNo}?starttime={startText}&endtime={endText}";
}
private static string FormatTime(DateTimeOffset value)
{
var useUtc = string.Equals(Environment.GetEnvironmentVariable("YUNCANG_RTSP_TIME"), "utc",
StringComparison.OrdinalIgnoreCase);
var time = useUtc ? value.UtcDateTime : value.ToLocalTime().DateTime;
return time.ToString("yyyyMMdd'T'HHmmss'Z'", CultureInfo.InvariantCulture);
}
/// <summary>
/// 录像机时钟与本机时钟的偏差(设备 - 本机,秒)。
///
/// 扫码时间来自本机时钟,回放定位用设备时间 → 两者必须在同一条时间轴上。
/// 读不到设备时间 / 设备不支持该命令时返回零(保持原有行为)。
/// </summary>
public TimeSpan ClockOffset(string host, int port, string userName, string password)
{
var key = $"{host}|{port}|{userName}";
if (_clockOffsets.TryGetValue(key, out var hit) && Environment.TickCount64 - hit.At < hit.Ttl)
{
return hit.Offset;
}
try
{
var before = DateTime.Now;
var device = _device.GetDeviceTime(host, port, userName, password);
var after = DateTime.Now;
// 取请求中点做本机时间,抵消一次往返的一半延迟
var local = before.AddTicks((after - before).Ticks / 2);
var offset = device - local;
_clockOffsets[key] = (offset, Environment.TickCount64, ClockOffsetTtlMs);
AppLog.Write($"[playback] 录像机 {host}:{port} 与本机时钟相差 {offset.TotalSeconds:+0.0;-0.0} 秒,回放时间已按录像机时钟对齐");
// 差到半小时以上基本不可能是「时钟没校准」,而是时区不一致:
// 这时回放时间会整体平移一个时区,画面 OSD 也会跟着对不上。
if (Math.Abs(offset.TotalMinutes) >= 30)
{
AppLog.Write($"[playback] ⚠ 差值达 {offset.TotalHours:+0.0;-0.0} 小时,疑似录像机时区与本机不一致"
+ "(请在录像机里把时区设为东八区,并检查摄像头是否跟随了错误的校时)");
}
return offset;
}
catch (Exception ex)
{
_clockOffsets[key] = (TimeSpan.Zero, Environment.TickCount64, ClockOffsetFailTtlMs);
AppLog.Write($"[playback] 读不到录像机时间(按本机时钟处理):{ex.Message}");
return TimeSpan.Zero;
}
}
/// <summary>生成回放 RTSP 地址(自动把本机时间平移成录像机时间)</summary>
public string BuildRtspUrlFor(string host, int port, string userName, string password,
int logicalChannel, DateTimeOffset start, DateTimeOffset end, int streamType = 0)
{
var offset = ClockOffset(host, port, userName, password);
return BuildRtspUrl(host, userName, password, logicalChannel,
start.Add(offset), end.Add(offset), streamType);
}
// ==================== ① 校验有没有录像 ====================
/// <summary>
/// 探测该时段有没有录像
///
/// **先走 8000(SDK 下载 2 秒到临时文件,看有没有数据)**,不行再走 RTSP 拉 2 秒看帧。
/// 设备不会主动告诉你空段,只能真拉一次。
/// </summary>
public async Task<PlaybackCheck> CheckAsync(string host, int port, string userName, string password,
int channel, DateTimeOffset start, DateTimeOffset end, CancellationToken ct = default)
{
if (end <= start) return new PlaybackCheck(false, 0, 0, "回放区间为空");
// 扫码时间是本机时钟 → 平移成录像机时间,否则时钟偏差会把面单挤出回放窗口
var clock = ClockOffset(host, port, userName, password);
start = start.Add(clock);
end = end.Add(clock);
var sdkKey = $"{host}|{port}|{channel}|pb";
var trySdk = !_sdkPlayback.TryGetValue(sdkKey, out var capable) || capable;
// ① SDK(8000 私有协议):**全速推送**,实测 14 MB/s(≈17 倍速)
var probeEnd = start.AddSeconds(Math.Min(2, Math.Max((end - start).TotalSeconds, 1)));
var probeFile = Path.Combine(Path.GetTempPath(), $"yc_probe_{Guid.NewGuid():N}.ps");
if (trySdk)
{
try
{
var bytes = await Task.Run(() => _device.PullPlaybackToFile(host, port, userName, password,
channel, start.LocalDateTime, probeEnd.LocalDateTime, probeFile, out _, null, ct), ct)
.ConfigureAwait(false);
AppLog.Write($"[playback] SDK 探测 {host} 通道{channel}:{bytes} 字节");
if (bytes > 16 * 1024)
{
_sdkPlayback[sdkKey] = true;
return new PlaybackCheck(true, -1, LogicalChannel(host, port, userName, password, channel),
null, "SDK");
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
_sdkPlayback[sdkKey] = false;
AppLog.Write($"[playback] SDK 探测失败({ex.Message}),本设备后续直接走 RTSP");
}
finally
{
TryDelete(probeFile);
}
}
// ② RTSP 回落
var ffmpeg = HikFfmpegService.ResolveFfmpeg()
?? throw new HikException(uint.MaxValue, "未找到 ffmpeg,无法校验回放(安装目录 native\\ffmpeg\\ffmpeg.exe 缺失,建议重新安装本软件)");
var logical = LogicalChannel(host, port, userName, password, channel);
var url = BuildRtspUrl(host, userName, password, logical, start, end);
var seconds = Math.Clamp((end - start).TotalSeconds, 0.5, 2.0);
var args = new[]
{
"-hide_banner", "-nostdin", "-loglevel", "error",
"-rtsp_transport", "tcp", "-timeout", SocketTimeoutUs,
"-i", url,
"-t", seconds.ToString("0.#", CultureInfo.InvariantCulture),
"-an", "-f", "null",
// ⚠️ 靠 -progress 才能拿到 frame=:ffmpeg 的统计行是 info 级别,
// 用 -loglevel error 时根本不会打印(曾经因此把所有时段误判成「无录像」)
"-progress", "pipe:2", "-nostats",
"-",
};
var output = new StringBuilder();
var exit = await RunAsync(ffmpeg, args, line => { lock (output) output.AppendLine(line); }, ct)
.ConfigureAwait(false);
string text;
lock (output) text = output.ToString();
var match = FrameRegex.Match(text);
var frames = match.Success && int.TryParse(match.Groups[1].Value, out var count) ? count : 0;
if (frames > 0) return new PlaybackCheck(true, frames, logical, null, "RTSP");
var error = Summarize(text) ?? (exit == 0 ? "该时段没有录像" : $"ffmpeg 退出码 {exit}");
return new PlaybackCheck(false, 0, logical, error, "RTSP");
}
// ==================== ② 下载成 mp4 ====================
/// <summary>
/// 下载一路回放到文件
///
/// 实测出来的两个坑(本项目 NVR):
/// 1. **回放流不会按 endtime 自己断**:ffmpeg 拉完数据还挂在 RTSP 读上,进程不退出 →
/// 必须加 <c>-timeout</c>(socket I/O 超时)オ能让它正常收尾;
/// 2. **不能直接写 mp4**:流没正常结束就不会写 moov atom,文件无法播放(moov atom not found)。
/// 所以先写 <c>mpegts</c>(流式容器,中途中断也能播),完成后本地转封装成 mp4。
///
/// 回放速度实测约 0.5x~3x(跟码流大小有关),所以**必须显示进度、必须能取消**。
/// </summary>
/// <returns>落地文件 + 这一路的真实起点(相对请求时间;测不到就是零)</returns>
public async Task<PlaybackClip> DownloadAsync(string host, int port, string userName, string password,
int channel, DateTimeOffset start, DateTimeOffset end, string outputPath,
IProgress<PlaybackProgress>? progress = null, CancellationToken ct = default)
{
var ffmpeg = HikFfmpegService.ResolveFfmpeg()
?? throw new HikException(uint.MaxValue, "未找到 ffmpeg,无法下载录像(安装目录 native\\ffmpeg\\ffmpeg.exe 缺失,建议重新安装本软件)");
if (end <= start) throw new HikException(uint.MaxValue, "回放区间为空");
// 扫码时间是本机时钟 → 平移成录像机时间(见 CheckAsync 的说明)
var clock = ClockOffset(host, port, userName, password);
start = start.Add(clock);
end = end.Add(clock);
Directory.CreateDirectory(Path.GetDirectoryName(outputPath) ?? AppContext.BaseDirectory);
// ① 优先 SDK(8000 私有协议),但**只在它被证明可用时**;
// 实测部分固件(本项目这台 NVR)GetFileByTime 返回句柄却不推数据 → 试一次就永久回落 RTSP。
var sdkKey = $"{host}|{port}|{channel}|pb";
if (!_sdkPlayback.TryGetValue(sdkKey, out var sdkCapable) || sdkCapable)
{
var tempPs = Path.Combine(Path.GetTempPath(), $"yc_pb_{Guid.NewGuid():N}.ps");
try
{
progress?.Report(new PlaybackProgress(0, "下载中(8000 全速)…"));
DateTime? osdStart = null;
var bytes = await Task.Run(() => _device.PullPlaybackToFile(host, port, userName, password, channel,
start.LocalDateTime, end.LocalDateTime, tempPs, out osdStart,
received => progress?.Report(new PlaybackProgress(null,
$"下载中(8000 全速){received / 1024.0 / 1024.0:0.0} MB")), ct), ct)
.ConfigureAwait(false);
AppLog.Write($"[playback] SDK 拉流完成:{bytes} 字节");
if (bytes > 16 * 1024)
{
_sdkPlayback[sdkKey] = true;
progress?.Report(new PlaybackProgress(0.99, "正在封装成 mp4…"));
if (await RepackAsync(ffmpeg, tempPs, outputPath, ct).ConfigureAwait(false))
{
var okSize = new FileInfo(outputPath).Length;
progress?.Report(new PlaybackProgress(1, $"下载完成({Math.Round(okSize / 1024.0 / 1024.0, 1)} MB)"));
AppLog.Write($"[playback] 回放已下载:{outputPath}({okSize} 字节)");
// ⚠️ 读不到 OSD 就**按原样合并**:时长反推实测不可靠(同一窗口两次 36.1s/42.1s),
// 硬套只会让偏差更大(现场反馈"还不如直接合并")
var offset = OffsetFromOsd(osdStart, start.LocalDateTime, channel) ?? TimeSpan.Zero;
return new PlaybackClip(outputPath, offset);
}
// mp4 封装不了 → 把设备原始 PS 留下(PotPlayer/VLC 能直接播)
var psPath = outputPath + ".ps";
if (File.Exists(psPath)) File.Delete(psPath);
File.Move(tempPs, psPath);
progress?.Report(new PlaybackProgress(1, "下载完成(原始封装 .ps)"));
AppLog.Write($"[playback] 封装失败,保留原始录像:{psPath}");
var psOffset = OffsetFromOsd(osdStart, start.LocalDateTime, channel) ?? TimeSpan.Zero;
return new PlaybackClip(psPath, psOffset);
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
_sdkPlayback[sdkKey] = false;
AppLog.Write($"[playback] SDK 下载失败({ex.Message}),本设备后续直接走 RTSP 554");
}
finally
{
TryDelete(tempPs);
}
}
var logical = LogicalChannel(host, port, userName, password, channel);
var url = BuildRtspUrl(host, userName, password, logical, start, end);
var totalMs = Math.Max((end - start).TotalMilliseconds, 1);
var totalSec = Math.Max((end - start).TotalSeconds, 1);
Directory.CreateDirectory(Path.GetDirectoryName(outputPath) ?? AppContext.BaseDirectory);
var tsPath = Path.ChangeExtension(outputPath, ".ts");
if (File.Exists(tsPath)) File.Delete(tsPath);
progress?.Report(new PlaybackProgress(0, "开始下载…"));
// ① 拉流存 ts(流式容器,中途取消也能播)
var pullArgs = new[]
{
"-hide_banner", "-nostdin", "-loglevel", "error",
"-rtsp_transport", "tcp", "-timeout", SocketTimeoutUs,
"-i", url,
"-t", (totalSec + 1).ToString("0", CultureInfo.InvariantCulture),
"-c:v", "copy", "-an", "-f", "mpegts",
"-progress", "pipe:2", "-nostats",
"-y", tsPath,
};
var exit = await RunAsync(ffmpeg, pullArgs,
line => ReportProgress(progress, line, totalMs, "下载中"), ct).ConfigureAwait(false);
var size = File.Exists(tsPath) ? new FileInfo(tsPath).Length : 0;
if (!File.Exists(tsPath) || size < 16 * 1024)
{
throw new HikException(uint.MaxValue,
exit == 0 ? "该时段没有拉到录像数据" : $"下载失败(ffmpeg 退出码 {exit})");
}
// ② 转封装成 mp4(本地操作,很快;失败就保留 ts)
progress?.Report(new PlaybackProgress(0.99, "正在封装成 mp4…"));
if (File.Exists(outputPath)) File.Delete(outputPath);
var convertArgs = new[]
{
"-hide_banner", "-nostdin", "-loglevel", "error",
"-i", tsPath,
"-c:v", "copy", "-an", "-movflags", "+faststart",
"-y", outputPath,
};
var convertExit = await RunAsync(ffmpeg, convertArgs, null, ct).ConfigureAwait(false);
var result = outputPath;
if (convertExit != 0 || !File.Exists(outputPath) || new FileInfo(outputPath).Length < 16 * 1024)
{
// mp4 封装不了(极少见)→ 保留 ts,也能直接播
AppLog.Write($"[playback] mp4 封装失败(exit={convertExit}),保留 ts:{tsPath}");
result = tsPath;
}
else
{
File.Delete(tsPath);
}
var finalSize = new FileInfo(result).Length;
progress?.Report(new PlaybackProgress(1, $"下载完成({Math.Round(finalSize / 1024.0 / 1024.0, 1)} MB)"));
AppLog.Write($"[playback] 回放已下载:{result}({finalSize} 字节)");
// RTSP 回放拿不到真实起点(设备按关键帧推流,前后差 1~2 秒),按请求时间算
return new PlaybackClip(result, TimeSpan.Zero);
}
/// <summary>
/// 探这一路在 <paramref name="start"/> 时刻的第一帧真实时间(设备本地时间)。
///
/// 回放预览走 RTSP 实时推流,主机侧拿不到"帧对应哪一秒";用 8000 协议开个小回放读一次
/// <c>NET_DVR_GetPlayBackOsdTime</c> 即可,几路按差值推迟出图就能对齐内容。
/// </summary>
public DateTime? ProbePlaybackStartOsd(NvrCredential credential, int channel, DateTimeOffset start)
{
var clock = ClockOffset(credential.Host, credential.Port, credential.Username, credential.Password);
return _device.ProbePlaybackOsdStart(credential.Host, credential.Port,
credential.Username, credential.Password, channel, start.Add(clock).LocalDateTime);
}
/// <summary>
/// 用**第一帧的 OSD 时间**算真实起点偏移(首选方案,精确到秒)
///
/// <c>NET_DVR_GetPlayBackOsdTime</c> 给的是录像内容时间(设备本地时间),
/// 和请求时间的差就是这一路真实晚了/早了多少。拿不到或读数离谱时返回 null,
/// 由调用方退回「时长反推」。
/// </summary>
private static TimeSpan? OffsetFromOsd(DateTime? osdStart, DateTime requestedDeviceStart, int channel)
{
if (osdStart is null) return null;
var offset = osdStart.Value - requestedDeviceStart;
if (Math.Abs(offset.TotalSeconds) > 60)
{
AppLog.Write($"[playback] 通道{channel} OSD 时间 {osdStart:HH:mm:ss} 与请求时间差 "
+ $"{offset.TotalSeconds:0.0} 秒(过大,疑似通道时钟不准),改用时长反推");
return null;
}
AppLog.Write($"[playback] 通道{channel} 首帧 OSD={osdStart.Value:HH:mm:ss},"
+ $"比请求时间{(offset < TimeSpan.Zero ? "早" : "晚")} {Math.Abs(offset.TotalSeconds):0.0} 秒");
return offset;
}
// ==================== ③ 按工作台布局合并成一个视频 ====================
/// <summary>
/// 把多路下载好的片段**按工作台画布布局合并成一个视频**
///
/// 做法:先铺一张黑画布(`color` 虚拟输入),每路 `scale` 到它在快照里的尺寸,
/// 再用 `overlay=x:y` 摆到对应位置 —— 与工作台页面上的画面摆放一致。
///
/// ⚠️ 踩过的坑:**不要**把每路先 <c>pad</c> 成整张画布再叠加 ——
/// 补边是黑底,叠上去会把下面那路的画面整块盖住(表现是「合成完只剩一个小窗,其余全黑」)。
///
/// 为什么要重新编码:多路叠加没法 `-c:v copy`(要重画每个像素),所以这一步比下载慢,
/// 用 <c>veryfast</c> + <c>crf 23</c> 折中。
/// </summary>
/// <param name="segments">各路下载好的文件(顺序与 <paramref name="streams"/> 一一对应)</param>
/// <param name="startOffsets">
/// 每路真实起点相对请求时间的偏移(见 <see cref="PlaybackClip.StartOffset"/>,null/缺项 = 不偏移)。
/// 各路是**从各自的关键帧**开始录的,不按这个差值把时间轴错开,合并后两格会差 1~2 秒。
/// </param>
/// <returns>合并后文件路径</returns>
public async Task<string> ComposeAsync(IReadOnlyList<string> segments, IReadOnlyList<PackStream> streams,
string outputPath, IReadOnlyList<TimeSpan>? startOffsets = null,
IProgress<PlaybackProgress>? progress = null, CancellationToken ct = default)
{
if (segments.Count == 0) throw new HikException(uint.MaxValue, "没有可合并的片段");
if (segments.Count != streams.Count) throw new HikException(uint.MaxValue, "片段数与流数量不一致");
var ffmpeg = HikFfmpegService.ResolveFfmpeg()
?? throw new HikException(uint.MaxValue, "未找到 ffmpeg,无法合并视频(安装目录 native\\ffmpeg\\ffmpeg.exe 缺失,建议重新安装本软件)");
if (segments.Count == 1)
{
if (!string.Equals(segments[0], outputPath, StringComparison.OrdinalIgnoreCase))
{
if (File.Exists(outputPath)) File.Delete(outputPath);
File.Copy(segments[0], outputPath);
}
return outputPath;
}
var canvasWidth = streams.Max(item => item.CanvasWidth) > 0
? streams.Max(item => item.CanvasWidth)
: 1920;
var canvasHeight = streams.Max(item => item.CanvasHeight) > 0
? streams.Max(item => item.CanvasHeight)
: 1080;
// 各路真实起点不同(各自从关键帧开始):按偏移把时间轴摆回同一时刻
var offsets = new double[segments.Count];
for (var i = 0; i < offsets.Length; i++)
{
var offset = startOffsets is not null && i < startOffsets.Count ? startOffsets[i] : TimeSpan.Zero;
offsets[i] = Math.Abs(offset.TotalSeconds) <= 15 ? offset.TotalSeconds : 0;
}
var maxDelaySec = offsets.Length > 0 ? offsets.Max() : 0;
// 输出要多留出「最晚开始」那一段,否则起点最晚的那路结尾会被切掉
var totalSec = Math.Max((streams[0].EndTime - streams[0].StartTime).TotalSeconds, 1)
+ Math.Max(maxDelaySec, 0);
var filters = new List<string>();
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;
// 帧率统一到 25(各路帧率不一样,overlay 会互相等待并对不齐)
filters.Add($"[{i + 1}:v]{TimingFilter(offsets[i])}"
+ $"scale={width}:{height}:force_original_aspect_ratio=decrease,"
+ $"fps=25,format=yuv420p,setsar=1[v{i}]");
}
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;
}
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)}",
};
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,
});
progress?.Report(new PlaybackProgress(0, "正在合并(按工作台布局)…"));
var totalMs = totalSec * 1000;
var exit = await RunAsync(ffmpeg, args.ToArray(),
line => ReportProgress(progress, line, totalMs, "合并中"), ct).ConfigureAwait(false);
if (exit != 0 || !File.Exists(outputPath) || new FileInfo(outputPath).Length < 16 * 1024)
{
throw new HikException(uint.MaxValue, $"合并失败(ffmpeg 退出码 {exit})");
}
var size = new FileInfo(outputPath).Length;
progress?.Report(new PlaybackProgress(1, $"合并完成({Math.Round(size / 1024.0 / 1024.0, 1)} MB)"));
AppLog.Write($"[playback] 已合并 {segments.Count} 路 → {outputPath}({size} 字节)");
return outputPath;
}
// ==================== 内部 ====================
/// <summary>
/// 按起点偏移给这一路做时间轴校正(拼在滤镜链最前面)
///
/// - 起点比请求**早**(offset &lt; 0):`trim` 掉多出来的那一段,再归零
/// - 起点比请求**晚**(offset &gt; 0):整体后移,前面那段留黑底
/// - 基本对齐(|offset| &lt; 50ms):什么都不做
/// </summary>
private static string TimingFilter(double offset)
{
if (Math.Abs(offset) < 0.05) return string.Empty;
var seconds = Math.Abs(offset).ToString("0.###", CultureInfo.InvariantCulture);
return offset < 0
? $"trim=start={seconds},setpts=PTS-STARTPTS,"
: $"setpts=PTS-STARTPTS+{seconds}/TB,";
}
/// <summary>把设备原始录像(PS)转封装成 mp4;失败返回 false</summary>
private async Task<bool> RepackAsync(string ffmpeg, string input, string outputPath, CancellationToken ct)
{
if (File.Exists(outputPath)) File.Delete(outputPath);
var args = new[]
{
"-hide_banner", "-nostdin", "-loglevel", "error",
"-i", input,
"-c:v", "copy", "-an", "-movflags", "+faststart",
"-y", outputPath,
};
var exit = await RunAsync(ffmpeg, args, null, ct).ConfigureAwait(false);
if (exit == 0 && File.Exists(outputPath) && new FileInfo(outputPath).Length > 16 * 1024) return true;
// 复制失败(PS 里码流不规范)→ 转码兜底
AppLog.Write($"[playback] 转封装失败(exit={exit}),改用转码");
if (File.Exists(outputPath)) File.Delete(outputPath);
var transcode = new[]
{
"-hide_banner", "-nostdin", "-loglevel", "error",
"-i", input,
"-c:v", "libx264", "-preset", "veryfast", "-crf", "23",
"-an", "-movflags", "+faststart",
"-y", outputPath,
};
exit = await RunAsync(ffmpeg, transcode, null, ct).ConfigureAwait(false);
return exit == 0 && File.Exists(outputPath) && new FileInfo(outputPath).Length > 16 * 1024;
}
private static void TryDelete(string path)
{
try
{
if (File.Exists(path)) File.Delete(path);
}
catch
{
// 临时文件删不掉不影响业务
}
}
/// <summary>
/// 跑一次 ffmpeg:stderr 逐行回调(进度/错误都在 stderr)
/// </summary>
private async Task<int> RunAsync(string ffmpeg, string[] args, Action<string>? onLine, CancellationToken ct)
{
var psi = new ProcessStartInfo
{
FileName = ffmpeg,
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
RedirectStandardInput = false,
};
foreach (var arg in args) psi.ArgumentList.Add(arg);
using var process = new Process { StartInfo = psi, EnableRaisingEvents = true };
process.ErrorDataReceived += (_, e) => { if (e.Data is not null) onLine?.Invoke(e.Data); };
process.OutputDataReceived += (_, e) => { if (e.Data is not null) onLine?.Invoke(e.Data); };
process.Start();
process.BeginErrorReadLine();
process.BeginOutputReadLine();
try
{
await process.WaitForExitAsync(ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
TryKill(process);
throw;
}
return process.ExitCode;
}
private static void TryKill(Process process)
{
try
{
if (!process.HasExited) process.Kill(entireProcessTree: true);
}
catch
{
// 进程已经退了
}
}
/// <summary>解析 `<c>-progress</c>` 的 `out_time_us=`,算百分比</summary>
private static void ReportProgress(IProgress<PlaybackProgress>? progress, string line, double totalMs, string label)
{
if (progress is null) return;
var time = OutTimeRegex.Match(line);
if (time.Success && long.TryParse(time.Groups[1].Value, out var micro))
{
var doneMs = micro / 1000.0;
var percent = Math.Clamp(doneMs / totalMs, 0, 0.999);
var speed = SpeedRegex.Match(line);
var suffix = speed.Success ? $" · {speed.Groups[1].Value}x" : string.Empty;
progress.Report(new PlaybackProgress(percent, $"{label} {percent:P0}{suffix}"));
}
}
/// <summary>把 ffmpeg 的输出压成一句能看懂的错因</summary>
private static string? Summarize(string output)
{
foreach (var line in output.Split('\n', StringSplitOptions.RemoveEmptyEntries))
{
var text = line.Trim();
if (text.Length == 0) continue;
if (text.Contains("401", StringComparison.Ordinal) || text.Contains("Unauthorized", StringComparison.OrdinalIgnoreCase))
return "录像机拒绝访问(账号/密码错)";
if (text.Contains("400 Bad Request", StringComparison.OrdinalIgnoreCase))
return "该时段没有录像(RTSP 返回 400)";
if (text.Contains("404", StringComparison.Ordinal) || text.Contains("Not Found", StringComparison.OrdinalIgnoreCase))
return "该通道/时段没有录像(RTSP 404)";
if (text.Contains("Connection refused", StringComparison.OrdinalIgnoreCase))
return "连不上录像机的 RTSP 端口(554)";
if (text.Contains("timed out", StringComparison.OrdinalIgnoreCase))
return "连接录像机超时";
if (line.StartsWith("Error", StringComparison.OrdinalIgnoreCase) || text.StartsWith("rtsp:", StringComparison.OrdinalIgnoreCase))
return text.Length > 160 ? text[..160] : text;
}
return null;
}
private static int ResolveRtspPort()
{
return int.TryParse(Environment.GetEnvironmentVariable("YUNCANG_RTSP_PORT"), out var port) && port > 0
? port
: 554;
}
public void Dispose()
{
// 后台任务由调用方各自取消;这里没有需要释放的资源
}
}