itgmania212121/stepmania/src/arch/Sound/DSoundHelpers.cpp

#include "../../global.h"
#include "DSoundHelpers.h"
#include "../../RageUtil.h"
#include "../../RageLog.h"
#include "archutils/Win32/GetFileInformation.h"

#if defined(_WINDOWS)
#include <mmsystem.h>
#endif
#define DIRECTSOUND_VERSION 0x0700
#include <dsound.h>

#pragma comment(lib, "dsound.lib")

BOOL CALLBACK DSound::EnumCallback( LPGUID lpGuid, LPCSTR lpcstrDescription, LPCSTR lpcstrModule, LPVOID lpContext )
{
	CString sLine = ssprintf( "DirectSound Driver: %s", lpcstrDescription );
	if( lpcstrModule[0] )
	{
		sLine += ssprintf( " (%s", lpcstrModule );

#ifndef _XBOX
		CString sPath = FindSystemFile( lpcstrModule );
		if( sPath != "" )
		{
			CString ver;
			if( GetFileVersion( sPath, ver ) )
				sLine += ssprintf(" %s", ver.c_str());
		}
#endif

		sLine += ")";
	}

	LOG->Info( "%s", sLine.c_str() );

	return TRUE;
}

void DSound::SetPrimaryBufferMode()
{
#ifndef _XBOX
	DSBUFFERDESC format;
	memset( &format, 0, sizeof(format) );
	format.dwSize = sizeof(format);
	format.dwFlags = DSBCAPS_PRIMARYBUFFER;
	format.dwBufferBytes = 0;
	format.lpwfxFormat = NULL;

	IDirectSoundBuffer *buf;
	HRESULT hr = this->GetDS()->CreateSoundBuffer(&format, &buf, NULL);
	/* hr */
	if( FAILED(hr) )
	{
		LOG->Warn(hr_ssprintf(hr, "Couldn't create primary buffer"));
		return;
	}

    WAVEFORMATEX waveformat;
	memset( &waveformat, 0, sizeof(waveformat) );
    waveformat.cbSize = 0;
    waveformat.wFormatTag = WAVE_FORMAT_PCM;
	waveformat.wBitsPerSample = 16;
	waveformat.nChannels = 2;
	waveformat.nSamplesPerSec = 44100;
	waveformat.nBlockAlign = 4;
	waveformat.nAvgBytesPerSec = waveformat.nSamplesPerSec * waveformat.nBlockAlign;

	// Set the primary buffer's format
    hr = IDirectSoundBuffer_SetFormat( buf, &waveformat );
	if( FAILED(hr) )
		LOG->Warn( hr_ssprintf(hr, "SetFormat on primary buffer") );

	DWORD got;
	hr = buf->GetFormat( &waveformat, sizeof(waveformat), &got );
	if( FAILED(hr) )
		LOG->Warn( hr_ssprintf(hr, "GetFormat on primary buffer") );
	else if( waveformat.nSamplesPerSec != 44100 )
		LOG->Warn( "Primary buffer set to %i instead of 44100", waveformat.nSamplesPerSec );

	/* MS docs:
	 *
	 * When there are no sounds playing, DirectSound stops the mixer engine and halts DMA 
	 * (direct memory access) activity. If your application has frequent short intervals of
	 * silence, the overhead of starting and stopping the mixer each time a sound is played
	 * may be worse than the DMA overhead if you kept the mixer active. Also, some sound
	 * hardware or drivers may produce unwanted audible artifacts from frequent starting and
	 * stopping of playback. If your application is playing audio almost continuously with only
	 * short breaks of silence, you can force the mixer engine to remain active by calling the
	 * IDirectSoundBuffer::Play method for the primary buffer. The mixer will continue to run
	 * silently.
	 *
	 * However, I just added the above code and I don't want to change more until it's tested.
	 */
//	buf->Play(0, 0, DSBPLAY_LOOPING);

	buf->Release();
#endif
}

