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>
38 snd_pcm_format_t format
;
55 static void *alsa_handle
;
56 #define MAKE_FUNC(f) static typeof(f) * p##f
57 MAKE_FUNC(snd_strerror
);
58 MAKE_FUNC(snd_pcm_open
);
59 MAKE_FUNC(snd_pcm_close
);
60 MAKE_FUNC(snd_pcm_nonblock
);
61 MAKE_FUNC(snd_pcm_frames_to_bytes
);
62 MAKE_FUNC(snd_pcm_hw_params_malloc
);
63 MAKE_FUNC(snd_pcm_hw_params_free
);
64 MAKE_FUNC(snd_pcm_hw_params_any
);
65 MAKE_FUNC(snd_pcm_hw_params_set_access
);
66 MAKE_FUNC(snd_pcm_hw_params_set_format
);
67 MAKE_FUNC(snd_pcm_hw_params_set_channels
);
68 MAKE_FUNC(snd_pcm_hw_params_set_periods_near
);
69 MAKE_FUNC(snd_pcm_hw_params_set_rate_near
);
70 MAKE_FUNC(snd_pcm_hw_params_set_rate
);
71 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_near
);
72 MAKE_FUNC(snd_pcm_hw_params_set_period_size_near
);
73 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_min
);
74 MAKE_FUNC(snd_pcm_hw_params_get_buffer_size
);
75 MAKE_FUNC(snd_pcm_hw_params_get_period_size
);
76 MAKE_FUNC(snd_pcm_hw_params_get_access
);
77 MAKE_FUNC(snd_pcm_hw_params_get_periods
);
78 MAKE_FUNC(snd_pcm_hw_params
);
79 MAKE_FUNC(snd_pcm_sw_params_malloc
);
80 MAKE_FUNC(snd_pcm_sw_params_current
);
81 MAKE_FUNC(snd_pcm_sw_params_set_avail_min
);
82 MAKE_FUNC(snd_pcm_sw_params
);
83 MAKE_FUNC(snd_pcm_sw_params_free
);
84 MAKE_FUNC(snd_pcm_prepare
);
85 MAKE_FUNC(snd_pcm_start
);
86 MAKE_FUNC(snd_pcm_resume
);
87 MAKE_FUNC(snd_pcm_wait
);
88 MAKE_FUNC(snd_pcm_state
);
89 MAKE_FUNC(snd_pcm_avail_update
);
90 MAKE_FUNC(snd_pcm_areas_silence
);
91 MAKE_FUNC(snd_pcm_mmap_begin
);
92 MAKE_FUNC(snd_pcm_mmap_commit
);
93 MAKE_FUNC(snd_pcm_readi
);
94 MAKE_FUNC(snd_pcm_writei
);
95 MAKE_FUNC(snd_pcm_drain
);
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
);
114 static const ALCchar alsaDevice
[] = "ALSA Software";
115 static DevMap
*allDevNameMap
;
116 static ALuint numDevNames
;
117 static DevMap
*allCaptureDevNameMap
;
118 static ALuint numCaptureDevNames
;
121 static int xrun_recovery(snd_pcm_t
*handle
, int err
)
125 err
= psnd_pcm_prepare(handle
);
127 AL_PRINT("prepare failed: %s\n", psnd_strerror(err
));
129 else if (err
== -ESTRPIPE
)
131 while ((err
= psnd_pcm_resume(handle
)) == -EAGAIN
)
132 Sleep(1); /* wait until the suspend flag is released */
135 err
= psnd_pcm_prepare(handle
);
137 AL_PRINT("prepare failed: %s\n", psnd_strerror(err
));
143 static int verify_state(snd_pcm_t
*handle
)
145 snd_pcm_state_t state
= psnd_pcm_state(handle
);
146 if(state
== SND_PCM_STATE_DISCONNECTED
)
148 if(state
== SND_PCM_STATE_XRUN
)
150 int err
= xrun_recovery(handle
, -EPIPE
);
151 if(err
< 0) return err
;
153 else if(state
== SND_PCM_STATE_SUSPENDED
)
155 int err
= xrun_recovery(handle
, -ESTRPIPE
);
156 if(err
< 0) return err
;
163 static ALuint
ALSAProc(ALvoid
*ptr
)
165 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
166 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
167 const snd_pcm_channel_area_t
*areas
= NULL
;
168 snd_pcm_sframes_t avail
, commitres
;
169 snd_pcm_uframes_t offset
, frames
;
173 while(!data
->killNow
)
175 int state
= verify_state(data
->pcmHandle
);
178 AL_PRINT("Invalid state detected: %s\n", psnd_strerror(state
));
179 aluHandleDisconnect(pDevice
);
183 avail
= psnd_pcm_avail_update(data
->pcmHandle
);
186 AL_PRINT("available update failed: %s\n", psnd_strerror(avail
));
190 // make sure there's frames to process
191 if(avail
>= 0 && avail
< (snd_pcm_sframes_t
)pDevice
->UpdateSize
)
193 if(state
!= SND_PCM_STATE_RUNNING
)
195 err
= psnd_pcm_start(data
->pcmHandle
);
198 AL_PRINT("start failed: %s\n", psnd_strerror(err
));
202 if(psnd_pcm_wait(data
->pcmHandle
, 1000) == 0)
203 AL_PRINT("Wait timeout... buffer size too low?\n");
206 avail
-= avail
%pDevice
->UpdateSize
;
208 // it is possible that contiguous areas are smaller, thus we use a loop
213 err
= psnd_pcm_mmap_begin(data
->pcmHandle
, &areas
, &offset
, &frames
);
216 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err
));
220 WritePtr
= (char*)areas
->addr
+ (offset
* areas
->step
/ 8);
221 aluMixData(pDevice
, WritePtr
, frames
);
223 commitres
= psnd_pcm_mmap_commit(data
->pcmHandle
, offset
, frames
);
224 if(commitres
< 0 || (commitres
-frames
) != 0)
226 AL_PRINT("mmap commit error: %s\n",
227 psnd_strerror(commitres
>= 0 ? -EPIPE
: commitres
));
238 static ALuint
ALSANoMMapProc(ALvoid
*ptr
)
240 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
241 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
242 snd_pcm_sframes_t avail
;
245 while(!data
->killNow
)
247 int state
= verify_state(data
->pcmHandle
);
250 AL_PRINT("Invalid state detected: %s\n", psnd_strerror(state
));
251 aluHandleDisconnect(pDevice
);
255 WritePtr
= data
->buffer
;
256 avail
= data
->size
/ psnd_pcm_frames_to_bytes(data
->pcmHandle
, 1);
257 aluMixData(pDevice
, WritePtr
, avail
);
261 int ret
= psnd_pcm_writei(data
->pcmHandle
, WritePtr
, avail
);
267 while((ret
=psnd_pcm_resume(data
->pcmHandle
)) == -EAGAIN
)
275 WritePtr
+= psnd_pcm_frames_to_bytes(data
->pcmHandle
, ret
);
282 ret
= psnd_pcm_prepare(data
->pcmHandle
);
292 static ALuint
ALSANoMMapCaptureProc(ALvoid
*ptr
)
294 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
295 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
296 snd_pcm_sframes_t avail
;
298 while(!data
->killNow
)
300 int state
= verify_state(data
->pcmHandle
);
303 AL_PRINT("Invalid state detected: %s\n", psnd_strerror(state
));
304 aluHandleDisconnect(pDevice
);
308 avail
= (snd_pcm_uframes_t
)data
->size
/ psnd_pcm_frames_to_bytes(data
->pcmHandle
, 1);
309 avail
= psnd_pcm_readi(data
->pcmHandle
, data
->buffer
, avail
);
315 while((avail
=psnd_pcm_resume(data
->pcmHandle
)) == -EAGAIN
)
321 if (avail
>= 0 && data
->doCapture
)
322 WriteRingBuffer(data
->ring
, data
->buffer
, avail
);
327 avail
= psnd_pcm_prepare(data
->pcmHandle
);
329 AL_PRINT("prepare error: %s\n", psnd_strerror(avail
));
336 static ALCboolean
alsa_open_playback(ALCdevice
*device
, const ALCchar
*deviceName
)
345 strncpy(driver
, GetConfigValue("alsa", "device", "default"), sizeof(driver
)-1);
346 driver
[sizeof(driver
)-1] = 0;
348 deviceName
= alsaDevice
;
349 else if(strcmp(deviceName
, alsaDevice
) != 0)
353 for(idx
= 0;idx
< numDevNames
;idx
++)
355 if(allDevNameMap
[idx
].name
&&
356 strcmp(deviceName
, allDevNameMap
[idx
].name
) == 0)
359 sprintf(driver
, "hw:%d,%d", allDevNameMap
[idx
].card
, allDevNameMap
[idx
].dev
);
367 data
= (alsa_data
*)calloc(1, sizeof(alsa_data
));
369 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_PLAYBACK
, SND_PCM_NONBLOCK
);
373 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_PLAYBACK
, SND_PCM_NONBLOCK
);
377 i
= psnd_pcm_nonblock(data
->pcmHandle
, 0);
379 psnd_pcm_close(data
->pcmHandle
);
384 AL_PRINT("Could not open playback device '%s': %s\n", driver
, psnd_strerror(i
));
388 device
->szDeviceName
= strdup(deviceName
);
389 device
->ExtraData
= data
;
393 static void alsa_close_playback(ALCdevice
*device
)
395 alsa_data
*data
= (alsa_data
*)device
->ExtraData
;
397 psnd_pcm_close(data
->pcmHandle
);
399 device
->ExtraData
= NULL
;
402 static ALCboolean
alsa_reset_playback(ALCdevice
*device
)
404 alsa_data
*data
= (alsa_data
*)device
->ExtraData
;
405 snd_pcm_uframes_t periodSizeInFrames
;
406 snd_pcm_sw_params_t
*sp
= NULL
;
407 snd_pcm_hw_params_t
*p
= NULL
;
408 snd_pcm_access_t access
;
409 unsigned int periods
;
416 switch(aluBytesFromFormat(device
->Format
))
419 data
->format
= SND_PCM_FORMAT_U8
;
422 data
->format
= SND_PCM_FORMAT_S16
;
425 data
->format
= SND_PCM_FORMAT_FLOAT
;
428 AL_PRINT("Unknown format: 0x%x\n", device
->Format
);
432 allowmmap
= GetConfigValueBool("alsa", "mmap", 1);
433 periods
= device
->NumUpdates
;
434 periodSizeInFrames
= device
->UpdateSize
;
435 rate
= device
->Frequency
;
438 psnd_pcm_hw_params_malloc(&p
);
440 if((i
=psnd_pcm_hw_params_any(data
->pcmHandle
, p
)) < 0)
442 /* set interleaved access */
443 if(err
== NULL
&& (!allowmmap
|| (i
=psnd_pcm_hw_params_set_access(data
->pcmHandle
, p
, SND_PCM_ACCESS_MMAP_INTERLEAVED
)) < 0))
445 if(periods
> 2) periods
--;
446 if((i
=psnd_pcm_hw_params_set_access(data
->pcmHandle
, p
, SND_PCM_ACCESS_RW_INTERLEAVED
)) < 0)
449 /* set format (implicitly sets sample bits) */
450 if(err
== NULL
&& (i
=psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, data
->format
)) < 0)
452 /* set channels (implicitly sets frame bits) */
453 if(err
== NULL
&& (i
=psnd_pcm_hw_params_set_channels(data
->pcmHandle
, p
, aluChannelsFromFormat(device
->Format
))) < 0)
454 err
= "set channels";
455 /* set periods (implicitly constrains period/buffer parameters) */
456 if(err
== NULL
&& (i
=psnd_pcm_hw_params_set_periods_near(data
->pcmHandle
, p
, &periods
, NULL
)) < 0)
457 err
= "set periods near";
458 /* set rate (implicitly constrains period/buffer parameters) */
459 if(err
== NULL
&& (i
=psnd_pcm_hw_params_set_rate_near(data
->pcmHandle
, p
, &rate
, NULL
)) < 0)
460 err
= "set rate near";
461 /* set period size in frame units (implicitly sets buffer size/bytes/time and period time/bytes) */
462 if(err
== NULL
&& (i
=psnd_pcm_hw_params_set_period_size_near(data
->pcmHandle
, p
, &periodSizeInFrames
, NULL
)) < 0)
463 err
= "set period size near";
464 /* install and prepare hardware configuration */
465 if(err
== NULL
&& (i
=psnd_pcm_hw_params(data
->pcmHandle
, p
)) < 0)
467 if(err
== NULL
&& (i
=psnd_pcm_hw_params_get_access(p
, &access
)) < 0)
469 if(err
== NULL
&& (i
=psnd_pcm_hw_params_get_period_size(p
, &periodSizeInFrames
, NULL
)) < 0)
470 err
= "get period size";
471 if(err
== NULL
&& (i
=psnd_pcm_hw_params_get_periods(p
, &periods
, NULL
)) < 0)
475 AL_PRINT("%s failed: %s\n", err
, psnd_strerror(i
));
476 psnd_pcm_hw_params_free(p
);
480 psnd_pcm_hw_params_free(p
);
483 psnd_pcm_sw_params_malloc(&sp
);
485 if((i
=psnd_pcm_sw_params_current(data
->pcmHandle
, sp
)) != 0)
487 if(err
== NULL
&& (i
=psnd_pcm_sw_params_set_avail_min(data
->pcmHandle
, sp
, periodSizeInFrames
)) != 0)
488 err
= "sw set avail min";
489 if(err
== NULL
&& (i
=psnd_pcm_sw_params(data
->pcmHandle
, sp
)) != 0)
490 err
= "sw set params";
493 AL_PRINT("%s failed: %s\n", err
, psnd_strerror(i
));
494 psnd_pcm_sw_params_free(sp
);
498 psnd_pcm_sw_params_free(sp
);
500 data
->size
= psnd_pcm_frames_to_bytes(data
->pcmHandle
, periodSizeInFrames
);
501 if(access
== SND_PCM_ACCESS_RW_INTERLEAVED
)
503 /* Increase periods by one, since the temp buffer counts as an extra
506 data
->buffer
= malloc(data
->size
);
509 AL_PRINT("buffer malloc failed\n");
512 data
->thread
= StartThread(ALSANoMMapProc
, device
);
516 i
= psnd_pcm_prepare(data
->pcmHandle
);
519 AL_PRINT("prepare error: %s\n", psnd_strerror(i
));
524 data
->thread
= StartThread(ALSAProc
, device
);
526 if(data
->thread
== NULL
)
528 AL_PRINT("Could not create playback thread\n");
534 device
->UpdateSize
= periodSizeInFrames
;
535 device
->NumUpdates
= periods
;
536 device
->Frequency
= rate
;
541 static void alsa_stop_playback(ALCdevice
*device
)
543 alsa_data
*data
= (alsa_data
*)device
->ExtraData
;
549 StopThread(data
->thread
);
557 static ALCboolean
alsa_open_capture(ALCdevice
*pDevice
, const ALCchar
*deviceName
)
560 snd_pcm_hw_params_t
*p
;
561 snd_pcm_uframes_t bufferSizeInFrames
;
571 strncpy(driver
, GetConfigValue("alsa", "capture", "default"), sizeof(driver
)-1);
572 driver
[sizeof(driver
)-1] = 0;
574 deviceName
= allCaptureDevNameMap
[0].name
;
579 for(idx
= 0;idx
< numCaptureDevNames
;idx
++)
581 if(allCaptureDevNameMap
[idx
].name
&&
582 strcmp(deviceName
, allCaptureDevNameMap
[idx
].name
) == 0)
584 devName
= allCaptureDevNameMap
[idx
].name
;
586 sprintf(driver
, "plughw:%d,%d", allCaptureDevNameMap
[idx
].card
, allCaptureDevNameMap
[idx
].dev
);
594 data
= (alsa_data
*)calloc(1, sizeof(alsa_data
));
596 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_CAPTURE
, SND_PCM_NONBLOCK
);
600 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_CAPTURE
, SND_PCM_NONBLOCK
);
604 i
= psnd_pcm_nonblock(data
->pcmHandle
, 0);
606 psnd_pcm_close(data
->pcmHandle
);
611 AL_PRINT("Could not open capture device '%s': %s\n", driver
, psnd_strerror(i
));
615 switch(aluBytesFromFormat(pDevice
->Format
))
618 data
->format
= SND_PCM_FORMAT_U8
;
621 data
->format
= SND_PCM_FORMAT_S16
;
624 data
->format
= SND_PCM_FORMAT_FLOAT
;
627 AL_PRINT("Unknown format: 0x%x\n", pDevice
->Format
);
628 psnd_pcm_close(data
->pcmHandle
);
634 bufferSizeInFrames
= pDevice
->UpdateSize
* pDevice
->NumUpdates
;
635 psnd_pcm_hw_params_malloc(&p
);
637 if((i
=psnd_pcm_hw_params_any(data
->pcmHandle
, p
)) < 0)
639 /* set interleaved access */
640 if(err
== NULL
&& (i
=psnd_pcm_hw_params_set_access(data
->pcmHandle
, p
, SND_PCM_ACCESS_RW_INTERLEAVED
)) < 0)
642 /* set format (implicitly sets sample bits) */
643 if(err
== NULL
&& (i
=psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, data
->format
)) < 0)
645 /* set channels (implicitly sets frame bits) */
646 if(err
== NULL
&& (i
=psnd_pcm_hw_params_set_channels(data
->pcmHandle
, p
, aluChannelsFromFormat(pDevice
->Format
))) < 0)
647 err
= "set channels";
648 /* set rate (implicitly constrains period/buffer parameters) */
649 if(err
== NULL
&& (i
=psnd_pcm_hw_params_set_rate(data
->pcmHandle
, p
, pDevice
->Frequency
, 0)) < 0)
650 err
= "set rate near";
651 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
652 if(err
== NULL
&& (i
=psnd_pcm_hw_params_set_buffer_size_near(data
->pcmHandle
, p
, &bufferSizeInFrames
)) < 0)
653 err
= "set buffer size near";
654 /* install and prepare hardware configuration */
655 if(err
== NULL
&& (i
=psnd_pcm_hw_params(data
->pcmHandle
, p
)) < 0)
659 AL_PRINT("%s failed: %s\n", err
, psnd_strerror(i
));
660 psnd_pcm_hw_params_free(p
);
661 psnd_pcm_close(data
->pcmHandle
);
666 if((i
=psnd_pcm_hw_params_get_period_size(p
, &bufferSizeInFrames
, NULL
)) < 0)
668 AL_PRINT("get size failed: %s\n", psnd_strerror(i
));
669 psnd_pcm_hw_params_free(p
);
670 psnd_pcm_close(data
->pcmHandle
);
675 psnd_pcm_hw_params_free(p
);
677 frameSize
= aluChannelsFromFormat(pDevice
->Format
);
678 frameSize
*= aluBytesFromFormat(pDevice
->Format
);
680 data
->ring
= CreateRingBuffer(frameSize
, pDevice
->UpdateSize
*pDevice
->NumUpdates
);
683 AL_PRINT("ring buffer create failed\n");
684 psnd_pcm_close(data
->pcmHandle
);
689 data
->size
= psnd_pcm_frames_to_bytes(data
->pcmHandle
, bufferSizeInFrames
);
690 data
->buffer
= malloc(data
->size
);
693 AL_PRINT("buffer malloc failed\n");
694 psnd_pcm_close(data
->pcmHandle
);
695 DestroyRingBuffer(data
->ring
);
700 pDevice
->ExtraData
= data
;
701 data
->thread
= StartThread(ALSANoMMapCaptureProc
, pDevice
);
702 if(data
->thread
== NULL
)
704 AL_PRINT("Could not create capture thread\n");
705 psnd_pcm_close(data
->pcmHandle
);
706 DestroyRingBuffer(data
->ring
);
707 pDevice
->ExtraData
= NULL
;
713 pDevice
->szDeviceName
= strdup(deviceName
);
717 static void alsa_close_capture(ALCdevice
*pDevice
)
719 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
722 StopThread(data
->thread
);
724 psnd_pcm_close(data
->pcmHandle
);
725 DestroyRingBuffer(data
->ring
);
729 pDevice
->ExtraData
= NULL
;
732 static void alsa_start_capture(ALCdevice
*pDevice
)
734 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
738 static void alsa_stop_capture(ALCdevice
*pDevice
)
740 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
744 static void alsa_capture_samples(ALCdevice
*pDevice
, ALCvoid
*pBuffer
, ALCuint lSamples
)
746 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
748 if(lSamples
<= (ALCuint
)RingBufferSize(data
->ring
))
749 ReadRingBuffer(data
->ring
, pBuffer
, lSamples
);
751 SetALCError(ALC_INVALID_VALUE
);
754 static ALCuint
alsa_available_samples(ALCdevice
*pDevice
)
756 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
757 return RingBufferSize(data
->ring
);
761 BackendFuncs alsa_funcs
= {
770 alsa_capture_samples
,
771 alsa_available_samples
774 void alc_alsa_init(BackendFuncs
*func_list
)
778 if(func_list
) *func_list
= alsa_funcs
;
781 alsa_handle
= dlopen("libasound.so.2", RTLD_NOW
);
786 #define LOAD_FUNC(f) do { \
787 p##f = (typeof(f)*)dlsym(alsa_handle, #f); \
788 if((str=dlerror()) != NULL) \
790 dlclose(alsa_handle); \
791 alsa_handle = NULL; \
792 AL_PRINT("Could not load %s from libasound.so.2: %s\n", #f, str); \
798 alsa_handle
= (void*)0xDEADBEEF;
799 #define LOAD_FUNC(f) p##f = f
802 LOAD_FUNC(snd_strerror
);
803 LOAD_FUNC(snd_pcm_open
);
804 LOAD_FUNC(snd_pcm_close
);
805 LOAD_FUNC(snd_pcm_nonblock
);
806 LOAD_FUNC(snd_pcm_frames_to_bytes
);
807 LOAD_FUNC(snd_pcm_hw_params_malloc
);
808 LOAD_FUNC(snd_pcm_hw_params_free
);
809 LOAD_FUNC(snd_pcm_hw_params_any
);
810 LOAD_FUNC(snd_pcm_hw_params_set_access
);
811 LOAD_FUNC(snd_pcm_hw_params_set_format
);
812 LOAD_FUNC(snd_pcm_hw_params_set_channels
);
813 LOAD_FUNC(snd_pcm_hw_params_set_periods_near
);
814 LOAD_FUNC(snd_pcm_hw_params_set_rate_near
);
815 LOAD_FUNC(snd_pcm_hw_params_set_rate
);
816 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near
);
817 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min
);
818 LOAD_FUNC(snd_pcm_hw_params_set_period_size_near
);
819 LOAD_FUNC(snd_pcm_hw_params_get_buffer_size
);
820 LOAD_FUNC(snd_pcm_hw_params_get_period_size
);
821 LOAD_FUNC(snd_pcm_hw_params_get_access
);
822 LOAD_FUNC(snd_pcm_hw_params_get_periods
);
823 LOAD_FUNC(snd_pcm_hw_params
);
824 LOAD_FUNC(snd_pcm_sw_params_malloc
);
825 LOAD_FUNC(snd_pcm_sw_params_current
);
826 LOAD_FUNC(snd_pcm_sw_params_set_avail_min
);
827 LOAD_FUNC(snd_pcm_sw_params
);
828 LOAD_FUNC(snd_pcm_sw_params_free
);
829 LOAD_FUNC(snd_pcm_prepare
);
830 LOAD_FUNC(snd_pcm_start
);
831 LOAD_FUNC(snd_pcm_resume
);
832 LOAD_FUNC(snd_pcm_wait
);
833 LOAD_FUNC(snd_pcm_state
);
834 LOAD_FUNC(snd_pcm_avail_update
);
835 LOAD_FUNC(snd_pcm_areas_silence
);
836 LOAD_FUNC(snd_pcm_mmap_begin
);
837 LOAD_FUNC(snd_pcm_mmap_commit
);
838 LOAD_FUNC(snd_pcm_readi
);
839 LOAD_FUNC(snd_pcm_writei
);
840 LOAD_FUNC(snd_pcm_drain
);
842 LOAD_FUNC(snd_pcm_info_malloc
);
843 LOAD_FUNC(snd_pcm_info_free
);
844 LOAD_FUNC(snd_pcm_info_set_device
);
845 LOAD_FUNC(snd_pcm_info_set_subdevice
);
846 LOAD_FUNC(snd_pcm_info_set_stream
);
847 LOAD_FUNC(snd_pcm_info_get_name
);
848 LOAD_FUNC(snd_ctl_pcm_next_device
);
849 LOAD_FUNC(snd_ctl_pcm_info
);
850 LOAD_FUNC(snd_ctl_open
);
851 LOAD_FUNC(snd_ctl_close
);
852 LOAD_FUNC(snd_ctl_card_info_malloc
);
853 LOAD_FUNC(snd_ctl_card_info_free
);
854 LOAD_FUNC(snd_ctl_card_info
);
855 LOAD_FUNC(snd_ctl_card_info_get_name
);
856 LOAD_FUNC(snd_card_next
);
861 void alc_alsa_deinit(void)
865 for(i
= 0;i
< numDevNames
;++i
)
866 free(allDevNameMap
[i
].name
);
868 allDevNameMap
= NULL
;
871 for(i
= 0;i
< numCaptureDevNames
;++i
)
872 free(allCaptureDevNameMap
[i
].name
);
873 free(allCaptureDevNameMap
);
874 allCaptureDevNameMap
= NULL
;
875 numCaptureDevNames
= 0;
879 dlclose(alsa_handle
);
884 void alc_alsa_probe(int type
)
887 int card
, err
, dev
, idx
;
888 snd_ctl_card_info_t
*info
;
889 snd_pcm_info_t
*pcminfo
;
890 snd_pcm_stream_t stream
;
894 if(!alsa_handle
) alc_alsa_init(NULL
);
895 if(!alsa_handle
) return;
897 psnd_ctl_card_info_malloc(&info
);
898 psnd_pcm_info_malloc(&pcminfo
);
900 if(type
== DEVICE_PROBE
)
901 AppendDeviceList(alsaDevice
);
902 else if(type
== ALL_DEVICE_PROBE
)
904 stream
= SND_PCM_STREAM_PLAYBACK
;
906 if(psnd_card_next(&card
) < 0 || card
< 0) {
907 AL_PRINT("no playback cards found...\n");
908 psnd_pcm_info_free(pcminfo
);
909 psnd_ctl_card_info_free(info
);
913 for(i
= 0;i
< numDevNames
;++i
)
914 free(allDevNameMap
[i
].name
);
916 allDevNameMap
= realloc(allDevNameMap
, sizeof(DevMap
) * 1);
917 allDevNameMap
[0].name
= strdup("ALSA Software on default");
918 AppendAllDeviceList(allDevNameMap
[0].name
);
922 sprintf(name
, "hw:%d", card
);
923 if ((err
= psnd_ctl_open(&handle
, name
, 0)) < 0) {
924 AL_PRINT("control open (%i): %s\n", card
, psnd_strerror(err
));
927 if ((err
= psnd_ctl_card_info(handle
, info
)) < 0) {
928 AL_PRINT("control hardware info (%i): %s\n", card
, psnd_strerror(err
));
929 psnd_ctl_close(handle
);
935 const char *cname
, *dname
;
938 if (psnd_ctl_pcm_next_device(handle
, &dev
)<0)
939 AL_PRINT("snd_ctl_pcm_next_device failed\n");
943 psnd_pcm_info_set_device(pcminfo
, dev
);
944 psnd_pcm_info_set_subdevice(pcminfo
, 0);
945 psnd_pcm_info_set_stream(pcminfo
, stream
);
946 if ((err
= psnd_ctl_pcm_info(handle
, pcminfo
)) < 0) {
948 AL_PRINT("control digital audio info (%i): %s\n", card
, psnd_strerror(err
));
952 temp
= realloc(allDevNameMap
, sizeof(DevMap
) * (idx
+1));
955 allDevNameMap
= temp
;
956 cname
= psnd_ctl_card_info_get_name(info
);
957 dname
= psnd_pcm_info_get_name(pcminfo
);
958 snprintf(name
, sizeof(name
), "ALSA Software on %s [%s] (hw:%d,%d)",
959 cname
, dname
, card
, dev
);
960 AppendAllDeviceList(name
);
961 allDevNameMap
[idx
].name
= strdup(name
);
962 allDevNameMap
[idx
].card
= card
;
963 allDevNameMap
[idx
].dev
= dev
;
967 psnd_ctl_close(handle
);
969 if(psnd_card_next(&card
) < 0) {
970 AL_PRINT("snd_card_next failed\n");
976 else if(type
== CAPTURE_DEVICE_PROBE
)
978 stream
= SND_PCM_STREAM_CAPTURE
;
980 if(psnd_card_next(&card
) < 0 || card
< 0) {
981 AL_PRINT("no capture cards found...\n");
982 psnd_pcm_info_free(pcminfo
);
983 psnd_ctl_card_info_free(info
);
987 for(i
= 0;i
< numCaptureDevNames
;++i
)
988 free(allCaptureDevNameMap
[i
].name
);
990 allCaptureDevNameMap
= realloc(allCaptureDevNameMap
, sizeof(DevMap
) * 1);
991 allCaptureDevNameMap
[0].name
= strdup("ALSA Capture on default");
992 AppendCaptureDeviceList(allCaptureDevNameMap
[0].name
);
996 sprintf(name
, "hw:%d", card
);
998 if ((err
= psnd_ctl_open(&handle
, name
, 0)) < 0) {
999 AL_PRINT("control open (%i): %s\n", card
, psnd_strerror(err
));
1001 if (err
>= 0 && (err
= psnd_ctl_card_info(handle
, info
)) < 0) {
1002 AL_PRINT("control hardware info (%i): %s\n", card
, psnd_strerror(err
));
1008 const char *cname
, *dname
;
1011 if (psnd_ctl_pcm_next_device(handle
, &dev
)<0)
1012 AL_PRINT("snd_ctl_pcm_next_device failed\n");
1015 psnd_pcm_info_set_device(pcminfo
, dev
);
1016 psnd_pcm_info_set_subdevice(pcminfo
, 0);
1017 psnd_pcm_info_set_stream(pcminfo
, stream
);
1018 if ((err
= psnd_ctl_pcm_info(handle
, pcminfo
)) < 0) {
1020 AL_PRINT("control digital audio info (%i): %s\n", card
, psnd_strerror(err
));
1024 temp
= realloc(allCaptureDevNameMap
, sizeof(DevMap
) * (idx
+1));
1027 allCaptureDevNameMap
= temp
;
1028 cname
= psnd_ctl_card_info_get_name(info
);
1029 dname
= psnd_pcm_info_get_name(pcminfo
);
1030 snprintf(name
, sizeof(name
), "ALSA Capture on %s [%s] (hw:%d,%d)",
1031 cname
, dname
, card
, dev
);
1032 AppendCaptureDeviceList(name
);
1033 allCaptureDevNameMap
[idx
].name
= strdup(name
);
1034 allCaptureDevNameMap
[idx
].card
= card
;
1035 allCaptureDevNameMap
[idx
].dev
= dev
;
1040 if(handle
) psnd_ctl_close(handle
);
1041 if(psnd_card_next(&card
) < 0) {
1042 AL_PRINT("snd_card_next failed\n");
1046 numCaptureDevNames
= idx
;
1049 psnd_pcm_info_free(pcminfo
);
1050 psnd_ctl_card_info_free(info
);