This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_alsa_audio.c
690 lines (604 loc) · 20.6 KB
1
/*
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
20
*/
21
#include "SDL_config.h"
22
23
24
25
/* Allow access to a raw mixing buffer */
#include <sys/types.h>
26
#include <signal.h> /* For kill() */
27
28
#include <errno.h>
#include <string.h>
29
30
#include "SDL_timer.h"
31
32
33
#include "SDL_audio.h"
#include "../SDL_audiomem.h"
#include "../SDL_audio_c.h"
34
35
#include "SDL_alsa_audio.h"
36
37
38
#ifdef SDL_AUDIO_DRIVER_ALSA_DYNAMIC
#include "SDL_loadso.h"
#endif
39
40
41
42
/* The tag name used by ALSA audio */
#define DRIVER_NAME "alsa"
43
static int (*ALSA_snd_pcm_open)
44
45
(snd_pcm_t **, const char *, snd_pcm_stream_t, int);
static int (*ALSA_snd_pcm_close) (snd_pcm_t * pcm);
46
static snd_pcm_sframes_t(*ALSA_snd_pcm_writei)
47
(snd_pcm_t *, const void *, snd_pcm_uframes_t);
48
static int (*ALSA_snd_pcm_recover) (snd_pcm_t *, int, int);
49
50
51
52
53
static int (*ALSA_snd_pcm_prepare) (snd_pcm_t *);
static int (*ALSA_snd_pcm_drain) (snd_pcm_t *);
static const char *(*ALSA_snd_strerror) (int);
static size_t(*ALSA_snd_pcm_hw_params_sizeof) (void);
static size_t(*ALSA_snd_pcm_sw_params_sizeof) (void);
54
55
static void (*ALSA_snd_pcm_hw_params_copy)
(snd_pcm_hw_params_t *, const snd_pcm_hw_params_t *);
56
static int (*ALSA_snd_pcm_hw_params_any) (snd_pcm_t *, snd_pcm_hw_params_t *);
57
static int (*ALSA_snd_pcm_hw_params_set_access)
58
(snd_pcm_t *, snd_pcm_hw_params_t *, snd_pcm_access_t);
59
static int (*ALSA_snd_pcm_hw_params_set_format)
60
(snd_pcm_t *, snd_pcm_hw_params_t *, snd_pcm_format_t);
61
static int (*ALSA_snd_pcm_hw_params_set_channels)
62
(snd_pcm_t *, snd_pcm_hw_params_t *, unsigned int);
63
64
static int (*ALSA_snd_pcm_hw_params_get_channels)
(const snd_pcm_hw_params_t *, unsigned int *);
65
66
67
68
static int (*ALSA_snd_pcm_hw_params_set_rate_near)
(snd_pcm_t *, snd_pcm_hw_params_t *, unsigned int *, int *);
static int (*ALSA_snd_pcm_hw_params_set_period_size_near)
(snd_pcm_t *, snd_pcm_hw_params_t *, snd_pcm_uframes_t *, int *);
69
70
static int (*ALSA_snd_pcm_hw_params_get_period_size)
(const snd_pcm_hw_params_t *, snd_pcm_uframes_t *, int *);
71
72
static int (*ALSA_snd_pcm_hw_params_set_periods_near)
(snd_pcm_t *, snd_pcm_hw_params_t *, unsigned int *, int *);
73
74
75
76
77
78
static int (*ALSA_snd_pcm_hw_params_get_periods)
(const snd_pcm_hw_params_t *, unsigned int *, int *);
static int (*ALSA_snd_pcm_hw_params_set_buffer_size_near)
(snd_pcm_t *pcm, snd_pcm_hw_params_t *, snd_pcm_uframes_t *);
static int (*ALSA_snd_pcm_hw_params_get_buffer_size)
(const snd_pcm_hw_params_t *, snd_pcm_uframes_t *);
79
80
81
static int (*ALSA_snd_pcm_hw_params) (snd_pcm_t *, snd_pcm_hw_params_t *);
static int (*ALSA_snd_pcm_sw_params_current) (snd_pcm_t *,
snd_pcm_sw_params_t *);
82
static int (*ALSA_snd_pcm_sw_params_set_start_threshold)
83
84
85
(snd_pcm_t *, snd_pcm_sw_params_t *, snd_pcm_uframes_t);
static int (*ALSA_snd_pcm_sw_params) (snd_pcm_t *, snd_pcm_sw_params_t *);
static int (*ALSA_snd_pcm_nonblock) (snd_pcm_t *, int);
86
static int (*ALSA_snd_pcm_wait)(snd_pcm_t *, int);
87
88
89
#ifdef SDL_AUDIO_DRIVER_ALSA_DYNAMIC
90
91
#define snd_pcm_hw_params_sizeof ALSA_snd_pcm_hw_params_sizeof
#define snd_pcm_sw_params_sizeof ALSA_snd_pcm_sw_params_sizeof
92
93
static const char *alsa_library = SDL_AUDIO_DRIVER_ALSA_DYNAMIC;
94
95
static void *alsa_handle = NULL;
96
97
static int
load_alsa_sym(const char *fn, void **addr)
98
{
99
100
101
102
*addr = SDL_LoadFunction(alsa_handle, fn);
if (*addr == NULL) {
/* Don't call SDL_SetError(): SDL_LoadFunction already did. */
return 0;
103
104
105
106
107
108
109
110
111
112
113
114
}
return 1;
}
/* cast funcs to char* first, to please GCC's strict aliasing rules. */
#define SDL_ALSA_SYM(x) \
if (!load_alsa_sym(#x, (void **) (char *) &ALSA_##x)) return -1
#else
#define SDL_ALSA_SYM(x) ALSA_##x = x
#endif
115
116
static int
load_alsa_syms(void)
117
118
119
120
{
SDL_ALSA_SYM(snd_pcm_open);
SDL_ALSA_SYM(snd_pcm_close);
SDL_ALSA_SYM(snd_pcm_writei);
121
SDL_ALSA_SYM(snd_pcm_recover);
122
123
124
125
126
SDL_ALSA_SYM(snd_pcm_prepare);
SDL_ALSA_SYM(snd_pcm_drain);
SDL_ALSA_SYM(snd_strerror);
SDL_ALSA_SYM(snd_pcm_hw_params_sizeof);
SDL_ALSA_SYM(snd_pcm_sw_params_sizeof);
127
SDL_ALSA_SYM(snd_pcm_hw_params_copy);
128
129
130
131
132
133
134
135
136
137
SDL_ALSA_SYM(snd_pcm_hw_params_any);
SDL_ALSA_SYM(snd_pcm_hw_params_set_access);
SDL_ALSA_SYM(snd_pcm_hw_params_set_format);
SDL_ALSA_SYM(snd_pcm_hw_params_set_channels);
SDL_ALSA_SYM(snd_pcm_hw_params_get_channels);
SDL_ALSA_SYM(snd_pcm_hw_params_set_rate_near);
SDL_ALSA_SYM(snd_pcm_hw_params_set_period_size_near);
SDL_ALSA_SYM(snd_pcm_hw_params_get_period_size);
SDL_ALSA_SYM(snd_pcm_hw_params_set_periods_near);
SDL_ALSA_SYM(snd_pcm_hw_params_get_periods);
138
139
SDL_ALSA_SYM(snd_pcm_hw_params_set_buffer_size_near);
SDL_ALSA_SYM(snd_pcm_hw_params_get_buffer_size);
140
141
142
143
144
SDL_ALSA_SYM(snd_pcm_hw_params);
SDL_ALSA_SYM(snd_pcm_sw_params_current);
SDL_ALSA_SYM(snd_pcm_sw_params_set_start_threshold);
SDL_ALSA_SYM(snd_pcm_sw_params);
SDL_ALSA_SYM(snd_pcm_nonblock);
145
SDL_ALSA_SYM(snd_pcm_wait);
146
147
return 0;
}
148
149
150
151
#undef SDL_ALSA_SYM
#ifdef SDL_AUDIO_DRIVER_ALSA_DYNAMIC
152
153
154
155
static void
UnloadALSALibrary(void)
{
156
if (alsa_handle != NULL) {
157
SDL_UnloadObject(alsa_handle);
158
159
alsa_handle = NULL;
}
160
161
}
162
163
164
static int
LoadALSALibrary(void)
{
165
166
int retval = 0;
if (alsa_handle == NULL) {
167
alsa_handle = SDL_LoadObject(alsa_library);
168
169
if (alsa_handle == NULL) {
retval = -1;
170
/* Don't call SDL_SetError(): SDL_LoadObject already did. */
171
172
173
} else {
retval = load_alsa_syms();
if (retval < 0) {
174
175
176
177
178
UnloadALSALibrary();
}
}
}
return retval;
179
180
181
182
}
#else
183
184
185
static void
UnloadALSALibrary(void)
{
186
187
}
188
189
190
static int
LoadALSALibrary(void)
{
191
load_alsa_syms();
192
return 0;
193
194
}
195
#endif /* SDL_AUDIO_DRIVER_ALSA_DYNAMIC */
196
197
198
static const char *
get_audio_device(int channels)
199
{
200
201
202
203
const char *device;
device = SDL_getenv("AUDIODEV"); /* Is there a standard variable name? */
if (device == NULL) {
204
205
206
207
208
209
210
211
212
213
214
switch (channels) {
case 6:
device = "plug:surround51";
break;
case 4:
device = "plug:surround40";
break;
default:
device = "default";
break;
}
215
216
}
return device;
217
218
219
220
}
/* This function waits until it is possible to write a full sound buffer */
221
static void
222
ALSA_WaitDevice(_THIS)
223
{
224
/* We're in blocking mode, so there's nothing to do here */
225
226
}
227
228
/* !!! FIXME: is there a channel swizzler in alsalib instead? */
229
230
231
232
233
234
/*
* http://bugzilla.libsdl.org/show_bug.cgi?id=110
* "For Linux ALSA, this is FL-FR-RL-RR-C-LFE
* and for Windows DirectX [and CoreAudio], this is FL-FR-C-LFE-RL-RR"
*/
#define SWIZ6(T) \
235
T *ptr = (T *) this->hidden->mixbuf; \
236
Uint32 i; \
237
for (i = 0; i < this->spec.samples; i++, ptr += 6) { \
238
239
240
241
242
T tmp; \
tmp = ptr[2]; ptr[2] = ptr[4]; ptr[4] = tmp; \
tmp = ptr[3]; ptr[3] = ptr[5]; ptr[5] = tmp; \
}
243
244
245
246
247
static __inline__ void
swizzle_alsa_channels_6_64bit(_THIS)
{
SWIZ6(Uint64);
}
248
249
250
251
252
253
static __inline__ void
swizzle_alsa_channels_6_32bit(_THIS)
{
SWIZ6(Uint32);
}
254
255
256
257
258
259
static __inline__ void
swizzle_alsa_channels_6_16bit(_THIS)
{
SWIZ6(Uint16);
}
260
261
262
263
264
265
static __inline__ void
swizzle_alsa_channels_6_8bit(_THIS)
{
SWIZ6(Uint8);
}
266
267
268
269
270
#undef SWIZ6
/*
271
272
* Called right before feeding this->hidden->mixbuf to the hardware. Swizzle
* channels from Windows/Mac order to the format alsalib will want.
273
*/
274
275
static __inline__ void
swizzle_alsa_channels(_THIS)
276
277
{
if (this->spec.channels == 6) {
278
const Uint16 fmtsize = (this->spec.format & 0xFF); /* bits/channel. */
279
280
281
282
283
284
285
286
287
288
289
290
291
292
if (fmtsize == 16)
swizzle_alsa_channels_6_16bit(this);
else if (fmtsize == 8)
swizzle_alsa_channels_6_8bit(this);
else if (fmtsize == 32)
swizzle_alsa_channels_6_32bit(this);
else if (fmtsize == 64)
swizzle_alsa_channels_6_64bit(this);
}
/* !!! FIXME: update this for 7.1 if needed, later. */
}
293
static void
294
ALSA_PlayDevice(_THIS)
295
{
296
int status;
297
298
299
300
const Uint8 *sample_buf = (const Uint8 *) this->hidden->mixbuf;
const int frame_size = (((int) (this->spec.format & 0xFF)) / 8) *
this->spec.channels;
snd_pcm_uframes_t frames_left = ((snd_pcm_uframes_t) this->spec.samples);
301
302
303
swizzle_alsa_channels(this);
304
305
306
while ( frames_left > 0 && this->enabled ) {
/* !!! FIXME: This works, but needs more testing before going live */
/*ALSA_snd_pcm_wait(this->hidden->pcm_handle, -1);*/
307
status = ALSA_snd_pcm_writei(this->hidden->pcm_handle,
308
sample_buf, frames_left);
309
310
311
if (status < 0) {
if (status == -EAGAIN) {
312
313
/* Apparently snd_pcm_recover() doesn't handle this case -
does it assume snd_pcm_wait() above? */
314
315
316
SDL_Delay(1);
continue;
}
317
status = ALSA_snd_pcm_recover(this->hidden->pcm_handle, status, 0);
318
319
if (status < 0) {
/* Hmm, not much we can do - abort */
320
321
fprintf(stderr, "ALSA write failed (unrecoverable): %s\n",
ALSA_snd_strerror(status));
322
323
324
325
326
this->enabled = 0;
return;
}
continue;
}
327
328
sample_buf += status * frame_size;
frames_left -= status;
329
}
330
331
}
332
static Uint8 *
333
ALSA_GetDeviceBuf(_THIS)
334
{
335
return (this->hidden->mixbuf);
336
337
}
338
static void
339
ALSA_CloseDevice(_THIS)
340
{
341
342
343
344
345
346
347
348
349
350
351
352
if (this->hidden != NULL) {
if (this->hidden->mixbuf != NULL) {
SDL_FreeAudioMem(this->hidden->mixbuf);
this->hidden->mixbuf = NULL;
}
if (this->hidden->pcm_handle) {
ALSA_snd_pcm_drain(this->hidden->pcm_handle);
ALSA_snd_pcm_close(this->hidden->pcm_handle);
this->hidden->pcm_handle = NULL;
}
SDL_free(this->hidden);
this->hidden = NULL;
353
}
354
355
}
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
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
417
418
419
420
421
422
423
424
425
426
427
428
429
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
457
458
459
460
461
462
463
464
465
466
467
static int
ALSA_finalize_hardware(_THIS, snd_pcm_hw_params_t *hwparams, int override)
{
int status;
snd_pcm_uframes_t bufsize;
/* "set" the hardware with the desired parameters */
status = ALSA_snd_pcm_hw_params(this->hidden->pcm_handle, hwparams);
if ( status < 0 ) {
return(-1);
}
/* Get samples for the actual buffer size */
status = ALSA_snd_pcm_hw_params_get_buffer_size(hwparams, &bufsize);
if ( status < 0 ) {
return(-1);
}
if ( !override && bufsize != this->spec.samples * 2 ) {
return(-1);
}
/* !!! FIXME: Is this safe to do? */
this->spec.samples = bufsize / 2;
/* This is useful for debugging */
if ( SDL_getenv("SDL_AUDIO_ALSA_DEBUG") ) {
snd_pcm_uframes_t persize = 0;
unsigned int periods = 0;
ALSA_snd_pcm_hw_params_get_period_size(hwparams, &persize, NULL);
ALSA_snd_pcm_hw_params_get_periods(hwparams, &periods, NULL);
fprintf(stderr,
"ALSA: period size = %ld, periods = %u, buffer size = %lu\n",
persize, periods, bufsize);
}
return(0);
}
static int
ALSA_set_period_size(_THIS, snd_pcm_hw_params_t *params, int override)
{
const char *env;
int status;
snd_pcm_hw_params_t *hwparams;
snd_pcm_uframes_t frames;
unsigned int periods;
/* Copy the hardware parameters for this setup */
snd_pcm_hw_params_alloca(&hwparams);
ALSA_snd_pcm_hw_params_copy(hwparams, params);
if ( !override ) {
env = SDL_getenv("SDL_AUDIO_ALSA_SET_PERIOD_SIZE");
if ( env ) {
override = SDL_atoi(env);
if ( override == 0 ) {
return(-1);
}
}
}
frames = this->spec.samples;
status = ALSA_snd_pcm_hw_params_set_period_size_near(
this->hidden->pcm_handle, hwparams, &frames, NULL);
if ( status < 0 ) {
return(-1);
}
periods = 2;
status = ALSA_snd_pcm_hw_params_set_periods_near(
this->hidden->pcm_handle, hwparams, &periods, NULL);
if ( status < 0 ) {
return(-1);
}
return ALSA_finalize_hardware(this, hwparams, override);
}
static int
ALSA_set_buffer_size(_THIS, snd_pcm_hw_params_t *params, int override)
{
const char *env;
int status;
snd_pcm_hw_params_t *hwparams;
snd_pcm_uframes_t frames;
/* Copy the hardware parameters for this setup */
snd_pcm_hw_params_alloca(&hwparams);
ALSA_snd_pcm_hw_params_copy(hwparams, params);
if ( !override ) {
env = SDL_getenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE");
if ( env ) {
override = SDL_atoi(env);
if ( override == 0 ) {
return(-1);
}
}
}
frames = this->spec.samples * 2;
status = ALSA_snd_pcm_hw_params_set_buffer_size_near(
this->hidden->pcm_handle, hwparams, &frames);
if ( status < 0 ) {
return(-1);
}
return ALSA_finalize_hardware(this, hwparams, override);
}
468
static int
469
ALSA_OpenDevice(_THIS, const char *devname, int iscapture)
470
{
471
472
473
474
475
476
int status = 0;
snd_pcm_t *pcm_handle = NULL;
snd_pcm_hw_params_t *hwparams = NULL;
snd_pcm_sw_params_t *swparams = NULL;
snd_pcm_format_t format = 0;
SDL_AudioFormat test_format = 0;
477
478
unsigned int rate = 0;
unsigned int channels = 0;
479
480
481
/* Initialize all variables that we clean on shutdown */
this->hidden = (struct SDL_PrivateAudioData *)
482
SDL_malloc((sizeof *this->hidden));
483
484
485
486
487
if (this->hidden == NULL) {
SDL_OutOfMemory();
return 0;
}
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
488
489
490
/* Open the audio device */
/* Name of device should depend on # channels in spec */
491
492
493
status = ALSA_snd_pcm_open(&pcm_handle,
get_audio_device(this->spec.channels),
SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
494
495
if (status < 0) {
496
497
498
499
ALSA_CloseDevice(this);
SDL_SetError("ALSA: Couldn't open audio device: %s",
ALSA_snd_strerror(status));
return 0;
500
501
}
502
503
this->hidden->pcm_handle = pcm_handle;
504
505
/* Figure out what the hardware is capable of */
snd_pcm_hw_params_alloca(&hwparams);
506
status = ALSA_snd_pcm_hw_params_any(pcm_handle, hwparams);
507
if (status < 0) {
508
509
510
511
ALSA_CloseDevice(this);
SDL_SetError("ALSA: Couldn't get hardware config: %s",
ALSA_snd_strerror(status));
return 0;
512
513
514
}
/* SDL only uses interleaved sample output */
515
516
status = ALSA_snd_pcm_hw_params_set_access(pcm_handle, hwparams,
SND_PCM_ACCESS_RW_INTERLEAVED);
517
if (status < 0) {
518
519
520
521
ALSA_CloseDevice(this);
SDL_SetError("ALSA: Couldn't set interleaved access: %s",
ALSA_snd_strerror(status));
return 0;
522
523
524
525
}
/* Try for a closest match on audio format */
status = -1;
526
for (test_format = SDL_FirstAudioFormat(this->spec.format);
527
test_format && (status < 0);) {
528
status = 0; /* if we can't support a format, it'll become -1. */
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
switch (test_format) {
case AUDIO_U8:
format = SND_PCM_FORMAT_U8;
break;
case AUDIO_S8:
format = SND_PCM_FORMAT_S8;
break;
case AUDIO_S16LSB:
format = SND_PCM_FORMAT_S16_LE;
break;
case AUDIO_S16MSB:
format = SND_PCM_FORMAT_S16_BE;
break;
case AUDIO_U16LSB:
format = SND_PCM_FORMAT_U16_LE;
break;
case AUDIO_U16MSB:
format = SND_PCM_FORMAT_U16_BE;
break;
548
case AUDIO_S32LSB:
549
format = SND_PCM_FORMAT_S32_LE;
550
551
break;
case AUDIO_S32MSB:
552
format = SND_PCM_FORMAT_S32_BE;
553
554
555
556
557
558
559
break;
case AUDIO_F32LSB:
format = SND_PCM_FORMAT_FLOAT_LE;
break;
case AUDIO_F32MSB:
format = SND_PCM_FORMAT_FLOAT_BE;
break;
560
default:
561
status = -1;
562
563
break;
}
564
if (status >= 0) {
565
566
status = ALSA_snd_pcm_hw_params_set_format(pcm_handle,
hwparams, format);
567
568
569
570
571
572
}
if (status < 0) {
test_format = SDL_NextAudioFormat();
}
}
if (status < 0) {
573
574
575
ALSA_CloseDevice(this);
SDL_SetError("ALSA: Couldn't find any hardware audio formats");
return 0;
576
}
577
this->spec.format = test_format;
578
579
/* Set the number of channels */
580
581
status = ALSA_snd_pcm_hw_params_set_channels(pcm_handle, hwparams,
this->spec.channels);
582
channels = this->spec.channels;
583
if (status < 0) {
584
585
status = ALSA_snd_pcm_hw_params_get_channels(hwparams, &channels);
if (status < 0) {
586
587
588
ALSA_CloseDevice(this);
SDL_SetError("ALSA: Couldn't set audio channels");
return 0;
589
}
590
this->spec.channels = channels;
591
592
593
}
/* Set the audio rate */
594
rate = this->spec.freq;
595
status = ALSA_snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams,
596
&rate, NULL);
597
if (status < 0) {
598
599
600
601
ALSA_CloseDevice(this);
SDL_SetError("ALSA: Couldn't set audio frequency: %s",
ALSA_snd_strerror(status));
return 0;
602
}
603
this->spec.freq = rate;
604
605
/* Set the buffer size, in samples */
606
607
608
609
610
611
612
613
if ( ALSA_set_period_size(this, hwparams, 0) < 0 &&
ALSA_set_buffer_size(this, hwparams, 0) < 0 ) {
/* Failed to set desired buffer size, do the best you can... */
if ( ALSA_set_period_size(this, hwparams, 1) < 0 ) {
ALSA_CloseDevice(this);
SDL_SetError("Couldn't set hardware audio parameters: %s", ALSA_snd_strerror(status));
return(-1);
}
614
}
615
616
/* Set the software parameters */
snd_pcm_sw_params_alloca(&swparams);
617
status = ALSA_snd_pcm_sw_params_current(pcm_handle, swparams);
618
if (status < 0) {
619
620
621
622
ALSA_CloseDevice(this);
SDL_SetError("ALSA: Couldn't get software config: %s",
ALSA_snd_strerror(status));
return 0;
623
}
624
status =
625
ALSA_snd_pcm_sw_params_set_start_threshold(pcm_handle, swparams, 1);
626
if (status < 0) {
627
628
629
630
ALSA_CloseDevice(this);
SDL_SetError("ALSA: Couldn't set start threshold: %s",
ALSA_snd_strerror(status));
return 0;
631
}
632
status = ALSA_snd_pcm_sw_params(pcm_handle, swparams);
633
if (status < 0) {
634
ALSA_CloseDevice(this);
635
SDL_SetError("Couldn't set software audio parameters: %s",
636
637
ALSA_snd_strerror(status));
return 0;
638
639
640
}
/* Calculate the final parameters for this audio specification */
641
SDL_CalculateAudioSpec(&this->spec);
642
643
/* Allocate mixing buffer */
644
645
646
647
648
649
this->hidden->mixlen = this->spec.size;
this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
if (this->hidden->mixbuf == NULL) {
ALSA_CloseDevice(this);
SDL_OutOfMemory();
return 0;
650
}
651
SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
652
653
/* Switch to blocking mode for playback */
654
ALSA_snd_pcm_nonblock(pcm_handle, 0);
655
656
/* We're ready to rock and roll. :-) */
657
658
659
660
661
662
663
return 1;
}
static void
ALSA_Deinitialize(void)
{
UnloadALSALibrary();
664
}
665
666
static int
667
ALSA_Init(SDL_AudioDriverImpl * impl)
668
669
670
671
672
673
674
675
676
677
678
679
{
if (LoadALSALibrary() < 0) {
return 0;
}
/* Set the function pointers */
impl->OpenDevice = ALSA_OpenDevice;
impl->WaitDevice = ALSA_WaitDevice;
impl->GetDeviceBuf = ALSA_GetDeviceBuf;
impl->PlayDevice = ALSA_PlayDevice;
impl->CloseDevice = ALSA_CloseDevice;
impl->Deinitialize = ALSA_Deinitialize;
680
impl->OnlyHasDefaultOutputDevice = 1; /* !!! FIXME: Add device enum! */
681
682
return 1; /* this audio target is available. */
683
684
685
686
}
AudioBootStrap ALSA_bootstrap = {
687
DRIVER_NAME, "ALSA PCM audio", ALSA_Init, 0
688
689
};
690
/* vi: set ts=4 sw=4 expandtab: */