DSound::DSound()
{
	HRESULT hr;

#ifndef _XBOX
    // Initialize COM
    if( FAILED( hr = CoInitialize( NULL ) ) )
		RageException::ThrowNonfatal(hr_ssprintf(hr, "CoInitialize"));
#endif

    // Create IDirectSound using the primary sound device
    if( FAILED( hr = DirectSoundCreate( NULL, &ds, NULL ) ) )
		RageException::ThrowNonfatal(hr_ssprintf(hr, "DirectSoundCreate"));

#ifndef _XBOX
	static bool bShownInfo = false;
	if( !bShownInfo )
	{
		bShownInfo = true;
		DirectSoundEnumerate(EnumCallback, 0);

		DSCAPS Caps;
		Caps.dwSize = sizeof(Caps);
		HRESULT hr;
		if( FAILED(hr = ds->GetCaps(&Caps)) )
		{
			LOG->Warn( hr_ssprintf(hr, "ds->GetCaps failed") );
		}
		else
		{
			LOG->Info( "DirectSound sample rates: %i..%i %s", Caps.dwMinSecondarySampleRate, Caps.dwMaxSecondarySampleRate,
				(Caps.dwFlags & DSCAPS_CONTINUOUSRATE)?"(continuous)":"" );
		}
	}

	/* Try to set primary mixing privileges */
	hr = ds->SetCooperativeLevel( GetDesktopWindow(), DSSCL_PRIORITY );
#endif

	SetPrimaryBufferMode();
}

DSound::~DSound()
{
	ds->Release();
#ifndef _XBOX
    CoUninitialize();
#endif
}

bool DSound::IsEmulated() const
{
#ifndef _XBOX
	/* Don't bother wasting time trying to create buffers if we're
 	 * emulated.  This also gives us better diagnostic information. */
	DSCAPS Caps;
	Caps.dwSize = sizeof(Caps);
	HRESULT hr;
	if( FAILED(hr = ds->GetCaps(&Caps)) )
	{
		LOG->Warn( hr_ssprintf(hr, "ds->GetCaps failed") );
		/* This is strange, so let's be conservative. */
		return true;
	}

	return !!(Caps.dwFlags & DSCAPS_EMULDRIVER);
#else
	return false;
#endif
}

DSoundBuf::DSoundBuf( DSound &ds, DSoundBuf::hw hardware,
					  int channels_, int samplerate_, int samplebits_, int writeahead_ )
{
	channels = channels_;
	samplerate = samplerate_;
	samplebits = samplebits_;
	writeahead = writeahead_ * bytes_per_frame();
	volume = -1; /* unset */
	buffer_locked = false;
	last_cursor_pos = write_cursor = buffer_bytes_filled = 0;
	LastPosition = 0;
	playing = false;

	/* The size of the actual DSound buffer.  This can be large; we generally
	 * won't fill it completely. */
	buffersize = 1024*64;
	buffersize = max( buffersize, writeahead );

	WAVEFORMATEX waveformat;
	memset( &waveformat, 0, sizeof(waveformat) );
	waveformat.cbSize = 0;
	waveformat.wFormatTag = WAVE_FORMAT_PCM;

	bool NeedCtrlFrequency = false;
	if( samplerate == DYNAMIC_SAMPLERATE )
	{
		samplerate = 44100;
		NeedCtrlFrequency = true;
	}

	int bytes = samplebits/8;
	waveformat.wBitsPerSample = WORD(samplebits);
	waveformat.nChannels = WORD(channels);
	waveformat.nSamplesPerSec = DWORD(samplerate);
	waveformat.nBlockAlign = WORD(bytes*channels);
	waveformat.nAvgBytesPerSec = samplerate * bytes*channels;

	/* Try to create the secondary buffer */
	DSBUFFERDESC format;
	memset( &format, 0, sizeof(format) );
	format.dwSize = sizeof(format);
#ifdef _XBOX
	format.dwFlags = 0;
#else
	format.dwFlags = DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_GLOBALFOCUS | DSBCAPS_CTRLVOLUME;
#endif
	
#ifndef _XBOX
	/* Don't use DSBCAPS_STATIC.  It's meant for static buffers, and we
	 * only use streaming buffers. */
	if( hardware == HW_HARDWARE )
		format.dwFlags |= DSBCAPS_LOCHARDWARE;
	else
		format.dwFlags |= DSBCAPS_LOCSOFTWARE;
#endif

	if( NeedCtrlFrequency )
		format.dwFlags |= DSBCAPS_CTRLFREQUENCY;

	format.dwBufferBytes = buffersize;
#ifndef _XBOX
	format.dwReserved = 0;
#else
	DSMIXBINVOLUMEPAIR dsmbvp[8] =
	{
		{ DSMIXBIN_FRONT_LEFT,		DSBVOLUME_MAX}, // left channel
		{ DSMIXBIN_FRONT_RIGHT,		DSBVOLUME_MAX}, // right channel
		{ DSMIXBIN_FRONT_CENTER,	DSBVOLUME_MAX}, // left channel
		{ DSMIXBIN_FRONT_CENTER,	DSBVOLUME_MAX}, // right channel
		{ DSMIXBIN_BACK_LEFT,		DSBVOLUME_MAX}, // left channel
		{ DSMIXBIN_BACK_RIGHT,		DSBVOLUME_MAX}, // right channel
		{ DSMIXBIN_LOW_FREQUENCY,	DSBVOLUME_MAX}, // left channel
		{ DSMIXBIN_LOW_FREQUENCY,	DSBVOLUME_MAX}  // right channel
	};
	DSMIXBINS dsmb;
	dsmb.dwMixBinCount = 8;
	dsmb.lpMixBinVolumePairs = dsmbvp;

	format.lpMixBins			= &dsmb;
#endif

	format.lpwfxFormat = &waveformat;

	HRESULT hr = ds.GetDS()->CreateSoundBuffer( &format, &buf, NULL );
	if( FAILED(hr) )
		RageException::ThrowNonfatal( hr_ssprintf(hr, "CreateSoundBuffer failed") );

#ifndef _XBOX
	/* I'm not sure this should ever be needed, but ... */
	DSBCAPS bcaps;
	bcaps.dwSize=sizeof(bcaps);
	hr = buf->GetCaps(&bcaps);
	if( FAILED(hr) )
		RageException::Throw(hr_ssprintf(hr, "buf->GetCaps"));
	if( int(bcaps.dwBufferBytes) != buffersize )
	{
		LOG->Warn( "bcaps.dwBufferBytes (%i) != buffersize(%i); adjusting", bcaps.dwBufferBytes, buffersize );
		buffersize = bcaps.dwBufferBytes;
		writeahead = min( writeahead, buffersize );
	}

	if( !(bcaps.dwFlags & DSBCAPS_CTRLVOLUME) )
		LOG->Warn( "Sound channel missing DSBCAPS_CTRLVOLUME" );
	if( !(bcaps.dwFlags & DSBCAPS_GETCURRENTPOSITION2) )
		LOG->Warn( "Sound channel missing DSBCAPS_GETCURRENTPOSITION2" );

	DWORD got;
	hr = buf->GetFormat( &waveformat, sizeof(waveformat), &got );
	if( FAILED(hr) )
		LOG->Warn( hr_ssprintf(hr, "GetFormat on secondary buffer") );
	else if( (int) waveformat.nSamplesPerSec != samplerate )
		LOG->Warn( "Secondary buffer set to %i instead of %i", waveformat.nSamplesPerSec, samplerate );
#endif
}

