Merge changes I505c4aea,I2ae0529c

* changes:
  Import SDL release-1.2.15
  Handle SDL windows with BGRA color

1 files changed, 705 insertions, 0 deletions

diff --git a/distrib/sdl-1.2.15/src/audio/windx5/SDL_dx5audio.c b/distrib/sdl-1.2.15/src/audio/windx5/SDL_dx5audio.c
new file mode 100644
index 0000000..c3d42ae
--- /dev/null
+++ b/distrib/sdl-1.2.15/src/audio/windx5/SDL_dx5audio.c
@@ -0,0 +1,705 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2012 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "SDL_dx5audio.h"
+
+/* Define this if you want to use DirectX 6 DirectSoundNotify interface */
+//#define USE_POSITION_NOTIFY
+
+/* DirectX function pointers for audio */
+HRESULT (WINAPI *DSoundCreate)(LPGUID, LPDIRECTSOUND *, LPUNKNOWN);
+
+/* Audio driver functions */
+static int DX5_OpenAudio(_THIS, SDL_AudioSpec *spec);
+static void DX5_ThreadInit(_THIS);
+static void DX5_WaitAudio_BusyWait(_THIS);
+#ifdef USE_POSITION_NOTIFY
+static void DX6_WaitAudio_EventWait(_THIS);
+#endif
+static void DX5_PlayAudio(_THIS);
+static Uint8 *DX5_GetAudioBuf(_THIS);
+static void DX5_WaitDone(_THIS);
+static void DX5_CloseAudio(_THIS);
+
+/* Audio driver bootstrap functions */
+
+static int Audio_Available(void)
+{
+	HINSTANCE DSoundDLL;
+	int dsound_ok;
+
+	/* Version check DSOUND.DLL (Is DirectX okay?) */
+	dsound_ok = 0;
+	DSoundDLL = LoadLibrary(TEXT("DSOUND.DLL"));
+	if ( DSoundDLL != NULL ) {
+		/* We just use basic DirectSound, we're okay */
+		/* Yay! */
+		/* Unfortunately, the sound drivers on NT have
+		   higher latencies than the audio buffers used
+		   by many SDL applications, so there are gaps
+		   in the audio - it sounds terrible.  Punt for now.
+		 */
+		OSVERSIONINFO ver;
+		ver.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
+		GetVersionEx(&ver);
+		switch (ver.dwPlatformId) {
+			case VER_PLATFORM_WIN32_NT:
+				if ( ver.dwMajorVersion > 4 ) {
+					/* Win2K */
+					dsound_ok = 1;
+				} else {
+					/* WinNT */
+					dsound_ok = 0;
+				}
+				break;
+			default:
+				/* Win95 or Win98 */
+				dsound_ok = 1;
+				break;
+		}
+		/* Now check for DirectX 5 or better - otherwise
+		 * we will fail later in DX5_OpenAudio without a chance
+		 * to fall back to the DIB driver. */
+		if (dsound_ok) {
+			/* DirectSoundCaptureCreate was added in DX5 */
+			if (!GetProcAddress(DSoundDLL, TEXT("DirectSoundCaptureCreate")))
+				dsound_ok = 0;
+
+		}
+		/* Clean up.. */
+		FreeLibrary(DSoundDLL);
+	}
+	return(dsound_ok);
+}
+
+/* Functions for loading the DirectX functions dynamically */
+static HINSTANCE DSoundDLL = NULL;
+
+static void DX5_Unload(void)
+{
+	if ( DSoundDLL != NULL ) {
+		FreeLibrary(DSoundDLL);
+		DSoundCreate = NULL;
+		DSoundDLL = NULL;
+	}
+}
+static int DX5_Load(void)
+{
+	int status;
+
+	DX5_Unload();
+	DSoundDLL = LoadLibrary(TEXT("DSOUND.DLL"));
+	if ( DSoundDLL != NULL ) {
+		DSoundCreate = (void *)GetProcAddress(DSoundDLL,
+					TEXT("DirectSoundCreate"));
+	}
+	if ( DSoundDLL && DSoundCreate ) {
+		status = 0;
+	} else {
+		DX5_Unload();
+		status = -1;
+	}
+	return status;
+}
+
+static void Audio_DeleteDevice(SDL_AudioDevice *device)
+{
+	DX5_Unload();
+	SDL_free(device->hidden);
+	SDL_free(device);
+}
+
+static SDL_AudioDevice *Audio_CreateDevice(int devindex)
+{
+	SDL_AudioDevice *this;
+
+	/* Load DirectX */
+	if ( DX5_Load() < 0 ) {
+		return(NULL);
+	}
+
+	/* Initialize all variables that we clean on shutdown */
+	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
+	if ( this ) {
+		SDL_memset(this, 0, (sizeof *this));
+		this->hidden = (struct SDL_PrivateAudioData *)
+				SDL_malloc((sizeof *this->hidden));
+	}
+	if ( (this == NULL) || (this->hidden == NULL) ) {
+		SDL_OutOfMemory();
+		if ( this ) {
+			SDL_free(this);
+		}
+		return(0);
+	}
+	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+	/* Set the function pointers */
+	this->OpenAudio = DX5_OpenAudio;
+	this->ThreadInit = DX5_ThreadInit;
+	this->WaitAudio = DX5_WaitAudio_BusyWait;
+	this->PlayAudio = DX5_PlayAudio;
+	this->GetAudioBuf = DX5_GetAudioBuf;
+	this->WaitDone = DX5_WaitDone;
+	this->CloseAudio = DX5_CloseAudio;
+
+	this->free = Audio_DeleteDevice;
+
+	return this;
+}
+
+AudioBootStrap DSOUND_bootstrap = {
+	"dsound", "Win95/98/2000 DirectSound",
+	Audio_Available, Audio_CreateDevice
+};
+
+static void SetDSerror(const char *function, int code)
+{
+	static const char *error;
+	static char  errbuf[1024];
+
+	errbuf[0] = 0;
+	switch (code) {
+		case E_NOINTERFACE:
+			error = 
+		"Unsupported interface\n-- Is DirectX 5.0 or later installed?";
+			break;
+		case DSERR_ALLOCATED:
+			error = "Audio device in use";
+			break;
+		case DSERR_BADFORMAT:
+			error = "Unsupported audio format";
+			break;
+		case DSERR_BUFFERLOST:
+			error = "Mixing buffer was lost";
+			break;
+		case DSERR_CONTROLUNAVAIL:
+			error = "Control requested is not available";
+			break;
+		case DSERR_INVALIDCALL:
+			error = "Invalid call for the current state";
+			break;
+		case DSERR_INVALIDPARAM:
+			error = "Invalid parameter";
+			break;
+		case DSERR_NODRIVER:
+			error = "No audio device found";
+			break;
+		case DSERR_OUTOFMEMORY:
+			error = "Out of memory";
+			break;
+		case DSERR_PRIOLEVELNEEDED:
+			error = "Caller doesn't have priority";
+			break;
+		case DSERR_UNSUPPORTED:
+			error = "Function not supported";
+			break;
+		default:
+			SDL_snprintf(errbuf, SDL_arraysize(errbuf),
+			         "%s: Unknown DirectSound error: 0x%x",
+								function, code);
+			break;
+	}
+	if ( ! errbuf[0] ) {
+		SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: %s", function, error);
+	}
+	SDL_SetError("%s", errbuf);
+	return;
+}
+
+/* DirectSound needs to be associated with a window */
+static HWND mainwin = NULL;
+/* */
+void DX5_SoundFocus(HWND hwnd)
+{
+	mainwin = hwnd;
+}
+
+static void DX5_ThreadInit(_THIS)
+{
+	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
+}
+
+static void DX5_WaitAudio_BusyWait(_THIS)
+{
+	DWORD status;
+	DWORD cursor, junk;
+	HRESULT result;
+
+	/* Semi-busy wait, since we have no way of getting play notification
+	   on a primary mixing buffer located in hardware (DirectX 5.0)
+	*/
+	result = IDirectSoundBuffer_GetCurrentPosition(mixbuf, &junk, &cursor);
+	if ( result != DS_OK ) {
+		if ( result == DSERR_BUFFERLOST ) {
+			IDirectSoundBuffer_Restore(mixbuf);
+		}
+#ifdef DEBUG_SOUND
+		SetDSerror("DirectSound GetCurrentPosition", result);
+#endif
+		return;
+	}
+
+	while ( (cursor/mixlen) == lastchunk ) {
+		/* FIXME: find out how much time is left and sleep that long */
+		SDL_Delay(1);
+
+		/* Try to restore a lost sound buffer */
+		IDirectSoundBuffer_GetStatus(mixbuf, &status);
+		if ( (status&DSBSTATUS_BUFFERLOST) ) {
+			IDirectSoundBuffer_Restore(mixbuf);
+			IDirectSoundBuffer_GetStatus(mixbuf, &status);
+			if ( (status&DSBSTATUS_BUFFERLOST) ) {
+				break;
+			}
+		}
+		if ( ! (status&DSBSTATUS_PLAYING) ) {
+			result = IDirectSoundBuffer_Play(mixbuf, 0, 0, DSBPLAY_LOOPING);
+			if ( result == DS_OK ) {
+				continue;
+			}
+#ifdef DEBUG_SOUND
+			SetDSerror("DirectSound Play", result);
+#endif
+			return;
+		}
+
+		/* Find out where we are playing */
+		result = IDirectSoundBuffer_GetCurrentPosition(mixbuf,
+								&junk, &cursor);
+		if ( result != DS_OK ) {
+			SetDSerror("DirectSound GetCurrentPosition", result);
+			return;
+		}
+	}
+}
+
+#ifdef USE_POSITION_NOTIFY
+static void DX6_WaitAudio_EventWait(_THIS)
+{
+	DWORD status;
+	HRESULT result;
+
+	/* Try to restore a lost sound buffer */
+	IDirectSoundBuffer_GetStatus(mixbuf, &status);
+	if ( (status&DSBSTATUS_BUFFERLOST) ) {
+		IDirectSoundBuffer_Restore(mixbuf);
+		IDirectSoundBuffer_GetStatus(mixbuf, &status);
+		if ( (status&DSBSTATUS_BUFFERLOST) ) {
+			return;
+		}
+	}
+	if ( ! (status&DSBSTATUS_PLAYING) ) {
+		result = IDirectSoundBuffer_Play(mixbuf, 0, 0, DSBPLAY_LOOPING);
+		if ( result != DS_OK ) {
+#ifdef DEBUG_SOUND
+			SetDSerror("DirectSound Play", result);
+#endif
+			return;
+		}
+	}
+	WaitForSingleObject(audio_event, INFINITE);
+}
+#endif /* USE_POSITION_NOTIFY */
+
+static void DX5_PlayAudio(_THIS)
+{
+	/* Unlock the buffer, allowing it to play */
+	if ( locked_buf ) {
+		IDirectSoundBuffer_Unlock(mixbuf, locked_buf, mixlen, NULL, 0);
+	}
+
+}
+
+static Uint8 *DX5_GetAudioBuf(_THIS)
+{
+	DWORD   cursor, junk;
+	HRESULT result;
+	DWORD   rawlen;
+
+	/* Figure out which blocks to fill next */
+	locked_buf = NULL;
+	result = IDirectSoundBuffer_GetCurrentPosition(mixbuf, &junk, &cursor);
+	if ( result == DSERR_BUFFERLOST ) {
+		IDirectSoundBuffer_Restore(mixbuf);
+		result = IDirectSoundBuffer_GetCurrentPosition(mixbuf,
+								&junk, &cursor);
+	}
+	if ( result != DS_OK ) {
+		SetDSerror("DirectSound GetCurrentPosition", result);
+		return(NULL);
+	}
+	cursor /= mixlen;
+#ifdef DEBUG_SOUND
+	/* Detect audio dropouts */
+	{ DWORD spot = cursor;
+	  if ( spot < lastchunk ) {
+	    spot += NUM_BUFFERS;
+	  }
+	  if ( spot > lastchunk+1 ) {
+	    fprintf(stderr, "Audio dropout, missed %d fragments\n",
+	            (spot - (lastchunk+1)));
+	  }
+	}
+#endif
+	lastchunk = cursor;
+	cursor = (cursor+1)%NUM_BUFFERS;
+	cursor *= mixlen;
+
+	/* Lock the audio buffer */
+	result = IDirectSoundBuffer_Lock(mixbuf, cursor, mixlen,
+				(LPVOID *)&locked_buf, &rawlen, NULL, &junk, 0);
+	if ( result == DSERR_BUFFERLOST ) {
+		IDirectSoundBuffer_Restore(mixbuf);
+		result = IDirectSoundBuffer_Lock(mixbuf, cursor, mixlen,
+				(LPVOID *)&locked_buf, &rawlen, NULL, &junk, 0);
+	}
+	if ( result != DS_OK ) {
+		SetDSerror("DirectSound Lock", result);
+		return(NULL);
+	}
+	return(locked_buf);
+}
+
+static void DX5_WaitDone(_THIS)
+{
+	Uint8 *stream;
+
+	/* Wait for the playing chunk to finish */
+	stream = this->GetAudioBuf(this);
+	if ( stream != NULL ) {
+		SDL_memset(stream, silence, mixlen);
+		this->PlayAudio(this);
+	}
+	this->WaitAudio(this);
+
+	/* Stop the looping sound buffer */
+	IDirectSoundBuffer_Stop(mixbuf);
+}
+
+static void DX5_CloseAudio(_THIS)
+{
+	if ( sound != NULL ) {
+		if ( mixbuf != NULL ) {
+			/* Clean up the audio buffer */
+			IDirectSoundBuffer_Release(mixbuf);
+			mixbuf = NULL;
+		}
+		if ( audio_event != NULL ) {
+			CloseHandle(audio_event);
+			audio_event = NULL;
+		}
+		IDirectSound_Release(sound);
+		sound = NULL;
+	}
+}
+
+#ifdef USE_PRIMARY_BUFFER
+/* This function tries to create a primary audio buffer, and returns the
+   number of audio chunks available in the created buffer.
+*/
+static int CreatePrimary(LPDIRECTSOUND sndObj, HWND focus, 
+	LPDIRECTSOUNDBUFFER *sndbuf, WAVEFORMATEX *wavefmt, Uint32 chunksize)
+{
+	HRESULT result;
+	DSBUFFERDESC format;
+	DSBCAPS caps;
+	int numchunks;
+
+	/* Try to set primary mixing privileges */
+	result = IDirectSound_SetCooperativeLevel(sndObj, focus,
+							DSSCL_WRITEPRIMARY);
+	if ( result != DS_OK ) {
+#ifdef DEBUG_SOUND
+		SetDSerror("DirectSound SetCooperativeLevel", result);
+#endif
+		return(-1);
+	}
+
+	/* Try to create the primary buffer */
+	SDL_memset(&format, 0, sizeof(format));
+	format.dwSize = sizeof(format);
+	format.dwFlags=(DSBCAPS_PRIMARYBUFFER|DSBCAPS_GETCURRENTPOSITION2);
+	format.dwFlags |= DSBCAPS_STICKYFOCUS;
+#ifdef USE_POSITION_NOTIFY
+	format.dwFlags |= DSBCAPS_CTRLPOSITIONNOTIFY;
+#endif
+	result = IDirectSound_CreateSoundBuffer(sndObj, &format, sndbuf, NULL);
+	if ( result != DS_OK ) {
+#ifdef DEBUG_SOUND
+		SetDSerror("DirectSound CreateSoundBuffer", result);
+#endif
+		return(-1);
+	}
+
+	/* Check the size of the fragment buffer */
+	SDL_memset(&caps, 0, sizeof(caps));
+	caps.dwSize = sizeof(caps);
+	result = IDirectSoundBuffer_GetCaps(*sndbuf, &caps);
+	if ( result != DS_OK ) {
+#ifdef DEBUG_SOUND
+		SetDSerror("DirectSound GetCaps", result);
+#endif
+		IDirectSoundBuffer_Release(*sndbuf);
+		return(-1);
+	}
+	if ( (chunksize > caps.dwBufferBytes) ||
+				((caps.dwBufferBytes%chunksize) != 0) ) {
+		/* The primary buffer size is not a multiple of 'chunksize'
+		   -- this hopefully doesn't happen when 'chunksize' is a 
+		      power of 2.
+		*/
+		IDirectSoundBuffer_Release(*sndbuf);
+		SDL_SetError(
+"Primary buffer size is: %d, cannot break it into chunks of %d bytes\n",
+					caps.dwBufferBytes, chunksize);
+		return(-1);
+	}
+	numchunks = (caps.dwBufferBytes/chunksize);
+
+	/* Set the primary audio format */
+	result = IDirectSoundBuffer_SetFormat(*sndbuf, wavefmt);
+	if ( result != DS_OK ) {
+#ifdef DEBUG_SOUND
+		SetDSerror("DirectSound SetFormat", result);
+#endif
+		IDirectSoundBuffer_Release(*sndbuf);
+		return(-1);
+	}
+	return(numchunks);
+}
+#endif /* USE_PRIMARY_BUFFER */
+
+/* This function tries to create a secondary audio buffer, and returns the
+   number of audio chunks available in the created buffer.
+*/
+static int CreateSecondary(LPDIRECTSOUND sndObj, HWND focus,
+	LPDIRECTSOUNDBUFFER *sndbuf, WAVEFORMATEX *wavefmt, Uint32 chunksize)
+{
+	const int numchunks = 8;
+	HRESULT result;
+	DSBUFFERDESC format;
+	LPVOID pvAudioPtr1, pvAudioPtr2;
+	DWORD  dwAudioBytes1, dwAudioBytes2;
+
+	/* Try to set primary mixing privileges */
+	if ( focus ) {
+		result = IDirectSound_SetCooperativeLevel(sndObj,
+					focus, DSSCL_PRIORITY);
+	} else {
+		result = IDirectSound_SetCooperativeLevel(sndObj,
+					GetDesktopWindow(), DSSCL_NORMAL);
+	}
+	if ( result != DS_OK ) {
+#ifdef DEBUG_SOUND
+		SetDSerror("DirectSound SetCooperativeLevel", result);
+#endif
+		return(-1);
+	}
+
+	/* Try to create the secondary buffer */
+	SDL_memset(&format, 0, sizeof(format));
+	format.dwSize = sizeof(format);
+	format.dwFlags = DSBCAPS_GETCURRENTPOSITION2;
+#ifdef USE_POSITION_NOTIFY
+	format.dwFlags |= DSBCAPS_CTRLPOSITIONNOTIFY;
+#endif
+	if ( ! focus ) {
+		format.dwFlags |= DSBCAPS_GLOBALFOCUS;
+	} else {
+		format.dwFlags |= DSBCAPS_STICKYFOCUS;
+	}
+	format.dwBufferBytes = numchunks*chunksize;
+	if ( (format.dwBufferBytes < DSBSIZE_MIN) ||
+	     (format.dwBufferBytes > DSBSIZE_MAX) ) {
+		SDL_SetError("Sound buffer size must be between %d and %d",
+				DSBSIZE_MIN/numchunks, DSBSIZE_MAX/numchunks);
+		return(-1);
+	}
+	format.dwReserved = 0;
+	format.lpwfxFormat = wavefmt;
+	result = IDirectSound_CreateSoundBuffer(sndObj, &format, sndbuf, NULL);
+	if ( result != DS_OK ) {
+		SetDSerror("DirectSound CreateSoundBuffer", result);
+		return(-1);
+	}
+	IDirectSoundBuffer_SetFormat(*sndbuf, wavefmt);
+
+	/* Silence the initial audio buffer */
+	result = IDirectSoundBuffer_Lock(*sndbuf, 0, format.dwBufferBytes,
+	                                 (LPVOID *)&pvAudioPtr1, &dwAudioBytes1,
+	                                 (LPVOID *)&pvAudioPtr2, &dwAudioBytes2,
+	                                 DSBLOCK_ENTIREBUFFER);
+	if ( result == DS_OK ) {
+		if ( wavefmt->wBitsPerSample == 8 ) {
+			SDL_memset(pvAudioPtr1, 0x80, dwAudioBytes1);
+		} else {
+			SDL_memset(pvAudioPtr1, 0x00, dwAudioBytes1);
+		}
+		IDirectSoundBuffer_Unlock(*sndbuf,
+		                          (LPVOID)pvAudioPtr1, dwAudioBytes1,
+		                          (LPVOID)pvAudioPtr2, dwAudioBytes2);
+	}
+
+	/* We're ready to go */
+	return(numchunks);
+}
+
+/* This function tries to set position notify events on the mixing buffer */
+#ifdef USE_POSITION_NOTIFY
+static int CreateAudioEvent(_THIS)
+{
+	LPDIRECTSOUNDNOTIFY notify;
+	DSBPOSITIONNOTIFY *notify_positions;
+	int i, retval;
+	HRESULT result;
+
+	/* Default to fail on exit */
+	retval = -1;
+	notify = NULL;
+
+	/* Query for the interface */
+	result = IDirectSoundBuffer_QueryInterface(mixbuf,
+			&IID_IDirectSoundNotify, (void *)&notify);
+	if ( result != DS_OK ) {
+		goto done;
+	}
+
+	/* Allocate the notify structures */
+	notify_positions = (DSBPOSITIONNOTIFY *)SDL_malloc(NUM_BUFFERS*
+					sizeof(*notify_positions));
+	if ( notify_positions == NULL ) {
+		goto done;
+	}
+
+	/* Create the notify event */
+	audio_event = CreateEvent(NULL, FALSE, FALSE, NULL);
+	if ( audio_event == NULL ) {
+		goto done;
+	}
+
+	/* Set up the notify structures */
+	for ( i=0; i<NUM_BUFFERS; ++i ) {
+		notify_positions[i].dwOffset = i*mixlen;
+		notify_positions[i].hEventNotify = audio_event;
+	}
+	result = IDirectSoundNotify_SetNotificationPositions(notify,
+					NUM_BUFFERS, notify_positions);
+	if ( result == DS_OK ) {
+		retval = 0;
+	}
+done:
+	if ( notify != NULL ) {
+		IDirectSoundNotify_Release(notify);
+	}
+	return(retval);
+}
+#endif /* USE_POSITION_NOTIFY */
+
+static int DX5_OpenAudio(_THIS, SDL_AudioSpec *spec)
+{
+	HRESULT      result;
+	WAVEFORMATEX waveformat;
+
+	/* Set basic WAVE format parameters */
+	SDL_memset(&waveformat, 0, sizeof(waveformat));
+	waveformat.wFormatTag = WAVE_FORMAT_PCM;
+
+	/* Determine the audio parameters from the AudioSpec */
+	switch ( spec->format & 0xFF ) {
+		case 8:
+			/* Unsigned 8 bit audio data */
+			spec->format = AUDIO_U8;
+			silence = 0x80;
+			waveformat.wBitsPerSample = 8;
+			break;
+		case 16:
+			/* Signed 16 bit audio data */
+			spec->format = AUDIO_S16;
+			silence = 0x00;
+			waveformat.wBitsPerSample = 16;
+			break;
+		default:
+			SDL_SetError("Unsupported audio format");
+			return(-1);
+	}
+	waveformat.nChannels = spec->channels;
+	waveformat.nSamplesPerSec = spec->freq;
+	waveformat.nBlockAlign =
+		waveformat.nChannels * (waveformat.wBitsPerSample/8);
+	waveformat.nAvgBytesPerSec = 
+		waveformat.nSamplesPerSec * waveformat.nBlockAlign;
+
+	/* Update the fragment size as size in bytes */
+	SDL_CalculateAudioSpec(spec);
+
+	/* Open the audio device */
+	result = DSoundCreate(NULL, &sound, NULL);
+	if ( result != DS_OK ) {
+		SetDSerror("DirectSoundCreate", result);
+		return(-1);
+	}
+
+	/* Create the audio buffer to which we write */
+	NUM_BUFFERS = -1;
+#ifdef USE_PRIMARY_BUFFER
+	if ( mainwin ) {
+		NUM_BUFFERS = CreatePrimary(sound, mainwin, &mixbuf,
+						&waveformat, spec->size);
+	}
+#endif /* USE_PRIMARY_BUFFER */
+	if ( NUM_BUFFERS < 0 ) {
+		NUM_BUFFERS = CreateSecondary(sound, mainwin, &mixbuf,
+						&waveformat, spec->size);
+		if ( NUM_BUFFERS < 0 ) {
+			return(-1);
+		}
+#ifdef DEBUG_SOUND
+		fprintf(stderr, "Using secondary audio buffer\n");
+#endif
+	}
+#ifdef DEBUG_SOUND
+	else
+		fprintf(stderr, "Using primary audio buffer\n");
+#endif
+
+	/* The buffer will auto-start playing in DX5_WaitAudio() */
+	lastchunk = 0;
+	mixlen = spec->size;
+
+#ifdef USE_POSITION_NOTIFY
+	/* See if we can use DirectX 6 event notification */
+	if ( CreateAudioEvent(this) == 0 ) {
+		this->WaitAudio = DX6_WaitAudio_EventWait;
+	} else {
+		this->WaitAudio = DX5_WaitAudio_BusyWait;
+	}
+#endif
+	return(0);
+}
+