Set avail_min so snd_pcm_wait will wait for the full update to be ready
[openal-soft.git] / Alc / alsa.c
blob582e8da1689d0aaf36160fbd8670ca90fe3c7117
1 /**
2 * OpenAL cross platform audio library
3 * Copyright (C) 1999-2007 by authors.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
21 #include "config.h"
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <memory.h>
26 #ifdef HAVE_DLFCN_H
27 #include <dlfcn.h>
28 #endif
29 #include "alMain.h"
30 #include "AL/al.h"
31 #include "AL/alc.h"
33 #include <alsa/asoundlib.h>
36 typedef struct {
37 snd_pcm_t *pcmHandle;
38 snd_pcm_format_t format;
40 ALvoid *buffer;
41 ALsizei size;
43 RingBuffer *ring;
44 int doCapture;
46 volatile int killNow;
47 ALvoid *thread;
48 } alsa_data;
50 typedef struct {
51 ALCchar *name;
52 int card, dev;
53 } DevMap;
55 static void *alsa_handle;
56 #define MAKE_FUNC(f) static typeof(f) * p##f
57 MAKE_FUNC(snd_strerror);
58 MAKE_FUNC(snd_pcm_open);
59 MAKE_FUNC(snd_pcm_close);
60 MAKE_FUNC(snd_pcm_nonblock);
61 MAKE_FUNC(snd_pcm_frames_to_bytes);
62 MAKE_FUNC(snd_pcm_hw_params_malloc);
63 MAKE_FUNC(snd_pcm_hw_params_free);
64 MAKE_FUNC(snd_pcm_hw_params_any);
65 MAKE_FUNC(snd_pcm_hw_params_set_access);
66 MAKE_FUNC(snd_pcm_hw_params_set_format);
67 MAKE_FUNC(snd_pcm_hw_params_set_channels);
68 MAKE_FUNC(snd_pcm_hw_params_set_periods_near);
69 MAKE_FUNC(snd_pcm_hw_params_set_rate_near);
70 MAKE_FUNC(snd_pcm_hw_params_set_rate);
71 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_near);
72 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_min);
73 MAKE_FUNC(snd_pcm_hw_params_get_buffer_size);
74 MAKE_FUNC(snd_pcm_hw_params_get_period_size);
75 MAKE_FUNC(snd_pcm_hw_params_get_access);
76 MAKE_FUNC(snd_pcm_hw_params);
77 MAKE_FUNC(snd_pcm_sw_params_malloc);
78 MAKE_FUNC(snd_pcm_sw_params_current);
79 MAKE_FUNC(snd_pcm_sw_params_set_avail_min);
80 MAKE_FUNC(snd_pcm_sw_params);
81 MAKE_FUNC(snd_pcm_sw_params_free);
82 MAKE_FUNC(snd_pcm_prepare);
83 MAKE_FUNC(snd_pcm_start);
84 MAKE_FUNC(snd_pcm_resume);
85 MAKE_FUNC(snd_pcm_wait);
86 MAKE_FUNC(snd_pcm_state);
87 MAKE_FUNC(snd_pcm_avail_update);
88 MAKE_FUNC(snd_pcm_areas_silence);
89 MAKE_FUNC(snd_pcm_mmap_begin);
90 MAKE_FUNC(snd_pcm_mmap_commit);
91 MAKE_FUNC(snd_pcm_readi);
92 MAKE_FUNC(snd_pcm_writei);
93 MAKE_FUNC(snd_pcm_drain);
94 MAKE_FUNC(snd_pcm_info_malloc);
95 MAKE_FUNC(snd_pcm_info_free);
96 MAKE_FUNC(snd_pcm_info_set_device);
97 MAKE_FUNC(snd_pcm_info_set_subdevice);
98 MAKE_FUNC(snd_pcm_info_set_stream);
99 MAKE_FUNC(snd_pcm_info_get_name);
100 MAKE_FUNC(snd_ctl_pcm_next_device);
101 MAKE_FUNC(snd_ctl_pcm_info);
102 MAKE_FUNC(snd_ctl_open);
103 MAKE_FUNC(snd_ctl_close);
104 MAKE_FUNC(snd_ctl_card_info_malloc);
105 MAKE_FUNC(snd_ctl_card_info_free);
106 MAKE_FUNC(snd_ctl_card_info);
107 MAKE_FUNC(snd_ctl_card_info_get_name);
108 MAKE_FUNC(snd_card_next);
109 #undef MAKE_FUNC
111 #define MAX_ALL_DEVICES 32
113 static ALCchar *alsaDevice;
114 static DevMap allDevNameMap[MAX_ALL_DEVICES];
115 static DevMap allCaptureDevNameMap[MAX_ALL_DEVICES];
117 static int xrun_recovery(snd_pcm_t *handle, int err)
119 if (err == -EPIPE)
120 { /* under-run */
121 err = psnd_pcm_prepare(handle);
122 if (err < 0)
123 AL_PRINT("prepare failed: %s\n", psnd_strerror(err));
125 else if (err == -ESTRPIPE)
127 while ((err = psnd_pcm_resume(handle)) == -EAGAIN)
128 Sleep(1); /* wait until the suspend flag is released */
129 if (err < 0)
131 err = psnd_pcm_prepare(handle);
132 if (err < 0)
133 AL_PRINT("prepare failed: %s\n", psnd_strerror(err));
136 return err;
140 static ALuint ALSAProc(ALvoid *ptr)
142 ALCdevice *pDevice = (ALCdevice*)ptr;
143 alsa_data *data = (alsa_data*)pDevice->ExtraData;
144 const snd_pcm_channel_area_t *areas = NULL;
145 snd_pcm_sframes_t avail, commitres;
146 snd_pcm_uframes_t offset, frames;
147 char *WritePtr;
148 int WriteCnt;
149 int err;
151 while(!data->killNow)
153 snd_pcm_state_t state = psnd_pcm_state(data->pcmHandle);
154 if(state == SND_PCM_STATE_XRUN)
156 err = xrun_recovery(data->pcmHandle, -EPIPE);
157 if (err < 0)
159 AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
160 break;
163 else if (state == SND_PCM_STATE_SUSPENDED)
165 err = xrun_recovery(data->pcmHandle, -ESTRPIPE);
166 if (err < 0)
168 AL_PRINT("SUSPEND recovery failed: %s\n", psnd_strerror(err));
169 break;
173 avail = psnd_pcm_avail_update(data->pcmHandle);
174 if(avail < 0)
176 err = xrun_recovery(data->pcmHandle, avail);
177 if (err < 0)
179 AL_PRINT("available update failed: %s\n", psnd_strerror(err));
180 break;
184 // make sure there's frames to process
185 if(avail >= 0 && avail < (snd_pcm_sframes_t)pDevice->UpdateSize)
187 if(state != SND_PCM_STATE_RUNNING)
189 err = psnd_pcm_start(data->pcmHandle);
190 if(err < 0)
191 err = xrun_recovery(data->pcmHandle, err);
192 if(err < 0)
194 AL_PRINT("start failed: %s\n", psnd_strerror(err));
195 break;
198 else if(psnd_pcm_wait(data->pcmHandle, 1000) == 0)
199 AL_PRINT("Wait timeout... buffer size too low?\n");
200 continue;
202 avail = pDevice->UpdateSize;
204 // it is possible that contiguous areas are smaller, thus we use a loop
205 while (avail > 0)
207 frames = avail;
209 err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &frames);
210 if (err < 0)
212 err = xrun_recovery(data->pcmHandle, err);
213 if (err < 0)
214 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
215 break;
218 WritePtr = (char*)areas->addr + (offset * areas->step / 8);
219 WriteCnt = psnd_pcm_frames_to_bytes(data->pcmHandle, frames);
220 SuspendContext(NULL);
221 aluMixData(pDevice->Context, WritePtr, WriteCnt, pDevice->Format);
222 ProcessContext(NULL);
224 commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, frames);
225 if (commitres < 0 || (commitres-frames) != 0)
227 AL_PRINT("mmap commit error: %s\n",
228 psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
229 break;
232 avail -= frames;
236 return 0;
239 static ALuint ALSANoMMapProc(ALvoid *ptr)
241 ALCdevice *pDevice = (ALCdevice*)ptr;
242 alsa_data *data = (alsa_data*)pDevice->ExtraData;
243 snd_pcm_sframes_t avail;
244 char *WritePtr;
246 while(!data->killNow)
248 SuspendContext(NULL);
249 aluMixData(pDevice->Context, data->buffer, data->size, pDevice->Format);
250 ProcessContext(NULL);
252 WritePtr = data->buffer;
253 avail = (snd_pcm_uframes_t)data->size / psnd_pcm_frames_to_bytes(data->pcmHandle, 1);
254 while(avail > 0)
256 int ret = psnd_pcm_writei(data->pcmHandle, WritePtr, avail);
257 switch (ret)
259 case -EAGAIN:
260 continue;
261 case -ESTRPIPE:
262 while((ret=psnd_pcm_resume(data->pcmHandle)) == -EAGAIN)
263 Sleep(1);
264 break;
265 case -EPIPE:
266 break;
267 default:
268 if (ret >= 0)
270 WritePtr += psnd_pcm_frames_to_bytes(data->pcmHandle, ret);
271 avail -= ret;
273 break;
275 if (ret < 0)
277 ret = psnd_pcm_prepare(data->pcmHandle);
278 if(ret < 0)
279 break;
284 return 0;
287 static ALuint ALSANoMMapCaptureProc(ALvoid *ptr)
289 ALCdevice *pDevice = (ALCdevice*)ptr;
290 alsa_data *data = (alsa_data*)pDevice->ExtraData;
291 snd_pcm_sframes_t avail;
293 while(!data->killNow)
295 avail = (snd_pcm_uframes_t)data->size / psnd_pcm_frames_to_bytes(data->pcmHandle, 1);
296 avail = psnd_pcm_readi(data->pcmHandle, data->buffer, avail);
297 switch(avail)
299 case -EAGAIN:
300 continue;
301 case -ESTRPIPE:
302 while((avail=psnd_pcm_resume(data->pcmHandle)) == -EAGAIN)
303 Sleep(1);
304 break;
305 case -EPIPE:
306 break;
307 default:
308 if (avail >= 0 && data->doCapture)
309 WriteRingBuffer(data->ring, data->buffer, avail);
310 break;
312 if(avail < 0)
314 avail = psnd_pcm_prepare(data->pcmHandle);
315 if(avail < 0)
316 AL_PRINT("prepare error: %s\n", psnd_strerror(avail));
320 return 0;
323 static ALCboolean alsa_open_playback(ALCdevice *device, const ALCchar *deviceName)
325 snd_pcm_uframes_t bufferSizeInFrames;
326 snd_pcm_sw_params_t *sp = NULL;
327 snd_pcm_hw_params_t *p = NULL;
328 snd_pcm_access_t access;
329 unsigned int periods;
330 unsigned int rate;
331 alsa_data *data;
332 char driver[64];
333 const char *str;
334 int allowmmap;
335 char *err;
336 int i;
338 if(!alsa_handle)
339 return ALC_FALSE;
341 strncpy(driver, GetConfigValue("alsa", "device", "default"), sizeof(driver)-1);
342 driver[sizeof(driver)-1] = 0;
343 if(deviceName)
345 size_t idx;
347 for(idx = 0;idx < MAX_ALL_DEVICES;idx++)
349 if(allDevNameMap[idx].name &&
350 strcmp(deviceName, allDevNameMap[idx].name) == 0)
352 device->szDeviceName = allDevNameMap[idx].name;
353 if(idx > 0)
354 sprintf(driver, "hw:%d,%d", allDevNameMap[idx].card, allDevNameMap[idx].dev);
355 goto open_alsa;
358 if(strcmp(deviceName, alsaDevice) == 0)
360 device->szDeviceName = alsaDevice;
361 goto open_alsa;
363 return ALC_FALSE;
365 else
366 device->szDeviceName = alsaDevice;
368 open_alsa:
369 data = (alsa_data*)calloc(1, sizeof(alsa_data));
371 i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
372 if(i < 0)
374 Sleep(200);
375 i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
377 if(i >= 0)
379 i = psnd_pcm_nonblock(data->pcmHandle, 0);
380 if(i < 0)
381 psnd_pcm_close(data->pcmHandle);
383 if(i < 0)
385 free(data);
386 AL_PRINT("Could not open playback device '%s': %s\n", driver, psnd_strerror(i));
387 return ALC_FALSE;
390 switch(aluBytesFromFormat(device->Format))
392 case 1:
393 data->format = SND_PCM_FORMAT_U8;
394 break;
395 case 2:
396 data->format = SND_PCM_FORMAT_S16;
397 break;
398 default:
399 data->format = SND_PCM_FORMAT_UNKNOWN;
400 AL_PRINT("Unknown format?! %x\n", device->Format);
403 periods = GetConfigValueInt("alsa", "periods", 0);
404 bufferSizeInFrames = device->UpdateSize;
405 rate = device->Frequency;
407 str = GetConfigValue("alsa", "mmap", "true");
408 allowmmap = (strcasecmp(str, "true") == 0 ||
409 strcasecmp(str, "yes") == 0 ||
410 strcasecmp(str, "on") == 0 ||
411 atoi(str) != 0);
413 err = NULL;
414 psnd_pcm_hw_params_malloc(&p);
416 if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
417 err = "any";
418 /* set interleaved access */
419 if(err == NULL && (!allowmmap || (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0))
421 if((i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
422 err = "set access";
424 /* set format (implicitly sets sample bits) */
425 if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format)) < 0)
426 err = "set format";
427 /* set channels (implicitly sets frame bits) */
428 if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(device->Format))) < 0)
429 err = "set channels";
430 /* set periods (implicitly constrains period/buffer parameters) */
431 if(err == NULL && periods && (i=psnd_pcm_hw_params_set_periods_near(data->pcmHandle, p, &periods, NULL)) < 0)
432 err = "set periods near";
433 /* set rate (implicitly constrains period/buffer parameters) */
434 if(err == NULL && (i=psnd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &rate, NULL)) < 0)
435 err = "set rate near";
436 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
437 if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
438 err = "set buffer size near";
439 /* install and prepare hardware configuration */
440 if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
441 err = "set params";
442 if(err != NULL)
444 AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
445 psnd_pcm_hw_params_free(p);
446 psnd_pcm_close(data->pcmHandle);
447 free(data);
448 return ALC_FALSE;
451 if((i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
453 AL_PRINT("get_access failed: %s\n", psnd_strerror(i));
454 psnd_pcm_hw_params_free(p);
455 psnd_pcm_close(data->pcmHandle);
456 free(data);
457 return ALC_FALSE;
460 if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
462 AL_PRINT("get_period_size failed: %s\n", psnd_strerror(i));
463 psnd_pcm_hw_params_free(p);
464 psnd_pcm_close(data->pcmHandle);
465 free(data);
466 return ALC_FALSE;
469 psnd_pcm_hw_params_free(p);
471 err = NULL;
472 psnd_pcm_sw_params_malloc(&sp);
474 if((i=psnd_pcm_sw_params_current(data->pcmHandle, sp)) != 0)
475 err = "sw current";
476 if(err == NULL && (i=psnd_pcm_sw_params_set_avail_min(data->pcmHandle, sp, bufferSizeInFrames)) != 0)
477 err = "sw set avail min";
478 if(err == NULL && (i=psnd_pcm_sw_params(data->pcmHandle, sp)) != 0)
479 err = "sw set params";
480 if(err != NULL)
482 AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
483 psnd_pcm_sw_params_free(sp);
484 psnd_pcm_close(data->pcmHandle);
485 free(data);
486 return ALC_FALSE;
489 psnd_pcm_sw_params_free(sp);
491 data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, device->UpdateSize);
492 if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
494 data->buffer = malloc(data->size);
495 if(!data->buffer)
497 AL_PRINT("buffer malloc failed\n");
498 psnd_pcm_close(data->pcmHandle);
499 free(data);
500 return ALC_FALSE;
503 else
505 i = psnd_pcm_prepare(data->pcmHandle);
506 if(i < 0)
508 AL_PRINT("prepare error: %s\n", psnd_strerror(i));
509 psnd_pcm_close(data->pcmHandle);
510 free(data->buffer);
511 free(data);
512 return ALC_FALSE;
516 device->ExtraData = data;
517 if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
518 data->thread = StartThread(ALSANoMMapProc, device);
519 else
520 data->thread = StartThread(ALSAProc, device);
521 if(data->thread == NULL)
523 AL_PRINT("Could not create playback thread\n");
524 psnd_pcm_close(data->pcmHandle);
525 device->ExtraData = NULL;
526 free(data->buffer);
527 free(data);
528 return ALC_FALSE;
531 device->UpdateSize = bufferSizeInFrames;
532 device->Frequency = rate;
534 return ALC_TRUE;
537 static void alsa_close_playback(ALCdevice *device)
539 alsa_data *data = (alsa_data*)device->ExtraData;
540 data->killNow = 1;
541 StopThread(data->thread);
542 psnd_pcm_close(data->pcmHandle);
544 free(data->buffer);
545 free(data);
546 device->ExtraData = NULL;
550 static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
552 snd_pcm_format_t alsaFormat;
553 snd_pcm_hw_params_t *p;
554 snd_pcm_uframes_t bufferSizeInFrames;
555 snd_pcm_access_t access;
556 const char *str;
557 alsa_data *data;
558 char driver[64];
559 int allowmmap;
560 char *err;
561 int i;
563 if(!alsa_handle)
564 return ALC_FALSE;
566 strncpy(driver, GetConfigValue("alsa", "capture", "default"), sizeof(driver)-1);
567 driver[sizeof(driver)-1] = 0;
568 if(deviceName)
570 size_t idx;
572 for(idx = 0;idx < MAX_ALL_DEVICES;idx++)
574 if(allCaptureDevNameMap[idx].name &&
575 strcmp(deviceName, allCaptureDevNameMap[idx].name) == 0)
577 pDevice->szDeviceName = allCaptureDevNameMap[idx].name;
578 if(idx > 0)
579 sprintf(driver, "plughw:%d,%d", allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev);
580 goto open_alsa;
583 return ALC_FALSE;
585 else
586 pDevice->szDeviceName = allCaptureDevNameMap[0].name;
588 open_alsa:
589 data = (alsa_data*)calloc(1, sizeof(alsa_data));
591 i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
592 if(i < 0)
594 Sleep(200);
595 i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
597 if(i >= 0)
599 i = psnd_pcm_nonblock(data->pcmHandle, 0);
600 if(i < 0)
601 psnd_pcm_close(data->pcmHandle);
603 if(i < 0)
605 free(data);
606 AL_PRINT("Could not open capture device '%s': %s\n", driver, psnd_strerror(i));
607 return ALC_FALSE;
610 switch(aluBytesFromFormat(format))
612 case 1:
613 alsaFormat = SND_PCM_FORMAT_U8;
614 break;
615 case 2:
616 alsaFormat = SND_PCM_FORMAT_S16;
617 break;
618 default:
619 alsaFormat = SND_PCM_FORMAT_UNKNOWN;
620 AL_PRINT("Unknown format?! %x\n", format);
623 str = GetConfigValue("alsa", "mmap", "true");
624 allowmmap = (strcasecmp(str, "true") == 0 ||
625 strcasecmp(str, "yes") == 0 ||
626 strcasecmp(str, "on") == 0 ||
627 atoi(str) != 0);
629 err = NULL;
630 bufferSizeInFrames = SampleSize;
631 psnd_pcm_hw_params_malloc(&p);
633 if(!allowmmap)
634 err = "no mmap";
635 if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
636 err = "any";
637 /* set interleaved access */
638 if(err == NULL && (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0)
640 err = "set access";
641 allowmmap = 0;
643 /* set format (implicitly sets sample bits) */
644 if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format)) < 0)
645 err = "set format";
646 /* set channels (implicitly sets frame bits) */
647 if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
648 err = "set channels";
649 /* set rate (implicitly constrains period/buffer parameters) */
650 if(err == NULL && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0)) < 0)
651 err = "set rate near";
652 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
653 if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_min(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
655 err = "set buffer size min";
656 allowmmap = 0;
658 /* install and prepare hardware configuration */
659 if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
660 err = "set params";
661 if(!allowmmap)
663 err = NULL;
664 if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
665 err = "any";
666 /* set interleaved access */
667 if(err == NULL && (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0)
668 err = "set access";
669 /* set format (implicitly sets sample bits) */
670 if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format)) < 0)
671 err = "set format";
672 /* set channels (implicitly sets frame bits) */
673 if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
674 err = "set channels";
675 /* set rate (implicitly constrains period/buffer parameters) */
676 if(err == NULL && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0)) < 0)
677 err = "set rate near";
678 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
679 if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
680 err = "set buffer size near";
681 /* install and prepare hardware configuration */
682 if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
683 err = "set params";
685 if(err != NULL)
687 AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
688 psnd_pcm_hw_params_free(p);
689 psnd_pcm_close(data->pcmHandle);
690 free(data);
691 return ALC_FALSE;
694 if((i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
696 AL_PRINT("get_access failed: %s\n", psnd_strerror(i));
697 psnd_pcm_hw_params_free(p);
698 psnd_pcm_close(data->pcmHandle);
699 free(data);
700 return ALC_FALSE;
702 if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
704 AL_PRINT("get size failed: %s\n", psnd_strerror(i));
705 psnd_pcm_hw_params_free(p);
706 psnd_pcm_close(data->pcmHandle);
707 free(data);
708 return ALC_FALSE;
711 psnd_pcm_hw_params_free(p);
713 if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
715 ALuint frameSize = aluChannelsFromFormat(pDevice->Format);
716 frameSize *= aluBytesFromFormat(pDevice->Format);
718 data->ring = CreateRingBuffer(frameSize, SampleSize);
719 if(!data->ring)
721 AL_PRINT("ring buffer create failed\n");
722 psnd_pcm_close(data->pcmHandle);
723 free(data);
724 return ALC_FALSE;
727 data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
728 data->buffer = malloc(data->size);
729 if(!data->buffer)
731 AL_PRINT("buffer malloc failed\n");
732 psnd_pcm_close(data->pcmHandle);
733 DestroyRingBuffer(data->ring);
734 free(data);
735 return ALC_FALSE;
738 pDevice->ExtraData = data;
739 data->thread = StartThread(ALSANoMMapCaptureProc, pDevice);
740 if(data->thread == NULL)
742 AL_PRINT("Could not create capture thread\n");
743 pDevice->ExtraData = NULL;
744 psnd_pcm_close(data->pcmHandle);
745 DestroyRingBuffer(data->ring);
746 free(data->buffer);
747 free(data);
748 return ALC_FALSE;
751 else
753 i = psnd_pcm_prepare(data->pcmHandle);
754 if(i < 0)
756 AL_PRINT("prepare error: %s\n", psnd_strerror(i));
757 psnd_pcm_close(data->pcmHandle);
758 free(data);
759 return ALC_FALSE;
761 pDevice->ExtraData = data;
764 return ALC_TRUE;
767 static void alsa_close_capture(ALCdevice *pDevice)
769 alsa_data *data = (alsa_data*)pDevice->ExtraData;
771 if(data->thread)
773 data->killNow = 1;
774 StopThread(data->thread);
775 DestroyRingBuffer(data->ring);
777 psnd_pcm_close(data->pcmHandle);
779 free(data);
780 pDevice->ExtraData = NULL;
783 static void alsa_start_capture(ALCdevice *pDevice)
785 alsa_data *data = (alsa_data*)pDevice->ExtraData;
786 data->doCapture = 1;
787 if(!data->thread)
789 psnd_pcm_prepare(data->pcmHandle);
790 psnd_pcm_start(data->pcmHandle);
794 static void alsa_stop_capture(ALCdevice *pDevice)
796 alsa_data *data = (alsa_data*)pDevice->ExtraData;
797 data->doCapture = 0;
798 if(!data->thread)
799 psnd_pcm_drain(data->pcmHandle);
802 static void alsa_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
804 alsa_data *data = (alsa_data*)pDevice->ExtraData;
805 const snd_pcm_channel_area_t *areas = NULL;
806 snd_pcm_sframes_t frames, commitres;
807 snd_pcm_uframes_t size, offset;
808 snd_pcm_state_t state;
809 int err;
811 if(data->thread)
813 if(lSamples <= (ALCuint)RingBufferSize(data->ring))
814 ReadRingBuffer(data->ring, pBuffer, lSamples);
815 else
816 SetALCError(ALC_INVALID_VALUE);
817 return;
820 state = psnd_pcm_state(data->pcmHandle);
821 if(state == SND_PCM_STATE_XRUN)
823 err = xrun_recovery(data->pcmHandle, -EPIPE);
824 if(err < 0)
826 AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
827 return;
831 frames = psnd_pcm_avail_update(data->pcmHandle);
832 if(frames < 0)
834 err = xrun_recovery(data->pcmHandle, frames);
835 if (err < 0)
836 AL_PRINT("available update failed: %s\n", psnd_strerror(err));
837 else
838 frames = psnd_pcm_avail_update(data->pcmHandle);
840 if (frames < (snd_pcm_sframes_t)lSamples)
842 SetALCError(ALC_INVALID_VALUE);
843 return;
846 // it is possible that contiguous areas are smaller, thus we use a loop
847 while (lSamples > 0)
849 char *Pointer;
850 int Count;
852 size = lSamples;
853 err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &size);
854 if (err < 0)
856 err = xrun_recovery(data->pcmHandle, err);
857 if (err < 0)
859 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
860 break;
862 continue;
865 Pointer = (char*)areas->addr + (offset * areas->step / 8);
866 Count = psnd_pcm_frames_to_bytes(data->pcmHandle, size);
868 memcpy(pBuffer, Pointer, Count);
869 pBuffer = (char*)pBuffer + Count;
871 commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, size);
872 if (commitres < 0 || (commitres-size) != 0)
874 AL_PRINT("mmap commit error: %s\n",
875 psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
876 break;
879 lSamples -= size;
883 static ALCuint alsa_available_samples(ALCdevice *pDevice)
885 alsa_data *data = (alsa_data*)pDevice->ExtraData;
886 snd_pcm_sframes_t frames;
887 snd_pcm_state_t state;
888 int err;
890 if(data->thread)
891 return RingBufferSize(data->ring);
893 state = psnd_pcm_state(data->pcmHandle);
894 if(state == SND_PCM_STATE_XRUN)
896 err = xrun_recovery(data->pcmHandle, -EPIPE);
897 if(err >= 0)
899 if(data->doCapture)
900 err = psnd_pcm_start(data->pcmHandle);
902 if (err < 0)
904 AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
905 return 0;
909 frames = psnd_pcm_avail_update(data->pcmHandle);
910 if(frames < 0)
912 err = xrun_recovery(data->pcmHandle, frames);
913 if (err < 0)
914 AL_PRINT("available update failed: %s\n", psnd_strerror(err));
915 else
916 frames = psnd_pcm_avail_update(data->pcmHandle);
918 return max(frames, 0);
922 BackendFuncs alsa_funcs = {
923 alsa_open_playback,
924 alsa_close_playback,
925 alsa_open_capture,
926 alsa_close_capture,
927 alsa_start_capture,
928 alsa_stop_capture,
929 alsa_capture_samples,
930 alsa_available_samples
933 void alc_alsa_init(BackendFuncs *func_list)
935 snd_ctl_t *handle;
936 int card, err, dev, idx = 1;
937 snd_ctl_card_info_t *info;
938 snd_pcm_info_t *pcminfo;
939 snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
940 char name[128];
941 char *str;
943 *func_list = alsa_funcs;
945 #ifdef HAVE_DLFCN_H
946 alsa_handle = dlopen("libasound.so.2", RTLD_NOW);
947 if(!alsa_handle)
948 return;
949 dlerror();
951 #define LOAD_FUNC(f) do { \
952 p##f = (typeof(f)*)dlsym(alsa_handle, #f); \
953 if((str=dlerror()) != NULL) \
955 dlclose(alsa_handle); \
956 alsa_handle = NULL; \
957 AL_PRINT("Could not load %s from libasound.so.2: %s\n", #f, str); \
958 return; \
960 } while(0)
961 #else
962 str = NULL;
963 alsa_handle = (void*)0xDEADBEEF;
964 #define LOAD_FUNC(f) p##f = f
965 #endif
967 LOAD_FUNC(snd_strerror);
968 LOAD_FUNC(snd_pcm_open);
969 LOAD_FUNC(snd_pcm_close);
970 LOAD_FUNC(snd_pcm_nonblock);
971 LOAD_FUNC(snd_pcm_frames_to_bytes);
972 LOAD_FUNC(snd_pcm_hw_params_malloc);
973 LOAD_FUNC(snd_pcm_hw_params_free);
974 LOAD_FUNC(snd_pcm_hw_params_any);
975 LOAD_FUNC(snd_pcm_hw_params_set_access);
976 LOAD_FUNC(snd_pcm_hw_params_set_format);
977 LOAD_FUNC(snd_pcm_hw_params_set_channels);
978 LOAD_FUNC(snd_pcm_hw_params_set_periods_near);
979 LOAD_FUNC(snd_pcm_hw_params_set_rate_near);
980 LOAD_FUNC(snd_pcm_hw_params_set_rate);
981 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near);
982 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min);
983 LOAD_FUNC(snd_pcm_hw_params_get_buffer_size);
984 LOAD_FUNC(snd_pcm_hw_params_get_period_size);
985 LOAD_FUNC(snd_pcm_hw_params_get_access);
986 LOAD_FUNC(snd_pcm_hw_params);
987 LOAD_FUNC(snd_pcm_sw_params_malloc);
988 LOAD_FUNC(snd_pcm_sw_params_current);
989 LOAD_FUNC(snd_pcm_sw_params_set_avail_min);
990 LOAD_FUNC(snd_pcm_sw_params);
991 LOAD_FUNC(snd_pcm_sw_params_free);
992 LOAD_FUNC(snd_pcm_prepare);
993 LOAD_FUNC(snd_pcm_start);
994 LOAD_FUNC(snd_pcm_resume);
995 LOAD_FUNC(snd_pcm_wait);
996 LOAD_FUNC(snd_pcm_state);
997 LOAD_FUNC(snd_pcm_avail_update);
998 LOAD_FUNC(snd_pcm_areas_silence);
999 LOAD_FUNC(snd_pcm_mmap_begin);
1000 LOAD_FUNC(snd_pcm_mmap_commit);
1001 LOAD_FUNC(snd_pcm_readi);
1002 LOAD_FUNC(snd_pcm_writei);
1003 LOAD_FUNC(snd_pcm_drain);
1005 LOAD_FUNC(snd_pcm_info_malloc);
1006 LOAD_FUNC(snd_pcm_info_free);
1007 LOAD_FUNC(snd_pcm_info_set_device);
1008 LOAD_FUNC(snd_pcm_info_set_subdevice);
1009 LOAD_FUNC(snd_pcm_info_set_stream);
1010 LOAD_FUNC(snd_pcm_info_get_name);
1011 LOAD_FUNC(snd_ctl_pcm_next_device);
1012 LOAD_FUNC(snd_ctl_pcm_info);
1013 LOAD_FUNC(snd_ctl_open);
1014 LOAD_FUNC(snd_ctl_close);
1015 LOAD_FUNC(snd_ctl_card_info_malloc);
1016 LOAD_FUNC(snd_ctl_card_info_free);
1017 LOAD_FUNC(snd_ctl_card_info);
1018 LOAD_FUNC(snd_ctl_card_info_get_name);
1019 LOAD_FUNC(snd_card_next);
1021 #undef LOAD_FUNC
1023 psnd_ctl_card_info_malloc(&info);
1024 psnd_pcm_info_malloc(&pcminfo);
1026 card = -1;
1027 if(psnd_card_next(&card) < 0 || card < 0)
1028 AL_PRINT("no playback cards found...\n");
1030 alsaDevice = AppendDeviceList("ALSA Software");
1031 allDevNameMap[0].name = AppendAllDeviceList("ALSA Software on default");
1033 while (card >= 0) {
1034 sprintf(name, "hw:%d", card);
1035 if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
1036 AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
1037 goto next_card;
1039 if ((err = psnd_ctl_card_info(handle, info)) < 0) {
1040 AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
1041 psnd_ctl_close(handle);
1042 goto next_card;
1045 dev = -1;
1046 while (idx < MAX_ALL_DEVICES) {
1047 const char *cname, *dname;
1049 if (psnd_ctl_pcm_next_device(handle, &dev)<0)
1050 AL_PRINT("snd_ctl_pcm_next_device failed\n");
1051 if (dev < 0)
1052 break;
1054 psnd_pcm_info_set_device(pcminfo, dev);
1055 psnd_pcm_info_set_subdevice(pcminfo, 0);
1056 psnd_pcm_info_set_stream(pcminfo, stream);
1057 if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
1058 if (err != -ENOENT)
1059 AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
1060 continue;
1063 cname = psnd_ctl_card_info_get_name(info);
1064 dname = psnd_pcm_info_get_name(pcminfo);
1065 snprintf(name, sizeof(name), "ALSA Software on %s [%s] (hw:%d,%d)",
1066 cname, dname, card, dev);
1067 allDevNameMap[idx].name = AppendAllDeviceList(name);
1068 allDevNameMap[idx].card = card;
1069 allDevNameMap[idx].dev = dev;
1070 idx++;
1072 psnd_ctl_close(handle);
1073 next_card:
1074 if(psnd_card_next(&card) < 0) {
1075 AL_PRINT("snd_card_next failed\n");
1076 break;
1081 stream = SND_PCM_STREAM_CAPTURE;
1083 card = -1;
1084 if(psnd_card_next(&card) < 0 || card < 0) {
1085 AL_PRINT("no capture cards found...\n");
1086 psnd_pcm_info_free(pcminfo);
1087 psnd_ctl_card_info_free(info);
1088 return;
1091 allCaptureDevNameMap[0].name = AppendCaptureDeviceList("ALSA Capture on default");
1092 idx = 1;
1094 while (card >= 0) {
1095 sprintf(name, "hw:%d", card);
1096 handle = NULL;
1097 if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
1098 AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
1100 if (err >= 0 && (err = psnd_ctl_card_info(handle, info)) < 0) {
1101 AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
1103 else if (err >= 0)
1105 dev = -1;
1106 while (idx < MAX_ALL_DEVICES) {
1107 const char *cname, *dname;
1109 if (psnd_ctl_pcm_next_device(handle, &dev)<0)
1110 AL_PRINT("snd_ctl_pcm_next_device failed\n");
1111 if (dev < 0)
1112 break;
1113 psnd_pcm_info_set_device(pcminfo, dev);
1114 psnd_pcm_info_set_subdevice(pcminfo, 0);
1115 psnd_pcm_info_set_stream(pcminfo, stream);
1116 if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
1117 if (err != -ENOENT)
1118 AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
1119 continue;
1122 cname = psnd_ctl_card_info_get_name(info);
1123 dname = psnd_pcm_info_get_name(pcminfo);
1124 snprintf(name, sizeof(name), "ALSA Capture on %s [%s] (hw:%d,%d)",
1125 cname, dname, card, dev);
1126 allCaptureDevNameMap[idx].name = AppendCaptureDeviceList(name);
1127 allCaptureDevNameMap[idx].card = card;
1128 allCaptureDevNameMap[idx].dev = dev;
1129 idx++;
1132 if(handle) psnd_ctl_close(handle);
1133 if(psnd_card_next(&card) < 0) {
1134 AL_PRINT("snd_card_next failed\n");
1135 break;
1138 psnd_pcm_info_free(pcminfo);
1139 psnd_ctl_card_info_free(info);