This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_nto_audio.c
465 lines (400 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
145
selectret =
select(this->hidden->audio_fd + 1, NULL, &wfds, NULL, NULL);
146
147
148
switch (selectret) {
case -1:
case 0:
149
SDL_SetError("NTO: select() failed: %s\n", strerror(errno));
150
151
return;
default:
152
if (FD_ISSET(this->hidden->audio_fd, &wfds)) {
153
154
155
return;
}
break;
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
} else if ((errno == EINVAL) || (errno == EIO)) {
188
SDL_memset(&cstatus, 0, sizeof(cstatus));
189
190
191
192
193
194
195
196
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;
}
197
198
if ((cstatus.status == SND_PCM_STATUS_UNDERRUN) ||
(cstatus.status == SND_PCM_STATUS_READY)) {
199
rval = snd_pcm_plugin_prepare(this->hidden->audio_handle,
200
SND_PCM_CHANNEL_PLAYBACK);
201
202
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
} while ((towrite > 0) && (this->enabled));
216
217
/* If we couldn't write, assume fatal error for now */
218
if (towrite != 0) {
219
220
this->enabled = 0;
}
221
222
}
223
static Uint8 *
224
NTO_GetDeviceBuf(_THIS)
225
{
226
return this->hidden->pcm_buf;
227
228
}
229
static void
230
NTO_CloseDevice(_THIS)
231
{
232
233
234
235
236
237
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;
238
}
239
240
241
if (this->hidden->pcm_buf != NULL) {
SDL_FreeAudioMem(this->hidden->pcm_buf);
this->hidden->pcm_buf = NULL;
242
}
243
244
SDL_free(this->hidden);
this->hidden = NULL;
245
}
246
247
}
248
static int
249
NTO_OpenDevice(_THIS, const char *devname, int iscapture)
250
{
251
252
253
254
255
256
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;
257
258
259
/* Initialize all variables that we clean on shutdown */
this->hidden = (struct SDL_PrivateAudioData *)
260
SDL_malloc((sizeof *this->hidden));
261
262
263
if (this->hidden == NULL) {
SDL_OutOfMemory();
return 0;
264
}
265
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
266
267
268
269
270
/* initialize channel transfer parameters to default */
NTO_InitAudioParams(&cparams);
/* Open the audio device */
271
272
273
274
rval = snd_pcm_open_preferred(&this->hidden->audio_handle,
&this->hidden->cardno,
&this->hidden->deviceno, OPEN_FLAGS);
275
if (rval < 0) {
276
277
278
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_open", rval);
return 0;
279
280
}
281
if (!NTO_CheckBuggyCards(this, QSA_MMAP_WORKAROUND)) {
282
/* enable count status parameter */
283
284
285
286
287
288
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;
289
290
291
292
293
294
295
296
}
}
/* Try for a closest match on audio format */
format = 0;
/* can't use format as SND_PCM_SFMT_U8 = 0 in nto */
found = 0;
297
for (test_format = SDL_FirstAudioFormat(this->spec.format); !found;) {
298
/* if match found set format to equivalent ALSA format */
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
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;
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
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;
340
341
default:
break;
342
343
}
344
if (!found) {
345
346
347
348
349
test_format = SDL_NextAudioFormat();
}
}
/* assumes test_format not 0 on success */
350
if (test_format == 0) {
351
352
353
NTO_CloseDevice(this);
SDL_SetError("NTO: Couldn't find any hardware audio formats");
return 0;
354
355
}
356
this->spec.format = test_format;
357
358
359
360
361
/* Set the audio format */
cparams.format.format = format;
/* Set mono or stereo audio (currently only two channels supported) */
362
cparams.format.voices = this->spec.channels;
363
364
/* Set rate */
365
cparams.format.rate = this->spec.freq;
366
367
/* Setup the transfer parameters according to cparams */
368
rval = snd_pcm_plugin_params(this->hidden->audio_handle, &cparams);
369
if (rval < 0) {
370
371
372
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_channel_params", rval);
return 0;
373
374
375
}
/* Make sure channel is setup right one last time */
376
SDL_memset(&csetup, '\0', sizeof(csetup));
377
csetup.channel = SND_PCM_CHANNEL_PLAYBACK;
378
379
380
381
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;
382
383
384
}
/* Calculate the final parameters for this audio specification */
385
SDL_CalculateAudioSpec(&this->spec);
386
387
this->hidden->pcm_len = this->spec.size;
388
389
390
391
if (this->hidden->pcm_len == 0) {
this->hidden->pcm_len =
csetup.buf.block.frag_size * this->spec.channels *
392
(snd_pcm_format_width(format) / 8);
393
394
}
395
396
397
398
/*
* 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)
399
*/
400
401
this->hidden->pcm_buf =
(Uint8 *) SDL_AllocAudioMem(this->hidden->pcm_len);
402
403
404
405
if (this->hidden->pcm_buf == NULL) {
NTO_CloseDevice(this);
SDL_OutOfMemory();
return 0;
406
}
407
408
SDL_memset(this->hidden->pcm_buf, this->spec.silence,
this->hidden->pcm_len);
409
410
/* get the file descriptor */
411
412
413
this->hidden->audio_fd =
snd_pcm_file_descriptor(this->hidden->audio_handle,
SND_PCM_CHANNEL_PLAYBACK);
414
415
416
417
if (this->hidden->audio_fd < 0) {
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_file_descriptor", rval);
return 0;
418
419
420
}
/* Trigger audio playback */
421
422
rval = snd_pcm_plugin_prepare(this->hidden->audio_handle,
SND_PCM_CHANNEL_PLAYBACK);
423
if (rval < 0) {
424
425
426
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_plugin_prepare", rval);
return 0;
427
428
}
429
430
431
/* We're really ready to rock and roll. :-) */
return 1;
}
432
433
434
static int
435
NTO_Init(SDL_AudioDriverImpl * impl)
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
{
/* 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;
456
impl->OnlyHasDefaultOutputDevice = 1; /* !!! FIXME: add device enum! */
457
458
return 1;
459
}
460
461
462
463
464
AudioBootStrap QNXNTOAUDIO_bootstrap = {
DRIVER_NAME, "QNX6 QSA-NTO Audio", NTO_Init, 0
};
465
/* vi: set ts=4 sw=4 expandtab: */