void JbcfilterAudioProcessor::setParameter (int index, float newValue)
{
switch (index) {
case cutoffParam:
cutoff = newValue;
printf("new cutoff %f\n", cutoff);
updateCoefficients(cutoff);
break;
case delayParam:
delay = newValue;
printf("new delay %f\n", delay);
break;
//case gainParam:
// gain = newValue;
break;
case distortionEnabledParam:
distortionEnabledFlag = newValue > 0.5f;
break;
case distortionParam:
distortion = newValue;
break;
default:
break;
}
}
MultiFilter::MultiFilter(FilterType type, float sampleRate, float defaultFreq) {
updateSampleRate(sampleRate);
fType = type;
frequency = defaultFreq;
dbGain = 0.f;
q = 0.71f;
filter = *new stk::BiQuad();
updateCoefficients();
}
void BiquadDSPKernel::getFrequencyResponse(int nFrequencies, const float* frequencyHz, float* magResponse, float* phaseResponse)
{
bool isGood = nFrequencies > 0 && frequencyHz && magResponse && phaseResponse;
ASSERT(isGood);
if (!isGood)
return;
Vector<float> frequency(nFrequencies);
double nyquist = this->nyquist();
// Convert from frequency in Hz to normalized frequency (0 -> 1),
// with 1 equal to the Nyquist frequency.
for (int k = 0; k < nFrequencies; ++k)
frequency[k] = narrowPrecisionToFloat(frequencyHz[k] / nyquist);
double cutoffFrequency;
double Q;
double gain;
double detune; // in Cents
{
// Get a copy of the current biquad filter coefficients so we can update the biquad with
// these values. We need to synchronize with process() to prevent process() from updating
// the filter coefficients while we're trying to access them. The process will update it
// next time around.
//
// The BiquadDSPKernel object here (along with it's Biquad object) is for querying the
// frequency response and is NOT the same as the one in process() which is used for
// performing the actual filtering. This one is is created in
// BiquadProcessor::getFrequencyResponse for this purpose. Both, however, point to the same
// BiquadProcessor object.
//
// FIXME: Simplify this: crbug.com/390266
MutexLocker processLocker(m_processLock);
cutoffFrequency = biquadProcessor()->parameter1().value();
Q = biquadProcessor()->parameter2().value();
gain = biquadProcessor()->parameter3().value();
detune = biquadProcessor()->parameter4().value();
}
updateCoefficients(cutoffFrequency, Q, gain, detune);
m_biquad.getFrequencyResponse(nFrequencies, frequency.data(), magResponse, phaseResponse);
}
void BiquadDSPKernel::updateCoefficientsIfNecessary()
{
if (biquadProcessor()->filterCoefficientsDirty()) {
double cutoffFrequency;
double Q;
double gain;
double detune; // in Cents
if (biquadProcessor()->hasSampleAccurateValues()) {
cutoffFrequency = biquadProcessor()->parameter1().finalValue();
Q = biquadProcessor()->parameter2().finalValue();
gain = biquadProcessor()->parameter3().finalValue();
detune = biquadProcessor()->parameter4().finalValue();
} else {
cutoffFrequency = biquadProcessor()->parameter1().smoothedValue();
Q = biquadProcessor()->parameter2().smoothedValue();
gain = biquadProcessor()->parameter3().smoothedValue();
detune = biquadProcessor()->parameter4().smoothedValue();
}
updateCoefficients(cutoffFrequency, Q, gain, detune);
}
}
void MultiFilter::changeFilterType(FilterType type) {
fType = type;
updateCoefficients();
}
void MultiFilter::updateSampleRate(float newSampleRate) {
fs = newSampleRate;
updateCoefficients();
}
// asynchronous step solver
int e_trsolver::stepsolve_async(nr_double_t steptime)
{
// Start to sweep through time.
int error = 0;
convError = 0;
time = steptime;
// update the interpolation time of any externally controlled
// components which require it.
updateExternalInterpTime(time);
// make the stored histories for all ircuits that have
// requested them at least as long as the next major time
// step so we can reject the step later if needed and
// restore all the histories to their previous state
updateHistoryAges (time - lastasynctime);
//delta = (steptime - time) / 10;
//if (progress) logprogressbar (i, swp->getSize (), 40);
#if DEBUG && 0
messagefcn (LOG_STATUS, "NOTIFY: %s: solving netlist for t = %e\n",
getName (), (double) time);
#endif
do
{
#if STEPDEBUG
if (delta == deltaMin)
{
messagefcn (LOG_ERROR,
"WARNING: %s: minimum delta h = %.3e at t = %.3e\n",
getName (), (double) delta, (double) current);
}
#endif
// update the integration coefficients
updateCoefficients (delta);
// Run predictor to get a start value for the solution vector for
// the successive iterative corrector process
error += predictor ();
// restart Newton iteration
if (rejected)
{
restart (); // restart non-linear devices
rejected = 0;
}
// Run corrector process with appropriate exception handling.
// The corrector iterates through the solutions of the integration
// process until a certain error tolerance has been reached.
try_running () // #defined as: do {
{
error += corrector ();
}
catch_exception () // #defined as: } while (0); if (estack.top ()) switch (estack.top()->getCode ())
{
case EXCEPTION_NO_CONVERGENCE:
pop_exception ();
// Reduce step-size (by half) if failed to converge.
if (current > 0) current -= delta;
delta /= 2;
if (delta <= deltaMin)
{
delta = deltaMin;
adjustOrder (1);
}
if (current > 0) current += delta;
// Update statistics.
statRejected++;
statConvergence++;
rejected++;
converged = 0;
error = 0;
// Start using damped Newton-Raphson.
convHelper = CONV_SteepestDescent;
convError = 2;
#if DEBUG
messagefcn (LOG_ERROR, "WARNING: delta rejected at t = %.3e, h = %.3e "
"(no convergence)\n", (double) saveCurrent, (double) delta);
#endif
break;
default:
// Otherwise return.
estack.print ();
error++;
break;
}
if (error) return -1;
if (rejected) continue;
// check whether Jacobian matrix is still non-singular
if (!A->isFinite ())
{
messagefcn (LOG_ERROR, "ERROR: %s: Jacobian singular at t = %.3e, "
"aborting %s analysis\n", getName (), (double) current,
getDescription ().c_str());
return -1;
}
// Update statistics and no more damped Newton-Raphson.
statIterations += iterations;
if (--convError < 0) convHelper = 0;
// Now advance in time or not...
if (running > 1)
{
adjustDelta (time);
adjustOrder ();
}
else
{
fillStates ();
nextStates ();
rejected = 0;
}
saveCurrent = current;
current += delta;
running++;
converged++;
// Tell integrators to be running.
setMode (MODE_NONE);
// Initialize or update history.
if (running > 1)
{
updateHistory (saveCurrent);
}
else
{
initHistory (saveCurrent);
}
}
while (saveCurrent < time); // Hit a requested time point?
return 0;
}
/* synchronous step solver for external ode routine
*
* This function solves the circuit for a single time delta provided
* by an external source. Convergence issues etc. are expected to
* be handled by the external solver, as it is in full control of the
* time stepping.
*/
int e_trsolver::stepsolve_sync(nr_double_t synctime)
{
int error = 0;
convError = 0;
time = synctime;
// update the interpolation time of any externally controlled
// components which require it.
updateExternalInterpTime(time);
// copy the externally chosen time step to delta
delta = time - lastsynctime;
// get the current solution time
//current += delta;
// updates the integrator coefficients, and updates the array of prev
// 8 deltas with the new delta for this step
updateCoefficients (delta);
// Run predictor to get a start value for the solution vector for
// the successive iterative corrector process
error += predictor ();
// restart Newton iteration
restart (); // restart non-linear devices
// Attempt to solve the circuit with the given delta
try_running () // #defined as: do {
{
//error += solve_nonlinear_step ();
error += corrector ();
}
catch_exception () // #defined as: } while (0); if (estack.top ()) switch (estack.top()->getCode ())
{
case EXCEPTION_NO_CONVERGENCE:
pop_exception ();
// Retry using damped Newton-Raphson.
this->convHelper = CONV_SteepestDescent;
convError = 2;
#if DEBUG
messagefcn (LOG_ERROR, "WARNING: delta rejected at t = %.3e, h = %.3e "
"(no convergence)\n", (double) saveCurrent, (double) delta);
#endif
try_running () // #defined as: do {
{
// error += solve_nonlinear_step ();
error += solve_nonlinear ();
}
catch_exception () // #defined as: } while (0); if (estack.top ()) switch (estack.top()->getCode ())
{
case EXCEPTION_NO_CONVERGENCE:
pop_exception ();
// Update statistics.
statRejected++;
statConvergence++;
rejected++;
converged = 0;
error = 0;
break;
default:
// Otherwise return.
estack.print ();
error++;
break;
}
// Update statistics and no more damped Newton-Raphson.
// statIterations += iterations;
// if (--convError < 0) this->convHelper = 0;
break;
default:
// Otherwise return.
estack.print ();
error++;
break;
}
// if there was an error other than non-convergence, return -1
if (error) return -1;
// check whether Jacobian matrix is still non-singular
if (!A->isFinite ())
{
// messagefcn (LOG_ERROR, "ERROR: %s: Jacobian singular at t = %.3e, "
// "aborting %s analysis\n", getName (), (double) current,
// getDescription ());
return -1;
}
return 0;
}
void AudioSourceTone::setParameters(const float32_t sampleRate, const float32_t frequency, const float32_t amplitude) {
_sampleRate = std::max(sampleRate, 1.0f);
_frequency = std::max(frequency, 1.0f);
_amplitude = std::max(amplitude, 1.0f);
updateCoefficients();
}
void ToneFilter::setFs(float newFs){
fs=newFs;
updateCoefficients();
}
void ToneFilter::setTone(float newTone){ //float tone must be a float between 0 and 1 (no check is performed)
tone=newTone;
updateCoefficients();
}