Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-08-09 08:49:05 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge pull request #6581 from kencooke/audio-reverb

Browse source 
New reverb parameters
This commit is contained in:
Philip Rosedale 2015-12-08 14:59:58 -08:00
commit bda4e41958
4 changed files with 277 additions and 160 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

60
examples/utilities/tools/reverbTest.js
View file

@ -12,31 +12,57 @@
Script.include("cookies.js"); Script.include("cookies.js");
var audioOptions = new AudioEffectOptions({ var audioOptions = new AudioEffectOptions({
maxRoomSize: 50, bandwidth: 10000,
preDelay: 20,
lateDelay: 0,
reverbTime: 2,
earlyDiffusion: 100,
lateDiffusion: 100,
roomSize: 50, roomSize: 50,
reverbTime: 4, density: 100,
damping: 0.50, bassMult: 1.5,
inputBandwidth: 0.8, bassFreq: 250,
earlyLevel: 0, highGain: -6,
tailLevel: 0, highFreq: 3000,
dryLevel: -6, modRate: 2.3,
wetLevel: -6 modDepth: 50,
earlyGain: 0,
lateGain: 0,
earlyMixLeft: 20,
earlyMixRight: 20,
lateMixLeft: 90,
lateMixRight: 90,
wetDryMix: 50,
}); });
AudioDevice.setReverbOptions(audioOptions); AudioDevice.setReverbOptions(audioOptions);
AudioDevice.setReverb(true); AudioDevice.setReverb(true);
print("Reverb is ON."); print("Reverb is ON.");
var panel = new Panel(10, 200); var panel = new Panel(10, 160);
var parameters = [ var parameters = [
{ name: "roomSize", min: 0, max: 100, units: " feet" }, { name: "bandwidth", min: 1000, max: 12000, units: " Hz" },
{ name: "reverbTime", min: 0, max: 10, units: " sec" }, { name: "preDelay", min: 0, max: 333, units: " ms" },
{ name: "damping", min: 0, max: 1, units: " " }, { name: "lateDelay", min: 0, max: 166, units: " ms" },
{ name: "inputBandwidth", min: 0, max: 1, units: " " }, { name: "reverbTime", min: 0.1, max: 10, units: " seconds" },
{ name: "earlyLevel", min: -48, max: 0, units: " dB" }, { name: "earlyDiffusion", min: 0, max: 100, units: " percent" },
{ name: "tailLevel", min: -48, max: 0, units: " dB" }, { name: "lateDiffusion", min: 0, max: 100, units: " percent" },
{ name: "wetLevel", min: -48, max: 0, units: " dB" }, { name: "roomSize", min: 0, max: 100, units: " percent" },
{ name: "density", min: 0, max: 100, units: " percent" },
{ name: "bassMult", min: 0.1, max: 4, units: " ratio" },
{ name: "bassFreq", min: 10, max: 500, units: " Hz" },
{ name: "highGain", min: -24, max: 0, units: " dB" },
{ name: "highFreq", min: 1000, max: 12000, units: " Hz" },
{ name: "modRate", min: 0.1, max: 10, units: " Hz" },
{ name: "modDepth", min: 0, max: 100, units: " percent" },
{ name: "earlyGain", min: -96, max: 24, units: " dB" },
{ name: "lateGain", min: -96, max: 24, units: " dB" },
{ name: "earlyMixLeft", min: 0, max: 100, units: " percent" },
{ name: "earlyMixRight", min: 0, max: 100, units: " percent" },
{ name: "lateMixLeft", min: 0, max: 100, units: " percent" },
{ name: "lateMixRight", min: 0, max: 100, units: " percent" },
{ name: "wetDryMix", min: 0, max: 100, units: " percent" },
] ]
function setter(name) { function setter(name) {
@ -48,7 +74,7 @@ function getter(name) {
} }
function displayer(units) { function displayer(units) {
return function(value) { return (value).toFixed(1) + units; }; return function(value) { return (value).toFixed(1) + units; }
} }
// create a slider for each parameter // create a slider for each parameter

74
libraries/audio-client/src/AudioClient.cpp
View file

@ -541,26 +541,40 @@ bool AudioClient::switchOutputToAudioDevice(const QString& outputDeviceName) {
void AudioClient::configureReverb() { void AudioClient::configureReverb() {
ReverbParameters p; ReverbParameters p;
_listenerReverb.getParameters(&p);
// for now, reuse the gverb parameters
p.sampleRate = _outputFormat.sampleRate(); p.sampleRate = _outputFormat.sampleRate();
p.roomSize = _reverbOptions->getRoomSize();
p.bandwidth = _reverbOptions->getBandwidth();
p.preDelay = _reverbOptions->getPreDelay();
p.lateDelay = _reverbOptions->getLateDelay();
p.reverbTime = _reverbOptions->getReverbTime(); p.reverbTime = _reverbOptions->getReverbTime();
p.highGain = -24.0f * (1.0f - _reverbOptions->getDamping()); p.earlyDiffusion = _reverbOptions->getEarlyDiffusion();
p.bandwidth = 10000.0f * _reverbOptions->getInputBandwidth(); p.lateDiffusion = _reverbOptions->getLateDiffusion();
p.earlyGain = _reverbOptions->getEarlyLevel(); p.roomSize = _reverbOptions->getRoomSize();
p.lateGain = _reverbOptions->getTailLevel(); p.density = _reverbOptions->getDensity();
p.wetDryMix = 100.0f * powf(10.0f, _reverbOptions->getWetLevel() * (1/20.0f)); p.bassMult = _reverbOptions->getBassMult();
p.bassFreq = _reverbOptions->getBassFreq();
p.highGain = _reverbOptions->getHighGain();
p.highFreq = _reverbOptions->getHighFreq();
p.modRate = _reverbOptions->getModRate();
p.modDepth = _reverbOptions->getModDepth();
p.earlyGain = _reverbOptions->getEarlyGain();
p.lateGain = _reverbOptions->getLateGain();
p.earlyMixLeft = _reverbOptions->getEarlyMixLeft();
p.earlyMixRight = _reverbOptions->getEarlyMixRight();
p.lateMixLeft = _reverbOptions->getLateMixLeft();
p.lateMixRight = _reverbOptions->getLateMixRight();
p.wetDryMix = _reverbOptions->getWetDryMix();
_listenerReverb.setParameters(&p); _listenerReverb.setParameters(&p);
// used for adding self-reverb to loopback audio // used only for adding self-reverb to loopback audio
p.wetDryMix = 100.0f; p.wetDryMix = 100.0f;
p.preDelay = 0.0f; p.preDelay = 0.0f;
p.earlyGain = -96.0f; // disable ER p.earlyGain = -96.0f; // disable ER
p.lateGain -= 12.0f; // quieter than listener reverb p.lateGain -= 12.0f; // quieter than listener reverb
p.lateMixLeft = 0.0f; p.lateMixLeft = 0.0f;
p.lateMixRight = 0.0f; p.lateMixRight = 0.0f;
_sourceReverb.setParameters(&p); _sourceReverb.setParameters(&p);
} }
@ -572,10 +586,10 @@ void AudioClient::updateReverbOptions() {
_zoneReverbOptions.setReverbTime(_receivedAudioStream.getRevebTime()); _zoneReverbOptions.setReverbTime(_receivedAudioStream.getRevebTime());
reverbChanged = true; reverbChanged = true;
} }
if (_zoneReverbOptions.getWetLevel() != _receivedAudioStream.getWetLevel()) { //if (_zoneReverbOptions.getWetLevel() != _receivedAudioStream.getWetLevel()) {
_zoneReverbOptions.setWetLevel(_receivedAudioStream.getWetLevel()); // _zoneReverbOptions.setWetLevel(_receivedAudioStream.getWetLevel());
reverbChanged = true; // reverbChanged = true;
} //}
if (_reverbOptions != &_zoneReverbOptions) { if (_reverbOptions != &_zoneReverbOptions) {
_reverbOptions = &_zoneReverbOptions; _reverbOptions = &_zoneReverbOptions;
@ -602,17 +616,27 @@ void AudioClient::setReverb(bool reverb) {
void AudioClient::setReverbOptions(const AudioEffectOptions* options) { void AudioClient::setReverbOptions(const AudioEffectOptions* options) {
// Save the new options // Save the new options
_scriptReverbOptions.setMaxRoomSize(options->getMaxRoomSize()); _scriptReverbOptions.setBandwidth(options->getBandwidth());
_scriptReverbOptions.setRoomSize(options->getRoomSize()); _scriptReverbOptions.setPreDelay(options->getPreDelay());
_scriptReverbOptions.setLateDelay(options->getLateDelay());
_scriptReverbOptions.setReverbTime(options->getReverbTime()); _scriptReverbOptions.setReverbTime(options->getReverbTime());
_scriptReverbOptions.setDamping(options->getDamping()); _scriptReverbOptions.setEarlyDiffusion(options->getEarlyDiffusion());
_scriptReverbOptions.setSpread(options->getSpread()); _scriptReverbOptions.setLateDiffusion(options->getLateDiffusion());
_scriptReverbOptions.setInputBandwidth(options->getInputBandwidth()); _scriptReverbOptions.setRoomSize(options->getRoomSize());
_scriptReverbOptions.setEarlyLevel(options->getEarlyLevel()); _scriptReverbOptions.setDensity(options->getDensity());
_scriptReverbOptions.setTailLevel(options->getTailLevel()); _scriptReverbOptions.setBassMult(options->getBassMult());
_scriptReverbOptions.setBassFreq(options->getBassFreq());
_scriptReverbOptions.setDryLevel(options->getDryLevel()); _scriptReverbOptions.setHighGain(options->getHighGain());
_scriptReverbOptions.setWetLevel(options->getWetLevel()); _scriptReverbOptions.setHighFreq(options->getHighFreq());
_scriptReverbOptions.setModRate(options->getModRate());
_scriptReverbOptions.setModDepth(options->getModDepth());
_scriptReverbOptions.setEarlyGain(options->getEarlyGain());
_scriptReverbOptions.setLateGain(options->getLateGain());
_scriptReverbOptions.setEarlyMixLeft(options->getEarlyMixLeft());
_scriptReverbOptions.setEarlyMixRight(options->getEarlyMixRight());
_scriptReverbOptions.setLateMixLeft(options->getLateMixLeft());
_scriptReverbOptions.setLateMixRight(options->getLateMixRight());
_scriptReverbOptions.setWetDryMix(options->getWetDryMix());
if (_reverbOptions == &_scriptReverbOptions) { if (_reverbOptions == &_scriptReverbOptions) {
// Apply them to the reverb instances // Apply them to the reverb instances

149
libraries/audio/src/AudioEffectOptions.cpp
View file

@ -10,58 +10,76 @@
#include "AudioEffectOptions.h" #include "AudioEffectOptions.h"
static const QString MAX_ROOM_SIZE_HANDLE = "maxRoomSize"; static const QString BANDWIDTH_HANDLE = "bandwidth";
static const QString ROOM_SIZE_HANDLE = "roomSize"; static const QString PRE_DELAY_HANDLE = "preDelay";
static const QString LATE_DELAY_HANDLE = "lateDelay";
static const QString REVERB_TIME_HANDLE = "reverbTime"; static const QString REVERB_TIME_HANDLE = "reverbTime";
static const QString DAMPIMG_HANDLE = "damping"; static const QString EARLY_DIFFUSION_HANDLE = "earlyDiffusion";
static const QString SPREAD_HANDLE = "spread"; static const QString LATE_DIFFUSION_HANDLE = "lateDiffusion";
static const QString INPUT_BANDWIDTH_HANDLE = "inputBandwidth"; static const QString ROOM_SIZE_HANDLE = "roomSize";
static const QString EARLY_LEVEL_HANDLE = "earlyLevel"; static const QString DENSITY_HANDLE = "density";
static const QString TAIL_LEVEL_HANDLE = "tailLevel"; static const QString BASS_MULT_HANDLE = "bassMult";
static const QString DRY_LEVEL_HANDLE = "dryLevel"; static const QString BASS_FREQ_HANDLE = "bassFreq";
static const QString WET_LEVEL_HANDLE = "wetLevel"; static const QString HIGH_GAIN_HANDLE = "highGain";
static const QString HIGH_FREQ_HANDLE = "highFreq";
static const QString MOD_RATE_HANDLE = "modRate";
static const QString MOD_DEPTH_HANDLE = "modDepth";
static const QString EARLY_GAIN_HANDLE = "earlyGain";
static const QString LATE_GAIN_HANDLE = "lateGain";
static const QString EARLY_MIX_LEFT_HANDLE = "earlyMixLeft";
static const QString EARLY_MIX_RIGHT_HANDLE = "earlyMixRight";
static const QString LATE_MIX_LEFT_HANDLE = "lateMixLeft";
static const QString LATE_MIX_RIGHT_HANDLE = "lateMixRight";
static const QString WET_DRY_MIX_HANDLE = "wetDryMix";
AudioEffectOptions::AudioEffectOptions(QScriptValue arguments) : static const float BANDWIDTH_DEFAULT = 10000.0f;
_maxRoomSize(50.0f), static const float PRE_DELAY_DEFAULT = 20.0f;
_roomSize(50.0f), static const float LATE_DELAY_DEFAULT = 0.0f;
_reverbTime(4.0f), static const float REVERB_TIME_DEFAULT = 2.0f;
_damping(0.5f), static const float EARLY_DIFFUSION_DEFAULT = 100.0f;
_spread(15.0f), static const float LATE_DIFFUSION_DEFAULT = 100.0f;
_inputBandwidth(0.75f), static const float ROOM_SIZE_DEFAULT = 50.0f;
_earlyLevel(-12.0f), static const float DENSITY_DEFAULT = 100.0f;
_tailLevel(-18.0f), static const float BASS_MULT_DEFAULT = 1.5f;
_dryLevel(0.0f), static const float BASS_FREQ_DEFAULT = 250.0f;
_wetLevel(0.0f) { static const float HIGH_GAIN_DEFAULT = -6.0f;
if (arguments.property(MAX_ROOM_SIZE_HANDLE).isNumber()) { static const float HIGH_FREQ_DEFAULT = 3000.0f;
_maxRoomSize = arguments.property(MAX_ROOM_SIZE_HANDLE).toNumber(); static const float MOD_RATE_DEFAULT = 2.3f;
} static const float MOD_DEPTH_DEFAULT = 50.0f;
if (arguments.property(ROOM_SIZE_HANDLE).isNumber()) { static const float EARLY_GAIN_DEFAULT = 0.0f;
_roomSize = arguments.property(ROOM_SIZE_HANDLE).toNumber(); static const float LATE_GAIN_DEFAULT = 0.0f;
} static const float EARLY_MIX_LEFT_DEFAULT = 20.0f;
if (arguments.property(REVERB_TIME_HANDLE).isNumber()) { static const float EARLY_MIX_RIGHT_DEFAULT = 20.0f;
_reverbTime = arguments.property(REVERB_TIME_HANDLE).toNumber(); static const float LATE_MIX_LEFT_DEFAULT = 90.0f;
} static const float LATE_MIX_RIGHT_DEFAULT = 90.0f;
if (arguments.property(DAMPIMG_HANDLE).isNumber()) { static const float WET_DRY_MIX_DEFAULT = 50.0f;
_damping = arguments.property(DAMPIMG_HANDLE).toNumber();
} static void setOption(QScriptValue arguments, const QString name, float defaultValue, float& variable) {
if (arguments.property(SPREAD_HANDLE).isNumber()) { variable = arguments.property(name).isNumber() ? arguments.property(name).toNumber() : defaultValue;
_spread = arguments.property(SPREAD_HANDLE).toNumber(); }
}
if (arguments.property(INPUT_BANDWIDTH_HANDLE).isNumber()) { AudioEffectOptions::AudioEffectOptions(QScriptValue arguments) {
_inputBandwidth = arguments.property(INPUT_BANDWIDTH_HANDLE).toNumber(); setOption(arguments, BANDWIDTH_HANDLE, BANDWIDTH_DEFAULT, _bandwidth);
} setOption(arguments, PRE_DELAY_HANDLE, PRE_DELAY_DEFAULT, _preDelay);
if (arguments.property(EARLY_LEVEL_HANDLE).isNumber()) { setOption(arguments, LATE_DELAY_HANDLE, LATE_DELAY_DEFAULT, _lateDelay);
_earlyLevel = arguments.property(EARLY_LEVEL_HANDLE).toNumber(); setOption(arguments, REVERB_TIME_HANDLE, REVERB_TIME_DEFAULT, _reverbTime);
} setOption(arguments, EARLY_DIFFUSION_HANDLE, EARLY_DIFFUSION_DEFAULT, _earlyDiffusion);
if (arguments.property(TAIL_LEVEL_HANDLE).isNumber()) { setOption(arguments, LATE_DIFFUSION_HANDLE, LATE_DIFFUSION_DEFAULT, _lateDiffusion);
_tailLevel = arguments.property(TAIL_LEVEL_HANDLE).toNumber(); setOption(arguments, ROOM_SIZE_HANDLE, ROOM_SIZE_DEFAULT, _roomSize);
} setOption(arguments, DENSITY_HANDLE, DENSITY_DEFAULT, _density);
if (arguments.property(DRY_LEVEL_HANDLE).isNumber()) { setOption(arguments, BASS_MULT_HANDLE, BASS_MULT_DEFAULT, _bassMult);
_dryLevel = arguments.property(DRY_LEVEL_HANDLE).toNumber(); setOption(arguments, BASS_FREQ_HANDLE, BASS_FREQ_DEFAULT, _bassFreq);
} setOption(arguments, HIGH_GAIN_HANDLE, HIGH_GAIN_DEFAULT, _highGain);
if (arguments.property(WET_LEVEL_HANDLE).isNumber()) { setOption(arguments, HIGH_FREQ_HANDLE, HIGH_FREQ_DEFAULT, _highFreq);
_wetLevel = arguments.property(WET_LEVEL_HANDLE).toNumber(); setOption(arguments, MOD_RATE_HANDLE, MOD_RATE_DEFAULT, _modRate);
} setOption(arguments, MOD_DEPTH_HANDLE, MOD_DEPTH_DEFAULT, _modDepth);
setOption(arguments, EARLY_GAIN_HANDLE, EARLY_GAIN_DEFAULT, _earlyGain);
setOption(arguments, LATE_GAIN_HANDLE, LATE_GAIN_DEFAULT, _lateGain);
setOption(arguments, EARLY_MIX_LEFT_HANDLE, EARLY_MIX_LEFT_DEFAULT, _earlyMixLeft);
setOption(arguments, EARLY_MIX_RIGHT_HANDLE, EARLY_MIX_RIGHT_DEFAULT, _earlyMixRight);
setOption(arguments, LATE_MIX_LEFT_HANDLE, LATE_MIX_LEFT_DEFAULT, _lateMixLeft);
setOption(arguments, LATE_MIX_RIGHT_HANDLE, LATE_MIX_RIGHT_DEFAULT, _lateMixRight);
setOption(arguments, WET_DRY_MIX_HANDLE, WET_DRY_MIX_DEFAULT, _wetDryMix);
} }
AudioEffectOptions::AudioEffectOptions(const AudioEffectOptions &other) : QObject() { AudioEffectOptions::AudioEffectOptions(const AudioEffectOptions &other) : QObject() {
@ -69,17 +87,28 @@ AudioEffectOptions::AudioEffectOptions(const AudioEffectOptions &other) : QObjec
} }
AudioEffectOptions& AudioEffectOptions::operator=(const AudioEffectOptions &other) { AudioEffectOptions& AudioEffectOptions::operator=(const AudioEffectOptions &other) {
_maxRoomSize = other._maxRoomSize; _bandwidth = other._bandwidth;
_roomSize = other._roomSize; _preDelay = other._preDelay;
_lateDelay = other._lateDelay;
_reverbTime = other._reverbTime; _reverbTime = other._reverbTime;
_damping = other._damping; _earlyDiffusion = other._earlyDiffusion;
_spread = other._spread; _lateDiffusion = other._lateDiffusion;
_inputBandwidth = other._inputBandwidth; _roomSize = other._roomSize;
_earlyLevel = other._earlyLevel; _density = other._density;
_tailLevel = other._tailLevel; _bassMult = other._bassMult;
_dryLevel = other._dryLevel; _bassFreq = other._bassFreq;
_wetLevel = other._wetLevel; _highGain = other._highGain;
_highFreq = other._highFreq;
_modRate = other._modRate;
_modDepth = other._modDepth;
_earlyGain = other._earlyGain;
_lateGain = other._lateGain;
_earlyMixLeft = other._earlyMixLeft;
_earlyMixRight = other._earlyMixRight;
_lateMixLeft = other._lateMixLeft;
_lateMixRight = other._lateMixRight;
_wetDryMix = other._wetDryMix;
return *this; return *this;
} }

154
libraries/audio/src/AudioEffectOptions.h
View file

@ -15,32 +15,30 @@
#include <QtScript/QScriptContext> #include <QtScript/QScriptContext>
#include <QtScript/QScriptEngine> #include <QtScript/QScriptEngine>
#include "AudioReverb.h"
class AudioEffectOptions : public QObject { class AudioEffectOptions : public QObject {
Q_OBJECT Q_OBJECT
// Meters Square Q_PROPERTY(float bandwidth READ getBandwidth WRITE setBandwidth)
Q_PROPERTY(float maxRoomSize READ getMaxRoomSize WRITE setMaxRoomSize) Q_PROPERTY(float preDelay READ getPreDelay WRITE setPreDelay)
Q_PROPERTY(float roomSize READ getRoomSize WRITE setRoomSize) Q_PROPERTY(float lateDelay READ getLateDelay WRITE setLateDelay)
// Seconds
Q_PROPERTY(float reverbTime READ getReverbTime WRITE setReverbTime) Q_PROPERTY(float reverbTime READ getReverbTime WRITE setReverbTime)
Q_PROPERTY(float earlyDiffusion READ getEarlyDiffusion WRITE setEarlyDiffusion)
// Ratio between 0 and 1 Q_PROPERTY(float lateDiffusion READ getLateDiffusion WRITE setLateDiffusion)
Q_PROPERTY(float damping READ getDamping WRITE setDamping) Q_PROPERTY(float roomSize READ getRoomSize WRITE setRoomSize)
Q_PROPERTY(float density READ getDensity WRITE setDensity)
// (?) Does not appear to be set externally very often Q_PROPERTY(float bassMult READ getBassMult WRITE setBassMult)
Q_PROPERTY(float spread READ getSpread WRITE setSpread) Q_PROPERTY(float bassFreq READ getBassFreq WRITE setBassFreq)
Q_PROPERTY(float highGain READ getHighGain WRITE setHighGain)
// Ratio between 0 and 1 Q_PROPERTY(float highFreq READ getHighFreq WRITE setHighFreq)
Q_PROPERTY(float inputBandwidth READ getInputBandwidth WRITE setInputBandwidth) Q_PROPERTY(float modRate READ getModRate WRITE setModRate)
Q_PROPERTY(float modDepth READ getModDepth WRITE setModDepth)
// in dB Q_PROPERTY(float earlyGain READ getEarlyGain WRITE setEarlyGain)
Q_PROPERTY(float earlyLevel READ getEarlyLevel WRITE setEarlyLevel) Q_PROPERTY(float lateGain READ getLateGain WRITE setLateGain)
Q_PROPERTY(float tailLevel READ getTailLevel WRITE setTailLevel) Q_PROPERTY(float earlyMixLeft READ getEarlyMixLeft WRITE setEarlyMixLeft)
Q_PROPERTY(float dryLevel READ getDryLevel WRITE setDryLevel) Q_PROPERTY(float earlyMixRight READ getEarlyMixRight WRITE setEarlyMixRight)
Q_PROPERTY(float wetLevel READ getWetLevel WRITE setWetLevel) Q_PROPERTY(float lateMixLeft READ getLateMixLeft WRITE setLateMixLeft)
Q_PROPERTY(float lateMixRight READ getLateMixRight WRITE setLateMixRight)
Q_PROPERTY(float wetDryMix READ getWetDryMix WRITE setWetDryMix)
public: public:
AudioEffectOptions(QScriptValue arguments = QScriptValue()); AudioEffectOptions(QScriptValue arguments = QScriptValue());
@ -49,60 +47,100 @@ public:
static QScriptValue constructor(QScriptContext* context, QScriptEngine* engine); static QScriptValue constructor(QScriptContext* context, QScriptEngine* engine);
float getRoomSize() const { return _roomSize; } float getBandwidth() const { return _bandwidth; }
void setRoomSize(float roomSize ) { _roomSize = roomSize; } void setBandwidth(float bandwidth) { _bandwidth = bandwidth; }
float getMaxRoomSize() const { return _maxRoomSize; } float getPreDelay() const { return _preDelay; }
void setMaxRoomSize(float maxRoomSize ) { _maxRoomSize = maxRoomSize; } void setPreDelay(float preDelay) { _preDelay = preDelay; }
float getLateDelay() const { return _lateDelay; }
void setLateDelay(float lateDelay) { _lateDelay = lateDelay; }
float getReverbTime() const { return _reverbTime; } float getReverbTime() const { return _reverbTime; }
void setReverbTime(float reverbTime ) { _reverbTime = reverbTime; } void setReverbTime(float reverbTime) { _reverbTime = reverbTime; }
float getDamping() const { return _damping; } float getEarlyDiffusion() const { return _earlyDiffusion; }
void setDamping(float damping ) { _damping = damping; } void setEarlyDiffusion(float earlyDiffusion) { _earlyDiffusion = earlyDiffusion; }
float getSpread() const { return _spread; } float getLateDiffusion() const { return _lateDiffusion; }
void setSpread(float spread ) { _spread = spread; } void setLateDiffusion(float lateDiffusion) { _lateDiffusion = lateDiffusion; }
float getInputBandwidth() const { return _inputBandwidth; } float getRoomSize() const { return _roomSize; }
void setInputBandwidth(float inputBandwidth ) { _inputBandwidth = inputBandwidth; } void setRoomSize(float roomSize) { _roomSize = roomSize; }
float getEarlyLevel() const { return _earlyLevel; } float getDensity() const { return _density; }
void setEarlyLevel(float earlyLevel ) { _earlyLevel = earlyLevel; } void setDensity(float density) { _density = density; }
float getTailLevel() const { return _tailLevel; } float getBassMult() const { return _bassMult; }
void setTailLevel(float tailLevel ) { _tailLevel = tailLevel; } void setBassMult(float bassMult) { _bassMult = bassMult; }
float getDryLevel() const { return _dryLevel; } float getBassFreq() const { return _bassFreq; }
void setDryLevel(float dryLevel) { _dryLevel = dryLevel; } void setBassFreq(float bassFreq) { _bassFreq = bassFreq; }
float getWetLevel() const { return _wetLevel; } float getHighGain() const { return _highGain; }
void setWetLevel(float wetLevel) { _wetLevel = wetLevel; } void setHighGain(float highGain) { _highGain = highGain; }
float getHighFreq() const { return _highFreq; }
void setHighFreq(float highFreq) { _highFreq = highFreq; }
float getModRate() const { return _modRate; }
void setModRate(float modRate) { _modRate = modRate; }
float getModDepth() const { return _modDepth; }
void setModDepth(float modDepth) { _modDepth = modDepth; }
float getEarlyGain() const { return _earlyGain; }
void setEarlyGain(float earlyGain) { _earlyGain = earlyGain; }
float getLateGain() const { return _lateGain; }
void setLateGain(float lateGain) { _lateGain = lateGain; }
float getEarlyMixLeft() const { return _earlyMixLeft; }
void setEarlyMixLeft(float earlyMixLeft) { _earlyMixLeft = earlyMixLeft; }
float getEarlyMixRight() const { return _earlyMixRight; }
void setEarlyMixRight(float earlyMixRight) { _earlyMixRight = earlyMixRight; }
float getLateMixLeft() const { return _lateMixLeft; }
void setLateMixLeft(float lateMixLeft) { _lateMixLeft = lateMixLeft; }
float getLateMixRight() const { return _lateMixRight; }
void setLateMixRight(float lateMixRight) { _lateMixRight = lateMixRight; }
float getWetDryMix() const { return _wetDryMix; }
void setWetDryMix(float wetDryMix) { _wetDryMix = wetDryMix; }
private: private:
// http://wiki.audacityteam.org/wiki/GVerb#Instant_Reverberb_settings float _bandwidth; // [20, 24000] Hz
// Meters Square float _preDelay; // [0, 333] ms
float _maxRoomSize; float _lateDelay; // [0, 166] ms
float _roomSize;
// Seconds float _reverbTime; // [0.1, 100] seconds
float _reverbTime;
// Ratio between 0 and 1 float _earlyDiffusion; // [0, 100] percent
float _damping; float _lateDiffusion; // [0, 100] percent
// ? (Does not appear to be set externally very often) float _roomSize; // [0, 100] percent
float _spread; float _density; // [0, 100] percent
// Ratio between 0 and 1 float _bassMult; // [0.1, 10] ratio
float _inputBandwidth; float _bassFreq; // [10, 500] Hz
float _highGain; // [-24, 0] dB
float _highFreq; // [1000, 12000] Hz
// dB float _modRate; // [0.1, 10] Hz
float _earlyLevel; float _modDepth; // [0, 100] percent
float _tailLevel;
float _dryLevel; float _earlyGain; // [-96, +24] dB
float _wetLevel; float _lateGain; // [-96, +24] dB
float _earlyMixLeft; // [0, 100] percent
float _earlyMixRight; // [0, 100] percent
float _lateMixLeft; // [0, 100] percent
float _lateMixRight; // [0, 100] percent
float _wetDryMix; // [0, 100] percent
}; };
#endif // hifi_AudioEffectOptions_h #endif // hifi_AudioEffectOptions_h