This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_nto_audio.c
512 lines (436 loc) · 14.2 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
74
75
76
77
78
static void NTO_ThreadInit (_THIS);
static int NTO_OpenAudio (_THIS, SDL_AudioSpec * spec);
static void NTO_WaitAudio (_THIS);
static void NTO_PlayAudio (_THIS);
static Uint8 *NTO_GetAudioBuf (_THIS);
static void NTO_CloseAudio (_THIS);
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 (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
available = 0;
handle = NULL;
147
rval = snd_pcm_open_preferred (&handle, NULL, NULL, OPEN_FLAGS);
148
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
170
if ((device) && (device->hidden)) {
SDL_free (device->hidden);
171
}
172
173
if (device) {
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
185
186
187
this = (SDL_AudioDevice *) SDL_malloc (sizeof (SDL_AudioDevice));
if (this) {
SDL_memset (this, 0, sizeof (SDL_AudioDevice));
this->hidden = (struct SDL_PrivateAudioData *)
SDL_malloc (sizeof (struct SDL_PrivateAudioData));
188
}
189
190
191
192
193
if ((this == NULL) || (this->hidden == NULL)) {
SDL_OutOfMemory ();
if (this) {
SDL_free (this);
}
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
fd_set wfds;
int selectret;
225
226
FD_ZERO (&wfds);
FD_SET (audio_fd, &wfds);
227
228
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
towrite = this->spec.size;
pcmbuffer = pcm_buf;
/* Write the audio data, checking for EAGAIN (buffer full) and underrun */
do {
262
263
264
written = snd_pcm_plugin_write (audio_handle, pcm_buf, towrite);
if (written != towrite) {
if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
265
/* Let a little CPU time go by and try to write again */
266
SDL_Delay (1);
267
268
269
270
/* if we wrote some data */
towrite -= written;
pcmbuffer += written * this->spec.channels;
continue;
271
272
273
} else {
if ((errno == EINVAL) || (errno == EIO)) {
SDL_memset (&cstatus, 0, sizeof (cstatus));
274
cstatus.channel = SND_PCM_CHANNEL_PLAYBACK;
275
276
277
278
279
280
if ((rval =
snd_pcm_plugin_status (audio_handle,
&cstatus)) < 0) {
SDL_SetError
("NTO_PlayAudio(): snd_pcm_plugin_status failed: %s\n",
snd_strerror (rval));
281
return;
282
283
284
285
286
287
288
289
290
291
}
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));
292
293
return;
}
294
}
295
continue;
296
} else {
297
298
299
return;
}
}
300
} else {
301
302
303
304
/* we wrote all remaining data */
towrite -= written;
pcmbuffer += written * this->spec.channels;
}
305
306
}
while ((towrite > 0) && (this->enabled));
307
308
/* If we couldn't write, assume fatal error for now */
309
if (towrite != 0) {
310
311
312
313
this->enabled = 0;
}
return;
314
315
}
316
317
static Uint8 *
NTO_GetAudioBuf (_THIS)
318
{
319
return pcm_buf;
320
321
}
322
323
static void
NTO_CloseAudio (_THIS)
324
{
325
326
327
328
int rval;
this->enabled = 0;
329
330
331
332
333
334
335
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));
336
337
return;
}
338
339
340
if ((rval = snd_pcm_close (audio_handle)) < 0) {
SDL_SetError ("NTO_CloseAudio(): snd_pcm_close failed: %s\n",
snd_strerror (rval));
341
342
343
344
return;
}
audio_handle = NULL;
}
345
346
}
347
348
static int
NTO_OpenAudio (_THIS, SDL_AudioSpec * spec)
349
{
350
351
352
353
354
355
356
357
int rval;
int format;
Uint16 test_format;
int found;
audio_handle = NULL;
this->enabled = 0;
358
359
if (pcm_buf != NULL) {
SDL_FreeAudioMem (pcm_buf);
360
361
362
363
pcm_buf = NULL;
}
/* initialize channel transfer parameters to default */
364
NTO_InitAudioParams (&cparams);
365
366
/* Open the audio device */
367
368
369
370
371
372
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));
373
374
375
return (-1);
}
376
if (!NTO_CheckBuggyCards (this, QSA_MMAP_WORKAROUND)) {
377
/* enable count status parameter */
378
379
380
381
382
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));
383
384
385
386
387
388
389
390
391
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;
392
for (test_format = SDL_FirstAudioFormat (spec->format); !found;) {
393
/* if match found set format to equivalent ALSA format */
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
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;
default:
break;
421
422
}
423
424
if (!found) {
test_format = SDL_NextAudioFormat ();
425
426
427
428
}
}
/* assumes test_format not 0 on success */
429
430
431
if (test_format == 0) {
SDL_SetError
("NTO_OpenAudio(): Couldn't find any hardware audio formats");
432
433
434
435
436
437
438
439
440
441
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;
442
443
444
445
446
/* Set rate */
cparams.format.rate = spec->freq;
/* Setup the transfer parameters according to cparams */
447
448
449
450
451
rval = snd_pcm_plugin_params (audio_handle, &cparams);
if (rval < 0) {
SDL_SetError
("NTO_OpenAudio(): snd_pcm_channel_params failed: %s\n",
snd_strerror (rval));
452
453
454
455
return (-1);
}
/* Make sure channel is setup right one last time */
456
SDL_memset (&csetup, 0x00, sizeof (csetup));
457
csetup.channel = SND_PCM_CHANNEL_PLAYBACK;
458
459
if (snd_pcm_plugin_setup (audio_handle, &csetup) < 0) {
SDL_SetError ("NTO_OpenAudio(): Unable to setup playback channel\n");
460
461
462
463
464
return -1;
}
/* Calculate the final parameters for this audio specification */
465
SDL_CalculateAudioSpec (spec);
466
467
468
pcm_len = spec->size;
469
470
471
472
if (pcm_len == 0) {
pcm_len =
csetup.buf.block.frag_size * spec->channels *
(snd_pcm_format_width (format) / 8);
473
474
475
476
}
/* 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)
477
478
479
480
*/
pcm_buf = (Uint8 *) SDL_AllocAudioMem (pcm_len);
if (pcm_buf == NULL) {
SDL_SetError ("NTO_OpenAudio(): pcm buffer allocation failed\n");
481
482
return (-1);
}
483
SDL_memset (pcm_buf, spec->silence, pcm_len);
484
485
/* get the file descriptor */
486
487
488
489
490
491
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));
492
493
494
495
return (-1);
}
/* Trigger audio playback */
496
497
498
499
rval = snd_pcm_plugin_prepare (audio_handle, SND_PCM_CHANNEL_PLAYBACK);
if (rval < 0) {
SDL_SetError ("snd_pcm_plugin_prepare failed: %s\n",
snd_strerror (rval));
500
501
502
503
504
505
return (-1);
}
this->enabled = 1;
/* Get the parent process id (we're the parent of the audio thread) */
506
parent = getpid ();
507
508
509
/* We're really ready to rock and roll. :-) */
return (0);
510
}
511
512
/* vi: set ts=4 sw=4 expandtab: */