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
33 #include <alsa/asoundlib.h>
54 static void *alsa_handle
;
55 #define MAKE_FUNC(f) static typeof(f) * p##f
56 MAKE_FUNC(snd_strerror
);
57 MAKE_FUNC(snd_pcm_open
);
58 MAKE_FUNC(snd_pcm_close
);
59 MAKE_FUNC(snd_pcm_nonblock
);
60 MAKE_FUNC(snd_pcm_frames_to_bytes
);
61 MAKE_FUNC(snd_pcm_bytes_to_frames
);
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_rate_resample
);
72 MAKE_FUNC(snd_pcm_hw_params_set_buffer_time_near
);
73 MAKE_FUNC(snd_pcm_hw_params_set_period_time_near
);
74 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_near
);
75 MAKE_FUNC(snd_pcm_hw_params_set_period_size_near
);
76 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_min
);
77 MAKE_FUNC(snd_pcm_hw_params_get_buffer_size
);
78 MAKE_FUNC(snd_pcm_hw_params_get_period_size
);
79 MAKE_FUNC(snd_pcm_hw_params_get_access
);
80 MAKE_FUNC(snd_pcm_hw_params_get_periods
);
81 MAKE_FUNC(snd_pcm_hw_params
);
82 MAKE_FUNC(snd_pcm_sw_params_malloc
);
83 MAKE_FUNC(snd_pcm_sw_params_current
);
84 MAKE_FUNC(snd_pcm_sw_params_set_avail_min
);
85 MAKE_FUNC(snd_pcm_sw_params
);
86 MAKE_FUNC(snd_pcm_sw_params_free
);
87 MAKE_FUNC(snd_pcm_prepare
);
88 MAKE_FUNC(snd_pcm_start
);
89 MAKE_FUNC(snd_pcm_resume
);
90 MAKE_FUNC(snd_pcm_wait
);
91 MAKE_FUNC(snd_pcm_state
);
92 MAKE_FUNC(snd_pcm_avail_update
);
93 MAKE_FUNC(snd_pcm_areas_silence
);
94 MAKE_FUNC(snd_pcm_mmap_begin
);
95 MAKE_FUNC(snd_pcm_mmap_commit
);
96 MAKE_FUNC(snd_pcm_readi
);
97 MAKE_FUNC(snd_pcm_writei
);
98 MAKE_FUNC(snd_pcm_drain
);
99 MAKE_FUNC(snd_pcm_recover
);
100 MAKE_FUNC(snd_pcm_info_malloc
);
101 MAKE_FUNC(snd_pcm_info_free
);
102 MAKE_FUNC(snd_pcm_info_set_device
);
103 MAKE_FUNC(snd_pcm_info_set_subdevice
);
104 MAKE_FUNC(snd_pcm_info_set_stream
);
105 MAKE_FUNC(snd_pcm_info_get_name
);
106 MAKE_FUNC(snd_ctl_pcm_next_device
);
107 MAKE_FUNC(snd_ctl_pcm_info
);
108 MAKE_FUNC(snd_ctl_open
);
109 MAKE_FUNC(snd_ctl_close
);
110 MAKE_FUNC(snd_ctl_card_info_malloc
);
111 MAKE_FUNC(snd_ctl_card_info_free
);
112 MAKE_FUNC(snd_ctl_card_info
);
113 MAKE_FUNC(snd_ctl_card_info_get_name
);
114 MAKE_FUNC(snd_card_next
);
118 static const ALCchar alsaDevice
[] = "ALSA Default";
119 static DevMap
*allDevNameMap
;
120 static ALuint numDevNames
;
121 static DevMap
*allCaptureDevNameMap
;
122 static ALuint numCaptureDevNames
;
125 void *alsa_load(void)
132 alsa_handle
= dlopen("libasound.so.2", RTLD_NOW
);
137 #define LOAD_FUNC(f) do { \
138 p##f = dlsym(alsa_handle, #f); \
139 if((str=dlerror()) != NULL) \
141 dlclose(alsa_handle); \
142 alsa_handle = NULL; \
143 AL_PRINT("Could not load %s from libasound.so.2: %s\n", #f, str); \
149 alsa_handle
= (void*)0xDEADBEEF;
150 #define LOAD_FUNC(f) p##f = f
153 LOAD_FUNC(snd_strerror
);
154 LOAD_FUNC(snd_pcm_open
);
155 LOAD_FUNC(snd_pcm_close
);
156 LOAD_FUNC(snd_pcm_nonblock
);
157 LOAD_FUNC(snd_pcm_frames_to_bytes
);
158 LOAD_FUNC(snd_pcm_bytes_to_frames
);
159 LOAD_FUNC(snd_pcm_hw_params_malloc
);
160 LOAD_FUNC(snd_pcm_hw_params_free
);
161 LOAD_FUNC(snd_pcm_hw_params_any
);
162 LOAD_FUNC(snd_pcm_hw_params_set_access
);
163 LOAD_FUNC(snd_pcm_hw_params_set_format
);
164 LOAD_FUNC(snd_pcm_hw_params_set_channels
);
165 LOAD_FUNC(snd_pcm_hw_params_set_periods_near
);
166 LOAD_FUNC(snd_pcm_hw_params_set_rate_near
);
167 LOAD_FUNC(snd_pcm_hw_params_set_rate
);
168 LOAD_FUNC(snd_pcm_hw_params_set_rate_resample
);
169 LOAD_FUNC(snd_pcm_hw_params_set_buffer_time_near
);
170 LOAD_FUNC(snd_pcm_hw_params_set_period_time_near
);
171 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near
);
172 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min
);
173 LOAD_FUNC(snd_pcm_hw_params_set_period_size_near
);
174 LOAD_FUNC(snd_pcm_hw_params_get_buffer_size
);
175 LOAD_FUNC(snd_pcm_hw_params_get_period_size
);
176 LOAD_FUNC(snd_pcm_hw_params_get_access
);
177 LOAD_FUNC(snd_pcm_hw_params_get_periods
);
178 LOAD_FUNC(snd_pcm_hw_params
);
179 LOAD_FUNC(snd_pcm_sw_params_malloc
);
180 LOAD_FUNC(snd_pcm_sw_params_current
);
181 LOAD_FUNC(snd_pcm_sw_params_set_avail_min
);
182 LOAD_FUNC(snd_pcm_sw_params
);
183 LOAD_FUNC(snd_pcm_sw_params_free
);
184 LOAD_FUNC(snd_pcm_prepare
);
185 LOAD_FUNC(snd_pcm_start
);
186 LOAD_FUNC(snd_pcm_resume
);
187 LOAD_FUNC(snd_pcm_wait
);
188 LOAD_FUNC(snd_pcm_state
);
189 LOAD_FUNC(snd_pcm_avail_update
);
190 LOAD_FUNC(snd_pcm_areas_silence
);
191 LOAD_FUNC(snd_pcm_mmap_begin
);
192 LOAD_FUNC(snd_pcm_mmap_commit
);
193 LOAD_FUNC(snd_pcm_readi
);
194 LOAD_FUNC(snd_pcm_writei
);
195 LOAD_FUNC(snd_pcm_drain
);
196 LOAD_FUNC(snd_pcm_recover
);
198 LOAD_FUNC(snd_pcm_info_malloc
);
199 LOAD_FUNC(snd_pcm_info_free
);
200 LOAD_FUNC(snd_pcm_info_set_device
);
201 LOAD_FUNC(snd_pcm_info_set_subdevice
);
202 LOAD_FUNC(snd_pcm_info_set_stream
);
203 LOAD_FUNC(snd_pcm_info_get_name
);
204 LOAD_FUNC(snd_ctl_pcm_next_device
);
205 LOAD_FUNC(snd_ctl_pcm_info
);
206 LOAD_FUNC(snd_ctl_open
);
207 LOAD_FUNC(snd_ctl_close
);
208 LOAD_FUNC(snd_ctl_card_info_malloc
);
209 LOAD_FUNC(snd_ctl_card_info_free
);
210 LOAD_FUNC(snd_ctl_card_info
);
211 LOAD_FUNC(snd_ctl_card_info_get_name
);
212 LOAD_FUNC(snd_card_next
);
219 static DevMap
*probe_devices(snd_pcm_stream_t stream
, ALuint
*count
)
222 int card
, err
, dev
, idx
;
223 snd_ctl_card_info_t
*info
;
224 snd_pcm_info_t
*pcminfo
;
228 psnd_ctl_card_info_malloc(&info
);
229 psnd_pcm_info_malloc(&pcminfo
);
232 if((err
=psnd_card_next(&card
)) < 0)
233 AL_PRINT("Failed to find a card: %s\n", psnd_strerror(err
));
235 DevList
= malloc(sizeof(DevMap
) * 1);
236 DevList
[0].name
= strdup("ALSA Default");
240 sprintf(name
, "hw:%d", card
);
241 if((err
= psnd_ctl_open(&handle
, name
, 0)) < 0)
243 AL_PRINT("control open (%i): %s\n", card
, psnd_strerror(err
));
246 if((err
= psnd_ctl_card_info(handle
, info
)) < 0)
248 AL_PRINT("control hardware info (%i): %s\n", card
, psnd_strerror(err
));
249 psnd_ctl_close(handle
);
256 const char *cname
, *dname
;
259 if(psnd_ctl_pcm_next_device(handle
, &dev
) < 0)
260 AL_PRINT("snd_ctl_pcm_next_device failed\n");
264 psnd_pcm_info_set_device(pcminfo
, dev
);
265 psnd_pcm_info_set_subdevice(pcminfo
, 0);
266 psnd_pcm_info_set_stream(pcminfo
, stream
);
267 if((err
= psnd_ctl_pcm_info(handle
, pcminfo
)) < 0) {
269 AL_PRINT("control digital audio info (%i): %s\n", card
, psnd_strerror(err
));
273 temp
= realloc(DevList
, sizeof(DevMap
) * (idx
+1));
277 cname
= psnd_ctl_card_info_get_name(info
);
278 dname
= psnd_pcm_info_get_name(pcminfo
);
279 snprintf(name
, sizeof(name
), "%s [%s] (hw:%d,%d) via ALSA",
280 cname
, dname
, card
, dev
);
281 DevList
[idx
].name
= strdup(name
);
282 DevList
[idx
].card
= card
;
283 DevList
[idx
].dev
= dev
;
287 psnd_ctl_close(handle
);
289 if(psnd_card_next(&card
) < 0) {
290 AL_PRINT("snd_card_next failed\n");
295 psnd_pcm_info_free(pcminfo
);
296 psnd_ctl_card_info_free(info
);
303 static int xrun_recovery(snd_pcm_t
*handle
, int err
)
305 err
= psnd_pcm_recover(handle
, err
, 1);
307 AL_PRINT("recover failed: %s\n", psnd_strerror(err
));
311 static int verify_state(snd_pcm_t
*handle
)
313 snd_pcm_state_t state
= psnd_pcm_state(handle
);
314 if(state
== SND_PCM_STATE_DISCONNECTED
)
316 if(state
== SND_PCM_STATE_XRUN
)
318 int err
= xrun_recovery(handle
, -EPIPE
);
319 if(err
< 0) return err
;
321 else if(state
== SND_PCM_STATE_SUSPENDED
)
323 int err
= xrun_recovery(handle
, -ESTRPIPE
);
324 if(err
< 0) return err
;
331 static ALuint
ALSAProc(ALvoid
*ptr
)
333 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
334 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
335 const snd_pcm_channel_area_t
*areas
= NULL
;
336 snd_pcm_sframes_t avail
, commitres
;
337 snd_pcm_uframes_t offset
, frames
;
343 while(!data
->killNow
)
345 int state
= verify_state(data
->pcmHandle
);
348 AL_PRINT("Invalid state detected: %s\n", psnd_strerror(state
));
349 aluHandleDisconnect(pDevice
);
353 avail
= psnd_pcm_avail_update(data
->pcmHandle
);
356 AL_PRINT("available update failed: %s\n", psnd_strerror(avail
));
360 // make sure there's frames to process
361 if((snd_pcm_uframes_t
)avail
< pDevice
->UpdateSize
)
363 if(state
!= SND_PCM_STATE_RUNNING
)
365 err
= psnd_pcm_start(data
->pcmHandle
);
368 AL_PRINT("start failed: %s\n", psnd_strerror(err
));
372 if(psnd_pcm_wait(data
->pcmHandle
, 1000) == 0)
373 AL_PRINT("Wait timeout... buffer size too low?\n");
376 avail
-= avail
%pDevice
->UpdateSize
;
378 // it is possible that contiguous areas are smaller, thus we use a loop
383 err
= psnd_pcm_mmap_begin(data
->pcmHandle
, &areas
, &offset
, &frames
);
386 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err
));
390 WritePtr
= (char*)areas
->addr
+ (offset
* areas
->step
/ 8);
391 aluMixData(pDevice
, WritePtr
, frames
);
393 commitres
= psnd_pcm_mmap_commit(data
->pcmHandle
, offset
, frames
);
394 if(commitres
< 0 || (commitres
-frames
) != 0)
396 AL_PRINT("mmap commit error: %s\n",
397 psnd_strerror(commitres
>= 0 ? -EPIPE
: commitres
));
408 static ALuint
ALSANoMMapProc(ALvoid
*ptr
)
410 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
411 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
412 snd_pcm_sframes_t avail
;
417 while(!data
->killNow
)
419 int state
= verify_state(data
->pcmHandle
);
422 AL_PRINT("Invalid state detected: %s\n", psnd_strerror(state
));
423 aluHandleDisconnect(pDevice
);
427 WritePtr
= data
->buffer
;
428 avail
= data
->size
/ psnd_pcm_frames_to_bytes(data
->pcmHandle
, 1);
429 aluMixData(pDevice
, WritePtr
, avail
);
433 int ret
= psnd_pcm_writei(data
->pcmHandle
, WritePtr
, avail
);
441 ret
= psnd_pcm_recover(data
->pcmHandle
, ret
, 1);
448 WritePtr
+= psnd_pcm_frames_to_bytes(data
->pcmHandle
, ret
);
455 ret
= psnd_pcm_prepare(data
->pcmHandle
);
465 static ALCboolean
alsa_open_playback(ALCdevice
*device
, const ALCchar
*deviceName
)
474 strncpy(driver
, GetConfigValue("alsa", "device", "default"), sizeof(driver
)-1);
475 driver
[sizeof(driver
)-1] = 0;
478 deviceName
= alsaDevice
;
479 else if(strcmp(deviceName
, alsaDevice
) != 0)
484 allDevNameMap
= probe_devices(SND_PCM_STREAM_PLAYBACK
, &numDevNames
);
486 for(idx
= 0;idx
< numDevNames
;idx
++)
488 if(allDevNameMap
[idx
].name
&&
489 strcmp(deviceName
, allDevNameMap
[idx
].name
) == 0)
492 sprintf(driver
, "hw:%d,%d", allDevNameMap
[idx
].card
, allDevNameMap
[idx
].dev
);
496 if(idx
== numDevNames
)
500 data
= (alsa_data
*)calloc(1, sizeof(alsa_data
));
502 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_PLAYBACK
, SND_PCM_NONBLOCK
);
506 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_PLAYBACK
, SND_PCM_NONBLOCK
);
510 i
= psnd_pcm_nonblock(data
->pcmHandle
, 0);
512 psnd_pcm_close(data
->pcmHandle
);
517 AL_PRINT("Could not open playback device '%s': %s\n", driver
, psnd_strerror(i
));
521 device
->szDeviceName
= strdup(deviceName
);
522 device
->ExtraData
= data
;
526 static void alsa_close_playback(ALCdevice
*device
)
528 alsa_data
*data
= (alsa_data
*)device
->ExtraData
;
530 psnd_pcm_close(data
->pcmHandle
);
532 device
->ExtraData
= NULL
;
535 static ALCboolean
alsa_reset_playback(ALCdevice
*device
)
537 alsa_data
*data
= (alsa_data
*)device
->ExtraData
;
538 snd_pcm_uframes_t periodSizeInFrames
;
539 unsigned int periodLen
, bufferLen
;
540 snd_pcm_sw_params_t
*sp
= NULL
;
541 snd_pcm_hw_params_t
*p
= NULL
;
542 snd_pcm_access_t access
;
543 snd_pcm_format_t format
;
544 unsigned int periods
;
551 switch(aluBytesFromFormat(device
->Format
))
554 format
= SND_PCM_FORMAT_U8
;
557 format
= SND_PCM_FORMAT_S16
;
560 format
= SND_PCM_FORMAT_FLOAT
;
563 AL_PRINT("Unknown format: 0x%x\n", device
->Format
);
567 allowmmap
= GetConfigValueBool("alsa", "mmap", 1);
568 periods
= device
->NumUpdates
;
569 periodLen
= (ALuint64
)device
->UpdateSize
* 1000000 / device
->Frequency
;
570 rate
= device
->Frequency
;
573 psnd_pcm_hw_params_malloc(&p
);
575 if((i
=psnd_pcm_hw_params_any(data
->pcmHandle
, p
)) < 0)
577 /* set interleaved access */
578 if(i
>= 0 && (!allowmmap
|| (i
=psnd_pcm_hw_params_set_access(data
->pcmHandle
, p
, SND_PCM_ACCESS_MMAP_INTERLEAVED
)) < 0))
580 if(periods
> 2) periods
--;
581 if((i
=psnd_pcm_hw_params_set_access(data
->pcmHandle
, p
, SND_PCM_ACCESS_RW_INTERLEAVED
)) < 0)
584 /* set format (implicitly sets sample bits) */
585 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, format
)) < 0)
587 switch(aluChannelsFromFormat(device
->Format
))
589 case 1: device
->Format
= AL_FORMAT_MONO_FLOAT32
; break;
590 case 2: device
->Format
= AL_FORMAT_STEREO_FLOAT32
; break;
591 case 4: device
->Format
= AL_FORMAT_QUAD32
; break;
592 case 6: device
->Format
= AL_FORMAT_51CHN32
; break;
593 case 7: device
->Format
= AL_FORMAT_61CHN32
; break;
594 case 8: device
->Format
= AL_FORMAT_71CHN32
; break;
596 if(format
== SND_PCM_FORMAT_FLOAT
||
597 (i
=psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, SND_PCM_FORMAT_FLOAT
)) < 0)
599 switch(aluChannelsFromFormat(device
->Format
))
601 case 1: device
->Format
= AL_FORMAT_MONO16
; break;
602 case 2: device
->Format
= AL_FORMAT_STEREO16
; break;
603 case 4: device
->Format
= AL_FORMAT_QUAD16
; break;
604 case 6: device
->Format
= AL_FORMAT_51CHN16
; break;
605 case 7: device
->Format
= AL_FORMAT_61CHN16
; break;
606 case 8: device
->Format
= AL_FORMAT_71CHN16
; break;
608 if(format
== SND_PCM_FORMAT_S16
||
609 (i
=psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, SND_PCM_FORMAT_S16
)) < 0)
611 switch(aluChannelsFromFormat(device
->Format
))
613 case 1: device
->Format
= AL_FORMAT_MONO8
; break;
614 case 2: device
->Format
= AL_FORMAT_STEREO8
; break;
615 case 4: device
->Format
= AL_FORMAT_QUAD8
; break;
616 case 6: device
->Format
= AL_FORMAT_51CHN8
; break;
617 case 7: device
->Format
= AL_FORMAT_61CHN8
; break;
618 case 8: device
->Format
= AL_FORMAT_71CHN8
; break;
620 if(format
== SND_PCM_FORMAT_U8
||
621 (i
=psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, SND_PCM_FORMAT_U8
)) < 0)
626 /* set channels (implicitly sets frame bits) */
627 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_channels(data
->pcmHandle
, p
, aluChannelsFromFormat(device
->Format
))) < 0)
629 switch(aluBytesFromFormat(device
->Format
))
631 case 1: device
->Format
= AL_FORMAT_STEREO8
; break;
632 case 2: device
->Format
= AL_FORMAT_STEREO16
; break;
633 case 4: device
->Format
= AL_FORMAT_STEREO_FLOAT32
; break;
635 if((i
=psnd_pcm_hw_params_set_channels(data
->pcmHandle
, p
, 2)) < 0)
637 switch(aluBytesFromFormat(device
->Format
))
639 case 1: device
->Format
= AL_FORMAT_MONO8
; break;
640 case 2: device
->Format
= AL_FORMAT_MONO16
; break;
641 case 4: device
->Format
= AL_FORMAT_MONO_FLOAT32
; break;
643 if((i
=psnd_pcm_hw_params_set_channels(data
->pcmHandle
, p
, 1)) < 0)
644 err
= "set channels";
647 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_rate_resample(data
->pcmHandle
, p
, 0)) < 0)
649 AL_PRINT("Failed to disable ALSA resampler\n");
652 /* set rate (implicitly constrains period/buffer parameters) */
653 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_rate_near(data
->pcmHandle
, p
, &rate
, NULL
)) < 0)
654 err
= "set rate near";
655 /* set buffer time (implicitly constrains period/buffer parameters) */
656 bufferLen
= periodLen
* periods
;
657 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_buffer_time_near(data
->pcmHandle
, p
, &bufferLen
, NULL
)) < 0)
658 err
= "set buffer time near";
659 /* set period time in frame units (implicitly sets buffer size/bytes/time and period size/bytes) */
660 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_period_time_near(data
->pcmHandle
, p
, &periodLen
, NULL
)) < 0)
661 err
= "set period time near";
662 /* install and prepare hardware configuration */
663 if(i
>= 0 && (i
=psnd_pcm_hw_params(data
->pcmHandle
, p
)) < 0)
665 if(i
>= 0 && (i
=psnd_pcm_hw_params_get_access(p
, &access
)) < 0)
667 if(i
>= 0 && (i
=psnd_pcm_hw_params_get_period_size(p
, &periodSizeInFrames
, NULL
)) < 0)
668 err
= "get period size";
669 if(i
>= 0 && (i
=psnd_pcm_hw_params_get_periods(p
, &periods
, NULL
)) < 0)
673 AL_PRINT("%s failed: %s\n", err
, psnd_strerror(i
));
674 psnd_pcm_hw_params_free(p
);
678 psnd_pcm_hw_params_free(p
);
681 psnd_pcm_sw_params_malloc(&sp
);
683 if((i
=psnd_pcm_sw_params_current(data
->pcmHandle
, sp
)) != 0)
685 if(i
== 0 && (i
=psnd_pcm_sw_params_set_avail_min(data
->pcmHandle
, sp
, periodSizeInFrames
)) != 0)
686 err
= "sw set avail min";
687 if(i
== 0 && (i
=psnd_pcm_sw_params(data
->pcmHandle
, sp
)) != 0)
688 err
= "sw set params";
691 AL_PRINT("%s failed: %s\n", err
, psnd_strerror(i
));
692 psnd_pcm_sw_params_free(sp
);
696 psnd_pcm_sw_params_free(sp
);
698 device
->TimeRes
= (ALuint64
)periodSizeInFrames
* 1000000000 / rate
;
699 device
->Frequency
= rate
;
701 SetDefaultChannelOrder(device
);
703 data
->size
= psnd_pcm_frames_to_bytes(data
->pcmHandle
, periodSizeInFrames
);
704 if(access
== SND_PCM_ACCESS_RW_INTERLEAVED
)
706 /* Increase periods by one, since the temp buffer counts as an extra
709 data
->buffer
= malloc(data
->size
);
712 AL_PRINT("buffer malloc failed\n");
715 device
->UpdateSize
= periodSizeInFrames
;
716 device
->NumUpdates
= periods
;
717 data
->thread
= StartThread(ALSANoMMapProc
, device
);
721 i
= psnd_pcm_prepare(data
->pcmHandle
);
724 AL_PRINT("prepare error: %s\n", psnd_strerror(i
));
727 device
->UpdateSize
= periodSizeInFrames
;
728 device
->NumUpdates
= periods
;
729 data
->thread
= StartThread(ALSAProc
, device
);
731 if(data
->thread
== NULL
)
733 AL_PRINT("Could not create playback thread\n");
742 static void alsa_stop_playback(ALCdevice
*device
)
744 alsa_data
*data
= (alsa_data
*)device
->ExtraData
;
749 StopThread(data
->thread
);
758 static ALCboolean
alsa_open_capture(ALCdevice
*pDevice
, const ALCchar
*deviceName
)
760 snd_pcm_hw_params_t
*p
;
761 snd_pcm_uframes_t bufferSizeInFrames
;
762 snd_pcm_format_t format
;
772 strncpy(driver
, GetConfigValue("alsa", "capture", "default"), sizeof(driver
)-1);
773 driver
[sizeof(driver
)-1] = 0;
775 if(!allCaptureDevNameMap
)
776 allCaptureDevNameMap
= probe_devices(SND_PCM_STREAM_CAPTURE
, &numCaptureDevNames
);
779 deviceName
= allCaptureDevNameMap
[0].name
;
784 for(idx
= 0;idx
< numCaptureDevNames
;idx
++)
786 if(allCaptureDevNameMap
[idx
].name
&&
787 strcmp(deviceName
, allCaptureDevNameMap
[idx
].name
) == 0)
790 sprintf(driver
, "plughw:%d,%d", allCaptureDevNameMap
[idx
].card
, allCaptureDevNameMap
[idx
].dev
);
794 if(idx
== numCaptureDevNames
)
798 data
= (alsa_data
*)calloc(1, sizeof(alsa_data
));
800 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_CAPTURE
, SND_PCM_NONBLOCK
);
804 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_CAPTURE
, SND_PCM_NONBLOCK
);
808 AL_PRINT("Could not open capture device '%s': %s\n", driver
, psnd_strerror(i
));
813 switch(aluBytesFromFormat(pDevice
->Format
))
816 format
= SND_PCM_FORMAT_U8
;
819 format
= SND_PCM_FORMAT_S16
;
822 format
= SND_PCM_FORMAT_FLOAT
;
825 AL_PRINT("Unknown format: 0x%x\n", pDevice
->Format
);
830 bufferSizeInFrames
= pDevice
->UpdateSize
* pDevice
->NumUpdates
;
831 psnd_pcm_hw_params_malloc(&p
);
833 if((i
=psnd_pcm_hw_params_any(data
->pcmHandle
, p
)) < 0)
835 /* set interleaved access */
836 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_access(data
->pcmHandle
, p
, SND_PCM_ACCESS_RW_INTERLEAVED
)) < 0)
838 /* set format (implicitly sets sample bits) */
839 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, format
)) < 0)
841 /* set channels (implicitly sets frame bits) */
842 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_channels(data
->pcmHandle
, p
, aluChannelsFromFormat(pDevice
->Format
))) < 0)
843 err
= "set channels";
844 /* set rate (implicitly constrains period/buffer parameters) */
845 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_rate(data
->pcmHandle
, p
, pDevice
->Frequency
, 0)) < 0)
846 err
= "set rate near";
847 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
848 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_buffer_size_near(data
->pcmHandle
, p
, &bufferSizeInFrames
)) < 0)
849 err
= "set buffer size near";
850 /* install and prepare hardware configuration */
851 if(i
>= 0 && (i
=psnd_pcm_hw_params(data
->pcmHandle
, p
)) < 0)
855 AL_PRINT("%s failed: %s\n", err
, psnd_strerror(i
));
856 psnd_pcm_hw_params_free(p
);
860 if((i
=psnd_pcm_hw_params_get_period_size(p
, &bufferSizeInFrames
, NULL
)) < 0)
862 AL_PRINT("get size failed: %s\n", psnd_strerror(i
));
863 psnd_pcm_hw_params_free(p
);
867 psnd_pcm_hw_params_free(p
);
869 frameSize
= aluFrameSizeFromFormat(pDevice
->Format
);
871 data
->ring
= CreateRingBuffer(frameSize
, pDevice
->UpdateSize
*pDevice
->NumUpdates
);
874 AL_PRINT("ring buffer create failed\n");
878 data
->size
= psnd_pcm_frames_to_bytes(data
->pcmHandle
, bufferSizeInFrames
);
879 data
->buffer
= malloc(data
->size
);
882 AL_PRINT("buffer malloc failed\n");
886 pDevice
->szDeviceName
= strdup(deviceName
);
888 pDevice
->ExtraData
= data
;
893 DestroyRingBuffer(data
->ring
);
894 psnd_pcm_close(data
->pcmHandle
);
897 pDevice
->ExtraData
= NULL
;
901 static void alsa_close_capture(ALCdevice
*pDevice
)
903 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
905 psnd_pcm_close(data
->pcmHandle
);
906 DestroyRingBuffer(data
->ring
);
910 pDevice
->ExtraData
= NULL
;
913 static void alsa_start_capture(ALCdevice
*Device
)
915 alsa_data
*data
= (alsa_data
*)Device
->ExtraData
;
918 err
= psnd_pcm_start(data
->pcmHandle
);
921 AL_PRINT("start failed: %s\n", psnd_strerror(err
));
922 aluHandleDisconnect(Device
);
925 data
->doCapture
= AL_TRUE
;
928 static void alsa_stop_capture(ALCdevice
*Device
)
930 alsa_data
*data
= (alsa_data
*)Device
->ExtraData
;
931 psnd_pcm_drain(data
->pcmHandle
);
932 data
->doCapture
= AL_FALSE
;
935 static ALCuint
alsa_available_samples(ALCdevice
*Device
)
937 alsa_data
*data
= (alsa_data
*)Device
->ExtraData
;
938 snd_pcm_sframes_t avail
;
940 avail
= (Device
->Connected
? psnd_pcm_avail_update(data
->pcmHandle
) : 0);
943 AL_PRINT("avail update failed: %s\n", psnd_strerror(avail
));
945 if((avail
=psnd_pcm_recover(data
->pcmHandle
, avail
, 1)) >= 0)
948 avail
= psnd_pcm_start(data
->pcmHandle
);
950 avail
= psnd_pcm_avail_update(data
->pcmHandle
);
954 AL_PRINT("restore error: %s\n", psnd_strerror(avail
));
955 aluHandleDisconnect(Device
);
960 snd_pcm_sframes_t amt
;
962 amt
= psnd_pcm_bytes_to_frames(data
->pcmHandle
, data
->size
);
963 if(avail
< amt
) amt
= avail
;
965 amt
= psnd_pcm_readi(data
->pcmHandle
, data
->buffer
, amt
);
968 AL_PRINT("read error: %s\n", psnd_strerror(amt
));
972 if((amt
=psnd_pcm_recover(data
->pcmHandle
, amt
, 1)) >= 0)
975 amt
= psnd_pcm_start(data
->pcmHandle
);
977 amt
= psnd_pcm_avail_update(data
->pcmHandle
);
981 AL_PRINT("restore error: %s\n", psnd_strerror(amt
));
982 aluHandleDisconnect(Device
);
989 WriteRingBuffer(data
->ring
, data
->buffer
, amt
);
993 return RingBufferSize(data
->ring
);
996 static void alsa_capture_samples(ALCdevice
*Device
, ALCvoid
*Buffer
, ALCuint Samples
)
998 alsa_data
*data
= (alsa_data
*)Device
->ExtraData
;
1000 if(Samples
<= alsa_available_samples(Device
))
1001 ReadRingBuffer(data
->ring
, Buffer
, Samples
);
1003 alcSetError(Device
, ALC_INVALID_VALUE
);
1006 static ALuint64
alsa_get_time(ALCdevice
*Device
)
1008 return Device
->SamplesPlayed
* 1000000000 / Device
->Frequency
;
1012 BackendFuncs alsa_funcs
= {
1014 alsa_close_playback
,
1015 alsa_reset_playback
,
1021 alsa_capture_samples
,
1022 alsa_available_samples
,
1026 void alc_alsa_init(BackendFuncs
*func_list
)
1028 *func_list
= alsa_funcs
;
1031 void alc_alsa_deinit(void)
1035 for(i
= 0;i
< numDevNames
;++i
)
1036 free(allDevNameMap
[i
].name
);
1037 free(allDevNameMap
);
1038 allDevNameMap
= NULL
;
1041 for(i
= 0;i
< numCaptureDevNames
;++i
)
1042 free(allCaptureDevNameMap
[i
].name
);
1043 free(allCaptureDevNameMap
);
1044 allCaptureDevNameMap
= NULL
;
1045 numCaptureDevNames
= 0;
1050 dlclose(alsa_handle
);
1056 void alc_alsa_probe(int type
)
1063 if(type
== DEVICE_PROBE
)
1064 AppendDeviceList(alsaDevice
);
1065 else if(type
== ALL_DEVICE_PROBE
)
1067 for(i
= 0;i
< numDevNames
;++i
)
1068 free(allDevNameMap
[i
].name
);
1070 free(allDevNameMap
);
1071 allDevNameMap
= probe_devices(SND_PCM_STREAM_PLAYBACK
, &numDevNames
);
1073 for(i
= 0;i
< numDevNames
;++i
)
1074 AppendAllDeviceList(allDevNameMap
[i
].name
);
1076 else if(type
== CAPTURE_DEVICE_PROBE
)
1078 for(i
= 0;i
< numCaptureDevNames
;++i
)
1079 free(allCaptureDevNameMap
[i
].name
);
1081 free(allCaptureDevNameMap
);
1082 allCaptureDevNameMap
= probe_devices(SND_PCM_STREAM_CAPTURE
, &numCaptureDevNames
);
1084 for(i
= 0;i
< numCaptureDevNames
;++i
)
1085 AppendCaptureDeviceList(allCaptureDevNameMap
[i
].name
);