Windows GetDIBits ne renvoie pas les valeurs attendues

Fonction GetDIBits référence , section remarques:

Le bitmap identifié par le paramètre hbmp ne doit pas être sélectionné dans un contexte d'appareil lorsque l'application appelle cette fonction.

Désélectionnez le bitmap avant d'appeler GetBIBits.

HBITMAP oldBitmap = SelectObject(captureDC, captureBitmap);
...
// Deselect captureBitmap by selecting oldBitmap.
SelectObject(captureDC, oldBitmap);

N'oubliez pas d'ajouter du code de nettoyage (restaurer le bitmap, détruire le bitmap, détruire ou libérer contextes de l'appareil).

BitBlt effectue la copie proprement dite. Les fonctions du presse-papiers doivent être appelées après BitBlt

Notez également, dans les paramètres multi-moniteurs, SM_CXSCREEN / Y ... donne la taille du moniteur principal. Utilisez SM_XVIRTUALSCREEN / XV ... pour tout l'écran. SM_XVIRTUALSCREEN / Y donnera la coordonnée X / Y (elle est généralement zéro)

Assurez-vous de libérer toutes les poignées et de supprimer les objets utilisés lorsque vous avez terminé. En fait, il n'est pas nécessaire de déclarer targetDC etc. comme membres de la classe.

Si l'application n'est pas consciente de DPI, le bitmap peut paraître plus petit en fonction des paramètres DPI. Appelez SetProcessDPIAware () au début du programme pour une solution rapide ou définissez le manifeste.

Comme indiqué dans le commentaire, avec SetClipboardData (CF_BITMAP, captureBitmap); le système prend en charge captureBitmap . Évitez d'appeler cette fonction ou de faire une copie du bitmap à passer dans le presse-papiers.

int main()
{
    int screenWidth = GetSystemMetrics(SM_CXVIRTUALSCREEN);
    int screenHeight = GetSystemMetrics(SM_CYVIRTUALSCREEN);
    int screen_x = GetSystemMetrics(SM_XVIRTUALSCREEN);
    int screen_y = GetSystemMetrics(SM_YVIRTUALSCREEN);

    screenWidth = GetSystemMetrics(SM_CXSCREEN);
    screenHeight = GetSystemMetrics(SM_CYSCREEN);
    screen_x = 0;
    screen_y = 0;

    RGBQUAD* pixels = new RGBQUAD[screenWidth * screenHeight];

    DWORD size = screenWidth * screenHeight * 4;

    ZeroMemory(pixels, size);

    HDC targetDC = GetDC(NULL);
    HDC captureDC = CreateCompatibleDC(targetDC);
    HBITMAP captureBitmap = CreateCompatibleBitmap(targetDC, screenWidth, screenHeight);
    HGDIOBJ old = SelectObject(captureDC, captureBitmap);

    if(!BitBlt(captureDC, 0, 0, screenWidth, screenHeight, targetDC,
        screen_x, screen_y, SRCCOPY))
        printf("BitBlt error\n");

    SelectObject(captureDC, old);

    BITMAPINFO bmi = { 0 };
    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth = screenWidth;
    bmi.bmiHeader.biHeight = -screenHeight;
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = 32;
    bmi.bmiHeader.biCompression = BI_RGB;
    bmi.bmiHeader.biSizeImage = 0;

    if(OpenClipboard(NULL))
    {
        EmptyClipboard();
        SetClipboardData(CF_BITMAP, 
                    CopyImage(captureBitmap, IMAGE_BITMAP, 0, 0, LR_DEFAULTSIZE));
        CloseClipboard();
    }

    if(!GetDIBits(targetDC,
        captureBitmap,
        0,
        screenHeight,
        pixels,
        &bmi,
        DIB_RGB_COLORS
    ))
        printf("%s: GetDIBits failed\n", __FUNCTION__);

    BITMAPFILEHEADER filehdr = { 'MB', 54 + size, 0, 0, 54 };
    std::ofstream f("test.bmp", std::ios::binary);
    f.write((char*)&filehdr, sizeof(filehdr));
    f.write((char*)&bmi, sizeof(bmi));
    f.write((char*)pixels, size);

    //cleanup:      
    SelectObject(captureDC, old);
    DeleteObject(captureBitmap);
    DeleteDC(captureDC);
    ReleaseDC(0, targetDC);
}

Bogue supplémentaire:

    bfh.bfSize =
            2
            + sizeof(BITMAPFILEHEADER)
            + sizeof(BITMAPINFOHEADER)
            + ((screenWidth*3 + 3) & ~3) * screenHeight;

Je pense que cela devrait être

    // Important: each row has to be padded to multiple of DWORD.
    // Valid only for 24 bits per pixel bitmaps.
    // Remark: 32 bits per pixel have rows always aligned (padding==0)
    int padding = 3 - (screenWidth*3 + 3)%4;
    // or
    // int padding = 3 - ((screenWidth*3 + 3) & 3);
    for (int y = 0; y < screenHeight; y++)
    {
        for (int x = 0; x < screenWidth; x++)
        {
            unsigned char r = pixels[x + y*screenWidth].rgbRed;
            unsigned char g = pixels[x + y*screenWidth].rgbGreen;
            unsigned char b = pixels[x + y*screenWidth].rgbBlue;
            fwrite(&b, 1, 1, file);
            fwrite(&g, 1, 1, file);
            fwrite(&r, 1, 1, file);
        }
        // Important: each row has to be padded to multiple of DWORD.
        fwrite("\0\0\0\0", 1, padding, file);
    }

Mais les lignes nécessitent un remplissage multiplié par 4 octets: p >

    for (int y = 0; y < screenHeight; y++)
    {
        for (int x = 0; x < screenWidth; x++)
        {
            unsigned char r = pixels[x + y*screenWidth].rgbRed;
            unsigned char g = pixels[x + y*screenWidth].rgbGreen;
            unsigned char b = pixels[x + y*screenWidth].rgbBlue;
            fwrite(&b, 1, 1, file);
            fwrite(&g, 1, 1, file);
            fwrite(&r, 1, 1, file);
        }
    }

Ajuster la taille du fichier (valable pour 24 bits par pixel):

    for (int y = 0; y < screenHeight; y++)
    {
        for (int x = 0; x < screenWidth; x++)
        {
            unsigned char r = pixels[x + y].rgbRed;
            unsigned char g = pixels[x + y].rgbGreen;
            unsigned char b = pixels[x + y].rgbBlue;
            fwrite(&b, 1, 1, file);
            fwrite(&g, 1, 1, file);
            fwrite(&r, 1, 1, file);
        }
    }