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