distrib/sdl-1.2.12/src/audio/windx5/SDL_dx5audio.c - platform/external/qemu - Gitiles

 /*
     SDL - Simple DirectMedia Layer
     Copyright (C) 1997-2006 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);
 }
	/*
	SDL - Simple DirectMedia Layer
	Copyright (C) 1997-2006 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);
	}