au.AudioGameplayVolume.UpdateRate

au.AudioGameplayVolume.UpdateRate

#Overview

name: au.AudioGameplayVolume.UpdateRate

This variable is created as a Console Variable (cvar).

It is referenced in 26 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of au.AudioGameplayVolume.UpdateRate is to control how frequently the Audio Gameplay Volume system checks for listener changes with respect to audio gameplay volumes. This setting is part of the Audio Gameplay Volume plugin in Unreal Engine 5.

The Audio Gameplay Volume subsystem relies on this setting variable. It’s used in the UAudioGameplayVolumeSubsystem class to determine the update frequency for the system.

The value of this variable is set using an FAutoConsoleVariableRef, which means it can be adjusted through console commands or configuration files. The default value is 0.05 seconds (50 milliseconds).

This variable interacts with other variables in the system:

  1. MinUpdateRate: Ensures the update rate doesn’t go below a certain threshold (0.016 seconds).
  2. UpdateRateJitterDelta: Adds a random jitter to the update rate to prevent synchronization issues.

Developers should be aware of the following when using this variable:

  1. Lower values will increase responsiveness but may impact performance.
  2. Higher values will decrease responsiveness but may improve performance.
  3. The actual update rate includes a random jitter, so it’s not strictly fixed.

Best practices when using this variable include:

  1. Balance between responsiveness and performance based on your game’s needs.
  2. Consider the minimum update rate (MinUpdateRate) when adjusting this value.
  3. Be aware of the jitter effect when fine-tuning the system’s behavior.

Regarding the associated variable UpdateRate: The purpose of UpdateRate is to control how frequently various systems in Unreal Engine update their data or perform certain operations. It’s used in multiple contexts, including animation, UI updates, and audio processing.

This variable is used across different subsystems and plugins, including:

  1. Live Link Curve Debug UI
  2. Timecode Synchronizer
  3. Common UI
  4. Audio Mixer
  5. Animation System

The value of UpdateRate is typically set within the specific system that uses it, often as a parameter in a constructor or initialization function.

Developers should be aware that:

  1. UpdateRate affects the trade-off between responsiveness and performance in various systems.
  2. Different systems may have different optimal update rates.
  3. Some systems may have minimum or maximum limits for the update rate.

Best practices for using UpdateRate include:

  1. Adjust the value based on the specific needs of each system.
  2. Consider the performance implications of very high update rates.
  3. For time-sensitive operations, ensure the update rate is sufficient to meet responsiveness requirements.

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Plugins/AudioGameplayVolume/Source/AudioGameplayVolume/Private/AudioGameplayVolumeSubsystem.cpp:32

Scope (from outer to inner):

file
namespace    AudioGameplayVolumeConsoleVariables

