packServer/desktop/Views/PlaybackPreviewWindow.xaml.cs
liufumingren fd2ed16033 多路回放/预览改为以最长的那一路为准收尾
各路是从自己的关键帧起推的,同样 8 秒的请求,20fps 那路只有 8.0 秒、
25fps 那路有 9.0 秒。按请求窗口统一截断会把长的那段尾巴切掉,
不截断又会一直往后播。

- 预览窗口:按「队列空了 + 1.5 秒没再收到新帧」判定这一路播完,
  且必须播过窗口 80% 才认(中间网络卡一下不能当播完);
  先播完的定格最后一帧,等全部播完再释放设备会话;
  另有 Window + 15 秒硬上限,防止录像机一直推流
- 标题显示「回放结束(Xs)」,X 是最长那路的实际时长
- 合并下载:总时长取各段真实时长中最长的一段(读 ffmpeg 的 Duration:),
  短的那格在 overlay 里定格最后一帧

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

447 lines
18 KiB
C#
Raw Permalink 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"/> 帧,避免越播越晚;
/// 4. **以最长的那一路为准收尾**:各路从自己的关键帧起推,内容长度本来就不一样
/// (实测同一个 8 秒请求:20fps 那路是 8.0 秒、25fps 那路是 9.0 秒),
/// 谁先播完谁停在最后一帧,等最长的那路播完再一起收尾 —— 不按请求窗口把长的那段切掉。
///
/// 布局直接从后端快照来(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;
/// <summary>队列空了、且这么久没再收到新帧 → 这一路的内容播完了(尾巴留短一点,别让结束前干等)</summary>
private const int StallMs = 1500;
/// <summary>
/// 硬上限:请求窗口再多留这么久。
/// 录像机不保证按 endtime 断流,万一某一路一直推,不能让窗口永远关不掉。
/// </summary>
private const int MaxTailMs = 15000;
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;
/// <summary>最后一帧到达时间(TickCount64):用来判断这一路的内容是不是已经推完了</summary>
public long LastFrameAt { 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.LastFrameAt = 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);
// ④ 以**最长的那一路**为准收尾:先播完的停在最后一帧,等长的那路播完再一起停
StopFinishedSessions(now);
}
/// <summary>
/// 内容播完就收:**总时长取最长的那一路**,不按请求窗口把长的那段切掉。
///
/// 各路是从自己的关键帧起推的,同样 8 秒的请求,20fps 那路只有 8.0 秒、25fps 那路有 9.0 秒,
/// 所以这里不看窗口,而是看「队列空了 + 这么久没再收到新帧」判定这一路到底了;
/// 先播完的保持最后一帧,等所有路都播完再关窗(外加一个 Window + <see cref="MaxTailMs"/> 的硬上限)。
/// </summary>
private void StopFinishedSessions(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;
var drained = QueueDepth(session) == 0;
var stalled = session.LastFrameAt >= 0 && now - session.LastFrameAt > StallMs;
// 只有播到窗口的 80% 之后才认「推完了」:中间网络卡一下(>1.5 秒没包)不能当播完
var nearEnd = session.Window <= TimeSpan.Zero
|| elapsed >= session.Window.TotalMilliseconds * 0.8;
var overrun = session.Window > TimeSpan.Zero
&& elapsed > session.Window.TotalMilliseconds + MaxTailMs;
if (!overrun && !(drained && stalled && nearEnd)) continue;
session.Ended = true;
lock (session.Sync)
{
session.Buffer.Clear();
}
// 画面**保留最后一帧**(不清 Image),等最长的那路播完一起收尾
session.Status.Text = $"{session.Stream.DisplayName} 已播完({elapsed / 1000.0:0.0}s)";
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} · 回放结束({elapsed / 1000.0:0.0}s)";
}
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();
}
}