[sdl_omap.git] / src / audio / sun / SDL_sunaudio.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 Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

/* Allow access to a raw mixing buffer */

#include <fcntl.h>
#include <errno.h>
#ifdef __NETBSD__
#include <sys/ioctl.h>
#include <sys/audioio.h>
#endif
#ifdef __SVR4
#include <sys/audioio.h>
#else
#include <sys/time.h>
#include <sys/types.h>
#endif
#include <unistd.h>

#include "SDL_timer.h"
#include "SDL_audio.h"
#include "../SDL_audiomem.h"
#include "../SDL_audio_c.h"
#include "../SDL_audiodev_c.h"
#include "SDL_sunaudio.h"

/* Open the audio device for playback, and don't block if busy */
#define OPEN_FLAGS	(O_WRONLY|O_NONBLOCK)

/* Audio driver functions */
static int DSP_OpenAudio(_THIS, SDL_AudioSpec *spec);
static void DSP_WaitAudio(_THIS);
static void DSP_PlayAudio(_THIS);
static Uint8 *DSP_GetAudioBuf(_THIS);
static void DSP_CloseAudio(_THIS);

static Uint8 snd2au(int sample);

/* Audio driver bootstrap functions */

static int Audio_Available(void)
{
	int fd;
	int available;

	available = 0;
	fd = SDL_OpenAudioPath(NULL, 0, OPEN_FLAGS, 1);
	if ( fd >= 0 ) {
		available = 1;
		close(fd);
	}
	return(available);
}

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));
	audio_fd = -1;

	/* Set the function pointers */
	this->OpenAudio = DSP_OpenAudio;
	this->WaitAudio = DSP_WaitAudio;
	this->PlayAudio = DSP_PlayAudio;
	this->GetAudioBuf = DSP_GetAudioBuf;
	this->CloseAudio = DSP_CloseAudio;

	this->free = Audio_DeleteDevice;

	return this;
}

AudioBootStrap SUNAUDIO_bootstrap = {
	"audio", "UNIX /dev/audio interface",
	Audio_Available, Audio_CreateDevice
};

#ifdef DEBUG_AUDIO
void CheckUnderflow(_THIS)
{
#ifdef AUDIO_GETINFO
	audio_info_t info;
	int left;

	ioctl(audio_fd, AUDIO_GETINFO, &info);
	left = (written - info.play.samples);
	if ( written && (left == 0) ) {
		fprintf(stderr, "audio underflow!\n");
	}
#endif
}
#endif

void DSP_WaitAudio(_THIS)
{
#ifdef AUDIO_GETINFO
#define SLEEP_FUDGE	10		/* 10 ms scheduling fudge factor */
	audio_info_t info;
	Sint32 left;

	ioctl(audio_fd, AUDIO_GETINFO, &info);
	left = (written - info.play.samples);
	if ( left > fragsize ) {
		Sint32 sleepy;

		sleepy = ((left - fragsize)/frequency);
		sleepy -= SLEEP_FUDGE;
		if ( sleepy > 0 ) {
			SDL_Delay(sleepy);
		}
	}
#else
	fd_set fdset;

	FD_ZERO(&fdset);
	FD_SET(audio_fd, &fdset);
	select(audio_fd+1, NULL, &fdset, NULL, NULL);
#endif
}

void DSP_PlayAudio(_THIS)
{
	/* Write the audio data */
	if ( ulaw_only ) {
		/* Assuming that this->spec.freq >= 8000 Hz */
		int accum, incr, pos;
		Uint8 *aubuf;

		accum = 0;
		incr  = this->spec.freq/8;
		aubuf = ulaw_buf;
		switch (audio_fmt & 0xFF) {
			case 8: {
				Uint8 *sndbuf;

				sndbuf = mixbuf;
				for ( pos=0; pos < fragsize; ++pos ) {
					*aubuf = snd2au((0x80-*sndbuf)*64);
					accum += incr;
					while ( accum > 0 ) {
						accum -= 1000;
						sndbuf += 1;
					}
					aubuf += 1;
				}
			}
			break;
			case 16: {
				Sint16 *sndbuf;

				sndbuf = (Sint16 *)mixbuf;
				for ( pos=0; pos < fragsize; ++pos ) {
					*aubuf = snd2au(*sndbuf/4);
					accum += incr;
					while ( accum > 0 ) {
						accum -= 1000;
						sndbuf += 1;
					}
					aubuf += 1;
				}
			}
			break;
		}
#ifdef DEBUG_AUDIO
		CheckUnderflow(this);
#endif
		if ( write(audio_fd, ulaw_buf, fragsize) < 0 ) {
			/* Assume fatal error, for now */
			this->enabled = 0;
		}
		written += fragsize;
	} else {
#ifdef DEBUG_AUDIO
		CheckUnderflow(this);
#endif
		if ( write(audio_fd, mixbuf, this->spec.size) < 0 ) {
			/* Assume fatal error, for now */
			this->enabled = 0;
		}
		written += fragsize;
	}
}

