В настоящее время я работаю над созданием Ambilight для моего компьютерного монитора с C#, Arduino и Ikea Dioder. В настоящее время аппаратная часть работает безупречно; однако у меня проблема с определением среднего цвета части экрана.

У меня есть две проблемы с используемыми реализациями:

1. Производительность. Оба этих алгоритма добавляют заметное торможение на экране. Ничего примечательного, но при просмотре видео раздражает.

2. Нет поддержки полноэкранных игр. Когда игра находится в полноэкранном режиме, оба этих метода просто возвращают белый цвет.

   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 здесь.

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 Здесь.

Полную кодовую базу можно найти здесь.