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