/*
 * PortAudio Portable Real-Time Audio Library
 * Latest Version at: http://www.softsynth.com/portaudio/
 * DirectSound Implementation
 *
 * Copyright (c) 1999-2000 Phil Burk
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files
 * (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * Any person wishing to distribute modifications to the Software is
 * requested to send the modifications to the original developer so that
 * they can be incorporated into the canonical version.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */
/* Modifications
 *    7/19/01 Mike Berry - casts for compiling with __MWERKS__ CodeWarrior
 *    9/27/01 Phil Burk - use number of frames instead of real-time for CPULoad calculation.
 */
/* Compiler flags:
	SUPPORT_AUDIO_CAPTURE - define this flag if you want to SUPPORT_AUDIO_CAPTURE
 */
#include <stdio.h>
#include <stdlib.h>
#ifndef __MWERKS__
#include <malloc.h>
#include <memory.h>
#endif //__MWERKS__
#include <math.h>
#if 0
#include "portaudio.h"
#include "pa_host.h"
#include "pa_trace.h"
#include "dsound_wrapper.h"
#endif
#define PRINT(x) { printf x; fflush(stdout); }
#define ERR_RPT(x) PRINT(x)
#define DBUG(x)  /* PRINT(x) */
#define DBUGX(x) /* PRINT(x) */
#define PA_USE_HIGH_LATENCY   (0)
#if PA_USE_HIGH_LATENCY
#define PA_WIN_9X_LATENCY     (500)
#define PA_WIN_NT_LATENCY     (600)
#else
#define PA_WIN_9X_LATENCY     (140)
#define PA_WIN_NT_LATENCY     (280)
#endif
/* Trigger an underflow for testing purposes. Should normally be (0). */
#define PA_SIMULATE_UNDERFLOW (0)
#if PA_SIMULATE_UNDERFLOW
static  gUnderCallbackCounter = 0;
#define UNDER_START_GAP       (10)
#define UNDER_STOP_GAP        (UNDER_START_GAP + 4)
#endif
/************************************************* Definitions ********/
typedef struct internalPortAudioStream internalPortAudioStream;
typedef struct internalPortAudioDevice
{
	GUID                             pad_GUID;
	GUID                            *pad_lpGUID;
	double                           pad_SampleRates[10]; /* for pointing to from pad_Info FIXME?!*/
	PaDeviceInfo                     pad_Info;
} internalPortAudioDevice;
/* Define structure to contain all DirectSound and Windows specific data. */
typedef struct PaHostSoundControl
{
	DSoundWrapper    pahsc_DSoundWrapper;
	MMRESULT         pahsc_TimerID;
	BOOL             pahsc_IfInsideCallback;  /* Test for reentrancy. */
	short           *pahsc_NativeBuffer;
	unsigned int     pahsc_BytesPerBuffer;    /* native buffer size in bytes */
	double           pahsc_ValidFramesWritten;
	int              pahsc_FramesPerDSBuffer;
/* For measuring CPU utilization. */
	LARGE_INTEGER    pahsc_EntryCount;
	double           pahsc_InverseTicksPerUserBuffer;
} PaHostSoundControl;
/************************************************* Shared Data ********/
/* FIXME - put Mutex around this shared data. */
static int sNumDevices = 0;
static int sDeviceIndex = 0;
static internalPortAudioDevice *sDevices = NULL;
static int sDefaultInputDeviceID = paNoDevice;
static int sDefaultOutputDeviceID = paNoDevice;
static int sEnumerationError;
static int sPaHostError = 0;
/************************************************* Prototypes **********/
static internalPortAudioDevice *Pa_GetInternalDevice( PaDeviceID id );
static BOOL CALLBACK Pa_EnumProc(LPGUID lpGUID, 
				         LPCTSTR lpszDesc,
				         LPCTSTR lpszDrvName, 
				         LPVOID lpContext );
static BOOL CALLBACK Pa_CountDevProc(LPGUID lpGUID, 
				         LPCTSTR lpszDesc,
				         LPCTSTR lpszDrvName, 
				         LPVOID lpContext );
static Pa_QueryDevices( void );
static void CALLBACK Pa_TimerCallback(UINT uID, UINT uMsg,
									  DWORD dwUser, DWORD dw1, DWORD dw2);
