diff options
author | Franklin Wei <git@fwei.tk> | 2018-02-07 20:04:46 -0500 |
---|---|---|
committer | Franklin Wei <git@fwei.tk> | 2018-03-12 20:52:01 -0400 |
commit | 6039eb05ba6d82ef56f2868c96654c552d117bf9 (patch) | |
tree | 9db7016bcbf66cfdf7b9bc998d84c6eaff9c8378 /apps/plugins/sdl/src/audio/windib | |
parent | ef373c03b96b0be08babca581d9f10bccfd4931f (diff) | |
download | rockbox-6039eb05ba6d82ef56f2868c96654c552d117bf9.tar.gz rockbox-6039eb05ba6d82ef56f2868c96654c552d117bf9.zip |
sdl: remove non-rockbox drivers
We never use any of these other drivers, so having them around just takes
up space.
Change-Id: Iced812162df1fef3fd55522b7e700acb6c3bcd41
Diffstat (limited to 'apps/plugins/sdl/src/audio/windib')
-rw-r--r-- | apps/plugins/sdl/src/audio/windib/SDL_dibaudio.c | 322 | ||||
-rw-r--r-- | apps/plugins/sdl/src/audio/windib/SDL_dibaudio.h | 49 |
2 files changed, 0 insertions, 371 deletions
diff --git a/apps/plugins/sdl/src/audio/windib/SDL_dibaudio.c b/apps/plugins/sdl/src/audio/windib/SDL_dibaudio.c deleted file mode 100644 index 51a9a4d60a..0000000000 --- a/apps/plugins/sdl/src/audio/windib/SDL_dibaudio.c +++ /dev/null | |||
@@ -1,322 +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 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 | 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 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | 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 | /* Allow access to a raw mixing buffer */ | ||
25 | |||
26 | #define WIN32_LEAN_AND_MEAN | ||
27 | #include <windows.h> | ||
28 | #include <mmsystem.h> | ||
29 | |||
30 | #include "SDL_timer.h" | ||
31 | #include "SDL_audio.h" | ||
32 | #include "../SDL_audio_c.h" | ||
33 | #include "SDL_dibaudio.h" | ||
34 | #if defined(_WIN32_WCE) && (_WIN32_WCE < 300) | ||
35 | #include "win_ce_semaphore.h" | ||
36 | #endif | ||
37 | |||
38 | |||
39 | /* Audio driver functions */ | ||
40 | static int DIB_OpenAudio(_THIS, SDL_AudioSpec *spec); | ||
41 | static void DIB_ThreadInit(_THIS); | ||
42 | static void DIB_WaitAudio(_THIS); | ||
43 | static Uint8 *DIB_GetAudioBuf(_THIS); | ||
44 | static void DIB_PlayAudio(_THIS); | ||
45 | static void DIB_WaitDone(_THIS); | ||
46 | static void DIB_CloseAudio(_THIS); | ||
47 | |||
48 | /* Audio driver bootstrap functions */ | ||
49 | |||
50 | static int Audio_Available(void) | ||
51 | { | ||
52 | return(1); | ||
53 | } | ||
54 | |||
55 | static void Audio_DeleteDevice(SDL_AudioDevice *device) | ||
56 | { | ||
57 | SDL_free(device->hidden); | ||
58 | SDL_free(device); | ||
59 | } | ||
60 | |||
61 | static SDL_AudioDevice *Audio_CreateDevice(int devindex) | ||
62 | { | ||
63 | SDL_AudioDevice *this; | ||
64 | |||
65 | /* Initialize all variables that we clean on shutdown */ | ||
66 | this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice)); | ||
67 | if ( this ) { | ||
68 | SDL_memset(this, 0, (sizeof *this)); | ||
69 | this->hidden = (struct SDL_PrivateAudioData *) | ||
70 | SDL_malloc((sizeof *this->hidden)); | ||
71 | } | ||
72 | if ( (this == NULL) || (this->hidden == NULL) ) { | ||
73 | SDL_OutOfMemory(); | ||
74 | if ( this ) { | ||
75 | SDL_free(this); | ||
76 | } | ||
77 | return(0); | ||
78 | } | ||
79 | SDL_memset(this->hidden, 0, (sizeof *this->hidden)); | ||
80 | |||
81 | /* Set the function pointers */ | ||
82 | this->OpenAudio = DIB_OpenAudio; | ||
83 | this->ThreadInit = DIB_ThreadInit; | ||
84 | this->WaitAudio = DIB_WaitAudio; | ||
85 | this->PlayAudio = DIB_PlayAudio; | ||
86 | this->GetAudioBuf = DIB_GetAudioBuf; | ||
87 | this->WaitDone = DIB_WaitDone; | ||
88 | this->CloseAudio = DIB_CloseAudio; | ||
89 | |||
90 | this->free = Audio_DeleteDevice; | ||
91 | |||
92 | return this; | ||
93 | } | ||
94 | |||
95 | AudioBootStrap WAVEOUT_bootstrap = { | ||
96 | "waveout", "Win95/98/NT/2000 WaveOut", | ||
97 | Audio_Available, Audio_CreateDevice | ||
98 | }; | ||
99 | |||
100 | |||
101 | /* The Win32 callback for filling the WAVE device */ | ||
102 | static void CALLBACK FillSound(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance, | ||
103 | DWORD dwParam1, DWORD dwParam2) | ||
104 | { | ||
105 | SDL_AudioDevice *this = (SDL_AudioDevice *)dwInstance; | ||
106 | |||
107 | /* Only service "buffer done playing" messages */ | ||
108 | if ( uMsg != WOM_DONE ) | ||
109 | return; | ||
110 | |||
111 | /* Signal that we are done playing a buffer */ | ||
112 | #if defined(_WIN32_WCE) && (_WIN32_WCE < 300) | ||
113 | ReleaseSemaphoreCE(audio_sem, 1, NULL); | ||
114 | #else | ||
115 | ReleaseSemaphore(audio_sem, 1, NULL); | ||
116 | #endif | ||
117 | } | ||
118 | |||
119 | static void SetMMerror(char *function, MMRESULT code) | ||
120 | { | ||
121 | size_t len; | ||
122 | char errbuf[MAXERRORLENGTH]; | ||
123 | #ifdef _WIN32_WCE | ||
124 | wchar_t werrbuf[MAXERRORLENGTH]; | ||
125 | #endif | ||
126 | |||
127 | SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: ", function); | ||
128 | len = SDL_strlen(errbuf); | ||
129 | |||
130 | #ifdef _WIN32_WCE | ||
131 | /* UNICODE version */ | ||
132 | waveOutGetErrorText(code, werrbuf, MAXERRORLENGTH-len); | ||
133 | WideCharToMultiByte(CP_ACP,0,werrbuf,-1,errbuf+len,MAXERRORLENGTH-len,NULL,NULL); | ||
134 | #else | ||
135 | waveOutGetErrorText(code, errbuf+len, (UINT)(MAXERRORLENGTH-len)); | ||
136 | #endif | ||
137 | |||
138 | SDL_SetError("%s",errbuf); | ||
139 | } | ||
140 | |||
141 | /* Set high priority for the audio thread */ | ||
142 | static void DIB_ThreadInit(_THIS) | ||
143 | { | ||
144 | SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST); | ||
145 | } | ||
146 | |||
147 | void DIB_WaitAudio(_THIS) | ||
148 | { | ||
149 | /* Wait for an audio chunk to finish */ | ||
150 | #if defined(_WIN32_WCE) && (_WIN32_WCE < 300) | ||
151 | WaitForSemaphoreCE(audio_sem, INFINITE); | ||
152 | #else | ||
153 | WaitForSingleObject(audio_sem, INFINITE); | ||
154 | #endif | ||
155 | } | ||
156 | |||
157 | Uint8 *DIB_GetAudioBuf(_THIS) | ||
158 | { | ||
159 | Uint8 *retval; | ||
160 | |||
161 | retval = (Uint8 *)(wavebuf[next_buffer].lpData); | ||
162 | return retval; | ||
163 | } | ||
164 | |||
165 | void DIB_PlayAudio(_THIS) | ||
166 | { | ||
167 | /* Queue it up */ | ||
168 | waveOutWrite(sound, &wavebuf[next_buffer], sizeof(wavebuf[0])); | ||
169 | next_buffer = (next_buffer+1)%NUM_BUFFERS; | ||
170 | } | ||
171 | |||
172 | void DIB_WaitDone(_THIS) | ||
173 | { | ||
174 | int i, left; | ||
175 | |||
176 | do { | ||
177 | left = NUM_BUFFERS; | ||
178 | for ( i=0; i<NUM_BUFFERS; ++i ) { | ||
179 | if ( wavebuf[i].dwFlags & WHDR_DONE ) { | ||
180 | --left; | ||
181 | } | ||
182 | } | ||
183 | if ( left > 0 ) { | ||
184 | SDL_Delay(100); | ||
185 | } | ||
186 | } while ( left > 0 ); | ||
187 | } | ||
188 | |||
189 | void DIB_CloseAudio(_THIS) | ||
190 | { | ||
191 | int i; | ||
192 | |||
193 | /* Close up audio */ | ||
194 | if ( audio_sem ) { | ||
195 | #if defined(_WIN32_WCE) && (_WIN32_WCE < 300) | ||
196 | CloseSynchHandle(audio_sem); | ||
197 | #else | ||
198 | CloseHandle(audio_sem); | ||
199 | #endif | ||
200 | } | ||
201 | if ( sound ) { | ||
202 | waveOutClose(sound); | ||
203 | } | ||
204 | |||
205 | /* Clean up mixing buffers */ | ||
206 | for ( i=0; i<NUM_BUFFERS; ++i ) { | ||
207 | if ( wavebuf[i].dwUser != 0xFFFF ) { | ||
208 | waveOutUnprepareHeader(sound, &wavebuf[i], | ||
209 | sizeof(wavebuf[i])); | ||
210 | wavebuf[i].dwUser = 0xFFFF; | ||
211 | } | ||
212 | } | ||
213 | /* Free raw mixing buffer */ | ||
214 | if ( mixbuf != NULL ) { | ||
215 | SDL_free(mixbuf); | ||
216 | mixbuf = NULL; | ||
217 | } | ||
218 | } | ||
219 | |||
220 | int DIB_OpenAudio(_THIS, SDL_AudioSpec *spec) | ||
221 | { | ||
222 | MMRESULT result; | ||
223 | int i; | ||
224 | WAVEFORMATEX waveformat; | ||
225 | |||
226 | /* Initialize the wavebuf structures for closing */ | ||
227 | sound = NULL; | ||
228 | audio_sem = NULL; | ||
229 | for ( i = 0; i < NUM_BUFFERS; ++i ) | ||
230 | wavebuf[i].dwUser = 0xFFFF; | ||
231 | mixbuf = NULL; | ||
232 | |||
233 | /* Set basic WAVE format parameters */ | ||
234 | SDL_memset(&waveformat, 0, sizeof(waveformat)); | ||
235 | waveformat.wFormatTag = WAVE_FORMAT_PCM; | ||
236 | |||
237 | /* Determine the audio parameters from the AudioSpec */ | ||
238 | switch ( spec->format & 0xFF ) { | ||
239 | case 8: | ||
240 | /* Unsigned 8 bit audio data */ | ||
241 | spec->format = AUDIO_U8; | ||
242 | waveformat.wBitsPerSample = 8; | ||
243 | break; | ||
244 | case 16: | ||
245 | /* Signed 16 bit audio data */ | ||
246 | spec->format = AUDIO_S16; | ||
247 | waveformat.wBitsPerSample = 16; | ||
248 | break; | ||
249 | default: | ||
250 | SDL_SetError("Unsupported audio format"); | ||
251 | return(-1); | ||
252 | } | ||
253 | waveformat.nChannels = spec->channels; | ||
254 | waveformat.nSamplesPerSec = spec->freq; | ||
255 | waveformat.nBlockAlign = | ||
256 | waveformat.nChannels * (waveformat.wBitsPerSample/8); | ||
257 | waveformat.nAvgBytesPerSec = | ||
258 | waveformat.nSamplesPerSec * waveformat.nBlockAlign; | ||
259 | |||
260 | /* Check the buffer size -- minimum of 1/4 second (word aligned) */ | ||
261 | if ( spec->samples < (spec->freq/4) ) | ||
262 | spec->samples = ((spec->freq/4)+3)&~3; | ||
263 | |||
264 | /* Update the fragment size as size in bytes */ | ||
265 | SDL_CalculateAudioSpec(spec); | ||
266 | |||
267 | /* Open the audio device */ | ||
268 | result = waveOutOpen(&sound, WAVE_MAPPER, &waveformat, | ||
269 | (DWORD_PTR)FillSound, (DWORD_PTR)this, CALLBACK_FUNCTION); | ||
270 | if ( result != MMSYSERR_NOERROR ) { | ||
271 | SetMMerror("waveOutOpen()", result); | ||
272 | return(-1); | ||
273 | } | ||
274 | |||
275 | #ifdef SOUND_DEBUG | ||
276 | /* Check the sound device we retrieved */ | ||
277 | { | ||
278 | WAVEOUTCAPS caps; | ||
279 | |||
280 | result = waveOutGetDevCaps((UINT)sound, &caps, sizeof(caps)); | ||
281 | if ( result != MMSYSERR_NOERROR ) { | ||
282 | SetMMerror("waveOutGetDevCaps()", result); | ||
283 | return(-1); | ||
284 | } | ||
285 | printf("Audio device: %s\n", caps.szPname); | ||
286 | } | ||
287 | #endif | ||
288 | |||
289 | /* Create the audio buffer semaphore */ | ||
290 | #if defined(_WIN32_WCE) && (_WIN32_WCE < 300) | ||
291 | audio_sem = CreateSemaphoreCE(NULL, NUM_BUFFERS-1, NUM_BUFFERS, NULL); | ||
292 | #else | ||
293 | audio_sem = CreateSemaphore(NULL, NUM_BUFFERS-1, NUM_BUFFERS, NULL); | ||
294 | #endif | ||
295 | if ( audio_sem == NULL ) { | ||
296 | SDL_SetError("Couldn't create semaphore"); | ||
297 | return(-1); | ||
298 | } | ||
299 | |||
300 | /* Create the sound buffers */ | ||
301 | mixbuf = (Uint8 *)SDL_malloc(NUM_BUFFERS*spec->size); | ||
302 | if ( mixbuf == NULL ) { | ||
303 | SDL_SetError("Out of memory"); | ||
304 | return(-1); | ||
305 | } | ||
306 | for ( i = 0; i < NUM_BUFFERS; ++i ) { | ||
307 | SDL_memset(&wavebuf[i], 0, sizeof(wavebuf[i])); | ||
308 | wavebuf[i].lpData = (LPSTR) &mixbuf[i*spec->size]; | ||
309 | wavebuf[i].dwBufferLength = spec->size; | ||
310 | wavebuf[i].dwFlags = WHDR_DONE; | ||
311 | result = waveOutPrepareHeader(sound, &wavebuf[i], | ||
312 | sizeof(wavebuf[i])); | ||
313 | if ( result != MMSYSERR_NOERROR ) { | ||
314 | SetMMerror("waveOutPrepareHeader()", result); | ||
315 | return(-1); | ||
316 | } | ||
317 | } | ||
318 | |||
319 | /* Ready to go! */ | ||
320 | next_buffer = 0; | ||
321 | return(0); | ||
322 | } | ||
diff --git a/apps/plugins/sdl/src/audio/windib/SDL_dibaudio.h b/apps/plugins/sdl/src/audio/windib/SDL_dibaudio.h deleted file mode 100644 index d2c62280b5..0000000000 --- a/apps/plugins/sdl/src/audio/windib/SDL_dibaudio.h +++ /dev/null | |||
@@ -1,49 +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 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 | 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 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | 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 | #ifndef _SDL_lowaudio_h | ||
25 | #define _SDL_lowaudio_h | ||
26 | |||
27 | #include "../SDL_sysaudio.h" | ||
28 | |||
29 | /* Hidden "this" pointer for the video functions */ | ||
30 | #define _THIS SDL_AudioDevice *this | ||
31 | |||
32 | #define NUM_BUFFERS 2 /* -- Don't lower this! */ | ||
33 | |||
34 | struct SDL_PrivateAudioData { | ||
35 | HWAVEOUT sound; | ||
36 | HANDLE audio_sem; | ||
37 | Uint8 *mixbuf; /* The raw allocated mixing buffer */ | ||
38 | WAVEHDR wavebuf[NUM_BUFFERS]; /* Wave audio fragments */ | ||
39 | int next_buffer; | ||
40 | }; | ||
41 | |||
42 | /* Old variable names */ | ||
43 | #define sound (this->hidden->sound) | ||
44 | #define audio_sem (this->hidden->audio_sem) | ||
45 | #define mixbuf (this->hidden->mixbuf) | ||
46 | #define wavebuf (this->hidden->wavebuf) | ||
47 | #define next_buffer (this->hidden->next_buffer) | ||
48 | |||
49 | #endif /* _SDL_lowaudio_h */ | ||