Source code excerpt:

	float UpdateRate = 0.05f;
	FAutoConsoleVariableRef CVarUpdateInterval(
		TEXT("au.AudioGameplayVolume.UpdateRate"),
		UpdateRate,
		TEXT("How frequently we check for listener changes with respect to audio gameplay volumes, in seconds."),
		ECVF_Default);

	float UpdateRateJitterDelta = 0.025f;
	FAutoConsoleVariableRef CVarUpdateRateJitterDelta(

#Associated Variable and Callsites

This variable is associated with another variable named UpdateRate. They share the same value. See the following C++ source code.

#Loc: <Workspace>/Engine/Plugins/Animation/LiveLinkCurveDebugUI/Source/LiveLinkCurveDebugUI/Private/SLiveLinkCurveDebugUI.cpp:21

Scope (from outer to inner):

file
function     void SLiveLinkCurveDebugUI::Construct

Source code excerpt:

void SLiveLinkCurveDebugUI::Construct(const FArguments& InArgs)
{
	this->UpdateRate = InArgs._UpdateRate;
	this->OnSubjectNameChanged = InArgs._OnSubjectNameChanged;

	CachedLiveLinkSubjectName = InArgs._InitialLiveLinkSubjectName;

	//Try and get the LiveLink Client now and cache it off
	CachedLiveLinkClient = nullptr;

#Loc: <Workspace>/Engine/Plugins/Animation/LiveLinkCurveDebugUI/Source/LiveLinkCurveDebugUI/Private/SLiveLinkCurveDebugUI.cpp:88

Scope (from outer to inner):

file
function     void SLiveLinkCurveDebugUI::Construct

Source code excerpt:

	//Kick off initial CurveData generation
	UpdateCurveData();
	NextUpdateTime = static_cast<double>(UpdateRate) + FSlateApplication::Get().GetCurrentTime();
}

TSharedRef<ITableRow> SLiveLinkCurveDebugUI::GenerateListRow(TSharedPtr<FLiveLinkDebugCurveNodeBase> InItem, const TSharedRef<STableViewBase>& InOwningTable)
{
	return SNew(SLiveLinkCurveDebugUIListItem, InOwningTable)
		.CurveInfo(InItem);

#Loc: <Workspace>/Engine/Plugins/Animation/LiveLinkCurveDebugUI/Source/LiveLinkCurveDebugUI/Private/SLiveLinkCurveDebugUI.cpp:105

Scope (from outer to inner):

file
function     void SLiveLinkCurveDebugUI::Tick

Source code excerpt:

		{
			UpdateCurveData();
			NextUpdateTime = static_cast<double>(UpdateRate) + CurrentTime;

			DebugListView->RequestListRefresh();
		}
	}

	SUserWidget::Tick(AllottedGeometry, InCurrentTime, InDeltaTime);

#Loc: <Workspace>/Engine/Plugins/Animation/LiveLinkCurveDebugUI/Source/LiveLinkCurveDebugUI/Public/SLiveLinkCurveDebugUI.h:65

Scope (from outer to inner):

file
class        class SLiveLinkCurveDebugUI : public SUserWidget

Source code excerpt:


	//Used to limit how often we update curve data for performance
	float UpdateRate;
	double NextQueuedUpdateTime;
	double NextUpdateTime;

	TSharedPtr<SListView<TSharedPtr<FLiveLinkDebugCurveNodeBase>>> DebugListView;
};

#Loc: <Workspace>/Engine/Plugins/AudioGameplayVolume/Source/AudioGameplayVolume/Private/AudioGameplayVolumeSubsystem.cpp:30

Scope (from outer to inner):

file
namespace    AudioGameplayVolumeConsoleVariables

