feat(desktop): 多路回放按 OSD 时间对齐,合并时摆回同一时间轴

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

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
liufumingren 2026-10-21 00:47:43 +08:00
parent e5a6558eb5
commit e8923dbe56
8 changed files with 597 additions and 72 deletions

View File

@ -1231,7 +1231,7 @@ public partial class MainWindow : Window
// 限 2 是给 NVR 留余量(同时开太多回放连接会互相抢带宽)。
const int maxParallel = 2;
var gate = new SemaphoreSlim(maxParallel);
var saved = new string?[streams.Count];
var saved = new PlaybackClip?[streams.Count];
var tasks = new List<Task>();
void UpdateLine(int slot, string text) => Dispatcher.Invoke(() =>
@ -1269,7 +1269,7 @@ public partial class MainWindow : Window
stream.StartTime, stream.EndTime, path, progress, ct).ConfigureAwait(false);
saved[slot] = file;
UpdateLine(slot, $"第 {slot + 1}/{streams.Count} 路:{stream.DisplayName} ✓ {file}");
UpdateLine(slot, $"第 {slot + 1}/{streams.Count} 路:{stream.DisplayName} ✓ {file.Path}");
}
catch (OperationCanceledException)
{
@ -1289,10 +1289,10 @@ public partial class MainWindow : Window
await Task.WhenAll(tasks).ConfigureAwait(true);
// 保持与 streams 一一对应(失败的那路不参与合并)
var done = new List<(PackStream Stream, string Path)>();
var done = new List<(PackStream Stream, PlaybackClip Clip)>();
for (var i = 0; i < streams.Count; i++)
{
if (saved[i] is { } file) done.Add((streams[i], file));
if (saved[i] is { } clip) done.Add((streams[i], clip));
}
if (done.Count > 0)
@ -1314,9 +1314,10 @@ public partial class MainWindow : Window
}
else
{
var target = Path.Combine(folder, Path.GetFileName(done[0].Path));
var single = done[0].Clip.Path;
var target = Path.Combine(folder, Path.GetFileName(single));
if (File.Exists(target)) File.Delete(target);
File.Move(done[0].Path, target);
File.Move(single, target);
_lastOutputFolder = folder;
OpenFolderButton.Visibility = Visibility.Visible;
@ -1341,10 +1342,11 @@ public partial class MainWindow : Window
}
/// <summary>合并失败时把片段从临时目录搬到用户目录(不丢数据),再清临时目录</summary>
private void MoveSegmentsOut(List<(PackStream Stream, string Path)> done, string folder, string workDir)
private void MoveSegmentsOut(List<(PackStream Stream, PlaybackClip Clip)> done, string folder, string workDir)
{
foreach (var (_, path) in done)
foreach (var (_, clip) in done)
{
var path = clip.Path;
try
{
var target = Path.Combine(folder, Path.GetFileName(path));
@ -1385,7 +1387,7 @@ public partial class MainWindow : Window
///
/// 合并成功 → 删临时目录里各路段;失败 → 把片段搬到 <paramref name="folder"/> 保住数据。
/// </summary>
private async Task<bool> ComposeAsync(PackQuery query, List<(PackStream Stream, string Path)> done,
private async Task<bool> ComposeAsync(PackQuery query, List<(PackStream Stream, PlaybackClip Clip)> done,
string output, string workDir)
{
var merged = new List<string>();
@ -1394,10 +1396,13 @@ public partial class MainWindow : Window
var progress = new Progress<PlaybackProgress>(p =>
ShowPlayback(string.Join(Environment.NewLine, merged) + Environment.NewLine + p.Message));
// 各路真实起点不同(都从自己的关键帧开始)→ 按偏移摆回同一时间轴
var path = await _playback.ComposeAsync(
done.Select(item => item.Path).ToList(),
done.Select(item => item.Clip.Path).ToList(),
done.Select(item => item.Stream).ToList(),
output, progress, CancellationToken.None);
output,
done.Select(item => item.Clip.StartOffset).ToList(),
progress, CancellationToken.None);
merged.Add($"合并完成:{path}");
return true;

View File

@ -704,11 +704,22 @@ public sealed class HikDeviceService : IDisposable
/// - ⚠️ <c>NET_DVR_GetFileByTime*</c>(直接存文件)在这台固件上不工作,不要用。
/// </summary>
/// <param name="onProgress">已接收字节数(总大小未知,界面按 MB 显示)</param>
/// <param name="firstOsdTime">
/// **第一帧的真实内容时间**(设备本地时间;拿不到为 null)。
///
/// 回放是从「请求时间所在关键帧」开始推的,各通道关键帧位置不同 →
/// 同一窗口开始拉的两段录像,第一帧的真实时间会差 0~几秒,合并后画面就错开。
/// 用 <c>NET_DVR_GetPlayBackOsdTime</c> 在第一包数据到达时读一次,即可精确对齐。
/// </param>
/// <returns>实际写入字节数</returns>
public long PullPlaybackToFile(string host, int port, string userName, string password,
int channel, DateTime start, DateTime end, string outputPath,
Action<long>? onProgress = null, CancellationToken ct = default)
out DateTime? firstOsdTime, Action<long>? onProgress = null, CancellationToken ct = default)
{
firstOsdTime = null;
var osdTime = (DateTime?)null;
var osdTried = false;
Validate(host, port, userName, password);
if (channel <= 0) throw new ArgumentException("channel 必须是正整数");
if (end <= start) throw new ArgumentException("结束时间必须晚于开始时间");
@ -783,6 +794,15 @@ public sealed class HikDeviceService : IDisposable
{
lastSize = current;
lastGrowth = DateTime.UtcNow;
// 第一包数据到手:只试一次读当前帧的 OSD 时间(= 这一路真实内容起点)。
// 读失败就别再试了 —— 这台固件不支持(err=12),每来一包都试会刷满日志
if (!osdTried)
{
osdTried = true;
osdTime = TryReadPlaybackOsdTime(handle);
}
onProgress?.Invoke(current);
}
@ -821,9 +841,105 @@ public sealed class HikDeviceService : IDisposable
}
}
firstOsdTime = osdTime;
return written;
}
/// <summary>
/// 读当前回放帧的 OSD 时间(录像的真实内容时间,设备本地时间)
/// 读不到 / 数值明显不合理(年份不在 2000~2100)返回 null。
/// </summary>
private static DateTime? TryReadPlaybackOsdTime(int handle)
{
var buffer = Marshal.AllocHGlobal(TimeCfgBufferSize);
try
{
Marshal.Copy(new byte[TimeCfgBufferSize], 0, buffer, TimeCfgBufferSize);
if (!HikSdk.NET_DVR_GetPlayBackOsdTime(handle, buffer))
{
var err = HikSdk.NET_DVR_GetLastError();
AppLog.Write($"[hik] 读回放 OSD 时间失败:err={err}({HikSdk.DescribeError(err)})");
return null;
}
var year = Marshal.ReadInt32(buffer, 0);
var month = Marshal.ReadInt32(buffer, 4);
var day = Marshal.ReadInt32(buffer, 8);
var hour = Marshal.ReadInt32(buffer, 12);
var minute = Marshal.ReadInt32(buffer, 16);
var second = Marshal.ReadInt32(buffer, 20);
if (year < 2000 || year > 2100 || month is < 1 or > 12 || day is < 1 or > 31
|| hour is < 0 or > 23 || minute is < 0 or > 59 || second is < 0 or > 59)
{
AppLog.Write($"[hik] 回放 OSD 时间读数异常:{year}-{month}-{day} {hour}:{minute}:{second}");
return null;
}
return new DateTime(year, month, day, hour, minute, second, DateTimeKind.Unspecified);
}
catch (Exception ex)
{
AppLog.Write($"[hik] 读回放 OSD 时间失败:{ex.Message}");
return null;
}
finally
{
Marshal.FreeHGlobal(buffer);
}
}
/// <summary>
/// 只探一下「这个通道在 start 时刻的第一帧真实时间」(开一个 3 秒的小回放,读到 OSD 就停)。
///
/// 回放预览用的是 RTSP 实时推流,主机侧拿不到内容时间;这里先用 8000 协议问一次,
/// 得到每路真实起点后再按差值推迟出图,几路的画面内容才对得上。
/// </summary>
public DateTime? ProbePlaybackOsdStart(string host, int port, string userName, string password,
int channel, DateTime start, int timeoutMs = 6000)
{
Validate(host, port, userName, password);
HikSdk.EnsureInitialized();
DateTime? osd = null;
var gate = new ManualResetEventSlim(false);
HikSdk.PlayDataCallback callback = (_, _, _, size, _) =>
{
if (size > 0) gate.Set();
};
ExecuteWithSession(host, port, userName, password, userId =>
{
var sdkStart = ToSdkTime(start);
var sdkStop = ToSdkTime(start.AddSeconds(3));
var handle = HikSdk.NET_DVR_PlayBackByTime(userId, channel, ref sdkStart, ref sdkStop, IntPtr.Zero);
if (handle < 0) return;
try
{
if (!HikSdk.NET_DVR_SetPlayDataCallBack(handle, callback, IntPtr.Zero)) return;
if (!HikSdk.NET_DVR_PlayBackControl(handle, HikSdk.PlayStart, 0, IntPtr.Zero)) return;
if (!gate.Wait(timeoutMs)) return;
// 回调线程刚收到数据,等它落到解码侧一点点再读
Thread.Sleep(60);
osd = TryReadPlaybackOsdTime(handle);
}
finally
{
HikSdk.NET_DVR_PlayBackControl(handle, HikSdk.PlayStop, 0, IntPtr.Zero);
HikSdk.NET_DVR_StopPlayBack(handle);
}
});
gate.Dispose();
return osd;
}
private static HikSdk.NET_DVR_TIME ToSdkTime(DateTime time) => new()
{
dwYear = (uint)time.Year,

View File

@ -152,6 +152,28 @@ public sealed class HikFfmpegService : IDisposable
}
}
/// <summary>
/// 订阅这一路的**每一帧**(回调在 ffmpeg 读线程上,只做入队这类快操作)。
///
/// 和 <see cref="TryGetLatest"/> 的区别:那边是「只留最新一帧」,适合网页这类只关心画面的场景;
/// 但**回放对齐不能丢帧** —— ffmpeg 定位到关键帧后会把「关键帧→请求时间」的整段一次性吐出来,
/// 只留最新帧会把这串的前面全丢掉,拿到的“第一帧”可能已经是两秒后的画面,
/// 几路按它算延迟就会整体错开(现场就是这个现象)。
/// </summary>
public IDisposable Subscribe(int handle, Action<byte[]> onFrame)
{
if (!_streams.TryGetValue(handle, out var stream)) return new NoopDisposable();
return stream.AddSubscriber(onFrame);
}
private sealed class NoopDisposable : IDisposable
{
public void Dispose()
{
// 没有订阅成功(流已关闭),什么都不用做
}
}
public bool Close(int handle)
{
lock (_gate)
@ -321,6 +343,7 @@ public sealed class HikFfmpegService : IDisposable
private sealed class FfmpegStream
{
private readonly object _sync = new();
private readonly List<Action<byte[]>> _subscribers = new();
private byte[] _latest = Array.Empty<byte>();
private long _version;
@ -331,13 +354,31 @@ public sealed class HikFfmpegService : IDisposable
public Process? Process { get; set; }
public string? LastError { get; set; }
/// <summary>新帧覆盖(背压:只留最新的,慢客户端不会把内存吃掉)</summary>
/// <summary>
/// 新帧入队:覆盖「最新一帧」(背压),同时**逐帧通知订阅者**(回放对齐要每一帧)
/// </summary>
public void Enqueue(byte[] frame)
{
Action<byte[]>[] snapshot;
lock (_sync)
{
_latest = frame;
_version++;
snapshot = _subscribers.Count == 0 ? Array.Empty<Action<byte[]>>() : _subscribers.ToArray();
}
// 回调在 ffmpeg 读线程上:只允许做入队这类快操作
foreach (var handler in snapshot)
{
try
{
handler(frame);
}
catch (Exception ex)
{
AppLog.Write($"[ffmpeg] 帧回调异常({Description}):{ex.Message}");
}
}
}
@ -357,6 +398,35 @@ public sealed class HikFfmpegService : IDisposable
}
}
public IDisposable AddSubscriber(Action<byte[]> handler)
{
lock (_sync) _subscribers.Add(handler);
return new Subscription(this, handler);
}
private void RemoveSubscriber(Action<byte[]> handler)
{
lock (_sync) _subscribers.Remove(handler);
}
private sealed class Subscription : IDisposable
{
private FfmpegStream? _owner;
private readonly Action<byte[]> _handler;
public Subscription(FfmpegStream owner, Action<byte[]> handler)
{
_owner = owner;
_handler = handler;
}
public void Dispose()
{
_owner?.RemoveSubscriber(_handler);
_owner = null;
}
}
public void Terminate()
{
try

View File

@ -25,6 +25,14 @@ public sealed record PlaybackCheck(bool HasRecord, int Frames, int LogicalChanne
/// <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
///
@ -49,6 +57,7 @@ public sealed class HikPlaybackService : IDisposable
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";
@ -75,6 +84,17 @@ public sealed class HikPlaybackService : IDisposable
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;
@ -93,6 +113,21 @@ public sealed class HikPlaybackService : IDisposable
/// </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
{
@ -104,8 +139,8 @@ public sealed class HikPlaybackService : IDisposable
AppLog.Write($"[playback] 取起始数字通道号失败,按 {startDigital} 兜底:{ex.Message}");
}
var logical = channel - startDigital + 1;
return logical > 0 ? logical : channel;
_startDigital[key] = (startDigital, Environment.TickCount64);
return startDigital;
}
/// <summary>
@ -226,7 +261,7 @@ public sealed class HikPlaybackService : IDisposable
try
{
var bytes = await Task.Run(() => _device.PullPlaybackToFile(host, port, userName, password,
channel, start.LocalDateTime, probeEnd.LocalDateTime, probeFile, null, ct), ct)
channel, start.LocalDateTime, probeEnd.LocalDateTime, probeFile, out _, null, ct), ct)
.ConfigureAwait(false);
AppLog.Write($"[playback] SDK 探测 {host} 通道{channel}:{bytes} 字节");
@ -303,8 +338,8 @@ public sealed class HikPlaybackService : IDisposable
///
/// 回放速度实测约 0.5x~3x(跟码流大小有关),所以**必须显示进度、必须能取消**。
/// </summary>
/// <returns>落地文件路径(mp4;转封装失败时是 .ts)</returns>
public async Task<string> DownloadAsync(string host, int port, string userName, string password,
/// <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)
{
@ -330,8 +365,9 @@ public sealed class HikPlaybackService : IDisposable
{
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,
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);
@ -341,13 +377,18 @@ public sealed class HikPlaybackService : IDisposable
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} 字节)");
return outputPath;
// ⚠️ 读不到 OSD 就**按原样合并**:时长反推实测不可靠(同一窗口两次 36.1s/42.1s),
// 硬套只会让偏差更大(现场反馈"还不如直接合并")
var offset = OffsetFromOsd(osdStart, start.LocalDateTime, channel) ?? TimeSpan.Zero;
return new PlaybackClip(outputPath, offset);
}
// mp4 封装不了 → 把设备原始 PS 留下(PotPlayer/VLC 能直接播)
@ -356,7 +397,9 @@ public sealed class HikPlaybackService : IDisposable
File.Move(tempPs, psPath);
progress?.Report(new PlaybackProgress(1, "下载完成(原始封装 .ps)"));
AppLog.Write($"[playback] 封装失败,保留原始录像:{psPath}");
return psPath;
var psOffset = OffsetFromOsd(osdStart, start.LocalDateTime, channel) ?? TimeSpan.Zero;
return new PlaybackClip(psPath, psOffset);
}
}
catch (OperationCanceledException)
@ -437,7 +480,46 @@ public sealed class HikPlaybackService : IDisposable
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} 字节)");
return result;
// 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;
}
// ==================== ③ 按工作台布局合并成一个视频 ====================
@ -455,9 +537,14 @@ public sealed class HikPlaybackService : IDisposable
/// 用 <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, IProgress<PlaybackProgress>? progress = null, CancellationToken ct = default)
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, "片段数与流数量不一致");
@ -482,7 +569,18 @@ public sealed class HikPlaybackService : IDisposable
? streams.Max(item => item.CanvasHeight)
: 1080;
var totalSec = Math.Max((streams[0].EndTime - streams[0].StartTime).TotalSeconds, 1);
// 各路真实起点不同(各自从关键帧开始):按偏移把时间轴摆回同一时刻
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++)
@ -492,7 +590,8 @@ public sealed class HikPlaybackService : IDisposable
var height = stream.Layout.Height > 0 ? stream.Layout.Height : canvasHeight;
// 帧率统一到 25(各路帧率不一样,overlay 会互相等待并对不齐)
filters.Add($"[{i + 1}:v]scale={width}:{height}:force_original_aspect_ratio=decrease,"
filters.Add($"[{i + 1}:v]{TimingFilter(offsets[i])}"
+ $"scale={width}:{height}:force_original_aspect_ratio=decrease,"
+ $"fps=25,format=yuv420p,setsar=1[v{i}]");
}
@ -547,6 +646,23 @@ public sealed class HikPlaybackService : IDisposable
// ==================== 内部 ====================
/// <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)
{

View File

@ -333,6 +333,15 @@ internal static class HikSdk
[DllImport(Dll, CallingConvention = CallingConvention.StdCall)]
internal static extern int NET_DVR_GetPlayBackPos(int lPlayHandle);
/// <summary>
/// 取**当前回放帧对应的 OSD 时间**(输出 <c>NET_DVR_TIME</c>,24 字节)。
///
/// 这是录像的真实内容时间(录像机回放时间轴),不是"会话相对时间"——
/// 多路对齐只有靠它才能精确到秒:各路从哪个关键帧起播、晚了多少,读一次就知道。
/// </summary>
[DllImport(Dll, CallingConvention = CallingConvention.StdCall)]
internal static extern bool NET_DVR_GetPlayBackOsdTime(int lPlayHandle, IntPtr lpOsdTime);
/// <summary>初始化 SDK(幂等)。找不到 HCNetSDK.dll 时抛 <see cref="HikException"/></summary>
internal static void EnsureInitialized()
{

View File

@ -93,7 +93,7 @@ public sealed class PlaybackDownloadService
Directory.CreateDirectory(workDir);
var warnings = new List<string>();
var saved = new string?[streams.Count];
var saved = new PlaybackClip?[streams.Count];
var gate = new SemaphoreSlim(MaxParallel);
var credentials = new Dictionary<int, NvrCredential>();
var credentialGate = new SemaphoreSlim(1, 1);
@ -147,10 +147,10 @@ public sealed class PlaybackDownloadService
await Task.WhenAll(tasks).ConfigureAwait(false);
var parts = new List<(PackStream Stream, string Path)>();
var parts = new List<(PackStream Stream, PlaybackClip Clip)>();
for (var i = 0; i < streams.Count; i++)
{
if (saved[i] is { } file) parts.Add((streams[i], file));
if (saved[i] is { } clip) parts.Add((streams[i], clip));
}
if (parts.Count == 0)
@ -161,9 +161,10 @@ public sealed class PlaybackDownloadService
if (parts.Count == 1)
{
var target = Path.Combine(folder, Path.GetFileName(parts[0].Path));
var single = parts[0].Clip.Path;
var target = Path.Combine(folder, Path.GetFileName(single));
if (File.Exists(target)) File.Delete(target);
File.Move(parts[0].Path, target);
File.Move(single, target);
progress?.Report($"已保存:{target}");
return new PlaybackDownloadResult(folder, target, new[] { target }, warnings);
}
@ -175,9 +176,10 @@ public sealed class PlaybackDownloadService
try
{
await _playback.ComposeAsync(
parts.Select(item => item.Path).ToList(),
parts.Select(item => item.Clip.Path).ToList(),
parts.Select(item => item.Stream).ToList(),
merged,
parts.Select(item => item.Clip.StartOffset).ToList(),
new Progress<PlaybackProgress>(p => progress?.Report(p.Message)),
ct).ConfigureAwait(false);
@ -189,11 +191,11 @@ public sealed class PlaybackDownloadService
// 合并失败不丢数据:把各路段搬到用户目录
warnings.Add($"合并失败:{ex.Message}");
var moved = new List<string>();
foreach (var (_, path) in parts)
foreach (var (_, clip) in parts)
{
var target = Path.Combine(folder, Path.GetFileName(path));
var target = Path.Combine(folder, Path.GetFileName(clip.Path));
if (File.Exists(target)) File.Delete(target);
File.Move(path, target);
File.Move(clip.Path, target);
moved.Add(target);
}
return new PlaybackDownloadResult(folder, null, moved, warnings);

View File

@ -6,7 +6,6 @@
Background="#101216">
<DockPanel>
<DockPanel DockPanel.Dock="Top" Margin="12,10,12,6">
<Button DockPanel.Dock="Right" Content="关闭" Padding="14,4" Click="Close_Click" />
<TextBlock x:Name="TitleText" Foreground="#E5E7EB" FontSize="13"
VerticalAlignment="Center" TextTrimming="CharacterEllipsis"
Text="回放预览" />

View File

@ -1,6 +1,7 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Imaging;
@ -17,6 +18,16 @@ namespace YuncangTrace.LocalService.Views;
/// ffmpeg 按时间拉 RTSP 回放 → 转 MJPEG → 每帧取最新一张贴到 <see cref="Image"/>。
/// 不解码到窗口,所以可以同时播很多路;坏处是 CPU 比硬解高一点。
///
/// **几路怎么对齐**(现场反馈:两路开播时间差好几秒,画面错开):
/// 各路 RTSP 建链有快有慢,先出帧的那路会一直"跑在前面"。这里的做法是
/// **先一起等、再按帧一起放**:
/// 1. ffmpeg 每出一帧就回调一次(<see cref="HikFfmpegService.Subscribe"/>),按顺序进各自的队列
/// —— 不能"定时取最新一帧",否则开头那串关键帧会被整段丢掉,两路就差出秒级;
/// 2. 每一路都出过第一帧后(或判定没录像)才开始播,每 <see cref="FrameIntervalMs"/> 从每路队列
/// **各取一帧**,先上线的那路就是从头放队列里的积压 —— 几路天然停在同一个内容位置;
/// 3. 队列超过 <see cref="MaxQueuedFrames"/> 帧(设备推得比实时快)就丢到
/// <see cref="CatchUpFrames"/> 帧,避免越播越晚。
///
/// 布局直接从后端快照来(canvasWidth/Height + 每路的 x/y/width/height),
/// 用 <see cref="Viewbox"/> 等比缩放,窗口多大都不变形。
/// </summary>
@ -25,19 +36,60 @@ public partial class PlaybackPreviewWindow : Window
/// <summary>取帧频率(ms):40ms ≈ 25fps,与设备帧率一致</summary>
private const int FrameIntervalMs = 40;
/// <summary>超过这么久还没出第一帧:当这路没有录像</summary>
private const int FirstFrameTimeoutMs = 12000;
/// <summary>单路队列上限(≈9 秒):等同步时的积压最多留这么多</summary>
private const int MaxQueuedFrames = 220;
/// <summary>超过上限时丢到这个深度(≈2 秒),别让播放越拖越晚</summary>
private const int CatchUpFrames = 50;
private readonly List<Session> _sessions = new();
private readonly DispatcherTimer? _timer;
private readonly HikFfmpegService? _ffmpeg;
/// <summary>各路是否已经算出对齐延迟(都出过第一帧,或已判定没画面)</summary>
private bool _aligned;
private long _alignedAt;
private readonly string _title = string.Empty;
private sealed class Session
{
public PackStream Stream { get; init; } = null!;
public string RtspUrl { get; init; } = string.Empty;
public string OpenKey { get; init; } = string.Empty;
public Image Image { get; init; } = null!;
public TextBlock Status { get; init; } = null!;
public int Handle { get; set; }
public long FrameVersion { get; set; }
public DateTime StartedAt { get; } = DateTime.Now;
/// <summary>帧订阅(ffmpeg 每出一帧回调一次,不丢帧)</summary>
public IDisposable? Subscription { get; set; }
/// <summary>缓冲区锁:帧回调在 ffmpeg 线程,渲染在 UI 线程</summary>
public object Sync { get; } = new();
/// <summary>是否已经提示过「已就绪,等待同步」</summary>
public bool ReadyShown { get; set; }
/// <summary>待显示的帧队列(**按内容顺序**,每 tick 取一帧)</summary>
public Queue<byte[]> Buffer { get; } = new();
/// <summary>第一帧到达时间(TickCount64);-1 = 还没出帧</summary>
public long FirstFrameAt { get; set; } = -1;
public long OpenedAt { get; init; }
/// <summary>请求的回放时长(窗口);播到这里就该停</summary>
public TimeSpan Window { get; init; }
/// <summary>窗口播完(画面停在最后一帧)</summary>
public bool Ended { get; set; }
/// <summary>没画面 / 打开失败</summary>
public bool Finished { get; set; }
public long LastShownSecond { get; set; } = -1;
}
/// <param name="streams">要播的回放流(同一工作台的一批)</param>
@ -64,14 +116,17 @@ public partial class PlaybackPreviewWindow : Window
Canvas.Height = canvasHeight;
var first = streams[0];
TitleText.Text = $"{first.StartTime.ToLocalTime():yyyy-MM-dd HH:mm:ss} ~ "
_title = $"{first.StartTime.ToLocalTime():yyyy-MM-dd HH:mm:ss} ~ "
+ $"{first.EndTime.ToLocalTime():HH:mm:ss} · {streams.Count} 路回放"
+ $"({canvasWidth}×{canvasHeight})";
TitleText.Text = _title;
foreach (var stream in streams.OrderBy(item => item.Layout.ZIndex).ThenBy(item => item.Layout.SortNo))
{
if (!credentials.TryGetValue(stream.NvrId, out var credential)) continue;
// 通道换算 / 时钟偏差在服务里都带缓存(一台设备只问一次);
// 逐路问设备会让后开的流晚好几秒,几路画面就错开了
var logical = playback.LogicalChannel(credential.Host, credential.Port,
credential.Username, credential.Password, stream.ChannelNo);
@ -115,20 +170,21 @@ public partial class PlaybackPreviewWindow : Window
Panel.SetZIndex(panel, stream.Layout.ZIndex);
Canvas.Children.Add(panel);
var session = new Session { Stream = stream, Image = image, Status = status };
try
_sessions.Add(new Session
{
session.Handle = ffmpeg.OpenUrl(url,
$"{credential.Host}|{stream.ChannelNo}|{stream.StartTime.ToUnixTimeSeconds()}|{stream.EndTime.ToUnixTimeSeconds()}");
_sessions.Add(session);
}
catch (Exception ex)
{
status.Text = $"{stream.DisplayName} 打开失败:{ex.Message}";
}
Stream = stream,
RtspUrl = url,
OpenKey = $"{credential.Host}|{stream.ChannelNo}|{stream.StartTime.ToUnixTimeSeconds()}|{stream.EndTime.ToUnixTimeSeconds()}",
Image = image,
Status = status,
OpenedAt = Environment.TickCount64,
Window = stream.EndTime - stream.StartTime,
});
}
// 几路**同时**开:串行开的话后一路要等前面建链,画面天然错开几秒
Task.WaitAll(_sessions.Select(session => Task.Run(() => Open(session))).ToArray());
_timer = new DispatcherTimer(DispatcherPriority.Render) { Interval = TimeSpan.FromMilliseconds(FrameIntervalMs) };
_timer.Tick += OnTick;
_timer.Start();
@ -136,54 +192,198 @@ public partial class PlaybackPreviewWindow : Window
Closed += (_, _) => DisposeSessions();
}
private void Open(Session session)
{
if (_ffmpeg is null) return;
try
{
session.Handle = _ffmpeg.OpenUrl(session.RtspUrl, session.OpenKey);
// ⚠️ 必须**订阅每一帧**,不能定时去取「最新一帧」:
// ffmpeg 定位到关键帧后,会把「关键帧 → 请求时间」那一段帧**一次性吐出来**,
// 只留最新帧会把这段的前面全丢掉 —— 这一路的“第一帧”其实是 1~2 秒后的画面,
// 按它算对齐延迟就整体错开(现场:小窗一出现就比大窗超前)。
session.Subscription = _ffmpeg.Subscribe(session.Handle, frame =>
{
lock (session.Sync)
{
if (session.FirstFrameAt < 0) session.FirstFrameAt = Environment.TickCount64;
session.Buffer.Enqueue(frame);
}
});
}
catch (Exception ex)
{
session.Finished = true;
var text = $"{session.Stream.DisplayName} 打开失败:{ex.Message}";
Dispatcher.BeginInvoke(new Action(() => session.Status.Text = text));
}
}
private void OnTick(object? sender, EventArgs e)
{
if (_ffmpeg is null) return;
var now = Environment.TickCount64;
// ① 帧已经由订阅回调按顺序收进缓冲(不丢帧),这里只负责对齐与出图
// ② 还没对齐:等每一路都出过第一帧(或判定它没有录像)
if (!_aligned)
{
TryAlign(now);
if (!_aligned) return;
}
// ③ 出图:每路各取队头一帧,先上线的那路放的是等同步时攒下的积压 → 几路落在同一时刻
foreach (var session in _sessions) Render(session, now);
// ④ 按**请求窗口**收尾:录像机不会按 endtime 自己断流(各路停的时机还不一样),
// 不在这里截断的话,流量大的那路会一直往后播,而先停的那路画面已经冻住了
StopAtWindowEnd(now);
}
/// <summary>到了请求的回放时长就停(各路一起停,画面停在最后一帧并释放设备会话)</summary>
private void StopAtWindowEnd(long now)
{
if (!_aligned || _ffmpeg is null) return;
var elapsed = now - _alignedAt;
foreach (var session in _sessions)
{
if (session.Finished || session.Ended || session.Handle <= 0) continue;
if (session.Window <= TimeSpan.Zero) continue;
// 留 0.5 秒余量:最后一帧本身要画出来
if (elapsed <= session.Window.TotalMilliseconds + 500) continue;
session.Ended = true;
lock (session.Sync)
{
session.Buffer.Clear();
}
session.Status.Text = $"{session.Stream.DisplayName} 回放结束";
session.LastShownSecond = -1;
session.Subscription?.Dispose();
session.Subscription = null;
try
{
_ffmpeg.Close(session.Handle);
}
catch
{
// 关窗时忽略
}
session.Handle = 0;
}
if (_sessions.Count == 0) return;
if (!_sessions.All(item => item.Ended || item.Finished)) return;
_timer?.Stop();
TitleText.Text = $"{_title} · 回放结束";
}
private static int QueueDepth(Session session)
{
lock (session.Sync) return session.Buffer.Count;
}
/// <summary>等每一路都出过第一帧(或判定没录像)→ 统一开始按帧播放</summary>
private void TryAlign(long now)
{
foreach (var session in _sessions)
{
if (_ffmpeg is null || session.Finished || session.Handle <= 0) continue;
if (session.Finished || session.FirstFrameAt >= 0) continue;
if (!_ffmpeg.TryGetLatest(session.Handle, session.FrameVersion, 1, out var frame, out var version))
if (now - session.OpenedAt > FirstFrameTimeoutMs)
{
// 超过 12 秒还没出帧:大概率这段时间没录像
if (session.Image.Source is null && (DateTime.Now - session.StartedAt).TotalSeconds > 12)
{
session.Status.Text = $"{session.Stream.DisplayName} 没有画面(该时段可能没有录像)";
session.Finished = true;
}
continue;
session.Status.Text = $"{session.Stream.DisplayName} 没有画面(该时段可能没有录像)";
session.Finished = true;
}
}
var pending = _sessions.Where(item => !item.Finished && item.Handle > 0).ToList();
if (pending.Count == 0)
{
_aligned = true;
return;
}
// 还有路在连:先不播,免得"先到先看"造成错位
if (pending.Any(item => item.FirstFrameAt < 0))
{
var ready = pending.Count(item => item.FirstFrameAt >= 0);
TitleText.Text = $"{_title} · 同步中 {ready}/{pending.Count}";
foreach (var session in pending.Where(item => item.FirstFrameAt >= 0 && !item.ReadyShown))
{
session.ReadyShown = true;
session.Status.Text = $"{session.Stream.DisplayName} 已就绪,等待同步…";
}
session.FrameVersion = version;
return;
}
_aligned = true;
_alignedAt = now;
TitleText.Text = _title;
// 先上线的那几路已经攒了一队列(相当于“落后”几秒),从队头开始放正好和最后上线的那路同步
AppLog.Write("[playback] 多路回放开始同步播放(各路基线帧数:"
+ string.Join("、", pending.Select(item => $"{item.Stream.DisplayName}={QueueDepth(item)}帧")) + ")");
}
private void Render(Session session, long now)
{
if (session.FirstFrameAt < 0 || session.Ended) return;
// 一个 tick 出一帧(队列顺序 = 内容顺序):不管 ffmpeg 开头一次吐了多少帧,都不会跳
byte[]? picked = null;
lock (session.Sync)
{
// 设备推得比实时快时(有的固件会补帧),先丢掉积压,别让播放越拖越晚
if (session.Buffer.Count > MaxQueuedFrames)
{
while (session.Buffer.Count > CatchUpFrames) session.Buffer.Dequeue();
}
if (session.Buffer.Count > 0) picked = session.Buffer.Dequeue();
}
if (picked is not null)
{
try
{
var bitmap = new BitmapImage();
bitmap.BeginInit();
bitmap.CacheOption = BitmapCacheOption.OnLoad;
bitmap.StreamSource = new System.IO.MemoryStream(frame);
bitmap.StreamSource = new System.IO.MemoryStream(picked);
bitmap.EndInit();
bitmap.Freeze();
session.Image.Source = bitmap;
if (session.Status.Text.EndsWith('…'))
{
var elapsed = (DateTime.Now - session.StartedAt).TotalSeconds;
session.Status.Text = $"{session.Stream.DisplayName} {elapsed:0}s";
}
else
{
var elapsed = (DateTime.Now - session.StartedAt).TotalSeconds;
session.Status.Text = $"{session.Stream.DisplayName} {elapsed:0}s";
}
}
catch
{
// 半帧/坏帧直接丢掉,下一帧再说
}
}
}
private void Close_Click(object sender, RoutedEventArgs e) => Close();
// ⚠️ 这个秒数只是**本机出图节奏**(从对齐那一刻算起),两路相同不代表画面内容是同一时刻;
// 内容是否对齐只能看画面里烧的 OSD 或画面本身,别拿这个当对齐证据。
var elapsed = (now - _alignedAt) / 1000;
if (elapsed != session.LastShownSecond)
{
session.LastShownSecond = elapsed;
session.Status.Text = $"{session.Stream.DisplayName} {elapsed}s";
}
}
private void DisposeSessions()
{
@ -191,6 +391,14 @@ public partial class PlaybackPreviewWindow : Window
foreach (var session in _sessions)
{
session.Subscription?.Dispose();
session.Subscription = null;
lock (session.Sync)
{
session.Buffer.Clear();
}
if (session.Handle <= 0 || _ffmpeg is null) continue;
try
{