// 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 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 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 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);
}
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);
}