/********************************* BEGIN CPU UTILIZATION MEASUREMENT ****/
static void Pa_StartUsageCalculation( internalPortAudioStream   *past )
{
	PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
	if( pahsc == NULL ) return;
/* Query system timer for usage analysis and to prevent overuse of CPU. */
	QueryPerformanceCounter( &pahsc->pahsc_EntryCount );
}
static void Pa_EndUsageCalculation( internalPortAudioStream   *past )
{
	LARGE_INTEGER CurrentCount = { 0, 0 };
	PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
	if( pahsc == NULL ) return;
/*
** Measure CPU utilization during this callback. Note that this calculation
** assumes that we had the processor the whole time.
*/
#define LOWPASS_COEFFICIENT_0   (0.9)
#define LOWPASS_COEFFICIENT_1   (0.99999 - LOWPASS_COEFFICIENT_0)
	if( QueryPerformanceCounter( &CurrentCount ) )
	{
		LONGLONG InsideCount = CurrentCount.QuadPart - pahsc->pahsc_EntryCount.QuadPart;	
		double newUsage = InsideCount * pahsc->pahsc_InverseTicksPerUserBuffer;
		past->past_Usage = (LOWPASS_COEFFICIENT_0 * past->past_Usage) +
			(LOWPASS_COEFFICIENT_1 * newUsage);
	}
}
/****************************************** END CPU UTILIZATION *******/
static PaError Pa_QueryDevices( void )
{
	int numBytes;
	sDefaultInputDeviceID = paNoDevice;
	sDefaultOutputDeviceID = paNoDevice;
/* Enumerate once just to count devices. */
	sNumDevices = 0; // for default device
	DirectSoundEnumerate( (LPDSENUMCALLBACK)Pa_CountDevProc, NULL );
#if SUPPORT_AUDIO_CAPTURE
	DirectSoundCaptureEnumerate( (LPDSENUMCALLBACK)Pa_CountDevProc, NULL );
#endif /* SUPPORT_AUDIO_CAPTURE */
/* Allocate structures to hold device info. */
	numBytes = sNumDevices * sizeof(internalPortAudioDevice);
	sDevices = (internalPortAudioDevice *)PaHost_AllocateFastMemory( numBytes ); /* MEM */
	if( sDevices == NULL ) return paInsufficientMemory;
/* Enumerate again to fill in structures. */
	sDeviceIndex = 0;
	sEnumerationError = 0;
	DirectSoundEnumerate( (LPDSENUMCALLBACK)Pa_EnumProc, (void *)0 );
#if SUPPORT_AUDIO_CAPTURE
	if( sEnumerationError != paNoError ) return sEnumerationError;
	sEnumerationError = 0;
	DirectSoundCaptureEnumerate( (LPDSENUMCALLBACK)Pa_EnumProc, (void *)1 );
#endif /* SUPPORT_AUDIO_CAPTURE */
	return sEnumerationError;
}
/************************************************************************************/
long Pa_GetHostError()
{
	return sPaHostError;
}
/************************************************************************************
** Just count devices so we know how much memory to allocate.
*/
static BOOL CALLBACK Pa_CountDevProc(LPGUID lpGUID, 
				         LPCTSTR lpszDesc,
				         LPCTSTR lpszDrvName, 
				         LPVOID lpContext )
{
	sNumDevices++;
	return TRUE;
}
/************************************************************************************
** Extract capabilities info from each device.
*/
static BOOL CALLBACK Pa_EnumProc(LPGUID lpGUID, 
				         LPCTSTR lpszDesc,
				         LPCTSTR lpszDrvName, 
				         LPVOID lpContext )
{
	HRESULT    hr;
	LPDIRECTSOUND          lpDirectSound;
#if SUPPORT_AUDIO_CAPTURE
	LPDIRECTSOUNDCAPTURE   lpDirectSoundCapture;
#endif /* SUPPORT_AUDIO_CAPTURE */
	int        isInput  = (int) lpContext;  /* Passed from Pa_CountDevices() */
	internalPortAudioDevice *pad;
		
	if( sDeviceIndex >= sNumDevices )
	{
		sEnumerationError = paInternalError;
		return FALSE;
	}
	pad = &sDevices[sDeviceIndex];
/* Copy GUID to static array. Set pointer. */
	if( lpGUID == NULL )
	{
		pad->pad_lpGUID = NULL;
	}
	else
	{
		memcpy( &pad->pad_GUID, lpGUID, sizeof(GUID) );
		pad->pad_lpGUID = &pad->pad_GUID;
	}
	pad->pad_Info.sampleRates = pad->pad_SampleRates;  /* Point to array. */
/* Allocate room for descriptive name. */
	if( lpszDesc != NULL )
	{
		int len = strlen(lpszDesc);
		pad->pad_Info.name = (char *)malloc( len+1 );
		if( pad->pad_Info.name == NULL )
		{
			sEnumerationError = paInsufficientMemory;
			return FALSE;
		}
		memcpy( (void *) pad->pad_Info.name, lpszDesc, len+1 );
	}
#if SUPPORT_AUDIO_CAPTURE
	if( isInput )
	{
	/********** Input ******************************/
		DSCCAPS     caps;
		if( lpGUID == NULL ) sDefaultInputDeviceID = sDeviceIndex;
		hr = DirectSoundCaptureCreate(  lpGUID, &lpDirectSoundCapture,   NULL );
		if( hr != DS_OK )
		{
			pad->pad_Info.maxInputChannels = 0;
			DBUG(("Cannot create Capture for %s. Result = 0x%x\n", lpszDesc, hr ));
		}
		else
		{
	/* Query device characteristics. */
			caps.dwSize = sizeof(caps);
			IDirectSoundCapture_GetCaps( lpDirectSoundCapture, &caps );
			/* printf("caps.dwFormats = 0x%x\n", caps.dwFormats ); */
			pad->pad_Info.maxInputChannels = caps.dwChannels;
	/* Determine sample rates from flags. */
			if( caps.dwChannels == 2 )
			{
				int index = 0;
				if( caps.dwFormats & WAVE_FORMAT_1S16) pad->pad_SampleRates[index++] = 11025.0;
				if( caps.dwFormats & WAVE_FORMAT_2S16) pad->pad_SampleRates[index++] = 22050.0;
				if( caps.dwFormats & WAVE_FORMAT_4S16) pad->pad_SampleRates[index++] = 44100.0;
				pad->pad_Info.numSampleRates = index;
			}
			else if( caps.dwChannels == 1 )
			{
				int index = 0;
				if( caps.dwFormats & WAVE_FORMAT_1M16) pad->pad_SampleRates[index++] = 11025.0;
				if( caps.dwFormats & WAVE_FORMAT_2M16) pad->pad_SampleRates[index++] = 22050.0;
				if( caps.dwFormats & WAVE_FORMAT_4M16) pad->pad_SampleRates[index++] = 44100.0;
				pad->pad_Info.numSampleRates = index;
			}
			else pad->pad_Info.numSampleRates = 0;
			IDirectSoundCapture_Release( lpDirectSoundCapture );
		}
	}
	else
#endif /* SUPPORT_AUDIO_CAPTURE */
	{
	/********** Output ******************************/
		DSCAPS     caps;
		if( lpGUID == NULL ) sDefaultOutputDeviceID = sDeviceIndex;
	/* Create interfaces for each object. */
		hr = DirectSoundCreate(  lpGUID, &lpDirectSound,   NULL );
		if( hr != DS_OK )
		{
			pad->pad_Info.maxOutputChannels = 0;
			DBUG(("Cannot create dsound for %s. Result = 0x%x\n", lpszDesc, hr ));
		}
		else
		{
		/* Query device characteristics. */
			caps.dwSize = sizeof(caps);
			IDirectSound_GetCaps( lpDirectSound, &caps );
			pad->pad_Info.maxOutputChannels = ( caps.dwFlags & DSCAPS_PRIMARYSTEREO ) ? 2 : 1;
		/* Get sample rates. */
			pad->pad_SampleRates[0] = (double) caps.dwMinSecondarySampleRate;
			pad->pad_SampleRates[1] = (double) caps.dwMaxSecondarySampleRate;
			if( caps.dwFlags & DSCAPS_CONTINUOUSRATE ) pad->pad_Info.numSampleRates = -1;
			else if( caps.dwMinSecondarySampleRate == caps.dwMaxSecondarySampleRate )
			{
				if( caps.dwMinSecondarySampleRate == 0 )
				{
			/*
			** On my Thinkpad 380Z, DirectSoundV6 returns min-max=0 !!
			** But it supports continuous sampling.
			** So fake range of rates, and hope it really supports it.
			*/
					pad->pad_SampleRates[0] = 11025.0f;
					pad->pad_SampleRates[1] = 48000.0f;
					pad->pad_Info.numSampleRates = -1; /* continuous range */
					
					DBUG(("PA - Reported rates both zero. Setting to fake values for device #%d\n", sDeviceIndex ));
				}
				else
				{
					pad->pad_Info.numSampleRates = 1;
				}
			}
			else if( (caps.dwMinSecondarySampleRate < 1000.0) && (caps.dwMaxSecondarySampleRate > 50000.0) )
			{
			/* The EWS88MT drivers lie, lie, lie. The say they only support two rates, 100 & 100000.
			** But we know that they really support a range of rates!
			** So when we see a ridiculous set of rates, assume it is a range.
			*/
				pad->pad_Info.numSampleRates = -1;
				DBUG(("PA - Sample rate range used instead of two odd values for device #%d\n", sDeviceIndex ));
			}
			else pad->pad_Info.numSampleRates = 2;
			IDirectSound_Release( lpDirectSound );
		}
	}
	pad->pad_Info.nativeSampleFormats = paInt16;
	sDeviceIndex++;
	return( TRUE );
}
/*************************************************************************/
int Pa_CountDevices()
{
	if( sNumDevices <= 0 ) Pa_Initialize();
	return sNumDevices;
}
static internalPortAudioDevice *Pa_GetInternalDevice( PaDeviceID id )
{
	if( (id < 0) || ( id >= Pa_CountDevices()) ) return NULL;
	return &sDevices[id];
}
/*************************************************************************/
const PaDeviceInfo* Pa_GetDeviceInfo( PaDeviceID id )
{
	internalPortAudioDevice *pad;
	if( (id < 0) || ( id >= Pa_CountDevices()) ) return NULL;
	pad = Pa_GetInternalDevice( id );
	return  &pad->pad_Info ;
}
static PaError Pa_MaybeQueryDevices( void )
{
	if( sNumDevices == 0 )
	{
		return Pa_QueryDevices();
	}
	return 0;
}
/*************************************************************************
** Returns recommended device ID.
** On the PC, the recommended device can be specified by the user by
** setting an environment variable. For example, to use device #1.
**
**    set PA_RECOMMENDED_OUTPUT_DEVICE=1
**
** The user should first determine the available device ID by using
** the supplied application "pa_devs".
*/
#define PA_ENV_BUF_SIZE  (32)
#define PA_REC_IN_DEV_ENV_NAME  ("PA_RECOMMENDED_INPUT_DEVICE")
#define PA_REC_OUT_DEV_ENV_NAME  ("PA_RECOMMENDED_OUTPUT_DEVICE")
static PaDeviceID PaHost_GetEnvDefaultDeviceID( char *envName )
{
	DWORD   hresult;
	char    envbuf[PA_ENV_BUF_SIZE];
	PaDeviceID recommendedID = paNoDevice;
/* Let user determine default device by setting environment variable. */
	hresult = GetEnvironmentVariable( envName, envbuf, PA_ENV_BUF_SIZE );
	if( (hresult > 0) && (hresult < PA_ENV_BUF_SIZE) )
	{
		recommendedID = atoi( envbuf );
	}
	return recommendedID;
}
PaDeviceID Pa_GetDefaultInputDeviceID( void )
{
	PaError result;
	result = PaHost_GetEnvDefaultDeviceID( PA_REC_IN_DEV_ENV_NAME );
	if( result < 0 )
	{
		result = Pa_MaybeQueryDevices();
		if( result < 0 ) return result;
		result = sDefaultInputDeviceID;
	}
	return result;
}
PaDeviceID Pa_GetDefaultOutputDeviceID( void )
{
	PaError result;
	result = PaHost_GetEnvDefaultDeviceID( PA_REC_OUT_DEV_ENV_NAME );
	if( result < 0 )
	{
		result = Pa_MaybeQueryDevices();
		if( result < 0 ) return result;
		result = sDefaultOutputDeviceID;
	}
	return result;
}
/**********************************************************************
** Make sure that we have queried the device capabilities.
*/
PaError PaHost_Init( void )
{
#if PA_SIMULATE_UNDERFLOW
	PRINT(("WARNING - Underflow Simulation Enabled - Expect a Big Glitch!!!\n"));
#endif
	return Pa_MaybeQueryDevices();
}
static PaError Pa_TimeSlice( internalPortAudioStream   *past )
{
	PaError           result = 0;
	long              bytesEmpty = 0;
	long              bytesFilled = 0;
	long              bytesToXfer = 0;
	long              numChunks;
	HRESULT           hresult;
	PaHostSoundControl  *pahsc;
	short            *nativeBufPtr;
	past->past_NumCallbacks += 1;
	pahsc = (PaHostSoundControl *) past->past_DeviceData;
	if( pahsc == NULL ) return paInternalError;
/* How much input data is available? */
#if SUPPORT_AUDIO_CAPTURE
	if( past->past_NumInputChannels > 0 )
	{
		DSW_QueryInputFilled( &pahsc->pahsc_DSoundWrapper, &bytesFilled );
		bytesToXfer = bytesFilled;
	}
#endif /* SUPPORT_AUDIO_CAPTURE */
/* How much output room is available? */
	if( past->past_NumOutputChannels > 0 )
	{
		DSW_QueryOutputSpace( &pahsc->pahsc_DSoundWrapper, &bytesEmpty );
		bytesToXfer = bytesEmpty;
	}
	AddTraceMessage( "bytesEmpty ", bytesEmpty );
/* Choose smallest value if both are active. */
	if( (past->past_NumInputChannels > 0) && (past->past_NumOutputChannels > 0) )
	{
		bytesToXfer = ( bytesFilled < bytesEmpty ) ? bytesFilled : bytesEmpty;
	}
/*	printf("bytesFilled = %d, bytesEmpty = %d, bytesToXfer = %d\n",
		bytesFilled, bytesEmpty, bytesToXfer);
*/
/* Quantize to multiples of a buffer. */
	numChunks = bytesToXfer / pahsc->pahsc_BytesPerBuffer;
	if( numChunks > (long)(past->past_NumUserBuffers/2) )
	{
		numChunks = (long)past->past_NumUserBuffers/2;
	}
	else if( numChunks < 0 )
	{
		numChunks = 0;
	}
	AddTraceMessage( "numChunks ", numChunks );
	nativeBufPtr = pahsc->pahsc_NativeBuffer;
	if( numChunks > 0 )
	{
		while( numChunks-- > 0 )
		{
		/* Measure usage based on time to process one user buffer. */
			Pa_StartUsageCalculation( past );
	#if SUPPORT_AUDIO_CAPTURE
	/* Get native data from DirectSound. */
			if( past->past_NumInputChannels > 0 )
			{
				hresult = DSW_ReadBlock( &pahsc->pahsc_DSoundWrapper, (char *) nativeBufPtr, pahsc->pahsc_BytesPerBuffer );
				if( hresult < 0 )
				{
					ERR_RPT(("DirectSound ReadBlock failed, hresult = 0x%x\n",hresult));
					sPaHostError = hresult;
					break;
				}
			}
	#endif /* SUPPORT_AUDIO_CAPTURE */
	/* Convert 16 bit native data to user data and call user routine. */
			result = Pa_CallConvertInt16( past, nativeBufPtr, nativeBufPtr );
			if( result != 0) break;
	/* Pass native data to DirectSound. */
			if( past->past_NumOutputChannels > 0 )
			{
			/*	static short DEBUGHACK = 0;
				DEBUGHACK += 0x0049;
				nativeBufPtr[0] = DEBUGHACK; /* Make buzz to see if DirectSound still running. */
				hresult = DSW_WriteBlock( &pahsc->pahsc_DSoundWrapper, (char *) nativeBufPtr, pahsc->pahsc_BytesPerBuffer );
				if( hresult < 0 )
				{
					ERR_RPT(("DirectSound WriteBlock failed, result = 0x%x\n",hresult));
					sPaHostError = hresult;
					break;
				}
			}
			Pa_EndUsageCalculation( past );
		}
	}
	return result;
}
/*******************************************************************/
static void CALLBACK Pa_TimerCallback(UINT uID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD dw2)
{
	internalPortAudioStream   *past;
	PaHostSoundControl  *pahsc;
#if PA_SIMULATE_UNDERFLOW
	gUnderCallbackCounter++;
	if( (gUnderCallbackCounter >= UNDER_START_GAP) &&
		(gUnderCallbackCounter <= UNDER_STOP_GAP) )
	{
		if( gUnderCallbackCounter == UNDER_START_GAP)
		{
			AddTraceMessage("Begin stall: gUnderCallbackCounter =======", gUnderCallbackCounter );
		}
		if( gUnderCallbackCounter == UNDER_STOP_GAP)
		{
			AddTraceMessage("End stall: gUnderCallbackCounter =======", gUnderCallbackCounter );
		}
		return;
	}
#endif
	past = (internalPortAudioStream *) dwUser;
	if( past == NULL ) return;
	pahsc = (PaHostSoundControl *) past->past_DeviceData;
	if( pahsc == NULL ) return;
	if( !pahsc->pahsc_IfInsideCallback && past->past_IsActive )
	{
		if( past->past_StopNow )
		{
			past->past_IsActive = 0;
		}
		else if( past->past_StopSoon )
		{
			DSoundWrapper   *dsw = &pahsc->pahsc_DSoundWrapper;
			if( past->past_NumOutputChannels > 0 )
			{
				DSW_ZeroEmptySpace( dsw ); 
				AddTraceMessage("Pa_TimerCallback: waiting - written ", (int) dsw->dsw_FramesWritten );
				AddTraceMessage("Pa_TimerCallback: waiting - played ", (int) dsw->dsw_FramesPlayed );
		/* clear past_IsActive when all sound played */
				if( dsw->dsw_FramesPlayed >= past->past_FrameCount )
				{
					past->past_IsActive = 0;
				}
			}
			else
			{
				past->past_IsActive = 0;
			}
		}
		else
		{
			pahsc->pahsc_IfInsideCallback = 1;
			if( Pa_TimeSlice( past ) != 0)  /* Call time slice independant of timing method. */
			{
				past->past_StopSoon = 1;
			}
			pahsc->pahsc_IfInsideCallback = 0;
		}
	}
}
/*******************************************************************/
PaError PaHost_OpenStream( internalPortAudioStream   *past )
{
	HRESULT          hr;
	PaError          result = paNoError;
	PaHostSoundControl *pahsc;
	int              numBytes, maxChannels;
	unsigned int     minNumBuffers;
	internalPortAudioDevice *pad;
	DSoundWrapper   *dsw;
/* Allocate and initialize host data. */
	pahsc = (PaHostSoundControl *) PaHost_AllocateFastMemory(sizeof(PaHostSoundControl)); /* MEM */
	if( pahsc == NULL )
	{
		result = paInsufficientMemory;
		goto error;
	}
	memset( pahsc, 0, sizeof(PaHostSoundControl) );
	past->past_DeviceData = (void *) pahsc;
	pahsc->pahsc_TimerID = 0;
	dsw = &pahsc->pahsc_DSoundWrapper;
	DSW_Init( dsw );
/* Allocate native buffer. */
	maxChannels = ( past->past_NumOutputChannels > past->past_NumInputChannels ) ?
		past->past_NumOutputChannels : past->past_NumInputChannels;
	pahsc->pahsc_BytesPerBuffer = past->past_FramesPerUserBuffer * maxChannels * sizeof(short);
	if( maxChannels > 0 )
	{
		pahsc->pahsc_NativeBuffer = (short *) PaHost_AllocateFastMemory(pahsc->pahsc_BytesPerBuffer); /* MEM */
		if( pahsc->pahsc_NativeBuffer == NULL )
		{
			result = paInsufficientMemory;
			goto error;
		}
	}
	else
	{
		result = paInvalidChannelCount;
		goto error;
	}
	
	DBUG(("PaHost_OpenStream: pahsc_MinFramesPerHostBuffer = %d\n", pahsc->pahsc_MinFramesPerHostBuffer ));
	minNumBuffers = Pa_GetMinNumBuffers( past->past_FramesPerUserBuffer, past->past_SampleRate );
	past->past_NumUserBuffers = ( minNumBuffers > past->past_NumUserBuffers ) ? minNumBuffers : past->past_NumUserBuffers;
	numBytes = pahsc->pahsc_BytesPerBuffer * past->past_NumUserBuffers;
	if( numBytes < DSBSIZE_MIN )
	{
		result = paBufferTooSmall;
		goto error;
	}
	if( numBytes > DSBSIZE_MAX )
	{
		result = paBufferTooBig;
		goto error;
	}
	pahsc->pahsc_FramesPerDSBuffer = past->past_FramesPerUserBuffer * past->past_NumUserBuffers;
	{
		int msecLatency = (int) ((pahsc->pahsc_FramesPerDSBuffer * 1000) / past->past_SampleRate);
		PRINT(("PortAudio on DirectSound - Latency = %d frames, %d msec\n", pahsc->pahsc_FramesPerDSBuffer, msecLatency ));
	}
/* ------------------ OUTPUT */
	if( (past->past_OutputDeviceID >= 0) && (past->past_NumOutputChannels > 0) )
	{
		DBUG(("PaHost_OpenStream: deviceID = 0x%x\n", past->past_OutputDeviceID));
		pad = Pa_GetInternalDevice( past->past_OutputDeviceID );
		hr = DirectSoundCreate( pad->pad_lpGUID, &dsw->dsw_pDirectSound,   NULL );
/* If this fails, then try each output device until we find one that works. */
		if( hr != DS_OK )
		{
			int i;
			ERR_RPT(("Creation of requested Audio Output device '%s' failed.\n",
				((pad->pad_lpGUID == NULL) ? "Default" : pad->pad_Info.name) ));
			for( i=0; i<Pa_CountDevices(); i++ )
			{
				pad = Pa_GetInternalDevice( i );
				if( pad->pad_Info.maxOutputChannels >= past->past_NumOutputChannels )
				{
					DBUG(("Try device '%s' instead.\n", pad->pad_Info.name ));
					hr = DirectSoundCreate( pad->pad_lpGUID, &dsw->dsw_pDirectSound,   NULL );
					if( hr == DS_OK )
					{
						ERR_RPT(("Using device '%s' instead.\n", pad->pad_Info.name ));
						break;
					}
				}
			}
		}
		if( hr != DS_OK )
		{
			ERR_RPT(("PortAudio: DirectSoundCreate() failed!\n"));
			result = paHostError;
			sPaHostError = hr;
			goto error;
		}
		hr = DSW_InitOutputBuffer( dsw,
			(unsigned long) (past->past_SampleRate + 0.5),
			past->past_NumOutputChannels, numBytes );
		DBUG(("DSW_InitOutputBuffer() returns %x\n", hr));
		if( hr != DS_OK )
		{
			result = paHostError;
			sPaHostError = hr;
			goto error;
		}
		past->past_FrameCount = pahsc->pahsc_DSoundWrapper.dsw_FramesWritten;
	}
#if SUPPORT_AUDIO_CAPTURE
/* ------------------ INPUT */
	if( (past->past_InputDeviceID >= 0) && (past->past_NumInputChannels > 0) )
	{
		pad = Pa_GetInternalDevice( past->past_InputDeviceID );
		hr = DirectSoundCaptureCreate( pad->pad_lpGUID, &dsw->dsw_pDirectSoundCapture,   NULL );
/* If this fails, then try each input device until we find one that works. */
		if( hr != DS_OK )
		{
			int i;
			ERR_RPT(("Creation of requested Audio Capture device '%s' failed.\n",
				((pad->pad_lpGUID == NULL) ? "Default" : pad->pad_Info.name) ));
			for( i=0; i<Pa_CountDevices(); i++ )
			{
				pad = Pa_GetInternalDevice( i );
				if( pad->pad_Info.maxInputChannels >= past->past_NumInputChannels )
				{
					PRINT(("Try device '%s' instead.\n", pad->pad_Info.name ));
					hr = DirectSoundCaptureCreate( pad->pad_lpGUID, &dsw->dsw_pDirectSoundCapture,   NULL );
					if( hr == DS_OK ) break;
				}
			}
		}
		if( hr != DS_OK )
		{
			ERR_RPT(("PortAudio: DirectSoundCaptureCreate() failed!\n"));
			result = paHostError;
			sPaHostError = hr;
			goto error;
		}
		hr = DSW_InitInputBuffer( dsw,
			(unsigned long) (past->past_SampleRate + 0.5),
			past->past_NumInputChannels, numBytes );
		DBUG(("DSW_InitInputBuffer() returns %x\n", hr));
		if( hr != DS_OK )
		{
			ERR_RPT(("PortAudio: DSW_InitInputBuffer() returns %x\n", hr));
			result = paHostError;
			sPaHostError = hr;
			goto error;
		}
	}
#endif /* SUPPORT_AUDIO_CAPTURE */
	/* Calculate scalar used in CPULoad calculation. */ 
	{
		LARGE_INTEGER frequency;
		if( QueryPerformanceFrequency( &frequency ) == 0 )
		{
			pahsc->pahsc_InverseTicksPerUserBuffer = 0.0;
		}
		else
		{
			pahsc->pahsc_InverseTicksPerUserBuffer = past->past_SampleRate /
				( (double)frequency.QuadPart * past->past_FramesPerUserBuffer );
			DBUG(("pahsc_InverseTicksPerUserBuffer = %g\n", pahsc->pahsc_InverseTicksPerUserBuffer ));
		}
	}
	return result;
error:
	PaHost_CloseStream( past );
	return result;
}
/*************************************************************************/
PaError PaHost_StartOutput( internalPortAudioStream *past )
{
	HRESULT          hr;
	PaHostSoundControl *pahsc;
	PaError          result = paNoError;
	pahsc = (PaHostSoundControl *) past->past_DeviceData;
/* Give user callback a chance to pre-fill buffer. */
	result = Pa_TimeSlice( past );
	if( result != paNoError ) return result; // FIXME - what if finished?
	hr = DSW_StartOutput( &pahsc->pahsc_DSoundWrapper );
	DBUG(("PaHost_StartOutput: DSW_StartOutput returned = 0x%X.\n", hr));
	if( hr != DS_OK )
	{
		result = paHostError;
		sPaHostError = hr;
		goto error;
	}
error:
	return result;
}
/*************************************************************************/
PaError PaHost_StartInput( internalPortAudioStream *past )
{
	PaError          result = paNoError;
#if SUPPORT_AUDIO_CAPTURE
	HRESULT          hr;
	PaHostSoundControl *pahsc;
	pahsc = (PaHostSoundControl *) past->past_DeviceData;
	hr = DSW_StartInput( &pahsc->pahsc_DSoundWrapper );
	DBUG(("Pa_StartStream: DSW_StartInput returned = 0x%X.\n", hr));
	if( hr != DS_OK )
	{
		result = paHostError;
		sPaHostError = hr;
		goto error;
	}
error:
#endif /* SUPPORT_AUDIO_CAPTURE */
	return result;
}
/*************************************************************************/
PaError PaHost_StartEngine( internalPortAudioStream *past )
{
	PaHostSoundControl *pahsc;
	PaError          result = paNoError;
	pahsc = (PaHostSoundControl *) past->past_DeviceData;
	past->past_StopNow = 0;
	past->past_StopSoon = 0;
	past->past_IsActive = 1;
/* Create timer that will wake us up so we can fill the DSound buffer. */
	{
		int msecPerBuffer;
		int resolution;
		int bufsPerInterrupt = past->past_NumUserBuffers/4;
		if( bufsPerInterrupt < 1 ) bufsPerInterrupt = 1;
		msecPerBuffer = 1000 * (bufsPerInterrupt * past->past_FramesPerUserBuffer) / (int) past->past_SampleRate;
		if( msecPerBuffer < 10 ) msecPerBuffer = 10;
		else if( msecPerBuffer > 100 ) msecPerBuffer = 100;
		resolution = msecPerBuffer/4;
		pahsc->pahsc_TimerID = timeSetEvent( msecPerBuffer, resolution, (LPTIMECALLBACK) Pa_TimerCallback,
		(DWORD) past, TIME_PERIODIC );
	}
	if( pahsc->pahsc_TimerID == 0 )
	{
		past->past_IsActive = 0;
		result = paHostError;
		sPaHostError = 0;
		goto error;
	}
error:
	return result;
}
/*************************************************************************/
PaError PaHost_StopEngine( internalPortAudioStream *past, int abort )
{
	int timeoutMsec;
	PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
	if( pahsc == NULL ) return paNoError;
	if( abort ) past->past_StopNow = 1;
	past->past_StopSoon = 1;
/* Set timeout at 20% beyond maximum time we might wait. */
	timeoutMsec = (int) (1200.0 * pahsc->pahsc_FramesPerDSBuffer / past->past_SampleRate);
	while( past->past_IsActive && (timeoutMsec > 0)  )
	{
		Sleep(10);
		timeoutMsec -= 10;
	}
	if( pahsc->pahsc_TimerID != 0 )
	{
		timeKillEvent(pahsc->pahsc_TimerID);  /* Stop callback timer. */
		pahsc->pahsc_TimerID = 0;
	}
	return paNoError;
}
/*************************************************************************/
PaError PaHost_StopInput( internalPortAudioStream *past, int abort )
{
#if SUPPORT_AUDIO_CAPTURE
	HRESULT hr;
	PaHostSoundControl *pahsc = (PaHostSoundControl *) past->past_DeviceData;
	if( pahsc == NULL ) return paNoError;
	(void) abort;
	hr = DSW_StopInput( &pahsc->pahsc_DSoundWrapper );
	DBUG(("DSW_StopInput() result is %x\n", hr));
#endif /* SUPPORT_AUDIO_CAPTURE */
	return paNoError;
}
/*************************************************************************/
PaError PaHost_StopOutput( internalPortAudioStream *past, int abort )
{
	HRESULT hr;
	PaHostSoundControl *pahsc;
	pahsc = (PaHostSoundControl *) past->past_DeviceData;
	if( pahsc == NULL ) return paNoError;
	(void) abort;
	hr = DSW_StopOutput( &pahsc->pahsc_DSoundWrapper );
	DBUG(("DSW_StopOutput() result is %x\n", hr));
	return paNoError;
}
/*******************************************************************/
PaError PaHost_CloseStream( internalPortAudioStream   *past )
{
	PaHostSoundControl *pahsc;
	if( past == NULL ) return paBadStreamPtr;
	pahsc = (PaHostSoundControl *) past->past_DeviceData;
	if( pahsc == NULL ) return paNoError;
	DSW_Term( &pahsc->pahsc_DSoundWrapper );
	if( pahsc->pahsc_NativeBuffer )
	{
		PaHost_FreeFastMemory( pahsc->pahsc_NativeBuffer, pahsc->pahsc_BytesPerBuffer ); /* MEM */
		pahsc->pahsc_NativeBuffer = NULL;
	}
	PaHost_FreeFastMemory( pahsc, sizeof(PaHostSoundControl) ); /* MEM */
	past->past_DeviceData = NULL;
	return paNoError;
}
/*************************************************************************
** Determine minimum number of buffers required for this host based
** on minimum latency. Latency can be optionally set by user by setting
** an environment variable. For example, to set latency to 200 msec, put:
**
**    set PA_MIN_LATENCY_MSEC=200
**
** in the AUTOEXEC.BAT file and reboot.
** If the environment variable is not set, then the latency will be determined
** based on the OS. Windows NT has higher latency than Win95.
*/
#define PA_LATENCY_ENV_NAME  ("PA_MIN_LATENCY_MSEC")
int Pa_GetMinNumBuffers( int framesPerBuffer, double sampleRate )
{
	char      envbuf[PA_ENV_BUF_SIZE];
	DWORD     hostVersion;
	DWORD     hresult;
	int       minLatencyMsec = 0;
	double    msecPerBuffer = (1000.0 * framesPerBuffer) / sampleRate;
	int       minBuffers;
/* Let user determine minimal latency by setting environment variable. */
	hresult = GetEnvironmentVariable( PA_LATENCY_ENV_NAME, envbuf, PA_ENV_BUF_SIZE );
	if( (hresult > 0) && (hresult < PA_ENV_BUF_SIZE) )
	{
		minLatencyMsec = atoi( envbuf );
	}
	else
	{
/* Set minimal latency based on whether NT or Win95.
 * NT has higher latency.
 */
		hostVersion = GetVersion();
/* High bit clear if NT */
		minLatencyMsec = ( (hostVersion & 0x80000000) == 0 ) ? PA_WIN_NT_LATENCY : PA_WIN_9X_LATENCY  ;
#if PA_USE_HIGH_LATENCY
		PRINT(("PA - Minimum Latency set to %d msec!\n", minLatencyMsec ));
#endif
	}
	minBuffers = (int) (1.0 + ((double)minLatencyMsec / msecPerBuffer));
	if( minBuffers < 2 ) minBuffers = 2;
	return minBuffers;
}
/*************************************************************************/
PaError PaHost_Term( void )
{
	int i;
/* Free names allocated during enumeration. */
	for( i=0; i<sNumDevices; i++ )
	{
		if( sDevices[i].pad_Info.name != NULL )
		{
			free( (void *) sDevices[i].pad_Info.name );
			sDevices[i].pad_Info.name = NULL;
		}
	}
	if( sDevices != NULL )
	{
		PaHost_FreeFastMemory( sDevices, sNumDevices * sizeof(internalPortAudioDevice) ); /* MEM */
		sDevices = NULL;
		sNumDevices = 0;
	}
	return 0;
}
void Pa_Sleep( long msec )
{
	Sleep( msec );
}
/*************************************************************************
 * Allocate memory that can be accessed in real-time.
 * This may need to be held in physical memory so that it is not
 * paged to virtual memory.
 * This call MUST be balanced with a call to PaHost_FreeFastMemory().
 * Memory will be set to zero.
 */
