px_win_wmme.c

IAX协议客户端源码

   PxInfo *info = (PxInfo *)mixer;

   VolumeFunction(info->hOutputMixer, info->speakerID, &volume);
}

/*
 PCM output volume
*/

int Px_SupportsPCMOutputVolume( PxMixer* mixer )
{
   PxInfo* info = ( PxInfo* )( mixer ) ;
   return ( info->waveID == -1 ) ? 0 : 1 ;
}

PxVolume Px_GetPCMOutputVolume( PxMixer *mixer )
{
   PxInfo *info = (PxInfo *)mixer;
   PxVolume vol;

   vol = -1.0;
   VolumeFunction(info->hOutputMixer, info->waveID, &vol);
   return vol;
}

void Px_SetPCMOutputVolume( PxMixer *mixer, PxVolume volume )
{
   PxInfo *info = (PxInfo *)mixer;

   VolumeFunction(info->hOutputMixer, info->waveID, &volume);
}


/*
 All output volumes
*/

int Px_GetNumOutputVolumes( PxMixer *mixer )
{
   PxInfo *info = (PxInfo *)mixer;

   return 2;
}

const char *Px_GetOutputVolumeName( PxMixer *mixer, int i )
{
   PxInfo *info = (PxInfo *)mixer;

   if (i==1)
      return "Wave Out";
   else
      return "Master Volume";
}

PxVolume Px_GetOutputVolume( PxMixer *mixer, int i )
{
   PxInfo *info = (PxInfo *)mixer;

   if (i==1)
      return Px_GetPCMOutputVolume(mixer);
   else
      return Px_GetMasterVolume(mixer);
}

void Px_SetOutputVolume( PxMixer *mixer, int i, PxVolume volume )
{
   PxInfo *info = (PxInfo *)mixer;

   if (i==1)
      Px_SetPCMOutputVolume(mixer, volume);
   else
      Px_SetMasterVolume(mixer, volume);
}

/*
 Input sources
*/

int Px_GetNumInputSources( PxMixer *mixer )
{
   PxInfo *info = (PxInfo *)mixer;

   return info->numInputs;
}

const char *Px_GetInputSourceName( PxMixer *mixer, int i)
{
   PxInfo *info = (PxInfo *)mixer;

   return info->src[i].name;
}

int Px_GetCurrentInputSource( PxMixer *mixer )
{
   PxInfo *info = (PxInfo *)mixer;
   MIXERCONTROLDETAILS details;
   MIXERCONTROLDETAILS_BOOLEAN flags[32];
   MMRESULT result;
   int i;

   details.cbStruct = sizeof(MIXERCONTROLDETAILS);
   details.dwControlID = info->muxID;
   details.cMultipleItems = info->numInputs;
   details.cChannels = 1;
   details.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
   details.paDetails = (LPMIXERCONTROLDETAILS_BOOLEAN)&flags[0];

   result = mixerGetControlDetails(info->hInputMixer,
                                   (LPMIXERCONTROLDETAILS)&details,
                                   MIXER_GETCONTROLDETAILSF_VALUE);

   if (result == MMSYSERR_NOERROR) {
      for(i=0; i<info->numInputs; i++)
         if (flags[i].fValue)
            return i;
   }

   return 0;
}

void Px_SetCurrentInputSource( PxMixer *mixer, int i )
{
   PxInfo *info = (PxInfo *)mixer;
   MIXERCONTROLDETAILS details;
   MIXERCONTROLDETAILS_BOOLEAN flags[32];
   MMRESULT result;
   int j;

   details.cbStruct = sizeof(MIXERCONTROLDETAILS);
   details.dwControlID = info->muxID;
   details.cMultipleItems = info->numInputs;
   details.cChannels = 1;
   details.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
   details.paDetails = (LPMIXERCONTROLDETAILS_BOOLEAN)&flags[0];

   for(j=0; j<info->numInputs; j++)
      flags[j].fValue = (i == j);

   result = mixerSetControlDetails(info->hInputMixer,
                                   (LPMIXERCONTROLDETAILS)&details,
                                   MIXER_SETCONTROLDETAILSF_VALUE);
}

/*
 Input volume
*/

PxVolume Px_GetInputVolume( PxMixer *mixer )
{
   PxInfo *info = (PxInfo *)mixer;
   PxVolume vol;
   int src = Px_GetCurrentInputSource(mixer);

   vol = -1.0;
   VolumeFunction(info->hInputMixer, info->src[src].controlID, &vol);
   return vol;
}