void DSoundBuf::SetSampleRate(int hz)
{
	samplerate = hz;
	HRESULT hr = buf->SetFrequency( hz );
	if( FAILED(hr) )
		RageException::Throw( hr_ssprintf(hr, "buf->SetFrequency(%i)", hz) );
}

void DSoundBuf::SetVolume(float vol)
{
	ASSERT(vol >= 0);
	ASSERT(vol <= 1);
	
	if( vol == 0 )
		vol = 0.001f;		// fix log10f(0) == -INF
	float vl2 = log10f(vol) / log10f(2); /* vol log 2 */

	/* Volume is a multiplier; SetVolume wants attenuation in hundredths of a decibel. */
	const int new_volume = max( int(1000 * vl2), DSBVOLUME_MIN );

	if( volume == new_volume )
		return;

	HRESULT hr = buf->SetVolume( new_volume );
	if( FAILED(hr) )
	{
		static bool bWarned = false;
		if( !bWarned )
			LOG->Warn( hr_ssprintf(hr, "DirectSoundBuffer::SetVolume(%i) failed", volume) );
		bWarned = true;
		return;
	}

	volume = new_volume;
}

/* Determine if "pos" is between "start" and "end", for a circular buffer. */
static bool contained( int start, int end, int pos )
{
	if( end >= start ) /* start ... pos ... end */
		return start <= pos && pos <= end;
	else
		return pos >= start || pos <= end;
}

DSoundBuf::~DSoundBuf()
{
	buf->Release();
}

