Changeset 8506 for trunk/src


Ignore:
Timestamp:
May 28, 2002, 3:35:02 PM (23 years ago)
Author:
sandervl
Message:

Implemented mixerSetControlDetails + mixer updates/fixes

Location:
trunk/src/winmm
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/winmm/mixer.cpp

    r8498 r8506  
    1 /* $Id: mixer.cpp,v 1.20 2002-05-27 16:10:24 sandervl Exp $ */
     1/* $Id: mixer.cpp,v 1.21 2002-05-28 13:35:02 sandervl Exp $ */
    22
    33/*
    … …  
    116116            }
    117117
    118             if(OSLibMixGetRecSource(&dwRecSrc, NULL, NULL) == FALSE) {
     118            if(OSLibMixGetRecSource(&dwRecSrc) == FALSE) {
    119119                dprintf(("OSLibMixGetRecSource failed!!"));
    120120                return MIXERR_INVALCONTROL;
    … …  
    144144
    145145            dprintf(("MIXERCONTROL_CONTROLTYPE_VOLUME"));
    146             if(OSLibMixGetVolume(mixerControls[lpmcd->dwControlID].id, NULL, &dwVolLeft, &dwVolRight) == FALSE) {
     146            if(OSLibMixGetVolume(mixerControls[lpmcd->dwControlID].id, &dwVolLeft, &dwVolRight) == FALSE) {
    147147                dprintf(("OSLibMixGetVolume failed!!"));
    148148                return MIXERR_INVALCONTROL;
    149149            }
    150150            pDetails->dwValue = dwVolLeft;
    151             dprintf(("Left volume %d", dwVolLeft));
     151            dprintf(("%s Left volume %d", mixerControls[lpmcd->dwControlID].ctrl.szName, dwVolLeft));
    152152            if(lpmcd->cChannels == 2) {
    153                 dprintf(("Right volume %d", dwVolRight));
     153                dprintf(("%s Right volume %d", mixerControls[lpmcd->dwControlID].ctrl.szName, dwVolRight));
    154154                pDetails += 1;
    155155                pDetails->dwValue = dwVolRight;
    … …  
    165165
    166166            dprintf(("MIXERCONTROL_CONTROLTYPE_MUTE"));
    167             if(OSLibMixGetVolume(mixerControls[lpmcd->dwControlID].id, &fMute, NULL, NULL) == FALSE) {
     167            if(OSLibMixGetMute(mixerControls[lpmcd->dwControlID].id, &fMute) == FALSE) {
    168168                dprintf(("OSLibMixGetVolume failed!!"));
    169169                return MIXERR_INVALCONTROL;
    170170            }
    171171            pDetails->fValue = fMute;
    172             dprintf(("Left mute %d", fMute));
     172            dprintf(("%s Left mute %d", mixerControls[lpmcd->dwControlID].ctrl.szName, fMute));
    173173            if(lpmcd->cChannels == 2) {
    174                 dprintf(("Right mute %d", fMute));
     174                dprintf(("%s Right mute %d", mixerControls[lpmcd->dwControlID].ctrl.szName, fMute));
    175175                pDetails += 1;
    176176                pDetails->fValue = fMute;
    … …  
    187187            dprintf(("MIXERCONTROL_CONTROLTYPE_FADER"));
    188188
    189             if(lpmcd->cChannels != 1) {
    190                 dprintf(("Invalid nr of channels %d!!", lpmcd->cChannels));
    191                 return MMSYSERR_INVALPARAM;
    192             }
    193             if(OSLibMixGetVolume(mixerControls[lpmcd->dwControlID].id, NULL, &dwLevelL, NULL) == FALSE) {
     189            if(OSLibMixGetVolume(mixerControls[lpmcd->dwControlID].id, &dwLevelL, NULL) == FALSE) {
    194190                dprintf(("OSLibMixGetVolume failed!!"));
    195191                return MIXERR_INVALCONTROL;
    … …  
    202198            else dprintf(("3D depth %d", dwLevelL));
    203199#endif
     200            if(lpmcd->cChannels == 2) {
     201                pDetails += 1;
     202                pDetails->dwValue = dwLevelL;
     203            }
     204            //todo > 2 channels (??)
    204205            return MMSYSERR_NOERROR;
    205206        }
    206207
    207208        case MIXERCONTROL_CONTROLTYPE_BASS:
    208         {
    209             MIXERCONTROLDETAILS_UNSIGNED *pDetails = (MIXERCONTROLDETAILS_UNSIGNED *)lpmcd->paDetails;
    210             DWORD dwLevelL;
    211 
    212             dprintf(("MIXERCONTROL_CONTROLTYPE_BASS"));
    213 
    214             if(lpmcd->cChannels != 1) {
    215                 dprintf(("Invalid nr of channels %d!!", lpmcd->cChannels));
    216                 return MMSYSERR_INVALPARAM;
    217             }
    218             if(OSLibMixGetVolume(mixerControls[lpmcd->dwControlID].id, NULL, &dwLevelL, NULL) == FALSE) {
    219                 dprintf(("OSLibMixGetVolume failed!!"));
    220                 return MIXERR_INVALCONTROL;
    221             }
    222             pDetails->dwValue = dwLevelL;
    223             dprintf(("Bass %d", dwLevelL));
    224             return MMSYSERR_NOERROR;
    225         }
    226 
    227209        case MIXERCONTROL_CONTROLTYPE_TREBLE:
    228210        {
    … …  
    230212            DWORD dwLevelL;
    231213
    232             dprintf(("MIXERCONTROL_CONTROLTYPE_TREBLE"));
    233 
    234             if(lpmcd->cChannels != 1) {
    235                 dprintf(("Invalid nr of channels %d!!", lpmcd->cChannels));
    236                 return MMSYSERR_INVALPARAM;
    237             }
    238             if(OSLibMixGetVolume(mixerControls[lpmcd->dwControlID].id, NULL, &dwLevelL, NULL) == FALSE) {
     214            switch(fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
     215            case MIXERCONTROL_CONTROLTYPE_TREBLE:
     216                dprintf(("MIXERCONTROL_CONTROLTYPE_TREBLE"));
     217                break;
     218            case MIXERCONTROL_CONTROLTYPE_BASS:
     219                dprintf(("MIXERCONTROL_CONTROLTYPE_BASS"));
     220                break;
     221            }
     222
     223            if(OSLibMixGetVolume(mixerControls[lpmcd->dwControlID].id, &dwLevelL, NULL) == FALSE) {
    239224                dprintf(("OSLibMixGetVolume failed!!"));
    240225                return MIXERR_INVALCONTROL;
    241226            }
    242227            pDetails->dwValue = dwLevelL;
    243             dprintf(("Treble %d", dwLevelL));
     228            dprintf(("%s %d", mixerControls[lpmcd->dwControlID].ctrl.szName, dwLevelL));
     229            if(lpmcd->cChannels == 2) {
     230                pDetails += 1;
     231                pDetails->dwValue = dwLevelL;
     232            }
    244233            return MMSYSERR_NOERROR;
    245234        }
    … …  
    466455        }
    467456    }
    468     if(lpmcd == NULL || lpmcd->cbDetails != sizeof(MIXERCONTROLDETAILS)) {
    469         dprintf(("ERROR: invalid pointer or structure size"));
     457    if(lpmcd == NULL || lpmcd->cbStruct != sizeof(MIXERCONTROLDETAILS)) {
     458        dprintf(("ERROR: invalid pointer or structure size %x %d", lpmcd, lpmcd->cbStruct));
    470459        return MMSYSERR_INVALPARAM;
    471460    }
    … …  
    504493                return MMSYSERR_INVALPARAM;
    505494            }
    506 #if 0
    507             if(OSLibMixGetRecSource(&dwRecSrc, NULL, NULL) == FALSE) {
    508                 dprintf(("OSLibMixGetRecSource failed!!"));
    509                 return MIXERR_INVALCONTROL;
    510             }
    511             //clear the array
    512             memset(pDetails, 0, sizeof(MIXERCONTROLDETAILS_BOOLEAN)*lpmcd->u.cMultipleItems);
    513             //mark recording source
     495            //select recording source
    514496            for(int i=0;i<nrDestinations;i++) {
    515                 if(mixerDest[i].id == MIXER_DEST_WAVEIN) {
     497                if(mixerDest[i].id == MIXER_DEST_WAVEIN)
     498                {
    516499                    for(int j=0;j<mixerDest[i].cConnections;j++) {
    517500                        dprintf(("wavein source %d (id %d)", pmixerLines[mixerDest[i].Connections[j]]->id, mixerDest[i].Connections[j]));
    518                         if(pmixerLines[mixerDest[i].Connections[j]]->id == dwRecSrc) {
    519                             pDetails[j].fValue = 1;
     501                        if(pDetails[j].fValue)
     502                        {
     503                            if(OSLibMixSetRecSource(pmixerLines[mixerDest[i].Connections[j]]->id) == FALSE) {
     504                                dprintf(("OSLibMixGetRecSource failed!!"));
     505                                return MIXERR_INVALCONTROL;
     506                            }
    520507                            return MMSYSERR_NOERROR;
    521508                        }
    … …  
    524511            }
    525512            dprintf(("recording source %d not found!!", dwRecSrc));
    526 #endif
    527513            break;
    528514        }
    … …  
    531517        {
    532518            MIXERCONTROLDETAILS_UNSIGNED *pDetails = (MIXERCONTROLDETAILS_UNSIGNED *)lpmcd->paDetails;
     519            DWORD dwVolumeL, dwVolumeR;
    533520
    534521            dprintf(("MIXERCONTROL_CONTROLTYPE_VOLUME"));
    535             dprintf(("Left volume %d", pDetails->dwValue));
     522            dwVolumeL = pDetails->dwValue;
     523
     524            dprintf(("%s Left volume %d", mixerControls[lpmcd->dwControlID].ctrl.szName, pDetails->dwValue));
    536525            if(lpmcd->cChannels == 2) {
    537526                pDetails += 1;
    538                 dprintf(("Right volume %d", pDetails->dwValue));
    539             }
     527                dprintf(("%s Right volume %d", mixerControls[lpmcd->dwControlID].ctrl.szName, pDetails->dwValue));
     528                dwVolumeR = pDetails->dwValue;
     529            }
     530            else dwVolumeR = dwVolumeL;
    540531            //todo > 2 channels
     532
     533            if(OSLibMixSetVolume(mixerControls[lpmcd->dwControlID].id, dwVolumeL, dwVolumeR) == FALSE) {
     534                return MMSYSERR_INVALPARAM;
     535            }
     536            mixerControls[lpmcd->dwControlID].val[0].dwValue = dwVolumeL;
     537            mixerControls[lpmcd->dwControlID].val[1].dwValue = dwVolumeR;
    541538            return MMSYSERR_NOERROR;
    542539        }
    … …  
    545542        {
    546543            MIXERCONTROLDETAILS_BOOLEAN *pDetails = (MIXERCONTROLDETAILS_BOOLEAN *)lpmcd->paDetails;
     544            BOOL fMute;
    547545
    548546            dprintf(("MIXERCONTROL_CONTROLTYPE_MUTE"));
    549             dprintf(("Left mute %d", pDetails->fValue));
     547            dprintf(("%s Left mute %d", mixerControls[lpmcd->dwControlID].ctrl.szName, pDetails->fValue));
     548            fMute = pDetails->fValue;
    550549            if(lpmcd->cChannels == 2) {
    551550                pDetails += 1;
    552                 dprintf(("Right mute %d", pDetails->fValue));
     551                dprintf(("%s Right mute %d", mixerControls[lpmcd->dwControlID].ctrl.szName, pDetails->fValue));
    553552            }
    554553            //todo > 2 channels (usually only 1 channel is requested though)
     554
     555            if(OSLibMixSetMute(mixerControls[lpmcd->dwControlID].id, fMute) == FALSE) {
     556                return MMSYSERR_INVALPARAM;
     557            }
     558            mixerControls[lpmcd->dwControlID].val[0].dwValue = fMute;
    555559            return MMSYSERR_NOERROR;
    556560        }
    557561
     562        case MIXERCONTROL_CONTROLTYPE_BASS:
     563        case MIXERCONTROL_CONTROLTYPE_TREBLE:
    558564        case MIXERCONTROL_CONTROLTYPE_FADER:
    559565        {
    560566            MIXERCONTROLDETAILS_UNSIGNED *pDetails = (MIXERCONTROLDETAILS_UNSIGNED *)lpmcd->paDetails;
    561 
    562             dprintf(("MIXERCONTROL_CONTROLTYPE_FADER"));
    563 
    564             if(lpmcd->cChannels != 1) {
    565                 dprintf(("Invalid nr of channels %d!!", lpmcd->cChannels));
     567            DWORD dwLevel;
     568
     569#ifdef DEBUG
     570            switch(fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
     571            case MIXERCONTROL_CONTROLTYPE_TREBLE:
     572                dprintf(("MIXERCONTROL_CONTROLTYPE_TREBLE"));
     573                break;
     574            case MIXERCONTROL_CONTROLTYPE_BASS:
     575                dprintf(("MIXERCONTROL_CONTROLTYPE_BASS"));
     576                break;
     577            case MIXERCONTROL_CONTROLTYPE_FADER:
     578                dprintf(("MIXERCONTROL_CONTROLTYPE_FADER"));
     579                break;
     580            }
     581#endif
     582            dprintf(("%s %d", mixerControls[lpmcd->dwControlID].ctrl.szName, pDetails->dwValue));
     583            dwLevel = pDetails->dwValue;
     584            if(OSLibMixSetVolume(mixerControls[lpmcd->dwControlID].id, dwLevel, dwLevel) == FALSE) {
    566585                return MMSYSERR_INVALPARAM;
    567586            }
    568 #ifdef DEBUG
    569             if(mixerControls[lpmcd->dwControlID].id == MIX_CTRL_OUT_L_3DCENTER) {
    570                  dprintf(("3D center %d", pDetails->dwValue));
    571             }
    572             else dprintf(("3D depth %d", pDetails->dwValue));
    573 #endif
    574             return MMSYSERR_NOERROR;
    575         }
    576 
    577         case MIXERCONTROL_CONTROLTYPE_BASS:
    578         {
    579             MIXERCONTROLDETAILS_UNSIGNED *pDetails = (MIXERCONTROLDETAILS_UNSIGNED *)lpmcd->paDetails;
    580 
    581             dprintf(("MIXERCONTROL_CONTROLTYPE_BASS"));
    582 
    583             if(lpmcd->cChannels != 1) {
    584                 dprintf(("Invalid nr of channels %d!!", lpmcd->cChannels));
    585                 return MMSYSERR_INVALPARAM;
    586             }
    587             dprintf(("Bass %d", pDetails->dwValue));
    588             return MMSYSERR_NOERROR;
    589         }
    590 
    591         case MIXERCONTROL_CONTROLTYPE_TREBLE:
    592         {
    593             MIXERCONTROLDETAILS_UNSIGNED *pDetails = (MIXERCONTROLDETAILS_UNSIGNED *)lpmcd->paDetails;
    594 
    595             dprintf(("MIXERCONTROL_CONTROLTYPE_TREBLE"));
    596 
    597             if(lpmcd->cChannels != 1) {
    598                 dprintf(("Invalid nr of channels %d!!", lpmcd->cChannels));
    599                 return MMSYSERR_INVALPARAM;
    600             }
    601             dprintf(("Treble %d", pDetails->dwValue));
     587            mixerControls[lpmcd->dwControlID].val[0].dwValue = dwLevel;
    602588            return MMSYSERR_NOERROR;
    603589        }

  • trunk/src/winmm/mixeros2.cpp

    r8493 r8506  
    1 /* $Id: mixeros2.cpp,v 1.5 2002-05-26 10:52:31 sandervl Exp $ */
     1/* $Id: mixeros2.cpp,v 1.6 2002-05-28 13:35:02 sandervl Exp $ */
    22
    33/*
    … …  
    3232static HFILE hPDDMix = 0;
    3333static char  mixerApiMap[256] = {0};
     34static int   szVolumeLevels[MIX_CTRL_MAX][2] = {0};
    3435
    3536/******************************************************************************/
    … …  
    5657    }
    5758
     59    memset(szVolumeLevels, -1, sizeof(szVolumeLevels));
    5860    return TRUE;
    5961}
    … …  
    126128        idx = RECORDGAINSET;
    127129        break;
    128 
    129130    default:
    130131        return -1;
    … …  
    147148/******************************************************************************/
    148149/******************************************************************************/
    149 BOOL OSLibMixSetVolume(DWORD dwControl, BOOL fMute, DWORD dwVolLeft, DWORD dwVolRight)
     150BOOL OSLibMixSetVolume(DWORD dwControl, DWORD dwVolLeft, DWORD dwVolRight)
     151{
     152    DWORD     dwFunc, dwIOCT90VolLeft, dwIOCT90VolRight;
     153    MIXSTRUCT mixstruct;
     154
     155    //TODO: implement master volume with MMPM2
     156    if(dwControl == MIX_CTRL_VOL_OUT_LINE) {
     157        return TRUE;
     158    }
     159
     160    //wave in recording levels are virtual controls as there is only
     161    //one control for recording gain
     162    switch(dwControl) {
     163    case MIX_CTRL_VOL_IN_W_MONO:
     164    case MIX_CTRL_VOL_IN_W_PHONE:
     165    case MIX_CTRL_VOL_IN_W_MIC:
     166    case MIX_CTRL_VOL_IN_W_LINE:
     167    case MIX_CTRL_VOL_IN_W_CD:
     168    case MIX_CTRL_VOL_IN_W_VIDEO:
     169    case MIX_CTRL_VOL_IN_W_AUX:
     170    case MIX_CTRL_VOL_IN_W_PCM:
     171        szVolumeLevels[dwControl][0] = dwVolLeft;
     172        szVolumeLevels[dwControl][1] = dwVolRight;
     173        break;
     174    }
     175    dwFunc = OSLibMixGetIndex(dwControl);
     176    if(dwFunc == -1) {
     177        return FALSE;
     178    }
     179    dwFunc += MONOINSET;
     180
     181    //first get current mute value
     182    if(mixerapiIOCTL90(hPDDMix, dwFunc-MONOINSET+MONOINQUERY, &mixstruct, sizeof(mixstruct)) == FALSE) {
     183        return FALSE;
     184    }
     185
     186    if(dwVolLeft > MIXER_WIN32_MAX_VOLUME || dwVolRight > MIXER_WIN32_MAX_VOLUME) {
     187        dprintf(("OSLibMixSetVolume: Volume (%d,%d) out of RANGE!!", dwVolLeft, dwVolRight));
     188        return FALSE;
     189    }
     190    if(dwControl == MIX_CTRL_OUT_L_TREBLE) {
     191        //get bass value (right = treble, left = bass)
     192        OSLibMixGetVolume(MIX_CTRL_OUT_L_BASS, &dwVolLeft, NULL);
     193    }
     194    else
     195    if(dwControl == MIX_CTRL_OUT_L_BASS) {
     196        //get treble value (right = treble, left = bass)
     197        OSLibMixGetVolume(MIX_CTRL_OUT_L_TREBLE, &dwVolRight, NULL);
     198    }
     199
     200    dwIOCT90VolLeft  = WIN32_TO_IOCTL90_VOLUME(dwVolLeft);
     201    dwIOCT90VolRight = WIN32_TO_IOCTL90_VOLUME(dwVolRight);
     202
     203    if(mixstruct.VolumeL == dwIOCT90VolLeft &&
     204       mixstruct.VolumeR == dwIOCT90VolRight)
     205    {
     206        return TRUE; //nothing to do
     207    }
     208    //change volume levels
     209    mixstruct.VolumeL = dwIOCT90VolLeft;
     210    mixstruct.VolumeR = dwIOCT90VolRight;
     211
     212    if(mixerapiIOCTL90(hPDDMix, dwFunc, &mixstruct, sizeof(mixstruct)) == TRUE) {
     213        return TRUE;
     214    }
     215    dprintf(("OSLibMixSetVolume: mixerapiIOCTL90 %d failed!!", dwFunc));
     216    return FALSE;
     217}
     218/******************************************************************************/
     219/******************************************************************************/
     220BOOL OSLibMixSetMute(DWORD dwControl, BOOL fMute)
    150221{
    151222    DWORD     dwFunc;
    … …  
    153224
    154225    //TODO: implement master volume with MMPM2
    155     if(dwControl == MIX_CTRL_VOL_OUT_LINE || dwControl == MIX_CTRL_MUTE_OUT_LINE) {
     226    if(dwControl == MIX_CTRL_MUTE_OUT_LINE) {
    156227        return TRUE;
    157228    }
    … …  
    163234    dwFunc += MONOINSET;
    164235
    165     if(dwVolLeft > MIXER_IOCTL90_MAX_VOLUME || dwVolRight > MIXER_IOCTL90_MAX_VOLUME) {
    166         dprintf(("OSLibMixSetVolume: Volume (%d,%d) out of RANGE!!", dwVolLeft, dwVolRight));
    167         return FALSE;
    168     }
    169     mixstruct.Mute    = fMute;
    170     mixstruct.VolumeL = WIN32_TO_IOCTL90_VOLUME(dwVolLeft);
    171     mixstruct.VolumeR = WIN32_TO_IOCTL90_VOLUME(dwVolRight);
     236    //first get current volume levels
     237    if(mixerapiIOCTL90(hPDDMix, dwFunc-MONOINSET+MONOINQUERY, &mixstruct, sizeof(mixstruct)) == FALSE) {
     238        return FALSE;
     239    }
     240
     241    if(mixstruct.Mute == fMute) {
     242        return TRUE; //nothing to do
     243    }
     244   
     245    //change mute
     246    mixstruct.Mute = fMute;
    172247
    173248    if(mixerapiIOCTL90(hPDDMix, dwFunc, &mixstruct, sizeof(mixstruct)) == TRUE) {
    … …  
    179254/******************************************************************************/
    180255/******************************************************************************/
    181 BOOL OSLibMixGetVolume(DWORD dwControl, BOOL *pfMute, DWORD *pdwVolLeft, DWORD *pdwVolRight)
     256BOOL OSLibMixGetVolume(DWORD dwControl, DWORD *pdwVolLeft, DWORD *pdwVolRight)
    182257{
    183258    DWORD     dwFunc;
    … …  
    185260
    186261    //TODO: implement master volume with MMPM2
    187     if(dwControl == MIX_CTRL_VOL_OUT_LINE || dwControl == MIX_CTRL_MUTE_OUT_LINE) {
    188         if(pfMute)      *pfMute      = 0;
     262    if(dwControl == MIX_CTRL_VOL_OUT_LINE) {
    189263        if(pdwVolLeft)  *pdwVolLeft  = 50000;
    190264        if(pdwVolRight) *pdwVolRight = 50000;
    … …  
    192266    }
    193267
     268    //wave in recording levels are virtual controls as there is only
     269    //one control for recording gain
     270    switch(dwControl) {
     271    case MIX_CTRL_VOL_IN_W_MONO:
     272    case MIX_CTRL_VOL_IN_W_PHONE:
     273    case MIX_CTRL_VOL_IN_W_MIC:
     274    case MIX_CTRL_VOL_IN_W_LINE:
     275    case MIX_CTRL_VOL_IN_W_CD:
     276    case MIX_CTRL_VOL_IN_W_VIDEO:
     277    case MIX_CTRL_VOL_IN_W_AUX:
     278    case MIX_CTRL_VOL_IN_W_PCM:
     279        if(szVolumeLevels[dwControl][0] != -1) {
     280            if(pdwVolLeft)  *pdwVolLeft  = szVolumeLevels[dwControl][0];
     281            if(pdwVolRight) *pdwVolRight = szVolumeLevels[dwControl][1];
     282            return TRUE;
     283        }
     284        break;
     285    }
     286
    194287    dwFunc = OSLibMixGetIndex(dwControl);
    195288    if(dwFunc == -1) {
    … …  
    207300    mixstruct.VolumeR = min(MIXER_IOCTL90_MAX_VOLUME, mixstruct.VolumeR);
    208301
    209     if(pfMute)      *pfMute      = mixstruct.Mute;
    210     if(pdwVolLeft)  *pdwVolLeft  = IOCTL90_TO_WIN32_VOLUME(mixstruct.VolumeL);
    211     if(pdwVolRight) *pdwVolRight = IOCTL90_TO_WIN32_VOLUME(mixstruct.VolumeR);
    212 
     302    if(dwControl == MIX_CTRL_OUT_L_TREBLE) {
     303        mixstruct.VolumeL = mixstruct.VolumeR;  //right = treble, left = bass
     304    }
     305    else
     306    if(dwControl == MIX_CTRL_OUT_L_BASS) {
     307        mixstruct.VolumeR = mixstruct.VolumeL;  //right = treble, left = bass
     308    }
     309
     310    //save volume levels
     311    szVolumeLevels[dwControl][0] = IOCTL90_TO_WIN32_VOLUME(mixstruct.VolumeL);
     312    szVolumeLevels[dwControl][1] = IOCTL90_TO_WIN32_VOLUME(mixstruct.VolumeR);
     313
     314    if(pdwVolLeft)  *pdwVolLeft  = szVolumeLevels[dwControl][0];
     315    if(pdwVolRight) *pdwVolRight = szVolumeLevels[dwControl][1];
     316
     317    return TRUE;
     318}
     319/******************************************************************************/
     320/******************************************************************************/
     321BOOL OSLibMixGetMute(DWORD dwControl, BOOL *pfMute)
     322{
     323    DWORD     dwFunc;
     324    MIXSTRUCT mixstruct;
     325
     326    //TODO: implement master volume with MMPM2
     327    if(dwControl == MIX_CTRL_MUTE_OUT_LINE) {
     328        if(pfMute)      *pfMute      = 0;
     329        return TRUE;
     330    }
     331    dwFunc = OSLibMixGetIndex(dwControl);
     332    if(dwFunc == -1) {
     333        return FALSE;
     334    }
     335    dwFunc += MONOINQUERY;
     336
     337    if(mixerapiIOCTL90(hPDDMix, dwFunc, &mixstruct, sizeof(mixstruct)) == FALSE) {
     338        return FALSE;
     339    }
     340    if(pfMute) *pfMute = mixstruct.Mute;
    213341    return TRUE;
    214342}
    … …  
    273401BOOL OSLibMixIsRecSourcePresent(DWORD dwRecSrc)
    274402{
    275     DWORD dwOldRecSrc, dwVolL, dwVolR;
    276 
    277     if(OSLibMixGetRecSource(&dwOldRecSrc, &dwVolL, &dwVolR) == FALSE) {
    278         return FALSE;
    279     }
    280     if(OSLibMixSetRecSource(dwRecSrc, dwVolL, dwVolR) == FALSE) {
    281         return FALSE;
    282     }
    283     OSLibMixSetRecSource(dwOldRecSrc, dwVolL, dwVolR);
     403    if(OSLibMixSetRecSource(dwRecSrc) == FALSE) {
     404        return FALSE;
     405    }
    284406    return TRUE;
    285407}
    286408/******************************************************************************/
    287409/******************************************************************************/
    288 BOOL OSLibMixSetRecSource(DWORD dwRecSrc, DWORD dwVolL, DWORD dwVolR)
    289 {
    290     DWORD idx;
     410BOOL OSLibMixSetRecSource(DWORD dwRecSrc)
     411{
     412    DWORD     idx, volidx;
    291413    MIXSTRUCT mixstruct;
     414    DWORD     dwVolL, dwVolR;
    292415
    293416    switch(dwRecSrc) {
    294417    case MIXER_SRC_IN_W_MIC:
    295418        idx = I90SRC_MIC;
     419        volidx = MIX_CTRL_VOL_IN_W_MIC;
    296420        break;
    297421    case MIXER_SRC_IN_W_CD:
    298422        idx = I90SRC_CD;
     423        volidx = MIX_CTRL_VOL_IN_W_CD;
    299424        break;
    300425    case MIXER_SRC_IN_W_VIDEO:
    301426        idx = I90SRC_VIDEO;
     427        volidx = MIX_CTRL_VOL_IN_W_VIDEO;
    302428        break;
    303429    case MIXER_SRC_IN_W_AUX:
    304430        idx = I90SRC_AUX;
     431        volidx = MIX_CTRL_VOL_IN_W_AUX;
    305432        break;
    306433    case MIXER_SRC_IN_W_LINE:
    307434        idx = I90SRC_LINE;
     435        volidx = MIX_CTRL_VOL_IN_W_LINE;
    308436        break;
    309437    case MIXER_SRC_IN_W_PHONE:
    310438        idx = I90SRC_PHONE;
     439        volidx = MIX_CTRL_VOL_IN_W_PHONE;
    311440        break;
    312441    default:
    … …  
    316445    mixstruct.VolumeL = idx;
    317446
     447    //select recording source
    318448    if(mixerapiIOCTL90(hPDDMix, RECORDSRCSET, &mixstruct, sizeof(mixstruct)) == FALSE) {
    319449        dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDSRCSET failed!!"));
    … …  
    321451    }
    322452
    323     mixstruct.Mute    = 0;
     453    dwVolL = szVolumeLevels[volidx][0];
     454    dwVolR = szVolumeLevels[volidx][1];
    324455    mixstruct.VolumeL = WIN32_TO_IOCTL90_VOLUME(dwVolL);
    325456    mixstruct.VolumeR = WIN32_TO_IOCTL90_VOLUME(dwVolR);
     457    mixstruct.Mute    = 0;
     458
     459    //set recording gain to that of the selected source
    326460    if(mixerapiIOCTL90(hPDDMix, RECORDGAINSET, &mixstruct, sizeof(mixstruct)) == FALSE) {
    327461        dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDGAINSET failed!!"));
    … …  
    332466/******************************************************************************/
    333467/******************************************************************************/
    334 BOOL OSLibMixGetRecSource(DWORD *pdwRecSrc, DWORD *pdwVolL, DWORD *pdwVolR)
     468BOOL OSLibMixGetRecSource(DWORD *pdwRecSrc)
    335469{
    336470    DWORD idx;
    … …  
    366500    if(pdwRecSrc) {
    367501        *pdwRecSrc = idx;
    368     }
    369     if(mixerapiIOCTL90(hPDDMix, RECORDGAINQUERY, &mixstruct, sizeof(mixstruct)) == FALSE) {
    370         dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDGAINQUERY failed!!"));
    371         return FALSE;
    372     }
    373     if(pdwVolL) {
    374         *pdwVolL = IOCTL90_TO_WIN32_VOLUME(mixstruct.VolumeL);
    375     }
    376     if(pdwVolR) {
    377         *pdwVolR = IOCTL90_TO_WIN32_VOLUME(mixstruct.VolumeR);
    378502    }
    379503    return TRUE;

  • trunk/src/winmm/mixeros2.h

    r8493 r8506  
    1 /* $Id: mixeros2.h,v 1.6 2002-05-26 10:52:31 sandervl Exp $ */
     1/* $Id: mixeros2.h,v 1.7 2002-05-28 13:35:02 sandervl Exp $ */
    22
    33/*
    … …  
    113113
    114114BOOL OSLibMixIsControlPresent(DWORD dwControl);
    115 BOOL OSLibMixSetVolume(DWORD dwControl, BOOL fMute, DWORD dwVolLeft, DWORD dwVolRight);
    116 BOOL OSLibMixGetVolume(DWORD dwControl, BOOL *pfMute, DWORD *pdwVolLeft, DWORD *pdwVolRight);
    117 BOOL OSLibMixSetRecSource(DWORD dwRecSrc, DWORD dwVolL, DWORD dwVolR);
    118 BOOL OSLibMixGetRecSource(DWORD *pdwRecSrc, DWORD *pdwVolL, DWORD *pdwVolR);
     115BOOL OSLibMixSetVolume(DWORD dwControl, DWORD dwVolLeft, DWORD dwVolRight);
     116BOOL OSLibMixGetVolume(DWORD dwControl, DWORD *pdwVolLeft, DWORD *pdwVolRight);
     117BOOL OSLibMixSetMute(DWORD dwControl, BOOL fMute);
     118BOOL OSLibMixGetMute(DWORD dwControl, BOOL *pfMute);
     119BOOL OSLibMixSetRecSource(DWORD dwRecSrc);
     120BOOL OSLibMixGetRecSource(DWORD *pdwRecSrc);
    119121BOOL OSLibMixIsRecSourcePresent(DWORD dwRecSrc);
    120122BOOL OSLibMixGetCtrlCaps(DWORD dwControl, LONG *plMinimum, LONG *plMaximum, DWORD *pcSteps);
Note: See TracChangeset for help on using the changeset viewer.