void Px_SetInputVolume( PxMixer *mixer, PxVolume volume )
{
   PxInfo *info = (PxInfo *)mixer;
   int src = Px_GetCurrentInputSource(mixer);

   VolumeFunction(info->hInputMixer, info->src[src].controlID, &volume);
}

/*
  Balance
*/

int Px_SupportsOutputBalance( PxMixer *mixer )
{
   return 0;
}

PxBalance Px_GetOutputBalance( PxMixer *mixer )
{
   return 0.0;
}

void Px_SetOutputBalance( PxMixer *mixer, PxBalance balance )
{
}

/*
  Playthrough
*/

int Px_SupportsPlaythrough( PxMixer *mixer )
{
   return 0;
}

PxVolume Px_GetPlaythrough( PxMixer *mixer )
{
   return 0.0;
}

void Px_SetPlaythrough( PxMixer *mixer, PxVolume volume )
{
}

int Px_SetMicrophoneBoost( PxMixer* mixer, int enable )
{
   MIXERLINE mixerLine ;
   LPMIXERCONTROL mixerControl ;
   MIXERLINECONTROLS mixerLineControls ;
   MIXERCONTROLDETAILS mixerControlDetails ;
   MIXERCONTROLDETAILS_BOOLEAN value ;
   MMRESULT mmr = MMSYSERR_ERROR ;
   DWORD boost_id = -1 ;
   DWORD x ;

   // cast void pointer
   PxInfo* info = ( PxInfo* )( mixer ) ;

   if ( info == NULL )
      return MMSYSERR_ERROR ;

   //
   // get line info
   //

   mixerLine.cbStruct = sizeof( MIXERLINE ) ;
   mixerLine.dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE ;

   mmr = mixerGetLineInfo(
         ( HMIXEROBJ )( info->hInputMixer ),
         &mixerLine,
         MIXER_GETLINEINFOF_COMPONENTTYPE
         ) ;

   if ( mmr != MMSYSERR_NOERROR )
      return mmr ;

   //
   // get all controls
   //

   mixerControl = (MIXERCONTROL *)malloc( sizeof( MIXERCONTROL ) * mixerLine.cControls ) ;

   mixerLineControls.cbStruct = sizeof( MIXERLINECONTROLS ) ;
   mixerLineControls.dwLineID = mixerLine.dwLineID ;
   mixerLineControls.cControls = mixerLine.cControls ;
   mixerLineControls.cbmxctrl = sizeof( MIXERCONTROL ) ;
   mixerLineControls.pamxctrl = ( LPMIXERCONTROL )( mixerControl ) ;

   mmr = mixerGetLineControls(
         ( HMIXEROBJ )( info->hInputMixer ),
         &mixerLineControls,
         MIXER_GETLINECONTROLSF_ALL
         ) ;

   if ( mmr != MMSYSERR_NOERROR )
   {
      free(mixerControl);

      return mmr ;
   }

   //
   // find boost control
   //

   for ( x = 0 ; x < mixerLineControls.cControls ; ++x )
   {
      // check control type
      if ( mixerControl[x].dwControlType & MIXERCONTROL_CONTROLTYPE_BOOLEAN )
      {
         // normalize control name
         char* name = _strupr( mixerControl[x].szName ) ;

         // check for 'mic' and 'boost'
         if (
               ( strstr( name, "MIC" ) != NULL )
               && ( strstr( name, "BOOST" ) != NULL )
            )
         {
            boost_id = mixerControl[x].dwControlID ;
            break ;
         }
      }
   }

   if ( boost_id == -1 )
   {
      free(mixerControl);

      return MMSYSERR_ERROR ;
   }

   //
   // get control details
   //

   mixerControlDetails.cbStruct = sizeof( MIXERCONTROLDETAILS ) ;
   mixerControlDetails.dwControlID = boost_id ;
   mixerControlDetails.cChannels = 1 ;
   mixerControlDetails.cMultipleItems = 0 ;
   mixerControlDetails.cbDetails = sizeof( MIXERCONTROLDETAILS_BOOLEAN ) ;
   mixerControlDetails.paDetails = &value ;

   mmr = mixerGetControlDetails(
         ( HMIXEROBJ )( info->hInputMixer ),
         &mixerControlDetails,
         MIXER_GETCONTROLDETAILSF_VALUE
         ) ;

   if ( mmr != MMSYSERR_NOERROR )
   {
      free(mixerControl);

      return mmr ;
   }

   //
   // update value
   //

   value.fValue = ( enable == 0 ) ? 0L : 1L ;

   //
   // set control details
   //

   mmr = mixerSetControlDetails(
         ( HMIXEROBJ )( info->hInputMixer ),
         &mixerControlDetails,
         MIXER_SETCONTROLDETAILSF_VALUE
         ) ;

   free(mixerControl);

   if ( mmr != MMSYSERR_NOERROR )
      return mmr ;

   return mmr ;
}

