wehub-resource-sync
746 lines
27 KiB
C#
746 lines
27 KiB
C#
using System.Runtime.InteropServices.ComTypes;
|
|
using System.Threading;
|
|
using DirectShowLib;
|
|
using OpenCvSharp;
|
|
using SharpDX;
|
|
using Device = SharpDX.Direct3D11.Device;
|
|
using FormatType = DirectShowLib.FormatType;
|
|
|
|
namespace Lib.io.video;
|
|
|
|
[Guid("cd5a182e-254b-4e65-820b-ff754122614c")]
|
|
public class VideoDeviceInput : Instance<VideoDeviceInput>, ICustomDropdownHolder
|
|
{
|
|
// Output slots
|
|
[Output(Guid = "1d0159cc-33d2-46b1-9c0c-7054aa560df5", DirtyFlagTrigger = DirtyFlagTrigger.Animated)]
|
|
public readonly Slot<Texture2D> Texture = new();
|
|
|
|
[Output(Guid = "9C2E4C11-09B6-4F4D-8F99-4A7372D5F2B5", DirtyFlagTrigger = DirtyFlagTrigger.Animated)]
|
|
public readonly Slot<Int2> Resolution = new();
|
|
|
|
[Output(Guid = "A1B2C3D4-5678-90EF-1234-567890ABCDEF", DirtyFlagTrigger = DirtyFlagTrigger.Animated)]
|
|
public new readonly Slot<string> Status = new();
|
|
|
|
[Output(Guid = "868D5FFE-032C-4522-B56B-D96B30841DB7", DirtyFlagTrigger = DirtyFlagTrigger.Animated)]
|
|
public readonly Slot<int> UpdateCount = new();
|
|
|
|
private const float Epsilon = 1e-4f;
|
|
|
|
// Static device information
|
|
private static List<WebcamWithIndex> _webcamWithIndices;
|
|
private static Dictionary<string, List<(int Width, int Height, double Fps)>> _webcamCapabilities;
|
|
private static readonly object _capabilitiesLock = new();
|
|
private static readonly Lock _staticInitLock = new();
|
|
private static bool _devicesScanned;
|
|
private readonly Lock _captureDeviceLock = new();
|
|
private readonly Lock _lockObject = new();
|
|
|
|
[Input(Guid = "236D4C5C-0022-4416-A22C-D6DF73C306E2")]
|
|
public readonly InputSlot<bool> Active = new();
|
|
|
|
[Input(Guid = "3022DE8A-5D88-4A37-9799-780F2A838A6E")]
|
|
public readonly InputSlot<float> ApplyRotationData = new();
|
|
|
|
[Input(Guid = "11F7432D-31F1-44B9-8F75-B1569B314B13")]
|
|
public readonly InputSlot<int> CustomFps = new();
|
|
|
|
[Input(Guid = "C9E1C1F6-3A18-4A1C-8A5E-4B4119965B6E")]
|
|
public readonly InputSlot<Int2> CustomResolution = new();
|
|
|
|
[Input(Guid = "22513B82-E77A-417A-8A46-24E677F072D4")]
|
|
public readonly InputSlot<bool> DeactivateWhenNotShowing = new();
|
|
|
|
[Input(Guid = "A57E815D-70C9-4D3B-998C-D13506B8F56E")]
|
|
public readonly InputSlot<bool> FlipHorizontally = new();
|
|
|
|
[Input(Guid = "3022DE8A-5D88-4A37-9799-780F2A838A5F")]
|
|
public readonly InputSlot<bool> FlipVertically = new();
|
|
|
|
[Input(Guid = "f5b900ec-ee17-123e-9972-cdd0580c104e")]
|
|
public readonly InputSlot<string> InputDeviceName = new();
|
|
|
|
[Input(Guid = "8D2C28C7-1234-40E2-9388-75574519543D")]
|
|
public readonly InputSlot<bool> OpenSettings = new();
|
|
|
|
[Input(Guid = "67E149A5-F7B6-47BC-B147-3B9B11C19C29")]
|
|
public readonly InputSlot<bool> Reconnect = new();
|
|
|
|
[Input(Guid = "F187A997-7E4A-48C6-81F9-2A27F150A68A")]
|
|
public readonly InputSlot<Vector2> Reposition = new();
|
|
|
|
|
|
[Input(Guid = "49019D29-873E-4B7C-A897-C575A384A650", MappedType = typeof(ResolutionFpsTypeEnum))]
|
|
public readonly InputSlot<int> ResolutionFpsType = new();
|
|
|
|
[Input(Guid = "805602D5-52B2-4A73-A337-12E00C3C91F2")]
|
|
public readonly InputSlot<Vector2> Scale = new();
|
|
|
|
|
|
|
|
private CancellationTokenSource _cancellationTokenSource;
|
|
|
|
// Instance variables
|
|
private VideoCapture _capture;
|
|
private Thread _captureThread;
|
|
private Texture2D _gpuTexture;
|
|
private int _height;
|
|
private volatile string _lastStatusMessage = "";
|
|
private Mat _sharedMat;
|
|
private int _storeDeviceIndex = -1;
|
|
|
|
// Transformation cache
|
|
private Mat _transformationMatrix;
|
|
private int _width;
|
|
|
|
public VideoDeviceInput()
|
|
{
|
|
Texture.UpdateAction = Update;
|
|
UpdateCount.UpdateAction = Update;
|
|
Resolution.UpdateAction = Update;
|
|
Status.UpdateAction = Update;
|
|
}
|
|
|
|
private void SetStatus(string message)
|
|
{
|
|
_lastStatusMessage = message;
|
|
}
|
|
|
|
private void Update(EvaluationContext context)
|
|
{
|
|
ScanWebCamDevices();
|
|
|
|
var deviceName = InputDeviceName.GetValue(context);
|
|
if (string.IsNullOrEmpty(deviceName) && _webcamWithIndices?.Count > 0)
|
|
{
|
|
deviceName = _webcamWithIndices[0].Name;
|
|
}
|
|
|
|
if (!TryGetIndexForDeviceName(deviceName, out var selectedDeviceIndex))
|
|
{
|
|
SetStatus($"Error: Camera '{deviceName}' not found.");
|
|
StopCaptureThread();
|
|
}
|
|
else
|
|
{
|
|
var deviceIsActive = Active.GetValue(context);
|
|
var deactivateWhenNotShowing = DeactivateWhenNotShowing.GetValue(context);
|
|
|
|
bool shouldBeCapturing = deviceIsActive && (!deactivateWhenNotShowing || IsActiveInGraph());
|
|
|
|
bool reconnectTriggered = Reconnect.GetValue(context);
|
|
if (reconnectTriggered)
|
|
{
|
|
Reconnect.SetTypedInputValue(false);
|
|
}
|
|
|
|
if (shouldBeCapturing)
|
|
{
|
|
if (IsCaptureThreadRunning() && (selectedDeviceIndex != _storeDeviceIndex || reconnectTriggered))
|
|
{
|
|
StopCaptureThread();
|
|
}
|
|
|
|
if (!IsCaptureThreadRunning())
|
|
{
|
|
_storeDeviceIndex = selectedDeviceIndex;
|
|
StartCaptureThread(context);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
StopCaptureThread();
|
|
}
|
|
}
|
|
|
|
if (OpenSettings.GetValue(context))
|
|
{
|
|
OpenVideoSettings();
|
|
OpenSettings.SetTypedInputValue(false);
|
|
}
|
|
|
|
lock (_lockObject)
|
|
{
|
|
if (_sharedMat != null && !_sharedMat.Empty())
|
|
{
|
|
UploadMat(ResourceManager.Device, _sharedMat);
|
|
Texture.Value = _gpuTexture;
|
|
UpdateCount.Value++;
|
|
Resolution.Value = new Int2(_sharedMat.Width, _sharedMat.Height);
|
|
}
|
|
}
|
|
|
|
Status.Value = _lastStatusMessage;
|
|
}
|
|
|
|
private bool IsCaptureThreadRunning()
|
|
{
|
|
return _captureThread != null && _captureThread.IsAlive;
|
|
}
|
|
|
|
private bool IsActiveInGraph() => true;
|
|
|
|
private void StartCaptureThread(EvaluationContext context)
|
|
{
|
|
if (IsCaptureThreadRunning()) return;
|
|
|
|
var settings = new CaptureThreadSettings(this, context);
|
|
_cancellationTokenSource = new CancellationTokenSource();
|
|
var token = _cancellationTokenSource.Token;
|
|
|
|
_captureThread = new Thread(() => CaptureLoop(settings, token))
|
|
{
|
|
IsBackground = true,
|
|
Name = "Video Capture Thread",
|
|
Priority = ThreadPriority.BelowNormal
|
|
};
|
|
_captureThread.Start();
|
|
}
|
|
|
|
private void StopCaptureThread()
|
|
{
|
|
if (!IsCaptureThreadRunning()) return;
|
|
|
|
_cancellationTokenSource?.Cancel();
|
|
|
|
if (!_captureThread.Join(TimeSpan.FromSeconds(2)))
|
|
{
|
|
Log.Debug("Video capture thread did not exit in time.");
|
|
}
|
|
|
|
_captureThread = null;
|
|
_cancellationTokenSource?.Dispose();
|
|
_cancellationTokenSource = null;
|
|
|
|
lock (_captureDeviceLock)
|
|
{
|
|
_capture?.Dispose();
|
|
_capture = null;
|
|
}
|
|
}
|
|
|
|
private void CaptureLoop(CaptureThreadSettings settings, CancellationToken token)
|
|
{
|
|
try
|
|
{
|
|
lock (_captureDeviceLock)
|
|
{
|
|
if (token.IsCancellationRequested) return;
|
|
|
|
_capture = new VideoCapture();
|
|
|
|
if (settings.ResolutionFpsType == ResolutionFpsTypeEnum.Custom)
|
|
{
|
|
_capture.Set(VideoCaptureProperties.FrameWidth, settings.CustomResolution.X);
|
|
_capture.Set(VideoCaptureProperties.FrameHeight, settings.CustomResolution.Y);
|
|
_capture.Set(VideoCaptureProperties.Fps, settings.CustomFps);
|
|
}
|
|
|
|
if (!_capture.Open(_storeDeviceIndex, VideoCaptureAPIs.DSHOW))
|
|
{
|
|
SetStatus("Error: Failed to open video capture device.");
|
|
return;
|
|
}
|
|
}
|
|
|
|
Thread.Sleep(100);
|
|
|
|
lock (_captureDeviceLock)
|
|
{
|
|
if (token.IsCancellationRequested || _capture == null) return;
|
|
|
|
if (settings.ResolutionFpsType == ResolutionFpsTypeEnum.Custom)
|
|
{
|
|
bool widthSet = _capture.Set(VideoCaptureProperties.FrameWidth, settings.CustomResolution.X);
|
|
bool heightSet = _capture.Set(VideoCaptureProperties.FrameHeight, settings.CustomResolution.Y);
|
|
bool fpsSet = _capture.Set(VideoCaptureProperties.Fps, settings.CustomFps);
|
|
|
|
if (!widthSet || !heightSet || !fpsSet)
|
|
{
|
|
Log.Debug("Set returned false—camera doesn't support requested settings.");
|
|
}
|
|
|
|
var actualWidth = (int)_capture.Get(VideoCaptureProperties.FrameWidth);
|
|
var actualHeight = (int)_capture.Get(VideoCaptureProperties.FrameHeight);
|
|
var actualFps = _capture.Get(VideoCaptureProperties.Fps);
|
|
|
|
if (actualWidth != settings.CustomResolution.X || actualHeight != settings.CustomResolution.Y ||
|
|
Math.Abs(actualFps - settings.CustomFps) > 0.01)
|
|
{
|
|
SetStatus($"Warning: Using {actualWidth}x{actualHeight}@{actualFps:F2}fps (requested {settings.CustomResolution.X}x{settings.CustomResolution.Y}@{settings.CustomFps}fps).");
|
|
}
|
|
else
|
|
{
|
|
SetStatus($"Success: Running at {settings.CustomResolution.X}x{settings.CustomResolution.Y}@{settings.CustomFps}fps.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetStatus("Running at device default settings.");
|
|
}
|
|
}
|
|
|
|
using var frame = new Mat();
|
|
using var bgraMat = new Mat();
|
|
|
|
while (!token.IsCancellationRequested)
|
|
{
|
|
Mat currentFrame = null;
|
|
bool frameReadSuccess = false;
|
|
|
|
lock (_captureDeviceLock)
|
|
{
|
|
if (_capture != null && _capture.IsOpened())
|
|
{
|
|
frameReadSuccess = _capture.Read(frame);
|
|
}
|
|
}
|
|
|
|
if (frameReadSuccess && !frame.Empty())
|
|
{
|
|
SetStatus("Running");
|
|
Cv2.CvtColor(frame, bgraMat, ColorConversionCodes.BGR2BGRA);
|
|
|
|
if (settings.FlipVertically)
|
|
Cv2.Flip(bgraMat, bgraMat, FlipMode.Y);
|
|
|
|
if (settings.FlipHorizontally)
|
|
Cv2.Flip(bgraMat, bgraMat, FlipMode.X);
|
|
|
|
if (settings.ResolutionFpsType == ResolutionFpsTypeEnum.Custom)
|
|
{
|
|
var targetSize = new Size(settings.CustomResolution.X, settings.CustomResolution.Y);
|
|
if (bgraMat.Size() != targetSize)
|
|
{
|
|
using var resized = new Mat();
|
|
Cv2.Resize(bgraMat, resized, targetSize, 0, 0, InterpolationFlags.Cubic);
|
|
currentFrame = resized.Clone();
|
|
SetStatus(_lastStatusMessage + " (Software resize)");
|
|
}
|
|
}
|
|
|
|
currentFrame ??= bgraMat;
|
|
|
|
if (settings.HasTransformation())
|
|
{
|
|
UpdateTransformationMatrix(settings, currentFrame.Size());
|
|
var newSize = new Size(currentFrame.Width, currentFrame.Height);
|
|
|
|
lock (_lockObject)
|
|
{
|
|
if (_sharedMat == null || _sharedMat.Width != newSize.Width || _sharedMat.Height != newSize.Height)
|
|
{
|
|
_sharedMat?.Dispose();
|
|
_sharedMat = new Mat(newSize, MatType.CV_8UC4);
|
|
}
|
|
|
|
Cv2.WarpAffine(currentFrame, _sharedMat, _transformationMatrix, newSize);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lock (_lockObject)
|
|
{
|
|
if (_sharedMat == null || _sharedMat.Width != currentFrame.Width || _sharedMat.Height != currentFrame.Height)
|
|
{
|
|
_sharedMat?.Dispose();
|
|
_sharedMat = new Mat(currentFrame.Height, currentFrame.Width, MatType.CV_8UC4);
|
|
}
|
|
|
|
currentFrame.CopyTo(_sharedMat);
|
|
}
|
|
}
|
|
|
|
if (currentFrame != bgraMat)
|
|
{
|
|
currentFrame.Dispose();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetStatus("Error: Failed to retrieve frame.");
|
|
Thread.Sleep(100);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
// A TypeInitializationException (e.g. OpenCV's native NativeMethods cctor failing to load
|
|
// OpenCvSharpExtern.dll or one of its dependencies) carries the real cause — DllNotFound,
|
|
// BadImageFormat, etc. — only in its inner exception; the outer message is generic.
|
|
var cause = e.InnerException ?? e;
|
|
Log.Debug($"Video capture thread failed: {cause.GetType().Name}: {cause.Message}\n{e}");
|
|
SetStatus($"Error: Capture failed - {cause.Message}");
|
|
}
|
|
finally
|
|
{
|
|
lock (_captureDeviceLock)
|
|
{
|
|
_capture?.Dispose();
|
|
_capture = null;
|
|
}
|
|
|
|
_transformationMatrix?.Dispose();
|
|
}
|
|
}
|
|
|
|
private void UpdateTransformationMatrix(CaptureThreadSettings settings, Size frameSize)
|
|
{
|
|
_transformationMatrix?.Dispose();
|
|
_transformationMatrix = new Mat(2, 3, MatType.CV_32FC1);
|
|
|
|
var center = new Point2f(frameSize.Width / 2.0f, frameSize.Height / 2.0f);
|
|
var angleRad = settings.Rotation * Math.PI / 180.0;
|
|
var cos = (float)Math.Cos(angleRad);
|
|
var sin = (float)Math.Sin(angleRad);
|
|
|
|
_transformationMatrix.Set(0, 0, cos * settings.Scale.X);
|
|
_transformationMatrix.Set(0, 1, sin * settings.Scale.Y);
|
|
_transformationMatrix.Set(1, 0, -sin * settings.Scale.X);
|
|
_transformationMatrix.Set(1, 1, cos * settings.Scale.Y);
|
|
|
|
var tx = (1.0f - cos * settings.Scale.X) * center.X - sin * settings.Scale.Y * center.Y;
|
|
var ty = sin * settings.Scale.X * center.X + (1.0f - cos * settings.Scale.Y) * center.Y;
|
|
|
|
_transformationMatrix.Set(0, 2, settings.Reposition.X + tx);
|
|
_transformationMatrix.Set(1, 2, settings.Reposition.Y + ty);
|
|
}
|
|
|
|
private void UploadMat(Device device, Mat mat)
|
|
{
|
|
if (mat == null || mat.Empty())
|
|
{
|
|
Log.Debug("UploadMat: Mat is null or empty. Skipping upload.");
|
|
return;
|
|
}
|
|
|
|
var width = mat.Width;
|
|
var height = mat.Height;
|
|
|
|
if (_gpuTexture == null || _width != width || _height != height)
|
|
{
|
|
_gpuTexture?.Dispose();
|
|
_width = width;
|
|
_height = height;
|
|
|
|
var texDesc = new Texture2DDescription
|
|
{
|
|
Width = width,
|
|
Height = height,
|
|
MipLevels = 1,
|
|
ArraySize = 1,
|
|
Format = Format.B8G8R8A8_UNorm,
|
|
SampleDescription = new SampleDescription(1, 0),
|
|
Usage = ResourceUsage.Default,
|
|
BindFlags = BindFlags.ShaderResource,
|
|
CpuAccessFlags = CpuAccessFlags.None,
|
|
OptionFlags = ResourceOptionFlags.None
|
|
};
|
|
var sharpDxTexture = new SharpDX.Direct3D11.Texture2D(device, texDesc);
|
|
_gpuTexture = new Texture2D(sharpDxTexture);
|
|
}
|
|
|
|
var dataBox = new DataBox(mat.Data, (int)mat.Step(), 0);
|
|
device.ImmediateContext.UpdateSubresource(dataBox, _gpuTexture);
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (!disposing)
|
|
return;
|
|
|
|
StopCaptureThread();
|
|
|
|
_gpuTexture?.Dispose();
|
|
_gpuTexture = null;
|
|
|
|
_transformationMatrix?.Dispose();
|
|
_transformationMatrix = null;
|
|
|
|
lock (_lockObject)
|
|
{
|
|
_sharedMat?.Dispose();
|
|
_sharedMat = null;
|
|
}
|
|
}
|
|
|
|
private sealed record CaptureThreadSettings
|
|
{
|
|
public readonly int CustomFps;
|
|
public readonly Int2 CustomResolution;
|
|
public readonly bool FlipHorizontally;
|
|
public readonly bool FlipVertically;
|
|
public readonly Vector2 Reposition;
|
|
public readonly ResolutionFpsTypeEnum ResolutionFpsType;
|
|
public readonly float Rotation;
|
|
public readonly Vector2 Scale;
|
|
|
|
public CaptureThreadSettings(VideoDeviceInput owner, EvaluationContext context)
|
|
{
|
|
ResolutionFpsType = (ResolutionFpsTypeEnum)owner.ResolutionFpsType.GetValue(context);
|
|
CustomResolution = owner.CustomResolution.GetValue(context);
|
|
CustomFps = owner.CustomFps.GetValue(context);
|
|
FlipVertically = owner.FlipVertically.GetValue(context);
|
|
FlipHorizontally = owner.FlipHorizontally.GetValue(context);
|
|
Rotation = owner.ApplyRotationData.GetValue(context);
|
|
Reposition = owner.Reposition.GetValue(context);
|
|
Scale = owner.Scale.GetValue(context);
|
|
}
|
|
|
|
public bool HasTransformation()
|
|
{
|
|
return Math.Abs(Rotation) > Epsilon ||
|
|
Math.Abs(Scale.X - 1.0f) > Epsilon || Math.Abs(Scale.Y - 1.0f) > Epsilon ||
|
|
Math.Abs(Reposition.X) > Epsilon || Math.Abs(Reposition.Y) > Epsilon;
|
|
}
|
|
}
|
|
|
|
private enum ResolutionFpsTypeEnum
|
|
{
|
|
DeviceDefault = 0,
|
|
Custom = 1
|
|
}
|
|
|
|
#region Device Configuration UI
|
|
private void OpenVideoSettings()
|
|
{
|
|
try
|
|
{
|
|
lock (_captureDeviceLock)
|
|
{
|
|
if (_capture != null && _capture.IsOpened())
|
|
{
|
|
_capture.Set(VideoCaptureProperties.Settings, 1);
|
|
}
|
|
else
|
|
{
|
|
Log.Debug("Cannot open settings, capture device is not available.");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Debug($"Failed to open video settings: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
public void OpenCrossbarSettings()
|
|
{
|
|
Log.Debug("Crossbar settings not implemented for this version.");
|
|
}
|
|
#endregion
|
|
|
|
#region Dropdown UI
|
|
string ICustomDropdownHolder.GetValueForInput(Guid inputId)
|
|
{
|
|
if (inputId == InputDeviceName.Id) return InputDeviceName.Value;
|
|
if (inputId == CustomResolution.Id) return $"{CustomResolution.Value.X}x{CustomResolution.Value.Y}";
|
|
if (inputId == CustomFps.Id) return CustomFps.Value.ToString();
|
|
return string.Empty;
|
|
}
|
|
|
|
IEnumerable<string> ICustomDropdownHolder.GetOptionsForInput(Guid inputId)
|
|
{
|
|
if (inputId == InputDeviceName.Id)
|
|
{
|
|
if (_webcamWithIndices == null || _webcamWithIndices.Count == 0)
|
|
{
|
|
yield return "No devices found";
|
|
yield break;
|
|
}
|
|
|
|
foreach (var (webcam, _) in _webcamWithIndices)
|
|
yield return webcam;
|
|
}
|
|
else if (inputId == CustomResolution.Id)
|
|
{
|
|
var deviceName = InputDeviceName.Value;
|
|
lock (_capabilitiesLock)
|
|
{
|
|
if (_webcamCapabilities != null && _webcamCapabilities.ContainsKey(deviceName))
|
|
{
|
|
foreach (var (w, h, _) in _webcamCapabilities[deviceName].DistinctBy(c => (c.Width, c.Height)))
|
|
yield return $"{w}x{h}";
|
|
}
|
|
else
|
|
yield return "640x480";
|
|
}
|
|
}
|
|
else if (inputId == CustomFps.Id)
|
|
{
|
|
var deviceName = InputDeviceName.Value;
|
|
lock (_capabilitiesLock)
|
|
{
|
|
if (_webcamCapabilities != null && _webcamCapabilities.ContainsKey(deviceName))
|
|
{
|
|
foreach (var (_, _, fps) in _webcamCapabilities[deviceName].DistinctBy(c => c.Fps))
|
|
yield return $"{fps:F0}";
|
|
}
|
|
else
|
|
yield return "30";
|
|
}
|
|
}
|
|
}
|
|
|
|
void ICustomDropdownHolder.HandleResultForInput(Guid inputId, string selected, bool isAListItem)
|
|
{
|
|
if (inputId == InputDeviceName.Id)
|
|
InputDeviceName.SetTypedInputValue(selected);
|
|
else if (inputId == CustomResolution.Id)
|
|
{
|
|
if (selected != null)
|
|
{
|
|
var parts = selected.Split('x');
|
|
if (parts.Length == 2 &&
|
|
int.TryParse(parts[0], out var w) &&
|
|
int.TryParse(parts[1], out var h))
|
|
{
|
|
CustomResolution.SetTypedInputValue(new Int2(w, h));
|
|
|
|
var deviceName = InputDeviceName.Value;
|
|
lock (_capabilitiesLock)
|
|
{
|
|
if (_webcamCapabilities.TryGetValue(deviceName, out var caps) &&
|
|
!caps.Any(c => c.Width == w && c.Height == h))
|
|
{
|
|
SetStatus("Warning: Unsupported resolution—may fallback.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (inputId == CustomFps.Id)
|
|
{
|
|
if (double.TryParse(selected, out var fps))
|
|
{
|
|
CustomFps.SetTypedInputValue((int)fps);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Scanning for webcams and capabilities
|
|
public static void ScanWebCamDevices()
|
|
{
|
|
lock (_staticInitLock)
|
|
{
|
|
if (_devicesScanned)
|
|
return;
|
|
|
|
_webcamWithIndices = new List<WebcamWithIndex>();
|
|
lock (_capabilitiesLock)
|
|
{
|
|
_webcamCapabilities = new Dictionary<string, List<(int Width, int Height, double Fps)>>();
|
|
}
|
|
|
|
try
|
|
{
|
|
var videoInputDevices = DsDevice.GetDevicesOfCat(FilterCategory.VideoInputDevice);
|
|
for (var i = 0; i < videoInputDevices.Length; i++)
|
|
{
|
|
var device = videoInputDevices[i];
|
|
_webcamWithIndices.Add(new WebcamWithIndex(device.Name, i));
|
|
|
|
var capabilities = new List<(int Width, int Height, double Fps)>();
|
|
try
|
|
{
|
|
if (device.Mon is not IMoniker moniker)
|
|
{
|
|
Log.Debug($"Moniker is null for device {device.Name}");
|
|
continue;
|
|
}
|
|
|
|
var filterGuid = typeof(IBaseFilter).GUID;
|
|
moniker.BindToObject(null, null, ref filterGuid, out var filter);
|
|
if (filter is not IBaseFilter captureFilter)
|
|
{
|
|
Log.Debug($"Failed to create capture filter for {device.Name}");
|
|
continue;
|
|
}
|
|
|
|
captureFilter.EnumPins(out var enumPins);
|
|
var pins = new IPin[1];
|
|
while (enumPins.Next(1, pins, IntPtr.Zero) == 0)
|
|
{
|
|
pins[0].QueryPinInfo(out var pinInfo);
|
|
if (pinInfo.dir == PinDirection.Output)
|
|
{
|
|
if (pins[0] is IAMStreamConfig streamConfig)
|
|
{
|
|
streamConfig.GetNumberOfCapabilities(out int count, out int size);
|
|
if (size > 0)
|
|
{
|
|
var capsPtr = Marshal.AllocCoTaskMem(size);
|
|
try
|
|
{
|
|
for (int j = 0; j < count; j++)
|
|
{
|
|
streamConfig.GetStreamCaps(j, out var mediaType, capsPtr);
|
|
if (mediaType != null &&
|
|
mediaType.formatType == FormatType.VideoInfo &&
|
|
mediaType.formatPtr != IntPtr.Zero)
|
|
{
|
|
var vih = Marshal.PtrToStructure<VideoInfoHeader>(mediaType.formatPtr);
|
|
int w = vih.BmiHeader.Width;
|
|
int h = vih.BmiHeader.Height;
|
|
double fps = vih.AvgTimePerFrame > 0
|
|
? 10_000_000.0 / vih.AvgTimePerFrame
|
|
: 30.0;
|
|
capabilities.Add((w, h, fps));
|
|
}
|
|
|
|
if (mediaType != null)
|
|
DsUtils.FreeAMMediaType(mediaType);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Marshal.FreeCoTaskMem(capsPtr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Marshal.ReleaseComObject(pins[0]);
|
|
}
|
|
|
|
Marshal.ReleaseComObject(enumPins);
|
|
Marshal.ReleaseComObject(captureFilter);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Debug($"Failed to get capabilities for {device.Name}: {e.Message}");
|
|
}
|
|
|
|
lock (_capabilitiesLock)
|
|
{
|
|
_webcamCapabilities.Add(device.Name, capabilities);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Debug("Failed to scan webcams: " + e.Message);
|
|
}
|
|
|
|
_devicesScanned = true;
|
|
}
|
|
}
|
|
|
|
private static bool TryGetIndexForDeviceName(string deviceName, out int index)
|
|
{
|
|
index = -1;
|
|
if (_webcamWithIndices == null) return false;
|
|
|
|
var device = _webcamWithIndices.FirstOrDefault(d => d.Name == deviceName);
|
|
if (device != null)
|
|
{
|
|
index = device.Index;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public sealed record WebcamWithIndex(string Name, int Index);
|
|
#endregion
|
|
} |