Any supported sound formats for Java on Windows 7?

Question 1

After figuring out it was a problem with our JNI code doing this:

rc=CoInitialize(NULL);
rc=OleInitialize(NULL);
{
     WNDCLASSEX     wc; 
     // Register the class of our window to host the browser. 'WindowProc' is our message handler
 // and 'ClassName' is the class name. You can choose any class name you want.
 ZeroMemory(&wc, sizeof(WNDCLASSEX));
 wc.cbSize = sizeof(WNDCLASSEX);
 wc.hInstance = hinstance;
 wc.lpfnWndProc = WindowProc;
 wc.lpszClassName = &ClassName[0];
 rc=RegisterClassEx(&wc);
}

It was a problem because we were calling it in the wrong place in dllMain(...). Instead, we moved it into the place where it is only called once, right before it is actually needed to open an embedded browser.

This resolved our problem.

Question 2

I've run into a similar issue before (though not in relation to loading DLLs.) Javasound works underneath by using 1 or more mixers, each with 1 or more lines. Each of those lines has a number of formats that it says it supports, but this doesn't mean it won't spontaneously combust when given that format to play (essentially, there's nothing stopping it from boasting about playing formats it can't.)

When you use AudioSystem.getLine(), it will iterate over all these lines from all these mixers, and essentially return the first one it comes across that says it can handle that format. If that line is a big fat liar, then it won't look for others - it'll just go with it and produce the error that you're seeing.

Now the important thing to remember here is that the order it iterates over these lines is compeltely arbitrary. So anything could cause it to change, including something that seems seemingly irrelevant, such as loading a DLL. I can see one of two possibilities here, the DLL is somehow providing another audio line that's causing the issue, or loading the DLL just causes the arbitrary order to change, and when you do that it comes across the suspect line first for some reason.

The workaround isn't nice, but it's nicer than playing a sound and waiting a bit, you essentially have to test the line to see if it's telling the truth:

SourceDataLine dataline = null;
for (Mixer.Info mixerInfo : AudioSystem.getMixerInfo()) {
    try {
        Mixer mixer = AudioSystem.getMixer(mixerInfo);
        dataline = (SourceDataLine)mixer.getLine(info);
        if(dataline==null) {
            continue; //Doesn't support this format
        }
        dataline.open(audioFormat);
        dataline.start();
    }
    catch (Exception ex) {
        //If we get here it's a buggered line, so loop round again
        continue;
    }
    try {
        dataline.close();
    }
    catch (Exception ex) {
        ex.printStackTrace(); //Shouldn't get here
    }
}


if(dataline==null) {
    //No dataline capable of *really* playing the stream
}
else {
    //We have a non-lying dataline!
}

This way takes a bit longer, but it's essentially a double check - we loop through each data line, and if it says it can play the format, we check if it really can - and only in that case do we then determine if it's safe to use.