/* Figure out if we've underrun, and act if appropriate. */
void DSoundBuf::CheckUnderrun( int cursorstart, int cursorend, int chunksize )
{
	/* XXX We can figure out if we've underrun, and increase the write-ahead
	 * when it happens.  Two problems:
	 * 1. It's ugly to wait until we actually underrun. (We could store the
	 *    write-ahead, though.)
	 * 2. We don't want a random underrun (eg. virus scanner starts) to
	 *    permanently increase our write-ahead.  We want the smallest possible
	 *    that will give us reliable audio in normal conditions.  I'm not sure
	 *    of a robust way to do this.
	 *
	 * Also, writeahead should be a static (all buffers write ahead the same
	 * amount); writeahead in the ctor should be a hint only (initial value),
	 * and the sound driver should query a sound to get the current writeahead
	 * in GetLatencySeconds().
	 */

	/* If the buffer is full, we can't be underrunning. */
	if( buffer_bytes_filled >= buffersize )
		return;

	/* If nothing is expected to be filled, we can't underrun. */
	if( cursorstart == cursorend )
		return;

	/* If there's no data in the buffer at all, then we've completely underrun.  Our
	 * write cursor is irrelevant; we might be unrelated to the play position completely.
	 * Realign. */
	if( buffer_bytes_filled == 0 )
	{
		/* There's no data filled at all.  We've completely underrun. */
		/* XXX */

		int missed_by = cursorend - write_cursor;
		wrap( missed_by, buffersize );
		int first_byte_filled = write_cursor-buffer_bytes_filled;
		wrap( first_byte_filled, buffersize );

		LOG->Trace("major underrun: %i..%i filled but cursor at %i..%i (missed it by %i) %i/%i",
			first_byte_filled, write_cursor, cursorstart, cursorend,
			missed_by, buffer_bytes_filled, buffersize);

		write_cursor = cursorstart;
	}

	/*
	 * Invariant: the filled region now starts at the beginning of the play region.
	 * The "Update buffer_bytes_filled" logic, combined with the above empty buffer
	 * check, guarantees this.
	 *
	 * This is important, so let's consider all cases as of the start of get_output_buf:
	 *
	 * 1: ....ffff....pppp... (no overlap)
	 *   invalid: buffer_bytes_filled should have been set to 0.
	 *
	 * 2: ....ffff.... (overlap, filled is earlier)
	 *    ..pppp......
	 *   invalid: buffer_bytes_filled should have been set to 2, resulting in:
	 *    ......ff....
	 *    ...pppp.....
	 *
	 * 3: ......ffff.. (overlap, filled is later)
	 *    ....pppp....
	 *   invalid: This case can only happen if the play cursor has wrapped all the
	 *   way around, in which case buffer_bytes_filled should have been set to 0.
	 *
	 * 4: ....ffff.... valid
	 *    ....pppp....
	 * 5: ....ff...... valid
	 *    ....pppp....
	 * 6: ............ valid (no data filled)
	 *    ....pppp....
	 */
	int first_byte_filled = write_cursor-buffer_bytes_filled;
	wrap( first_byte_filled, buffersize );
	if( first_byte_filled != cursorstart )
	{
		LOG->Trace("%i..%i filled but cursor at %i..%i (%i max)",
			first_byte_filled, write_cursor, cursorstart, cursorend, buffer_bytes_filled );
		FAIL_M( "DSoundBuf::CheckUnderrun internal error" );
	}

	if( contained(first_byte_filled, write_cursor, cursorend) )
	{
		/* The end of the play cursor has data.  We haven't underrun (case #4). */
		return;
	}

	/* We've underrun.  Let's figure out whether, if we continue filling, we'll fill
	 * the buffer enough to stop underrunning.  This is a little ugly, since we need
	 * to simulate. */
	int fake_buffer_bytes_filled = buffer_bytes_filled;
	int fake_write_cursor = write_cursor;
	while(1)
	{
		if( fake_buffer_bytes_filled > writeahead )
			break;

		int num_bytes_empty = writeahead-fake_buffer_bytes_filled;
		if( num_bytes_empty < chunksize )
			break;

		num_bytes_empty = min(num_bytes_empty, buffersize - fake_write_cursor);
//		num_bytes_empty = min(num_bytes_empty, chunksize);

		fake_buffer_bytes_filled += num_bytes_empty;
		fake_write_cursor += num_bytes_empty;
		wrap( fake_write_cursor, buffersize );
	}

	LOG->Trace("write_cursor %i, fake_write_cursor %i, fake_buffer_bytes_filled %i",
		write_cursor, fake_write_cursor, fake_buffer_bytes_filled );

	bool bCanCatchUp = contained(first_byte_filled, fake_write_cursor, cursorend);
	/*
	 * If bCanCatchUp is false, then based on our writeahead and the chunksize, we'll
	 * never fill the buffer.  This isn't fuzzy; we simply aren't filling enough, and
	 * we need to increase the writeahead.
	 *
	 * If bCanCatchUp is true, we simply fell behind and we can catch up.  If this
	 * happens repeatedly, then while the writeahead is sufficient for the prefetch,
	 * the scheduler isn't keeping up, and we probably need to increase the writeahead.
	 *
	 * This is a tricky support issue.  We don't want to have to adjust the writeahead
	 * dynamically if we can help it, since that means we've already underrun.  It's
	 * much better to have a properly tuned writeahead for all systems to begin with.
	 * I'd much prefer to receive bug reports when the writeahead wasn't enough, so we
	 * can figure out the correct writeahead and use it by default.
	 *
	 * Also, unless we write the writeahead to a preference to keep it long-term (which
	 * I'm wary of doing), we'll go through this every game.
	 */
	if( bCanCatchUp )
	{
		/* If we simply continue, we'll catch up.  We'll probably have an audible
		 * glitch, but we can't prevent that.  However, we can probably avoid an
		 * arrow skip. */
		/* XXX: if this happens repeatedly over a period of time, increase writeahead */
		int missed_by = cursorend - write_cursor;
		wrap( missed_by, buffersize );
		LOG->Trace("minor underrun: %i..%i filled but cursor at %i..%i (missed it by %i) %i/%i",
			first_byte_filled, write_cursor, cursorstart, cursorend,
			missed_by, buffer_bytes_filled, buffersize);
		return;
	}

	/*
	 * Based on our writeahead and the chunksize, we'll never fill the buffer.  We
	 * need to increase the writeahead.
	 */

	int prefetch = cursorend - cursorstart;
	wrap( prefetch, buffersize );

	int old_writeahead = writeahead;
	writeahead = writeahead * 4 / 3;
	/* Snap to bytes_per_frame. */
	writeahead = (writeahead / bytes_per_frame()) * bytes_per_frame();
	writeahead = min( writeahead, buffersize );

	LOG->Trace("insufficient writeahead: wants %i (cursor at %i..%i), but we'll only fill to %i; writeahead adjusted from %i to %i",
		prefetch/bytes_per_frame(), cursorstart, cursorend,
		fake_buffer_bytes_filled/bytes_per_frame(), old_writeahead/bytes_per_frame(), writeahead/bytes_per_frame() );
}

