Mercurial > sdl-ios-xcode

comparison src/audio/windib/SDL_dibaudio.c @ 1662:782fd950bd46 SDL-1.3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Revamp of the video system in progress - adding support for multiple displays, multiple windows, and a full video mode selection API. WARNING: None of the video drivers have been updated for the new API yet! The API is still under design and very fluid. The code is now run through a consistent indent format: indent -i4 -nut -nsc -br -ce The headers are being converted to automatically generate doxygen documentation.
author Sam Lantinga <slouken@libsdl.org>
date Sun, 28 May 2006 13:04:16 +0000
parents 84de7511f79f
children 4da1ee79c9af
comparison
equal deleted inserted replaced
1661:281d3f4870e5 1662:782fd950bd46
35 #include "win_ce_semaphore.h" 35 #include "win_ce_semaphore.h"
36 #endif 36 #endif
37 37
38 38
39 /* Audio driver functions */ 39 /* Audio driver functions */
40 static int DIB_OpenAudio(_THIS, SDL_AudioSpec *spec); 40 static int DIB_OpenAudio (_THIS, SDL_AudioSpec * spec);
41 static void DIB_ThreadInit(_THIS); 41 static void DIB_ThreadInit (_THIS);
42 static void DIB_WaitAudio(_THIS); 42 static void DIB_WaitAudio (_THIS);
43 static Uint8 *DIB_GetAudioBuf(_THIS); 43 static Uint8 *DIB_GetAudioBuf (_THIS);
44 static void DIB_PlayAudio(_THIS); 44 static void DIB_PlayAudio (_THIS);
45 static void DIB_WaitDone(_THIS); 45 static void DIB_WaitDone (_THIS);
46 static void DIB_CloseAudio(_THIS); 46 static void DIB_CloseAudio (_THIS);
47 47
48 /* Audio driver bootstrap functions */ 48 /* Audio driver bootstrap functions */
49 49
50 static int Audio_Available(void) 50 static int
51 { 51 Audio_Available (void)
52 return(1); 52 {
53 } 53 return (1);
54 54 }
55 static void Audio_DeleteDevice(SDL_AudioDevice *device) 55
56 { 56 static void
57 SDL_free(device->hidden); 57 Audio_DeleteDevice (SDL_AudioDevice * device)
58 SDL_free(device); 58 {
59 } 59 SDL_free (device->hidden);
60 60 SDL_free (device);
61 static SDL_AudioDevice *Audio_CreateDevice(int devindex) 61 }
62 { 62
63 SDL_AudioDevice *this; 63 static SDL_AudioDevice *
64 64 Audio_CreateDevice (int devindex)
65 /* Initialize all variables that we clean on shutdown */ 65 {
66 this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice)); 66 SDL_AudioDevice *this;
67 if ( this ) { 67
68 SDL_memset(this, 0, (sizeof *this)); 68 /* Initialize all variables that we clean on shutdown */
69 this->hidden = (struct SDL_PrivateAudioData *) 69 this = (SDL_AudioDevice *) SDL_malloc (sizeof (SDL_AudioDevice));
70 SDL_malloc((sizeof *this->hidden)); 70 if (this) {
71 } 71 SDL_memset (this, 0, (sizeof *this));
72 if ( (this == NULL) || (this->hidden == NULL) ) { 72 this->hidden = (struct SDL_PrivateAudioData *)
73 SDL_OutOfMemory(); 73 SDL_malloc ((sizeof *this->hidden));
74 if ( this ) { 74 }
75 SDL_free(this); 75 if ((this == NULL) || (this->hidden == NULL)) {
76 } 76 SDL_OutOfMemory ();
77 return(0); 77 if (this) {
78 } 78 SDL_free (this);
79 SDL_memset(this->hidden, 0, (sizeof *this->hidden)); 79 }
80 80 return (0);
81 /* Set the function pointers */ 81 }
82 this->OpenAudio = DIB_OpenAudio; 82 SDL_memset (this->hidden, 0, (sizeof *this->hidden));
83 this->ThreadInit = DIB_ThreadInit; 83
84 this->WaitAudio = DIB_WaitAudio; 84 /* Set the function pointers */
85 this->PlayAudio = DIB_PlayAudio; 85 this->OpenAudio = DIB_OpenAudio;
86 this->GetAudioBuf = DIB_GetAudioBuf; 86 this->ThreadInit = DIB_ThreadInit;
87 this->WaitDone = DIB_WaitDone; 87 this->WaitAudio = DIB_WaitAudio;
88 this->CloseAudio = DIB_CloseAudio; 88 this->PlayAudio = DIB_PlayAudio;
89 89 this->GetAudioBuf = DIB_GetAudioBuf;
90 this->free = Audio_DeleteDevice; 90 this->WaitDone = DIB_WaitDone;
91 91 this->CloseAudio = DIB_CloseAudio;
92 return this; 92
93 this->free = Audio_DeleteDevice;
94
95 return this;
93 } 96 }
94 97
95 AudioBootStrap WAVEOUT_bootstrap = { 98 AudioBootStrap WAVEOUT_bootstrap = {
96 "waveout", "Win95/98/NT/2000 WaveOut", 99 "waveout", "Win95/98/NT/2000 WaveOut",
97 Audio_Available, Audio_CreateDevice 100 Audio_Available, Audio_CreateDevice
98 }; 101 };
99 102
100 103
101 /* The Win32 callback for filling the WAVE device */ 104 /* The Win32 callback for filling the WAVE device */
102 static void CALLBACK FillSound(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance, 105 static void CALLBACK
103 DWORD dwParam1, DWORD dwParam2) 106 FillSound (HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance,
104 { 107 DWORD dwParam1, DWORD dwParam2)
105 SDL_AudioDevice *this = (SDL_AudioDevice *)dwInstance; 108 {
106 109 SDL_AudioDevice *this = (SDL_AudioDevice *) dwInstance;
107 /* Only service "buffer done playing" messages */ 110
108 if ( uMsg != WOM_DONE ) 111 /* Only service "buffer done playing" messages */
109 return; 112 if (uMsg != WOM_DONE)
110 113 return;
111 /* Signal that we are done playing a buffer */ 114
112 #if defined(_WIN32_WCE) && (_WIN32_WCE < 300) 115 /* Signal that we are done playing a buffer */
113 ReleaseSemaphoreCE(audio_sem, 1, NULL); 116 #if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
114 #else 117 ReleaseSemaphoreCE (audio_sem, 1, NULL);
115 ReleaseSemaphore(audio_sem, 1, NULL); 118 #else
116 #endif 119 ReleaseSemaphore (audio_sem, 1, NULL);
117 } 120 #endif
118 121 }
119 static void SetMMerror(char *function, MMRESULT code) 122
120 { 123 static void
121 size_t len; 124 SetMMerror (char *function, MMRESULT code)
122 char errbuf[MAXERRORLENGTH]; 125 {
126 size_t len;
127 char errbuf[MAXERRORLENGTH];
123 #ifdef _WIN32_WCE 128 #ifdef _WIN32_WCE
124 wchar_t werrbuf[MAXERRORLENGTH]; 129 wchar_t werrbuf[MAXERRORLENGTH];
125 #endif 130 #endif
126 131
127 SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: ", function); 132 SDL_snprintf (errbuf, SDL_arraysize (errbuf), "%s: ", function);
128 len = SDL_strlen(errbuf); 133 len = SDL_strlen (errbuf);
129 134
130 #ifdef _WIN32_WCE 135 #ifdef _WIN32_WCE
131 /* UNICODE version */ 136 /* UNICODE version */
132 waveOutGetErrorText(code, werrbuf, MAXERRORLENGTH-len); 137 waveOutGetErrorText (code, werrbuf, MAXERRORLENGTH - len);
133 WideCharToMultiByte(CP_ACP,0,werrbuf,-1,errbuf+len,MAXERRORLENGTH-len,NULL,NULL); 138 WideCharToMultiByte (CP_ACP, 0, werrbuf, -1, errbuf + len,
134 #else 139 MAXERRORLENGTH - len, NULL, NULL);
135 waveOutGetErrorText(code, errbuf+len, (UINT)(MAXERRORLENGTH-len)); 140 #else
136 #endif 141 waveOutGetErrorText (code, errbuf + len, (UINT) (MAXERRORLENGTH - len));
137 142 #endif
138 SDL_SetError("%s",errbuf); 143
144 SDL_SetError ("%s", errbuf);
139 } 145 }
140 146
141 /* Set high priority for the audio thread */ 147 /* Set high priority for the audio thread */
142 static void DIB_ThreadInit(_THIS) 148 static void
143 { 149 DIB_ThreadInit (_THIS)
144 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST); 150 {
145 } 151 SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_HIGHEST);
146 152 }
147 void DIB_WaitAudio(_THIS) 153
148 { 154 void
149 /* Wait for an audio chunk to finish */ 155 DIB_WaitAudio (_THIS)
150 #if defined(_WIN32_WCE) && (_WIN32_WCE < 300) 156 {
151 WaitForSemaphoreCE(audio_sem, INFINITE); 157 /* Wait for an audio chunk to finish */
152 #else 158 #if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
153 WaitForSingleObject(audio_sem, INFINITE); 159 WaitForSemaphoreCE (audio_sem, INFINITE);
154 #endif 160 #else
155 } 161 WaitForSingleObject (audio_sem, INFINITE);
156 162 #endif
157 Uint8 *DIB_GetAudioBuf(_THIS) 163 }
158 { 164
159 Uint8 *retval; 165 Uint8 *
160 166 DIB_GetAudioBuf (_THIS)
161 retval = (Uint8 *)(wavebuf[next_buffer].lpData); 167 {
162 return retval; 168 Uint8 *retval;
163 } 169
164 170 retval = (Uint8 *) (wavebuf[next_buffer].lpData);
165 void DIB_PlayAudio(_THIS) 171 return retval;
166 { 172 }
167 /* Queue it up */ 173
168 waveOutWrite(sound, &wavebuf[next_buffer], sizeof(wavebuf[0])); 174 void
169 next_buffer = (next_buffer+1)%NUM_BUFFERS; 175 DIB_PlayAudio (_THIS)
170 } 176 {
171 177 /* Queue it up */
172 void DIB_WaitDone(_THIS) 178 waveOutWrite (sound, &wavebuf[next_buffer], sizeof (wavebuf[0]));
173 { 179 next_buffer = (next_buffer + 1) % NUM_BUFFERS;
174 int i, left; 180 }
175 181
176 do { 182 void
177 left = NUM_BUFFERS; 183 DIB_WaitDone (_THIS)
178 for ( i=0; i<NUM_BUFFERS; ++i ) { 184 {
179 if ( wavebuf[i].dwFlags & WHDR_DONE ) { 185 int i, left;
180 --left; 186
181 } 187 do {
182 } 188 left = NUM_BUFFERS;
183 if ( left > 0 ) { 189 for (i = 0; i < NUM_BUFFERS; ++i) {
184 SDL_Delay(100); 190 if (wavebuf[i].dwFlags & WHDR_DONE) {
185 } 191 --left;
186 } while ( left > 0 ); 192 }
187 } 193 }
188 194 if (left > 0) {
189 void DIB_CloseAudio(_THIS) 195 SDL_Delay (100);
190 { 196 }
191 int i; 197 }
192 198 while (left > 0);
193 /* Close up audio */ 199 }
194 if ( audio_sem ) { 200
195 #if defined(_WIN32_WCE) && (_WIN32_WCE < 300) 201 void
196 CloseSynchHandle(audio_sem); 202 DIB_CloseAudio (_THIS)
197 #else 203 {
198 CloseHandle(audio_sem); 204 int i;
199 #endif 205
200 } 206 /* Close up audio */
201 if ( sound ) { 207 if (audio_sem) {
202 waveOutClose(sound); 208 #if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
203 } 209 CloseSynchHandle (audio_sem);
204 210 #else
205 /* Clean up mixing buffers */ 211 CloseHandle (audio_sem);
206 for ( i=0; i<NUM_BUFFERS; ++i ) { 212 #endif
207 if ( wavebuf[i].dwUser != 0xFFFF ) { 213 }
208 waveOutUnprepareHeader(sound, &wavebuf[i], 214 if (sound) {
209 sizeof(wavebuf[i])); 215 waveOutClose (sound);
210 wavebuf[i].dwUser = 0xFFFF; 216 }
211 } 217
212 } 218 /* Clean up mixing buffers */
213 /* Free raw mixing buffer */ 219 for (i = 0; i < NUM_BUFFERS; ++i) {
214 if ( mixbuf != NULL ) { 220 if (wavebuf[i].dwUser != 0xFFFF) {
215 SDL_free(mixbuf); 221 waveOutUnprepareHeader (sound, &wavebuf[i], sizeof (wavebuf[i]));
216 mixbuf = NULL; 222 wavebuf[i].dwUser = 0xFFFF;
217 } 223 }
218 } 224 }
219 225 /* Free raw mixing buffer */
220 int DIB_OpenAudio(_THIS, SDL_AudioSpec *spec) 226 if (mixbuf != NULL) {
221 { 227 SDL_free (mixbuf);
222 MMRESULT result; 228 mixbuf = NULL;
223 int i; 229 }
224 WAVEFORMATEX waveformat; 230 }
225 231
226 /* Initialize the wavebuf structures for closing */ 232 int
227 sound = NULL; 233 DIB_OpenAudio (_THIS, SDL_AudioSpec * spec)
228 audio_sem = NULL; 234 {
229 for ( i = 0; i < NUM_BUFFERS; ++i ) 235 MMRESULT result;
230 wavebuf[i].dwUser = 0xFFFF; 236 int i;
231 mixbuf = NULL; 237 WAVEFORMATEX waveformat;
232 238
233 /* Set basic WAVE format parameters */ 239 /* Initialize the wavebuf structures for closing */
234 SDL_memset(&waveformat, 0, sizeof(waveformat)); 240 sound = NULL;
235 waveformat.wFormatTag = WAVE_FORMAT_PCM; 241 audio_sem = NULL;
236 242 for (i = 0; i < NUM_BUFFERS; ++i)
237 /* Determine the audio parameters from the AudioSpec */ 243 wavebuf[i].dwUser = 0xFFFF;
238 switch ( spec->format & 0xFF ) { 244 mixbuf = NULL;
239 case 8: 245
240 /* Unsigned 8 bit audio data */ 246 /* Set basic WAVE format parameters */
241 spec->format = AUDIO_U8; 247 SDL_memset (&waveformat, 0, sizeof (waveformat));
242 waveformat.wBitsPerSample = 8; 248 waveformat.wFormatTag = WAVE_FORMAT_PCM;
243 break; 249
244 case 16: 250 /* Determine the audio parameters from the AudioSpec */
245 /* Signed 16 bit audio data */ 251 switch (spec->format & 0xFF) {
246 spec->format = AUDIO_S16; 252 case 8:
247 waveformat.wBitsPerSample = 16; 253 /* Unsigned 8 bit audio data */
248 break; 254 spec->format = AUDIO_U8;
249 default: 255 waveformat.wBitsPerSample = 8;
250 SDL_SetError("Unsupported audio format"); 256 break;
251 return(-1); 257 case 16:
252 } 258 /* Signed 16 bit audio data */
253 waveformat.nChannels = spec->channels; 259 spec->format = AUDIO_S16;
254 waveformat.nSamplesPerSec = spec->freq; 260 waveformat.wBitsPerSample = 16;
255 waveformat.nBlockAlign = 261 break;
256 waveformat.nChannels * (waveformat.wBitsPerSample/8); 262 default:
257 waveformat.nAvgBytesPerSec = 263 SDL_SetError ("Unsupported audio format");
258 waveformat.nSamplesPerSec * waveformat.nBlockAlign; 264 return (-1);
259 265 }
260 /* Check the buffer size -- minimum of 1/4 second (word aligned) */ 266 waveformat.nChannels = spec->channels;
261 if ( spec->samples < (spec->freq/4) ) 267 waveformat.nSamplesPerSec = spec->freq;
262 spec->samples = ((spec->freq/4)+3)&~3; 268 waveformat.nBlockAlign =
263 269 waveformat.nChannels * (waveformat.wBitsPerSample / 8);
264 /* Update the fragment size as size in bytes */ 270 waveformat.nAvgBytesPerSec =
265 SDL_CalculateAudioSpec(spec); 271 waveformat.nSamplesPerSec * waveformat.nBlockAlign;
266 272
267 /* Open the audio device */ 273 /* Check the buffer size -- minimum of 1/4 second (word aligned) */
268 result = waveOutOpen(&sound, WAVE_MAPPER, &waveformat, 274 if (spec->samples < (spec->freq / 4))
269 (DWORD_PTR)FillSound, (DWORD_PTR)this, CALLBACK_FUNCTION); 275 spec->samples = ((spec->freq / 4) + 3) & ~3;
270 if ( result != MMSYSERR_NOERROR ) { 276
271 SetMMerror("waveOutOpen()", result); 277 /* Update the fragment size as size in bytes */
272 return(-1); 278 SDL_CalculateAudioSpec (spec);
273 } 279
274 280 /* Open the audio device */
281 result = waveOutOpen (&sound, WAVE_MAPPER, &waveformat,
282 (DWORD_PTR) FillSound, (DWORD_PTR) this,
283 CALLBACK_FUNCTION);
284 if (result != MMSYSERR_NOERROR) {
285 SetMMerror ("waveOutOpen()", result);
286 return (-1);
287 }
275 #ifdef SOUND_DEBUG 288 #ifdef SOUND_DEBUG
276 /* Check the sound device we retrieved */ 289 /* Check the sound device we retrieved */
277 { 290 {
278 WAVEOUTCAPS caps; 291 WAVEOUTCAPS caps;
279 292
280 result = waveOutGetDevCaps((UINT)sound, &caps, sizeof(caps)); 293 result = waveOutGetDevCaps ((UINT) sound, &caps, sizeof (caps));
281 if ( result != MMSYSERR_NOERROR ) { 294 if (result != MMSYSERR_NOERROR) {
282 SetMMerror("waveOutGetDevCaps()", result); 295 SetMMerror ("waveOutGetDevCaps()", result);
283 return(-1); 296 return (-1);
284 } 297 }
285 printf("Audio device: %s\n", caps.szPname); 298 printf ("Audio device: %s\n", caps.szPname);
286 } 299 }
287 #endif 300 #endif
288 301
289 /* Create the audio buffer semaphore */ 302 /* Create the audio buffer semaphore */
290 #if defined(_WIN32_WCE) && (_WIN32_WCE < 300) 303 #if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
291 audio_sem = CreateSemaphoreCE(NULL, NUM_BUFFERS-1, NUM_BUFFERS, NULL); 304 audio_sem = CreateSemaphoreCE (NULL, NUM_BUFFERS - 1, NUM_BUFFERS, NULL);
292 #else 305 #else
293 audio_sem = CreateSemaphore(NULL, NUM_BUFFERS-1, NUM_BUFFERS, NULL); 306 audio_sem = CreateSemaphore (NULL, NUM_BUFFERS - 1, NUM_BUFFERS, NULL);
294 #endif 307 #endif
295 if ( audio_sem == NULL ) { 308 if (audio_sem == NULL) {
296 SDL_SetError("Couldn't create semaphore"); 309 SDL_SetError ("Couldn't create semaphore");
297 return(-1); 310 return (-1);
298 } 311 }
299 312
300 /* Create the sound buffers */ 313 /* Create the sound buffers */
301 mixbuf = (Uint8 *)SDL_malloc(NUM_BUFFERS*spec->size); 314 mixbuf = (Uint8 *) SDL_malloc (NUM_BUFFERS * spec->size);
302 if ( mixbuf == NULL ) { 315 if (mixbuf == NULL) {
303 SDL_SetError("Out of memory"); 316 SDL_SetError ("Out of memory");
304 return(-1); 317 return (-1);
305 } 318 }
306 for ( i = 0; i < NUM_BUFFERS; ++i ) { 319 for (i = 0; i < NUM_BUFFERS; ++i) {
307 SDL_memset(&wavebuf[i], 0, sizeof(wavebuf[i])); 320 SDL_memset (&wavebuf[i], 0, sizeof (wavebuf[i]));
308 wavebuf[i].lpData = (LPSTR) &mixbuf[i*spec->size]; 321 wavebuf[i].lpData = (LPSTR) & mixbuf[i * spec->size];
309 wavebuf[i].dwBufferLength = spec->size; 322 wavebuf[i].dwBufferLength = spec->size;
310 wavebuf[i].dwFlags = WHDR_DONE; 323 wavebuf[i].dwFlags = WHDR_DONE;
311 result = waveOutPrepareHeader(sound, &wavebuf[i], 324 result = waveOutPrepareHeader (sound, &wavebuf[i],
312 sizeof(wavebuf[i])); 325 sizeof (wavebuf[i]));
313 if ( result != MMSYSERR_NOERROR ) { 326 if (result != MMSYSERR_NOERROR) {
314 SetMMerror("waveOutPrepareHeader()", result); 327 SetMMerror ("waveOutPrepareHeader()", result);
315 return(-1); 328 return (-1);
316 } 329 }
317 } 330 }
318 331
319 /* Ready to go! */ 332 /* Ready to go! */
320 next_buffer = 0; 333 next_buffer = 0;
321 return(0); 334 return (0);
322 } 335 }
336
337 /* vi: set ts=4 sw=4 expandtab: */