Copying from a packed DIB void pointer

Question

I am working on an API to cache GDI objects, written in C++, in which I am implementing different Create methods that imitate the win32 API. One such method is CreateDIBPatternBrushPt(), which takes in a VOID* to a packed DIB. The VOID* contains a BITMAPINFO structure followed immediately by an array of bytes defining the pixels of the bitmap. I did some research on packed DIBs. According to the book, Programming Windows, as well as Wikipedia the length is equal to the product of the row length and biHeight (a member of BITMAPINFOHEADER), where:

RowLength = 4 * ((bmi.bcWidth * bmi.bcBitCount + 31) / 32) ;

So, currently my thought is to do something like this:

//copy BIMAPINFO to access width and height
//lpPackedDIB is the VOID* parameter of CreateDIBPatternBrushPt()
BITMAPINFO tmpBitmapInfo;
std::memcpy(&tmpBitmapInfo, lpPackedDIB, sizeof(BITMAPINFO));

//copy entire packed DIB
int rowLength = 4 * ((tmpBitmapInfo.bmiHeader.biWidth * tmpBitmapInfo.bmiHeader.biBitCount + 31) / 32);
std::memcpy(m_pPackedDIB, lpPackedDIB, sizeof(BITMAPINFO) + rowLength * std::abs(bitmapInfo.bmiHeader.biHeight));

Does this seem like a valid way to do this? I would also like to know where lpPackedDIB would come from for people who use CreateDIBPatternBrushPt(), so that I can properly test this logic.

EDIT:

References: https://msdn.microsoft.com/en-us/library/windows/desktop/dd183493(v=vs.85).aspx https://en.wikipedia.org/wiki/BMP_file_format#File_structure https://www-user.tu-chemnitz.de/~heha/petzold/ch15b.htm (particularly "The DIB Pixel Bits" section)

Answer 1

This answer was posted before, but taken down for some reason. It doesn't directly address the question, but it gives good insight to the problem I was facing. Credit to user: Barmak Shemirani.

You can simply use CreatePatternBrush to get HBRUSH from HBITAMP

Or use CreateDIBPatternBrushPt. However, note that packed dib is only 14 bytes smaller, since it doesn't need BITMAPFILEHEADER. This makes it useful for very small brushes. For example a 2x1 green/black brush:

typedef struct
{
    BITMAPINFOHEADER header;
    unsigned char bits[2 * 1 * 4];
} DIBSTRUCT;

const DIBSTRUCT dib =
{ 
    { sizeof(BITMAPINFOHEADER), 2, 1, 1, 32, BI_RGB, 0, 0, 0, 0, 0 },
    { 0,0xff,0,0, 0,0,0,0 }
};

HBRUSH hbrush = CreateDIBPatternBrushPt(&dib, DIB_RGB_COLORS);

You can make the brush from bitmap file as well. Allocate the dib, add room for BITMAPINFOHEADER and color table. Then copy BITMAPINFOHEADER, followed by color table (if any), followed by pixels. Example:

HBRUSH getbrush(HBITMAP hbitmap)
{
    BITMAP bm;
    GetObject(hbitmap, sizeof(bm), &bm);

    int colorCount = 0;
    if (bm.bmBitsPixel == 1) colorCount = 2;
    if (bm.bmBitsPixel == 4) colorCount = 16;
    if (bm.bmBitsPixel == 8) colorCount = 256;

    RGBQUAD rgb[256];
    if (colorCount)
    {
        HDC memdc = CreateCompatibleDC(NULL);
        HGDIOBJ oldbitmap = SelectObject(memdc, hbitmap);
        GetDIBColorTable(memdc, 0, colorCount, rgb);
        SelectObject(memdc, oldbitmap);
        DeleteDC(memdc);
    }

    BITMAPINFOHEADER bminfo = { sizeof(BITMAPINFOHEADER), 
    bm.bmWidth, bm.bmHeight, 1, bm.bmBitsPixel, BI_RGB, 0, 0, 0, 0, 0 };
    DWORD size = ((bm.bmWidth * bm.bmBitsPixel + 31) / 32) * 4 * bm.bmHeight;
    char *dib = new char[sizeof(BITMAPINFOHEADER) + colorCount * 4 + size];
    memcpy(dib, &bminfo, sizeof(BITMAPINFOHEADER));
    memcpy(dib + sizeof(BITMAPINFOHEADER), rgb, colorCount * 4);
    memcpy(dib + sizeof(BITMAPINFOHEADER) + colorCount * 4, bm.bmBits, size);
    HBRUSH hbrush = CreateDIBPatternBrushPt(dib, DIB_RGB_COLORS);

    //clearnup
    DeleteObject(hbitmap);
    delete[]dib;

    return hbrush;
}