2 * OpenAL cross platform audio library
3 * Copyright (C) 1999-2007 by authors.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
33 #include <alsa/asoundlib.h>
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_info_malloc
);
96 MAKE_FUNC(snd_pcm_info_free
);
97 MAKE_FUNC(snd_pcm_info_set_device
);
98 MAKE_FUNC(snd_pcm_info_set_subdevice
);
99 MAKE_FUNC(snd_pcm_info_set_stream
);
100 MAKE_FUNC(snd_pcm_info_get_name
);
101 MAKE_FUNC(snd_ctl_pcm_next_device
);
102 MAKE_FUNC(snd_ctl_pcm_info
);
103 MAKE_FUNC(snd_ctl_open
);
104 MAKE_FUNC(snd_ctl_close
);
105 MAKE_FUNC(snd_ctl_card_info_malloc
);
106 MAKE_FUNC(snd_ctl_card_info_free
);
107 MAKE_FUNC(snd_ctl_card_info
);
108 MAKE_FUNC(snd_ctl_card_info_get_name
);
109 MAKE_FUNC(snd_card_next
);
113 static const ALCchar alsaDevice
[] = "ALSA Software";
114 static DevMap
*allDevNameMap
;
115 static ALuint numDevNames
;
116 static DevMap
*allCaptureDevNameMap
;
117 static ALuint numCaptureDevNames
;
118 static volatile ALuint load_count
;
128 alsa_handle
= dlopen("libasound.so.2", RTLD_NOW
);
133 #define LOAD_FUNC(f) do { \
134 p##f = dlsym(alsa_handle, #f); \
135 if((str=dlerror()) != NULL) \
137 dlclose(alsa_handle); \
138 alsa_handle = NULL; \
139 AL_PRINT("Could not load %s from libasound.so.2: %s\n", #f, str); \
145 alsa_handle
= (void*)0xDEADBEEF;
146 #define LOAD_FUNC(f) p##f = f
149 LOAD_FUNC(snd_strerror
);
150 LOAD_FUNC(snd_pcm_open
);
151 LOAD_FUNC(snd_pcm_close
);
152 LOAD_FUNC(snd_pcm_nonblock
);
153 LOAD_FUNC(snd_pcm_frames_to_bytes
);
154 LOAD_FUNC(snd_pcm_hw_params_malloc
);
155 LOAD_FUNC(snd_pcm_hw_params_free
);
156 LOAD_FUNC(snd_pcm_hw_params_any
);
157 LOAD_FUNC(snd_pcm_hw_params_set_access
);
158 LOAD_FUNC(snd_pcm_hw_params_set_format
);
159 LOAD_FUNC(snd_pcm_hw_params_set_channels
);
160 LOAD_FUNC(snd_pcm_hw_params_set_periods_near
);
161 LOAD_FUNC(snd_pcm_hw_params_set_rate_near
);
162 LOAD_FUNC(snd_pcm_hw_params_set_rate
);
163 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near
);
164 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min
);
165 LOAD_FUNC(snd_pcm_hw_params_set_period_size_near
);
166 LOAD_FUNC(snd_pcm_hw_params_get_buffer_size
);
167 LOAD_FUNC(snd_pcm_hw_params_get_period_size
);
168 LOAD_FUNC(snd_pcm_hw_params_get_access
);
169 LOAD_FUNC(snd_pcm_hw_params_get_periods
);
170 LOAD_FUNC(snd_pcm_hw_params
);
171 LOAD_FUNC(snd_pcm_sw_params_malloc
);
172 LOAD_FUNC(snd_pcm_sw_params_current
);
173 LOAD_FUNC(snd_pcm_sw_params_set_avail_min
);
174 LOAD_FUNC(snd_pcm_sw_params
);
175 LOAD_FUNC(snd_pcm_sw_params_free
);
176 LOAD_FUNC(snd_pcm_prepare
);
177 LOAD_FUNC(snd_pcm_start
);
178 LOAD_FUNC(snd_pcm_resume
);
179 LOAD_FUNC(snd_pcm_wait
);
180 LOAD_FUNC(snd_pcm_state
);
181 LOAD_FUNC(snd_pcm_avail_update
);
182 LOAD_FUNC(snd_pcm_areas_silence
);
183 LOAD_FUNC(snd_pcm_mmap_begin
);
184 LOAD_FUNC(snd_pcm_mmap_commit
);
185 LOAD_FUNC(snd_pcm_readi
);
186 LOAD_FUNC(snd_pcm_writei
);
187 LOAD_FUNC(snd_pcm_drain
);
189 LOAD_FUNC(snd_pcm_info_malloc
);
190 LOAD_FUNC(snd_pcm_info_free
);
191 LOAD_FUNC(snd_pcm_info_set_device
);
192 LOAD_FUNC(snd_pcm_info_set_subdevice
);
193 LOAD_FUNC(snd_pcm_info_set_stream
);
194 LOAD_FUNC(snd_pcm_info_get_name
);
195 LOAD_FUNC(snd_ctl_pcm_next_device
);
196 LOAD_FUNC(snd_ctl_pcm_info
);
197 LOAD_FUNC(snd_ctl_open
);
198 LOAD_FUNC(snd_ctl_close
);
199 LOAD_FUNC(snd_ctl_card_info_malloc
);
200 LOAD_FUNC(snd_ctl_card_info_free
);
201 LOAD_FUNC(snd_ctl_card_info
);
202 LOAD_FUNC(snd_ctl_card_info_get_name
);
203 LOAD_FUNC(snd_card_next
);
210 void alsa_unload(void)
212 if(load_count
== 0 || --load_count
> 0)
216 dlclose(alsa_handle
);
222 static int xrun_recovery(snd_pcm_t
*handle
, int err
)
226 err
= psnd_pcm_prepare(handle
);
228 AL_PRINT("prepare failed: %s\n", psnd_strerror(err
));
230 else if (err
== -ESTRPIPE
)
232 while ((err
= psnd_pcm_resume(handle
)) == -EAGAIN
)
233 Sleep(1); /* wait until the suspend flag is released */
236 err
= psnd_pcm_prepare(handle
);
238 AL_PRINT("prepare failed: %s\n", psnd_strerror(err
));
244 static int verify_state(snd_pcm_t
*handle
)
246 snd_pcm_state_t state
= psnd_pcm_state(handle
);
247 if(state
== SND_PCM_STATE_DISCONNECTED
)
249 if(state
== SND_PCM_STATE_XRUN
)
251 int err
= xrun_recovery(handle
, -EPIPE
);
252 if(err
< 0) return err
;
254 else if(state
== SND_PCM_STATE_SUSPENDED
)
256 int err
= xrun_recovery(handle
, -ESTRPIPE
);
257 if(err
< 0) return err
;
264 static ALuint
ALSAProc(ALvoid
*ptr
)
266 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
267 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
268 const snd_pcm_channel_area_t
*areas
= NULL
;
269 snd_pcm_sframes_t avail
, commitres
;
270 snd_pcm_uframes_t offset
, frames
;
274 EnableRTPrio(RTPrioLevel
);
276 while(!data
->killNow
)
278 int state
= verify_state(data
->pcmHandle
);
281 AL_PRINT("Invalid state detected: %s\n", psnd_strerror(state
));
282 aluHandleDisconnect(pDevice
);
286 avail
= psnd_pcm_avail_update(data
->pcmHandle
);
289 AL_PRINT("available update failed: %s\n", psnd_strerror(avail
));
293 // make sure there's frames to process
294 if((snd_pcm_uframes_t
)avail
< pDevice
->UpdateSize
)
296 if(state
!= SND_PCM_STATE_RUNNING
)
298 err
= psnd_pcm_start(data
->pcmHandle
);
301 AL_PRINT("start failed: %s\n", psnd_strerror(err
));
305 if(psnd_pcm_wait(data
->pcmHandle
, 1000) == 0)
306 AL_PRINT("Wait timeout... buffer size too low?\n");
309 avail
-= avail
%pDevice
->UpdateSize
;
311 // it is possible that contiguous areas are smaller, thus we use a loop
316 err
= psnd_pcm_mmap_begin(data
->pcmHandle
, &areas
, &offset
, &frames
);
319 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err
));
323 WritePtr
= (char*)areas
->addr
+ (offset
* areas
->step
/ 8);
324 aluMixData(pDevice
, WritePtr
, frames
);
326 commitres
= psnd_pcm_mmap_commit(data
->pcmHandle
, offset
, frames
);
327 if(commitres
< 0 || (commitres
-frames
) != 0)
329 AL_PRINT("mmap commit error: %s\n",
330 psnd_strerror(commitres
>= 0 ? -EPIPE
: commitres
));
341 static ALuint
ALSANoMMapProc(ALvoid
*ptr
)
343 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
344 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
345 snd_pcm_sframes_t avail
;
348 EnableRTPrio(RTPrioLevel
);
350 while(!data
->killNow
)
352 int state
= verify_state(data
->pcmHandle
);
355 AL_PRINT("Invalid state detected: %s\n", psnd_strerror(state
));
356 aluHandleDisconnect(pDevice
);
360 WritePtr
= data
->buffer
;
361 avail
= data
->size
/ psnd_pcm_frames_to_bytes(data
->pcmHandle
, 1);
362 aluMixData(pDevice
, WritePtr
, avail
);
366 int ret
= psnd_pcm_writei(data
->pcmHandle
, WritePtr
, avail
);
372 while((ret
=psnd_pcm_resume(data
->pcmHandle
)) == -EAGAIN
)
380 WritePtr
+= psnd_pcm_frames_to_bytes(data
->pcmHandle
, ret
);
387 ret
= psnd_pcm_prepare(data
->pcmHandle
);
397 static ALuint
ALSANoMMapCaptureProc(ALvoid
*ptr
)
399 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
400 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
401 snd_pcm_sframes_t avail
;
403 EnableRTPrio(RTPrioLevel
);
405 while(!data
->killNow
)
407 int state
= verify_state(data
->pcmHandle
);
410 AL_PRINT("Invalid state detected: %s\n", psnd_strerror(state
));
411 aluHandleDisconnect(pDevice
);
415 avail
= (snd_pcm_uframes_t
)data
->size
/ psnd_pcm_frames_to_bytes(data
->pcmHandle
, 1);
416 avail
= psnd_pcm_readi(data
->pcmHandle
, data
->buffer
, avail
);
422 while((avail
=psnd_pcm_resume(data
->pcmHandle
)) == -EAGAIN
)
428 if (avail
>= 0 && data
->doCapture
)
429 WriteRingBuffer(data
->ring
, data
->buffer
, avail
);
434 avail
= psnd_pcm_prepare(data
->pcmHandle
);
436 AL_PRINT("prepare error: %s\n", psnd_strerror(avail
));
443 static ALCboolean
alsa_open_playback(ALCdevice
*device
, const ALCchar
*deviceName
)
449 strncpy(driver
, GetConfigValue("alsa", "device", "default"), sizeof(driver
)-1);
450 driver
[sizeof(driver
)-1] = 0;
452 deviceName
= alsaDevice
;
453 else if(strcmp(deviceName
, alsaDevice
) != 0)
457 for(idx
= 0;idx
< numDevNames
;idx
++)
459 if(allDevNameMap
[idx
].name
&&
460 strcmp(deviceName
, allDevNameMap
[idx
].name
) == 0)
463 sprintf(driver
, "hw:%d,%d", allDevNameMap
[idx
].card
, allDevNameMap
[idx
].dev
);
467 if(idx
== numDevNames
)
475 data
= (alsa_data
*)calloc(1, sizeof(alsa_data
));
477 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_PLAYBACK
, SND_PCM_NONBLOCK
);
481 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_PLAYBACK
, SND_PCM_NONBLOCK
);
485 i
= psnd_pcm_nonblock(data
->pcmHandle
, 0);
487 psnd_pcm_close(data
->pcmHandle
);
492 AL_PRINT("Could not open playback device '%s': %s\n", driver
, psnd_strerror(i
));
497 device
->szDeviceName
= strdup(deviceName
);
498 device
->ExtraData
= data
;
502 static void alsa_close_playback(ALCdevice
*device
)
504 alsa_data
*data
= (alsa_data
*)device
->ExtraData
;
506 psnd_pcm_close(data
->pcmHandle
);
508 device
->ExtraData
= NULL
;
513 static ALCboolean
alsa_reset_playback(ALCdevice
*device
)
515 alsa_data
*data
= (alsa_data
*)device
->ExtraData
;
516 snd_pcm_uframes_t periodSizeInFrames
;
517 snd_pcm_sw_params_t
*sp
= NULL
;
518 snd_pcm_hw_params_t
*p
= NULL
;
519 snd_pcm_access_t access
;
520 snd_pcm_format_t format
;
521 unsigned int periods
;
528 switch(aluBytesFromFormat(device
->Format
))
531 format
= SND_PCM_FORMAT_U8
;
534 format
= SND_PCM_FORMAT_S16
;
537 format
= SND_PCM_FORMAT_FLOAT
;
540 AL_PRINT("Unknown format: 0x%x\n", device
->Format
);
544 allowmmap
= GetConfigValueBool("alsa", "mmap", 1);
545 periods
= device
->NumUpdates
;
546 periodSizeInFrames
= device
->UpdateSize
;
547 rate
= device
->Frequency
;
550 psnd_pcm_hw_params_malloc(&p
);
552 if((i
=psnd_pcm_hw_params_any(data
->pcmHandle
, p
)) < 0)
554 /* set interleaved access */
555 if(i
>= 0 && (!allowmmap
|| (i
=psnd_pcm_hw_params_set_access(data
->pcmHandle
, p
, SND_PCM_ACCESS_MMAP_INTERLEAVED
)) < 0))
557 if(periods
> 2) periods
--;
558 if((i
=psnd_pcm_hw_params_set_access(data
->pcmHandle
, p
, SND_PCM_ACCESS_RW_INTERLEAVED
)) < 0)
561 /* set format (implicitly sets sample bits) */
562 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, format
)) < 0)
564 switch(aluChannelsFromFormat(device
->Format
))
566 case 1: device
->Format
= AL_FORMAT_MONO_FLOAT32
; break;
567 case 2: device
->Format
= AL_FORMAT_STEREO_FLOAT32
; break;
568 case 4: device
->Format
= AL_FORMAT_QUAD32
; break;
569 case 6: device
->Format
= AL_FORMAT_51CHN32
; break;
570 case 7: device
->Format
= AL_FORMAT_61CHN32
; break;
571 case 8: device
->Format
= AL_FORMAT_71CHN32
; break;
573 if((i
=psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, SND_PCM_FORMAT_FLOAT
)) < 0)
575 switch(aluChannelsFromFormat(device
->Format
))
577 case 1: device
->Format
= AL_FORMAT_MONO16
; break;
578 case 2: device
->Format
= AL_FORMAT_STEREO16
; break;
579 case 4: device
->Format
= AL_FORMAT_QUAD16
; break;
580 case 6: device
->Format
= AL_FORMAT_51CHN16
; break;
581 case 7: device
->Format
= AL_FORMAT_61CHN16
; break;
582 case 8: device
->Format
= AL_FORMAT_71CHN16
; break;
584 if((i
=psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, SND_PCM_FORMAT_S16
)) < 0)
586 switch(aluChannelsFromFormat(device
->Format
))
588 case 1: device
->Format
= AL_FORMAT_MONO8
; break;
589 case 2: device
->Format
= AL_FORMAT_STEREO8
; break;
590 case 4: device
->Format
= AL_FORMAT_QUAD8
; break;
591 case 6: device
->Format
= AL_FORMAT_51CHN8
; break;
592 case 7: device
->Format
= AL_FORMAT_61CHN8
; break;
593 case 8: device
->Format
= AL_FORMAT_71CHN8
; break;
595 if((i
=psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, SND_PCM_FORMAT_U8
)) < 0)
600 /* set channels (implicitly sets frame bits) */
601 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_channels(data
->pcmHandle
, p
, aluChannelsFromFormat(device
->Format
))) < 0)
603 switch(aluBytesFromFormat(device
->Format
))
605 case 1: device
->Format
= AL_FORMAT_STEREO8
; break;
606 case 2: device
->Format
= AL_FORMAT_STEREO16
; break;
607 case 4: device
->Format
= AL_FORMAT_STEREO_FLOAT32
; break;
609 if((i
=psnd_pcm_hw_params_set_channels(data
->pcmHandle
, p
, 2)) < 0)
611 switch(aluBytesFromFormat(device
->Format
))
613 case 1: device
->Format
= AL_FORMAT_MONO8
; break;
614 case 2: device
->Format
= AL_FORMAT_MONO16
; break;
615 case 4: device
->Format
= AL_FORMAT_MONO_FLOAT32
; break;
617 if((i
=psnd_pcm_hw_params_set_channels(data
->pcmHandle
, p
, 1)) < 0)
618 err
= "set channels";
621 /* set periods (implicitly constrains period/buffer parameters) */
622 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_periods_near(data
->pcmHandle
, p
, &periods
, NULL
)) < 0)
623 err
= "set periods near";
624 /* set rate (implicitly constrains period/buffer parameters) */
625 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_rate_near(data
->pcmHandle
, p
, &rate
, NULL
)) < 0)
626 err
= "set rate near";
627 /* set period size in frame units (implicitly sets buffer size/bytes/time and period time/bytes) */
628 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_period_size_near(data
->pcmHandle
, p
, &periodSizeInFrames
, NULL
)) < 0)
629 err
= "set period size near";
630 /* install and prepare hardware configuration */
631 if(i
>= 0 && (i
=psnd_pcm_hw_params(data
->pcmHandle
, p
)) < 0)
633 if(i
>= 0 && (i
=psnd_pcm_hw_params_get_access(p
, &access
)) < 0)
635 if(i
>= 0 && (i
=psnd_pcm_hw_params_get_period_size(p
, &periodSizeInFrames
, NULL
)) < 0)
636 err
= "get period size";
637 if(i
>= 0 && (i
=psnd_pcm_hw_params_get_periods(p
, &periods
, NULL
)) < 0)
641 AL_PRINT("%s failed: %s\n", err
, psnd_strerror(i
));
642 psnd_pcm_hw_params_free(p
);
646 psnd_pcm_hw_params_free(p
);
649 psnd_pcm_sw_params_malloc(&sp
);
651 if((i
=psnd_pcm_sw_params_current(data
->pcmHandle
, sp
)) != 0)
653 if(i
== 0 && (i
=psnd_pcm_sw_params_set_avail_min(data
->pcmHandle
, sp
, periodSizeInFrames
)) != 0)
654 err
= "sw set avail min";
655 if(i
== 0 && (i
=psnd_pcm_sw_params(data
->pcmHandle
, sp
)) != 0)
656 err
= "sw set params";
659 AL_PRINT("%s failed: %s\n", err
, psnd_strerror(i
));
660 psnd_pcm_sw_params_free(sp
);
664 psnd_pcm_sw_params_free(sp
);
666 SetDefaultChannelOrder(device
);
668 data
->size
= psnd_pcm_frames_to_bytes(data
->pcmHandle
, periodSizeInFrames
);
669 if(access
== SND_PCM_ACCESS_RW_INTERLEAVED
)
671 /* Increase periods by one, since the temp buffer counts as an extra
674 data
->buffer
= malloc(data
->size
);
677 AL_PRINT("buffer malloc failed\n");
680 device
->UpdateSize
= periodSizeInFrames
;
681 device
->NumUpdates
= periods
;
682 device
->Frequency
= rate
;
683 data
->thread
= StartThread(ALSANoMMapProc
, device
);
687 i
= psnd_pcm_prepare(data
->pcmHandle
);
690 AL_PRINT("prepare error: %s\n", psnd_strerror(i
));
693 device
->UpdateSize
= periodSizeInFrames
;
694 device
->NumUpdates
= periods
;
695 device
->Frequency
= rate
;
696 data
->thread
= StartThread(ALSAProc
, device
);
698 if(data
->thread
== NULL
)
700 AL_PRINT("Could not create playback thread\n");
709 static void alsa_stop_playback(ALCdevice
*device
)
711 alsa_data
*data
= (alsa_data
*)device
->ExtraData
;
716 StopThread(data
->thread
);
725 static ALCboolean
alsa_open_capture(ALCdevice
*pDevice
, const ALCchar
*deviceName
)
728 snd_pcm_hw_params_t
*p
;
729 snd_pcm_uframes_t bufferSizeInFrames
;
730 snd_pcm_format_t format
;
737 strncpy(driver
, GetConfigValue("alsa", "capture", "default"), sizeof(driver
)-1);
738 driver
[sizeof(driver
)-1] = 0;
740 deviceName
= allCaptureDevNameMap
[0].name
;
745 for(idx
= 0;idx
< numCaptureDevNames
;idx
++)
747 if(allCaptureDevNameMap
[idx
].name
&&
748 strcmp(deviceName
, allCaptureDevNameMap
[idx
].name
) == 0)
750 devName
= allCaptureDevNameMap
[idx
].name
;
752 sprintf(driver
, "plughw:%d,%d", allCaptureDevNameMap
[idx
].card
, allCaptureDevNameMap
[idx
].dev
);
756 if(idx
== numCaptureDevNames
)
764 data
= (alsa_data
*)calloc(1, sizeof(alsa_data
));
766 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_CAPTURE
, SND_PCM_NONBLOCK
);
770 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_CAPTURE
, SND_PCM_NONBLOCK
);
774 i
= psnd_pcm_nonblock(data
->pcmHandle
, 0);
776 psnd_pcm_close(data
->pcmHandle
);
780 AL_PRINT("Could not open capture device '%s': %s\n", driver
, psnd_strerror(i
));
786 switch(aluBytesFromFormat(pDevice
->Format
))
789 format
= SND_PCM_FORMAT_U8
;
792 format
= SND_PCM_FORMAT_S16
;
795 format
= SND_PCM_FORMAT_FLOAT
;
798 AL_PRINT("Unknown format: 0x%x\n", pDevice
->Format
);
803 bufferSizeInFrames
= pDevice
->UpdateSize
* pDevice
->NumUpdates
;
804 psnd_pcm_hw_params_malloc(&p
);
806 if((i
=psnd_pcm_hw_params_any(data
->pcmHandle
, p
)) < 0)
808 /* set interleaved access */
809 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_access(data
->pcmHandle
, p
, SND_PCM_ACCESS_RW_INTERLEAVED
)) < 0)
811 /* set format (implicitly sets sample bits) */
812 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, format
)) < 0)
814 /* set channels (implicitly sets frame bits) */
815 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_channels(data
->pcmHandle
, p
, aluChannelsFromFormat(pDevice
->Format
))) < 0)
816 err
= "set channels";
817 /* set rate (implicitly constrains period/buffer parameters) */
818 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_rate(data
->pcmHandle
, p
, pDevice
->Frequency
, 0)) < 0)
819 err
= "set rate near";
820 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
821 if(i
>= 0 && (i
=psnd_pcm_hw_params_set_buffer_size_near(data
->pcmHandle
, p
, &bufferSizeInFrames
)) < 0)
822 err
= "set buffer size near";
823 /* install and prepare hardware configuration */
824 if(i
>= 0 && (i
=psnd_pcm_hw_params(data
->pcmHandle
, p
)) < 0)
828 AL_PRINT("%s failed: %s\n", err
, psnd_strerror(i
));
829 psnd_pcm_hw_params_free(p
);
833 if((i
=psnd_pcm_hw_params_get_period_size(p
, &bufferSizeInFrames
, NULL
)) < 0)
835 AL_PRINT("get size failed: %s\n", psnd_strerror(i
));
836 psnd_pcm_hw_params_free(p
);
840 psnd_pcm_hw_params_free(p
);
842 frameSize
= aluChannelsFromFormat(pDevice
->Format
);
843 frameSize
*= aluBytesFromFormat(pDevice
->Format
);
845 data
->ring
= CreateRingBuffer(frameSize
, pDevice
->UpdateSize
*pDevice
->NumUpdates
);
848 AL_PRINT("ring buffer create failed\n");
852 data
->size
= psnd_pcm_frames_to_bytes(data
->pcmHandle
, bufferSizeInFrames
);
853 data
->buffer
= malloc(data
->size
);
856 AL_PRINT("buffer malloc failed\n");
860 pDevice
->ExtraData
= data
;
861 data
->thread
= StartThread(ALSANoMMapCaptureProc
, pDevice
);
862 if(data
->thread
== NULL
)
864 AL_PRINT("Could not create capture thread\n");
868 pDevice
->szDeviceName
= strdup(deviceName
);
873 DestroyRingBuffer(data
->ring
);
874 psnd_pcm_close(data
->pcmHandle
);
878 pDevice
->ExtraData
= NULL
;
882 static void alsa_close_capture(ALCdevice
*pDevice
)
884 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
887 StopThread(data
->thread
);
889 psnd_pcm_close(data
->pcmHandle
);
890 DestroyRingBuffer(data
->ring
);
894 pDevice
->ExtraData
= NULL
;
899 static void alsa_start_capture(ALCdevice
*pDevice
)
901 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
905 static void alsa_stop_capture(ALCdevice
*pDevice
)
907 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
911 static void alsa_capture_samples(ALCdevice
*pDevice
, ALCvoid
*pBuffer
, ALCuint lSamples
)
913 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
915 if(lSamples
<= (ALCuint
)RingBufferSize(data
->ring
))
916 ReadRingBuffer(data
->ring
, pBuffer
, lSamples
);
918 alcSetError(ALC_INVALID_VALUE
);
921 static ALCuint
alsa_available_samples(ALCdevice
*pDevice
)
923 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
924 return RingBufferSize(data
->ring
);
928 BackendFuncs alsa_funcs
= {
937 alsa_capture_samples
,
938 alsa_available_samples
941 void alc_alsa_init(BackendFuncs
*func_list
)
943 *func_list
= alsa_funcs
;
946 void alc_alsa_deinit(void)
950 for(i
= 0;i
< numDevNames
;++i
)
951 free(allDevNameMap
[i
].name
);
953 allDevNameMap
= NULL
;
956 for(i
= 0;i
< numCaptureDevNames
;++i
)
957 free(allCaptureDevNameMap
[i
].name
);
958 free(allCaptureDevNameMap
);
959 allCaptureDevNameMap
= NULL
;
960 numCaptureDevNames
= 0;
963 void alc_alsa_probe(int type
)
966 int card
, err
, dev
, idx
;
967 snd_ctl_card_info_t
*info
;
968 snd_pcm_info_t
*pcminfo
;
969 snd_pcm_stream_t stream
;
974 if(!alsa_handle
) return;
976 psnd_ctl_card_info_malloc(&info
);
977 psnd_pcm_info_malloc(&pcminfo
);
980 if((err
=psnd_card_next(&card
)) < 0)
981 AL_PRINT("Failed to find a card: %s\n", psnd_strerror(err
));
983 if(type
== DEVICE_PROBE
)
984 AppendDeviceList(alsaDevice
);
985 else if(type
== ALL_DEVICE_PROBE
)
987 stream
= SND_PCM_STREAM_PLAYBACK
;
989 for(i
= 0;i
< numDevNames
;++i
)
990 free(allDevNameMap
[i
].name
);
992 allDevNameMap
= realloc(allDevNameMap
, sizeof(DevMap
) * 1);
993 allDevNameMap
[0].name
= strdup("ALSA Software on default");
994 AppendAllDeviceList(allDevNameMap
[0].name
);
998 sprintf(name
, "hw:%d", card
);
999 if ((err
= psnd_ctl_open(&handle
, name
, 0)) < 0) {
1000 AL_PRINT("control open (%i): %s\n", card
, psnd_strerror(err
));
1003 if ((err
= psnd_ctl_card_info(handle
, info
)) < 0) {
1004 AL_PRINT("control hardware info (%i): %s\n", card
, psnd_strerror(err
));
1005 psnd_ctl_close(handle
);
1011 const char *cname
, *dname
;
1014 if (psnd_ctl_pcm_next_device(handle
, &dev
)<0)
1015 AL_PRINT("snd_ctl_pcm_next_device failed\n");
1019 psnd_pcm_info_set_device(pcminfo
, dev
);
1020 psnd_pcm_info_set_subdevice(pcminfo
, 0);
1021 psnd_pcm_info_set_stream(pcminfo
, stream
);
1022 if ((err
= psnd_ctl_pcm_info(handle
, pcminfo
)) < 0) {
1024 AL_PRINT("control digital audio info (%i): %s\n", card
, psnd_strerror(err
));
1028 temp
= realloc(allDevNameMap
, sizeof(DevMap
) * (idx
+1));
1031 allDevNameMap
= temp
;
1032 cname
= psnd_ctl_card_info_get_name(info
);
1033 dname
= psnd_pcm_info_get_name(pcminfo
);
1034 snprintf(name
, sizeof(name
), "ALSA Software on %s [%s] (hw:%d,%d)",
1035 cname
, dname
, card
, dev
);
1036 AppendAllDeviceList(name
);
1037 allDevNameMap
[idx
].name
= strdup(name
);
1038 allDevNameMap
[idx
].card
= card
;
1039 allDevNameMap
[idx
].dev
= dev
;
1043 psnd_ctl_close(handle
);
1045 if(psnd_card_next(&card
) < 0) {
1046 AL_PRINT("snd_card_next failed\n");
1052 else if(type
== CAPTURE_DEVICE_PROBE
)
1054 stream
= SND_PCM_STREAM_CAPTURE
;
1056 for(i
= 0;i
< numCaptureDevNames
;++i
)
1057 free(allCaptureDevNameMap
[i
].name
);
1059 allCaptureDevNameMap
= realloc(allCaptureDevNameMap
, sizeof(DevMap
) * 1);
1060 allCaptureDevNameMap
[0].name
= strdup("ALSA Capture on default");
1061 AppendCaptureDeviceList(allCaptureDevNameMap
[0].name
);
1065 sprintf(name
, "hw:%d", card
);
1067 if ((err
= psnd_ctl_open(&handle
, name
, 0)) < 0) {
1068 AL_PRINT("control open (%i): %s\n", card
, psnd_strerror(err
));
1070 if (err
>= 0 && (err
= psnd_ctl_card_info(handle
, info
)) < 0) {
1071 AL_PRINT("control hardware info (%i): %s\n", card
, psnd_strerror(err
));
1077 const char *cname
, *dname
;
1080 if (psnd_ctl_pcm_next_device(handle
, &dev
)<0)
1081 AL_PRINT("snd_ctl_pcm_next_device failed\n");
1084 psnd_pcm_info_set_device(pcminfo
, dev
);
1085 psnd_pcm_info_set_subdevice(pcminfo
, 0);
1086 psnd_pcm_info_set_stream(pcminfo
, stream
);
1087 if ((err
= psnd_ctl_pcm_info(handle
, pcminfo
)) < 0) {
1089 AL_PRINT("control digital audio info (%i): %s\n", card
, psnd_strerror(err
));
1093 temp
= realloc(allCaptureDevNameMap
, sizeof(DevMap
) * (idx
+1));
1096 allCaptureDevNameMap
= temp
;
1097 cname
= psnd_ctl_card_info_get_name(info
);
1098 dname
= psnd_pcm_info_get_name(pcminfo
);
1099 snprintf(name
, sizeof(name
), "ALSA Capture on %s [%s] (hw:%d,%d)",
1100 cname
, dname
, card
, dev
);
1101 AppendCaptureDeviceList(name
);
1102 allCaptureDevNameMap
[idx
].name
= strdup(name
);
1103 allCaptureDevNameMap
[idx
].card
= card
;
1104 allCaptureDevNameMap
[idx
].dev
= dev
;
1109 if(handle
) psnd_ctl_close(handle
);
1110 if(psnd_card_next(&card
) < 0) {
1111 AL_PRINT("snd_card_next failed\n");
1115 numCaptureDevNames
= idx
;
1118 psnd_pcm_info_free(pcminfo
);
1119 psnd_ctl_card_info_free(info
);