bool DSoundBuf::get_output_buf( char **buffer, unsigned *bufsiz, int chunksize )
{
	ASSERT(!buffer_locked);

	chunksize *= bytes_per_frame();

	DWORD cursorstart, cursorend;

	HRESULT result;

	/* It's easiest to think of the cursor as a block, starting and ending at
	 * the two values returned by GetCurrentPosition, that we can't write to. */
	result = buf->GetCurrentPosition( &cursorstart, &cursorend );
#ifndef _XBOX
	if ( result == DSERR_BUFFERLOST )
	{
		buf->Restore();
		result = buf->GetCurrentPosition( &cursorstart, &cursorend );
	}
	if ( result != DS_OK )
	{
		LOG->Warn( hr_ssprintf(result, "DirectSound::GetCurrentPosition failed") );
		return false;
	}
#endif

	/* Some cards (Creative AudioPCI) have a no-write area even when not playing.  I'm not
	 * sure what that means, but it breaks the assumption that we can fill the whole writeahead
	 * when prebuffering. */
	if( !playing )
		cursorend = cursorstart;

	/* Update buffer_bytes_filled. */
	{
		int first_byte_filled = write_cursor-buffer_bytes_filled;
		wrap( first_byte_filled, buffersize );

		/* The number of bytes that have been played since the last time we got here: */
		int bytes_played = cursorstart - first_byte_filled;
		wrap( bytes_played, buffersize );

		buffer_bytes_filled -= bytes_played;
		buffer_bytes_filled = max( 0, buffer_bytes_filled );
	}

	CheckUnderrun( cursorstart, cursorend, chunksize );

	/* If we already have enough bytes written ahead, stop. */
	if( buffer_bytes_filled > writeahead )
		return false;

	int num_bytes_empty = writeahead-buffer_bytes_filled;

	/* num_bytes_empty is the amount of free buffer space.  If it's
	 * too small, come back later. */
	if( num_bytes_empty < chunksize )
		return false;

	/* I don't want to deal with DSound's split-circular-buffer locking stuff, so clamp
	 * the writing space at the end of the physical buffer. */
	num_bytes_empty = min(num_bytes_empty, buffersize - write_cursor);

	/* Don't fill more than one chunk at a time.  This reduces the maximum
	 * amount of time until we give data; that way, if we're short on time,
	 * we'll give some data soon instead of lots of data later. */
	/* Let's not do this; treat chunksize as a "min bytes to fill" above (so we're not
	 * constantly filling in a few frames at a time), but not "max bytes to fill".  This
	 * reduces cases where we don't fill the buffer as much as we should, and in practice
	 * makes the "increase the writeahead" logic work much better. */
//	num_bytes_empty = min(num_bytes_empty, chunksize);

//	LOG->Trace("gave %i at %i (%i, %i) %i filled", num_bytes_empty, write_cursor, cursor, write, buffer_bytes_filled);

	/* Lock the audio buffer. */
#ifdef _XBOX
	result = buf->Lock( write_cursor, num_bytes_empty, (LPVOID *)buffer, (DWORD *) bufsiz, NULL, NULL, 0 );
#else
	DWORD junk;
	result = buf->Lock( write_cursor, num_bytes_empty, (LPVOID *)buffer, (DWORD *) bufsiz, NULL, &junk, 0 );
#endif

#ifndef _XBOX
	if ( result == DSERR_BUFFERLOST )
	{
		buf->Restore();
		result = buf->Lock( write_cursor, num_bytes_empty, (LPVOID *)buffer, (DWORD *) bufsiz, NULL, &junk, 0 );
	}
#endif
	if ( result != DS_OK )
	{
		LOG->Warn( hr_ssprintf(result, "Couldn't lock the DirectSound buffer.") );
		return false;
	}

	write_cursor += num_bytes_empty;
	if( write_cursor >= buffersize )
		write_cursor -= buffersize;

	buffer_bytes_filled += num_bytes_empty;

	/* Increment last_cursor_pos to point at where the data we're about to
	 * ask for will actually be played. */
	last_cursor_pos += num_bytes_empty / bytes_per_frame();
	buffer_locked = true;

	return true;
}

