|
#pragma once
|
|
#include <stdio.h>
|
#include <vector>
|
#include "Parameters.h"
|
#include "ReverbChannel.h"
|
#include "AllpassDiffuser.h"
|
#include "MultitapDelay.h"
|
#include "Utils.h"
|
|
namespace ReverbHallRoom
|
{
|
class ReverbController
|
{
|
private:
|
int samplerate;
|
|
ReverbChannel channelL;
|
ReverbChannel channelR;
|
double parameters[(int)Parameter::COUNT] = {0};
|
|
public:
|
ReverbController(int samplerate = 48000) :
|
channelL(samplerate, ChannelLR::Left),
|
channelR(samplerate, ChannelLR::Right)
|
{
|
this->samplerate = samplerate;
|
}
|
|
int GetSamplerate()
|
{
|
return samplerate;
|
}
|
|
void SetSamplerate(int samplerate)
|
{
|
this->samplerate = samplerate;
|
channelL.SetSamplerate(samplerate);
|
channelR.SetSamplerate(samplerate);
|
}
|
|
int GetParameterCount()
|
{
|
return Parameter::COUNT;
|
}
|
|
double* GetAllParameters()
|
{
|
return parameters;
|
}
|
|
void SetParameter(int paramId, double value)
|
{
|
parameters[paramId] = value;
|
auto scaled = ScaleParam(value, paramId);
|
channelL.SetParameter(paramId, scaled);
|
channelR.SetParameter(paramId, scaled);
|
}
|
|
void ClearBuffers()
|
{
|
channelL.ClearBuffers();
|
channelR.ClearBuffers();
|
}
|
|
void Process(float* inL, float* inR, float* outL, float* outR, int bufSize)
|
{
|
float outLTemp[BUFFER_SIZE];
|
float outRTemp[BUFFER_SIZE];
|
|
while (bufSize > 0)
|
{
|
int subBufSize = bufSize > BUFFER_SIZE ? BUFFER_SIZE : bufSize;
|
ProcessChunk(inL, inR, outLTemp, outRTemp, subBufSize);
|
Utils::Copy(outL, outLTemp, subBufSize);
|
Utils::Copy(outR, outRTemp, subBufSize);
|
inL = &inL[subBufSize];
|
inR = &inR[subBufSize];
|
outL = &outL[subBufSize];
|
outR = &outR[subBufSize];
|
bufSize -= subBufSize;
|
}
|
}
|
|
private:
|
void ProcessChunk(float* inL, float* inR, float* outL, float* outR, int bufSize)
|
{
|
float leftChannelIn[BUFFER_SIZE];
|
float rightChannelIn[BUFFER_SIZE];
|
|
float inputMix = ScaleParam(parameters[Parameter::InputMix], Parameter::InputMix);
|
float cm = inputMix * 0.5;
|
float cmi = (1 - cm);
|
|
for (int i = 0; i < bufSize; i++)
|
{
|
leftChannelIn[i] = inL[i] * cmi + inR[i] * cm;
|
rightChannelIn[i] = inR[i] * cmi + inL[i] * cm;
|
}
|
|
channelL.Process(leftChannelIn, outL, bufSize);
|
channelR.Process(rightChannelIn, outR, bufSize);
|
}
|
};
|
}
|
