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

Question

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

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

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

Спасибо.

Answer 1

Это очень похоже на вопрос, заданный несколько лет назад: Здесь . Этот вопрос заключался в том, можно ли использовать способности directx для захвата для повышения производительности.

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

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

Answer 2

Для тех, кто заходит в эту ветку, я пришел к такому решению:

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

Answer 3

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