richedit: Avoid rewrapping all text for isolated format changes.
[wine] / dlls / winealsa.drv / waveinit.c
1 /*
2  * Sample Wine Driver for Advanced Linux Sound System (ALSA)
3  *      Based on version <final> of the ALSA API
4  *
5  * This file performs the initialisation and scanning of the sound subsystem.
6  *
7  * Copyright    2002 Eric Pouech
8  *              2002 Marco Pietrobono
9  *              2003 Christian Costa : WaveIn support
10  *              2006-2007 Maarten Lankhorst
11  *
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.
16  *
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.
21  *
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
25  */
26
27 #include "config.h"
28
29 #ifdef HAVE_ALSA
30
31 #include "wine/port.h"
32
33 #include <stdlib.h>
34 #include <stdarg.h>
35 #include <stdio.h>
36 #include <string.h>
37 #ifdef HAVE_UNISTD_H
38 # include <unistd.h>
39 #endif
40 #include <errno.h>
41 #include <limits.h>
42 #include <fcntl.h>
43 #ifdef HAVE_SYS_IOCTL_H
44 # include <sys/ioctl.h>
45 #endif
46 #ifdef HAVE_SYS_MMAN_H
47 # include <sys/mman.h>
48 #endif
49 #include "windef.h"
50 #include "winbase.h"
51 #include "wingdi.h"
52 #include "winerror.h"
53 #include "winuser.h"
54 #include "winnls.h"
55 #include "winreg.h"
56 #include "mmddk.h"
57
58 /* ksmedia.h defines KSDATAFORMAT_SUBTYPE_PCM and KSDATAFORMAT_SUBTYPE_IEEE_FLOAT
59  * However either all files that use it will define it, or no files will
60  * The only way to solve this is by adding initguid.h here, and include the guid that way
61  */
62 #include "initguid.h"
63 #include "alsa.h"
64
65 #include "wine/library.h"
66 #include "wine/unicode.h"
67 #include "wine/debug.h"
68
69 WINE_DEFAULT_DEBUG_CHANNEL(wave);
70
71 /*----------------------------------------------------------------------------
72 **  ALSA_TestDeviceForWine
73 **
74 **      Test to see if a given device is sufficient for Wine.
75 */
76 static int ALSA_TestDeviceForWine(int card, int device,  snd_pcm_stream_t streamtype)
77 {
78     snd_pcm_t *pcm = NULL;
79     char pcmname[256];
80     int retcode;
81     snd_pcm_hw_params_t *hwparams;
82     const char *reason = NULL;
83     unsigned int rrate;
84
85     hwparams = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_hw_params_sizeof() );
86
87     /* Note that the plug: device masks out a lot of info, we want to avoid that */
88     sprintf(pcmname, "hw:%d,%d", card, device);
89     retcode = snd_pcm_open(&pcm, pcmname, streamtype, SND_PCM_NONBLOCK);
90     if (retcode < 0)
91     {
92         /* Note that a busy device isn't automatically disqualified */
93         if (retcode == (-1 * EBUSY))
94             retcode = 0;
95         goto exit;
96     }
97
98     retcode = snd_pcm_hw_params_any(pcm, hwparams);
99     if (retcode < 0)
100     {
101         reason = "Could not retrieve hw_params";
102         goto exit;
103     }
104
105     /* set the count of channels */
106     retcode = snd_pcm_hw_params_set_channels(pcm, hwparams, 2);
107     if (retcode < 0)
108     {
109         reason = "Could not set channels";
110         goto exit;
111     }
112
113     rrate = 44100;
114     retcode = snd_pcm_hw_params_set_rate_near(pcm, hwparams, &rrate, 0);
115     if (retcode < 0)
116     {
117         reason = "Could not set rate";
118         goto exit;
119     }
120
121     if (rrate == 0)
122     {
123         reason = "Rate came back as 0";
124         goto exit;
125     }
126
127     /* write the parameters to device */
128     retcode = snd_pcm_hw_params(pcm, hwparams);
129     if (retcode < 0)
130     {
131         reason = "Could not set hwparams";
132         goto exit;
133     }
134
135     retcode = 0;
136
137 exit:
138     if (pcm)
139         snd_pcm_close(pcm);
140     HeapFree( GetProcessHeap(), 0, hwparams );
141
142     if (retcode != 0 && retcode != (-1 * ENOENT))
143         TRACE("Discarding card %d/device %d:  %s [%d(%s)]\n", card, device, reason, retcode, snd_strerror(retcode));
144
145     return retcode;
146 }
147
148 /*----------------------------------------------------------------------------
149 ** ALSA_RegGetString
150 **  Retrieve a string from a registry key
151 */
152 static int ALSA_RegGetString(HKEY key, const char *value, char **bufp)
153 {
154     DWORD rc;
155     DWORD type;
156     DWORD bufsize;
157
158     *bufp = NULL;
159     rc = RegQueryValueExA(key, value, NULL, &type, NULL, &bufsize);
160     if (rc != ERROR_SUCCESS)
161         return(rc);
162
163     if (type != REG_SZ)
164         return 1;
165
166     *bufp = HeapAlloc(GetProcessHeap(), 0, bufsize);
167     if (! *bufp)
168         return 1;
169
170     rc = RegQueryValueExA(key, value, NULL, NULL, (LPBYTE)*bufp, &bufsize);
171     return rc;
172 }
173
174 /*----------------------------------------------------------------------------
175 ** ALSA_RegGetBoolean
176 **  Get a string and interpret it as a boolean
177 */
178
179 /* Possible truths:
180    Y(es), T(rue), 1, E(nabled) */
181
182 #define IS_OPTION_TRUE(ch) ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1' || (ch) == 'e' || (ch) == 'E')
183 static int ALSA_RegGetBoolean(HKEY key, const char *value, BOOL *answer)
184 {
185     DWORD rc;
186     char *buf = NULL;
187
188     rc = ALSA_RegGetString(key, value, &buf);
189     if (buf)
190     {
191         *answer = FALSE;
192         if (IS_OPTION_TRUE(*buf))
193             *answer = TRUE;
194
195         HeapFree(GetProcessHeap(), 0, buf);
196     }
197
198     return rc;
199 }
200
201 /*----------------------------------------------------------------------------
202 ** ALSA_RegGetInt
203 **  Get a string and interpret it as a DWORD
204 */
205 static int ALSA_RegGetInt(HKEY key, const char *value, DWORD *answer)
206 {
207     DWORD rc;
208     char *buf = NULL;
209
210     rc = ALSA_RegGetString(key, value, &buf);
211     if (buf)
212     {
213         *answer = atoi(buf);
214         HeapFree(GetProcessHeap(), 0, buf);
215     }
216
217     return rc;
218 }
219
220 /* return a string duplicated on the win32 process heap, free with HeapFree */
221 static char* ALSA_strdup(const char *s) {
222     char *result = HeapAlloc(GetProcessHeap(), 0, strlen(s)+1);
223     if (!result)
224         return NULL;
225     strcpy(result, s);
226     return result;
227 }
228
229 #define ALSA_RETURN_ONFAIL(mycall)                                      \
230 {                                                                       \
231     int rc;                                                             \
232     {rc = mycall;}                                                      \
233     if ((rc) < 0)                                                       \
234     {                                                                   \
235         ERR("%s failed:  %s(%d)\n", #mycall, snd_strerror(rc), rc);     \
236         return(rc);                                                     \
237     }                                                                   \
238 }
239
240 /*----------------------------------------------------------------------------
241 **  ALSA_ComputeCaps
242 **
243 **      Given an ALSA PCM, figure out our HW CAPS structure info.
244 **  ctl can be null, pcm is required, as is all output parms.
245 **
246 */
247 static int ALSA_ComputeCaps(snd_ctl_t *ctl, snd_pcm_t *pcm,
248         WORD *channels, DWORD *flags, DWORD *formats, DWORD *supports)
249 {
250     snd_pcm_hw_params_t *hw_params;
251     snd_pcm_format_mask_t *fmask;
252     snd_pcm_access_mask_t *acmask;
253     unsigned int ratemin = 0;
254     unsigned int ratemax = 0;
255     unsigned int chmin = 0;
256     unsigned int chmax = 0;
257     int rc, dir = 0;
258
259     hw_params = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_hw_params_sizeof() );
260     fmask = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_format_mask_sizeof() );
261     acmask = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_access_mask_sizeof() );
262
263     if ((rc = snd_pcm_hw_params_any(pcm, hw_params)) < 0) goto done;
264
265     snd_pcm_hw_params_get_format_mask(hw_params, fmask);
266
267     if ((rc = snd_pcm_hw_params_get_access_mask(hw_params, acmask)) < 0) goto done;
268
269     if ((rc = snd_pcm_hw_params_get_rate_min(hw_params, &ratemin, &dir)) < 0) goto done;
270     if ((rc = snd_pcm_hw_params_get_rate_max(hw_params, &ratemax, &dir)) < 0) goto done;
271     if ((rc = snd_pcm_hw_params_get_channels_min(hw_params, &chmin)) < 0) goto done;
272     if ((rc = snd_pcm_hw_params_get_channels_max(hw_params, &chmax)) < 0) goto done;
273
274 #define X(r,v) \
275     if ( (r) >= ratemin && ( (r) <= ratemax || ratemax == -1) ) \
276     { \
277        if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_U8)) \
278        { \
279           if (chmin <= 1 && 1 <= chmax) \
280               *formats |= WAVE_FORMAT_##v##M08; \
281           if (chmin <= 2 && 2 <= chmax) \
282               *formats |= WAVE_FORMAT_##v##S08; \
283        } \
284        if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_S16_LE)) \
285        { \
286           if (chmin <= 1 && 1 <= chmax) \
287               *formats |= WAVE_FORMAT_##v##M16; \
288           if (chmin <= 2 && 2 <= chmax) \
289               *formats |= WAVE_FORMAT_##v##S16; \
290        } \
291     }
292     X(11025,1);
293     X(22050,2);
294     X(44100,4);
295     X(48000,48);
296     X(96000,96);
297 #undef X
298
299     if (chmin > 1)
300         FIXME("Device has a minimum of %d channels\n", chmin);
301     *channels = chmax;
302
303     /* FIXME: is sample accurate always true ?
304     ** Can we do WAVECAPS_PITCH, WAVECAPS_SYNC, or WAVECAPS_PLAYBACKRATE? */
305     *supports |= WAVECAPS_SAMPLEACCURATE;
306
307     /* FIXME: NONITERLEAVED and COMPLEX are not supported right now */
308     if ( snd_pcm_access_mask_test( acmask, SND_PCM_ACCESS_MMAP_INTERLEAVED ) )
309         *supports |= WAVECAPS_DIRECTSOUND;
310
311     /* check for volume control support */
312     if (ctl) {
313         if (snd_ctl_name(ctl))
314         {
315             snd_hctl_t *hctl;
316             if (snd_hctl_open(&hctl, snd_ctl_name(ctl), 0) >= 0)
317             {
318                 snd_hctl_load(hctl);
319                 if (!ALSA_CheckSetVolume( hctl, NULL, NULL, NULL, NULL, NULL, NULL, NULL ))
320                 {
321                     *supports |= WAVECAPS_VOLUME;
322                     if (chmin <= 2 && 2 <= chmax)
323                         *supports |= WAVECAPS_LRVOLUME;
324                 }
325                 snd_hctl_free(hctl);
326                 snd_hctl_close(hctl);
327             }
328         }
329     }
330
331     *flags = DSCAPS_CERTIFIED | DSCAPS_CONTINUOUSRATE;
332     *flags |= DSCAPS_SECONDARYMONO | DSCAPS_SECONDARYSTEREO;
333     *flags |= DSCAPS_SECONDARY8BIT | DSCAPS_SECONDARY16BIT;
334
335     if (*formats & (WAVE_FORMAT_1M08  | WAVE_FORMAT_2M08  |
336                                WAVE_FORMAT_4M08  | WAVE_FORMAT_48M08 |
337                                WAVE_FORMAT_96M08 | WAVE_FORMAT_1M16  |
338                                WAVE_FORMAT_2M16  | WAVE_FORMAT_4M16  |
339                                WAVE_FORMAT_48M16 | WAVE_FORMAT_96M16) )
340         *flags |= DSCAPS_PRIMARYMONO;
341
342     if (*formats & (WAVE_FORMAT_1S08  | WAVE_FORMAT_2S08  |
343                                WAVE_FORMAT_4S08  | WAVE_FORMAT_48S08 |
344                                WAVE_FORMAT_96S08 | WAVE_FORMAT_1S16  |
345                                WAVE_FORMAT_2S16  | WAVE_FORMAT_4S16  |
346                                WAVE_FORMAT_48S16 | WAVE_FORMAT_96S16) )
347         *flags |= DSCAPS_PRIMARYSTEREO;
348
349     if (*formats & (WAVE_FORMAT_1M08  | WAVE_FORMAT_2M08  |
350                                WAVE_FORMAT_4M08  | WAVE_FORMAT_48M08 |
351                                WAVE_FORMAT_96M08 | WAVE_FORMAT_1S08  |
352                                WAVE_FORMAT_2S08  | WAVE_FORMAT_4S08  |
353                                WAVE_FORMAT_48S08 | WAVE_FORMAT_96S08) )
354         *flags |= DSCAPS_PRIMARY8BIT;
355
356     if (*formats & (WAVE_FORMAT_1M16  | WAVE_FORMAT_2M16  |
357                                WAVE_FORMAT_4M16  | WAVE_FORMAT_48M16 |
358                                WAVE_FORMAT_96M16 | WAVE_FORMAT_1S16  |
359                                WAVE_FORMAT_2S16  | WAVE_FORMAT_4S16  |
360                                WAVE_FORMAT_48S16 | WAVE_FORMAT_96S16) )
361         *flags |= DSCAPS_PRIMARY16BIT;
362
363     rc = 0;
364
365 done:
366     if (rc < 0) ERR("failed: %s(%d)\n", snd_strerror(rc), rc);
367     HeapFree( GetProcessHeap(), 0, hw_params );
368     HeapFree( GetProcessHeap(), 0, fmask );
369     HeapFree( GetProcessHeap(), 0, acmask );
370     return rc;
371 }
372
373 /*----------------------------------------------------------------------------
374 **  ALSA_AddCommonDevice
375 **
376 **      Perform Alsa initialization common to both capture and playback
377 **
378 **  Side Effect:  ww->pcname and ww->ctlname may need to be freed.
379 **
380 **  Note:  this was originally coded by using snd_pcm_name(pcm), until
381 **         I discovered that with at least one version of alsa lib,
382 **         the use of a pcm named default:0 would cause snd_pcm_name() to fail.
383 **         So passing the name in is logically extraneous.  Sigh.
384 */
385 static int ALSA_AddCommonDevice(snd_ctl_t *ctl, snd_pcm_t *pcm, const char *pcmname, WINE_WAVEDEV *ww)
386 {
387     snd_pcm_info_t *infop;
388     int rc;
389
390     infop = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_info_sizeof() );
391     if ((rc = snd_pcm_info(pcm, infop)) < 0)
392     {
393         HeapFree( GetProcessHeap(), 0, infop );
394         return rc;
395     }
396
397     if (pcm && pcmname)
398         ww->pcmname = ALSA_strdup(pcmname);
399     else
400     {
401         HeapFree( GetProcessHeap(), 0, infop );
402         return -1;
403     }
404
405     if (ctl && snd_ctl_name(ctl))
406         ww->ctlname = ALSA_strdup(snd_ctl_name(ctl));
407
408     strcpy(ww->interface_name, "winealsa: ");
409     memcpy(ww->interface_name + strlen(ww->interface_name),
410             ww->pcmname,
411             min(strlen(ww->pcmname), sizeof(ww->interface_name) - strlen("winealsa:   ")));
412
413     strcpy(ww->ds_desc.szDrvname, "winealsa.drv");
414
415     memcpy(ww->ds_desc.szDesc, snd_pcm_info_get_name(infop),
416             min( (sizeof(ww->ds_desc.szDesc) - 1), strlen(snd_pcm_info_get_name(infop))) );
417
418     ww->ds_caps.dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
419     ww->ds_caps.dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
420     ww->ds_caps.dwPrimaryBuffers = 1;
421
422     HeapFree( GetProcessHeap(), 0, infop );
423     return 0;
424 }
425
426 /*----------------------------------------------------------------------------
427 ** ALSA_FreeDevice
428 */
429 static void ALSA_FreeDevice(WINE_WAVEDEV *ww)
430 {
431     HeapFree(GetProcessHeap(), 0, ww->pcmname);
432     ww->pcmname = NULL;
433
434     HeapFree(GetProcessHeap(), 0, ww->ctlname);
435     ww->ctlname = NULL;
436 }
437
438 /*----------------------------------------------------------------------------
439 **  ALSA_AddDeviceToArray
440 **
441 **      Dynamically size one of the wavein or waveout arrays of devices,
442 **  and add a fully configured device node to the array.
443 **
444 */
445 static int ALSA_AddDeviceToArray(WINE_WAVEDEV *ww, WINE_WAVEDEV **array,
446         DWORD *count, DWORD *alloced, int isdefault)
447 {
448     int i = *count;
449
450     if (*count >= *alloced)
451     {
452         (*alloced) += WAVEDEV_ALLOC_EXTENT_SIZE;
453         if (! (*array))
454             *array = HeapAlloc(GetProcessHeap(), 0, sizeof(*ww) * (*alloced));
455         else
456             *array = HeapReAlloc(GetProcessHeap(), 0, *array, sizeof(*ww) * (*alloced));
457
458         if (!*array)
459         {
460             return -1;
461         }
462     }
463
464     /* If this is the default, arrange for it to be the first element */
465     if (isdefault && i > 0)
466     {
467         (*array)[*count] = (*array)[0];
468         i = 0;
469     }
470
471     (*array)[i] = *ww;
472
473     (*count)++;
474     return 0;
475 }
476
477 /*----------------------------------------------------------------------------
478 **  ALSA_AddPlaybackDevice
479 **
480 **      Add a given Alsa device to Wine's internal list of Playback
481 **  devices.
482 */
483 static int ALSA_AddPlaybackDevice(snd_ctl_t *ctl, snd_pcm_t *pcm, const char *pcmname, int isdefault)
484 {
485     WINE_WAVEDEV    wwo;
486     int rc;
487
488     memset(&wwo, '\0', sizeof(wwo));
489
490     rc = ALSA_AddCommonDevice(ctl, pcm, pcmname, &wwo);
491     if (rc)
492         return(rc);
493
494     MultiByteToWideChar(CP_UNIXCP, 0, wwo.ds_desc.szDesc, -1,
495                         wwo.outcaps.szPname, sizeof(wwo.outcaps.szPname)/sizeof(WCHAR));
496     wwo.outcaps.szPname[sizeof(wwo.outcaps.szPname)/sizeof(WCHAR) - 1] = '\0';
497
498     wwo.outcaps.wMid = MM_CREATIVE;
499     wwo.outcaps.wPid = MM_CREATIVE_SBP16_WAVEOUT;
500     wwo.outcaps.vDriverVersion = 0x0100;
501
502     rc = ALSA_ComputeCaps(ctl, pcm, &wwo.outcaps.wChannels, &wwo.ds_caps.dwFlags,
503             &wwo.outcaps.dwFormats, &wwo.outcaps.dwSupport);
504     if (rc)
505     {
506         WARN("Error calculating device caps for pcm [%s]\n", wwo.pcmname);
507         ALSA_FreeDevice(&wwo);
508         return(rc);
509     }
510
511     rc = ALSA_AddDeviceToArray(&wwo, &WOutDev, &ALSA_WodNumDevs, &ALSA_WodNumMallocedDevs, isdefault);
512     if (rc)
513         ALSA_FreeDevice(&wwo);
514     return (rc);
515 }
516
517 /*----------------------------------------------------------------------------
518 **  ALSA_AddCaptureDevice
519 **
520 **      Add a given Alsa device to Wine's internal list of Capture
521 **  devices.
522 */
523 static int ALSA_AddCaptureDevice(snd_ctl_t *ctl, snd_pcm_t *pcm, const char *pcmname, int isdefault)
524 {
525     WINE_WAVEDEV    wwi;
526     int rc;
527
528     memset(&wwi, '\0', sizeof(wwi));
529
530     rc = ALSA_AddCommonDevice(ctl, pcm, pcmname, &wwi);
531     if (rc)
532         return(rc);
533
534     MultiByteToWideChar(CP_UNIXCP, 0, wwi.ds_desc.szDesc, -1,
535                         wwi.incaps.szPname, sizeof(wwi.incaps.szPname) / sizeof(WCHAR));
536     wwi.incaps.szPname[sizeof(wwi.incaps.szPname)/sizeof(WCHAR) - 1] = '\0';
537
538     wwi.incaps.wMid = MM_CREATIVE;
539     wwi.incaps.wPid = MM_CREATIVE_SBP16_WAVEOUT;
540     wwi.incaps.vDriverVersion = 0x0100;
541
542     rc = ALSA_ComputeCaps(ctl, pcm, &wwi.incaps.wChannels, &wwi.ds_caps.dwFlags,
543             &wwi.incaps.dwFormats, &wwi.dwSupport);
544     if (rc)
545     {
546         WARN("Error calculating device caps for pcm [%s]\n", wwi.pcmname);
547         ALSA_FreeDevice(&wwi);
548         return(rc);
549     }
550
551     rc = ALSA_AddDeviceToArray(&wwi, &WInDev, &ALSA_WidNumDevs, &ALSA_WidNumMallocedDevs, isdefault);
552     if (rc)
553         ALSA_FreeDevice(&wwi);
554     return(rc);
555 }
556
557 /*----------------------------------------------------------------------------
558 **  ALSA_CheckEnvironment
559 **
560 **      Given an Alsa style configuration node, scan its subitems
561 **  for environment variable names, and use them to find an override,
562 **  if appropriate.
563 **      This is essentially a long and convoluted way of doing:
564 **          getenv("ALSA_CARD")
565 **          getenv("ALSA_CTL_CARD")
566 **          getenv("ALSA_PCM_CARD")
567 **          getenv("ALSA_PCM_DEVICE")
568 **
569 **  The output value is set with the atoi() of the first environment
570 **  variable found to be set, if any; otherwise, it is left alone
571 */
572 static void ALSA_CheckEnvironment(snd_config_t *node, int *outvalue)
573 {
574     snd_config_iterator_t iter;
575
576     for (iter = snd_config_iterator_first(node);
577          iter != snd_config_iterator_end(node);
578          iter = snd_config_iterator_next(iter))
579     {
580         snd_config_t *leaf = snd_config_iterator_entry(iter);
581         if (snd_config_get_type(leaf) == SND_CONFIG_TYPE_STRING)
582         {
583             const char *value;
584             if (snd_config_get_string(leaf, &value) >= 0)
585             {
586                 char *p = getenv(value);
587                 if (p)
588                 {
589                     *outvalue = atoi(p);
590                     return;
591                 }
592             }
593         }
594     }
595 }
596
597 /*----------------------------------------------------------------------------
598 **  ALSA_DefaultDevices
599 **
600 **      Jump through Alsa style hoops to (hopefully) properly determine
601 **  Alsa defaults for CTL Card #, as well as for PCM Card + Device #.
602 **  We'll also find out if the user has set any of the environment
603 **  variables that specify we're to use a specific card or device.
604 **
605 **  Parameters:
606 **      directhw        Whether to use a direct hardware device or not;
607 **                      essentially switches the pcm device name from
608 **                      one of 'default:X' or 'plughw:X' to "hw:X"
609 **      defctlcard      If !NULL, will hold the ctl card number given
610 **                      by the ALSA config as the default
611 **      defpcmcard      If !NULL, default pcm card #
612 **      defpcmdev       If !NULL, default pcm device #
613 **      fixedctlcard    If !NULL, and the user set the appropriate
614 **                          environment variable, we'll set to the
615 **                          card the user specified.
616 **      fixedpcmcard    If !NULL, and the user set the appropriate
617 **                          environment variable, we'll set to the
618 **                          card the user specified.
619 **      fixedpcmdev     If !NULL, and the user set the appropriate
620 **                          environment variable, we'll set to the
621 **                          device the user specified.
622 **
623 **  Returns:  0 on success, < 0 on failure
624 */
625 static int ALSA_DefaultDevices(int directhw,
626             long *defctlcard,
627             long *defpcmcard, long *defpcmdev,
628             int *fixedctlcard,
629             int *fixedpcmcard, int *fixedpcmdev)
630 {
631     snd_config_t   *configp;
632     char pcmsearch[256];
633
634     ALSA_RETURN_ONFAIL(snd_config_update());
635
636     if (defctlcard)
637         if (snd_config_search(snd_config, "defaults.ctl.card", &configp) >= 0)
638             snd_config_get_integer(configp, defctlcard);
639
640     if (defpcmcard)
641         if (snd_config_search(snd_config, "defaults.pcm.card", &configp) >= 0)
642             snd_config_get_integer(configp, defpcmcard);
643
644     if (defpcmdev)
645         if (snd_config_search(snd_config, "defaults.pcm.device", &configp) >= 0)
646             snd_config_get_integer(configp, defpcmdev);
647
648
649     if (fixedctlcard)
650     {
651         if (snd_config_search(snd_config, "ctl.hw.@args.CARD.default.vars", &configp) >= 0)
652             ALSA_CheckEnvironment(configp, fixedctlcard);
653     }
654
655     if (fixedpcmcard)
656     {
657         sprintf(pcmsearch, "pcm.%s.@args.CARD.default.vars", directhw ? "hw" : "plughw");
658         if (snd_config_search(snd_config, pcmsearch, &configp) >= 0)
659             ALSA_CheckEnvironment(configp, fixedpcmcard);
660     }
661
662     if (fixedpcmdev)
663     {
664         sprintf(pcmsearch, "pcm.%s.@args.DEV.default.vars", directhw ? "hw" : "plughw");
665         if (snd_config_search(snd_config, pcmsearch, &configp) >= 0)
666             ALSA_CheckEnvironment(configp, fixedpcmdev);
667     }
668
669     return 0;
670 }
671
672
673 /*----------------------------------------------------------------------------
674 **  ALSA_ScanDevices
675 **
676 **      Iterate through all discoverable ALSA cards, searching
677 **  for usable PCM devices.
678 **
679 **  Parameters:
680 **      directhw        Whether to use a direct hardware device or not;
681 **                      essentially switches the pcm device name from
682 **                      one of 'default:X' or 'plughw:X' to "hw:X"
683 **      defctlcard      Alsa's notion of the default ctl card.
684 **      defpcmcard         . pcm card
685 **      defpcmdev          . pcm device
686 **      fixedctlcard    If not -1, then gives the value of ALSA_CTL_CARD
687 **                          or equivalent environment variable
688 **      fixedpcmcard    If not -1, then gives the value of ALSA_PCM_CARD
689 **                          or equivalent environment variable
690 **      fixedpcmdev     If not -1, then gives the value of ALSA_PCM_DEVICE
691 **                          or equivalent environment variable
692 **
693 **  Returns:  0 on success, < 0 on failure
694 */
695 static int ALSA_ScanDevices(int directhw,
696         long defctlcard, long defpcmcard, long defpcmdev,
697         int fixedctlcard, int fixedpcmcard, int fixedpcmdev)
698 {
699     int card = fixedpcmcard;
700     int scan_devices = (fixedpcmdev == -1);
701
702     /*------------------------------------------------------------------------
703     ** Loop through all available cards
704     **----------------------------------------------------------------------*/
705     if (card == -1)
706         snd_card_next(&card);
707
708     for (; card != -1; snd_card_next(&card))
709     {
710         char ctlname[256];
711         snd_ctl_t *ctl;
712         int rc;
713         int device;
714
715         /*--------------------------------------------------------------------
716         ** Try to open a ctl handle; Wine doesn't absolutely require one,
717         **  but it does allow for volume control and for device scanning
718         **------------------------------------------------------------------*/
719         sprintf(ctlname, "hw:%d", fixedctlcard == -1 ? card : fixedctlcard);
720         rc = snd_ctl_open(&ctl, ctlname, SND_CTL_NONBLOCK);
721         if (rc < 0)
722         {
723             ctl = NULL;
724             WARN("Unable to open an alsa ctl for [%s] (pcm card %d): %s; not scanning devices\n",
725                     ctlname, card, snd_strerror(rc));
726             if (fixedpcmdev == -1)
727                 fixedpcmdev = 0;
728         }
729
730         /*--------------------------------------------------------------------
731         ** Loop through all available devices on this card
732         **------------------------------------------------------------------*/
733         device = fixedpcmdev;
734         if (device == -1)
735             snd_ctl_pcm_next_device(ctl, &device);
736
737         for (; device != -1; snd_ctl_pcm_next_device(ctl, &device))
738         {
739             char defaultpcmname[256];
740             char plugpcmname[256];
741             char hwpcmname[256];
742             char *pcmname = NULL;
743             snd_pcm_t *pcm;
744
745             sprintf(defaultpcmname, "default");
746             sprintf(plugpcmname,    "plughw:%d,%d", card, device);
747             sprintf(hwpcmname,      "hw:%d,%d", card, device);
748
749             /*----------------------------------------------------------------
750             ** See if it's a valid playback device
751             **--------------------------------------------------------------*/
752             if (ALSA_TestDeviceForWine(card, device, SND_PCM_STREAM_PLAYBACK) == 0)
753             {
754                 /* If we can, try the default:X device name first */
755                 if (! scan_devices && ! directhw)
756                 {
757                     pcmname = defaultpcmname;
758                     rc = snd_pcm_open(&pcm, pcmname, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
759                 }
760                 else
761                     rc = -1;
762
763                 if (rc < 0)
764                 {
765                     pcmname = directhw ? hwpcmname : plugpcmname;
766                     rc = snd_pcm_open(&pcm, pcmname, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
767                 }
768
769                 if (rc >= 0)
770                 {
771                     if (defctlcard == card && defpcmcard == card && defpcmdev == device)
772                         ALSA_AddPlaybackDevice(ctl, pcm, pcmname, TRUE);
773                     else
774                         ALSA_AddPlaybackDevice(ctl, pcm, pcmname, FALSE);
775                     snd_pcm_close(pcm);
776                 }
777                 else
778                 {
779                     TRACE("Device [%s/%s] failed to open for playback: %s\n",
780                         directhw || scan_devices ? "(N/A)" : defaultpcmname,
781                         directhw ? hwpcmname : plugpcmname,
782                         snd_strerror(rc));
783                 }
784             }
785
786             /*----------------------------------------------------------------
787             ** See if it's a valid capture device
788             **--------------------------------------------------------------*/
789             if (ALSA_TestDeviceForWine(card, device, SND_PCM_STREAM_CAPTURE) == 0)
790             {
791                 /* If we can, try the default:X device name first */
792                 if (! scan_devices && ! directhw)
793                 {
794                     pcmname = defaultpcmname;
795                     rc = snd_pcm_open(&pcm, pcmname, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
796                 }
797                 else
798                     rc = -1;
799
800                 if (rc < 0)
801                 {
802                     pcmname = directhw ? hwpcmname : plugpcmname;
803                     rc = snd_pcm_open(&pcm, pcmname, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
804                 }
805
806                 if (rc >= 0)
807                 {
808                     if (defctlcard == card && defpcmcard == card && defpcmdev == device)
809                         ALSA_AddCaptureDevice(ctl, pcm, pcmname, TRUE);
810                     else
811                         ALSA_AddCaptureDevice(ctl, pcm, pcmname, FALSE);
812
813                     snd_pcm_close(pcm);
814                 }
815                 else
816                 {
817                     TRACE("Device [%s/%s] failed to open for capture: %s\n",
818                         directhw || scan_devices ? "(N/A)" : defaultpcmname,
819                         directhw ? hwpcmname : plugpcmname,
820                         snd_strerror(rc));
821                 }
822             }
823
824             if (! scan_devices)
825                 break;
826         }
827
828         if (ctl)
829             snd_ctl_close(ctl);
830
831         /*--------------------------------------------------------------------
832         ** If the user has set env variables such that we're pegged to
833         **  a specific card, then break after we've examined it
834         **------------------------------------------------------------------*/
835         if (fixedpcmcard != -1)
836             break;
837     }
838
839     return 0;
840
841 }
842
843 /*----------------------------------------------------------------------------
844 ** ALSA_PerformDefaultScan
845 **  Perform the basic default scanning for devices within ALSA.
846 **  The hope is that this routine implements a 'correct'
847 **  scanning algorithm from the Alsalib point of view.
848 **
849 **      Note that Wine, overall, has other mechanisms to
850 **  override and specify exact CTL and PCM device names,
851 **  but this routine is imagined as the default that
852 **  99% of users will use.
853 **
854 **      The basic algorithm is simple:
855 **  Use snd_card_next to iterate cards; within cards, use
856 **  snd_ctl_pcm_next_device to iterate through devices.
857 **
858 **      We add a little complexity by taking into consideration
859 **  environment variables such as ALSA_CARD (et all), and by
860 **  detecting when a given device matches the default specified
861 **  by Alsa.
862 **
863 **  Parameters:
864 **      directhw        If !0, indicates we should use the hw:X
865 **                      PCM interface, rather than first try
866 **                      the 'default' device followed by the plughw
867 **                      device.  (default and plughw do fancy mixing
868 **                      and audio scaling, if they are available).
869 **      devscan         If TRUE, we should scan all devices, not
870 **                      juse use device 0 on each card
871 **
872 **  Returns:
873 **      0   on success
874 **
875 **  Effects:
876 **      Invokes the ALSA_AddXXXDevice functions on valid
877 **  looking devices
878 */
879 static int ALSA_PerformDefaultScan(int directhw, BOOL devscan)
880 {
881     long defctlcard = -1, defpcmcard = -1, defpcmdev = -1;
882     int fixedctlcard = -1, fixedpcmcard = -1, fixedpcmdev = -1;
883     int rc;
884
885     /* FIXME:  We should dlsym the new snd_names_list/snd_names_list_free 1.0.9 apis,
886     **          and use them instead of this scan mechanism if they are present         */
887
888     rc = ALSA_DefaultDevices(directhw, &defctlcard, &defpcmcard, &defpcmdev,
889             &fixedctlcard, &fixedpcmcard, &fixedpcmdev);
890     if (rc)
891         return(rc);
892
893     if (fixedpcmdev == -1 && ! devscan)
894         fixedpcmdev = 0;
895
896     return(ALSA_ScanDevices(directhw, defctlcard, defpcmcard, defpcmdev, fixedctlcard, fixedpcmcard, fixedpcmdev));
897 }
898
899
900 /*----------------------------------------------------------------------------
901 ** ALSA_AddUserSpecifiedDevice
902 **  Add a device given from the registry
903 */
904 static int ALSA_AddUserSpecifiedDevice(const char *ctlname, const char *pcmname)
905 {
906     int rc;
907     int okay = 0;
908     snd_ctl_t *ctl = NULL;
909     snd_pcm_t *pcm = NULL;
910
911     if (ctlname)
912     {
913         rc = snd_ctl_open(&ctl, ctlname, SND_CTL_NONBLOCK);
914         if (rc < 0)
915             ctl = NULL;
916     }
917
918     rc = snd_pcm_open(&pcm, pcmname, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
919     if (rc >= 0)
920     {
921         ALSA_AddPlaybackDevice(ctl, pcm, pcmname, FALSE);
922         okay++;
923         snd_pcm_close(pcm);
924     }
925
926     rc = snd_pcm_open(&pcm, pcmname, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
927     if (rc >= 0)
928     {
929         ALSA_AddCaptureDevice(ctl, pcm, pcmname, FALSE);
930         okay++;
931         snd_pcm_close(pcm);
932     }
933
934     if (ctl)
935         snd_ctl_close(ctl);
936
937     return (okay == 0);
938 }
939
940
941 /*----------------------------------------------------------------------------
942 ** ALSA_WaveInit
943 **  Initialize the Wine Alsa sub system.
944 ** The main task is to probe for and store a list of all appropriate playback
945 ** and capture devices.
946 **  Key control points are from the registry key:
947 **  [Software\Wine\Alsa Driver]
948 **  AutoScanCards           Whether or not to scan all known sound cards
949 **                          and add them to Wine's list (default yes)
950 **  AutoScanDevices         Whether or not to scan all known PCM devices
951 **                          on each card (default no)
952 **  UseDirectHW             Whether or not to use the hw:X device,
953 **                          instead of the fancy default:X or plughw:X device.
954 **                          The hw:X device goes straight to the hardware
955 **                          without any fancy mixing or audio scaling in between.
956 **  DeviceCount             If present, specifies the number of hard coded
957 **                          Alsa devices to add to Wine's list; default 0
958 **  DevicePCMn              Specifies the Alsa PCM devices to open for
959 **                          Device n (where n goes from 1 to DeviceCount)
960 **  DeviceCTLn              Specifies the Alsa control devices to open for
961 **                          Device n (where n goes from 1 to DeviceCount)
962 **
963 **                          Using AutoScanCards no, and then Devicexxx info
964 **                          is a way to exactly specify the devices used by Wine.
965 **
966 */
967 LONG ALSA_WaveInit(void)
968 {
969     DWORD rc;
970     BOOL  AutoScanCards = TRUE;
971     BOOL  AutoScanDevices = FALSE;
972     BOOL  UseDirectHW = FALSE;
973     DWORD DeviceCount = 0;
974     HKEY  key = 0;
975     int   i;
976
977     if (!wine_dlopen("libasound.so.2", RTLD_LAZY|RTLD_GLOBAL, NULL, 0))
978     {
979         ERR("Error: ALSA lib needs to be loaded with flags RTLD_LAZY and RTLD_GLOBAL.\n");
980         return -1;
981     }
982
983     /* @@ Wine registry key: HKCU\Software\Wine\Alsa Driver */
984     rc = RegOpenKeyExA(HKEY_CURRENT_USER, "Software\\Wine\\Alsa Driver", 0, KEY_QUERY_VALUE, &key);
985     if (rc == ERROR_SUCCESS)
986     {
987         ALSA_RegGetBoolean(key, "AutoScanCards", &AutoScanCards);
988         ALSA_RegGetBoolean(key, "AutoScanDevices", &AutoScanDevices);
989         ALSA_RegGetBoolean(key, "UseDirectHW", &UseDirectHW);
990         ALSA_RegGetInt(key, "DeviceCount", &DeviceCount);
991     }
992
993     if (AutoScanCards)
994         rc = ALSA_PerformDefaultScan(UseDirectHW, AutoScanDevices);
995
996     for (i = 0; i < DeviceCount; i++)
997     {
998         char *ctl_name = NULL;
999         char *pcm_name = NULL;
1000         char value[30];
1001
1002         sprintf(value, "DevicePCM%d", i + 1);
1003         if (ALSA_RegGetString(key, value, &pcm_name) == ERROR_SUCCESS)
1004         {
1005             sprintf(value, "DeviceCTL%d", i + 1);
1006             ALSA_RegGetString(key, value, &ctl_name);
1007             ALSA_AddUserSpecifiedDevice(ctl_name, pcm_name);
1008         }
1009
1010         HeapFree(GetProcessHeap(), 0, ctl_name);
1011         HeapFree(GetProcessHeap(), 0, pcm_name);
1012     }
1013
1014     if (key)
1015         RegCloseKey(key);
1016
1017     return (rc);
1018 }
1019
1020 #endif /* HAVE_ALSA */