This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_nto_audio.c
526 lines (450 loc) · 14.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
/* Audio driver functions */
73
static void NTO_ThreadInit(_THIS);
74
static int NTO_OpenAudio(_THIS, SDL_AudioSpec * spec);
75
76
static void NTO_WaitAudio(_THIS);
static void NTO_PlayAudio(_THIS);
77
static Uint8 *NTO_GetAudioBuf(_THIS);
78
79
static void NTO_CloseAudio(_THIS);
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(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
106
int status;
struct sched_param param;
107
108
109
110
111
/* increasing default 10 priority to 25 to avoid jerky sound */
status = SchedGet(0, 0, ¶m);
param.sched_priority = param.sched_curpriority + 15;
status = SchedSet(0, 0, SCHED_NOCHANGE, ¶m);
112
113
}
114
/* PCM transfer channel parameters initialize function */
115
116
static void
NTO_InitAudioParams(snd_pcm_channel_params_t * cpars)
117
{
118
SDL_memset(cpars, 0, sizeof(snd_pcm_channel_params_t));
119
120
121
122
cpars->channel = SND_PCM_CHANNEL_PLAYBACK;
cpars->mode = SND_PCM_MODE_BLOCK;
cpars->start_mode = SND_PCM_START_DATA;
123
cpars->stop_mode = SND_PCM_STOP_STOP;
124
125
126
127
128
129
130
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;
131
132
}
133
134
static int
NTO_AudioAvailable(void)
135
{
136
/* See if we can open a nonblocking channel.
137
138
Return value '1' means we can.
Return value '0' means we cannot. */
139
140
141
int available;
int rval;
142
snd_pcm_t *handle;
143
144
145
146
147
148
available = 0;
handle = NULL;
rval = snd_pcm_open_preferred(&handle, NULL, NULL, OPEN_FLAGS);
149
if (rval >= 0) {
150
151
available = 1;
152
153
154
155
if ((rval = snd_pcm_close(handle)) < 0) {
SDL_SetError
("NTO_AudioAvailable(): snd_pcm_close failed: %s\n",
snd_strerror(rval));
156
157
available = 0;
}
158
159
160
} else {
SDL_SetError
("NTO_AudioAvailable(): there are no available audio devices.\n");
161
162
163
164
}
return (available);
}
165
166
167
static void
NTO_DeleteAudioDevice(SDL_AudioDevice * device)
168
{
169
if ((device) && (device->hidden)) {
170
SDL_free(device->hidden);
171
}
172
if (device) {
173
SDL_free(device);
174
}
175
176
}
177
178
static SDL_AudioDevice *
NTO_CreateAudioDevice(int devindex)
179
{
180
181
182
SDL_AudioDevice *this;
/* Initialize all variables that we clean on shutdown */
183
184
this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
if (this) {
185
SDL_memset(this, 0, sizeof(SDL_AudioDevice));
186
187
this->hidden = (struct SDL_PrivateAudioData *)
SDL_malloc(sizeof(struct SDL_PrivateAudioData));
188
}
189
if ((this == NULL) || (this->hidden == NULL)) {
190
SDL_OutOfMemory();
191
if (this) {
192
SDL_free(this);
193
}
194
195
return (0);
}
196
SDL_memset(this->hidden, 0, sizeof(struct SDL_PrivateAudioData));
197
198
199
200
201
202
203
204
205
206
207
208
209
audio_handle = NULL;
/* Set the function pointers */
this->ThreadInit = NTO_ThreadInit;
this->OpenAudio = NTO_OpenAudio;
this->WaitAudio = NTO_WaitAudio;
this->PlayAudio = NTO_PlayAudio;
this->GetAudioBuf = NTO_GetAudioBuf;
this->CloseAudio = NTO_CloseAudio;
this->free = NTO_DeleteAudioDevice;
return this;
210
211
}
212
AudioBootStrap QNXNTOAUDIO_bootstrap = {
213
214
215
DRIVER_NAME, "QNX6 QSA-NTO Audio",
NTO_AudioAvailable,
NTO_CreateAudioDevice
216
217
218
};
/* This function waits until it is possible to write a full sound buffer */
219
220
static void
NTO_WaitAudio(_THIS)
221
{
222
223
224
225
226
227
228
fd_set wfds;
int selectret;
FD_ZERO(&wfds);
FD_SET(audio_fd, &wfds);
do {
229
230
231
232
233
234
235
236
237
238
239
240
selectret = select(audio_fd + 1, NULL, &wfds, NULL, NULL);
switch (selectret) {
case -1:
case 0:
SDL_SetError("NTO_WaitAudio(): select() failed: %s\n",
strerror(errno));
return;
default:
if (FD_ISSET(audio_fd, &wfds)) {
return;
}
break;
241
}
242
243
}
while (1);
244
245
}
246
247
static void
NTO_PlayAudio(_THIS)
248
{
249
250
int written, rval;
int towrite;
251
void *pcmbuffer;
252
253
if (!this->enabled) {
254
255
return;
}
256
257
258
259
260
261
262
towrite = this->spec.size;
pcmbuffer = pcm_buf;
/* Write the audio data, checking for EAGAIN (buffer full) and underrun */
do {
written = snd_pcm_plugin_write(audio_handle, pcm_buf, towrite);
263
264
if (written != towrite) {
if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
265
266
267
268
269
270
/* 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;
271
272
} else {
if ((errno == EINVAL) || (errno == EIO)) {
273
SDL_memset(&cstatus, 0, sizeof(cstatus));
274
cstatus.channel = SND_PCM_CHANNEL_PLAYBACK;
275
276
277
278
279
if ((rval =
snd_pcm_plugin_status(audio_handle, &cstatus)) < 0) {
SDL_SetError
("NTO_PlayAudio(): snd_pcm_plugin_status failed: %s\n",
snd_strerror(rval));
280
return;
281
282
283
284
285
286
287
288
289
290
}
if ((cstatus.status == SND_PCM_STATUS_UNDERRUN)
|| (cstatus.status == SND_PCM_STATUS_READY)) {
if ((rval =
snd_pcm_plugin_prepare(audio_handle,
SND_PCM_CHANNEL_PLAYBACK))
< 0) {
SDL_SetError
("NTO_PlayAudio(): snd_pcm_plugin_prepare failed: %s\n",
snd_strerror(rval));
291
292
return;
}
293
}
294
continue;
295
} else {
296
297
298
return;
}
}
299
} else {
300
301
302
303
/* we wrote all remaining data */
towrite -= written;
pcmbuffer += written * this->spec.channels;
}
304
305
}
while ((towrite > 0) && (this->enabled));
306
307
/* If we couldn't write, assume fatal error for now */
308
if (towrite != 0) {
309
310
311
312
this->enabled = 0;
}
return;
313
314
}
315
316
static Uint8 *
NTO_GetAudioBuf(_THIS)
317
{
318
return pcm_buf;
319
320
}
321
322
static void
NTO_CloseAudio(_THIS)
323
{
324
325
326
327
int rval;
this->enabled = 0;
328
329
330
331
332
333
334
if (audio_handle != NULL) {
if ((rval =
snd_pcm_plugin_flush(audio_handle,
SND_PCM_CHANNEL_PLAYBACK)) < 0) {
SDL_SetError
("NTO_CloseAudio(): snd_pcm_plugin_flush failed: %s\n",
snd_strerror(rval));
335
336
return;
}
337
338
339
if ((rval = snd_pcm_close(audio_handle)) < 0) {
SDL_SetError("NTO_CloseAudio(): snd_pcm_close failed: %s\n",
snd_strerror(rval));
340
341
342
343
return;
}
audio_handle = NULL;
}
344
345
}
346
347
static int
NTO_OpenAudio(_THIS, SDL_AudioSpec * spec)
348
{
349
350
int rval;
int format;
351
SDL_AudioFormat test_format;
352
353
354
355
356
int found;
audio_handle = NULL;
this->enabled = 0;
357
358
if (pcm_buf != NULL) {
SDL_FreeAudioMem(pcm_buf);
359
360
361
362
363
364
365
pcm_buf = NULL;
}
/* initialize channel transfer parameters to default */
NTO_InitAudioParams(&cparams);
/* Open the audio device */
366
367
368
369
370
rval =
snd_pcm_open_preferred(&audio_handle, &cardno, &deviceno, OPEN_FLAGS);
if (rval < 0) {
SDL_SetError("NTO_OpenAudio(): snd_pcm_open failed: %s\n",
snd_strerror(rval));
371
372
373
return (-1);
}
374
if (!NTO_CheckBuggyCards(this, QSA_MMAP_WORKAROUND)) {
375
/* enable count status parameter */
376
377
378
379
380
if ((rval =
snd_pcm_plugin_set_disable(audio_handle,
PLUGIN_DISABLE_MMAP)) < 0) {
SDL_SetError("snd_pcm_plugin_set_disable failed: %s\n",
snd_strerror(rval));
381
382
383
384
385
386
387
388
389
return (-1);
}
}
/* Try for a closest match on audio format */
format = 0;
/* can't use format as SND_PCM_SFMT_U8 = 0 in nto */
found = 0;
390
for (test_format = SDL_FirstAudioFormat(spec->format); !found;) {
391
/* if match found set format to equivalent ALSA format */
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
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;
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
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;
433
434
default:
break;
435
436
}
437
if (!found) {
438
439
440
441
442
test_format = SDL_NextAudioFormat();
}
}
/* assumes test_format not 0 on success */
443
444
445
if (test_format == 0) {
SDL_SetError
("NTO_OpenAudio(): Couldn't find any hardware audio formats");
446
447
448
449
450
451
452
453
454
455
return (-1);
}
spec->format = test_format;
/* Set the audio format */
cparams.format.format = format;
/* Set mono or stereo audio (currently only two channels supported) */
cparams.format.voices = spec->channels;
456
457
458
459
460
461
/* Set rate */
cparams.format.rate = spec->freq;
/* Setup the transfer parameters according to cparams */
rval = snd_pcm_plugin_params(audio_handle, &cparams);
462
463
464
465
if (rval < 0) {
SDL_SetError
("NTO_OpenAudio(): snd_pcm_channel_params failed: %s\n",
snd_strerror(rval));
466
467
468
469
return (-1);
}
/* Make sure channel is setup right one last time */
470
SDL_memset(&csetup, 0x00, sizeof(csetup));
471
csetup.channel = SND_PCM_CHANNEL_PLAYBACK;
472
if (snd_pcm_plugin_setup(audio_handle, &csetup) < 0) {
473
474
475
476
477
478
479
480
481
482
SDL_SetError("NTO_OpenAudio(): Unable to setup playback channel\n");
return -1;
}
/* Calculate the final parameters for this audio specification */
SDL_CalculateAudioSpec(spec);
pcm_len = spec->size;
483
484
485
486
if (pcm_len == 0) {
pcm_len =
csetup.buf.block.frag_size * spec->channels *
(snd_pcm_format_width(format) / 8);
487
488
489
490
}
/* 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)
491
492
493
*/
pcm_buf = (Uint8 *) SDL_AllocAudioMem(pcm_len);
if (pcm_buf == NULL) {
494
495
496
SDL_SetError("NTO_OpenAudio(): pcm buffer allocation failed\n");
return (-1);
}
497
SDL_memset(pcm_buf, spec->silence, pcm_len);
498
499
/* get the file descriptor */
500
501
502
503
504
505
if ((audio_fd =
snd_pcm_file_descriptor(audio_handle,
SND_PCM_CHANNEL_PLAYBACK)) < 0) {
SDL_SetError
("NTO_OpenAudio(): snd_pcm_file_descriptor failed with error code: %s\n",
snd_strerror(rval));
506
507
508
509
510
return (-1);
}
/* Trigger audio playback */
rval = snd_pcm_plugin_prepare(audio_handle, SND_PCM_CHANNEL_PLAYBACK);
511
512
513
if (rval < 0) {
SDL_SetError("snd_pcm_plugin_prepare failed: %s\n",
snd_strerror(rval));
514
515
516
517
518
519
520
521
522
523
return (-1);
}
this->enabled = 1;
/* Get the parent process id (we're the parent of the audio thread) */
parent = getpid();
/* We're really ready to rock and roll. :-) */
return (0);
524
}
525
526
/* vi: set ts=4 sw=4 expandtab: */