Получение изображения экрана без принтскрина

#include "stdafx.h"
#include <windows.h>
#include <ShellAPI.h>
#include <fstream>
#include <time.h>
 
using namespace std;
 
void ErrorMessage(char *str)
{
    ofstream error("fastscreen_error.log");
    const time_t timer = time(NULL);
    char* time = ctime(&timer);
    MessageBox(NULL,L"Program start is failure", L"Error Information",MB_OK|MB_ICONSTOP);
    error << time << "Program start is faliure" << endl;
    error.close();
    exit(1);
}
 
PBITMAPINFO CreateBitmapInfoStruct(HBITMAP hBmp)
{ 
    BITMAP bmp; 
    PBITMAPINFO pbmi; 
    WORD    cClrBits; 
 
    // Retrieve the bitmap color format, width, and height. 
    if (!GetObject(hBmp, sizeof(BITMAP), (LPSTR)&bmp)) 
        ErrorMessage("GetObject"); 
 
    // Convert the color format to a count of bits. 
    cClrBits = (WORD)(bmp.bmPlanes * bmp.bmBitsPixel); 
    if (cClrBits == 1) 
        cClrBits = 1; 
    else if (cClrBits <= 4) 
        cClrBits = 4; 
    else if (cClrBits <= 8) 
        cClrBits = 8; 
    else if (cClrBits <= 16) 
        cClrBits = 16; 
    else if (cClrBits <= 24) 
        cClrBits = 24; 
    else cClrBits = 32; 
 
    // Allocate memory for the BITMAPINFO structure. (This structure 
    // contains a BITMAPINFOHEADER structure and an array of RGBQUAD 
    // data structures.) 
 
     if (cClrBits != 24) 
         pbmi = (PBITMAPINFO) LocalAlloc(LPTR, 
                    sizeof(BITMAPINFOHEADER) + 
                    sizeof(RGBQUAD) * (1<< cClrBits)); 
 
     // There is no RGBQUAD array for the 24-bit-per-pixel format. 
 
     else 
         pbmi = (PBITMAPINFO) LocalAlloc(LPTR, 
                    sizeof(BITMAPINFOHEADER)); 
 
    // Initialize the fields in the BITMAPINFO structure. 
 
    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); 
    pbmi->bmiHeader.biWidth = bmp.bmWidth; 
    pbmi->bmiHeader.biHeight = bmp.bmHeight; 
    pbmi->bmiHeader.biPlanes = bmp.bmPlanes; 
    pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel; 
    if (cClrBits < 24) 
        pbmi->bmiHeader.biClrUsed = (1<<cClrBits); 
 
    // If the bitmap is not compressed, set the BI_RGB flag. 
    pbmi->bmiHeader.biCompression = BI_RGB; 
 
    // Compute the number of bytes in the array of color 
    // indices and store the result in biSizeImage. 
    // For Windows NT, the width must be DWORD aligned unless 
    // the bitmap is RLE compressed. This example shows this. 
    // For Windows 95/98/Me, the width must be WORD aligned unless the 
    // bitmap is RLE compressed.
 
    pbmi->bmiHeader.biSizeImage = ((pbmi->bmiHeader.biWidth * cClrBits +31) & ~31) /8
                                  * pbmi->bmiHeader.biHeight; 
    // Set biClrImportant to 0, indicating that all of the 
    // device colors are important. 
     pbmi->bmiHeader.biClrImportant = 0; 
     return pbmi; 
 } 
 
