multimedia/mixer.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * Sample MIXER Wine Driver for Linux
   5  *
   6  * Copyright    1997 Marcus Meissner
   7  *              1999 Eric Pouech
   8  */
   9
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <unistd.h>
  13 #include <fcntl.h>
  14 #include <sys/ioctl.h>
  15 #include "windef.h"
  16 #include "user.h"
  17 #include "driver.h"
  18 #include "mmddk.h"
  19 #include "oss.h"
  20 #include "debugtools.h"
  21
  22 DEFAULT_DEBUG_CHANNEL(mmaux)
  23
  24 #ifdef HAVE_OSS
  25
  26 #define MIXER_DEV "/dev/mixer"
  27
  28 #define WINE_MIXER_MANUF_ID             0xAA
  29 #define WINE_MIXER_PRODUCT_ID           0x55
  30 #define WINE_MIXER_VERSION              0x0100
  31 #define WINE_MIXER_NAME                 "WINE OSS Mixer"
  32
  33 #define WINE_CHN_MASK(_x)               (1L << (_x))
  34 #define WINE_CHN_SUPPORTS(_c, _x)       ((_c) & WINE_CHN_MASK(_x))
  35 #define WINE_MIXER_MASK                 (WINE_CHN_MASK(SOUND_MIXER_VOLUME) | \
  36                                          WINE_CHN_MASK(SOUND_MIXER_BASS)   | \
  37                                          WINE_CHN_MASK(SOUND_MIXER_TREBLE) | \
  38                                          WINE_CHN_MASK(SOUND_MIXER_SYNTH)  | \
  39                                          WINE_CHN_MASK(SOUND_MIXER_PCM)    | \
  40                                          WINE_CHN_MASK(SOUND_MIXER_LINE)   | \
  41                                          WINE_CHN_MASK(SOUND_MIXER_MIC)    | \
  42                                          WINE_CHN_MASK(SOUND_MIXER_CD))
  43
  44 /* FIXME: the two following string arrays should be moved to a resource file in a string table */
  45 /* if it's done, better use a struct to hold labels, name, and muted channel volume cache */
  46 static char*    MIX_Labels[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_LABELS;
  47 static char*    MIX_Names [SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES;
  48 static int      MIX_Volume[SOUND_MIXER_NRDEVICES];
  49 static int      MIX_DevMask = 0;
  50 static int      MIX_StereoMask = 0;
  51
  52 /**************************************************************************
  53  *                              MIX_GetVal                      [internal]
  54  */
  55 static  BOOL    MIX_GetVal(int chn, int* val)
  56 {
  57     int         mixer;
  58     BOOL        ret = FALSE;
  59
  60     if ((mixer = open(MIXER_DEV, O_RDWR)) < 0) {
  61         /* FIXME: ENXIO => no mixer installed */
  62         WARN("mixer device not available !\n");
  63     } else {
  64         if (ioctl(mixer, MIXER_READ(chn), val) >= 0) {
  65             TRACE("Reading %x on %d\n", *val, chn);
  66             ret = TRUE;
  67         }
  68         close(mixer);
  69     }
  70     return ret;
  71 }
  72
  73 /**************************************************************************
  74  *                              MIX_SetVal                      [internal]
  75  */
  76 static  BOOL    MIX_SetVal(int chn, int val)
  77 {
  78     int         mixer;
  79     BOOL        ret = FALSE;
  80
  81     TRACE("Writing %x on %d\n", val, chn);
  82
  83     if ((mixer = open(MIXER_DEV, O_RDWR)) < 0) {
  84         /* FIXME: ENXIO => no mixer installed */
  85         WARN("mixer device not available !\n");
  86     } else {
  87         if (ioctl(mixer, MIXER_WRITE(chn), &val) >= 0) {
  88             ret = TRUE;
  89         }
  90         close(mixer);
  91     }
  92     return ret;
  93 }
  94
  95 /**************************************************************************
  96  *                              MIX_GetDevCaps                  [internal]
  97  */
  98 static DWORD MIX_GetDevCaps(WORD wDevID, LPMIXERCAPSA lpCaps, DWORD dwSize)
  99 {
 100     TRACE("(%04X, %p, %lu);\n", wDevID, lpCaps, dwSize);
 101
 102     if (wDevID != 0) return MMSYSERR_BADDEVICEID;
 103     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
 104     if (!MIX_DevMask) return MMSYSERR_NOTENABLED;
 105
 106     lpCaps->wMid = WINE_MIXER_MANUF_ID;
 107     lpCaps->wPid = WINE_MIXER_PRODUCT_ID;
 108     lpCaps->vDriverVersion = WINE_MIXER_VERSION;
 109     strcpy(lpCaps->szPname, WINE_MIXER_NAME);
 110
 111     lpCaps->cDestinations = 1;
 112     lpCaps->fdwSupport = 0; /* No bits defined yet */
 113
 114     return MMSYSERR_NOERROR;
 115 }
 116
 117 /**************************************************************************
 118  *                              MIX_GetLineInfoFromIndex        [internal]
 119  */
 120 static  void    MIX_GetLineInfoFromIndex(LPMIXERLINEA lpMl, int devmask, DWORD idx)
 121 {
 122     strcpy(lpMl->szShortName, MIX_Labels[idx]);
 123     strcpy(lpMl->szName, MIX_Names[idx]);
 124     lpMl->dwLineID = idx;
 125     lpMl->dwDestination = 0; /* index for speakers */
 126     lpMl->cConnections = 1;
 127     lpMl->cControls = 2;
 128     switch (idx) {
 129     case SOUND_MIXER_SYNTH:
 130         lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER;
 131         lpMl->fdwLine    |= MIXERLINE_LINEF_SOURCE;
 132         break;
 133     case SOUND_MIXER_CD:
 134         lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC;
 135         lpMl->fdwLine    |= MIXERLINE_LINEF_SOURCE;
 136         break;
 137     case SOUND_MIXER_LINE:
 138         lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_LINE;
 139         lpMl->fdwLine    |= MIXERLINE_LINEF_SOURCE;
 140         break;
 141     case SOUND_MIXER_MIC:
 142         lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
 143         lpMl->fdwLine    |= MIXERLINE_LINEF_SOURCE;
 144         break;
 145     case SOUND_MIXER_PCM:
 146         lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
 147         lpMl->fdwLine    |= MIXERLINE_LINEF_SOURCE;
 148         break;
 149     default:
 150         ERR("Index %ld not handled.\n", idx);
 151         break;
 152     }
 153 }
 154
 155 /**************************************************************************
 156  *                              MIX_GetLineInfo                 [internal]
 157  */
 158 static DWORD MIX_GetLineInfo(WORD wDevID, LPMIXERLINEA lpMl, DWORD fdwInfo)
 159 {
 160     int                 i, j;
 161     BOOL                isDst = FALSE;
 162     DWORD               ret = MMSYSERR_NOERROR;
 163
 164     TRACE("(%04X, %p, %lu);\n", wDevID, lpMl, fdwInfo);
 165     if (lpMl == NULL || lpMl->cbStruct != sizeof(*lpMl))
 166         return MMSYSERR_INVALPARAM;
 167
 168     /* FIXME: set all the variables correctly... the lines below
 169      * are very wrong...
 170      */
 171     lpMl->fdwLine       = MIXERLINE_LINEF_ACTIVE;
 172     lpMl->cChannels     = 1;
 173     lpMl->dwUser        = 0;
 174     lpMl->cControls     = 2;
 175
 176     switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK) {
 177     case MIXER_GETLINEINFOF_DESTINATION:
 178         TRACE("DESTINATION (%08lx)\n", lpMl->dwDestination);
 179         /* FIXME: Linux doesn't seem to support multiple outputs?
 180          * So we have only one output type: Speaker.
 181          */
 182         lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
 183         lpMl->dwSource = 0xFFFFFFFF;
 184         lpMl->dwLineID = SOUND_MIXER_VOLUME;
 185         strncpy(lpMl->szShortName, MIX_Labels[SOUND_MIXER_VOLUME], MIXER_SHORT_NAME_CHARS);
 186         strncpy(lpMl->szName, MIX_Names[SOUND_MIXER_VOLUME], MIXER_LONG_NAME_CHARS);
 187
 188         /* we have all connections found in the MIX_DevMask */
 189         lpMl->cConnections = 0;
 190         for (j = 1; j < SOUND_MIXER_NRDEVICES; j++)
 191             if (WINE_CHN_SUPPORTS(MIX_DevMask, j))
 192                 lpMl->cConnections++;
 193         if (WINE_CHN_SUPPORTS(MIX_StereoMask, SOUND_MIXER_VOLUME))
 194             lpMl->cChannels++;
 195         break;
 196     case MIXER_GETLINEINFOF_SOURCE:
 197         TRACE("SOURCE (%08lx)\n", lpMl->dwSource);
 198         i = lpMl->dwSource;
 199         for (j = 1; j < SOUND_MIXER_NRDEVICES; j++) {
 200             if (WINE_CHN_SUPPORTS(MIX_DevMask, j) && (i-- == 0))
 201                 break;
 202         }
 203         if (j >= SOUND_MIXER_NRDEVICES)
 204             return MIXERR_INVALLINE;
 205         if (WINE_CHN_SUPPORTS(MIX_StereoMask, j))
 206             lpMl->cChannels++;
 207         MIX_GetLineInfoFromIndex(lpMl, MIX_DevMask, j);
 208         break;
 209     case MIXER_GETLINEINFOF_LINEID:
 210         TRACE("LINEID (%08lx)\n", lpMl->dwLineID);
 211         if (lpMl->dwLineID >= SOUND_MIXER_NRDEVICES)
 212             return MIXERR_INVALLINE;
 213         if (WINE_CHN_SUPPORTS(MIX_StereoMask, lpMl->dwLineID))
 214             lpMl->cChannels++;
 215         MIX_GetLineInfoFromIndex(lpMl, MIX_DevMask, lpMl->dwLineID);
 216         break;
 217     case MIXER_GETLINEINFOF_COMPONENTTYPE:
 218         TRACE("COMPONENT TYPE (%08lx)\n", lpMl->dwComponentType);
 219
 220         switch (lpMl->dwComponentType) {
 221         case MIXERLINE_COMPONENTTYPE_DST_SPEAKERS:
 222             i = SOUND_MIXER_VOLUME;
 223             lpMl->dwDestination = 0;
 224             lpMl->dwSource = 0xFFFFFFFF;
 225             isDst = TRUE;
 226             break;
 227         case MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER:
 228             i = SOUND_MIXER_SYNTH;
 229             lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
 230             break;
 231         case MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC:
 232             i = SOUND_MIXER_CD;
 233             lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
 234             break;
 235         case MIXERLINE_COMPONENTTYPE_SRC_LINE:
 236             i = SOUND_MIXER_LINE;
 237             lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
 238             break;
 239         case MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE:
 240             i = SOUND_MIXER_MIC;
 241             lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
 242             break;
 243         case MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT:
 244             i = SOUND_MIXER_PCM;
 245             lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
 246             break;
 247         default:
 248             FIXME("Unhandled component type (%08lx)\n", lpMl->dwComponentType);
 249             return MMSYSERR_INVALPARAM;
 250         }
 251
 252         if (WINE_CHN_SUPPORTS(MIX_DevMask, i)) {
 253             strcpy(lpMl->szShortName, MIX_Labels[i]);
 254             strcpy(lpMl->szName, MIX_Names[i]);
 255             lpMl->dwLineID = i;
 256         }
 257         if (WINE_CHN_SUPPORTS(MIX_StereoMask, i))
 258             lpMl->cChannels++;
 259         lpMl->cConnections = 0;
 260         if (isDst) {
 261             for (j = 1; j < SOUND_MIXER_NRDEVICES; j++) {
 262                 if (WINE_CHN_SUPPORTS(MIX_DevMask, j)) {
 263                     lpMl->cConnections++;
 264                 }
 265             }
 266         }
 267         break;
 268     case MIXER_GETLINEINFOF_TARGETTYPE:
 269         FIXME("_TARGETTYPE not implemented yet.\n");
 270         break;
 271     default:
 272         WARN("Unknown flag (%08lx)\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK);
 273         break;
 274     }
 275
 276     lpMl->Target.dwType = MIXERLINE_TARGETTYPE_AUX;
 277     lpMl->Target.dwDeviceID = 0xFFFFFFFF;
 278     lpMl->Target.wMid = WINE_MIXER_MANUF_ID;
 279     lpMl->Target.wPid = WINE_MIXER_PRODUCT_ID;
 280     lpMl->Target.vDriverVersion = WINE_MIXER_VERSION;
 281     strcpy(lpMl->Target.szPname, WINE_MIXER_NAME);
 282
 283     return ret;
 284 }
 285
 286 /**************************************************************************
 287  *                              MIX_GetLineInfo                 [internal]
 288  */
 289 static DWORD MIX_Open(WORD wDevID, LPMIXEROPENDESC lpMod, DWORD flags)
 290 {
 291     TRACE("(%04X, %p, %lu);\n", wDevID, lpMod, flags);
 292     if (lpMod == NULL) return MMSYSERR_INVALPARAM;
 293
 294     return (MIX_DevMask == 0) ? MMSYSERR_NODRIVER : MMSYSERR_NOERROR;
 295 }
 296
 297 /**************************************************************************
 298  *                              MIX_MakeControlID               [internal]
 299  */
 300 static DWORD MIX_MakeControlID(DWORD lineID, DWORD controlType)
 301 {
 302     switch (controlType) {
 303     case MIXERCONTROL_CONTROLTYPE_VOLUME:
 304         return 2 * lineID + 0;
 305     case MIXERCONTROL_CONTROLTYPE_MUTE:
 306         return 2 * lineID + 1;
 307     }
 308     FIXME("Internal error");
 309     return 0x00FADE00;
 310 }
 311
 312 /**************************************************************************
 313  *                              MIX_SplitControlID              [internal]
 314  */
 315 static BOOL MIX_SplitControlID(DWORD controlID, LPDWORD lineID, LPDWORD controlType)
 316 {
 317     *lineID = controlID / 2;
 318     *controlType = (controlID & 1) ?
 319         MIXERCONTROL_CONTROLTYPE_MUTE : MIXERCONTROL_CONTROLTYPE_VOLUME;
 320
 321     return *lineID < SOUND_MIXER_NRDEVICES && WINE_CHN_SUPPORTS(MIX_DevMask, *lineID);
 322 }
 323
 324 /**************************************************************************
 325  *                              MIX_DoGetLineControls           [internal]
 326  */
 327 static void MIX_DoGetLineControls(LPMIXERCONTROLA mc, DWORD lineID, DWORD dwType)
 328 {
 329     mc->cbStruct = sizeof(MIXERCONTROLA);
 330
 331     switch (dwType) {
 332     case MIXERCONTROL_CONTROLTYPE_VOLUME:
 333         TRACE("Returning volume control\n");
 334         mc->dwControlID = MIX_MakeControlID(lineID, dwType);
 335         mc->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
 336         mc->fdwControl = 0;
 337         mc->cMultipleItems = 0;
 338         strncpy(mc->szShortName, "Vol", MIXER_SHORT_NAME_CHARS);
 339         strncpy(mc->szName, "Volume", MIXER_LONG_NAME_CHARS);
 340         memset(&mc->Bounds, 0, sizeof(mc->Bounds));
 341         /* CONTROLTYPE_VOLUME uses the MIXER_CONTROLDETAILS_UNSIGNED struct,
 342          * [0, 100] is the range supported by OSS
 343          * FIXME: sounds like MIXERCONTROL_CONTROLTYPE_VOLUME is always between 0 and 65536
 344          * whatever the min and max values are...
 345          * look at conversions done in (Get|Set)ControlDetails to stay in [0, 100] range
 346          */
 347         mc->Bounds.s1.dwMinimum = 0;
 348         mc->Bounds.s1.dwMaximum = 100;
 349         memset(&mc->Metrics, 0, sizeof(mc->Metrics));
 350         break;
 351     case MIXERCONTROL_CONTROLTYPE_MUTE:
 352         TRACE("Returning mute control\n");
 353         mc->dwControlID = MIX_MakeControlID(lineID, dwType);
 354         mc->dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
 355         mc->fdwControl = 0;
 356         mc->cMultipleItems = 0;
 357         strncpy(mc->szShortName, "Mute", MIXER_SHORT_NAME_CHARS);
 358         strncpy(mc->szName, "Mute", MIXER_LONG_NAME_CHARS);
 359         memset(&mc->Bounds, 0, sizeof(mc->Bounds));
 360         memset(&mc->Metrics, 0, sizeof(mc->Metrics));
 361         break;
 362     default:
 363         FIXME("Internal error: unknown type: %08lx\n", dwType);
 364     }
 365 }
 366
 367 /**************************************************************************
 368  *                              MIX_GetLineControls             [internal]
 369  */
 370 static  DWORD   MIX_GetLineControls(WORD wDevID, LPMIXERLINECONTROLSA lpMlc, DWORD flags)
 371 {
 372     DWORD               dwRet = MMSYSERR_NOERROR;
 373     DWORD               lineID, controlType;
 374
 375     TRACE("(%04X, %p, %lu);\n", wDevID, lpMlc, flags);
 376
 377     if (lpMlc == NULL) return MMSYSERR_INVALPARAM;
 378     if (lpMlc->cbStruct < sizeof(*lpMlc) ||
 379         lpMlc->cbmxctrl < sizeof(MIXERCONTROLA))
 380         return MMSYSERR_INVALPARAM;
 381
 382     switch (flags & MIXER_GETLINECONTROLSF_QUERYMASK) {
 383     case MIXER_GETLINECONTROLSF_ALL:
 384         TRACE("line=%08lx GLCF_ALL (%ld)\n", lpMlc->dwLineID, lpMlc->cControls);
 385         if (lpMlc->cControls != 2) {
 386             dwRet = MMSYSERR_INVALPARAM;
 387         } else {
 388             MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_VOLUME);
 389             MIX_DoGetLineControls(&lpMlc->pamxctrl[1], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_MUTE);
 390         }
 391         break;
 392     case MIXER_GETLINECONTROLSF_ONEBYID:
 393         TRACE("line=%08lx GLCF_ONEBYID (%lx)\n", lpMlc->dwLineID, lpMlc->u.dwControlID);
 394         if (MIX_SplitControlID(lpMlc->u.dwControlID, &lineID, &controlType))
 395             MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lineID, controlType);
 396         else
 397             dwRet = MMSYSERR_INVALPARAM;
 398         break;
 399     case MIXER_GETLINECONTROLSF_ONEBYTYPE:
 400         TRACE("line=%08lx GLCF_ONEBYTYPE (%lx)\n", lpMlc->dwLineID, lpMlc->u.dwControlType);
 401         switch (lpMlc->u.dwControlType & MIXERCONTROL_CT_CLASS_MASK) {
 402         case MIXERCONTROL_CT_CLASS_FADER:
 403             MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_VOLUME);
 404             break;
 405         case MIXERCONTROL_CT_CLASS_SWITCH:
 406             MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_MUTE);
 407             break;
 408         default:
 409             dwRet = MMSYSERR_INVALPARAM;
 410         }
 411         break;
 412     default:
 413         ERR("Unknown flag %08lx\n", flags & MIXER_GETLINECONTROLSF_QUERYMASK);
 414         dwRet = MMSYSERR_INVALPARAM;
 415     }
 416
 417     return dwRet;
 418 }
 419
 420 /**************************************************************************
 421  *                              MIX_GetControlDetails           [internal]
 422  */
 423 static  DWORD   MIX_GetControlDetails(WORD wDevID, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
 424 {
 425     DWORD       ret = MMSYSERR_NOTSUPPORTED;
 426     DWORD       lineID, controlType;
 427
 428     TRACE("(%04X, %p, %lu);\n", wDevID, lpmcd, fdwDetails);
 429
 430     if (lpmcd == NULL) return MMSYSERR_INVALPARAM;
 431
 432     switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
 433     case MIXER_GETCONTROLDETAILSF_VALUE:
 434         TRACE("GCD VALUE (%08lx)\n", lpmcd->dwControlID);
 435         if (MIX_SplitControlID(lpmcd->dwControlID, &lineID, &controlType)) {
 436             switch (controlType) {
 437             case MIXERCONTROL_CONTROLTYPE_VOLUME:
 438                 {
 439                     LPMIXERCONTROLDETAILS_UNSIGNED      mcdu;
 440                     int                                 val;
 441
 442                     /* return value is 00RL (4 bytes)... */
 443                     if ((val = MIX_Volume[lineID]) == -1 && !MIX_GetVal(lineID, &val))
 444                         return MMSYSERR_INVALPARAM;
 445
 446                     switch (lpmcd->cChannels) {
 447                     case 1:
 448                         /* mono... so R = L */
 449                         mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)lpmcd->paDetails;
 450                         mcdu->dwValue = (LOBYTE(LOWORD(val)) * 65536L) / 100;
 451                         break;
 452                     case 2:
 453                         /* stereo, left is paDetails[0] */
 454                         mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 0 * lpmcd->cbDetails);
 455                         mcdu->dwValue = (LOBYTE(LOWORD(val)) * 65536L) / 100;
 456                         mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 1 * lpmcd->cbDetails);
 457                         mcdu->dwValue = (HIBYTE(LOWORD(val)) * 65536L) / 100;
 458                         break;
 459                     default:
 460                         WARN("Unknown cChannels (%ld)\n", lpmcd->cChannels);
 461                         return MMSYSERR_INVALPARAM;
 462                     }
 463                     TRACE("=> %08lx\n", mcdu->dwValue);
 464                 }
 465                 break;
 466             case MIXERCONTROL_CONTROLTYPE_MUTE:
 467                 {
 468                     LPMIXERCONTROLDETAILS_BOOLEAN       mcdb;
 469
 470                     /* we mute both channels at the same time */
 471                     mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
 472                     mcdb->fValue = (MIX_Volume[lineID] != -1);
 473                 }
 474                 break;
 475             }
 476             ret = MMSYSERR_NOERROR;
 477         } else {
 478             ret = MMSYSERR_INVALPARAM;
 479         }
 480         break;
 481     case MIXER_GETCONTROLDETAILSF_LISTTEXT:
 482         FIXME("NIY\n");
 483         break;
 484     default:
 485         WARN("Unknown flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK);
 486     }
 487     return ret;
 488 }
 489
 490 /**************************************************************************
 491  *                              MIX_SetControlDetails           [internal]
 492  */
 493 static  DWORD   MIX_SetControlDetails(WORD wDevID, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
 494 {
 495     DWORD       ret = MMSYSERR_NOTSUPPORTED;
 496     DWORD       lineID, controlType;
 497     int         val;
 498
 499     TRACE("(%04X, %p, %lu);\n", wDevID, lpmcd, fdwDetails);
 500
 501     if (lpmcd == NULL) return MMSYSERR_INVALPARAM;
 502
 503     switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
 504     case MIXER_GETCONTROLDETAILSF_VALUE:
 505         TRACE("GCD VALUE (%08lx)\n", lpmcd->dwControlID);
 506         if (MIX_SplitControlID(lpmcd->dwControlID, &lineID, &controlType)) {
 507             switch (controlType) {
 508             case MIXERCONTROL_CONTROLTYPE_VOLUME:
 509                 {
 510                     LPMIXERCONTROLDETAILS_UNSIGNED      mcdu;
 511
 512                     /* val should contain 00RL */
 513                     switch (lpmcd->cChannels) {
 514                     case 1:
 515                         /* mono... so R = L */
 516                         mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)lpmcd->paDetails;
 517                         TRACE("Setting RL to %08ld\n", mcdu->dwValue);
 518                         val = 0x101 * ((mcdu->dwValue * 100) >> 16);
 519                         break;
 520                     case 2:
 521                         /* stereo, left is paDetails[0] */
 522                         mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 0 * lpmcd->cbDetails);
 523                         TRACE("Setting L to %08ld\n", mcdu->dwValue);
 524                         val = ((mcdu->dwValue * 100) >> 16);
 525                         mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 1 * lpmcd->cbDetails);
 526                         TRACE("Setting R to %08ld\n", mcdu->dwValue);
 527                         val += ((mcdu->dwValue * 100) >> 16) << 8;
 528                         break;
 529                     default:
 530                         WARN("Unknown cChannels (%ld)\n", lpmcd->cChannels);
 531                         return MMSYSERR_INVALPARAM;
 532                     }
 533
 534                     if (MIX_Volume[lineID] == -1) {
 535                         if (!MIX_SetVal(lineID, val))
 536                             return MMSYSERR_INVALPARAM;
 537                     } else {
 538                         MIX_Volume[lineID] = val;
 539                     }
 540                 }
 541                 ret = MMSYSERR_NOERROR;
 542                 break;
 543             case MIXERCONTROL_CONTROLTYPE_MUTE:
 544                 {
 545                     LPMIXERCONTROLDETAILS_BOOLEAN       mcdb;
 546
 547                     mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
 548                     if (mcdb->fValue) {
 549                         if (!MIX_GetVal(lineID, &MIX_Volume[lineID]))
 550                             return MMSYSERR_INVALPARAM;
 551                         if (!MIX_SetVal(lineID, 0))
 552                             return MMSYSERR_INVALPARAM;
 553                     } else {
 554                         if (!MIX_SetVal(lineID, MIX_Volume[lineID]))
 555                             return MMSYSERR_INVALPARAM;
 556                         MIX_Volume[lineID] = -1;
 557                     }
 558                 }
 559                 ret = MMSYSERR_NOERROR;
 560                 break;
 561             }
 562         }
 563         break;
 564     case MIXER_GETCONTROLDETAILSF_LISTTEXT:
 565         FIXME("NIY\n");
 566         break;
 567     default:
 568         WARN("Unknown GetControlDetails flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK);
 569     }
 570     return MMSYSERR_NOTSUPPORTED;
 571 }
 572
 573 /**************************************************************************
 574  *                              MIX_GetNumDevs                  [internal]
 575  */
 576 static  DWORD   MIX_GetNumDevs(UINT wDevID)
 577 {
 578     return (MIX_DevMask != 0) ? 1 : 0;
 579 }
 580
 581 /**************************************************************************
 582  *                              MIX_Init                        [internal]
 583  */
 584 static  DWORD   MIX_Init(void)
 585 {
 586     int mixer, i;
 587
 588     if ((mixer = open(MIXER_DEV, O_RDWR)) < 0) {
 589         if (errno == ENODEV || errno == ENXIO) {
 590             /* no driver present */
 591             return MMSYSERR_NODRIVER;
 592         }
 593         return MMSYSERR_ERROR;
 594     }
 595     if (ioctl(mixer, SOUND_MIXER_READ_DEVMASK, &MIX_DevMask) == -1) {
 596         close(mixer);
 597         perror("ioctl mixer SOUND_MIXER_DEVMASK");
 598         return MMSYSERR_NOTENABLED;
 599     }
 600     MIX_DevMask &= WINE_MIXER_MASK;
 601     if (ioctl(mixer, SOUND_MIXER_READ_STEREODEVS, &MIX_StereoMask) == -1) {
 602         close(mixer);
 603         perror("ioctl mixer SOUND_MIXER_STEREODEVS");
 604         return MMSYSERR_NOTENABLED;
 605     }
 606     MIX_StereoMask &= WINE_MIXER_MASK;
 607
 608 #if 0
 609     int                 recsrc, recmask;
 610
 611     if (ioctl(mixer, SOUND_MIXER_READ_RECSRC, &recsrc) == -1) {
 612         close(mixer);
 613         perror("ioctl mixer SOUND_MIXER_RECSRC");
 614         return MMSYSERR_NOTENABLED;
 615     }
 616
 617     if (ioctl(mixer, SOUND_MIXER_READ_RECMASK, &recmask) == -1) {
 618         close(mixer);
 619         perror("ioctl mixer SOUND_MIXER_RECMASK");
 620         return MMSYSERR_NOTENABLED;
 621     }
 622 #endif
 623     for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 624         MIX_Volume[i] = -1;
 625     }
 626     close(mixer);
 627
 628     return MMSYSERR_NOERROR;
 629 }
 630
 631 #endif /* HAVE_OSS */
 632
 633 /**************************************************************************
 634  *                              OSS_mixMessage          [sample driver]
 635  */
 636 DWORD WINAPI OSS_mixMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
 637                             DWORD dwParam1, DWORD dwParam2)
 638 {
 639     TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n",
 640           wDevID, wMsg, dwUser, dwParam1, dwParam2);
 641
 642 #ifdef HAVE_OSS
 643     switch(wMsg) {
 644     case DRVM_INIT:
 645         return MIX_Init();
 646         break;
 647     case DRVM_EXIT:
 648     case DRVM_ENABLE:
 649     case DRVM_DISABLE:
 650         /* FIXME: Pretend this is supported */
 651         return 0;
 652     case MXDM_GETDEVCAPS:
 653         return MIX_GetDevCaps(wDevID, (LPMIXERCAPSA)dwParam1, dwParam2);
 654     case MXDM_GETLINEINFO:
 655         return MIX_GetLineInfo(wDevID, (LPMIXERLINEA)dwParam1, dwParam2);
 656     case MXDM_GETNUMDEVS:
 657         return MIX_GetNumDevs(wDevID);
 658     case MXDM_OPEN:
 659         return MIX_Open(wDevID, (LPMIXEROPENDESC)dwParam1, dwParam2);
 660     case MXDM_CLOSE:
 661         return MMSYSERR_NOERROR;
 662     case MXDM_GETLINECONTROLS:
 663         return MIX_GetLineControls(wDevID, (LPMIXERLINECONTROLSA)dwParam1, dwParam2);
 664     case MXDM_GETCONTROLDETAILS:
 665         return MIX_GetControlDetails(wDevID, (LPMIXERCONTROLDETAILS)dwParam1, dwParam2);
 666     case MXDM_SETCONTROLDETAILS:
 667         return MIX_SetControlDetails(wDevID, (LPMIXERCONTROLDETAILS)dwParam1, dwParam2);
 668     default:
 669         WARN("unknown message %d!\n", wMsg);
 670     }
 671     return MMSYSERR_NOTSUPPORTED;
 672 #else
 673     return MMSYSERR_NOTENABLED;
 674 #endif
 675 }
 676
 677