Backups/ViPERFX_RE
1
0
Fork 0
mirror of https://github.com/AndroidAudioMods/ViPERFX_RE.git synced 2025-06-08 02:29:40 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Reformatted code

Browse Source 
Indentated with 4 spaces
This commit is contained in:
Iscle 2022-08-23 00:26:44 +02:00
parent 7912b7deec
commit 926aec54bb
61 changed files with 703 additions and 518 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/cpp/Effect.cpp
View File

@ -43,12 +43,12 @@ int32_t Effect::process(audio_buffer_s *in, audio_buffer_s *out) {
} }
int32_t Effect::command(uint32_t cmdCode, uint32_t cmdSize, void *pCmdData, uint32_t *replySize, void *pReplyData) { int32_t Effect::command(uint32_t cmdCode, uint32_t cmdSize, void *pCmdData, uint32_t *replySize, void *pReplyData) {
switch(cmdCode) { switch (cmdCode) {
case EFFECT_CMD_INIT: case EFFECT_CMD_INIT:
case EFFECT_CMD_SET_CONFIG: case EFFECT_CMD_SET_CONFIG:
case EFFECT_CMD_SET_PARAM: case EFFECT_CMD_SET_PARAM:
case EFFECT_CMD_SET_PARAM_COMMIT: case EFFECT_CMD_SET_PARAM_COMMIT:
*((int*)pReplyData) = 0; *((int *) pReplyData) = 0;
case EFFECT_CMD_RESET: case EFFECT_CMD_RESET:
case EFFECT_CMD_SET_PARAM_DEFERRED: case EFFECT_CMD_SET_PARAM_DEFERRED:
case EFFECT_CMD_SET_DEVICE: case EFFECT_CMD_SET_DEVICE:
@ -58,7 +58,7 @@ int32_t Effect::command(uint32_t cmdCode, uint32_t cmdSize, void *pCmdData, uint
case EFFECT_CMD_SET_AUDIO_SOURCE: case EFFECT_CMD_SET_AUDIO_SOURCE:
break; break;
case EFFECT_CMD_SET_CONFIG_REVERSE: case EFFECT_CMD_SET_CONFIG_REVERSE:
*((int*)pReplyData) = -EINVAL; *((int *) pReplyData) = -EINVAL;
default: default:
return -EINVAL; return -EINVAL;
case EFFECT_CMD_GET_CONFIG: case EFFECT_CMD_GET_CONFIG:
@ -77,9 +77,10 @@ return -EINVAL
int32_t Effect::configure(effect_config_t *newConfig) { int32_t Effect::configure(effect_config_t *newConfig) {
v4a_print(ANDROID_LOG_INFO, "Begin audio configure ..."); v4a_print(ANDROID_LOG_INFO, "Begin audio configure ...");
v4a_print(ANDROID_LOG_INFO, "Checking input and output configuration ..."); v4a_print(ANDROID_LOG_INFO, "Checking input and output configuration ...");
if (newConfig->inputCfg.samplingRate != newConfig->outputCfg.samplingRate) { if (newConfig->inputCfg.samplingRate != newConfig->outputCfg.samplingRate) {
v4a_printf(ANDROID_LOG_ERROR, "ViPER4Android disabled, reason [in.SR = %d, out.SR = %d]", newConfig->inputCfg.samplingRate, newConfig->outputCfg.samplingRate); v4a_printf(ANDROID_LOG_ERROR, "ViPER4Android disabled, reason [in.SR = %d, out.SR = %d]",
newConfig->inputCfg.samplingRate, newConfig->outputCfg.samplingRate);
DO_ERROR(); DO_ERROR();
} }
@ -89,7 +90,8 @@ int32_t Effect::configure(effect_config_t *newConfig) {
} }
if (newConfig->inputCfg.channels != newConfig->outputCfg.channels) { if (newConfig->inputCfg.channels != newConfig->outputCfg.channels) {
v4a_printf(ANDROID_LOG_ERROR, "ViPER4Android disabled, reason [in.CH = %d, out.CH = %d]", newConfig->inputCfg.channels, newConfig->outputCfg.channels); v4a_printf(ANDROID_LOG_ERROR, "ViPER4Android disabled, reason [in.CH = %d, out.CH = %d]",
newConfig->inputCfg.channels, newConfig->outputCfg.channels);
DO_ERROR(); DO_ERROR();
} }
@ -116,9 +118,9 @@ int32_t Effect::configure(effect_config_t *newConfig) {
memcpy(&this->config, newConfig, sizeof(effect_config_t)); memcpy(&this->config, newConfig, sizeof(effect_config_t));
this->configureOk = true; this->configureOk = true;
v4a_print(ANDROID_LOG_INFO, "Audio configure finished"); v4a_print(ANDROID_LOG_INFO, "Audio configure finished");
return 0; return 0;
} }

11
src/cpp/Effect.h
View File

@ -10,11 +10,14 @@
class Effect { class Effect {
public: public:
Effect(); Effect();
~Effect(); ~Effect();
virtual int32_t command(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData, uint32_t* replySize, void* pReplyData); virtual int32_t command(uint32_t cmdCode, uint32_t cmdSize, void *pCmdData, uint32_t *replySize, void *pReplyData);
int32_t process(audio_buffer_s *in, audio_buffer_s *out); int32_t process(audio_buffer_s *in, audio_buffer_s *out);
int32_t configure(effect_config_t* config);
int32_t configure(effect_config_t *config);
bool enabled; bool enabled;
bool configureOk; bool configureOk;
@ -23,7 +26,7 @@ public:
// Misc data here? // Misc data here?
// TODO: Figure out what buffer is used for // TODO: Figure out what buffer is used for
float* buffer; float *buffer;
uint32_t bufferSize; uint32_t bufferSize;
void* instance; // type: ProcessUnit_FX void *instance; // type: ProcessUnit_FX
}; };

3
src/cpp/ProcessUnit_FX.cpp
View File

@ -15,7 +15,8 @@ ProcessUnit_FX::~ProcessUnit_FX() {
} }
int32_t ProcessUnit_FX::command(uint32_t cmdCode, uint32_t cmdSize, void *pCmdData, uint32_t *replySize, void *pReplyData) { int32_t
ProcessUnit_FX::command(uint32_t cmdCode, uint32_t cmdSize, void *pCmdData, uint32_t *replySize, void *pReplyData) {
// TODO // TODO
return -1; return -1;
} }

30
src/cpp/ProcessUnit_FX.h
View File

@ -20,38 +20,40 @@
class ProcessUnit_FX : public Effect { class ProcessUnit_FX : public Effect {
public: public:
ProcessUnit_FX(); ProcessUnit_FX();
~ProcessUnit_FX(); ~ProcessUnit_FX();
int32_t command(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData, uint32_t* replySize, void* pReplyData) override; int32_t command(uint32_t cmdCode, uint32_t cmdSize, void *pCmdData, uint32_t *replySize, void *pReplyData) override;
void processBuffer(float* buffer, int frameSize); void processBuffer(float *buffer, int frameSize);
// TODO: Parameter types/names // TODO: Parameter types/names
void DispatchCommand(int param_1, int param_2,int param_3, int param_4,int param_5, int param_6,int param_7); void DispatchCommand(int param_1, int param_2, int param_3, int param_4, int param_5, int param_6, int param_7);
void ResetAllEffects(); void ResetAllEffects();
bool init_ok, enabled, force_enabled, fetcomp_enabled; bool init_ok, enabled, force_enabled, fetcomp_enabled;
FxMode mode; FxMode mode;
// AdaptiveBuffer_F32* adaptiveBuffer; // AdaptiveBuffer_F32* adaptiveBuffer;
WaveBuffer_I32* waveBuffer; WaveBuffer_I32 *waveBuffer;
// Convolver* convolver; // Convolver* convolver;
VHE* vhe; VHE *vhe;
// ViPERDDC* vddc; // ViPERDDC* vddc;
SpectrumExtend* spectrumExtend; SpectrumExtend *spectrumExtend;
// IIRFilter* iirfilter; // IIRFilter* iirfilter;
// ColorfulMusic* colm; // ColorfulMusic* colm;
Reverberation* reverb; Reverberation *reverb;
// PlaybackGain* playbackGain; // PlaybackGain* playbackGain;
// FETCompressor* fetcomp; // FETCompressor* fetcomp;
DynamicSystem* dynsys; DynamicSystem *dynsys;
// ViPERBass* bass; // ViPERBass* bass;
ViPERClarity* clarity; ViPERClarity *clarity;
DiffSurround* diffSurround; DiffSurround *diffSurround;
Cure* cure; Cure *cure;
TubeSimulator* tube; TubeSimulator *tube;
AnalogX* analogx; AnalogX *analogx;
SpeakerCorrection* speakerCorrection; SpeakerCorrection *speakerCorrection;
// SoftwareLimiter* limiter[2]; // SoftwareLimiter* limiter[2];
int unk[3]; int unk[3];

2
src/cpp/constants.h
View File

@ -7,7 +7,9 @@
#ifdef ANDROID_TOOLCHAIN #ifdef ANDROID_TOOLCHAIN
#include <android/errno.h> #include <android/errno.h>
#else #else
#include <cerrno> #include <cerrno>
#endif #endif
#include "log.h" // TODO: Remove this dependency #include "log.h" // TODO: Remove this dependency

22
src/cpp/effects/AnalogX.cpp
View File

@ -27,7 +27,7 @@ AnalogX::AnalogX() {
} }
void AnalogX::Process(float *samples, uint32_t size) { void AnalogX::Process(float *samples, uint32_t size) {
for (int i = 0; i < 2*size; i++) { for (int i = 0; i < 2 * size; i++) {
float sample = samples[i]; float sample = samples[i];
int index = i % 2; int index = i % 2;
@ -47,11 +47,11 @@ void AnalogX::Process(float *samples, uint32_t size) {
} }
void AnalogX::Reset() { void AnalogX::Reset() {
this->highpass[0].RefreshFilter(FilterType::HIGHPASS, 0.f, 240.f, (float)this->samplerate, 0.717, false); this->highpass[0].RefreshFilter(FilterType::HIGHPASS, 0.f, 240.f, (float) this->samplerate, 0.717, false);
this->highpass[1].RefreshFilter(FilterType::HIGHPASS, 0.f, 240.f, (float)this->samplerate, 0.717, false); this->highpass[1].RefreshFilter(FilterType::HIGHPASS, 0.f, 240.f, (float) this->samplerate, 0.717, false);
this->peak[0].RefreshFilter(FilterType::PEAK, 0.58f, 633.f, (float)this->samplerate, 6.28, true); this->peak[0].RefreshFilter(FilterType::PEAK, 0.58f, 633.f, (float) this->samplerate, 6.28, true);
this->peak[1].RefreshFilter(FilterType::PEAK, 0.58f, 633.f, (float)this->samplerate, 6.28, true); this->peak[1].RefreshFilter(FilterType::PEAK, 0.58f, 633.f, (float) this->samplerate, 6.28, true);
this->harmonics[0].Reset(); this->harmonics[0].Reset();
this->harmonics[1].Reset(); this->harmonics[1].Reset();
@ -60,20 +60,20 @@ void AnalogX::Reset() {
this->harmonics[0].SetHarmonics(ANALOGX_HARMONICS); this->harmonics[0].SetHarmonics(ANALOGX_HARMONICS);
this->harmonics[1].SetHarmonics(ANALOGX_HARMONICS); this->harmonics[1].SetHarmonics(ANALOGX_HARMONICS);
this->gain = 0.6f; this->gain = 0.6f;
this->lowpass[0].RefreshFilter(FilterType::LOWPASS, 0.0, 18233.f, (float)this->samplerate, 0.717f, false); this->lowpass[0].RefreshFilter(FilterType::LOWPASS, 0.0, 18233.f, (float) this->samplerate, 0.717f, false);
this->lowpass[1].RefreshFilter(FilterType::LOWPASS, 0.0, 18233.f, (float)this->samplerate, 0.717f, false); this->lowpass[1].RefreshFilter(FilterType::LOWPASS, 0.0, 18233.f, (float) this->samplerate, 0.717f, false);
} else if (this->processingModel == 1) { } else if (this->processingModel == 1) {
this->harmonics[0].SetHarmonics(ANALOGX_HARMONICS); this->harmonics[0].SetHarmonics(ANALOGX_HARMONICS);
this->harmonics[1].SetHarmonics(ANALOGX_HARMONICS); this->harmonics[1].SetHarmonics(ANALOGX_HARMONICS);
this->gain = 1.2f; this->gain = 1.2f;
this->lowpass[0].RefreshFilter(FilterType::LOWPASS, 0.0, 19650.f, (float)this->samplerate, 0.717f, false); this->lowpass[0].RefreshFilter(FilterType::LOWPASS, 0.0, 19650.f, (float) this->samplerate, 0.717f, false);
this->lowpass[1].RefreshFilter(FilterType::LOWPASS, 0.0, 19650.f, (float)this->samplerate, 0.717f, false); this->lowpass[1].RefreshFilter(FilterType::LOWPASS, 0.0, 19650.f, (float) this->samplerate, 0.717f, false);
} else if (this->processingModel == 2) { } else if (this->processingModel == 2) {
this->harmonics[0].SetHarmonics(ANALOGX_HARMONICS); this->harmonics[0].SetHarmonics(ANALOGX_HARMONICS);
this->harmonics[1].SetHarmonics(ANALOGX_HARMONICS); this->harmonics[1].SetHarmonics(ANALOGX_HARMONICS);
this->gain = 2.4f; this->gain = 2.4f;
this->lowpass[0].RefreshFilter(FilterType::LOWPASS, 0.0, 16307.f, (float)this->samplerate, 0.717f, false); this->lowpass[0].RefreshFilter(FilterType::LOWPASS, 0.0, 16307.f, (float) this->samplerate, 0.717f, false);
this->lowpass[1].RefreshFilter(FilterType::LOWPASS, 0.0, 16307.f, (float)this->samplerate, 0.717f, false); this->lowpass[1].RefreshFilter(FilterType::LOWPASS, 0.0, 16307.f, (float) this->samplerate, 0.717f, false);
} }
this->freqRange = 0; this->freqRange = 0;

4
src/cpp/effects/AnalogX.h
View File

@ -12,10 +12,12 @@ class AnalogX {
public: public:
AnalogX(); AnalogX();
void Process(float* samples, uint32_t size); void Process(float *samples, uint32_t size);
void Reset(); void Reset();
void SetProcessingModel(int model); void SetProcessingModel(int model);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
MultiBiquad highpass[2]; MultiBiquad highpass[2];

11
src/cpp/effects/Cure.h
View File

@ -12,17 +12,26 @@ class Cure {
public: public:
Cure(); Cure();
void Process(float* buffer, uint32_t size); void Process(float *buffer, uint32_t size);
void Reset(); void Reset();
void SetEnable(bool enabled); void SetEnable(bool enabled);
uint16_t GetCutoff(); uint16_t GetCutoff();
float GetFeedback(); float GetFeedback();
float GetLevelDelay(); float GetLevelDelay();
preset_t GetPreset(); preset_t GetPreset();
void SetCutoff(uint16_t cutoff); void SetCutoff(uint16_t cutoff);
void SetFeedback(float feedback); void SetFeedback(float feedback);
void SetPreset(preset_t preset); void SetPreset(preset_t preset);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
Crossfeed crossfeed; Crossfeed crossfeed;

6
src/cpp/effects/DiffSurround.cpp
View File

@ -20,8 +20,8 @@ DiffSurround::~DiffSurround() {
} }
void DiffSurround::Process(float *samples, uint32_t size) { void DiffSurround::Process(float *samples, uint32_t size) {
float* bufs[2]; float *bufs[2];
float* outbufs[2]; float *outbufs[2];
if (this->enabled) { if (this->enabled) {
bufs[0] = this->buffers[0]->PushZerosGetBuffer(size); bufs[0] = this->buffers[0]->PushZerosGetBuffer(size);
@ -47,7 +47,7 @@ void DiffSurround::Reset() {
this->buffers[0]->Reset(); this->buffers[0]->Reset();
this->buffers[1]->Reset(); this->buffers[1]->Reset();
this->buffers[1]->PushZeros((uint32_t)(this->delayTime / 1000.f * (float)this->samplerate)); this->buffers[1]->PushZeros((uint32_t) (this->delayTime / 1000.f * (float) this->samplerate));
} }
void DiffSurround::SetDelayTime(float value) { void DiffSurround::SetDelayTime(float value) {

8
src/cpp/effects/DiffSurround.h
View File

@ -11,19 +11,23 @@
class DiffSurround { class DiffSurround {
public: public:
DiffSurround(); DiffSurround();
~DiffSurround(); ~DiffSurround();
void Process(float* samples, uint32_t size); void Process(float *samples, uint32_t size);
void Reset(); void Reset();
void SetDelayTime(float value); void SetDelayTime(float value);
void SetEnable(bool enabled); void SetEnable(bool enabled);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
uint32_t samplerate; uint32_t samplerate;
bool enabled; bool enabled;
float delayTime; float delayTime;
WaveBuffer_I32* buffers[2]; WaveBuffer_I32 *buffers[2];
}; };

2
src/cpp/effects/DynamicSystem.cpp
View File

@ -12,7 +12,7 @@ DynamicSystem::DynamicSystem() {
this->bass.Reset(); this->bass.Reset();
} }
void DynamicSystem::Process(float* samples, uint32_t size) { void DynamicSystem::Process(float *samples, uint32_t size) {
if (this->enabled) { if (this->enabled) {
this->bass.FilterSamples(samples, size); this->bass.FilterSamples(samples, size);
} }

8
src/cpp/effects/DynamicSystem.h
View File

@ -11,14 +11,20 @@ class DynamicSystem {
public: public:
DynamicSystem(); DynamicSystem();
void Process(float* samples, uint32_t size); void Process(float *samples, uint32_t size);
void Reset(); void Reset();
void SetBassGain(float gain); void SetBassGain(float gain);
void SetEnable(bool enable); void SetEnable(bool enable);
void SetSideGain(float gainX, float gainY); void SetSideGain(float gainX, float gainY);
void SetXCoeffs(uint32_t low, uint32_t high); void SetXCoeffs(uint32_t low, uint32_t high);
void SetYCoeffs(uint32_t low, uint32_t high); void SetYCoeffs(uint32_t low, uint32_t high);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
DynamicBass bass; DynamicBass bass;

9
src/cpp/effects/Reverberation.h
View File

@ -11,14 +11,21 @@ public:
Reverberation(); Reverberation();
void Reset(); void Reset();
void Process(float* buffer, uint32_t size);
void Process(float *buffer, uint32_t size);
void SetEnable(bool enable); void SetEnable(bool enable);
void SetRoomSize(float value); void SetRoomSize(float value);
void SetDamp(float value); void SetDamp(float value);
void SetWet(float value); void SetWet(float value);
void SetDry(float value); void SetDry(float value);
void SetWidth(float value); void SetWidth(float value);
void SetSamplingRate(uint32_t value); void SetSamplingRate(uint32_t value);
float roomsize; float roomsize;

4
src/cpp/effects/SpeakerCorrection.cpp
View File

@ -28,8 +28,8 @@ void SpeakerCorrection::Reset() {
this->bandpass[0].Reset(); this->bandpass[0].Reset();
this->bandpass[1].Reset(); this->bandpass[1].Reset();
this->highpass[0].RefreshFilter(FilterType::HIGHPASS, 0.f, 80.f, (float)this->samplerate, 1.f, false); this->highpass[0].RefreshFilter(FilterType::HIGHPASS, 0.f, 80.f, (float) this->samplerate, 1.f, false);
this->highpass[1].RefreshFilter(FilterType::HIGHPASS, 0.f, 80.f, (float)this->samplerate, 1.f, false); this->highpass[1].RefreshFilter(FilterType::HIGHPASS, 0.f, 80.f, (float) this->samplerate, 1.f, false);
this->lowpass[0].SetLowPassParameter(13500.f, this->samplerate, 1.0); this->lowpass[0].SetLowPassParameter(13500.f, this->samplerate, 1.0);
this->lowpass[1].SetLowPassParameter(13500.f, this->samplerate, 1.0); this->lowpass[1].SetLowPassParameter(13500.f, this->samplerate, 1.0);
this->bandpass[0].SetBandPassParameter(420.f, this->samplerate, 3.88f); this->bandpass[0].SetBandPassParameter(420.f, this->samplerate, 3.88f);

4
src/cpp/effects/SpeakerCorrection.h
View File

@ -11,10 +11,12 @@ class SpeakerCorrection {
public: public:
SpeakerCorrection(); SpeakerCorrection();
void Process(float* samples, uint32_t size); void Process(float *samples, uint32_t size);
void Reset(); void Reset();
void SetEnable(bool enabled); void SetEnable(bool enabled);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
uint32_t samplerate; uint32_t samplerate;

12
src/cpp/effects/SpectrumExtend.cpp
View File

@ -42,11 +42,15 @@ void SpectrumExtend::Process(float *samples, uint32_t size) {
} }
void SpectrumExtend::Reset() { void SpectrumExtend::Reset() {
this->highpass[0].RefreshFilter(FilterType::HIGHPASS, 0.0, (float)this->referenceFreq, (float)this->samplerate, 0.717, false); this->highpass[0].RefreshFilter(FilterType::HIGHPASS, 0.0, (float) this->referenceFreq, (float) this->samplerate,
this->highpass[1].RefreshFilter(FilterType::HIGHPASS, 0.0, (float)this->referenceFreq, (float)this->samplerate, 0.717, false); 0.717, false);
this->highpass[1].RefreshFilter(FilterType::HIGHPASS, 0.0, (float) this->referenceFreq, (float) this->samplerate,
0.717, false);
this->lowpass[0].RefreshFilter(FilterType::LOWPASS, 0.0, (float)this->referenceFreq / 2.f - 2000.f, (float)this->referenceFreq, 0.717, false); this->lowpass[0].RefreshFilter(FilterType::LOWPASS, 0.0, (float) this->referenceFreq / 2.f - 2000.f,
this->lowpass[1].RefreshFilter(FilterType::LOWPASS, 0.0, (float)this->referenceFreq / 2.f - 2000.f, (float)this->referenceFreq, 0.717, false); (float) this->referenceFreq, 0.717, false);
this->lowpass[1].RefreshFilter(FilterType::LOWPASS, 0.0, (float) this->referenceFreq / 2.f - 2000.f,
(float) this->referenceFreq, 0.717, false);
this->harmonics[0].Reset(); this->harmonics[0].Reset();
this->harmonics[1].Reset(); this->harmonics[1].Reset();

8
src/cpp/effects/SpectrumExtend.h
View File

@ -11,13 +11,19 @@
class SpectrumExtend { class SpectrumExtend {
public: public:
SpectrumExtend(); SpectrumExtend();
~SpectrumExtend(); ~SpectrumExtend();
void Process(float* samples, uint32_t size); void Process(float *samples, uint32_t size);
void Reset(); void Reset();
void SetEnable(bool enable); void SetEnable(bool enable);
void SetExciter(float value); void SetExciter(float value);
void SetReferenceFrequency(uint32_t freq); void SetReferenceFrequency(uint32_t freq);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
MultiBiquad highpass[2]; MultiBiquad highpass[2];

8
src/cpp/effects/TubeSimulator.cpp
View File

@ -19,10 +19,10 @@ void TubeSimulator::Reset() {
void TubeSimulator::TubeProcess(float *buffer, uint32_t size) { void TubeSimulator::TubeProcess(float *buffer, uint32_t size) {
if (this->enabled && size > 0) { if (this->enabled && size > 0) {
for (int x = 0; x < size; x++) { for (int x = 0; x < size; x++) {
this->acc[0] = (this->acc[0] + buffer[2*x]) / 2.f; this->acc[0] = (this->acc[0] + buffer[2 * x]) / 2.f;
this->acc[1] = (this->acc[1] + buffer[2*x+1]) / 2.f; this->acc[1] = (this->acc[1] + buffer[2 * x + 1]) / 2.f;
buffer[2*x] = this->acc[0]; buffer[2 * x] = this->acc[0];
buffer[2*x+1] = this->acc[1]; buffer[2 * x + 1] = this->acc[1];
} }
} }
} }

3
src/cpp/effects/TubeSimulator.h
View File

@ -11,7 +11,8 @@ public:
TubeSimulator(); TubeSimulator();
void Reset(); void Reset();
void TubeProcess(float* buffer, uint32_t size);
void TubeProcess(float *buffer, uint32_t size);
float acc[2]; float acc[2];
bool enabled; bool enabled;

7
src/cpp/effects/VHE.h
View File

@ -11,14 +11,19 @@
class VHE { class VHE {
public: public:
VHE(); VHE();
~VHE(); ~VHE();
void Process(float* source, float* dest, int frameSize); void Process(float *source, float *dest, int frameSize);
void Reset(); void Reset();
bool GetEnabled(); bool GetEnabled();
void SetEffectLevel(uint32_t level); void SetEffectLevel(uint32_t level);
void SetEnable(bool enabled); void SetEnable(bool enabled);
void SetSamplingRate(uint32_t srate); void SetSamplingRate(uint32_t srate);
PConvSingle_F32 convLeft, convRight; PConvSingle_F32 convLeft, convRight;

7
src/cpp/effects/ViPERClarity.h
View File

@ -19,13 +19,18 @@ class ViPERClarity {
public: public:
ViPERClarity(); ViPERClarity();
void Process(float* samples, uint32_t size); void Process(float *samples, uint32_t size);
void Reset(); void Reset();
void SetClarity(float gainPercent); void SetClarity(float gainPercent);
void SetClarityToFilter(); void SetClarityToFilter();
void SetEnable(bool enabled); void SetEnable(bool enabled);
void SetProcessMode(ClarityMode mode); void SetProcessMode(ClarityMode mode);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
NoiseSharpening sharp; NoiseSharpening sharp;

7
src/cpp/utils/CAllpassFilter.h
View File

@ -11,13 +11,16 @@ public:
CAllpassFilter(); CAllpassFilter();
void Mute(); void Mute();
float Process(float sample); float Process(float sample);
float GetFeedback(); float GetFeedback();
void SetBuffer(float* buffer, uint32_t size);
void SetBuffer(float *buffer, uint32_t size);
void SetFeedback(float feedback); void SetFeedback(float feedback);
float* buffer; float *buffer;
uint32_t bufidx; uint32_t bufidx;
uint32_t bufsize; uint32_t bufsize;
float feedback; float feedback;

9
src/cpp/utils/CCombFilter.h
View File

@ -11,19 +11,24 @@ public:
CCombFilter(); CCombFilter();
float Process(float sample); float Process(float sample);
void Mute(); void Mute();
float GetDamp(); float GetDamp();
float GetFeedback(); float GetFeedback();
void SetDamp(float damp); void SetDamp(float damp);
void SetFeedback(float feedback); void SetFeedback(float feedback);
void SetBuffer(float* buffer, uint32_t size);
void SetBuffer(float *buffer, uint32_t size);
float feedback; float feedback;
float filterstore; float filterstore;
float damp; float damp;
float damp2; float damp2;
float* buffer; float *buffer;
uint32_t size; uint32_t size;
uint32_t bufidx; uint32_t bufidx;
}; };

40
src/cpp/utils/CRevModel.cpp
View File

@ -85,11 +85,11 @@ void CRevModel::Mute() {
return; return;
} }
for (int i=0; i<8; i++) { for (int i = 0; i < 8; i++) {
combL[i].Mute(); combL[i].Mute();
combR[i].Mute(); combR[i].Mute();
} }
for (int i=0; i<4; i++) { for (int i = 0; i < 4; i++) {
allpassL[i].Mute(); allpassL[i].Mute();
allpassR[i].Mute(); allpassR[i].Mute();
} }
@ -101,18 +101,18 @@ void CRevModel::ProcessReplace(float *bufL, float *bufR, uint32_t size) {
float outR = 0.f; float outR = 0.f;
float input = (*bufL + *bufR) * gain; float input = (*bufL + *bufR) * gain;
for (int i=0; i<8; i++) { for (int i = 0; i < 8; i++) {
outL += combL[i].Process(input); outL += combL[i].Process(input);
outR += combR[i].Process(input); outR += combR[i].Process(input);
} }
for (int i=0; i<4; i++) { for (int i = 0; i < 4; i++) {
outL = allpassL[i].Process(outL); outL = allpassL[i].Process(outL);
outR = allpassR[i].Process(outR); outR = allpassR[i].Process(outR);
} }
*bufL = outL*wet1 + outR*wet2 + *bufL * dry; *bufL = outL * wet1 + outR * wet2 + *bufL * dry;
*bufR = outR*wet1 + outL*wet2 + *bufR * dry; *bufR = outR * wet1 + outL * wet2 + *bufR * dry;
bufL += 1; bufL += 1;
bufR += 1; bufR += 1;
@ -120,8 +120,8 @@ void CRevModel::ProcessReplace(float *bufL, float *bufR, uint32_t size) {
} }
void CRevModel::UpdateCoeffs() { void CRevModel::UpdateCoeffs() {
wet1 = wet*(width/2.f + 0.5f); wet1 = wet * (width / 2.f + 0.5f);
wet2 = wet*((1.f-width)/2.f); wet2 = wet * ((1.f - width) / 2.f);
if (mode == 1) { if (mode == 1) {
roomsize1 = 1.f; roomsize1 = 1.f;
@ -133,46 +133,46 @@ void CRevModel::UpdateCoeffs() {
gain = 0.015f; gain = 0.015f;
} }
for (int i=0; i<8; i++) { for (int i = 0; i < 8; i++) {
combL[i].SetFeedback(roomsize1); combL[i].SetFeedback(roomsize1);
combR[i].SetFeedback(roomsize1); combR[i].SetFeedback(roomsize1);
} }
for(int i=0; i<8; i++) { for (int i = 0; i < 8; i++) {
combL[i].SetDamp(damp1); combL[i].SetDamp(damp1);
combR[i].SetDamp(damp1); combR[i].SetDamp(damp1);
} }
} }
void CRevModel::Reset() { void CRevModel::Reset() {
for (int i=0; i<8; i++) { for (int i = 0; i < 8; i++) {
combL[i].Mute(); combL[i].Mute();
combR[i].Mute(); combR[i].Mute();
} }
for(int i=0; i<4; i++) { for (int i = 0; i < 4; i++) {
allpassL[i].Mute(); allpassL[i].Mute();
allpassR[i].Mute(); allpassR[i].Mute();
} }
} }
void CRevModel::SetRoomSize(float value) { void CRevModel::SetRoomSize(float value) {
roomsize = (value*0.28f) + 0.7f; roomsize = (value * 0.28f) + 0.7f;
UpdateCoeffs(); UpdateCoeffs();
} }
void CRevModel::SetDamp(float value) { void CRevModel::SetDamp(float value) {
damp = value*0.4f; damp = value * 0.4f;
UpdateCoeffs(); UpdateCoeffs();
} }
void CRevModel::SetWet(float value) { void CRevModel::SetWet(float value) {
wet = value*3.f; wet = value * 3.f;
UpdateCoeffs(); UpdateCoeffs();
} }
void CRevModel::SetDry(float value) { void CRevModel::SetDry(float value) {
dry = value*2.f; dry = value * 2.f;
} }
void CRevModel::SetWidth(float value) { void CRevModel::SetWidth(float value) {
@ -186,19 +186,19 @@ void CRevModel::SetMode(int value) {
} }
float CRevModel::GetRoomSize() { float CRevModel::GetRoomSize() {
return (roomsize-0.7f)/0.28f; return (roomsize - 0.7f) / 0.28f;
} }
float CRevModel::GetDamp() { float CRevModel::GetDamp() {
return damp/0.4f; return damp / 0.4f;
} }
float CRevModel::GetWet() { float CRevModel::GetWet() {
return wet/3.f; return wet / 3.f;
} }
float CRevModel::GetDry() { float CRevModel::GetDry() {
return dry/2.f; return dry / 2.f;
} }
float CRevModel::GetWidth() { float CRevModel::GetWidth() {

17
src/cpp/utils/CRevModel.h
View File

@ -10,24 +10,39 @@
class CRevModel { class CRevModel {
public: public:
CRevModel(); CRevModel();
~CRevModel(); ~CRevModel();
void Mute(); void Mute();
void ProcessReplace(float *bufL, float *bufR, uint32_t size); void ProcessReplace(float *bufL, float *bufR, uint32_t size);
void UpdateCoeffs(); void UpdateCoeffs();
void Reset(); void Reset();
void SetRoomSize(float value); void SetRoomSize(float value);
void SetDamp(float value); void SetDamp(float value);
void SetWet(float value); void SetWet(float value);
void SetDry(float value); void SetDry(float value);
void SetWidth(float value); void SetWidth(float value);
void SetMode(int value); void SetMode(int value);
float GetRoomSize(); float GetRoomSize();
float GetDamp(); float GetDamp();
float GetWet(); float GetWet();
float GetDry(); float GetDry();
float GetWidth(); float GetWidth();
int GetMode(); int GetMode();
float gain; float gain;
@ -48,7 +63,7 @@ public:
CAllpassFilter allpassL[4]; CAllpassFilter allpassL[4];
CAllpassFilter allpassR[4]; CAllpassFilter allpassR[4];
float* buffers[24]; float *buffers[24];
}; };

37
src/cpp/utils/Crossfeed.cpp
View File

@ -16,7 +16,7 @@ Crossfeed::Crossfeed() {
this->a1_hi = 0.f; this->a1_hi = 0.f;
this->b1_hi = 0.f; this->b1_hi = 0.f;
this->gain = 0.f; this->gain = 0.f;
memset(&this->lfs, 0, 6*sizeof(float)); memset(&this->lfs, 0, 6 * sizeof(float));
this->samplerate = DEFAULT_SAMPLERATE; this->samplerate = DEFAULT_SAMPLERATE;
this->preset.cutoff = 700; this->preset.cutoff = 700;
this->preset.feedback = 45; this->preset.feedback = 45;
@ -31,31 +31,32 @@ void Crossfeed::Reset() {
double GB_lo = level * -5.0 / 6.0 - 3.0; double GB_lo = level * -5.0 / 6.0 - 3.0;
double GB_hi = level / 6.0 - 3.0; double GB_hi = level / 6.0 - 3.0;
double G_lo = pow( 10, GB_lo / 20.0 ); double G_lo = pow(10, GB_lo / 20.0);
double G_hi = 1.0 - pow( 10, GB_hi / 20.0 ); double G_hi = 1.0 - pow(10, GB_hi / 20.0);
double Fc_hi = cutoff * pow( 2.0, ( GB_lo - 20.0 * log10( G_hi ) ) / 12.0 ); double Fc_hi = cutoff * pow(2.0, (GB_lo - 20.0 * log10(G_hi)) / 12.0);
double x = exp( -2.0 * M_PI * cutoff / this->samplerate ); double x = exp(-2.0 * M_PI * cutoff / this->samplerate);
this->b1_lo = (float)x; this->b1_lo = (float) x;
this->a0_lo = (float)(G_lo * ( 1.0 - x )); this->a0_lo = (float) (G_lo * (1.0 - x));
x = exp( -2.0 * M_PI * Fc_hi / this->samplerate ); x = exp(-2.0 * M_PI * Fc_hi / this->samplerate);
this->b1_hi = (float)x; this->b1_hi = (float) x;
this->a0_hi = (float)(1.0 - G_hi * ( 1.0 - x )); this->a0_hi = (float) (1.0 - G_hi * (1.0 - x));
this->a1_hi = (float)-x; this->a1_hi = (float) -x;
this->gain = (float)(1.0 / ( 1.0 - G_hi + G_lo )); this->gain = (float) (1.0 / (1.0 - G_hi + G_lo));
memset(&this->lfs, 0, 6*sizeof(float)); memset(&this->lfs, 0, 6 * sizeof(float));
} }
void Crossfeed::ProcessFrames(float* buffer, uint32_t size) { void Crossfeed::ProcessFrames(float *buffer, uint32_t size) {
for (int x = 0; x < size; x+=2) { for (int x = 0; x < size; x += 2) {
FilterSample(&buffer[x]); FilterSample(&buffer[x]);
} }
} }
#define lo_filter(in, out_1) (this->a0_lo * (in) + this->b1_lo * (out_1)) #define lo_filter(in, out_1) (this->a0_lo * (in) + this->b1_lo * (out_1))
#define hi_filter(in, in_1, out_1) (this->a0_hi * (in) + this->a1_hi * (in_1) + this->b1_hi * (out_1)) #define hi_filter(in, in_1, out_1) (this->a0_hi * (in) + this->a1_hi * (in_1) + this->b1_hi * (out_1))
void Crossfeed::FilterSample(float *sample) { void Crossfeed::FilterSample(float *sample) {
this->lfs.lo[0] = lo_filter(sample[0], this->lfs.lo[0]); this->lfs.lo[0] = lo_filter(sample[0], this->lfs.lo[0]);
this->lfs.lo[1] = lo_filter(sample[1], this->lfs.lo[1]); this->lfs.lo[1] = lo_filter(sample[1], this->lfs.lo[1]);
@ -74,12 +75,12 @@ uint16_t Crossfeed::GetCutoff() {
} }
float Crossfeed::GetFeedback() { float Crossfeed::GetFeedback() {
return (float)this->preset.feedback / 10.f; return (float) this->preset.feedback / 10.f;
} }
float Crossfeed::GetLevelDelay() { float Crossfeed::GetLevelDelay() {
if (this->preset.cutoff <= 1800) { if (this->preset.cutoff <= 1800) {
return (18700.f / (float)this->preset.cutoff) * 10.f; return (18700.f / (float) this->preset.cutoff) * 10.f;
} else { } else {
return 0.f; return 0.f;
} }
@ -95,7 +96,7 @@ void Crossfeed::SetCutoff(uint16_t cutoff) {
} }
void Crossfeed::SetFeedback(float feedback) { void Crossfeed::SetFeedback(float feedback) {
this->preset.feedback = (uint16_t)(feedback * 10); this->preset.feedback = (uint16_t) (feedback * 10);
Reset(); Reset();
} }

13
src/cpp/utils/Crossfeed.h
View File

@ -17,16 +17,25 @@ public:
Crossfeed(); Crossfeed();
void Reset(); void Reset();
void ProcessFrames(float* buffer, uint32_t size);
void FilterSample(float* sample); void ProcessFrames(float *buffer, uint32_t size);
void FilterSample(float *sample);
uint16_t GetCutoff(); uint16_t GetCutoff();
float GetFeedback(); float GetFeedback();
float GetLevelDelay(); float GetLevelDelay();
preset_t GetPreset(); preset_t GetPreset();
void SetCutoff(uint16_t cutoff); void SetCutoff(uint16_t cutoff);
void SetFeedback(float feedback); void SetFeedback(float feedback);
void SetPreset(preset_t preset); void SetPreset(preset_t preset);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
uint32_t samplerate; uint32_t samplerate;

18
src/cpp/utils/DepthSurround.cpp
View File

@ -21,8 +21,8 @@ void DepthSurround::Process(float *samples, uint32_t size) {
if (this->enabled) { if (this->enabled) {
if (!this->strengthAtLeast500) { if (!this->strengthAtLeast500) {
for (int i = 0; i < size; i++) { for (int i = 0; i < size; i++) {
float sampleLeft = samples[2*i]; float sampleLeft = samples[2 * i];
float sampleRight = samples[2*i+1]; float sampleRight = samples[2 * i + 1];
this->prev[0] = this->gain * this->delay[0].ProcessSample(sampleLeft + this->prev[1]); this->prev[0] = this->gain * this->delay[0].ProcessSample(sampleLeft + this->prev[1]);
this->prev[1] = this->gain * this->delay[1].ProcessSample(sampleRight + this->prev[0]); this->prev[1] = this->gain * this->delay[1].ProcessSample(sampleRight + this->prev[0]);
@ -33,13 +33,13 @@ void DepthSurround::Process(float *samples, uint32_t size) {
float diff = (l - r) / 2.f; float diff = (l - r) / 2.f;
float avg = (l + r) / 2.f; float avg = (l + r) / 2.f;
float avgOut = this->highpass.ProcessSample(diff); float avgOut = this->highpass.ProcessSample(diff);
samples[2*i] = avg + (diff - avgOut); samples[2 * i] = avg + (diff - avgOut);
samples[2*i+1] = avg - (diff - avgOut); samples[2 * i + 1] = avg - (diff - avgOut);
} }
} else { } else {
for (int i = 0; i < size; i++) { for (int i = 0; i < size; i++) {
float sampleLeft = samples[2*i]; float sampleLeft = samples[2 * i];
float sampleRight = samples[2*i+1]; float sampleRight = samples[2 * i + 1];
this->prev[0] = this->gain * this->delay[0].ProcessSample(sampleLeft + this->prev[1]); this->prev[0] = this->gain * this->delay[0].ProcessSample(sampleLeft + this->prev[1]);
this->prev[1] = -this->gain * this->delay[1].ProcessSample(sampleRight + this->prev[0]); this->prev[1] = -this->gain * this->delay[1].ProcessSample(sampleRight + this->prev[0]);
@ -50,8 +50,8 @@ void DepthSurround::Process(float *samples, uint32_t size) {
float diff = (l - r) / 2.f; float diff = (l - r) / 2.f;
float avg = (l + r) / 2.f; float avg = (l + r) / 2.f;
float avgOut = this->highpass.ProcessSample(diff); float avgOut = this->highpass.ProcessSample(diff);
samples[2*i] = avg + (diff - avgOut); samples[2 * i] = avg + (diff - avgOut);
samples[2*i+1] = avg - (diff - avgOut); samples[2 * i + 1] = avg - (diff - avgOut);
} }
} }
} }
@ -61,7 +61,7 @@ void DepthSurround::RefreshStrength(short strength) {
this->strengthAtLeast500 = strength >= 500; this->strengthAtLeast500 = strength >= 500;
this->enabled = strength != 0; this->enabled = strength != 0;
if (strength != 0) { if (strength != 0) {
float _gain = powf(10.f,((strength / 1000.f) * 10.f - 15.f) / 20.f); float _gain = powf(10.f, ((strength / 1000.f) * 10.f - 15.f) / 20.f);
if (fabsf(_gain) > 1.f) { if (fabsf(_gain) > 1.f) {
_gain = 1.f; _gain = 1.f;
} }

5
src/cpp/utils/DepthSurround.h
View File

@ -13,9 +13,12 @@ class DepthSurround {
public: public:
DepthSurround(); DepthSurround();
void Process(float* samples, uint32_t size); void Process(float *samples, uint32_t size);
void RefreshStrength(short strength); void RefreshStrength(short strength);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
void SetStrength(short strength); void SetStrength(short strength);
short strength; short strength;

18
src/cpp/utils/DynamicBass.cpp
View File

@ -14,7 +14,7 @@ DynamicBass::DynamicBass() {
this->lowFreqX = 120; this->lowFreqX = 120;
this->highFreqX = 80; this->highFreqX = 80;
this->lowFreqY = 40; this->lowFreqY = 40;
this->highFreqY = (float)this->samplerate / 4.f; this->highFreqY = (float) this->samplerate / 4.f;
this->filterX.SetPassFilter(this->lowFreqX, this->highFreqX); this->filterX.SetPassFilter(this->lowFreqX, this->highFreqX);
this->filterY.SetPassFilter(this->lowFreqY, this->highFreqY); this->filterY.SetPassFilter(this->lowFreqY, this->highFreqY);
@ -30,23 +30,23 @@ void DynamicBass::Reset() {
void DynamicBass::FilterSamples(float *samples, uint32_t size) { void DynamicBass::FilterSamples(float *samples, uint32_t size) {
if (this->lowFreqX <= 120) { if (this->lowFreqX <= 120) {
for (int i = 0; i < size; i++) { for (int i = 0; i < size; i++) {
float left = samples[2*i]; float left = samples[2 * i];
float right = samples[2*i+1]; float right = samples[2 * i + 1];
float avg = this->lowPass.ProcessSample(left + right); float avg = this->lowPass.ProcessSample(left + right);
samples[2*i] = left + avg; samples[2 * i] = left + avg;
samples[2*i+1] = right + avg; samples[2 * i + 1] = right + avg;
} }
} else { } else {
for (int i = 0; i < size; i++) { for (int i = 0; i < size; i++) {
float x1, x2, x3, x4, x5, x6, y1, y2, y3, y4, y5, y6; float x1, x2, x3, x4, x5, x6, y1, y2, y3, y4, y5, y6;
this->filterX.DoFilterLeft(samples[2*i], &x1, &x2, &x3); this->filterX.DoFilterLeft(samples[2 * i], &x1, &x2, &x3);
this->filterX.DoFilterRight(samples[2*i+1], &x4, &x5, &x6); this->filterX.DoFilterRight(samples[2 * i + 1], &x4, &x5, &x6);
this->filterY.DoFilterLeft(this->bassGain * x1, &y1, &y2, &y3); this->filterY.DoFilterLeft(this->bassGain * x1, &y1, &y2, &y3);
this->filterY.DoFilterRight(this->bassGain * x4, &y4, &y5, &y6); this->filterY.DoFilterRight(this->bassGain * x4, &y4, &y5, &y6);
samples[2*i] = x2 + y3 + this->sideGainX * y2 + this->sideGainY * y1 + x3; samples[2 * i] = x2 + y3 + this->sideGainX * y2 + this->sideGainY * y1 + x3;
samples[2*i+1] = x5 + y6 + this->sideGainX * y5 + this->sideGainY * y4 + x6; samples[2 * i + 1] = x5 + y6 + this->sideGainX * y5 + this->sideGainY * y4 + x6;
} }
} }
} }

8
src/cpp/utils/DynamicBass.h
View File

@ -12,12 +12,18 @@ class DynamicBass {
public: public:
DynamicBass(); DynamicBass();
void FilterSamples(float* samples, uint32_t size); void FilterSamples(float *samples, uint32_t size);
void Reset(); void Reset();
void SetBassGain(float gain); void SetBassGain(float gain);
void SetFilterXPassFrequency(uint32_t low, uint32_t high); void SetFilterXPassFrequency(uint32_t low, uint32_t high);
void SetFilterYPassFrequency(uint32_t low, uint32_t high); void SetFilterYPassFrequency(uint32_t low, uint32_t high);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
void SetSideGain(float gainX, float gainY); void SetSideGain(float gainX, float gainY);
uint32_t lowFreqX, highFreqX; uint32_t lowFreqX, highFreqX;

14
src/cpp/utils/FixedBiquad.cpp
View File

@ -11,7 +11,8 @@ FixedBiquad::FixedBiquad() {
} }
float FixedBiquad::ProcessSample(float sample) { float FixedBiquad::ProcessSample(float sample) {
float out = sample * this->b0 + this->x_1 * this->b1 + this->x_2 * this->b2 + this->y_1 * this->a1 + this->y_2 * this->a2; float out = sample * this->b0 + this->x_1 * this->b1 + this->x_2 * this->b2 + this->y_1 * this->a1 +
this->y_2 * this->a2;
this->y_2 = this->y_1; this->y_2 = this->y_1;
this->y_1 = out; this->y_1 = out;
this->x_2 = this->x_1; this->x_2 = this->x_1;
@ -44,16 +45,17 @@ void FixedBiquad::SetCoeffs(float a0, float a1, float a2, float b0, float b1, fl
} }
void FixedBiquad::SetBandPassParameter(float frequency, uint32_t samplerate, float qFactor) { void FixedBiquad::SetBandPassParameter(float frequency, uint32_t samplerate, float qFactor) {
float x = (2.f * frequency * (float)M_PI / (float)samplerate); float x = (2.f * frequency * (float) M_PI / (float) samplerate);
float sinX = sinf(x); float sinX = sinf(x);
float cosX = cosf(x); float cosX = cosf(x);
float y = x / (2.f * qFactor); float y = x / (2.f * qFactor);
SetCoeffs(y + 1.f, -2.f * cosX, 1.f - y, sinX / 2.f, 0.f, -sinX / 2.f); SetCoeffs(y + 1.f, -2.f * cosX, 1.f - y, sinX / 2.f, 0.f, -sinX / 2.f);
} }
void FixedBiquad::SetHighPassParameter(float frequency, uint32_t samplerate, float param_4, float qFactor, float param_6) { void
FixedBiquad::SetHighPassParameter(float frequency, uint32_t samplerate, float param_4, float qFactor, float param_6) {
// TODO: Cleanup and named params // TODO: Cleanup and named params
float fVar12 = (frequency * 2.f * (float)M_PI) / (float)samplerate; float fVar12 = (frequency * 2.f * (float) M_PI) / (float) samplerate;
float x = powf(10.f, param_4 / 40.f); float x = powf(10.f, param_4 / 40.f);
float fVar5 = (1.f / x + x) * (1.f / qFactor - 1.f) + 2.f; float fVar5 = (1.f / x + x) * (1.f / qFactor - 1.f) + 2.f;
float fVar7 = sqrtf(x); float fVar7 = sqrtf(x);
@ -63,7 +65,7 @@ void FixedBiquad::SetHighPassParameter(float frequency, uint32_t samplerate, flo
fVar5 = cosf(fVar12); fVar5 = cosf(fVar12);
fVar12 = fVar10 + fVar8 * fVar5; fVar12 = fVar10 + fVar8 * fVar5;
float fVar11 = fVar10 - fVar8 * fVar5; float fVar11 = fVar10 - fVar8 * fVar5;
float fVar2 = powf(10.f,param_6 / 20.f); float fVar2 = powf(10.f, param_6 / 20.f);
float fVar9 = fVar8 - fVar10 * fVar5; float fVar9 = fVar8 - fVar10 * fVar5;
SetCoeffs(fVar11 + (fVar7 + fVar7) * fVar6, SetCoeffs(fVar11 + (fVar7 + fVar7) * fVar6,
fVar9 + fVar9, fVar9 + fVar9,
@ -74,7 +76,7 @@ void FixedBiquad::SetHighPassParameter(float frequency, uint32_t samplerate, flo
} }
void FixedBiquad::SetLowPassParameter(float frequency, uint32_t samplerate, float qFactor) { void FixedBiquad::SetLowPassParameter(float frequency, uint32_t samplerate, float qFactor) {
float x = (frequency * 2.f * (float)M_PI) / (float)samplerate; float x = (frequency * 2.f * (float) M_PI) / (float) samplerate;
float sinX = sinf(x); float sinX = sinf(x);
float y = sinX / (qFactor * 2.f); float y = sinX / (qFactor * 2.f);
float cosX = cosf(x); float cosX = cosf(x);

5
src/cpp/utils/FixedBiquad.h
View File

@ -12,10 +12,15 @@ public:
FixedBiquad(); FixedBiquad();
float ProcessSample(float sample); float ProcessSample(float sample);
void Reset(); void Reset();
void SetCoeffs(float a0, float a1, float a2, float b0, float b1, float b2); void SetCoeffs(float a0, float a1, float a2, float b0, float b1, float b2);
void SetBandPassParameter(float frequency, uint32_t samplerate, float qFactor); void SetBandPassParameter(float frequency, uint32_t samplerate, float qFactor);
void SetHighPassParameter(float frequency, uint32_t samplerate, float param_4, float qFactor, float param_6); void SetHighPassParameter(float frequency, uint32_t samplerate, float param_4, float qFactor, float param_6);
void SetLowPassParameter(float frequency, uint32_t samplerate, float qFactor); void SetLowPassParameter(float frequency, uint32_t samplerate, float qFactor);

8
src/cpp/utils/Harmonic.cpp
View File

@ -68,9 +68,9 @@ void Harmonic::UpdateCoeffs(float *coefficients) {
float fVar6; float fVar6;
float _coeffs[20]; float _coeffs[20];
float afStack76[14]; float afStack76[14];
memset(_coeffs, 0, 11 * sizeof(float)); memset(_coeffs, 0, 11 * sizeof(float));
this->buildup = (int)fabsf(coefficients[10]); this->buildup = (int) fabsf(coefficients[10]);
memcpy(&_coeffs[1], coefficients, 10 * sizeof(float)); memcpy(&_coeffs[1], coefficients, 10 * sizeof(float));
fVar6 = 1.f / ( fVar6 = 1.f / (
@ -98,7 +98,7 @@ void Harmonic::UpdateCoeffs(float *coefficients) {
_coeffs[11] = _coeffs[10]; _coeffs[11] = _coeffs[10];
fVar6 = _coeffs[11]; fVar6 = _coeffs[11];
for (int i = 2; i < 11; i++) { for (int i = 2; i < 11; i++) {
for(int idx = 0; idx < i; idx++) { for (int idx = 0; idx < i; idx++) {
_coeffs[11] = fVar6; _coeffs[11] = fVar6;
fVar5 = _coeffs[10 - idx + i]; fVar5 = _coeffs[10 - idx + i];
fVar6 = afStack76[2 - idx + i]; fVar6 = afStack76[2 - idx + i];
@ -116,6 +116,6 @@ void Harmonic::UpdateCoeffs(float *coefficients) {
_coeffs[11] = _coeffs[0] * 0.5f - _coeffs[11]; _coeffs[11] = _coeffs[0] * 0.5f - _coeffs[11];
for (int i = 0; i < 11; i++) { for (int i = 0; i < 11; i++) {
this->coeffs[i] = _coeffs[11+i]; this->coeffs[i] = _coeffs[11 + i];
} }
} }

7
src/cpp/utils/Harmonic.h
View File

@ -10,13 +10,16 @@
class Harmonic { class Harmonic {
public: public:
Harmonic(); Harmonic();
~Harmonic(); ~Harmonic();
float Process(float sample); float Process(float sample);
void Reset(); void Reset();
void SetHarmonics(float* coeffs);
void UpdateCoeffs(float* coeffs); void SetHarmonics(float *coeffs);
void UpdateCoeffs(float *coeffs);
float coeffs[11]; float coeffs[11];
float lastProcessed; float lastProcessed;

14
src/cpp/utils/HiFi.cpp
View File

@ -28,14 +28,14 @@ HiFi::~HiFi() {
void HiFi::Process(float *samples, uint32_t size) { void HiFi::Process(float *samples, uint32_t size) {
if (size > 0) { if (size > 0) {
float* bpBuf = this->buffers[0]->PushZerosGetBuffer(size); float *bpBuf = this->buffers[0]->PushZerosGetBuffer(size);
float* lpBuf = this->buffers[1]->PushZerosGetBuffer(size); float *lpBuf = this->buffers[1]->PushZerosGetBuffer(size);
if (bpBuf == nullptr || lpBuf == nullptr) { if (bpBuf == nullptr || lpBuf == nullptr) {
Reset(); Reset();
return; return;
} }
for (int i = 0; i < size*2; i++) { for (int i = 0; i < size * 2; i++) {
int index = i % 2; int index = i % 2;
float out1 = do_filter_lh(this->filters[index].lowpass, samples[i]); float out1 = do_filter_lh(this->filters[index].lowpass, samples[i]);
float out2 = do_filter_lh(this->filters[index].highpass, samples[i]); float out2 = do_filter_lh(this->filters[index].highpass, samples[i]);
@ -44,8 +44,8 @@ void HiFi::Process(float *samples, uint32_t size) {
lpBuf[i] = out1; lpBuf[i] = out1;
bpBuf[i] = out3; bpBuf[i] = out3;
} }
float* bpOut = this->buffers[0]->GetCurrentBufferI32Ptr(); float *bpOut = this->buffers[0]->GetCurrentBufferI32Ptr();
float* lpOut = this->buffers[1]->GetCurrentBufferI32Ptr(); float *lpOut = this->buffers[1]->GetCurrentBufferI32Ptr();
for (int i = 0; i < size * 2; i++) { for (int i = 0; i < size * 2; i++) {
float hp = samples[i] * this->gain * 1.2f; float hp = samples[i] * this->gain * 1.2f;
float bp = bpOut[i] * this->gain; float bp = bpOut[i] * this->gain;
@ -66,9 +66,9 @@ void HiFi::Reset() {
this->filters[i].bandpass->Mute(); this->filters[i].bandpass->Mute();
} }
this->buffers[0]->Reset(); this->buffers[0]->Reset();
this->buffers[0]->PushZeros(this->samplerate/400); this->buffers[0]->PushZeros(this->samplerate / 400);
this->buffers[1]->Reset(); this->buffers[1]->Reset();
this->buffers[1]->PushZeros(this->samplerate/200); this->buffers[1]->PushZeros(this->samplerate / 200);
} }

13
src/cpp/utils/HiFi.h
View File

@ -12,19 +12,22 @@
class HiFi { class HiFi {
public: public:
HiFi(); HiFi();
~HiFi(); ~HiFi();
void Process(float* samples, uint32_t size); void Process(float *samples, uint32_t size);
void Reset(); void Reset();
void SetClarity(float value); void SetClarity(float value);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
WaveBuffer_I32* buffers[2]; WaveBuffer_I32 *buffers[2];
struct { struct {
IIR_NOrder_BW_LH* lowpass; IIR_NOrder_BW_LH *lowpass;
IIR_NOrder_BW_LH* highpass; IIR_NOrder_BW_LH *highpass;
IIR_NOrder_BW_BP* bandpass; IIR_NOrder_BW_BP *bandpass;
} filters[2]; } filters[2];
float gain; float gain;
uint32_t samplerate; uint32_t samplerate;

3
src/cpp/utils/HighShelf.cpp
View File

@ -6,7 +6,8 @@
#include "HighShelf.h" #include "HighShelf.h"
float HighShelf::Process(float sample) { float HighShelf::Process(float sample) {
float out = sample * this->b0 + this->x_1 * this->b1 + this->x_2 * this->b2 + this->y_1 * this->a1 + this->y_2 * this->a2; float out = sample * this->b0 + this->x_1 * this->b1 + this->x_2 * this->b2 + this->y_1 * this->a1 +
this->y_2 * this->a2;
this->y_2 = this->y_1; this->y_2 = this->y_1;
this->y_1 = out; this->y_1 = out;
this->x_2 = this->x_1; this->x_2 = this->x_1;

4
src/cpp/utils/HighShelf.h
View File

@ -3,6 +3,7 @@
// //
#pragma once #pragma once
#include <cstdint> #include <cstdint>
class HighShelf { class HighShelf {
@ -10,8 +11,11 @@ public:
float Process(float sample); float Process(float sample);
void SetFrequency(uint32_t freq); void SetFrequency(uint32_t freq);
void SetGain(float gain); void SetGain(float gain);
void SetQuality(float q); void SetQuality(float q);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
uint32_t frequency, samplerate; uint32_t frequency, samplerate;

42
src/cpp/utils/IIR_1st.cpp
View File

@ -32,7 +32,7 @@ void IIR_1st::SetCoefficients(float b0, float b1, float a1) {
void IIR_1st::setHPF_A(float frequency, uint32_t samplerate) { void IIR_1st::setHPF_A(float frequency, uint32_t samplerate) {
this->a1 = angle(frequency, samplerate); this->a1 = angle(frequency, samplerate);
float norm = (1+a1)/2.f; float norm = (1 + a1) / 2.f;
this->b0 = norm; this->b0 = norm;
this->b1 = -norm; this->b1 = -norm;
} }
@ -40,22 +40,22 @@ void IIR_1st::setHPF_A(float frequency, uint32_t samplerate) {
void IIR_1st::setHPF_BW(float frequency, uint32_t samplerate) { void IIR_1st::setHPF_BW(float frequency, uint32_t samplerate) {
float omega_2 = omega_2(); float omega_2 = omega_2();
float tan_omega_2 = tanf(omega_2); float tan_omega_2 = tanf(omega_2);
this->b0 = 1/(1+tan_omega_2); this->b0 = 1 / (1 + tan_omega_2);
this->b1 = -this->b0; this->b1 = -this->b0;
this->a1 = (1-tan_omega_2)/(1+tan_omega_2); this->a1 = (1 - tan_omega_2) / (1 + tan_omega_2);
} }
void IIR_1st::setHPF_C(float frequency, uint32_t samplerate) { void IIR_1st::setHPF_C(float frequency, uint32_t samplerate) {
this->b0 = (float)samplerate/((float)samplerate+frequency); this->b0 = (float) samplerate / ((float) samplerate + frequency);
this->b1 = -1 * this->b0; this->b1 = -1 * this->b0;
this->a1 = ((float)samplerate-frequency)/((float)samplerate+frequency); this->a1 = ((float) samplerate - frequency) / ((float) samplerate + frequency);
} }
void IIR_1st::setHPFwLPS_A(float frequency, uint32_t samplerate) { void IIR_1st::setHPFwLPS_A(float frequency, uint32_t samplerate) {
this->a1 = -0.12f; this->a1 = -0.12f;
this->b0 = -1.f; this->b0 = -1.f;
this->b1 = angle(frequency, samplerate); this->b1 = angle(frequency, samplerate);
float norm = (1-this->a1) / fabsf(this->b0 + this->b1); float norm = (1 - this->a1) / fabsf(this->b0 + this->b1);
this->b0 *= norm; this->b0 *= norm;
this->b1 *= norm;; this->b1 *= norm;;
} }
@ -64,7 +64,7 @@ void IIR_1st::setHSF_A(float f1, float f2, uint32_t samplerate) {
this->a1 = angle(f1, samplerate); this->a1 = angle(f1, samplerate);
this->b0 = -1.f; this->b0 = -1.f;
this->b1 = angle(f2, samplerate); this->b1 = angle(f2, samplerate);
float norm = (1-this->a1)/(this->b0 + this->b1); float norm = (1 - this->a1) / (this->b0 + this->b1);
this->b0 *= norm; this->b0 *= norm;
this->b1 *= norm; this->b1 *= norm;
} }
@ -73,7 +73,7 @@ void IIR_1st::setLPF_A(float frequency, uint32_t samplerate) {
this->a1 = angle(frequency, samplerate); this->a1 = angle(frequency, samplerate);
this->b0 = 1.f; this->b0 = 1.f;
this->b1 = 0.12f; this->b1 = 0.12f;
float norm = (1+this->a1)/(this->b0 + this->b1); float norm = (1 + this->a1) / (this->b0 + this->b1);
this->b0 *= norm; this->b0 *= norm;
this->b1 *= norm; this->b1 *= norm;
} }
@ -81,15 +81,15 @@ void IIR_1st::setLPF_A(float frequency, uint32_t samplerate) {
void IIR_1st::setLPF_BW(float frequency, uint32_t samplerate) { void IIR_1st::setLPF_BW(float frequency, uint32_t samplerate) {
float omega_2 = omega_2(); float omega_2 = omega_2();
float tan_omega_2 = tanf(omega_2); float tan_omega_2 = tanf(omega_2);
this->a1 = (1-tan_omega_2)/(1+tan_omega_2); this->a1 = (1 - tan_omega_2) / (1 + tan_omega_2);
this->b0 = tan_omega_2/(1+tan_omega_2); this->b0 = tan_omega_2 / (1 + tan_omega_2);
this->b1 = this->b0; this->b1 = this->b0;
} }
void IIR_1st::setLPF_C(float frequency, uint32_t samplerate) { void IIR_1st::setLPF_C(float frequency, uint32_t samplerate) {
this->b0 = frequency/((float)samplerate+frequency); this->b0 = frequency / ((float) samplerate + frequency);
this->b1 = this->b0; this->b1 = this->b0;
this->a1 = ((float)samplerate-frequency)/((float)samplerate+frequency); this->a1 = ((float) samplerate - frequency) / ((float) samplerate + frequency);
} }
void IIR_1st::setLSF_A(float f1, float f2, uint32_t samplerate) { void IIR_1st::setLSF_A(float f1, float f2, uint32_t samplerate) {
@ -100,7 +100,7 @@ void IIR_1st::setLSF_A(float f1, float f2, uint32_t samplerate) {
void IIR_1st::setPole(float a1) { void IIR_1st::setPole(float a1) {
this->a1 = a1; this->a1 = a1;
this->b0 = 1.f-fabsf(a1); this->b0 = 1.f - fabsf(a1);
this->b1 = 0.f; this->b1 = 0.f;
} }
@ -108,7 +108,7 @@ void IIR_1st::setPoleHPF(float frequency, uint32_t samplerate) {
float omega = omega(); float omega = omega();
float cos_omega = cosf(omega); float cos_omega = cosf(omega);
float tmp = (2.f + cos_omega); float tmp = (2.f + cos_omega);
float coeff = tmp-sqrtf(tmp*tmp-1.f); float coeff = tmp - sqrtf(tmp * tmp - 1.f);
this->a1 = -coeff; this->a1 = -coeff;
this->b0 = 1.f - coeff; this->b0 = 1.f - coeff;
this->b1 = 0; this->b1 = 0;
@ -118,7 +118,7 @@ void IIR_1st::setPoleLPF(float frequency, uint32_t samplerate) {
float omega = omega(); float omega = omega();
float cos_omega = cosf(omega); float cos_omega = cosf(omega);
float tmp = (2.f - cos_omega); float tmp = (2.f - cos_omega);
float coeff = tmp-sqrtf(tmp*tmp-1.f); float coeff = tmp - sqrtf(tmp * tmp - 1.f);
this->a1 = coeff; this->a1 = coeff;
this->b0 = 1.f - coeff; this->b0 = 1.f - coeff;
this->b1 = 0.f; this->b1 = 0.f;
@ -137,18 +137,18 @@ void IIR_1st::setZeroHPF(float frequency, uint32_t samplerate) {
float omega = omega(); float omega = omega();
float cos_omega = cosf(omega); float cos_omega = cosf(omega);
float tmp = (1.f - 2.f * cos_omega); float tmp = (1.f - 2.f * cos_omega);
float coeff = tmp-sqrtf(tmp*tmp-1.f); float coeff = tmp - sqrtf(tmp * tmp - 1.f);
this->a1 = 0.f; this->a1 = 0.f;
this->b0 = 1.f/(1.f+coeff); this->b0 = 1.f / (1.f + coeff);
this->b1 = -coeff/(1.f+coeff); this->b1 = -coeff / (1.f + coeff);
} }
void IIR_1st::setZeroLPF(float frequency, uint32_t samplerate) { void IIR_1st::setZeroLPF(float frequency, uint32_t samplerate) {
float omega = omega(); float omega = omega();
float cos_omega = cosf(omega); float cos_omega = cosf(omega);
float tmp = (1.f + 2.f * cos_omega); float tmp = (1.f + 2.f * cos_omega);
float coeff = tmp-sqrtf(tmp*tmp-1.f); float coeff = tmp - sqrtf(tmp * tmp - 1.f);
this->a1 = 0.f; this->a1 = 0.f;
this->b0 = 1.f/(1.f+coeff); this->b0 = 1.f / (1.f + coeff);
this->b1 = coeff/(1.f+coeff); this->b1 = coeff / (1.f + coeff);
} }

19
src/cpp/utils/IIR_1st.h
View File

@ -3,6 +3,7 @@
// //
#pragma once #pragma once
#include <cstdint> #include <cstdint>
class IIR_1st { class IIR_1st {
@ -10,28 +11,44 @@ public:
IIR_1st(); IIR_1st();
void Mute(); void Mute();
void SetCoefficients(float b0, float b1, float a1); void SetCoefficients(float b0, float b1, float a1);
void setHPF_A(float frequency, uint32_t samplerate); void setHPF_A(float frequency, uint32_t samplerate);
void setHPF_BW(float frequency, uint32_t samplerate); void setHPF_BW(float frequency, uint32_t samplerate);
void setHPF_C(float frequency, uint32_t samplerate); void setHPF_C(float frequency, uint32_t samplerate);
void setHPFwLPS_A(float frequency, uint32_t samplerate); void setHPFwLPS_A(float frequency, uint32_t samplerate);
void setHSF_A(float f1, float f2, uint32_t samplerate); void setHSF_A(float f1, float f2, uint32_t samplerate);
void setLPF_A(float frequency, uint32_t samplerate); void setLPF_A(float frequency, uint32_t samplerate);
void setLPF_BW(float frequency, uint32_t samplerate); void setLPF_BW(float frequency, uint32_t samplerate);
void setLPF_C(float frequency, uint32_t samplerate); void setLPF_C(float frequency, uint32_t samplerate);
void setLSF_A(float f1, float f2, uint32_t samplerate); void setLSF_A(float f1, float f2, uint32_t samplerate);
void setPole(float a1); void setPole(float a1);
void setPoleHPF(float frequency, uint32_t samplerate); void setPoleHPF(float frequency, uint32_t samplerate);
void setPoleLPF(float frequency, uint32_t samplerate); void setPoleLPF(float frequency, uint32_t samplerate);
void setZero(float b1); void setZero(float b1);
void setZeroHPF(float frequency, uint32_t samplerate); void setZeroHPF(float frequency, uint32_t samplerate);
void setZeroLPF(float frequency, uint32_t samplerate); void setZeroLPF(float frequency, uint32_t samplerate);
float b0, b1, a1; float b0, b1, a1;
float prevSample; float prevSample;
}; };
inline float do_filter(IIR_1st* filter, float sample) { inline float do_filter(IIR_1st *filter, float sample) {
float hist = sample * filter->b1; float hist = sample * filter->b1;
sample = filter->prevSample + sample * filter->b0; sample = filter->prevSample + sample * filter->b0;
filter->prevSample = sample * filter->a1 + hist; filter->prevSample = sample * filter->a1 + hist;

12
src/cpp/utils/IIR_NOrder_BW_BP.h
View File

@ -9,30 +9,32 @@
class IIR_NOrder_BW_BP { class IIR_NOrder_BW_BP {
public: public:
explicit IIR_NOrder_BW_BP(uint32_t order); explicit IIR_NOrder_BW_BP(uint32_t order);
~IIR_NOrder_BW_BP(); ~IIR_NOrder_BW_BP();
void Mute(); void Mute();
void setBPF(float highCut, float lowCut, uint32_t samplerate); void setBPF(float highCut, float lowCut, uint32_t samplerate);
IIR_1st* lowpass; IIR_1st *lowpass;
IIR_1st* highpass; IIR_1st *highpass;
uint32_t order; uint32_t order;
}; };
inline float do_filter_bplp(IIR_NOrder_BW_BP* filt, float sample) { inline float do_filter_bplp(IIR_NOrder_BW_BP *filt, float sample) {
for (int idx = 0; idx < filt->order; idx++) { for (int idx = 0; idx < filt->order; idx++) {
sample = do_filter(&filt->lowpass[idx], sample); sample = do_filter(&filt->lowpass[idx], sample);
} }
return sample; return sample;
} }
inline float do_filter_bphp(IIR_NOrder_BW_BP* filt, float sample) { inline float do_filter_bphp(IIR_NOrder_BW_BP *filt, float sample) {
for (int idx = 0; idx < filt->order; idx++) { for (int idx = 0; idx < filt->order; idx++) {
sample = do_filter(&filt->highpass[idx], sample); sample = do_filter(&filt->highpass[idx], sample);
} }
return sample; return sample;
} }
inline float do_filter_bp(IIR_NOrder_BW_BP* filt, float sample) { inline float do_filter_bp(IIR_NOrder_BW_BP *filt, float sample) {
return do_filter_bphp(filt, do_filter_bplp(filt, sample)); return do_filter_bphp(filt, do_filter_bplp(filt, sample));
} }

7
src/cpp/utils/IIR_NOrder_BW_LH.h
View File

@ -9,17 +9,20 @@
class IIR_NOrder_BW_LH { class IIR_NOrder_BW_LH {
public: public:
explicit IIR_NOrder_BW_LH(uint32_t order); explicit IIR_NOrder_BW_LH(uint32_t order);
~IIR_NOrder_BW_LH(); ~IIR_NOrder_BW_LH();
void Mute(); void Mute();
void setLPF(float frequency, uint32_t samplerate); void setLPF(float frequency, uint32_t samplerate);
void setHPF(float frequency, uint32_t samplerate); void setHPF(float frequency, uint32_t samplerate);
IIR_1st* filters; IIR_1st *filters;
uint32_t order; uint32_t order;
}; };
inline float do_filter_lh(IIR_NOrder_BW_LH* filt, float sample) { inline float do_filter_lh(IIR_NOrder_BW_LH *filt, float sample) {
for (int idx = 0; idx < filt->order; idx++) { for (int idx = 0; idx < filt->order; idx++) {
sample = do_filter(&filt->filters[idx], sample); sample = do_filter(&filt->filters[idx], sample);
} }

16
src/cpp/utils/MultiBiquad.cpp
View File

@ -18,7 +18,8 @@ MultiBiquad::MultiBiquad() {
} }
float MultiBiquad::ProcessSample(float sample) { float MultiBiquad::ProcessSample(float sample) {
float out = sample * this->b0 + this->x_1 * this->b1 + this->x_2 * this->b2 + this->y_1 * this->a1 + this->y_2 * this->a2; float out = sample * this->b0 + this->x_1 * this->b1 + this->x_2 * this->b2 + this->y_1 * this->a1 +
this->y_2 * this->a2;
this->y_2 = this->y_1; this->y_2 = this->y_1;
this->y_1 = out; this->y_1 = out;
this->x_2 = this->x_1; this->x_2 = this->x_1;
@ -26,7 +27,8 @@ float MultiBiquad::ProcessSample(float sample) {
return out; return out;
} }
void MultiBiquad::RefreshFilter(FilterType type, float gainAmp, float freq, float samplerate, float qFactor, bool param_7) { void
MultiBiquad::RefreshFilter(FilterType type, float gainAmp, float freq, float samplerate, float qFactor, bool param_7) {
bool uVar1; bool uVar1;
int iVar2; int iVar2;
int iVar3; int iVar3;
@ -45,24 +47,24 @@ void MultiBiquad::RefreshFilter(FilterType type, float gainAmp, float freq, floa
double b1; double b1;
double b2; double b2;
dVar10 = pow(10.0,gainAmp / 40.0); dVar10 = pow(10.0, gainAmp / 40.0);
dVar4 = (freq * 2*M_PI) / samplerate; dVar4 = (freq * 2 * M_PI) / samplerate;
dVar5 = sin(dVar4); dVar5 = sin(dVar4);
dVar11 = cos(dVar4); dVar11 = cos(dVar4);
uVar1 = type == HIGHSHELF; uVar1 = type == HIGHSHELF;
dVar4 = (1.0 / dVar10 + dVar10) * (1.0 / qFactor - 1.0) + 2.0; dVar4 = (1.0 / dVar10 + dVar10) * (1.0 / qFactor - 1.0) + 2.0;
dVar6 = sqrt(dVar4); dVar6 = sqrt(dVar4);
if (!(bool)uVar1) { if (!(bool) uVar1) {
dVar4 = sinh(dVar4); dVar4 = sinh(dVar4);
dVar6 = dVar4; dVar6 = dVar4;
} }
dVar4 = sqrt(dVar10); dVar4 = sqrt(dVar10);
dVar5 = dVar5 * 0.5 * dVar6; dVar5 = dVar5 * 0.5 * dVar6;
if (!(bool)uVar1) { if (!(bool) uVar1) {
dVar4 = sinh(dVar10); dVar4 = sinh(dVar10);
} }
dVar4 = (dVar4 + dVar4) * dVar5; dVar4 = (dVar4 + dVar4) * dVar5;
switch(type) { switch (type) {
case LOWPASS: case LOWPASS:
b1 = 1.0 - dVar11; b1 = 1.0 - dVar11;
dVar10 = b1; dVar10 = b1;

1
src/cpp/utils/MultiBiquad.h
View File

@ -22,6 +22,7 @@ public:
MultiBiquad(); MultiBiquad();
float ProcessSample(float sample); float ProcessSample(float sample);
void RefreshFilter(FilterType type, float gainAmp, float freq, float samplerate, float qFactor, bool param_7); void RefreshFilter(FilterType type, float gainAmp, float freq, float samplerate, float qFactor, bool param_7);
float y_2, y_1, x_2, x_1; float y_2, y_1, x_2, x_1;

8
src/cpp/utils/NoiseSharpening.cpp
View File

@ -13,8 +13,8 @@ NoiseSharpening::NoiseSharpening() {
void NoiseSharpening::Process(float *buffer, uint32_t size) { void NoiseSharpening::Process(float *buffer, uint32_t size) {
for (int i = 0; i < size; i++) { for (int i = 0; i < size; i++) {
float sampleLeft = buffer[i*2]; float sampleLeft = buffer[i * 2];
float sampleRight = buffer[i*2+1]; float sampleRight = buffer[i * 2 + 1];
float prevLeft = this->in[0]; float prevLeft = this->in[0];
float prevRight = this->in[1]; float prevRight = this->in[1];
this->in[0] = sampleLeft; this->in[0] = sampleLeft;
@ -33,8 +33,8 @@ void NoiseSharpening::Process(float *buffer, uint32_t size) {
float right = this->filters[1].prevSample + (sampleRightIn) * this->filters[1].b0; float right = this->filters[1].prevSample + (sampleRightIn) * this->filters[1].b0;
this->filters[1].prevSample = (sampleRightIn) * this->filters[1].a1 + hist; this->filters[1].prevSample = (sampleRightIn) * this->filters[1].a1 + hist;
buffer[i*2] = left; buffer[i * 2] = left;
buffer[i*2+1] = right; buffer[i * 2 + 1] = right;
} }
} }

5
src/cpp/utils/NoiseSharpening.h
View File

@ -11,9 +11,12 @@ class NoiseSharpening {
public: public:
NoiseSharpening(); NoiseSharpening();
void Process(float* buffer, uint32_t size); void Process(float *buffer, uint32_t size);
void Reset(); void Reset();
void SetGain(float gain); void SetGain(float gain);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
IIR_1st filters[2]; IIR_1st filters[2];

4
src/cpp/utils/PConvSingle_F32.cpp
View File

@ -56,7 +56,7 @@ int PConvSingle_F32::LoadKernel(float *buf, int param_2, int segmentSize) {
if (param_2 > 0 && segmentSize > 0 && segmentSize % 2 == 0) { if (param_2 > 0 && segmentSize > 0 && segmentSize % 2 == 0) {
this->enabled = false; this->enabled = false;
ReleaseResources(); ReleaseResources();
this->data = (PConvData *)malloc(0x140); // TODO: Sizeof this->data = (PConvData *) malloc(0x140); // TODO: Sizeof
memset(this->data, 0, 0x140); // Ditto memset(this->data, 0, 0x140); // Ditto
this->segmentSize = segmentSize; this->segmentSize = segmentSize;
int n = ProcessKernel(buf, param_2, 1); int n = ProcessKernel(buf, param_2, 1);
@ -76,7 +76,7 @@ int PConvSingle_F32::LoadKernel(float *buf, float *param_2, int segmentSize, int
if (param_5 > 0 && segmentSize > 0 && segmentSize % 2 == 0) { if (param_5 > 0 && segmentSize > 0 && segmentSize % 2 == 0) {
this->enabled = false; this->enabled = false;
ReleaseResources(); ReleaseResources();
this->data = (PConvData *)malloc(0x140); // TODO: Sizeof this->data = (PConvData *) malloc(0x140); // TODO: Sizeof
memset(this->data, 0, 0x140); // Ditto memset(this->data, 0, 0x140); // Ditto
this->segmentSize = segmentSize; this->segmentSize = segmentSize;
int n = ProcessKernel(1, param_2, param_4, param_5); int n = ProcessKernel(1, param_2, param_4, param_5);

50
src/cpp/utils/PConvSingle_F32.h
View File

@ -8,46 +8,58 @@ typedef struct {
int unk_0x00; int unk_0x00;
int unk_0x04; int unk_0x04;
int unk_0x08; int unk_0x08;
float* unk_buffer; float *unk_buffer;
float* fftInputBuffer; float *fftInputBuffer;
float* fftOutputBuffer; float *fftOutputBuffer;
float* unk_buffer_2; float *unk_buffer_2;
float* unk_buffer_3; float *unk_buffer_3;
int size_A; int size_A;
void* field_A1; void *field_A1;
void* field_A2; void *field_A2;
int size_B; int size_B;
void* field_B1; void *field_B1;
void* field_B2; void *field_B2;
int* unk_0x120; int *unk_0x120;
void* fft_plan_1; void *fft_plan_1;
void* fft_plan_2; void *fft_plan_2;
} PConvData; } PConvData;
class PConvSingle_F32 { class PConvSingle_F32 {
public: public:
PConvSingle_F32(); PConvSingle_F32();
~PConvSingle_F32(); ~PConvSingle_F32();
void Reset(); void Reset();
int GetFFTSize(); int GetFFTSize();
int GetSegmentCount(); int GetSegmentCount();
int GetSegmentSize(); int GetSegmentSize();
bool InstanceUsable(); bool InstanceUsable();
void Convolve(float* buffer); void Convolve(float *buffer);
void ConvolveInterleaved(float* buffer, int channel);
void ConvSegment(float* buffer, bool interleaved, int channel); void ConvolveInterleaved(float *buffer, int channel);
void ConvSegment(float *buffer, bool interleaved, int channel);
int LoadKernel(float *buf, int param_2, int segmentSize);
int LoadKernel(float *buf, float *param_2, int segmentSize, int param_4, int param_5);
int ProcessKernel(float *param_1, int param_2, int param_3);
int LoadKernel(float* buf, int param_2, int segmentSize);
int LoadKernel(float* buf, float* param_2, int segmentSize, int param_4, int param_5);
int ProcessKernel(float* param_1, int param_2, int param_3);
int ProcessKernel(int param_2, float *param_3, int param_4, int param_5); int ProcessKernel(int param_2, float *param_3, int param_4, int param_5);
void ReleaseResources(); void ReleaseResources();
void UnloadKernel(); void UnloadKernel();
bool enabled; bool enabled;
int segments, segmentSize; int segments, segmentSize;
PConvData* data; // TODO: Type PConvData *data; // TODO: Type
}; };

12
src/cpp/utils/PassFilter.cpp
View File

@ -29,8 +29,8 @@ void PassFilter::Reset() {
cutoff = 18000; cutoff = 18000;
} }
this->filters[0]->setLPF((float)cutoff, this->samplerate); this->filters[0]->setLPF((float) cutoff, this->samplerate);
this->filters[1]->setLPF((float)cutoff, this->samplerate); this->filters[1]->setLPF((float) cutoff, this->samplerate);
this->filters[2]->setLPF(10.f, cutoff); this->filters[2]->setLPF(10.f, cutoff);
this->filters[3]->setLPF(10.f, cutoff); this->filters[3]->setLPF(10.f, cutoff);
@ -42,16 +42,16 @@ void PassFilter::Reset() {
void PassFilter::ProcessFrames(float *buffer, uint32_t size) { void PassFilter::ProcessFrames(float *buffer, uint32_t size) {
for (int x = 0; x < size; x++) { for (int x = 0; x < size; x++) {
float left = buffer[2*x]; float left = buffer[2 * x];
float right = buffer[2*x+1]; float right = buffer[2 * x + 1];
left = do_filter_lh(this->filters[2], left); left = do_filter_lh(this->filters[2], left);
left = do_filter_lh(this->filters[0], left); left = do_filter_lh(this->filters[0], left);
right = do_filter_lh(this->filters[3], right); right = do_filter_lh(this->filters[3], right);
right = do_filter_lh(this->filters[1], right); right = do_filter_lh(this->filters[1], right);
buffer[2*x] = left; buffer[2 * x] = left;
buffer[2*x+1] = right; buffer[2 * x + 1] = right;
} }
} }

7
src/cpp/utils/PassFilter.h
View File

@ -10,12 +10,15 @@
class PassFilter { class PassFilter {
public: public:
PassFilter(); PassFilter();
~PassFilter(); ~PassFilter();
void Reset(); void Reset();
void ProcessFrames(float* buffer, uint32_t size);
void ProcessFrames(float *buffer, uint32_t size);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
IIR_NOrder_BW_LH* filters[4]; IIR_NOrder_BW_LH *filters[4];
uint32_t samplerate; uint32_t samplerate;
}; };

10
src/cpp/utils/PolesFilter.cpp
View File

@ -22,13 +22,13 @@ void PolesFilter::UpdateCoeff() {
memset(&this->channels[0], 0, sizeof(channel)); memset(&this->channels[0], 0, sizeof(channel));
memset(&this->channels[1], 0, sizeof(channel)); memset(&this->channels[1], 0, sizeof(channel));
this->channels[0].lower_angle = ((float)this->lower_freq * M_PI / (float)this->samplerate); this->channels[0].lower_angle = ((float) this->lower_freq * M_PI / (float) this->samplerate);
this->channels[1].lower_angle = ((float)this->lower_freq * M_PI / (float)this->samplerate); this->channels[1].lower_angle = ((float) this->lower_freq * M_PI / (float) this->samplerate);
this->channels[0].upper_angle = ((float)this->upper_freq * M_PI / (float)this->samplerate); this->channels[0].upper_angle = ((float) this->upper_freq * M_PI / (float) this->samplerate);
this->channels[1].upper_angle = ((float)this->upper_freq * M_PI / (float)this->samplerate); this->channels[1].upper_angle = ((float) this->upper_freq * M_PI / (float) this->samplerate);
} }
inline void DoFilterSide(channel* side, float sample, float* out1, float* out2, float* out3) { inline void DoFilterSide(channel *side, float sample, float *out1, float *out2, float *out3) {
float oldestSampleIn = side->in[2]; float oldestSampleIn = side->in[2];
side->in[2] = side->in[1]; side->in[2] = side->in[1];
side->in[1] = side->in[0]; side->in[1] = side->in[0];

8
src/cpp/utils/PolesFilter.h
View File

@ -21,11 +21,15 @@ public:
PolesFilter(); PolesFilter();
void Reset(); void Reset();
void UpdateCoeff(); void UpdateCoeff();
void DoFilterLeft(float sample, float* out1, float* out2, float* out3);
void DoFilterRight(float sample, float* out1, float* out2, float* out3); void DoFilterLeft(float sample, float *out1, float *out2, float *out3);
void DoFilterRight(float sample, float *out1, float *out2, float *out3);
void SetPassFilter(uint32_t lower_freq, uint32_t upper_freq); void SetPassFilter(uint32_t lower_freq, uint32_t upper_freq);
void SetSamplingRate(uint32_t samplerate); void SetSamplingRate(uint32_t samplerate);
channel channels[2]; channel channels[2];

14
src/cpp/utils/Subwoofer.cpp
View File

@ -7,7 +7,7 @@
#include <cmath> #include <cmath>
Subwoofer::Subwoofer() { Subwoofer::Subwoofer() {
float samplerate = (float)DEFAULT_SAMPLERATE; float samplerate = (float) DEFAULT_SAMPLERATE;
this->peak[0].RefreshFilter(FilterType::PEAK, 0.f, 37.f, samplerate, 1.f, false); this->peak[0].RefreshFilter(FilterType::PEAK, 0.f, 37.f, samplerate, 1.f, false);
this->peak[1].RefreshFilter(FilterType::PEAK, 0.f, 37.f, samplerate, 1.f, false); this->peak[1].RefreshFilter(FilterType::PEAK, 0.f, 37.f, samplerate, 1.f, false);
this->peakLow[0].RefreshFilter(FilterType::PEAK, 0.f, 75.f, samplerate, 1.f, false); this->peakLow[0].RefreshFilter(FilterType::PEAK, 0.f, 75.f, samplerate, 1.f, false);
@ -31,10 +31,10 @@ void Subwoofer::SetBassGain(uint32_t samplerate, float gainDb) {
float gain = 20.f * log10f(gainDb); float gain = 20.f * log10f(gainDb);
float gainLower = 20.f * log10f(gainDb / 8.f); float gainLower = 20.f * log10f(gainDb / 8.f);
this->peak[0].RefreshFilter(FilterType::PEAK, gain, 44.f, (float)samplerate, 0.75, true); this->peak[0].RefreshFilter(FilterType::PEAK, gain, 44.f, (float) samplerate, 0.75, true);
this->peak[1].RefreshFilter(FilterType::PEAK, gain, 44.f, (float)samplerate, 0.75, true); this->peak[1].RefreshFilter(FilterType::PEAK, gain, 44.f, (float) samplerate, 0.75, true);
this->peakLow[0].RefreshFilter(FilterType::PEAK, gainLower, 80.f, (float)samplerate, 0.2, true); this->peakLow[0].RefreshFilter(FilterType::PEAK, gainLower, 80.f, (float) samplerate, 0.2, true);
this->peakLow[1].RefreshFilter(FilterType::PEAK, gainLower, 80.f, (float)samplerate, 0.2, true); this->peakLow[1].RefreshFilter(FilterType::PEAK, gainLower, 80.f, (float) samplerate, 0.2, true);
this->lowpass[0].RefreshFilter(FilterType::LOWPASS, 0.f, 380.f, (float)samplerate, 0.6, false); this->lowpass[0].RefreshFilter(FilterType::LOWPASS, 0.f, 380.f, (float) samplerate, 0.6, false);
this->lowpass[1].RefreshFilter(FilterType::LOWPASS, 0.f, 380.f, (float)samplerate, 0.6, false); this->lowpass[1].RefreshFilter(FilterType::LOWPASS, 0.f, 380.f, (float) samplerate, 0.6, false);
} }

2
src/cpp/utils/Subwoofer.h
View File

@ -12,7 +12,7 @@ class Subwoofer {
public: public:
Subwoofer(); Subwoofer();
void Process(float* samples, uint32_t size); void Process(float *samples, uint32_t size);
void SetBassGain(uint32_t samplerate, float gainDb); void SetBassGain(uint32_t samplerate, float gainDb);

4
src/cpp/utils/TimeConstDelay.cpp
View File

@ -23,14 +23,14 @@ float TimeConstDelay::ProcessSample(float sample) {
if (this->samples != nullptr) { if (this->samples != nullptr) {
float val = this->samples[this->offset]; float val = this->samples[this->offset];
this->samples[this->offset] = sample; this->samples[this->offset] = sample;
this->offset = (int)modf((float)this->offset + 1, (float*)&this->sampleCount); this->offset = (int) modf((float) this->offset + 1, (float *) &this->sampleCount);
return val; return val;
} }
return 0.f; return 0.f;
} }
void TimeConstDelay::SetParameters(uint32_t samplerate, float delay) { void TimeConstDelay::SetParameters(uint32_t samplerate, float delay) {
this->sampleCount = (int)((float)samplerate * delay * 0.5f); this->sampleCount = (int) ((float) samplerate * delay * 0.5f);
if (this->samples != nullptr) { if (this->samples != nullptr) {
free(this->samples); free(this->samples);
} }

4
src/cpp/utils/TimeConstDelay.h
View File

@ -8,12 +8,14 @@
class TimeConstDelay { class TimeConstDelay {
public: public:
TimeConstDelay(); TimeConstDelay();
~TimeConstDelay(); ~TimeConstDelay();
float ProcessSample(float sample); float ProcessSample(float sample);
void SetParameters(uint32_t samplerate, float delay); void SetParameters(uint32_t samplerate, float delay);
float* samples; float *samples;
uint32_t offset; uint32_t offset;
uint32_t sampleCount; uint32_t sampleCount;
}; };

12
src/cpp/utils/WaveBuffer_I32.cpp
View File

@ -10,7 +10,7 @@ WaveBuffer_I32::WaveBuffer_I32(int channels, uint32_t size) {
this->channels = channels; this->channels = channels;
this->size = size * channels; this->size = size * channels;
this->index = 0; this->index = 0;
this->buffer = (float*)malloc(this->size * sizeof(float)); this->buffer = (float *) malloc(this->size * sizeof(float));
} }
WaveBuffer_I32::~WaveBuffer_I32() { WaveBuffer_I32::~WaveBuffer_I32() {
@ -40,7 +40,7 @@ uint32_t WaveBuffer_I32::PopSamples(uint32_t size, bool resetIndex) {
if (this->channels * size <= this->index) { if (this->channels * size <= this->index) {
this->index -= this->channels * size; this->index -= this->channels * size;
memmove(this->buffer, &this->buffer[this->channels*size], this->index * sizeof(float)); memmove(this->buffer, &this->buffer[this->channels * size], this->index * sizeof(float));
return size; return size;
} }
@ -61,7 +61,7 @@ uint32_t WaveBuffer_I32::PopSamples(float *dest, uint32_t size, bool resetIndex)
if (this->channels * size <= this->index) { if (this->channels * size <= this->index) {
memcpy(dest, this->buffer, this->index * sizeof(float)); memcpy(dest, this->buffer, this->index * sizeof(float));
this->index -= this->channels * size; this->index -= this->channels * size;
memmove(this->buffer, &this->buffer[this->channels*size], this->index * sizeof(float)); memmove(this->buffer, &this->buffer[this->channels * size], this->index * sizeof(float));
return size; return size;
} }
@ -82,7 +82,7 @@ int WaveBuffer_I32::PushSamples(float *source, uint32_t size) {
if (size > 0) { if (size > 0) {
if (this->size < this->channels * size + this->index) { if (this->size < this->channels * size + this->index) {
float* buf = (float*)malloc((this->channels * size + this->index) * sizeof(float)); float *buf = (float *) malloc((this->channels * size + this->index) * sizeof(float));
if (buf == nullptr) { if (buf == nullptr) {
return 0; return 0;
} }
@ -105,7 +105,7 @@ int WaveBuffer_I32::PushZeros(uint32_t size) {
if (size > 0) { if (size > 0) {
if (this->size < this->channels * size + this->index) { if (this->size < this->channels * size + this->index) {
float* buf = (float*)malloc((this->channels * size + this->index) * sizeof(float)); float *buf = (float *) malloc((this->channels * size + this->index) * sizeof(float));
if (buf == nullptr) { if (buf == nullptr) {
return 0; return 0;
} }
@ -128,7 +128,7 @@ float *WaveBuffer_I32::PushZerosGetBuffer(uint32_t size) {
if (size > 0) { if (size > 0) {
if (this->size < this->channels * size + this->index) { if (this->size < this->channels * size + this->index) {
float* buf = (float*)malloc((this->channels * size + this->index) * sizeof(float)); float *buf = (float *) malloc((this->channels * size + this->index) * sizeof(float));
if (buf == nullptr) { if (buf == nullptr) {
return nullptr; return nullptr;
} }

19
src/cpp/utils/WaveBuffer_I32.h
View File

@ -10,21 +10,30 @@
class WaveBuffer_I32 { class WaveBuffer_I32 {
public: public:
WaveBuffer_I32(int channels, uint32_t size); WaveBuffer_I32(int channels, uint32_t size);
~WaveBuffer_I32(); ~WaveBuffer_I32();
void Reset(); void Reset();
uint32_t GetBufferOffset(); uint32_t GetBufferOffset();
uint32_t GetBufferSize(); uint32_t GetBufferSize();
float* GetCurrentBufferI32Ptr();
float *GetCurrentBufferI32Ptr();
uint32_t PopSamples(uint32_t size, bool resetIndex); uint32_t PopSamples(uint32_t size, bool resetIndex);
uint32_t PopSamples(float* dest, uint32_t size, bool resetIndex);
int PushSamples(float* source, uint32_t size); uint32_t PopSamples(float *dest, uint32_t size, bool resetIndex);
int PushSamples(float *source, uint32_t size);
int PushZeros(uint32_t size); int PushZeros(uint32_t size);
float* PushZerosGetBuffer(uint32_t size);
float *PushZerosGetBuffer(uint32_t size);
void SetBufferOffset(uint32_t offset); void SetBufferOffset(uint32_t offset);
float* buffer; float *buffer;
uint32_t size; uint32_t size;
uint32_t index; uint32_t index;
int channels; int channels;

256
src/cpp/viper.cpp
View File

@ -7,8 +7,8 @@
static effect_descriptor_t viper_descriptor = { static effect_descriptor_t viper_descriptor = {
// Identical type/uuid to original ViPER4Android // Identical type/uuid to original ViPER4Android
.type = {0x00000000, 0x0000, 0x0000, 0x0000, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }, .type = {0x00000000, 0x0000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
.uuid = {0x41d3c987, 0xe6cf, 0x11e3, 0xa88a, { 0x11, 0xab, 0xa5, 0xd5, 0xc5, 0x1b } }, .uuid = {0x41d3c987, 0xe6cf, 0x11e3, 0xa88a, {0x11, 0xab, 0xa5, 0xd5, 0xc5, 0x1b}},
.apiVersion = EFFECT_CONTROL_API_VERSION, .apiVersion = EFFECT_CONTROL_API_VERSION,
.flags = EFFECT_FLAG_OUTPUT_BOTH | EFFECT_FLAG_INPUT_BOTH | EFFECT_FLAG_INSERT_LAST | EFFECT_FLAG_TYPE_INSERT, .flags = EFFECT_FLAG_OUTPUT_BOTH | EFFECT_FLAG_INPUT_BOTH | EFFECT_FLAG_INSERT_LAST | EFFECT_FLAG_TYPE_INSERT,
.cpuLoad = 8, // In 0.1 MIPS units as estimated on an ARM9E core (ARMv5TE) with 0 WS .cpuLoad = 8, // In 0.1 MIPS units as estimated on an ARM9E core (ARMv5TE) with 0 WS
@ -16,147 +16,153 @@ static effect_descriptor_t viper_descriptor = {
}; };
extern "C" { extern "C" {
struct ViperContext { struct ViperContext {
const struct effect_interface_s *interface; const struct effect_interface_s *interface;
ProcessUnit_FX *effect; ProcessUnit_FX *effect;
effect_descriptor_t *descriptor; effect_descriptor_t *descriptor;
}; };
static int32_t viper_process(effect_handle_t self, audio_buffer_t *in, audio_buffer_t *out) { static int32_t viper_process(effect_handle_t self, audio_buffer_t *in, audio_buffer_t *out) {
auto pContext = (ViperContext *) self; auto pContext = (ViperContext *) self;
if (pContext == nullptr) { if (pContext == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_process(), Error [pContext = NULL]"); v4a_printf(ANDROID_LOG_ERROR, "viper_process(), Error [pContext = NULL]");
return -EINVAL; return -EINVAL;
}
if (in == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_process(), Error [in = NULL]");
return -EINVAL;
}
if (out == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_process(), Error [out = NULL]");
return -EINVAL;
}
return pContext->effect->process(in, out);
} }
static int32_t viper_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize, void *pCmdData, uint32_t *replySize, void *pReplyData) { if (in == nullptr) {
auto pContext = (ViperContext *) self; v4a_printf(ANDROID_LOG_ERROR, "viper_process(), Error [in = NULL]");
return -EINVAL;
if (pContext == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_command(), Error [pContext = NULL]");
return -EINVAL;
}
return pContext->effect->command(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
} }
static int32_t viper_get_descriptor(effect_handle_t self, effect_descriptor_t *pDescriptor) { if (out == nullptr) {
auto *pContext = (ViperContext *) self; v4a_printf(ANDROID_LOG_ERROR, "viper_process(), Error [out = NULL]");
return -EINVAL;
if (pContext == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_get_descriptor(), Error [pContext = NULL]");
return -EINVAL;
}
if (pDescriptor == nullptr) {
v4a_print(ANDROID_LOG_ERROR, "viper_get_descriptor(), Error [pDescriptor = NULL]");
return -EINVAL;
}
*pDescriptor = *pContext->descriptor;
return 0;
} }
const effect_interface_s viper_interface = { return pContext->effect->process(in, out);
}
static int32_t
viper_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize, void *pCmdData, uint32_t *replySize,
void *pReplyData) {
auto pContext = (ViperContext *) self;
if (pContext == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_command(), Error [pContext = NULL]");
return -EINVAL;
}
return pContext->effect->command(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
}
static int32_t viper_get_descriptor(effect_handle_t self, effect_descriptor_t *pDescriptor) {
auto *pContext = (ViperContext *) self;
if (pContext == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_get_descriptor(), Error [pContext = NULL]");
return -EINVAL;
}
if (pDescriptor == nullptr) {
v4a_print(ANDROID_LOG_ERROR, "viper_get_descriptor(), Error [pDescriptor = NULL]");
return -EINVAL;
}
*pDescriptor = *pContext->descriptor;
return 0;
}
const effect_interface_s viper_interface = {
.process = viper_process, .process = viper_process,
.command = viper_command, .command = viper_command,
.get_descriptor = viper_get_descriptor .get_descriptor = viper_get_descriptor
}; };
int32_t viper_effect_create(const effect_uuid_t *uuid, int32_t sessionId, int32_t ioId, effect_handle_t *pHandle) { int32_t viper_effect_create(const effect_uuid_t *uuid, int32_t sessionId, int32_t ioId, effect_handle_t *pHandle) {
v4a_print(ANDROID_LOG_INFO, "Enter viper_effect_create()"); v4a_print(ANDROID_LOG_INFO, "Enter viper_effect_create()");
if (uuid == nullptr) { if (uuid == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_effect_create(), Error [uuid = NULL]"); v4a_printf(ANDROID_LOG_ERROR, "viper_effect_create(), Error [uuid = NULL]");
return -EINVAL; return -EINVAL;
}
if (pHandle == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_effect_create(), Error [pHandle = NULL]");
return -EINVAL;
}
if (memcmp(uuid, &viper_descriptor.uuid, sizeof(effect_uuid_t)) != 0) {
v4a_print(ANDROID_LOG_ERROR, "viper_effect_create(), Error [effect not found]");
return -EINVAL;
}
v4a_printf(ANDROID_LOG_INFO, "viper_effect_create(), uuid = %08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x", uuid->timeLow, uuid->timeMid, uuid->timeHiAndVersion, uuid->clockSeq, uuid->node[0], uuid->node[1], uuid->node[2], uuid->node[3], uuid->node[4], uuid->node[5]);
v4a_print(ANDROID_LOG_INFO, "viper_effect_create(), v4a standard effect (normal), Constructing ProcessUnit_FX");
auto *pContext = new ViperContext;
pContext->interface = &viper_interface;
pContext->effect = new ProcessUnit_FX();
pContext->descriptor = &viper_descriptor;
v4a_print(ANDROID_LOG_INFO, "Creating ViPER4Android Reworked [" VERSION_STRING "]");
*pHandle = (effect_handle_t) pContext;
return 0;
} }
int32_t viper_effect_release(effect_handle_t handle) { if (pHandle == nullptr) {
auto *pContext = (ViperContext *) handle; v4a_printf(ANDROID_LOG_ERROR, "viper_effect_create(), Error [pHandle = NULL]");
return -EINVAL;
v4a_print(ANDROID_LOG_INFO, "Enter viper_effect_release()");
if (pContext == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_effect_release(), Error [pContext = NULL]");
return -EINVAL;
}
v4a_print(ANDROID_LOG_INFO, "viper_effect_release(), Deconstructing ProcessUnit");
if (pContext->effect != nullptr) {
delete pContext->effect;
pContext->effect = nullptr;
}
delete pContext;
return 0;
} }
int32_t viper_effect_get_descriptor(const effect_uuid_t *uuid, effect_descriptor_t *pDescriptor) { if (memcmp(uuid, &viper_descriptor.uuid, sizeof(effect_uuid_t)) != 0) {
v4a_print(ANDROID_LOG_INFO, "Enter viper_effect_get_descriptor()"); v4a_print(ANDROID_LOG_ERROR, "viper_effect_create(), Error [effect not found]");
return -EINVAL;
if (uuid == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_effect_get_descriptor(), Error [uuid = NULL]");
return -EINVAL;
}
if (pDescriptor == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_effect_get_descriptor(), Error [pDescriptor = NULL]");
return -EINVAL;
}
if (memcmp(uuid, &viper_descriptor.uuid, sizeof(effect_uuid_t)) != 0) {
v4a_print(ANDROID_LOG_ERROR, "viper_effect_get_descriptor(), Error [effect not found]");
return -EINVAL;
}
v4a_printf(ANDROID_LOG_INFO, "viper_effect_get_descriptor(), uuid = %08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x", uuid->timeLow, uuid->timeMid, uuid->timeHiAndVersion, uuid->clockSeq, uuid->node[0], uuid->node[1], uuid->node[2], uuid->node[3], uuid->node[4], uuid->node[5]);
*pDescriptor = viper_descriptor;
return 0;
} }
audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = { v4a_printf(ANDROID_LOG_INFO, "viper_effect_create(), uuid = %08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x",
uuid->timeLow, uuid->timeMid, uuid->timeHiAndVersion, uuid->clockSeq, uuid->node[0], uuid->node[1],
uuid->node[2], uuid->node[3], uuid->node[4], uuid->node[5]);
v4a_print(ANDROID_LOG_INFO, "viper_effect_create(), v4a standard effect (normal), Constructing ProcessUnit_FX");
auto *pContext = new ViperContext;
pContext->interface = &viper_interface;
pContext->effect = new ProcessUnit_FX();
pContext->descriptor = &viper_descriptor;
v4a_print(ANDROID_LOG_INFO, "Creating ViPER4Android Reworked [" VERSION_STRING "]");
*pHandle = (effect_handle_t) pContext;
return 0;
}
int32_t viper_effect_release(effect_handle_t handle) {
auto *pContext = (ViperContext *) handle;
v4a_print(ANDROID_LOG_INFO, "Enter viper_effect_release()");
if (pContext == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_effect_release(), Error [pContext = NULL]");
return -EINVAL;
}
v4a_print(ANDROID_LOG_INFO, "viper_effect_release(), Deconstructing ProcessUnit");
if (pContext->effect != nullptr) {
delete pContext->effect;
pContext->effect = nullptr;
}
delete pContext;
return 0;
}
int32_t viper_effect_get_descriptor(const effect_uuid_t *uuid, effect_descriptor_t *pDescriptor) {
v4a_print(ANDROID_LOG_INFO, "Enter viper_effect_get_descriptor()");
if (uuid == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_effect_get_descriptor(), Error [uuid = NULL]");
return -EINVAL;
}
if (pDescriptor == nullptr) {
v4a_printf(ANDROID_LOG_ERROR, "viper_effect_get_descriptor(), Error [pDescriptor = NULL]");
return -EINVAL;
}
if (memcmp(uuid, &viper_descriptor.uuid, sizeof(effect_uuid_t)) != 0) {
v4a_print(ANDROID_LOG_ERROR, "viper_effect_get_descriptor(), Error [effect not found]");
return -EINVAL;
}
v4a_printf(ANDROID_LOG_INFO, "viper_effect_get_descriptor(), uuid = %08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x",
uuid->timeLow, uuid->timeMid, uuid->timeHiAndVersion, uuid->clockSeq, uuid->node[0], uuid->node[1],
uuid->node[2], uuid->node[3], uuid->node[4], uuid->node[5]);
*pDescriptor = viper_descriptor;
return 0;
}
audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = {
.tag = AUDIO_EFFECT_LIBRARY_TAG, .tag = AUDIO_EFFECT_LIBRARY_TAG,
.version = EFFECT_LIBRARY_API_VERSION, .version = EFFECT_LIBRARY_API_VERSION,
.name = "ViPER4Android FX Reworked", .name = "ViPER4Android FX Reworked",
@ -164,5 +170,5 @@ extern "C" {
.create_effect = viper_effect_create, .create_effect = viper_effect_create,
.release_effect = viper_effect_release, .release_effect = viper_effect_release,
.get_descriptor = viper_effect_get_descriptor, .get_descriptor = viper_effect_get_descriptor,
}; };
} }

282
src/cpp/viper.h
View File

@ -7,154 +7,154 @@
// Source: https://github.com/vipersaudio/viperfx_core_binary/blob/master/viperfx_intf.h // Source: https://github.com/vipersaudio/viperfx_core_binary/blob/master/viperfx_intf.h
extern "C" { extern "C" {
enum ParamsMode { enum ParamsMode {
COMMAND_CODE_GET = 0x01, COMMAND_CODE_GET = 0x01,
COMMAND_CODE_SET, COMMAND_CODE_SET,
}; };
enum ParamsGet { enum ParamsGet {
PARAM_GET_STATUS_BEGIN = 0x08000, PARAM_GET_STATUS_BEGIN = 0x08000,
PARAM_GET_DRIVER_VERSION, PARAM_GET_DRIVER_VERSION,
PARAM_GET_NEONENABLED, PARAM_GET_NEONENABLED,
PARAM_GET_ENABLED, PARAM_GET_ENABLED,
PARAM_GET_DRVCANWORK, PARAM_GET_DRVCANWORK,
PARAM_GET_EFFECT_TYPE, PARAM_GET_EFFECT_TYPE,
PARAM_GET_SAMPLINGRATE, PARAM_GET_SAMPLINGRATE,
PARAM_GET_CONVKNLID, PARAM_GET_CONVKNLID,
PARAM_GET_STATUS_END PARAM_GET_STATUS_END
}; };
enum ParamsSet { enum ParamsSet {
PARAM_SET_STATUS_BEGIN = 0x09000, PARAM_SET_STATUS_BEGIN = 0x09000,
PARAM_SET_RESET_STATUS, PARAM_SET_RESET_STATUS,
PARAM_SET_SAMPLINGRATE, PARAM_SET_SAMPLINGRATE,
PARAM_SET_DOPROCESS_STATUS, PARAM_SET_DOPROCESS_STATUS,
PARAM_SET_STATUS_END PARAM_SET_STATUS_END
}; };
enum ParamsConfigure { enum ParamsConfigure {
PARAM_PROCESSUNIT_FX_BEGIN = 0x10000, PARAM_PROCESSUNIT_FX_BEGIN = 0x10000,
PARAM_FX_TYPE_SWITCH, PARAM_FX_TYPE_SWITCH,
PARAM_HPFX_CONV_PROCESS_ENABLED, PARAM_HPFX_CONV_PROCESS_ENABLED,
PARAM_HPFX_CONV_UPDATEKERNEL, PARAM_HPFX_CONV_UPDATEKERNEL,
/*****************************************/ /*****************************************/
// Please use PARAM_HPFX_CONV_UPDATEKERNEL instead // Please use PARAM_HPFX_CONV_UPDATEKERNEL instead
PARAM_HPFX_CONV_PREPAREBUFFER, PARAM_HPFX_CONV_PREPAREBUFFER,
PARAM_HPFX_CONV_SETBUFFER, PARAM_HPFX_CONV_SETBUFFER,
PARAM_HPFX_CONV_COMMITBUFFER, PARAM_HPFX_CONV_COMMITBUFFER,
/*****************************************/ /*****************************************/
PARAM_HPFX_CONV_CROSSCHANNEL, PARAM_HPFX_CONV_CROSSCHANNEL,
PARAM_HPFX_VHE_PROCESS_ENABLED, PARAM_HPFX_VHE_PROCESS_ENABLED,
PARAM_HPFX_VHE_EFFECT_LEVEL, PARAM_HPFX_VHE_EFFECT_LEVEL,
PARAM_HPFX_VDDC_PROCESS_ENABLED, PARAM_HPFX_VDDC_PROCESS_ENABLED,
PARAM_HPFX_VDDC_COEFFS, PARAM_HPFX_VDDC_COEFFS,
PARAM_HPFX_VSE_PROCESS_ENABLED, PARAM_HPFX_VSE_PROCESS_ENABLED,
PARAM_HPFX_VSE_REFERENCE_BARK, PARAM_HPFX_VSE_REFERENCE_BARK,
PARAM_HPFX_VSE_BARK_RECONSTRUCT, PARAM_HPFX_VSE_BARK_RECONSTRUCT,
PARAM_HPFX_FIREQ_PROCESS_ENABLED, PARAM_HPFX_FIREQ_PROCESS_ENABLED,
PARAM_HPFX_FIREQ_BANDLEVEL, PARAM_HPFX_FIREQ_BANDLEVEL,
PARAM_HPFX_COLM_PROCESS_ENABLED, PARAM_HPFX_COLM_PROCESS_ENABLED,
PARAM_HPFX_COLM_WIDENING, PARAM_HPFX_COLM_WIDENING,
PARAM_HPFX_COLM_MIDIMAGE, PARAM_HPFX_COLM_MIDIMAGE,
PARAM_HPFX_COLM_DEPTH, PARAM_HPFX_COLM_DEPTH,
PARAM_HPFX_DIFFSURR_PROCESS_ENABLED, PARAM_HPFX_DIFFSURR_PROCESS_ENABLED,
PARAM_HPFX_DIFFSURR_DELAYTIME, PARAM_HPFX_DIFFSURR_DELAYTIME,
PARAM_HPFX_REVB_PROCESS_ENABLED, PARAM_HPFX_REVB_PROCESS_ENABLED,
PARAM_HPFX_REVB_ROOMSIZE, PARAM_HPFX_REVB_ROOMSIZE,
PARAM_HPFX_REVB_WIDTH, PARAM_HPFX_REVB_WIDTH,
PARAM_HPFX_REVB_DAMP, PARAM_HPFX_REVB_DAMP,
PARAM_HPFX_REVB_WET, PARAM_HPFX_REVB_WET,
PARAM_HPFX_REVB_DRY, PARAM_HPFX_REVB_DRY,
PARAM_HPFX_AGC_PROCESS_ENABLED, PARAM_HPFX_AGC_PROCESS_ENABLED,
PARAM_HPFX_AGC_RATIO, PARAM_HPFX_AGC_RATIO,
PARAM_HPFX_AGC_VOLUME, PARAM_HPFX_AGC_VOLUME,
PARAM_HPFX_AGC_MAXSCALER, PARAM_HPFX_AGC_MAXSCALER,
PARAM_HPFX_DYNSYS_PROCESS_ENABLED, PARAM_HPFX_DYNSYS_PROCESS_ENABLED,
PARAM_HPFX_DYNSYS_XCOEFFS, PARAM_HPFX_DYNSYS_XCOEFFS,
PARAM_HPFX_DYNSYS_YCOEFFS, PARAM_HPFX_DYNSYS_YCOEFFS,
PARAM_HPFX_DYNSYS_SIDEGAIN, PARAM_HPFX_DYNSYS_SIDEGAIN,
PARAM_HPFX_DYNSYS_BASSGAIN, PARAM_HPFX_DYNSYS_BASSGAIN,
PARAM_HPFX_VIPERBASS_PROCESS_ENABLED, PARAM_HPFX_VIPERBASS_PROCESS_ENABLED,
PARAM_HPFX_VIPERBASS_MODE, PARAM_HPFX_VIPERBASS_MODE,
PARAM_HPFX_VIPERBASS_SPEAKER, PARAM_HPFX_VIPERBASS_SPEAKER,
PARAM_HPFX_VIPERBASS_BASSGAIN, PARAM_HPFX_VIPERBASS_BASSGAIN,
PARAM_HPFX_VIPERCLARITY_PROCESS_ENABLED, PARAM_HPFX_VIPERCLARITY_PROCESS_ENABLED,
PARAM_HPFX_VIPERCLARITY_MODE, PARAM_HPFX_VIPERCLARITY_MODE,
PARAM_HPFX_VIPERCLARITY_CLARITY, PARAM_HPFX_VIPERCLARITY_CLARITY,
PARAM_HPFX_CURE_PROCESS_ENABLED, PARAM_HPFX_CURE_PROCESS_ENABLED,
PARAM_HPFX_CURE_CROSSFEED, PARAM_HPFX_CURE_CROSSFEED,
PARAM_HPFX_TUBE_PROCESS_ENABLED, PARAM_HPFX_TUBE_PROCESS_ENABLED,
PARAM_HPFX_ANALOGX_PROCESS_ENABLED, PARAM_HPFX_ANALOGX_PROCESS_ENABLED,
PARAM_HPFX_ANALOGX_MODE, PARAM_HPFX_ANALOGX_MODE,
PARAM_HPFX_OUTPUT_VOLUME, PARAM_HPFX_OUTPUT_VOLUME,
PARAM_HPFX_OUTPUT_PAN, PARAM_HPFX_OUTPUT_PAN,
PARAM_HPFX_LIMITER_THRESHOLD, PARAM_HPFX_LIMITER_THRESHOLD,
PARAM_SPKFX_CONV_PROCESS_ENABLED, PARAM_SPKFX_CONV_PROCESS_ENABLED,
PARAM_SPKFX_CONV_UPDATEKERNEL, PARAM_SPKFX_CONV_UPDATEKERNEL,
PARAM_SPKFX_CONV_PREPAREBUFFER, PARAM_SPKFX_CONV_PREPAREBUFFER,
PARAM_SPKFX_CONV_SETBUFFER, PARAM_SPKFX_CONV_SETBUFFER,
PARAM_SPKFX_CONV_COMMITBUFFER, PARAM_SPKFX_CONV_COMMITBUFFER,
PARAM_SPKFX_CONV_CROSSCHANNEL, PARAM_SPKFX_CONV_CROSSCHANNEL,
PARAM_SPKFX_FIREQ_PROCESS_ENABLED, PARAM_SPKFX_FIREQ_PROCESS_ENABLED,
PARAM_SPKFX_FIREQ_BANDLEVEL, PARAM_SPKFX_FIREQ_BANDLEVEL,
PARAM_SPKFX_REVB_PROCESS_ENABLED, PARAM_SPKFX_REVB_PROCESS_ENABLED,
PARAM_SPKFX_REVB_ROOMSIZE, PARAM_SPKFX_REVB_ROOMSIZE,
PARAM_SPKFX_REVB_WIDTH, PARAM_SPKFX_REVB_WIDTH,
PARAM_SPKFX_REVB_DAMP, PARAM_SPKFX_REVB_DAMP,
PARAM_SPKFX_REVB_WET, PARAM_SPKFX_REVB_WET,
PARAM_SPKFX_REVB_DRY, PARAM_SPKFX_REVB_DRY,
PARAM_SPKFX_AGC_PROCESS_ENABLED, PARAM_SPKFX_AGC_PROCESS_ENABLED,
PARAM_SPKFX_AGC_RATIO, PARAM_SPKFX_AGC_RATIO,
PARAM_SPKFX_AGC_VOLUME, PARAM_SPKFX_AGC_VOLUME,
PARAM_SPKFX_AGC_MAXSCALER, PARAM_SPKFX_AGC_MAXSCALER,
PARAM_SPKFX_OUTPUT_VOLUME, PARAM_SPKFX_OUTPUT_VOLUME,
PARAM_SPKFX_LIMITER_THRESHOLD, PARAM_SPKFX_LIMITER_THRESHOLD,
PARAM_HPFX_FETCOMP_PROCESS_ENABLED, PARAM_HPFX_FETCOMP_PROCESS_ENABLED,
PARAM_HPFX_FETCOMP_THRESHOLD, PARAM_HPFX_FETCOMP_THRESHOLD,
PARAM_HPFX_FETCOMP_RATIO, PARAM_HPFX_FETCOMP_RATIO,
PARAM_HPFX_FETCOMP_KNEEWIDTH, PARAM_HPFX_FETCOMP_KNEEWIDTH,
PARAM_HPFX_FETCOMP_AUTOKNEE_ENABLED, PARAM_HPFX_FETCOMP_AUTOKNEE_ENABLED,
PARAM_HPFX_FETCOMP_GAIN, PARAM_HPFX_FETCOMP_GAIN,
PARAM_HPFX_FETCOMP_AUTOGAIN_ENABLED, PARAM_HPFX_FETCOMP_AUTOGAIN_ENABLED,
PARAM_HPFX_FETCOMP_ATTACK, PARAM_HPFX_FETCOMP_ATTACK,
PARAM_HPFX_FETCOMP_AUTOATTACK_ENABLED, PARAM_HPFX_FETCOMP_AUTOATTACK_ENABLED,
PARAM_HPFX_FETCOMP_RELEASE, PARAM_HPFX_FETCOMP_RELEASE,
PARAM_HPFX_FETCOMP_AUTORELEASE_ENABLED, PARAM_HPFX_FETCOMP_AUTORELEASE_ENABLED,
PARAM_HPFX_FETCOMP_META_KNEEMULTI, PARAM_HPFX_FETCOMP_META_KNEEMULTI,
PARAM_HPFX_FETCOMP_META_MAXATTACK, PARAM_HPFX_FETCOMP_META_MAXATTACK,
PARAM_HPFX_FETCOMP_META_MAXRELEASE, PARAM_HPFX_FETCOMP_META_MAXRELEASE,
PARAM_HPFX_FETCOMP_META_CREST, PARAM_HPFX_FETCOMP_META_CREST,
PARAM_HPFX_FETCOMP_META_ADAPT, PARAM_HPFX_FETCOMP_META_ADAPT,
PARAM_HPFX_FETCOMP_META_NOCLIP_ENABLED, PARAM_HPFX_FETCOMP_META_NOCLIP_ENABLED,
PARAM_SPKFX_FETCOMP_PROCESS_ENABLED, PARAM_SPKFX_FETCOMP_PROCESS_ENABLED,
PARAM_SPKFX_FETCOMP_THRESHOLD, PARAM_SPKFX_FETCOMP_THRESHOLD,
PARAM_SPKFX_FETCOMP_RATIO, PARAM_SPKFX_FETCOMP_RATIO,
PARAM_SPKFX_FETCOMP_KNEEWIDTH, PARAM_SPKFX_FETCOMP_KNEEWIDTH,
PARAM_SPKFX_FETCOMP_AUTOKNEE_ENABLED, PARAM_SPKFX_FETCOMP_AUTOKNEE_ENABLED,
PARAM_SPKFX_FETCOMP_GAIN, PARAM_SPKFX_FETCOMP_GAIN,
PARAM_SPKFX_FETCOMP_AUTOGAIN_ENABLED, PARAM_SPKFX_FETCOMP_AUTOGAIN_ENABLED,
PARAM_SPKFX_FETCOMP_ATTACK, PARAM_SPKFX_FETCOMP_ATTACK,
PARAM_SPKFX_FETCOMP_AUTOATTACK_ENABLED, PARAM_SPKFX_FETCOMP_AUTOATTACK_ENABLED,
PARAM_SPKFX_FETCOMP_RELEASE, PARAM_SPKFX_FETCOMP_RELEASE,
PARAM_SPKFX_FETCOMP_AUTORELEASE_ENABLED, PARAM_SPKFX_FETCOMP_AUTORELEASE_ENABLED,
PARAM_SPKFX_FETCOMP_META_KNEEMULTI, PARAM_SPKFX_FETCOMP_META_KNEEMULTI,
PARAM_SPKFX_FETCOMP_META_MAXATTACK, PARAM_SPKFX_FETCOMP_META_MAXATTACK,
PARAM_SPKFX_FETCOMP_META_MAXRELEASE, PARAM_SPKFX_FETCOMP_META_MAXRELEASE,
PARAM_SPKFX_FETCOMP_META_CREST, PARAM_SPKFX_FETCOMP_META_CREST,
PARAM_SPKFX_FETCOMP_META_ADAPT, PARAM_SPKFX_FETCOMP_META_ADAPT,
PARAM_SPKFX_FETCOMP_META_NOCLIP_ENABLED, PARAM_SPKFX_FETCOMP_META_NOCLIP_ENABLED,
PARAM_PROCESSUNIT_FX_END PARAM_PROCESSUNIT_FX_END
}; };
enum FxMode { enum FxMode {
ViPER_FX_TYPE_NONE = 0, ViPER_FX_TYPE_NONE = 0,
ViPER_FX_TYPE_HEADPHONE = 1, ViPER_FX_TYPE_HEADPHONE = 1,
ViPER_FX_TYPE_SPEAKER = 2, ViPER_FX_TYPE_SPEAKER = 2,
ViPER_FX_TYPE_COUNT ViPER_FX_TYPE_COUNT
}; };
} }