?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Improve a couple error messages with the full ALSA device control name
[openal-soft/openal-hmr.git] / Alc / backends / alsa.c
blob3ad7f20df08ce8fa58a1e617f6ac39e76aeb6389
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.
8 *
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.
13 *
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
19 */
20
21 #include "config.h"
22
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <memory.h>
26
27 #include "alMain.h"
28
29 #include <alsa/asoundlib.h>
30
31
32 static const ALCchar alsaDevice[] = "ALSA Default";
33
34
35 static void *alsa_handle;
36 #ifdef HAVE_DYNLOAD
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);
64 MAKE_FUNC(snd_pcm_sw_params_malloc);
65 MAKE_FUNC(snd_pcm_sw_params_current);
66 MAKE_FUNC(snd_pcm_sw_params_set_avail_min);
67 MAKE_FUNC(snd_pcm_sw_params_set_stop_threshold);
68 MAKE_FUNC(snd_pcm_sw_params);
69 MAKE_FUNC(snd_pcm_sw_params_free);
70 MAKE_FUNC(snd_pcm_prepare);
71 MAKE_FUNC(snd_pcm_start);
72 MAKE_FUNC(snd_pcm_resume);
73 MAKE_FUNC(snd_pcm_reset);
74 MAKE_FUNC(snd_pcm_wait);
75 MAKE_FUNC(snd_pcm_state);
76 MAKE_FUNC(snd_pcm_avail_update);
77 MAKE_FUNC(snd_pcm_areas_silence);
78 MAKE_FUNC(snd_pcm_mmap_begin);
79 MAKE_FUNC(snd_pcm_mmap_commit);
80 MAKE_FUNC(snd_pcm_readi);
81 MAKE_FUNC(snd_pcm_writei);
82 MAKE_FUNC(snd_pcm_drain);
83 MAKE_FUNC(snd_pcm_recover);
84 MAKE_FUNC(snd_pcm_info_malloc);
85 MAKE_FUNC(snd_pcm_info_free);
86 MAKE_FUNC(snd_pcm_info_set_device);
87 MAKE_FUNC(snd_pcm_info_set_subdevice);
88 MAKE_FUNC(snd_pcm_info_set_stream);
89 MAKE_FUNC(snd_pcm_info_get_name);
90 MAKE_FUNC(snd_ctl_pcm_next_device);
91 MAKE_FUNC(snd_ctl_pcm_info);
92 MAKE_FUNC(snd_ctl_open);
93 MAKE_FUNC(snd_ctl_close);
94 MAKE_FUNC(snd_ctl_card_info_malloc);
95 MAKE_FUNC(snd_ctl_card_info_free);
96 MAKE_FUNC(snd_ctl_card_info);
97 MAKE_FUNC(snd_ctl_card_info_get_name);
98 MAKE_FUNC(snd_ctl_card_info_get_id);
99 MAKE_FUNC(snd_card_next);
100 #undef MAKE_FUNC
101
102 #define snd_strerror psnd_strerror
103 #define snd_pcm_open psnd_pcm_open
104 #define snd_pcm_close psnd_pcm_close
105 #define snd_pcm_nonblock psnd_pcm_nonblock
106 #define snd_pcm_frames_to_bytes psnd_pcm_frames_to_bytes
107 #define snd_pcm_bytes_to_frames psnd_pcm_bytes_to_frames
108 #define snd_pcm_hw_params_malloc psnd_pcm_hw_params_malloc
109 #define snd_pcm_hw_params_free psnd_pcm_hw_params_free
110 #define snd_pcm_hw_params_any psnd_pcm_hw_params_any
111 #define snd_pcm_hw_params_set_access psnd_pcm_hw_params_set_access
112 #define snd_pcm_hw_params_set_format psnd_pcm_hw_params_set_format
113 #define snd_pcm_hw_params_set_channels psnd_pcm_hw_params_set_channels
114 #define snd_pcm_hw_params_set_periods_near psnd_pcm_hw_params_set_periods_near
115 #define snd_pcm_hw_params_set_rate_near psnd_pcm_hw_params_set_rate_near
116 #define snd_pcm_hw_params_set_rate psnd_pcm_hw_params_set_rate
117 #define snd_pcm_hw_params_set_rate_resample psnd_pcm_hw_params_set_rate_resample
118 #define snd_pcm_hw_params_set_buffer_time_near psnd_pcm_hw_params_set_buffer_time_near
119 #define snd_pcm_hw_params_set_period_time_near psnd_pcm_hw_params_set_period_time_near
120 #define snd_pcm_hw_params_set_buffer_size_near psnd_pcm_hw_params_set_buffer_size_near
121 #define snd_pcm_hw_params_set_period_size_near psnd_pcm_hw_params_set_period_size_near
122 #define snd_pcm_hw_params_set_buffer_size_min psnd_pcm_hw_params_set_buffer_size_min
123 #define snd_pcm_hw_params_get_buffer_size psnd_pcm_hw_params_get_buffer_size
124 #define snd_pcm_hw_params_get_period_size psnd_pcm_hw_params_get_period_size
125 #define snd_pcm_hw_params_get_access psnd_pcm_hw_params_get_access
126 #define snd_pcm_hw_params_get_periods psnd_pcm_hw_params_get_periods
127 #define snd_pcm_hw_params psnd_pcm_hw_params
128 #define snd_pcm_sw_params_malloc psnd_pcm_sw_params_malloc
129 #define snd_pcm_sw_params_current psnd_pcm_sw_params_current
130 #define snd_pcm_sw_params_set_avail_min psnd_pcm_sw_params_set_avail_min
131 #define snd_pcm_sw_params_set_stop_threshold psnd_pcm_sw_params_set_stop_threshold
132 #define snd_pcm_sw_params psnd_pcm_sw_params
133 #define snd_pcm_sw_params_free psnd_pcm_sw_params_free
134 #define snd_pcm_prepare psnd_pcm_prepare
135 #define snd_pcm_start psnd_pcm_start
136 #define snd_pcm_resume psnd_pcm_resume
137 #define snd_pcm_reset psnd_pcm_reset
138 #define snd_pcm_wait psnd_pcm_wait
139 #define snd_pcm_state psnd_pcm_state
140 #define snd_pcm_avail_update psnd_pcm_avail_update
141 #define snd_pcm_areas_silence psnd_pcm_areas_silence
142 #define snd_pcm_mmap_begin psnd_pcm_mmap_begin
143 #define snd_pcm_mmap_commit psnd_pcm_mmap_commit
144 #define snd_pcm_readi psnd_pcm_readi
145 #define snd_pcm_writei psnd_pcm_writei
146 #define snd_pcm_drain psnd_pcm_drain
147 #define snd_pcm_recover psnd_pcm_recover
148 #define snd_pcm_info_malloc psnd_pcm_info_malloc
149 #define snd_pcm_info_free psnd_pcm_info_free
150 #define snd_pcm_info_set_device psnd_pcm_info_set_device
151 #define snd_pcm_info_set_subdevice psnd_pcm_info_set_subdevice
152 #define snd_pcm_info_set_stream psnd_pcm_info_set_stream
153 #define snd_pcm_info_get_name psnd_pcm_info_get_name
154 #define snd_ctl_pcm_next_device psnd_ctl_pcm_next_device
155 #define snd_ctl_pcm_info psnd_ctl_pcm_info
156 #define snd_ctl_open psnd_ctl_open
157 #define snd_ctl_close psnd_ctl_close
158 #define snd_ctl_card_info_malloc psnd_ctl_card_info_malloc
159 #define snd_ctl_card_info_free psnd_ctl_card_info_free
160 #define snd_ctl_card_info psnd_ctl_card_info
161 #define snd_ctl_card_info_get_name psnd_ctl_card_info_get_name
162 #define snd_ctl_card_info_get_id psnd_ctl_card_info_get_id
163 #define snd_card_next psnd_card_next
164 #endif
165
166
167 static ALCboolean alsa_load(void)
168 {
169 if(!alsa_handle)
170 {
171 #ifdef HAVE_DYNLOAD
172 alsa_handle = LoadLib("libasound.so.2");
173 if(!alsa_handle)
174 return ALC_FALSE;
175
176 #define LOAD_FUNC(f) do { \
177 p##f = GetSymbol(alsa_handle, #f); \
178 if(p##f == NULL) { \
179 CloseLib(alsa_handle); \
180 alsa_handle = NULL; \
181 return ALC_FALSE; \
182 } \
183 } while(0)
184 LOAD_FUNC(snd_strerror);
185 LOAD_FUNC(snd_pcm_open);
186 LOAD_FUNC(snd_pcm_close);
187 LOAD_FUNC(snd_pcm_nonblock);
188 LOAD_FUNC(snd_pcm_frames_to_bytes);
189 LOAD_FUNC(snd_pcm_bytes_to_frames);
190 LOAD_FUNC(snd_pcm_hw_params_malloc);
191 LOAD_FUNC(snd_pcm_hw_params_free);
192 LOAD_FUNC(snd_pcm_hw_params_any);
193 LOAD_FUNC(snd_pcm_hw_params_set_access);
194 LOAD_FUNC(snd_pcm_hw_params_set_format);
195 LOAD_FUNC(snd_pcm_hw_params_set_channels);
196 LOAD_FUNC(snd_pcm_hw_params_set_periods_near);
197 LOAD_FUNC(snd_pcm_hw_params_set_rate_near);
198 LOAD_FUNC(snd_pcm_hw_params_set_rate);
199 LOAD_FUNC(snd_pcm_hw_params_set_rate_resample);
200 LOAD_FUNC(snd_pcm_hw_params_set_buffer_time_near);
201 LOAD_FUNC(snd_pcm_hw_params_set_period_time_near);
202 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near);
203 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min);
204 LOAD_FUNC(snd_pcm_hw_params_set_period_size_near);
205 LOAD_FUNC(snd_pcm_hw_params_get_buffer_size);
206 LOAD_FUNC(snd_pcm_hw_params_get_period_size);
207 LOAD_FUNC(snd_pcm_hw_params_get_access);
208 LOAD_FUNC(snd_pcm_hw_params_get_periods);
209 LOAD_FUNC(snd_pcm_hw_params);
210 LOAD_FUNC(snd_pcm_sw_params_malloc);
211 LOAD_FUNC(snd_pcm_sw_params_current);
212 LOAD_FUNC(snd_pcm_sw_params_set_avail_min);
213 LOAD_FUNC(snd_pcm_sw_params_set_stop_threshold);
214 LOAD_FUNC(snd_pcm_sw_params);
215 LOAD_FUNC(snd_pcm_sw_params_free);
216 LOAD_FUNC(snd_pcm_prepare);
217 LOAD_FUNC(snd_pcm_start);
218 LOAD_FUNC(snd_pcm_resume);
219 LOAD_FUNC(snd_pcm_reset);
220 LOAD_FUNC(snd_pcm_wait);
221 LOAD_FUNC(snd_pcm_state);
222 LOAD_FUNC(snd_pcm_avail_update);
223 LOAD_FUNC(snd_pcm_areas_silence);
224 LOAD_FUNC(snd_pcm_mmap_begin);
225 LOAD_FUNC(snd_pcm_mmap_commit);
226 LOAD_FUNC(snd_pcm_readi);
227 LOAD_FUNC(snd_pcm_writei);
228 LOAD_FUNC(snd_pcm_drain);
229 LOAD_FUNC(snd_pcm_recover);
230 LOAD_FUNC(snd_pcm_info_malloc);
231 LOAD_FUNC(snd_pcm_info_free);
232 LOAD_FUNC(snd_pcm_info_set_device);
233 LOAD_FUNC(snd_pcm_info_set_subdevice);
234 LOAD_FUNC(snd_pcm_info_set_stream);
235 LOAD_FUNC(snd_pcm_info_get_name);
236 LOAD_FUNC(snd_ctl_pcm_next_device);
237 LOAD_FUNC(snd_ctl_pcm_info);
238 LOAD_FUNC(snd_ctl_open);
239 LOAD_FUNC(snd_ctl_close);
240 LOAD_FUNC(snd_ctl_card_info_malloc);
241 LOAD_FUNC(snd_ctl_card_info_free);
242 LOAD_FUNC(snd_ctl_card_info);
243 LOAD_FUNC(snd_ctl_card_info_get_name);
244 LOAD_FUNC(snd_ctl_card_info_get_id);
245 LOAD_FUNC(snd_card_next);
246 #undef LOAD_FUNC
247 #else
248 alsa_handle = (void*)0xDEADBEEF;
249 #endif
250 }
251 return ALC_TRUE;
252 }
253
254
255 typedef struct {
256 snd_pcm_t *pcmHandle;
257
258 ALvoid *buffer;
259 ALsizei size;
260
261 ALboolean doCapture;
262 RingBuffer *ring;
263
264 volatile int killNow;
265 ALvoid *thread;
266 } alsa_data;
267
268 typedef struct {
269 ALCchar *name;
270 char *card;
271 int dev;
272 } DevMap;
273
274 static DevMap *allDevNameMap;
275 static ALuint numDevNames;
276 static DevMap *allCaptureDevNameMap;
277 static ALuint numCaptureDevNames;
278
279 static const char *device_prefix;
280 static const char *capture_prefix;
281
282
283 static DevMap *probe_devices(snd_pcm_stream_t stream, ALuint *count)
284 {
285 snd_ctl_t *handle;
286 int card, err, dev, idx;
287 snd_ctl_card_info_t *info;
288 snd_pcm_info_t *pcminfo;
289 DevMap *DevList;
290 char name[1024];
291
292 snd_ctl_card_info_malloc(&info);
293 snd_pcm_info_malloc(&pcminfo);
294
295 card = -1;
296 if((err=snd_card_next(&card)) < 0)
297 ERR("Failed to find a card: %s\n", snd_strerror(err));
298
299 DevList = malloc(sizeof(DevMap) * 1);
300 DevList[0].name = strdup("ALSA Default");
301 DevList[0].card = NULL;
302 DevList[0].dev = 0;
303 idx = 1;
304 while(card >= 0)
305 {
306 sprintf(name, "hw:%d", card);
307 if((err = snd_ctl_open(&handle, name, 0)) < 0)
308 {
309 ERR("control open (hw:%d): %s\n", card, snd_strerror(err));
310 goto next_card;
311 }
312 if((err = snd_ctl_card_info(handle, info)) < 0)
313 {
314 ERR("control hardware info (hw:%d): %s\n", card, snd_strerror(err));
315 snd_ctl_close(handle);
316 goto next_card;
317 }
318
319 dev = -1;
320 while(1)
321 {
322 const char *cname, *dname, *cid;
323 void *temp;
324
325 if(snd_ctl_pcm_next_device(handle, &dev) < 0)
326 ERR("snd_ctl_pcm_next_device failed\n");
327 if(dev < 0)
328 break;
329
330 snd_pcm_info_set_device(pcminfo, dev);
331 snd_pcm_info_set_subdevice(pcminfo, 0);
332 snd_pcm_info_set_stream(pcminfo, stream);
333 if((err = snd_ctl_pcm_info(handle, pcminfo)) < 0) {
334 if(err != -ENOENT)
335 ERR("control digital audio info (hw:%d): %s\n", card, snd_strerror(err));
336 continue;
337 }
338
339 temp = realloc(DevList, sizeof(DevMap) * (idx+1));
340 if(temp)
341 {
342 DevList = temp;
343 cname = snd_ctl_card_info_get_name(info);
344 dname = snd_pcm_info_get_name(pcminfo);
345 cid = snd_ctl_card_info_get_id(info);
346 snprintf(name, sizeof(name), "%s, %s (CARD=%s,DEV=%d)",
347 cname, dname, cid, dev);
348 DevList[idx].name = strdup(name);
349 DevList[idx].card = strdup(cid);
350 DevList[idx].dev = dev;
351 idx++;
352 }
353 }
354 snd_ctl_close(handle);
355 next_card:
356 if(snd_card_next(&card) < 0) {
357 ERR("snd_card_next failed\n");
358 break;
359 }
360 }
361
362 snd_pcm_info_free(pcminfo);
363 snd_ctl_card_info_free(info);
364
365 *count = idx;
366 return DevList;
367 }
368
369
370 static int xrun_recovery(snd_pcm_t *handle, int err)
371 {
372 err = snd_pcm_recover(handle, err, 1);
373 if(err < 0)
374 ERR("recover failed: %s\n", snd_strerror(err));
375 return err;
376 }
377
378 static int verify_state(snd_pcm_t *handle)
379 {
380 snd_pcm_state_t state = snd_pcm_state(handle);
381 if(state == SND_PCM_STATE_DISCONNECTED)
382 return -ENODEV;
383 if(state == SND_PCM_STATE_XRUN)
384 {
385 int err = xrun_recovery(handle, -EPIPE);
386 if(err < 0) return err;
387 }
388 else if(state == SND_PCM_STATE_SUSPENDED)
389 {
390 int err = xrun_recovery(handle, -ESTRPIPE);
391 if(err < 0) return err;
392 }
393
394 return state;
395 }
396
397
398 static ALuint ALSAProc(ALvoid *ptr)
399 {
400 ALCdevice *pDevice = (ALCdevice*)ptr;
401 alsa_data *data = (alsa_data*)pDevice->ExtraData;
402 const snd_pcm_channel_area_t *areas = NULL;
403 snd_pcm_uframes_t update_size, num_updates;
404 snd_pcm_sframes_t avail, commitres;
405 snd_pcm_uframes_t offset, frames;
406 char *WritePtr;
407 int err;
408
409 SetRTPriority();
410
411 update_size = pDevice->UpdateSize;
412 num_updates = pDevice->NumUpdates;
413 while(!data->killNow)
414 {
415 int state = verify_state(data->pcmHandle);
416 if(state < 0)
417 {
418 ERR("Invalid state detected: %s\n", snd_strerror(state));
419 aluHandleDisconnect(pDevice);
420 break;
421 }
422
423 avail = snd_pcm_avail_update(data->pcmHandle);
424 if(avail < 0)
425 {
426 ERR("available update failed: %s\n", snd_strerror(avail));
427 continue;
428 }
429
430 if((snd_pcm_uframes_t)avail > update_size*(num_updates+1))
431 {
432 WARN("available samples exceeds the buffer size\n");
433 snd_pcm_reset(data->pcmHandle);
434 continue;
435 }
436
437 // make sure there's frames to process
438 if((snd_pcm_uframes_t)avail < update_size)
439 {
440 if(state != SND_PCM_STATE_RUNNING)
441 {
442 err = snd_pcm_start(data->pcmHandle);
443 if(err < 0)
444 {
445 ERR("start failed: %s\n", snd_strerror(err));
446 continue;
447 }
448 }
449 if(snd_pcm_wait(data->pcmHandle, 1000) == 0)
450 ERR("Wait timeout... buffer size too low?\n");
451 continue;
452 }
453 avail -= avail%update_size;
454
455 // it is possible that contiguous areas are smaller, thus we use a loop
456 while(avail > 0)
457 {
458 frames = avail;
459
460 err = snd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &frames);
461 if(err < 0)
462 {
463 ERR("mmap begin error: %s\n", snd_strerror(err));
464 break;
465 }
466
467 WritePtr = (char*)areas->addr + (offset * areas->step / 8);
468 aluMixData(pDevice, WritePtr, frames);
469
470 commitres = snd_pcm_mmap_commit(data->pcmHandle, offset, frames);
471 if(commitres < 0 || (commitres-frames) != 0)
472 {
473 ERR("mmap commit error: %s\n",
474 snd_strerror(commitres >= 0 ? -EPIPE : commitres));
475 break;
476 }
477
478 avail -= frames;
479 }
480 }
481
482 return 0;
483 }
484
485 static ALuint ALSANoMMapProc(ALvoid *ptr)
486 {
487 ALCdevice *pDevice = (ALCdevice*)ptr;
488 alsa_data *data = (alsa_data*)pDevice->ExtraData;
489 snd_pcm_sframes_t avail;
490 char *WritePtr;
491
492 SetRTPriority();
493
494 while(!data->killNow)
495 {
496 int state = verify_state(data->pcmHandle);
497 if(state < 0)
498 {
499 ERR("Invalid state detected: %s\n", snd_strerror(state));
500 aluHandleDisconnect(pDevice);
501 break;
502 }
503
504 WritePtr = data->buffer;
505 avail = data->size / snd_pcm_frames_to_bytes(data->pcmHandle, 1);
506 aluMixData(pDevice, WritePtr, avail);
507
508 while(avail > 0)
509 {
510 int ret = snd_pcm_writei(data->pcmHandle, WritePtr, avail);
511 switch (ret)
512 {
513 case -EAGAIN:
514 continue;
515 case -ESTRPIPE:
516 case -EPIPE:
517 case -EINTR:
518 ret = snd_pcm_recover(data->pcmHandle, ret, 1);
519 if(ret < 0)
520 avail = 0;
521 break;
522 default:
523 if (ret >= 0)
524 {
525 WritePtr += snd_pcm_frames_to_bytes(data->pcmHandle, ret);
526 avail -= ret;
527 }
528 break;
529 }
530 if (ret < 0)
531 {
532 ret = snd_pcm_prepare(data->pcmHandle);
533 if(ret < 0)
534 break;
535 }
536 }
537 }
538
539 return 0;
540 }
541
542 static ALCenum alsa_open_playback(ALCdevice *device, const ALCchar *deviceName)
543 {
544 const char *driver = "default";
545 alsa_data *data;
546 char str[128];
547 int i;
548
549 ConfigValueStr("alsa", "device", &driver);
550
551 if(!deviceName)
552 deviceName = alsaDevice;
553 else if(strcmp(deviceName, alsaDevice) != 0)
554 {
555 size_t idx;
556
557 if(!allDevNameMap)
558 allDevNameMap = probe_devices(SND_PCM_STREAM_PLAYBACK, &numDevNames);
559
560 for(idx = 0;idx < numDevNames;idx++)
561 {
562 if(allDevNameMap[idx].name &&
563 strcmp(deviceName, allDevNameMap[idx].name) == 0)
564 {
565 if(idx > 0)
566 {
567 snprintf(str, sizeof(str), "%sCARD=%s,DEV=%d", device_prefix,
568 allDevNameMap[idx].card, allDevNameMap[idx].dev);
569 driver = str;
570 }
571 break;
572 }
573 }
574 if(idx == numDevNames)
575 return ALC_INVALID_VALUE;
576 }
577
578 data = (alsa_data*)calloc(1, sizeof(alsa_data));
579
580 i = snd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
581 if(i >= 0)
582 {
583 i = snd_pcm_nonblock(data->pcmHandle, 0);
584 if(i < 0)
585 snd_pcm_close(data->pcmHandle);
586 }
587 if(i < 0)
588 {
589 free(data);
590 ERR("Could not open playback device '%s': %s\n", driver, snd_strerror(i));
591 return ALC_OUT_OF_MEMORY;
592 }
593
594 device->szDeviceName = strdup(deviceName);
595 device->ExtraData = data;
596 return ALC_NO_ERROR;
597 }
598
599 static void alsa_close_playback(ALCdevice *device)
600 {
601 alsa_data *data = (alsa_data*)device->ExtraData;
602
603 snd_pcm_close(data->pcmHandle);
604 free(data);
605 device->ExtraData = NULL;
606 }
607
608 static ALCboolean alsa_reset_playback(ALCdevice *device)
609 {
610 alsa_data *data = (alsa_data*)device->ExtraData;
611 snd_pcm_uframes_t periodSizeInFrames;
612 unsigned int periodLen, bufferLen;
613 snd_pcm_sw_params_t *sp = NULL;
614 snd_pcm_hw_params_t *p = NULL;
615 snd_pcm_access_t access;
616 snd_pcm_format_t format;
617 unsigned int periods;
618 unsigned int rate;
619 int allowmmap;
620 char *err;
621 int i;
622
623
624 format = -1;
625 switch(device->FmtType)
626 {
627 case DevFmtByte:
628 format = SND_PCM_FORMAT_S8;
629 break;
630 case DevFmtUByte:
631 format = SND_PCM_FORMAT_U8;
632 break;
633 case DevFmtShort:
634 format = SND_PCM_FORMAT_S16;
635 break;
636 case DevFmtUShort:
637 format = SND_PCM_FORMAT_U16;
638 break;
639 case DevFmtFloat:
640 format = SND_PCM_FORMAT_FLOAT;
641 break;
642 }
643
644 allowmmap = GetConfigValueBool("alsa", "mmap", 1);
645 periods = device->NumUpdates;
646 periodLen = (ALuint64)device->UpdateSize * 1000000 / device->Frequency;
647 bufferLen = periodLen * periods;
648 rate = device->Frequency;
649
650 err = NULL;
651 snd_pcm_hw_params_malloc(&p);
652
653 if((i=snd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
654 err = "any";
655 /* set interleaved access */
656 if(i >= 0 && (!allowmmap || (i=snd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0))
657 {
658 if(periods > 2)
659 {
660 periods--;
661 bufferLen = periodLen * periods;
662 }
663 if((i=snd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
664 err = "set access";
665 }
666 /* set format (implicitly sets sample bits) */
667 if(i >= 0 && (i=snd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
668 {
669 device->FmtType = DevFmtFloat;
670 if(format == SND_PCM_FORMAT_FLOAT ||
671 (i=snd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_FLOAT)) < 0)
672 {
673 device->FmtType = DevFmtShort;
674 if(format == SND_PCM_FORMAT_S16 ||
675 (i=snd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_S16)) < 0)
676 {
677 device->FmtType = DevFmtUByte;
678 if(format == SND_PCM_FORMAT_U8 ||
679 (i=snd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_U8)) < 0)
680 err = "set format";
681 }
682 }
683 }
684 /* set channels (implicitly sets frame bits) */
685 if(i >= 0 && (i=snd_pcm_hw_params_set_channels(data->pcmHandle, p, ChannelsFromDevFmt(device->FmtChans))) < 0)
686 {
687 if((i=snd_pcm_hw_params_set_channels(data->pcmHandle, p, 2)) < 0)
688 {
689 if((i=snd_pcm_hw_params_set_channels(data->pcmHandle, p, 1)) < 0)
690 err = "set channels";
691 else
692 device->FmtChans = DevFmtMono;
693 }
694 else
695 device->FmtChans = DevFmtStereo;
696 }
697 if(i >= 0 && (i=snd_pcm_hw_params_set_rate_resample(data->pcmHandle, p, 0)) < 0)
698 {
699 ERR("Failed to disable ALSA resampler\n");
700 i = 0;
701 }
702 /* set rate (implicitly constrains period/buffer parameters) */
703 if(i >= 0 && (i=snd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &rate, NULL)) < 0)
704 err = "set rate near";
705 /* set buffer time (implicitly constrains period/buffer parameters) */
706 if(i >= 0 && (i=snd_pcm_hw_params_set_buffer_time_near(data->pcmHandle, p, &bufferLen, NULL)) < 0)
707 err = "set buffer time near";
708 /* set period time in frame units (implicitly sets buffer size/bytes/time and period size/bytes) */
709 if(i >= 0 && (i=snd_pcm_hw_params_set_period_time_near(data->pcmHandle, p, &periodLen, NULL)) < 0)
710 err = "set period time near";
711 /* install and prepare hardware configuration */
712 if(i >= 0 && (i=snd_pcm_hw_params(data->pcmHandle, p)) < 0)
713 err = "set params";
714 if(i >= 0 && (i=snd_pcm_hw_params_get_access(p, &access)) < 0)
715 err = "get access";
716 if(i >= 0 && (i=snd_pcm_hw_params_get_period_size(p, &periodSizeInFrames, NULL)) < 0)
717 err = "get period size";
718 if(i >= 0 && (i=snd_pcm_hw_params_get_periods(p, &periods, NULL)) < 0)
719 err = "get periods";
720 if(i < 0)
721 {
722 ERR("%s failed: %s\n", err, snd_strerror(i));
723 snd_pcm_hw_params_free(p);
724 return ALC_FALSE;
725 }
726
727 snd_pcm_hw_params_free(p);
728
729 err = NULL;
730 snd_pcm_sw_params_malloc(&sp);
731
732 if((i=snd_pcm_sw_params_current(data->pcmHandle, sp)) != 0)
733 err = "sw current";
734 if(i == 0 && (i=snd_pcm_sw_params_set_avail_min(data->pcmHandle, sp, periodSizeInFrames)) != 0)
735 err = "sw set avail min";
736 if(i == 0 && (i=snd_pcm_sw_params_set_stop_threshold(data->pcmHandle, sp, periodSizeInFrames*periods)) != 0)
737 err = "sw set stop threshold";
738 if(i == 0 && (i=snd_pcm_sw_params(data->pcmHandle, sp)) != 0)
739 err = "sw set params";
740 if(i != 0)
741 {
742 ERR("%s failed: %s\n", err, snd_strerror(i));
743 snd_pcm_sw_params_free(sp);
744 return ALC_FALSE;
745 }
746
747 snd_pcm_sw_params_free(sp);
748
749 device->Frequency = rate;
750 SetDefaultChannelOrder(device);
751
752 data->size = snd_pcm_frames_to_bytes(data->pcmHandle, periodSizeInFrames);
753 if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
754 {
755 /* Increase periods by one, since the temp buffer counts as an extra
756 * period */
757 periods++;
758 data->buffer = malloc(data->size);
759 if(!data->buffer)
760 {
761 ERR("buffer malloc failed\n");
762 return ALC_FALSE;
763 }
764 device->UpdateSize = periodSizeInFrames;
765 device->NumUpdates = periods;
766 data->thread = StartThread(ALSANoMMapProc, device);
767 }
768 else
769 {
770 i = snd_pcm_prepare(data->pcmHandle);
771 if(i < 0)
772 {
773 ERR("prepare error: %s\n", snd_strerror(i));
774 return ALC_FALSE;
775 }
776 device->UpdateSize = periodSizeInFrames;
777 device->NumUpdates = periods;
778 data->thread = StartThread(ALSAProc, device);
779 }
780 if(data->thread == NULL)
781 {
782 ERR("Could not create playback thread\n");
783 free(data->buffer);
784 data->buffer = NULL;
785 return ALC_FALSE;
786 }
787
788 return ALC_TRUE;
789 }
790
791 static void alsa_stop_playback(ALCdevice *device)
792 {
793 alsa_data *data = (alsa_data*)device->ExtraData;
794
795 if(data->thread)
796 {
797 data->killNow = 1;
798 StopThread(data->thread);
799 data->thread = NULL;
800 }
801 data->killNow = 0;
802 free(data->buffer);
803 data->buffer = NULL;
804 }
805
806
807 static ALCenum alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName)
808 {
809 const char *driver = "default";
810 snd_pcm_hw_params_t *p;
811 snd_pcm_uframes_t bufferSizeInFrames;
812 snd_pcm_uframes_t periodSizeInFrames;
813 snd_pcm_format_t format;
814 ALuint frameSize;
815 alsa_data *data;
816 char str[128];
817 char *err;
818 int i;
819
820 ConfigValueStr("alsa", "capture", &driver);
821
822 if(!allCaptureDevNameMap)
823 allCaptureDevNameMap = probe_devices(SND_PCM_STREAM_CAPTURE, &numCaptureDevNames);
824
825 if(!deviceName)
826 deviceName = allCaptureDevNameMap[0].name;
827 else
828 {
829 size_t idx;
830
831 for(idx = 0;idx < numCaptureDevNames;idx++)
832 {
833 if(allCaptureDevNameMap[idx].name &&
834 strcmp(deviceName, allCaptureDevNameMap[idx].name) == 0)
835 {
836 if(idx > 0)
837 {
838 snprintf(str, sizeof(str), "%sCARD=%s,DEV=%d", capture_prefix,
839 allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev);
840 driver = str;
841 }
842 break;
843 }
844 }
845 if(idx == numCaptureDevNames)
846 return ALC_INVALID_VALUE;
847 }
848
849 data = (alsa_data*)calloc(1, sizeof(alsa_data));
850
851 i = snd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
852 if(i < 0)
853 {
854 ERR("Could not open capture device '%s': %s\n", driver, snd_strerror(i));
855 free(data);
856 return ALC_INVALID_VALUE;
857 }
858
859 format = -1;
860 switch(pDevice->FmtType)
861 {
862 case DevFmtByte:
863 format = SND_PCM_FORMAT_S8;
864 break;
865 case DevFmtUByte:
866 format = SND_PCM_FORMAT_U8;
867 break;
868 case DevFmtShort:
869 format = SND_PCM_FORMAT_S16;
870 break;
871 case DevFmtUShort:
872 format = SND_PCM_FORMAT_U16;
873 break;
874 case DevFmtFloat:
875 format = SND_PCM_FORMAT_FLOAT;
876 break;
877 }
878
879 err = NULL;
880 bufferSizeInFrames = maxu(pDevice->UpdateSize*pDevice->NumUpdates,
881 100*pDevice->Frequency/1000);
882 periodSizeInFrames = minu(bufferSizeInFrames, 50*pDevice->Frequency/1000);
883 snd_pcm_hw_params_malloc(&p);
884
885 if((i=snd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
886 err = "any";
887 /* set interleaved access */
888 if(i >= 0 && (i=snd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
889 err = "set access";
890 /* set format (implicitly sets sample bits) */
891 if(i >= 0 && (i=snd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
892 err = "set format";
893 /* set channels (implicitly sets frame bits) */
894 if(i >= 0 && (i=snd_pcm_hw_params_set_channels(data->pcmHandle, p, ChannelsFromDevFmt(pDevice->FmtChans))) < 0)
895 err = "set channels";
896 /* set rate (implicitly constrains period/buffer parameters) */
897 if(i >= 0 && (i=snd_pcm_hw_params_set_rate(data->pcmHandle, p, pDevice->Frequency, 0)) < 0)
898 err = "set rate near";
899 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
900 if(i >= 0 && (i=snd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
901 err = "set buffer size near";
902 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
903 if(i >= 0 && (i=snd_pcm_hw_params_set_period_size_near(data->pcmHandle, p, &periodSizeInFrames, NULL)) < 0)
904 err = "set period size near";
905 /* install and prepare hardware configuration */
906 if(i >= 0 && (i=snd_pcm_hw_params(data->pcmHandle, p)) < 0)
907 err = "set params";
908 if(i < 0)
909 {
910 ERR("%s failed: %s\n", err, snd_strerror(i));
911 snd_pcm_hw_params_free(p);
912 goto error;
913 }
914
915 if((i=snd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
916 {
917 ERR("get size failed: %s\n", snd_strerror(i));
918 snd_pcm_hw_params_free(p);
919 goto error;
920 }
921
922 snd_pcm_hw_params_free(p);
923
924 frameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
925
926 data->ring = CreateRingBuffer(frameSize, pDevice->UpdateSize*pDevice->NumUpdates);
927 if(!data->ring)
928 {
929 ERR("ring buffer create failed\n");
930 goto error;
931 }
932
933 data->size = snd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
934 data->buffer = malloc(data->size);
935 if(!data->buffer)
936 {
937 ERR("buffer malloc failed\n");
938 goto error;
939 }
940
941 pDevice->szDeviceName = strdup(deviceName);
942
943 pDevice->ExtraData = data;
944 return ALC_NO_ERROR;
945
946 error:
947 free(data->buffer);
948 DestroyRingBuffer(data->ring);
949 snd_pcm_close(data->pcmHandle);
950 free(data);
951
952 pDevice->ExtraData = NULL;
953 return ALC_INVALID_VALUE;
954 }
955
956 static void alsa_close_capture(ALCdevice *pDevice)
957 {
958 alsa_data *data = (alsa_data*)pDevice->ExtraData;
959
960 snd_pcm_close(data->pcmHandle);
961 DestroyRingBuffer(data->ring);
962
963 free(data->buffer);
964 free(data);
965 pDevice->ExtraData = NULL;
966 }
967
968 static void alsa_start_capture(ALCdevice *Device)
969 {
970 alsa_data *data = (alsa_data*)Device->ExtraData;
971 int err;
972
973 err = snd_pcm_start(data->pcmHandle);
974 if(err < 0)
975 {
976 ERR("start failed: %s\n", snd_strerror(err));
977 aluHandleDisconnect(Device);
978 }
979 else
980 data->doCapture = AL_TRUE;
981 }
982
983 static void alsa_stop_capture(ALCdevice *Device)
984 {
985 alsa_data *data = (alsa_data*)Device->ExtraData;
986 snd_pcm_drain(data->pcmHandle);
987 data->doCapture = AL_FALSE;
988 }
989
990 static ALCenum alsa_capture_samples(ALCdevice *Device, ALCvoid *Buffer, ALCuint Samples)
991 {
992 alsa_data *data = (alsa_data*)Device->ExtraData;
993 ReadRingBuffer(data->ring, Buffer, Samples);
994 return ALC_NO_ERROR;
995 }
996
997 static ALCuint alsa_available_samples(ALCdevice *Device)
998 {
999 alsa_data *data = (alsa_data*)Device->ExtraData;
1000 snd_pcm_sframes_t avail;
1001
1002 avail = (Device->Connected ? snd_pcm_avail_update(data->pcmHandle) : 0);
1003 if(avail < 0)
1004 {
1005 ERR("avail update failed: %s\n", snd_strerror(avail));
1006
1007 if((avail=snd_pcm_recover(data->pcmHandle, avail, 1)) >= 0)
1008 {
1009 if(data->doCapture)
1010 avail = snd_pcm_start(data->pcmHandle);
1011 if(avail >= 0)
1012 avail = snd_pcm_avail_update(data->pcmHandle);
1013 }
1014 if(avail < 0)
1015 {
1016 ERR("restore error: %s\n", snd_strerror(avail));
1017 aluHandleDisconnect(Device);
1018 }
1019 }
1020 while(avail > 0)
1021 {
1022 snd_pcm_sframes_t amt;
1023
1024 amt = snd_pcm_bytes_to_frames(data->pcmHandle, data->size);
1025 if(avail < amt) amt = avail;
1026
1027 amt = snd_pcm_readi(data->pcmHandle, data->buffer, amt);
1028 if(amt < 0)
1029 {
1030 ERR("read error: %s\n", snd_strerror(amt));
1031
1032 if(amt == -EAGAIN)
1033 continue;
1034 if((amt=snd_pcm_recover(data->pcmHandle, amt, 1)) >= 0)
1035 {
1036 if(data->doCapture)
1037 amt = snd_pcm_start(data->pcmHandle);
1038 if(amt >= 0)
1039 amt = snd_pcm_avail_update(data->pcmHandle);
1040 }
1041 if(amt < 0)
1042 {
1043 ERR("restore error: %s\n", snd_strerror(amt));
1044 aluHandleDisconnect(Device);
1045 break;
1046 }
1047 avail = amt;
1048 continue;
1049 }
1050
1051 WriteRingBuffer(data->ring, data->buffer, amt);
1052 avail -= amt;
1053 }
1054
1055 return RingBufferSize(data->ring);
1056 }
1057
1058
1059 static const BackendFuncs alsa_funcs = {
1060 alsa_open_playback,
1061 alsa_close_playback,
1062 alsa_reset_playback,
1063 alsa_stop_playback,
1064 alsa_open_capture,
1065 alsa_close_capture,
1066 alsa_start_capture,
1067 alsa_stop_capture,
1068 alsa_capture_samples,
1069 alsa_available_samples
1070 };
1071
1072 ALCboolean alc_alsa_init(BackendFuncs *func_list)
1073 {
1074 if(!alsa_load())
1075 return ALC_FALSE;
1076 device_prefix = GetConfigValue("alsa", "device-prefix", "plughw:");
1077 capture_prefix = GetConfigValue("alsa", "capture-prefix", "plughw:");
1078 *func_list = alsa_funcs;
1079 return ALC_TRUE;
1080 }
1081
1082 void alc_alsa_deinit(void)
1083 {
1084 ALuint i;
1085
1086 for(i = 0;i < numDevNames;++i)
1087 {
1088 free(allDevNameMap[i].name);
1089 free(allDevNameMap[i].card);
1090 }
1091 free(allDevNameMap);
1092 allDevNameMap = NULL;
1093 numDevNames = 0;
1094
1095 for(i = 0;i < numCaptureDevNames;++i)
1096 {
1097 free(allCaptureDevNameMap[i].name);
1098 free(allCaptureDevNameMap[i].card);
1099 }
1100 free(allCaptureDevNameMap);
1101 allCaptureDevNameMap = NULL;
1102 numCaptureDevNames = 0;
1103
1104 #ifdef HAVE_DYNLOAD
1105 if(alsa_handle)
1106 CloseLib(alsa_handle);
1107 alsa_handle = NULL;
1108 #endif
1109 }
1110
1111 void alc_alsa_probe(enum DevProbe type)
1112 {
1113 ALuint i;
1114
1115 switch(type)
1116 {
1117 case DEVICE_PROBE:
1118 AppendDeviceList(alsaDevice);
1119 break;
1120
1121 case ALL_DEVICE_PROBE:
1122 for(i = 0;i < numDevNames;++i)
1123 {
1124 free(allDevNameMap[i].name);
1125 free(allDevNameMap[i].card);
1126 }
1127
1128 free(allDevNameMap);
1129 allDevNameMap = probe_devices(SND_PCM_STREAM_PLAYBACK, &numDevNames);
1130
1131 for(i = 0;i < numDevNames;++i)
1132 AppendAllDeviceList(allDevNameMap[i].name);
1133 break;
1134
1135 case CAPTURE_DEVICE_PROBE:
1136 for(i = 0;i < numCaptureDevNames;++i)
1137 {
1138 free(allCaptureDevNameMap[i].name);
1139 free(allCaptureDevNameMap[i].card);
1140 }
1141
1142 free(allCaptureDevNameMap);
1143 allCaptureDevNameMap = probe_devices(SND_PCM_STREAM_CAPTURE, &numCaptureDevNames);
1144
1145 for(i = 0;i < numCaptureDevNames;++i)
1146 AppendCaptureDeviceList(allCaptureDevNameMap[i].name);
1147 break;
1148 }
1149 }
fork of openal-soft for dark-hammer project