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