Get correct cursor image from Windows API

I'm trying to get cursor data (mask and color, if available) as a byte array using GetDIBits(), with the correct size and correct animation frame but it's proving to be unreliable.

Also, I would like to get or be able to simulate the multiple frames available in a cursor, such as what is possible when using DrawIconEx(), passing the cursorStep parameter.

Basically what I'm trying to emulate is part of the behavior of IDXGIOutputDuplication::GetFramePointerShape(), to get a buffer (byte[]) with the contents of the current cursor, just without having to rely on the DirectX library.

So, I want:

1. Get the cursor data as a byte[], even with the mask working (SOLVED).
2. Get the cursor data with the correct size, not a fixed 32x32px cursor.
3. Get the actual animation frame of the cursor.

Just as the DXGI method provides if I'm using OutputDuplication, but in my case, I'm not.

1) Get the cursor mask correctly (solved):

TL;DR: Wrong data interpretation on my part.

I'm calling GetDIBits() once, passing null as the buffer parameter to get the details of the color/mask images and a second time to get the image.

It works all right with the color image but returns a wrong data size and wrong image content for the mask image.

Here's a comparison and the code sample. Files ending with "2" were created by using System.Drawing.Bitmap.FromHBitmap() while the others were obtained from GetDiBits().

For some reason, GetDIBits() returns this data (BitmapInfoHeader) for the mask. Also, only returns 128 bytes (256 if the mask has two frames, such as for the I-Beam/Text cursor), which is way too little for 32x32px or 32x64px masks.

Here's my code so far (it's C#):

WindowDeviceContext = User32.GetWindowDC(IntPtr.Zero);

//The parameter passed in the structs is just to be able to calculate the size of it. 
var cursorInfo = new CursorInfo(false);

if (!User32.GetCursorInfo(out cursorInfo))
    return;

if (cursorInfo.Flags != Native.Constants.CursorShowing)
{
    Gdi32.DeleteObject(cursorInfo.CursorHandle);
    return;
}

var iconHandle = User32.CopyIcon(cursorInfo.CursorHandle);

if (iconHandle == IntPtr.Zero)
{
    User32.DestroyIcon(iconHandle);
    Gdi32.DeleteObject(cursorInfo.CursorHandle);
    return;
}

if (!User32.GetIconInfo(iconHandle, out var iconInfo))
{
    Gdi32.DeleteObject(iconInfo.Color);
    Gdi32.DeleteObject(iconInfo.Mask);

    User32.DestroyIcon(iconHandle);
    Gdi32.DeleteObject(cursorInfo.CursorHandle);
    return;
}

//Color.
var colorHeader = new BitmapInfoHeader(false);

//Gets the color image details.
Gdi32.GetDIBits(WindowDeviceContext, iconInfo.Color, 0, 0, null, ref colorHeader, DibColorModes.RgbColors);

if (colorHeader.Height != 0)
{
    colorHeader.Height *= -1;

    var colorBuffer = new byte[colorHeader.SizeImage];

    Gdi32.GetDIBits(WindowDeviceContext, iconInfo.Color, 0, (uint)(colorHeader.Height * -1), colorBuffer, ref colorHeader, DibColorModes.RgbColors);
    
    //Converts a byte array to image (System.Windows.Media.Imaging.BitmapSource) just for testing.
    var image = ImageUtil.ImageMethods.FromArray(colorBuffer, colorHeader.Width, colorHeader.Height * -1, 4); //4 channels

    using var fileStream = new FileStream(@"Color.png", FileMode.Create);
    var bmpEncoder = new PngBitmapEncoder();
    bmpEncoder.Frames.Add(BitmapFrame.Create(image));
    bmpEncoder.Save(fileStream);

    //Converts the HBitmap to Bitmap, just for testing too.
    var image2 = System.Drawing.Image.FromHbitmap(iconInfo.Color);
    image2.Save(@"Color2.png");
}

//Mask.
var maskHeader = new BitmapInfoHeader(false);

//Gets the mask image details.
Gdi32.GetDIBits(WindowDeviceContext, iconInfo.Mask, 0, 0, null, ref maskHeader, DibColorModes.RgbColors);

