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;
///
/// 多路回放预览:**按扫码当时工作台的画布布局**把几路回放摆在一起播
///
/// 做法(和网页端预览一条路):
/// ffmpeg 按时间拉 RTSP 回放 → 转 MJPEG → 每帧取最新一张贴到 。
/// 不解码到窗口,所以可以同时播很多路;坏处是 CPU 比硬解高一点。
///
/// **几路怎么对齐**(现场反馈:两路开播时间差好几秒,画面错开):
/// 各路 RTSP 建链有快有慢,先出帧的那路会一直"跑在前面"。这里的做法是
/// **先一起等、再按帧一起放**:
/// 1. ffmpeg 每出一帧就回调一次(),按顺序进各自的队列
/// —— 不能"定时取最新一帧",否则开头那串关键帧会被整段丢掉,两路就差出秒级;
/// 2. 每一路都出过第一帧后(或判定没录像)才开始播,每 从每路队列
/// **各取一帧**,先上线的那路就是从头放队列里的积压 —— 几路天然停在同一个内容位置;
/// 3. 队列超过 帧(设备推得比实时快)就丢到
/// 帧,避免越播越晚;
/// 4. **以最长的那一路为准收尾**:各路从自己的关键帧起推,内容长度本来就不一样
/// (实测同一个 8 秒请求:20fps 那路是 8.0 秒、25fps 那路是 9.0 秒),
/// 谁先播完谁停在最后一帧,等最长的那路播完再一起收尾 —— 不按请求窗口把长的那段切掉。
///
/// 布局直接从后端快照来(canvasWidth/Height + 每路的 x/y/width/height),
/// 用 等比缩放,窗口多大都不变形。
///
public partial class PlaybackPreviewWindow : Window
{
/// 取帧频率(ms):40ms ≈ 25fps,与设备帧率一致
private const int FrameIntervalMs = 40;
/// 超过这么久还没出第一帧:当这路没有录像
private const int FirstFrameTimeoutMs = 12000;
/// 单路队列上限(≈9 秒):等同步时的积压最多留这么多
private const int MaxQueuedFrames = 220;
/// 超过上限时丢到这个深度(≈2 秒),别让播放越拖越晚
private const int CatchUpFrames = 50;
/// 队列空了、且这么久没再收到新帧 → 这一路的内容播完了(尾巴留短一点,别让结束前干等)
private const int StallMs = 1500;
///
/// 硬上限:请求窗口再多留这么久。
/// 录像机不保证按 endtime 断流,万一某一路一直推,不能让窗口永远关不掉。
///
private const int MaxTailMs = 15000;
private readonly List _sessions = new();
private readonly DispatcherTimer? _timer;
private readonly HikFfmpegService? _ffmpeg;
/// 各路是否已经算出对齐延迟(都出过第一帧,或已判定没画面)
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; }
/// 帧订阅(ffmpeg 每出一帧回调一次,不丢帧)
public IDisposable? Subscription { get; set; }
/// 缓冲区锁:帧回调在 ffmpeg 线程,渲染在 UI 线程
public object Sync { get; } = new();
/// 是否已经提示过「已就绪,等待同步」
public bool ReadyShown { get; set; }
/// 待显示的帧队列(**按内容顺序**,每 tick 取一帧)
public Queue Buffer { get; } = new();
/// 第一帧到达时间(TickCount64);-1 = 还没出帧
public long FirstFrameAt { get; set; } = -1;
/// 最后一帧到达时间(TickCount64):用来判断这一路的内容是不是已经推完了
public long LastFrameAt { get; set; } = -1;
public long OpenedAt { get; init; }
/// 请求的回放时长(窗口);播到这里就该停
public TimeSpan Window { get; init; }
/// 窗口播完(画面停在最后一帧)
public bool Ended { get; set; }
/// 没画面 / 打开失败
public bool Finished { get; set; }
public long LastShownSecond { get; set; } = -1;
}
/// 要播的回放流(同一工作台的一批)
/// MJPEG 管线
/// 回放服务(生成 RTSP 地址)
/// nvrId → 凭据
public PlaybackPreviewWindow(IReadOnlyList streams,
HikFfmpegService ffmpeg, HikPlaybackService playback, IReadOnlyDictionary 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);
}
///
/// 内容播完就收:**总时长取最长的那一路**,不按请求窗口把长的那段切掉。
///
/// 各路是从自己的关键帧起推的,同样 8 秒的请求,20fps 那路只有 8.0 秒、25fps 那路有 9.0 秒,
/// 所以这里不看窗口,而是看「队列空了 + 这么久没再收到新帧」判定这一路到底了;
/// 先播完的保持最后一帧,等所有路都播完再关窗(外加一个 Window + 的硬上限)。
///
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;
}
/// 等每一路都出过第一帧(或判定没录像)→ 统一开始按帧播放
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();
}
}