Возможно ли считать 2000 пикселей с экрана, очень быстро?

#include <windows.h>
 
#define MyGetPixel(bytes,x,y,width,height,colorbits) \
    ((COLORREF)((BYTE)(bytes [(colorbits) * (((height)-(y)) * (width) + (x)) + 2]) | \
               ((BYTE)(bytes [(colorbits) * (((height)-(y)) * (width) + (x)) + 1]) << 8) | \
               ((BYTE)(bytes [(colorbits) * (((height)-(y)) * (width) + (x))]) << 16)))
 
static SIZE screen_size;
static HDC hImageDC;
static HBITMAP hImageBitmap, hImageOldBitmap;
 
DWORD WINAPI Thread (LPVOID hWnd)
{
    HDC hDisplayDC = CreateDC ("DISPLAY", NULL, NULL, NULL);
    if (hDisplayDC)
    {
         screen_size.cx = GetDeviceCaps (hDisplayDC, HORZRES);
         screen_size.cy = GetDeviceCaps (hDisplayDC, VERTRES);
         
         if (hImageDC)
         {
              SelectObject (hImageDC, hImageOldBitmap);
              DeleteObject (hImageBitmap);
              DeleteDC (hImageDC);
         }
         
         HDC hDC = GetDC ((HWND) hWnd);
         hImageDC = CreateCompatibleDC (hDC);
         hImageBitmap = CreateCompatibleBitmap (hDC, screen_size.cx, screen_size.cy);
         hImageOldBitmap = (HBITMAP) SelectObject (hImageDC, hImageBitmap);
         PatBlt (hImageDC, 0, 0, screen_size.cx, screen_size.cy, WHITENESS);
         
         HDC hMemDC = CreateCompatibleDC (hDC);
         HBITMAP hMemBmp = CreateCompatibleBitmap (hDC, screen_size.cx, screen_size.cy);
         HBITMAP hOldBmp = (HBITMAP) SelectObject (hMemDC, hMemBmp);
         BitBlt (hMemDC, 0, 0, screen_size.cx, screen_size.cy, hDisplayDC, 0, 0, SRCCOPY);
         ReleaseDC ((HWND) hWnd, hDC);
         
         BITMAPINFO bi = {0};
         bi.bmiHeader.biSize = sizeof (bi.bmiHeader);
         GetDIBits (hMemDC, hMemBmp, 0, 0, NULL, &bi, DIB_RGB_COLORS);
         bi.bmiHeader.biCompression = BI_RGB;
         WORD ColorBits = bi.bmiHeader.biBitCount >> 3;
         BYTE *bytes = (BYTE *) GlobalAlloc (GPTR, bi.bmiHeader.biSizeImage * ColorBits);
         GetDIBits (hMemDC, hMemBmp, 0, bi.bmiHeader.biHeight, (LPVOID) bytes, &bi, DIB_RGB_COLORS);
         
         for (int x=0; x<screen_size.cx; x++)
              for (int y=0; y<screen_size.cy; y++)
              {
                   COLORREF pixel = MyGetPixel (bytes, x, y, bi.bmiHeader.biWidth, bi.bmiHeader.biHeight, ColorBits);
                   SetPixel (hImageDC, x, y, pixel);
              }
         SelectObject (hMemDC, hOldBmp);
         DeleteObject (hMemBmp);
         DeleteDC (hMemDC);
         GlobalFree ((HGLOBAL) bytes);
         DeleteDC (hDisplayDC);
         InvalidateRect ((HWND) hWnd, NULL, TRUE);
    }
    return 0;
}
 
LRESULT CALLBACK WindowProcedure (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
         case WM_CREATE:
         {
              CreateWindow ("button", "grab pixels", WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON, 10, 10, 100, 20, hWnd, (HMENU) 1, NULL, NULL);
         }
         break;
         
         case WM_COMMAND:
         {
              if (LOWORD (wParam) == 1)
              {
                   DWORD thID;
                   CreateThread (NULL, 0, Thread, (LPVOID) hWnd, 0, &thID);
              }
         }
         break;
         
         case WM_PAINT:
         {
              PAINTSTRUCT ps;
              HDC hDC = BeginPaint (hWnd, &ps);
              if (hImageDC)
                   BitBlt (hDC, 10, 50, screen_size.cx, screen_size.cy, hImageDC, 0, 0, SRCCOPY);
              EndPaint (hWnd, &ps);
         }
         break;
         
         case WM_DESTROY:
         {
              if (hImageDC)
              {
                   SelectObject (hImageDC, hImageOldBitmap);
                   DeleteObject (hImageBitmap);
                   DeleteDC (hImageDC);
              }
              PostQuitMessage (0);
         }
         break;
    }
    return DefWindowProc (hWnd, msg, wParam, lParam);
}
 
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE, LPSTR, int)
{
    WNDCLASS wc;
    wc.style         = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc   = WindowProcedure;
    wc.hInstance     = hInstance;
    wc.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
    wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
    wc.lpszClassName = "grab_pixel_class";
    wc.lpszMenuName  = NULL;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    
    if (!RegisterClass (&wc))
    {
         MessageBox (NULL, "Window Registration Failed!", "Error!", MB_OK | MB_ICONERROR);
         return 0;
    }
    
    HWND hWnd = CreateWindow (wc.lpszClassName, "___", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, 700, 500, NULL, NULL, hInstance, NULL);
    if (!hWnd)
    {
         MessageBox (NULL, "Window Creation Failed!", "Error!", MB_OK | MB_ICONERROR);
         UnregisterClass (wc.lpszClassName, hInstance);
         return 0;
    }
    
    ShowWindow (hWnd, SW_SHOW);
    UpdateWindow (hWnd);
    
    MSG msg;
    while (GetMessage (&msg, NULL, 0, 0))
    {
         DispatchMessage (&msg);
         TranslateMessage (&msg);
    }
    
    UnregisterClass (wc.lpszClassName, hInstance);
    return (int) msg.wParam;
}

