PInvoke, variable length arrays [Solved]

Question

5.00/5 (2 votes)

See more:

I'm using some midi API functions that take a MIDIHDR structure.

C#

[StructLayout(LayoutKind.Sequential)]
public struct MIDIHDR
{
    public IntPtr lpData;
    public int dwBufferLength;
    public int dwBytesRecorded;
    public IntPtr dwUser;
    public int dwFlags;
    public IntPtr lpNext;
    public IntPtr reserved;
    public int dwOffset;
    public IntPtr dwReserved;
}

lpData is a pointer to the data. This data is an array of MIDIEVENT structures

[StructLayout(LayoutKind.Sequential)]
public struct MIDIEVENT
{
    public uint dwDeltaTime;
    public uint dwStreamID;
    public uint dwEvent;
}

If I only have one element in the array I can use

int eventSize = Marshal.SizeOf(ev) * events.Length;
IntPtr eventPointer = Marshal.AllocHGlobal(eventSize);
for (int i = 0; i < events.Length; i++)
    Marshal.StructureToPtr(events[i], (IntPtr)((int)eventPointer + (eventSize * i)), false);

but I get Arithmetic operation resulted in an overflow when the second event is reached when playing the events (midiStreamRestart(handle)) if there is more than one element.

So, what's the best way to marshal an array of structures, and why doesn't the above work?

Posted 14-Aug-09 11:29am

DaveyM69

Updated 25-Aug-09 11:19am

0x3c0

v2

Add a Solution

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Luc Pattyn · Accepted Answer · 2009-08-14T11:46:00

Hi Dave,

I have avoided such complexities till now, except for once, a rather simple variable array length.

Here are the results of the Antwerp jury:
In

[1]  int eventSize = Marshal.SizeOf(ev) * events.Length;
[2]  IntPtr eventPointer = Marshal.AllocHGlobal(eventSize);
[3]  for (int i = 0; i < events.Length; i++)
[4]      Marshal.StructureToPtr(events[i], (IntPtr)((int)eventPointer + (eventSize * i)), false);

There is something fishy about eventSize;
[1] is an attempt to compute the overall size; it may be correct, I am not sure, as Sizeof(ev) is the size of one struct and could be rounded up to a multiple of 16 or so, whereas an array would not contain padding bytes between elements.
And [4] treats eventSize as if it were the size of a single element, which it isn't. So that is probably the direct cause of your overflow.
Seems like you want to move the multiplication from [1] to [2].

FWIW: IntPtr will adapt to Win32/Win64 as you probably know; don't let it fool you.

:)