ansaurus

Question

Answer 1

+2 A:

Your P/Invoke declarations are impeccable. However, there's something very odd about the WAVEHDR dump you posted. It is missing the lpData field. If you insert that, all the numbers line up properly (i.e. lpData = 0x19904c00, dwBufferLength = 0x0000fa00, etc).

Not sure how this came about, but it somehow is using the wrong WAVEHDR declaration. WinMM.WinMM ought to be a hint.

Hans Passant 2010-04-15 11:51:11

It's not missing it, but it is at the end with the other IntPtr objects. I found that beeing very odd but am not sure if I can tell the memory position of a field by it's position in the local view of VS.net.

Daniel Baulig 2010-04-15 13:07:37

Yes, very odd. Debugger bug? Do you actually get garbage when you read the dwBufferLength field?

Hans Passant 2010-04-15 13:28:59

Yes it did. I changed some stuff and moved the byte[] buffer and the GCHandle bufferPin variables to a class-wide scope, because I was afraid either (or both) might be destroyed at some point by the garbage collector and thus the API functions would scew up. Since I changed that wavehdr.dwBufferLength is not an arbitary large number anymore, but 0. While it still does not work I am sure this is an improvement.

Daniel Baulig 2010-04-15 13:38:31

Answer 2

+1 A:

PInvoke.Net is THE place to go for finding PInvoke declarations. This page describes the waveInAddBuffer method and its C# equivalent, as well as links to WAVEHDR.

I had a look at various methods that you use but could not find anything helpful in your case. A difference with PInvoke.net's version and yours is that PInvoke uses the CharSet propery of StructLayout, but I guess it is not relevant.

A good book on the interoperability subject is: NET-and-COM

Timores 2010-04-15 12:12:21

Thank you for the links, but sadly, as you already said, they did not help me in this issue. I tried toying around with the CharSet property without any success.

Daniel Baulig 2010-04-15 13:14:57

Answer 3

A:

Ok, I figured it out. All my code was basicly correct. However, I screwed up with the WAVEHDR structure. The waveIn* functions not only expect a reference to an WAVEHDR structure but also expect this structure to sustain until waveInHeaderUnprepare is called upon it. So the WAVEHDR structure will need to be created in an global or at least big enough context to sustain untl waveInHeaderUnprepare is called on it and propably needs to be pinned aswell using a GCHandle, so that it will not change it's position in memory (which afaik is not guaranteed in managed code). Here sis my updated and cleaned up code:

    private WinMM.WinMM.AudioRecordingDelegate waveIn;
    private IntPtr handle;
    private WinMM.WinMM.WAVEHDR header;
    private GCHandle headerPin;
    private GCHandle bufferPin;
    private byte[] buffer;
    private uint bufferLength;

    private void setupBuffer()
    {
        header.lpData = bufferPin.AddrOfPinnedObject();
        header.dwBufferLength = bufferLength;
        header.dwFlags = 0;
        header.dwBytesRecorded = 0;
        header.dwLoops = 0;
        header.dwUser = IntPtr.Zero;
        header.lpNext = IntPtr.Zero;
        header.reserved = IntPtr.Zero;

        int i = WinMM.WinMM.waveInPrepareHeader(handle, ref header, Convert.ToUInt32(Marshal.SizeOf(header)));
        if (i != WinMM.WinMM.MMSYSERR_NOERROR)
        {
            this.Text = "Error: waveInPrepare " + i.ToString();
            return;
        }
        i = WinMM.WinMM.waveInAddBuffer(handle, ref header, Convert.ToUInt32(Marshal.SizeOf(header)));
        if (i != WinMM.WinMM.MMSYSERR_NOERROR)
        {
            this.Text = "Error: waveInAddrBuffer";
            return;
        }
    }

    private void setupWaveIn()
    {
        handle = new IntPtr();
        WinMM.WinMM.WAVEFORMAT format;
        format.wFormatTag = WinMM.WinMM.WAVE_FORMAT_PCM;
        format.nChannels = 1;
        format.nSamplesPerSec = 8000;
        format.wBitsPerSample = 8;
        format.nBlockAlign = Convert.ToUInt16(format.nChannels * format.wBitsPerSample);
        format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
        bufferLength = format.nAvgBytesPerSec / 800;
        headerPin = GCHandle.Alloc(header, GCHandleType.Pinned);
        buffer = new byte[bufferLength];
        bufferPin = GCHandle.Alloc(buffer, GCHandleType.Pinned);
        format.cbSize = 0;

        int i = WinMM.WinMM.waveInOpen(out handle, WinMM.WinMM.WAVE_MAPPER, ref format, Marshal.GetFunctionPointerForDelegate(waveIn), IntPtr.Zero, WinMM.WinMM.CALLBACK_FUNCTION);
        if (i != WinMM.WinMM.MMSYSERR_NOERROR) 
        {
            this.Text = "Error: waveInOpen";
            return;
        }

        setupBuffer();

        WinMM.WinMM.waveInStart(handle);
    }

    private void callbackWaveIn(IntPtr deviceHandle, uint message, IntPtr instance, ref WinMM.WinMM.WAVEHDR wavehdr, IntPtr reserved2)
    {
        if (message == WinMM.WinMM.WIM_DATA)
            if (this.InvokeRequired)
                this.Invoke(waveIn, deviceHandle, message, instance, wavehdr, reserved2);
            else
            {
                if (wavehdr.dwBytesRecorded > 0)
                {
                    foreach (byte buf in buffer)
                    {
                        // do something cool with your byte stream
                    }
                }

                int i = WinMM.WinMM.waveInUnprepareHeader(deviceHandle, ref header, Convert.ToUInt32(Marshal.SizeOf(wavehdr)));
                if (i != WinMM.WinMM.MMSYSERR_NOERROR)
                {
                    this.Text = "Error: waveInUnprepareHeader " + i;
                }
                setupBuffer();
            }
    }

Thank you for your help. I hope someone can use the code I was able to come up with.

Daniel Baulig 2010-04-16 19:20:33

ansaurus

tags:

views:

answers:

Marshalling to a native library in C#

related questions