Source code excerpt:


	float MinUpdateRate = 0.016f;
	float UpdateRate = 0.05f;
	FAutoConsoleVariableRef CVarUpdateInterval(
		TEXT("au.AudioGameplayVolume.UpdateRate"),
		UpdateRate,
		TEXT("How frequently we check for listener changes with respect to audio gameplay volumes, in seconds."),
		ECVF_Default);

	float UpdateRateJitterDelta = 0.025f;
	FAutoConsoleVariableRef CVarUpdateRateJitterDelta(
		TEXT("au.AudioGameplayVolume.UpdateRate.JitterDelta"),

#Loc: <Workspace>/Engine/Plugins/AudioGameplayVolume/Source/AudioGameplayVolume/Private/AudioGameplayVolumeSubsystem.cpp:192

Scope (from outer to inner):

file
function     void UAudioGameplayVolumeSubsystem::Update

Source code excerpt:


	const float JitterDelta = FMath::RandRange(0.f, AudioGameplayVolumeConsoleVariables::UpdateRateJitterDelta);
	NextUpdateDeltaTime = FMath::Max(AudioGameplayVolumeConsoleVariables::UpdateRate + JitterDelta, AudioGameplayVolumeConsoleVariables::MinUpdateRate);
	TimeSinceUpdate = 0.f;

	if (bHasStaleProxy)
	{
		FAudioDeviceHandle AudioDeviceHandle = GetAudioDeviceHandle();
		if (AudioDeviceHandle.IsValid())

#Loc: <Workspace>/Engine/Plugins/Media/TimecodeSynchronizer/Source/TimecodeSynchronizerEditor/Private/Widgets/STimecodeSynchronizerWidget.cpp:60

Scope (from outer to inner):

file
function     void STimecodeSynchronizerBarWidget::Tick

Source code excerpt:

void STimecodeSynchronizerBarWidget::Tick(const FGeometry& InAllottedGeometry, const double InCurrentTime, const float InDeltaTime)
{
	if ((GFrameNumber % UpdateRate.Get()) == 0)
	{
		CurrentFrameWidth = FrameWidth.Get();

		int32 SourceCount = TimecodeSynchronizer->GetSynchronizedSources().Num();
		if (SourceCount)
		{

#Loc: <Workspace>/Engine/Plugins/Media/TimecodeSynchronizer/Source/TimecodeSynchronizerEditor/Private/Widgets/STimecodeSynchronizerWidget.cpp:308

Scope (from outer to inner):

file
function     void STimecodeSynchronizerBarWidget::Construct

Source code excerpt:

void STimecodeSynchronizerBarWidget::Construct(const FArguments& InArgs, UTimecodeSynchronizer& InTimecodeSynchronizer)
{
	UpdateRate = InArgs._UpdateRate;
	FrameWidth = InArgs._FrameWidth;

	TimecodeSynchronizer.Reset(&InTimecodeSynchronizer);
	SetCanTick(true);
}

void STimecodeSynchronizerBarWidget::SetUpdateRate(int32 InUpdateFrequency)
{
	UpdateRate.Set(InUpdateFrequency);
}

void STimecodeSynchronizerBarWidget::SetFrameWidth(int32 InFrameWidth)
{
	FrameWidth.Set(InFrameWidth);
}

#Loc: <Workspace>/Engine/Plugins/Media/TimecodeSynchronizer/Source/TimecodeSynchronizerEditor/Private/Widgets/STimecodeSynchronizerWidget.h:50

Scope (from outer to inner):

file
class        class STimecodeSynchronizerBarWidget : public SWidget

Source code excerpt:


private:
	TAttribute<int32> UpdateRate;
	TAttribute<int32> FrameWidth;

	int32 CurrentFrameWidth;
	FFrameRate CurrentFrameRate;
	int32 CurrentFrameValue;
	int32 CurrentFrame;

#Loc: <Workspace>/Engine/Plugins/Runtime/CommonUI/Source/CommonUI/Private/CommonNumericTextBlock.cpp:102

Scope (from outer to inner):

file
function     void UCommonNumericTextBlock::OnTimerTick

Source code excerpt:


	static const float MinimumUpdateInterval = 0.05f;
	const float UpdateRate = FMath::Max(InterpolationUpdateInterval, MinimumUpdateInterval);

	if (DeltaSeconds > UpdateRate)
	{
		// Leverage actual tick as time-delta-based workhorse function.
		Tick(DeltaSeconds);

		// Update tick time so future calls to TimerTick behave properly.
		LastTimerTickTime = CurrentTickTime;

#Loc: <Workspace>/Engine/Source/Runtime/AudioMixer/Private/AudioMixerSubmix.cpp:2211

Scope (from outer to inner):

file
namespace    Audio
function     void FMixerSubmix::AddSpectralAnalysisDelegate

Source code excerpt:

		NewDelegateInfo.LastUpdateTime = -1.0f;
		NewDelegateInfo.DelegateSettings = InDelegateSettings;
		NewDelegateInfo.DelegateSettings.UpdateRate = FMath::Clamp(NewDelegateInfo.DelegateSettings.UpdateRate, 1.0f, 30.0f);
		NewDelegateInfo.UpdateDelta = 1.0f / NewDelegateInfo.DelegateSettings.UpdateRate;

		NewDelegateInfo.OnSubmixSpectralAnalysis.AddUnique(OnSubmixSpectralAnalysisBP);

		{
			FScopeLock SpectrumAnalyzerLock(&SpectrumAnalyzerCriticalSection);

#Loc: <Workspace>/Engine/Source/Runtime/AudioMixer/Private/AudioMixerSubmix.cpp:2293

Scope (from outer to inner):

file
namespace    Audio
function     void FMixerSubmix::StartSpectrumAnalysis

Source code excerpt:


						FInlineEnvelopeFollowerInitParams EnvelopeFollowerInitParams;
						EnvelopeFollowerInitParams.SampleRate = DelegateInfo.DelegateSettings.UpdateRate;
						EnvelopeFollowerInitParams.AttackTimeMsec = static_cast<float>(BandSettings.AttackTimeMsec);
						EnvelopeFollowerInitParams.ReleaseTimeMsec = static_cast<float>(BandSettings.ReleaseTimeMsec);
						NewBand.EnvelopeFollower.Init(EnvelopeFollowerInitParams);
					
						DelegateInfo.SpectralBands.Add(NewBand);
					}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Engine/EngineTypes.h:2393

Scope: file

Source code excerpt:

	/** How often animation will be updated/ticked. 1 = every frame, 2 = every 2 frames, etc. */
	UPROPERTY()
	int32 UpdateRate;

	/** How often animation will be evaluated. 1 = every frame, 2 = every 2 frames, etc.
	 *  has to be a multiple of UpdateRate. */
	UPROPERTY()
	int32 EvaluationRate;

	/** Track time we have lost via skipping */
	UPROPERTY(Transient)
	float TickedPoseOffestTime;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Engine/EngineTypes.h:2461

Scope (from outer to inner):

file
function     FAnimUpdateRateParameters

Source code excerpt:

		, bSkipUpdate(false)
		, bSkipEvaluation(false)
		, UpdateRate(1)
		, EvaluationRate(1)
		, TickedPoseOffestTime(0.f)
		, AdditionalTime(0.f)
		, ThisTickDelta(0.f)
		, BaseNonRenderedUpdateRate(4)
		, MaxEvalRateForInterpolation(4)

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Engine/EngineTypes.h:2532

Scope (from outer to inner):

file
function     FColor GetUpdateRateDebugColor

Source code excerpt:

		if (OptimizeMode == TrailMode)
		{
			switch (UpdateRate)
			{
			case 1: return FColor::Red;
			case 2: return FColor::Green;
			case 3: return FColor::Blue;
			}
			return FColor::Black;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Sound/SoundSubmix.h:128

Scope: file

Source code excerpt:


	// Number of times a second the delegate is triggered. 
	float UpdateRate; 

	// The decibel level considered silence.
	float DecibelNoiseFloor; 

	// If true, returned values are scaled between 0 and 1.
	bool bDoNormalize;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Sound/SoundSubmix.h:414

Scope (from outer to inner):

file
class        class USoundSubmix : public USoundSubmixWithParentBase

Source code excerpt:

	 *	@param	InBandsettings					The frequency bands to analyze and their envelope-following settings.
	 *  @param  OnSubmixSpectralAnalysisBP		Event to fire when new spectral data is available.
	 *	@param	UpdateRate						How often to retrieve the data from the spectral analyzer and broadcast the event. Max is 30 times per second.
	 *	@param  InterpMethod                    Method to used for band peak calculation.
	 *	@param  SpectrumType                    Metric to use when returning spectrum values.
	 *	@param  DecibelNoiseFloor               Decibel Noise Floor to consider as silence when using a Decibel Spectrum Type.
	 *	@param  bDoNormalize                    If true, output band values will be normalized between zero and one.
	 *	@param  bDoAutoRange                    If true, output band values will have their ranges automatically adjusted to the minimum and maximum values in the audio. Output band values will be normalized between zero and one.
	 *	@param  AutoRangeAttackTime             The time (in seconds) it takes for the range to expand to 90% of a larger range.
	 *	@param  AutoRangeReleaseTime            The time (in seconds) it takes for the range to shrink to 90% of a smaller range.
	 */
	UFUNCTION(BlueprintCallable, Category = "Audio|Spectrum", meta = (WorldContext = "WorldContextObject", AdvancedDisplay = 3))
	ENGINE_API void AddSpectralAnalysisDelegate(const UObject* WorldContextObject, const TArray<FSoundSubmixSpectralAnalysisBandSettings>& InBandSettings, const FOnSubmixSpectralAnalysisBP& OnSubmixSpectralAnalysisBP, float UpdateRate = 10.f, float DecibelNoiseFloor=-40.f, bool bDoNormalize = true, bool bDoAutoRange = false, float AutoRangeAttackTime = 0.1f, float AutoRangeReleaseTime = 60.f);

	/**
	 *	Remove a spectral analysis delegate.
	 *  @param  OnSubmixSpectralAnalysisBP		The event delegate to remove.
	 */
	UFUNCTION(BlueprintCallable, Category = "Audio|Spectrum", meta = (WorldContext = "WorldContextObject"))
	ENGINE_API void RemoveSpectralAnalysisDelegate(const UObject* WorldContextObject, const FOnSubmixSpectralAnalysisBP& OnSubmixSpectralAnalysisBP);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Sound/SoundSubmix.h:459

Scope (from outer to inner):

file
class        class USoundSubmix : public USoundSubmixWithParentBase

Source code excerpt:

	static ENGINE_API FSoundSpectrumAnalyzerSettings GetSpectrumAnalyzerSettings(EFFTSize FFTSize, EFFTPeakInterpolationMethod InterpolationMethod, EFFTWindowType WindowType, float HopSize, EAudioSpectrumType SpectrumType);

	static ENGINE_API FSoundSpectrumAnalyzerDelegateSettings GetSpectrumAnalysisDelegateSettings(const TArray<FSoundSubmixSpectralAnalysisBandSettings>& InBandSettings, float UpdateRate, float DecibelNoiseFloor, bool bDoNormalize, bool bDoAutoRange, float AutoRangeAttackTime, float AutoRangeReleaseTime);
protected:

	ENGINE_API virtual void Serialize(FArchive& Ar) override;
	ENGINE_API virtual void PostLoad() override;

#if WITH_EDITOR

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimInstance.cpp:1034

Scope (from outer to inner):

file
function     void UAnimInstance::DisplayDebugInstance

Source code excerpt:

			{
				DebugText = FString::Printf(TEXT("URO Rate(%d) SkipUpdate(%d) SkipEval(%d) Interp(%d)"),
					UROParams->UpdateRate, UROParams->ShouldSkipUpdate(), UROParams->ShouldSkipEvaluation(),
					UROParams->ShouldInterpolateSkippedFrames());

				DisplayDebugManager.DrawString(DebugText, Indent);
			}
		}
	}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimInstanceProxy.cpp:765

Scope (from outer to inner):

file
function     void FAnimInstanceProxy::InitializeObjects

Source code excerpt:

		if(bDoUro)
		{
			NumUroSkippedFrames_Update = RateParams->UpdateRate - 1;

			const bool bDoEvalOptimization = RateParams->DoEvaluationRateOptimizations();
			if(bDoEvalOptimization)
			{
				NumUroSkippedFrames_Eval = RateParams->EvaluationRate - 1;
			}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Components/SkinnedMeshComponent.cpp:1382

Scope (from outer to inner):

file
function     void USkinnedMeshComponent::TickUpdateRate

Source code excerpt:


				FString DebugString = FString::Printf(TEXT("%s UpdateRate(%d) EvaluationRate(%d) ShouldInterpolateSkippedFrames(%d) ShouldSkipUpdate(%d) Interp Alpha (%f) AdditionalTime(%f)"),
					*GetNameSafe(GetSkinnedAsset()), AnimUpdateRateParams->UpdateRate, AnimUpdateRateParams->EvaluationRate,
					AnimUpdateRateParams->ShouldInterpolateSkippedFrames(), AnimUpdateRateParams->ShouldSkipUpdate(), AnimUpdateRateParams->GetInterpolationAlpha(), AnimUpdateRateParams->AdditionalTime);

				GEngine->AddOnScreenDebugMessage(INDEX_NONE, 0.f, FColor::Red, DebugString, false);
			}
#endif // ENABLE_DRAW_DEBUG
		}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Components/SkinnedMeshComponent.cpp:5085

Scope (from outer to inner):

file
function     void FAnimUpdateRateParameters::SetTrailMode

Source code excerpt:

	ThisTickDelta = DeltaTime;

	UpdateRate = FMath::Max(NewUpdateRate, 1);

	// Make sure EvaluationRate is a multiple of UpdateRate.
	EvaluationRate = FMath::Max((NewEvaluationRate / UpdateRate) * UpdateRate, 1);
	bInterpolateSkippedFrames = (FAnimUpdateRateManager::CVarURODisableInterpolation.GetValueOnAnyThread() == 0) &&
		((bNewInterpSkippedFrames && (EvaluationRate < MaxEvalRateForInterpolation)) || (FAnimUpdateRateManager::CVarForceInterpolation.GetValueOnAnyThread() == 1));

	// Make sure we don't overflow. we don't need very large numbers.
	const uint32 Counter = (GFrameCounter + UpdateRateShift) % MAX_uint32;

	bSkipUpdate = ((Counter % UpdateRate) > 0);
	bSkipEvaluation = ((Counter % EvaluationRate) > 0);

	// As UpdateRate changes, because of LODs for example,
	// make sure we're not caught in a loop where we don't update longer than our update rate.
	{
		SkippedUpdateFrames = bSkipUpdate ? ++SkippedUpdateFrames : 0;
		SkippedEvalFrames = bSkipEvaluation ? ++SkippedEvalFrames : 0;

		// If we've gone longer that our UpdateRate, force an update to happen.
		if ((SkippedUpdateFrames >= UpdateRate) || (SkippedEvalFrames >= EvaluationRate))
		{
			bSkipUpdate = false;
			bSkipEvaluation = false;
			SkippedUpdateFrames = 0;
			SkippedEvalFrames = 0;
		}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/SoundSubmix.cpp:277

Scope (from outer to inner):

file
function     void USoundSubmix::AddSpectralAnalysisDelegate

Source code excerpt:

}

void USoundSubmix::AddSpectralAnalysisDelegate(const UObject* WorldContextObject, const TArray<FSoundSubmixSpectralAnalysisBandSettings>& InBandSettings, const FOnSubmixSpectralAnalysisBP& OnSubmixSpectralAnalysisBP, float UpdateRate,  float DecibelNoiseFloor, bool bDoNormalize, bool bDoAutoRange, float AutoRangeAttackTime, float AutoRangeReleaseTime)
{

	if (!GEngine)
	{
		return;
	}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/SoundSubmix.cpp:290

Scope (from outer to inner):

file
function     void USoundSubmix::AddSpectralAnalysisDelegate

Source code excerpt:

		if (FAudioDevice* AudioDevice = ThisWorld->GetAudioDeviceRaw())
		{
			FSoundSpectrumAnalyzerDelegateSettings DelegateSettings = USoundSubmix::GetSpectrumAnalysisDelegateSettings(InBandSettings, UpdateRate, DecibelNoiseFloor, bDoNormalize, bDoAutoRange, AutoRangeAttackTime, AutoRangeReleaseTime);


			AudioDevice->AddSpectralAnalysisDelegate(this, DelegateSettings, OnSubmixSpectralAnalysisBP);
		}
	}
}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/SoundSubmix.cpp:1221

Scope (from outer to inner):

file
function     FSoundSpectrumAnalyzerDelegateSettings USoundSubmix::GetSpectrumAnalysisDelegateSettings

Source code excerpt:

}

FSoundSpectrumAnalyzerDelegateSettings USoundSubmix::GetSpectrumAnalysisDelegateSettings(const TArray<FSoundSubmixSpectralAnalysisBandSettings>& InBandSettings, float UpdateRate, float DecibelNoiseFloor, bool bDoNormalize, bool bDoAutoRange, float AutoRangeAttackTime, float AutoRangeReleaseTime)
{
	FSoundSpectrumAnalyzerDelegateSettings DelegateSettings;

	DelegateSettings.BandSettings = InBandSettings;
	DelegateSettings.UpdateRate = UpdateRate;
	DelegateSettings.DecibelNoiseFloor = DecibelNoiseFloor;
	DelegateSettings.bDoNormalize = bDoNormalize;
	DelegateSettings.bDoAutoRange = bDoAutoRange;
	DelegateSettings.AutoRangeAttackTime = AutoRangeAttackTime;
	DelegateSettings.AutoRangeReleaseTime = AutoRangeReleaseTime;