public void StartCaptureFromItem(GraphicsCaptureItem item)
{
this.StopCapture();
capture = new ScreenCapture(item);
capture.FrameReady += FrameReady;
capture.StartCapture();
}
private void UpdateProvider(string oldValue, string newValue)
{
this.IsFailed = false;
this.powerPointGraphicsCaptureItemsFactory.Remove(oldValue);
if (this.currentGraphicsItem != null)
{
this.currentGraphicsItem.Closed -= Next_Closed;
}
if (App.Current?.MainWindow == null)
{
return;
}
var next = this.powerPointGraphicsCaptureItemsFactory.GetOrCreateGraphicsCaptureItem(newValue);
if (next == null && newValue != null)
{
this.IsFailed = true;
}
else if (next != null)
{
next.Closed += Next_Closed;
}
this.currentGraphicsItem = next;
this.UpdateSource();
}
protected virtual void ResetFramePool(SizeInt32 size, bool recreateDevice)
{
do
{
try
{
if (recreateDevice)
{
_device = Direct3D11Helper.CreateDevice(!PresentationToNDIAddIn.Properties.Settings.Default.UseHw);
}
}
catch
{
_device = null;
recreateDevice = true;
}
} while (_device == null);
// detect change from or to fullscreen --> captureItem needs to be recreated
if ((_wasFullscreenBefore && !IsFullscreen) || (!_wasFullscreenBefore && IsFullscreen))
{
_wasFullscreenBefore = IsFullscreen;
DisposeCaptureItemDependentStuff();
_item = GetItem();
CreateCaptureItemDependendStuff();
}
else
{
_framePool.Recreate(_device, PixelFormat, 2, size);
}
}
public RecordingOptions(GraphicsCaptureItem target, SizeUInt32 resolution, uint bitrate, uint frameRate)
{
Target = target;
Resolution = resolution;
Bitrate = bitrate;
FrameRate = frameRate;
}
private void Application_SlideShowBegin(SlideShowWindow Wn)
{
if (!PresentationToNDIAddIn.Properties.Settings.Default.NDIDynamic)
{
return;
}
_window = Wn;
_wasFullscreenBefore = IsFullscreen;
_xOrig = Wn.Presentation.SlideMaster.Width;
_yOrig = Wn.Presentation.SlideMaster.Height;
_device = Direct3D11Helper.CreateDevice(!PresentationToNDIAddIn.Properties.Settings.Default.UseHw);
_d3dDevice = Direct3D11Helper.CreateSharpDXDevice(_device);
_factory = new Factory2();
_item = GetItem();
CreateCaptureItemDependendStuff();
_ndiSender = new Thread(SendNdi)
{
Priority = ThreadPriority.Normal, Name = "DynamicNdiSenderThread", IsBackground = true
};
_ndiSender.Start();
}
public void SetGraphicItem(GraphicsCaptureItem item)
{
this.ResetState();
this.item = item;
if (this.item != null)
{
this.renderTargetDescription = new Texture2DDescription
{
CpuAccessFlags = CpuAccessFlags.None,
Width = item.Size.Width,
Height = item.Size.Height,
Usage = ResourceUsage.Default,
Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
ArraySize = 1,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
OptionFlags = ResourceOptionFlags.Shared,
MipLevels = 1,
SampleDescription = new SampleDescription(1, 0),
};
this.renderTarget = new Texture2D(d3dDevice, this.renderTargetDescription);
framePool = Direct3D11CaptureFramePool.Create(device, DirectXPixelFormat.B8G8R8A8UIntNormalized, 2, this.item.Size);
session = framePool.CreateCaptureSession(this.item);
lastSize = this.item.Size;
framePool.FrameArrived += this.OnFrameArrived;
session.StartCapture();
}
}
public void StartCapture(IntPtr hWnd, Device device, Factory factory)
{
var capturePicker = new GraphicsCapturePicker();
// ReSharper disable once PossibleInvalidCastException
// ReSharper disable once SuspiciousTypeConversion.Global
var initializer = (IInitializeWithWindow)(object)capturePicker;
initializer.Initialize(hWnd);
_captureItem = capturePicker.PickSingleItemAsync().AsTask().Result;
if (_captureItem == null)
{
return;
}
_captureItem.Closed += CaptureItemOnClosed;
var hr = NativeMethods.CreateDirect3D11DeviceFromDXGIDevice(device.NativePointer, out var pUnknown);
if (hr != 0)
{
StopCapture();
return;
}
var winrtDevice = (IDirect3DDevice)Marshal.GetObjectForIUnknown(pUnknown);
Marshal.Release(pUnknown);
_captureFramePool = Direct3D11CaptureFramePool.Create(winrtDevice, DirectXPixelFormat.B8G8R8A8UIntNormalized, 2, _captureItem.Size);
_captureSession = _captureFramePool.CreateCaptureSession(_captureItem);
_captureSession.StartCapture();
IsCapturing = true;
}
public void Dispose()
{
_closedEvent.Set();
_framePool?.Dispose();
_session?.Dispose();
if (_captureItem != null)
{
_captureItem.Closed -= OnClosed;
}
_captureItem = null;
_device = null;
_d3dDevice = null;
_composeTexture?.Dispose();
_composeTexture = null;
_composeRenderTargetView?.Dispose();
_composeRenderTargetView = null;
_currentFrame?.Dispose();
//_session?.Dispose();
//_swapChain?.Dispose();
//_swapChain = null;
//_framePool = null;
//_session = null;
//_captureItem = null;
}
public void StartCaptureFromItem(GraphicsCaptureItem item)
{
StopCapture();
capture_core = new BasicCapture(device, item);
capture_core.StartCapture();
}
public void StartCaptureInternal(GraphicsCaptureItem item)
{
StopCapture();
_item = item;
_lastSize = _item.Size;
_swapChain = new CanvasSwapChain(_canvasDevice, _item.Size.Width, _item.Size.Height, 96);
swapChain.SwapChain = _swapChain;
_framePool = Direct3D11CaptureFramePool.Create(
_canvasDevice, // D3D device
DirectXPixelFormat.B8G8R8A8UIntNormalized, // Pixel format
60, // Number of frames
_item.Size); // Size of the buffers
_session = _framePool.CreateCaptureSession(_item);
_framePool.FrameArrived += (s, a) =>
{
using (var frame = _framePool.TryGetNextFrame())
{
ProcessFrame(frame);
}
};
_item.Closed += (s, a) =>
{
StopCapture();
};
_session.StartCapture();
}
public void UpdateResolution(SizeInt32 size)
{
if (size.Height <= 0 || size.Width <= 0)
{
return;
}
if (_framePool is not null && _session is not null)
{
// Unsubscribe from old framePool
_framePool.FrameArrived -= OnFrameArrived;
// Dispose old session and framePool
_session.Dispose();
_framePool.Dispose();
}
_canvasDevice = CanvasDevice.GetSharedDevice();
// Create a frame pool with room for only 1 frame because we're getting a single frame, not a video.
_framePool =
Direct3D11CaptureFramePool.Create(_canvasDevice, DirectXPixelFormat.B8G8R8A8UIntNormalized, 1, size);
_session = _framePool.CreateCaptureSession(GraphicsCaptureItem.CreateFromVisual(_capturedVisual));
_framePool.FrameArrived += OnFrameArrived;
_session.StartCapture();
}
public void StopRecord()
{
field = null;
framePool.Dispose();
canvasDevice.Dispose();
session.Dispose();
}
public MainApplication(ProcessDetection processDetection, List <ClientMap> clientMapList, Settings appSettings)
{
this.AppSettings = appSettings;
InitializeBackgroundWorker();
this.processDetection = processDetection;
this.ClientMapping = clientMapList.AsEnumerable();
IEnumerable <MonitorInfo> monitors = MonitorEnumerationHelper.GetMonitors();
IEnumerable <MonitorInfo> primMons = from primaryMonitor in monitors
where primaryMonitor.IsPrimary == true
select primaryMonitor;
MonitorInfo monitor = primMons.FirstOrDefault();
GraphicsCaptureItem item = CaptureHelper.CreateItemForMonitor(monitor.Hmon);
switch (Settings.AppRunMode)
{
case SettingsAppRunMode.MockGame:
this.mockImage = new Mat(Settings.MockImageGame);
break;
case SettingsAppRunMode.MockLauncher:
this.mockImage = new Mat(Settings.MockImageLauncher);
break;
}
if (item != null)
{
this.StartCaptureFromItem(item);
}
}
private async Task StartCaptureInternal(GraphicsCaptureItem item)
{
// Stop the previous capture if we had one.
StopCapture();
_item = item;
_lastSize = _item.Size;
_canvasDevice = new CanvasDevice();
_framePool = Direct3D11CaptureFramePool.Create(
_canvasDevice, // D3D device
DirectXPixelFormat.B8G8R8A8UIntNormalized, // Pixel format
2, // Number of frames
_item.Size); // Size of the buffers
_item.Closed += (s, a) =>
{
StopCapture();
};
_session = _framePool.CreateCaptureSession(_item);
_session.StartCapture();
await Task.Delay(500);
var frame = _framePool.TryGetNextFrame();
await ProcessFrame(frame);
StopCapture();
}
public void Stop()
{
_captureItem = null;
_framePool.Dispose();
_framePool = null;
_session.Dispose();
_session = null;
}
public void StartCaptureFromItem(GraphicsCaptureItem item, IntPtr hWnd)
{
StopCapture();
capture = new BasicCapture(device, item, hWnd);
capture.StartCapture();
}
public void StopCapture()
{
_session?.Dispose();
_framePool?.Dispose();
_item = null;
_session = null;
_framePool = null;
}
public Encoder(IDirect3DDevice device, GraphicsCaptureItem item)
{
_device = device;
_captureItem = item;
_isRecording = false;
CreateMediaObjects();
}
private void StartCapture(GraphicsCaptureItem item)
{
_capture = new CaptureEngine(_device, item);
_capture.FrameArrived += _headBridge.OnFrameArrived;
_capture.FrameArrived += _vestBridge.OnFrameArrived;
_capture.FrameArrived += _leftArmBridge.OnFrameArrived;
_capture.FrameArrived += _rightArmBridge.OnFrameArrived;
_capture.StartCapture();
}
public void StopCapture() // ...or release resources
{
_captureSession?.Dispose();
_captureFramePool?.Dispose();
_captureSession = null;
_captureFramePool = null;
_captureItem = null;
IsCapturing = false;
}
private void StartHmonCapture(IntPtr hmon)
{
GraphicsCaptureItem item = CaptureHelper.CreateItemForMonitor(hmon);
if (item != null)
{
sample.StartCaptureFromItem(item);
}
}
private void StartHwndCapture(IntPtr hwnd)
{
GraphicsCaptureItem item = CaptureHelper.CreateItemForWindow(hwnd);
if (item != null)
{
sample.StartCaptureFromItem(item);
}
}
public Encoder(IDirect3DDevice device, GraphicsCaptureItem item)
{
_device = device;
_d3dDevice = Direct3D11Helpers.CreateSharpDXDevice(device);
_captureItem = item;
_isRecording = false;
_previewLock = new object();
CreateMediaObjects();
}
public void OnInitialization()
{
//LND
lnd = new LEDandDisplay(50, 30, 16, "COM6", 1650, 1050, false, 50);
Update();
//WriteSittings();
ReadSittings();
ShowSittings();
//rec
_canvasDevice = new CanvasDevice();
_compositionGraphicsDevice = CanvasComposition.CreateCompositionGraphicsDevice(
Window.Current.Compositor,
_canvasDevice);
//framerate
dt = DateTime.Now;
//Arduino
ArduinoInit();
//background
bgndSession = new ExtendedExecutionSession();
bgndSession.Reason = ExtendedExecutionReason.Unspecified;
//drawing
_compositor = Window.Current.Compositor;
_surface = _compositionGraphicsDevice.CreateDrawingSurface(
new Size(100, 100),
DirectXPixelFormat.B8G8R8A8UIntNormalized,
DirectXAlphaMode.Premultiplied);
var visual = _compositor.CreateSpriteVisual();
visual.RelativeSizeAdjustment = Vector2.One;
var brush = _compositor.CreateSurfaceBrush(_surface);
brush.HorizontalAlignmentRatio = 0.5f;
brush.VerticalAlignmentRatio = 0.5f;
brush.Stretch = CompositionStretch.Uniform;
visual.Brush = brush;
ElementCompositionPreview.SetElementChildVisual(this, visual);
if (!GraphicsCaptureSession.IsSupported())
{
CaptureButton.Visibility = Visibility.Collapsed;
}
//autostart
if (lnd.autostart == true)
{
_item = lnd.item;
//StartCaptureInternal(lnd.item);
StartCaptureAsync();
}
}
public void StartCaptureFromItem(GraphicsCaptureItem item)
{
StopCapture();
_capture = new BasicCapture(_device, item);
var surface = _capture.CreateSurface(_compositor);
_brush.Surface = surface;
_capture.StartCapture();
}
public Encoder(Direct3D11Device device, GraphicsCaptureItem item)
{
_device = device;
_deviceContext = device.ImmediateContext;
_multiThread = _device.Multithread;
_captureItem = item;
_captureItem.Closed += OnCaptureItemClosed;
_isRecording = false;
CreateMediaObjects();
}
/// <summary>
/// Starts a video capture from the provided capture item.
/// </summary>
/// <param name="item">The <see cref="GraphicsCaptureItem" /> to start the video capture from.</param>
public void StartCapture(GraphicsCaptureItem item)
{
InitializeDevices();
InitializeEvents();
InitializeCaptureItem(item);
InitializeFramePool();
InitializeSession();
InitializeBlankTexture();
Task.Run(EnqueueFrames);
}
public void Dispose()
{
_session?.Dispose();
_framePool?.Dispose();
_swapChain?.Dispose();
_swapChain = null;
_framePool = null;
_session = null;
_item = null;
}
public async Task Record(GraphicsCaptureItem _field)
{
canvasDevice = new CanvasDevice();
field = _field;
framePool = Direct3D11CaptureFramePool.Create(
canvasDevice, // D3D device
DirectXPixelFormat.A8P8, // Pixel format
2, // Number of frames
field.Size); // Size of the buffers
session = framePool.CreateCaptureSession(field);
}
private async Task StartPickerCaptureAsync()
{
var picker = new GraphicsCapturePicker();
picker.SetWindow(hwnd);
GraphicsCaptureItem item = await picker.PickSingleItemAsync();
if (item != null)
{
sample.StartCaptureFromItem(item);
}
}
