C# какой самый быстрый способ сделать снимок экрана?

я реализую функцию, которая будет делать снимок экрана несколько раз и выводить грязные прямоугольники между 2 различными снимками, а затем отправить повторно нарисовать экран в окне.

Я могу заставить его работать между 20~30FPS в настоящее время. Это уже приемлемо. Но потом я сделал эталон и измерил его эффективность. Выяснил, что Graphics.CopyFromScreen() занимает до 50% времени обработки. (Да. Даже в худшем случае, это все равно займет больше времени, чем найти все грязные прямоугольники), тогда я использовал родной Реализация API BitBlt() и не получить улучшения.

Я знаю, что в этом случае не может быть никаких практических причин, чтобы сделать это быстрее, чем 30FPS. Мне просто интересно, есть ли быстрый способ сделать снимок экрана?

спасибо.

7
.net c# graphics

3 ответов

Это очень похоже на вопрос, заданный несколько лет назад: здесь. Вопрос был в том ... --3-->захват directx способности могут быть использованы для повышения производительности.

консенсус заключался в том, что он, вероятно, не обеспечит никакого повышения производительности, TightVNC делает это очень быстро, обманывая. Он использует драйвер, который не должен использовать API, который (предположительно) использует .NET.

в какой-то момент я вспоминаю, глядя на исходный код для Camstudio и я считаю, что они используют возможности захвата directx. Я не думаю, что вы можете нажать так много за 30 fps, и большую часть времени даже этого. Я не уверен, что это проблема с крючками, которые camstudio использует, чтобы выяснить, когда что-то изменилось или фактический механизм захвата.

6

для тех, кто пришел к этой теме, я пришел к этому решению:

using SharpDX;
using SharpDX.Direct3D11;
using SharpDX.DXGI;
using System;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Threading.Tasks;

вам понадобится пакет SharpDX и SharpDX.Direct3D11

public class ScreenStateLogger
{
    private byte[] _previousScreen;
    private bool _run, _init;

    public int Size { get; private set; }
    public ScreenStateLogger()
    {

    }

    public void Start()
    {
        _run = true;
        var factory = new Factory1();
        //Get first adapter
        var adapter = factory.GetAdapter1(0);
        //Get device from adapter
        var device = new SharpDX.Direct3D11.Device(adapter);
        //Get front buffer of the adapter
        var output = adapter.GetOutput(0);
        var output1 = output.QueryInterface<Output1>();

        // Width/Height of desktop to capture
        int width = output.Description.DesktopBounds.Right;
        int height = output.Description.DesktopBounds.Bottom;

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

        Task.Factory.StartNew(() =>
        {
            // Duplicate the output
            using (var duplicatedOutput = output1.DuplicateOutput(device))
            {
                while (_run)
                {
                    try
                    {
                        SharpDX.DXGI.Resource screenResource;
                        OutputDuplicateFrameInformation duplicateFrameInformation;

                        // Try to get duplicated frame within given time is ms
                        duplicatedOutput.AcquireNextFrame(5, out duplicateFrameInformation, out screenResource);

                        // copy resource into memory that can be accessed by the CPU
                        using (var screenTexture2D = screenResource.QueryInterface<Texture2D>())
                            device.ImmediateContext.CopyResource(screenTexture2D, screenTexture);

                        // Get the desktop capture texture
                        var mapSource = device.ImmediateContext.MapSubresource(screenTexture, 0, MapMode.Read, SharpDX.Direct3D11.MapFlags.None);

                        // Create Drawing.Bitmap
                        using (var bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb))
                        {
                            var boundsRect = new Rectangle(0, 0, width, height);

                            // Copy pixels from screen capture Texture to GDI bitmap
                            var mapDest = bitmap.LockBits(boundsRect, ImageLockMode.WriteOnly, bitmap.PixelFormat);
                            var sourcePtr = mapSource.DataPointer;
                            var destPtr = mapDest.Scan0;
                            for (int y = 0; y < height; y++)
                            {
                                // Copy a single line 
                                Utilities.CopyMemory(destPtr, sourcePtr, width * 4);

                                // Advance pointers
                                sourcePtr = IntPtr.Add(sourcePtr, mapSource.RowPitch);
                                destPtr = IntPtr.Add(destPtr, mapDest.Stride);
                            }

                            // Release source and dest locks
                            bitmap.UnlockBits(mapDest);
                            device.ImmediateContext.UnmapSubresource(screenTexture, 0);

                            using (var ms = new MemoryStream())
                            {
                                bitmap.Save(ms, ImageFormat.Bmp);
                                ScreenRefreshed?.Invoke(this, ms.ToArray());
                                _init = true;
                            }
                        }
                        screenResource.Dispose();
                        duplicatedOutput.ReleaseFrame();
                    }
                    catch (SharpDXException e)
                    {
                        if (e.ResultCode.Code != SharpDX.DXGI.ResultCode.WaitTimeout.Result.Code)
                        {
                            Trace.TraceError(e.Message);
                            Trace.TraceError(e.StackTrace);
                        }
                    }
                }
            }
        });
        while (!_init) ;
    }

    public void Stop()
    {
        _run = false;
    }

    public EventHandler<byte[]> ScreenRefreshed;
}

этот код получит как можно быстрее кадры из переднего буфера графического устройства и получит байт[] из создаваемого растрового изображения. Код кажется стабильным в использовании памяти и процессора (GPU и CPU).

использование :

var screenStateLogger = new ScreenStateLogger();
screenStateLogger.ScreenRefreshed += (sender, data) =>
{
    //New frame in data
};
screenStateLogger.Start();
3

для альтернативы CopyFromScreen() Регистрация этой. Обратите внимание, что Graphics.CopyFromScreen() сам вызывает API BitBlt() скопировать с экрана, вы можете проверить исходный код через рефлектор.

0