#include "stdafx.h"
#include <Windows.h>
#include <iostream>
#include <math.h>
#include <stdio.h>
using namespace std;
 
/* Globals */
int ScreenX = GetDeviceCaps(GetDC(0), HORZRES);
int ScreenY = GetDeviceCaps(GetDC(0), VERTRES);
BYTE* ScreenData = 0;
 
void ScreenCap()
{
    HDC hScreen = GetDC(0);
    ScreenX = GetDeviceCaps(hScreen, HORZRES);
    ScreenY = GetDeviceCaps(hScreen, VERTRES);
 
    HDC hdcMem = CreateCompatibleDC(hScreen); 
    HBITMAP hBitmap = CreateCompatibleBitmap(hScreen, ScreenX, ScreenY);
    HGDIOBJ hOld = SelectObject(hdcMem, hBitmap);
    BitBlt(hdcMem, 0, 0, ScreenX, ScreenY, hScreen, 0, 0, SRCCOPY);
    SelectObject(hdcMem, hOld);
 
    BITMAPINFOHEADER bmi = { 0 };
    bmi.biSize = sizeof(BITMAPINFOHEADER);
    bmi.biPlanes = 1;
    bmi.biBitCount = 32;
    bmi.biWidth = ScreenX;
    bmi.biHeight = -ScreenY;
    bmi.biCompression = BI_RGB;
    bmi.biSizeImage = 0;// 3 * ScreenX * ScreenY;
 
    if (ScreenData)
        free(ScreenData);
    ScreenData = (BYTE*)malloc(4 * ScreenX * ScreenY);
 
    GetDIBits(hdcMem, hBitmap, 0, ScreenY, ScreenData, (BITMAPINFO*)&bmi, DIB_RGB_COLORS);
 
    ReleaseDC(GetDesktopWindow(), hScreen);
    DeleteDC(hdcMem);
    DeleteObject(hBitmap);
}
 
inline int PosB(int x, int y)
{
    return ScreenData[4 * ((y*ScreenX) + x)];
}
 
inline int PosG(int x, int y)
{
    return ScreenData[4 * ((y*ScreenX) + x) + 1];
}
 
inline int PosR(int x, int y)
{
    return ScreenData[4 * ((y*ScreenX) + x) + 2];
}
 
bool ButtonPress(int Key)
{
    bool button_pressed = false;
 
    while (GetAsyncKeyState(Key))
        button_pressed = true;
 
    return button_pressed;
}
 
int main()
{
    FILE * pFile;
    fopen_s(&pFile, "C:/ Users/Арсэн/Documents/Output.txt", "w");
    int A[100][100] = {0};
    while (true)
    {
        if (ButtonPress(VK_SPACE))
        {
            ScreenCap();
            // Print out current cursor position
            POINT p;
            GetCursorPos(&p);
            printf("X:%d Y:%d \n", p.x, p.y);
        //  SetCursorPos(1280, 720);
            // Print out RGB value at that position
            for (int i = p.x; i < p.x+100; i++)
            {
                for (int j = p.y; j < p.y+25; j++)
                {
                    if (PosR(i, j) == 255 && PosR(i, j) == 255 && PosR(i, j) == 255) A[i - p.x][j - p.y] = 1;
                }
            }
            std::cout << "Bitmap: r: " << PosR(p.x, p.y) << " g: " << PosG(p.x, p.y) << " b: " << PosB(p.x, p.y) << "\n";
            for (int i = 0; i < 100; i++)
            {
                for (int j = 0; j < 25; j++)
                {
                    printf("%d", A[i][j]);
                }
                printf("\n");
            }
            
        }
        else if (ButtonPress(VK_ESCAPE))
        {
            printf("Quit\n");
            break;
        }
    }
    
    system("PAUSE");
    return 0;
}