2 * Sample Wine Driver for Advanced Linux Sound System (ALSA)
3 * Based on version <final> of the ALSA API
5 * This file performs the initialisation and scanning of the sound subsystem.
7 * Copyright 2002 Eric Pouech
8 * 2002 Marco Pietrobono
9 * 2003 Christian Costa : WaveIn support
10 * 2006-2007 Maarten Lankhorst
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
28 #include "wine/port.h"
40 #ifdef HAVE_SYS_IOCTL_H
41 # include <sys/ioctl.h>
43 #ifdef HAVE_SYS_MMAN_H
44 # include <sys/mman.h>
55 /* ksmedia.h defines KSDATAFORMAT_SUBTYPE_PCM and KSDATAFORMAT_SUBTYPE_IEEE_FLOAT
56 * However either all files that use it will define it, or no files will
57 * The only way to solve this is by adding initguid.h here, and include the guid that way
62 #include "wine/library.h"
63 #include "wine/unicode.h"
64 #include "wine/debug.h"
66 WINE_DEFAULT_DEBUG_CHANNEL(wave
);
70 /*----------------------------------------------------------------------------
71 ** ALSA_TestDeviceForWine
73 ** Test to see if a given device is sufficient for Wine.
75 static int ALSA_TestDeviceForWine(int card
, int device
, snd_pcm_stream_t streamtype
)
77 snd_pcm_t
*pcm
= NULL
;
80 snd_pcm_hw_params_t
*hwparams
;
81 const char *reason
= NULL
;
84 /* Note that the plug: device masks out a lot of info, we want to avoid that */
85 sprintf(pcmname
, "hw:%d,%d", card
, device
);
86 retcode
= snd_pcm_open(&pcm
, pcmname
, streamtype
, SND_PCM_NONBLOCK
);
89 /* Note that a busy device isn't automatically disqualified */
90 if (retcode
== (-1 * EBUSY
))
95 snd_pcm_hw_params_alloca(&hwparams
);
97 retcode
= snd_pcm_hw_params_any(pcm
, hwparams
);
100 reason
= "Could not retrieve hw_params";
104 /* set the count of channels */
105 retcode
= snd_pcm_hw_params_set_channels(pcm
, hwparams
, 2);
108 reason
= "Could not set channels";
113 retcode
= snd_pcm_hw_params_set_rate_near(pcm
, hwparams
, &rrate
, 0);
116 reason
= "Could not set rate";
122 reason
= "Rate came back as 0";
126 /* write the parameters to device */
127 retcode
= snd_pcm_hw_params(pcm
, hwparams
);
130 reason
= "Could not set hwparams";
140 if (retcode
!= 0 && retcode
!= (-1 * ENOENT
))
141 TRACE("Discarding card %d/device %d: %s [%d(%s)]\n", card
, device
, reason
, retcode
, snd_strerror(retcode
));
146 /*----------------------------------------------------------------------------
148 ** Retrieve a string from a registry key
150 static int ALSA_RegGetString(HKEY key
, const char *value
, char **bufp
)
157 rc
= RegQueryValueExA(key
, value
, NULL
, &type
, NULL
, &bufsize
);
158 if (rc
!= ERROR_SUCCESS
)
164 *bufp
= HeapAlloc(GetProcessHeap(), 0, bufsize
);
168 rc
= RegQueryValueExA(key
, value
, NULL
, NULL
, (LPBYTE
)*bufp
, &bufsize
);
172 /*----------------------------------------------------------------------------
173 ** ALSA_RegGetBoolean
174 ** Get a string and interpret it as a boolean
178 Y(es), T(rue), 1, E(nabled) */
180 #define IS_OPTION_TRUE(ch) ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1' || (ch) == 'e' || (ch) == 'E')
181 static int ALSA_RegGetBoolean(HKEY key
, const char *value
, BOOL
*answer
)
186 rc
= ALSA_RegGetString(key
, value
, &buf
);
190 if (IS_OPTION_TRUE(*buf
))
193 HeapFree(GetProcessHeap(), 0, buf
);
199 /*----------------------------------------------------------------------------
200 ** ALSA_RegGetBoolean
201 ** Get a string and interpret it as a DWORD
203 static int ALSA_RegGetInt(HKEY key
, const char *value
, DWORD
*answer
)
208 rc
= ALSA_RegGetString(key
, value
, &buf
);
212 HeapFree(GetProcessHeap(), 0, buf
);
218 /* return a string duplicated on the win32 process heap, free with HeapFree */
219 static char* ALSA_strdup(const char *s
) {
220 char *result
= HeapAlloc(GetProcessHeap(), 0, strlen(s
)+1);
227 #define ALSA_RETURN_ONFAIL(mycall) \
233 ERR("%s failed: %s(%d)\n", #mycall, snd_strerror(rc), rc); \
238 /*----------------------------------------------------------------------------
241 ** Given an ALSA PCM, figure out our HW CAPS structure info.
242 ** ctl can be null, pcm is required, as is all output parms.
245 static int ALSA_ComputeCaps(snd_ctl_t
*ctl
, snd_pcm_t
*pcm
,
246 WORD
*channels
, DWORD
*flags
, DWORD
*formats
, DWORD
*supports
)
248 snd_pcm_hw_params_t
*hw_params
;
249 snd_pcm_format_mask_t
*fmask
;
250 snd_pcm_access_mask_t
*acmask
;
251 unsigned int ratemin
= 0;
252 unsigned int ratemax
= 0;
253 unsigned int chmin
= 0;
254 unsigned int chmax
= 0;
257 snd_pcm_hw_params_alloca(&hw_params
);
258 ALSA_RETURN_ONFAIL(snd_pcm_hw_params_any(pcm
, hw_params
));
260 snd_pcm_format_mask_alloca(&fmask
);
261 snd_pcm_hw_params_get_format_mask(hw_params
, fmask
);
263 snd_pcm_access_mask_alloca(&acmask
);
264 ALSA_RETURN_ONFAIL(snd_pcm_hw_params_get_access_mask(hw_params
, acmask
));
266 ALSA_RETURN_ONFAIL(snd_pcm_hw_params_get_rate_min(hw_params
, &ratemin
, &dir
));
267 ALSA_RETURN_ONFAIL(snd_pcm_hw_params_get_rate_max(hw_params
, &ratemax
, &dir
));
268 ALSA_RETURN_ONFAIL(snd_pcm_hw_params_get_channels_min(hw_params
, &chmin
));
269 ALSA_RETURN_ONFAIL(snd_pcm_hw_params_get_channels_max(hw_params
, &chmax
));
272 if ( (r) >= ratemin && ( (r) <= ratemax || ratemax == -1) ) \
274 if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_U8)) \
276 if (chmin <= 1 && 1 <= chmax) \
277 *formats |= WAVE_FORMAT_##v##M08; \
278 if (chmin <= 2 && 2 <= chmax) \
279 *formats |= WAVE_FORMAT_##v##S08; \
281 if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_S16_LE)) \
283 if (chmin <= 1 && 1 <= chmax) \
284 *formats |= WAVE_FORMAT_##v##M16; \
285 if (chmin <= 2 && 2 <= chmax) \
286 *formats |= WAVE_FORMAT_##v##S16; \
297 FIXME("Device has a minimum of %d channels\n", chmin
);
300 /* FIXME: is sample accurate always true ?
301 ** Can we do WAVECAPS_PITCH, WAVECAPS_SYNC, or WAVECAPS_PLAYBACKRATE? */
302 *supports
|= WAVECAPS_SAMPLEACCURATE
;
304 /* FIXME: NONITERLEAVED and COMPLEX are not supported right now */
305 if ( snd_pcm_access_mask_test( acmask
, SND_PCM_ACCESS_MMAP_INTERLEAVED
) )
306 *supports
|= WAVECAPS_DIRECTSOUND
;
308 /* check for volume control support */
310 if (snd_ctl_name(ctl
))
313 if (snd_hctl_open(&hctl
, snd_ctl_name(ctl
), 0) >= 0)
316 if (!ALSA_CheckSetVolume( hctl
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
))
318 *supports
|= WAVECAPS_VOLUME
;
319 if (chmin
<= 2 && 2 <= chmax
)
320 *supports
|= WAVECAPS_LRVOLUME
;
323 snd_hctl_close(hctl
);
328 *flags
= DSCAPS_CERTIFIED
| DSCAPS_CONTINUOUSRATE
;
329 *flags
|= DSCAPS_SECONDARYMONO
| DSCAPS_SECONDARYSTEREO
;
330 *flags
|= DSCAPS_SECONDARY8BIT
| DSCAPS_SECONDARY16BIT
;
332 if (*formats
& (WAVE_FORMAT_1M08
| WAVE_FORMAT_2M08
|
333 WAVE_FORMAT_4M08
| WAVE_FORMAT_48M08
|
334 WAVE_FORMAT_96M08
| WAVE_FORMAT_1M16
|
335 WAVE_FORMAT_2M16
| WAVE_FORMAT_4M16
|
336 WAVE_FORMAT_48M16
| WAVE_FORMAT_96M16
) )
337 *flags
|= DSCAPS_PRIMARYMONO
;
339 if (*formats
& (WAVE_FORMAT_1S08
| WAVE_FORMAT_2S08
|
340 WAVE_FORMAT_4S08
| WAVE_FORMAT_48S08
|
341 WAVE_FORMAT_96S08
| WAVE_FORMAT_1S16
|
342 WAVE_FORMAT_2S16
| WAVE_FORMAT_4S16
|
343 WAVE_FORMAT_48S16
| WAVE_FORMAT_96S16
) )
344 *flags
|= DSCAPS_PRIMARYSTEREO
;
346 if (*formats
& (WAVE_FORMAT_1M08
| WAVE_FORMAT_2M08
|
347 WAVE_FORMAT_4M08
| WAVE_FORMAT_48M08
|
348 WAVE_FORMAT_96M08
| WAVE_FORMAT_1S08
|
349 WAVE_FORMAT_2S08
| WAVE_FORMAT_4S08
|
350 WAVE_FORMAT_48S08
| WAVE_FORMAT_96S08
) )
351 *flags
|= DSCAPS_PRIMARY8BIT
;
353 if (*formats
& (WAVE_FORMAT_1M16
| WAVE_FORMAT_2M16
|
354 WAVE_FORMAT_4M16
| WAVE_FORMAT_48M16
|
355 WAVE_FORMAT_96M16
| WAVE_FORMAT_1S16
|
356 WAVE_FORMAT_2S16
| WAVE_FORMAT_4S16
|
357 WAVE_FORMAT_48S16
| WAVE_FORMAT_96S16
) )
358 *flags
|= DSCAPS_PRIMARY16BIT
;
363 /*----------------------------------------------------------------------------
364 ** ALSA_AddCommonDevice
366 ** Perform Alsa initialization common to both capture and playback
368 ** Side Effect: ww->pcname and ww->ctlname may need to be freed.
370 ** Note: this was originally coded by using snd_pcm_name(pcm), until
371 ** I discovered that with at least one version of alsa lib,
372 ** the use of a pcm named default:0 would cause snd_pcm_name() to fail.
373 ** So passing the name in is logically extraneous. Sigh.
375 static int ALSA_AddCommonDevice(snd_ctl_t
*ctl
, snd_pcm_t
*pcm
, const char *pcmname
, WINE_WAVEDEV
*ww
)
377 snd_pcm_info_t
*infop
;
379 snd_pcm_info_alloca(&infop
);
380 ALSA_RETURN_ONFAIL(snd_pcm_info(pcm
, infop
));
383 ww
->pcmname
= ALSA_strdup(pcmname
);
387 if (ctl
&& snd_ctl_name(ctl
))
388 ww
->ctlname
= ALSA_strdup(snd_ctl_name(ctl
));
390 strcpy(ww
->interface_name
, "winealsa: ");
391 memcpy(ww
->interface_name
+ strlen(ww
->interface_name
),
393 min(strlen(ww
->pcmname
), sizeof(ww
->interface_name
) - strlen("winealsa: ")));
395 strcpy(ww
->ds_desc
.szDrvname
, "winealsa.drv");
397 memcpy(ww
->ds_desc
.szDesc
, snd_pcm_info_get_name(infop
),
398 min( (sizeof(ww
->ds_desc
.szDesc
) - 1), strlen(snd_pcm_info_get_name(infop
))) );
400 ww
->ds_caps
.dwMinSecondarySampleRate
= DSBFREQUENCY_MIN
;
401 ww
->ds_caps
.dwMaxSecondarySampleRate
= DSBFREQUENCY_MAX
;
402 ww
->ds_caps
.dwPrimaryBuffers
= 1;
407 /*----------------------------------------------------------------------------
410 static void ALSA_FreeDevice(WINE_WAVEDEV
*ww
)
412 HeapFree(GetProcessHeap(), 0, ww
->pcmname
);
415 HeapFree(GetProcessHeap(), 0, ww
->ctlname
);
419 /*----------------------------------------------------------------------------
420 ** ALSA_AddDeviceToArray
422 ** Dynamically size one of the wavein or waveout arrays of devices,
423 ** and add a fully configured device node to the array.
426 static int ALSA_AddDeviceToArray(WINE_WAVEDEV
*ww
, WINE_WAVEDEV
**array
,
427 DWORD
*count
, DWORD
*alloced
, int isdefault
)
431 if (*count
>= *alloced
)
433 (*alloced
) += WAVEDEV_ALLOC_EXTENT_SIZE
;
435 *array
= HeapAlloc(GetProcessHeap(), 0, sizeof(*ww
) * (*alloced
));
437 *array
= HeapReAlloc(GetProcessHeap(), 0, *array
, sizeof(*ww
) * (*alloced
));
445 /* If this is the default, arrange for it to be the first element */
446 if (isdefault
&& i
> 0)
448 (*array
)[*count
] = (*array
)[0];
458 /*----------------------------------------------------------------------------
459 ** ALSA_AddPlaybackDevice
461 ** Add a given Alsa device to Wine's internal list of Playback
464 static int ALSA_AddPlaybackDevice(snd_ctl_t
*ctl
, snd_pcm_t
*pcm
, const char *pcmname
, int isdefault
)
469 memset(&wwo
, '\0', sizeof(wwo
));
471 rc
= ALSA_AddCommonDevice(ctl
, pcm
, pcmname
, &wwo
);
475 MultiByteToWideChar(CP_ACP
, 0, wwo
.ds_desc
.szDesc
, -1,
476 wwo
.outcaps
.szPname
, sizeof(wwo
.outcaps
.szPname
)/sizeof(WCHAR
));
477 wwo
.outcaps
.szPname
[sizeof(wwo
.outcaps
.szPname
)/sizeof(WCHAR
) - 1] = '\0';
479 wwo
.outcaps
.wMid
= MM_CREATIVE
;
480 wwo
.outcaps
.wPid
= MM_CREATIVE_SBP16_WAVEOUT
;
481 wwo
.outcaps
.vDriverVersion
= 0x0100;
483 rc
= ALSA_ComputeCaps(ctl
, pcm
, &wwo
.outcaps
.wChannels
, &wwo
.ds_caps
.dwFlags
,
484 &wwo
.outcaps
.dwFormats
, &wwo
.outcaps
.dwSupport
);
487 WARN("Error calculating device caps for pcm [%s]\n", wwo
.pcmname
);
488 ALSA_FreeDevice(&wwo
);
492 rc
= ALSA_AddDeviceToArray(&wwo
, &WOutDev
, &ALSA_WodNumDevs
, &ALSA_WodNumMallocedDevs
, isdefault
);
494 ALSA_FreeDevice(&wwo
);
498 /*----------------------------------------------------------------------------
499 ** ALSA_AddCaptureDevice
501 ** Add a given Alsa device to Wine's internal list of Capture
504 static int ALSA_AddCaptureDevice(snd_ctl_t
*ctl
, snd_pcm_t
*pcm
, const char *pcmname
, int isdefault
)
509 memset(&wwi
, '\0', sizeof(wwi
));
511 rc
= ALSA_AddCommonDevice(ctl
, pcm
, pcmname
, &wwi
);
515 MultiByteToWideChar(CP_ACP
, 0, wwi
.ds_desc
.szDesc
, -1,
516 wwi
.incaps
.szPname
, sizeof(wwi
.incaps
.szPname
) / sizeof(WCHAR
));
517 wwi
.incaps
.szPname
[sizeof(wwi
.incaps
.szPname
)/sizeof(WCHAR
) - 1] = '\0';
519 wwi
.incaps
.wMid
= MM_CREATIVE
;
520 wwi
.incaps
.wPid
= MM_CREATIVE_SBP16_WAVEOUT
;
521 wwi
.incaps
.vDriverVersion
= 0x0100;
523 rc
= ALSA_ComputeCaps(ctl
, pcm
, &wwi
.incaps
.wChannels
, &wwi
.ds_caps
.dwFlags
,
524 &wwi
.incaps
.dwFormats
, &wwi
.dwSupport
);
527 WARN("Error calculating device caps for pcm [%s]\n", wwi
.pcmname
);
528 ALSA_FreeDevice(&wwi
);
532 rc
= ALSA_AddDeviceToArray(&wwi
, &WInDev
, &ALSA_WidNumDevs
, &ALSA_WidNumMallocedDevs
, isdefault
);
534 ALSA_FreeDevice(&wwi
);
538 /*----------------------------------------------------------------------------
539 ** ALSA_CheckEnvironment
541 ** Given an Alsa style configuration node, scan its subitems
542 ** for environment variable names, and use them to find an override,
544 ** This is essentially a long and convolunted way of doing:
545 ** getenv("ALSA_CARD")
546 ** getenv("ALSA_CTL_CARD")
547 ** getenv("ALSA_PCM_CARD")
548 ** getenv("ALSA_PCM_DEVICE")
550 ** The output value is set with the atoi() of the first environment
551 ** variable found to be set, if any; otherwise, it is left alone
553 static void ALSA_CheckEnvironment(snd_config_t
*node
, int *outvalue
)
555 snd_config_iterator_t iter
;
557 for (iter
= snd_config_iterator_first(node
);
558 iter
!= snd_config_iterator_end(node
);
559 iter
= snd_config_iterator_next(iter
))
561 snd_config_t
*leaf
= snd_config_iterator_entry(iter
);
562 if (snd_config_get_type(leaf
) == SND_CONFIG_TYPE_STRING
)
565 if (snd_config_get_string(leaf
, &value
) >= 0)
567 char *p
= getenv(value
);
578 /*----------------------------------------------------------------------------
579 ** ALSA_DefaultDevices
581 ** Jump through Alsa style hoops to (hopefully) properly determine
582 ** Alsa defaults for CTL Card #, as well as for PCM Card + Device #.
583 ** We'll also find out if the user has set any of the environment
584 ** variables that specify we're to use a specific card or device.
587 ** directhw Whether to use a direct hardware device or not;
588 ** essentially switches the pcm device name from
589 ** one of 'default:X' or 'plughw:X' to "hw:X"
590 ** defctlcard If !NULL, will hold the ctl card number given
591 ** by the ALSA config as the default
592 ** defpcmcard If !NULL, default pcm card #
593 ** defpcmdev If !NULL, default pcm device #
594 ** fixedctlcard If !NULL, and the user set the appropriate
595 ** environment variable, we'll set to the
596 ** card the user specified.
597 ** fixedpcmcard If !NULL, and the user set the appropriate
598 ** environment variable, we'll set to the
599 ** card the user specified.
600 ** fixedpcmdev If !NULL, and the user set the appropriate
601 ** environment variable, we'll set to the
602 ** device the user specified.
604 ** Returns: 0 on success, < 0 on failiure
606 static int ALSA_DefaultDevices(int directhw
,
608 long *defpcmcard
, long *defpcmdev
,
610 int *fixedpcmcard
, int *fixedpcmdev
)
612 snd_config_t
*configp
;
615 ALSA_RETURN_ONFAIL(snd_config_update());
618 if (snd_config_search(snd_config
, "defaults.ctl.card", &configp
) >= 0)
619 snd_config_get_integer(configp
, defctlcard
);
622 if (snd_config_search(snd_config
, "defaults.pcm.card", &configp
) >= 0)
623 snd_config_get_integer(configp
, defpcmcard
);
626 if (snd_config_search(snd_config
, "defaults.pcm.device", &configp
) >= 0)
627 snd_config_get_integer(configp
, defpcmdev
);
632 if (snd_config_search(snd_config
, "ctl.hw.@args.CARD.default.vars", &configp
) >= 0)
633 ALSA_CheckEnvironment(configp
, fixedctlcard
);
638 sprintf(pcmsearch
, "pcm.%s.@args.CARD.default.vars", directhw
? "hw" : "plughw");
639 if (snd_config_search(snd_config
, pcmsearch
, &configp
) >= 0)
640 ALSA_CheckEnvironment(configp
, fixedpcmcard
);
645 sprintf(pcmsearch
, "pcm.%s.@args.DEV.default.vars", directhw
? "hw" : "plughw");
646 if (snd_config_search(snd_config
, pcmsearch
, &configp
) >= 0)
647 ALSA_CheckEnvironment(configp
, fixedpcmdev
);
654 /*----------------------------------------------------------------------------
657 ** Iterate through all discoverable ALSA cards, searching
658 ** for usable PCM devices.
661 ** directhw Whether to use a direct hardware device or not;
662 ** essentially switches the pcm device name from
663 ** one of 'default:X' or 'plughw:X' to "hw:X"
664 ** defctlcard Alsa's notion of the default ctl card.
665 ** defpcmcard . pcm card
666 ** defpcmdev . pcm device
667 ** fixedctlcard If not -1, then gives the value of ALSA_CTL_CARD
668 ** or equivalent environment variable
669 ** fixedpcmcard If not -1, then gives the value of ALSA_PCM_CARD
670 ** or equivalent environment variable
671 ** fixedpcmdev If not -1, then gives the value of ALSA_PCM_DEVICE
672 ** or equivalent environment variable
674 ** Returns: 0 on success, < 0 on failiure
676 static int ALSA_ScanDevices(int directhw
,
677 long defctlcard
, long defpcmcard
, long defpcmdev
,
678 int fixedctlcard
, int fixedpcmcard
, int fixedpcmdev
)
680 int card
= fixedpcmcard
;
681 int scan_devices
= (fixedpcmdev
== -1);
683 /*------------------------------------------------------------------------
684 ** Loop through all available cards
685 **----------------------------------------------------------------------*/
687 snd_card_next(&card
);
689 for (; card
!= -1; snd_card_next(&card
))
696 /*--------------------------------------------------------------------
697 ** Try to open a ctl handle; Wine doesn't absolutely require one,
698 ** but it does allow for volume control and for device scanning
699 **------------------------------------------------------------------*/
700 sprintf(ctlname
, "hw:%d", fixedctlcard
== -1 ? card
: fixedctlcard
);
701 rc
= snd_ctl_open(&ctl
, ctlname
, SND_CTL_NONBLOCK
);
705 WARN("Unable to open an alsa ctl for [%s] (pcm card %d): %s; not scanning devices\n",
706 ctlname
, card
, snd_strerror(rc
));
707 if (fixedpcmdev
== -1)
711 /*--------------------------------------------------------------------
712 ** Loop through all available devices on this card
713 **------------------------------------------------------------------*/
714 device
= fixedpcmdev
;
716 snd_ctl_pcm_next_device(ctl
, &device
);
718 for (; device
!= -1; snd_ctl_pcm_next_device(ctl
, &device
))
720 char defaultpcmname
[256];
721 char plugpcmname
[256];
723 char *pcmname
= NULL
;
726 sprintf(defaultpcmname
, "default:%d", card
);
727 sprintf(plugpcmname
, "plughw:%d,%d", card
, device
);
728 sprintf(hwpcmname
, "hw:%d,%d", card
, device
);
730 /*----------------------------------------------------------------
731 ** See if it's a valid playback device
732 **--------------------------------------------------------------*/
733 if (ALSA_TestDeviceForWine(card
, device
, SND_PCM_STREAM_PLAYBACK
) == 0)
735 /* If we can, try the default:X device name first */
736 if (! scan_devices
&& ! directhw
)
738 pcmname
= defaultpcmname
;
739 rc
= snd_pcm_open(&pcm
, pcmname
, SND_PCM_STREAM_PLAYBACK
, SND_PCM_NONBLOCK
);
746 pcmname
= directhw
? hwpcmname
: plugpcmname
;
747 rc
= snd_pcm_open(&pcm
, pcmname
, SND_PCM_STREAM_PLAYBACK
, SND_PCM_NONBLOCK
);
752 if (defctlcard
== card
&& defpcmcard
== card
&& defpcmdev
== device
)
753 ALSA_AddPlaybackDevice(ctl
, pcm
, pcmname
, TRUE
);
755 ALSA_AddPlaybackDevice(ctl
, pcm
, pcmname
, FALSE
);
760 TRACE("Device [%s/%s] failed to open for playback: %s\n",
761 directhw
|| scan_devices
? "(N/A)" : defaultpcmname
,
762 directhw
? hwpcmname
: plugpcmname
,
767 /*----------------------------------------------------------------
768 ** See if it's a valid capture device
769 **--------------------------------------------------------------*/
770 if (ALSA_TestDeviceForWine(card
, device
, SND_PCM_STREAM_CAPTURE
) == 0)
772 /* If we can, try the default:X device name first */
773 if (! scan_devices
&& ! directhw
)
775 pcmname
= defaultpcmname
;
776 rc
= snd_pcm_open(&pcm
, pcmname
, SND_PCM_STREAM_CAPTURE
, SND_PCM_NONBLOCK
);
783 pcmname
= directhw
? hwpcmname
: plugpcmname
;
784 rc
= snd_pcm_open(&pcm
, pcmname
, SND_PCM_STREAM_CAPTURE
, SND_PCM_NONBLOCK
);
789 if (defctlcard
== card
&& defpcmcard
== card
&& defpcmdev
== device
)
790 ALSA_AddCaptureDevice(ctl
, pcm
, pcmname
, TRUE
);
792 ALSA_AddCaptureDevice(ctl
, pcm
, pcmname
, FALSE
);
798 TRACE("Device [%s/%s] failed to open for capture: %s\n",
799 directhw
|| scan_devices
? "(N/A)" : defaultpcmname
,
800 directhw
? hwpcmname
: plugpcmname
,
812 /*--------------------------------------------------------------------
813 ** If the user has set env variables such that we're pegged to
814 ** a specific card, then break after we've examined it
815 **------------------------------------------------------------------*/
816 if (fixedpcmcard
!= -1)
824 /*----------------------------------------------------------------------------
825 ** ALSA_PerformDefaultScan
826 ** Perform the basic default scanning for devices within ALSA.
827 ** The hope is that this routine implements a 'correct'
828 ** scanning algorithm from the Alsalib point of view.
830 ** Note that Wine, overall, has other mechanisms to
831 ** override and specify exact CTL and PCM device names,
832 ** but this routine is imagined as the default that
833 ** 99% of users will use.
835 ** The basic algorithm is simple:
836 ** Use snd_card_next to iterate cards; within cards, use
837 ** snd_ctl_pcm_next_device to iterate through devices.
839 ** We add a little complexity by taking into consideration
840 ** environment variables such as ALSA_CARD (et all), and by
841 ** detecting when a given device matches the default specified
845 ** directhw If !0, indicates we should use the hw:X
846 ** PCM interface, rather than first try
847 ** the 'default' device followed by the plughw
848 ** device. (default and plughw do fancy mixing
849 ** and audio scaling, if they are available).
850 ** devscan If TRUE, we should scan all devices, not
851 ** juse use device 0 on each card
857 ** Invokes the ALSA_AddXXXDevice functions on valid
860 static int ALSA_PerformDefaultScan(int directhw
, BOOL devscan
)
862 long defctlcard
= -1, defpcmcard
= -1, defpcmdev
= -1;
863 int fixedctlcard
= -1, fixedpcmcard
= -1, fixedpcmdev
= -1;
866 /* FIXME: We should dlsym the new snd_names_list/snd_names_list_free 1.0.9 apis,
867 ** and use them instead of this scan mechanism if they are present */
869 rc
= ALSA_DefaultDevices(directhw
, &defctlcard
, &defpcmcard
, &defpcmdev
,
870 &fixedctlcard
, &fixedpcmcard
, &fixedpcmdev
);
874 if (fixedpcmdev
== -1 && ! devscan
)
877 return(ALSA_ScanDevices(directhw
, defctlcard
, defpcmcard
, defpcmdev
, fixedctlcard
, fixedpcmcard
, fixedpcmdev
));
881 /*----------------------------------------------------------------------------
882 ** ALSA_AddUserSpecifiedDevice
883 ** Add a device given from the registry
885 static int ALSA_AddUserSpecifiedDevice(const char *ctlname
, const char *pcmname
)
889 snd_ctl_t
*ctl
= NULL
;
890 snd_pcm_t
*pcm
= NULL
;
894 rc
= snd_ctl_open(&ctl
, ctlname
, SND_CTL_NONBLOCK
);
899 rc
= snd_pcm_open(&pcm
, pcmname
, SND_PCM_STREAM_PLAYBACK
, SND_PCM_NONBLOCK
);
902 ALSA_AddPlaybackDevice(ctl
, pcm
, pcmname
, FALSE
);
907 rc
= snd_pcm_open(&pcm
, pcmname
, SND_PCM_STREAM_CAPTURE
, SND_PCM_NONBLOCK
);
910 ALSA_AddCaptureDevice(ctl
, pcm
, pcmname
, FALSE
);
922 /*----------------------------------------------------------------------------
924 ** Initialize the Wine Alsa sub system.
925 ** The main task is to probe for and store a list of all appropriate playback
926 ** and capture devices.
927 ** Key control points are from the registry key:
928 ** [Software\Wine\Alsa Driver]
929 ** AutoScanCards Whether or not to scan all known sound cards
930 ** and add them to Wine's list (default yes)
931 ** AutoScanDevices Whether or not to scan all known PCM devices
932 ** on each card (default no)
933 ** UseDirectHW Whether or not to use the hw:X device,
934 ** instead of the fancy default:X or plughw:X device.
935 ** The hw:X device goes straight to the hardware
936 ** without any fancy mixing or audio scaling in between.
937 ** DeviceCount If present, specifies the number of hard coded
938 ** Alsa devices to add to Wine's list; default 0
939 ** DevicePCMn Specifies the Alsa PCM devices to open for
940 ** Device n (where n goes from 1 to DeviceCount)
941 ** DeviceCTLn Specifies the Alsa control devices to open for
942 ** Device n (where n goes from 1 to DeviceCount)
944 ** Using AutoScanCards no, and then Devicexxx info
945 ** is a way to exactly specify the devices used by Wine.
948 LONG
ALSA_WaveInit(void)
951 BOOL AutoScanCards
= TRUE
;
952 BOOL AutoScanDevices
= FALSE
;
953 BOOL UseDirectHW
= FALSE
;
954 DWORD DeviceCount
= 0;
958 if (!wine_dlopen("libasound.so.2", RTLD_LAZY
|RTLD_GLOBAL
, NULL
, 0))
960 ERR("Error: ALSA lib needs to be loaded with flags RTLD_LAZY and RTLD_GLOBAL.\n");
964 /* @@ Wine registry key: HKCU\Software\Wine\Alsa Driver */
965 rc
= RegOpenKeyExA(HKEY_CURRENT_USER
, "Software\\Wine\\Alsa Driver", 0, KEY_QUERY_VALUE
, &key
);
966 if (rc
== ERROR_SUCCESS
)
968 ALSA_RegGetBoolean(key
, "AutoScanCards", &AutoScanCards
);
969 ALSA_RegGetBoolean(key
, "AutoScanDevices", &AutoScanDevices
);
970 ALSA_RegGetBoolean(key
, "UseDirectHW", &UseDirectHW
);
971 ALSA_RegGetInt(key
, "DeviceCount", &DeviceCount
);
975 rc
= ALSA_PerformDefaultScan(UseDirectHW
, AutoScanDevices
);
977 for (i
= 0; i
< DeviceCount
; i
++)
979 char *ctl_name
= NULL
;
980 char *pcm_name
= NULL
;
983 sprintf(value
, "DevicePCM%d", i
+ 1);
984 if (ALSA_RegGetString(key
, value
, &pcm_name
) == ERROR_SUCCESS
)
986 sprintf(value
, "DeviceCTL%d", i
+ 1);
987 ALSA_RegGetString(key
, value
, &ctl_name
);
988 ALSA_AddUserSpecifiedDevice(ctl_name
, pcm_name
);
991 HeapFree(GetProcessHeap(), 0, ctl_name
);
992 HeapFree(GetProcessHeap(), 0, pcm_name
);
1001 #endif /* HAVE_ALSA */