【问题标题】：C# Quickest Way to Get Average Colors of ScreenC#获取屏幕平均颜色的最快方法
【发布时间】：2013-11-02 05:26:29
【问题描述】：

我目前正在使用 C#、arduino 和 Ikea Dioder 为我的电脑显示器创建流光溢彩。目前硬件部分运行完美；但是，我在检测屏幕部分的平均颜色时遇到了问题。

我使用的实现有两个问题：

性能 - 这两种算法都会在屏幕上添加一些明显的卡顿。没什么好看的，但是看视频的时候很烦。

不支持全屏游戏 - 当游戏处于全屏模式时，这两种方法都只会返回白色。

public class DirectxColorProvider : IColorProvider
{

    private static Device d;
    private static Collection<long> colorPoints;

    public DirectxColorProvider()
    {
        PresentParameters present_params = new PresentParameters();
        if (d == null)
        {
            d = new Device(new Direct3D(), 0, DeviceType.Hardware, IntPtr.Zero, CreateFlags.SoftwareVertexProcessing, present_params);
        }
        if (colorPoints == null)
        {
            colorPoints = GetColorPoints();
        }
    }

    public byte[] GetColors()
    {
        var color = new byte[4];

        using (var screen = this.CaptureScreen())
        {
            DataRectangle dr = screen.LockRectangle(LockFlags.None);
            using (var gs = dr.Data)
            {
                color = avcs(gs, colorPoints);
            }
        }

        return color;
    }

    private Surface CaptureScreen()
    {
        Surface s = Surface.CreateOffscreenPlain(d, Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, Format.A8R8G8B8, Pool.Scratch);
        d.GetFrontBufferData(0, s);
        return s;
    }

    private static byte[] avcs(DataStream gs, Collection<long> positions)
    {
        byte[] bu = new byte[4];
        int r = 0;
        int g = 0;
        int b = 0;
        int i = 0;

        foreach (long pos in positions)
        {
            gs.Position = pos;
            gs.Read(bu, 0, 4);
            r += bu[2];
            g += bu[1];
            b += bu[0];
            i++;
        }

        byte[] result = new byte[3];
        result[0] = (byte)(r / i);
        result[1] = (byte)(g / i);
        result[2] = (byte)(b / i);

        return result;
    }

    private Collection<long> GetColorPoints()
    {
        const long offset = 20;
        const long Bpp = 4;

        var box = GetBox();

        var colorPoints = new Collection<long>();
        for (var x = box.X; x < (box.X + box.Length); x += offset)
        {
            for (var y = box.Y; y < (box.Y + box.Height); y += offset)
            {
                long pos = (y * Screen.PrimaryScreen.Bounds.Width + x) * Bpp;
                colorPoints.Add(pos);
            }
        }

        return colorPoints;
    }

    private ScreenBox GetBox()
    {
        var box = new ScreenBox();

        int m = 8;

        box.X = (Screen.PrimaryScreen.Bounds.Width - m) / 3;
        box.Y = (Screen.PrimaryScreen.Bounds.Height - m) / 3;

        box.Length = box.X * 2;
        box.Height = box.Y * 2;

        return box;
    }

    private class ScreenBox
    {
        public long X { get; set; }
        public long Y { get; set; }
        public long Length { get; set; }
        public long Height { get; set; }
    }

}

您可以找到用于directX 实现的文件here。

public class GDIColorProvider : Form, IColorProvider
{
    private static Rectangle box;
    private readonly IColorHelper _colorHelper;

    public GDIColorProvider()
    {
        _colorHelper = new ColorHelper();
        box = _colorHelper.GetCenterBox();
    }

    public byte[] GetColors()
    {
        var colors = new byte[3];

        IntPtr hDesk = GetDesktopWindow();
        IntPtr hSrce = GetDC(IntPtr.Zero);
        IntPtr hDest = CreateCompatibleDC(hSrce);
        IntPtr hBmp = CreateCompatibleBitmap(hSrce, box.Width, box.Height);
        IntPtr hOldBmp = SelectObject(hDest, hBmp);
        bool b = BitBlt(hDest, box.X, box.Y, (box.Width - box.X), (box.Height - box.Y), hSrce, 0, 0, CopyPixelOperation.SourceCopy);
        using(var bmp = Bitmap.FromHbitmap(hBmp))
        {
            colors = _colorHelper.AverageColors(bmp);
        }

        SelectObject(hDest, hOldBmp);
        DeleteObject(hBmp);
        DeleteDC(hDest);
        ReleaseDC(hDesk, hSrce);

        return colors;
    }

    // P/Invoke declarations
    [DllImport("gdi32.dll")]
    static extern bool BitBlt(IntPtr hdcDest, int xDest, int yDest, int
    wDest, int hDest, IntPtr hdcSource, int xSrc, int ySrc, CopyPixelOperation rop);
    [DllImport("user32.dll")]
    static extern bool ReleaseDC(IntPtr hWnd, IntPtr hDc);
    [DllImport("gdi32.dll")]
    static extern IntPtr DeleteDC(IntPtr hDc);
    [DllImport("gdi32.dll")]
    static extern IntPtr DeleteObject(IntPtr hDc);
    [DllImport("gdi32.dll")]
    static extern IntPtr CreateCompatibleBitmap(IntPtr hdc, int nWidth, int nHeight);
    [DllImport("gdi32.dll")]
    static extern IntPtr CreateCompatibleDC(IntPtr hdc);
    [DllImport("gdi32.dll")]
    static extern IntPtr SelectObject(IntPtr hdc, IntPtr bmp);
    [DllImport("user32.dll")]
    private static extern IntPtr GetDesktopWindow();
    [DllImport("user32.dll")]
    private static extern IntPtr GetWindowDC(IntPtr ptr);
    [DllImport("user32.dll")]
    private static extern IntPtr GetDC(IntPtr ptr);
}

