diff options
Diffstat (limited to 'apps/plugins/sdl/src/audio/mme/SDL_mmeaudio.c')
-rw-r--r-- | apps/plugins/sdl/src/audio/mme/SDL_mmeaudio.c | 264 |
1 files changed, 0 insertions, 264 deletions
diff --git a/apps/plugins/sdl/src/audio/mme/SDL_mmeaudio.c b/apps/plugins/sdl/src/audio/mme/SDL_mmeaudio.c deleted file mode 100644 index 64a0ecc36d..0000000000 --- a/apps/plugins/sdl/src/audio/mme/SDL_mmeaudio.c +++ /dev/null | |||
@@ -1,264 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Library General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Library General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Library General Public | ||
16 | License along with this library; if not, write to the Free | ||
17 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | /* Tru64 UNIX MME support */ | ||
25 | #include <mme_api.h> | ||
26 | |||
27 | #include "SDL_timer.h" | ||
28 | #include "SDL_audio.h" | ||
29 | #include "../SDL_audio_c.h" | ||
30 | #include "SDL_mmeaudio.h" | ||
31 | |||
32 | static BOOL inUse[NUM_BUFFERS]; | ||
33 | |||
34 | /* Audio driver functions */ | ||
35 | static int MME_OpenAudio(_THIS, SDL_AudioSpec *spec); | ||
36 | static void MME_WaitAudio(_THIS); | ||
37 | static Uint8 *MME_GetAudioBuf(_THIS); | ||
38 | static void MME_PlayAudio(_THIS); | ||
39 | static void MME_WaitDone(_THIS); | ||
40 | static void MME_CloseAudio(_THIS); | ||
41 | |||
42 | /* Audio driver bootstrap functions */ | ||
43 | static int Audio_Available(void) | ||
44 | { | ||
45 | return(1); | ||
46 | } | ||
47 | |||
48 | static void Audio_DeleteDevice(SDL_AudioDevice *device) | ||
49 | { | ||
50 | if ( device ) { | ||
51 | if ( device->hidden ) { | ||
52 | SDL_free(device->hidden); | ||
53 | device->hidden = NULL; | ||
54 | } | ||
55 | SDL_free(device); | ||
56 | device = NULL; | ||
57 | } | ||
58 | } | ||
59 | |||
60 | static SDL_AudioDevice *Audio_CreateDevice(int devindex) | ||
61 | { | ||
62 | SDL_AudioDevice *this; | ||
63 | |||
64 | /* Initialize all variables that we clean on shutdown */ | ||
65 | this = SDL_malloc(sizeof(SDL_AudioDevice)); | ||
66 | if ( this ) { | ||
67 | SDL_memset(this, 0, (sizeof *this)); | ||
68 | this->hidden = SDL_malloc((sizeof *this->hidden)); | ||
69 | } | ||
70 | if ( (this == NULL) || (this->hidden == NULL) ) { | ||
71 | SDL_OutOfMemory(); | ||
72 | if ( this ) { | ||
73 | SDL_free(this); | ||
74 | } | ||
75 | return(0); | ||
76 | } | ||
77 | SDL_memset(this->hidden, 0, (sizeof *this->hidden)); | ||
78 | /* Set the function pointers */ | ||
79 | this->OpenAudio = MME_OpenAudio; | ||
80 | this->WaitAudio = MME_WaitAudio; | ||
81 | this->PlayAudio = MME_PlayAudio; | ||
82 | this->GetAudioBuf = MME_GetAudioBuf; | ||
83 | this->WaitDone = MME_WaitDone; | ||
84 | this->CloseAudio = MME_CloseAudio; | ||
85 | this->free = Audio_DeleteDevice; | ||
86 | |||
87 | return this; | ||
88 | } | ||
89 | |||
90 | AudioBootStrap MMEAUDIO_bootstrap = { | ||
91 | "waveout", "Tru64 MME WaveOut", | ||
92 | Audio_Available, Audio_CreateDevice | ||
93 | }; | ||
94 | |||
95 | static void SetMMerror(char *function, MMRESULT code) | ||
96 | { | ||
97 | int len; | ||
98 | char errbuf[MAXERRORLENGTH]; | ||
99 | |||
100 | SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: ", function); | ||
101 | len = SDL_strlen(errbuf); | ||
102 | waveOutGetErrorText(code, errbuf+len, MAXERRORLENGTH-len); | ||
103 | SDL_SetError("%s",errbuf); | ||
104 | } | ||
105 | |||
106 | static void CALLBACK MME_CALLBACK(HWAVEOUT hwo, | ||
107 | UINT uMsg, | ||
108 | DWORD dwInstance, | ||
109 | LPARAM dwParam1, | ||
110 | LPARAM dwParam2) | ||
111 | { | ||
112 | WAVEHDR *wp = (WAVEHDR *) dwParam1; | ||
113 | |||
114 | if ( uMsg == WOM_DONE ) | ||
115 | inUse[wp->dwUser] = FALSE; | ||
116 | } | ||
117 | |||
118 | static int MME_OpenAudio(_THIS, SDL_AudioSpec *spec) | ||
119 | { | ||
120 | MMRESULT result; | ||
121 | int i; | ||
122 | |||
123 | mixbuf = NULL; | ||
124 | |||
125 | /* Set basic WAVE format parameters */ | ||
126 | shm = mmeAllocMem(sizeof(*shm)); | ||
127 | if ( shm == NULL ) { | ||
128 | SDL_SetError("Out of memory: shm"); | ||
129 | return(-1); | ||
130 | } | ||
131 | shm->sound = 0; | ||
132 | shm->wFmt.wf.wFormatTag = WAVE_FORMAT_PCM; | ||
133 | |||
134 | /* Determine the audio parameters from the AudioSpec */ | ||
135 | switch ( spec->format & 0xFF ) { | ||
136 | case 8: | ||
137 | /* Unsigned 8 bit audio data */ | ||
138 | spec->format = AUDIO_U8; | ||
139 | shm->wFmt.wBitsPerSample = 8; | ||
140 | break; | ||
141 | case 16: | ||
142 | /* Signed 16 bit audio data */ | ||
143 | spec->format = AUDIO_S16; | ||
144 | shm->wFmt.wBitsPerSample = 16; | ||
145 | break; | ||
146 | default: | ||
147 | SDL_SetError("Unsupported audio format"); | ||
148 | return(-1); | ||
149 | } | ||
150 | |||
151 | shm->wFmt.wf.nChannels = spec->channels; | ||
152 | shm->wFmt.wf.nSamplesPerSec = spec->freq; | ||
153 | shm->wFmt.wf.nBlockAlign = | ||
154 | shm->wFmt.wf.nChannels * shm->wFmt.wBitsPerSample / 8; | ||
155 | shm->wFmt.wf.nAvgBytesPerSec = | ||
156 | shm->wFmt.wf.nSamplesPerSec * shm->wFmt.wf.nBlockAlign; | ||
157 | |||
158 | /* Check the buffer size -- minimum of 1/4 second (word aligned) */ | ||
159 | if ( spec->samples < (spec->freq/4) ) | ||
160 | spec->samples = ((spec->freq/4)+3)&~3; | ||
161 | |||
162 | /* Update the fragment size as size in bytes */ | ||
163 | SDL_CalculateAudioSpec(spec); | ||
164 | |||
165 | /* Open the audio device */ | ||
166 | result = waveOutOpen(&(shm->sound), | ||
167 | WAVE_MAPPER, | ||
168 | &(shm->wFmt.wf), | ||
169 | MME_CALLBACK, | ||
170 | NULL, | ||
171 | (CALLBACK_FUNCTION|WAVE_OPEN_SHAREABLE)); | ||
172 | if ( result != MMSYSERR_NOERROR ) { | ||
173 | SetMMerror("waveOutOpen()", result); | ||
174 | return(-1); | ||
175 | } | ||
176 | |||
177 | /* Create the sound buffers */ | ||
178 | mixbuf = (Uint8 *)mmeAllocBuffer(NUM_BUFFERS * (spec->size)); | ||
179 | if ( mixbuf == NULL ) { | ||
180 | SDL_SetError("Out of memory: mixbuf"); | ||
181 | return(-1); | ||
182 | } | ||
183 | |||
184 | for (i = 0; i < NUM_BUFFERS; i++) { | ||
185 | shm->wHdr[i].lpData = &mixbuf[i * (spec->size)]; | ||
186 | shm->wHdr[i].dwBufferLength = spec->size; | ||
187 | shm->wHdr[i].dwFlags = 0; | ||
188 | shm->wHdr[i].dwUser = i; | ||
189 | shm->wHdr[i].dwLoops = 0; /* loop control counter */ | ||
190 | shm->wHdr[i].lpNext = NULL; /* reserved for driver */ | ||
191 | shm->wHdr[i].reserved = 0; | ||
192 | inUse[i] = FALSE; | ||
193 | } | ||
194 | next_buffer = 0; | ||
195 | return 0; | ||
196 | } | ||
197 | |||
198 | static void MME_WaitAudio(_THIS) | ||
199 | { | ||
200 | while ( inUse[next_buffer] ) { | ||
201 | mmeWaitForCallbacks(); | ||
202 | mmeProcessCallbacks(); | ||
203 | } | ||
204 | } | ||
205 | |||
206 | static Uint8 *MME_GetAudioBuf(_THIS) | ||
207 | { | ||
208 | Uint8 *retval; | ||
209 | |||
210 | inUse[next_buffer] = TRUE; | ||
211 | retval = (Uint8 *)(shm->wHdr[next_buffer].lpData); | ||
212 | return retval; | ||
213 | } | ||
214 | |||
215 | static void MME_PlayAudio(_THIS) | ||
216 | { | ||
217 | /* Queue it up */ | ||
218 | waveOutWrite(shm->sound, &(shm->wHdr[next_buffer]), sizeof(WAVEHDR)); | ||
219 | next_buffer = (next_buffer+1)%NUM_BUFFERS; | ||
220 | } | ||
221 | |||
222 | static void MME_WaitDone(_THIS) | ||
223 | { | ||
224 | MMRESULT result; | ||
225 | int i; | ||
226 | |||
227 | if ( shm->sound ) { | ||
228 | for (i = 0; i < NUM_BUFFERS; i++) | ||
229 | while ( inUse[i] ) { | ||
230 | mmeWaitForCallbacks(); | ||
231 | mmeProcessCallbacks(); | ||
232 | } | ||
233 | result = waveOutReset(shm->sound); | ||
234 | if ( result != MMSYSERR_NOERROR ) | ||
235 | SetMMerror("waveOutReset()", result); | ||
236 | mmeProcessCallbacks(); | ||
237 | } | ||
238 | } | ||
239 | |||
240 | static void MME_CloseAudio(_THIS) | ||
241 | { | ||
242 | MMRESULT result; | ||
243 | |||
244 | if ( mixbuf ) { | ||
245 | result = mmeFreeBuffer(mixbuf); | ||
246 | if (result != MMSYSERR_NOERROR ) | ||
247 | SetMMerror("mmeFreeBuffer", result); | ||
248 | mixbuf = NULL; | ||
249 | } | ||
250 | |||
251 | if ( shm ) { | ||
252 | if ( shm->sound ) { | ||
253 | result = waveOutClose(shm->sound); | ||
254 | if (result != MMSYSERR_NOERROR ) | ||
255 | SetMMerror("waveOutClose()", result); | ||
256 | mmeProcessCallbacks(); | ||
257 | } | ||
258 | result = mmeFreeMem(shm); | ||
259 | if (result != MMSYSERR_NOERROR ) | ||
260 | SetMMerror("mmeFreeMem()", result); | ||
261 | shm = NULL; | ||
262 | } | ||
263 | } | ||
264 | |||