This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_mintaudio_mcsn.c
418 lines (347 loc) · 11.8 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2004 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
slouken@libsdl.org
*/
22
#include "SDL_config.h"
23
24
25
26
27
28
29
30
/*
MiNT audio driver
using XBIOS functions (MacSound compatible driver)
Patrice Mandin
*/
31
#include <support.h>
32
33
34
35
36
37
38
/* Mint includes */
#include <mint/osbind.h>
#include <mint/falcon.h>
#include <mint/cookie.h>
#include "SDL_audio.h"
39
40
#include "../SDL_audio_c.h"
#include "../SDL_sysaudio.h"
41
42
#include "../../video/ataricommon/SDL_atarimxalloc_c.h"
43
44
45
46
47
48
49
50
51
52
#include "SDL_mintaudio.h"
#include "SDL_mintaudio_mcsn.h"
/*--- Defines ---*/
#define MINT_AUDIO_DRIVER_NAME "mint_mcsn"
/* Debug print info */
#define DEBUG_NAME "audio:mcsn: "
53
#if 0
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#define DEBUG_PRINT(what) \
{ \
printf what; \
}
#else
#define DEBUG_PRINT(what)
#endif
/*--- Static variables ---*/
static unsigned long cookie_snd, cookie_mch;
static cookie_mcsn_t *cookie_mcsn;
/*--- Audio driver functions ---*/
69
70
71
72
static void Mint_CloseAudio(_THIS);
static int Mint_OpenAudio(_THIS, SDL_AudioSpec * spec);
static void Mint_LockAudio(_THIS);
static void Mint_UnlockAudio(_THIS);
73
74
/* To check/init hardware audio */
75
76
static int Mint_CheckAudio(_THIS, SDL_AudioSpec * spec);
static void Mint_InitAudio(_THIS, SDL_AudioSpec * spec);
77
78
79
/*--- Audio driver bootstrap functions ---*/
80
static int
81
Audio_Available(void)
82
{
83
unsigned long dummy;
84
const char *envr = SDL_getenv("SDL_AUDIODRIVER");
85
86
SDL_MintAudio_mint_present = (Getcookie(C_MiNT, &dummy) == C_FOUND);
87
88
/* We can't use XBIOS in interrupt with Magic, don't know about thread */
89
if (Getcookie(C_MagX, &dummy) == C_FOUND) {
90
91
return (0);
}
92
93
/* Check if user asked a different audio driver */
94
95
if ((envr) && (SDL_strcmp(envr, MINT_AUDIO_DRIVER_NAME) != 0)) {
DEBUG_PRINT((DEBUG_NAME "user asked a different audio driver\n"));
96
97
return (0);
}
98
99
/* Cookie _MCH present ? if not, assume ST machine */
100
if (Getcookie(C__MCH, &cookie_mch) == C_NOTFOUND) {
101
102
cookie_mch = MCH_ST;
}
103
104
/* Cookie _SND present ? if not, assume ST machine */
105
if (Getcookie(C__SND, &cookie_snd) == C_NOTFOUND) {
106
107
cookie_snd = SND_PSG;
}
108
109
110
/* Check if we have 16 bits audio */
if ((cookie_snd & SND_16BIT) == 0) {
111
DEBUG_PRINT((DEBUG_NAME "no 16 bits sound\n"));
112
113
return (0);
}
114
115
/* Cookie MCSN present ? */
116
117
if (Getcookie(C_McSn, (long *) &cookie_mcsn) != C_FOUND) {
DEBUG_PRINT((DEBUG_NAME "no MCSN audio\n"));
118
119
return (0);
}
120
121
122
/* Check if interrupt at end of replay */
if (cookie_mcsn->pint == 0) {
123
DEBUG_PRINT((DEBUG_NAME "no interrupt at end of replay\n"));
124
125
return (0);
}
126
127
/* Check if audio is lockable */
128
129
if (Locksnd() != 1) {
DEBUG_PRINT((DEBUG_NAME "audio locked by other application\n"));
130
131
return (0);
}
132
133
Unlocksnd();
134
135
DEBUG_PRINT((DEBUG_NAME "MCSN audio available!\n"));
136
return (1);
137
138
}
139
static void
140
Audio_DeleteDevice(SDL_AudioDevice * device)
141
{
142
143
SDL_free(device->hidden);
SDL_free(device);
144
145
}
146
static SDL_AudioDevice *
147
Audio_CreateDevice(int devindex)
148
{
149
SDL_AudioDevice *this;
150
151
/* Initialize all variables that we clean on shutdown */
152
this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
153
if (this) {
154
SDL_memset(this, 0, (sizeof *this));
155
this->hidden = (struct SDL_PrivateAudioData *)
156
SDL_malloc((sizeof *this->hidden));
157
}
158
if ((this == NULL) || (this->hidden == NULL)) {
159
SDL_OutOfMemory();
160
if (this) {
161
SDL_free(this);
162
}
163
return (0);
164
}
165
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
166
167
/* Set the function pointers */
168
169
170
this->OpenAudio = Mint_OpenAudio;
this->CloseAudio = Mint_CloseAudio;
this->LockAudio = Mint_LockAudio;
171
this->UnlockAudio = Mint_UnlockAudio;
172
this->free = Audio_DeleteDevice;
173
174
175
176
177
return this;
}
AudioBootStrap MINTAUDIO_MCSN_bootstrap = {
178
179
MINT_AUDIO_DRIVER_NAME, "MiNT MCSN audio driver",
Audio_Available, Audio_CreateDevice
180
181
};
182
static void
183
Mint_LockAudio(_THIS)
184
{
185
/* Stop replay */
186
Buffoper(0);
187
188
}
189
static void
190
Mint_UnlockAudio(_THIS)
191
{
192
/* Restart replay */
193
Buffoper(SB_PLA_ENA | SB_PLA_RPT);
194
195
}
196
static void
197
Mint_CloseAudio(_THIS)
198
{
199
/* Stop replay */
200
201
SDL_MintAudio_WaitThread();
Buffoper(0);
202
203
204
if (!SDL_MintAudio_mint_present) {
/* Uninstall interrupt */
205
Jdisint(MFP_DMASOUND);
206
}
207
208
209
210
/* Wait if currently playing sound */
while (SDL_MintAudio_mutex != 0) {
}
211
212
213
/* Clear buffers */
if (SDL_MintAudio_audiobuf[0]) {
214
Mfree(SDL_MintAudio_audiobuf[0]);
215
216
SDL_MintAudio_audiobuf[0] = SDL_MintAudio_audiobuf[1] = NULL;
}
217
218
/* Unlock sound system */
219
Unlocksnd();
220
221
}
222
static int
223
Mint_CheckAudio(_THIS, SDL_AudioSpec * spec)
224
{
225
226
227
int i;
unsigned long masterclock, masterprediv;
228
229
230
231
232
DEBUG_PRINT((DEBUG_NAME "asked: %d bits, ", spec->format & 0x00ff));
DEBUG_PRINT(("signed=%d, ", ((spec->format & 0x8000) != 0)));
DEBUG_PRINT(("big endian=%d, ", ((spec->format & 0x1000) != 0)));
DEBUG_PRINT(("channels=%d, ", spec->channels));
DEBUG_PRINT(("freq=%d\n", spec->freq));
233
234
235
236
237
238
239
/* Check formats available */
MINTAUDIO_freqcount = 0;
switch (cookie_mcsn->play) {
case MCSN_ST:
spec->channels = 1;
spec->format = 8; /* FIXME: is it signed or unsigned ? */
240
SDL_MintAudio_AddFrequency(this, 12500, 0, 0, -1);
241
242
243
244
245
246
247
248
249
250
break;
case MCSN_TT: /* Also STE, Mega STE */
spec->format = AUDIO_S8;
masterclock = MASTERCLOCK_STE;
masterprediv = MASTERPREDIV_STE;
if ((cookie_mch >> 16) == MCH_TT) {
masterclock = MASTERCLOCK_TT;
masterprediv = MASTERPREDIV_TT;
}
for (i = 0; i < 4; i++) {
251
252
253
254
SDL_MintAudio_AddFrequency(this,
masterclock / (masterprediv *
(1 << i)),
masterclock, 3 - i, -1);
255
256
257
258
259
260
261
262
}
break;
case MCSN_FALCON: /* Also Mac */
for (i = 1; i < 12; i++) {
/* Remove unusable Falcon codec predivisors */
if ((i == 6) || (i == 8) || (i == 10)) {
continue;
}
263
264
265
266
SDL_MintAudio_AddFrequency(this,
MASTERCLOCK_FALCON1 /
(MASTERPREDIV_FALCON * (i + 1)),
CLK25M, i + 1, -1);
267
268
269
}
if (cookie_mcsn->res1 != 0) {
for (i = 1; i < 4; i++) {
270
271
272
273
274
SDL_MintAudio_AddFrequency(this,
(cookie_mcsn->res1) /
(MASTERPREDIV_FALCON *
(1 << i)), CLKEXT,
(1 << i) - 1, -1);
275
276
277
278
279
280
281
282
283
}
}
spec->format |= 0x8000; /* Audio is always signed */
if ((spec->format & 0x00ff) == 16) {
spec->format |= 0x1000; /* Audio is always big endian */
spec->channels = 2; /* 16 bits always stereo */
}
break;
}
284
285
#if 1
286
for (i = 0; i < MINTAUDIO_freqcount; i++) {
287
288
289
290
DEBUG_PRINT((DEBUG_NAME "freq %d: %lu Hz, clock %lu, prediv %d\n",
i, MINTAUDIO_frequencies[i].frequency,
MINTAUDIO_frequencies[i].masterclock,
MINTAUDIO_frequencies[i].predivisor));
291
}
292
293
#endif
294
MINTAUDIO_numfreq = SDL_MintAudio_SearchFrequency(this, spec->freq);
295
spec->freq = MINTAUDIO_frequencies[MINTAUDIO_numfreq].frequency;
296
297
298
299
300
301
DEBUG_PRINT((DEBUG_NAME "obtained: %d bits, ", spec->format & 0x00ff));
DEBUG_PRINT(("signed=%d, ", ((spec->format & 0x8000) != 0)));
DEBUG_PRINT(("big endian=%d, ", ((spec->format & 0x1000) != 0)));
DEBUG_PRINT(("channels=%d, ", spec->channels));
DEBUG_PRINT(("freq=%d\n", spec->freq));
302
303
return 0;
304
305
}
306
static void
307
Mint_InitAudio(_THIS, SDL_AudioSpec * spec)
308
{
309
310
311
312
313
314
int channels_mode, prediv, dmaclock;
void *buffer;
/* Stop currently playing sound */
SDL_MintAudio_quit_thread = SDL_FALSE;
SDL_MintAudio_thread_finished = SDL_TRUE;
315
316
SDL_MintAudio_WaitThread();
Buffoper(0);
317
318
/* Set replay tracks */
319
320
Settracks(0, 0);
Setmontracks(0);
321
322
323
324
325
326
327
328
329
330
331
332
/* Select replay format */
channels_mode = STEREO16;
switch (spec->format & 0xff) {
case 8:
if (spec->channels == 2) {
channels_mode = STEREO8;
} else {
channels_mode = MONO8;
}
break;
}
333
334
if (Setmode(channels_mode) < 0) {
DEBUG_PRINT((DEBUG_NAME "Setmode() failed\n"));
335
}
336
337
338
339
340
dmaclock = MINTAUDIO_frequencies[MINTAUDIO_numfreq].masterclock;
prediv = MINTAUDIO_frequencies[MINTAUDIO_numfreq].predivisor;
switch (cookie_mcsn->play) {
case MCSN_TT:
341
342
343
Devconnect(DMAPLAY, DAC, CLK25M, CLKOLD, 1);
Soundcmd(SETPRESCALE, prediv);
DEBUG_PRINT((DEBUG_NAME "STE/TT prescaler selected\n"));
344
345
break;
case MCSN_FALCON:
346
347
Devconnect(DMAPLAY, DAC, dmaclock, prediv, 1);
DEBUG_PRINT((DEBUG_NAME "Falcon prescaler selected\n"));
348
349
break;
}
350
351
352
/* Set buffer */
buffer = SDL_MintAudio_audiobuf[SDL_MintAudio_numbuf];
353
354
if (Setbuffer(0, buffer, buffer + spec->size) < 0) {
DEBUG_PRINT((DEBUG_NAME "Setbuffer() failed\n"));
355
}
356
357
if (SDL_MintAudio_mint_present) {
358
SDL_MintAudio_thread_pid = tfork(SDL_MintAudio_Thread, 0);
359
360
} else {
/* Install interrupt */
361
362
363
Jdisint(MFP_DMASOUND);
Xbtimer(XB_TIMERA, 8, 1, SDL_MintAudio_XbiosInterrupt);
Jenabint(MFP_DMASOUND);
364
365
366
if (Setinterrupt(SI_TIMERA, SI_PLAY) < 0) {
DEBUG_PRINT((DEBUG_NAME "Setinterrupt() failed\n"));
367
368
369
370
}
}
/* Go */
371
372
Buffoper(SB_PLA_ENA | SB_PLA_RPT);
DEBUG_PRINT((DEBUG_NAME "hardware initialized\n"));
373
374
}
375
static int
376
Mint_OpenAudio(_THIS, SDL_AudioSpec * spec)
377
{
378
/* Lock sound system */
379
380
if (Locksnd() != 1) {
SDL_SetError("Mint_OpenAudio: Audio system already in use");
381
382
return (-1);
}
383
384
SDL_MintAudio_device = this;
385
386
/* Check audio capabilities */
387
if (Mint_CheckAudio(this, spec) == -1) {
388
389
return -1;
}
390
391
SDL_CalculateAudioSpec(spec);
392
393
/* Allocate memory for audio buffers in DMA-able RAM */
394
DEBUG_PRINT((DEBUG_NAME "buffer size=%d\n", spec->size));
395
396
SDL_MintAudio_audiobuf[0] = Atari_SysMalloc(spec->size * 2, MX_STRAM);
397
if (SDL_MintAudio_audiobuf[0] == NULL) {
398
SDL_SetError("MINT_OpenAudio: Not enough memory for audio buffer");
399
400
401
402
return (-1);
}
SDL_MintAudio_audiobuf[1] = SDL_MintAudio_audiobuf[0] + spec->size;
SDL_MintAudio_numbuf = 0;
403
SDL_memset(SDL_MintAudio_audiobuf[0], spec->silence, spec->size * 2);
404
405
SDL_MintAudio_audiosize = spec->size;
SDL_MintAudio_mutex = 0;
406
407
408
409
410
DEBUG_PRINT((DEBUG_NAME "buffer 0 at 0x%08x\n",
SDL_MintAudio_audiobuf[0]));
DEBUG_PRINT((DEBUG_NAME "buffer 1 at 0x%08x\n",
SDL_MintAudio_audiobuf[1]));
411
412
/* Setup audio hardware */
413
Mint_InitAudio(this, spec);
414
415
return (1); /* We don't use SDL threaded audio */
416
}
417
418
/* vi: set ts=4 sw=4 expandtab: */