Question

I’m working on an app that plays audio continuously using the waveOut... API from winmm.dll. The app uses “leapfrog” buffers, which are basically a bunch of arrays of samples that you dump into the audio queue. Windows plays them seamlessly in sequence, and as each buffer completes Windows calls a callback function. Inside this function, I load the next set of samples into the buffer, process them however, and then dump the buffer back into the audio queue. In this way, the audio plays indefinitely.

For animation purposes, I’m trying to incorporate waveOutGetPosition into the application (since the “buffer done” callbacks are irregular enough to cause jerky animation). waveOutGetPosition returns the current position of playback, so it’s hyper-precise.

The problem is that in my application, making calls to waveOutGetPosition eventually causes the application to lock up – the sound stops and the call never returns. I’ve boiled things down to a simple app that demonstrates the problem. You can run the app here:

http://www.musigenesis.com/SO/waveOut%20demo.exe

If you just hear a tiny bit of piano over and over, it’s working. It’s just meant to demonstrate the problem. The source code for this project is here (all the meat is in LeapFrogPlayer.cs):

http://www.musigenesis.com/SO/WaveOutDemo.zip

The first button runs the app in leapfrog mode without making the calls to waveOutGetPosition. If you click this, the app will play forever without breaking (the X button will close it and shut it off). The second button starts the leapfrogger and also starts a forms timer that calls the waveOutGetPosition and displays the current position. Click this and the app will run for a short while and then lock up. On my laptop, it usually locks up in 15-30 seconds; at most it’s taken a minute.

I have no idea how to fix this, so any help or suggestions would be most welcome. I’ve found very few posts on this issue, but it seems that there is a potential deadlock, either from multiple calls to waveOutGetPosition or from calls to that and waveOutWrite that occur at the same time. It’s possible that I’m calling this too frequently for the system to handle.

Edit: forgot to mention, I’m running this on Windows Vista. This might not happen at all on other OSes.

Edit 2: I’ve found little about this problem online, except for these (unanswered) posts:

http://social.msdn.microsoft.com/Forums/en-US/windowsgeneraldevelopmentissues/thread/c6a1e80e-4a18-47e7-af11-56a89f638ad7

Edit 3: Well, I’m now able to reproduce this problem at will. If I call waveOutGetPosition immediately after waveOutWrite (in the following line of code) the application hangs every time. It also hangs in an especially bad way – it seems to lock up my whole OS for awhile, not just the app itself. So it appears that waveOutGetPosition deadlocks if it occurs at nearly the same time as waveOutWrite, not just literally at the same time, which might explain why the locks aren’t working for me. Yeesh.

Answer 1

The solution to this was very simple (thanks to Larry Osterman): replace the callback with a WndProc.

The waveOutOpen method can take either a delegate (for callback) or a window handle. I was using the delegate approach, which is apparently inherently prone to deadlocking (makes sense, especially in managed code). I was able to simply have my player class inherit from Control and override the WndProc method, and do the same stuff in this method that I was doing in the callback. Now I can call waveOutGetPosition forever and it never locks up.