[sdl_omap.git] / src / audio / mint / SDL_mintaudio_dma8.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    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
*/
#include "SDL_config.h"

/*
	MiNT audio driver
	using DMA 8bits (hardware access)

	Patrice Mandin
*/

/* Mint includes */
#include <mint/osbind.h>
#include <mint/falcon.h>
#include <mint/cookie.h>

#include "SDL_audio.h"
#include "../SDL_audio_c.h"
#include "../SDL_sysaudio.h"

#include "../../video/ataricommon/SDL_atarimxalloc_c.h"

#include "SDL_mintaudio.h"
#include "SDL_mintaudio_dma8.h"

/*--- Defines ---*/

#define MINT_AUDIO_DRIVER_NAME "mint_dma8"

/* Debug print info */
#define DEBUG_NAME "audio:dma8: "
#if 0
#define DEBUG_PRINT(what) \
	{ \
		printf what; \
	}
#else
#define DEBUG_PRINT(what)
#endif

/*--- Static variables ---*/

static unsigned long cookie_snd, cookie_mch;

/*--- 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);

/*--- Audio driver bootstrap functions ---*/

static int Audio_Available(void)
{
	const char *envr = SDL_getenv("SDL_AUDIODRIVER");

	/* 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;
	}

	/* 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;
	}

	/* Check if we have 8 bits audio */
	if ((cookie_snd & SND_8BIT)==0) {
		DEBUG_PRINT((DEBUG_NAME "no 8 bits sound\n"));
	    return(0);
	}

	/* Check if audio is lockable */
	if (cookie_snd & SND_16BIT) {
		if (Locksnd()!=1) {
			DEBUG_PRINT((DEBUG_NAME "audio locked by other application\n"));
			return(0);
		}

		Unlocksnd();
	}

	DEBUG_PRINT((DEBUG_NAME "8 bits audio available!\n"));
	return(1);
}

static void Audio_DeleteDevice(SDL_AudioDevice *device)
{
    SDL_free(device->hidden);
    SDL_free(device);
}

static SDL_AudioDevice *Audio_CreateDevice(int devindex)
{
	SDL_AudioDevice *this;

	/* Initialize all variables that we clean on shutdown */
	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
    if ( this ) {
        SDL_memset(this, 0, (sizeof *this));
        this->hidden = (struct SDL_PrivateAudioData *)
                SDL_malloc((sizeof *this->hidden));
    }
    if ( (this == NULL) || (this->hidden == NULL) ) {
        SDL_OutOfMemory();
        if ( this ) {
            SDL_free(this);
        }
        return(0);
    }
    SDL_memset(this->hidden, 0, (sizeof *this->hidden));

    /* 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_DMA8_bootstrap = {
	MINT_AUDIO_DRIVER_NAME, "MiNT DMA 8 bits audio driver",
	Audio_Available, Audio_CreateDevice
};

static void Mint_LockAudio(_THIS)
{
	void *oldpile;

	/* Stop replay */
	oldpile=(void *)Super(0);
	DMAAUDIO_IO.control=0;
	Super(oldpile);
}

static void Mint_UnlockAudio(_THIS)
{
	void *oldpile;

	/* Restart replay */
	oldpile=(void *)Super(0);
	DMAAUDIO_IO.control=3;
	Super(oldpile);
}

static void Mint_CloseAudio(_THIS)
{
	void *oldpile;

	/* Stop replay */
	oldpile=(void *)Super(0);
	DMAAUDIO_IO.control=0;
	Super(oldpile);

	DEBUG_PRINT((DEBUG_NAME "closeaudio: replay stopped\n"));

	/* Disable interrupt */
	Jdisint(MFP_DMASOUND);

	DEBUG_PRINT((DEBUG_NAME "closeaudio: interrupt disabled\n"));

	/* Wait if currently playing sound */
	while (SDL_MintAudio_mutex != 0) {
	}

	DEBUG_PRINT((DEBUG_NAME "closeaudio: no more interrupt running\n"));

	/* Clear buffers */
	if (SDL_MintAudio_audiobuf[0]) {
		Mfree(SDL_MintAudio_audiobuf[0]);
		SDL_MintAudio_audiobuf[0] = SDL_MintAudio_audiobuf[1] = NULL;
	}

	DEBUG_PRINT((DEBUG_NAME "closeaudio: buffers freed\n"));
}

