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"); }
// ---------------------------------------------------------- void ofxAudioUnitMixer::setOutputVolume(float volume) // ---------------------------------------------------------- { ERR_CHK(AudioUnitSetParameter(*_unit, kMultiChannelMixerParam_Volume, kAudioUnitScope_Output, 0, volume, 0), "setting mixer output 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); } }
void FCoreAudioDevice::SetMatrixMixerInputVolume( int32 Input, float Volume ) { check( Input < MAX_MULTICHANNEL_AUDIOCHANNELS ); uint32 InputOffset = Input * MatrixMixerInputFormat.mChannelsPerFrame; // Set Input channel 0 volume uint32 element = CalculateMatrixElement( InputOffset + 0, -1 ); AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, Volume, 0 ); // Set Input channel 1 volume element = CalculateMatrixElement( InputOffset + 1, -1 ); AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, Volume, 0 ); // Set Input channel 2 volume element = CalculateMatrixElement( InputOffset + 2, -1 ); AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, Volume, 0 ); // Set Input channel 3 volume element = CalculateMatrixElement( InputOffset + 3, -1 ); AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, Volume, 0 ); // Set Input channel 4 volume element = CalculateMatrixElement( InputOffset + 4, -1 ); AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, Volume, 0 ); // Set Input channel 5 volume element = CalculateMatrixElement( InputOffset + 5, -1 ); AudioUnitSetParameter( MatrixMixerUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, element, Volume, 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"); };
int sa_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_METHOD OsxAudioUnitsOutput_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 CAUMatrixMixer::SetOutputVolume(UInt32 element, Float32 vol) { if (!m_audioUnit) return false; OSStatus ret = AudioUnitSetParameter(m_audioUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Output, element, vol, 0); if (ret) { CLog::Log(LOGERROR, "CAUMatrixMixer::SetOutputVolume: " "Unable to set output volume. Error = %s", GetError(ret).c_str()); 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; }
bool CAUMatrixMixer::SetGlobalVolume(Float32 vol) { if (!m_audioUnit) return false; OSStatus ret = AudioUnitSetParameter(m_audioUnit, kMatrixMixerParam_Volume, kAudioUnitScope_Global, 0xFFFFFFFF, vol, 0); if (ret) { CLog::Log(LOGERROR, "CAUMatrixMixer::SetGlobalVolume: " "Unable to set global volume. Error = %s", GetError(ret).c_str()); return false; } return true; }
bool CAUOutputDevice::SetCurrentVolume(Float32 vol) { if (!m_audioUnit) return false; OSStatus ret = AudioUnitSetParameter(m_audioUnit, kHALOutputParam_Volume, kAudioUnitScope_Global, 0, vol, 0); if (ret) { CLog::Log(LOGERROR, "CCoreAudioUnit::SetCurrentVolume: " "Unable to set AudioUnit volume. Error = %s", GetError(ret).c_str()); return false; } return true; }