int Px_GetMicrophoneBoost( PxMixer* mixer )
{
   MIXERLINE mixerLine ;
   LPMIXERCONTROL mixerControl ;
   MIXERLINECONTROLS mixerLineControls ;
   MIXERCONTROLDETAILS mixerControlDetails ;
   MIXERCONTROLDETAILS_BOOLEAN value ;
   MMRESULT mmr = MMSYSERR_ERROR ;
   DWORD boost_id = -1 ;
   DWORD x ;

   // cast void pointer
   PxInfo* info = ( PxInfo* )( mixer ) ;

   if ( info == NULL )
      return -1 ;

   //
   // get line info
   //

   mixerLine.cbStruct = sizeof( MIXERLINE ) ;
   mixerLine.dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE ;

   mmr = mixerGetLineInfo(
         ( HMIXEROBJ )( info->hInputMixer ),
         &mixerLine,
         MIXER_GETLINEINFOF_COMPONENTTYPE
         ) ;

   if ( mmr != MMSYSERR_NOERROR )
      return -1 ;

   //
   // get all controls
   //

   mixerControl = (MIXERCONTROL *)malloc( sizeof( MIXERCONTROL ) * mixerLine.cControls ) ;

   mixerLineControls.cbStruct = sizeof( MIXERLINECONTROLS ) ;
   mixerLineControls.dwLineID = mixerLine.dwLineID ;
   mixerLineControls.cControls = mixerLine.cControls ;
   mixerLineControls.cbmxctrl = sizeof( MIXERCONTROL ) ;
   mixerLineControls.pamxctrl = ( LPMIXERCONTROL )( mixerControl ) ;

   mmr = mixerGetLineControls(
         ( HMIXEROBJ )( info->hInputMixer ),
         &mixerLineControls,
         MIXER_GETLINECONTROLSF_ALL
         ) ;

   if ( mmr != MMSYSERR_NOERROR )
   {
      free(mixerControl);

      return -1 ;
   }

   //
   // find boost control
   //

   for ( x = 0 ; x < mixerLineControls.cControls ; ++x )
   {
      // check control type
      if ( mixerControl[x].dwControlType & MIXERCONTROL_CONTROLTYPE_BOOLEAN )
      {
         // normalize control name
         char* name = _strupr( mixerControl[x].szName ) ;

         // check for 'mic' and 'boost'
         if (
               ( strstr( name, "MIC" ) != NULL )
               && ( strstr( name, "BOOST" ) != NULL )
            )
         {
            boost_id = mixerControl[x].dwControlID ;
            break ;
         }
      }
   }

   if ( boost_id == -1 )
   {
      free(mixerControl);

      return -1 ;
   }

   //
   // get control details
   //

   mixerControlDetails.cbStruct = sizeof( MIXERCONTROLDETAILS ) ;
   mixerControlDetails.dwControlID = boost_id ;
   mixerControlDetails.cChannels = 1 ;
   mixerControlDetails.cMultipleItems = 0 ;
   mixerControlDetails.cbDetails = sizeof( MIXERCONTROLDETAILS_BOOLEAN ) ;
   mixerControlDetails.paDetails = &value ;

   mmr = mixerGetControlDetails(
         ( HMIXEROBJ )( info->hInputMixer ),
         &mixerControlDetails,
         MIXER_GETCONTROLDETAILSF_VALUE
         ) ;

   free(mixerControl);

   if ( mmr != MMSYSERR_NOERROR )
      return -1 ;

   return ( int )( value.fValue ) ;
}

int Px_SetCurrentInputSourceByName( PxMixer* mixer, const char* name )
{
   int x ;

   // cast void pointer
   PxInfo* info = ( PxInfo* )( mixer ) ;

   // make sure we have a mixer
   if ( info == NULL )
      return MMSYSERR_ERROR ;

   // make sure we have a search name
   if ( name == NULL )
      return MMSYSERR_ERROR ;

   //
   // set input source
   //

   for ( x = 0 ; x < info->numInputs ; ++x )
   {
      // compare passed name with control name
      if ( strcasecmp( info->src[x].name, name ) == 0 )
      {
         // set input source
         Px_SetCurrentInputSource( mixer, x ) ;

         // make sure set'ing worked
         if ( Px_GetCurrentInputSource( mixer ) == x )
            return MMSYSERR_NOERROR ;
         else
            return MMSYSERR_ERROR ;
      }
   }

   return MMSYSERR_ERROR ;
}