?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Simplify removing the context handle from the device's context array
[openal-soft.git] / Alc / alsa.c
blobdebab873375136c39375b48c6af497824f38c260
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 if(!alsa_load())
539 return ALC_FALSE;
540
541 strncpy(driver, GetConfigValue("alsa", "device", "default"), sizeof(driver)-1);
542 driver[sizeof(driver)-1] = 0;
543
544 if(!deviceName)
545 deviceName = alsaDevice;
546 else if(strcmp(deviceName, alsaDevice) != 0)
547 {
548 size_t idx;
549
550 if(!allDevNameMap)
551 allDevNameMap = probe_devices(SND_PCM_STREAM_PLAYBACK, &numDevNames);
552
553 for(idx = 0;idx < numDevNames;idx++)
554 {
555 if(allDevNameMap[idx].name &&
556 strcmp(deviceName, allDevNameMap[idx].name) == 0)
557 {
558 if(idx > 0)
559 sprintf(driver, "hw:%d,%d", allDevNameMap[idx].card, allDevNameMap[idx].dev);
560 break;
561 }
562 }
563 if(idx == numDevNames)
564 {
565 alsa_unload();
566 return ALC_FALSE;
567 }
568 }
569
570 data = (alsa_data*)calloc(1, sizeof(alsa_data));
571
572 i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
573 if(i < 0)
574 {
575 Sleep(200);
576 i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
577 }
578 if(i >= 0)
579 {
580 i = psnd_pcm_nonblock(data->pcmHandle, 0);
581 if(i < 0)
582 psnd_pcm_close(data->pcmHandle);
583 }
584 if(i < 0)
585 {
586 free(data);
587 AL_PRINT("Could not open playback device '%s': %s\n", driver, psnd_strerror(i));
588 alsa_unload();
589 return ALC_FALSE;
590 }
591
592 device->szDeviceName = strdup(deviceName);
593 device->ExtraData = data;
594 return ALC_TRUE;
595 }
596
597 static void alsa_close_playback(ALCdevice *device)
598 {
599 alsa_data *data = (alsa_data*)device->ExtraData;
600
601 psnd_pcm_close(data->pcmHandle);
602 free(data);
603 device->ExtraData = NULL;
604
605 alsa_unload();
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 switch(aluBytesFromFormat(device->Format))
625 {
626 case 1:
627 format = SND_PCM_FORMAT_U8;
628 break;
629 case 2:
630 format = SND_PCM_FORMAT_S16;
631 break;
632 case 4:
633 format = SND_PCM_FORMAT_FLOAT;
634 break;
635 default:
636 AL_PRINT("Unknown format: 0x%x\n", device->Format);
637 return ALC_FALSE;
638 }
639
640 allowmmap = GetConfigValueBool("alsa", "mmap", 1);
641 periods = device->NumUpdates;
642 periodLen = (ALuint64)device->UpdateSize * 1000000 / device->Frequency;
643 rate = device->Frequency;
644
645 err = NULL;
646 psnd_pcm_hw_params_malloc(&p);
647
648 if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
649 err = "any";
650 /* set interleaved access */
651 if(i >= 0 && (!allowmmap || (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0))
652 {
653 if(periods > 2) periods--;
654 if((i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
655 err = "set access";
656 }
657 /* set format (implicitly sets sample bits) */
658 if(i >= 0 && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
659 {
660 switch(aluChannelsFromFormat(device->Format))
661 {
662 case 1: device->Format = AL_FORMAT_MONO_FLOAT32; break;
663 case 2: device->Format = AL_FORMAT_STEREO_FLOAT32; break;
664 case 4: device->Format = AL_FORMAT_QUAD32; break;
665 case 6: device->Format = AL_FORMAT_51CHN32; break;
666 case 7: device->Format = AL_FORMAT_61CHN32; break;
667 case 8: device->Format = AL_FORMAT_71CHN32; break;
668 }
669 if((i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_FLOAT)) < 0)
670 {
671 switch(aluChannelsFromFormat(device->Format))
672 {
673 case 1: device->Format = AL_FORMAT_MONO16; break;
674 case 2: device->Format = AL_FORMAT_STEREO16; break;
675 case 4: device->Format = AL_FORMAT_QUAD16; break;
676 case 6: device->Format = AL_FORMAT_51CHN16; break;
677 case 7: device->Format = AL_FORMAT_61CHN16; break;
678 case 8: device->Format = AL_FORMAT_71CHN16; break;
679 }
680 if((i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_S16)) < 0)
681 {
682 switch(aluChannelsFromFormat(device->Format))
683 {
684 case 1: device->Format = AL_FORMAT_MONO8; break;
685 case 2: device->Format = AL_FORMAT_STEREO8; break;
686 case 4: device->Format = AL_FORMAT_QUAD8; break;
687 case 6: device->Format = AL_FORMAT_51CHN8; break;
688 case 7: device->Format = AL_FORMAT_61CHN8; break;
689 case 8: device->Format = AL_FORMAT_71CHN8; break;
690 }
691 if((i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_U8)) < 0)
692 err = "set format";
693 }
694 }
695 }
696 /* set channels (implicitly sets frame bits) */
697 if(i >= 0 && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(device->Format))) < 0)
698 {
699 switch(aluBytesFromFormat(device->Format))
700 {
701 case 1: device->Format = AL_FORMAT_STEREO8; break;
702 case 2: device->Format = AL_FORMAT_STEREO16; break;
703 case 4: device->Format = AL_FORMAT_STEREO_FLOAT32; break;
704 }
705 if((i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, 2)) < 0)
706 {
707 switch(aluBytesFromFormat(device->Format))
708 {
709 case 1: device->Format = AL_FORMAT_MONO8; break;
710 case 2: device->Format = AL_FORMAT_MONO16; break;
711 case 4: device->Format = AL_FORMAT_MONO_FLOAT32; break;
712 }
713 if((i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, 1)) < 0)
714 err = "set channels";
715 }
716 }
717 if(i >= 0 && (i=psnd_pcm_hw_params_set_rate_resample(data->pcmHandle, p, 0)) < 0)
718 {
719 AL_PRINT("Failed to disable ALSA resampler\n");
720 i = 0;
721 }
722 /* set rate (implicitly constrains period/buffer parameters) */
723 if(i >= 0 && (i=psnd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &rate, NULL)) < 0)
724 err = "set rate near";
725 /* set buffer time (implicitly constrains period/buffer parameters) */
726 bufferLen = periodLen * periods;
727 if(i >= 0 && (i=psnd_pcm_hw_params_set_buffer_time_near(data->pcmHandle, p, &bufferLen, NULL)) < 0)
728 err = "set buffer time near";
729 /* set period time in frame units (implicitly sets buffer size/bytes/time and period size/bytes) */
730 if(i >= 0 && (i=psnd_pcm_hw_params_set_period_time_near(data->pcmHandle, p, &periodLen, NULL)) < 0)
731 err = "set period time near";
732 /* install and prepare hardware configuration */
733 if(i >= 0 && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
734 err = "set params";
735 if(i >= 0 && (i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
736 err = "get access";
737 if(i >= 0 && (i=psnd_pcm_hw_params_get_period_size(p, &periodSizeInFrames, NULL)) < 0)
738 err = "get period size";
739 if(i >= 0 && (i=psnd_pcm_hw_params_get_periods(p, &periods, NULL)) < 0)
740 err = "get periods";
741 if(i < 0)
742 {
743 AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
744 psnd_pcm_hw_params_free(p);
745 return ALC_FALSE;
746 }
747
748 psnd_pcm_hw_params_free(p);
749
750 err = NULL;
751 psnd_pcm_sw_params_malloc(&sp);
752
753 if((i=psnd_pcm_sw_params_current(data->pcmHandle, sp)) != 0)
754 err = "sw current";
755 if(i == 0 && (i=psnd_pcm_sw_params_set_avail_min(data->pcmHandle, sp, periodSizeInFrames)) != 0)
756 err = "sw set avail min";
757 if(i == 0 && (i=psnd_pcm_sw_params(data->pcmHandle, sp)) != 0)
758 err = "sw set params";
759 if(i != 0)
760 {
761 AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
762 psnd_pcm_sw_params_free(sp);
763 return ALC_FALSE;
764 }
765
766 psnd_pcm_sw_params_free(sp);
767
768 SetDefaultChannelOrder(device);
769
770 data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, periodSizeInFrames);
771 if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
772 {
773 /* Increase periods by one, since the temp buffer counts as an extra
774 * period */
775 periods++;
776 data->buffer = malloc(data->size);
777 if(!data->buffer)
778 {
779 AL_PRINT("buffer malloc failed\n");
780 return ALC_FALSE;
781 }
782 device->UpdateSize = periodSizeInFrames;
783 device->NumUpdates = periods;
784 device->Frequency = rate;
785 data->thread = StartThread(ALSANoMMapProc, device);
786 }
787 else
788 {
789 i = psnd_pcm_prepare(data->pcmHandle);
790 if(i < 0)
791 {
792 AL_PRINT("prepare error: %s\n", psnd_strerror(i));
793 return ALC_FALSE;
794 }
795 device->UpdateSize = periodSizeInFrames;
796 device->NumUpdates = periods;
797 device->Frequency = rate;
798 data->thread = StartThread(ALSAProc, device);
799 }
800 if(data->thread == NULL)
801 {
802 AL_PRINT("Could not create playback thread\n");
803 free(data->buffer);
804 data->buffer = NULL;
805 return ALC_FALSE;
806 }
807
808 return ALC_TRUE;
809 }
810
811 static void alsa_stop_playback(ALCdevice *device)
812 {
813 alsa_data *data = (alsa_data*)device->ExtraData;
814
815 if(data->thread)
816 {
817 data->killNow = 1;
818 StopThread(data->thread);
819 data->thread = NULL;
820 }
821 data->killNow = 0;
822 free(data->buffer);
823 data->buffer = NULL;
824 }
825
826
827 static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName)
828 {
829 const char *devName;
830 snd_pcm_hw_params_t *p;
831 snd_pcm_uframes_t bufferSizeInFrames;
832 snd_pcm_format_t format;
833 ALuint frameSize;
834 alsa_data *data;
835 char driver[64];
836 char *err;
837 int i;
838
839 if(!alsa_load())
840 return ALC_FALSE;
841
842 strncpy(driver, GetConfigValue("alsa", "capture", "default"), sizeof(driver)-1);
843 driver[sizeof(driver)-1] = 0;
844
845 if(!allCaptureDevNameMap)
846 allCaptureDevNameMap = probe_devices(SND_PCM_STREAM_CAPTURE, &numCaptureDevNames);
847
848 if(!deviceName)
849 deviceName = allCaptureDevNameMap[0].name;
850 else
851 {
852 size_t idx;
853
854 for(idx = 0;idx < numCaptureDevNames;idx++)
855 {
856 if(allCaptureDevNameMap[idx].name &&
857 strcmp(deviceName, allCaptureDevNameMap[idx].name) == 0)
858 {
859 devName = allCaptureDevNameMap[idx].name;
860 if(idx > 0)
861 sprintf(driver, "plughw:%d,%d", allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev);
862 break;
863 }
864 }
865 if(idx == numCaptureDevNames)
866 {
867 alsa_unload();
868 return ALC_FALSE;
869 }
870 }
871
872 data = (alsa_data*)calloc(1, sizeof(alsa_data));
873
874 i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
875 if(i < 0)
876 {
877 Sleep(200);
878 i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
879 }
880 if(i >= 0)
881 {
882 i = psnd_pcm_nonblock(data->pcmHandle, 0);
883 if(i < 0)
884 psnd_pcm_close(data->pcmHandle);
885 }
886 if(i < 0)
887 {
888 AL_PRINT("Could not open capture device '%s': %s\n", driver, psnd_strerror(i));
889 free(data);
890 alsa_unload();
891 return ALC_FALSE;
892 }
893
894 switch(aluBytesFromFormat(pDevice->Format))
895 {
896 case 1:
897 format = SND_PCM_FORMAT_U8;
898 break;
899 case 2:
900 format = SND_PCM_FORMAT_S16;
901 break;
902 case 4:
903 format = SND_PCM_FORMAT_FLOAT;
904 break;
905 default:
906 AL_PRINT("Unknown format: 0x%x\n", pDevice->Format);
907 goto error;
908 }
909
910 err = NULL;
911 bufferSizeInFrames = pDevice->UpdateSize * pDevice->NumUpdates;
912 psnd_pcm_hw_params_malloc(&p);
913
914 if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
915 err = "any";
916 /* set interleaved access */
917 if(i >= 0 && (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
918 err = "set access";
919 /* set format (implicitly sets sample bits) */
920 if(i >= 0 && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
921 err = "set format";
922 /* set channels (implicitly sets frame bits) */
923 if(i >= 0 && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
924 err = "set channels";
925 /* set rate (implicitly constrains period/buffer parameters) */
926 if(i >= 0 && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, pDevice->Frequency, 0)) < 0)
927 err = "set rate near";
928 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
929 if(i >= 0 && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
930 err = "set buffer size near";
931 /* install and prepare hardware configuration */
932 if(i >= 0 && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
933 err = "set params";
934 if(i < 0)
935 {
936 AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
937 psnd_pcm_hw_params_free(p);
938 goto error;
939 }
940
941 if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
942 {
943 AL_PRINT("get size failed: %s\n", psnd_strerror(i));
944 psnd_pcm_hw_params_free(p);
945 goto error;
946 }
947
948 psnd_pcm_hw_params_free(p);
949
950 frameSize = aluChannelsFromFormat(pDevice->Format);
951 frameSize *= aluBytesFromFormat(pDevice->Format);
952
953 data->ring = CreateRingBuffer(frameSize, pDevice->UpdateSize*pDevice->NumUpdates);
954 if(!data->ring)
955 {
956 AL_PRINT("ring buffer create failed\n");
957 goto error;
958 }
959
960 data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
961 data->buffer = malloc(data->size);
962 if(!data->buffer)
963 {
964 AL_PRINT("buffer malloc failed\n");
965 goto error;
966 }
967
968 pDevice->ExtraData = data;
969 data->thread = StartThread(ALSANoMMapCaptureProc, pDevice);
970 if(data->thread == NULL)
971 {
972 AL_PRINT("Could not create capture thread\n");
973 goto error;
974 }
975
976 pDevice->szDeviceName = strdup(deviceName);
977 return ALC_TRUE;
978
979 error:
980 free(data->buffer);
981 DestroyRingBuffer(data->ring);
982 psnd_pcm_close(data->pcmHandle);
983 free(data);
984 alsa_unload();
985
986 pDevice->ExtraData = NULL;
987 return ALC_FALSE;
988 }
989
990 static void alsa_close_capture(ALCdevice *pDevice)
991 {
992 alsa_data *data = (alsa_data*)pDevice->ExtraData;
993
994 data->killNow = 1;
995 StopThread(data->thread);
996
997 psnd_pcm_close(data->pcmHandle);
998 DestroyRingBuffer(data->ring);
999
1000 free(data->buffer);
1001 free(data);
1002 pDevice->ExtraData = NULL;
1003
1004 alsa_unload();
1005 }
1006
1007 static void alsa_start_capture(ALCdevice *pDevice)
1008 {
1009 alsa_data *data = (alsa_data*)pDevice->ExtraData;
1010 data->doCapture = 1;
1011 }
1012
1013 static void alsa_stop_capture(ALCdevice *pDevice)
1014 {
1015 alsa_data *data = (alsa_data*)pDevice->ExtraData;
1016 data->doCapture = 0;
1017 }
1018
1019 static void alsa_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
1020 {
1021 alsa_data *data = (alsa_data*)pDevice->ExtraData;
1022
1023 if(lSamples <= (ALCuint)RingBufferSize(data->ring))
1024 ReadRingBuffer(data->ring, pBuffer, lSamples);
1025 else
1026 alcSetError(pDevice, ALC_INVALID_VALUE);
1027 }
1028
1029 static ALCuint alsa_available_samples(ALCdevice *pDevice)
1030 {
1031 alsa_data *data = (alsa_data*)pDevice->ExtraData;
1032 return RingBufferSize(data->ring);
1033 }
1034
1035
1036 BackendFuncs alsa_funcs = {
1037 alsa_open_playback,
1038 alsa_close_playback,
1039 alsa_reset_playback,
1040 alsa_stop_playback,
1041 alsa_open_capture,
1042 alsa_close_capture,
1043 alsa_start_capture,
1044 alsa_stop_capture,
1045 alsa_capture_samples,
1046 alsa_available_samples
1047 };
1048
1049 void alc_alsa_init(BackendFuncs *func_list)
1050 {
1051 *func_list = alsa_funcs;
1052 }
1053
1054 void alc_alsa_deinit(void)
1055 {
1056 ALuint i;
1057
1058 for(i = 0;i < numDevNames;++i)
1059 free(allDevNameMap[i].name);
1060 free(allDevNameMap);
1061 allDevNameMap = NULL;
1062 numDevNames = 0;
1063
1064 for(i = 0;i < numCaptureDevNames;++i)
1065 free(allCaptureDevNameMap[i].name);
1066 free(allCaptureDevNameMap);
1067 allCaptureDevNameMap = NULL;
1068 numCaptureDevNames = 0;
1069 }
1070
1071 void alc_alsa_probe(int type)
1072 {
1073 ALuint i;
1074
1075 if(!alsa_load())
1076 return;
1077
1078 if(type == DEVICE_PROBE)
1079 AppendDeviceList(alsaDevice);
1080 else if(type == ALL_DEVICE_PROBE)
1081 {
1082 for(i = 0;i < numDevNames;++i)
1083 free(allDevNameMap[i].name);
1084
1085 free(allDevNameMap);
1086 allDevNameMap = probe_devices(SND_PCM_STREAM_PLAYBACK, &numDevNames);
1087
1088 for(i = 0;i < numDevNames;++i)
1089 AppendAllDeviceList(allDevNameMap[i].name);
1090 }
1091 else if(type == CAPTURE_DEVICE_PROBE)
1092 {
1093 for(i = 0;i < numCaptureDevNames;++i)
1094 free(allCaptureDevNameMap[i].name);
1095
1096 free(allCaptureDevNameMap);
1097 allCaptureDevNameMap = probe_devices(SND_PCM_STREAM_CAPTURE, &numCaptureDevNames);
1098
1099 for(i = 0;i < numCaptureDevNames;++i)
1100 AppendCaptureDeviceList(allCaptureDevNameMap[i].name);
1101 }
1102
1103 alsa_unload();
1104 }
Software OpenAL implementation