static int Mint_CheckAudio(_THIS, SDL_AudioSpec *spec)
{
	int i, masterprediv, sfreq;
	unsigned long masterclock;

	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));

	if (spec->channels > 2)
		spec->channels = 2;

	/* Check formats available */
	spec->format = AUDIO_S8;
	
	/* Calculate and select the closest frequency */
	sfreq=0;
	masterclock=MASTERCLOCK_STE;
	masterprediv=MASTERPREDIV_STE;
	switch(cookie_mch>>16) {
/*
		case MCH_STE:
			masterclock=MASTERCLOCK_STE;
			masterprediv=MASTERPREDIV_STE;
			break;
*/
		case MCH_TT:
			masterclock=MASTERCLOCK_TT;
			masterprediv=MASTERPREDIV_TT;
			break;
		case MCH_F30:
		case MCH_ARANYM:
			masterclock=MASTERCLOCK_FALCON1;
			masterprediv=MASTERPREDIV_FALCON;
			sfreq=1;
			break;
	}
	
	MINTAUDIO_freqcount=0;
	for (i=sfreq;i<4;i++) {
		SDL_MintAudio_AddFrequency(this, masterclock/(masterprediv*(1<<i)),
			masterclock, i-sfreq, -1);
	}

#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;

	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));

	return 0;
}

static void Mint_InitAudio(_THIS, SDL_AudioSpec *spec)
{
	void *oldpile;
	unsigned long buffer;
	unsigned char mode;
	
	/* Set replay tracks */
	if (cookie_snd & SND_16BIT) {
		Settracks(0,0);
		Setmontracks(0);
	}

	oldpile=(void *)Super(0);

	/* Stop currently playing sound */
	DMAAUDIO_IO.control=0;

	/* Set buffer */
	buffer = (unsigned long) SDL_MintAudio_audiobuf[SDL_MintAudio_numbuf];
	DMAAUDIO_IO.start_high = (buffer>>16) & 255;
	DMAAUDIO_IO.start_mid = (buffer>>8) & 255;
	DMAAUDIO_IO.start_low = buffer & 255;

	buffer += SDL_MintAudio_audiosize;
	DMAAUDIO_IO.end_high = (buffer>>16) & 255;
	DMAAUDIO_IO.end_mid = (buffer>>8) & 255;
	DMAAUDIO_IO.end_low = buffer & 255;

	mode = 3-MINTAUDIO_frequencies[MINTAUDIO_numfreq].predivisor;
	if (spec->channels==1) {
		mode |= 1<<7;
	}
	DMAAUDIO_IO.sound_ctrl = mode;	

	/* Set interrupt */
	Jdisint(MFP_DMASOUND);
	Xbtimer(XB_TIMERA, 8, 1, SDL_MintAudio_Dma8Interrupt);
	Jenabint(MFP_DMASOUND);

	if (cookie_snd & SND_16BIT) {
		if (Setinterrupt(SI_TIMERA, SI_PLAY)<0) {
			DEBUG_PRINT((DEBUG_NAME "Setinterrupt() failed\n"));
		}
	}

	/* Go */
	DMAAUDIO_IO.control = 3;	/* playback + repeat */

	Super(oldpile);
}

