Changeset 8477 for trunk/src


Ignore:
Timestamp:
May 23, 2002, 3:50:16 PM (23 years ago)
Author:
sandervl
Message:

mixer updates

Location:
trunk/src/winmm
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/winmm/mixer.cpp

    r8472 r8477  
    1 /* $Id: mixer.cpp,v 1.12 2002-05-22 20:19:11 sandervl Exp $ */
     1/* $Id: mixer.cpp,v 1.13 2002-05-23 13:50:15 sandervl Exp $ */
    22
    33/*
    … …  
    66 * Copyright 2002 Sander van Leeuwen (sandervl@xs4all.nl)
    77 *
     8 * TODO: Mixer notification
     9 *
     10 * NOTE: Not really flexible (capabilities, > 1 audio card)
     11 *
    812 * Project Odin Software License can be found in LICENSE.TXT
    913 *
    … …  
    1923#include <os2win.h>
    2024#include <string.h>
     25#include <dbglog.h>
    2126#include <mmsystem.h>
    22 #include <odinwrap.h>
    23 #include <misc.h>
     27#include <winnls.h>
    2428
    2529#include "waveoutdart.h"
    … …  
    3236#include "dbglocal.h"
    3337
    34 
    35 MIXERLINEA    mixerDest[MAX_MIXER_DESTINATIONS] = {0};
    36 MIXERLINEA    mixerSource[MAX_MIXER_SOURCES]    = {0};
    37 MIXERCONTROLA mixerControls[MAX_MIXER_CONTROLS] = {0};
     38static BOOL mixerAddControl(DWORD dwControl);
     39static BOOL mixerAddSource(DWORD dwDest);
     40static BOOL mixerAddDestination(DWORD dwSource);
     41
     42static MIXERLINEA    mixerDest[MAX_MIXER_DESTINATIONS] = {0};
     43static MIXERLINEA    mixerSource[MAX_MIXER_SOURCES]    = {0};
     44static MIXERCONTROLA mixerControls[MAX_MIXER_CONTROLS] = {0};
     45static int           nrDestinations                    = 0;
     46static int           nrSources                         = 0;
     47static int           nrControls                        = 0;
     48static int           nrLineOutInputs                   = 0;
     49static int           nrLineOutControls                 = 0;
     50static int           nrWaveInInputs                    = 0;
     51static int           nrWaveInControls                  = 0;
     52static int           nrSPDIFInputs                     = 0;
     53static int           nrSPDIFControls                   = 0;
    3854
    3955/******************************************************************************/
    … …  
    4157MMRESULT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
    4258{
    43     DWORD       ret = MMSYSERR_NOTSUPPORTED;
    4459    DWORD       lineID, controlType;
    4560   
    … …  
    5671        break;
    5772    }
    58     return ret;
     73    return MMSYSERR_NOERROR;
    5974}
    6075/******************************************************************************/
    … …  
    89104/******************************************************************************/
    90105/******************************************************************************/
    91 MMRESULT WINAPI mixerGetLineControlsA(HMIXEROBJ  hmxobj, LPMIXERLINECONTROLSA lpMlc, DWORD fdwControls)
    92 {
    93  DWORD dwRet = MMSYSERR_NOERROR;
    94  DWORD lineID, controlType;
     106MMRESULT WINAPI mixerGetLineControlsA(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSA lpMlc, DWORD fdwControls)
     107{
     108    DWORD dwRet = MMSYSERR_NOERROR;
     109    DWORD lineID, controlType;
     110    DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
     111
     112    if(!pMixInfo) {
     113        return MMSYSERR_INVALHANDLE;
     114    }
    95115
    96116    if (lpMlc == NULL) return MMSYSERR_INVALPARAM;
    97     if (lpMlc->cbStruct < sizeof(*lpMlc) ||
    98         lpMlc->cbmxctrl < sizeof(MIXERCONTROLA))
    99         return MMSYSERR_INVALPARAM;
     117
     118    if (lpMlc->cbStruct < sizeof(*lpMlc) || lpMlc->cbmxctrl < sizeof(MIXERCONTROLA))
     119            return MMSYSERR_INVALPARAM;
    100120
    101121    switch(fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK)
    … …  
    110130    case MIXER_GETLINECONTROLSF_ONEBYID:
    111131            break;
     132
    112133    case MIXER_GETLINECONTROLSF_ONEBYTYPE:
    113134            switch (lpMlc->u.dwControlType & MIXERCONTROL_CT_CLASS_MASK) {
    … …  
    120141        }
    121142        break;
     143
    122144    default:
    123145            dprintf(("Unknown flag %08lx\n", fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK));
    … …  
    131153MMRESULT WINAPI mixerGetLineControlsW(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSW pmxlc, DWORD fdwControls)
    132154{
     155    DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
     156
     157    if(!pMixInfo) {
     158        return MMSYSERR_INVALHANDLE;
     159    }
     160
    133161    dprintf(("WINMM:mixerGetGetLineControlsW - stub\n" ));
    134162    return MIXERR_INVALLINE;
    … …  
    138166MMRESULT WINAPI mixerGetLineInfoA(HMIXEROBJ hmxobj, LPMIXERLINEA lpMl, DWORD fdwInfo)
    139167{
    140     if (lpMl == NULL || lpMl->cbStruct != sizeof(*lpMl))
     168    DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
     169
     170    if(!pMixInfo) {
     171        return MMSYSERR_INVALHANDLE;
     172    }
     173
     174    if (lpMl == NULL || lpMl->cbStruct != sizeof(*lpMl)) {
     175        dprintf(("ERROR: mixerGetLineInfoA: invalid paramter!!"));
    141176            return MMSYSERR_INVALPARAM;
     177    }
    142178   
    143     /* FIXME: set all the variables correctly... the lines below
    144      * are very wrong...
    145      */
    146     lpMl->fdwLine       = MIXERLINE_LINEF_ACTIVE;
    147     lpMl->cChannels     = 1;
    148     lpMl->dwUser        = 0;
    149     lpMl->cControls     = 2;
    150 
    151179    switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK)
    152180    {
    153181    case MIXER_GETLINEINFOF_DESTINATION:
     182        dprintf(("MIXER_GETLINEINFOF_DESTINATION"));
     183        if(lpMl->dwDestination >= nrDestinations) {
     184            dprintf(("ERROR: Invalid desitnation %d", lpMl->dwDestination));
     185            return MMSYSERR_INVALPARAM;
     186        }
     187        memcpy(lpMl, &mixerDest[lpMl->dwDestination], sizeof(MIXERLINEA));
    154188        break;
    155189
    156190    case MIXER_GETLINEINFOF_LINEID:
     191        dprintf(("MIXER_GETLINEINFOF_LINEID"));
    157192        break;
    158193
    159194    case MIXER_GETLINEINFOF_SOURCE:
     195        dprintf(("MIXER_GETLINEINFOF_SOURCE"));
     196        if(lpMl->dwDestination >= nrDestinations) {
     197            dprintf(("ERROR: Invalid desitnation %d", lpMl->dwDestination));
     198            return MMSYSERR_INVALPARAM;
     199        }
    160200        break;
    161201
    162202    case MIXER_GETLINEINFOF_COMPONENTTYPE:
     203        dprintf(("MIXER_GETLINEINFOF_COMPONENTTYPE"));
    163204            switch (lpMl->dwComponentType)
    164205            {
    … …  
    171212                return MMSYSERR_INVALPARAM;
    172213            }
    173         lpMl->cConnections  = 0;
    174         lpMl->cControls     = 1;
    175         lpMl->cChannels     = 2;
    176214            break;
    177215
    … …  
    182220            dprintf(("Unknown flag (%08lx)\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK));
    183221            break;
    184     }
    185    
    186     lpMl->Target.dwType = MIXERLINE_TARGETTYPE_AUX;
    187     lpMl->Target.dwDeviceID = 0xFFFFFFFF;
    188     lpMl->Target.wMid = 0;
    189     lpMl->Target.wPid = 0;
    190     lpMl->Target.vDriverVersion = 1;
    191     lstrcpyA(lpMl->Target.szPname, WINMM_MIXERSTRING_A);
    192    
     222    }   
    193223    return MMSYSERR_NOERROR;
    194224}
    195 
     225/******************************************************************************/
    196226/******************************************************************************/
    197227MMRESULT WINAPI mixerGetLineInfoW(HMIXEROBJ hmxobj, LPMIXERLINEW pmxl, DWORD fdwInfo)
    198228{
    199     dprintf(("WINMM:mixerGetLineInfoW - stub\n" ));
    200     return MIXERR_INVALLINE;
     229    DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
     230    MIXERLINEA     line;
     231    MMRESULT       result;
     232
     233    if(!pMixInfo) {
     234        return MMSYSERR_INVALHANDLE;
     235    }
     236    line.cbStruct              = sizeof(MIXERLINEA);
     237    line.cChannels             = pmxl->cChannels;
     238    line.cConnections          = pmxl->cConnections;
     239    line.dwComponentType       = pmxl->dwComponentType;
     240    line.dwDestination         = pmxl->dwDestination;
     241    line.dwLineID              = pmxl->dwLineID;
     242    line.dwSource              = pmxl->dwSource;
     243    line.dwUser                = pmxl->dwUser;
     244    line.fdwLine               = pmxl->fdwLine;
     245    line.szName[0]             = 0;
     246    line.szShortName[0]        = 0;
     247    line.Target.dwDeviceID     = pmxl->Target.dwDeviceID;
     248    line.Target.dwType         = pmxl->Target.dwType;
     249    line.Target.vDriverVersion = pmxl->Target.vDriverVersion;
     250    line.Target.wMid           = pmxl->Target.wMid;
     251    line.Target.wPid           = pmxl->Target.wPid;
     252    line.Target.szPname[0]     = 0;
     253
     254    result = mixerGetLineInfoA(hmxobj, &line, fdwInfo);
     255    if(result != MMSYSERR_NOERROR) {
     256        return result;
     257    }
     258    pmxl->cbStruct              = sizeof(MIXERLINEA);
     259    pmxl->cChannels             = line.cChannels;
     260    pmxl->cConnections          = line.cConnections;
     261    pmxl->dwComponentType       = line.dwComponentType;
     262    pmxl->dwDestination         = line.dwDestination;
     263    pmxl->dwLineID              = line.dwLineID;
     264    pmxl->dwSource              = line.dwSource;
     265    pmxl->dwUser                = line.dwUser;
     266    pmxl->fdwLine               = line.fdwLine;
     267    MultiByteToWideChar(CP_ACP, 0, line.szName, -1, pmxl->szName, sizeof(line.szName));
     268    MultiByteToWideChar(CP_ACP, 0, line.szShortName, -1, pmxl->szShortName, sizeof(line.szShortName));
     269    pmxl->Target.dwDeviceID     = line.Target.dwDeviceID;
     270    pmxl->Target.dwType         = line.Target.dwType;
     271    pmxl->Target.vDriverVersion = line.Target.vDriverVersion;
     272    pmxl->Target.wMid           = line.Target.wMid;
     273    pmxl->Target.wPid           = line.Target.wPid;
     274    pmxl->Target.szPname[0]     = 0;
     275    MultiByteToWideChar(CP_ACP, 0, line.Target.szPname, -1, pmxl->Target.szPname, sizeof(line.Target.szPname));
     276    return MMSYSERR_NOERROR;
    201277}
    202278/******************************************************************************/
    … …  
    237313
    238314        pmxcaps->fdwSupport    = 0;    //no mixer flags exist
    239         pmxcaps->cDestinations = 1;
     315        pmxcaps->cDestinations = nrDestinations;
    240316    }
    241317
    … …  
    263339
    264340        pmxcaps->fdwSupport    = 0;    //no mixer flags exist
    265         pmxcaps->cDestinations = 1;
     341        pmxcaps->cDestinations = nrDestinations;
    266342    }
    267343
    … …  
    272348MMRESULT WINAPI mixerGetID(HMIXEROBJ hmxobj, UINT * puMxId, DWORD fdwId)
    273349{
    274     DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
    275 
    276     if(!pMixInfo) {
    277         return MMSYSERR_INVALHANDLE;
    278     }
    279 
    280     if(puMxId) {
    281         *puMxId = pMixInfo->uDeviceID;
    282     }
    283     else *puMxId = 0;
     350    switch(fdwId) {
     351    case MIXER_OBJECTF_MIXER:
     352    {
     353        DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
     354        if(!pMixInfo) {
     355            if(puMxId) {
     356                *puMxId = -1;
     357            }
     358            return MMSYSERR_INVALHANDLE;
     359        }
     360        if(puMxId) {
     361            *puMxId = pMixInfo->uDeviceID;
     362        }
     363        break;
     364    }
     365
     366    case MIXER_OBJECTF_HMIXER:
     367    case MIXER_OBJECTF_WAVEOUT:
     368    case MIXER_OBJECTF_HWAVEOUT:
     369    case MIXER_OBJECTF_WAVEIN:
     370    case MIXER_OBJECTF_HWAVEIN:
     371    case MIXER_OBJECTF_MIDIOUT:
     372    case MIXER_OBJECTF_HMIDIOUT:
     373    case MIXER_OBJECTF_MIDIIN:
     374    case MIXER_OBJECTF_HMIDIIN:
     375    case MIXER_OBJECTF_AUX:
     376        //TODO: assume default mixer
     377        if(puMxId) {
     378            *puMxId = 0;
     379        }
     380        break;
     381    default:
     382        if(puMxId) {
     383            *puMxId = -1;
     384        }
     385        return MMSYSERR_INVALPARAM;
     386    }
    284387    return MMSYSERR_NOERROR;
    285388}
    … …  
    306409    if(phmx)
    307410        *phmx = (HMIXER)pMixInfo;
     411
    308412    return MMSYSERR_NOERROR;
    309413}
    … …  
    324428
    325429    if(OSLibMixerOpen() == FALSE) {
     430        //Line out destination
     431        mixerAddControl(MIX_CTRL_VOL_OUT_LINE);
     432        mixerAddControl(MIX_CTRL_MUTE_OUT_LINE);
     433        //muast add after all controls (for counting controls & inputs)
     434        mixerAddDestination(MIXER_DEST_LINEOUT);
     435
     436        //WaveIn destination
     437        mixerAddControl(MIX_CTRL_VOL_IN_W_MIC);
     438        mixerAddControl(MIX_CTRL_VOL_IN_W_LINE);
     439        //must add after all recording inputs (to count them)
     440        mixerAddControl(MIX_CTRL_MUX_IN_W_SRC);
     441        //muast add after all wave in controls (for counting controls & inputs)
     442        mixerAddDestination(MIXER_DEST_WAVEIN);
     443        return TRUE;
     444    }
     445    //Line out destination
     446    mixerAddControl(MIX_CTRL_VOL_OUT_LINE);
     447    mixerAddControl(MIX_CTRL_MUTE_OUT_LINE);
     448
     449    if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_SPDIF)) {
     450        mixerAddSource(MIXER_SRC_SPDIF);
     451        mixerAddControl(MIX_CTRL_VOL_IN_L_SPDIF);
     452        mixerAddControl(MIX_CTRL_MUTE_IN_L_SPDIF);
     453    }
     454
     455    if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_MONO)) {
     456        mixerAddSource(MIXER_SRC_MONOIN);
     457        mixerAddControl(MIX_CTRL_VOL_IN_L_MONO);
     458        mixerAddControl(MIX_CTRL_MUTE_IN_L_MONO);
     459    }
     460    if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_PHONE)) {
     461        mixerAddSource(MIXER_SRC_PHONE);
     462        mixerAddControl(MIX_CTRL_VOL_IN_L_PHONE);
     463        mixerAddControl(MIX_CTRL_MUTE_IN_L_PHONE);
     464    }
     465    if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_MIC)) {
     466        mixerAddSource(MIXER_SRC_MIC);
     467        mixerAddControl(MIX_CTRL_VOL_IN_L_MIC);
     468        mixerAddControl(MIX_CTRL_MUTE_IN_L_MIC);
     469        if(OSLibMixIsControlPresent(MIX_CTRL_BOOST_IN_L_MIC)) {
     470            mixerAddControl(MIX_CTRL_BOOST_IN_L_MIC);
     471        }
     472    }
     473    if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_LINE)) {
     474        mixerAddSource(MIXER_SRC_LINE);
     475        mixerAddControl(MIX_CTRL_VOL_IN_L_LINE);
     476        mixerAddControl(MIX_CTRL_MUTE_IN_L_LINE);
     477    }
     478    if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_CD)) {
     479        mixerAddSource(MIXER_SRC_CD);
     480        mixerAddControl(MIX_CTRL_VOL_IN_L_CD);
     481        mixerAddControl(MIX_CTRL_MUTE_IN_L_CD);
     482    }
     483    if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_VIDEO)) {
     484        mixerAddSource(MIXER_SRC_VIDEO);
     485        mixerAddControl(MIX_CTRL_VOL_IN_L_VIDEO);
     486        mixerAddControl(MIX_CTRL_MUTE_IN_L_VIDEO);
     487    }
     488    if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_AUX)) {
     489        mixerAddSource(MIXER_SRC_AUX);
     490        mixerAddControl(MIX_CTRL_VOL_IN_L_AUX);
     491        mixerAddControl(MIX_CTRL_MUTE_IN_L_AUX);
     492    }
     493    if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_PCM)) {
     494        mixerAddSource(MIXER_SRC_PCM);
     495        mixerAddControl(MIX_CTRL_VOL_IN_L_PCM);
     496        mixerAddControl(MIX_CTRL_MUTE_IN_L_PCM);
     497    }
     498    if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_WAVETABLE)) {
     499        mixerAddSource(MIXER_SRC_WAVETABLE);
     500        mixerAddControl(MIX_CTRL_VOL_IN_L_WAVETABLE);
     501        mixerAddControl(MIX_CTRL_MUTE_IN_L_WAVETABLE);
     502    }
     503    if(OSLibMixIsControlPresent(MIX_CTRL_VOL_IN_L_MIDI)) {
     504        mixerAddSource(MIXER_SRC_MIDI);
     505        mixerAddControl(MIX_CTRL_VOL_IN_L_MIDI);
     506        mixerAddControl(MIX_CTRL_MUTE_IN_L_MIDI);
     507    }
     508    if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_3DCENTER)) {
     509        mixerAddControl(MIX_CTRL_OUT_L_3DCENTER);
     510    }
     511    if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_3DDEPTH)) {
     512        mixerAddControl(MIX_CTRL_OUT_L_3DDEPTH);
     513    }
     514    if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_TREBLE)) {
     515        mixerAddControl(MIX_CTRL_OUT_L_TREBLE);
     516    }
     517    if(OSLibMixIsControlPresent(MIX_CTRL_OUT_L_BASS)) {
     518        mixerAddControl(MIX_CTRL_OUT_L_BASS);
     519    }
     520    //muast add after all controls (for counting controls & inputs)
     521    mixerAddDestination(MIXER_DEST_LINEOUT);
     522
     523    //Wave In Destination
     524    if(OSLibMixIsControlPresent(MIX_CTRL_MUX_IN_W_SRC)) {
     525        if(OSLibMixIsRecSourcePresent(MIX_CTRL_VOL_IN_W_MONO)) {
     526            mixerAddControl(MIX_CTRL_VOL_IN_W_MONO);
     527        }
     528        if(OSLibMixIsRecSourcePresent(MIX_CTRL_VOL_IN_W_PHONE)) {
     529            mixerAddControl(MIX_CTRL_VOL_IN_W_PHONE);
     530        }
     531        if(OSLibMixIsRecSourcePresent(MIX_CTRL_VOL_IN_W_MIC)) {
     532            mixerAddControl(MIX_CTRL_VOL_IN_W_MIC);
     533        }
     534        if(OSLibMixIsRecSourcePresent(MIX_CTRL_VOL_IN_W_LINE)) {
     535            mixerAddControl(MIX_CTRL_VOL_IN_W_LINE);
     536        }
     537        if(OSLibMixIsRecSourcePresent(MIX_CTRL_VOL_IN_W_CD)) {
     538            mixerAddControl(MIX_CTRL_VOL_IN_W_CD);
     539        }
     540        if(OSLibMixIsRecSourcePresent(MIX_CTRL_VOL_IN_W_SPDIF)) {
     541            mixerAddControl(MIX_CTRL_VOL_IN_W_SPDIF);
     542        }
     543        if(OSLibMixIsRecSourcePresent(MIX_CTRL_VOL_IN_W_VIDEO)) {
     544            mixerAddControl(MIX_CTRL_VOL_IN_W_VIDEO);
     545        }
     546        if(OSLibMixIsRecSourcePresent(MIX_CTRL_VOL_IN_W_AUX)) {
     547            mixerAddControl(MIX_CTRL_VOL_IN_W_AUX);
     548        }
     549        if(OSLibMixIsRecSourcePresent(MIX_CTRL_VOL_IN_W_PCM)) {
     550            mixerAddControl(MIX_CTRL_VOL_IN_W_PCM);
     551        }
     552        if(OSLibMixIsRecSourcePresent(MIX_CTRL_VOL_IN_W_WAVETABLE)) {
     553            mixerAddControl(MIX_CTRL_VOL_IN_W_WAVETABLE);
     554        }
     555        if(OSLibMixIsRecSourcePresent(MIX_CTRL_VOL_IN_W_MIDI)) {
     556            mixerAddControl(MIX_CTRL_VOL_IN_W_MIDI);
     557        }
     558        //must add after all recording inputs (to count them)
     559        mixerAddControl(MIX_CTRL_MUX_IN_W_SRC);
     560        //muast add after all wave in controls (for counting controls & inputs)
     561        mixerAddDestination(MIXER_DEST_WAVEIN);
     562    }
     563
     564    //SPDIF destination
     565    if(OSLibMixIsControlPresent(MIX_CTRL_VOL_OUT_SPDIF)) {
     566        mixerAddControl(MIX_CTRL_VOL_OUT_SPDIF);
     567        mixerAddControl(MIX_CTRL_MUTE_OUT_SPDIF);
     568        mixerAddDestination(MIXER_DEST_SPDIFOUT);
     569    }
     570
     571    return TRUE;
     572}
     573/******************************************************************************/
     574/******************************************************************************/
     575void mixerExit()
     576{
     577    OSLibMixerClose();
     578}
     579/******************************************************************************/
     580/******************************************************************************/
     581static BOOL mixerAddSource(DWORD dwSource)
     582{
     583    MIXERLINEA *pline  = &mixerSource[nrSources];
     584
     585    if(nrSources >= MAX_MIXER_SOURCES) {
     586        dprintf(("ERROR: mixerAddSource: out of room!!!"));
     587        DebugInt3();
    326588        return FALSE;
    327589    }
     590
     591    pline->cbStruct = sizeof(MIXERLINEA);
     592    memset(pline, 0, sizeof(MIXERLINEA));
     593
     594    switch(dwSource) {
     595    case MIXER_SRC_MONOIN:
     596    case MIXER_SRC_PHONE:
     597        pline->dwSource        = nrSources;
     598        pline->cChannels       = 1;
     599        pline->cConnections    = 0;
     600        pline->cControls       = 0;
     601        pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE;
     602        pline->dwDestination   = 0;
     603        pline->dwLineID        = (DWORD)-1;
     604        pline->fdwLine         = MIXERLINE_LINEF_SOURCE;
     605        pline->Target.dwType   = MIXERLINE_TARGETTYPE_UNDEFINED;
     606        nrLineOutInputs++;
     607        break;
     608
     609    case MIXER_SRC_MIC:
     610        pline->dwSource        = nrSources;
     611        pline->cChannels       = 1;
     612        pline->cConnections    = 0;
     613        pline->cControls       = 0;
     614        pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
     615        pline->dwDestination   = 0;
     616        pline->dwLineID        = (DWORD)-1;
     617        pline->fdwLine         = MIXERLINE_LINEF_SOURCE;
     618        pline->Target.dwType   = MIXERLINE_TARGETTYPE_UNDEFINED;
     619        nrLineOutInputs++;
     620        break;
     621
     622    case MIXER_SRC_LINE:
     623        pline->dwSource        = nrSources;
     624        pline->cChannels       = 2;
     625        pline->cConnections    = 0;
     626        pline->cControls       = 0;
     627        pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_LINE;
     628        pline->dwDestination   = 0;
     629        pline->dwLineID        = (DWORD)-1;
     630        pline->fdwLine         = MIXERLINE_LINEF_SOURCE;
     631        pline->Target.dwType   = MIXERLINE_TARGETTYPE_UNDEFINED;
     632        nrLineOutInputs++;
     633        break;
     634
     635    case MIXER_SRC_CD:
     636        pline->dwSource        = nrSources;
     637        pline->cChannels       = 2;
     638        pline->cConnections    = 0;
     639        pline->cControls       = 0;
     640        pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC;
     641        pline->dwDestination   = 0;
     642        pline->dwLineID        = (DWORD)-1;
     643        pline->fdwLine         = MIXERLINE_LINEF_SOURCE;
     644        pline->Target.dwType   = MIXERLINE_TARGETTYPE_UNDEFINED;
     645        nrLineOutInputs++;
     646        break;
     647
     648    case MIXER_SRC_SPDIF:
     649        pline->dwSource        = nrSources;
     650        pline->cChannels       = 2;
     651        pline->cConnections    = 0;
     652        pline->cControls       = 0;
     653        pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_DIGITAL;
     654        pline->dwDestination   = 0;
     655        pline->dwLineID        = (DWORD)-1;
     656        pline->fdwLine         = MIXERLINE_LINEF_SOURCE;
     657        pline->Target.dwType   = MIXERLINE_TARGETTYPE_UNDEFINED;
     658        nrLineOutInputs++;
     659        break;
     660
     661    case MIXER_SRC_VIDEO:
     662        pline->dwSource        = nrSources;
     663        pline->cChannels       = 2;
     664        pline->cConnections    = 0;
     665        pline->cControls       = 0;
     666        pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED;
     667        pline->dwDestination   = 0;
     668        pline->dwLineID        = (DWORD)-1;
     669        pline->fdwLine         = MIXERLINE_LINEF_SOURCE;
     670        pline->Target.dwType   = MIXERLINE_TARGETTYPE_UNDEFINED;
     671        nrLineOutInputs++;
     672        break;
     673
     674    case MIXER_SRC_AUX:
     675        pline->dwSource        = nrSources;
     676        pline->cChannels       = 2;
     677        pline->cConnections    = 0;
     678        pline->cControls       = 0;
     679        pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY;
     680        pline->dwDestination   = 0;
     681        pline->dwLineID        = (DWORD)-1;
     682        pline->fdwLine         = MIXERLINE_LINEF_SOURCE;
     683        pline->Target.dwType   = MIXERLINE_TARGETTYPE_AUX;
     684        nrLineOutInputs++;
     685        break;
     686
     687    case MIXER_SRC_PCM:
     688        pline->dwSource        = nrSources;
     689        pline->cChannels       = 2;
     690        pline->cConnections    = 0;
     691        pline->cControls       = 0;
     692        pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
     693        pline->dwDestination   = 0;
     694        pline->dwLineID        = (DWORD)-1;
     695        pline->fdwLine         = MIXERLINE_LINEF_SOURCE;
     696        pline->Target.dwType   = MIXERLINE_TARGETTYPE_WAVEOUT;
     697        nrLineOutInputs++;
     698        break;
     699
     700    case MIXER_SRC_WAVETABLE:
     701    case MIXER_SRC_MIDI:
     702        pline->dwSource        = nrSources;
     703        pline->cChannels       = 2;
     704        pline->cConnections    = 0;
     705        pline->cControls       = 0;
     706        pline->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER;
     707        pline->dwDestination   = 0;
     708        pline->dwLineID        = (DWORD)-1;
     709        pline->fdwLine         = MIXERLINE_LINEF_SOURCE;
     710        pline->Target.dwType   = MIXERLINE_TARGETTYPE_MIDIOUT;
     711        nrLineOutInputs++;
     712        break;
     713
     714    default:
     715        DebugInt3();
     716        return FALSE;
     717    }
     718    strncpy(pline->szShortName, szSourceName[dwSource][0], sizeof(pline->szShortName));
     719    strncpy(pline->szName,      szSourceName[dwSource][1], sizeof(pline->szName));
     720
     721    dprintf(("Adding Source %s (%s)", pline->szName, pline->szShortName));
     722
     723    nrSources++;
    328724    return TRUE;
    329725}
    330726/******************************************************************************/
    331727/******************************************************************************/
    332 void mixerExit()
    333 {
    334     OSLibMixerClose();
    335 }
    336 /******************************************************************************/
    337 /******************************************************************************/
    338 
     728static BOOL mixerAddDestination(DWORD dwDest)
     729{
     730    MIXERLINEA *pline  = &mixerDest[nrDestinations];
     731
     732    if(nrDestinations >= MAX_MIXER_DESTINATIONS) {
     733        dprintf(("ERROR: mixerAddDestination: out of room!!!"));
     734        DebugInt3();
     735        return FALSE;
     736    }
     737    pline->cbStruct = sizeof(MIXERLINEA);
     738    memset(pline, 0, sizeof(MIXERLINEA));
     739
     740    switch(dwDest) {
     741    case MIXER_DEST_LINEOUT:
     742        pline->dwDestination   = nrDestinations;
     743        pline->cChannels       = 2;
     744        pline->cConnections    = nrLineOutInputs;
     745        pline->cControls       = nrLineOutControls;
     746        pline->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
     747        pline->dwSource        = 0;
     748        pline->dwLineID        = (DWORD)-1;
     749        pline->fdwLine         = MIXERLINE_LINEF_ACTIVE;
     750        pline->Target.dwType   = MIXERLINE_TARGETTYPE_UNDEFINED;
     751        break;
     752
     753    case MIXER_DEST_SPDIFOUT:
     754        pline->dwDestination   = nrDestinations;
     755        pline->cChannels       = 2;
     756        pline->cConnections    = nrSPDIFInputs;
     757        pline->cControls       = nrSPDIFControls;
     758        pline->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_DIGITAL;
     759        pline->dwSource        = 0;
     760        pline->dwLineID        = (DWORD)-1;
     761        pline->fdwLine         = 0;
     762        pline->Target.dwType   = MIXERLINE_TARGETTYPE_UNDEFINED;
     763        break;
     764
     765    case MIXER_DEST_WAVEIN:
     766        pline->dwSource        = nrSources;
     767        pline->cChannels       = 2;
     768        pline->cConnections    = nrWaveInInputs;
     769        pline->cControls       = nrWaveInControls;
     770        pline->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
     771        pline->dwDestination   = 0;
     772        pline->dwLineID        = (DWORD)-1;
     773        pline->fdwLine         = MIXERLINE_LINEF_SOURCE;
     774        pline->Target.dwType   = MIXERLINE_TARGETTYPE_UNDEFINED;
     775        break;
     776       
     777    default:
     778        DebugInt3();
     779        return FALSE;
     780    }
     781    strncpy(pline->szShortName, szDestName[dwDest][0], sizeof(pline->szShortName));
     782    strncpy(pline->szName,      szDestName[dwDest][1], sizeof(pline->szName));
     783    dprintf(("Adding destination %s (%s)", pline->szName, pline->szShortName));
     784    nrDestinations++;
     785    return TRUE;
     786}
     787/******************************************************************************/
     788/******************************************************************************/
     789static BOOL mixerAddControl(DWORD dwControl)
     790{
     791    MIXERCONTROLA *pctrl  = &mixerControls[nrControls];
     792
     793    if(nrControls >= MAX_MIXER_CONTROLS) {
     794        dprintf(("ERROR: mixerAddControl: out of room!!!"));
     795        DebugInt3();
     796        return FALSE;
     797    }
     798
     799    pctrl->cbStruct = sizeof(MIXERCONTROLA);
     800    memset(pctrl, 0, sizeof(MIXERCONTROLA));
     801
     802    switch(dwControl) {
     803    case MIX_CTRL_VOL_OUT_LINE:
     804    case MIX_CTRL_VOL_IN_L_MONO:
     805    case MIX_CTRL_VOL_IN_L_PHONE:
     806    case MIX_CTRL_VOL_IN_L_MIC:
     807    case MIX_CTRL_VOL_IN_L_LINE:
     808    case MIX_CTRL_VOL_IN_L_CD:
     809    case MIX_CTRL_VOL_IN_L_SPDIF:
     810    case MIX_CTRL_VOL_IN_L_VIDEO:
     811    case MIX_CTRL_VOL_IN_L_AUX:
     812    case MIX_CTRL_VOL_IN_L_PCM:
     813    case MIX_CTRL_VOL_IN_L_WAVETABLE:
     814    case MIX_CTRL_VOL_IN_L_MIDI:
     815        pctrl->cMultipleItems   = 0;
     816        pctrl->fdwControl       = 0;
     817        pctrl->dwControlID      = nrControls;
     818        pctrl->dwControlType    = MIXERCONTROL_CONTROLTYPE_VOLUME;
     819        strncpy(pctrl->szShortName, szCtrlName[dwControl][0], sizeof(pctrl->szShortName));
     820        strncpy(pctrl->szName,      szCtrlName[dwControl][1], sizeof(pctrl->szName));
     821        pctrl->Bounds.s.lMinimum = 0;
     822        pctrl->Bounds.s.lMaximum = 100;
     823        pctrl->Metrics.cSteps    = 1;
     824        nrControls++;
     825        nrLineOutControls++;
     826        break;
     827
     828    case MIX_CTRL_VOL_IN_W_MONO:
     829    case MIX_CTRL_VOL_IN_W_PHONE:
     830    case MIX_CTRL_VOL_IN_W_MIC:
     831    case MIX_CTRL_VOL_IN_W_LINE:
     832    case MIX_CTRL_VOL_IN_W_CD:
     833    case MIX_CTRL_VOL_IN_W_SPDIF:
     834    case MIX_CTRL_VOL_IN_W_VIDEO:
     835    case MIX_CTRL_VOL_IN_W_AUX:
     836    case MIX_CTRL_VOL_IN_W_PCM:
     837    case MIX_CTRL_VOL_IN_W_WAVETABLE:
     838    case MIX_CTRL_VOL_IN_W_MIDI:
     839        pctrl->cMultipleItems   = 0;
     840        pctrl->fdwControl       = 0;
     841        pctrl->dwControlID      = nrControls;
     842        pctrl->dwControlType    = MIXERCONTROL_CONTROLTYPE_VOLUME;
     843        strncpy(pctrl->szShortName, szCtrlName[dwControl][0], sizeof(pctrl->szShortName));
     844        strncpy(pctrl->szName,      szCtrlName[dwControl][1], sizeof(pctrl->szName));
     845        pctrl->Bounds.s.lMinimum = 0;
     846        pctrl->Bounds.s.lMaximum = 100;
     847        pctrl->Metrics.cSteps    = 1;
     848        nrControls++;
     849        nrWaveInControls++;
     850        nrWaveInInputs++;
     851        break;
     852
     853    case MIX_CTRL_MUTE_OUT_LINE:
     854    case MIX_CTRL_MUTE_IN_L_MONO:
     855    case MIX_CTRL_MUTE_IN_L_PHONE:
     856    case MIX_CTRL_MUTE_IN_L_MIC:
     857    case MIX_CTRL_MUTE_IN_L_LINE:
     858    case MIX_CTRL_MUTE_IN_L_CD:
     859    case MIX_CTRL_MUTE_IN_L_SPDIF:
     860    case MIX_CTRL_MUTE_IN_L_VIDEO:
     861    case MIX_CTRL_MUTE_IN_L_AUX:
     862    case MIX_CTRL_MUTE_IN_L_PCM:
     863        pctrl->cMultipleItems   = 0;
     864        pctrl->fdwControl       = MIXERCONTROL_CONTROLF_UNIFORM;
     865        pctrl->dwControlID      = nrControls;
     866        pctrl->dwControlType    = MIXERCONTROL_CONTROLTYPE_MUTE;
     867        strncpy(pctrl->szShortName, szCtrlName[dwControl][0], sizeof(pctrl->szShortName));
     868        strncpy(pctrl->szName,      szCtrlName[dwControl][1], sizeof(pctrl->szName));
     869        pctrl->Bounds.s.lMinimum = 0;
     870        pctrl->Bounds.s.lMaximum = 1;
     871        pctrl->Metrics.cSteps    = 0;
     872        nrControls++;
     873        nrLineOutControls++;
     874        break;
     875
     876    case MIX_CTRL_VOL_OUT_SPDIF:
     877        pctrl->cMultipleItems   = 0;
     878        pctrl->fdwControl       = 0;
     879        pctrl->dwControlID      = nrControls;
     880        pctrl->dwControlType    = MIXERCONTROL_CONTROLTYPE_VOLUME;
     881        strncpy(pctrl->szShortName, szCtrlName[MIX_CTRL_VOL_OUT_SPDIF][0], sizeof(pctrl->szShortName));
     882        strncpy(pctrl->szName,      szCtrlName[MIX_CTRL_VOL_OUT_SPDIF][1], sizeof(pctrl->szName));
     883        pctrl->Bounds.s.lMinimum = 0;
     884        pctrl->Bounds.s.lMaximum = 100;
     885        pctrl->Metrics.cSteps    = 1;
     886        nrControls++;
     887        nrSPDIFControls++;
     888        break;
     889
     890    case MIX_CTRL_MUTE_OUT_SPDIF:
     891        pctrl->cMultipleItems   = 0;
     892        pctrl->fdwControl       = MIXERCONTROL_CONTROLF_UNIFORM;
     893        pctrl->dwControlID      = nrControls;
     894        pctrl->dwControlType    = MIXERCONTROL_CONTROLTYPE_MUTE;
     895        strncpy(pctrl->szShortName, szCtrlName[MIX_CTRL_MUTE_OUT_SPDIF][0], sizeof(pctrl->szShortName));
     896        strncpy(pctrl->szName,      szCtrlName[MIX_CTRL_MUTE_OUT_SPDIF][1], sizeof(pctrl->szName));
     897        pctrl->Bounds.s.lMinimum = 0;
     898        pctrl->Bounds.s.lMaximum = 1;
     899        pctrl->Metrics.cSteps    = 0;
     900        nrControls++;
     901        nrSPDIFControls++;
     902        break;
     903
     904    case MIX_CTRL_BOOST_IN_L_MIC:
     905        pctrl->cMultipleItems   = 0;
     906        pctrl->fdwControl       = MIXERCONTROL_CONTROLF_UNIFORM;
     907        pctrl->dwControlID      = nrControls;
     908        pctrl->dwControlType    = MIXERCONTROL_CONTROLTYPE_ONOFF;
     909        strncpy(pctrl->szShortName, szCtrlName[MIX_CTRL_BOOST_IN_L_MIC][0], sizeof(pctrl->szShortName));
     910        strncpy(pctrl->szName,      szCtrlName[MIX_CTRL_BOOST_IN_L_MIC][1], sizeof(pctrl->szName));
     911        pctrl->Bounds.s.lMinimum = 0;
     912        pctrl->Bounds.s.lMaximum = 1;
     913        pctrl->Metrics.cSteps    = 0;
     914        nrControls++;
     915        nrLineOutControls++;
     916        break;
     917
     918    case MIX_CTRL_OUT_L_3DDEPTH:
     919        pctrl->cMultipleItems   = 0;
     920        pctrl->fdwControl       = MIXERCONTROL_CONTROLF_UNIFORM;
     921        pctrl->dwControlID      = nrControls;
     922        pctrl->dwControlType    = MIXERCONTROL_CONTROLTYPE_FADER;
     923        strncpy(pctrl->szShortName, szCtrlName[MIX_CTRL_OUT_L_3DDEPTH][0], sizeof(pctrl->szShortName));
     924        strncpy(pctrl->szName,      szCtrlName[MIX_CTRL_OUT_L_3DDEPTH][1], sizeof(pctrl->szName));
     925        pctrl->Bounds.s.lMinimum = 0;
     926        pctrl->Bounds.s.lMaximum = 100;
     927        pctrl->Metrics.cSteps    = 1;
     928        nrControls++;
     929        nrLineOutControls++;
     930        break;
     931
     932    case MIX_CTRL_OUT_L_3DCENTER:
     933        pctrl->cMultipleItems   = 0;
     934        pctrl->fdwControl       = MIXERCONTROL_CONTROLF_UNIFORM;
     935        pctrl->dwControlID      = nrControls;
     936        pctrl->dwControlType    = MIXERCONTROL_CONTROLTYPE_FADER;
     937        strncpy(pctrl->szShortName, szCtrlName[MIX_CTRL_OUT_L_3DCENTER][0], sizeof(pctrl->szShortName));
     938        strncpy(pctrl->szName,      szCtrlName[MIX_CTRL_OUT_L_3DCENTER][1], sizeof(pctrl->szName));
     939        pctrl->Bounds.s.lMinimum = 0;
     940        pctrl->Bounds.s.lMaximum = 100;
     941        pctrl->Metrics.cSteps    = 1;
     942        nrControls++;
     943        nrLineOutControls++;
     944        break;
     945
     946    case MIX_CTRL_MUX_IN_W_SRC:
     947        pctrl->cMultipleItems   = nrWaveInControls;
     948        pctrl->fdwControl       = MIXERCONTROL_CONTROLF_MULTIPLE | MIXERCONTROL_CONTROLF_UNIFORM;
     949        pctrl->dwControlID      = nrControls;
     950        pctrl->dwControlType    = MIXERCONTROL_CONTROLTYPE_MUX;
     951        strncpy(pctrl->szShortName, szCtrlName[MIX_CTRL_MUX_IN_W_SRC][0], sizeof(pctrl->szShortName));
     952        strncpy(pctrl->szName,      szCtrlName[MIX_CTRL_MUX_IN_W_SRC][1], sizeof(pctrl->szName));
     953        pctrl->Bounds.s.lMinimum = 0;
     954        pctrl->Bounds.s.lMaximum = 1;
     955        pctrl->Metrics.cSteps    = 1;
     956        nrControls++;
     957        nrWaveInControls++;
     958        break;
     959
     960    case MIX_CTRL_OUT_L_TREBLE:
     961        pctrl->cMultipleItems   = 0;
     962        pctrl->fdwControl       = 0;
     963        pctrl->dwControlID      = nrControls;
     964        pctrl->dwControlType    = MIXERCONTROL_CONTROLTYPE_TREBLE;
     965        strncpy(pctrl->szShortName, szCtrlName[MIX_CTRL_OUT_L_TREBLE][0], sizeof(pctrl->szShortName));
     966        strncpy(pctrl->szName,      szCtrlName[MIX_CTRL_OUT_L_TREBLE][1], sizeof(pctrl->szName));
     967        pctrl->Bounds.s.lMinimum = 0;
     968        pctrl->Bounds.s.lMaximum = 100;
     969        pctrl->Metrics.cSteps    = 1;
     970        nrControls++;
     971        nrLineOutControls++;
     972        break;
     973
     974    case MIX_CTRL_OUT_L_BASS:
     975        pctrl->cMultipleItems   = 0;
     976        pctrl->fdwControl       = 0;
     977        pctrl->dwControlID      = nrControls;
     978        pctrl->dwControlType    = MIXERCONTROL_CONTROLTYPE_BASS;
     979        strncpy(pctrl->szShortName, szCtrlName[MIX_CTRL_OUT_L_BASS][0], sizeof(pctrl->szShortName));
     980        strncpy(pctrl->szName,      szCtrlName[MIX_CTRL_OUT_L_BASS][1], sizeof(pctrl->szName));
     981        pctrl->Bounds.s.lMinimum = 0;
     982        pctrl->Bounds.s.lMaximum = 100;
     983        pctrl->Metrics.cSteps    = 1;
     984        nrControls++;
     985        nrLineOutControls++;
     986        break;
     987
     988    default:
     989        DebugInt3();
     990        return FALSE;
     991    }
     992    dprintf(("Adding control %s (%s)", pctrl->szName, pctrl->szShortName));
     993    return TRUE;
     994}
     995/******************************************************************************/
     996/******************************************************************************/
     997

  • trunk/src/winmm/mixer.h

    r8472 r8477  
    1 /* $Id: mixer.h,v 1.1 2002-05-22 20:19:19 sandervl Exp $ */
     1/* $Id: mixer.h,v 1.2 2002-05-23 13:50:15 sandervl Exp $ */
    22
    33/*
    … …  
    1313#ifndef __WINMM_MIXER_H__
    1414#define __WINMM_MIXER_H__
     15
     16#include "mixeros2.h"
    1517
    1618#define WINMM_MIXERSTRING_A             "OS/2 WINMM Mixer"
    … …  
    3436void mixerExit();
    3537
     38extern char *szCtrlName[MIX_CTRL_MAX][2];
     39extern char *szSourceName[MIXER_SRC_MAX][2];
     40extern char *szDestName[MIXER_DEST_MAX][2];
     41
    3642#ifdef __cplusplus
    3743}

  • trunk/src/winmm/mixeros2.cpp

    r8472 r8477  
    1 /* $Id: mixeros2.cpp,v 1.1 2002-05-22 20:19:11 sandervl Exp $ */
     1/* $Id: mixeros2.cpp,v 1.2 2002-05-23 13:50:15 sandervl Exp $ */
    22
    33/*
    … …  
    7373
    7474    switch(dwControl) {
    75     case MIXER_CTRL_MONOIN:
     75    case MIX_CTRL_VOL_IN_L_MONO:
     76    case MIX_CTRL_MUTE_IN_L_MONO:
    7677        idx = MONOINSET;
    7778        break;
    78     case MIXER_CTRL_PHONE:
     79    case MIX_CTRL_VOL_IN_L_PHONE:
     80    case MIX_CTRL_MUTE_IN_L_PHONE:
    7981        idx = PHONESET;
    8082        break;
    81     case MIXER_CTRL_MIC:
     83    case MIX_CTRL_VOL_IN_L_MIC:
     84    case MIX_CTRL_MUTE_IN_L_MIC:
    8285        idx = MICSET;
    8386        break;
    84     case MIXER_CTRL_LINE:
     87    case MIX_CTRL_VOL_IN_L_LINE:
     88    case MIX_CTRL_MUTE_IN_L_LINE:
    8589        idx = LINESET;
    8690        break;
    87     case MIXER_CTRL_CD:
     91    case MIX_CTRL_VOL_IN_L_CD:
     92    case MIX_CTRL_MUTE_IN_L_CD:
    8893        idx = CDSET;
    8994        break;
    90     case MIXER_CTRL_VIDEO:
     95    case MIX_CTRL_VOL_IN_L_VIDEO:
     96    case MIX_CTRL_MUTE_IN_L_VIDEO:
    9197        idx = VIDEOSET;
    9298        break;
    93     case MIXER_CTRL_AUX:
     99    case MIX_CTRL_VOL_IN_L_AUX:
     100    case MIX_CTRL_MUTE_IN_L_AUX:
    94101        idx = AUXSET;
    95102        break;
    96     case MIXER_CTRL_BASS:
     103    case MIX_CTRL_OUT_L_BASS:
     104    case MIX_CTRL_OUT_L_TREBLE:
    97105        idx = BASSTREBLESET;
    98106        break;
    99     case MIXER_CTRL_TREBLE:
    100         idx = BASSTREBLESET;
    101         break;
    102     case MIXER_CTRL_3D:
     107    case MIX_CTRL_OUT_L_3DCENTER:
     108    case MIX_CTRL_OUT_L_3DDEPTH:
    103109        idx = THREEDSET;
    104110        break;
    105     case MIXER_CTRL_STREAMVOL:
     111    case MIX_CTRL_VOL_IN_L_PCM:
     112    case MIX_CTRL_MUTE_IN_L_PCM:
    106113        idx = STREAMVOLSET;
    107114        break;
    108     case MIXER_CTRL_RECORDSRC:
     115    case MIX_CTRL_MUX_IN_W_SRC:
    109116        idx = RECORDSRCSET;
    110117        break;
    111     case MIXER_CTRL_RECORDGAIN:
    112         idx = RECORDGAINSET;
    113         break;
    114118    default:
    115         DebugInt3();
    116119        return -1;
    117120    }
    … …  
    188191/******************************************************************************/
    189192/******************************************************************************/
    190 BOOL OSLibMixSetRecSource(DWORD dwRecSrc)
     193BOOL OSLibMixIsRecSourcePresent(DWORD dwRecSrc)
     194{
     195    DWORD dwOldRecSrc, dwVolL, dwVolR;
     196
     197    if(OSLibMixGetRecSource(&dwOldRecSrc, &dwVolL, &dwVolR) == FALSE) {
     198        return FALSE;
     199    }
     200    if(OSLibMixSetRecSource(dwRecSrc, dwVolL, dwVolR) == FALSE) {
     201        return FALSE;
     202    }
     203    OSLibMixSetRecSource(dwOldRecSrc, dwVolL, dwVolR);
     204    return TRUE;
     205}
     206/******************************************************************************/
     207/******************************************************************************/
     208BOOL OSLibMixSetRecSource(DWORD dwRecSrc, DWORD dwVolL, DWORD dwVolR)
    191209{
    192210    DWORD idx;
    … …  
    194212
    195213    switch(dwRecSrc) {
    196     case MIXER_RECSRC_MIC:
     214    case MIX_CTRL_VOL_IN_W_MIC:
    197215        idx = I90SRC_MIC;
    198216        break;
    199     case MIXER_RECSRC_CD:
     217    case MIX_CTRL_VOL_IN_W_CD:
    200218        idx = I90SRC_CD;
    201219        break;
    202     case MIXER_RECSRC_VIDEO:
     220    case MIX_CTRL_VOL_IN_W_VIDEO:
    203221        idx = I90SRC_VIDEO;
    204222        break;
    205     case MIXER_RECSRC_AUX:
     223    case MIX_CTRL_VOL_IN_W_AUX:
    206224        idx = I90SRC_AUX;
    207225        break;
    208     case MIXER_RECSRC_LINE:
     226    case MIX_CTRL_VOL_IN_W_LINE:
    209227        idx = I90SRC_LINE;
    210228        break;
    211     case MIXER_RECSRC_RES5:
    212         idx = I90SRC_RES5;
    213         break;
    214     case MIXER_RECSRC_RES6:
    215         idx = I90SRC_RES6;
    216         break;
    217     case MIXER_RECSRC_PHONE:
     229    case MIX_CTRL_VOL_IN_W_PHONE:
    218230        idx = I90SRC_PHONE;
     231        break;
     232    default:
     233        return FALSE;
     234    }
     235    mixstruct.Mute    = 0;
     236    mixstruct.VolumeL = idx;
     237
     238    if(mixerapiIOCTL90(hPDDMix, RECORDSRCSET, &mixstruct, sizeof(mixstruct)) == FALSE) {
     239        dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDSRCSET failed!!"));
     240        return FALSE;
     241    }
     242
     243    mixstruct.Mute    = 0;
     244    mixstruct.VolumeL = dwVolL;
     245    mixstruct.VolumeR = dwVolR;
     246    if(mixerapiIOCTL90(hPDDMix, RECORDGAINSET, &mixstruct, sizeof(mixstruct)) == FALSE) {
     247        dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDGAINSET failed!!"));
     248        return FALSE;
     249    }
     250    return TRUE;
     251}
     252/******************************************************************************/
     253/******************************************************************************/
     254BOOL OSLibMixGetRecSource(DWORD *pdwRecSrc, DWORD *pdwVolL, DWORD *pdwVolR)
     255{
     256    DWORD idx;
     257    MIXSTRUCT mixstruct;
     258
     259    if(mixerapiIOCTL90(hPDDMix, RECORDSRCQUERY, &mixstruct, sizeof(mixstruct)) == FALSE) {
     260        dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDSRCGET failed!!"));
     261        return FALSE;
     262    }
     263    switch(mixstruct.VolumeL) {
     264    case I90SRC_MIC:
     265        idx = MIX_CTRL_VOL_IN_W_MIC;
     266        break;
     267    case I90SRC_CD:
     268        idx = MIX_CTRL_VOL_IN_W_CD;
     269        break;
     270    case I90SRC_VIDEO:
     271        idx = MIX_CTRL_VOL_IN_W_VIDEO;
     272        break;
     273    case I90SRC_AUX:
     274        idx = MIX_CTRL_VOL_IN_W_AUX;
     275        break;
     276    case I90SRC_LINE:
     277        idx = MIX_CTRL_VOL_IN_W_LINE;
     278        break;
     279    case I90SRC_PHONE:
     280        idx = MIX_CTRL_VOL_IN_W_PHONE;
    219281        break;
    220282    default:
    … …  
    222284        return FALSE;
    223285    }
    224     mixstruct.Mute    = 0;
    225     mixstruct.VolumeL = idx;
    226 
    227     if(mixerapiIOCTL90(hPDDMix, RECORDSRCSET, &mixstruct, sizeof(mixstruct)) == TRUE) {
    228         return TRUE;
    229     }
    230     dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDSRCSET failed!!"));
    231     return FALSE;
    232 }
    233 /******************************************************************************/
    234 /******************************************************************************/
    235 BOOL OSLibMixGetRecSource(DWORD *pdwRecSrc)
    236 {
    237     DWORD idx;
    238     MIXSTRUCT mixstruct;
    239 
    240     if(mixerapiIOCTL90(hPDDMix, RECORDSRCQUERY, &mixstruct, sizeof(mixstruct)) == FALSE) {
    241         dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDSRCGET failed!!"));
    242         return FALSE;
    243     }
    244     switch(mixstruct.VolumeL) {
    245     case I90SRC_MIC:
    246         idx = MIXER_RECSRC_MIC;
    247         break;
    248     case I90SRC_CD:
    249         idx = MIXER_RECSRC_CD;
    250         break;
    251     case I90SRC_VIDEO:
    252         idx = MIXER_RECSRC_VIDEO;
    253         break;
    254     case I90SRC_AUX:
    255         idx = MIXER_RECSRC_AUX;
    256         break;
    257     case I90SRC_LINE:
    258         idx = MIXER_RECSRC_LINE;
    259         break;
    260     case I90SRC_RES5:
    261         idx = MIXER_RECSRC_RES5;
    262         break;
    263     case I90SRC_RES6:
    264         idx = MIXER_RECSRC_RES6;
    265         break;
    266     case I90SRC_PHONE:
    267         idx = MIXER_RECSRC_PHONE;
    268         break;
    269     default:
    270         DebugInt3();
    271         return FALSE;
    272     }
    273286    if(pdwRecSrc) {
    274287        *pdwRecSrc = idx;
     288    }
     289    if(mixerapiIOCTL90(hPDDMix, RECORDGAINQUERY, &mixstruct, sizeof(mixstruct)) == FALSE) {
     290        dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDGAINQUERY failed!!"));
     291        return FALSE;
     292    }
     293    if(pdwVolL) {
     294        *pdwVolL = mixstruct.VolumeL;
     295    }
     296    if(pdwVolR) {
     297        *pdwVolR = mixstruct.VolumeR;
    275298    }
    276299    return TRUE;

  • trunk/src/winmm/mixeros2.h

    r8472 r8477  
    1 /* $Id: mixeros2.h,v 1.1 2002-05-22 20:19:11 sandervl Exp $ */
     1/* $Id: mixeros2.h,v 1.2 2002-05-23 13:50:16 sandervl Exp $ */
    22
    33/*
    … …  
    1414#define __WINMM_OS2MIXER_H__
    1515
    16 #define MIXER_MAX_VOLUME        100
     16#define MIXER_MAX_VOLUME                100
    1717
    18 #define MIXER_CTRL_MONOIN       0
    19 #define MIXER_CTRL_PHONE        1
    20 #define MIXER_CTRL_MIC          2
    21 #define MIXER_CTRL_LINE         3
    22 #define MIXER_CTRL_CD           4
    23 #define MIXER_CTRL_VIDEO        5
    24 #define MIXER_CTRL_AUX          6
    25 #define MIXER_CTRL_3D           7
    26 #define MIXER_CTRL_STREAMVOL    8
    27 #define MIXER_CTRL_RECORDSRC    9
    28 #define MIXER_CTRL_RECORDGAIN   10
    29 #define MIXER_CTRL_TREBLE       11
    30 #define MIXER_CTRL_BASS         12
     18#define MIX_CTRL_VOL_OUT_LINE           0
     19#define MIX_CTRL_MUTE_OUT_LINE          1
     20#define MIX_CTRL_VOL_IN_L_MONO          2
     21#define MIX_CTRL_MUTE_IN_L_MONO         3
     22#define MIX_CTRL_VOL_IN_L_PHONE         4
     23#define MIX_CTRL_MUTE_IN_L_PHONE        5
     24#define MIX_CTRL_VOL_IN_L_MIC           6
     25#define MIX_CTRL_MUTE_IN_L_MIC          7
     26#define MIX_CTRL_BOOST_IN_L_MIC         8
     27#define MIX_CTRL_VOL_IN_L_LINE          9
     28#define MIX_CTRL_MUTE_IN_L_LINE         10
     29#define MIX_CTRL_VOL_IN_L_CD            11
     30#define MIX_CTRL_MUTE_IN_L_CD           12
     31#define MIX_CTRL_VOL_IN_L_SPDIF         13
     32#define MIX_CTRL_MUTE_IN_L_SPDIF        14
     33#define MIX_CTRL_VOL_OUT_SPDIF          15
     34#define MIX_CTRL_MUTE_OUT_SPDIF         16
     35#define MIX_CTRL_VOL_IN_L_VIDEO         17
     36#define MIX_CTRL_MUTE_IN_L_VIDEO        18
     37#define MIX_CTRL_VOL_IN_L_AUX           19
     38#define MIX_CTRL_MUTE_IN_L_AUX          20
     39#define MIX_CTRL_VOL_IN_L_PCM           21
     40#define MIX_CTRL_MUTE_IN_L_PCM          22
     41#define MIX_CTRL_VOL_IN_L_WAVETABLE     23
     42#define MIX_CTRL_MUTE_IN_L_WAVETABLE    24
     43#define MIX_CTRL_VOL_IN_L_MIDI          25
     44#define MIX_CTRL_MUTE_IN_L_MIDI         26
     45#define MIX_CTRL_OUT_L_3DCENTER         27
     46#define MIX_CTRL_OUT_L_3DDEPTH          28
     47#define MIX_CTRL_OUT_L_TREBLE           29
     48#define MIX_CTRL_OUT_L_BASS             30
     49#define MIX_CTRL_MUX_IN_W_SRC           31
     50#define MIX_CTRL_VOL_IN_W_MONO          32
     51#define MIX_CTRL_VOL_IN_W_PHONE         33
     52#define MIX_CTRL_VOL_IN_W_MIC           34
     53#define MIX_CTRL_VOL_IN_W_LINE          35
     54#define MIX_CTRL_VOL_IN_W_CD            36
     55#define MIX_CTRL_VOL_IN_W_SPDIF         37
     56#define MIX_CTRL_VOL_IN_W_VIDEO         38
     57#define MIX_CTRL_VOL_IN_W_AUX           39
     58#define MIX_CTRL_VOL_IN_W_PCM           40
     59#define MIX_CTRL_VOL_IN_W_WAVETABLE     41
     60#define MIX_CTRL_VOL_IN_W_MIDI          42
     61#define MIX_CTRL_MAX                    43
    3162
    32 #define MIXER_RECSRC_MIC        0
    33 #define MIXER_RECSRC_CD         1
    34 #define MIXER_RECSRC_VIDEO      2
    35 #define MIXER_RECSRC_AUX        3
    36 #define MIXER_RECSRC_LINE       4
    37 #define MIXER_RECSRC_RES5       5
    38 #define MIXER_RECSRC_RES6       6
    39 #define MIXER_RECSRC_PHONE      7
     63#define MIXER_SRC_MONOIN        0
     64#define MIXER_SRC_PHONE         1
     65#define MIXER_SRC_MIC           2
     66#define MIXER_SRC_LINE          3
     67#define MIXER_SRC_CD            4
     68#define MIXER_SRC_SPDIF         5
     69#define MIXER_SRC_VIDEO         6
     70#define MIXER_SRC_AUX           7
     71#define MIXER_SRC_PCM           8
     72#define MIXER_SRC_WAVETABLE     9
     73#define MIXER_SRC_MIDI          10
     74#define MIXER_SRC_MAX           11
     75
     76#define MIXER_DEST_LINEOUT      0
     77#define MIXER_DEST_WAVEIN       1
     78#define MIXER_DEST_SPDIFOUT     2
     79#define MIXER_DEST_MAX          3
    4080
    4181#ifdef __cplusplus
    … …  
    4989BOOL OSLibMixSetVolume(DWORD dwControl, BOOL fMute, DWORD dwVolLeft, DWORD dwVolRight);
    5090BOOL OSLibMixGetVolume(DWORD dwControl, BOOL *pfMute, DWORD *pdwVolLeft, DWORD *pdwVolRight);
    51 BOOL OSLibMixSetRecSource(DWORD dwRecSrc);
    52 BOOL OSLibMixGetRecSource(DWORD *pdwRecSrc);
     91BOOL OSLibMixSetRecSource(DWORD dwRecSrc, DWORD dwVolL, DWORD dwVolR);
     92BOOL OSLibMixGetRecSource(DWORD *pdwRecSrc, DWORD *pdwVolL, DWORD *pdwVolR);
     93BOOL OSLibMixIsRecSourcePresent(DWORD dwRecSrc);
    5394
    5495#ifdef __cplusplus

  • trunk/src/winmm/winmm.mak

    r8472 r8477  
    1 # $Id: winmm.mak,v 1.10 2002-05-22 20:19:11 sandervl Exp $
     1# $Id: winmm.mak,v 1.11 2002-05-23 13:50:16 sandervl Exp $
    22
    33#
    … …  
    4343$(OBJDIR)\mixer.obj \
    4444$(OBJDIR)\mixeros2.obj \
     45$(OBJDIR)\mixerdata.obj \
    4546$(OBJDIR)\midi.obj \
    4647$(OBJDIR)\irtmidi.obj \
Note: See TracChangeset for help on using the changeset viewer.