This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_dibaudio.c
336 lines (288 loc) · 8.6 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2006 Sam Lantinga
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
11
12
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
13
Lesser General Public License for more details.
14
15
16
17
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
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
/* Allow access to a raw mixing buffer */
26
27
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
28
29
30
#include <mmsystem.h>
#include "SDL_timer.h"
31
#include "SDL_audio.h"
32
#include "../SDL_audio_c.h"
33
#include "SDL_dibaudio.h"
34
35
36
#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
#include "win_ce_semaphore.h"
#endif
37
38
39
/* Audio driver functions */
40
static int DIB_OpenAudio(_THIS, SDL_AudioSpec * spec);
41
42
43
44
45
46
47
48
49
static void DIB_ThreadInit(_THIS);
static void DIB_WaitAudio(_THIS);
static Uint8 *DIB_GetAudioBuf(_THIS);
static void DIB_PlayAudio(_THIS);
static void DIB_WaitDone(_THIS);
static void DIB_CloseAudio(_THIS);
/* Audio driver bootstrap functions */
50
51
static int
Audio_Available(void)
52
{
53
return (1);
54
55
}
56
57
static void
Audio_DeleteDevice(SDL_AudioDevice * device)
58
{
59
60
SDL_free(device->hidden);
SDL_free(device);
61
62
}
63
64
static SDL_AudioDevice *
Audio_CreateDevice(int devindex)
65
{
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
SDL_AudioDevice *this;
/* 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 = DIB_OpenAudio;
this->ThreadInit = DIB_ThreadInit;
this->WaitAudio = DIB_WaitAudio;
this->PlayAudio = DIB_PlayAudio;
this->GetAudioBuf = DIB_GetAudioBuf;
this->WaitDone = DIB_WaitDone;
this->CloseAudio = DIB_CloseAudio;
this->free = Audio_DeleteDevice;
return this;
96
97
98
}
AudioBootStrap WAVEOUT_bootstrap = {
99
100
"waveout", "Win95/98/NT/2000 WaveOut",
Audio_Available, Audio_CreateDevice
101
102
103
104
};
/* The Win32 callback for filling the WAVE device */
105
106
107
static void CALLBACK
FillSound(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance,
DWORD dwParam1, DWORD dwParam2)
108
{
109
SDL_AudioDevice *this = (SDL_AudioDevice *) dwInstance;
110
111
112
113
/* Only service "buffer done playing" messages */
if (uMsg != WOM_DONE)
return;
114
115
/* Signal that we are done playing a buffer */
116
#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
117
ReleaseSemaphoreCE(audio_sem, 1, NULL);
118
#else
119
ReleaseSemaphore(audio_sem, 1, NULL);
120
#endif
121
122
}
123
124
static void
SetMMerror(char *function, MMRESULT code)
125
{
126
127
size_t len;
char errbuf[MAXERRORLENGTH];
128
#ifdef _WIN32_WCE
129
wchar_t werrbuf[MAXERRORLENGTH];
130
#endif
131
132
133
SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: ", function);
len = SDL_strlen(errbuf);
134
135
#ifdef _WIN32_WCE
136
137
138
139
/* UNICODE version */
waveOutGetErrorText(code, werrbuf, MAXERRORLENGTH - len);
WideCharToMultiByte(CP_ACP, 0, werrbuf, -1, errbuf + len,
MAXERRORLENGTH - len, NULL, NULL);
140
#else
141
waveOutGetErrorText(code, errbuf + len, (UINT) (MAXERRORLENGTH - len));
142
143
#endif
144
SDL_SetError("%s", errbuf);
145
146
147
}
/* Set high priority for the audio thread */
148
149
static void
DIB_ThreadInit(_THIS)
150
{
151
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
152
153
}
154
155
void
DIB_WaitAudio(_THIS)
156
{
157
/* Wait for an audio chunk to finish */
158
#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
159
WaitForSemaphoreCE(audio_sem, INFINITE);
160
#else
161
WaitForSingleObject(audio_sem, INFINITE);
162
#endif
163
164
}
165
166
Uint8 *
DIB_GetAudioBuf(_THIS)
167
{
168
Uint8 *retval;
169
170
171
retval = (Uint8 *) (wavebuf[next_buffer].lpData);
return retval;
172
173
}
174
175
void
DIB_PlayAudio(_THIS)
176
{
177
178
179
/* Queue it up */
waveOutWrite(sound, &wavebuf[next_buffer], sizeof(wavebuf[0]));
next_buffer = (next_buffer + 1) % NUM_BUFFERS;
180
181
}
182
183
void
DIB_WaitDone(_THIS)
184
{
185
186
187
188
189
190
191
192
193
194
195
196
197
198
int i, left;
do {
left = NUM_BUFFERS;
for (i = 0; i < NUM_BUFFERS; ++i) {
if (wavebuf[i].dwFlags & WHDR_DONE) {
--left;
}
}
if (left > 0) {
SDL_Delay(100);
}
}
while (left > 0);
199
200
}
201
202
void
DIB_CloseAudio(_THIS)
203
{
204
int i;
205
206
207
/* Close up audio */
if (audio_sem) {
208
#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
209
CloseSynchHandle(audio_sem);
210
#else
211
CloseHandle(audio_sem);
212
#endif
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
}
if (sound) {
waveOutClose(sound);
}
/* Clean up mixing buffers */
for (i = 0; i < NUM_BUFFERS; ++i) {
if (wavebuf[i].dwUser != 0xFFFF) {
waveOutUnprepareHeader(sound, &wavebuf[i], sizeof(wavebuf[i]));
wavebuf[i].dwUser = 0xFFFF;
}
}
/* Free raw mixing buffer */
if (mixbuf != NULL) {
SDL_free(mixbuf);
mixbuf = NULL;
}
230
231
}
232
233
int
DIB_OpenAudio(_THIS, SDL_AudioSpec * spec)
234
{
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
MMRESULT result;
int i;
WAVEFORMATEX waveformat;
/* Initialize the wavebuf structures for closing */
sound = NULL;
audio_sem = NULL;
for (i = 0; i < NUM_BUFFERS; ++i)
wavebuf[i].dwUser = 0xFFFF;
mixbuf = NULL;
/* 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;
waveformat.wBitsPerSample = 8;
break;
case 16:
/* Signed 16 bit audio data */
spec->format = AUDIO_S16;
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;
/* Check the buffer size -- minimum of 1/4 second (word aligned) */
if (spec->samples < (spec->freq / 4))
spec->samples = ((spec->freq / 4) + 3) & ~3;
/* Update the fragment size as size in bytes */
SDL_CalculateAudioSpec(spec);
/* Open the audio device */
result = waveOutOpen(&sound, WAVE_MAPPER, &waveformat,
(DWORD_PTR) FillSound, (DWORD_PTR) this,
CALLBACK_FUNCTION);
if (result != MMSYSERR_NOERROR) {
SetMMerror("waveOutOpen()", result);
return (-1);
}
288
#ifdef SOUND_DEBUG
289
290
291
292
293
294
295
296
297
298
299
/* Check the sound device we retrieved */
{
WAVEOUTCAPS caps;
result = waveOutGetDevCaps((UINT) sound, &caps, sizeof(caps));
if (result != MMSYSERR_NOERROR) {
SetMMerror("waveOutGetDevCaps()", result);
return (-1);
}
printf("Audio device: %s\n", caps.szPname);
}
300
301
#endif
302
/* Create the audio buffer semaphore */
303
#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
304
audio_sem = CreateSemaphoreCE(NULL, NUM_BUFFERS - 1, NUM_BUFFERS, NULL);
305
#else
306
audio_sem = CreateSemaphore(NULL, NUM_BUFFERS - 1, NUM_BUFFERS, NULL);
307
#endif
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
if (audio_sem == NULL) {
SDL_SetError("Couldn't create semaphore");
return (-1);
}
/* Create the sound buffers */
mixbuf = (Uint8 *) SDL_malloc(NUM_BUFFERS * spec->size);
if (mixbuf == NULL) {
SDL_SetError("Out of memory");
return (-1);
}
for (i = 0; i < NUM_BUFFERS; ++i) {
SDL_memset(&wavebuf[i], 0, sizeof(wavebuf[i]));
wavebuf[i].lpData = (LPSTR) & mixbuf[i * spec->size];
wavebuf[i].dwBufferLength = spec->size;
wavebuf[i].dwFlags = WHDR_DONE;
result = waveOutPrepareHeader(sound, &wavebuf[i], sizeof(wavebuf[i]));
if (result != MMSYSERR_NOERROR) {
SetMMerror("waveOutPrepareHeader()", result);
return (-1);
}
}
/* Ready to go! */
next_buffer = 0;
return (0);
334
}
335
336
/* vi: set ts=4 sw=4 expandtab: */