/*

    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);

}