void DSoundBuf::release_output_buf( char *buffer, unsigned bufsiz )
{
	buf->Unlock( buffer, bufsiz, NULL, 0 );
	buffer_locked = false;
}

int64_t DSoundBuf::GetPosition() const
{
	DWORD cursor, junk;
	buf->GetCurrentPosition( &cursor, &junk );
	int cursor_frames = int(cursor) / bytes_per_frame();
	int write_cursor_frames = write_cursor  / bytes_per_frame();

	int frames_behind = write_cursor_frames - cursor_frames;
	/* frames_behind will be 0 if we're called before the buffer starts playing:
	 * both write_cursor_frames and cursor_frames will be 0. */
	if( frames_behind < 0 )
		frames_behind += buffersize_frames(); /* unwrap */

	int64_t ret = last_cursor_pos - frames_behind;

	/* Failsafe: never return a value smaller than we've already returned.
	 * This can happen once in a while in underrun conditions. */
	ret = max( LastPosition, ret );
	LastPosition = ret;

	return ret;
}

void DSoundBuf::Play()
{
	if( playing )
		return;
	buf->Play( 0, 0, DSBPLAY_LOOPING );
	playing = true;
}

void DSoundBuf::Stop()
{
	if( !playing )
		return;

	buf->Stop();
	buf->SetCurrentPosition(0);

	last_cursor_pos = write_cursor = buffer_bytes_filled = 0;
	LastPosition = 0;

	/* When stopped and rewound, the play and write cursors should both be 0. */
	/* This isn't true on some broken cards. */
//	DWORD play, write;
//	buf->GetCurrentPosition( &play, &write );
//	ASSERT_M( play == 0 && write == 0, ssprintf("%i, %i", play, write) );

	playing = false;
}

/*
 * (c) 2002-2004 Glenn Maynard
 * All rights reserved.
 * 
 * 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, and/or sell copies of the Software, and to permit persons to
 * whom the Software is furnished to do so, provided that the above
 * copyright notice(s) and this permission notice appear in all copies of
 * the Software and that both the above copyright notice(s) and this
 * permission notice appear in supporting documentation.
 * 
 * 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 OF
 * THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
 * INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT
 * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */