git.oblomov.eu Git - wine/blob - dlls/winealsa.drv/mixer.c

   1 /*
   2  * Alsa MIXER Wine Driver for Linux
   3  * Very loosely based on wineoss mixer driver
   4  *
   5  * Copyright 2007 Maarten Lankhorst
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <stdlib.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #ifdef HAVE_UNISTD_H
  30 # include <unistd.h>
  31 #endif
  32 #include <fcntl.h>
  33 #include <errno.h>
  34 #include <assert.h>
  35 #ifdef HAVE_SYS_IOCTL_H
  36 # include <sys/ioctl.h>
  37 #endif
  38
  39 #define NONAMELESSUNION
  40 #define NONAMELESSSTRUCT
  41
  42 #include "windef.h"
  43 #include "winbase.h"
  44 #include "wingdi.h"
  45 #include "winerror.h"
  46 #include "winuser.h"
  47 #include "winnls.h"
  48 #include "mmddk.h"
  49 #include "mmsystem.h"
  50 #include "alsa.h"
  51 #include "wine/unicode.h"
  52 #include "wine/debug.h"
  53
  54 WINE_DEFAULT_DEBUG_CHANNEL(mixer);
  55
  56 #ifdef HAVE_ALSA
  57
  58 #define WINE_MIXER_MANUF_ID      0xAA
  59 #define WINE_MIXER_PRODUCT_ID    0x55
  60 #define WINE_MIXER_VERSION       0x0100
  61
  62 /* Generic notes:
  63  * In windows it seems to be required for all controls to have a volume switch
  64  * In alsa that's optional
  65  *
  66  * I assume for playback controls, that there is always a playback volume switch available
  67  * Mute is optional
  68  *
  69  * For capture controls, it is needed that there is a capture switch and a volume switch,
  70  * It doesn't matter whether it is a playback volume switch or a capture volume switch.
  71  * The code will first try to get/adjust capture volume, if that fails it tries playback volume
  72  * It is not pretty, but under my 3 test cards it seems that there is no other choice:
  73  * Most capture controls don't have a capture volume setting
  74  *
  75  * MUX means that only capture source can be exclusively selected,
  76  * MIXER means that multiple sources can be selected simultaneously.
  77  */
  78
  79 static const char * getMessage(UINT uMsg)
  80 {
  81     static char str[64];
  82 #define MSG_TO_STR(x) case x: return #x;
  83     switch (uMsg){
  84     MSG_TO_STR(DRVM_INIT);
  85     MSG_TO_STR(DRVM_EXIT);
  86     MSG_TO_STR(DRVM_ENABLE);
  87     MSG_TO_STR(DRVM_DISABLE);
  88     MSG_TO_STR(MXDM_GETDEVCAPS);
  89     MSG_TO_STR(MXDM_GETLINEINFO);
  90     MSG_TO_STR(MXDM_GETNUMDEVS);
  91     MSG_TO_STR(MXDM_OPEN);
  92     MSG_TO_STR(MXDM_CLOSE);
  93     MSG_TO_STR(MXDM_GETLINECONTROLS);
  94     MSG_TO_STR(MXDM_GETCONTROLDETAILS);
  95     MSG_TO_STR(MXDM_SETCONTROLDETAILS);
  96     default: break;
  97     }
  98 #undef MSG_TO_STR
  99     sprintf(str, "UNKNOWN(%08x)", uMsg);
 100     return str;
 101 }
 102
 103 static const char * getControlType(DWORD dwControlType)
 104 {
 105 #define TYPE_TO_STR(x) case x: return #x;
 106     switch (dwControlType) {
 107     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_CUSTOM);
 108     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BOOLEANMETER);
 109     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SIGNEDMETER);
 110     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PEAKMETER);
 111     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER);
 112     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BOOLEAN);
 113     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_ONOFF);
 114     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MUTE);
 115     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MONO);
 116     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_LOUDNESS);
 117     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_STEREOENH);
 118     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BASS_BOOST);
 119     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BUTTON);
 120     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_DECIBELS);
 121     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SIGNED);
 122     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_UNSIGNED);
 123     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PERCENT);
 124     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SLIDER);
 125     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PAN);
 126     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_QSOUNDPAN);
 127     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_FADER);
 128     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_VOLUME);
 129     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BASS);
 130     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_TREBLE);
 131     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_EQUALIZER);
 132     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SINGLESELECT);
 133     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MUX);
 134     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT);
 135     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MIXER);
 136     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MICROTIME);
 137     TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MILLITIME);
 138     }
 139 #undef TYPE_TO_STR
 140     return wine_dbg_sprintf("UNKNOWN(%08x)", dwControlType);
 141 }
 142
 143 /* A simple declaration of a line control
 144  * These are each of the channels that show up
 145  */
 146 typedef struct line {
 147     /* Name we present to outside world */
 148     WCHAR name[MAXPNAMELEN];
 149
 150     DWORD component;
 151     DWORD dst;
 152     DWORD capt;
 153     DWORD chans;
 154     snd_mixer_elem_t *elem;
 155 } line;
 156
 157 /* A control structure, with toggle enabled switch
 158  * Control structures control volume, muted, which capture source
 159  */
 160 typedef struct control {
 161     BOOL enabled;
 162     MIXERCONTROLW c;
 163 } control;
 164
 165 /* Mixer device */
 166 typedef struct mixer
 167 {
 168     snd_mixer_t *mix;
 169     WCHAR mixername[MAXPNAMELEN];
 170
 171     int chans, dests;
 172     LPDRVCALLBACK callback;
 173     DWORD_PTR callbackpriv;
 174     HDRVR hmx;
 175
 176     line *lines;
 177     control *controls;
 178 } mixer;
 179
 180 #define MAX_MIXERS 32
 181 #define CONTROLSPERLINE 3
 182 #define OFS_MUTE 2
 183 #define OFS_MUX 1
 184
 185 static int cards = 0;
 186 static mixer mixdev[MAX_MIXERS];
 187 static HANDLE thread;
 188 static int elem_callback(snd_mixer_elem_t *elem, unsigned int mask);
 189 static DWORD WINAPI ALSA_MixerPollThread(LPVOID lParam);
 190 static CRITICAL_SECTION elem_crst;
 191 static int msg_pipe[2];
 192 static LONG refcnt;
 193
 194 /* found channel names in alsa lib, alsa api doesn't have another way for this
 195  * map name -> componenttype, worst case we get a wrong componenttype which is
 196  * mostly harmless
 197  */
 198
 199 static const struct mixerlinetype {
 200     const char *name;  DWORD cmpt;
 201 } converttable[] = {
 202     { "Master",     MIXERLINE_COMPONENTTYPE_DST_SPEAKERS,    },
 203     { "Capture",    MIXERLINE_COMPONENTTYPE_DST_WAVEIN,      },
 204     { "PCM",        MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT,     },
 205     { "PC Speaker", MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER,   },
 206     { "Synth",      MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER, },
 207     { "Headphone",  MIXERLINE_COMPONENTTYPE_DST_HEADPHONES,  },
 208     { "Mic",        MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE,  },
 209     { "Aux",        MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED,   },
 210     { "CD",         MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC, },
 211     { "Line",       MIXERLINE_COMPONENTTYPE_SRC_LINE,        },
 212     { "Phone",      MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE,   },
 213 };
 214
 215 /* Map name to MIXERLINE_COMPONENTTYPE_XXX */
 216 static int getcomponenttype(const char *name)
 217 {
 218     int x;
 219     for (x=0; x< sizeof(converttable)/sizeof(converttable[0]); ++x)
 220         if (!strcasecmp(name, converttable[x].name))
 221         {
 222             TRACE("%d -> %s\n", x, name);
 223             return converttable[x].cmpt;
 224         }
 225     WARN("Unknown mixer name %s, probably harmless\n", name);
 226     return MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED;
 227 }
 228
 229 /* Is this control suited for showing up? */
 230 static int blacklisted(snd_mixer_elem_t *elem)
 231 {
 232     const char *name = snd_mixer_selem_get_name(elem);
 233     BOOL blisted = 0;
 234
 235     if (!snd_mixer_selem_has_playback_volume(elem) &&
 236         (!snd_mixer_selem_has_capture_volume(elem) ||
 237          !snd_mixer_selem_has_capture_switch(elem)))
 238         blisted = 1;
 239
 240     TRACE("%s: %x\n", name, blisted);
 241     return blisted;
 242 }
 243
 244 static void fillcontrols(mixer *mmixer)
 245 {
 246     int id;
 247     for (id = 0; id < mmixer->chans; ++id)
 248     {
 249         line *mline = &mmixer->lines[id];
 250         int ofs = CONTROLSPERLINE * id;
 251         int x;
 252         long min, max;
 253
 254         TRACE("Filling control %d\n", id);
 255         if (id == 1 && !mline->elem)
 256             continue;
 257
 258         if (mline->capt && snd_mixer_selem_has_capture_volume(mline->elem))
 259             snd_mixer_selem_get_capture_volume_range(mline->elem, &min, &max);
 260         else
 261             snd_mixer_selem_get_playback_volume_range(mline->elem, &min, &max);
 262
 263         /* (!snd_mixer_selem_has_playback_volume(elem) || snd_mixer_selem_has_capture_volume(elem)) */
 264         /* Volume, always enabled by definition of blacklisted channels */
 265         mmixer->controls[ofs].enabled = 1;
 266         mmixer->controls[ofs].c.cbStruct = sizeof(mmixer->controls[ofs].c);
 267         mmixer->controls[ofs].c.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
 268         mmixer->controls[ofs].c.dwControlID = ofs;
 269         mmixer->controls[ofs].c.Bounds.s1.dwMinimum = 0;
 270         mmixer->controls[ofs].c.Bounds.s1.dwMaximum = 65535;
 271         mmixer->controls[ofs].c.Metrics.cSteps = 65536/(max-min);
 272
 273         if ((id == 1 && snd_mixer_selem_has_capture_switch(mline->elem)) ||
 274             (!mline->capt && snd_mixer_selem_has_playback_switch(mline->elem)))
 275         { /* MUTE button optional, main capture channel should have one too */
 276             mmixer->controls[ofs+OFS_MUTE].enabled = 1;
 277             mmixer->controls[ofs+OFS_MUTE].c.cbStruct = sizeof(mmixer->controls[ofs].c);
 278             mmixer->controls[ofs+OFS_MUTE].c.dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
 279             mmixer->controls[ofs+OFS_MUTE].c.dwControlID = ofs+OFS_MUTE;
 280             mmixer->controls[ofs+OFS_MUTE].c.Bounds.s1.dwMaximum = 1;
 281         }
 282
 283         if (mline->capt && snd_mixer_selem_has_capture_switch_exclusive(mline->elem))
 284             mmixer->controls[CONTROLSPERLINE+OFS_MUX].c.dwControlType = MIXERCONTROL_CONTROLTYPE_MUX;
 285
 286         if (id == 1)
 287         { /* Capture select, in case cMultipleItems is 0, it means capture is disabled anyway */
 288             mmixer->controls[ofs+OFS_MUX].enabled = 1;
 289             mmixer->controls[ofs+OFS_MUX].c.cbStruct = sizeof(mmixer->controls[ofs].c);
 290             mmixer->controls[ofs+OFS_MUX].c.dwControlType = MIXERCONTROL_CONTROLTYPE_MIXER;
 291             mmixer->controls[ofs+OFS_MUX].c.dwControlID = ofs+OFS_MUX;
 292             mmixer->controls[ofs+OFS_MUX].c.fdwControl = MIXERCONTROL_CONTROLF_MULTIPLE;
 293
 294             for (x = 0; x<mmixer->chans; ++x)
 295                 if (x != id && mmixer->lines[x].dst == id)
 296                     ++(mmixer->controls[ofs+OFS_MUX].c.cMultipleItems);
 297             if (!mmixer->controls[ofs+OFS_MUX].c.cMultipleItems)
 298                 mmixer->controls[ofs+OFS_MUX].enabled = 0;
 299
 300             mmixer->controls[ofs+OFS_MUX].c.Bounds.s1.dwMaximum = mmixer->controls[ofs+OFS_MUX].c.cMultipleItems - 1;
 301             mmixer->controls[ofs+OFS_MUX].c.Metrics.cSteps = mmixer->controls[ofs+OFS_MUX].c.cMultipleItems;
 302         }
 303         for (x=0; x<CONTROLSPERLINE; ++x)
 304         {
 305             lstrcpynW(mmixer->controls[ofs+x].c.szShortName, mline->name, sizeof(mmixer->controls[ofs+x].c.szShortName)/sizeof(WCHAR));
 306             lstrcpynW(mmixer->controls[ofs+x].c.szName, mline->name, sizeof(mmixer->controls[ofs+x].c.szName)/sizeof(WCHAR));
 307         }
 308     }
 309 }
 310
 311 /* get amount of channels for elem */
 312 /* Officially we should keep capture/playback separated,
 313  * but that's not going to work in the alsa api */
 314 static int chans(mixer *mmixer, snd_mixer_elem_t * elem, DWORD capt)
 315 {
 316     int ret=0, chn;
 317
 318     if (capt && snd_mixer_selem_has_capture_volume(elem)) {
 319         for (chn = 0; chn <= SND_MIXER_SCHN_LAST; ++chn)
 320             if (snd_mixer_selem_has_capture_channel(elem, chn))
 321                 ++ret;
 322     } else {
 323         for (chn = 0; chn <= SND_MIXER_SCHN_LAST; ++chn)
 324             if (snd_mixer_selem_has_playback_channel(elem, chn))
 325                 ++ret;
 326     }
 327     if (!ret)
 328         FIXME("Mixer channel %s was found for %s, but no channels were found? Wrong selection!\n", snd_mixer_selem_get_name(elem), (snd_mixer_selem_has_playback_volume(elem) ? "playback" : "capture"));
 329     return ret;
 330 }
 331
 332 static void filllines(mixer *mmixer, snd_mixer_elem_t *mastelem, snd_mixer_elem_t *captelem, int capt)
 333 {
 334     snd_mixer_elem_t *elem;
 335     line *mline = mmixer->lines;
 336
 337     /* Master control */
 338     MultiByteToWideChar(CP_UNIXCP, 0, snd_mixer_selem_get_name(mastelem), -1, mline->name, sizeof(mline->name)/sizeof(WCHAR));
 339     mline->component = getcomponenttype(snd_mixer_selem_get_name(mastelem));
 340     mline->dst = 0;
 341     mline->capt = 0;
 342     mline->elem = mastelem;
 343     mline->chans = chans(mmixer, mastelem, 0);
 344
 345     snd_mixer_elem_set_callback(mastelem, &elem_callback);
 346     snd_mixer_elem_set_callback_private(mastelem, &mmixer);
 347
 348     /* Capture control
 349      * Note: since mmixer->dests = 1, it means only playback control is visible
 350      * This makes sense, because if there are no capture sources capture control
 351      * can't do anything and should be invisible */
 352
 353     /* Control 1 is reserved for capture even when not enabled */
 354     ++mline;
 355     if (capt)
 356     {
 357         MultiByteToWideChar(CP_UNIXCP, 0, snd_mixer_selem_get_name(captelem), -1, mline->name, sizeof(mline->name)/sizeof(WCHAR));
 358         mline->component = getcomponenttype(snd_mixer_selem_get_name(captelem));
 359         mline->dst = 1;
 360         mline->capt = 1;
 361         mline->elem = captelem;
 362         mline->chans = chans(mmixer, captelem, 1);
 363
 364         snd_mixer_elem_set_callback(captelem, &elem_callback);
 365         snd_mixer_elem_set_callback_private(captelem, &mmixer);
 366     }
 367
 368     for (elem = snd_mixer_first_elem(mmixer->mix); elem; elem = snd_mixer_elem_next(elem))
 369         if (elem != mastelem && elem != captelem && !blacklisted(elem))
 370         {
 371             const char * name = snd_mixer_selem_get_name(elem);
 372             DWORD comp = getcomponenttype(name);
 373
 374             if (snd_mixer_selem_has_playback_volume(elem))
 375             {
 376                 (++mline)->component = comp;
 377                 MultiByteToWideChar(CP_UNIXCP, 0, name, -1, mline->name, MAXPNAMELEN);
 378                 mline->capt = mline->dst = 0;
 379                 mline->elem = elem;
 380                 mline->chans = chans(mmixer, elem, 0);
 381             }
 382             else if (!capt)
 383                 continue;
 384
 385             if (capt && snd_mixer_selem_has_capture_switch(elem))
 386             {
 387                 (++mline)->component = comp;
 388                 MultiByteToWideChar(CP_UNIXCP, 0, name, -1, mline->name, MAXPNAMELEN);
 389                 mline->capt = mline->dst = 1;
 390                 mline->elem = elem;
 391                 mline->chans = chans(mmixer, elem, 1);
 392             }
 393
 394             snd_mixer_elem_set_callback(elem, &elem_callback);
 395             snd_mixer_elem_set_callback_private(elem, &mmixer);
 396         }
 397 }
 398
 399 /* Windows api wants to have a 'master' device to which all slaves are attached
 400  * There are 2 ones in this code:
 401  * - 'Master', fall back to 'Headphone' if unavailable, and if that's not available 'PCM'
 402  * - 'Capture'
 403  * Capture might not always be available, so should be prepared to be without if needed
 404  */
 405
 406 static void ALSA_MixerInit(void)
 407 {
 408     int x, mixnum = 0;
 409
 410     for (x = 0; x < MAX_MIXERS; ++x)
 411     {
 412         int card, err, capcontrols = 0;
 413         char cardind[6], cardname[10];
 414
 415         snd_ctl_t *ctl;
 416         snd_mixer_elem_t *elem, *mastelem = NULL, *headelem = NULL, *captelem = NULL, *pcmelem = NULL;
 417         snd_ctl_card_info_t *info = NULL;
 418         snd_ctl_card_info_alloca(&info);
 419
 420         memset(&mixdev[mixnum], 0, sizeof(*mixdev));
 421         snprintf(cardind, sizeof(cardind), "%d", x);
 422         card = snd_card_get_index(cardind);
 423         if (card < 0)
 424             continue;
 425
 426         snprintf(cardname, sizeof(cardname), "hw:%d", card);
 427
 428         err = snd_ctl_open(&ctl, cardname, 0);
 429         if (err < 0)
 430         {
 431             WARN("Cannot open card: %s\n", snd_strerror(err));
 432             continue;
 433         }
 434
 435         err = snd_ctl_card_info(ctl, info);
 436         if (err < 0)
 437         {
 438             WARN("Cannot get card info: %s\n", snd_strerror(err));
 439             snd_ctl_close(ctl);
 440             continue;
 441         }
 442
 443         MultiByteToWideChar(CP_UNIXCP, 0, snd_ctl_card_info_get_name(info), -1, mixdev[mixnum].mixername, sizeof(mixdev[mixnum].mixername)/sizeof(WCHAR));
 444         snd_ctl_close(ctl);
 445
 446         err = snd_mixer_open(&mixdev[mixnum].mix, 0);
 447         if (err < 0)
 448         {
 449             WARN("Error occurred opening mixer: %s\n", snd_strerror(err));
 450             continue;
 451         }
 452
 453         err = snd_mixer_attach(mixdev[mixnum].mix, cardname);
 454         if (err < 0)
 455             goto eclose;
 456
 457         err = snd_mixer_selem_register(mixdev[mixnum].mix, NULL, NULL);
 458         if (err < 0)
 459             goto eclose;
 460
 461         err = snd_mixer_load(mixdev[mixnum].mix);
 462         if (err < 0)
 463             goto eclose;
 464
 465         /* First, lets see what's available..
 466          * If there are multiple Master or Captures, all except 1 will be added as slaves
 467          */
 468         for (elem = snd_mixer_first_elem(mixdev[mixnum].mix); elem; elem = snd_mixer_elem_next(elem))
 469             if (!strcasecmp(snd_mixer_selem_get_name(elem), "Master") && !mastelem)
 470                 mastelem = elem;
 471             else if (!strcasecmp(snd_mixer_selem_get_name(elem), "Capture") && !captelem)
 472                 captelem = elem;
 473             else if (!blacklisted(elem))
 474             {
 475                 if (snd_mixer_selem_has_capture_switch(elem))
 476                     ++capcontrols;
 477                 if (snd_mixer_selem_has_playback_volume(elem))
 478                 {
 479                     if (!strcasecmp(snd_mixer_selem_get_name(elem), "Headphone") && !headelem)
 480                         headelem = elem;
 481                     else if (!strcasecmp(snd_mixer_selem_get_name(elem), "PCM") && !pcmelem)
 482                         pcmelem = elem;
 483                     else
 484                         ++(mixdev[mixnum].chans);
 485                 }
 486             }
 487
 488         /* Add master channel, uncounted channels and an extra for capture  */
 489         mixdev[mixnum].chans += !!mastelem + !!headelem + !!pcmelem + 1;
 490
 491         /* If there is only 'Capture' and 'Master', this device is not worth it */
 492         if (mixdev[mixnum].chans == 2)
 493         {
 494             WARN("No channels found, skipping device!\n");
 495             goto close;
 496         }
 497
 498         /* Master element can't have a capture control in this code, so
 499          * if Headphone or PCM is promoted to master, unset its capture control */
 500         if (headelem && !mastelem)
 501         {
 502             /* Using 'Headphone' as master device */
 503             mastelem = headelem;
 504             capcontrols -= !!snd_mixer_selem_has_capture_switch(mastelem);
 505         }
 506         else if (pcmelem && !mastelem)
 507         {
 508             /* Use 'PCM' as master device */
 509             mastelem = pcmelem;
 510             capcontrols -= !!snd_mixer_selem_has_capture_switch(mastelem);
 511         }
 512         else if (!mastelem)
 513         {
 514             /* If there is nothing sensible that can act as 'Master' control, something is wrong */
 515             FIXME("No master control found, disabling mixer\n");
 516             goto close;
 517         }
 518
 519         if (!captelem || !capcontrols)
 520         {
 521             /* Can't enable capture, so disabling it
 522              * Note: capture control will still exist because
 523              * dwLineID 0 and 1 are reserved for Master and Capture
 524              */
 525             WARN("No use enabling capture part of mixer, capture control found: %s, amount of capture controls: %d\n",
 526                  (!captelem ? "no" : "yes"), capcontrols);
 527             capcontrols = 0;
 528             mixdev[mixnum].dests = 1;
 529         }
 530         else
 531         {
 532             mixdev[mixnum].chans += capcontrols;
 533             mixdev[mixnum].dests = 2;
 534         }
 535
 536         mixdev[mixnum].lines = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(line) * mixdev[mixnum].chans);
 537         mixdev[mixnum].controls = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(control) * CONTROLSPERLINE*mixdev[mixnum].chans);
 538         err = -ENOMEM;
 539         if (!mixdev[mixnum].lines || !mixdev[mixnum].controls)
 540             goto close;
 541
 542         filllines(&mixdev[mixnum], mastelem, captelem, capcontrols);
 543         fillcontrols(&mixdev[mixnum]);
 544
 545         TRACE("%s: Amount of controls: %i/%i, name: %s\n", cardname, mixdev[mixnum].dests, mixdev[mixnum].chans, debugstr_w(mixdev[mixnum].mixername));
 546         mixnum++;
 547         continue;
 548
 549         eclose:
 550         WARN("Error occurred initialising mixer: %s\n", snd_strerror(err));
 551         close:
 552         HeapFree(GetProcessHeap(), 0, mixdev[mixnum].lines);
 553         HeapFree(GetProcessHeap(), 0, mixdev[mixnum].controls);
 554         snd_mixer_close(mixdev[mixnum].mix);
 555     }
 556     cards = mixnum;
 557
 558     /* There is no trouble with already assigning callbacks without initialising critsect:
 559      * Callbacks only occur when snd_mixer_handle_events is called (only happens in thread)
 560      */
 561     InitializeCriticalSection(&elem_crst);
 562     elem_crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ALSA_MIXER.elem_crst");
 563     TRACE("\n");
 564 }
 565
 566 static void ALSA_MixerExit(void)
 567 {
 568     int x;
 569
 570     if (refcnt)
 571     {
 572         WARN("Callback thread still alive, terminating uncleanly, refcnt: %d\n", refcnt);
 573         /* Least we can do is making sure we're not in 'foreign' code */
 574         EnterCriticalSection(&elem_crst);
 575         TerminateThread(thread, 1);
 576         refcnt = 0;
 577     }
 578
 579     TRACE("Cleaning up\n");
 580
 581     elem_crst.DebugInfo->Spare[0] = 0;
 582     DeleteCriticalSection(&elem_crst);
 583     for (x = 0; x < cards; ++x)
 584     {
 585         snd_mixer_close(mixdev[x].mix);
 586         HeapFree(GetProcessHeap(), 0, mixdev[x].lines);
 587         HeapFree(GetProcessHeap(), 0, mixdev[x].controls);
 588     }
 589     cards = 0;
 590 }
 591
 592 static mixer* MIX_GetMix(UINT wDevID)
 593 {
 594     mixer *mmixer;
 595
 596     if (wDevID < 0 || wDevID >= cards)
 597     {
 598         WARN("Invalid mixer id: %d\n", wDevID);
 599         return NULL;
 600     }
 601
 602     mmixer = &mixdev[wDevID];
 603     return mmixer;
 604 }
 605
 606 /* Since alsa doesn't tell what exactly changed, just assume all affected controls changed */
 607 static int elem_callback(snd_mixer_elem_t *elem, unsigned int type)
 608 {
 609     mixer *mmixer = snd_mixer_elem_get_callback_private(elem);
 610     int x;
 611     BOOL captchanged = 0;
 612
 613     if (type != SND_CTL_EVENT_MASK_VALUE)
 614         return 0;
 615
 616     assert(mmixer);
 617
 618     EnterCriticalSection(&elem_crst);
 619
 620     if (!mmixer->callback)
 621         goto out;
 622
 623     for (x=0; x<mmixer->chans; ++x)
 624     {
 625         const int ofs = CONTROLSPERLINE*x;
 626         if (elem != mmixer->lines[x].elem)
 627             continue;
 628
 629         if (mmixer->lines[x].capt)
 630             ++captchanged;
 631
 632         TRACE("Found changed control %s\n", debugstr_w(mmixer->lines[x].name));
 633         mmixer->callback(mmixer->hmx, MM_MIXM_LINE_CHANGE, mmixer->callbackpriv, x, 0);
 634         mmixer->callback(mmixer->hmx, MM_MIXM_CONTROL_CHANGE, mmixer->callbackpriv, ofs, 0);
 635
 636         if (mmixer->controls[ofs+OFS_MUTE].enabled)
 637             mmixer->callback(mmixer->hmx, MM_MIXM_CONTROL_CHANGE, mmixer->callbackpriv, ofs+OFS_MUTE, 0);
 638     }
 639     if (captchanged)
 640         mmixer->callback(mmixer->hmx, MM_MIXM_CONTROL_CHANGE, mmixer->callbackpriv, CONTROLSPERLINE+OFS_MUX, 0);
 641
 642     out:
 643     LeaveCriticalSection(&elem_crst);
 644
 645     return 0;
 646 }
 647
 648 static DWORD WINAPI ALSA_MixerPollThread(LPVOID lParam)
 649 {
 650     struct pollfd *pfds = NULL;
 651     int x, y, err, mcnt, count = 1;
 652
 653     TRACE("%p\n", lParam);
 654
 655     for (x = 0; x < cards; ++x)
 656         count += snd_mixer_poll_descriptors_count(mixdev[x].mix);
 657
 658     TRACE("Counted %d descriptors\n", count);
 659     pfds = HeapAlloc(GetProcessHeap(), 0, count * sizeof(struct pollfd));
 660
 661     if (!pfds)
 662     {
 663         WARN("Out of memory\n");
 664         goto die;
 665     }
 666
 667     pfds[0].fd = msg_pipe[0];
 668     pfds[0].events = POLLIN;
 669
 670     y = 1;
 671     for (x = 0; x < cards; ++x)
 672         y += snd_mixer_poll_descriptors(mixdev[x].mix, &pfds[y], count - y);
 673
 674     while ((err = poll(pfds, (unsigned int) count, -1)) >= 0 || errno == EINTR || errno == EAGAIN)
 675     {
 676         if (pfds[0].revents & POLLIN)
 677             break;
 678
 679         mcnt = 1;
 680         for (x = y = 0; x < cards; ++x)
 681         {
 682             int j, max = snd_mixer_poll_descriptors_count(mixdev[x].mix);
 683             for (j = 0; j < max; ++j)
 684                 if (pfds[mcnt+j].revents)
 685                 {
 686                     y += snd_mixer_handle_events(mixdev[x].mix);
 687                     break;
 688                 }
 689             mcnt += max;
 690         }
 691         if (y)
 692             TRACE("Handled %d events\n", y);
 693     }
 694
 695     die:
 696     TRACE("Shutting down\n");
 697     HeapFree(GetProcessHeap(), 0, pfds);
 698
 699     y = read(msg_pipe[0], &x, sizeof(x));
 700     close(msg_pipe[1]);
 701     close(msg_pipe[0]);
 702     return 0;
 703 }
 704
 705 static DWORD MIX_Open(UINT wDevID, LPMIXEROPENDESC desc, DWORD_PTR flags)
 706 {
 707     mixer *mmixer = MIX_GetMix(wDevID);
 708     if (!mmixer)
 709         return MMSYSERR_BADDEVICEID;
 710
 711     flags &= CALLBACK_TYPEMASK;
 712     switch (flags)
 713     {
 714     case CALLBACK_NULL:
 715         goto done;
 716
 717     case CALLBACK_FUNCTION:
 718         break;
 719
 720     default:
 721         FIXME("Unhandled callback type: %08lx\n", flags & CALLBACK_TYPEMASK);
 722         return MIXERR_INVALVALUE;
 723     }
 724
 725     mmixer->callback = (LPDRVCALLBACK)desc->dwCallback;
 726     mmixer->callbackpriv = desc->dwInstance;
 727     mmixer->hmx = (HDRVR)desc->hmx;
 728
 729     done:
 730     if (InterlockedIncrement(&refcnt) == 1)
 731     {
 732         if (pipe(msg_pipe) >= 0)
 733         {
 734             thread = CreateThread(NULL, 0, ALSA_MixerPollThread, NULL, 0, NULL);
 735             if (!thread)
 736             {
 737                 close(msg_pipe[0]);
 738                 close(msg_pipe[1]);
 739                 msg_pipe[0] = msg_pipe[1] = -1;
 740             }
 741         }
 742         else
 743             msg_pipe[0] = msg_pipe[1] = -1;
 744     }
 745
 746     return MMSYSERR_NOERROR;
 747 }
 748
 749 static DWORD MIX_Close(UINT wDevID)
 750 {
 751     int x;
 752     mixer *mmixer = MIX_GetMix(wDevID);
 753     if (!mmixer)
 754         return MMSYSERR_BADDEVICEID;
 755
 756     EnterCriticalSection(&elem_crst);
 757     mmixer->callback = 0;
 758     LeaveCriticalSection(&elem_crst);
 759
 760     if (!InterlockedDecrement(&refcnt))
 761     {
 762         if (write(msg_pipe[1], &x, sizeof(x)) > 0)
 763         {
 764             TRACE("Shutting down thread...\n");
 765             WaitForSingleObject(thread, INFINITE);
 766             TRACE("Done\n");
 767         }
 768     }
 769
 770     return MMSYSERR_NOERROR;
 771 }
 772
 773 static DWORD MIX_GetDevCaps(UINT wDevID, LPMIXERCAPS2W caps, DWORD_PTR parm2)
 774 {
 775     mixer *mmixer = MIX_GetMix(wDevID);
 776     MIXERCAPS2W capsW;
 777
 778     if (!caps)
 779         return MMSYSERR_INVALPARAM;
 780
 781     if (!mmixer)
 782         return MMSYSERR_BADDEVICEID;
 783
 784     memset(&capsW, 0, sizeof(MIXERCAPS2W));
 785
 786     capsW.wMid = WINE_MIXER_MANUF_ID;
 787     capsW.wPid = WINE_MIXER_PRODUCT_ID;
 788     capsW.vDriverVersion = WINE_MIXER_VERSION;
 789
 790     lstrcpynW(capsW.szPname, mmixer->mixername, sizeof(capsW.szPname)/sizeof(WCHAR));
 791     capsW.cDestinations = mmixer->dests;
 792     memcpy(caps, &capsW, min(parm2, sizeof(capsW)));
 793     return MMSYSERR_NOERROR;
 794 }
 795
 796 /* convert win32 volume to alsa volume, and vice versa */
 797 static INT normalized(INT value, INT prevmax, INT nextmax)
 798 {
 799     int ret = MulDiv(value, nextmax, prevmax);
 800
 801     /* Have to stay in range */
 802     TRACE("%d/%d -> %d/%d\n", value, prevmax, ret, nextmax);
 803     if (ret > nextmax)
 804         ret = nextmax;
 805     else if (ret < 0)
 806         ret = 0;
 807
 808     return ret;
 809 }
 810
 811 /* get amount of sources for dest */
 812 static int getsrccntfromchan(mixer *mmixer, int dad)
 813 {
 814     int i, j=0;
 815
 816     for (i=0; i<mmixer->chans; ++i)
 817         if (i != dad && mmixer->lines[i].dst == dad)
 818         {
 819             ++j;
 820         }
 821     if (!j)
 822         FIXME("No src found for %i (%s)?\n", dad, debugstr_w(mmixer->lines[dad].name));
 823     return j;
 824 }
 825
 826 /* find lineid for source 'num' with dest 'dad' */
 827 static int getsrclinefromchan(mixer *mmixer, int dad, int num)
 828 {
 829     int i, j=0;
 830     for (i=0; i<mmixer->chans; ++i)
 831         if (i != dad && mmixer->lines[i].dst == dad)
 832         {
 833             if (num == j)
 834                 return i;
 835             ++j;
 836         }
 837     WARN("No src found for src %i from dest %i\n", num, dad);
 838     return 0;
 839 }
 840
 841 /* get the source number belonging to line */
 842 static int getsrcfromline(mixer *mmixer, int line)
 843 {
 844     int i, j=0, dad = mmixer->lines[line].dst;
 845
 846     for (i=0; i<mmixer->chans; ++i)
 847         if (i != dad && mmixer->lines[i].dst == dad)
 848         {
 849             if (line == i)
 850                 return j;
 851             ++j;
 852         }
 853     WARN("No src found for line %i with dad %i\n", line, dad);
 854     return 0;
 855 }
 856
 857 /* Get volume/muted/capture channel */
 858 static DWORD MIX_GetControlDetails(UINT wDevID, LPMIXERCONTROLDETAILS mctrld, DWORD_PTR flags)
 859 {
 860     mixer *mmixer = MIX_GetMix(wDevID);
 861     DWORD ctrl;
 862     DWORD line;
 863     control *ct;
 864
 865     if (!mctrld)
 866         return MMSYSERR_INVALPARAM;
 867
 868     ctrl = mctrld->dwControlID;
 869     line = ctrl/CONTROLSPERLINE;
 870
 871     if (mctrld->cbStruct != sizeof(*mctrld))
 872         return MMSYSERR_INVALPARAM;
 873
 874     if (!mmixer)
 875         return MMSYSERR_BADDEVICEID;
 876
 877     if (line < 0 || line >= mmixer->chans || !mmixer->controls[ctrl].enabled)
 878         return MIXERR_INVALCONTROL;
 879
 880     ct = &mmixer->controls[ctrl];
 881
 882     flags &= MIXER_GETCONTROLDETAILSF_QUERYMASK;
 883
 884     switch (flags) {
 885     case MIXER_GETCONTROLDETAILSF_VALUE:
 886         TRACE("MIXER_GETCONTROLDETAILSF_VALUE (%d/%d)\n", ctrl, line);
 887         switch (ct->c.dwControlType)
 888         {
 889         case MIXERCONTROL_CONTROLTYPE_VOLUME:
 890         {
 891             long min = 0, max = 0, vol = 0;
 892             int chn;
 893             LPMIXERCONTROLDETAILS_UNSIGNED mcdu;
 894             snd_mixer_elem_t * elem = mmixer->lines[line].elem;
 895
 896             if (mctrld->cbDetails != sizeof(MIXERCONTROLDETAILS_UNSIGNED))
 897             {
 898                 WARN("invalid parameter: cbDetails %d\n", mctrld->cbDetails);
 899                 return MMSYSERR_INVALPARAM;
 900             }
 901
 902             TRACE("%s MIXERCONTROLDETAILS_UNSIGNED[%u]\n", getControlType(ct->c.dwControlType), mctrld->cChannels);
 903
 904             mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)mctrld->paDetails;
 905
 906             if (mctrld->cChannels != 1 && mmixer->lines[line].chans != mctrld->cChannels)
 907             {
 908                 WARN("Unsupported cChannels (%d instead of %d)\n", mctrld->cChannels, mmixer->lines[line].chans);
 909                 return MMSYSERR_INVALPARAM;
 910             }
 911
 912             if (mmixer->lines[line].capt && snd_mixer_selem_has_capture_volume(elem)) {
 913                 snd_mixer_selem_get_capture_volume_range(elem, &min, &max);
 914                 for (chn = 0; chn <= SND_MIXER_SCHN_LAST; ++chn)
 915                     if (snd_mixer_selem_has_capture_channel(elem, chn))
 916                     {
 917                         snd_mixer_selem_get_capture_volume(elem, chn, &vol);
 918                         mcdu->dwValue = normalized(vol - min, max, 65535);
 919                         if (mctrld->cChannels == 1)
 920                             break;
 921                         ++mcdu;
 922                     }
 923             } else {
 924                 snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
 925
 926                 for (chn = 0; chn <= SND_MIXER_SCHN_LAST; ++chn)
 927                     if (snd_mixer_selem_has_playback_channel(elem, chn))
 928                     {
 929                         snd_mixer_selem_get_playback_volume(elem, chn, &vol);
 930                         mcdu->dwValue = normalized(vol - min, max, 65535);
 931                         if (mctrld->cChannels == 1)
 932                             break;
 933                         ++mcdu;
 934                     }
 935             }
 936
 937             return MMSYSERR_NOERROR;
 938         }
 939
 940         case MIXERCONTROL_CONTROLTYPE_ONOFF:
 941         case MIXERCONTROL_CONTROLTYPE_MUTE:
 942         {
 943             LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
 944             int chn, ival;
 945             snd_mixer_elem_t * elem = mmixer->lines[line].elem;
 946
 947             if (mctrld->cbDetails != sizeof(MIXERCONTROLDETAILS_BOOLEAN))
 948             {
 949                 WARN("invalid parameter: cbDetails %d\n", mctrld->cbDetails);
 950                 return MMSYSERR_INVALPARAM;
 951             }
 952
 953             TRACE("%s MIXERCONTROLDETAILS_BOOLEAN[%u]\n", getControlType(ct->c.dwControlType), mctrld->cChannels);
 954
 955             mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)mctrld->paDetails;
 956
 957             if (line == 1)
 958                 for (chn = 0; chn <= SND_MIXER_SCHN_LAST; ++chn)
 959                 {
 960                     if (!snd_mixer_selem_has_capture_channel(elem, chn))
 961                         continue;
 962                     snd_mixer_selem_get_capture_switch(elem, chn, &ival);
 963                     break;
 964                 }
 965             else
 966                 for (chn = 0; chn <= SND_MIXER_SCHN_LAST; ++chn)
 967                 {
 968                     if (!snd_mixer_selem_has_playback_channel(elem, chn))
 969                         continue;
 970                     snd_mixer_selem_get_playback_switch(elem, chn, &ival);
 971                     break;
 972                 }
 973
 974             mcdb->fValue = !ival;
 975             TRACE("=> %s\n", mcdb->fValue ? "on" : "off");
 976             return MMSYSERR_NOERROR;
 977         }
 978         case MIXERCONTROL_CONTROLTYPE_MIXER:
 979         case MIXERCONTROL_CONTROLTYPE_MUX:
 980         {
 981             LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
 982             int x, i=0, ival = 0, chn;
 983
 984             if (mctrld->cbDetails != sizeof(MIXERCONTROLDETAILS_BOOLEAN))
 985             {
 986                 WARN("invalid parameter: cbDetails %d\n", mctrld->cbDetails);
 987                 return MMSYSERR_INVALPARAM;
 988             }
 989
 990             TRACE("%s MIXERCONTROLDETAILS_BOOLEAN[%u]\n", getControlType(ct->c.dwControlType), mctrld->cChannels);
 991
 992             mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)mctrld->paDetails;
 993
 994             for (x = 0; x<mmixer->chans; ++x)
 995                 if (line != x && mmixer->lines[x].dst == line)
 996                 {
 997                     ival = 0;
 998                     for (chn = 0; chn <= SND_MIXER_SCHN_LAST; ++chn)
 999                     {
1000                         if (!snd_mixer_selem_has_capture_channel(mmixer->lines[x].elem, chn))
1001                             continue;
1002                         snd_mixer_selem_get_capture_switch(mmixer->lines[x].elem, chn, &ival);
1003                         if (ival)
1004                             break;
1005                     }
1006                     if (i >= mctrld->u.cMultipleItems)
1007                     {
1008                         TRACE("overflow\n");
1009                         return MMSYSERR_INVALPARAM;
1010                     }
1011                     TRACE("fVal[%i] = %sselected\n", i, (!ival ? "un" : ""));
1012                     mcdb[i++].fValue = ival;
1013                 }
1014             break;
1015         }
1016         default:
1017
1018             FIXME("Unhandled controltype %s\n", getControlType(ct->c.dwControlType));
1019             return MMSYSERR_INVALPARAM;
1020         }
1021         return MMSYSERR_NOERROR;
1022
1023     case MIXER_GETCONTROLDETAILSF_LISTTEXT:
1024         TRACE("MIXER_GETCONTROLDETAILSF_LISTTEXT (%d)\n", ctrl);
1025
1026         if (ct->c.dwControlType == MIXERCONTROL_CONTROLTYPE_MUX || ct->c.dwControlType == MIXERCONTROL_CONTROLTYPE_MIXER)
1027         {
1028             LPMIXERCONTROLDETAILS_LISTTEXTW mcdlt = (LPMIXERCONTROLDETAILS_LISTTEXTW)mctrld->paDetails;
1029             int i, j;
1030
1031             for (i = j = 0; j < mmixer->chans; ++j)
1032                 if (j != line && mmixer->lines[j].dst == line)
1033                 {
1034                     if (i > mctrld->u.cMultipleItems)
1035                         return MMSYSERR_INVALPARAM;
1036                     mcdlt->dwParam1 = j;
1037                     mcdlt->dwParam2 = mmixer->lines[j].component;
1038                     lstrcpynW(mcdlt->szName, mmixer->lines[j].name, sizeof(mcdlt->szName) / sizeof(WCHAR));
1039                     TRACE("Adding %i as %s\n", j, debugstr_w(mcdlt->szName));
1040                     ++i; ++mcdlt;
1041                 }
1042             if (i < mctrld->u.cMultipleItems)
1043                 return MMSYSERR_INVALPARAM;
1044             return MMSYSERR_NOERROR;
1045         }
1046         FIXME ("Imagine this code being horribly broken and incomplete, introducing: reality\n");
1047         return MMSYSERR_INVALPARAM;
1048
1049     default:
1050         WARN("Unknown flag (%08lx)\n", flags);
1051         return MMSYSERR_INVALPARAM;
1052     }
1053 }
1054
1055 /* Set volume/capture channel/muted for control */
1056 static DWORD MIX_SetControlDetails(UINT wDevID, LPMIXERCONTROLDETAILS mctrld, DWORD_PTR flags)
1057 {
1058     mixer *mmixer = MIX_GetMix(wDevID);
1059     DWORD ctrl, line, i;
1060     control *ct;
1061     snd_mixer_elem_t * elem;
1062
1063     if (!mctrld)
1064         return MMSYSERR_INVALPARAM;
1065
1066     ctrl = mctrld->dwControlID;
1067     line = ctrl/CONTROLSPERLINE;
1068
1069     if (mctrld->cbStruct != sizeof(*mctrld))
1070     {
1071         WARN("Invalid size of mctrld %d\n", mctrld->cbStruct);
1072         return MMSYSERR_INVALPARAM;
1073     }
1074
1075     if (!mmixer)
1076         return MMSYSERR_BADDEVICEID;
1077
1078     if (line < 0 || line >= mmixer->chans)
1079     {
1080         WARN("Invalid line id: %d not in range of 0-%d\n", line, mmixer->chans-1);
1081         return MMSYSERR_INVALPARAM;
1082     }
1083
1084     if (!mmixer->controls[ctrl].enabled)
1085     {
1086         WARN("Control %d not enabled\n", ctrl);
1087         return MIXERR_INVALCONTROL;
1088     }
1089
1090     ct = &mmixer->controls[ctrl];
1091     elem = mmixer->lines[line].elem;
1092     flags &= MIXER_SETCONTROLDETAILSF_QUERYMASK;
1093
1094     switch (flags) {
1095     case MIXER_SETCONTROLDETAILSF_VALUE:
1096         TRACE("MIXER_SETCONTROLDETAILSF_VALUE (%d)\n", ctrl);
1097         break;
1098
1099     default:
1100         WARN("Unknown flag (%08lx)\n", flags);
1101         return MMSYSERR_INVALPARAM;
1102     }
1103
1104     switch (ct->c.dwControlType)
1105     {
1106     case MIXERCONTROL_CONTROLTYPE_VOLUME:
1107     {
1108         long min = 0, max = 0;
1109         int chn;
1110         LPMIXERCONTROLDETAILS_UNSIGNED mcdu;
1111         snd_mixer_elem_t * elem = mmixer->lines[line].elem;
1112
1113         if (mctrld->cbDetails != sizeof(MIXERCONTROLDETAILS_UNSIGNED))
1114         {
1115             WARN("invalid parameter: cbDetails %d\n", mctrld->cbDetails);
1116             return MMSYSERR_INVALPARAM;
1117         }
1118
1119         if (mctrld->cChannels != 1 && mmixer->lines[line].chans != mctrld->cChannels)
1120         {
1121             WARN("Unsupported cChannels (%d instead of %d)\n", mctrld->cChannels, mmixer->lines[line].chans);
1122             return MMSYSERR_INVALPARAM;
1123         }
1124
1125         TRACE("%s MIXERCONTROLDETAILS_UNSIGNED[%u]\n", getControlType(ct->c.dwControlType), mctrld->cChannels);
1126         mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)mctrld->paDetails;
1127
1128         for (chn=0; chn<mctrld->cChannels;++chn)
1129         {
1130             TRACE("Chan %d value %d\n", chn, mcdu[chn].dwValue);
1131         }
1132
1133         /* There isn't always a capture volume, so in that case change playback volume */
1134         if (mmixer->lines[line].capt && snd_mixer_selem_has_capture_volume(elem))
1135         {
1136             snd_mixer_selem_get_capture_volume_range(elem, &min, &max);
1137
1138             for (chn = 0; chn <= SND_MIXER_SCHN_LAST; ++chn)
1139                 if (snd_mixer_selem_has_capture_channel(elem, chn))
1140                 {
1141                     snd_mixer_selem_set_capture_volume(elem, chn, min + normalized(mcdu->dwValue, 65535, max));
1142                     if (mctrld->cChannels != 1)
1143                         mcdu++;
1144                 }
1145         }
1146         else
1147         {
1148             snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
1149
1150             for (chn = 0; chn <= SND_MIXER_SCHN_LAST; ++chn)
1151                 if (snd_mixer_selem_has_playback_channel(elem, chn))
1152                 {
1153                     snd_mixer_selem_set_playback_volume(elem, chn, min + normalized(mcdu->dwValue, 65535, max));
1154                     if (mctrld->cChannels != 1)
1155                         mcdu++;
1156                 }
1157         }
1158
1159         break;
1160     }
1161     case MIXERCONTROL_CONTROLTYPE_MUTE:
1162     case MIXERCONTROL_CONTROLTYPE_ONOFF:
1163     {
1164         LPMIXERCONTROLDETAILS_BOOLEAN   mcdb;
1165
1166         if (mctrld->cbDetails != sizeof(MIXERCONTROLDETAILS_BOOLEAN))
1167         {
1168             WARN("invalid parameter: cbDetails %d\n", mctrld->cbDetails);
1169             return MMSYSERR_INVALPARAM;
1170         }
1171
1172         TRACE("%s MIXERCONTROLDETAILS_BOOLEAN[%u]\n", getControlType(ct->c.dwControlType), mctrld->cChannels);
1173
1174         mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)mctrld->paDetails;
1175         if (line == 1) /* Mute/unmute capturing */
1176             for (i = 0; i <= SND_MIXER_SCHN_LAST; ++i)
1177             {
1178                 if (snd_mixer_selem_has_capture_channel(elem, i))
1179                     snd_mixer_selem_set_capture_switch(elem, i, !mcdb->fValue);
1180             }
1181         else
1182             for (i = 0; i <= SND_MIXER_SCHN_LAST; ++i)
1183                 if (snd_mixer_selem_has_playback_channel(elem, i))
1184                     snd_mixer_selem_set_playback_switch(elem, i, !mcdb->fValue);
1185         break;
1186     }
1187
1188     case MIXERCONTROL_CONTROLTYPE_MIXER:
1189     case MIXERCONTROL_CONTROLTYPE_MUX:
1190     {
1191         LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
1192         int x, i=0, chn;
1193         int didone = 0, canone = (ct->c.dwControlType == MIXERCONTROL_CONTROLTYPE_MUX);
1194
1195         if (mctrld->cbDetails != sizeof(MIXERCONTROLDETAILS_BOOLEAN))
1196         {
1197             WARN("invalid parameter: cbDetails %d\n", mctrld->cbDetails);
1198             return MMSYSERR_INVALPARAM;
1199         }
1200
1201         TRACE("%s MIXERCONTROLDETAILS_BOOLEAN[%u]\n", getControlType(ct->c.dwControlType), mctrld->cChannels);
1202         mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)mctrld->paDetails;
1203
1204         for (x=i=0; x < mmixer->chans; ++x)
1205             if (line != x && mmixer->lines[x].dst == line)
1206             {
1207                 TRACE("fVal[%i] (%s) = %i\n", i, debugstr_w(mmixer->lines[x].name), mcdb[i].fValue);
1208                 if (i >= mctrld->u.cMultipleItems)
1209                 {
1210                     TRACE("Too many items to fit, overflowing\n");
1211                     return MIXERR_INVALVALUE;
1212                 }
1213                 if (mcdb[i].fValue && canone && didone)
1214                 {
1215                     TRACE("Nice try, but it's not going to work\n");
1216                     elem_callback(mmixer->lines[1].elem, SND_CTL_EVENT_MASK_VALUE);
1217                     return MIXERR_INVALVALUE;
1218                 }
1219                 if (mcdb[i].fValue)
1220                     didone = 1;
1221                 ++i;
1222             }
1223
1224         if (canone && !didone)
1225         {
1226             TRACE("Nice try, this is not going to work either\n");
1227             elem_callback(mmixer->lines[1].elem, SND_CTL_EVENT_MASK_VALUE);
1228             return MIXERR_INVALVALUE;
1229         }
1230
1231         for (x = i = 0; x<mmixer->chans; ++x)
1232             if (line != x && mmixer->lines[x].dst == line)
1233             {
1234                 if (mcdb[i].fValue)
1235                     for (chn = 0; chn <= SND_MIXER_SCHN_LAST; ++chn)
1236                     {
1237                         if (!snd_mixer_selem_has_capture_channel(mmixer->lines[x].elem, chn))
1238                             continue;
1239                         snd_mixer_selem_set_capture_switch(mmixer->lines[x].elem, chn, mcdb[i].fValue);
1240                     }
1241                 ++i;
1242             }
1243
1244         /* If it's a MUX, it means that only 1 channel can be selected
1245          * and the other channels are unselected
1246          *
1247          * For MIXER multiple sources are allowed, so unselect here
1248          */
1249         if (canone)
1250             break;
1251
1252         for (x = i = 0; x<mmixer->chans; ++x)
1253             if (line != x && mmixer->lines[x].dst == line)
1254             {
1255                 if (!mcdb[i].fValue)
1256                     for (chn = 0; chn <= SND_MIXER_SCHN_LAST; ++chn)
1257                     {
1258                         if (!snd_mixer_selem_has_capture_channel(mmixer->lines[x].elem, chn))
1259                             continue;
1260                         snd_mixer_selem_set_capture_switch(mmixer->lines[x].elem, chn, mcdb[i].fValue);
1261                     }
1262                 ++i;
1263             }
1264         break;
1265     }
1266     default:
1267         FIXME("Unhandled type %s\n", getControlType(ct->c.dwControlType));
1268         return MMSYSERR_INVALPARAM;
1269     }
1270     return MMSYSERR_NOERROR;
1271 }
1272
1273 /* Here we give info over the source/dest line given by dwSource+dwDest or dwDest, respectively
1274  * It is also possible that a line is found by componenttype or target type, latter is not implemented yet
1275  * Most important values returned in struct:
1276  * dwLineID
1277  * sz(Short)Name
1278  * line control count
1279  * amount of channels
1280  */
1281 static DWORD MIX_GetLineInfo(UINT wDevID, LPMIXERLINEW Ml, DWORD_PTR flags)
1282 {
1283     DWORD_PTR qf = flags & MIXER_GETLINEINFOF_QUERYMASK;
1284     mixer *mmixer = MIX_GetMix(wDevID);
1285     line *mline;
1286     int idx, i;
1287
1288     if (!Ml)
1289     {
1290         WARN("No Ml\n");
1291         return MMSYSERR_INVALPARAM;
1292     }
1293
1294     if (!mmixer)
1295     {
1296         WARN("Device %u not found\n", wDevID);
1297         return MMSYSERR_BADDEVICEID;
1298     }
1299
1300     if (Ml->cbStruct != sizeof(*Ml))
1301     {
1302         WARN("invalid parameter: Ml->cbStruct = %d\n", Ml->cbStruct);
1303         return MMSYSERR_INVALPARAM;
1304     }
1305
1306     Ml->fdwLine = MIXERLINE_LINEF_ACTIVE;
1307     Ml->dwUser  = 0;
1308
1309     switch (qf)
1310     {
1311     case MIXER_GETLINEINFOF_COMPONENTTYPE:
1312     {
1313         Ml->dwLineID = 0xFFFF;
1314         for (idx = 0; idx < mmixer->chans; ++idx)
1315             if (mmixer->lines[idx].component == Ml->dwComponentType)
1316             {
1317                 Ml->dwLineID = idx;
1318                 break;
1319             }
1320         if (Ml->dwLineID == 0xFFFF)
1321             return MMSYSERR_KEYNOTFOUND;
1322         /* Now that we have lineid, fallback to lineid*/
1323     }
1324
1325     case MIXER_GETLINEINFOF_LINEID:
1326         if (Ml->dwLineID < 0 || Ml->dwLineID >= mmixer->chans)
1327             return MIXERR_INVALLINE;
1328
1329         TRACE("MIXER_GETLINEINFOF_LINEID %d\n", Ml->dwLineID);
1330         Ml->dwDestination = mmixer->lines[Ml->dwLineID].dst;
1331
1332         if (Ml->dwDestination != Ml->dwLineID)
1333         {
1334             Ml->dwSource = getsrcfromline(mmixer, Ml->dwLineID);
1335             Ml->cConnections = 1;
1336         }
1337         else
1338         {
1339             Ml->cConnections = getsrccntfromchan(mmixer, Ml->dwLineID);
1340             Ml->dwSource = 0xFFFFFFFF;
1341         }
1342         TRACE("Connections %d, source %d\n", Ml->cConnections, Ml->dwSource);
1343         break;
1344
1345     case MIXER_GETLINEINFOF_DESTINATION:
1346         if (Ml->dwDestination < 0 || Ml->dwDestination >= mmixer->dests)
1347         {
1348             WARN("dest %d out of bounds\n", Ml->dwDestination);
1349             return MIXERR_INVALLINE;
1350         }
1351
1352         Ml->dwLineID = Ml->dwDestination;
1353         Ml->cConnections = getsrccntfromchan(mmixer, Ml->dwLineID);
1354         Ml->dwSource = 0xFFFFFFFF;
1355         break;
1356
1357     case MIXER_GETLINEINFOF_SOURCE:
1358         if (Ml->dwDestination < 0 || Ml->dwDestination >= mmixer->dests)
1359         {
1360             WARN("dest %d for source out of bounds\n", Ml->dwDestination);
1361             return MIXERR_INVALLINE;
1362         }
1363
1364         if (Ml->dwSource < 0 || Ml->dwSource >= getsrccntfromchan(mmixer, Ml->dwDestination))
1365         {
1366             WARN("src %d out of bounds\n", Ml->dwSource);
1367             return MIXERR_INVALLINE;
1368         }
1369
1370         Ml->dwLineID = getsrclinefromchan(mmixer, Ml->dwDestination, Ml->dwSource);
1371         Ml->cConnections = 1;
1372         break;
1373
1374     case MIXER_GETLINEINFOF_TARGETTYPE:
1375         FIXME("TODO: TARGETTYPE, stub\n");
1376         return MMSYSERR_INVALPARAM;
1377
1378     default:
1379         FIXME("Unknown query flag: %08lx\n", qf);
1380         return MMSYSERR_INVALPARAM;
1381     }
1382
1383     if (Ml->dwLineID >= mmixer->dests)
1384         Ml->fdwLine |= MIXERLINE_LINEF_SOURCE;
1385
1386     mline = &mmixer->lines[Ml->dwLineID];
1387     Ml->dwComponentType = mline->component;
1388     Ml->cChannels = mmixer->lines[Ml->dwLineID].chans;
1389     Ml->cControls = 0;
1390
1391     for (i=CONTROLSPERLINE*Ml->dwLineID;i<CONTROLSPERLINE*(Ml->dwLineID+1); ++i)
1392         if (mmixer->controls[i].enabled)
1393             ++(Ml->cControls);
1394
1395     lstrcpynW(Ml->szShortName, mmixer->lines[Ml->dwLineID].name, sizeof(Ml->szShortName)/sizeof(WCHAR));
1396     lstrcpynW(Ml->szName, mmixer->lines[Ml->dwLineID].name, sizeof(Ml->szName)/sizeof(WCHAR));
1397     if (mline->capt)
1398         Ml->Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
1399     else
1400         Ml->Target.dwType = MIXERLINE_TARGETTYPE_WAVEOUT;
1401     Ml->Target.dwDeviceID = 0xFFFFFFFF;
1402     Ml->Target.wMid = WINE_MIXER_MANUF_ID;
1403     Ml->Target.wPid = WINE_MIXER_PRODUCT_ID;
1404     Ml->Target.vDriverVersion = WINE_MIXER_VERSION;
1405     lstrcpynW(Ml->Target.szPname, mmixer->mixername, sizeof(Ml->Target.szPname)/sizeof(WCHAR));
1406     return MMSYSERR_NOERROR;
1407 }
1408
1409 /* Get the controls that belong to a certain line, either all or 1 */
1410 static DWORD MIX_GetLineControls(UINT wDevID, LPMIXERLINECONTROLSW mlc, DWORD_PTR flags)
1411 {
1412     mixer *mmixer = MIX_GetMix(wDevID);
1413     int i,j = 0;
1414     DWORD ct;
1415
1416     if (!mlc || mlc->cbStruct != sizeof(*mlc))
1417     {
1418         WARN("Invalid mlc %p, cbStruct: %d\n", mlc, (!mlc ? -1 : mlc->cbStruct));
1419         return MMSYSERR_INVALPARAM;
1420     }
1421
1422     if (mlc->cbmxctrl != sizeof(MIXERCONTROLW))
1423     {
1424         WARN("cbmxctrl %d\n", mlc->cbmxctrl);
1425         return MMSYSERR_INVALPARAM;
1426     }
1427
1428     if (!mmixer)
1429         return MMSYSERR_BADDEVICEID;
1430
1431     flags &= MIXER_GETLINECONTROLSF_QUERYMASK;
1432
1433     if (flags == MIXER_GETLINECONTROLSF_ONEBYID)
1434         mlc->dwLineID = mlc->u.dwControlID / CONTROLSPERLINE;
1435
1436     if (mlc->dwLineID < 0 || mlc->dwLineID >= mmixer->chans)
1437     {
1438         TRACE("Invalid dwLineID %d\n", mlc->dwLineID);
1439         return MIXERR_INVALLINE;
1440     }
1441
1442     switch (flags)
1443     {
1444     case MIXER_GETLINECONTROLSF_ALL:
1445        TRACE("line=%08x MIXER_GETLINECONTROLSF_ALL (%d)\n", mlc->dwLineID, mlc->cControls);
1446        for (i = 0; i < CONTROLSPERLINE; ++i)
1447            if (mmixer->controls[i+mlc->dwLineID * CONTROLSPERLINE].enabled)
1448            {
1449                memcpy(&mlc->pamxctrl[j], &mmixer->controls[i+mlc->dwLineID * CONTROLSPERLINE].c, sizeof(MIXERCONTROLW));
1450                TRACE("Added %s (%s)\n", debugstr_w(mlc->pamxctrl[j].szShortName), debugstr_w(mlc->pamxctrl[j].szName));
1451                ++j;
1452                if (j > mlc->cControls)
1453                {
1454                    WARN("invalid parameter\n");
1455                    return MMSYSERR_INVALPARAM;
1456                }
1457            }
1458
1459         if (!j || mlc->cControls > j)
1460         {
1461             WARN("invalid parameter\n");
1462             return MMSYSERR_INVALPARAM;
1463         }
1464         break;
1465     case MIXER_GETLINECONTROLSF_ONEBYID:
1466         TRACE("line=%08x MIXER_GETLINECONTROLSF_ONEBYID (%x)\n", mlc->dwLineID, mlc->u.dwControlID);
1467
1468         if (!mmixer->controls[mlc->u.dwControlID].enabled)
1469            return MIXERR_INVALCONTROL;
1470
1471         mlc->pamxctrl[0] = mmixer->controls[mlc->u.dwControlID].c;
1472         break;
1473     case MIXER_GETLINECONTROLSF_ONEBYTYPE:
1474         TRACE("line=%08x MIXER_GETLINECONTROLSF_ONEBYTYPE (%s)\n", mlc->dwLineID, getControlType(mlc->u.dwControlType));
1475
1476         ct = mlc->u.dwControlType & MIXERCONTROL_CT_CLASS_MASK;
1477         for (i = 0; i <= CONTROLSPERLINE; ++i)
1478         {
1479             const int ofs = i+mlc->dwLineID*CONTROLSPERLINE;
1480             if (i == CONTROLSPERLINE)
1481             {
1482                 WARN("invalid parameter: control %s not found\n", getControlType(mlc->u.dwControlType));
1483                 return MIXERR_INVALCONTROL;
1484             }
1485             if (mmixer->controls[ofs].enabled && (mmixer->controls[ofs].c.dwControlType & MIXERCONTROL_CT_CLASS_MASK) == ct)
1486             {
1487                 mlc->pamxctrl[0] = mmixer->controls[ofs].c;
1488                 break;
1489             }
1490         }
1491     break;
1492     default:
1493         FIXME("Unknown flag %08lx\n", flags & MIXER_GETLINECONTROLSF_QUERYMASK);
1494         return MMSYSERR_INVALPARAM;
1495     }
1496
1497     return MMSYSERR_NOERROR;
1498 }
1499
1500 #endif /*HAVE_ALSA*/
1501
1502 /**************************************************************************
1503  *                        mxdMessage (WINEALSA.3)
1504  */
1505 DWORD WINAPI ALSA_mxdMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
1506                              DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1507 {
1508 #ifdef HAVE_ALSA
1509     DWORD ret;
1510     TRACE("(%04X, %s, %08lX, %08lX, %08lX);\n", wDevID, getMessage(wMsg),
1511           dwUser, dwParam1, dwParam2);
1512
1513     switch (wMsg)
1514     {
1515     case DRVM_INIT: ALSA_MixerInit(); ret = MMSYSERR_NOERROR; break;
1516     case DRVM_EXIT: ALSA_MixerExit(); ret = MMSYSERR_NOERROR; break;
1517     /* All taken care of by driver initialisation */
1518     /* Unimplemented, and not needed */
1519     case DRVM_ENABLE:
1520     case DRVM_DISABLE:
1521         ret = MMSYSERR_NOERROR; break;
1522
1523     case MXDM_OPEN:
1524         ret = MIX_Open(wDevID, (LPMIXEROPENDESC) dwParam1, dwParam2); break;
1525
1526     case MXDM_CLOSE:
1527         ret = MIX_Close(wDevID); break;
1528
1529     case MXDM_GETDEVCAPS:
1530         ret = MIX_GetDevCaps(wDevID, (LPMIXERCAPS2W)dwParam1, dwParam2); break;
1531
1532     case MXDM_GETLINEINFO:
1533         ret = MIX_GetLineInfo(wDevID, (LPMIXERLINEW)dwParam1, dwParam2); break;
1534
1535     case MXDM_GETLINECONTROLS:
1536         ret = MIX_GetLineControls(wDevID, (LPMIXERLINECONTROLSW)dwParam1, dwParam2); break;
1537
1538     case MXDM_GETCONTROLDETAILS:
1539         ret = MIX_GetControlDetails(wDevID, (LPMIXERCONTROLDETAILS)dwParam1, dwParam2); break;
1540
1541     case MXDM_SETCONTROLDETAILS:
1542         ret = MIX_SetControlDetails(wDevID, (LPMIXERCONTROLDETAILS)dwParam1, dwParam2); break;
1543
1544     case MXDM_GETNUMDEVS:
1545         ret = cards; break;
1546
1547     default:
1548         WARN("unknown message %s!\n", getMessage(wMsg));
1549         return MMSYSERR_NOTSUPPORTED;
1550     }
1551
1552     TRACE("Returning %08X\n", ret);
1553     return ret;
1554 #else /*HAVE_ALSA*/
1555     TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
1556
1557     return MMSYSERR_NOTENABLED;
1558 #endif /*HAVE_ALSA*/
1559 }