Fastest method for screen capture

[gurupras]

This is mostly a question.

I currently have the following code that I obtained from a SharpDX example.

        // Create DXGI Factory1
        var factory = new Factory1();
        var adapter = factory.GetAdapter1(0);

        // Create device from Adapter
        var device = new Device(adapter);

        // Get DXGI.Output
        var output = adapter.GetOutput(numOutput);
        var output1 = output.QueryInterface<Output1>();

        // Create Staging texture CPU-accessible
        var textureDesc = new Texture2DDescription
        {
            CpuAccessFlags = CpuAccessFlags.Read,
            BindFlags = BindFlags.None,
            Format = Format.B8G8R8A8_UNorm,
            Width = width,
            Height = height,
            OptionFlags = ResourceOptionFlags.None,
            MipLevels = 1,
            ArraySize = 1,
            SampleDescription = { Count = 1, Quality = 0 },
            Usage = ResourceUsage.Staging
        };

        var screenTexture = new Texture2D(device, textureDesc);

        // Duplicate the output
        var duplicatedOutput = output1.DuplicateOutput(device);

I've been reading a lot of about the back buffer and how it is often better to read the back buffer.
Could you please help me get started on how to read from the back buffer?

Also, is there a good study of the latencies of various methods available somewhere?

[dngs365]

Copy the back buffer to a staging resource what has been created like above.
Back buffer is a DXGI surface and a DXGI resource as well.
https://msdn.microsoft.com/en-us/library/windows/desktop/ff476392(v=vs.85).aspx

This way might not fast however I don't think that making the back buffer to CPU readable is better.
Because CPU access possibilities are related with GPU access performance as well.
Should be the GPU access the back buffer much more frequently than CPU.
Therefore, taking GPU's performance is better than CPU's.

If you want to draw same scene to several back buffers, you can bind at most 8 render targets to the pipeline at the same time in DX11 and later.

[OndrejPetrzilka]

Most essential information is here:
https://msdn.microsoft.com/en-us/library/windows/desktop/bb205132(v=vs.85).aspx

When you're saying 'Fastest method for screen capture', there can be two explanations:

1. Obtain the data from render target as quickly as possible
2. Obtain the data from render target with smallest possible impact on performance

These may seem similar, but when you realize you're on parallel system (CPU - GPU), they are very different.

In first case you just use CopyResource into STAGING texture and MapSubresource, that's it. What happens is when application calls MapSubresource: it flushes GPU command buffer and waits until the copy is completed, by the time MapSubresource call completes, GPU will idle (because command buffer is empty).
You'll get your copy as fast as possible, but GPU will idle (e.g. framerate drops).

In second case you'll do just same, but call MapSubresource with MapFlags.DoNotWait. The MapSubresource can fail (returning empty box), but it won't stall GPU. When it fails, you just call it again some time later (e.g. next frame). This way, you'll get data a little later, but won't stall the GPU.

In case you want to do this continuously (e.g. capturing output every single frame). you'll need several STAGING textures and you'll be cycling them. You can reuse the texture for next capture after you successfully read the data from it. Typical number of such textures will be 1-4.

Some GPU vendors provide specific API for high-performance screen capture (e.g. game streaming) , for example:
https://developer.nvidia.com/capture-sdk