This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_mintaudio_stfa.c
331 lines (264 loc) · 8.81 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
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"
39
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: "
51
#if 0
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
};
/*--- Audio driver functions ---*/
74
75
76
77
static void Mint_CloseAudio(_THIS);
static int Mint_OpenAudio(_THIS, SDL_AudioSpec * spec);
static void Mint_LockAudio(_THIS);
static void Mint_UnlockAudio(_THIS);
78
79
/* 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
static int
86
Audio_Available(void)
87
{
88
const char *envr = SDL_getenv("SDL_AUDIODRIVER");
89
90
/* Check if user asked a different audio driver */
91
92
if ((envr) && (SDL_strcmp(envr, MINT_AUDIO_DRIVER_NAME) != 0)) {
DEBUG_PRINT((DEBUG_NAME "user asked a different audio driver\n"));
93
94
return (0);
}
95
96
/* Cookie _MCH present ? if not, assume ST machine */
97
if (Getcookie(C__MCH, &cookie_mch) == C_NOTFOUND) {
98
99
cookie_mch = MCH_ST;
}
100
101
/* Cookie _SND present ? if not, assume ST machine */
102
if (Getcookie(C__SND, &cookie_snd) == C_NOTFOUND) {
103
104
cookie_snd = SND_PSG;
}
105
106
/* Cookie STFA present ? */
107
108
if (Getcookie(C_STFA, (long *) &cookie_stfa) != C_FOUND) {
DEBUG_PRINT((DEBUG_NAME "no STFA audio\n"));
109
110
return (0);
}
111
112
SDL_MintAudio_stfa = cookie_stfa;
113
114
DEBUG_PRINT((DEBUG_NAME "STFA audio available!\n"));
115
return (1);
116
117
}
118
static void
119
Audio_DeleteDevice(SDL_AudioDevice * device)
120
{
121
122
SDL_free(device->hidden);
SDL_free(device);
123
124
}
125
static SDL_AudioDevice *
126
Audio_CreateDevice(int devindex)
127
{
128
SDL_AudioDevice *this;
129
130
/* Initialize all variables that we clean on shutdown */
131
this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
132
if (this) {
133
SDL_memset(this, 0, (sizeof *this));
134
this->hidden = (struct SDL_PrivateAudioData *)
135
SDL_malloc((sizeof *this->hidden));
136
}
137
if ((this == NULL) || (this->hidden == NULL)) {
138
SDL_OutOfMemory();
139
if (this) {
140
SDL_free(this);
141
}
142
return (0);
143
}
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;
152
153
154
155
156
return this;
}
AudioBootStrap MINTAUDIO_STFA_bootstrap = {
157
158
MINT_AUDIO_DRIVER_NAME, "MiNT STFA audio driver",
Audio_Available, Audio_CreateDevice
159
160
};
161
static void
162
Mint_LockAudio(_THIS)
163
{
164
void *oldpile;
165
166
/* Stop replay */
167
oldpile = (void *) Super(0);
168
cookie_stfa->sound_enable = STFA_PLAY_DISABLE;
169
Super(oldpile);
170
171
}
172
static void
173
Mint_UnlockAudio(_THIS)
174
{
175
void *oldpile;
176
177
/* Restart replay */
178
oldpile = (void *) Super(0);
179
cookie_stfa->sound_enable = STFA_PLAY_ENABLE | STFA_PLAY_REPEAT;
180
Super(oldpile);
181
182
}
183
static void
184
Mint_CloseAudio(_THIS)
185
{
186
void *oldpile;
187
188
/* Stop replay */
189
oldpile = (void *) Super(0);
190
cookie_stfa->sound_enable = STFA_PLAY_DISABLE;
191
Super(oldpile);
192
193
194
195
/* Wait if currently playing sound */
while (SDL_MintAudio_mutex != 0) {
}
196
197
198
/* Clear buffers */
if (SDL_MintAudio_audiobuf[0]) {
199
Mfree(SDL_MintAudio_audiobuf[0]);
200
201
SDL_MintAudio_audiobuf[0] = SDL_MintAudio_audiobuf[1] = NULL;
}
202
203
}
204
static int
205
Mint_CheckAudio(_THIS, SDL_AudioSpec * spec)
206
{
207
208
int i;
209
210
211
212
213
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));
214
215
216
217
/* Check formats available */
MINTAUDIO_freqcount = 0;
for (i = 0; i < 16; i++) {
218
SDL_MintAudio_AddFrequency(this, freqs[i], 0, i, -1);
219
}
220
221
#if 1
222
for (i = 0; i < MINTAUDIO_freqcount; i++) {
223
224
225
226
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));
227
}
228
229
#endif
230
MINTAUDIO_numfreq = SDL_MintAudio_SearchFrequency(this, spec->freq);
231
spec->freq = MINTAUDIO_frequencies[MINTAUDIO_numfreq].frequency;
232
233
234
235
236
237
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));
238
239
return 0;
240
241
}
242
static void
243
Mint_InitAudio(_THIS, SDL_AudioSpec * spec)
244
{
245
246
void *buffer;
void *oldpile;
247
248
buffer = SDL_MintAudio_audiobuf[SDL_MintAudio_numbuf];
249
250
oldpile = (void *) Super(0);
251
252
253
/* Stop replay */
cookie_stfa->sound_enable = STFA_PLAY_DISABLE;
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
/* Select replay format */
cookie_stfa->sound_control =
MINTAUDIO_frequencies[MINTAUDIO_numfreq].predivisor;
if ((spec->format & 0xff) == 8) {
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;
}
if ((spec->format & 0x8000) != 0) {
cookie_stfa->sound_control |= STFA_FORMAT_SIGNED;
} else {
cookie_stfa->sound_control |= STFA_FORMAT_UNSIGNED;
}
if ((spec->format & 0x1000) != 0) {
cookie_stfa->sound_control |= STFA_FORMAT_BIGENDIAN;
} else {
cookie_stfa->sound_control |= STFA_FORMAT_LITENDIAN;
}
278
279
280
281
/* Set buffer */
cookie_stfa->sound_start = (unsigned long) buffer;
cookie_stfa->sound_end = (unsigned long) (buffer + spec->size);
282
283
284
/* Set interrupt */
cookie_stfa->stfa_it = SDL_MintAudio_StfaInterrupt;
285
286
287
/* Restart replay */
cookie_stfa->sound_enable = STFA_PLAY_ENABLE | STFA_PLAY_REPEAT;
288
289
Super(oldpile);
290
291
DEBUG_PRINT((DEBUG_NAME "hardware initialized\n"));
292
293
}
294
static int
295
Mint_OpenAudio(_THIS, SDL_AudioSpec * spec)
296
{
297
SDL_MintAudio_device = this;
298
299
/* Check audio capabilities */
300
if (Mint_CheckAudio(this, spec) == -1) {
301
302
return -1;
}
303
304
SDL_CalculateAudioSpec(spec);
305
306
/* Allocate memory for audio buffers in DMA-able RAM */
307
DEBUG_PRINT((DEBUG_NAME "buffer size=%d\n", spec->size));
308
309
SDL_MintAudio_audiobuf[0] = Atari_SysMalloc(spec->size * 2, MX_STRAM);
310
if (SDL_MintAudio_audiobuf[0] == NULL) {
311
SDL_SetError("MINT_OpenAudio: Not enough memory for audio buffer");
312
313
314
315
return (-1);
}
SDL_MintAudio_audiobuf[1] = SDL_MintAudio_audiobuf[0] + spec->size;
SDL_MintAudio_numbuf = 0;
316
SDL_memset(SDL_MintAudio_audiobuf[0], spec->silence, spec->size * 2);
317
318
SDL_MintAudio_audiosize = spec->size;
SDL_MintAudio_mutex = 0;
319
320
321
322
323
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]));
324
325
/* Setup audio hardware */
326
Mint_InitAudio(this, spec);
327
328
return (1); /* We don't use threaded audio */
329
}
330
331
/* vi: set ts=4 sw=4 expandtab: */