827 lines
30 KiB
C#
827 lines
30 KiB
C#
using System.Net;
|
||
using System.Text;
|
||
using System.Collections.Concurrent;
|
||
using DotNext;
|
||
using DotNext.Threading;
|
||
|
||
namespace server.Services;
|
||
|
||
public class VideoStreamClient
|
||
{
|
||
public string? ClientId { get; set; } = string.Empty;
|
||
public bool IsEnabled { get; set; } = true;
|
||
public int FrameWidth { get; set; }
|
||
public int FrameHeight { get; set; }
|
||
public int FrameRate { get; set; }
|
||
public AsyncLazy<Peripherals.CameraClient.Camera> Camera { get; set; }
|
||
public CancellationTokenSource CTS { get; set; }
|
||
public readonly AsyncReaderWriterLock Lock = new();
|
||
|
||
public VideoStreamClient(
|
||
string clientId, int width, int height, AsyncLazy<Peripherals.CameraClient.Camera> camera)
|
||
{
|
||
ClientId = clientId;
|
||
FrameWidth = width;
|
||
FrameHeight = height;
|
||
FrameRate = 30;
|
||
Camera = camera;
|
||
CTS = new CancellationTokenSource();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 表示摄像头连接状态信息
|
||
/// </summary>
|
||
public class VideoStreamEndpoint
|
||
{
|
||
public required string BoardId { get; set; } = "";
|
||
public required string MjpegUrl { get; set; } = "";
|
||
public required string VideoUrl { get; set; } = "";
|
||
public required string SnapshotUrl { get; set; } = "";
|
||
public required string HtmlUrl { get; set; } = "";
|
||
public required string UsbCameraUrl { get; set; } = "";
|
||
|
||
public required bool IsEnabled { get; set; }
|
||
|
||
/// <summary>
|
||
/// 视频流的帧率（FPS）
|
||
/// </summary>
|
||
public required int FrameRate { get; set; }
|
||
|
||
public int FrameWidth { get; set; }
|
||
public int FrameHeight { get; set; }
|
||
|
||
/// <summary>
|
||
/// 视频分辨率（如 640x480）
|
||
/// </summary>
|
||
public string Resolution => $"{FrameWidth}x{FrameHeight}";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 表示视频流服务的运行状态
|
||
/// </summary>
|
||
public class VideoStreamServiceStatus
|
||
{
|
||
/// <summary>
|
||
/// 服务是否正在运行
|
||
/// </summary>
|
||
public bool IsRunning { get; set; }
|
||
|
||
/// <summary>
|
||
/// 服务监听的端口号
|
||
/// </summary>
|
||
public int ServerPort { get; set; }
|
||
|
||
/// <summary>
|
||
/// 当前连接的客户端端点列表
|
||
/// </summary>
|
||
public List<VideoStreamEndpoint> ClientEndpoints { get; set; } = new();
|
||
|
||
/// <summary>
|
||
/// 当前连接的客户端数量
|
||
/// </summary>
|
||
public int ConnectedClientsNum => ClientEndpoints.Count;
|
||
}
|
||
|
||
/// <summary>
|
||
/// HTTP 视频流服务，用于从 FPGA 获取图像数据并推送到前端网页
|
||
/// 支持动态配置摄像头地址和端口
|
||
/// </summary>
|
||
public class HttpVideoStreamService : BackgroundService
|
||
{
|
||
private static readonly NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
|
||
|
||
private HttpListener? _httpListener;
|
||
private readonly int _serverPort = 4321;
|
||
|
||
private readonly ConcurrentDictionary<string, VideoStreamClient> _clientDict = new();
|
||
|
||
// USB Camera 相关
|
||
private AsyncLazy<UsbCameraCapture> _usbCamera = new(async token => await InitializeUsbCamera(token));
|
||
|
||
private static async Task<UsbCameraCapture> InitializeUsbCamera(CancellationToken token)
|
||
{
|
||
try
|
||
{
|
||
var camera = new UsbCameraCapture();
|
||
var devices = camera.GetDevices();
|
||
for (int i = 0; i < devices.Count; i++)
|
||
logger.Info($"Device[{i}]: {devices[i].Name}");
|
||
await camera.StartAsync(1, 2592, 1994, 30);
|
||
return camera;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.Error(ex, "Failed to start USB camera");
|
||
throw;
|
||
}
|
||
}
|
||
|
||
private Optional<VideoStreamClient> TryGetClient(string boardId)
|
||
{
|
||
return _clientDict.TryGetValue(boardId, out var client) ? client : null;
|
||
}
|
||
|
||
private Optional<VideoStreamClient> GetOrCreateClient(
|
||
string boardId, int initWidth, int initHeight)
|
||
{
|
||
if (_clientDict.TryGetValue(boardId, out var client))
|
||
{
|
||
// 可在此处做分辨率/Camera等配置更新
|
||
return client;
|
||
}
|
||
|
||
var userManager = new Database.UserManager();
|
||
|
||
var boardRet = userManager.GetBoardByID(Guid.Parse(boardId));
|
||
if (!boardRet.IsSuccessful || !boardRet.Value.HasValue)
|
||
{
|
||
logger.Error($"Failed to get board with ID {boardId}");
|
||
return null;
|
||
}
|
||
|
||
var board = boardRet.Value.Value;
|
||
|
||
var camera = new AsyncLazy<Peripherals.CameraClient.Camera>(async (_) =>
|
||
{
|
||
var camera = new Peripherals.CameraClient.Camera(board.IpAddr, board.Port);
|
||
var ret = await camera.Init();
|
||
if (!ret.IsSuccessful || !ret.Value)
|
||
{
|
||
logger.Error("Camera Init Failed!");
|
||
throw new Exception("Camera Init Failed!");
|
||
}
|
||
return camera;
|
||
});
|
||
|
||
client = new VideoStreamClient(boardId, initWidth, initHeight, camera);
|
||
_clientDict[boardId] = client;
|
||
return client;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 初始化 HttpVideoStreamService
|
||
/// </summary>
|
||
public override async Task StartAsync(CancellationToken cancellationToken)
|
||
{
|
||
_httpListener = new HttpListener();
|
||
_httpListener.Prefixes.Add($"http://{Global.LocalHost}:{_serverPort}/");
|
||
_httpListener.Start();
|
||
logger.Info($"Video Stream Service started on port {_serverPort}");
|
||
|
||
await base.StartAsync(cancellationToken);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 停止 HTTP 视频流服务
|
||
/// </summary>
|
||
public override async Task StopAsync(CancellationToken cancellationToken)
|
||
{
|
||
foreach (var clientKey in _clientDict.Keys)
|
||
{
|
||
var client = _clientDict[clientKey];
|
||
client.CTS.Cancel();
|
||
if (!client.Camera.IsValueCreated) continue;
|
||
|
||
using (await client.Lock.AcquireWriteLockAsync(cancellationToken))
|
||
{
|
||
var camera = await client.Camera.WithCancellation(cancellationToken);
|
||
await camera.EnableHardwareTrans(false);
|
||
}
|
||
}
|
||
_clientDict.Clear();
|
||
await base.StopAsync(cancellationToken);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 执行 HTTP 视频流服务
|
||
/// </summary>
|
||
/// <param name="stoppingToken">取消令牌</param>
|
||
/// <returns>任务</returns>
|
||
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
|
||
{
|
||
while (!stoppingToken.IsCancellationRequested)
|
||
{
|
||
if (_httpListener == null) continue;
|
||
try
|
||
{
|
||
logger.Debug("Waiting for HTTP request...");
|
||
var contextTask = _httpListener.GetContextAsync();
|
||
var completedTask = await Task.WhenAny(contextTask, Task.Delay(-1, stoppingToken));
|
||
if (completedTask == contextTask)
|
||
{
|
||
var context = contextTask.Result;
|
||
logger.Debug($"Received request: {context.Request.Url?.AbsolutePath}");
|
||
if (context != null)
|
||
_ = HandleRequestAsync(context, stoppingToken);
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.Error(ex, "Error in GetContextAsync");
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
private async Task HandleRequestAsync(HttpListenerContext context, CancellationToken cancellationToken)
|
||
{
|
||
var path = context.Request.Url?.AbsolutePath ?? "/";
|
||
var boardId = context.Request.QueryString["boardId"];
|
||
if (string.IsNullOrEmpty(boardId))
|
||
{
|
||
await SendErrorAsync(context.Response, "Missing clientId");
|
||
return;
|
||
}
|
||
|
||
var width = int.TryParse(context.Request.QueryString["width"], out var w) ? w : 640;
|
||
var height = int.TryParse(context.Request.QueryString["height"], out var h) ? h : 480;
|
||
|
||
var clientOpt = GetOrCreateClient(boardId, width, height);
|
||
if (!clientOpt.HasValue)
|
||
{
|
||
await SendErrorAsync(context.Response, "Invalid clientId or camera not available");
|
||
return;
|
||
}
|
||
|
||
var client = clientOpt.Value;
|
||
var token = CancellationTokenSource.CreateLinkedTokenSource(
|
||
client.CTS.Token, cancellationToken).Token;
|
||
|
||
try
|
||
{
|
||
token.ThrowIfCancellationRequested();
|
||
logger.Info("新HTTP客户端连接: {RemoteEndPoint}", context.Request.RemoteEndPoint);
|
||
|
||
if (path == "/video")
|
||
{
|
||
// MJPEG 流请求（FPGA）
|
||
await HandleMjpegStreamAsync(context.Response, client, token);
|
||
}
|
||
else if (path == "/usbCamera")
|
||
{
|
||
// USB Camera MJPEG流请求
|
||
await HandleUsbCameraStreamAsync(context.Response, client, token);
|
||
}
|
||
else if (path == "/snapshot")
|
||
{
|
||
// 单帧图像请求
|
||
await HandleSnapshotRequestAsync(context.Response, client, token);
|
||
}
|
||
else if (path == "/html")
|
||
{
|
||
// HTML页面请求
|
||
await SendIndexHtmlPageAsync(context.Response);
|
||
}
|
||
else
|
||
{
|
||
// 默认返回简单的HTML页面，提供链接到视频页面
|
||
await SendIndexHtmlPageAsync(context.Response);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.Error(ex, "接受HTTP客户端连接时发生错误");
|
||
}
|
||
}
|
||
|
||
private async Task SendErrorAsync(HttpListenerResponse response, string message)
|
||
{
|
||
response.StatusCode = 400;
|
||
await response.OutputStream.WriteAsync(System.Text.Encoding.UTF8.GetBytes(message));
|
||
response.Close();
|
||
}
|
||
|
||
// USB Camera MJPEG流处理
|
||
private async Task HandleUsbCameraStreamAsync(
|
||
HttpListenerResponse response, VideoStreamClient client, CancellationToken cancellationToken)
|
||
{
|
||
var camera = await _usbCamera.WithCancellation(cancellationToken);
|
||
|
||
Action<byte[]> frameHandler = async (jpegData) =>
|
||
{
|
||
try
|
||
{
|
||
var header = Encoding.ASCII.GetBytes("--boundary\r\nContent-Type: image/jpeg\r\nContent-Length: " + jpegData.Length + "\r\n\r\n");
|
||
await response.OutputStream.WriteAsync(header, 0, header.Length, cancellationToken);
|
||
await response.OutputStream.WriteAsync(jpegData, 0, jpegData.Length, cancellationToken);
|
||
await response.OutputStream.WriteAsync(new byte[] { 0x0D, 0x0A }, 0, 2, cancellationToken); // \r\n
|
||
await response.OutputStream.FlushAsync(cancellationToken);
|
||
}
|
||
catch
|
||
{
|
||
logger.Error("Error sending MJPEG frame");
|
||
}
|
||
};
|
||
|
||
try
|
||
{
|
||
if (!camera.IsCapturing)
|
||
{
|
||
logger.Error("USB Camera is not capturing");
|
||
response.StatusCode = 500;
|
||
await response.OutputStream.FlushAsync(cancellationToken);
|
||
response.Close();
|
||
return;
|
||
}
|
||
|
||
response.ContentType = "multipart/x-mixed-replace; boundary=--boundary";
|
||
response.Headers.Add("Cache-Control", "no-cache, no-store, must-revalidate");
|
||
response.Headers.Add("Pragma", "no-cache");
|
||
response.Headers.Add("Expires", "0");
|
||
|
||
logger.Info("Start USB Camera MJPEG Stream");
|
||
|
||
camera.FrameReady += frameHandler;
|
||
|
||
while (true)
|
||
{
|
||
cancellationToken.ThrowIfCancellationRequested();
|
||
await Task.Delay(-1, cancellationToken);
|
||
}
|
||
}
|
||
catch (OperationCanceledException)
|
||
{
|
||
logger.Info("USB Camera MJPEG 串流取消");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.Error(ex, "USB Camera MJPEG流处理异常");
|
||
}
|
||
finally
|
||
{
|
||
camera.FrameReady -= frameHandler;
|
||
logger.Info("Usb Camera Stream Stopped");
|
||
try { response.Close(); } catch { }
|
||
}
|
||
}
|
||
|
||
private async Task HandleSnapshotRequestAsync(
|
||
HttpListenerResponse response, VideoStreamClient client, CancellationToken cancellationToken)
|
||
{
|
||
// 读取 Camera 快照，返回 JPEG
|
||
var camera = await client.Camera.WithCancellation(cancellationToken);
|
||
var frameResult = await camera.ReadFrame();
|
||
if (!frameResult.IsSuccessful || frameResult.Value == null)
|
||
{
|
||
response.StatusCode = 500;
|
||
await response.OutputStream.WriteAsync(Encoding.UTF8.GetBytes("Failed to get snapshot"));
|
||
response.Close();
|
||
return;
|
||
}
|
||
var jpegResult = Common.Image.ConvertRGB24ToJpeg(frameResult.Value, client.FrameWidth, client.FrameHeight, 80);
|
||
if (!jpegResult.IsSuccessful)
|
||
{
|
||
response.StatusCode = 500;
|
||
await response.OutputStream.WriteAsync(Encoding.UTF8.GetBytes("JPEG conversion failed"));
|
||
response.Close();
|
||
return;
|
||
}
|
||
response.ContentType = "image/jpeg";
|
||
response.ContentLength64 = jpegResult.Value.Length;
|
||
await response.OutputStream.WriteAsync(jpegResult.Value, 0, jpegResult.Value.Length, cancellationToken);
|
||
response.Close();
|
||
}
|
||
|
||
private async Task HandleMjpegStreamAsync(
|
||
HttpListenerResponse response, VideoStreamClient client, CancellationToken cancellationToken)
|
||
{
|
||
response.ContentType = "multipart/x-mixed-replace; boundary=--boundary";
|
||
response.Headers.Add("Cache-Control", "no-cache, no-store, must-revalidate");
|
||
response.Headers.Add("Pragma", "no-cache");
|
||
response.Headers.Add("Expires", "0");
|
||
|
||
var camera = await client.Camera.WithCancellation(cancellationToken);
|
||
while (!cancellationToken.IsCancellationRequested)
|
||
{
|
||
var frameResult = await camera.ReadFrame();
|
||
if (!frameResult.IsSuccessful || frameResult.Value == null) continue;
|
||
var jpegResult = Common.Image.ConvertRGB24ToJpeg(frameResult.Value, client.FrameWidth, client.FrameHeight, 80);
|
||
if (!jpegResult.IsSuccessful) continue;
|
||
|
||
var header = Encoding.ASCII.GetBytes("--boundary\r\nContent-Type: image/jpeg\r\nContent-Length: " + jpegResult.Value.Length + "\r\n\r\n");
|
||
await response.OutputStream.WriteAsync(header, 0, header.Length, cancellationToken);
|
||
await response.OutputStream.WriteAsync(jpegResult.Value, 0, jpegResult.Value.Length, cancellationToken);
|
||
await response.OutputStream.WriteAsync(new byte[] { 0x0D, 0x0A }, 0, 2, cancellationToken);
|
||
await response.OutputStream.FlushAsync(cancellationToken);
|
||
|
||
await Task.Delay(1000 / client.FrameWidth, cancellationToken);
|
||
}
|
||
response.Close();
|
||
}
|
||
|
||
private async Task SendVideoHtmlPageAsync(HttpListenerResponse response)
|
||
{
|
||
string html = $@"
|
||
<!DOCTYPE html>
|
||
<html>
|
||
<head>
|
||
<title>FPGA 视频流</title>
|
||
<meta charset=""utf-8"">
|
||
<style>
|
||
body {{ font-family: Arial, sans-serif; text-align: center; margin: 20px; }}
|
||
h1 {{ color: #333; }}
|
||
.video-container {{ margin: 20px auto; max-width: 800px; }}
|
||
.controls {{ margin: 10px 0; }}
|
||
img {{ max-width: 100%; border: 1px solid #ddd; }}
|
||
button {{ padding: 8px 16px; margin: 0 5px; cursor: pointer; }}
|
||
</style>
|
||
</head>
|
||
<body>
|
||
<h1>FPGA 实时视频流</h1>
|
||
<div class=""video-container"">
|
||
<img id=""videoStream"" src=""/video-stream"" alt=""FPGA视频流"" />
|
||
</div>
|
||
<div class=""controls"">
|
||
<button onclick=""document.getElementById('videoStream').src='/snapshot?t=' + new Date().getTime()"">刷新快照</button>
|
||
<button onclick=""document.getElementById('videoStream').src='/video-stream'"">开始流媒体</button>
|
||
<span id=""status"">状态: 连接中...</span>
|
||
</div>
|
||
<script>
|
||
document.getElementById('videoStream').onload = function() {{
|
||
document.getElementById('status').textContent = '状态: 已连接';
|
||
}};
|
||
document.getElementById('videoStream').onerror = function() {{
|
||
document.getElementById('status').textContent = '状态: 连接错误';
|
||
}};
|
||
</script>
|
||
</body>
|
||
</html>
|
||
";
|
||
|
||
response.ContentType = "text/html";
|
||
response.ContentEncoding = Encoding.UTF8;
|
||
byte[] buffer = Encoding.UTF8.GetBytes(html);
|
||
response.ContentLength64 = buffer.Length;
|
||
|
||
await response.OutputStream.WriteAsync(buffer, 0, buffer.Length);
|
||
response.Close();
|
||
}
|
||
|
||
private async Task SendIndexHtmlPageAsync(HttpListenerResponse response)
|
||
{
|
||
string html = $@"
|
||
<!DOCTYPE html>
|
||
<html>
|
||
<head>
|
||
<title>FPGA WebLab 视频服务</title>
|
||
<meta charset=""utf-8"">
|
||
<style>
|
||
body {{ font-family: Arial, sans-serif; text-align: center; margin: 20px; }}
|
||
h1 {{ color: #333; }}
|
||
.links {{ margin: 20px; }}
|
||
a {{ padding: 10px 15px; background-color: #4CAF50; color: white; text-decoration: none; border-radius: 4px; margin: 5px; display: inline-block; }}
|
||
a:hover {{ background-color: #45a049; }}
|
||
</style>
|
||
</head>
|
||
<body>
|
||
<h1>FPGA WebLab 视频服务</h1>
|
||
<div class=""links"">
|
||
<a href=""/video-feed.html"">观看实时视频</a>
|
||
<a href=""/snapshot"" target=""_blank"">获取当前快照</a>
|
||
</div>
|
||
<p>HTTP流媒体服务端口: {_serverPort}</p>
|
||
</body>
|
||
</html>
|
||
";
|
||
|
||
response.ContentType = "text/html";
|
||
response.ContentEncoding = Encoding.UTF8;
|
||
byte[] buffer = Encoding.UTF8.GetBytes(html);
|
||
response.ContentLength64 = buffer.Length;
|
||
|
||
await response.OutputStream.WriteAsync(buffer, 0, buffer.Length);
|
||
response.Close();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 从 FPGA 获取图像数据
|
||
/// 实际从摄像头读取 RGB565 格式数据并转换为 RGB24
|
||
/// </summary>
|
||
private async Task<byte[]?> GetFPGAImageData(
|
||
VideoStreamClient client, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
using (await client.Lock.AcquireWriteLockAsync(cancellationToken))
|
||
{
|
||
// 从摄像头读取帧数据
|
||
var readStartTime = DateTime.UtcNow;
|
||
var camera = await client.Camera.WithCancellation(cancellationToken);
|
||
var result = await camera.ReadFrame();
|
||
var readEndTime = DateTime.UtcNow;
|
||
var readTime = (readEndTime - readStartTime).TotalMilliseconds;
|
||
|
||
if (!result.IsSuccessful)
|
||
{
|
||
logger.Error("读取摄像头帧数据失败: {Error}", result.Error);
|
||
return new byte[0];
|
||
}
|
||
|
||
var rgb565Data = result.Value;
|
||
|
||
// 验证数据长度是否正确
|
||
if (!Common.Image.ValidateImageDataLength(rgb565Data, client.FrameWidth, client.FrameHeight, 2))
|
||
{
|
||
logger.Warn("摄像头数据长度不匹配，期望: {Expected}, 实际: {Actual}",
|
||
client.FrameWidth * client.FrameHeight * 2, rgb565Data.Length);
|
||
}
|
||
|
||
// 将 RGB565 转换为 RGB24
|
||
var convertStartTime = DateTime.UtcNow;
|
||
var rgb24Result = Common.Image.ConvertRGB565ToRGB24(rgb565Data, client.FrameWidth, client.FrameHeight, isLittleEndian: false);
|
||
var convertEndTime = DateTime.UtcNow;
|
||
var convertTime = (convertEndTime - convertStartTime).TotalMilliseconds;
|
||
|
||
if (!rgb24Result.IsSuccessful)
|
||
{
|
||
logger.Error("RGB565转RGB24失败: {Error}", rgb24Result.Error);
|
||
return new byte[0];
|
||
}
|
||
|
||
return rgb24Result.Value;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.Error(ex, "获取FPGA图像数据时发生错误");
|
||
return new byte[0];
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设置视频流分辨率
|
||
/// </summary>
|
||
/// <param name="boardId">板卡ID</param>
|
||
/// <param name="width">宽度</param>
|
||
/// <param name="height">高度</param>
|
||
/// <param name="timeout">超时时间（毫秒）</param>
|
||
/// <param name="cancellationToken">取消令牌</param>
|
||
/// <returns>设置结果</returns>
|
||
public async Task<Result<bool>> SetResolutionAsync(
|
||
string boardId, int width, int height,
|
||
int timeout = 100, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
var client = TryGetClient(boardId).OrThrow(() => new Exception($"无法获取摄像头客户端: {boardId}"));
|
||
|
||
using (await client.Lock.AcquireWriteLockAsync(TimeSpan.FromMilliseconds(timeout), cancellationToken))
|
||
{
|
||
var currentCamera = await client.Camera.WithCancellation(cancellationToken);
|
||
if (currentCamera == null)
|
||
{
|
||
var message = $"获取摄像头失败";
|
||
logger.Error(message);
|
||
return new(new Exception(message));
|
||
}
|
||
|
||
// 设置摄像头分辨率
|
||
var ret = await currentCamera.ChangeResolution(width, height);
|
||
if (!ret.IsSuccessful)
|
||
{
|
||
var message = $"设置摄像头分辨率失败: {ret.Error}";
|
||
logger.Error(message);
|
||
return new(new Exception(message));
|
||
}
|
||
|
||
if (!ret.Value)
|
||
{
|
||
logger.Warn($"设置摄像头分辨率失败");
|
||
return false;
|
||
}
|
||
|
||
// 更新HTTP服务的分辨率配置
|
||
client.FrameWidth = width;
|
||
client.FrameHeight = height;
|
||
|
||
logger.Info($"视频流分辨率已成功设置为 {width}x{height}");
|
||
return true;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var message = $"设置分辨率时发生错误: {ex.Message}";
|
||
logger.Error(ex, message);
|
||
return new(new Exception(message));
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 初始化摄像头自动对焦功能
|
||
/// </summary>
|
||
/// <returns>初始化结果</returns>
|
||
public async Task<bool> InitAutoFocusAsync(
|
||
string boardId, int timeout = 1000, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
var client = TryGetClient(boardId).OrThrow(() => new Exception($"无法获取摄像头客户端: {boardId}"));
|
||
|
||
using (await client.Lock.AcquireWriteLockAsync(
|
||
TimeSpan.FromMilliseconds(timeout), cancellationToken))
|
||
{
|
||
var camera = await client.Camera.WithCancellation(cancellationToken);
|
||
var result = await camera.InitAutoFocus();
|
||
|
||
if (result.IsSuccessful && result.Value)
|
||
{
|
||
logger.Info($"Board{boardId}摄像头自动对焦功能初始化成功");
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
logger.Error($"Board{boardId}摄像头自动对焦功能初始化失败: {result.Error?.Message ?? "未知错误"}");
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.Error(ex, $"Board{boardId}初始化摄像头自动对焦功能时发生异常");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 执行摄像头自动对焦
|
||
/// </summary>
|
||
/// <returns>对焦结果</returns>
|
||
public async Task<bool> PerformAutoFocusAsync(
|
||
string boardId, int timeout = 1000, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
var client = TryGetClient(boardId).OrThrow(() => new Exception($"无法获取摄像头客户端: {boardId}"));
|
||
|
||
logger.Info($"Board{boardId}开始执行摄像头自动对焦");
|
||
|
||
var camera = await client.Camera.WithCancellation(cancellationToken);
|
||
var result = await camera.PerformAutoFocus();
|
||
|
||
if (result.IsSuccessful && result.Value)
|
||
{
|
||
logger.Info($"Board{boardId}摄像头自动对焦成功");
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
logger.Error($"Board{boardId}摄像头自动对焦执行失败: {result.Error?.Message ?? "未知错误"}");
|
||
return false;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.Error(ex, $"Board{boardId}执行摄像头自动对焦时发生异常");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置摄像头连接参数
|
||
/// </summary>
|
||
/// <param name="boardId">板卡ID</param>
|
||
/// <param name="cancellationToken">取消令牌</param>
|
||
/// <returns>配置是否成功</returns>
|
||
public async Task<bool> ConfigureCameraAsync(string boardId, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
var client = TryGetClient(boardId).OrThrow(() => new Exception($"无法获取摄像头客户端: {boardId}"));
|
||
var camera = await client.Camera.WithCancellation(cancellationToken);
|
||
|
||
using (await client.Lock.AcquireWriteLockAsync(cancellationToken))
|
||
{
|
||
var ret = await camera.Init();
|
||
if (!ret.IsSuccessful)
|
||
{
|
||
logger.Error(ret.Error);
|
||
throw ret.Error;
|
||
}
|
||
|
||
if (!ret.Value)
|
||
{
|
||
logger.Error($"Camera Init Failed!");
|
||
throw new Exception($"Camera Init Failed!");
|
||
}
|
||
}
|
||
|
||
using (await client.Lock.AcquireWriteLockAsync(cancellationToken))
|
||
{
|
||
var ret = await camera.ChangeResolution(client.FrameWidth, client.FrameHeight);
|
||
if (!ret.IsSuccessful)
|
||
{
|
||
logger.Error(ret.Error);
|
||
throw ret.Error;
|
||
}
|
||
|
||
if (!ret.Value)
|
||
{
|
||
logger.Error($"Camera Resolution Change Failed!");
|
||
throw new Exception($"Camera Resolution Change Failed!");
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.Error(ex, "配置摄像头连接时发生错误");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
public async Task SetVideoStreamEnableAsync(string boardId, bool enable)
|
||
{
|
||
try
|
||
{
|
||
var client = TryGetClient(boardId).OrThrow(() => new Exception($"无法获取摄像头客户端: {boardId}"));
|
||
|
||
if (client.IsEnabled == enable)
|
||
return;
|
||
|
||
using (await client.Lock.AcquireWriteLockAsync())
|
||
{
|
||
if (!enable || client.CTS.IsCancellationRequested)
|
||
{
|
||
client.CTS.Cancel();
|
||
client.CTS = new CancellationTokenSource();
|
||
}
|
||
|
||
if (!client.Camera.IsValueCreated) return;
|
||
|
||
var camera = await client.Camera.WithCancellation(client.CTS.Token);
|
||
var disableResult = await camera.EnableHardwareTrans(enable);
|
||
if (disableResult.IsSuccessful && disableResult.Value)
|
||
logger.Info($"Successfully disabled camera {boardId} hardware transmission");
|
||
else
|
||
logger.Error($"Failed to disable camera {boardId} hardware transmission: {disableResult.Error}");
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.Error(ex, $"Exception occurred while disabling video transmission for {boardId}");
|
||
}
|
||
}
|
||
|
||
public async ValueTask<bool> TestCameraConnection(string boardId)
|
||
{
|
||
try
|
||
{
|
||
var client = TryGetClient(boardId).OrThrow(() => new Exception($"无法获取摄像头客户端: {boardId}"));
|
||
|
||
var imageData = await GetFPGAImageData(client);
|
||
if (imageData == null || imageData.Length == 0)
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.Error(ex, $"Board{boardId}执行摄像头自动对焦时发生异常");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
public VideoStreamEndpoint GetVideoEndpoint(string boardId)
|
||
{
|
||
var client = GetOrCreateClient(boardId, 640, 480).OrThrow(() => new Exception($"无法获取摄像头客户端: {boardId}"));
|
||
|
||
return new VideoStreamEndpoint
|
||
{
|
||
BoardId = boardId,
|
||
MjpegUrl = $"http://{Global.LocalHost}:{_serverPort}/mjpeg?boardId={boardId}",
|
||
VideoUrl = $"http://{Global.LocalHost}:{_serverPort}/video?boardId={boardId}",
|
||
SnapshotUrl = $"http://{Global.LocalHost}:{_serverPort}/snapshot?boardId={boardId}",
|
||
UsbCameraUrl = $"http://{Global.LocalHost}:{_serverPort}/usbCamera?boardId={boardId}",
|
||
HtmlUrl = $"http://{Global.LocalHost}:{_serverPort}/html?boardId={boardId}",
|
||
IsEnabled = client.IsEnabled,
|
||
FrameRate = client.FrameRate
|
||
};
|
||
}
|
||
|
||
public List<VideoStreamEndpoint> GetAllVideoEndpoints()
|
||
{
|
||
var endpoints = new List<VideoStreamEndpoint>();
|
||
|
||
foreach (var boardId in _clientDict.Keys)
|
||
endpoints.Add(GetVideoEndpoint(boardId));
|
||
|
||
return endpoints;
|
||
}
|
||
|
||
public VideoStreamServiceStatus GetServiceStatus()
|
||
{
|
||
return new VideoStreamServiceStatus
|
||
{
|
||
IsRunning = true,
|
||
ServerPort = _serverPort,
|
||
ClientEndpoints = GetAllVideoEndpoints()
|
||
};
|
||
}
|
||
}
|