This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_mintaudio_stfa.c
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
31
32
33
34
35
36
/*
MiNT audio driver
using XBIOS functions (STFA driver)
Patrice Mandin
*/
/* Mint includes */
#include <mint/osbind.h>
#include <mint/falcon.h>
#include <mint/cookie.h>
#include "SDL_audio.h"
37
38
#include "../SDL_audio_c.h"
#include "../SDL_sysaudio.h"
40
#include "../../video/ataricommon/SDL_atarimxalloc_c.h"
41
42
43
44
45
46
47
48
49
50
#include "SDL_mintaudio.h"
#include "SDL_mintaudio_stfa.h"
/*--- Defines ---*/
#define MINT_AUDIO_DRIVER_NAME "mint_stfa"
/* Debug print info */
#define DEBUG_NAME "audio:stfa: "
52
53
54
55
56
57
58
59
60
61
62
63
64
#define DEBUG_PRINT(what) \
{ \
printf what; \
}
#else
#define DEBUG_PRINT(what)
#endif
/*--- Static variables ---*/
static unsigned long cookie_snd, cookie_mch;
static cookie_stfa_t *cookie_stfa;
65
66
67
68
69
static const int freqs[16] = {
4995, 6269, 7493, 8192,
9830, 10971, 12538, 14985,
16384, 19819, 21943, 24576,
30720, 32336, 43885, 49152
70
71
72
73
74
};
/*--- Audio driver functions ---*/
static void Mint_CloseAudio(_THIS);
75
static int Mint_OpenAudio(_THIS, SDL_AudioSpec * spec);
76
77
78
79
static void Mint_LockAudio(_THIS);
static void Mint_UnlockAudio(_THIS);
/* To check/init hardware audio */
80
81
static int Mint_CheckAudio(_THIS, SDL_AudioSpec * spec);
static void Mint_InitAudio(_THIS, SDL_AudioSpec * spec);
82
83
84
/*--- Audio driver bootstrap functions ---*/
85
86
static int
Audio_Available(void)
88
const char *envr = SDL_getenv("SDL_AUDIODRIVER");
90
91
92
93
94
/* Check if user asked a different audio driver */
if ((envr) && (SDL_strcmp(envr, MINT_AUDIO_DRIVER_NAME) != 0)) {
DEBUG_PRINT((DEBUG_NAME "user asked a different audio driver\n"));
return (0);
}
96
97
98
99
/* Cookie _MCH present ? if not, assume ST machine */
if (Getcookie(C__MCH, &cookie_mch) == C_NOTFOUND) {
cookie_mch = MCH_ST;
}
101
102
103
104
/* Cookie _SND present ? if not, assume ST machine */
if (Getcookie(C__SND, &cookie_snd) == C_NOTFOUND) {
cookie_snd = SND_PSG;
}
106
107
108
109
110
/* Cookie STFA present ? */
if (Getcookie(C_STFA, (long *) &cookie_stfa) != C_FOUND) {
DEBUG_PRINT((DEBUG_NAME "no STFA audio\n"));
return (0);
}
112
SDL_MintAudio_stfa = cookie_stfa;
114
115
DEBUG_PRINT((DEBUG_NAME "STFA audio available!\n"));
return (1);
118
119
static void
Audio_DeleteDevice(SDL_AudioDevice * device)
121
122
SDL_free(device->hidden);
SDL_free(device);
125
126
static SDL_AudioDevice *
Audio_CreateDevice(int devindex)
128
SDL_AudioDevice *this;
130
131
132
/* Initialize all variables that we clean on shutdown */
this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
if (this) {
133
SDL_memset(this, 0, (sizeof *this));
134
this->hidden = (struct SDL_PrivateAudioData *)
135
SDL_malloc((sizeof *this->hidden));
137
if ((this == NULL) || (this->hidden == NULL)) {
138
SDL_OutOfMemory();
140
SDL_free(this);
144
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
145
146
/* Set the function pointers */
147
148
149
this->OpenAudio = Mint_OpenAudio;
this->CloseAudio = Mint_CloseAudio;
this->LockAudio = Mint_LockAudio;
150
this->UnlockAudio = Mint_UnlockAudio;
151
this->free = Audio_DeleteDevice;
153
154
155
156
157
/* Uses interrupt driven audio, without thread */
#if SDL_THREADS_DISABLED
this->SkipMixerLock = 1;
#endif
158
159
160
161
return this;
}
AudioBootStrap MINTAUDIO_STFA_bootstrap = {
162
163
MINT_AUDIO_DRIVER_NAME, "MiNT STFA audio driver",
Audio_Available, Audio_CreateDevice
166
167
static void
Mint_LockAudio(_THIS)
169
void *oldpile;
171
172
173
174
/* Stop replay */
oldpile = (void *) Super(0);
cookie_stfa->sound_enable = STFA_PLAY_DISABLE;
Super(oldpile);
177
178
static void
Mint_UnlockAudio(_THIS)
180
void *oldpile;
182
183
184
185
/* Restart replay */
oldpile = (void *) Super(0);
cookie_stfa->sound_enable = STFA_PLAY_ENABLE | STFA_PLAY_REPEAT;
Super(oldpile);
188
189
static void
Mint_CloseAudio(_THIS)
191
void *oldpile;
193
194
195
196
/* Stop replay */
oldpile = (void *) Super(0);
cookie_stfa->sound_enable = STFA_PLAY_DISABLE;
Super(oldpile);
198
199
200
/* Wait if currently playing sound */
while (SDL_MintAudio_mutex != 0) {
}
202
203
204
205
206
/* Clear buffers */
if (SDL_MintAudio_audiobuf[0]) {
Mfree(SDL_MintAudio_audiobuf[0]);
SDL_MintAudio_audiobuf[0] = SDL_MintAudio_audiobuf[1] = NULL;
}
209
210
static int
Mint_CheckAudio(_THIS, SDL_AudioSpec * spec)
214
215
DEBUG_PRINT((DEBUG_NAME "asked: %d bits, ",
SDL_AUDIO_BITSIZE(spec->format)));
216
217
218
DEBUG_PRINT(("float=%d, ", SDL_AUDIO_ISFLOAT(spec->format)));
DEBUG_PRINT(("signed=%d, ", SDL_AUDIO_ISSIGNED(spec->format)));
DEBUG_PRINT(("big endian=%d, ", SDL_AUDIO_ISBIGENDIAN(spec->format)));
219
220
221
DEBUG_PRINT(("channels=%d, ", spec->channels));
DEBUG_PRINT(("freq=%d\n", spec->freq));
222
if (SDL_AUDIO_BITSIZE(spec->format) > 16) {
223
spec->format = AUDIO_S16SYS; /* clamp out int32/float32 ... */
224
225
226
}
if (spec->channels > 2) {
227
spec->channels = 2; /* no more than stereo! */
230
231
232
233
234
/* Check formats available */
MINTAUDIO_freqcount = 0;
for (i = 0; i < 16; i++) {
SDL_MintAudio_AddFrequency(this, freqs[i], 0, i, -1);
}
237
238
239
240
241
242
for (i = 0; i < MINTAUDIO_freqcount; i++) {
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));
}
243
244
#endif
245
246
MINTAUDIO_numfreq = SDL_MintAudio_SearchFrequency(this, spec->freq);
spec->freq = MINTAUDIO_frequencies[MINTAUDIO_numfreq].frequency;
248
249
DEBUG_PRINT((DEBUG_NAME "obtained: %d bits, ",
SDL_AUDIO_BITSIZE(spec->format)));
250
251
252
DEBUG_PRINT(("float=%d, ", SDL_AUDIO_ISFLOAT(spec->format)));
DEBUG_PRINT(("signed=%d, ", SDL_AUDIO_ISSIGNED(spec->format)));
DEBUG_PRINT(("big endian=%d, ", SDL_AUDIO_ISBIGENDIAN(spec->format)));
253
254
DEBUG_PRINT(("channels=%d, ", spec->channels));
DEBUG_PRINT(("freq=%d\n", spec->freq));
259
260
static void
Mint_InitAudio(_THIS, SDL_AudioSpec * spec)
262
263
void *buffer;
void *oldpile;
265
buffer = SDL_MintAudio_audiobuf[SDL_MintAudio_numbuf];
267
oldpile = (void *) Super(0);
269
270
/* Stop replay */
cookie_stfa->sound_enable = STFA_PLAY_DISABLE;
272
273
274
/* Select replay format */
cookie_stfa->sound_control =
MINTAUDIO_frequencies[MINTAUDIO_numfreq].predivisor;
275
if (SDL_AUDIO_BITSIZE(spec->format) == 8) {
276
277
278
279
280
281
282
283
284
cookie_stfa->sound_control |= STFA_FORMAT_8BIT;
} else {
cookie_stfa->sound_control |= STFA_FORMAT_16BIT;
}
if (spec->channels == 2) {
cookie_stfa->sound_control |= STFA_FORMAT_STEREO;
} else {
cookie_stfa->sound_control |= STFA_FORMAT_MONO;
}
285
if (SDL_AUDIO_ISSIGNED(spec->format) != 0) {
286
287
288
289
cookie_stfa->sound_control |= STFA_FORMAT_SIGNED;
} else {
cookie_stfa->sound_control |= STFA_FORMAT_UNSIGNED;
}
290
if (SDL_AUDIO_ISBIGENDIAN(spec->format) != 0) {
291
292
293
294
cookie_stfa->sound_control |= STFA_FORMAT_BIGENDIAN;
} else {
cookie_stfa->sound_control |= STFA_FORMAT_LITENDIAN;
}
296
297
298
/* Set buffer */
cookie_stfa->sound_start = (unsigned long) buffer;
cookie_stfa->sound_end = (unsigned long) (buffer + spec->size);
300
301
/* Set interrupt */
cookie_stfa->stfa_it = SDL_MintAudio_StfaInterrupt;
303
304
/* Restart replay */
cookie_stfa->sound_enable = STFA_PLAY_ENABLE | STFA_PLAY_REPEAT;
306
Super(oldpile);
308
DEBUG_PRINT((DEBUG_NAME "hardware initialized\n"));
311
312
static int
Mint_OpenAudio(_THIS, SDL_AudioSpec * spec)
314
SDL_MintAudio_device = this;
316
317
318
319
/* Check audio capabilities */
if (Mint_CheckAudio(this, spec) == -1) {
return -1;
}
321
SDL_CalculateAudioSpec(spec);
323
324
/* Allocate memory for audio buffers in DMA-able RAM */
DEBUG_PRINT((DEBUG_NAME "buffer size=%d\n", spec->size));
326
327
328
329
330
331
332
333
334
335
SDL_MintAudio_audiobuf[0] = Atari_SysMalloc(spec->size * 2, MX_STRAM);
if (SDL_MintAudio_audiobuf[0] == NULL) {
SDL_SetError("MINT_OpenAudio: Not enough memory for audio buffer");
return (-1);
}
SDL_MintAudio_audiobuf[1] = SDL_MintAudio_audiobuf[0] + spec->size;
SDL_MintAudio_numbuf = 0;
SDL_memset(SDL_MintAudio_audiobuf[0], spec->silence, spec->size * 2);
SDL_MintAudio_audiosize = spec->size;
SDL_MintAudio_mutex = 0;
337
338
339
340
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]));
342
343
SDL_MintAudio_CheckFpu();
344
345
/* Setup audio hardware */
Mint_InitAudio(this, spec);
347
return (1); /* We don't use threaded audio */
349
350
/* vi: set ts=4 sw=4 expandtab: */