ArgumentException on IAudioClient Activation and Initialization

[waylaa]

Trying to activate an IAudioClient through this code:

internal AudioClient CreateAudioClient()
{
    _device.Activate(typeof(IAudioClient).GUID, CLSCTX.CLSCTX_ALL, pActivationParams: null, out object client);
    return new AudioClient((IAudioClient)client);
}

results in an ArgumentException afterwards when trying to initialize IAudioClient with this code:

    internal void Initialize(long requestedDuration, WAVEFORMATEX waveFormat)
    {
        client.Initialize
        (
            AUDCLNT_SHAREMODE.AUDCLNT_SHAREMODE_SHARED,
            StreamFlags: 0x80000000 | 0x08000000, // AutoConvertPCM | SrcDefaultQuality.
            hnsBufferDuration: requestedDuration,
            hnsPeriodicity: 0,
            pFormat: waveFormat,
            AudioSessionGuid: null
        );

        _isInitialized = true;
    }

The exception is caused here:

	[global::System.CodeDom.Compiler.GeneratedCode("Microsoft.Windows.CsWin32", "0.3.106+a37a0b4b70")]
	internal static partial class Media_Audio_IAudioClient_Extensions
	{
		/// <inheritdoc cref="winmdroot.Media.Audio.IAudioClient.Initialize(winmdroot.Media.Audio.AUDCLNT_SHAREMODE, uint, long, long, winmdroot.Media.Audio.WAVEFORMATEX*, global::System.Guid*)"/>
		internal static unsafe void Initialize(this winmdroot.Media.Audio.IAudioClient @this, winmdroot.Media.Audio.AUDCLNT_SHAREMODE ShareMode, uint StreamFlags, long hnsBufferDuration, long hnsPeriodicity, in winmdroot.Media.Audio.WAVEFORMATEX pFormat, global::System.Guid? AudioSessionGuid)
		{
			fixed (winmdroot.Media.Audio.WAVEFORMATEX* pFormatLocal = &pFormat)
			{
				global::System.Guid AudioSessionGuidLocal = AudioSessionGuid ?? default(global::System.Guid);
				@this.Initialize(ShareMode, StreamFlags, hnsBufferDuration, hnsPeriodicity, pFormatLocal, AudioSessionGuid.HasValue ? &AudioSessionGuidLocal : null);
			}
		}

[AArnott]

What is in your waveFormat argument? Is cbSize non-zero? If it is, then that struct acts as a header for a larger buffer, and copying it around on the stack as you do with your internal void Initialize(long requestedDuration, WAVEFORMATEX waveFormat) method is faulty.

I can't be sure whether that's what is causing your ArgumentException, but that's my guess. And my prescription would be to always deal with WAVEFORMATEX* so that you're pointing to a valid instance with a buffer after it rather than a stack copy.

[waylaa]

I get a WAVEFORMATEX from here:

internal unsafe WAVEFORMATEX Format
{
    get
    {
        // client is IAudioClient.
        client.GetMixFormat(out WAVEFORMATEX* waveFormatptr);

        WAVEFORMATEX waveFormat = *waveFormatptr;
        Marshal.FreeCoTaskMem((nint)waveFormatptr);

        return waveFormat;
    }
}

The property above returns a WAVEFORMATEX with these values:

Field	Value
cbSize	22
nAvgBytesPerSec	192000
nBlockAlign	4
nChannels	1
nSamplesPerSec	48000
wBitsPerSample	32
wFormatTag	65534

I just pass the given WAVEFORMATEX to AudioClient's Initialize method with no changes whatsoever.

[AArnott]

Given cbSize is 22, then per the struct's documentation there are bytes after the struct that are important. But you're taking the WAVEFORMATEX* and copying only the struct itself onto your stack, and then freeing the non-managed memory that held the original struct and the data you never copied.

A struct like this must not ever be handed around as WAVEFORMATEX. You must only ever hand around WAVEFORMATEX* because of this un-managed size of the struct, meaning it can never exist on the stack.

[waylaa]

So I just change the property to this (or use Unsafe.AsRef instead)?

Edit: Apparently the IAudioClient initializes with the property being like this below. However, is it possible to avoid pointers by using ref or something else instead?

internal unsafe WAVEFORMATEX* Format
{
    get
    {
        // client is IAudioClient.
        client.GetMixFormat(out WAVEFORMATEX* waveFormatptr);
        return waveFormatptr;
    }
}

[AArnott]

Yes, retaining the pointer in the property type would address it. But if you needed to release the unmanaged memory around the struct before, you still need to think about how to do that. And as property getters are not generally expected to allocate and leak unmanaged memory on each invocation (e.g. think about the debugger Locals window calling property getters all the time), I would strongly encourage you to not expose this as a property. Exposing as a method, with the caller's responsibility to release memory after use prominently documented, seems much better.

Alternatively you could define your own fully managed type, and this property getter could copy all the data (including the trailing buffer) into that managed type, release the unmanaged memory, and then return the copy.

[AArnott]

As for using ref, yes your property could return ref WAVEFORMATEX in order to 'hide' the pointer. But IMO that's very risky because it'll be sure easy for the caller to copy the struct onto the stack somewhere, unaware that the pointer behind it is critical. And it wouldn't solve the problem of ultimately needing to change the ref back into a pointer to release the memory too.

[waylaa]

Got it. Thank you for resolving my issue.