This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_nto_audio.c
463 lines (398 loc) · 13.4 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
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
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
26
27
28
29
30
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sched.h>
31
#include <sys/select.h>
32
33
#include <sys/neutrino.h>
#include <sys/asoundlib.h>
34
35
#include "SDL_timer.h"
36
#include "SDL_audio.h"
37
38
#include "../SDL_audiomem.h"
#include "../SDL_audio_c.h"
39
40
41
#include "SDL_nto_audio.h"
/* The tag name used by NTO audio */
42
#define DRIVER_NAME "qsa-nto"
43
44
45
46
/* default channel communication parameters */
#define DEFAULT_CPARAMS_RATE 22050
#define DEFAULT_CPARAMS_VOICES 1
47
/* FIXME: need to add in the near future flexible logic with frag_size and frags count */
48
#define DEFAULT_CPARAMS_FRAG_SIZE 4096
49
#define DEFAULT_CPARAMS_FRAGS_MIN 1
50
#define DEFAULT_CPARAMS_FRAGS_MAX 1
51
52
/* Open the audio device for playback, and don't block if busy */
53
#define OPEN_FLAGS SND_PCM_OPEN_PLAYBACK
54
55
56
57
58
59
#define QSA_NO_WORKAROUNDS 0x00000000
#define QSA_MMAP_WORKAROUND 0x00000001
struct BuggyCards
{
60
61
char *cardname;
unsigned long bugtype;
62
63
64
65
};
#define QSA_WA_CARDS 3
66
67
68
69
struct BuggyCards buggycards[QSA_WA_CARDS] = {
{"Sound Blaster Live!", QSA_MMAP_WORKAROUND},
{"Vortex 8820", QSA_MMAP_WORKAROUND},
{"Vortex 8830", QSA_MMAP_WORKAROUND},
70
71
};
72
73
74
75
76
77
78
static inline void
NTO_SetError(const char *fn, int rval)
{
SDL_SetError("NTO: %s failed: %s", fn, snd_strerror(rval));
}
79
80
/* card names check to apply the workarounds */
81
82
static int
NTO_CheckBuggyCards(_THIS, unsigned long checkfor)
83
84
85
{
char scardname[33];
int it;
86
87
if (snd_card_get_name(this->hidden->cardno, scardname, 32) < 0) {
88
89
90
return 0;
}
91
92
93
94
95
96
for (it = 0; it < QSA_WA_CARDS; it++) {
if (SDL_strcmp(buggycards[it].cardname, scardname) == 0) {
if (buggycards[it].bugtype == checkfor) {
return 1;
}
}
97
98
99
100
}
return 0;
}
101
102
103
static void
NTO_ThreadInit(_THIS)
104
{
105
struct sched_param param;
106
int status = SchedGet(0, 0, ¶m);
107
108
109
110
/* increasing default 10 priority to 25 to avoid jerky sound */
param.sched_priority = param.sched_curpriority + 15;
status = SchedSet(0, 0, SCHED_NOCHANGE, ¶m);
111
112
}
113
/* PCM transfer channel parameters initialize function */
114
115
static void
NTO_InitAudioParams(snd_pcm_channel_params_t * cpars)
116
{
117
SDL_memset(cpars, 0, sizeof(snd_pcm_channel_params_t));
118
119
120
121
cpars->channel = SND_PCM_CHANNEL_PLAYBACK;
cpars->mode = SND_PCM_MODE_BLOCK;
cpars->start_mode = SND_PCM_START_DATA;
122
cpars->stop_mode = SND_PCM_STOP_STOP;
123
124
125
126
127
128
129
cpars->format.format = SND_PCM_SFMT_S16_LE;
cpars->format.interleave = 1;
cpars->format.rate = DEFAULT_CPARAMS_RATE;
cpars->format.voices = DEFAULT_CPARAMS_VOICES;
cpars->buf.block.frag_size = DEFAULT_CPARAMS_FRAG_SIZE;
cpars->buf.block.frags_min = DEFAULT_CPARAMS_FRAGS_MIN;
cpars->buf.block.frags_max = DEFAULT_CPARAMS_FRAGS_MAX;
130
131
132
133
}
/* This function waits until it is possible to write a full sound buffer */
134
static void
135
NTO_WaitDevice(_THIS)
136
{
137
138
139
140
fd_set wfds;
int selectret;
FD_ZERO(&wfds);
141
FD_SET(this->hidden->audio_fd, &wfds);
142
143
do {
144
selectret = select(this->hidden->audio_fd+1, NULL, &wfds, NULL, NULL);
145
146
147
switch (selectret) {
case -1:
case 0:
148
SDL_SetError("NTO: select() failed: %s\n", strerror(errno));
149
150
return;
default:
151
if (FD_ISSET(this->hidden->audio_fd, &wfds)) {
152
153
154
return;
}
break;
155
}
156
157
}
while (1);
158
159
}
160
static void
161
NTO_PlayDevice(_THIS)
162
{
163
snd_pcm_channel_status_t cstatus;
164
165
int written, rval;
int towrite;
166
void *pcmbuffer;
167
168
if ((!this->enabled) || (!this->hidden)) {
169
170
return;
}
171
172
towrite = this->spec.size;
173
pcmbuffer = this->hidden->pcm_buf;
174
175
176
/* Write the audio data, checking for EAGAIN (buffer full) and underrun */
do {
177
178
written = snd_pcm_plugin_write(this->hidden->audio_handle,
pcmbuffer, towrite);
179
180
if (written != towrite) {
if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
181
182
183
184
185
186
/* Let a little CPU time go by and try to write again */
SDL_Delay(1);
/* if we wrote some data */
towrite -= written;
pcmbuffer += written * this->spec.channels;
continue;
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
} else if ((errno == EINVAL) || (errno == EIO)) {
SDL_memset(&cstatus, 0, sizeof (cstatus));
cstatus.channel = SND_PCM_CHANNEL_PLAYBACK;
rval = snd_pcm_plugin_status(this->hidden->audio_handle,
&cstatus);
if (rval < 0) {
NTO_SetError("snd_pcm_plugin_status", rval);
return;
}
if ( (cstatus.status == SND_PCM_STATUS_UNDERRUN) ||
(cstatus.status == SND_PCM_STATUS_READY)) {
rval = snd_pcm_plugin_prepare(this->hidden->audio_handle,
SND_PCM_CHANNEL_PLAYBACK);
if (rval < 0) {
NTO_SetError("snd_pcm_plugin_prepare", rval);
203
return;
204
}
205
}
206
207
208
continue;
} else {
return;
209
}
210
} else {
211
212
213
214
/* we wrote all remaining data */
towrite -= written;
pcmbuffer += written * this->spec.channels;
}
215
216
}
while ((towrite > 0) && (this->enabled));
217
218
/* If we couldn't write, assume fatal error for now */
219
if (towrite != 0) {
220
221
this->enabled = 0;
}
222
223
}
224
static Uint8 *
225
NTO_GetDeviceBuf(_THIS)
226
{
227
return this->hidden->pcm_buf;
228
229
}
230
static void
231
NTO_CloseDevice(_THIS)
232
{
233
234
235
236
237
238
if (this->hidden != NULL) {
if (this->hidden->audio_handle != NULL) {
snd_pcm_plugin_flush(this->hidden->audio_handle,
SND_PCM_CHANNEL_PLAYBACK);
snd_pcm_close(this->hidden->audio_handle);
this->hidden->audio_handle = NULL;
239
}
240
241
242
if (this->hidden->pcm_buf != NULL) {
SDL_FreeAudioMem(this->hidden->pcm_buf);
this->hidden->pcm_buf = NULL;
243
}
244
245
SDL_free(this->hidden);
this->hidden = NULL;
246
}
247
248
}
249
static int
250
NTO_OpenDevice(_THIS, const char *devname, int iscapture)
251
{
252
253
254
255
256
257
int rval = 0;
int format = 0;
SDL_AudioFormat test_format = 0;
int found = 0;
snd_pcm_channel_setup_t csetup;
snd_pcm_channel_params_t cparams;
258
259
260
261
262
263
264
/* Initialize all variables that we clean on shutdown */
this->hidden = (struct SDL_PrivateAudioData *)
SDL_malloc((sizeof *this->hidden));
if (this->hidden == NULL) {
SDL_OutOfMemory();
return 0;
265
}
266
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
267
268
269
270
271
/* initialize channel transfer parameters to default */
NTO_InitAudioParams(&cparams);
/* Open the audio device */
272
273
274
275
rval = snd_pcm_open_preferred(&this->hidden->audio_handle,
&this->hidden->cardno,
&this->hidden->deviceno, OPEN_FLAGS);
276
if (rval < 0) {
277
278
279
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_open", rval);
return 0;
280
281
}
282
if (!NTO_CheckBuggyCards(this, QSA_MMAP_WORKAROUND)) {
283
/* enable count status parameter */
284
285
286
287
288
289
rval = snd_pcm_plugin_set_disable(this->hidden->audio_handle,
PLUGIN_DISABLE_MMAP);
if (rval < 0) {
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_plugin_set_disable", rval);
return 0;
290
291
292
293
294
295
296
297
}
}
/* Try for a closest match on audio format */
format = 0;
/* can't use format as SND_PCM_SFMT_U8 = 0 in nto */
found = 0;
298
for (test_format = SDL_FirstAudioFormat(this->spec.format); !found;) {
299
/* if match found set format to equivalent ALSA format */
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
switch (test_format) {
case AUDIO_U8:
format = SND_PCM_SFMT_U8;
found = 1;
break;
case AUDIO_S8:
format = SND_PCM_SFMT_S8;
found = 1;
break;
case AUDIO_S16LSB:
format = SND_PCM_SFMT_S16_LE;
found = 1;
break;
case AUDIO_S16MSB:
format = SND_PCM_SFMT_S16_BE;
found = 1;
break;
case AUDIO_U16LSB:
format = SND_PCM_SFMT_U16_LE;
found = 1;
break;
case AUDIO_U16MSB:
format = SND_PCM_SFMT_U16_BE;
found = 1;
break;
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
case AUDIO_S32LSB:
format = SND_PCM_SFMT_S32_LE;
found = 1;
break;
case AUDIO_S32MSB:
format = SND_PCM_SFMT_S32_BE;
found = 1;
break;
case AUDIO_F32LSB:
format = SND_PCM_SFMT_FLOAT_LE;
found = 1;
break;
case AUDIO_F32MSB:
format = SND_PCM_SFMT_FLOAT_BE;
found = 1;
break;
341
342
default:
break;
343
344
}
345
if (!found) {
346
347
348
349
350
test_format = SDL_NextAudioFormat();
}
}
/* assumes test_format not 0 on success */
351
if (test_format == 0) {
352
353
354
NTO_CloseDevice(this);
SDL_SetError("NTO: Couldn't find any hardware audio formats");
return 0;
355
356
}
357
this->spec.format = test_format;
358
359
360
361
362
/* Set the audio format */
cparams.format.format = format;
/* Set mono or stereo audio (currently only two channels supported) */
363
cparams.format.voices = this->spec.channels;
364
365
/* Set rate */
366
cparams.format.rate = this->spec.freq;
367
368
/* Setup the transfer parameters according to cparams */
369
rval = snd_pcm_plugin_params(this->hidden->audio_handle, &cparams);
370
if (rval < 0) {
371
372
373
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_channel_params", rval);
return 0;
374
375
376
}
/* Make sure channel is setup right one last time */
377
SDL_memset(&csetup, '\0', sizeof (csetup));
378
csetup.channel = SND_PCM_CHANNEL_PLAYBACK;
379
380
381
382
if (snd_pcm_plugin_setup(this->hidden->audio_handle, &csetup) < 0) {
NTO_CloseDevice(this);
SDL_SetError("NTO: Unable to setup playback channel\n");
return 0;
383
384
385
}
/* Calculate the final parameters for this audio specification */
386
SDL_CalculateAudioSpec(&this->spec);
387
388
this->hidden->pcm_len = this->spec.size;
389
390
391
392
if (this->hidden->pcm_len == 0) {
this->hidden->pcm_len =
csetup.buf.block.frag_size * this->spec.channels *
393
(snd_pcm_format_width(format) / 8);
394
395
}
396
397
398
399
/*
* Allocate memory to the audio buffer and initialize with silence
* (Note that buffer size must be a multiple of fragment size, so find
* closest multiple)
400
*/
401
402
403
404
405
this->hidden->pcm_buf = (Uint8 *) SDL_AllocAudioMem(this->hidden->pcm_len);
if (this->hidden->pcm_buf == NULL) {
NTO_CloseDevice(this);
SDL_OutOfMemory();
return 0;
406
}
407
SDL_memset(this->hidden->pcm_buf,this->spec.silence,this->hidden->pcm_len);
408
409
/* get the file descriptor */
410
411
412
413
414
415
this->hidden->audio_fd = snd_pcm_file_descriptor(this->hidden->audio_handle,
SND_PCM_CHANNEL_PLAYBACK);
if (this->hidden->audio_fd < 0) {
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_file_descriptor", rval);
return 0;
416
417
418
}
/* Trigger audio playback */
419
420
rval = snd_pcm_plugin_prepare(this->hidden->audio_handle,
SND_PCM_CHANNEL_PLAYBACK);
421
if (rval < 0) {
422
423
424
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_plugin_prepare", rval);
return 0;
425
426
}
427
428
429
/* We're really ready to rock and roll. :-) */
return 1;
}
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
static int
NTO_Init(SDL_AudioDriverImpl *impl)
{
/* See if we can open a nonblocking channel. */
snd_pcm_t *handle = NULL;
int rval = snd_pcm_open_preferred(&handle, NULL, NULL, OPEN_FLAGS);
if (rval < 0) {
SDL_SetError("NTO: couldn't open preferred audio device");
return 0;
}
if ((rval = snd_pcm_close(handle)) < 0) {
SDL_SetError("NTO: couldn't close test audio device");
return 0;
}
/* Set the function pointers */
impl->OpenDevice = NTO_OpenDevice;
impl->ThreadInit = NTO_ThreadInit;
impl->WaitDevice = NTO_WaitDevice;
impl->PlayDevice = NTO_PlayDevice;
impl->GetDeviceBuf = NTO_GetDeviceBuf;
impl->CloseDevice = NTO_CloseDevice;
impl->OnlyHasDefaultOutputDevice = 1; /* !!! FIXME: add device enum! */
return 1;
457
}
458
459
460
461
462
AudioBootStrap QNXNTOAUDIO_bootstrap = {
DRIVER_NAME, "QNX6 QSA-NTO Audio", NTO_Init, 0
};
463
/* vi: set ts=4 sw=4 expandtab: */