void *PaHost_AllocateFastMemory( long numBytes )
{
	void *addr = GlobalAlloc( GPTR, numBytes ); /* FIXME - do we need physical memory? Use VirtualLock() */ /* MEM */
	return addr;
}
/*************************************************************************
 * Free memory that could be accessed in real-time.
 * This call MUST be balanced with a call to PaHost_AllocateFastMemory().
 */
void PaHost_FreeFastMemory( void *addr, long numBytes )
{
	if( addr != NULL ) GlobalFree( addr ); /* MEM */
}
/***********************************************************************/
PaError PaHost_StreamActive( internalPortAudioStream   *past )
{
	PaHostSoundControl *pahsc;
	if( past == NULL ) return paBadStreamPtr;
	pahsc = (PaHostSoundControl *) past->past_DeviceData;
	if( pahsc == NULL ) return paInternalError;
	return (PaError) (past->past_IsActive);
}
/*************************************************************************/
PaTimestamp Pa_StreamTime( PortAudioStream *stream )
{
	DSoundWrapper   *dsw;
	internalPortAudioStream   *past = (internalPortAudioStream *) stream;
	PaHostSoundControl *pahsc;
	if( past == NULL ) return paBadStreamPtr;
	pahsc = (PaHostSoundControl *) past->past_DeviceData;
	dsw = &pahsc->pahsc_DSoundWrapper;
	return dsw->dsw_FramesPlayed;
}