Uint8 *DSP_GetAudioBuf(_THIS)
{
	return(mixbuf);
}

void DSP_CloseAudio(_THIS)
{
	if ( mixbuf != NULL ) {
		SDL_FreeAudioMem(mixbuf);
		mixbuf = NULL;
	}
	if ( ulaw_buf != NULL ) {
		SDL_free(ulaw_buf);
		ulaw_buf = NULL;
	}
	close(audio_fd);
}

int DSP_OpenAudio(_THIS, SDL_AudioSpec *spec)
{
	char audiodev[1024];
#ifdef AUDIO_SETINFO
	int enc;
#endif
	int desired_freq = spec->freq;

	/* Initialize our freeable variables, in case we fail*/
	audio_fd = -1;
	mixbuf = NULL;
	ulaw_buf = NULL;

	/* Determine the audio parameters from the AudioSpec */
	switch ( spec->format & 0xFF ) {

		case 8: { /* Unsigned 8 bit audio data */
			spec->format = AUDIO_U8;
#ifdef AUDIO_SETINFO
			enc = AUDIO_ENCODING_LINEAR8;
#endif
		}
		break;

		case 16: { /* Signed 16 bit audio data */
		        spec->format = AUDIO_S16SYS;
#ifdef AUDIO_SETINFO
			enc = AUDIO_ENCODING_LINEAR;
#endif
		}
		break;

		default: {
			SDL_SetError("Unsupported audio format");
			return(-1);
		}
	}
	audio_fmt = spec->format;

	/* Open the audio device */
	audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 1);
	if ( audio_fd < 0 ) {
		SDL_SetError("Couldn't open %s: %s", audiodev,
			     strerror(errno));
		return(-1);
	}

	ulaw_only = 0;		/* modern Suns do support linear audio */