您可以找到用于 GDI 实施的文件 Here。

可以在Here找到完整的代码库。

【问题讨论】：

对于口吃，你有没有剖析看看什么需要这么长时间？通过读取每 1000 个像素（仍然是来自 1080p 屏幕的约 2,000 个点的样本；您可以选择更大的值）并且仅每 10 帧执行一次，您可能会看到更快的速度。
GetFrontBufferData 的文档说“该方法在设计上很慢，因此不应在性能关键路径中使用。”。你试过GetBackBuffer吗？
不是得到一个大盒子，而是需要多少时间才能得到许多（例如 200）个带有BitBlt 的小（例如 1 像素）盒子？
实际上，如果您想尝试这种方法，使用GetPixel 可能会更好。
对于游戏或某些视频播放器等全屏应用程序，您将无法轻松获得屏幕颜色。它们直接绘制到屏幕上，并且它们并不总是公开从缓冲区读取的能力。即使他们这样做，您也必须明确编写特定于 DirectX/OpenGL/等的代码。

标签： c# directx screen-scraping gdi+ directx-11

【解决方案1】：

更新答案

截屏速度慢的问题很可能是BitBlt()在源和目标的像素格式不匹配时进行了像素转换。来自docs：

如果源和目标设备上下文的颜色格式不匹配，BitBlt 函数将源颜色格式转换为与目标格式匹配。

这是导致我的代码性能下降的原因，尤其是在更高分辨率时。

默认像素格式似乎是PixelFormat.Format32bppArgb，所以这就是你应该使用的缓冲区：

var screen = new Bitmap(bounds.Width, bounds.Height, PixelFormat.Format32bppArgb);
var gfx = Graphics.FromImage(screen);
gfx.CopyFromScreen(bounds.Location, new Point(0, 0), bounds.Size);

性能下降的下一个来源是Bitmap.GetPixel()，它会进行边界检查。分析每个像素时切勿使用它。而是锁定位图数据并获取指向它的指针：

public unsafe Color GetAverageColor(Bitmap image, int sampleStep = 1) {
    var data = image.LockBits(
        new Rectangle(Point.Empty, Image.Size),
        ImageLockMode.ReadOnly,
        PixelFormat.Format32bppArgb);

    var row = (int*)data.Scan0.ToPointer();
    var (sumR, sumG, sumB) = (0L, 0L, 0L);
    var stride = data.Stride / sizeof(int) * sampleStep;

    for (var y = 0; y < data.Height; y += sampleStep) {
        for (var x = 0; x < data.Width; x += sampleStep) {
            var argb = row[x];
            sumR += (argb & 0x00FF0000) >> 16;
            sumG += (argb & 0x0000FF00) >> 8;
            sumB += argb & 0x000000FF;
        }
        row += stride;
    }

    image.UnlockBits(data);

    var numSamples = data.Width / sampleStep * data.Height / sampleStep;
    var avgR = sumR / numSamples;
    var avgG = sumG / numSamples;
    var avgB = sumB / numSamples;
    return Color.FromArgb((int)avgR, (int)avgG, (int)avgB);
}

根据屏幕大小，这应该会让您的时间远低于 10 毫秒。如果还是太慢可以增加GetAverageColor()的sampleStep参数。

原答案

我最近做了同样的事情，并想出了一些效果出奇的好。

诀窍是创建一个大小为 1x1 像素的附加位图，并在其图形上下文中设置良好的插值模式（双线性或双三次，但不是最近邻）。

然后，您利用插值将捕获的位图绘制到该 1x1 位图中，并检索该像素以获得平均颜色。

我正在以大约 30 fps 的速度执行此操作。当屏幕显示 GPU 渲染（例如，在 Chrome 中启用硬件加速的情况下观看 YouTube 全屏）时，没有可见的卡顿或任何东西。事实上，应用程序的 CPU 利用率远低于 10%。但是，如果我关闭 Chrome 的硬件加速，那么如果你看得足够近，肯定会有一些轻微的卡顿现象。

以下是代码的相关部分：

using var screen = new Bitmap(width, height);
using var screenGfx = Graphics.FromImage(screen);

using var avg = new Bitmap(1, 1);
using var avgGfx = Graphics.FromImage(avg);
avgGfx.InterpolationMode = InterpolationMode.HighQualityBicubic;

while (true) {
    screenGfx.CopyFromScreen(left, top, 0, 0, screen.Size);
    avgGfx.DrawImage(screen, 0, 0, avg.Width, avg.Height);
    var color = avg.GetPixel(0, 0);
    var bright = (int)Math.Round(Math.Clamp(color.GetBrightness() * 100, 1, 100));
    // set color and brightness on your device
    // wait 1000/fps milliseconds
}

请注意，这适用于 GPU 渲染，因为 System.Drawing.Common 现在使用 GDI+。但是，当内容受 DRM 保护时，它不起作用。所以它不适用于 Netflix，例如 :(

我在GitHub 上发布了代码。尽管我因为 Netflix 的 DRM 保护而放弃了该项目，但它可能会对其他人有所帮助。

【讨论】：