Managed byte[] to unmanaged byte array using ATL/COM

Question

I want to pass some image data from C# code to unmanaged C++ using ATL/COM

From C# code side i do something like this:

void SendFrame([In, MarshalAs(UnmanagedType.SafeArray, SafeArraySubType=VarEnum.VT_UI1)] ref byte[] frameData);

But I'm not sure how should I handle this function in my C++ code.

For now I have something like this:

_ATL_FUNC_INFO OnSendFrameDef = { CC_STDCALL, VT_EMPTY, 1, { VT_SAFEARRAY | VT_UI1 } };

void __stdcall OnSendFrame(SAFEARRAY* ppData)
{
   BYTE* pData;
   SafeArrayAccessData(ppData, (void **) &pData);

   // Doing some stuff with my pData

   SafeArrayUnaccessData(ppData);
}

Can anyone give me some suggestions how I can make this thing work?

Thanks.

You need to remove the *ref* keyword so you don't pass a SAFEARRAY**, rest should be good. A plain byte[] and an extra argument to pass the array size would work too and saves overhead. — Hans Passant, Nov 08 '12 at 18:41

score 2 · Answer 1 · answered Nov 08 '12 at 16:52

2

Since the SAFEARRAY is already marshaled to your unmanaged code, and you're using ATL, you can use the CComSafeArray class, as it handles all the cleanup when working with SAFEARRAY instances:

_ATL_FUNC_INFO OnSendFrameDef = { CC_STDCALL, VT_EMPTY, 1, 
    { VT_SAFEARRAY | VT_UI1 } };

void __stdcall OnSendFrame(SAFEARRAY* ppData)
{
    // Wrap in a CComSafeArray.
    // On the stack means all calls to cleanup
    // will be cleaned up when the stack
    // is exited.
    CComSafeArray<byte> array;
    array.Attach(ppData);

    // Work with the elements, get the first one.
    byte b = array.GetAt(0);

    // And so on.  The destructor for CComSafeArray
    // will be called here and cleaned up.
}

answered Nov 08 '12 at 16:52

casperOne

73,706
19
184
253

Thanks casperOne, but I'm still doing something wrong, I'm getting message box with "Assertion failed" in "atlcom.h" file (line 4722). Looks like "DispCallFunc" function returns with "E_INVALIDARG" Maybe my "_ATL_FUNC_INFO" is wrong? My .tlh content looks like this~: struct __declspec(uuid("401d2950-7c0e-3ac7-9beb-85ea798feb2d")) ITestStreamEvents : IDispatch { HRESULT OnSendFrame (SAFEARRAY * frameData ); }; – Gediminas Nov 09 '12 at 08:19
@Gediminas you need to update the main question with this info; code in comments doesn't work very well. – casperOne Nov 09 '12 at 11:42

score 2 · Accepted Answer · answered Nov 09 '12 at 11:51

I've managed to achieve my goal! For those who are interested:

My event handler descriptor looks like this:

_ATL_FUNC_INFO Stream::OnStreamFrameCallbackDef = { CC_STDCALL, VT_EMPTY, 1, { VT_DISPATCH } };

My C++ function:

void __stdcall Stream::OnStreamFrameCallback(IDispatch* pFrame)
{
   // NOTE that this "IStreamFramePtr" is COM's Ptr of my "IStreamFrame"
   MyCOM::IStreamFramePtr pStreamFrame = pFrame;

   // Thanks casperOne♦ for this:
   CComSafeArray<byte> array;
                   array.Attach(pStreamFrame->GetBuffer());

   // Now I can do stuff that I need...
   byte* pBuffer = &array.GetAt(0);
}

My "IStreamFrame" in my .tlh file looks like this:

struct __declspec(uuid("1f6efffc-0ac7-3221-8175-5272a09cea82"))
IStreamFrame : IDispatch
{
    __declspec(property(get=GetWidth))
    long Width;
    __declspec(property(get=GetHeight))
    long Height;
    __declspec(property(get=GetBuffer))
    SAFEARRAY * Buffer;

    long GetWidth ( );
    long GetHeight ( );
    SAFEARRAY * GetBuffer ( );
};

In my C# code I have something like this:

[ComVisible(true)]
[InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIDispatch)]
public interface IStreamFrame
{
    int     Width   { [return: MarshalAs(UnmanagedType.I4)]         get; }
    int     Height  { [return: MarshalAs(UnmanagedType.I4)]         get; }
    byte[]  Buffer  { [return: MarshalAs(UnmanagedType.SafeArray, SafeArraySubType=VarEnum.VT_UI1)]  get; }
};


