using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using YuncangTrace.LocalService.Services.Hik;
using ZXing;
using ZXing.Common;
namespace YuncangTrace.LocalService.Services.Scan;
/// 一路面单摄像头的运行状态(界面展示用)
public sealed class LabelCameraRuntime
{
public int WorkstationId { get; init; }
public int CameraId { get; init; }
public string WorkstationName { get; init; } = string.Empty;
public string CameraName { get; init; } = string.Empty;
public string ChannelId { get; init; } = string.Empty;
public string ChannelName { get; init; } = string.Empty;
/// 工作台 → 摄像头 → 上报通道(**不含密码**)
public string Summary { get; init; } = string.Empty;
/// stopped / starting / running / error
public string State { get; set; } = "stopped";
public string StateText => State switch
{
"running" => "识别中",
"starting" => "启动中…",
"error" => "异常",
_ => "已停止",
};
/// 最近识别到的条码
public string LastCode { get; set; } = string.Empty;
///
/// 条码历史(旧 → 新,最多 4 个;末尾是**最后出现**的那个)。
/// 多张面单同框时靠它判断「这个码是新出现的,还是刚才就已经有了」。
///
public string RecentCodes { get; set; } = string.Empty;
///
/// **首次识别时间**:也就是这条记录真正上报/落库用的时间。
/// 面单一直摆在拍摄区不会刷新(重复命中不改时间),避免界面看起来「时间一直在跳」。
///
public DateTime? LastCodeAt { get; set; }
/// 最近一次命中的时间(同一张面单每秒都在刷新,只用于排障看摄像头是否在扫)
public DateTime? LastHitAt { get; set; }
/// 当前用的码流(主/子 + 分辨率),例如「主码流 2304x1296」
public string StreamText { get; set; } = string.Empty;
/// 最近一帧的解码耗时(毫秒,含透视矫正 + ZXing 解码;用来看机器吃不吃得消)
public double LastDecodeMs { get; set; }
/// 最近一帧的 CV 定位耗时(毫秒:找条码横带 + 估倾角;不含解码)
public double LastCvMs { get; set; }
/// 最近一帧走的是哪条路径(ROI / 退避跳过 / 整帧 / 扫角…):用来定位耗时尖峰
public string LastPath { get; set; } = string.Empty;
/// ROI 连续解失败次数(≥3 时进入隔帧退避)
public int RoiFailStreak { get; set; }
/// 同一个码连续解出的次数(≥3 时进入稳态退避,画面一变就清零)
public int SteadyHits { get; set; }
/// 从管道读到的总帧数(ffmpeg 实际产出,用来核对 `fps=8` 是否生效)
public long FramesRead { get; set; }
/// 读帧线程按 DecodeFps 限速后丢弃的帧数
public long FrameThrottled { get; set; }
/// 解码循环总共处理了多少帧
public long FramesDecoded { get; set; }
/// 等新帧花了多久(毫秒):≈ 1000/实际处理帧率 说明是「帧不够」,否则是处理慢
public double LastWaitMs { get; set; }
/// 两次取帧之间的完整周期(毫秒):含 CV、解码、上报等全部开销
public double LastLoopMs { get; set; }
/// 最近一帧自动定位到的条码区域(ROI w x h;定位失败时为「未定位」)
public string RoiText { get; set; } = string.Empty;
/// 最近一帧「透视矫正 + ZXing 解码」耗时(毫秒)
public double RoiRatio { get; set; }
/// 最近一次取到帧时积压了几帧(0=实时;>0 说明解码跟不上、这些旧帧被丢了)
public long FrameLag { get; set; }
/// 累计丢弃的旧帧数(读帧线程只保留最新一帧)
public long FrameDropped { get; set; }
/// 累计命中次数(含重复帧合并后的上报次数)
public long Hits { get; set; }
public string? LastError { get; set; }
public string LastCodeAtText => LastCodeAt?.ToString("MM-dd HH:mm:ss") ?? "—";
/// 最近一次命中的时间(精确到毫秒:面单每秒都在刷新,用来判断刷新是否及时)
public string LastHitAtText => LastHitAt?.ToString("HH:mm:ss.fff") ?? "—";
}
///
/// 面单摄像头识别 worker:按服务端下发的配置**拉流 → 解码 → 识别 → 上报**。
///
/// 链路(全部在后台服务进程里跑,与扫码枪链路互不影响):
///
/// ffmpeg(RTSP) → 原始灰度帧 → 条带裁剪 → ZXing 解码
/// → ScanService.ReportCameraScanAsync(写记录 + 立即上报 + 通知安卓播报)
///
///
/// 为什么用 ffmpeg 而不是 8000 私有协议:录像机/摄像头型号杂,RTSP 最通用,
/// 且 ffmpeg 已经随安装包发布(回放校验/合并也在用),不需要再引解码器。
///
/// 为什么要试多个通道号:RTSP 的通道序号是「1 起的相对序号」,而库里存的是**设备通道号**
/// (数字通道从 33 起)。换算需要问录像机(SDK 只有取流子进程能做),
/// 所以这里按候选依次试(`channelNo-32` → `channelNo`),成功后**记住**用过的序号。
///
public sealed class LabelScanWorker : IDisposable
{
///
/// 画面里「连续一段时间没有任何条码」超过这个时长,就认为面单真的被拿走了。
///
/// **这是「面单是否离开过」的唯一判据**,两个地方都用它:
/// - 识别线程:判断重新出现的是不是新一轮打包(),
/// 决定记录时间用新的还是沿用本轮首次;
/// - :判断要不要重新上报/播报(`CameraPresenceGap`)。
///
/// 为什么用「画面里有没有条码」而不是「有没有解出码」:接入 OpenCV 后 无候选 是可信的
/// (面单在视野里就一定有候选),而「解不出」还会发生在面单明明在场的时候(反光、遮一角)。
///
/// 数值 45 秒:正常打包时手挡、侧身取件一般不会让面单整个离开画面这么久;
/// 而开箱换货再封箱通常要一分钟以上,能识别成新一轮打包。
///
internal static readonly TimeSpan RepackAbsence = TimeSpan.FromSeconds(45);
/// 解码帧率:面单放进去会停住,6fps 足够,也不至于把机器 CPU 吃满
private const int DecodeFps = 6;
/// 条码合法性:4~64 位、只含常见条码字符、至少 6 位数字(压掉误识别噪声)
private static readonly Regex AllowPattern = new("^[0-9A-Za-z][0-9A-Za-z\\-_/]{3,63}$", RegexOptions.Compiled);
private readonly Func> _report;
private readonly Dictionary _runners = new(StringComparer.OrdinalIgnoreCase);
private readonly List _runtimes = new();
private readonly object _gate = new();
private bool _disposed;
/// 命中回调:(channelId, barcode, wsType) → 负责写入记录并通知安卓
public LabelScanWorker(Func> report)
{
_report = report;
}
/// 当前所有识别任务的状态(按 target 顺序)
public IReadOnlyList Runtimes
{
get
{
lock (_gate) return _runtimes.ToList();
}
}
/// 运行时状态变了(界面/状态文件据此刷新)
public event Action? Changed;
///
/// 按最新配置对账:新增的启动、配置变了的重建、消失的停掉。
/// 配置没变的不会被打断(拉配置每 5 分钟一次,不能每次都断流)。
///
public void Apply(IReadOnlyList targets)
{
if (_disposed) return;
var wanted = new HashSet(StringComparer.OrdinalIgnoreCase);
var runtimes = new List();
foreach (var target in targets)
{
// 摄像头停用/没有上报通道的直接跳过(服务端已经过滤过一遍,这里再兜一次)
if (!target.CameraEnabled || string.IsNullOrWhiteSpace(target.ChannelId))
{
AppLog.Write($"[label-scan] 跳过(摄像头停用或没有上报通道):{target.Summary}");
continue;
}
var key = KeyOf(target);
wanted.Add(key);
try
{
LabelCameraRunner runner;
var started = false;
lock (_gate)
{
if (!_runners.TryGetValue(key, out runner!) || !runner.Matches(target))
{
runner?.Stop();
_runners.Remove(key);
runner = new LabelCameraRunner(target, _report, RaiseChanged);
_runners[key] = runner;
started = true;
}
}
// 启动放在锁外:某一路拉流/建线程出问题,不能把整轮对账卡死或连累其它路
if (started)
{
runner.Start();
AppLog.Write($"[label-scan] 开始识别:{runner.Runtime.Summary}");
}
runtimes.Add(runner.Runtime);
}
catch (Exception ex)
{
// 一路失败不影响其它路:把半成品清掉,下一轮拉取会再试
lock (_gate) _runners.Remove(key);
AppLog.Write($"[label-scan] 启动识别失败:{target.Summary}:{ex.Message}");
}
}
List stale;
lock (_gate)
{
stale = _runners.Where(pair => !wanted.Contains(pair.Key)).Select(pair => pair.Value).ToList();
foreach (var key in _runners.Keys.Where(key => !wanted.Contains(key)).ToList()) _runners.Remove(key);
_runtimes.Clear();
_runtimes.AddRange(runtimes);
}
foreach (var runner in stale)
{
runner.Stop();
AppLog.Write($"[label-scan] 停止识别:{runner.Runtime.Summary}");
}
RaiseChanged();
}
/// 全部停掉(服务停止/关闭设备服务)
public void StopAll()
{
List all;
lock (_gate)
{
all = _runners.Values.ToList();
_runners.Clear();
_runtimes.Clear();
}
foreach (var runner in all) runner.Stop();
RaiseChanged();
}
private void RaiseChanged() => Changed?.Invoke();
private static string KeyOf(LabelCameraTarget target) => $"{target.WorkstationId}|{target.CameraId}|{target.ChannelId}";
/// 条码过滤(与扫码枪不同:摄像头误识别更多,所以字符集和长度都卡一下)
internal static string? CleanBarcode(string? raw)
{
if (string.IsNullOrWhiteSpace(raw)) return null;
var text = raw.Trim();
if (!AllowPattern.IsMatch(text)) return null;
var digits = text.Count(char.IsDigit);
return digits >= 6 ? text : null;
}
public void Dispose()
{
if (_disposed) return;
_disposed = true;
StopAll();
}
}
/// 一路摄像头的拉流 + 识别循环(ffmpeg 子进程 + 独立线程)
internal sealed class LabelCameraRunner
{
private const int ConnectTimeoutMs = 6000;
private const int ReconnectDelayMs = 3000;
///
/// 解码帧率:面单放进去会停住,8fps 足够(主码流单帧解码+识别约 15~45ms,吃得下)。
/// 帧率越高,面单放上去到识别的延迟越小。
///
private const int DecodeFps = 8;
///
/// 命中后连续多少帧「还是同一张面单」就进入稳态退避(隔帧检测)。
/// 面单一直摆着不动时每帧都跑检测是白花的。
///
private const int SteadyBackoffAfter = 3;
///
/// 连续多少帧「检测/解码都没结果」就进入失败退避(隔帧检测)。
/// 画面里没面单时不必每帧都跑完整的检测 + 解码。
///
private const int FailBackoffAfter = 3;
///
/// 退避时每 N 帧只检 N-1 帧之外的奇数帧(隔帧)。
/// 用帧序号的奇偶而不是时间:解码本身耗时稳定,帧序号更简单也更好预测。
///
private const int BackoffFrameModulo = 2;
///
/// 画面变化检测:整帧压成 32x18 块均值。退避期间靠它判断「有东西放进来/面单被拿走」,
/// 一旦变化就立刻恢复每帧检测,不会因为退避而漏掉新面单。
///
private const int SceneGridX = 32;
private const int SceneGridY = 18;
private const int SceneCellSamples = 4;
///
/// 缩略图平均灰度差超过这个值就认为画面变了。
/// 实测:传感器噪声 1.97~2.11;有物体进入画面 12.09。取 6.0 两头都留了余量。
///
private const double SceneChangeMeanDiff = 6.0;
/// 主码流 / 子码流的 RTSP 后缀(`Streaming/Channels/{序号}01|02`)
private const string MainStreamSuffix = "01";
private const string SubStreamSuffix = "02";
///
/// 子码流能用多小:实测这台录像机子码流是 800x448,条码只有 1.8px/模块,**读不出来**;
/// 1152x648 / 1280x720 能读。所以宽度够 1080 才用子码流(拉流解码开销只有主码流的 1/7)。
///
private const int MinSubStreamWidth = 1080;
/// 数字通道偏移:设备通道号从 33 起 → 64 号通道通常是 RTSP 第 32 路
private const int DigitalChannelOffset = 32;
private readonly LabelCameraTarget _target;
private readonly Func> _report;
private readonly Action _changed;
private readonly CancellationTokenSource _cts = new();
private Thread? _thread;
///
/// 命中后要上报的条码队列(**扫描线程只入队,不等结果**)。
/// 上报里有写记录文件、触发上传、通知安卓等动作,任何一个慢都不该拖住拉流和识别。
/// 容量小 + 满了丢最旧:识别出来的是「面单」,积压的旧事件没有价值。
///
private readonly BlockingCollection _pendingReports = new(new ConcurrentQueue(), 8);
private Thread? _reportThread;
/// 当前正在跑的 ffmpeg 子进程( 要能立刻把它杀掉)
private Process? _process;
/// 一条待上报的识别结果
/// 这张面单是从「画面里一段时间没有任何条码」之后重新出现的(真重新打包)
private readonly record struct PendingReport(string Code, double DecodeMs, double CvMs, bool AfterAbsence);
/// 已确认可用的码流(成功后固定,重连不再重新探测——每次探测要 1 秒以上)
private static readonly Dictionary StreamCache = new(StringComparer.OrdinalIgnoreCase);
/// 选中的码流:RTSP 序号 + 主/子后缀 + 分辨率
private sealed record StreamChoice(int Index, string Suffix, int Width, int Height)
{
public string Profile => Suffix == SubStreamSuffix ? "子码流" : "主码流";
public string Text => $"{Profile} {Width}x{Height}";
}
/// 上一次命中的条码与时间(同一张面单连续命中时做节流)
private string _lastSeenCode = string.Empty;
private DateTime _lastReportAt = DateTime.MinValue;
/// 上一次真正写日志的条码(同一张面单每秒命中一次,不能每次都刷日志)
private string _lastLoggedCode = string.Empty;
/// 同一个码连续命中次数(达到 后隔帧检测)
private int _steadyHits;
///
/// 画面里「上一次有条码」的时刻(含解不出的候选)。
/// 用它判断面单是否真的离开过:离开超过 再回来,
/// 就是新一轮打包(装错了重新打包),记录时间要用新的。
///
private DateTime? _barcodeVisibleAt;
///
/// 检测到「面单离开过又回来」的时刻(锁存到第一次成功解码上报为止)。
/// 面单刚回到画面时可能连续几帧「有候选但解不出」,不能因此丢掉重新打包的标记。
///
private DateTime? _repackDetectedAt;
/// 连续多少帧没结果就隔帧检测(见 )
private int _failStreak;
/// 上一次成功解出的条码(用于判断「还是同一张面单」)
private string _lastHitCode = string.Empty;
///
/// 条码历史(旧 → 新,末尾 = 最后出现的那个)。
///
/// 为什么要有它:一帧里可能同时解出**多个**条码(两张面单并排)。
/// 只读一个必然漏单,而「谁先解出来」取决于检测器给的角点顺序、跟谁是新面单无关,
/// 所以必须记住刚才出现过哪些码,才能分辨出「刚进来的新码」和「一直在画面里的旧码」。
///
private readonly List<(string Code, DateTime At)> _codeHistory = new();
/// 上一帧看得见的码:区分「一直在画面里」和「离开又回来」,后者才算最后出现
private readonly HashSet _visibleLastFrame = new(StringComparer.Ordinal);
///
/// 条码历史保留条数。至少要 2 个才能做「新码 / 旧码」的对比;留 4 个是为了
/// 画面里同时出现两三张面单(或一两帧误读)时,不会把仍然在场的码挤出去、下一帧又被当成新码重报。
///
private const int CodeHistorySize = 4;
public LabelCameraRunner(LabelCameraTarget target, Func> report, Action changed)
{
_target = target;
_report = report;
_changed = changed;
Runtime = new LabelCameraRuntime
{
WorkstationId = target.WorkstationId,
CameraId = target.CameraId,
WorkstationName = target.WorkstationName,
CameraName = target.CameraName,
ChannelId = target.ChannelId,
ChannelName = target.ChannelName,
Summary = target.Summary,
};
}
public LabelCameraRuntime Runtime { get; }
/// 配置是否一致(不一致就重建:换了 NVR/通道/码流都要重启)
public bool Matches(LabelCameraTarget target)
=> target.CameraId == _target.CameraId
&& target.ChannelId == _target.ChannelId
&& target.NvrHost == _target.NvrHost
&& target.NvrPort == _target.NvrPort
&& target.NvrUsername == _target.NvrUsername
&& target.NvrPassword == _target.NvrPassword
&& target.CameraChannelNo == _target.CameraChannelNo
&& target.StreamType == _target.StreamType;
public void Start()
{
// 扫描任务独占一条线程:拉流读取、识别、上报各走各的线程,谁慢都不拖别人
_thread = new Thread(() => LoopAsync().GetAwaiter().GetResult())
{
IsBackground = true,
Name = $"label-scan-{_target.CameraId}",
};
_thread.Start();
_reportThread = new Thread(ReportLoop) { IsBackground = true, Name = $"label-report-{_target.CameraId}" };
_reportThread.Start();
}
public void Stop()
{
try
{
_cts.Cancel();
// 直接杀掉 ffmpeg:只 Cancel 的话读帧线程还挂在管道读上,
// 要等下一帧/超时才退出——现场表现就是「取消掉的那路还在跑一会儿」。
TryKill(_process);
_pendingReports.CompleteAdding();
}
catch
{
// 忽略
}
SetState("stopped", null);
}
///
/// 上报线程:串行消费命中结果。
/// 扫描线程只负责 TryAdd,永远不等这一环(写记录、上报、通知安卓都可能慢)。
///
private void ReportLoop()
{
try
{
foreach (var pending in _pendingReports.GetConsumingEnumerable(_cts.Token))
{
try
{
var result = _report(_target.ChannelId, pending.Code, _target.WsType, pending.AfterAbsence).GetAwaiter().GetResult();
if (result.ScanTime is DateTime scanTime) Runtime.LastCodeAt = scanTime;
if (result.NewScan) Runtime.Hits++;
_changed();
if (result.NewScan || !string.Equals(pending.Code, _lastLoggedCode, StringComparison.Ordinal))
{
_lastLoggedCode = pending.Code;
AppLog.Write($"[label-scan] 识别到条码:{pending.Code}(通道 {_target.ChannelId}"
+ $",首次 {Runtime.LastCodeAtText},检测 {pending.CvMs:0.0}ms"
+ $",新记录={result.NewScan})");
}
}
catch (Exception ex)
{
AppLog.Write($"[label-scan] {Runtime.Summary} 上报识别结果失败:{ex.Message}");
}
}
}
catch (OperationCanceledException)
{
// 停机
}
catch (ObjectDisposedException)
{
// 停机
}
}
/// 把一次命中丢进上报队列(满了丢最旧的,扫描线程不阻塞)
private void EnqueueReport(string code, double decodeMs, double cvMs, bool afterAbsence)
{
if (_pendingReports.IsAddingCompleted) return;
var item = new PendingReport(code, decodeMs, cvMs, afterAbsence);
while (!_pendingReports.TryAdd(item))
{
if (!_pendingReports.TryTake(out _)) break; // 丢掉最旧的一条后再试
if (_pendingReports.IsAddingCompleted) return;
}
}
private async Task LoopAsync()
{
var ct = _cts.Token;
var attempts = 0;
while (!ct.IsCancellationRequested)
{
Process? process = null;
try
{
SetState("starting", null);
var stream = await ResolveAndProbeAsync(ct).ConfigureAwait(false);
if (stream.Width <= 0 || stream.Height <= 0) throw new InvalidOperationException("拿不到码流分辨率");
Runtime.StreamText = stream.Text;
process = StartFfmpeg(stream);
_process = process;
SetState("running", null);
if (attempts > 0) AppLog.Write($"[label-scan] {Runtime.Summary} 已重新连上码流({stream.Text})");
attempts = 0;
DecodeLoop(process, stream, ct);
if (ct.IsCancellationRequested) break;
throw new InvalidOperationException("码流已断开");
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
attempts++;
SetState("error", ex.Message);
if (attempts <= 3 || attempts % 10 == 0)
{
AppLog.Write($"[label-scan] {Runtime.Summary} 识别失败({ex.Message}),{ReconnectDelayMs / 1000} 秒后重试"
+ (attempts > 1 ? $";已重试 {attempts} 次" : string.Empty));
}
}
finally
{
if (ReferenceEquals(_process, process)) _process = null;
TryKill(process);
}
try
{
await Task.Delay(ReconnectDelayMs, ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
break;
}
}
SetState("stopped", null);
}
///
/// 选码流 + 找到可用的 RTSP 序号 + 拿分辨率。
///
/// 选流规则:**子码流够大就用子码流**(拉流解码开销只有主码流的 1/7,识别更快也更省 CPU),
/// 太小就退回主码流 —— 条码像素不够时子码流根本解不出来
/// (实测这台录像机子码流 800x448,条码只有 1.8px/模块,读不出;1152x648 / 1280x720 能读)。
///
/// 序号要按候选试(见类注释),结果缓存起来,重连不再重新探测(每次探测要 1 秒以上)。
///
private async Task ResolveAndProbeAsync(CancellationToken ct)
{
var cacheKey = $"{_target.NvrHost}|{_target.NvrPort}|{_target.CameraChannelNo}";
if (StreamCache.TryGetValue(cacheKey, out var cached))
{
try
{
var size = await ProbeSizeAsync(BuildRtspUrl(cached.Index, cached.Suffix), ct).ConfigureAwait(false);
if (size.Width == cached.Width && size.Height == cached.Height) return cached;
}
catch
{
// 探测失败就重新走一遍候选
}
}
Exception? lastError = null;
foreach (var index in Candidates())
{
foreach (var suffix in new[] { SubStreamSuffix, MainStreamSuffix })
{
ct.ThrowIfCancellationRequested();
var url = BuildRtspUrl(index, suffix);
try
{
var size = await ProbeSizeAsync(url, ct).ConfigureAwait(false);
if (size.Width <= 0 || size.Height <= 0)
{
lastError = new InvalidOperationException($"序号 {index}{suffix} 没有取到画面");
continue;
}
if (suffix == SubStreamSuffix && size.Width < MinSubStreamWidth)
{
AppLog.Write($"[label-scan] {Runtime.Summary} 子码流只有 {size.Width}x{size.Height}"
+ "(条码像素不够,读不出来),改用主码流");
continue;
}
var choice = new StreamChoice(index, suffix, size.Width, size.Height);
StreamCache[cacheKey] = choice;
AppLog.Write($"[label-scan] {Runtime.Summary} 码流就绪:{choice.Text}(序号 {index}{suffix})");
return choice;
}
catch (Exception ex)
{
lastError = ex;
}
}
}
throw new InvalidOperationException(lastError?.Message ?? "所有通道序号都取不到码流");
}
/// 候选 RTSP 序号:先按「数字通道从 33 起」换算,再退回用原始通道号
private IEnumerable Candidates()
{
var channelNo = _target.CameraChannelNo;
var logical = channelNo - DigitalChannelOffset;
if (logical > 0 && logical != channelNo) yield return logical;
if (channelNo > 0) yield return channelNo;
}
/// ******host:554/Streaming/Channels/{序号}{01|02}
private string BuildRtspUrl(int streamIndex, string suffix)
=> $"rtsp://{Uri.EscapeDataString(_target.NvrUsername)}:{Uri.EscapeDataString(_target.NvrPassword)}"
+ $"@{_target.NvrHost}:554/Streaming/Channels/{streamIndex}{suffix}";
/// 用 ffmpeg 打开一次流,从 stderr 里读出分辨率(拿不到就当失败)
private static async Task<(int Width, int Height)> ProbeSizeAsync(string url, CancellationToken ct)
{
var ffmpeg = HikFfmpegService.ResolveFfmpeg()
?? throw new InvalidOperationException("未找到 ffmpeg(安装目录 native\\ffmpeg\\ffmpeg.exe 缺失)");
using var process = NewProcess(ffmpeg, new[]
{
"-hide_banner", "-nostdin", "-rtsp_transport", "tcp", "-timeout", "5000000",
"-loglevel", "info", "-i", url,
});
process.StartInfo.RedirectStandardError = true;
var text = new StringBuilder();
process.ErrorDataReceived += (_, e) =>
{
if (e.Data is not null && text.Length < 64 * 1024) text.AppendLine(e.Data);
};
process.Start();
process.BeginErrorReadLine();
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
timeout.CancelAfter(ConnectTimeoutMs);
try
{
await process.WaitForExitAsync(timeout.Token).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
TryKill(process);
throw new InvalidOperationException("连接码流超时");
}
var matched = Regex.Match(text.ToString(), @"Video:.*?,\s*(\d{2,5})x(\d{2,5})");
if (!matched.Success) return (0, 0);
return (int.Parse(matched.Groups[1].Value), int.Parse(matched.Groups[2].Value));
}
private Process StartFfmpeg(StreamChoice stream)
{
var ffmpeg = HikFfmpegService.ResolveFfmpeg()
?? throw new InvalidOperationException("未找到 ffmpeg");
var args = new List
{
"-hide_banner", "-nostdin", "-loglevel", "error",
"-rtsp_transport", "tcp", "-timeout", "5000000",
// 只开 2 个解码线程:默认的帧级多线程会把输出往后压好几帧
// (实测同一条流:默认线程 OSD 到本机 2.6s,2 线程只要 0.5s)。
// 输入 20fps、我们只要 8fps,单帧解码慢一点完全够。
"-threads", "2",
"-i", BuildRtspUrl(stream.Index, stream.Suffix),
"-an",
// 抽帧 + 转灰度 rawvideo 从 stdout 吐出:每帧正好 width*height 字节
"-vf", $"fps={DecodeFps}",
"-f", "rawvideo", "-pix_fmt", "gray",
"-s", $"{stream.Width}x{stream.Height}",
"pipe:1",
};
var process = NewProcess(ffmpeg, args);
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.Start();
// stderr 必须读掉,否则管道满了 ffmpeg 会卡住
process.ErrorDataReceived += (_, e) =>
{
if (string.IsNullOrWhiteSpace(e.Data) || IsNoisyFfmpegLine(e.Data)) return;
AppLog.Write($"[label-scan] ffmpeg({Runtime.CameraName}):{e.Data}");
};
process.BeginErrorReadLine();
return process;
}
///
/// 这台录像机的 HEVC 码流本身就会吐这些告警(画面照常解出来),
/// 不滤掉的话每帧刷屏、把有用的日志顶没了。
///
private static bool IsNoisyFfmpegLine(string line)
=> line.Contains("hevc @", StringComparison.OrdinalIgnoreCase)
|| line.Contains("Error constructing the frame RPS", StringComparison.OrdinalIgnoreCase)
|| line.Contains("Could not find ref with POC", StringComparison.OrdinalIgnoreCase)
|| line.Contains("PPS id out of range", StringComparison.OrdinalIgnoreCase)
|| line.Contains("Last message repeated", StringComparison.OrdinalIgnoreCase);
/// 逐帧读灰度图并识别(帧不完整/超时就当断流)
private void DecodeLoop(Process process, StreamChoice choice, CancellationToken ct)
{
var width = choice.Width;
var height = choice.Height;
var frameBytes = width * height;
var stream = process.StandardOutput.BaseStream;
var frameIndex = 0;
var decodeWatch = new Stopwatch();
// 三块缓冲轮转:pending(读帧线程写) / latest(最新一帧) / buffer(解码用),靠交换引用避免每帧 2MB 拷贝
var buffer = new byte[frameBytes];
var pending = new byte[frameBytes];
var latest = new byte[frameBytes];
var frameGate = new object();
var frameReady = false;
var readerDone = false;
long produced = 0;
long consumed = 0;
var frameSignal = new SemaphoreSlim(0, 1);
// ffmpeg 的 `-vf fps=8` 是生效的(实测管道里就是 8 帧/秒),这里的限速只用于
// 兜住「某些流真的吐出更多帧」的情况。留 20% 容差:帧间隔实测 119~125ms,
// 若按严格的 125ms 判定,会每两帧才放过一帧(把 8fps 砍成 4fps)。
var publishIntervalMs = 1000.0 / DecodeFps;
var publishThresholdMs = publishIntervalMs * 0.8;
// 常驻读帧线程(独占线程,不占线程池):始终把管道读空,只保留最新一帧,旧帧直接丢弃。
// 不这样做的话:解码一帧要 10~380ms,而管道里每秒有 20~30 帧,
// 帧会越积越多,等解码器拿到时画面已经是几秒前的了(现场出现过 >3 秒延迟)。
var readerThread = new Thread(ReadFrames)
{
IsBackground = true,
Name = $"label-reader-{_target.CameraId}",
};
void ReadFrames()
{
var lastPublish = Stopwatch.GetTimestamp();
try
{
while (!ct.IsCancellationRequested)
{
var filled = 0;
while (filled < frameBytes)
{
var read = stream.Read(pending, filled, frameBytes - filled);
if (read <= 0) return;
filled += read;
}
Runtime.FramesRead++;
var elapsedMs = (Stopwatch.GetTimestamp() - lastPublish) * 1000.0 / Stopwatch.Frequency;
if (elapsedMs < publishThresholdMs)
{
// 还没到下一个解码时刻:这帧只读不用
Runtime.FrameThrottled++;
continue;
}
lastPublish = Stopwatch.GetTimestamp();
lock (frameGate)
{
(pending, latest) = (latest, pending);
frameReady = true;
produced++;
}
if (frameSignal.CurrentCount == 0) frameSignal.Release();
}
}
catch
{
// 断流 / 按取消 / 进程被杀:交给解码循环退出
}
finally
{
lock (frameGate) readerDone = true;
try { if (frameSignal.CurrentCount == 0) frameSignal.Release(); } catch { /* 已释放 */ }
}
}
readerThread.Start();
// 画面变化检测的缩略图(32x18),用于退避期间判断什么时候该恢复全帧率
var sceneNow = new byte[SceneGridX * SceneGridY];
var scenePrev = new byte[SceneGridX * SceneGridY];
var hasScene = false;
// 每次(重)连上码流都重置:重连期间看不到画面,不能算成「面单离开过」
_barcodeVisibleAt = null;
_repackDetectedAt = null;
// OpenCV 条码检测器:整图输入,直接给出条码的四角点(带旋转/透视)。
// 复用同一个 Mat 承接每帧灰度数据(SetArray 是 2MB memcpy,约 0.2ms),避免每帧分配。
using var detector = new OpenCvSharp.BarcodeDetector();
using var frameMat = new OpenCvSharp.Mat(height, width, OpenCvSharp.MatType.CV_8UC1);
// ZXing 只负责解「已矫正成轴对齐」的条码小图,输入很小,所以选项可以全开
var reader = new BarcodeReaderGeneric
{
AutoRotate = true,
Options = new DecodingOptions
{
TryHarder = true,
// 只认 Code128:运单条码都是 Code128。开启 EAN13 会把包裹/商品上的
// 商品条码也读进来(实测读到过 13 位商品码),属于误报。
PossibleFormats = new[] { BarcodeFormat.CODE_128 },
},
};
var lastConsumeAt = 0L;
while (!ct.IsCancellationRequested)
{
var waitStart = Stopwatch.GetTimestamp();
// 同步等待(不 await):整块扫描任务始终跑在自己的独占线程上,
// 不会被切到线程池去排队,线程池忙也影响不到识别。
frameSignal.Wait(ct);
Runtime.LastWaitMs = (Stopwatch.GetTimestamp() - waitStart) * 1000.0 / Stopwatch.Frequency;
// 与「上一帧被取走」的间隔 = 完整的循环周期(含上报等所有开销)
var nowTicks = Stopwatch.GetTimestamp();
if (lastConsumeAt != 0)
{
Runtime.LastLoopMs = (nowTicks - lastConsumeAt) * 1000.0 / Stopwatch.Frequency;
}
lastConsumeAt = nowTicks;
Runtime.FramesDecoded++;
long lag;
lock (frameGate)
{
if (!frameReady)
{
if (readerDone) return;
continue;
}
(latest, buffer) = (buffer, latest);
frameReady = false;
lag = produced - consumed - 1;
consumed++;
}
// lag = 这一帧之前被丢掉了几帧:0 表示实时,越大说明解码越跟不上
Runtime.FrameLag = lag > 0 ? lag : 0;
if (lag > 0) Runtime.FrameDropped += lag;
frameIndex++;
decodeWatch.Restart();
// 画面变化检测(很便宜,整帧采样约 9000 个点):退避期间靠它判断什么时候恢复全帧率。
// 面单拿走/换新/有人手伸进来都会让它变化,于是立刻恢复每帧检测。
CaptureScene(buffer, width, height, sceneNow);
var sceneChanged = hasScene && SceneDiff(scenePrev, sceneNow) > SceneChangeMeanDiff;
if (sceneChanged)
{
_steadyHits = 0;
_failStreak = 0;
}
Buffer.BlockCopy(sceneNow, 0, scenePrev, 0, sceneNow.Length);
hasScene = true;
// 退避:① 同一个码连续命中(面单没动)② 连续没结果(画面里没面单)。
// 两种都隔帧检测;画面一变立刻恢复。
var backoffSkipped = frameIndex % BackoffFrameModulo != 0
&& (_steadyHits >= SteadyBackoffAfter || _failStreak >= FailBackoffAfter);
string? code = null;
var path = "退避";
var candidates = 0;
// 本帧解出的**所有**条码(去重、按解出顺序)。多张面单同框时一个都不能丢。
var frameCodes = new List(4);
if (!backoffSkipped)
{
decodeWatch.Restart();
// 整图检测:OpenCvSharp 的 BarcodeDetector 内部做梯度/多尺度搜索,
// 输出每个条码的 4 个角点(8 个 float 一组),天然带旋转和透视。
frameMat.SetArray(buffer);
detector.DetectAndDecode(frameMat, out var points, out _, out _);
candidates = points is null ? 0 : points.Length / 4;
// 「画面里有没有条码」是判断面单是否真的离开的唯一可靠信号(OpenCV 的 无候选 可信)。
// 离开超过 RepackAbsence 才重新出现 → 认定为真正的新一轮打包(例如装错了重新打包)。
var visibleAt = DateTime.Now;
if (candidates > 0)
{
if (_barcodeVisibleAt is DateTime lastVisible
&& visibleAt - lastVisible >= LabelScanWorker.RepackAbsence)
{
// 锁存:面单刚回来那几帧可能「有候选但解不出」(运动模糊),
// 不能因为后面又检测到就丢掉这个标记。
_repackDetectedAt = visibleAt;
}
_barcodeVisibleAt = visibleAt;
}
Runtime.LastCvMs = decodeWatch.Elapsed.TotalMilliseconds;
decodeWatch.Restart();
// ⚠️ 一帧里的**每个**候选都要解,不能解出第一个就停:
// 角点顺序由检测器决定,跟「哪张是新面单」没有关系,
// 只认第一个 → 两张面单并排时必然只报旧码、漏掉新码。
for (var i = 0; i < candidates; i++)
{
var text = DecodeQuad(reader, frameMat, points!, i,
out var warpW, out var warpH, out var rasterMs, out var decodeMs);
// 与扫码枪同一条合法性校验:条码长度/字符集不合规的不算命中(压掉误读)
var decoded = LabelScanWorker.CleanBarcode(text);
if (decoded is null) continue;
if (!frameCodes.Contains(decoded)) frameCodes.Add(decoded);
if (code is null)
{
code = decoded;
decodeWatch.Stop();
Runtime.LastDecodeMs = decodeWatch.Elapsed.TotalMilliseconds;
Runtime.RoiText = $"条码 {warpW}x{warpH}";
Runtime.RoiRatio = Math.Round(rasterMs + decodeMs, 2);
path = "OpenCV解码";
}
}
if (frameCodes.Count > 1) path = $"OpenCV解码x{frameCodes.Count}";
if (code is null)
{
decodeWatch.Stop();
Runtime.LastDecodeMs = decodeWatch.Elapsed.TotalMilliseconds;
Runtime.RoiText = candidates == 0 ? "无候选" : $"候选{candidates}个未解出";
Runtime.RoiRatio = 0;
path = candidates == 0 ? "无候选" : "候选未解出";
}
}
if (backoffSkipped)
{
path = _steadyHits >= SteadyBackoffAfter ? "稳态退避" : "失败退避";
}
// 条码历史:本帧解出的**每个**码(不管以前出现过没有)都刷新「最后出现时间」,
// 顺便算出哪些是历史里没有的新码
var now = DateTime.Now;
var fresh = RememberCodes(frameCodes, now);
var current = CurrentCode(frameCodes);
// 计数维护:命中就累计稳态、清失败;真跑过但没结果就累计失败、清稳态
if (current is not null)
{
_steadyHits = string.Equals(current, _lastHitCode, StringComparison.Ordinal) ? _steadyHits + 1 : 1;
_lastHitCode = current;
_failStreak = 0;
}
else if (!backoffSkipped && !sceneChanged)
{
_failStreak++;
_steadyHits = 0;
}
Runtime.LastPath = path;
Runtime.RoiFailStreak = _failStreak;
Runtime.SteadyHits = _steadyHits;
Runtime.RecentCodes = string.Join(" | ", _codeHistory.Select(x => x.Code));
if (frameCodes.Count == 0) continue;
// 这一帧是不是「面单离开过、刚回来」后的第一次上报(真正的新一轮打包)。
// 锁存时间最多认 60 秒:超过说明中间又走了别的流程,不再算这次重新打包。
var afterAbsence = _repackDetectedAt is DateTime repackAt
&& now >= repackAt
&& now - repackAt <= TimeSpan.FromSeconds(60);
if (afterAbsence) _repackDetectedAt = null;
// 上报规则(多码同框时按这个走):
// 1. **历史里没有的新码 → 立即上报**(同帧出现几个新码就报几个,一个都不漏);
// 2. 历史里已有的旧码 → 只刷新在场,不重复建档/播报;
// 3. 两个码都在历史里时,真正上报/续期的是**最后出现的那个**(current),
// 不是检测器先解出来的那个。
foreach (var item in frameCodes)
{
var isFresh = fresh.Contains(item);
var isCurrent = string.Equals(item, current, StringComparison.Ordinal);
if (!isFresh && !isCurrent) continue;
// 同一个码一直在画面里:节流到 500ms 一次,只续「在场」,不重复上报
if (!isFresh
&& string.Equals(item, _lastSeenCode, StringComparison.Ordinal)
&& (now - _lastReportAt).TotalMilliseconds < 500) continue;
ReportHit(item, afterAbsence, now);
}
}
}
///
/// 把本帧解出的条码登记进历史,返回「本帧新出现」的码。
///
/// 排序规则(末尾 = 最后出现的那个):
/// - **一直在画面里**的码(上一帧也看得见)只更新时间、**不重排** ——
/// 否则同框的两个码每帧按解出顺序互相顶掉,「当前码」就会来回跳、上报跟着抖;
/// - **离开过又回来**的码挪到末尾(它才是最后出现的那个);
/// - 超过 没再出现的码直接淘汰 ——
/// 之后再出现就是新的一轮打包,按新码上报(与 ScanService 的在场判定同一个阈值)。
///
private List RememberCodes(List frameCodes, DateTime now)
{
var fresh = new List(frameCodes.Count);
for (var i = _codeHistory.Count - 1; i >= 0; i--)
{
if (now - _codeHistory[i].At >= LabelScanWorker.RepackAbsence) _codeHistory.RemoveAt(i);
}
foreach (var item in frameCodes)
{
var index = _codeHistory.FindIndex(x => string.Equals(x.Code, item, StringComparison.Ordinal));
if (index < 0)
{
fresh.Add(item);
_codeHistory.Add((item, now));
continue;
}
if (_visibleLastFrame.Contains(item))
{
_codeHistory[index] = (item, now);
continue;
}
// 上一帧没看见 → 现在回来了:它就是「最后出现」的那个
_codeHistory.RemoveAt(index);
_codeHistory.Add((item, now));
}
_visibleLastFrame.Clear();
foreach (var item in frameCodes) _visibleLastFrame.Add(item);
while (_codeHistory.Count > CodeHistorySize)
{
// 淘汰最旧的那个,但**本帧还看得见的不能淘汰**:
// 淘汰掉的话下一帧它又成了「新码」,会被重复上报一次。
var evict = _codeHistory.FindIndex(x => !frameCodes.Contains(x.Code));
if (evict < 0) break;
_codeHistory.RemoveAt(evict);
}
return fresh;
}
///
/// 本帧的「当前码」= 需要上报/续期的那个:历史里**最后出现**、且本帧还看得见的码。
///
/// 两个码都在历史里时,这里给出的永远是后出现的那个,而不是检测器先解出来的那个。
///
private string? CurrentCode(List frameCodes)
{
for (var i = _codeHistory.Count - 1; i >= 0; i--)
{
if (frameCodes.Contains(_codeHistory[i].Code)) return _codeHistory[i].Code;
}
return null;
}
/// 记一次命中并丢进上报队列(扫描线程只入队,不等写记录/上报/通知安卓)
private void ReportHit(string code, bool afterAbsence, DateTime now)
{
_lastSeenCode = code;
_lastReportAt = now;
// 最近命中/最近条码每次都刷新,但「首次识别时间」只认记录里的时间(面单不拿走就不变)
Runtime.LastCode = code;
Runtime.LastHitAt = now;
Runtime.LastError = null;
EnqueueReport(code, Runtime.LastDecodeMs, Runtime.LastCvMs, afterAbsence);
}
///
/// 把 OpenCV 检测到的第 index 个四角点区域做透视矫正,交给 ZXing 解 Code128。
///
/// 为什么必须矫正:现场面单是**竖放或斜着**摆的(实测四角点 (433,602)(450,514)(1371,685)(1354,774)),
/// 1D 码要求扫描线完整穿过整条,轴对齐裁剪会把条码截断 → 必然解不出。
/// 矫正成轴对齐后条码完整,ZXing 一次就能读出。
///
private static string? DecodeQuad(
BarcodeReaderGeneric reader,
OpenCvSharp.Mat frame,
OpenCvSharp.Point2f[] points,
int index,
out int warpedWidth,
out int warpedHeight,
out double rasterMs,
out double decodeMs)
{
warpedWidth = 0;
warpedHeight = 0;
rasterMs = 0;
decodeMs = 0;
try
{
var offset = index * 4;
var quad = OrderCorners(
points[offset], points[offset + 1], points[offset + 2], points[offset + 3]);
var wTop = Distance(quad[0], quad[1]);
var wBottom = Distance(quad[3], quad[2]);
var hLeft = Distance(quad[0], quad[3]);
var hRight = Distance(quad[1], quad[2]);
var outW = Math.Max(8, (int)Math.Round(Math.Max(wTop, wBottom)));
var outH = Math.Max(8, (int)Math.Round(Math.Max(hLeft, hRight)));
// 太小的框是误检(实测真实条码矫正后约 937x90)
if (outW < 40 || outH < 20) return null;
warpedWidth = outW;
warpedHeight = outH;
var rasterWatch = Stopwatch.StartNew();
var source = new[] { quad[0], quad[1], quad[2], quad[3] };
var target = new[]
{
new OpenCvSharp.Point2f(0, 0),
new OpenCvSharp.Point2f(outW - 1, 0),
new OpenCvSharp.Point2f(outW - 1, outH - 1),
new OpenCvSharp.Point2f(0, outH - 1),
};
using var transform = OpenCvSharp.Cv2.GetPerspectiveTransform(source, target);
using var warped = new OpenCvSharp.Mat();
OpenCvSharp.Cv2.WarpPerspective(frame, warped, transform, new OpenCvSharp.Size(outW, outH));
warped.GetArray(out byte[] raster);
rasterWatch.Stop();
rasterMs = rasterWatch.Elapsed.TotalMilliseconds;
var decodeWatch = Stopwatch.StartNew();
var text = reader.Decode(new PlanarYUVLuminanceSource(raster, outW, outH, 0, 0, outW, outH, false))?.Text;
decodeWatch.Stop();
decodeMs = decodeWatch.Elapsed.TotalMilliseconds;
return text;
}
catch
{
return null;
}
}
private static double Distance(OpenCvSharp.Point2f a, OpenCvSharp.Point2f b)
=> Math.Sqrt(Math.Pow(a.X - b.X, 2) + Math.Pow(a.Y - b.Y, 2));
/// 把 4 个角点排成「左上、右上、右下、左下」,保证透视变换不翻面
private static OpenCvSharp.Point2f[] OrderCorners(
OpenCvSharp.Point2f p0, OpenCvSharp.Point2f p1, OpenCvSharp.Point2f p2, OpenCvSharp.Point2f p3)
{
var points = new[] { p0, p1, p2, p3 };
OpenCvSharp.Point2f topLeft = points[0], topRight = points[0], bottomRight = points[0], bottomLeft = points[0];
var minSum = double.MaxValue;
var maxSum = double.MinValue;
var minDiff = double.MaxValue;
var maxDiff = double.MinValue;
foreach (var point in points)
{
var sum = point.X + point.Y;
var diff = point.Y - point.X;
if (sum < minSum) { minSum = sum; topLeft = point; }
if (sum > maxSum) { maxSum = sum; bottomRight = point; }
if (diff < minDiff) { minDiff = diff; topRight = point; }
if (diff > maxDiff) { maxDiff = diff; bottomLeft = point; }
}
return new[] { topLeft, topRight, bottomRight, bottomLeft };
}
///
/// 把整帧压成 32x18 的块均值缩略图(每格 4x4 采样取平均,约 9000 个采样点,<0.1ms)。
/// 只用来判断「画面有没有变化」,不参与识别。
///
private static void CaptureScene(byte[] frame, int width, int height, byte[] target)
{
var cellWidth = Math.Max(1, width / SceneGridX);
var cellHeight = Math.Max(1, height / SceneGridY);
var stepX = Math.Max(1, cellWidth / SceneCellSamples);
var stepY = Math.Max(1, cellHeight / SceneCellSamples);
for (var gy = 0; gy < SceneGridY; gy++)
{
var y0 = gy * cellHeight;
var yEnd = Math.Min(y0 + cellHeight, height);
for (var gx = 0; gx < SceneGridX; gx++)
{
var x0 = gx * cellWidth;
var xEnd = Math.Min(x0 + cellWidth, width);
var sum = 0;
var count = 0;
for (var y = y0; y < yEnd; y += stepY)
{
var rowBase = y * width;
for (var x = x0; x < xEnd; x += stepX)
{
sum += frame[rowBase + x];
count++;
}
}
target[gy * SceneGridX + gx] = count > 0 ? (byte)(sum / count) : (byte)0;
}
}
}
/// 两张缩略图的平均灰度差(0~255)
private static double SceneDiff(byte[] previous, byte[] current)
{
var sum = 0;
for (var i = 0; i < previous.Length; i++)
{
var delta = previous[i] - current[i];
sum += delta < 0 ? -delta : delta;
}
return (double)sum / previous.Length;
}
private void SetState(string state, string? error)
{
var changed = Runtime.State != state || Runtime.LastError != error;
Runtime.State = state;
Runtime.LastError = error;
if (changed) _changed();
}
private static Process NewProcess(string fileName, IEnumerable args)
{
var info = new ProcessStartInfo(fileName)
{
// stdout/stderr 都由调用方按需打开;stdin 一定要重定向,避免子进程读控制台卡住
RedirectStandardInput = true,
UseShellExecute = false,
CreateNoWindow = true,
};
foreach (var arg in args) info.ArgumentList.Add(arg);
return new Process { StartInfo = info };
}
private static void TryKill(Process? process)
{
if (process is null) return;
try
{
if (!process.HasExited) process.Kill(entireProcessTree: true);
}
catch
{
// 忽略
}
finally
{
try
{
process.Dispose();
}
catch
{
// 忽略
}
}
}
}