void CreateBMPFile(LPTSTR pszFile, HBITMAP hBMP, HDC hDC) 
 { 
    PBITMAPINFO pbi;
    HANDLE hf;                 // file handle 
    BITMAPFILEHEADER hdr;       // bitmap file-header 
    PBITMAPINFOHEADER pbih;     // bitmap info-header 
    LPBYTE lpBits;              // memory pointer 
    DWORD dwTotal;              // total count of bytes 
    DWORD cb;                   // incremental count of bytes 
    BYTE *hp;                   // byte pointer 
    DWORD dwTmp; 
 
    pbi = CreateBitmapInfoStruct(hBMP);
    pbih = (PBITMAPINFOHEADER) pbi; 
    lpBits = (LPBYTE) GlobalAlloc(GMEM_FIXED, pbih->biSizeImage);
 
    if (!lpBits) 
         ErrorMessage("GlobalAlloc"); 
 
    // Retrieve the color table (RGBQUAD array) and the bits 
    // (array of palette indices) from the DIB. 
    if (!GetDIBits(hDC, hBMP, 0, (WORD) pbih->biHeight, lpBits, pbi, 
        DIB_RGB_COLORS)) 
    {
        ErrorMessage("GetDIBits"); 
    }
 
    // Create the .BMP file. 
    hf = CreateFile(pszFile, 
                   GENERIC_READ | GENERIC_WRITE, 
                   (DWORD) 0, 
                    NULL, 
                   CREATE_ALWAYS, 
                   FILE_ATTRIBUTE_NORMAL, 
                   (HANDLE) NULL); 
    if (hf == INVALID_HANDLE_VALUE) 
        ErrorMessage("CreateFile"); 
    hdr.bfType = 0x4d42;        // 0x42 = "B" 0x4d = "M" 
    // Compute the size of the entire file. 
    hdr.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) + 
                 pbih->biSize + pbih->biClrUsed 
                 * sizeof(RGBQUAD) + pbih->biSizeImage); 
    hdr.bfReserved1 = 0; 
    hdr.bfReserved2 = 0; 
 
    // Compute the offset to the array of color indices. 
    hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + 
                    pbih->biSize + pbih->biClrUsed 
                    * sizeof (RGBQUAD); 
 
    // Copy the BITMAPFILEHEADER into the .BMP file. 
    if (!WriteFile(hf, (LPVOID) &hdr, sizeof(BITMAPFILEHEADER), 
        (LPDWORD) &dwTmp,  NULL)) 
    {
       ErrorMessage("WriteFile"); 
    }
 
    // Copy the BITMAPINFOHEADER and RGBQUAD array into the file. 
    if (!WriteFile(hf, (LPVOID) pbih, sizeof(BITMAPINFOHEADER) 
                  + pbih->biClrUsed * sizeof (RGBQUAD), 
                  (LPDWORD) &dwTmp, ( NULL)) )
        ErrorMessage("WriteFile"); 
 
    // Copy the array of color indices into the .BMP file. 
    dwTotal = cb = pbih->biSizeImage; 
    hp = lpBits; 
    if (!WriteFile(hf, (LPSTR) hp, (int) cb, (LPDWORD) &dwTmp,NULL)) 
           ErrorMessage("WriteFile"); 
 
    // Close the .BMP file. 
     if (!CloseHandle(hf)) 
           ErrorMessage("CloseHandle"); 
 
    // Free memory. 
    GlobalFree((HGLOBAL)lpBits);
}
 
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst,
                   LPSTR lpCmdLine, int nCmdShow)
{
    HDC hdcScreen, hdcCompatible;
    HBITMAP hbmScreen;
 
    hdcScreen = CreateDC(L"DISPLAY",NULL,NULL,NULL);
    if (!hdcScreen)
        ErrorMessage("CreateDC");
    hdcCompatible = CreateCompatibleDC(hdcScreen);
    if (!hdcCompatible)
        ErrorMessage("CreateCompatibleDC");
 
    hbmScreen = CreateCompatibleBitmap(hdcScreen,
        GetDeviceCaps(hdcScreen, HORZRES),
        GetDeviceCaps(hdcScreen, VERTRES));
    if (!hbmScreen)
        ErrorMessage("CreateCompatibleBitmap");
 
    if (!SelectObject(hdcCompatible,hbmScreen))
        ErrorMessage("SelectObject");
 
    if (!BitBlt(hdcCompatible,0,0,
        GetDeviceCaps(hdcCompatible,HORZRES),
        GetDeviceCaps(hdcCompatible,VERTRES),
        hdcScreen,0,0,SRCCOPY))
        ErrorMessage("BitBlt");
 
    CreateBMPFile(L"fastscreen.bmp",hbmScreen,hdcCompatible);
    CreateBMPFile(L"fastscreen.jpg",hbmScreen,hdcCompatible);
    CreateBMPFile(L"fastscreen.png",hbmScreen,hdcCompatible);
 
    DeleteObject(hbmScreen);
    DeleteDC(hdcScreen);
    DeleteDC(hdcCompatible);
 
    const time_t timer = time(NULL);
 
    ofstream log("fastscreen.log");
    char* time = ctime(&timer);
    log << time << "The program is successfully started" << endl;
    log.close();
    
    return 0;
}

int ScreenX = 0;
int ScreenY = 0;
BYTE* ScreenData = NULL;
bool lsb = false;
 
int LoadScreenBytes()
{
    ScreenX = GetDeviceCaps(GetDC(0), HORZRES);
    ScreenY = GetDeviceCaps(GetDC(0), VERTRES);
 
    if(lsb == true)
        delete[] ScreenData;
    ScreenData = new BYTE[3*ScreenX*ScreenY];
    lsb = true;
 
    HDC hdc = GetDC(NULL), hdcMem = CreateCompatibleDC (hdc);
    HBITMAP hBitmap = CreateCompatibleBitmap(hdc, ScreenX, ScreenY);
    BITMAPINFOHEADER bmi = {0};
    bmi.biSize = sizeof(BITMAPINFOHEADER);
    bmi.biPlanes = 1;
    bmi.biBitCount = 24;
    bmi.biWidth = ScreenX;
    bmi.biHeight = -ScreenY;
    bmi.biCompression = BI_RGB;
    SelectObject(hdcMem, hBitmap);
    BitBlt(hdcMem, 0, 0, ScreenX, ScreenY, hdc, 0, 0, SRCCOPY);
 
    GetDIBits(hdc, hBitmap, 0, ScreenY, ScreenData, (BITMAPINFO*)&bmi, DIB_RGB_COLORS);
    DeleteObject(hBitmap);
    DeleteDC(hdcMem);
    ReleaseDC(NULL, hdc);
    return 0;
}
int GetColor(int x, int y)
{
    if(lsb == false)
        return -1;
 
    int R=ScreenData[3*((y*ScreenX)+x)+2];
    int G=ScreenData[3*((y*ScreenX)+x)+1];
    int B=ScreenData[3*((y*ScreenX)+x)];
 
    return 0;
}