static int Mint_OpenAudio(_THIS, SDL_AudioSpec *spec)
{
	SDL_MintAudio_device = this;

	/* Check audio capabilities */
	if (Mint_CheckAudio(this, spec)==-1) {
		return -1;
	}

	SDL_CalculateAudioSpec(spec);

	/* Allocate memory for audio buffers in DMA-able RAM */
	DEBUG_PRINT((DEBUG_NAME "buffer size=%d\n", spec->size));

	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;

	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]));

	SDL_MintAudio_CheckFpu();

	/* Setup audio hardware */
	Mint_InitAudio(this, spec);

    return(1);	/* We don't use threaded audio */
}
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 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 DMA 8bits (hardware access)
	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_dma8.h"
	44
	45	/--- Defines ---/
	46
	47	#define MINT_AUDIO_DRIVER_NAME "mint_dma8"
	48
	49	/* Debug print info */
	50	#define DEBUG_NAME "audio:dma8: "
	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 unsigned long cookie_snd, cookie_mch;
	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	/--- Audio driver bootstrap functions ---/
76
77	static int Audio_Available(void)
78	{
79	const char *envr = SDL_getenv("SDL_AUDIODRIVER");
80
81	/* Check if user asked a different audio driver */
82	if ((envr) && (SDL_strcmp(envr, MINT_AUDIO_DRIVER_NAME)!=0)) {
83	DEBUG_PRINT((DEBUG_NAME "user asked a different audio driver\n"));
84	return 0;
85	}
86
87	/* Cookie _MCH present ? if not, assume ST machine */
88	if (Getcookie(C__MCH, &cookie_mch) == C_NOTFOUND) {
89	cookie_mch = MCH_ST;
90	}
91
92	/* Cookie _SND present ? if not, assume ST machine */
93	if (Getcookie(C__SND, &cookie_snd) == C_NOTFOUND) {
94	cookie_snd = SND_PSG;
95	}
96
97	/* Check if we have 8 bits audio */
98	if ((cookie_snd & SND_8BIT)==0) {
99	DEBUG_PRINT((DEBUG_NAME "no 8 bits sound\n"));
100	return(0);
101	}
102
103	/* Check if audio is lockable */
104	if (cookie_snd & SND_16BIT) {
105	if (Locksnd()!=1) {
106	DEBUG_PRINT((DEBUG_NAME "audio locked by other application\n"));
107	return(0);
108	}
109
110	Unlocksnd();
111	}
112
113	DEBUG_PRINT((DEBUG_NAME "8 bits audio available!\n"));
114	return(1);
115	}
116
117	static void Audio_DeleteDevice(SDL_AudioDevice *device)
118	{
119	SDL_free(device->hidden);
120	SDL_free(device);
121	}
122
123	static SDL_AudioDevice *Audio_CreateDevice(int devindex)
124	{
125	SDL_AudioDevice *this;
126
127	/* Initialize all variables that we clean on shutdown */
128	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
129	if ( this ) {
130	SDL_memset(this, 0, (sizeof *this));
131	this->hidden = (struct SDL_PrivateAudioData *)
132	SDL_malloc((sizeof *this->hidden));
133	}
134	if ( (this == NULL) \|\| (this->hidden == NULL) ) {
135	SDL_OutOfMemory();
136	if ( this ) {
137	SDL_free(this);
138	}
139	return(0);
140	}
141	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
142
143	/* Set the function pointers */
144	this->OpenAudio = Mint_OpenAudio;
145	this->CloseAudio = Mint_CloseAudio;
146	this->LockAudio = Mint_LockAudio;
147	this->UnlockAudio = Mint_UnlockAudio;
148	this->free = Audio_DeleteDevice;
149
150	return this;
151	}
152
153	AudioBootStrap MINTAUDIO_DMA8_bootstrap = {
154	MINT_AUDIO_DRIVER_NAME, "MiNT DMA 8 bits audio driver",
155	Audio_Available, Audio_CreateDevice
156	};
157
158	static void Mint_LockAudio(_THIS)
159	{
160	void *oldpile;
161
162	/* Stop replay */
163	oldpile=(void *)Super(0);
164	DMAAUDIO_IO.control=0;
165	Super(oldpile);
166	}
167
168	static void Mint_UnlockAudio(_THIS)
169	{
170	void *oldpile;
171
172	/* Restart replay */
173	oldpile=(void *)Super(0);
174	DMAAUDIO_IO.control=3;
175	Super(oldpile);
176	}
177
178	static void Mint_CloseAudio(_THIS)
179	{
180	void *oldpile;
181
182	/* Stop replay */
183	oldpile=(void *)Super(0);
184	DMAAUDIO_IO.control=0;
185	Super(oldpile);
186
187	DEBUG_PRINT((DEBUG_NAME "closeaudio: replay stopped\n"));
188
189	/* Disable interrupt */
190	Jdisint(MFP_DMASOUND);
191
192	DEBUG_PRINT((DEBUG_NAME "closeaudio: interrupt disabled\n"));
193
194	/* Wait if currently playing sound */
195	while (SDL_MintAudio_mutex != 0) {
196	}
197
198	DEBUG_PRINT((DEBUG_NAME "closeaudio: no more interrupt running\n"));
199
200	/* Clear buffers */
201	if (SDL_MintAudio_audiobuf[0]) {
202	Mfree(SDL_MintAudio_audiobuf[0]);
203	SDL_MintAudio_audiobuf[0] = SDL_MintAudio_audiobuf[1] = NULL;
204	}
205
206	DEBUG_PRINT((DEBUG_NAME "closeaudio: buffers freed\n"));
207	}
208
209	static int Mint_CheckAudio(_THIS, SDL_AudioSpec *spec)
210	{
211	int i, masterprediv, sfreq;
212	unsigned long masterclock;
213
214	DEBUG_PRINT((DEBUG_NAME "asked: %d bits, ",spec->format & 0x00ff));
215	DEBUG_PRINT(("signed=%d, ", ((spec->format & 0x8000)!=0)));
216	DEBUG_PRINT(("big endian=%d, ", ((spec->format & 0x1000)!=0)));
217	DEBUG_PRINT(("channels=%d, ", spec->channels));
218	DEBUG_PRINT(("freq=%d\n", spec->freq));
219
220	if (spec->channels > 2)
221	spec->channels = 2;
222
223	/* Check formats available */
224	spec->format = AUDIO_S8;
225
226	/* Calculate and select the closest frequency */
227	sfreq=0;
228	masterclock=MASTERCLOCK_STE;
229	masterprediv=MASTERPREDIV_STE;
230	switch(cookie_mch>>16) {
231	/*
232	case MCH_STE:
233	masterclock=MASTERCLOCK_STE;
234	masterprediv=MASTERPREDIV_STE;
235	break;
236	*/
237	case MCH_TT:
238	masterclock=MASTERCLOCK_TT;
239	masterprediv=MASTERPREDIV_TT;
240	break;
241	case MCH_F30:
242	case MCH_ARANYM:
243	masterclock=MASTERCLOCK_FALCON1;
244	masterprediv=MASTERPREDIV_FALCON;
245	sfreq=1;
246	break;
247	}
248
249	MINTAUDIO_freqcount=0;
250	for (i=sfreq;i<4;i++) {
251	SDL_MintAudio_AddFrequency(this, masterclock/(masterprediv*(1<<i)),
252	masterclock, i-sfreq, -1);
253	}
254
255	#if 1
256	for (i=0; i<MINTAUDIO_freqcount; i++) {
257	DEBUG_PRINT((DEBUG_NAME "freq %d: %lu Hz, clock %lu, prediv %d\n",
258	i, MINTAUDIO_frequencies[i].frequency, MINTAUDIO_frequencies[i].masterclock,
259	MINTAUDIO_frequencies[i].predivisor
260	));
261	}
262	#endif
263
264	MINTAUDIO_numfreq=SDL_MintAudio_SearchFrequency(this, spec->freq);
265	spec->freq=MINTAUDIO_frequencies[MINTAUDIO_numfreq].frequency;
266
267	DEBUG_PRINT((DEBUG_NAME "obtained: %d bits, ",spec->format & 0x00ff));
268	DEBUG_PRINT(("signed=%d, ", ((spec->format & 0x8000)!=0)));
269	DEBUG_PRINT(("big endian=%d, ", ((spec->format & 0x1000)!=0)));
270	DEBUG_PRINT(("channels=%d, ", spec->channels));
271	DEBUG_PRINT(("freq=%d\n", spec->freq));
272
273	return 0;
274	}
275
276	static void Mint_InitAudio(_THIS, SDL_AudioSpec *spec)
277	{
278	void *oldpile;
279	unsigned long buffer;
280	unsigned char mode;
281
282	/* Set replay tracks */
283	if (cookie_snd & SND_16BIT) {
284	Settracks(0,0);
285	Setmontracks(0);
286	}
287
288	oldpile=(void *)Super(0);
289
290	/* Stop currently playing sound */
291	DMAAUDIO_IO.control=0;
292
293	/* Set buffer */
294	buffer = (unsigned long) SDL_MintAudio_audiobuf[SDL_MintAudio_numbuf];
295	DMAAUDIO_IO.start_high = (buffer>>16) & 255;
296	DMAAUDIO_IO.start_mid = (buffer>>8) & 255;
297	DMAAUDIO_IO.start_low = buffer & 255;
298
299	buffer += SDL_MintAudio_audiosize;
300	DMAAUDIO_IO.end_high = (buffer>>16) & 255;
301	DMAAUDIO_IO.end_mid = (buffer>>8) & 255;
302	DMAAUDIO_IO.end_low = buffer & 255;
303
304	mode = 3-MINTAUDIO_frequencies[MINTAUDIO_numfreq].predivisor;
305	if (spec->channels==1) {
306	mode \|= 1<<7;
307	}
308	DMAAUDIO_IO.sound_ctrl = mode;
309
310	/* Set interrupt */
311	Jdisint(MFP_DMASOUND);
312	Xbtimer(XB_TIMERA, 8, 1, SDL_MintAudio_Dma8Interrupt);
313	Jenabint(MFP_DMASOUND);
314
315	if (cookie_snd & SND_16BIT) {
316	if (Setinterrupt(SI_TIMERA, SI_PLAY)<0) {
317	DEBUG_PRINT((DEBUG_NAME "Setinterrupt() failed\n"));
318	}
319	}
320
321	/* Go */
322	DMAAUDIO_IO.control = 3; /* playback + repeat */
323
324	Super(oldpile);
325	}
326
327	static int Mint_OpenAudio(_THIS, SDL_AudioSpec *spec)
328	{
329	SDL_MintAudio_device = this;
330
331	/* Check audio capabilities */
332	if (Mint_CheckAudio(this, spec)==-1) {
333	return -1;
334	}
335
336	SDL_CalculateAudioSpec(spec);
337
338	/* Allocate memory for audio buffers in DMA-able RAM */
339	DEBUG_PRINT((DEBUG_NAME "buffer size=%d\n", spec->size));
340
341	SDL_MintAudio_audiobuf[0] = Atari_SysMalloc(spec->size *2, MX_STRAM);
342	if (SDL_MintAudio_audiobuf[0]==NULL) {
343	SDL_SetError("MINT_OpenAudio: Not enough memory for audio buffer");
344	return (-1);
345	}
346	SDL_MintAudio_audiobuf[1] = SDL_MintAudio_audiobuf[0] + spec->size ;
347	SDL_MintAudio_numbuf=0;
348	SDL_memset(SDL_MintAudio_audiobuf[0], spec->silence, spec->size *2);
349	SDL_MintAudio_audiosize = spec->size;
350	SDL_MintAudio_mutex = 0;
351
352	DEBUG_PRINT((DEBUG_NAME "buffer 0 at 0x%08x\n", SDL_MintAudio_audiobuf[0]));
353	DEBUG_PRINT((DEBUG_NAME "buffer 1 at 0x%08x\n", SDL_MintAudio_audiobuf[1]));
354
355	SDL_MintAudio_CheckFpu();
356
357	/* Setup audio hardware */
358	Mint_InitAudio(this, spec);
359
360	return(1); /* We don't use threaded audio */
361	}