public int Write(Frame frame, int inputNo) { _currentFramePts = frame.Properties.Pts; _currentFrame?.Dispose(); _currentFrame = _uploader.Upload(frame.Properties.DataPtr0, frame.Properties.DataPtr1, frame.Properties.DataPtr2); return(0); }
public int Write(Frame frame, int inputNo) { _currentFramePts = frame.Properties.Pts; _currentFrame?.Dispose(); _currentFrame = _transform.Process(frame); return(0); }
// the code below failing due to GC /*public static SharpDX.WIC.BitmapSource LoadBitmap(DirectXContext directXContext, Stream stream) * { * var bitmapDecoder = new SharpDX.WIC.BitmapDecoder( * directXContext.ImagingFactory2, * stream, * SharpDX.WIC.DecodeOptions.CacheOnLoad); * * var formatConverter = new SharpDX.WIC.FormatConverter(directXContext.ImagingFactory2); * * formatConverter.Initialize( * bitmapDecoder.GetFrame(0), * SharpDX.WIC.PixelFormat.Format32bppPRGBA, * SharpDX.WIC.BitmapDitherType.None, * null, * 0.0, * SharpDX.WIC.BitmapPaletteType.Custom); * * return formatConverter; * }*/ public static DirectXResource CreateTexture2DFromBitmap(DirectXContext directXContext, SharpDX.WIC.BitmapSource bitmapSource) { // Allocate DataStream to receive the WIC image pixels int stride = bitmapSource.Size.Width * 4; using (var buffer = new SharpDX.DataStream(bitmapSource.Size.Height * stride, true, true)) { try { // Copy the content of the WIC to the buffer bitmapSource.CopyPixels(stride, buffer); } catch (Exception e) { Core.LogError(e, "Failed to load image into Dx"); } return(directXContext.Pool.Get("loadbitmap", DirectXResource.Desc(bitmapSource.Size.Width, bitmapSource.Size.Height, SharpDX.DXGI.Format.R8G8B8A8_UNorm, SharpDX.Direct3D11.BindFlags.ShaderResource, SharpDX.Direct3D11.ResourceUsage.Immutable), new SharpDX.DataRectangle(buffer.DataPointer, stride))); } }
public void Dispose() { _currentFrame?.Dispose(); _dx?.RemoveRef(); _currentFrame = null; _dx = null; }
private void DisplayAsTexture(DirectXResource res) { if (res.Texture2D == null) { Core.LogWarning("DisplayAsTexture failed as Texture2D == null"); return; } res.GetDx().RunOnContext(ctx => { ctx.CopyResource(res.Texture2D, _sharedResource); ctx.Flush(); }, "CopyToUI"); if (_d3dimage.TryLock(TimeSpan.FromMilliseconds(1500))) { _d3dimage.AddDirtyRect(new Int32Rect(0, 0, res.Texture2D.Description.Width, res.Texture2D.Description.Height)); _d3dimage.Unlock(); } else { Core.LogWarning("Failed to Lock DirectXPresenter/d3dimage"); } if (Source != _d3dimage) { Core.LogInfo("Assigning new D3DImage"); Source = _d3dimage; } }
public void Back(DirectXResource resource) { if (resource != null) { Interlocked.Decrement(ref _countInField); if (resource.CommandList != null) { resource.CommandList.Dispose(); resource.CommandList = null; } if (!resource.Cachable) { resource.CleanInternalResources(); return; } resource.InPoolTime = DateTime.UtcNow; lock (this) { if (_active) { _perType[resource.Texture2D.Description].AddLast(resource); return; } } if (resource != null) { resource.CleanInternalResources(); } } }
internal DirectXResource Render(DirectXContext dx, VideoFilterChainDescriptor filterChain, DeviceContext ctx, DirectXResource texture) { DirectXResource current = texture; try { if (dx != _dx || !Equals(filterChain, _filterChain)) { TearDown(); _dx = dx; _filterChain = filterChain; Setup(dx, filterChain); } foreach (var stage in _stages) { var next = stage.Render(ctx, current); if (current != next && current != texture) { dx.Pool.Back(current); } current = next; dx.Flush(ctx, "Filter stage"); } } catch (SharpDXException e) { _dx.Broken(e); } return(current); }
private void Render(DirectXResource input, DirectXDownloaderPlaneData plane, DeviceContext ctx) { using (var srv = input.GetShaderResourceView()) using (var rtv = plane.GpuTexture.GetRenderTargetView()) { plane.Pipeline.Render(ctx, rtv, srv); } }
private FramePlaneDesc Map(DirectXResource input, DirectXDownloaderPlaneData plane, DeviceContext ctx) { ctx.CopyResource(plane.GpuTexture.Texture2D, plane.CpuTexture.Texture2D); var db = ctx.MapSubresource(plane.CpuTexture.Texture2D, 0, MapMode.Read, SharpDX.Direct3D11.MapFlags.None); return(new FramePlaneDesc { Data = db.DataPointer, Stride = db.RowPitch, StrideCount = _height / plane.Format.HeightFactor }); }
private void Render(DirectXResource input, DirectXResource output, DirectXTransformerPlaneData plane, DeviceContext ctx) { using (var srv = input.GetShaderResourceView()) using (var rtv = new RenderTargetView(ctx.Device, output.Texture2D, new RenderTargetViewDescription { Format = plane.Format, Dimension = RenderTargetViewDimension.Texture2D })) { plane.Pipeline.Render(ctx, rtv, srv); } }
public virtual DirectXResource Render(DeviceContext ctx, DirectXResource source) { var target = Dx.Pool.Get("FilterStage", DirectXResource.Desc(source.Texture2D.Description.Width, source.Texture2D.Description.Height)); using var rtv = target.GetRenderTargetView(); using var srv = source.GetShaderResourceView(); Pipeline.SetPosition(DirectXPipelineConfig.FullRectangle, new Viewport(0, 0, source.Texture2D.Description.Width, source.Texture2D.Description.Height)); Render(ctx, rtv, srv, source.Texture2D.Description.Width, source.Texture2D.Description.Height); return(target); }
public int Write(Frame frame, int inputNo) { _currentFramePts = frame.Properties.Pts; _currentFrame?.Dispose(); _currentFrame = _dx.Pool.Get("passthru2", DirectXResource.Desc(_width, _height, SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct3D11.BindFlags.ShaderResource, SharpDX.Direct3D11.ResourceUsage.Immutable), new SharpDX.DataRectangle(frame.Properties.DataPtr0, _width * 4)); return(0); }
public ErrorCodes Read(Frame frame) { if (_currentFrame == null) { return(ErrorCodes.TryAgainLater); } else { frame.InitFromDirectX(_currentFrame, _currentFramePts); _currentFrame = null; return(ErrorCodes.Ok); } }
public DirectXResource Process(Frame input) { var texOut = _dx.Pool.Get("transfer out", DirectXResource.Desc(_width, _height, Format.NV12, BindFlags.RenderTarget, ResourceUsage.Default, ResourceOptionFlags.Shared, CpuAccessFlags.None)); _dx.RunOnContext(ctx => { for (int q = 0; q < _planes.Count; q++) { Render(input.DirectXResourceRef.Instance, texOut, _planes[q], ctx); } }, "Transfer Render"); return(texOut); }
private static DirectXDownloaderPlaneData CreatePlane(DirectXContext dx, int width, int height, DirectXDownloaderFormatPlane plane) { var config = new DirectXPipelineConfig { VertexShaderFile = "format_conversion.hlsl", VertexShaderFunction = plane.VS, PixelShaderFile = "format_conversion.hlsl", PixelShaderFunction = plane.PS, }; var pipeline = new DirectXPipeline <ConverterFilterConstantBuffer>(config, dx); pipeline.SetDebugColor(0, 0, 0, 1); pipeline.SetPosition(DirectXPipelineConfig.FullRectangle, new Viewport(0, 0, width / plane.WidthFactor, height / plane.HeightFactor)); var colorMatrix = ColorMatrices.GetInverted(ColorMatrices.Full709); var cm = colorMatrix.Values; var cb = new ConverterFilterConstantBuffer { width = width, height = height, width_i = 1.0f / width, width_d2 = width / 2, height_d2 = height / 2, width_x2_i = 0.5f / width, color_vec0 = new Vector4(cm[0], cm[1], cm[2], cm[3]), color_vec1 = new Vector4(cm[4], cm[5], cm[6], cm[7]), color_vec2 = new Vector4(cm[8], cm[9], cm[10], cm[11]), color_range_min = new Vector3(0.0f, 0.0f, 0.0f), color_range_max = new Vector3(1.0f, 1.0f, 1.0f), }; pipeline.SetConstantBuffer(cb, false); return(new DirectXDownloaderPlaneData { Format = plane, Pipeline = pipeline, GpuTexture = dx.Pool.Get("downloadGpu", DirectXResource.Desc(width / plane.WidthFactor, height / plane.HeightFactor, plane.Format)), CpuTexture = dx.Pool.Get("downloadCpu", DirectXResource.Desc(width / plane.WidthFactor, height / plane.HeightFactor, plane.Format, BindFlags.None, ResourceUsage.Staging, ResourceOptionFlags.None, CpuAccessFlags.Read)) }); }
private void DownloadAndDisplayAsBitmap(DirectXResource res) { int width = res.Texture2D.Description.Width; int height = res.Texture2D.Description.Height; var dx = res.GetDx(); PrepareSoftwareImage(width, height, PixelFormats.Bgra32); if (_cpuTexture == null || _cpuTexture.Texture2D == null || _cpuTexture.Texture2D.Description.Width != width || _cpuTexture.Texture2D.Description.Height != height || _cpuTextureOwner != dx) { _cpuTexture?.Dispose(); _cpuTextureOwner = dx; _cpuTexture = dx.Pool.Get("uiCpu", DirectXResource.Desc(width, height, SharpDX.DXGI.Format.B8G8R8A8_UNorm, BindFlags.None, ResourceUsage.Staging, ResourceOptionFlags.None, CpuAccessFlags.Read)); } DataBox db = new DataBox(); dx.RunOnContext(ctx => { ctx.CopyResource(res.Texture2D, _cpuTexture.Texture2D); ctx.Flush(); db = ctx.MapSubresource(_cpuTexture.Texture2D, 0, MapMode.Read, MapFlags.None); }, "Download for ui"); if (db.SlicePitch > 0) { _softwareImage.WritePixels(new Int32Rect(0, 0, width, height), db.DataPointer, db.SlicePitch, db.RowPitch); } dx.RunOnContext(ctx => ctx.UnmapSubresource(_cpuTexture.Texture2D, 0), "Unmap for ui"); if (Source != _softwareImage) { Source = _softwareImage; } }
public void Enqueue(IntPtr buffer, int size) { lock (_queueLock) { if (_queue.Count == _maxPackets) { _streamer.PacketPool.Back(_queue.Dequeue()); Core.LogWarning($"Queue '{_name}' reached maximum"); } var packet = _streamer.PacketPool.Rent(); var now = Core.GetCurrentTime(); if (_dx == null) { packet.InitFromBuffer(buffer, size, now); } else { var dx = _dx.Pool.Get("WebBrowserQueue", DirectXResource.Desc(_width, _height, SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct3D11.BindFlags.ShaderResource, SharpDX.Direct3D11.ResourceUsage.Immutable), new SharpDX.DataRectangle(buffer, _width * 4)); packet.InitFromDirectX(dx, now); } _queue.Enqueue(packet); // update last _streamer.PacketPool.Back(_last); _last = _streamer.PacketPool.Rent(); _last.CopyContentFrom(packet); _lastEnqueueTime = now; Monitor.PulseAll(_queueLock); } }
private DirectXPipeline <BlendingConstantBuffer> GetPipeline(VideoBlenderInputRuntime runtime, DirectXResource canvas, DirectXResource image) { if (_directXPipelineLowRes != null) { if (runtime.Description.Ptz.Width > 0 && runtime.Description.Ptz.Height > 0) { var heightScale = runtime.Description.Rect.Height / runtime.Description.Ptz.Height; var widthScale = runtime.Description.Rect.Width / runtime.Description.Ptz.Width; if (heightScale * canvas.Texture2D.Description.Height < 0.8 * image.Texture2D.Description.Height || widthScale * canvas.Texture2D.Description.Width < 0.8 * image.Texture2D.Description.Width) { return(_directXPipelineLowRes); } } } return(_directXPipeline); }
public int Write(Packet packet) { RemoveCurrent(); _currentFramePts = packet.Properties.Pts; if (_dx != null) { _currentResource = new RefCounted <DirectXResource>(_dx.Pool.Get("passthru", DirectXResource.Desc(_width, _height, SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct3D11.BindFlags.ShaderResource, SharpDX.Direct3D11.ResourceUsage.Immutable), new SharpDX.DataRectangle(packet.Properties.DataPtr, _width * 4))); } else { _currentResource = packet.DirectXResourceRef.AddRef(); } return(0); }
private bool RenderDirectX(Frame resultPayload, out PayloadTrace trace) { trace = null; bool hasAnyContent = false; var dx = _setup.Dx; try { if (dx.IsBrokenAndLog("Blender")) { return(false); } var texture = dx.Pool.Get("Blender", DirectXResource.Desc(_setup.Width, _setup.Height, SharpDX.DXGI.Format.B8G8R8A8_UNorm, BindFlags.ShaderResource | BindFlags.RenderTarget, ResourceUsage.Default, ResourceOptionFlags.None)); _defferedContext = _defferedContext ?? new DeviceContext(dx.Device); //using using (var rtv = texture.GetRenderTargetView()) { int counter = 0; foreach (var runtime in _inputRuntimesSorted) { var frameData = GetRuntimeOrFixedFrame(runtime); if (frameData != null && runtime.Description.Visible) { hasAnyContent = true; UpdateTrace(frameData, ref trace); var xResource = frameData.Payload.DirectXResourceRef.Instance; if (xResource.CommandList != null) { _defferedContext.ExecuteCommandList(xResource.CommandList, false); xResource.CommandList.Dispose(); xResource.CommandList = null; } var pipeline = GetPipeline(runtime, texture, xResource); SetDebugColor(pipeline, counter++); UpdatePositionInDxPipeline(runtime, pipeline, xResource.Texture2D.Description.Width, xResource.Texture2D.Description.Height); var filteredResource = runtime.DirectXFilterRuntime.Render(dx, runtime.Description.FilterChain, _defferedContext, xResource); if (ReferenceEquals(filteredResource, xResource)) { using (var srv = filteredResource.GetShaderResourceView()) pipeline.Render(_defferedContext, rtv, srv); dx.Flush(_defferedContext, "Blender Flush All"); } else { dx.Flush(_defferedContext, "Blender Flush All"); using (var srvFiltered = filteredResource.GetShaderResourceView()) pipeline.Render(_defferedContext, rtv, srvFiltered); dx.Flush(_defferedContext, "Blender Flush All"); filteredResource.Dispose(); } } } } if (hasAnyContent) { if (trace != null) { trace = PayloadTrace.Create(_name, trace); } dx.Flush(_defferedContext, "Blender Flush All"); var allFilteredResource = _dxFilterRuntime.Render(dx, _setup.WeakOptions.FilterChain, _defferedContext, texture); dx.Flush(_defferedContext, "Blender Flush All"); resultPayload.InitFromDirectX(allFilteredResource, _currentFpsTicks); if (allFilteredResource != texture) { dx.Pool.Back(texture); } } } catch (Exception e) { dx.Broken(e); } return(hasAnyContent); }
private void OpenSharedResourceIfNeeded(DirectXResource res) { try { bool reinit = false; _occludedCounter++; if (_occludedCounter % 1 == 0) // every 200 ms { var state = _device?.CheckDeviceState(_windowHandle) ?? DeviceState.Ok; bool occludedState = state == DeviceState.PresentOccluded; // happens when windows is locked; then we could get black screen in preview d3dImage reinit = _occludedState && !occludedState; // reinit if change from bad -> good if (reinit) { Core.LogInfo("occluded -> normal"); if (_windowStateManager.IsMinimized()) { _windowStateManager.IsMinimizedChanged += OnwindowStateManagerIsMinimizedChanged; } else { _ = ReinitSurfacesWithDelay(); } } if (!_occludedState && occludedState) { Core.LogInfo("normal -> occluded"); } _occludedState = occludedState; } if (_sharedResource == null || _sharedResource.Description.Width != res.Texture2D.Description.Width || _sharedResource.Description.Height != res.Texture2D.Description.Height || _sharedResourceOwner != res.GetDx() || _reinitSurfaces) { Core.LogInfo("Initing DX Presenter surface"); Source = null; _reinitSurfaces = false; _surfaceD9?.Dispose(); _sharedResource?.Dispose(); _surfaceD9 = null; _sharedResource = null; _sharedResourceOwner = null; IntPtr handle = IntPtr.Zero; _surfaceD9 = Surface.CreateRenderTarget(_device, res.Texture2D.Description.Width, res.Texture2D.Description.Height, Format.A8R8G8B8, MultisampleType.None, 0, true, ref handle); if (handle == IntPtr.Zero) { Core.LogWarning("DirectX 9 Device failed to create Surface. Reinit Devices"); _device?.Dispose(); _direct3d?.Dispose(); _device = null; _direct3d = null; InitDx9(); _surfaceD9 = Surface.CreateRenderTarget(_device, res.Texture2D.Description.Width, res.Texture2D.Description.Height, Format.A8R8G8B8, MultisampleType.None, 0, true, ref handle); if (handle == IntPtr.Zero) { Core.LogWarning("DirectX 9 Device failed to create Surface after recreation."); } } _sharedResource = res.GetDx().Device.OpenSharedResource <Texture2D>(handle); _sharedResourceOwner = res.GetDx(); _d3dimage = new D3DImage(); _d3dimage.Lock(); _d3dimage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, _surfaceD9.NativePointer); _d3dimage.Unlock(); Core.LogInfo("Inited DX Presenter surface"); } } catch (Exception e) { Core.LogError(e, "Failed to open shared resource"); } }