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

View File

@ -704,11 +704,22 @@ public sealed class HikDeviceService : IDisposable
/// - ⚠️ <c>NET_DVR_GetFileByTime*</c>(直接存文件)在这台固件上不工作,不要用。 /// - ⚠️ <c>NET_DVR_GetFileByTime*</c>(直接存文件)在这台固件上不工作,不要用。
/// </summary> /// </summary>
/// <param name="onProgress">已接收字节数(总大小未知,界面按 MB 显示)</param> /// <param name="onProgress">已接收字节数(总大小未知,界面按 MB 显示)</param>
/// <param name="firstOsdTime">
/// **第一帧的真实内容时间**(设备本地时间;拿不到为 null)。
///
/// 回放是从「请求时间所在关键帧」开始推的,各通道关键帧位置不同 →
/// 同一窗口开始拉的两段录像,第一帧的真实时间会差 0~几秒,合并后画面就错开。
/// 用 <c>NET_DVR_GetPlayBackOsdTime</c> 在第一包数据到达时读一次,即可精确对齐。
/// </param>
/// <returns>实际写入字节数</returns> /// <returns>实际写入字节数</returns>
public long PullPlaybackToFile(string host, int port, string userName, string password, public long PullPlaybackToFile(string host, int port, string userName, string password,
int channel, DateTime start, DateTime end, string outputPath, 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); Validate(host, port, userName, password);
if (channel <= 0) throw new ArgumentException("channel 必须是正整数"); if (channel <= 0) throw new ArgumentException("channel 必须是正整数");
if (end <= start) throw new ArgumentException("结束时间必须晚于开始时间"); if (end <= start) throw new ArgumentException("结束时间必须晚于开始时间");
@ -783,6 +794,15 @@ public sealed class HikDeviceService : IDisposable
{ {
lastSize = current; lastSize = current;
lastGrowth = DateTime.UtcNow; lastGrowth = DateTime.UtcNow;
// 第一包数据到手:只试一次读当前帧的 OSD 时间(= 这一路真实内容起点)。
// 读失败就别再试了 —— 这台固件不支持(err=12),每来一包都试会刷满日志
if (!osdTried)
{
osdTried = true;
osdTime = TryReadPlaybackOsdTime(handle);
}
onProgress?.Invoke(current); onProgress?.Invoke(current);
} }
@ -821,9 +841,105 @@ public sealed class HikDeviceService : IDisposable
} }
} }
firstOsdTime = osdTime;
return written; 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() private static HikSdk.NET_DVR_TIME ToSdkTime(DateTime time) => new()
{ {
dwYear = (uint)time.Year, 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) public bool Close(int handle)
{ {
lock (_gate) lock (_gate)
@ -321,6 +343,7 @@ public sealed class HikFfmpegService : IDisposable
private sealed class FfmpegStream private sealed class FfmpegStream
{ {
private readonly object _sync = new(); private readonly object _sync = new();
private readonly List<Action<byte[]>> _subscribers = new();
private byte[] _latest = Array.Empty<byte>(); private byte[] _latest = Array.Empty<byte>();
private long _version; private long _version;
@ -331,13 +354,31 @@ public sealed class HikFfmpegService : IDisposable
public Process? Process { get; set; } public Process? Process { get; set; }
public string? LastError { get; set; } public string? LastError { get; set; }
/// <summary>新帧覆盖(背压:只留最新的,慢客户端不会把内存吃掉)</summary> /// <summary>
/// 新帧入队:覆盖「最新一帧」(背压),同时**逐帧通知订阅者**(回放对齐要每一帧)
/// </summary>
public void Enqueue(byte[] frame) public void Enqueue(byte[] frame)
{ {
Action<byte[]>[] snapshot;
lock (_sync) lock (_sync)
{ {
_latest = frame; _latest = frame;
_version++; _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() public void Terminate()
{ {
try try

View File

@ -25,6 +25,14 @@ public sealed record PlaybackCheck(bool HasRecord, int Frames, int LogicalChanne
/// <param name="Message">当前状态文案</param> /// <param name="Message">当前状态文案</param>
public sealed record PlaybackProgress(double? Percent, string Message); 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> /// <summary>
/// 海康 **按时间回放**:校验有没有录像 / 拉流预览 / 下载成 mp4 /// 海康 **按时间回放**:校验有没有录像 / 拉流预览 / 下载成 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 OutTimeRegex = new(@"out_time_us=(\d+)", RegexOptions.Compiled);
private static readonly Regex SpeedRegex = new(@"speed=\s*([\d.]+)x", RegexOptions.Compiled); private static readonly Regex SpeedRegex = new(@"speed=\s*([\d.]+)x", RegexOptions.Compiled);
/// <summary>RTSP socket 读超时(微秒)。回放拉完设备不再推流,靠它让 ffmpeg 收尾退出</summary> /// <summary>RTSP socket 读超时(微秒)。回放拉完设备不再推流,靠它让 ffmpeg 收尾退出</summary>
private const string SocketTimeoutUs = "5000000"; private const string SocketTimeoutUs = "5000000";
@ -75,6 +84,17 @@ public sealed class HikPlaybackService : IDisposable
private const long ClockOffsetTtlMs = 10 * 60 * 1000; private const long ClockOffsetTtlMs = 10 * 60 * 1000;
private const long ClockOffsetFailTtlMs = 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) public HikPlaybackService(HikDeviceService device)
{ {
_device = device; _device = device;
@ -93,6 +113,21 @@ public sealed class HikPlaybackService : IDisposable
/// </summary> /// </summary>
public int LogicalChannel(string host, int port, string userName, string password, int channel) 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; var startDigital = 33;
try try
{ {
@ -104,8 +139,8 @@ public sealed class HikPlaybackService : IDisposable
AppLog.Write($"[playback] 取起始数字通道号失败,按 {startDigital} 兜底:{ex.Message}"); AppLog.Write($"[playback] 取起始数字通道号失败,按 {startDigital} 兜底:{ex.Message}");
} }
var logical = channel - startDigital + 1; _startDigital[key] = (startDigital, Environment.TickCount64);
return logical > 0 ? logical : channel; return startDigital;
} }
/// <summary> /// <summary>
@ -226,7 +261,7 @@ public sealed class HikPlaybackService : IDisposable
try try
{ {
var bytes = await Task.Run(() => _device.PullPlaybackToFile(host, port, userName, password, 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); .ConfigureAwait(false);
AppLog.Write($"[playback] SDK 探测 {host} 通道{channel}:{bytes} 字节"); AppLog.Write($"[playback] SDK 探测 {host} 通道{channel}:{bytes} 字节");
@ -303,8 +338,8 @@ public sealed class HikPlaybackService : IDisposable
/// ///
/// 回放速度实测约 0.5x~3x(跟码流大小有关),所以**必须显示进度、必须能取消**。 /// 回放速度实测约 0.5x~3x(跟码流大小有关),所以**必须显示进度、必须能取消**。
/// </summary> /// </summary>
/// <returns>落地文件路径(mp4;转封装失败时是 .ts)</returns> /// <returns>落地文件 + 这一路的真实起点(相对请求时间;测不到就是零)</returns>
public async Task<string> DownloadAsync(string host, int port, string userName, string password, public async Task<PlaybackClip> DownloadAsync(string host, int port, string userName, string password,
int channel, DateTimeOffset start, DateTimeOffset end, string outputPath, int channel, DateTimeOffset start, DateTimeOffset end, string outputPath,
IProgress<PlaybackProgress>? progress = null, CancellationToken ct = default) IProgress<PlaybackProgress>? progress = null, CancellationToken ct = default)
{ {
@ -330,8 +365,9 @@ public sealed class HikPlaybackService : IDisposable
{ {
progress?.Report(new PlaybackProgress(0, "下载中(8000 全速)…")); progress?.Report(new PlaybackProgress(0, "下载中(8000 全速)…"));
DateTime? osdStart = null;
var bytes = await Task.Run(() => _device.PullPlaybackToFile(host, port, userName, password, channel, 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, received => progress?.Report(new PlaybackProgress(null,
$"下载中(8000 全速){received / 1024.0 / 1024.0:0.0} MB")), ct), ct) $"下载中(8000 全速){received / 1024.0 / 1024.0:0.0} MB")), ct), ct)
.ConfigureAwait(false); .ConfigureAwait(false);
@ -341,13 +377,18 @@ public sealed class HikPlaybackService : IDisposable
if (bytes > 16 * 1024) if (bytes > 16 * 1024)
{ {
_sdkPlayback[sdkKey] = true; _sdkPlayback[sdkKey] = true;
progress?.Report(new PlaybackProgress(0.99, "正在封装成 mp4…")); progress?.Report(new PlaybackProgress(0.99, "正在封装成 mp4…"));
if (await RepackAsync(ffmpeg, tempPs, outputPath, ct).ConfigureAwait(false)) if (await RepackAsync(ffmpeg, tempPs, outputPath, ct).ConfigureAwait(false))
{ {
var okSize = new FileInfo(outputPath).Length; var okSize = new FileInfo(outputPath).Length;
progress?.Report(new PlaybackProgress(1, $"下载完成({Math.Round(okSize / 1024.0 / 1024.0, 1)} MB)")); progress?.Report(new PlaybackProgress(1, $"下载完成({Math.Round(okSize / 1024.0 / 1024.0, 1)} MB)"));
AppLog.Write($"[playback] 回放已下载:{outputPath}({okSize} 字节)"); 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 能直接播) // mp4 封装不了 → 把设备原始 PS 留下(PotPlayer/VLC 能直接播)
@ -356,7 +397,9 @@ public sealed class HikPlaybackService : IDisposable
File.Move(tempPs, psPath); File.Move(tempPs, psPath);
progress?.Report(new PlaybackProgress(1, "下载完成(原始封装 .ps)")); progress?.Report(new PlaybackProgress(1, "下载完成(原始封装 .ps)"));
AppLog.Write($"[playback] 封装失败,保留原始录像:{psPath}"); AppLog.Write($"[playback] 封装失败,保留原始录像:{psPath}");
return psPath;
var psOffset = OffsetFromOsd(osdStart, start.LocalDateTime, channel) ?? TimeSpan.Zero;
return new PlaybackClip(psPath, psOffset);
} }
} }
catch (OperationCanceledException) catch (OperationCanceledException)
@ -437,7 +480,46 @@ public sealed class HikPlaybackService : IDisposable
var finalSize = new FileInfo(result).Length; var finalSize = new FileInfo(result).Length;
progress?.Report(new PlaybackProgress(1, $"下载完成({Math.Round(finalSize / 1024.0 / 1024.0, 1)} MB)")); progress?.Report(new PlaybackProgress(1, $"下载完成({Math.Round(finalSize / 1024.0 / 1024.0, 1)} MB)"));
AppLog.Write($"[playback] 回放已下载:{result}({finalSize} 字节)"); 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> 折中。 /// 用 <c>veryfast</c> + <c>crf 23</c> 折中。
/// </summary> /// </summary>
/// <param name="segments">各路下载好的文件(顺序与 <paramref name="streams"/> 一一对应)</param> /// <param name="segments">各路下载好的文件(顺序与 <paramref name="streams"/> 一一对应)</param>
/// <param name="startOffsets">
/// 每路真实起点相对请求时间的偏移(见 <see cref="PlaybackClip.StartOffset"/>,null/缺项 = 不偏移)。
/// 各路是**从各自的关键帧**开始录的,不按这个差值把时间轴错开,合并后两格会差 1~2 秒。
/// </param>
/// <returns>合并后文件路径</returns> /// <returns>合并后文件路径</returns>
public async Task<string> ComposeAsync(IReadOnlyList<string> segments, IReadOnlyList<PackStream> streams, 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 == 0) throw new HikException(uint.MaxValue, "没有可合并的片段");
if (segments.Count != streams.Count) 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) ? streams.Max(item => item.CanvasHeight)
: 1080; : 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>(); var filters = new List<string>();
for (var i = 0; i < streams.Count; i++) 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; var height = stream.Layout.Height > 0 ? stream.Layout.Height : canvasHeight;
// 帧率统一到 25(各路帧率不一样,overlay 会互相等待并对不齐) // 帧率统一到 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}]"); + $"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> /// <summary>把设备原始录像(PS)转封装成 mp4;失败返回 false</summary>
private async Task<bool> RepackAsync(string ffmpeg, string input, string outputPath, CancellationToken ct) 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)] [DllImport(Dll, CallingConvention = CallingConvention.StdCall)]
internal static extern int NET_DVR_GetPlayBackPos(int lPlayHandle); 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> /// <summary>初始化 SDK(幂等)。找不到 HCNetSDK.dll 时抛 <see cref="HikException"/></summary>
internal static void EnsureInitialized() internal static void EnsureInitialized()
{ {

View File

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

View File

@ -6,7 +6,6 @@
Background="#101216"> Background="#101216">
<DockPanel> <DockPanel>
<DockPanel DockPanel.Dock="Top" Margin="12,10,12,6"> <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" <TextBlock x:Name="TitleText" Foreground="#E5E7EB" FontSize="13"
VerticalAlignment="Center" TextTrimming="CharacterEllipsis" VerticalAlignment="Center" TextTrimming="CharacterEllipsis"
Text="回放预览" /> Text="回放预览" />

View File

@ -1,6 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Threading.Tasks;
using System.Windows; using System.Windows;
using System.Windows.Controls; using System.Windows.Controls;
using System.Windows.Media.Imaging; using System.Windows.Media.Imaging;
@ -17,6 +18,16 @@ namespace YuncangTrace.LocalService.Views;
/// ffmpeg 按时间拉 RTSP 回放 → 转 MJPEG → 每帧取最新一张贴到 <see cref="Image"/>。 /// ffmpeg 按时间拉 RTSP 回放 → 转 MJPEG → 每帧取最新一张贴到 <see cref="Image"/>。
/// 不解码到窗口,所以可以同时播很多路;坏处是 CPU 比硬解高一点。 /// 不解码到窗口,所以可以同时播很多路;坏处是 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), /// 布局直接从后端快照来(canvasWidth/Height + 每路的 x/y/width/height),
/// 用 <see cref="Viewbox"/> 等比缩放,窗口多大都不变形。 /// 用 <see cref="Viewbox"/> 等比缩放,窗口多大都不变形。
/// </summary> /// </summary>
@ -25,19 +36,60 @@ public partial class PlaybackPreviewWindow : Window
/// <summary>取帧频率(ms):40ms ≈ 25fps,与设备帧率一致</summary> /// <summary>取帧频率(ms):40ms ≈ 25fps,与设备帧率一致</summary>
private const int FrameIntervalMs = 40; 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 List<Session> _sessions = new();
private readonly DispatcherTimer? _timer; private readonly DispatcherTimer? _timer;
private readonly HikFfmpegService? _ffmpeg; private readonly HikFfmpegService? _ffmpeg;
/// <summary>各路是否已经算出对齐延迟(都出过第一帧,或已判定没画面)</summary>
private bool _aligned;
private long _alignedAt;
private readonly string _title = string.Empty;
private sealed class Session private sealed class Session
{ {
public PackStream Stream { get; init; } = null!; 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 Image Image { get; init; } = null!;
public TextBlock Status { get; init; } = null!; public TextBlock Status { get; init; } = null!;
public int Handle { get; set; } 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 bool Finished { get; set; }
public long LastShownSecond { get; set; } = -1;
} }
/// <param name="streams">要播的回放流(同一工作台的一批)</param> /// <param name="streams">要播的回放流(同一工作台的一批)</param>
@ -64,14 +116,17 @@ public partial class PlaybackPreviewWindow : Window
Canvas.Height = canvasHeight; Canvas.Height = canvasHeight;
var first = streams[0]; 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} 路回放" + $"{first.EndTime.ToLocalTime():HH:mm:ss} · {streams.Count} 路回放"
+ $"({canvasWidth}×{canvasHeight})"; + $"({canvasWidth}×{canvasHeight})";
TitleText.Text = _title;
foreach (var stream in streams.OrderBy(item => item.Layout.ZIndex).ThenBy(item => item.Layout.SortNo)) foreach (var stream in streams.OrderBy(item => item.Layout.ZIndex).ThenBy(item => item.Layout.SortNo))
{ {
if (!credentials.TryGetValue(stream.NvrId, out var credential)) continue; if (!credentials.TryGetValue(stream.NvrId, out var credential)) continue;
// 通道换算 / 时钟偏差在服务里都带缓存(一台设备只问一次);
// 逐路问设备会让后开的流晚好几秒,几路画面就错开了
var logical = playback.LogicalChannel(credential.Host, credential.Port, var logical = playback.LogicalChannel(credential.Host, credential.Port,
credential.Username, credential.Password, stream.ChannelNo); credential.Username, credential.Password, stream.ChannelNo);
@ -115,20 +170,21 @@ public partial class PlaybackPreviewWindow : Window
Panel.SetZIndex(panel, stream.Layout.ZIndex); Panel.SetZIndex(panel, stream.Layout.ZIndex);
Canvas.Children.Add(panel); Canvas.Children.Add(panel);
var session = new Session { Stream = stream, Image = image, Status = status }; _sessions.Add(new Session
try
{ {
session.Handle = ffmpeg.OpenUrl(url, Stream = stream,
$"{credential.Host}|{stream.ChannelNo}|{stream.StartTime.ToUnixTimeSeconds()}|{stream.EndTime.ToUnixTimeSeconds()}"); RtspUrl = url,
_sessions.Add(session); OpenKey = $"{credential.Host}|{stream.ChannelNo}|{stream.StartTime.ToUnixTimeSeconds()}|{stream.EndTime.ToUnixTimeSeconds()}",
} Image = image,
catch (Exception ex) Status = status,
{ OpenedAt = Environment.TickCount64,
status.Text = $"{stream.DisplayName} 打开失败:{ex.Message}"; 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 = new DispatcherTimer(DispatcherPriority.Render) { Interval = TimeSpan.FromMilliseconds(FrameIntervalMs) };
_timer.Tick += OnTick; _timer.Tick += OnTick;
_timer.Start(); _timer.Start();
@ -136,54 +192,198 @@ public partial class PlaybackPreviewWindow : Window
Closed += (_, _) => DisposeSessions(); 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) 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) 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 秒还没出帧:大概率这段时间没录像 session.Status.Text = $"{session.Stream.DisplayName} 没有画面(该时段可能没有录像)";
if (session.Image.Source is null && (DateTime.Now - session.StartedAt).TotalSeconds > 12) session.Finished = true;
{ }
session.Status.Text = $"{session.Stream.DisplayName} 没有画面(该时段可能没有录像)"; }
session.Finished = true;
} var pending = _sessions.Where(item => !item.Finished && item.Handle > 0).ToList();
continue; 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 try
{ {
var bitmap = new BitmapImage(); var bitmap = new BitmapImage();
bitmap.BeginInit(); bitmap.BeginInit();
bitmap.CacheOption = BitmapCacheOption.OnLoad; bitmap.CacheOption = BitmapCacheOption.OnLoad;
bitmap.StreamSource = new System.IO.MemoryStream(frame); bitmap.StreamSource = new System.IO.MemoryStream(picked);
bitmap.EndInit(); bitmap.EndInit();
bitmap.Freeze(); bitmap.Freeze();
session.Image.Source = bitmap; 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 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() private void DisposeSessions()
{ {
@ -191,6 +391,14 @@ public partial class PlaybackPreviewWindow : Window
foreach (var session in _sessions) 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; if (session.Handle <= 0 || _ffmpeg is null) continue;
try try
{ {