diff options
Diffstat (limited to 'apps/plugins/sdl/src/audio/mint/SDL_mintaudio_gsxb.c')
-rw-r--r-- | apps/plugins/sdl/src/audio/mint/SDL_mintaudio_gsxb.c | 436 |
1 files changed, 436 insertions, 0 deletions
diff --git a/apps/plugins/sdl/src/audio/mint/SDL_mintaudio_gsxb.c b/apps/plugins/sdl/src/audio/mint/SDL_mintaudio_gsxb.c new file mode 100644 index 0000000000..8d7716a137 --- /dev/null +++ b/apps/plugins/sdl/src/audio/mint/SDL_mintaudio_gsxb.c | |||
@@ -0,0 +1,436 @@ | |||
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 | /* | ||
25 | MiNT audio driver | ||
26 | using XBIOS functions (GSXB compatible driver) | ||
27 | |||
28 | Patrice Mandin | ||
29 | */ | ||
30 | |||
31 | /* Mint includes */ | ||
32 | #include <mint/osbind.h> | ||
33 | #include <mint/falcon.h> | ||
34 | #include <mint/cookie.h> | ||
35 | |||
36 | #include "SDL_audio.h" | ||
37 | #include "../SDL_audio_c.h" | ||
38 | #include "../SDL_sysaudio.h" | ||
39 | |||
40 | #include "../../video/ataricommon/SDL_atarimxalloc_c.h" | ||
41 | |||
42 | #include "SDL_mintaudio.h" | ||
43 | #include "SDL_mintaudio_gsxb.h" | ||
44 | |||
45 | /*--- Defines ---*/ | ||
46 | |||
47 | #define MINT_AUDIO_DRIVER_NAME "mint_gsxb" | ||
48 | |||
49 | /* Debug print info */ | ||
50 | #define DEBUG_NAME "audio:gsxb: " | ||
51 | #if 0 | ||
52 | #define DEBUG_PRINT(what) \ | ||
53 | { \ | ||
54 | printf what; \ | ||
55 | } | ||
56 | #else | ||
57 | #define DEBUG_PRINT(what) | ||
58 | #endif | ||
59 | |||
60 | /*--- Static variables ---*/ | ||
61 | |||
62 | static long cookie_snd, cookie_gsxb; | ||
63 | |||
64 | /*--- Audio driver functions ---*/ | ||
65 | |||
66 | static void Mint_CloseAudio(_THIS); | ||
67 | static int Mint_OpenAudio(_THIS, SDL_AudioSpec *spec); | ||
68 | static void Mint_LockAudio(_THIS); | ||
69 | static void Mint_UnlockAudio(_THIS); | ||
70 | |||
71 | /* To check/init hardware audio */ | ||
72 | static int Mint_CheckAudio(_THIS, SDL_AudioSpec *spec); | ||
73 | static void Mint_InitAudio(_THIS, SDL_AudioSpec *spec); | ||
74 | |||
75 | /* GSXB callbacks */ | ||
76 | static void Mint_GsxbInterrupt(void); | ||
77 | static void Mint_GsxbNullInterrupt(void); | ||
78 | |||
79 | /*--- Audio driver bootstrap functions ---*/ | ||
80 | |||
81 | static int Audio_Available(void) | ||
82 | { | ||
83 | const char *envr = SDL_getenv("SDL_AUDIODRIVER"); | ||
84 | |||
85 | /* Check if user asked a different audio driver */ | ||
86 | if ((envr) && (SDL_strcmp(envr, MINT_AUDIO_DRIVER_NAME)!=0)) { | ||
87 | DEBUG_PRINT((DEBUG_NAME "user asked a different audio driver\n")); | ||
88 | return(0); | ||
89 | } | ||
90 | |||
91 | /* Cookie _SND present ? if not, assume ST machine */ | ||
92 | if (Getcookie(C__SND, &cookie_snd) == C_NOTFOUND) { | ||
93 | cookie_snd = SND_PSG; | ||
94 | } | ||
95 | |||
96 | /* Check if we have 16 bits audio */ | ||
97 | if ((cookie_snd & SND_16BIT)==0) { | ||
98 | DEBUG_PRINT((DEBUG_NAME "no 16 bits sound\n")); | ||
99 | return(0); | ||
100 | } | ||
101 | |||
102 | /* Cookie GSXB present ? */ | ||
103 | cookie_gsxb = (Getcookie(C_GSXB, &cookie_gsxb) == C_FOUND); | ||
104 | |||
105 | /* Is it GSXB ? */ | ||
106 | if (((cookie_snd & SND_GSXB)==0) || (cookie_gsxb==0)) { | ||
107 | DEBUG_PRINT((DEBUG_NAME "no GSXB audio\n")); | ||
108 | return(0); | ||
109 | } | ||
110 | |||
111 | /* Check if audio is lockable */ | ||
112 | if (Locksnd()!=1) { | ||
113 | DEBUG_PRINT((DEBUG_NAME "audio locked by other application\n")); | ||
114 | return(0); | ||
115 | } | ||
116 | |||
117 | Unlocksnd(); | ||
118 | |||
119 | DEBUG_PRINT((DEBUG_NAME "GSXB audio available!\n")); | ||
120 | return(1); | ||
121 | } | ||
122 | |||
123 | static void Audio_DeleteDevice(SDL_AudioDevice *device) | ||
124 | { | ||
125 | SDL_free(device->hidden); | ||
126 | SDL_free(device); | ||
127 | } | ||
128 | |||
129 | static SDL_AudioDevice *Audio_CreateDevice(int devindex) | ||
130 | { | ||
131 | SDL_AudioDevice *this; | ||
132 | |||
133 | /* Initialize all variables that we clean on shutdown */ | ||
134 | this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice)); | ||
135 | if ( this ) { | ||
136 | SDL_memset(this, 0, (sizeof *this)); | ||
137 | this->hidden = (struct SDL_PrivateAudioData *) | ||
138 | SDL_malloc((sizeof *this->hidden)); | ||
139 | } | ||
140 | if ( (this == NULL) || (this->hidden == NULL) ) { | ||
141 | SDL_OutOfMemory(); | ||
142 | if ( this ) { | ||
143 | SDL_free(this); | ||
144 | } | ||
145 | return(0); | ||
146 | } | ||
147 | SDL_memset(this->hidden, 0, (sizeof *this->hidden)); | ||
148 | |||
149 | /* Set the function pointers */ | ||
150 | this->OpenAudio = Mint_OpenAudio; | ||
151 | this->CloseAudio = Mint_CloseAudio; | ||
152 | this->LockAudio = Mint_LockAudio; | ||
153 | this->UnlockAudio = Mint_UnlockAudio; | ||
154 | this->free = Audio_DeleteDevice; | ||
155 | |||
156 | return this; | ||
157 | } | ||
158 | |||
159 | AudioBootStrap MINTAUDIO_GSXB_bootstrap = { | ||
160 | MINT_AUDIO_DRIVER_NAME, "MiNT GSXB audio driver", | ||
161 | Audio_Available, Audio_CreateDevice | ||
162 | }; | ||
163 | |||
164 | static void Mint_LockAudio(_THIS) | ||
165 | { | ||
166 | /* Stop replay */ | ||
167 | Buffoper(0); | ||
168 | } | ||
169 | |||
170 | static void Mint_UnlockAudio(_THIS) | ||
171 | { | ||
172 | /* Restart replay */ | ||
173 | Buffoper(SB_PLA_ENA|SB_PLA_RPT); | ||
174 | } | ||
175 | |||
176 | static void Mint_CloseAudio(_THIS) | ||
177 | { | ||
178 | /* Stop replay */ | ||
179 | Buffoper(0); | ||
180 | |||
181 | /* Uninstall interrupt */ | ||
182 | if (NSetinterrupt(2, SI_NONE, Mint_GsxbNullInterrupt)<0) { | ||
183 | DEBUG_PRINT((DEBUG_NAME "NSetinterrupt() failed in close\n")); | ||
184 | } | ||
185 | |||
186 | /* Wait if currently playing sound */ | ||
187 | while (SDL_MintAudio_mutex != 0) { | ||
188 | } | ||
189 | |||
190 | /* Clear buffers */ | ||
191 | if (SDL_MintAudio_audiobuf[0]) { | ||
192 | Mfree(SDL_MintAudio_audiobuf[0]); | ||
193 | SDL_MintAudio_audiobuf[0] = SDL_MintAudio_audiobuf[1] = NULL; | ||
194 | } | ||
195 | |||
196 | /* Unlock sound system */ | ||
197 | Unlocksnd(); | ||
198 | } | ||
199 | |||
200 | static int Mint_CheckAudio(_THIS, SDL_AudioSpec *spec) | ||
201 | { | ||
202 | long snd_format = 0; | ||
203 | int i, resolution, format_signed, format_bigendian; | ||
204 | Uint16 test_format = SDL_FirstAudioFormat(spec->format); | ||
205 | int valid_datatype = 0; | ||
206 | |||
207 | resolution = spec->format & 0x00ff; | ||
208 | format_signed = ((spec->format & 0x8000)!=0); | ||
209 | format_bigendian = ((spec->format & 0x1000)!=0); | ||
210 | |||
211 | DEBUG_PRINT((DEBUG_NAME "asked: %d bits, ",spec->format & 0x00ff)); | ||
212 | DEBUG_PRINT(("signed=%d, ", ((spec->format & 0x8000)!=0))); | ||
213 | DEBUG_PRINT(("big endian=%d, ", ((spec->format & 0x1000)!=0))); | ||
214 | DEBUG_PRINT(("channels=%d, ", spec->channels)); | ||
215 | DEBUG_PRINT(("freq=%d\n", spec->freq)); | ||
216 | |||
217 | if (spec->channels > 2) { | ||
218 | spec->channels = 2; /* no more than stereo! */ | ||
219 | } | ||
220 | |||
221 | while ((!valid_datatype) && (test_format)) { | ||
222 | /* Check formats available */ | ||
223 | snd_format = Sndstatus(SND_QUERYFORMATS); | ||
224 | spec->format = test_format; | ||
225 | resolution = spec->format & 0xff; | ||
226 | format_signed = (spec->format & (1<<15)); | ||
227 | format_bigendian = (spec->format & (1<<12)); | ||
228 | switch (test_format) { | ||
229 | case AUDIO_U8: | ||
230 | case AUDIO_S8: | ||
231 | if (snd_format & SND_FORMAT8) { | ||
232 | valid_datatype = 1; | ||
233 | snd_format = Sndstatus(SND_QUERY8BIT); | ||
234 | } | ||
235 | break; | ||
236 | |||
237 | case AUDIO_U16LSB: | ||
238 | case AUDIO_S16LSB: | ||
239 | case AUDIO_U16MSB: | ||
240 | case AUDIO_S16MSB: | ||
241 | if (snd_format & SND_FORMAT16) { | ||
242 | valid_datatype = 1; | ||
243 | snd_format = Sndstatus(SND_QUERY16BIT); | ||
244 | } | ||
245 | break; | ||
246 | |||
247 | default: | ||
248 | test_format = SDL_NextAudioFormat(); | ||
249 | break; | ||
250 | } | ||
251 | } | ||
252 | |||
253 | if (!valid_datatype) { | ||
254 | SDL_SetError("Unsupported audio format"); | ||
255 | return (-1); | ||
256 | } | ||
257 | |||
258 | /* Check signed/unsigned format */ | ||
259 | if (format_signed) { | ||
260 | if (snd_format & SND_FORMATSIGNED) { | ||
261 | /* Ok */ | ||
262 | } else if (snd_format & SND_FORMATUNSIGNED) { | ||
263 | /* Give unsigned format */ | ||
264 | spec->format = spec->format & (~0x8000); | ||
265 | } | ||
266 | } else { | ||
267 | if (snd_format & SND_FORMATUNSIGNED) { | ||
268 | /* Ok */ | ||
269 | } else if (snd_format & SND_FORMATSIGNED) { | ||
270 | /* Give signed format */ | ||
271 | spec->format |= 0x8000; | ||
272 | } | ||
273 | } | ||
274 | |||
275 | if (format_bigendian) { | ||
276 | if (snd_format & SND_FORMATBIGENDIAN) { | ||
277 | /* Ok */ | ||
278 | } else if (snd_format & SND_FORMATLITTLEENDIAN) { | ||
279 | /* Give little endian format */ | ||
280 | spec->format = spec->format & (~0x1000); | ||
281 | } | ||
282 | } else { | ||
283 | if (snd_format & SND_FORMATLITTLEENDIAN) { | ||
284 | /* Ok */ | ||
285 | } else if (snd_format & SND_FORMATBIGENDIAN) { | ||
286 | /* Give big endian format */ | ||
287 | spec->format |= 0x1000; | ||
288 | } | ||
289 | } | ||
290 | |||
291 | /* Calculate and select the closest frequency */ | ||
292 | MINTAUDIO_freqcount=0; | ||
293 | for (i=1;i<4;i++) { | ||
294 | SDL_MintAudio_AddFrequency(this, | ||
295 | MASTERCLOCK_44K/(MASTERPREDIV_MILAN*(1<<i)), MASTERCLOCK_44K, | ||
296 | (1<<i)-1, -1); | ||
297 | } | ||
298 | |||
299 | #if 1 | ||
300 | for (i=0; i<MINTAUDIO_freqcount; i++) { | ||
301 | DEBUG_PRINT((DEBUG_NAME "freq %d: %lu Hz, clock %lu, prediv %d\n", | ||
302 | i, MINTAUDIO_frequencies[i].frequency, MINTAUDIO_frequencies[i].masterclock, | ||
303 | MINTAUDIO_frequencies[i].predivisor | ||
304 | )); | ||
305 | } | ||
306 | #endif | ||
307 | |||
308 | MINTAUDIO_numfreq=SDL_MintAudio_SearchFrequency(this, spec->freq); | ||
309 | spec->freq=MINTAUDIO_frequencies[MINTAUDIO_numfreq].frequency; | ||
310 | |||
311 | DEBUG_PRINT((DEBUG_NAME "obtained: %d bits, ",spec->format & 0x00ff)); | ||
312 | DEBUG_PRINT(("signed=%d, ", ((spec->format & 0x8000)!=0))); | ||
313 | DEBUG_PRINT(("big endian=%d, ", ((spec->format & 0x1000)!=0))); | ||
314 | DEBUG_PRINT(("channels=%d, ", spec->channels)); | ||
315 | DEBUG_PRINT(("freq=%d\n", spec->freq)); | ||
316 | |||
317 | return 0; | ||
318 | } | ||
319 | |||
320 | static void Mint_InitAudio(_THIS, SDL_AudioSpec *spec) | ||
321 | { | ||
322 | int channels_mode, prediv; | ||
323 | void *buffer; | ||
324 | |||
325 | /* Stop currently playing sound */ | ||
326 | Buffoper(0); | ||
327 | |||
328 | /* Set replay tracks */ | ||
329 | Settracks(0,0); | ||
330 | Setmontracks(0); | ||
331 | |||
332 | /* Select replay format */ | ||
333 | switch (spec->format & 0xff) { | ||
334 | case 8: | ||
335 | if (spec->channels==2) { | ||
336 | channels_mode=STEREO8; | ||
337 | } else { | ||
338 | channels_mode=MONO8; | ||
339 | } | ||
340 | break; | ||
341 | case 16: | ||
342 | if (spec->channels==2) { | ||
343 | channels_mode=STEREO16; | ||
344 | } else { | ||
345 | channels_mode=MONO16; | ||
346 | } | ||
347 | break; | ||
348 | default: | ||
349 | channels_mode=STEREO16; | ||
350 | break; | ||
351 | } | ||
352 | if (Setmode(channels_mode)<0) { | ||
353 | DEBUG_PRINT((DEBUG_NAME "Setmode() failed\n")); | ||
354 | } | ||
355 | |||
356 | prediv = MINTAUDIO_frequencies[MINTAUDIO_numfreq].predivisor; | ||
357 | Devconnect(DMAPLAY, DAC, CLKEXT, prediv, 1); | ||
358 | |||
359 | /* Set buffer */ | ||
360 | buffer = SDL_MintAudio_audiobuf[SDL_MintAudio_numbuf]; | ||
361 | if (Setbuffer(0, buffer, buffer + spec->size)<0) { | ||
362 | DEBUG_PRINT((DEBUG_NAME "Setbuffer() failed\n")); | ||
363 | } | ||
364 | |||
365 | /* Install interrupt */ | ||
366 | if (NSetinterrupt(2, SI_PLAY, Mint_GsxbInterrupt)<0) { | ||
367 | DEBUG_PRINT((DEBUG_NAME "NSetinterrupt() failed\n")); | ||
368 | } | ||
369 | |||
370 | /* Go */ | ||
371 | Buffoper(SB_PLA_ENA|SB_PLA_RPT); | ||
372 | DEBUG_PRINT((DEBUG_NAME "hardware initialized\n")); | ||
373 | } | ||
374 | |||
375 | static int Mint_OpenAudio(_THIS, SDL_AudioSpec *spec) | ||
376 | { | ||
377 | /* Lock sound system */ | ||
378 | if (Locksnd()!=1) { | ||
379 | SDL_SetError("Mint_OpenAudio: Audio system already in use"); | ||
380 | return(-1); | ||
381 | } | ||
382 | |||
383 | SDL_MintAudio_device = this; | ||
384 | |||
385 | /* Check audio capabilities */ | ||
386 | if (Mint_CheckAudio(this, spec)==-1) { | ||
387 | return -1; | ||
388 | } | ||
389 | |||
390 | SDL_CalculateAudioSpec(spec); | ||
391 | |||
392 | /* Allocate memory for audio buffers in DMA-able RAM */ | ||
393 | DEBUG_PRINT((DEBUG_NAME "buffer size=%d\n", spec->size)); | ||
394 | |||
395 | SDL_MintAudio_audiobuf[0] = Atari_SysMalloc(spec->size *2, MX_STRAM); | ||
396 | if (SDL_MintAudio_audiobuf[0]==NULL) { | ||
397 | SDL_SetError("MINT_OpenAudio: Not enough memory for audio buffer"); | ||
398 | return (-1); | ||
399 | } | ||
400 | SDL_MintAudio_audiobuf[1] = SDL_MintAudio_audiobuf[0] + spec->size ; | ||
401 | SDL_MintAudio_numbuf=0; | ||
402 | SDL_memset(SDL_MintAudio_audiobuf[0], spec->silence, spec->size *2); | ||
403 | SDL_MintAudio_audiosize = spec->size; | ||
404 | SDL_MintAudio_mutex = 0; | ||
405 | |||
406 | DEBUG_PRINT((DEBUG_NAME "buffer 0 at 0x%08x\n", SDL_MintAudio_audiobuf[0])); | ||
407 | DEBUG_PRINT((DEBUG_NAME "buffer 1 at 0x%08x\n", SDL_MintAudio_audiobuf[1])); | ||
408 | |||
409 | SDL_MintAudio_CheckFpu(); | ||
410 | |||
411 | /* Setup audio hardware */ | ||
412 | Mint_InitAudio(this, spec); | ||
413 | |||
414 | return(1); /* We don't use threaded audio */ | ||
415 | } | ||
416 | |||
417 | static void Mint_GsxbInterrupt(void) | ||
418 | { | ||
419 | Uint8 *newbuf; | ||
420 | |||
421 | if (SDL_MintAudio_mutex) | ||
422 | return; | ||
423 | |||
424 | SDL_MintAudio_mutex=1; | ||
425 | |||
426 | SDL_MintAudio_numbuf ^= 1; | ||
427 | SDL_MintAudio_Callback(); | ||
428 | newbuf = SDL_MintAudio_audiobuf[SDL_MintAudio_numbuf]; | ||
429 | Setbuffer(0, newbuf, newbuf + SDL_MintAudio_audiosize); | ||
430 | |||
431 | SDL_MintAudio_mutex=0; | ||
432 | } | ||
433 | |||
434 | static void Mint_GsxbNullInterrupt(void) | ||
435 | { | ||
436 | } | ||