自学教程：C++ AudioUnitSetParameter函数代码示例

bool CCoreAudioMixMap::SetMixingMatrix(CAUMatrixMixer *mixerUnit,  CCoreAudioMixMap *mixMap, AudioStreamBasicDescription *inputFormat,  AudioStreamBasicDescription *fmt, int channelOffset){  if (!mixerUnit || !inputFormat || !fmt)    return false;  // Fetch the mixing unit size  UInt32 dims[2];  UInt32 size = sizeof(dims);  AudioUnitGetProperty(mixerUnit->GetUnit(),    kAudioUnitProperty_MatrixDimensions, kAudioUnitScope_Global, 0, dims, &size);  if(inputFormat->mChannelsPerFrame + channelOffset > dims[0])  {    CLog::Log(LOGERROR, "CCoreAudioMixMap::SetMixingMatrix - input format doesn't fit mixer size %u+%u > %u"                      , inputFormat->mChannelsPerFrame, channelOffset, dims[0]);    return false;  }  if(fmt->mChannelsPerFrame > dims[1])  {    CLog::Log(LOGERROR, "CCoreAudioMixMap::SetMixingMatrix - ouput format doesn't fit mixer size %u > %u"              , fmt->mChannelsPerFrame, dims[1]);    return false;  }  if(fmt->mChannelsPerFrame < dims[1])  {    CLog::Log(LOGWARNING, "CCoreAudioMixMap::SetMixingMatrix - ouput format doesn't specify all outputs %u < %u"              , fmt->mChannelsPerFrame, dims[1]);  }  // Configure the mixing matrix  Float32* val = (Float32*)*mixMap;  for (UInt32 i = 0; i < inputFormat->mChannelsPerFrame; ++i)  {    UInt32 j = 0;    for (; j < fmt->mChannelsPerFrame; ++j)    {      AudioUnitSetParameter(mixerUnit->GetUnit(),        kMatrixMixerParam_Volume, kAudioUnitScope_Global, ( (i + channelOffset) << 16 ) | j, *val++, 0);    }    // zero out additional outputs from this input    for (; j < dims[1]; ++j)    {      AudioUnitSetParameter(mixerUnit->GetUnit(),        kMatrixMixerParam_Volume, kAudioUnitScope_Global, ( (i + channelOffset) << 16 ) | j, 0.0f, 0);    }  }  CLog::Log(LOGDEBUG, "CCoreAudioGraph::Open: "    "Mixer Output Format: %d channels, %0.1f kHz, %d bits, %d bytes per frame",    (int)fmt->mChannelsPerFrame, fmt->mSampleRate / 1000.0f, (int)fmt->mBitsPerChannel, (int)fmt->mBytesPerFrame);  if (!mixerUnit->InitMatrixMixerVolumes())    return false;  return true;}

/**  * Calls the platform specific code to set the parameters that define a radio effect. *  * @param	RadioEffectParameters	The new parameters for the radio distortion effect.  */void FCoreAudioEffectsManager::SetRadioEffectParameters( const FAudioRadioEffect& RadioEffectParameters ){	enum ERadioEffectParams	{		RadioParam_ChebyshevPowerMultiplier,		RadioParam_ChebyshevPower,		RadioParam_ChebyshevMultiplier,		RadioParam_ChebyshevCubedMultiplier	};	const float ChebyshevPowerMultiplier = Radio_ChebyshevPowerMultiplier->GetValueOnGameThread();	const float ChebyshevPower = Radio_ChebyshevPower->GetValueOnGameThread();	const float ChebyshevMultiplier = Radio_ChebyshevMultiplier->GetValueOnGameThread();	const float ChebyshevCubedMultiplier = Radio_ChebyshevCubedMultiplier->GetValueOnGameThread();	for( uint32 Index = 1; Index < CORE_AUDIO_MAX_CHANNELS; Index++ )	{		FCoreAudioSoundSource *Source = ((FCoreAudioDevice*)AudioDevice)->AudioChannels[Index];		if( Source && Source->RadioUnit )		{			AudioUnitSetParameter( Source->RadioUnit, RadioParam_ChebyshevPowerMultiplier, kAudioUnitScope_Global, 0, ChebyshevPowerMultiplier, 0 );			AudioUnitSetParameter( Source->RadioUnit, RadioParam_ChebyshevPower, kAudioUnitScope_Global, 0, ChebyshevPower, 0 );			AudioUnitSetParameter( Source->RadioUnit, RadioParam_ChebyshevMultiplier, kAudioUnitScope_Global, 0, ChebyshevMultiplier, 0 );			AudioUnitSetParameter( Source->RadioUnit, RadioParam_ChebyshevCubedMultiplier, kAudioUnitScope_Global, 0, ChebyshevCubedMultiplier, 0 );		}	}}

void FCoreAudioDevice::SetupMatrixMixerInput( int32 Input, bool bIs6ChannelOGG ){	check( Input < MAX_MULTICHANNEL_AUDIOCHANNELS );		uint32 InputOffset = Input * MatrixMixerInputFormat.mChannelsPerFrame;	uint32 FLInputOffset	= 0;	uint32 FRInputOffset	= 1;	uint32 FCInputOffset	= 2;	uint32 LFEInputOffset	= 3;	uint32 SLInputOffset	= 4;	uint32 SRInputOffset	= 5;	// Channel ordering is different for 6 channel OGG files	if (bIs6ChannelOGG)	{		FLInputOffset	= 0;		FCInputOffset	= 1;		FRInputOffset	= 2;		SLInputOffset	= 3;		SRInputOffset	= 4;		LFEInputOffset	= 5;	}	// Enable input 0	AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Enable, kAudioUnitScope_Input, Input, 1.0, 0 );		// Set Matrix Input volume	SetMatrixMixerInputVolume( Input, 1.0 );		// FL channel to left output	uint32 element = CalculateMatrixElement( InputOffset + FLInputOffset, 0 );	AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, 1.0, 0 );		// FR channel to right output	element = CalculateMatrixElement( InputOffset + FRInputOffset, 1 );	AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, 1.0, 0 );		// FC channel to left & right output	element = CalculateMatrixElement( InputOffset + FCInputOffset, 0 );	AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, 0.5, 0 );	element = CalculateMatrixElement( InputOffset + FCInputOffset, 1 );	AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, 0.5, 0 );		// LFE channel to left & right output	element = CalculateMatrixElement( InputOffset + LFEInputOffset, 0 );	AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, 0.5, 0 );		element = CalculateMatrixElement( InputOffset + LFEInputOffset, 1 );	AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, 0.5, 0 );		// SL channel to left output	element = CalculateMatrixElement( InputOffset + SLInputOffset, 0 );	AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, 1.0, 0 );		// SR channel to right output	element = CalculateMatrixElement( InputOffset + SRInputOffset, 1 );	AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, 1.0, 0 );}

OSStatus writeRenderProc(void *inRefCon, 						 AudioUnitRenderActionFlags *inActionFlags,						 const AudioTimeStamp *inTimeStamp, 						 UInt32 inBusNumber,						 UInt32 inNumFrames, 						 AudioBufferList *ioData){    OSStatus err= noErr;    void *inInputDataProcUserData=NULL;	CAData *d=(CAData*)inRefCon;	if (gain_changed_out == true)	{		err = AudioUnitSetParameter(d->caOutAudioUnit, kAudioUnitParameterUnit_LinearGain,									   kAudioUnitScope_Global, 0, (Float32)gain_volume_out, 0);		if(err != noErr)		{			ms_error("failed to set output volume %i", err);		}	    gain_changed_out = false;		err= noErr;	}			if(d->write_started != FALSE) {		AudioStreamPacketDescription* outPacketDescription = NULL;		err = AudioConverterFillComplexBuffer(d->caOutConverter, writeACInputProc, inRefCon,											  &inNumFrames, ioData, outPacketDescription);		if(err != noErr)			ms_error("writeRenderProc:AudioConverterFillComplexBuffer err %08x %d", err, ioData->mNumberBuffers);	}    return err;}

bool CCoreAudioMixMap::SetMixingMatrix(CAUMatrixMixer *mixerUnit,  CCoreAudioMixMap *mixMap, AudioStreamBasicDescription *inputFormat,  AudioStreamBasicDescription *fmt, int channelOffset){  if (!mixerUnit || !inputFormat || !fmt)    return false;  // Configure the mixing matrix  Float32* val = (Float32*)*mixMap;  CLog::Log(LOGDEBUG, "CCoreAudioGraph::Open: Loading matrix mixer configuration");  for (UInt32 i = 0; i < inputFormat->mChannelsPerFrame; ++i)  {    val = (Float32*)*mixMap + i*m_deviceChannels;    for (UInt32 j = 0; j < fmt->mChannelsPerFrame; ++j)    {      OSStatus ret = AudioUnitSetParameter(mixerUnit->GetUnit(),        kMatrixMixerParam_Volume, kAudioUnitScope_Global, ( (i + channelOffset) << 16 ) | j, *val++, 0);      if (!ret)      {        CLog::Log(LOGINFO, "CCoreAudioGraph::Open: /t[%d][%d][%0.1f]",          (int)i + channelOffset, (int)j, *(val-1));      }    }  }  CLog::Log(LOGINFO, "CCoreAudioGraph::Open: "    "Mixer Output Format: %d channels, %0.1f kHz, %d bits, %d bytes per frame",    (int)fmt->mChannelsPerFrame, fmt->mSampleRate / 1000.0f, (int)fmt->mBitsPerChannel, (int)fmt->mBytesPerFrame);  if (!mixerUnit->InitMatrixMixerVolumes())    return false;  return true;}

bool auLoader::setParameter(int index, float value, long frames) {  if(AudioUnitSetParameter(m_plugin, index, kAudioUnitScope_Global, 0, value, frames) == noErr) {    return true;  }  else {    return false;  }}

void OutputImplAudioUnit::setVolume( float aVolume ){	aVolume = math<float>::clamp( aVolume, 0.0, 1.0 );	OSStatus err = AudioUnitSetParameter( mMixerUnit, kMultiChannelMixerParam_Volume, kAudioUnitScope_Output, 0, aVolume, 0 );	if( err ) {		//throw	}}

void CoreAudioOutput::setVolume(float vol){	this->_volume = vol;		OSSpinLockLock(this->_spinlockAU);	AudioUnitSetParameter(this->_au, kHALOutputParam_Volume, kAudioUnitScope_Global, 0, vol, 0);	OSSpinLockUnlock(this->_spinlockAU);}

static int control(int cmd,void *arg){ao_control_vol_t *control_vol;OSStatus err;Float32 vol;	switch (cmd) {	case AOCONTROL_GET_VOLUME:		control_vol = (ao_control_vol_t*)arg;		if (ao->b_digital) {			// Digital output has no volume adjust.			return CONTROL_FALSE;		}		err = AudioUnitGetParameter(ao->theOutputUnit, kHALOutputParam_Volume, kAudioUnitScope_Global, 0, &vol);		if(err==0) {			// printf("GET VOL=%f/n", vol);			control_vol->left=control_vol->right=vol*100.0/4.0;			return CONTROL_TRUE;		}		else {			ao_msg(MSGT_AO, MSGL_WARN, "could not get HAL output volume: [%4.4s]/n", (char *)&err);			return CONTROL_FALSE;		}	case AOCONTROL_SET_VOLUME:		control_vol = (ao_control_vol_t*)arg;		if (ao->b_digital) {			// Digital output can not set volume. Here we have to return true			// to make mixer forget it. Else mixer will add a soft filter,			// that's not we expected and the filter not support ac3 stream			// will cause mplayer die.			// Although not support set volume, but at least we support mute.			// MPlayer set mute by set volume to zero, we handle it.			if (control_vol->left == 0 && control_vol->right == 0)				ao->b_muted = 1;			else				ao->b_muted = 0;			return CONTROL_TRUE;		}		vol=(control_vol->left+control_vol->right)*4.0/200.0;		err = AudioUnitSetParameter(ao->theOutputUnit, kHALOutputParam_Volume, kAudioUnitScope_Global, 0, vol, 0);		if(err==0) {			// printf("SET VOL=%f/n", vol);			return CONTROL_TRUE;		}		else {			ao_msg(MSGT_AO, MSGL_WARN, "could not set HAL output volume: [%4.4s]/n", (char *)&err);			return CONTROL_FALSE;		}	  /* Everything is currently unimplemented */	default:	  return CONTROL_FALSE;	}}

	OSStatus			SetParameter(AudioUnitParameterID inID, AudioUnitScope scope, AudioUnitElement element,											Float32 value, UInt32 bufferOffsetFrames)	{			if (mSetParamProc != NULL) {				return reinterpret_cast<AudioUnitSetParameterProc>(mSetParamProc) (mConnInstanceStorage,										inID, scope, element, value, bufferOffsetFrames);			}			return AudioUnitSetParameter(mUnit, inID, scope, element, value, bufferOffsetFrames);	}

/** Set the volume of the current sequence. */static void DoSetVolume(){	if (_sequence == NULL) return;	AUGraph graph;	MusicSequenceGetAUGraph(_sequence, &graph);	AudioUnit output_unit = NULL;	/* Get output audio unit */	UInt32 node_count = 0;	AUGraphGetNodeCount(graph, &node_count);	for (UInt32 i = 0; i < node_count; i++) {		AUNode node;		AUGraphGetIndNode(graph, i, &node);		AudioUnit unit;		OSType comp_type = 0;#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)		if (MacOSVersionIsAtLeast(10, 5, 0)) {			/* The 10.6 SDK has changed the function prototype of			 * AUGraphNodeInfo. This is a binary compatible change,			 * but we need to get the type declaration right or			 * risk compilation errors. The header AudioComponent.h			 * was introduced in 10.6 so use it to decide which			 * type definition to use. */#ifdef __AUDIOCOMPONENT_H__			AudioComponentDescription desc;#else			ComponentDescription desc;#endif			AUGraphNodeInfo(graph, node, &desc, &unit);			comp_type = desc.componentType;		} else#endif		{#if (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5)			ComponentDescription desc;			AUGraphGetNodeInfo(graph, node, &desc, NULL, NULL, &unit);			comp_type = desc.componentType;#endif		}		if (comp_type == kAudioUnitType_Output) {			output_unit = unit;			break;		}	}	if (output_unit == NULL) {		DEBUG(driver, 1, "cocoa_m: Failed to get output node to set volume");		return;	}	Float32 vol = _volume / 127.0f;  // 0 - +127 -> 0.0 - 1.0	AudioUnitSetParameter(output_unit, kHALOutputParam_Volume, kAudioUnitScope_Global, 0, vol, 0);}

// ----------------------------------------------------------void ofxAudioUnitSampler::setVolume(float volume)// ----------------------------------------------------------{    AudioUnitSetParameter(*_unit,                          kMusicDeviceParam_Volume,                          kAudioUnitScope_Global,                          0,                          volume,                          0);}

/* * FOR SETTING VOLUME ON iOS, AudioQueue SHOULD BE USED INSTEAD OF AudioUnit */void AudioLoopImplCocoa::setVolume(float volume){#if !TARGET_OS_IPHONE    if (initialized)    {        OSStatus err = AudioUnitSetParameter(audioUnit, kHALOutputParam_Volume, kAudioUnitScope_Output, 0, volume, 0);        if (err) printf("AudioUnitSetParameter ERROR: %d/n", (int)err);    }#endif}

// ----------------------------------------------------------void ofxAudioUnitMixer::setInputVolume(float volume, int bus)// ----------------------------------------------------------{  ERR_CHK(AudioUnitSetParameter(*_unit,                                 kMultiChannelMixerParam_Volume,                                 kAudioUnitScope_Input,                                 bus,                                 volume,                                0),           "setting mixer input gain");}

static int set_volume(struct ao *ao, struct ao_control_vol *vol) {    struct priv *p = ao->priv;    float auvol = (vol->left + vol->right) / 200.0;    OSStatus err =        AudioUnitSetParameter(p->audio_unit, kHALOutputParam_Volume,                              kAudioUnitScope_Global, 0, auvol, 0);    CHECK_CA_ERROR("could not set HAL output volume");    return CONTROL_TRUE;coreaudio_error:    return CONTROL_ERROR;}

 int AudioDataMixerCallback(uint busIndex, int totalNbOfFrameToWrite,  AudioBufferList* data) {     char* outPtr = (char*)data->mBuffers[0].mData;          int remainingFramesToWrite = totalNbOfFrameToWrite;     while (remainingFramesToWrite > 0)     {         int nbOfFrameToWrite = std::min(remainingFramesToWrite, (ShouldBeLooped() ? LoopEndPoint : TotalNumberOfFrames) - CurrentFrame);                      CopyDataToBuffer(outPtr, nbOfFrameToWrite, NumberOfChannels);                  remainingFramesToWrite -= nbOfFrameToWrite;                      // Check if the track have to be re-looped         if (ShouldBeLooped() && CurrentFrame >= LoopEndPoint)         {             --NumberOfLoops;             CurrentFrame = LoopStartPoint;         }                  // Check if we reached the end of the track.         if (CurrentFrame >= TotalNumberOfFrames)         {             AudioUnitSetParameter((AudioUnit)HandleChannelMixer, kMultiChannelMixerParam_Enable, kAudioUnitScope_Input, busIndex, 0, 0);             AudioUnitSetParameter((AudioUnit)Handle3DMixer, k3DMixerParam_Enable, kAudioUnitScope_Input, busIndex, 0, 0);                      IsEnabled2D = false;             IsEnabled3D = false;                      PlaybackEnded = true;                      // Fill the rest of the buffer with blank             int sizeToBlank = sizeof(short) * NumberOfChannels * remainingFramesToWrite;             memset(outPtr, 0, sizeToBlank);                      return 0;         }     }          return 0; }

void CoreAudioSound::SetVolume(int volume){	OSStatus err;    m_volume = volume;	err = AudioUnitSetParameter(audioUnit,					kHALOutputParam_Volume,					kAudioUnitParameterFlag_Output, 0,					volume / 100., 0);	if (err != noErr)		ERROR_LOG(AUDIO, "error setting volume");}

void native_midi_setvolume(int volume){    if (latched_volume == volume)        return;    latched_volume = volume;    if ((currentsong) && (currentsong->audiounit)) {        const float floatvol = ((float) volume) / ((float) MIX_MAX_VOLUME);        AudioUnitSetParameter(currentsong->audiounit, kHALOutputParam_Volume,                              kAudioUnitScope_Global, 0, floatvol, 0);    }}

bool CCoreAudioUnit::SetCurrentVolume(Float32 vol){  if (!m_Component)    return false;    OSStatus ret = AudioUnitSetParameter(m_Component, kHALOutputParam_Volume, kAudioUnitScope_Global, 0, vol, 0);  if (ret)  {    CLog::Log(LOGERROR, "CCoreAudioUnit::SetCurrentVolume: Unable to set AudioUnit volume. Error = 0x%08x (%4.4s)", ret, CONVERT_OSSTATUS(ret));    return false;  }  return true;}

void macosx_audio_set_ogain(audio_desc_t ad,int vol){	UNUSED(ad);	OSStatus err = noErr;	// Remember the playback gain.	//devices[ad].pgain_ = level;	devices[ad].outputGain_ = vol; /// outputGainDivisor_;	//float og_scaled = devices[ad].outputGain_ / 16;	// Set the volume.	err = AudioUnitSetParameter(devices[ad].outputUnit_, kAudioUnitParameterUnit_LinearGain, kAudioUnitScope_Global, 0, devices[ad].outputGain_, 0);	if (err != noErr) fprintf(stderr, "Input device error: set_ogain");};

intsa_stream_set_volume_abs(sa_stream_t *s, float vol) {  if (s == NULL || s->output_unit == NULL) {    return SA_ERROR_NO_INIT;  }  pthread_mutex_lock(&s->mutex);  AudioUnitSetParameter(s->output_unit, kHALOutputParam_Volume,      kAudioUnitParameterFlag_Output, 0, vol, 0);  pthread_mutex_unlock(&s->mutex);  return SA_SUCCESS;}

void OutputImplAudioUnit::Track::play() {	AURenderCallbackStruct renderCallback;	renderCallback.inputProc = &OutputImplAudioUnit::Track::renderCallback;	renderCallback.inputProcRefCon = (void *)this;		OSStatus err;		err = AudioUnitSetProperty( mOutput->mMixerUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, mInputBus, mOutput->mPlayerDescription, sizeof( AudioStreamBasicDescription ) );	if( err ) {		//throw		std::cout << "Error setting track input bus format on mixer" << std::endl;	}		err = AudioUnitSetParameter( mOutput->mMixerUnit, kMultiChannelMixerParam_Enable, kAudioUnitScope_Input, mInputBus, 1, 0 );	if( err ) {		std::cout << "error enabling input bus" << std::endl;	}		err = AudioUnitSetParameter( mOutput->mMixerUnit, kMultiChannelMixerParam_Volume, kAudioUnitScope_Input, mInputBus, CINDER_DEFAULT_VOLUME, 0 );	if( err ) {		std::cout << "error setting default volume" << std::endl;	}		mIsPlaying = true;		err = AudioUnitAddRenderNotify( mOutput->mMixerUnit, OutputImplAudioUnit::Track::renderNotifyCallback, (void *)this );	if( err ) {		//throw		std::cout << "Error setting track redner notify callback on mixer" << std::endl;	}		err = AudioUnitSetProperty( mOutput->mMixerUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, mInputBus, &renderCallback, sizeof(renderCallback) );	if( err ) {		//throw		std::cout << "Error setting track redner callback on mixer" << std::endl;	}}

/*----------------------------------------------------------------------|    OsxAudioUnitsOutput_SetVolume+---------------------------------------------------------------------*/BLT_METHODOsxAudioUnitsOutput_SetVolume(BLT_VolumeControl* _self, float volume){    OsxAudioUnitsOutput* self = ATX_SELF(OsxAudioUnitsOutput, BLT_VolumeControl);    ComponentResult      result;    Float32              au_volume = volume;        result = AudioUnitSetParameter(self->audio_unit, kHALOutputParam_Volume, kAudioUnitScope_Global, 0, au_volume, 0);    if (result == noErr) {        return BLT_SUCCESS;    } else {        return BLT_FAILURE;    }    }

bool CAUMatrixMixer::SetInputBusFormat(UInt32 busCount, AudioStreamBasicDescription *pFormat){  if (!m_audioUnit)    return false;  UInt32 enable = 1;  for (UInt32 i = 0; i < busCount; i++)  {    AudioUnitSetParameter(m_audioUnit, kMatrixMixerParam_Enable, kAudioUnitScope_Input, i, enable, 0);    if (!SetFormat(pFormat, kAudioUnitScope_Input, i))      return false;  }  return true;}

bool CAUMultiChannelMixer::SetCurrentVolume(Float32 vol){  if (!m_audioUnit)    return false;  OSStatus ret = AudioUnitSetParameter(m_audioUnit, kMultiChannelMixerParam_Volume, kAudioUnitScope_Input, kInputBus, vol, 0);  if (ret)  {    CLog::Log(LOGERROR, "CAUMultiChannelMixer::SetCurrentVolume: Unable to set Mixer volume. Error = %s", GetError(ret).c_str());    return false;  }  return true;}