#ifdef AUDIO_SETINFO
	for(;;) {
	    audio_info_t info;
	    AUDIO_INITINFO(&info); /* init all fields to "no change" */

	    /* Try to set the requested settings */
	    info.play.sample_rate = spec->freq;
	    info.play.channels = spec->channels;
	    info.play.precision = (enc == AUDIO_ENCODING_ULAW)
		                  ? 8 : spec->format & 0xff;
	    info.play.encoding = enc;
	    if( ioctl(audio_fd, AUDIO_SETINFO, &info) == 0 ) {

		/* Check to be sure we got what we wanted */
		if(ioctl(audio_fd, AUDIO_GETINFO, &info) < 0) {
		    SDL_SetError("Error getting audio parameters: %s",
				 strerror(errno));
		    return -1;
		}
		if(info.play.encoding == enc
		   && info.play.precision == (spec->format & 0xff)
		   && info.play.channels == spec->channels) {
		    /* Yow! All seems to be well! */
		    spec->freq = info.play.sample_rate;
		    break;
		}
	    }

	    switch(enc) {
	    case AUDIO_ENCODING_LINEAR8:
		/* unsigned 8bit apparently not supported here */
		enc = AUDIO_ENCODING_LINEAR;
		spec->format = AUDIO_S16SYS;
		break;	/* try again */

	    case AUDIO_ENCODING_LINEAR:
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 Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 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	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	Sam Lantinga
	20	slouken@libsdl.org
	21	*/
	22	#include "SDL_config.h"
	23
	24	/* Allow access to a raw mixing buffer */
	25
	26	#include <fcntl.h>
	27	#include <errno.h>
	28	#ifdef __NETBSD__
	29	#include <sys/ioctl.h>
	30	#include <sys/audioio.h>
	31	#endif
	32	#ifdef __SVR4
	33	#include <sys/audioio.h>
	34	#else
	35	#include <sys/time.h>
	36	#include <sys/types.h>
	37	#endif
	38	#include <unistd.h>
	39
	40	#include "SDL_timer.h"
	41	#include "SDL_audio.h"
	42	#include "../SDL_audiomem.h"
	43	#include "../SDL_audio_c.h"
	44	#include "../SDL_audiodev_c.h"
	45	#include "SDL_sunaudio.h"
	46
	47	/* Open the audio device for playback, and don't block if busy */
	48	#define OPEN_FLAGS (O_WRONLY\|O_NONBLOCK)
	49
	50	/* Audio driver functions */
	51	static int DSP_OpenAudio(_THIS, SDL_AudioSpec *spec);
	52	static void DSP_WaitAudio(_THIS);
	53	static void DSP_PlayAudio(_THIS);
	54	static Uint8 *DSP_GetAudioBuf(_THIS);
	55	static void DSP_CloseAudio(_THIS);
	56
	57	static Uint8 snd2au(int sample);
	58
	59	/* Audio driver bootstrap functions */
	60
	61	static int Audio_Available(void)
	62	{
	63	int fd;
	64	int available;
65
66	available = 0;
67	fd = SDL_OpenAudioPath(NULL, 0, OPEN_FLAGS, 1);
68	if ( fd >= 0 ) {
69	available = 1;
70	close(fd);
71	}
72	return(available);
73	}
74
75	static void Audio_DeleteDevice(SDL_AudioDevice *device)
76	{
77	SDL_free(device->hidden);
78	SDL_free(device);
79	}
80
81	static SDL_AudioDevice *Audio_CreateDevice(int devindex)
82	{
83	SDL_AudioDevice *this;
84
85	/* Initialize all variables that we clean on shutdown */
86	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
87	if ( this ) {
88	SDL_memset(this, 0, (sizeof *this));
89	this->hidden = (struct SDL_PrivateAudioData *)
90	SDL_malloc((sizeof *this->hidden));
91	}
92	if ( (this == NULL) \|\| (this->hidden == NULL) ) {
93	SDL_OutOfMemory();
94	if ( this ) {
95	SDL_free(this);
96	}
97	return(0);
98	}
99	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
100	audio_fd = -1;
101
102	/* Set the function pointers */
103	this->OpenAudio = DSP_OpenAudio;
104	this->WaitAudio = DSP_WaitAudio;
105	this->PlayAudio = DSP_PlayAudio;
106	this->GetAudioBuf = DSP_GetAudioBuf;
107	this->CloseAudio = DSP_CloseAudio;
108
109	this->free = Audio_DeleteDevice;
110
111	return this;
112	}
113
114	AudioBootStrap SUNAUDIO_bootstrap = {
115	"audio", "UNIX /dev/audio interface",
116	Audio_Available, Audio_CreateDevice
117	};
118
119	#ifdef DEBUG_AUDIO
120	void CheckUnderflow(_THIS)
121	{
122	#ifdef AUDIO_GETINFO
123	audio_info_t info;
124	int left;
125
126	ioctl(audio_fd, AUDIO_GETINFO, &info);
127	left = (written - info.play.samples);
128	if ( written && (left == 0) ) {
129	fprintf(stderr, "audio underflow!\n");
130	}
131	#endif
132	}
133	#endif
134
135	void DSP_WaitAudio(_THIS)
136	{
137	#ifdef AUDIO_GETINFO
138	#define SLEEP_FUDGE 10 /* 10 ms scheduling fudge factor */
139	audio_info_t info;
140	Sint32 left;
141
142	ioctl(audio_fd, AUDIO_GETINFO, &info);
143	left = (written - info.play.samples);
144	if ( left > fragsize ) {
145	Sint32 sleepy;
146
147	sleepy = ((left - fragsize)/frequency);
148	sleepy -= SLEEP_FUDGE;
149	if ( sleepy > 0 ) {
150	SDL_Delay(sleepy);
151	}
152	}
153	#else
154	fd_set fdset;
155
156	FD_ZERO(&fdset);
157	FD_SET(audio_fd, &fdset);
158	select(audio_fd+1, NULL, &fdset, NULL, NULL);
159	#endif
160	}
161
162	void DSP_PlayAudio(_THIS)
163	{
164	/* Write the audio data */
165	if ( ulaw_only ) {
166	/* Assuming that this->spec.freq >= 8000 Hz */
167	int accum, incr, pos;
168	Uint8 *aubuf;
169
170	accum = 0;
171	incr = this->spec.freq/8;
172	aubuf = ulaw_buf;
173	switch (audio_fmt & 0xFF) {
174	case 8: {
175	Uint8 *sndbuf;
176
177	sndbuf = mixbuf;
178	for ( pos=0; pos < fragsize; ++pos ) {
179	aubuf = snd2au((0x80-sndbuf)*64);
180	accum += incr;
181	while ( accum > 0 ) {
182	accum -= 1000;
183	sndbuf += 1;
184	}
185	aubuf += 1;
186	}
187	}
188	break;
189	case 16: {
190	Sint16 *sndbuf;
191
192	sndbuf = (Sint16 *)mixbuf;
193	for ( pos=0; pos < fragsize; ++pos ) {
194	aubuf = snd2au(sndbuf/4);
195	accum += incr;
196	while ( accum > 0 ) {
197	accum -= 1000;
198	sndbuf += 1;
199	}
200	aubuf += 1;
201	}
202	}
203	break;
204	}
205	#ifdef DEBUG_AUDIO
206	CheckUnderflow(this);
207	#endif
208	if ( write(audio_fd, ulaw_buf, fragsize) < 0 ) {
209	/* Assume fatal error, for now */
210	this->enabled = 0;
211	}
212	written += fragsize;
213	} else {
214	#ifdef DEBUG_AUDIO
215	CheckUnderflow(this);
216	#endif
217	if ( write(audio_fd, mixbuf, this->spec.size) < 0 ) {
218	/* Assume fatal error, for now */
219	this->enabled = 0;
220	}
221	written += fragsize;
222	}
223	}
224
225	Uint8 *DSP_GetAudioBuf(_THIS)
226	{
227	return(mixbuf);
228	}
229
230	void DSP_CloseAudio(_THIS)
231	{
232	if ( mixbuf != NULL ) {
233	SDL_FreeAudioMem(mixbuf);
234	mixbuf = NULL;
235	}
236	if ( ulaw_buf != NULL ) {
237	SDL_free(ulaw_buf);
238	ulaw_buf = NULL;
239	}
240	close(audio_fd);
241	}
242
243	int DSP_OpenAudio(_THIS, SDL_AudioSpec *spec)
244	{
245	char audiodev[1024];
246	#ifdef AUDIO_SETINFO
247	int enc;
248	#endif
249	int desired_freq = spec->freq;
250
251	/* Initialize our freeable variables, in case we fail*/
252	audio_fd = -1;
253	mixbuf = NULL;
254	ulaw_buf = NULL;
255
256	/* Determine the audio parameters from the AudioSpec */
257	switch ( spec->format & 0xFF ) {
258
259	case 8: { /* Unsigned 8 bit audio data */
260	spec->format = AUDIO_U8;
261	#ifdef AUDIO_SETINFO
262	enc = AUDIO_ENCODING_LINEAR8;
263	#endif
264	}
265	break;
266
267	case 16: { /* Signed 16 bit audio data */
268	spec->format = AUDIO_S16SYS;
269	#ifdef AUDIO_SETINFO
270	enc = AUDIO_ENCODING_LINEAR;
271	#endif
272	}
273	break;
274
275	default: {
276	SDL_SetError("Unsupported audio format");
277	return(-1);
278	}
279	}
280	audio_fmt = spec->format;
281
282	/* Open the audio device */
283	audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 1);
284	if ( audio_fd < 0 ) {
285	SDL_SetError("Couldn't open %s: %s", audiodev,
286	strerror(errno));
287	return(-1);
288	}
289
290	ulaw_only = 0; /* modern Suns do support linear audio */
291	#ifdef AUDIO_SETINFO
292	for(;;) {
293	audio_info_t info;
294	AUDIO_INITINFO(&info); /* init all fields to "no change" */
295
296	/* Try to set the requested settings */
297	info.play.sample_rate = spec->freq;
298	info.play.channels = spec->channels;
299	info.play.precision = (enc == AUDIO_ENCODING_ULAW)
300	? 8 : spec->format & 0xff;
301	info.play.encoding = enc;
302	if( ioctl(audio_fd, AUDIO_SETINFO, &info) == 0 ) {
303
304	/* Check to be sure we got what we wanted */
305	if(ioctl(audio_fd, AUDIO_GETINFO, &info) < 0) {
306	SDL_SetError("Error getting audio parameters: %s",
307	strerror(errno));
308	return -1;
309	}
310	if(info.play.encoding == enc
311	&& info.play.precision == (spec->format & 0xff)
312	&& info.play.channels == spec->channels) {
313	/* Yow! All seems to be well! */
314	spec->freq = info.play.sample_rate;
315	break;
316	}
317	}
318
319	switch(enc) {
320	case AUDIO_ENCODING_LINEAR8:
321	/* unsigned 8bit apparently not supported here */
322	enc = AUDIO_ENCODING_LINEAR;
323	spec->format = AUDIO_S16SYS;
324	break; /* try again */
325
326	case AUDIO_ENCODING_LINEAR:
327