CreateDIBSection issue

[Gavin-Williams]

        IntPtr hBitmap = CreateDIBSection(
            dc,
            &bmInfo,
            DIB_USAGE.DIB_RGB_COLORS,
            out bits,
            SafeHandle hSection, // <<< What goes here?
            0);

I've tried

0
null
HANDLE.Null
IntPtr.Zero

Update. Sry, my formatting is not being preserved using 'code'. How do I pass in a null SafeHandle? I think the normal argument there is a zero.

An alternate question is ...

    void* bits;
    IntPtr hBitmap = CreateDIBSection(
        BitmapDeviceContext,
        &bmInfo,
        DIB_USAGE.DIB_RGB_COLORS,
        out &bits, // error - a ref or out value must be an assignable value.
        null,
        0);

Another way of trying it...

    IntPtr bits;
    IntPtr hBitmap = CreateDIBSection(
        BitmapDeviceContext,
        &bmInfo,
        DIB_USAGE.DIB_RGB_COLORS,
        out bits, // error - cannot convert from out nint to out void*
        null,
        0);

How can i make this work?

[Gavin-Williams]

Is there some example code for getting this to work? I'm just never going to work this out. I've asked copilot several times, it keeps suggesting using IntPtr, but that doesn't work. I've looked up how to turn IntPtr into a void pointer pointer. Like this...

    IntPtr dataPtr = new();
    void** voidPtr = (void**)dataPtr.ToPointer();

But then, cannot convert from void** to void*. So I drop one of the stars...

    IntPtr dataPtr = new();
    void* voidPtr = (void*)dataPtr.ToPointer();

Then I get 'cannot implicitly convert type DeleteObjectSafeHandle to nint.

I don't even know what the CreateDIBSection is asking of me. I'm just going around in wobbly circles.

I feel like asking for a void** is the problem here. There is no such thing as a void** AFAIC, it should be byte[] shouldn't it?

[AArnott]

Sry, my formatting is not being preserved using 'code'.

Try using 3 backticks followed by cs. That'll maintain formatting and add keyword highlighting.

Here's an example, but using apostrophes instead of backticks so that github won't hide the syntax I'm trying to show you.

'''cs
Your.CS(code);
'''

I've also edited your original post to fix the first snippet, so you can "edit" it again to see how it actually looks.

[AArnott]

There are two angles to your question, with different sources for answers.

1. How do I use CreateDIBSection? That's a question you should direct at the API docs or whatever win32 forums you can find. This CsWin32 repo is not an appropriate place to get general help on win32 functions.

2. What C# syntax can I use to call CreateDIBSection with the inputs I have in mind?
   This is a perfectly reasonable question to post here, and I believe it's the one you're asking. The rest of my post will answer this question.

At a high level, functions are declared once or twice (as overloads) by CsWin32. The first is typically an extern method and is very low-level. No reference types at all, no exceptions, no marshaling -- just pointers, structs, etc. Many methods get a "friendly overload" as well, which translates some pointers to reference types, may throw exceptions, etc.

When multiple overloads exist, you should have a clear idea in your head of which overload you are trying to call. Otherwise you'll be frustrated by the compiler giving you misleading or unhelpful error messages about what you are passing in and what it is expecting.

In this case, CsWin32 appears to be generating these two overloads:

winmdroot.Graphics.Gdi.HBITMAP CreateDIBSection(winmdroot.Graphics.Gdi.HDC hdc, winmdroot.Graphics.Gdi.BITMAPINFO* pbmi, winmdroot.Graphics.Gdi.DIB_USAGE usage, void** ppvBits, winmdroot.Foundation.HANDLE hSection, uint offset)
DeleteObjectSafeHandle CreateDIBSection(winmdroot.Graphics.Gdi.HDC hdc, winmdroot.Graphics.Gdi.BITMAPINFO* pbmi, winmdroot.Graphics.Gdi.DIB_USAGE usage, out void* ppvBits, SafeHandle hSection, uint offset)

Notice how the first uses structs that you would see in native C code, and the latter uses SafeHandle types.
The latter also reduces a void** ppvBits to an out void* ppvBits parameter. Since in your opening post you use the out modifier for this parameter, I'll assume you're trying to use the 'friendly overload'. Here's a compilable syntax for calling it:

using System.Runtime.InteropServices;
using Windows.Win32;
using Windows.Win32.Graphics.Gdi;

unsafe {
    HDC dc = default;
    BITMAPINFO bmInfo = default;
    void* bits;
    SafeHandle? hSection = null;

    DeleteObjectSafeHandle hBitmap = PInvoke.CreateDIBSection(
        dc,
        &bmInfo,
        DIB_USAGE.DIB_RGB_COLORS,
        out bits,
        hSection,
        0); 
}

In your question you appear to be getting hung up on the hSection parameter, which can be null iff you are calling the SafeHandle overload. If you're calling the extern overload that takes structs, it would look like this:

using Windows.Win32;
using Windows.Win32.Foundation;
using Windows.Win32.Graphics.Gdi;

unsafe {
    HDC dc = default;
    BITMAPINFO bmInfo = default;
    void* bits;
    HANDLE hSection = default;

    HBITMAP hBitmap = PInvoke.CreateDIBSection(
        dc,
        &bmInfo,
        DIB_USAGE.DIB_RGB_COLORS,
        &bits,
        hSection,
        0); 
}

When calling the overload that takes struct handles, the onus is on your program to be sure to avoid native memory leaks by always closing handles, even in exceptional cases. This is something that using SafeHandle in .NET often help you "get right", so the friendly overload is often the preferred way to go, although it adds allocations to the managed heap.

Of course, both of these samples are strictly compilable but would probably misbehave because I'm initializing the inputs only to their default values. To know what values to pass in would be the other category of question, which is better directed at Win32 forums.

Hope this helps!