packServer/desktop/Services/Hik/HikStreamService.cs

367 lines
14 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.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading;
namespace YuncangTrace.LocalService.Services.Hik;
/// <summary>
/// 取实时码流 + 本地解码(25fps 的预览就是靠它)。
///
/// 链路:<c>NET_DVR_RealPlay_V40</c>(8000 私有协议,TCP)→ 回调收到 PS 流 →
/// <c>PlayM4_InputData</c> 解码 → <c>PlayM4_GetJPEG</c> 取当前帧交给浏览器。
///
/// 与「抓帧」模式的差别(实测):
/// - 抓帧:设备端编码 JPEG,**上限约 5fps**(1080p 每帧 ~190ms),只适合低频快照;
/// - 解码:一路码流持续解码,可稳稳跑到设备实际帧率(本项目 25fps),
/// 代价是本机多一个解码线程、设备多一路预览连接。
///
/// 子码流(<paramref name="streamType"/> = 1)默认,因为预览流畅度优先、带宽小;
/// 要看细节可以传 0 走主码流。
/// </summary>
public sealed class HikStreamService : IDisposable
{
/// <summary>PlayM4 缓冲区(2MB,够 1080p 一段 GOP)</summary>
private const uint BufferPoolSize = 2 * 1024 * 1024;
/// <summary>取帧用的 JPEG 缓冲区(4MB)</summary>
private const uint JpegBufferSize = 4 * 1024 * 1024;
private readonly HikDeviceService _device;
private readonly ConcurrentDictionary<int, StreamSession> _streams = new();
/// <summary>复用键(host:port|user|channel|streamType|模式)→ 句柄</summary>
private readonly Dictionary<string, int> _byKey = new(StringComparer.OrdinalIgnoreCase);
/// <summary>串行化 Open/Close,避免两个浏览器同时申请同一通道时各开一路</summary>
private readonly object _gate = new();
private bool _disposed;
public HikStreamService(HikDeviceService device)
{
_device = device;
}
/// <summary>当前打开的码流数(排障用)</summary>
public int Count => _streams.Count;
/// <summary>
/// 打开一路实时流,返回句柄(NET_DVR_RealPlay_V40 的返回值)
/// </summary>
/// <param name="streamType">0-主码流,1-子码流</param>
/// <param name="renderWnd">
/// 渲染窗口句柄:<c>IntPtr.Zero</c> = 只解码(配合 <see cref="GetJpeg"/> 推给浏览器);
/// 传窗口句柄 = 解码器直接画到窗口,**满帧率(设备 25fps)且不经过 JPEG 编码**。
/// </param>
public int Open(string host, int port, string userName, string password, int channel, int streamType = 0, string? name = null, IntPtr renderWnd = default)
{
if (channel <= 0) throw new ArgumentException("channel 必须是正整数");
var finalStreamType = streamType == 1 ? 1 : 0;
var mode = renderWnd == IntPtr.Zero ? "decode" : "window";
var key = $"{host.Trim().ToLowerInvariant()}:{port}|{userName}|{channel}|{finalStreamType}|{mode}";
lock (_gate)
{
// 同一通道 + 同一码流已经在拉:直接复用,RefCount+1。
// 不这么做的话,每开一次预览就多一路 realplay,设备/摄像头很快到达并发上限,
// 新开的那一路拿到的是“没有数据的流”,页面就卡在“画面中断”(实测踩过)。
if (renderWnd == IntPtr.Zero && _byKey.TryGetValue(key, out var existing) && _streams.TryGetValue(existing, out var alive))
{
alive.RefCount++;
alive.Touch();
AppLog.Write($"实时流复用:{host} 通道 {channel}({(finalStreamType == 0 ? "主码流" : "子码流")})handle={existing} 引用数={alive.RefCount}");
return existing;
}
var handle = CreateStream(host, port, userName, password, channel, finalStreamType, name, renderWnd, key);
return handle;
}
}
private int CreateStream(string host, int port, string userName, string password, int channel, int finalStreamType, string? name, IntPtr renderWnd, string key)
{
// 复用登录会话(不重复登录设备),密码错在这里就会抛
var userId = _device.EnsureUser(host, port, userName, password);
var session = new StreamSession();
if (!PlayM4.PlayM4_GetPort(out var playPort))
{
throw new HikException(HikSdk.NET_DVR_GetLastError(), "PlayM4 取解码端口失败(PlayCtrl.dll 是否随 SDK 一起安装?)");
}
session.PlayPort = playPort;
session.Name = name;
session.RenderWnd = renderWnd;
session.Key = key;
PlayM4.PlayM4_SetStreamOpenMode(playPort, PlayM4.STREAME_REALTIME);
var info = new HikSdk.NET_DVR_PREVIEWINFO
{
lChannel = channel,
dwStreamType = (uint)finalStreamType,
dwLinkMode = 0, // TCP
hPlayWnd = IntPtr.Zero, // 只要数据,不由 SDK 画
bBlocked = 0,
bPassbackRecord = 0,
byPreviewMode = 0,
byStreamID = new byte[32],
byProtoType = 0,
byVideoCodingType = 0,
dwDisplayBufNum = 0,
byRes = new byte[212],
};
session.Callback = session.OnRealData; // 必须持有引用,否则被 GC 后回调崩
var handle = HikSdk.NET_DVR_RealPlay_V40(userId, ref info, session.Callback, IntPtr.Zero);
if (handle < 0)
{
var err = HikSdk.NET_DVR_GetLastError();
PlayM4.PlayM4_FreePort(playPort);
throw new HikException(err, $"打开实时流失败:{HikSdk.DescribeError(err)}");
}
session.Handle = handle;
session.Host = host;
session.Channel = channel;
session.StreamType = finalStreamType;
session.RefCount = 1;
_streams[handle] = session;
if (renderWnd == IntPtr.Zero) _byKey[key] = handle;
AppLog.Write($"实时流已打开:{host} 通道 {channel}({(finalStreamType == 0 ? "主码流" : "子码流")},{(renderWnd == IntPtr.Zero ? "仅解码" : "窗口渲染")})handle={handle} port={playPort}");
return handle;
}
/// <summary>
/// 取当前帧 JPEG;尚无解码帧时返回空数组(调用方稍后重试即可)
/// </summary>
public byte[] GetJpeg(int handle, int timeoutMs = 800)
{
if (!_streams.TryGetValue(handle, out var session)) return Array.Empty<byte>();
var deadline = Environment.TickCount64 + Math.Max(timeoutMs, 0);
while (Environment.TickCount64 <= deadline)
{
if (TryReadJpeg(session, out var frame) && frame.Length > 0) return frame;
if (_disposed) break;
Thread.Sleep(15);
}
return Array.Empty<byte>();
}
private static bool TryReadJpeg(StreamSession session, out byte[] frame)
{
frame = Array.Empty<byte>();
var buffer = Marshal.AllocHGlobal((int)JpegBufferSize);
try
{
if (!PlayM4.PlayM4_GetJPEG(session.PlayPort, buffer, JpegBufferSize, out var size) || size == 0)
{
return false;
}
frame = new byte[size];
Marshal.Copy(buffer, frame, 0, frame.Length);
return true;
}
catch
{
return false;
}
finally
{
Marshal.FreeHGlobal(buffer);
}
}
/// <summary>解出来的画面尺寸(宽 x 高),拿不到返回 (0,0)</summary>
public (int Width, int Height) GetSize(int handle)
{
if (!_streams.TryGetValue(handle, out var session)) return (0, 0);
return PlayM4.PlayM4_GetPictureSize(session.PlayPort, out var width, out var height) ? (width, height) : (0, 0);
}
/// <summary>关闭一路实时流(引用计数减到 0 才真的停)</summary>
public bool Close(int handle)
{
lock (_gate)
{
if (!_streams.TryGetValue(handle, out var session)) return false;
session.RefCount--;
if (session.RefCount > 0)
{
AppLog.Write($"实时流释放引用:handle={handle} 剩余={session.RefCount}");
return true;
}
_streams.TryRemove(handle, out _);
if (!string.IsNullOrEmpty(session.Key) && _byKey.TryGetValue(session.Key, out var mapped) && mapped == handle)
{
_byKey.Remove(session.Key);
}
try
{
HikSdk.NET_DVR_StopRealPlay(handle);
}
catch
{
// 退出阶段忽略
}
try
{
PlayM4.PlayM4_Stop(session.PlayPort);
PlayM4.PlayM4_CloseStream(session.PlayPort);
PlayM4.PlayM4_FreePort(session.PlayPort);
}
catch
{
// 忽略
}
AppLog.Write($"实时流已关闭:{session.Host} 通道 {session.Channel} handle={handle}");
return true;
}
}
public void CloseAll()
{
foreach (var handle in _streams.Keys.ToList())
{
Close(handle);
}
}
public void Dispose()
{
if (_disposed) return;
_disposed = true;
CloseAll();
}
/// <summary>一路实时流的状态(回调线程与 HTTP 线程共用)</summary>
private sealed class StreamSession
{
private readonly object _sync = new();
private byte[]? _systemHeader;
private bool _opened;
private bool _openFailed;
private bool _loggedFirstPacket;
public int Handle { get; set; }
public int PlayPort { get; set; }
public string Host { get; set; } = string.Empty;
public int Channel { get; set; }
public int StreamType { get; set; }
/// <summary>复用键(window 模式不参与复用,Key 为空)</summary>
public string Key { get; set; } = string.Empty;
/// <summary>有多少个预览会话在用它</summary>
public int RefCount { get; set; }
/// <summary>最近使用时间(配速/排障用)</summary>
public long LastUsedTicks { get; private set; } = Environment.TickCount64;
public void Touch() => LastUsedTicks = Environment.TickCount64;
/// <summary>渲染窗口(0 = 只解码不出图)</summary>
public IntPtr RenderWnd { get; set; }
public string? Name { get; set; }
/// <summary>回调委托(必须由本对象持有,避免被 GC 回收)</summary>
public HikSdk.RealDataCallback? Callback { get; set; }
/// <summary>SDK 网络线程回调:拿到 PS 流喂给 PlayM4</summary>
public void OnRealData(int lRealHandle, uint dwDataType, IntPtr pBuffer, uint dwBufSize, IntPtr pUser)
{
try
{
// 首次回调记一笔(排障:主码流打不开时能看出是没数据还是没解码)
if (!_loggedFirstPacket)
{
_loggedFirstPacket = true;
AppLog.Write($"实时流首包:通道 {Channel}({(StreamType == 0 ? "主码流" : "子码流")})type={dwDataType} size={dwBufSize}");
}
switch (dwDataType)
{
case 1: // 系统头(PS 头),打开流时一起交给解码器
lock (_sync)
{
_systemHeader = new byte[dwBufSize];
Marshal.Copy(pBuffer, _systemHeader, 0, (int)dwBufSize);
}
return;
case 2: // 流数据
break;
default:
return;
}
if (!EnsureOpened()) return;
// 直接指向 SDK 的缓冲区,解码器会拷走
PlayM4.PlayM4_InputData(PlayPort, pBuffer, dwBufSize);
}
catch (Exception ex)
{
if (!_openFailed)
{
_openFailed = true;
AppLog.Write($"实时流解码失败(通道 {Channel}):{ex.Message}");
}
}
}
private bool EnsureOpened()
{
if (_opened) return true;
lock (_sync)
{
if (_opened) return true;
var header = _systemHeader ?? Array.Empty<byte>();
var headerPtr = IntPtr.Zero;
try
{
if (header.Length > 0)
{
headerPtr = Marshal.AllocHGlobal(header.Length);
Marshal.Copy(header, 0, headerPtr, header.Length);
}
// 没拿到系统头也要开(PS 流的第一包自带头)
if (!PlayM4.PlayM4_OpenStream(PlayPort, headerPtr, (uint)header.Length, BufferPoolSize))
{
_openFailed = true;
AppLog.Write($"PlayM4 打开流失败:通道 {Channel} port={PlayPort} 头长度={header.Length}");
return false;
}
PlayM4.PlayM4_Play(PlayPort, RenderWnd); // 0 = 只解码不显示;有句柄 = 直接画到窗口(满帧)
_opened = true;
AppLog.Write($"PlayM4 已开流:通道 {Channel} port={PlayPort} 头长度={header.Length} 模式={(RenderWnd == IntPtr.Zero ? "仅解码" : "窗口")}");
return true;
}
finally
{
if (headerPtr != IntPtr.Zero) Marshal.FreeHGlobal(headerPtr);
}
}
}
}
}