SDL_mintaudio_stfa.c
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2012 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
41
42
43
44
45
46
47
48
#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: "
50
51
52
53
54
55
56
57
58
59
#define DEBUG_PRINT(what) \
{ \
printf what; \
}
#else
#define DEBUG_PRINT(what)
#endif
/*--- Static variables ---*/
60
static long cookie_snd, cookie_mch;
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
static cookie_stfa_t *cookie_stfa;
static const int freqs[16]={
4995, 6269, 7493, 8192,
9830, 10971, 12538, 14985,
16384, 19819, 21943, 24576,
30720, 32336, 43885, 49152
};
/*--- Audio driver functions ---*/
static void Mint_CloseAudio(_THIS);
static int Mint_OpenAudio(_THIS, SDL_AudioSpec *spec);
static void Mint_LockAudio(_THIS);
static void Mint_UnlockAudio(_THIS);
/* To check/init hardware audio */
static int Mint_CheckAudio(_THIS, SDL_AudioSpec *spec);
static void Mint_InitAudio(_THIS, SDL_AudioSpec *spec);
80
static void Mint_SwapBuffers(Uint8 *nextbuf, int nextsize);
81
82
83
84
85
/*--- Audio driver bootstrap functions ---*/
static int Audio_Available(void)
{
86
long dummy;
87
const char *envr = SDL_getenv("SDL_AUDIODRIVER");
88
89
/* Check if user asked a different audio driver */
90
if ((envr) && (SDL_strcmp(envr, MINT_AUDIO_DRIVER_NAME)!=0)) {
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
DEBUG_PRINT((DEBUG_NAME "user asked a different audio driver\n"));
return(0);
}
/* Cookie _MCH present ? if not, assume ST machine */
if (Getcookie(C__MCH, &cookie_mch) == C_NOTFOUND) {
cookie_mch = MCH_ST;
}
/* Cookie _SND present ? if not, assume ST machine */
if (Getcookie(C__SND, &cookie_snd) == C_NOTFOUND) {
cookie_snd = SND_PSG;
}
/* Cookie STFA present ? */
106
if (Getcookie(C_STFA, &dummy) != C_FOUND) {
107
108
109
DEBUG_PRINT((DEBUG_NAME "no STFA audio\n"));
return(0);
}
110
cookie_stfa = (cookie_stfa_t *) dummy;
111
112
113
114
115
116
117
DEBUG_PRINT((DEBUG_NAME "STFA audio available!\n"));
return(1);
}
static void Audio_DeleteDevice(SDL_AudioDevice *device)
{
118
119
SDL_free(device->hidden);
SDL_free(device);
120
121
122
123
124
125
126
}
static SDL_AudioDevice *Audio_CreateDevice(int devindex)
{
SDL_AudioDevice *this;
/* Initialize all variables that we clean on shutdown */
127
this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
128
if ( this ) {
129
SDL_memset(this, 0, (sizeof *this));
130
this->hidden = (struct SDL_PrivateAudioData *)
131
SDL_malloc((sizeof *this->hidden));
132
133
134
135
}
if ( (this == NULL) || (this->hidden == NULL) ) {
SDL_OutOfMemory();
if ( this ) {
136
SDL_free(this);
137
138
139
}
return(0);
}
140
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
/* Set the function pointers */
this->OpenAudio = Mint_OpenAudio;
this->CloseAudio = Mint_CloseAudio;
this->LockAudio = Mint_LockAudio;
this->UnlockAudio = Mint_UnlockAudio;
this->free = Audio_DeleteDevice;
return this;
}
AudioBootStrap MINTAUDIO_STFA_bootstrap = {
MINT_AUDIO_DRIVER_NAME, "MiNT STFA audio driver",
Audio_Available, Audio_CreateDevice
};
static void Mint_LockAudio(_THIS)
{
159
cookie_stfa->sound_enable=STFA_PLAY_DISABLE;
160
161
162
163
164
165
166
167
168
169
170
}
static void Mint_UnlockAudio(_THIS)
{
cookie_stfa->sound_enable=STFA_PLAY_ENABLE|STFA_PLAY_REPEAT;
}
static void Mint_CloseAudio(_THIS)
{
cookie_stfa->sound_enable=STFA_PLAY_DISABLE;
171
SDL_MintAudio_FreeBuffers();
172
173
174
175
176
177
178
179
}
static int Mint_CheckAudio(_THIS, SDL_AudioSpec *spec)
{
int i;
DEBUG_PRINT((DEBUG_NAME "asked: %d bits, ",spec->format & 0x00ff));
DEBUG_PRINT(("signed=%d, ", ((spec->format & 0x8000)!=0)));
180
DEBUG_PRINT(("big endian=%d, ", ((spec->format & 0x1000)!=0)));
181
182
183
DEBUG_PRINT(("channels=%d, ", spec->channels));
DEBUG_PRINT(("freq=%d\n", spec->freq));
184
185
186
187
if (spec->channels > 2) {
spec->channels = 2; /* no more than stereo! */
}
188
/* Check formats available */
189
190
MINTAUDIO_freqcount=0;
for (i=0;i<16;i++) {
191
SDL_MintAudio_AddFrequency(this, freqs[i], 0, i, -1);
194
195
196
197
198
199
200
201
202
203
204
#if 1
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
));
}
#endif
MINTAUDIO_numfreq=SDL_MintAudio_SearchFrequency(this, spec->freq);
spec->freq=MINTAUDIO_frequencies[MINTAUDIO_numfreq].frequency;
205
206
207
DEBUG_PRINT((DEBUG_NAME "obtained: %d bits, ",spec->format & 0x00ff));
DEBUG_PRINT(("signed=%d, ", ((spec->format & 0x8000)!=0)));
208
DEBUG_PRINT(("big endian=%d, ", ((spec->format & 0x1000)!=0)));
209
210
211
212
213
214
215
216
217
218
219
220
DEBUG_PRINT(("channels=%d, ", spec->channels));
DEBUG_PRINT(("freq=%d\n", spec->freq));
return 0;
}
static void Mint_InitAudio(_THIS, SDL_AudioSpec *spec)
{
/* Stop replay */
cookie_stfa->sound_enable=STFA_PLAY_DISABLE;
/* Select replay format */
221
cookie_stfa->sound_control = MINTAUDIO_frequencies[MINTAUDIO_numfreq].predivisor;
222
223
224
225
226
227
228
229
230
231
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;
}
232
if ((spec->format & 0x8000)!=0) {
233
234
235
236
cookie_stfa->sound_control |= STFA_FORMAT_SIGNED;
} else {
cookie_stfa->sound_control |= STFA_FORMAT_UNSIGNED;
}
237
if ((spec->format & 0x1000)!=0) {
238
cookie_stfa->sound_control |= STFA_FORMAT_BIGENDIAN;
239
240
} else {
cookie_stfa->sound_control |= STFA_FORMAT_LITENDIAN;
241
242
243
}
/* Set buffer */
244
Mint_SwapBuffers(MINTAUDIO_audiobuf[0], MINTAUDIO_audiosize);
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
/* Set interrupt */
cookie_stfa->stfa_it = SDL_MintAudio_StfaInterrupt;
/* Restart replay */
cookie_stfa->sound_enable=STFA_PLAY_ENABLE|STFA_PLAY_REPEAT;
DEBUG_PRINT((DEBUG_NAME "hardware initialized\n"));
}
static int Mint_OpenAudio(_THIS, SDL_AudioSpec *spec)
{
SDL_MintAudio_device = this;
/* Check audio capabilities */
if (Mint_CheckAudio(this, spec)==-1) {
return -1;
}
264
265
if (!SDL_MintAudio_InitBuffers(spec)) {
return -1;
268
/* Setup audio hardware */
269
MINTAUDIO_swapbuf = Mint_SwapBuffers;
270
271
272
273
Mint_InitAudio(this, spec);
return(1); /* We don't use threaded audio */
}
274
275
276
277
278
279
static void Mint_SwapBuffers(Uint8 *nextbuf, int nextsize)
{
cookie_stfa->sound_start = (unsigned long) nextbuf;
cookie_stfa->sound_end = cookie_stfa->sound_start + nextsize;
}