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
;
52 static void *alsa_handle
;
53 #define MAKE_FUNC(f) static typeof(f) * p##f
54 MAKE_FUNC(snd_strerror
);
55 MAKE_FUNC(snd_pcm_open
);
56 MAKE_FUNC(snd_pcm_close
);
57 MAKE_FUNC(snd_pcm_nonblock
);
58 MAKE_FUNC(snd_pcm_frames_to_bytes
);
59 MAKE_FUNC(snd_pcm_hw_params_malloc
);
60 MAKE_FUNC(snd_pcm_hw_params_free
);
61 MAKE_FUNC(snd_pcm_hw_params_any
);
62 MAKE_FUNC(snd_pcm_hw_params_set_access
);
63 MAKE_FUNC(snd_pcm_hw_params_set_format
);
64 MAKE_FUNC(snd_pcm_hw_params_set_channels
);
65 MAKE_FUNC(snd_pcm_hw_params_set_periods_near
);
66 MAKE_FUNC(snd_pcm_hw_params_set_rate_near
);
67 MAKE_FUNC(snd_pcm_hw_params_set_rate
);
68 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_near
);
69 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_min
);
70 MAKE_FUNC(snd_pcm_hw_params_get_access
);
71 MAKE_FUNC(snd_pcm_hw_params
);
72 MAKE_FUNC(snd_pcm_prepare
);
73 MAKE_FUNC(snd_pcm_start
);
74 MAKE_FUNC(snd_pcm_resume
);
75 MAKE_FUNC(snd_pcm_state
);
76 MAKE_FUNC(snd_pcm_avail_update
);
77 MAKE_FUNC(snd_pcm_areas_silence
);
78 MAKE_FUNC(snd_pcm_mmap_begin
);
79 MAKE_FUNC(snd_pcm_mmap_commit
);
80 MAKE_FUNC(snd_pcm_writei
);
81 MAKE_FUNC(snd_pcm_drain
);
82 MAKE_FUNC(snd_pcm_info_malloc
);
83 MAKE_FUNC(snd_pcm_info_free
);
84 MAKE_FUNC(snd_pcm_info_set_device
);
85 MAKE_FUNC(snd_pcm_info_set_subdevice
);
86 MAKE_FUNC(snd_pcm_info_set_stream
);
87 MAKE_FUNC(snd_pcm_info_get_name
);
88 MAKE_FUNC(snd_ctl_pcm_next_device
);
89 MAKE_FUNC(snd_ctl_pcm_info
);
90 MAKE_FUNC(snd_ctl_open
);
91 MAKE_FUNC(snd_ctl_close
);
92 MAKE_FUNC(snd_ctl_card_info_malloc
);
93 MAKE_FUNC(snd_ctl_card_info_free
);
94 MAKE_FUNC(snd_ctl_card_info
);
95 MAKE_FUNC(snd_ctl_card_info_get_name
);
96 MAKE_FUNC(snd_card_next
);
99 #define MAX_DEVICES 16
100 #define MAX_ALL_DEVICES 32
102 static DevMap allDevNameMap
[MAX_ALL_DEVICES
];
103 static ALCchar
*alsaDeviceList
[MAX_DEVICES
];
104 static ALCchar
*alsaCaptureDeviceList
[MAX_DEVICES
];
106 static int xrun_recovery(snd_pcm_t
*handle
, int err
)
110 err
= psnd_pcm_prepare(handle
);
112 err
= psnd_pcm_start(handle
);
114 AL_PRINT("prepare failed: %s\n", psnd_strerror(err
));
116 else if (err
== -ESTRPIPE
)
118 while ((err
= psnd_pcm_resume(handle
)) == -EAGAIN
)
119 usleep(1); /* wait until the suspend flag is released */
122 err
= psnd_pcm_prepare(handle
);
124 err
= psnd_pcm_start(handle
);
126 AL_PRINT("prepare failed: %s\n", psnd_strerror(err
));
133 static ALuint
ALSAProc(ALvoid
*ptr
)
135 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
136 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
137 const snd_pcm_channel_area_t
*areas
= NULL
;
138 snd_pcm_sframes_t avail
, commitres
;
139 snd_pcm_uframes_t offset
, frames
;
144 while(!data
->killNow
)
146 snd_pcm_state_t state
= psnd_pcm_state(data
->pcmHandle
);
147 if(state
== SND_PCM_STATE_XRUN
)
149 err
= xrun_recovery(data
->pcmHandle
, -EPIPE
);
152 AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err
));
156 else if (state
== SND_PCM_STATE_SUSPENDED
)
158 err
= xrun_recovery(data
->pcmHandle
, -ESTRPIPE
);
161 AL_PRINT("SUSPEND recovery failed: %s\n", psnd_strerror(err
));
166 avail
= psnd_pcm_avail_update(data
->pcmHandle
);
169 err
= xrun_recovery(data
->pcmHandle
, avail
);
172 AL_PRINT("available update failed: %s\n", psnd_strerror(err
));
177 // make sure there's frames to process
184 // it is possible that contiguous areas are smaller, thus we use a loop
189 err
= psnd_pcm_mmap_begin(data
->pcmHandle
, &areas
, &offset
, &frames
);
192 err
= xrun_recovery(data
->pcmHandle
, err
);
194 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err
));
198 SuspendContext(NULL
);
199 WritePtr
= (char*)areas
->addr
+ (offset
* areas
->step
/ 8);
200 WriteCnt
= psnd_pcm_frames_to_bytes(data
->pcmHandle
, frames
);
201 aluMixData(pDevice
->Context
, WritePtr
, WriteCnt
, pDevice
->Format
);
202 ProcessContext(NULL
);
204 commitres
= psnd_pcm_mmap_commit(data
->pcmHandle
, offset
, frames
);
205 if (commitres
< 0 || (commitres
-frames
) != 0)
207 AL_PRINT("mmap commit error: %s\n",
208 psnd_strerror(commitres
>= 0 ? -EPIPE
: commitres
));
219 static ALuint
ALSANoMMapProc(ALvoid
*ptr
)
221 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
222 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
223 snd_pcm_sframes_t avail
;
227 while(!data
->killNow
)
229 snd_pcm_state_t state
= psnd_pcm_state(data
->pcmHandle
);
230 if(state
== SND_PCM_STATE_XRUN
)
232 err
= xrun_recovery(data
->pcmHandle
, -EPIPE
);
235 AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err
));
239 else if (state
== SND_PCM_STATE_SUSPENDED
)
241 err
= xrun_recovery(data
->pcmHandle
, -ESTRPIPE
);
244 AL_PRINT("SUSPEND recovery failed: %s\n", psnd_strerror(err
));
249 SuspendContext(NULL
);
250 aluMixData(pDevice
->Context
, data
->buffer
, data
->size
, pDevice
->Format
);
251 ProcessContext(NULL
);
253 WritePtr
= data
->buffer
;
254 avail
= (snd_pcm_uframes_t
)data
->size
/ psnd_pcm_frames_to_bytes(data
->pcmHandle
, 1);
257 int ret
= psnd_pcm_writei(data
->pcmHandle
, WritePtr
, avail
);
264 ret
= psnd_pcm_resume(data
->pcmHandle
);
265 } while(ret
== -EAGAIN
);
272 WritePtr
+= psnd_pcm_frames_to_bytes(data
->pcmHandle
, ret
);
279 ret
= psnd_pcm_prepare(data
->pcmHandle
);
289 static void fill_silence(snd_pcm_t
*pcmHandle
, snd_pcm_format_t alsaFormat
, int channels
)
291 const snd_pcm_channel_area_t
*areas
= NULL
;
292 snd_pcm_sframes_t avail
, commitres
;
293 snd_pcm_uframes_t offset
, frames
;
296 avail
= psnd_pcm_avail_update(pcmHandle
);
299 err
= xrun_recovery(pcmHandle
, avail
);
302 AL_PRINT("available update failed: %s\n", psnd_strerror(err
));
307 // it is possible that contiguous areas are smaller, thus we use a loop
312 err
= psnd_pcm_mmap_begin(pcmHandle
, &areas
, &offset
, &frames
);
315 err
= xrun_recovery(pcmHandle
, err
);
318 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err
));
324 psnd_pcm_areas_silence(areas
, offset
, channels
, frames
, alsaFormat
);
326 commitres
= psnd_pcm_mmap_commit(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
));
338 static ALCboolean
alsa_open_playback(ALCdevice
*device
, const ALCchar
*deviceName
)
340 snd_pcm_uframes_t bufferSizeInFrames
;
341 snd_pcm_hw_params_t
*p
= NULL
;
342 snd_pcm_access_t access
;
343 unsigned int periods
;
349 strncpy(driver
, GetConfigValue("alsa", "device", "default"), sizeof(driver
)-1);
350 driver
[sizeof(driver
)-1] = 0;
355 for(idx
= 0;idx
< MAX_ALL_DEVICES
;idx
++)
357 if(allDevNameMap
[idx
].name
&&
358 strcmp(deviceName
, allDevNameMap
[idx
].name
) == 0)
360 device
->szDeviceName
= allDevNameMap
[idx
].name
;
362 sprintf(driver
, "hw:%d,%d", allDevNameMap
[idx
].card
, allDevNameMap
[idx
].dev
);
366 for(idx
= 0;idx
< MAX_DEVICES
;idx
++)
368 if(alsaDeviceList
[idx
] &&
369 strcmp(deviceName
, alsaDeviceList
[idx
]) == 0)
371 device
->szDeviceName
= alsaDeviceList
[idx
];
373 sprintf(driver
, "hw:%zd,0", idx
-1);
380 device
->szDeviceName
= alsaDeviceList
[0];
383 data
= (alsa_data
*)calloc(1, sizeof(alsa_data
));
385 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_PLAYBACK
, SND_PCM_NONBLOCK
);
389 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_PLAYBACK
, SND_PCM_NONBLOCK
);
393 i
= psnd_pcm_nonblock(data
->pcmHandle
, 0);
395 psnd_pcm_close(data
->pcmHandle
);
400 AL_PRINT("Could not open playback device '%s': %s\n", driver
, psnd_strerror(i
));
404 switch(aluBytesFromFormat(device
->Format
))
407 data
->format
= SND_PCM_FORMAT_U8
;
410 data
->format
= SND_PCM_FORMAT_S16
;
413 data
->format
= SND_PCM_FORMAT_UNKNOWN
;
414 AL_PRINT("Unknown format?! %x\n", device
->Format
);
417 periods
= GetConfigValueInt("alsa", "periods", 4);
418 if((int)periods
<= 0)
420 bufferSizeInFrames
= device
->UpdateFreq
;
422 psnd_pcm_hw_params_malloc(&p
);
423 #define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
424 /* start with the largest configuration space possible */
425 if(!(ok(psnd_pcm_hw_params_any(data
->pcmHandle
, p
), "any") &&
426 /* set interleaved access */
427 (ok(psnd_pcm_hw_params_set_access(data
->pcmHandle
, p
, SND_PCM_ACCESS_MMAP_INTERLEAVED
), "set access") ||
428 ok(psnd_pcm_hw_params_set_access(data
->pcmHandle
, p
, SND_PCM_ACCESS_RW_INTERLEAVED
), "set access"))&&
429 /* set format (implicitly sets sample bits) */
430 ok(psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, data
->format
), "set format") &&
431 /* set channels (implicitly sets frame bits) */
432 ok(psnd_pcm_hw_params_set_channels(data
->pcmHandle
, p
, device
->Channels
), "set channels") &&
433 /* set periods (implicitly constrains period/buffer parameters) */
434 ok(psnd_pcm_hw_params_set_periods_near(data
->pcmHandle
, p
, &periods
, NULL
), "set periods near") &&
435 /* set rate (implicitly constrains period/buffer parameters) */
436 ok(psnd_pcm_hw_params_set_rate_near(data
->pcmHandle
, p
, &device
->Frequency
, NULL
), "set rate near") &&
437 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
438 ok(psnd_pcm_hw_params_set_buffer_size_near(data
->pcmHandle
, p
, &bufferSizeInFrames
), "set buffer size near") &&
439 /* install and prepare hardware configuration */
440 ok(psnd_pcm_hw_params(data
->pcmHandle
, p
), "set params")))
442 AL_PRINT("%s failed: %s\n", err
, psnd_strerror(i
));
443 psnd_pcm_hw_params_free(p
);
444 psnd_pcm_close(data
->pcmHandle
);
450 if((i
=psnd_pcm_hw_params_get_access(p
, &access
)) < 0)
452 AL_PRINT("get_access failed: %s\n", psnd_strerror(i
));
453 psnd_pcm_hw_params_free(p
);
454 psnd_pcm_close(data
->pcmHandle
);
459 psnd_pcm_hw_params_free(p
);
461 device
->MaxNoOfSources
= 256;
462 device
->UpdateFreq
= bufferSizeInFrames
;
464 i
= psnd_pcm_prepare(data
->pcmHandle
);
467 AL_PRINT("prepare error: %s\n", psnd_strerror(i
));
468 psnd_pcm_close(data
->pcmHandle
);
474 data
->size
= psnd_pcm_frames_to_bytes(data
->pcmHandle
, bufferSizeInFrames
);
475 if(access
== SND_PCM_ACCESS_RW_INTERLEAVED
)
477 data
->buffer
= malloc(data
->size
);
480 AL_PRINT("buffer malloc failed\n");
481 psnd_pcm_close(data
->pcmHandle
);
487 fill_silence(data
->pcmHandle
, data
->format
, device
->Channels
);
489 i
= psnd_pcm_start(data
->pcmHandle
);
492 AL_PRINT("start error: %s\n", psnd_strerror(i
));
493 psnd_pcm_close(data
->pcmHandle
);
499 device
->ExtraData
= data
;
500 if(access
== SND_PCM_ACCESS_RW_INTERLEAVED
)
501 data
->thread
= StartThread(ALSANoMMapProc
, device
);
503 data
->thread
= StartThread(ALSAProc
, device
);
504 if(data
->thread
== NULL
)
506 psnd_pcm_close(data
->pcmHandle
);
507 device
->ExtraData
= NULL
;
516 static void alsa_close_playback(ALCdevice
*device
)
518 alsa_data
*data
= (alsa_data
*)device
->ExtraData
;
520 StopThread(data
->thread
);
521 psnd_pcm_close(data
->pcmHandle
);
525 device
->ExtraData
= NULL
;
529 static ALCboolean
alsa_open_capture(ALCdevice
*pDevice
, const ALCchar
*deviceName
, ALCuint frequency
, ALCenum format
, ALCsizei SampleSize
)
531 snd_pcm_format_t alsaFormat
;
532 snd_pcm_hw_params_t
*p
;
533 unsigned int periods
= 4;
534 snd_pcm_uframes_t bufferSizeInFrames
= SampleSize
;
540 strncpy(driver
, GetConfigValue("alsa", "capture", "default"), sizeof(driver
)-1);
541 driver
[sizeof(driver
)-1] = 0;
546 for(idx
= 0;idx
< MAX_DEVICES
;idx
++)
548 if(alsaCaptureDeviceList
[idx
] &&
549 strcmp(deviceName
, alsaCaptureDeviceList
[idx
]) == 0)
551 pDevice
->szDeviceName
= alsaCaptureDeviceList
[idx
];
553 sprintf(driver
, "hw:%zd,0", idx
-1);
560 pDevice
->szDeviceName
= alsaCaptureDeviceList
[0];
563 data
= (alsa_data
*)calloc(1, sizeof(alsa_data
));
565 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_CAPTURE
, SND_PCM_NONBLOCK
);
569 i
= psnd_pcm_open(&data
->pcmHandle
, driver
, SND_PCM_STREAM_CAPTURE
, SND_PCM_NONBLOCK
);
573 i
= psnd_pcm_nonblock(data
->pcmHandle
, 0);
575 psnd_pcm_close(data
->pcmHandle
);
580 AL_PRINT("Could not open capture device '%s': %s\n", driver
, psnd_strerror(i
));
584 switch(aluBytesFromFormat(format
))
587 alsaFormat
= SND_PCM_FORMAT_U8
;
590 alsaFormat
= SND_PCM_FORMAT_S16
;
593 alsaFormat
= SND_PCM_FORMAT_UNKNOWN
;
594 AL_PRINT("Unknown format?! %x\n", format
);
597 psnd_pcm_hw_params_malloc(&p
);
598 #define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
599 /* start with the largest configuration space possible */
600 if(!(ok(psnd_pcm_hw_params_any(data
->pcmHandle
, p
), "any") &&
601 /* set interleaved access */
602 ok(psnd_pcm_hw_params_set_access(data
->pcmHandle
, p
, SND_PCM_ACCESS_MMAP_INTERLEAVED
), "set access") &&
603 /* set format (implicitly sets sample bits) */
604 ok(psnd_pcm_hw_params_set_format(data
->pcmHandle
, p
, alsaFormat
), "set format") &&
605 /* set channels (implicitly sets frame bits) */
606 ok(psnd_pcm_hw_params_set_channels(data
->pcmHandle
, p
, pDevice
->Channels
), "set channels") &&
607 /* set periods (implicitly constrains period/buffer parameters) */
608 ok(psnd_pcm_hw_params_set_periods_near(data
->pcmHandle
, p
, &periods
, NULL
), "set periods near") &&
609 /* set rate (implicitly constrains period/buffer parameters) */
610 ok(psnd_pcm_hw_params_set_rate(data
->pcmHandle
, p
, frequency
, 0), "set rate") &&
611 /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
612 ok(psnd_pcm_hw_params_set_buffer_size_min(data
->pcmHandle
, p
, &bufferSizeInFrames
), "set buffer size min") &&
613 /* install and prepare hardware configuration */
614 ok(psnd_pcm_hw_params(data
->pcmHandle
, p
), "set params")))
616 AL_PRINT("%s failed: %s\n", err
, psnd_strerror(i
));
617 psnd_pcm_hw_params_free(p
);
618 psnd_pcm_close(data
->pcmHandle
);
623 psnd_pcm_hw_params_free(p
);
625 i
= psnd_pcm_prepare(data
->pcmHandle
);
628 AL_PRINT("prepare error: %s\n", psnd_strerror(i
));
629 psnd_pcm_close(data
->pcmHandle
);
634 pDevice
->ExtraData
= data
;
638 static void alsa_close_capture(ALCdevice
*pDevice
)
640 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
641 psnd_pcm_close(data
->pcmHandle
);
644 pDevice
->ExtraData
= NULL
;
647 static void alsa_start_capture(ALCdevice
*pDevice
)
649 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
650 psnd_pcm_start(data
->pcmHandle
);
653 static void alsa_stop_capture(ALCdevice
*pDevice
)
655 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
656 psnd_pcm_drain(data
->pcmHandle
);
659 static void alsa_capture_samples(ALCdevice
*pDevice
, ALCvoid
*pBuffer
, ALCuint lSamples
)
661 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
662 const snd_pcm_channel_area_t
*areas
= NULL
;
663 snd_pcm_sframes_t frames
, commitres
;
664 snd_pcm_uframes_t size
, offset
;
667 frames
= psnd_pcm_avail_update(data
->pcmHandle
);
670 err
= xrun_recovery(data
->pcmHandle
, frames
);
672 AL_PRINT("available update failed: %s\n", psnd_strerror(err
));
674 frames
= psnd_pcm_avail_update(data
->pcmHandle
);
676 if (frames
< (snd_pcm_sframes_t
)lSamples
)
678 SetALCError(ALC_INVALID_VALUE
);
682 // it is possible that contiguous areas are smaller, thus we use a loop
689 err
= psnd_pcm_mmap_begin(data
->pcmHandle
, &areas
, &offset
, &size
);
692 err
= xrun_recovery(data
->pcmHandle
, err
);
695 AL_PRINT("mmap begin error: %s\n", psnd_strerror(err
));
701 Pointer
= (char*)areas
->addr
+ (offset
* areas
->step
/ 8);
702 Count
= size
* pDevice
->FrameSize
;
704 memcpy(pBuffer
, Pointer
, Count
);
705 pBuffer
= (char*)pBuffer
+ Count
;
707 commitres
= psnd_pcm_mmap_commit(data
->pcmHandle
, offset
, size
);
708 if (commitres
< 0 || (commitres
-size
) != 0)
710 AL_PRINT("mmap commit error: %s\n",
711 psnd_strerror(commitres
>= 0 ? -EPIPE
: commitres
));
719 static ALCuint
alsa_available_samples(ALCdevice
*pDevice
)
721 alsa_data
*data
= (alsa_data
*)pDevice
->ExtraData
;
722 snd_pcm_sframes_t frames
= psnd_pcm_avail_update(data
->pcmHandle
);
725 int err
= xrun_recovery(data
->pcmHandle
, frames
);
727 AL_PRINT("available update failed: %s\n", psnd_strerror(err
));
729 frames
= psnd_pcm_avail_update(data
->pcmHandle
);
730 if(frames
< 0) /* ew.. */
731 SetALCError(ALC_INVALID_DEVICE
);
733 return max(frames
, 0);
737 BackendFuncs alsa_funcs
= {
744 alsa_capture_samples
,
745 alsa_available_samples
748 void alc_alsa_init(BackendFuncs
*func_list
)
751 int card
, err
, dev
, idx
= 1;
752 snd_ctl_card_info_t
*info
;
753 snd_pcm_info_t
*pcminfo
;
754 snd_pcm_stream_t stream
= SND_PCM_STREAM_PLAYBACK
;
758 *func_list
= alsa_funcs
;
761 alsa_handle
= dlopen("libasound.so.2", RTLD_NOW
);
766 #define LOAD_FUNC(f) do { \
767 p##f = (typeof(f)*)dlsym(alsa_handle, #f); \
768 if((str=dlerror()) != NULL) \
770 dlclose(alsa_handle); \
771 alsa_handle = NULL; \
772 AL_PRINT("Could not load %s from libasound.so.2: %s\n", #f, str); \
779 #define LOAD_FUNC(f) p##f = f
782 LOAD_FUNC(snd_strerror
);
783 LOAD_FUNC(snd_pcm_open
);
784 LOAD_FUNC(snd_pcm_close
);
785 LOAD_FUNC(snd_pcm_nonblock
);
786 LOAD_FUNC(snd_pcm_frames_to_bytes
);
787 LOAD_FUNC(snd_pcm_hw_params_malloc
);
788 LOAD_FUNC(snd_pcm_hw_params_free
);
789 LOAD_FUNC(snd_pcm_hw_params_any
);
790 LOAD_FUNC(snd_pcm_hw_params_set_access
);
791 LOAD_FUNC(snd_pcm_hw_params_set_format
);
792 LOAD_FUNC(snd_pcm_hw_params_set_channels
);
793 LOAD_FUNC(snd_pcm_hw_params_set_periods_near
);
794 LOAD_FUNC(snd_pcm_hw_params_set_rate_near
);
795 LOAD_FUNC(snd_pcm_hw_params_set_rate
);
796 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near
);
797 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min
);
798 LOAD_FUNC(snd_pcm_hw_params_get_access
);
799 LOAD_FUNC(snd_pcm_hw_params
);
800 LOAD_FUNC(snd_pcm_prepare
);
801 LOAD_FUNC(snd_pcm_start
);
802 LOAD_FUNC(snd_pcm_resume
);
803 LOAD_FUNC(snd_pcm_state
);
804 LOAD_FUNC(snd_pcm_avail_update
);
805 LOAD_FUNC(snd_pcm_areas_silence
);
806 LOAD_FUNC(snd_pcm_mmap_begin
);
807 LOAD_FUNC(snd_pcm_mmap_commit
);
808 LOAD_FUNC(snd_pcm_writei
);
809 LOAD_FUNC(snd_pcm_drain
);
811 LOAD_FUNC(snd_pcm_info_malloc
);
812 LOAD_FUNC(snd_pcm_info_free
);
813 LOAD_FUNC(snd_pcm_info_set_device
);
814 LOAD_FUNC(snd_pcm_info_set_subdevice
);
815 LOAD_FUNC(snd_pcm_info_set_stream
);
816 LOAD_FUNC(snd_pcm_info_get_name
);
817 LOAD_FUNC(snd_ctl_pcm_next_device
);
818 LOAD_FUNC(snd_ctl_pcm_info
);
819 LOAD_FUNC(snd_ctl_open
);
820 LOAD_FUNC(snd_ctl_close
);
821 LOAD_FUNC(snd_ctl_card_info_malloc
);
822 LOAD_FUNC(snd_ctl_card_info_free
);
823 LOAD_FUNC(snd_ctl_card_info
);
824 LOAD_FUNC(snd_ctl_card_info_get_name
);
825 LOAD_FUNC(snd_card_next
);
829 psnd_ctl_card_info_malloc(&info
);
830 psnd_pcm_info_malloc(&pcminfo
);
833 if(psnd_card_next(&card
) < 0 || card
< 0)
834 AL_PRINT("no playback cards found...\n");
837 alsaDeviceList
[0] = AppendDeviceList("ALSA Software on default");
838 allDevNameMap
[0].name
= AppendAllDeviceList("ALSA Software on default");
842 sprintf(name
, "hw:%d", card
);
843 if ((err
= psnd_ctl_open(&handle
, name
, 0)) < 0) {
844 AL_PRINT("control open (%i): %s\n", card
, psnd_strerror(err
));
847 if ((err
= psnd_ctl_card_info(handle
, info
)) < 0) {
848 AL_PRINT("control hardware info (%i): %s\n", card
, psnd_strerror(err
));
849 psnd_ctl_close(handle
);
852 if(card
< MAX_DEVICES
-1) {
853 snprintf(name
, sizeof(name
), "ALSA Software on %s",
854 psnd_ctl_card_info_get_name(info
));
855 alsaDeviceList
[card
+1] = AppendDeviceList(name
);
859 while (idx
< MAX_ALL_DEVICES
) {
860 const char *cname
, *dname
;
862 if (psnd_ctl_pcm_next_device(handle
, &dev
)<0)
863 AL_PRINT("snd_ctl_pcm_next_device failed\n");
866 psnd_pcm_info_set_device(pcminfo
, dev
);
867 psnd_pcm_info_set_subdevice(pcminfo
, 0);
868 psnd_pcm_info_set_stream(pcminfo
, stream
);
869 if ((err
= psnd_ctl_pcm_info(handle
, pcminfo
)) < 0) {
871 AL_PRINT("control digital audio info (%i): %s\n", card
, psnd_strerror(err
));
875 cname
= psnd_ctl_card_info_get_name(info
);
876 dname
= psnd_pcm_info_get_name(pcminfo
);
877 snprintf(name
, sizeof(name
), "ALSA Software on %s [%s]",
879 allDevNameMap
[idx
].name
= AppendAllDeviceList(name
);
880 allDevNameMap
[idx
].card
= card
;
881 allDevNameMap
[idx
].dev
= dev
;
884 psnd_ctl_close(handle
);
886 if(psnd_card_next(&card
) < 0) {
887 AL_PRINT("snd_card_next failed\n");
893 stream
= SND_PCM_STREAM_CAPTURE
;
896 if(psnd_card_next(&card
) < 0 || card
< 0) {
897 AL_PRINT("no capture cards found...\n");
898 psnd_pcm_info_free(pcminfo
);
899 psnd_ctl_card_info_free(info
);
903 alsaCaptureDeviceList
[0] = AppendCaptureDeviceList("ALSA Capture on default");
906 sprintf(name
, "hw:%d", card
);
908 if ((err
= psnd_ctl_open(&handle
, name
, 0)) < 0) {
909 AL_PRINT("control open (%i): %s\n", card
, psnd_strerror(err
));
911 if (err
>= 0 && (err
= psnd_ctl_card_info(handle
, info
)) < 0) {
912 AL_PRINT("control hardware info (%i): %s\n", card
, psnd_strerror(err
));
913 psnd_ctl_close(handle
);
915 else if (err
>= 0 && card
< MAX_DEVICES
-1)
917 snprintf(name
, sizeof(name
), "ALSA Capture on %s",
918 psnd_ctl_card_info_get_name(info
));
919 alsaCaptureDeviceList
[card
+1] = AppendCaptureDeviceList(name
);
921 if(handle
) psnd_ctl_close(handle
);
922 if(psnd_card_next(&card
) < 0) {
923 AL_PRINT("snd_card_next failed\n");
927 psnd_pcm_info_free(pcminfo
);
928 psnd_ctl_card_info_free(info
);