Frodo4/Src/SID_WIN32.h

/*
 *  SID_WIN32.h - 6581 emulation, WIN32 specific stuff
 *
 *  Frodo (C) 1994-1997,2002-2005 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <dsound.h>

#include "VIC.h"
#include "main.h"

#define FRAG_FREQ SCREEN_FREQ                           // one frag per frame

#define FRAGMENT_SIZE (SAMPLE_FREQ/FRAG_FREQ)           // samples, not bytes
#define FRAG_INTERVAL (1000/FRAG_FREQ)                  // in milliseconds
#define BUFFER_FRAGS FRAG_FREQ                          // frags the in buffer
#define BUFFER_SIZE  (2*FRAGMENT_SIZE*BUFFER_FRAGS)     // bytes, not samples
#define MAX_LEAD_AVG BUFFER_FRAGS                       // lead average count

// This won't hurt DirectX 2 but it will help when using the DirectX 3 runtime.
#if !defined(DSBCAPS_GETCURRENTPOSITION2)
#define DSBCAPS_GETCURRENTPOSITION2 0x00010000
#endif

class DigitalPlayer {

public:
        virtual ~DigitalPlayer() = 0;
        virtual BOOL Ready() = 0;
        virtual int GetCurrentPosition() = 0;
        virtual void Write(void *buffer, int position, int length) = 0;
        virtual void Pause() = 0;
        virtual void Resume() = 0;
};

DigitalPlayer::~DigitalPlayer()
{
}

class DirectSound: public DigitalPlayer {

public:
        DirectSound();
        ~DirectSound();
        BOOL Ready();
        int GetCurrentPosition();
        void Write(void *buffer, int position, int length);
        void Pause();
        void Resume();

private:
        BOOL ready;
        LPDIRECTSOUND pDS;
        LPDIRECTSOUNDBUFFER pPrimaryBuffer;
        LPDIRECTSOUNDBUFFER pSoundBuffer;
};

class WaveOut: public DigitalPlayer {

public:
        WaveOut();
        ~WaveOut();
        BOOL Ready();
        int GetCurrentPosition();
        void Write(void *buffer, int position, int length);
        void Pause();
        void Resume();

private:
        void UnprepareHeader(int index);
        void UnprepareHeaders();

private:
        BOOL ready;
        HWAVEOUT hWaveOut;
        char wave_buffer[BUFFER_SIZE];
        WAVEHDR wave_header[SCREEN_FREQ];
        int last_unprepared;
};

void DigitalRenderer::init_sound()
{
        ready = FALSE;
        sound_buffer = new SWORD[2*FRAGMENT_SIZE];
        ThePlayer = 0;
        to_output = 0;
        divisor = 0;
        lead = new int[MAX_LEAD_AVG];

        StartPlayer();
}

DigitalRenderer::~DigitalRenderer()
{
        StopPlayer();

        delete[] sound_buffer;
        delete[] lead;
}

void DigitalRenderer::StartPlayer()
{
        direct_sound = ThePrefs.DirectSound;
        if (ThePrefs.DirectSound)
                ThePlayer = new DirectSound;
        else
                ThePlayer = new WaveOut;
        ready = ThePlayer->Ready();
        sb_pos = 0;
        memset(lead, 0, sizeof(lead));
        lead_pos = 0;
}

void DigitalRenderer::StopPlayer()
{
        delete ThePlayer;
        ready = FALSE;
}

void DigitalRenderer::EmulateLine()
{
        if (!ready)
                return;

        sample_buf[sample_in_ptr] = volume;
        sample_in_ptr = (sample_in_ptr + 1) % SAMPLE_BUF_SIZE;

#if 0
        // Now see how many samples have to be added for this line.
        // XXX: This is too much computation here, precompute it.
        divisor += SAMPLE_FREQ;
        while (divisor >= 0)
                divisor -= TOTAL_RASTERS*SCREEN_FREQ, to_output++;

        // Calculate the sound data only when we have enough to fill
        // the buffer entirely.
        if (to_output < FRAGMENT_SIZE)
                return;
        to_output -= FRAGMENT_SIZE;

        VBlank();
#endif
}

void DigitalRenderer::VBlank()
{
        if (!ready)
                return;

        // Delete and recreate the player if preferences have changed.
        if (direct_sound != ThePrefs.DirectSound) {
                StopPlayer();
                StartPlayer();
        }

        // Convert latency preferences from milliseconds to frags.
        int lead_smooth = ThePrefs.LatencyAvg/FRAG_INTERVAL;
        int lead_hiwater = ThePrefs.LatencyMax/FRAG_INTERVAL;
        int lead_lowater = ThePrefs.LatencyMin/FRAG_INTERVAL;

        // Compute the current lead in frags.
        int current_position = ThePlayer->GetCurrentPosition();
        if (current_position == -1)
                return;
        int lead_in_bytes = (sb_pos - current_position + BUFFER_SIZE) % BUFFER_SIZE;
        if (lead_in_bytes >= BUFFER_SIZE/2)
                lead_in_bytes -= BUFFER_SIZE;
        int lead_in_frags = lead_in_bytes / int(2*FRAGMENT_SIZE);
        lead[lead_pos++] = lead_in_frags;
        if (lead_pos == lead_smooth)
                lead_pos = 0;

        // Compute the average lead in frags.
        int avg_lead = 0;
        for (int i = 0; i < lead_smooth; i++)
                avg_lead += lead[i];
        avg_lead /= lead_smooth;
        //Debug("lead = %d, avg = %d\n", lead_in_frags, avg_lead);

        // If we're getting too far ahead of the audio skip a frag.
        if (avg_lead > lead_hiwater) {
                for (int i = 0; i < lead_smooth; i++)
                        lead[i]--;
                Debug("Skipping a frag...\n");
                return;
        }

        // Calculate one frag.
        int nsamples = FRAGMENT_SIZE;
        calc_buffer(sound_buffer, 2*FRAGMENT_SIZE);

        // If we're getting too far behind the audio add an extra frag.
        if (avg_lead < lead_lowater) {
                for (int i = 0; i < lead_smooth; i++)
                        lead[i]++;
                Debug("Adding an extra frag...\n");
                calc_buffer(sound_buffer + FRAGMENT_SIZE, 2*FRAGMENT_SIZE);
                nsamples += FRAGMENT_SIZE;
        }

        // Write the frags to the player and update out write position. 
        ThePlayer->Write(sound_buffer, sb_pos, 2*nsamples);
        sb_pos = (sb_pos + 2*nsamples) % BUFFER_SIZE;
}

void DigitalRenderer::Pause()
{
        if (!ready)
                return;
        ThePlayer->Pause();
}

void DigitalRenderer::Resume()
{
        if (!ready)
                return;
        ThePlayer->Resume();
}

// Direct sound implemenation.

DirectSound::DirectSound()
{
        ready = FALSE;
        pDS = NULL;
        pPrimaryBuffer = NULL;
        pSoundBuffer = NULL;

        HRESULT dsrval = DirectSoundCreate(NULL, &pDS, NULL);
        if (dsrval != DS_OK) {
                DebugResult("DirectSoundCreate failed", dsrval);
                return;
        }

        // Set cooperative level trying to get exclusive or normal mode.
        DWORD level = ThePrefs.ExclusiveSound ? DSSCL_EXCLUSIVE : DSSCL_NORMAL;
        dsrval = pDS->SetCooperativeLevel(hwnd, level);
        if (dsrval != DS_OK) {
                DebugResult("SetCooperativeLevel failed", dsrval);
                return;
        }

        WAVEFORMATEX wfx;
        memset(&wfx, 0, sizeof(wfx));
        wfx.wFormatTag = WAVE_FORMAT_PCM;
        wfx.nChannels = 1;
        wfx.nSamplesPerSec = 44100;
        wfx.wBitsPerSample = 16;
        wfx.nBlockAlign = wfx.nChannels*wfx.wBitsPerSample/8;
        wfx.nAvgBytesPerSec = wfx.nBlockAlign*wfx.nSamplesPerSec;
        wfx.cbSize = 0;

        DSBUFFERDESC dsbd;
        memset(&dsbd, 0, sizeof(dsbd));
        dsbd.dwSize = sizeof(dsbd);
        dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER;
        dsbd.dwBufferBytes = 0;
        dsbd.lpwfxFormat = NULL;

        dsrval = pDS->CreateSoundBuffer(&dsbd, &pPrimaryBuffer, NULL);
        if (dsrval != DS_OK) {
                DebugResult("CreateSoundBuffer for primary failed", dsrval);
                return;
        }

        dsrval = pPrimaryBuffer->SetFormat(&wfx);
        if (dsrval != DS_OK) {
                DebugResult("SetFormat on primary failed", dsrval);
                //return;
        }

        dsrval = pPrimaryBuffer->Play(0, 0, DSBPLAY_LOOPING);
        if (dsrval != DS_OK) {
                DebugResult("Play primary failed", dsrval);
                return;
        }

        dsbd.dwSize = sizeof(dsbd);
        dsbd.dwFlags = DSBCAPS_GETCURRENTPOSITION2;
        dsbd.dwBufferBytes = BUFFER_SIZE;
        dsbd.lpwfxFormat = &wfx;

        dsrval = pDS->CreateSoundBuffer(&dsbd, &pSoundBuffer, NULL);
        if (dsrval != DS_OK) {
                DebugResult("CreateSoundBuffer failed", dsrval);
                return;
        }

        ready = TRUE;
}

DirectSound::~DirectSound()
{
        if (pDS != NULL) {
                if (pSoundBuffer != NULL) {
                        pSoundBuffer->Release();
                        pSoundBuffer = NULL;
                }
                if (pPrimaryBuffer != NULL) {
                        pPrimaryBuffer->Release();
                        pPrimaryBuffer = NULL;
                }
                pDS->Release();
                pDS = NULL;
        }
}

BOOL DirectSound::Ready()
{
        return ready;
}

int DirectSound::GetCurrentPosition()
{
        DWORD dwPlayPos, dwWritePos;
        HRESULT dsrval = pSoundBuffer->GetCurrentPosition(&dwPlayPos, &dwWritePos);
        if (dsrval != DS_OK) {
                DebugResult("GetCurrentPostion failed", dsrval);
                return -1;
        }
        return dwWritePos;
}

void DirectSound::Write(void *buffer, int position, int length)
{
        // Lock sound buffer.
        LPVOID pMem1, pMem2;
        DWORD dwSize1, dwSize2;
        HRESULT dsrval = pSoundBuffer->Lock(position, length,
                &pMem1, &dwSize1, &pMem2, &dwSize2, 0);
        if (dsrval != DS_OK) {
                DebugResult("Sound Lock failed", dsrval);
                return;
        }

        // Copy the sample buffer into the sound buffer.
        BYTE *pSample = (BYTE *) buffer;
        memcpy(pMem1, pSample, dwSize1);
        if (dwSize2 != 0)
                memcpy(pMem2, pSample + dwSize1, dwSize2);

        // Unlock the sound buffer.
        dsrval = pSoundBuffer->Unlock(pMem1, dwSize1, pMem2, dwSize2);
        if (dsrval != DS_OK) {
                DebugResult("Unlock failed\n", dsrval);
                return;
        }

        // Play the sound buffer.
        dsrval = pSoundBuffer->Play(0, 0, DSBPLAY_LOOPING);
        if (dsrval != DS_OK) {
                DebugResult("Play failed", dsrval);
                return;
        }
}

void DirectSound::Pause()
{
        HRESULT dsrval = pSoundBuffer->Stop();
        if (dsrval != DS_OK)
                DebugResult("Stop failed", dsrval);
        dsrval = pPrimaryBuffer->Stop();
        if (dsrval != DS_OK)
                DebugResult("Stop primary failed", dsrval);
}

void DirectSound::Resume()
{
        HRESULT dsrval = pPrimaryBuffer->Play(0, 0, DSBPLAY_LOOPING);
        if (dsrval != DS_OK)
                DebugResult("Play primary failed", dsrval);
        dsrval = pSoundBuffer->Play(0, 0, DSBPLAY_LOOPING);
        if (dsrval != DS_OK)
                DebugResult("Play failed", dsrval);
}

// Wave output implemenation.

WaveOut::WaveOut()
{
        ready = FALSE;

        WAVEFORMATEX wfx;
        memset(&wfx, 0, sizeof(wfx));
        wfx.wFormatTag = WAVE_FORMAT_PCM;
        wfx.nChannels = 1;
        wfx.nSamplesPerSec = 44100;
        wfx.wBitsPerSample = 16;
        wfx.nBlockAlign = wfx.nChannels*wfx.wBitsPerSample/8;
        wfx.nAvgBytesPerSec = wfx.nBlockAlign*wfx.nSamplesPerSec;
        wfx.cbSize = 0;
        MMRESULT worval = waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, 0);
        if (worval != MMSYSERR_NOERROR) {
                Debug("waveOutOpen returned %d\n", worval);
                return;
        }
        memset(wave_header, 0, sizeof(wave_header));

        last_unprepared = 0;

        ready = TRUE;
}

WaveOut::~WaveOut()
{
        waveOutReset(hWaveOut);
        UnprepareHeaders();
        waveOutClose(hWaveOut);
}

BOOL WaveOut::Ready()
{
        return ready;
}

int WaveOut::GetCurrentPosition()
{
        MMTIME mmtime;
        memset(&mmtime, 0, sizeof(mmtime));
        mmtime.wType = TIME_BYTES;
        MMRESULT worval = waveOutGetPosition(hWaveOut, &mmtime, sizeof(mmtime));
        if (worval != MMSYSERR_NOERROR) {
                Debug("waveOutGetPosition(%d) returned %d\n", worval);
                return -1;
        }
        int current_position = mmtime.u.cb % BUFFER_SIZE;
        return current_position;
}

void WaveOut::Write(void *buffer, int position, int length)
{
        // If we are called for a double length buffer split it in half.
        if (length == 4*FRAGMENT_SIZE) {
                int half = length/2;
                Write(buffer, position, half);
                Write(((char *) buffer) + half, position + half, half);
                return;
        }

        // Free up as many previous frags as possible.
        for (;;) {
                WAVEHDR &wh = wave_header[last_unprepared];
                if (!(wh.dwFlags & WHDR_DONE))
                        break;
                UnprepareHeader(last_unprepared);
                last_unprepared++;
                if (last_unprepared == BUFFER_FRAGS)
                        last_unprepared = 0;
        }

        // Make sure the current header isn't in use.
        int index = position/(2*FRAGMENT_SIZE);
        WAVEHDR &wh = wave_header[index];
        if (wh.dwFlags & WHDR_DONE)
                UnprepareHeader(index);
        if (wh.dwFlags != 0) {
                Debug("wave header %d is in use!\n", index);
                return;
        }
        
        // Prepare the header and write the sound data.
        wh.lpData = wave_buffer + position;
        wh.dwBufferLength = length;
        wh.dwFlags = 0;
        memcpy(wh.lpData, buffer, length);
        MMRESULT worval = waveOutPrepareHeader(hWaveOut, &wh, sizeof(wh));
        if (worval != MMSYSERR_NOERROR) {
                Debug("waveOutPrepareHeader(%d) returned %d\n", index, worval);
                return;
        }
        worval = waveOutWrite(hWaveOut, &wh, sizeof(wh));
        if (worval != MMSYSERR_NOERROR) {
                Debug("waveOutWrite(%d) returned %d\n", index, worval);
                return;
        }
}

void WaveOut::Pause()
{
        waveOutPause(hWaveOut);
}

void WaveOut::Resume()
{
        waveOutRestart(hWaveOut);
}

void WaveOut::UnprepareHeader(int index)
{
        WAVEHDR &wh = wave_header[index];
        MMRESULT worval = waveOutUnprepareHeader(hWaveOut, &wh, sizeof(wh));
        if (worval != MMSYSERR_NOERROR) {
                Debug("waveOutUnprepareHeader(%d) returned %d\n", index, worval);
                return;
        }
        memset(&wh, 0, sizeof(wh));
}

void WaveOut::UnprepareHeaders()
{
        for (int i = 0; i < BUFFER_FRAGS; i++) {
                WAVEHDR &wh = wave_header[i];
                if (wh.dwFlags & WHDR_DONE)
                        UnprepareHeader(i);
        }
}

#if 0

// Log player implemenation.

void Log::Write()
{
        // Dump the sound output to the log for debugging.
        {
                int last = sound_buffer[0];
                int count = 1;
                for (int i = 1; i < nsamples; i++) {
                        if (sound_buffer[i] == last) {
                                count++;
                                continue;
                        }
                        Debug("[%dx%d] ", count, last);
                        count = 1;
                        last = sound_buffer[i];
                }
                Debug("[%dx%d] ", count, last);
        }
}

#endif

#if 0

// File player implemenation.

void Log::Write()
{
        // Log the sound output to a file for debugging.
        {
                static FILE *ofp = NULL;
                if (ofp == NULL) {
                        ofp = fopen("debug.sid", "wb");
                        if (ofp == NULL)
                                Debug("fopen failed\n");
                }
                if (ofp != NULL) {
                        Debug("Write sound data to file\n");
                        if (fwrite(sound_buffer, 1, 2*nsamples, ofp) != 2*nsamples)
                                Debug("fwrite failed\n");
                }
        }
}

#endif
Revision:	1.4
Committed:	2005-06-27T19:55:48Z (19 years, 4 months ago) by cebix
Content type:	text/plain
Branch:	MAIN
CVS Tags:	VERSION_4_2, HEAD
Changes since 1.3:	+1 -1 lines
Log Message:	updated copyright dates
#	Content
1	/*
2	* SID_WIN32.h - 6581 emulation, WIN32 specific stuff
3	*
4	* Frodo (C) 1994-1997,2002-2005 Christian Bauer
5	*
6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/
20
21	#include <dsound.h>
22
23	#include "VIC.h"
24	#include "main.h"
25
26	#define FRAG_FREQ SCREEN_FREQ // one frag per frame
27
28	#define FRAGMENT_SIZE (SAMPLE_FREQ/FRAG_FREQ) // samples, not bytes
29	#define FRAG_INTERVAL (1000/FRAG_FREQ) // in milliseconds
30	#define BUFFER_FRAGS FRAG_FREQ // frags the in buffer
31	#define BUFFER_SIZE (2FRAGMENT_SIZEBUFFER_FRAGS) // bytes, not samples
32	#define MAX_LEAD_AVG BUFFER_FRAGS // lead average count
33
34	// This won't hurt DirectX 2 but it will help when using the DirectX 3 runtime.
35	#if !defined(DSBCAPS_GETCURRENTPOSITION2)
36	#define DSBCAPS_GETCURRENTPOSITION2 0x00010000
37	#endif
38
39	class DigitalPlayer {
40
41	public:
42	virtual ~DigitalPlayer() = 0;
43	virtual BOOL Ready() = 0;
44	virtual int GetCurrentPosition() = 0;
45	virtual void Write(void *buffer, int position, int length) = 0;
46	virtual void Pause() = 0;
47	virtual void Resume() = 0;
48	};
49
50	DigitalPlayer::~DigitalPlayer()
51	{
52	}
53
54	class DirectSound: public DigitalPlayer {
55
56	public:
57	DirectSound();
58	~DirectSound();
59	BOOL Ready();
60	int GetCurrentPosition();
61	void Write(void *buffer, int position, int length);
62	void Pause();
63	void Resume();
64
65	private:
66	BOOL ready;
67	LPDIRECTSOUND pDS;
68	LPDIRECTSOUNDBUFFER pPrimaryBuffer;
69	LPDIRECTSOUNDBUFFER pSoundBuffer;
70	};
71
72	class WaveOut: public DigitalPlayer {
73
74	public:
75	WaveOut();
76	~WaveOut();
77	BOOL Ready();
78	int GetCurrentPosition();
79	void Write(void *buffer, int position, int length);
80	void Pause();
81	void Resume();
82
83	private:
84	void UnprepareHeader(int index);
85	void UnprepareHeaders();
86
87	private:
88	BOOL ready;
89	HWAVEOUT hWaveOut;
90	char wave_buffer[BUFFER_SIZE];
91	WAVEHDR wave_header[SCREEN_FREQ];
92	int last_unprepared;
93	};
94
95	void DigitalRenderer::init_sound()
96	{
97	ready = FALSE;
98	sound_buffer = new SWORD[2*FRAGMENT_SIZE];
99	ThePlayer = 0;
100	to_output = 0;
101	divisor = 0;
102	lead = new int[MAX_LEAD_AVG];
103
104	StartPlayer();
105	}
106
107	DigitalRenderer::~DigitalRenderer()
108	{
109	StopPlayer();
110
111	delete[] sound_buffer;
112	delete[] lead;
113	}
114
115	void DigitalRenderer::StartPlayer()
116	{
117	direct_sound = ThePrefs.DirectSound;
118	if (ThePrefs.DirectSound)
119	ThePlayer = new DirectSound;
120	else
121	ThePlayer = new WaveOut;
122	ready = ThePlayer->Ready();
123	sb_pos = 0;
124	memset(lead, 0, sizeof(lead));
125	lead_pos = 0;
126	}
127
128	void DigitalRenderer::StopPlayer()
129	{
130	delete ThePlayer;
131	ready = FALSE;
132	}
133
134	void DigitalRenderer::EmulateLine()
135	{
136	if (!ready)
137	return;
138
139	sample_buf[sample_in_ptr] = volume;
140	sample_in_ptr = (sample_in_ptr + 1) % SAMPLE_BUF_SIZE;
141
142	#if 0
143	// Now see how many samples have to be added for this line.
144	// XXX: This is too much computation here, precompute it.
145	divisor += SAMPLE_FREQ;
146	while (divisor >= 0)
147	divisor -= TOTAL_RASTERS*SCREEN_FREQ, to_output++;
148
149	// Calculate the sound data only when we have enough to fill
150	// the buffer entirely.
151	if (to_output < FRAGMENT_SIZE)
152	return;
153	to_output -= FRAGMENT_SIZE;
154
155	VBlank();
156	#endif
157	}
158
159	void DigitalRenderer::VBlank()
160	{
161	if (!ready)
162	return;
163
164	// Delete and recreate the player if preferences have changed.
165	if (direct_sound != ThePrefs.DirectSound) {
166	StopPlayer();
167	StartPlayer();
168	}
169
170	// Convert latency preferences from milliseconds to frags.
171	int lead_smooth = ThePrefs.LatencyAvg/FRAG_INTERVAL;
172	int lead_hiwater = ThePrefs.LatencyMax/FRAG_INTERVAL;
173	int lead_lowater = ThePrefs.LatencyMin/FRAG_INTERVAL;
174
175	// Compute the current lead in frags.
176	int current_position = ThePlayer->GetCurrentPosition();
177	if (current_position == -1)
178	return;
179	int lead_in_bytes = (sb_pos - current_position + BUFFER_SIZE) % BUFFER_SIZE;
180	if (lead_in_bytes >= BUFFER_SIZE/2)
181	lead_in_bytes -= BUFFER_SIZE;
182	int lead_in_frags = lead_in_bytes / int(2*FRAGMENT_SIZE);
183	lead[lead_pos++] = lead_in_frags;
184	if (lead_pos == lead_smooth)
185	lead_pos = 0;
186
187	// Compute the average lead in frags.
188	int avg_lead = 0;
189	for (int i = 0; i < lead_smooth; i++)
190	avg_lead += lead[i];
191	avg_lead /= lead_smooth;
192	//Debug("lead = %d, avg = %d\n", lead_in_frags, avg_lead);
193
194	// If we're getting too far ahead of the audio skip a frag.
195	if (avg_lead > lead_hiwater) {
196	for (int i = 0; i < lead_smooth; i++)
197	lead[i]--;
198	Debug("Skipping a frag...\n");
199	return;
200	}
201
202	// Calculate one frag.
203	int nsamples = FRAGMENT_SIZE;
204	calc_buffer(sound_buffer, 2*FRAGMENT_SIZE);
205
206	// If we're getting too far behind the audio add an extra frag.
207	if (avg_lead < lead_lowater) {
208	for (int i = 0; i < lead_smooth; i++)
209	lead[i]++;
210	Debug("Adding an extra frag...\n");
211	calc_buffer(sound_buffer + FRAGMENT_SIZE, 2*FRAGMENT_SIZE);
212	nsamples += FRAGMENT_SIZE;
213	}
214
215	// Write the frags to the player and update out write position.
216	ThePlayer->Write(sound_buffer, sb_pos, 2*nsamples);
217	sb_pos = (sb_pos + 2*nsamples) % BUFFER_SIZE;
218	}
219
220	void DigitalRenderer::Pause()
221	{
222	if (!ready)
223	return;
224	ThePlayer->Pause();
225	}
226
227	void DigitalRenderer::Resume()
228	{
229	if (!ready)
230	return;
231	ThePlayer->Resume();
232	}
233
234	// Direct sound implemenation.
235
236	DirectSound::DirectSound()
237	{
238	ready = FALSE;
239	pDS = NULL;
240	pPrimaryBuffer = NULL;
241	pSoundBuffer = NULL;
242
243	HRESULT dsrval = DirectSoundCreate(NULL, &pDS, NULL);
244	if (dsrval != DS_OK) {
245	DebugResult("DirectSoundCreate failed", dsrval);
246	return;
247	}
248
249	// Set cooperative level trying to get exclusive or normal mode.
250	DWORD level = ThePrefs.ExclusiveSound ? DSSCL_EXCLUSIVE : DSSCL_NORMAL;
251	dsrval = pDS->SetCooperativeLevel(hwnd, level);
252	if (dsrval != DS_OK) {
253	DebugResult("SetCooperativeLevel failed", dsrval);
254	return;
255	}
256
257	WAVEFORMATEX wfx;
258	memset(&wfx, 0, sizeof(wfx));
259	wfx.wFormatTag = WAVE_FORMAT_PCM;
260	wfx.nChannels = 1;
261	wfx.nSamplesPerSec = 44100;
262	wfx.wBitsPerSample = 16;
263	wfx.nBlockAlign = wfx.nChannels*wfx.wBitsPerSample/8;
264	wfx.nAvgBytesPerSec = wfx.nBlockAlign*wfx.nSamplesPerSec;
265	wfx.cbSize = 0;
266
267	DSBUFFERDESC dsbd;
268	memset(&dsbd, 0, sizeof(dsbd));
269	dsbd.dwSize = sizeof(dsbd);
270	dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER;
271	dsbd.dwBufferBytes = 0;
272	dsbd.lpwfxFormat = NULL;
273
274	dsrval = pDS->CreateSoundBuffer(&dsbd, &pPrimaryBuffer, NULL);
275	if (dsrval != DS_OK) {
276	DebugResult("CreateSoundBuffer for primary failed", dsrval);
277	return;
278	}
279
280	dsrval = pPrimaryBuffer->SetFormat(&wfx);
281	if (dsrval != DS_OK) {
282	DebugResult("SetFormat on primary failed", dsrval);
283	//return;
284	}
285
286	dsrval = pPrimaryBuffer->Play(0, 0, DSBPLAY_LOOPING);
287	if (dsrval != DS_OK) {
288	DebugResult("Play primary failed", dsrval);
289	return;
290	}
291
292	dsbd.dwSize = sizeof(dsbd);
293	dsbd.dwFlags = DSBCAPS_GETCURRENTPOSITION2;
294	dsbd.dwBufferBytes = BUFFER_SIZE;
295	dsbd.lpwfxFormat = &wfx;
296
297	dsrval = pDS->CreateSoundBuffer(&dsbd, &pSoundBuffer, NULL);
298	if (dsrval != DS_OK) {
299	DebugResult("CreateSoundBuffer failed", dsrval);
300	return;
301	}
302
303	ready = TRUE;
304	}
305
306	DirectSound::~DirectSound()
307	{
308	if (pDS != NULL) {
309	if (pSoundBuffer != NULL) {
310	pSoundBuffer->Release();
311	pSoundBuffer = NULL;
312	}
313	if (pPrimaryBuffer != NULL) {
314	pPrimaryBuffer->Release();
315	pPrimaryBuffer = NULL;
316	}
317	pDS->Release();
318	pDS = NULL;
319	}
320	}
321
322	BOOL DirectSound::Ready()
323	{
324	return ready;
325	}
326
327	int DirectSound::GetCurrentPosition()
328	{
329	DWORD dwPlayPos, dwWritePos;
330	HRESULT dsrval = pSoundBuffer->GetCurrentPosition(&dwPlayPos, &dwWritePos);
331	if (dsrval != DS_OK) {
332	DebugResult("GetCurrentPostion failed", dsrval);
333	return -1;
334	}
335	return dwWritePos;
336	}
337
338	void DirectSound::Write(void *buffer, int position, int length)
339	{
340	// Lock sound buffer.
341	LPVOID pMem1, pMem2;
342	DWORD dwSize1, dwSize2;
343	HRESULT dsrval = pSoundBuffer->Lock(position, length,
344	&pMem1, &dwSize1, &pMem2, &dwSize2, 0);
345	if (dsrval != DS_OK) {
346	DebugResult("Sound Lock failed", dsrval);
347	return;
348	}
349
350	// Copy the sample buffer into the sound buffer.
351	BYTE pSample = (BYTE ) buffer;
352	memcpy(pMem1, pSample, dwSize1);
353	if (dwSize2 != 0)
354	memcpy(pMem2, pSample + dwSize1, dwSize2);
355
356	// Unlock the sound buffer.
357	dsrval = pSoundBuffer->Unlock(pMem1, dwSize1, pMem2, dwSize2);
358	if (dsrval != DS_OK) {
359	DebugResult("Unlock failed\n", dsrval);
360	return;
361	}
362
363	// Play the sound buffer.
364	dsrval = pSoundBuffer->Play(0, 0, DSBPLAY_LOOPING);
365	if (dsrval != DS_OK) {
366	DebugResult("Play failed", dsrval);
367	return;
368	}
369	}
370
371	void DirectSound::Pause()
372	{
373	HRESULT dsrval = pSoundBuffer->Stop();
374	if (dsrval != DS_OK)
375	DebugResult("Stop failed", dsrval);
376	dsrval = pPrimaryBuffer->Stop();
377	if (dsrval != DS_OK)
378	DebugResult("Stop primary failed", dsrval);
379	}
380
381	void DirectSound::Resume()
382	{
383	HRESULT dsrval = pPrimaryBuffer->Play(0, 0, DSBPLAY_LOOPING);
384	if (dsrval != DS_OK)
385	DebugResult("Play primary failed", dsrval);
386	dsrval = pSoundBuffer->Play(0, 0, DSBPLAY_LOOPING);
387	if (dsrval != DS_OK)
388	DebugResult("Play failed", dsrval);
389	}
390
391	// Wave output implemenation.
392
393	WaveOut::WaveOut()
394	{
395	ready = FALSE;
396
397	WAVEFORMATEX wfx;
398	memset(&wfx, 0, sizeof(wfx));
399	wfx.wFormatTag = WAVE_FORMAT_PCM;
400	wfx.nChannels = 1;
401	wfx.nSamplesPerSec = 44100;
402	wfx.wBitsPerSample = 16;
403	wfx.nBlockAlign = wfx.nChannels*wfx.wBitsPerSample/8;
404	wfx.nAvgBytesPerSec = wfx.nBlockAlign*wfx.nSamplesPerSec;
405	wfx.cbSize = 0;
406	MMRESULT worval = waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, 0);
407	if (worval != MMSYSERR_NOERROR) {
408	Debug("waveOutOpen returned %d\n", worval);
409	return;
410	}
411	memset(wave_header, 0, sizeof(wave_header));
412
413	last_unprepared = 0;
414
415	ready = TRUE;
416	}
417
418	WaveOut::~WaveOut()
419	{
420	waveOutReset(hWaveOut);
421	UnprepareHeaders();
422	waveOutClose(hWaveOut);
423	}
424
425	BOOL WaveOut::Ready()
426	{
427	return ready;
428	}
429
430	int WaveOut::GetCurrentPosition()
431	{
432	MMTIME mmtime;
433	memset(&mmtime, 0, sizeof(mmtime));
434	mmtime.wType = TIME_BYTES;
435	MMRESULT worval = waveOutGetPosition(hWaveOut, &mmtime, sizeof(mmtime));
436	if (worval != MMSYSERR_NOERROR) {
437	Debug("waveOutGetPosition(%d) returned %d\n", worval);
438	return -1;
439	}
440	int current_position = mmtime.u.cb % BUFFER_SIZE;
441	return current_position;
442	}
443
444	void WaveOut::Write(void *buffer, int position, int length)
445	{
446	// If we are called for a double length buffer split it in half.
447	if (length == 4*FRAGMENT_SIZE) {
448	int half = length/2;
449	Write(buffer, position, half);
450	Write(((char *) buffer) + half, position + half, half);
451	return;
452	}
453
454	// Free up as many previous frags as possible.
455	for (;;) {
456	WAVEHDR &wh = wave_header[last_unprepared];
457	if (!(wh.dwFlags & WHDR_DONE))
458	break;
459	UnprepareHeader(last_unprepared);
460	last_unprepared++;
461	if (last_unprepared == BUFFER_FRAGS)
462	last_unprepared = 0;
463	}
464
465	// Make sure the current header isn't in use.
466	int index = position/(2*FRAGMENT_SIZE);
467	WAVEHDR &wh = wave_header[index];
468	if (wh.dwFlags & WHDR_DONE)
469	UnprepareHeader(index);
470	if (wh.dwFlags != 0) {
471	Debug("wave header %d is in use!\n", index);
472	return;
473	}
474
475	// Prepare the header and write the sound data.
476	wh.lpData = wave_buffer + position;
477	wh.dwBufferLength = length;
478	wh.dwFlags = 0;
479	memcpy(wh.lpData, buffer, length);
480	MMRESULT worval = waveOutPrepareHeader(hWaveOut, &wh, sizeof(wh));
481	if (worval != MMSYSERR_NOERROR) {
482	Debug("waveOutPrepareHeader(%d) returned %d\n", index, worval);
483	return;
484	}
485	worval = waveOutWrite(hWaveOut, &wh, sizeof(wh));
486	if (worval != MMSYSERR_NOERROR) {
487	Debug("waveOutWrite(%d) returned %d\n", index, worval);
488	return;
489	}
490	}
491
492	void WaveOut::Pause()
493	{
494	waveOutPause(hWaveOut);
495	}
496
497	void WaveOut::Resume()
498	{
499	waveOutRestart(hWaveOut);
500	}
501
502	void WaveOut::UnprepareHeader(int index)
503	{
504	WAVEHDR &wh = wave_header[index];
505	MMRESULT worval = waveOutUnprepareHeader(hWaveOut, &wh, sizeof(wh));
506	if (worval != MMSYSERR_NOERROR) {
507	Debug("waveOutUnprepareHeader(%d) returned %d\n", index, worval);
508	return;
509	}
510	memset(&wh, 0, sizeof(wh));
511	}
512
513	void WaveOut::UnprepareHeaders()
514	{
515	for (int i = 0; i < BUFFER_FRAGS; i++) {
516	WAVEHDR &wh = wave_header[i];
517	if (wh.dwFlags & WHDR_DONE)
518	UnprepareHeader(i);
519	}
520	}
521
522	#if 0
523
524	// Log player implemenation.
525
526	void Log::Write()
527	{
528	// Dump the sound output to the log for debugging.
529	{
530	int last = sound_buffer[0];
531	int count = 1;
532	for (int i = 1; i < nsamples; i++) {
533	if (sound_buffer[i] == last) {
534	count++;
535	continue;
536	}
537	Debug("[%dx%d] ", count, last);
538	count = 1;
539	last = sound_buffer[i];
540	}
541	Debug("[%dx%d] ", count, last);
542	}
543	}
544
545	#endif
546
547	#if 0
548
549	// File player implemenation.
550
551	void Log::Write()
552	{
553	// Log the sound output to a file for debugging.
554	{
555	static FILE *ofp = NULL;
556	if (ofp == NULL) {
557	ofp = fopen("debug.sid", "wb");
558	if (ofp == NULL)
559	Debug("fopen failed\n");
560	}
561	if (ofp != NULL) {
562	Debug("Write sound data to file\n");
563	if (fwrite(sound_buffer, 1, 2nsamples, ofp) != 2nsamples)
564	Debug("fwrite failed\n");
565	}
566	}
567	}
568
569	#endif