packServer/desktop/Views/PlaybackPreviewWindow.xaml.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

416 lines
16 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.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using YuncangTrace.LocalService.Services;
using YuncangTrace.LocalService.Services.Hik;
namespace YuncangTrace.LocalService.Views;
/// <summary>
/// 多路回放预览:**按扫码当时工作台的画布布局**把几路回放摆在一起播
///
/// 做法(和网页端预览一条路):
/// 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>
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; }
/// <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>
/// <param name="ffmpeg">MJPEG 管线</param>
/// <param name="playback">回放服务(生成 RTSP 地址)</param>
/// <param name="credentials">nvrId → 凭据</param>
public PlaybackPreviewWindow(IReadOnlyList<PackStream> streams,
HikFfmpegService ffmpeg, HikPlaybackService playback, IReadOnlyDictionary<int, NvrCredential> credentials)
{
InitializeComponent();
_ffmpeg = ffmpeg;
if (streams.Count == 0)
{
TitleText.Text = "没有可播放的回放流";
return;
}
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;
Canvas.Width = canvasWidth;
Canvas.Height = canvasHeight;
var first = streams[0];
_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);
// 自动把本机时间平移成录像机时间(时钟偏差会让回放错位)
var url = playback.BuildRtspUrlFor(credential.Host, credential.Port,
credential.Username, credential.Password, logical,
stream.StartTime, stream.EndTime, stream.StreamType);
// 布局:宽高为 0 表示占满整张画布
var width = stream.Layout.Width > 0 ? stream.Layout.Width : canvasWidth;
var height = stream.Layout.Height > 0 ? stream.Layout.Height : canvasHeight;
var image = new Image { Stretch = System.Windows.Media.Stretch.Uniform };
var status = new TextBlock
{
Text = $"{stream.DisplayName} 连接中…",
Foreground = System.Windows.Media.Brushes.White,
Background = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromArgb(140, 0, 0, 0)),
Padding = new Thickness(4, 1, 4, 1),
FontSize = 12,
HorizontalAlignment = HorizontalAlignment.Left,
VerticalAlignment = VerticalAlignment.Top,
};
var host = new Grid();
host.Children.Add(image);
host.Children.Add(status);
var panel = new Border
{
Width = width,
Height = height,
Background = System.Windows.Media.Brushes.Black,
Child = host,
BorderBrush = System.Windows.Media.Brushes.Gray,
BorderThickness = new Thickness(1),
};
Canvas.SetLeft(panel, stream.Layout.X);
Canvas.SetTop(panel, stream.Layout.Y);
Panel.SetZIndex(panel, stream.Layout.ZIndex);
Canvas.Children.Add(panel);
_sessions.Add(new Session
{
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();
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 (session.Finished || session.FirstFrameAt >= 0) continue;
if (now - session.OpenedAt > FirstFrameTimeoutMs)
{
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} 已就绪,等待同步…";
}
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(picked);
bitmap.EndInit();
bitmap.Freeze();
session.Image.Source = bitmap;
}
catch
{
// 半帧/坏帧直接丢掉,下一帧再说
}
}
// ⚠️ 这个秒数只是**本机出图节奏**(从对齐那一刻算起),两路相同不代表画面内容是同一时刻;
// 内容是否对齐只能看画面里烧的 OSD 或画面本身,别拿这个当对齐证据。
var elapsed = (now - _alignedAt) / 1000;
if (elapsed != session.LastShownSecond)
{
session.LastShownSecond = elapsed;
session.Status.Text = $"{session.Stream.DisplayName} {elapsed}s";
}
}
private void DisposeSessions()
{
_timer?.Stop();
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
{
_ffmpeg.Close(session.Handle);
}
catch
{
// 关窗时忽略
}
session.Handle = 0;
}
_sessions.Clear();
}
}