Цвет пикселя

    SelectObject(MemoryDC, hBitmap);
    BitBlt(MemoryDC, 0, 0, screen_x, screen_y, ScreenDC , 0, 0, SRCCOPY);

#include <iostream>
#include <ctime>
#include <conio.h>
#include <windows.h>
 
class   CaptureScreen
{
public: CaptureScreen()
        {   // Контексты:
            ScreenDC = GetDC(0);
            MemoryDC = CreateCompatibleDC(ScreenDC);
 
            // Размер экрана:
            screen_x = GetSystemMetrics(SM_CXSCREEN);
            screen_y = GetSystemMetrics(SM_CYSCREEN);
 
            // Заполнение структуры формата                         :
            BMI.bmiHeader.biSize        =  sizeof (BITMAPINFOHEADER);
            BMI.bmiHeader.biWidth       =  screen_x                 ;
            // Отрицательное, чтобы изображение не было перевёрнутым:
            BMI.bmiHeader.biHeight      = -screen_y                 ;
            BMI.bmiHeader.biSizeImage   =  screen_x * screen_y * 3  ;
            BMI.bmiHeader.biCompression =  BI_RGB                   ;
            BMI.bmiHeader.biBitCount    =  24                       ;
            BMI.bmiHeader.biPlanes      =  1                        ;
 
            ScreenshotSize = BMI.bmiHeader.biSizeImage;
 
            hBitmap = CreateDIBSection( ScreenDC, 
                                        &BMI,
                                        DIB_RGB_COLORS,
                                        (void**)&buf, 0, 0);
        }
       ~CaptureScreen()
        {   DeleteDC     (MemoryDC      );
            ReleaseDC    (NULL, ScreenDC);
            DeleteObject (hBitmap       );
        }
 
    HDC     ScreenDC;
    HDC     MemoryDC;
    HBITMAP  hBitmap;
 
    // Размер экрана:
    int     screen_x;
    int     screen_y;
 
    BITMAPINFO   BMI;
 
    // Указатель на блок данных BGR, управляемый HBITMAP
    unsigned char* buf;
    
    // ScreenshotSize - глобальная переменная типа int, 
    // может меняться в ходе выполнения программы:
    int ScreenshotSize;
    
    void show_pixel()
    {   ///--------------------------------------------------------------------|
        /// Используем buf как нам хочется...
        /// после удаляем его хендлер (HBITMAP) для избежания утечки памяти.
        ///--------------------------------------------------------------------:
        get();
    }
 
    void info(int x, int y)
    {   system("cls");
    
        std::cout << "Разрешение экрана:\n";
        std::cout << "    screen_x = " << screen_x << "\n";
        std::cout << "    screen_y = " << screen_y << "\n";
        
        std::cout << "\nПозиция пикселя:\n";
        std::cout << "    x = " << x << "\n";
        std::cout << "    y = " << y << "\n\n";
 
        std::cout << "Цвет пикселя:\n";
        std::cout << "  R: " << int(buf[(y*screen_x + x)*3+2]) << "\n";
        std::cout << "  G: " << int(buf[(y*screen_x + x)*3+1]) << "\n";
        std::cout << "  B: " << int(buf[(y*screen_x + x)*3  ]) << "\n";
    }
    
    void to_file()
    {   get();
        // Если требуется RGB вместо BGR:
        //for(int i = 0; i < ScreenshotSize; i += 3)
        {   //std::swap(buf[i], buf[i + 2]);
        }
        /// TODO
        /// ...
        
        typedef struct                       // BMP file header structure
        {   unsigned int   bfSize;           // Size of file
            unsigned short bfReserved1;      // Reserved 
            unsigned short bfReserved2;      // ...
            unsigned int   bfOffBits;        // Offset to bitmap data
        } BITMAPFILEHEADER;
 
        typedef struct                       // BMP file info structure
        {   unsigned int   biSize;           // Size of info header
            int            biWidth;          // Width of image
            int            biHeight;         // Height of image
            unsigned short biPlanes;         // Number of color planes
            unsigned short biBitCount;       // Number of bits per pixel
            unsigned int   biCompression;    // Type of compression to use
            unsigned int   biSizeImage;      // Size of image data
            int            biXPelsPerMeter;  // X pixels per meter
            int            biYPelsPerMeter;  // Y pixels per meter
            unsigned int   biClrUsed;        // Number of colors used
            unsigned int   biClrImportant;   // Number of important colors
        } BITMAPINFOHEADER;
 
        BITMAPFILEHEADER bfh;
        BITMAPINFOHEADER bih;
 
        // Magic number for file. 
        // It does not fit in the header structure due to alignment requirements, 
        // so put it outside:
        unsigned short bfType = 0x4d42;
        bfh.bfReserved1 = 0;
        bfh.bfReserved2 = 0;
        bfh.bfSize      = 2 + sizeof(BITMAPFILEHEADER)
                            + sizeof(BITMAPINFOHEADER)
                            + screen_x * screen_y * 3;
        bfh.bfOffBits   = 0x36;
 
        bih.biSize = sizeof(BITMAPINFOHEADER);
        bih.biWidth         =  screen_x;
        bih.biHeight        = -screen_y;
        bih.biPlanes        =    1;
        bih.biBitCount      =   24;
        bih.biCompression   =    0;
        bih.biSizeImage     =    0;
        bih.biXPelsPerMeter = 5000;
        bih.biYPelsPerMeter = 5000;
        bih.biClrUsed       =    0;
        bih.biClrImportant  =    0;
 
        FILE *file = fopen("my.bmp", "wb");
        if (!file)
        {   printf("Could not write file\n");
            return;
        }
 
        // Write headers:
        fwrite(&bfType, 1, sizeof(bfType), file);
        fwrite(&bfh   , 1, sizeof(bfh)   , file);
        fwrite(&bih   , 1, sizeof(bih)   , file);
 
        // Write bitmap:
        for (int i = 0; i < ScreenshotSize; i++)
        {   //unsigned char r = *(buf + i);
            fwrite(buf + i, 1, 1, file);
        }
        fclose(file);
    }
    
    void get()///--------------------------------------------------------------:
    {   SelectObject(MemoryDC, hBitmap);
        BitBlt(MemoryDC, 0, 0, screen_x, screen_y, ScreenDC , 0, 0, SRCCOPY);
    }
};
 
int main()
{   setlocale(0, "");
    system("mode 30,18");
    SetConsoleTitle ("Capture Screen");
 
    CaptureScreen task;
                  task.to_file();
                  
    double time  = 0.;
    int    fps   = 0 ;
    int    ownes = 0 ;
    bool   b  = false;
    int    scr =    0;
    
    while(true)
    {   auto t0 = clock();
        task.get();
        time += (clock() - t0 + .0) / CLOCKS_PER_SEC;
        ownes++;
        if(time > 1.)
        {   fps = ownes; ownes = 0; time = 0.; b = true;
            if(scr) scr--;
        }
        
        task.info(100, 400);
        
        std::cout << "\nFPS: ";
        if(b) std::cout << fps         << "\n";
        else  std::cout << "жди секунду ...\n";
        
        if (_kbhit())
        {   char k = _getch();
            if (k == 32) task.to_file();
            scr = 3;
        }
        
        if(scr == 0) std::cout << "\nЧтобы сделать скриншот:\nжми ПРОБЕЛ ...\n";
        else         std::cout << "\nСкриншот готов\nв папке рядом с этим exe!\n";
        
        Sleep(60);
    }
}