public byte[] GetData(Resource res, int subresource, Size3 size, int pixelByteSize)
{
var result = new byte[size.Product * pixelByteSize];
var data = context.MapSubresource(res, subresource, MapMode.Read, MapFlags.None);
int srcOffset = 0;
int dstOffset = 0;
int rowSize = size.Width * pixelByteSize;
int sliceOffset = data.SlicePitch - data.RowPitch * size.Height;
Debug.Assert(rowSize <= data.RowPitch);
for (int curZ = 0; curZ < size.Depth; ++curZ)
{
for (int curY = 0; curY < size.Height; ++curY)
{
Marshal.Copy(data.DataPointer + srcOffset, result, dstOffset, rowSize);
srcOffset += data.RowPitch;
dstOffset += rowSize;
}
srcOffset += sliceOffset;
}
context.UnmapSubresource(res, subresource);
return(result);
}
unsafe void DrawVertices(int[] indices, Vertex[] vertices, int bufferIndex)
{
if (bufferIndex != currentBufferIndex)
{
indexBuffer = indexBuffers[bufferIndex];
vertexBuffer = vertexBuffers[bufferIndex];
currentBufferIndex = bufferIndex;
deviceContext.InputAssembler.SetIndexBuffer(indexBuffer, DXGI.Format.R32_UInt, 0);
deviceContext.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(vertexBuffer, sizeof(Vertex), 0));
}
DataStream stream;
deviceContext.MapSubresource(indexBuffer, D3D11.MapMode.WriteDiscard, D3D11.MapFlags.None, out stream);
stream.Position = 0;
stream.WriteRange(indices);
deviceContext.UnmapSubresource(indexBuffer, 0);
stream.Dispose();
deviceContext.MapSubresource(vertexBuffer, D3D11.MapMode.WriteDiscard, D3D11.MapFlags.None, out stream);
stream.Position = 0;
stream.WriteRange(vertices);
deviceContext.UnmapSubresource(vertexBuffer, 0);
stream.Dispose();
deviceContext.DrawIndexed(indices.Length, 0, 0);
}
public WaveSolution[] GetSolutionSet()
{
CloseCurrentBuffer();
DataStream stream;
WaveSolution[] read;
ImmediateContext.MapSubresource(_waveSwapChain.CurrentBuffer, 0, D3D11.MapMode.Read, D3D11.MapFlags.None, out stream);
read = stream.ReadRange <WaveSolution>(VertexCount);
ImmediateContext.UnmapSubresource(_waveSwapChain.CurrentBuffer, 0);
return(read);
}
public void Render()
{
if (!_isDirty)
{
return;
}
if (!IsEnabled)
{
return;
}
_wicRenderTarget.BeginDraw();
_wicRenderTarget.Clear(_clearColor);
_wicRenderTarget.DrawText(_text, _textFormat, _rect, _sceneColorBrush);
_wicRenderTarget.EndDraw();
var bitmapLock = _wicBitmap.Lock(SharpDX.WIC.BitmapLockFlags.Read);
DataStream stream;
_immediateContext.MapSubresource(_renderTexture, 0, 0, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out stream);
stream.WriteRange(bitmapLock.Data.DataPointer, _bitmapSize);
_immediateContext.UnmapSubresource(_renderTexture, 0);
stream.Dispose();
bitmapLock.Dispose();
_isDirty = false;
}
/// <summary>
/// Sets given content to the constant buffer.
/// </summary>
/// <param name="deviceContext">The context used for updating the constant buffer.</param>
/// <param name="dataToSet">The data to set.</param>
internal void SetData(D3D11.DeviceContext deviceContext, T dataToSet)
{
DataBox dataBox = deviceContext.MapSubresource(base.ConstantBuffer, 0, D3D11.MapMode.WriteDiscard, D3D11.MapFlags.None);
SharpDX.Utilities.Write(dataBox.DataPointer, ref dataToSet);
deviceContext.UnmapSubresource(base.ConstantBuffer, 0);
}
/// <summary>
/// Triggers internal rendering within the resource (e. g. Render to Texture).
/// </summary>
/// <param name="renderState">Current render state.</param>
public void Render(RenderState renderState)
{
D3D11.DeviceContext deviceContext = renderState.Device.DeviceImmediateContextD3D11;
// Upload the last read video frame to texture buffer on the graphics device
if (m_thumbnailFrame != null)
{
SharpDX.DataBox dataBox = deviceContext.MapSubresource(m_texture, 0, D3D11.MapMode.WriteDiscard, D3D11.MapFlags.None);
try
{
unsafe
{
int *frameBufferPointerNative = (int *)m_thumbnailFrame.Pointer.ToPointer();
int *textureBufferPointerNative = (int *)dataBox.DataPointer.ToPointer();
// Performance optimization using MemCopy
// see http://www.rolandk.de/wp/2015/05/wie-schnell-man-speicher-falsch-kopieren-kann/
for (int loopY = 0; loopY < m_videoHeight; loopY++)
{
IntPtr rowStartTexture = new IntPtr(textureBufferPointerNative + (dataBox.RowPitch / 4) * loopY);
IntPtr rowStartSource = new IntPtr(frameBufferPointerNative + (m_videoWidth) * loopY);
CommonTools.CopyMemory(rowStartSource, rowStartTexture, (ulong)dataBox.RowPitch);
}
}
}
finally
{
GraphicsHelper.SafeDispose(ref m_thumbnailFrame);
deviceContext.UnmapSubresource(m_texture, 0);
}
}
}
public void TakeSnapshot(string fileName)
{
Texture2D snapshotTexture;
lock (device)
{
Utilities.Dispose(ref rtv);
Utilities.Dispose(ref backBuffer);
swapChain.ResizeBuffers(0, decoder.vDecoder.info.Width, decoder.vDecoder.info.Height, Format.Unknown, SwapChainFlags.None);
backBuffer = Texture2D.FromSwapChain <Texture2D>(swapChain, 0);
rtv = new RenderTargetView(device, backBuffer);
context.Rasterizer.SetViewport(0, 0, backBuffer.Description.Width, backBuffer.Description.Height);
for (int i = 0; i < swapChain.Description.BufferCount; i++)
{
context.OutputMerger.SetRenderTargets(rtv);
context.ClearRenderTargetView(rtv, cfg.video._ClearColor);
context.Draw(6, 0);
swapChain.Present(cfg.video.VSync, PresentFlags.None);
}
snapshotTexture = new Texture2D(device, new Texture2DDescription()
{
Usage = ResourceUsage.Staging,
ArraySize = 1,
MipLevels = 1,
Width = backBuffer.Description.Width,
Height = backBuffer.Description.Height,
Format = Format.B8G8R8A8_UNorm,
BindFlags = BindFlags.None,
CpuAccessFlags = CpuAccessFlags.Read,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0)
});
context.CopyResource(backBuffer, snapshotTexture);
ResizeBuffers(null, null);
}
System.Drawing.Bitmap snapshotBitmap = new System.Drawing.Bitmap(snapshotTexture.Description.Width, snapshotTexture.Description.Height);
DataBox db = context.MapSubresource(snapshotTexture, 0, MapMode.Read, SharpDX.Direct3D11.MapFlags.None);
var bitmapData = snapshotBitmap.LockBits(new System.Drawing.Rectangle(0, 0, snapshotBitmap.Width, snapshotBitmap.Height), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
var sourcePtr = db.DataPointer;
var destPtr = bitmapData.Scan0;
for (int y = 0; y < snapshotBitmap.Height; y++)
{
Utilities.CopyMemory(destPtr, sourcePtr, snapshotBitmap.Width * 4);
sourcePtr = IntPtr.Add(sourcePtr, db.RowPitch);
destPtr = IntPtr.Add(destPtr, bitmapData.Stride);
}
snapshotBitmap.UnlockBits(bitmapData);
context.UnmapSubresource(snapshotTexture, 0);
snapshotTexture.Dispose();
try { snapshotBitmap.Save(fileName); } catch (Exception) { }
snapshotBitmap.Dispose();
}
public T[] GetData <T>(int count) where T : struct
{
_deviceContext.CopyResource(_buffer, _resultBuffer);
SharpDX.DataStream stream;
SharpDX.DataBox box = _deviceContext.MapSubresource(_resultBuffer, 0, MapMode.Read, MapFlags.None, out stream);
T[] result = stream.ReadRange <T>(count);
_deviceContext.UnmapSubresource(_buffer, 0);
return(result);
}
public static int[] GetIntArrayFromByfferData(SharpDX.Direct3D11.DeviceContext dc, SharpDX.Direct3D11.Buffer histogramCPU)
{
try
{
var databox = dc.MapSubresource(histogramCPU, 0, MapMode.Read, SharpDX.Direct3D11.MapFlags.None);
int[] intArray = new int[databox.RowPitch / sizeof(int)];
System.Runtime.InteropServices.Marshal.Copy(databox.DataPointer, intArray, 0, intArray.Length);
return(intArray);
}
finally
{
dc.UnmapSubresource(histogramCPU, 0);
}
}
/// <summary>
/// Triggers internal rendering within the resource (e. g. Render to Texture).
/// </summary>
/// <param name="renderState">Current render state.</param>
public void Render(RenderState renderState)
{
D3D11.DeviceContext deviceContext = renderState.Device.DeviceImmediateContextD3D11;
// Do nothing here if we have no new frame to render
if (m_lastFrameTimestamp >= m_videoReader.CurrentFrameTimestamp)
{
return;
}
// Upload the last read video frame to texture buffer on the graphics device
using (SeeingSharpMediaBuffer mediaBuffer = m_videoReader.GetCurrentFrame())
{
MF.MediaBuffer mediaBufferNative = mediaBuffer.GetBuffer();
SharpDX.DataBox dataBox = deviceContext.MapSubresource(m_texture, 0, D3D11.MapMode.WriteDiscard, D3D11.MapFlags.None);
try
{
int cbMaxLength;
int cbCurrentLenght;
IntPtr mediaBufferPointer = mediaBufferNative.Lock(out cbMaxLength, out cbCurrentLenght);
try
{
unsafe
{
int *frameBufferPointerNative = (int *)mediaBufferPointer.ToPointer();
int *textureBufferPointerNative = (int *)dataBox.DataPointer.ToPointer();
// Performance optimization using MemCopy
// see http://www.rolandk.de/wp/2015/05/wie-schnell-man-speicher-falsch-kopieren-kann/
for (int loopY = 0; loopY < m_currentHeight; loopY++)
{
IntPtr rowStartTexture = new IntPtr(textureBufferPointerNative + (dataBox.RowPitch / 4) * loopY);
IntPtr rowStartSource = new IntPtr(frameBufferPointerNative + (m_currentWidth) * loopY);
CommonTools.CopyMemory(rowStartSource, rowStartTexture, (ulong)dataBox.RowPitch);
}
}
}
finally
{
mediaBufferNative.Unlock();
}
}
finally
{
deviceContext.UnmapSubresource(m_texture, 0);
}
}
}
private Stream DumpAndSaveImage()
{
var stream = new MemoryStream();
var textureSDRCpuCopy = new D3D11.Texture2D(d3dDevice, new D3D11.Texture2DDescription
{
Width = description.CanvasRect.Width,
Height = description.CanvasRect.Height,
MipLevels = 1,
ArraySize = 1,
Format = DXGI.Format.B8G8R8A8_UNorm_SRgb,
Usage = D3D11.ResourceUsage.Staging,
SampleDescription = new DXGI.SampleDescription(1, 0),
BindFlags = D3D11.BindFlags.None,
CpuAccessFlags = D3D11.CpuAccessFlags.Read,
OptionFlags = D3D11.ResourceOptionFlags.None,
});
DataStream rawSdrImageDataStream;
d3dContext.CopyResource(textureSDRImage, textureSDRCpuCopy);
var dataBox = d3dContext.MapSubresource(textureSDRCpuCopy, 0, 0, D3D11.MapMode.Read, D3D11.MapFlags.None, out rawSdrImageDataStream);
var dataRectangle = new DataRectangle
{
DataPointer = rawSdrImageDataStream.DataPointer,
Pitch = dataBox.RowPitch,
};
using (var bitmap = new WIC.Bitmap(wicFactory, description.CanvasRect.Width, description.CanvasRect.Height, WIC.PixelFormat.Format32bppBGRA, dataRectangle))
using (var imageEncoder = new WIC.BmpBitmapEncoder(wicFactory, stream))
using (var encodeInstance = new WIC.BitmapFrameEncode(imageEncoder))
{
encodeInstance.Initialize();
encodeInstance.SetSize(bitmap.Size.Width, bitmap.Size.Height);
var pixelFormat = WIC.PixelFormat.Format24bppBGR;
encodeInstance.SetPixelFormat(ref pixelFormat);
encodeInstance.WriteSource(bitmap);
encodeInstance.Commit();
imageEncoder.Commit();
stream.Flush();
}
d3dContext.UnmapSubresource(textureSDRCpuCopy, 0);
rawSdrImageDataStream.Dispose();
textureSDRCpuCopy.Dispose();
return(stream);
}
/// <summary>
/// Takes a screenshot and returns it as a gdi bitmap.
/// </summary>
public GDI.Bitmap TakeScreenshotGdi(GDI.Size size)
{
//Get and read data from the gpu (create copy helper texture on demand)
if (_copyHelperTextureStaging == null)
{
_copyHelperTextureStaging = CreateStagingTexture(_d3d11Device, size);
}
_d3d11Context.CopyResource(_renderTexture, _copyHelperTextureStaging);
//Prepare target bitmap
var result = new GDI.Bitmap(size.Width, size.Height);
var dataBox = _d3d11Context.MapSubresource(_copyHelperTextureStaging, 0, D3D11.MapMode.Read, D3D11.MapFlags.None);
try
{
//Lock bitmap so it can be accessed for texture loading
System.Drawing.Imaging.BitmapData bitmapData = result.LockBits(
new System.Drawing.Rectangle(0, 0, result.Width, result.Height),
System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
try
{
//Copy bitmap data
memcpy(bitmapData.Scan0, dataBox.DataPointer, new UIntPtr((uint)(size.Width * size.Height * 4)));
}
finally
{
result.UnlockBits(bitmapData);
}
}
finally
{
_d3d11Context.UnmapSubresource(_copyHelperTextureStaging, 0);
}
return(result);
}
// TODO: Code that uses temporary resources (that calls this method) should be changed to use Managers and their interfaces
internal void UnmapSubresource(Resource resourceRef, int subresource)
{
m_deviceContext.UnmapSubresource(resourceRef, subresource);
CheckErrors();
}
/// <summary>
/// Copies to a stream using WIC. The format is converted if necessary.
/// </summary>
/// <param name="context"></param>
/// <param name="texture"></param>
/// <param name="outputFormat"></param>
/// <param name="stream"></param>
public void ToStream(SharpDX.Direct3D11.DeviceContext context, Texture2D texture, ImageFormat outputFormat, Stream stream)
{
if (wicFactory == null)
{
wicFactory = ToDispose(new SharpDX.WIC.ImagingFactory2());
}
DataStream dataStream;
var dataBox = context.MapSubresource(
texture,
0,
0,
MapMode.Read,
SharpDX.Direct3D11.MapFlags.None,
out dataStream);
try
{
var dataRectangle = new DataRectangle
{
DataPointer = dataStream.DataPointer,
Pitch = dataBox.RowPitch
};
var format = PixelFormatFromFormat(texture.Description.Format);
if (format == Guid.Empty)
{
return;
}
using (var bitmap = new SharpDX.WIC.Bitmap(
wicFactory,
texture.Description.Width,
texture.Description.Height,
format,
dataRectangle))
{
stream.Position = 0;
SharpDX.WIC.BitmapEncoder bitmapEncoder = null;
switch (outputFormat)
{
case ImageFormat.Bitmap:
bitmapEncoder = new SharpDX.WIC.BmpBitmapEncoder(wicFactory, stream);
break;
case ImageFormat.Jpeg:
bitmapEncoder = new SharpDX.WIC.JpegBitmapEncoder(wicFactory, stream);
break;
case ImageFormat.Png:
bitmapEncoder = new SharpDX.WIC.PngBitmapEncoder(wicFactory, stream);
break;
default:
return;
}
try
{
using (var bitmapFrameEncode = new SharpDX.WIC.BitmapFrameEncode(bitmapEncoder))
{
bitmapFrameEncode.Initialize();
bitmapFrameEncode.SetSize(bitmap.Size.Width, bitmap.Size.Height);
var pixelFormat = format;
bitmapFrameEncode.SetPixelFormat(ref pixelFormat);
if (pixelFormat != format)
{
// IWICFormatConverter
var converter = new SharpDX.WIC.FormatConverter(wicFactory);
if (converter.CanConvert(format, pixelFormat))
{
converter.Initialize(bitmap, SharpDX.WIC.PixelFormat.Format24bppBGR, SharpDX.WIC.BitmapDitherType.None, null, 0, SharpDX.WIC.BitmapPaletteType.MedianCut);
bitmapFrameEncode.SetPixelFormat(ref pixelFormat);
bitmapFrameEncode.WriteSource(converter);
}
else
{
this.DebugMessage(string.Format("Unable to convert Direct3D texture format {0} to a suitable WIC format", texture.Description.Format.ToString()));
return;
}
}
else
{
bitmapFrameEncode.WriteSource(bitmap);
}
bitmapFrameEncode.Commit();
bitmapEncoder.Commit();
}
}
finally
{
bitmapEncoder.Dispose();
}
}
}
finally
{
context.UnmapSubresource(texture, 0);
}
}
private bool UpdateBuffers(SharpDX.Direct3D11.DeviceContext deviceContext, int positionX, int positionY)
{
// If the position we are rendering this bitmap to has not changed then don't update the vertex buffer since it currently has the correct parameters.
if (PreviousPosX == positionX && PreviousPosY == positionY)
{
return(true);
}
// If it has changed then update the position it is being rendered to.
PreviousPosX = positionX;
PreviousPosY = positionY;
//// Calculate the screen coordinates of the left side of the bitmap.
float left = (-(ScreenWidth / 2)) + (float)positionX; //
// Calculate the screen coordinates of the right side of the bitmap.
float right = left + BitmapWidth;
// Calculate the screen coordinates of the top of the bitmap.
float top = (ScreenHeight / 2) - (float)positionY; //
// Calculate the screen coordinates of the bottom of the bitmap.
float bottom = top - BitmapHeight;
// Create and load the vertex array.
var vertices = new[]
{
new DVertexType() // First triangle.
{ // Top left.
position = new Vector3(left, top, 0),
texture = new Vector2(0, 0)
},
new DVertexType()
{ // Bottom right.
position = new Vector3(right, bottom, 0),
texture = new Vector2(1, 1)
},
new DVertexType()
{ // Bottom left.
position = new Vector3(left, bottom, 0),
texture = new Vector2(0, 1)
},
new DVertexType() // Second triangle.
{ // Top left.
position = new Vector3(left, top, 0),
texture = new Vector2(0, 0)
},
new DVertexType()
{ // Top right.
position = new Vector3(right, top, 0),
texture = new Vector2(1, 0)
},
new DVertexType()
{ // Bottom right.
position = new Vector3(right, bottom, 0),
texture = new Vector2(1, 1)
}
};
DataStream mappedResource;
#region Vertex Buffer
// mappedResource = VertexBuffer.Map(MapMode.WriteDiscard);
// Lock the vertex buffer so it can be written to.
deviceContext.MapSubresource(VertexBuffer, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out mappedResource);
// Copy the data into the vertex buffer.
mappedResource.WriteRange <DVertexType>(vertices);
// Unlock the vertex buffer.
deviceContext.UnmapSubresource(VertexBuffer, 0);
#endregion
vertices = null;
return(true);
}