if (maskHeader.Height != 0)
{
    maskHeader.Height *= -1;

    var maskBuffer = new byte[maskHeader.SizeImage];

    Gdi32.GetDIBits(WindowDeviceContext, iconInfo.Mask, 0, (uint) maskHeader.Height, maskBuffer, ref maskHeader, DibColorModes.RgbColors);
    
    //Converts a byte array to image (System.Windows.Media.Imaging.BitmapSource) just for testing.
    var image = ImageUtil.ImageMethods.FromArray(maskBuffer.ToList(), maskHeader.Width, maskHeader.Height * -1, 1, 1);
    
    using var fileStream = new FileStream(@"Mask.png", FileMode.Create);
    var bmpEncoder = new PngBitmapEncoder();
    bmpEncoder.Frames.Add(BitmapFrame.Create(image));
    bmpEncoder.Save(fileStream);

    //Converts the HBitmap to Bitmap, just for testing too.
    var image2 = System.Drawing.Image.FromHbitmap(iconInfo.Mask);
    image2.Save(@"Mask2.png");
}

Gdi32.DeleteObject(iconInfo.Color);
Gdi32.DeleteObject(iconInfo.Mask);
User32.DestroyIcon(iconHandle);
Gdi32.DeleteObject(cursorInfo.CursorHandle);

Solved:

With the proper interpretation of the bits per pixel of the mask image, this issue was solved.

public static BitmapSource FromArray(byte[] data, int width, int height, int channels, int bitsPerPixel = 32)
{
    var format = PixelFormats.Default;
    var stride = channels * ((bitsPerPixel * width + 31) / 32);

    //Abridged channel and bits by pixel to format converter.
    if (channels == 1)
    {
        format = PixelFormats.BlackWhite;
        stride = width / 8;
    }
    else if (channels == 3)
        format = PixelFormats.Bgr24; //RGB.
    else if (channels == 4)
        format = PixelFormats.Bgr32; //RGB + alpha.

    var wbm = new WriteableBitmap(width, height, 96, 96, format, null);
    wbm.WritePixels(new Int32Rect(0, 0, width, height), data, stride, 0);

    return wbm;
}

2) Get the correct size of the cursor:

As noted above, I'm only getting cursor images of size 32x32 or 32x64 (for masks).

I've tried to increase the size being passed to GetDIBits(), but the image being returned is always the same size.

Even if the size in Windows 10/11 settings is set to a bigger cursor size.

The IDXGIOutputDuplication::GetFramePointerShape() method returns a correct size, so it looks like it's possible. What does this method do in order to get the correct image size?

3) Get the actual cursor frame being displayed (for animated cursors):

As for the animation frame (steps) of the cursor, I don't see a way of getting multiple frames based on an index the same way that I would be able to draw with DrawIconEx():

//If the cursor rate needs to be precisely captured, I could use this undocumented API:
//https://source.winehq.org/source/dlls/user32/cursoricon.c#2325
//int rate = 0, num = 0;
//var ok1 = User32.GetCursorFrameInfo(cursorInfo.hCursor, IntPtr.Zero, 17, ref rate, ref num);

//CursorStep
var ok = User32.DrawIconEx(CompatibleDeviceContext, frame.CursorX - iconInfo.XHotspot, frame.CursorY - iconInfo.YHotspot, cursorInfo.CursorHandle, 0, 0, CursorStep, IntPtr.Zero, 0x0003);

if (!ok)
{
    CursorStep = 0;
    User32.DrawIconEx(CompatibleDeviceContext, frame.CursorX - iconInfo.XHotspot, frame.CursorY - iconInfo.YHotspot, cursorInfo.CursorHandle, 0, 0, CursorStep, IntPtr.Zero, 0x0003);
}
else
    CursorStep++;

Maybe I could draw the cursor color and masks separately using DrawIconEx() into two bitmaps (using the flags DI_IMAGE and DI_MASK in each call, passing the cursor step), and then getting the pixels using GetDIBits()?

But how to do that?