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
29 #include <alsa/asoundlib.h>
32 static const ALCchar alsaDevice
[] = "ALSA Default";
35 static void *alsa_handle
;
37 #define MAKE_FUNC(f) static typeof(f) * p##f
38 MAKE_FUNC(snd_strerror
);
39 MAKE_FUNC(snd_pcm_open
);
40 MAKE_FUNC(snd_pcm_close
);
41 MAKE_FUNC(snd_pcm_nonblock
);
42 MAKE_FUNC(snd_pcm_frames_to_bytes
);
43 MAKE_FUNC(snd_pcm_bytes_to_frames
);
44 MAKE_FUNC(snd_pcm_hw_params_malloc
);
45 MAKE_FUNC(snd_pcm_hw_params_free
);
46 MAKE_FUNC(snd_pcm_hw_params_any
);
47 MAKE_FUNC(snd_pcm_hw_params_set_access
);
48 MAKE_FUNC(snd_pcm_hw_params_set_format
);
49 MAKE_FUNC(snd_pcm_hw_params_set_channels
);
50 MAKE_FUNC(snd_pcm_hw_params_set_periods_near
);
51 MAKE_FUNC(snd_pcm_hw_params_set_rate_near
);
52 MAKE_FUNC(snd_pcm_hw_params_set_rate
);
53 MAKE_FUNC(snd_pcm_hw_params_set_rate_resample
);
54 MAKE_FUNC(snd_pcm_hw_params_set_buffer_time_near
);
55 MAKE_FUNC(snd_pcm_hw_params_set_period_time_near
);
56 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_near
);
57 MAKE_FUNC(snd_pcm_hw_params_set_period_size_near
);
58 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_min
);
59 MAKE_FUNC(snd_pcm_hw_params_get_buffer_size
);
60 MAKE_FUNC(snd_pcm_hw_params_get_period_size
);
61 MAKE_FUNC(snd_pcm_hw_params_get_access
);
62 MAKE_FUNC(snd_pcm_hw_params_get_periods
);
63 MAKE_FUNC(snd_pcm_hw_params_test_format
);
64 MAKE_FUNC(snd_pcm_hw_params_test_channels
);
65 MAKE_FUNC(snd_pcm_hw_params
);
66 MAKE_FUNC(snd_pcm_sw_params_malloc
);
67 MAKE_FUNC(snd_pcm_sw_params_current
);
68 MAKE_FUNC(snd_pcm_sw_params_set_avail_min
);
69 MAKE_FUNC(snd_pcm_sw_params_set_stop_threshold
);
70 MAKE_FUNC(snd_pcm_sw_params
);
71 MAKE_FUNC(snd_pcm_sw_params_free
);
72 MAKE_FUNC(snd_pcm_prepare
);
73 MAKE_FUNC(snd_pcm_start
);
74 MAKE_FUNC(snd_pcm_resume
);
75 MAKE_FUNC(snd_pcm_reset
);
76 MAKE_FUNC(snd_pcm_wait
);
77 MAKE_FUNC(snd_pcm_state
);
78 MAKE_FUNC(snd_pcm_avail_update
);
79 MAKE_FUNC(snd_pcm_areas_silence
);
80 MAKE_FUNC(snd_pcm_mmap_begin
);
81 MAKE_FUNC(snd_pcm_mmap_commit
);
82 MAKE_FUNC(snd_pcm_readi
);
83 MAKE_FUNC(snd_pcm_writei
);
84 MAKE_FUNC(snd_pcm_drain
);
85 MAKE_FUNC(snd_pcm_recover
);
86 MAKE_FUNC(snd_pcm_info_malloc
);
87 MAKE_FUNC(snd_pcm_info_free
);
88 MAKE_FUNC(snd_pcm_info_set_device
);
89 MAKE_FUNC(snd_pcm_info_set_subdevice
);
90 MAKE_FUNC(snd_pcm_info_set_stream
);
91 MAKE_FUNC(snd_pcm_info_get_name
);
92 MAKE_FUNC(snd_ctl_pcm_next_device
);
93 MAKE_FUNC(snd_ctl_pcm_info
);
94 MAKE_FUNC(snd_ctl_open
);
95 MAKE_FUNC(snd_ctl_close
);
96 MAKE_FUNC(snd_ctl_card_info_malloc
);
97 MAKE_FUNC(snd_ctl_card_info_free
);
98 MAKE_FUNC(snd_ctl_card_info
);
99 MAKE_FUNC(snd_ctl_card_info_get_name
);
100 MAKE_FUNC(snd_ctl_card_info_get_id
);
101 MAKE_FUNC(snd_card_next
);
104 #define snd_strerror psnd_strerror
105 #define snd_pcm_open psnd_pcm_open
106 #define snd_pcm_close psnd_pcm_close
107 #define snd_pcm_nonblock psnd_pcm_nonblock
108 #define snd_pcm_frames_to_bytes psnd_pcm_frames_to_bytes
109 #define snd_pcm_bytes_to_frames psnd_pcm_bytes_to_frames
110 #define snd_pcm_hw_params_malloc psnd_pcm_hw_params_malloc
111 #define snd_pcm_hw_params_free psnd_pcm_hw_params_free
112 #define snd_pcm_hw_params_any psnd_pcm_hw_params_any
113 #define snd_pcm_hw_params_set_access psnd_pcm_hw_params_set_access
114 #define snd_pcm_hw_params_set_format psnd_pcm_hw_params_set_format
115 #define snd_pcm_hw_params_set_channels psnd_pcm_hw_params_set_channels
116 #define snd_pcm_hw_params_set_periods_near psnd_pcm_hw_params_set_periods_near
117 #define snd_pcm_hw_params_set_rate_near psnd_pcm_hw_params_set_rate_near
118 #define snd_pcm_hw_params_set_rate psnd_pcm_hw_params_set_rate
119 #define snd_pcm_hw_params_set_rate_resample psnd_pcm_hw_params_set_rate_resample
120 #define snd_pcm_hw_params_set_buffer_time_near psnd_pcm_hw_params_set_buffer_time_near
121 #define snd_pcm_hw_params_set_period_time_near psnd_pcm_hw_params_set_period_time_near
122 #define snd_pcm_hw_params_set_buffer_size_near psnd_pcm_hw_params_set_buffer_size_near
123 #define snd_pcm_hw_params_set_period_size_near psnd_pcm_hw_params_set_period_size_near
124 #define snd_pcm_hw_params_set_buffer_size_min psnd_pcm_hw_params_set_buffer_size_min
125 #define snd_pcm_hw_params_get_buffer_size psnd_pcm_hw_params_get_buffer_size
126 #define snd_pcm_hw_params_get_period_size psnd_pcm_hw_params_get_period_size
127 #define snd_pcm_hw_params_get_access psnd_pcm_hw_params_get_access
128 #define snd_pcm_hw_params_get_periods psnd_pcm_hw_params_get_periods
129 #define snd_pcm_hw_params_test_format psnd_pcm_hw_params_test_format
130 #define snd_pcm_hw_params_test_channels psnd_pcm_hw_params_test_channels
131 #define snd_pcm_hw_params psnd_pcm_hw_params
132 #define snd_pcm_sw_params_malloc psnd_pcm_sw_params_malloc
133 #define snd_pcm_sw_params_current psnd_pcm_sw_params_current
134 #define snd_pcm_sw_params_set_avail_min psnd_pcm_sw_params_set_avail_min
135 #define snd_pcm_sw_params_set_stop_threshold psnd_pcm_sw_params_set_stop_threshold
136 #define snd_pcm_sw_params psnd_pcm_sw_params
137 #define snd_pcm_sw_params_free psnd_pcm_sw_params_free
138 #define snd_pcm_prepare psnd_pcm_prepare
139 #define snd_pcm_start psnd_pcm_start
140 #define snd_pcm_resume psnd_pcm_resume
141 #define snd_pcm_reset psnd_pcm_reset
142 #define snd_pcm_wait psnd_pcm_wait
143 #define snd_pcm_state psnd_pcm_state
144 #define snd_pcm_avail_update psnd_pcm_avail_update
145 #define snd_pcm_areas_silence psnd_pcm_areas_silence
146 #define snd_pcm_mmap_begin psnd_pcm_mmap_begin
147 #define snd_pcm_mmap_commit psnd_pcm_mmap_commit
148 #define snd_pcm_readi psnd_pcm_readi
149 #define snd_pcm_writei psnd_pcm_writei
150 #define snd_pcm_drain psnd_pcm_drain
151 #define snd_pcm_recover psnd_pcm_recover
152 #define snd_pcm_info_malloc psnd_pcm_info_malloc
153 #define snd_pcm_info_free psnd_pcm_info_free
154 #define snd_pcm_info_set_device psnd_pcm_info_set_device
155 #define snd_pcm_info_set_subdevice psnd_pcm_info_set_subdevice
156 #define snd_pcm_info_set_stream psnd_pcm_info_set_stream
157 #define snd_pcm_info_get_name psnd_pcm_info_get_name
158 #define snd_ctl_pcm_next_device psnd_ctl_pcm_next_device
159 #define snd_ctl_pcm_info psnd_ctl_pcm_info
160 #define snd_ctl_open psnd_ctl_open
161 #define snd_ctl_close psnd_ctl_close
162 #define snd_ctl_card_info_malloc psnd_ctl_card_info_malloc
163 #define snd_ctl_card_info_free psnd_ctl_card_info_free
164 #define snd_ctl_card_info psnd_ctl_card_info
165 #define snd_ctl_card_info_get_name psnd_ctl_card_info_get_name
166 #define snd_ctl_card_info_get_id psnd_ctl_card_info_get_id
167 #define snd_card_next psnd_card_next
171 static ALCboolean
alsa_load(void)
176 alsa_handle
= LoadLib("libasound.so.2");
180 #define LOAD_FUNC(f) do { \
181 p##f = GetSymbol(alsa_handle, #f); \
183 CloseLib(alsa_handle); \
184 alsa_handle = NULL; \
188 LOAD_FUNC(snd_strerror
);
189 LOAD_FUNC(snd_pcm_open
);
190 LOAD_FUNC(snd_pcm_close
);
191 LOAD_FUNC(snd_pcm_nonblock
);
192 LOAD_FUNC(snd_pcm_frames_to_bytes
);
193 LOAD_FUNC(snd_pcm_bytes_to_frames
);
194 LOAD_FUNC(snd_pcm_hw_params_malloc
);
195 LOAD_FUNC(snd_pcm_hw_params_free
);
196 LOAD_FUNC(snd_pcm_hw_params_any
);
197 LOAD_FUNC(snd_pcm_hw_params_set_access
);
198 LOAD_FUNC(snd_pcm_hw_params_set_format
);
199 LOAD_FUNC(snd_pcm_hw_params_set_channels
);
200 LOAD_FUNC(snd_pcm_hw_params_set_periods_near
);
201 LOAD_FUNC(snd_pcm_hw_params_set_rate_near
);
202 LOAD_FUNC(snd_pcm_hw_params_set_rate
);
203 LOAD_FUNC(snd_pcm_hw_params_set_rate_resample
);
204 LOAD_FUNC(snd_pcm_hw_params_set_buffer_time_near
);
205 LOAD_FUNC(snd_pcm_hw_params_set_period_time_near
);
206 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near
);
207 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min
);
208 LOAD_FUNC(snd_pcm_hw_params_set_period_size_near
);
209 LOAD_FUNC(snd_pcm_hw_params_get_buffer_size
);
210 LOAD_FUNC(snd_pcm_hw_params_get_period_size
);
211 LOAD_FUNC(snd_pcm_hw_params_get_access
);
212 LOAD_FUNC(snd_pcm_hw_params_get_periods
);
213 LOAD_FUNC(snd_pcm_hw_params_test_format
);
214 LOAD_FUNC(snd_pcm_hw_params_test_channels
);
215 LOAD_FUNC(snd_pcm_hw_params
);
216 LOAD_FUNC(snd_pcm_sw_params_malloc
);
217 LOAD_FUNC(snd_pcm_sw_params_current
);
218 LOAD_FUNC(snd_pcm_sw_params_set_avail_min
);
219 LOAD_FUNC(snd_pcm_sw_params_set_stop_threshold
);
220 LOAD_FUNC(snd_pcm_sw_params
);
221 LOAD_FUNC(snd_pcm_sw_params_free
);
222 LOAD_FUNC(snd_pcm_prepare
);
223 LOAD_FUNC(snd_pcm_start
);
224 LOAD_FUNC(snd_pcm_resume
);
225 LOAD_FUNC(snd_pcm_reset
);
226 LOAD_FUNC(snd_pcm_wait
);
227 LOAD_FUNC(snd_pcm_state
);
228 LOAD_FUNC(snd_pcm_avail_update
);
229 LOAD_FUNC(snd_pcm_areas_silence
);
230 LOAD_FUNC(snd_pcm_mmap_begin
);
231 LOAD_FUNC(snd_pcm_mmap_commit
);
232 LOAD_FUNC(snd_pcm_readi
);
233 LOAD_FUNC(snd_pcm_writei
);
234 LOAD_FUNC(snd_pcm_drain
);
235 LOAD_FUNC(snd_pcm_recover
);
236 LOAD_FUNC(snd_pcm_info_malloc
);
237 LOAD_FUNC(snd_pcm_info_free
);
238 LOAD_FUNC(snd_pcm_info_set_device
);
239 LOAD_FUNC(snd_pcm_info_set_subdevice
);
240 LOAD_FUNC(snd_pcm_info_set_stream
);
241 LOAD_FUNC(snd_pcm_info_get_name
);
242 LOAD_FUNC(snd_ctl_pcm_next_device
);
243 LOAD_FUNC(snd_ctl_pcm_info
);
244 LOAD_FUNC(snd_ctl_open
);
245 LOAD_FUNC(snd_ctl_close
);
246 LOAD_FUNC(snd_ctl_card_info_malloc
);
247 LOAD_FUNC(snd_ctl_card_info_free
);
248 LOAD_FUNC(snd_ctl_card_info
);
249 LOAD_FUNC(snd_ctl_card_info_get_name
);
250 LOAD_FUNC(snd_ctl_card_info_get_id
);
251 LOAD_FUNC(snd_card_next
);
254 alsa_handle
= (void*)0xDEADBEEF;
262 snd_pcm_t
*pcmHandle
;
270 volatile int killNow
;
279 static DevMap
*allDevNameMap
;
280 static ALuint numDevNames
;
281 static DevMap
*allCaptureDevNameMap
;
282 static ALuint numCaptureDevNames
;
285 static const char *prefix_name(snd_pcm_stream_t stream
)
287 assert(stream
== SND_PCM_STREAM_PLAYBACK
|| stream
== SND_PCM_STREAM_CAPTURE
);
288 return (stream
==SND_PCM_STREAM_PLAYBACK
) ? "device-prefix" : "capture-prefix";
291 static DevMap
*probe_devices(snd_pcm_stream_t stream
, ALuint
*count
)
293 const char *main_prefix
= "plughw:";
295 int card
, err
, dev
, idx
;
296 snd_ctl_card_info_t
*info
;
297 snd_pcm_info_t
*pcminfo
;
300 ConfigValueStr("alsa", prefix_name(stream
), &main_prefix
);
302 snd_ctl_card_info_malloc(&info
);
303 snd_pcm_info_malloc(&pcminfo
);
305 DevList
= malloc(sizeof(DevMap
) * 1);
306 DevList
[0].name
= strdup("ALSA Default");
307 DevList
[0].device
= NULL
;
311 if((err
=snd_card_next(&card
)) < 0)
312 ERR("Failed to find a card: %s\n", snd_strerror(err
));
315 const char *card_prefix
= main_prefix
;
316 const char *cardname
, *cardid
;
319 snprintf(name
, sizeof(name
), "hw:%d", card
);
320 if((err
= snd_ctl_open(&handle
, name
, 0)) < 0)
322 ERR("control open (hw:%d): %s\n", card
, snd_strerror(err
));
325 if((err
= snd_ctl_card_info(handle
, info
)) < 0)
327 ERR("control hardware info (hw:%d): %s\n", card
, snd_strerror(err
));
328 snd_ctl_close(handle
);
332 cardname
= snd_ctl_card_info_get_name(info
);
333 cardid
= snd_ctl_card_info_get_id(info
);
335 snprintf(name
, sizeof(name
), "%s-%s", prefix_name(stream
), cardid
);
336 ConfigValueStr("alsa", name
, &card_prefix
);
344 if(snd_ctl_pcm_next_device(handle
, &dev
) < 0)
345 ERR("snd_ctl_pcm_next_device failed\n");
349 snd_pcm_info_set_device(pcminfo
, dev
);
350 snd_pcm_info_set_subdevice(pcminfo
, 0);
351 snd_pcm_info_set_stream(pcminfo
, stream
);
352 if((err
= snd_ctl_pcm_info(handle
, pcminfo
)) < 0) {
354 ERR("control digital audio info (hw:%d): %s\n", card
, snd_strerror(err
));
358 temp
= realloc(DevList
, sizeof(DevMap
) * (idx
+1));
361 const char *device_prefix
= card_prefix
;
365 devname
= snd_pcm_info_get_name(pcminfo
);
367 snprintf(name
, sizeof(name
), "%s-%s-%d", prefix_name(stream
), cardid
, dev
);
368 ConfigValueStr("alsa", name
, &device_prefix
);
370 snprintf(name
, sizeof(name
), "%s, %s (CARD=%s,DEV=%d)",
371 cardname
, devname
, cardid
, dev
);
372 snprintf(device
, sizeof(device
), "%sCARD=%s,DEV=%d",
373 device_prefix
, cardid
, dev
);
375 DevList
[idx
].name
= strdup(name
);
376 DevList
[idx
].device
= strdup(device
);
380 snd_ctl_close(handle
);
382 if(snd_card_next(&card
) < 0) {
383 ERR("snd_card_next failed\n");
388 snd_pcm_info_free(pcminfo
);
389 snd_ctl_card_info_free(info
);
396 static int xrun_recovery(snd_pcm_t
*handle
, int err
)
398 err
= snd_pcm_recover(handle
, err
, 1);
400 ERR("recover failed: %s\n", snd_strerror(err
));
404 static int verify_state(snd_pcm_t
*handle
)
406 snd_pcm_state_t state
= snd_pcm_state(handle
);
407 if(state
== SND_PCM_STATE_DISCONNECTED
)
409 if(state
== SND_PCM_STATE_XRUN
)
411 int err
= xrun_recovery(handle
, -EPIPE
);
412 if(err
< 0) return err
;
414 else if(state
== SND_PCM_STATE_SUSPENDED
)
416 int err
= xrun_recovery(handle
, -ESTRPIPE
);
417 if(err
< 0) return err
;
424 static ALuint
ALSAProc(ALvoid
*ptr
)
426 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
427 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
428 const snd_pcm_channel_area_t
*areas
= NULL
;
429 snd_pcm_uframes_t update_size
, num_updates
;
430 snd_pcm_sframes_t avail
, commitres
;
431 snd_pcm_uframes_t offset
, frames
;
437 update_size
= pDevice
->UpdateSize
;
438 num_updates
= pDevice
->NumUpdates
;
439 while(!data
->killNow
)
441 int state
= verify_state(data
->pcmHandle
);
444 ERR("Invalid state detected: %s\n", snd_strerror(state
));
445 aluHandleDisconnect(pDevice
);
449 avail
= snd_pcm_avail_update(data
->pcmHandle
);
452 ERR("available update failed: %s\n", snd_strerror(avail
));
456 if((snd_pcm_uframes_t
)avail
> update_size
*(num_updates
+1))
458 WARN("available samples exceeds the buffer size\n");
459 snd_pcm_reset(data
->pcmHandle
);
463 // make sure there's frames to process
464 if((snd_pcm_uframes_t
)avail
< update_size
)
466 if(state
!= SND_PCM_STATE_RUNNING
)
468 err
= snd_pcm_start(data
->pcmHandle
);
471 ERR("start failed: %s\n", snd_strerror(err
));
475 if(snd_pcm_wait(data
->pcmHandle
, 1000) == 0)
476 ERR("Wait timeout... buffer size too low?\n");
479 avail
-= avail
%update_size
;
481 // it is possible that contiguous areas are smaller, thus we use a loop
486 err
= snd_pcm_mmap_begin(data
->pcmHandle
, &areas
, &offset
, &frames
);
489 ERR("mmap begin error: %s\n", snd_strerror(err
));
493 WritePtr
= (char*)areas
->addr
+ (offset
* areas
->step
/ 8);
494 aluMixData(pDevice
, WritePtr
, frames
);
496 commitres
= snd_pcm_mmap_commit(data
->pcmHandle
, offset
, frames
);
497 if(commitres
< 0 || (commitres
-frames
) != 0)
499 ERR("mmap commit error: %s\n",
500 snd_strerror(commitres
>= 0 ? -EPIPE
: commitres
));
511 static ALuint
ALSANoMMapProc(ALvoid
*ptr
)
513 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
514 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
515 snd_pcm_sframes_t avail
;
520 while(!data
->killNow
)
522 int state
= verify_state(data
->pcmHandle
);
525 ERR("Invalid state detected: %s\n", snd_strerror(state
));
526 aluHandleDisconnect(pDevice
);
530 WritePtr
= data
->buffer
;
531 avail
= data
->size
/ snd_pcm_frames_to_bytes(data
->pcmHandle
, 1);
532 aluMixData(pDevice
, WritePtr
, avail
);
536 int ret
= snd_pcm_writei(data
->pcmHandle
, WritePtr
, avail
);
544 ret
= snd_pcm_recover(data
->pcmHandle
, ret
, 1);
551 WritePtr
+= snd_pcm_frames_to_bytes(data
->pcmHandle
, ret
);
558 ret
= snd_pcm_prepare(data
->pcmHandle
);
568 static ALCenum
alsa_open_playback(ALCdevice
*device
, const ALCchar
*deviceName
)
570 const char *driver
= "default";
574 ConfigValueStr("alsa", "device", &driver
);
577 deviceName
= alsaDevice
;
578 else if(strcmp(deviceName
, alsaDevice
) != 0)
583 allDevNameMap
= probe_devices(SND_PCM_STREAM_PLAYBACK
, &numDevNames
);
585 for(idx
= 0;idx
< numDevNames
;idx
++)
587 if(allDevNameMap
[idx
].name
&&
588 strcmp(deviceName
, allDevNameMap
[idx
].name
) == 0)
591 driver
= allDevNameMap
[idx
].device
;
595 if(idx
== numDevNames
)
596 return ALC_INVALID_VALUE
;
599 data
= (alsa_data
*)calloc(1, sizeof(alsa_data
));
601 err
= snd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_PLAYBACK
, SND_PCM_NONBLOCK
);
604 err
= snd_pcm_nonblock(data
->pcmHandle
, 0);
605 if(err
< 0) snd_pcm_close(data
->pcmHandle
);
610 ERR("Could not open playback device '%s': %s\n", driver
, snd_strerror(err
));
611 return ALC_OUT_OF_MEMORY
;
614 device
->szDeviceName
= strdup(deviceName
);
615 device
->ExtraData
= data
;
619 static void alsa_close_playback(ALCdevice
*device
)
621 alsa_data
*data
= (alsa_data
*)device
->ExtraData
;
623 snd_pcm_close(data
->pcmHandle
);
625 device
->ExtraData
= NULL
;
628 static ALCboolean
alsa_reset_playback(ALCdevice
*device
)
630 alsa_data
*data
= (alsa_data
*)device
->ExtraData
;
631 snd_pcm_uframes_t periodSizeInFrames
;
632 unsigned int periodLen
, bufferLen
;
633 snd_pcm_sw_params_t
*sp
= NULL
;
634 snd_pcm_hw_params_t
*hp
= NULL
;
635 snd_pcm_access_t access
;
636 snd_pcm_format_t format
;
637 unsigned int periods
;
645 switch(device
->FmtType
)
648 format
= SND_PCM_FORMAT_S8
;
651 format
= SND_PCM_FORMAT_U8
;
654 format
= SND_PCM_FORMAT_S16
;
657 format
= SND_PCM_FORMAT_U16
;
660 format
= SND_PCM_FORMAT_S32
;
663 format
= SND_PCM_FORMAT_U32
;
666 format
= SND_PCM_FORMAT_FLOAT
;
670 allowmmap
= GetConfigValueBool("alsa", "mmap", 1);
671 periods
= device
->NumUpdates
;
672 periodLen
= (ALuint64
)device
->UpdateSize
* 1000000 / device
->Frequency
;
673 bufferLen
= periodLen
* periods
;
674 rate
= device
->Frequency
;
676 snd_pcm_hw_params_malloc(&hp
);
677 #define CHECK(x) if((funcerr=#x),(err=(x)) < 0) goto error
678 CHECK(snd_pcm_hw_params_any(data
->pcmHandle
, hp
));
679 /* set interleaved access */
680 if(!allowmmap
|| snd_pcm_hw_params_set_access(data
->pcmHandle
, hp
, SND_PCM_ACCESS_MMAP_INTERLEAVED
) < 0)
685 bufferLen
= periodLen
* periods
;
687 CHECK(snd_pcm_hw_params_set_access(data
->pcmHandle
, hp
, SND_PCM_ACCESS_RW_INTERLEAVED
));
689 /* test and set format (implicitly sets sample bits) */
690 if(snd_pcm_hw_params_test_format(data
->pcmHandle
, hp
, format
) < 0)
692 static const struct {
693 snd_pcm_format_t format
;
694 enum DevFmtType fmttype
;
696 { SND_PCM_FORMAT_FLOAT
, DevFmtFloat
},
697 { SND_PCM_FORMAT_S32
, DevFmtInt
},
698 { SND_PCM_FORMAT_U32
, DevFmtUInt
},
699 { SND_PCM_FORMAT_S16
, DevFmtShort
},
700 { SND_PCM_FORMAT_U16
, DevFmtUShort
},
701 { SND_PCM_FORMAT_S8
, DevFmtByte
},
702 { SND_PCM_FORMAT_U8
, DevFmtUByte
},
706 for(k
= 0;k
< COUNTOF(formatlist
);k
++)
708 format
= formatlist
[k
].format
;
709 if(snd_pcm_hw_params_test_format(data
->pcmHandle
, hp
, format
) >= 0)
711 device
->FmtType
= formatlist
[k
].fmttype
;
716 CHECK(snd_pcm_hw_params_set_format(data
->pcmHandle
, hp
, format
));
717 /* test and set channels (implicitly sets frame bits) */
718 if(snd_pcm_hw_params_test_channels(data
->pcmHandle
, hp
, ChannelsFromDevFmt(device
->FmtChans
)) < 0)
720 static const enum DevFmtChannels channellist
[] = {
729 for(k
= 0;k
< COUNTOF(channellist
);k
++)
731 if(snd_pcm_hw_params_test_channels(data
->pcmHandle
, hp
, ChannelsFromDevFmt(channellist
[k
])) >= 0)
733 device
->FmtChans
= channellist
[k
];
738 CHECK(snd_pcm_hw_params_set_channels(data
->pcmHandle
, hp
, ChannelsFromDevFmt(device
->FmtChans
)));
739 /* set rate (implicitly constrains period/buffer parameters) */
740 if(snd_pcm_hw_params_set_rate_resample(data
->pcmHandle
, hp
, 0) < 0)
741 ERR("Failed to disable ALSA resampler\n");
742 CHECK(snd_pcm_hw_params_set_rate_near(data
->pcmHandle
, hp
, &rate
, NULL
));
743 /* set buffer time (implicitly constrains period/buffer parameters) */
744 CHECK(snd_pcm_hw_params_set_buffer_time_near(data
->pcmHandle
, hp
, &bufferLen
, NULL
));
745 /* set period time (implicitly sets buffer size/bytes/time and period size/bytes) */
746 CHECK(snd_pcm_hw_params_set_period_time_near(data
->pcmHandle
, hp
, &periodLen
, NULL
));
747 /* install and prepare hardware configuration */
748 CHECK(snd_pcm_hw_params(data
->pcmHandle
, hp
));
749 /* retrieve configuration info */
750 CHECK(snd_pcm_hw_params_get_access(hp
, &access
));
751 CHECK(snd_pcm_hw_params_get_period_size(hp
, &periodSizeInFrames
, NULL
));
752 CHECK(snd_pcm_hw_params_get_periods(hp
, &periods
, NULL
));
754 snd_pcm_hw_params_free(hp
);
756 snd_pcm_sw_params_malloc(&sp
);
758 CHECK(snd_pcm_sw_params_current(data
->pcmHandle
, sp
));
759 CHECK(snd_pcm_sw_params_set_avail_min(data
->pcmHandle
, sp
, periodSizeInFrames
));
760 CHECK(snd_pcm_sw_params_set_stop_threshold(data
->pcmHandle
, sp
, periodSizeInFrames
*periods
));
761 CHECK(snd_pcm_sw_params(data
->pcmHandle
, sp
));
763 snd_pcm_sw_params_free(sp
);
766 device
->Frequency
= rate
;
767 SetDefaultChannelOrder(device
);
769 data
->size
= snd_pcm_frames_to_bytes(data
->pcmHandle
, periodSizeInFrames
);
770 if(access
== SND_PCM_ACCESS_RW_INTERLEAVED
)
772 /* Increase periods by one, since the temp buffer counts as an extra
775 data
->buffer
= malloc(data
->size
);
778 ERR("buffer malloc failed\n");
781 device
->UpdateSize
= periodSizeInFrames
;
782 device
->NumUpdates
= periods
;
783 data
->thread
= StartThread(ALSANoMMapProc
, device
);
787 err
= snd_pcm_prepare(data
->pcmHandle
);
790 ERR("snd_pcm_prepare(data->pcmHandle) failed: %s\n", snd_strerror(err
));
793 device
->UpdateSize
= periodSizeInFrames
;
794 device
->NumUpdates
= periods
;
795 data
->thread
= StartThread(ALSAProc
, device
);
797 if(data
->thread
== NULL
)
799 ERR("Could not create playback thread\n");
808 ERR("%s failed: %s\n", funcerr
, snd_strerror(err
));
809 if(hp
) snd_pcm_hw_params_free(hp
);
810 if(sp
) snd_pcm_sw_params_free(sp
);
814 static void alsa_stop_playback(ALCdevice
*device
)
816 alsa_data
*data
= (alsa_data
*)device
->ExtraData
;
821 StopThread(data
->thread
);
830 static ALCenum
alsa_open_capture(ALCdevice
*pDevice
, const ALCchar
*deviceName
)
832 const char *driver
= "default";
833 snd_pcm_hw_params_t
*hp
;
834 snd_pcm_uframes_t bufferSizeInFrames
;
835 snd_pcm_uframes_t periodSizeInFrames
;
836 snd_pcm_format_t format
;
842 ConfigValueStr("alsa", "capture", &driver
);
844 if(!allCaptureDevNameMap
)
845 allCaptureDevNameMap
= probe_devices(SND_PCM_STREAM_CAPTURE
, &numCaptureDevNames
);
847 if(!deviceName
&& numCaptureDevNames
> 0)
848 deviceName
= allCaptureDevNameMap
[0].name
;
853 for(idx
= 0;idx
< numCaptureDevNames
;idx
++)
855 if(allCaptureDevNameMap
[idx
].name
&&
856 strcmp(deviceName
, allCaptureDevNameMap
[idx
].name
) == 0)
859 driver
= allCaptureDevNameMap
[idx
].device
;
863 if(idx
== numCaptureDevNames
)
864 return ALC_INVALID_VALUE
;
867 data
= (alsa_data
*)calloc(1, sizeof(alsa_data
));
869 err
= snd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_CAPTURE
, SND_PCM_NONBLOCK
);
872 ERR("Could not open capture device '%s': %s\n", driver
, snd_strerror(err
));
874 return ALC_INVALID_VALUE
;
878 switch(pDevice
->FmtType
)
881 format
= SND_PCM_FORMAT_S8
;
884 format
= SND_PCM_FORMAT_U8
;
887 format
= SND_PCM_FORMAT_S16
;
890 format
= SND_PCM_FORMAT_U16
;
893 format
= SND_PCM_FORMAT_S32
;
896 format
= SND_PCM_FORMAT_U32
;
899 format
= SND_PCM_FORMAT_FLOAT
;
904 bufferSizeInFrames
= maxu(pDevice
->UpdateSize
*pDevice
->NumUpdates
,
905 100*pDevice
->Frequency
/1000);
906 periodSizeInFrames
= minu(bufferSizeInFrames
, 50*pDevice
->Frequency
/1000);
908 snd_pcm_hw_params_malloc(&hp
);
909 #define CHECK(x) if((funcerr=#x),(err=(x)) < 0) goto error
910 CHECK(snd_pcm_hw_params_any(data
->pcmHandle
, hp
));
911 /* set interleaved access */
912 CHECK(snd_pcm_hw_params_set_access(data
->pcmHandle
, hp
, SND_PCM_ACCESS_RW_INTERLEAVED
));
913 /* set format (implicitly sets sample bits) */
914 CHECK(snd_pcm_hw_params_set_format(data
->pcmHandle
, hp
, format
));
915 /* set channels (implicitly sets frame bits) */
916 CHECK(snd_pcm_hw_params_set_channels(data
->pcmHandle
, hp
, ChannelsFromDevFmt(pDevice
->FmtChans
)));
917 /* set rate (implicitly constrains period/buffer parameters) */
918 CHECK(snd_pcm_hw_params_set_rate(data
->pcmHandle
, hp
, pDevice
->Frequency
, 0));
919 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
920 CHECK(snd_pcm_hw_params_set_buffer_size_near(data
->pcmHandle
, hp
, &bufferSizeInFrames
));
921 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
922 CHECK(snd_pcm_hw_params_set_period_size_near(data
->pcmHandle
, hp
, &periodSizeInFrames
, NULL
));
923 /* install and prepare hardware configuration */
924 CHECK(snd_pcm_hw_params(data
->pcmHandle
, hp
));
925 /* retrieve configuration info */
926 CHECK(snd_pcm_hw_params_get_period_size(hp
, &bufferSizeInFrames
, NULL
));
928 snd_pcm_hw_params_free(hp
);
931 frameSize
= FrameSizeFromDevFmt(pDevice
->FmtChans
, pDevice
->FmtType
);
933 data
->ring
= CreateRingBuffer(frameSize
, pDevice
->UpdateSize
*pDevice
->NumUpdates
);
936 ERR("ring buffer create failed\n");
940 data
->size
= snd_pcm_frames_to_bytes(data
->pcmHandle
, bufferSizeInFrames
);
941 data
->buffer
= malloc(data
->size
);
944 ERR("buffer malloc failed\n");
948 pDevice
->szDeviceName
= strdup(deviceName
);
950 pDevice
->ExtraData
= data
;
954 ERR("%s failed: %s\n", funcerr
, snd_strerror(err
));
955 if(hp
) snd_pcm_hw_params_free(hp
);
959 DestroyRingBuffer(data
->ring
);
960 snd_pcm_close(data
->pcmHandle
);
963 pDevice
->ExtraData
= NULL
;
964 return ALC_INVALID_VALUE
;
967 static void alsa_close_capture(ALCdevice
*pDevice
)
969 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
971 snd_pcm_close(data
->pcmHandle
);
972 DestroyRingBuffer(data
->ring
);
976 pDevice
->ExtraData
= NULL
;
979 static void alsa_start_capture(ALCdevice
*Device
)
981 alsa_data
*data
= (alsa_data
*)Device
->ExtraData
;
984 err
= snd_pcm_start(data
->pcmHandle
);
987 ERR("start failed: %s\n", snd_strerror(err
));
988 aluHandleDisconnect(Device
);
991 data
->doCapture
= AL_TRUE
;
994 static void alsa_stop_capture(ALCdevice
*Device
)
996 alsa_data
*data
= (alsa_data
*)Device
->ExtraData
;
997 snd_pcm_drain(data
->pcmHandle
);
998 data
->doCapture
= AL_FALSE
;
1001 static ALCenum
alsa_capture_samples(ALCdevice
*Device
, ALCvoid
*Buffer
, ALCuint Samples
)
1003 alsa_data
*data
= (alsa_data
*)Device
->ExtraData
;
1004 ReadRingBuffer(data
->ring
, Buffer
, Samples
);
1005 return ALC_NO_ERROR
;
1008 static ALCuint
alsa_available_samples(ALCdevice
*Device
)
1010 alsa_data
*data
= (alsa_data
*)Device
->ExtraData
;
1011 snd_pcm_sframes_t avail
;
1013 avail
= (Device
->Connected
? snd_pcm_avail_update(data
->pcmHandle
) : 0);
1016 ERR("avail update failed: %s\n", snd_strerror(avail
));
1018 if((avail
=snd_pcm_recover(data
->pcmHandle
, avail
, 1)) >= 0)
1021 avail
= snd_pcm_start(data
->pcmHandle
);
1023 avail
= snd_pcm_avail_update(data
->pcmHandle
);
1027 ERR("restore error: %s\n", snd_strerror(avail
));
1028 aluHandleDisconnect(Device
);
1033 snd_pcm_sframes_t amt
;
1035 amt
= snd_pcm_bytes_to_frames(data
->pcmHandle
, data
->size
);
1036 if(avail
< amt
) amt
= avail
;
1038 amt
= snd_pcm_readi(data
->pcmHandle
, data
->buffer
, amt
);
1041 ERR("read error: %s\n", snd_strerror(amt
));
1045 if((amt
=snd_pcm_recover(data
->pcmHandle
, amt
, 1)) >= 0)
1048 amt
= snd_pcm_start(data
->pcmHandle
);
1050 amt
= snd_pcm_avail_update(data
->pcmHandle
);
1054 ERR("restore error: %s\n", snd_strerror(amt
));
1055 aluHandleDisconnect(Device
);
1062 WriteRingBuffer(data
->ring
, data
->buffer
, amt
);
1066 return RingBufferSize(data
->ring
);
1070 static const BackendFuncs alsa_funcs
= {
1072 alsa_close_playback
,
1073 alsa_reset_playback
,
1079 alsa_capture_samples
,
1080 alsa_available_samples
1083 ALCboolean
alc_alsa_init(BackendFuncs
*func_list
)
1087 *func_list
= alsa_funcs
;
1091 void alc_alsa_deinit(void)
1095 for(i
= 0;i
< numDevNames
;++i
)
1096 free(allDevNameMap
[i
].device
);
1097 free(allDevNameMap
);
1098 allDevNameMap
= NULL
;
1101 for(i
= 0;i
< numCaptureDevNames
;++i
)
1102 free(allCaptureDevNameMap
[i
].device
);
1103 free(allCaptureDevNameMap
);
1104 allCaptureDevNameMap
= NULL
;
1105 numCaptureDevNames
= 0;
1109 CloseLib(alsa_handle
);
1114 void alc_alsa_probe(enum DevProbe type
)
1120 case ALL_DEVICE_PROBE
:
1121 for(i
= 0;i
< numDevNames
;++i
)
1122 free(allDevNameMap
[i
].device
);
1124 free(allDevNameMap
);
1125 allDevNameMap
= probe_devices(SND_PCM_STREAM_PLAYBACK
, &numDevNames
);
1127 for(i
= 0;i
< numDevNames
;++i
)
1128 AppendAllDeviceList(allDevNameMap
[i
].name
);
1131 case CAPTURE_DEVICE_PROBE
:
1132 for(i
= 0;i
< numCaptureDevNames
;++i
)
1133 free(allCaptureDevNameMap
[i
].device
);
1135 free(allCaptureDevNameMap
);
1136 allCaptureDevNameMap
= probe_devices(SND_PCM_STREAM_CAPTURE
, &numCaptureDevNames
);
1138 for(i
= 0;i
< numCaptureDevNames
;++i
)
1139 AppendCaptureDeviceList(allCaptureDevNameMap
[i
].name
);