位图为char * win32问题

Question

Im trying to take a screenshot, converting it to a char * and sending it via winsocks.

I use bitmaps because it appears to be the easiest way.

Heres what I got so far:

HDC handle_ScreenDC = GetDC( NULL );
    HDC handle_MemoryDC = CreateCompatibleDC( handle_ScreenDC );
    BITMAP bitmap;
int x = GetDeviceCaps( handle_ScreenDC, HORZRES );
int y = GetDeviceCaps( handle_ScreenDC, VERTRES );

HBITMAP handle_Bitmap = CreateCompatibleBitmap( handle_ScreenDC, x, y );
SelectObject( handle_MemoryDC, handle_Bitmap );

BitBlt( handle_MemoryDC, 0, 0, x, y, handle_ScreenDC, 0, 0, SRCCOPY );

GetObject( handle_Bitmap, sizeof( BITMAP ), &bitmap );

BITMAPFILEHEADER bmfHeader;
BITMAPINFOHEADER bi;

bi.biSize = sizeof( BITMAPINFOHEADER );
bi.biWidth = bitmap.bmWidth;
bi.biHeight = bitmap.bmHeight;
bi.biPlanes = 1;
bi.biBitCount = 32;
bi.biCompression = BI_RGB;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0;
bi.biClrImportant = 0;

DWORD dwBmpSize = ( ( bitmap.bmWidth * bi.biBitCount + 5 ) / 32 ) * 4 * bitmap.bmHeight;

HANDLE hDIB = GlobalAlloc( GHND, dwBmpSize );

char* bufptr = ( char * ) GlobalLock( hDIB );

GetDIBits( handle_ScreenDC, handle_Bitmap, 0, ( UINT ) bitmap.bmHeight, bufptr, ( BITMAPINFO * ) &bi, DIB_RGB_COLORS );

return bufptr;

Now, I get a valid screenshot if I write hBitmap to a file ( which I do not want to do ).

However, when I try to convert the Bitmap to a char *, I always get the following data:

\x1\x1\x1ÿ\x1\x1\x1ÿ\x1\x1\x1ÿ\x1\x1\x1ÿ\x1\x1\x1ÿ\x1\x1\x1ÿ\x1\x1\x1ÿ\

Can anyone help me out?

Thanks in advance.

Answer 1

Not sure why you want to convert it to a string.. You could also do what you're currently doing which is to send over the header of the bitmap first. Followed by the pixels. I don't see the need to convert it to a string.

Here is a very basic example of converting the bitmap to a string (for the sake of answering the question).

class Image
{
private:
    std::vector<std::uint8_t> Pixels;
    std::uint32_t width, height;
    std::uint16_t BitsPerPixel;

public:
    explicit Image(HDC DC, int X, int Y, int Width, int Height);

    std::uint32_t get_width() {return width;}
    std::uint32_t get_height() {return height;}
    std::uint32_t get_bits_per_pixel() {return BitsPerPixel;}
    std::string to_string();
};

Image::Image(HDC DC, int X, int Y, int Width, int Height) : Pixels(), width(Width), height(Height), BitsPerPixel(32)
{
    BITMAP Bmp = {0};
    HBITMAP hBmp = reinterpret_cast<HBITMAP>(GetCurrentObject(DC, OBJ_BITMAP));

    if (GetObject(hBmp, sizeof(BITMAP), &Bmp) == 0)
        throw std::runtime_error("BITMAP DC NOT FOUND.");

    RECT area = {X, Y, X + Width, Y + Height};
    HWND Window = WindowFromDC(DC);
    GetClientRect(Window, &area);

    HDC MemDC = GetDC(nullptr);
    HDC SDC = CreateCompatibleDC(MemDC);
    HBITMAP hSBmp = CreateCompatibleBitmap(MemDC, width, height);
    DeleteObject(SelectObject(SDC, hSBmp));

    BitBlt(SDC, 0, 0, width, height, DC, X, Y, SRCCOPY);
    unsigned int data_size = ((width * BitsPerPixel + 31) / 32) * 4 * height;
    this->Pixels.resize(data_size);

    BITMAPINFO Info = {sizeof(BITMAPINFOHEADER), static_cast<long>(width), static_cast<long>(height), 1, BitsPerPixel, BI_RGB, data_size, 0, 0, 0, 0};

    GetDIBits(SDC, hSBmp, 0, height, &Pixels[0], &Info, DIB_RGB_COLORS);

    DeleteDC(SDC);
    DeleteObject(hSBmp);
    ReleaseDC(nullptr, MemDC);
}

std::string Image::to_string()
{
    auto base64encode = [](std::vector<uint8_t> &in, std::string &out) -> void {
        int i, j;
        char *ptr;
        uint32_t c[4];
        static char indexes[] = {0, 2, 1};
        static const char *Base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

        out.resize(4 * ((in.size() + 2) / 3));
        ptr = &out[0];

        for (i = 0, j = 0; i < in.size();)
        {
            c[0] = i < in.size() ? in[i++] : 0;
            c[1] = i < in.size() ? in[i++] : 0;
            c[2] = i < in.size() ? in[i++] : 0;

            c[3] = (c[0] << 0x10) + (c[1] << 0x08) + c[2];

            ptr[j++] = Base64Chars[(c[3] >> 3 * 6) & 0x3F];
            ptr[j++] = Base64Chars[(c[3] >> 2 * 6) & 0x3F];
            ptr[j++] = Base64Chars[(c[3] >> 1 * 6) & 0x3F];
            ptr[j++] = Base64Chars[(c[3] >> 0 * 6) & 0x3F];
        }

        for (i = 0; i < indexes[in.size() % 3]; ++i)
            ptr[out.size() - 1 - i] = '=';
    };

    std::string result;
    base64encode(Pixels, result);
    return result;
}

int main()
{
    //..
    Image img(screen_dc, 0, 0, screen_width, screen_height);
    std::string res = img.to_string();
    std::size_t size = res.size();

    //..
    socket.write(&screen_width, sizeof(screen_width));
    socket.write(&screen_height, sizeof(screen_height);
    socket.write(&size, sizeof(size));
    socket.write(&res[0], res.size());
}