[ComVisible(false)]
public delegate void StreamFrameCallback(IStreamFrame frame);

[ComVisible(true)]
[InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIDispatch)]
public interface IMyCOMStreamEvents
{
    [DispId(1)]
    void OnStreamFrameCallback([In, MarshalAs(UnmanagedType.IDispatch)] IStreamFrame frame);
}

Things seems to work just fine. But if anyone have any suggestions or noticed that I'm doing something wrong please let me know.

Thanks.

You'd save yourself a lot of trouble if you used an IDL file to describe your interfaces. With midl.exe, you'd generate the C/C++ interfaces, proxies and stubs and finally a TLB (type library) file which both Visual C++'s `#import` directive and .NET's tlbimp.exe know how to handle without hassle. The TLB files are also generally handled by many other development tools other than Microsoft's, which would make your final result better prepared for future interoperation. In the end, it pays off the time you spend leaning MIDL. — acelent, Nov 10 '12 at 15:16

score 1 · Answer 3 · edited Jun 20 '20 at 09:12

I strongly recommend you to create an IDL file to design your COM interfaces.

Given your example in your answer, a rather minimal IDL file could be like this:

import "oaidl.idl"; 

[object,
 uuid(1f6efffc-0ac7-3221-8175-5272a09cea82),
 dual,
 oleautomation]
interface IStreamFrame : IDispatch {
    [propget]
    HRESULT Width([out, retval] long *pWidth);
    
    [propget]
    HRESULT Height([out, retval] long *pHeight);
    
    [propget]
    HRESULT Buffer([out, retval] SAFEARRAY(byte) *pBuffer);
};

[uuid(1f6efffc-0ac7-3221-8175-5272a09cea83)]
library ContosoStreamFrame {
    importlib("stdole32.tlb");
    
    interface IStreamFrame;
};

You then use midl.exe to generate a .h with C/C++ interfaces, a _i.c for the CLSID and IID constants for C/C++ linking, a dlldata.c for RPC registering, a _p.c with proxy and stub marshalling stuff and a .tlb which is in general terms the parsed representation of the .idl file. This is all better described in the documentation.

EDIT: There seems to be no way to avoid the C/C++ file generation.

EDIT2: I just found a workaround, use nul as the output file for what you don't want. For instance, the following command only generates file.tlb:

midl.exe /header nul /iid nul /proxy nul /dlldata nul file.idl

Note: if your IStreamFrame interface is not meant to be used across processes, add the local attribute to the interface.

In C/C++, you can use the specific files that are generated, or #import the TLB file. In .NET, you can run tlbimp.exe on the TLB file, which generates a .NET assembly.

You can also use tlbexp.exe if your project is .NET centric. However, that'll require you to know the .NET COM annotations and what they mean in terms of IDL, so I'm not sure if there's any gain on saving one extra source-file in another language at the expense of lots of decoration noise in your interface and class definitions. It's perhaps a good option if you want to have full control of the classes and interfaces at the source level and you want to make it as easy as possible (read, optimized for usability and maybe speed) on .NET code.

Finally, you can automate all of this in Visual Studio by creating a project. If you use the IDL approach, add a custom build step that invokes midl.exe and tlbimp.exeand make the dependant projects depend on this project for a correct build order. If you use the .NET approach, add a custom build step that invokes tlbexp.exe and make the dependant C/C++ projects depend on this project.

EDIT: If you don't need the generated C/C++ files from midl.exe, you may add del commands to your custom build step for the specific output files.

EDIT2: Or use the nul workaround described above.

A common approach used when the type library already exists is to use Visual Studio to import it into .NET. But this way, you'll have to remember to regenerate the TLB and import it again if you update your IDL file.

score 0 · Answer 4 · answered Nov 08 '12 at 16:33

0

Have you considered C++/CLI? In your C++/CLI ref class you'd write a member function:

void SendFrame(cli::array<System::Byte> frameData)
{
    pin_ptr<System::Byte> p1 = &frameData[0];
    unsigned char *p2 = (unsigned char *)p1;

    // So now p2 is a raw pointer to the pinned array contents
}

answered Nov 08 '12 at 16:33

Daniel Earwicker

114,894
38
205
284

There's no indication that the code can be changed from a COM server, it, might have to remain a COM server. – casperOne Nov 08 '12 at 16:53
Thanks Daniel, but I can't use CLI – Gediminas Nov 09 '12 at 08:07

Managed byte[] to unmanaged byte array using ATL/COM

4 Answers4