DigitalMayhemPatch() : fs(getSampleRate()) {
registerParameter(PARAMETER_A, "Sampling Freq");
registerParameter(PARAMETER_B, "Mayhem Rate");
registerParameter(PARAMETER_C, "Mayhem Freq");
registerParameter(PARAMETER_D, "Mayhem Depth");
mayhem_freq = 1; //starting freq = 1*fs/size = 375 Hz
inc_flag = 1;
update_freq_cnt = 0;
prev_freq = 0;
}
void SquareGenerator::setFreq(uint16_t f)
{
if (f == 0) { // Silence
freq = f;
std::fill_n(samples, getSampleRate(), 0);
buff_size = getSampleRate() / INV_LATENCY;
return;
}
// ejem... Nyquist theorem
auto sr_2 = getSampleRate() /2;
f = f > sr_2 ? sr_2 : f;
if (f < INV_LATENCY) { // We not need to use all buffer
buff_size = (size_t)( std::ceil(getSampleRate() / (double)(f)));
} else {
buff_size = (size_t)(std::ceil(getSampleRate() / (double)(INV_LATENCY)));
}
freq = f;
}
void startNote (const int midiNoteNumber, const float velocity,
SynthesiserSound* /*sound*/, const int /*currentPitchWheelPosition*/)
{
currentAngle = 0.0;
level = velocity * 0.15;
tailOff = 0.0;
double cyclesPerSecond = MidiMessage::getMidiNoteInHertz (midiNoteNumber);
double cyclesPerSample = cyclesPerSecond / getSampleRate();
angleDelta = cyclesPerSample * 2.0 * double_Pi;
}
void startNote (int midiNoteNumber, float velocity,
SynthesiserSound* /*sound*/, int /*currentPitchWheelPosition*/)
{
playing = keyHeld;
currentAngle = 0.0;
for (int i = 0; i < HARMONICS; i++) {
levels[i] = 0.25;
}
level = velocity * 0.015;
const double cyclesPerSecond = MidiMessage::getMidiNoteInHertz (midiNoteNumber);
const double cyclesPerSample = cyclesPerSecond / getSampleRate();
// the angleDelta for the base frequency.
angleDelta = cyclesPerSample;
// reset o1
o1_angle = 0.0;
o1_angleDelta = o1_freq / getSampleRate();
}
Convolver2::Convolver2(audioMasterCallback audioMaster)
: AudioEffectX(audioMaster, 0, NUM_PARAMS) {
setNumInputs(NUM_INPUTS);
setNumOutputs(NUM_OUTPUTS);
setUniqueID(UNIQUE_ID);
editor = new Convolver2Editor(this);
core = new Convolver2Core(NUM_PARAMS, VERSION, DEF_PRODUCT);
core->setParameter(PRM_SAMPLE_RATE, getSampleRate(), true);
((Convolver2Editor*)editor)->setCore(core);
((Convolver2Core*)core)->setEditor((Convolver2Editor*)editor);
}
HarmonicOscillatorPatch(){
registerParameter(PARAMETER_A, "Tune");
registerParameter(PARAMETER_B, "Rate");
registerParameter(PARAMETER_C, "H2");
registerParameter(PARAMETER_D, "H3");
registerParameter(PARAMETER_E, "H4");
wavetable = FloatArray::create(samples);
osc = new WavetableOscillator(getSampleRate(), wavetable);
osc->setFrequency(440);
harms.setGlauberState(0.5);
harms.calculate(wavetable, samples);
}
void ZynWise::processReplacing(float **inputs, float **outputs, VstInt32 frames)
{
// original ZynAddSubFx code
float *outl = outputs[0];
float *outr = outputs[1];
EnterCriticalSection(&_zasf.vmaster->mutex);
_zasf.vmaster->GetAudioOutSamples(frames,
(int) getSampleRate(), outl, outr);
LeaveCriticalSection(&_zasf.vmaster->mutex);
}
void FilterNode::setFilterParameters()
{
Dsp::Params params;
params[0] = getSampleRate(); // sample rate
params[1] = 4; // order
params[2] = (highCut + lowCut)/2; // center frequency
params[3] = highCut - lowCut; // bandwidth
if (filter != 0)
filter->setParams (params);
}
void
Model::toXml(QTextStream &stream, QString indent,
QString extraAttributes) const
{
stream << indent;
stream << QString("<model id=\"%1\" name=\"%2\" sampleRate=\"%3\" start=\"%4\" end=\"%5\" %6/>\n")
.arg(getObjectExportId(this))
.arg(encodeEntities(objectName()))
.arg(getSampleRate())
.arg(getStartFrame())
.arg(getEndFrame())
.arg(extraAttributes);
}
void OutputDeviceNodeXAudio::initSourceVoice()
{
CI_ASSERT( ! mSourceVoice );
auto context = dynamic_pointer_cast<ContextXAudio>( getContext() );
auto wfx = msw::interleavedFloatWaveFormat( getSampleRate(), getNumChannels() );
IXAudio2 *xaudio = context->getXAudio();
UINT32 flags = ( mFilterEnabled ? XAUDIO2_VOICE_USEFILTER : 0 );
HRESULT hr = xaudio->CreateSourceVoice( &mSourceVoice, wfx.get(), flags, XAUDIO2_DEFAULT_FREQ_RATIO, mVoiceCallback.get() );
CI_ASSERT( hr == S_OK );
}
void SourceFile::seek( size_t readPositionFrames )
{
if( readPositionFrames >= mNumFrames )
return;
// adjust read pos for samplerate conversion so that it is relative to file num frames
size_t fileReadPos = readPositionFrames;
if( getSampleRate() != getSampleRateNative() )
fileReadPos *= size_t( (float)mFileNumFrames / (float)mNumFrames );
performSeek( fileReadPos );
mReadPos = readPositionFrames;
}
void mdaThruZero::resume() ///update internal parameters...
{
float * param = programs[curProgram].param;
rat = (float)(pow(10.0f, 3.f * param[0] - 2.f) * 2.f / getSampleRate());
dep = 2000.0f * param[1] * param[1];
dem = dep - dep * param[4];
dep -= dem;
wet = param[2];
dry = 1.f - wet;
if(param[0]<0.01f) { rat=0.0f; phi=(float)0.0f; }
fb = 1.9f * param[3] - 0.95f;
}
//------------------------------------------------------------------------
// resume()
// equivalent of prepareForPlay()
// NOTE: Ableton only calls this once
// and streams 0s throught the Plug-in when inactive!
void CSoftExciter::resume()
{
// prepare for play; flush buffers, etc...
m_fSampleRate = getSampleRate();
// set sample rate
// forward the prepareForPlay() call
if(m_pRAFXPlugIn)
{
m_pRAFXPlugIn->m_nSampleRate = (int)m_fSampleRate;
m_pRAFXPlugIn->prepareForPlay();
}
}
void NewProjectAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
{
if(editorIsReady)
newNotesFromAnalyser->sendActionMessage("N");
if(analyseNewFile){
analyseNewFile = false;
MessageManager* mm = MessageManager::getInstance();
void* dummy = this;
void* d = mm->callFunctionOnMessageThread(loadNewWaveFile, dummy);
}
// This is the place where you'd normally do the guts of your plugin's
// audio processing...
for (int channel = 0; channel < getNumInputChannels(); ++channel)
{
}
// In case we have more outputs than inputs, we'll clear any output
// channels that didn't contain input data, (because these aren't
// guaranteed to be empty - they may contain garbage).
for (int i = getNumInputChannels(); i < getNumOutputChannels(); ++i)
{
buffer.clear (i, 0, buffer.getNumSamples());
}
AudioPlayHead* playHead = getPlayHead();
AudioPlayHead::CurrentPositionInfo info;
playHead->getCurrentPosition(info);
float* channelData = buffer.getSampleData (0);
if(soundEditor != 0 && !loadingNewComponent)
soundEditor->getAudioSamplesToPlay(buffer, info.ppqPositionOfLastBarStart, getSampleRate(), currentSamplesPerBlock);
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API RezFilterController::getParamStringByValue (ParamID tag, ParamValue valueNormalized, String128 string)
{
UString128 result;
switch (tag)
{
case 4:
{
float att = (float)pow (10.0, -0.01 - 4.0 * valueNormalized);
result.printFloat (-301.0301 / (getSampleRate () * log10(1.0 - att)), 2);
break;
}
case 5:
{
float rel = 1.f - (float)pow (10.0, -2.00 - 4.0 * valueNormalized);
result.printFloat (-301.0301 / (getSampleRate () * log10(rel)), 2);
break;
}
case 7:
{
result.printFloat (pow (10.0f, (float)(4.f*valueNormalized - 2.f)), 2);
break;
}
case 8:
{
float tthr = 0;
if (valueNormalized<0.1f) tthr=0.f; else tthr = 3.f * valueNormalized * valueNormalized;
if (tthr == 0)
result.fromAscii("FREE RUN");
else
result.printFloat (20*log10 (0.5*tthr), 2);
break;
}
default:
return BaseController::getParamStringByValue (tag, valueNormalized, string);
}
result.copyTo (string, 128);
return kResultTrue;
}
//==============================================================================
Mcfx_delayAudioProcessor::Mcfx_delayAudioProcessor() : _delay_ms(0.f),
_delay_smpls(0),
_delay_buffer(2,256),
_buf_write_pos(0),
_buf_read_pos(0),
_buf_size(256)
{
_samplerate = getSampleRate();
if (_samplerate == 0.f) {
_samplerate = 44100.f;
}
}
/******************************************************************
*Método set_HPF da Classe AelIIR
*Parâmetros: void
*Define comportamento high pass do filtro
*******************************************************************/
void AelButterWorth::set_HPF(){
ON = highpass;
float y = tan( (M_PI * cutoff) / getSampleRate() );
float pow_2 = pow(y, 2);
coef_a[0] = 1 / ( 1 + (2 * y) + pow_2) ;
coef_a[1] = -2 * coef_a[0];
coef_a[2] = coef_a[0];
coef_b[0] = -coef_a[1] * ( pow_2 - 1 );
coef_b[1] = coef_a[0] * ( 1 - ( 2 * y ) + pow_2 );
}
unsigned int AmRtpAudio::conceal_loss(unsigned int ts_diff, unsigned char *buffer)
{
int s=0;
if(!use_default_plc){
amci_codec_t* codec = fmt->getCodec();
long h_codec = fmt->getHCodec();
assert(codec && codec->plc);
s = (*codec->plc)(buffer, PCM16_S2B(ts_diff),
fmt->channels,getSampleRate(),h_codec);
DBG("codec specific PLC (ts_diff = %i; s = %i)\n",ts_diff,s);
}
else {
s = default_plc(buffer, PCM16_S2B(ts_diff),
fmt->channels,getSampleRate());
DBG("default PLC (ts_diff = %i; s = %i)\n",ts_diff,s);
}
return s;
}
int AudioCapture::startAudioClient()
{
start();
connectToPhysical(0, 0); // Connect output to port 0
SettingsMgr::getInstance()->setSampleRate(getSampleRate());
if (isRealTime())
logger_->writeLog(my_name_, "Jack is real time");
else
logger_->writeLog(my_name_, "Jack is not real time");
return 0;
}
void mdaRePsycho::getParameterDisplay(int32_t index, char *text)
{
switch(index)
{
case 3: long2string((long)((30.0 * fParam1) - 30.0), text); break;
case 2: long2string((long)((fParam2 - 0.5) * 100.0), text); break;
case 0: long2string((long)(int(24.0 * fParam3) - 24.0), text); break;
case 5: long2string((long)(100.0 * fParam4), text); break;
case 4: long2string((long)(1000.0 * dtim / getSampleRate()), text); break;
case 1: long2string((long)(int(99.0 * fParam6) - 99.0), text); break;
case 6: if(fParam7>0.0) strcpy(text, "HIGH");
else strcpy(text, "LOW"); break;
}
}
/******************************************************************
*Método set_LPF da Classe AelIIR
*Parâmetros: void
*Define comportamento LOW pass do filtro
*******************************************************************/
void AelButterWorth::set_LPF(){
ON = lowpass;
float y = 1 / tan( (M_PI * cutoff) / getSampleRate() );
float pow_2 = pow(y, 2);
coef_a[0] = 1 / ( 1 + (2 * y) + pow_2 ) ;
coef_a[1] = 2 * coef_a[0];
coef_a[2] = coef_a[0];
coef_b[0] = coef_a[1] * (1 - pow_2);
coef_b[1] = coef_a[0] * (1 - (2 * y) + pow_2);
}
void AmAudioFile::forward(unsigned int msec)
{
long fpos = ftell(fp);
long int k = fmt->calcBytesToRead(((getSampleRate()/100)*msec)/10);
if(fpos <= (data_size - k)) {
DBG("Forwarding %d milliseconds (%ld bytes)\n", msec, k);
fseek(fp, k, SEEK_CUR);
clearBufferEOF();
} else {
DBG("Forwarding to EOF\n");
fseek(fp, data_size, SEEK_SET);
}
}
uint64_t SoundEmitter::getDuration() {
if (m_soundClip) {
//convert to milliseconds
double samplerate = static_cast<double>(getSampleRate()) / 1000.0;
double bitres = static_cast<double>(getBitResolution());
// convert to bits
double size = static_cast<double>(getDecodedLength()) * 8.0;
double stereo = (isStereo() ? 2.0 : 1.0);
double time = ( size / (samplerate * bitres) ) / stereo;
return static_cast<uint64_t>(time);
}
return 0;
}
void AmAudioFile::rewind(unsigned int msec)
{
long fpos = ftell(fp);
long int k = fmt->calcBytesToRead(((getSampleRate()/100)*msec)/10);
if(fpos > begin + k) {
DBG("Rewinding %d milliseconds (%ld bytes)\n", msec, k);
fseek(fp, -k, SEEK_CUR);
} else {
DBG("Rewinding file\n");
fseek(fp, begin, SEEK_SET);
}
clearBufferEOF();
}
//-----------------------------------------------------------------------------------------
void Compressor::setParameter (VstInt32 index, float value)
{
switch (index)
{
case kParamInputGain :
InputGainKnob=value;
input_gain=pow(10.0,(60.0*InputGainKnob-30.0)/20.0);
break;
case kParamThreshold:
ThresholdKnob=value;
threshold=pow(10.0,(30.0*ThresholdKnob-30.0)/20.0);
logthresh=20.0*log10(threshold);
break;
case kParamAttack :
AttackKnob = value;
attack_time = pow(10.0,(AttackKnob*3.0-4.0));
the_sample_rate=getSampleRate();
attack_amount=1.0-exp(-1.0/(attack_time*the_sample_rate));
break;
case kParamRelease:
ReleaseKnob = value;
release_time = 0.0175*pow(10.0,(log10(80.0)*ReleaseKnob));
the_sample_rate=getSampleRate();
release_amount=1.0-exp(-1.0/(release_time*the_sample_rate));
break;
case kParamRatio:
RatioKnob = value;
comp_ratio = pow(10.0,(RatioKnob*3.0));
break;
case kParamOutputGain:
OutputGainKnob=value;
output_gain=pow(10.0,(60.0*OutputGainKnob-30.0)/20.0);
break;
default :
break;
}
}
static ReturnCodes setupInputSource(SampleSource inputSource) {
if(inputSource == NULL) {
return RETURN_CODE_INVALID_ARGUMENT;
}
if(inputSource->sampleSourceType == SAMPLE_SOURCE_TYPE_PCM) {
sampleSourcePcmSetSampleRate(inputSource, getSampleRate());
sampleSourcePcmSetNumChannels(inputSource, getNumChannels());
}
if(!inputSource->openSampleSource(inputSource, SAMPLE_SOURCE_OPEN_READ)) {
logError("Input source '%s' could not be opened", inputSource->sourceName->data);
return RETURN_CODE_IO_ERROR;
}
return RETURN_CODE_SUCCESS;
}
void mdaSubSynth::getParameterDisplay(int32_t index, char *text)
{
char string[16];
switch(index)
{
case 1: sprintf(string, "%d", (int32_t)(100.0f * wet)); break;
case 2: sprintf(string, "%d", (int32_t)(0.0726 * getSampleRate() * pow(10.0,-2.5 + (1.5 * fParam3)))); break;
case 3: sprintf(string, "%d", (int32_t)(100. * dry)); break;
case 4: sprintf(string, "%.1f", 60.0f * fParam5 - 60.0f); break;
case 5: sprintf(string, "%d", (int32_t)(-301.03 / (getSampleRate() * log10(rls)))); break;
case 0: switch(typ)
{
case 0: strcpy(string, "Distort"); break;
case 1: strcpy(string, "Divide"); break;
case 2: strcpy(string, "Invert"); break;
case 3: strcpy(string, "Key Osc."); break;
}
}
string[8] = 0;
strcpy(text, (char *)string);
}
void mdaDetune::suspend() ///clear any buffers...
{
memset(buf, 0, sizeof (buf));
memset(win, 0, sizeof (win));
pos0 = 0; pos1 = pos2 = 0.0f;
//recalculate crossfade window
buflen = 1 << (8 + (VstInt32)(4.9f * programs[curProgram].param[3]));
if (buflen > BUFMAX) buflen = BUFMAX;
bufres = 1000.0f * (float)buflen / getSampleRate();
VstInt32 i; //hanning half-overlap-and-add
double p=0.0, dp=6.28318530718/buflen;
for(i=0;i<buflen;i++) { win[i] = (float)(0.5 - 0.5 * cos(p)); p+=dp; }
}
void processAudio(AudioBuffer &buffer){
// update filter coefficients
float fn = getFrequency()/getSampleRate();
float Q = getQ();
float g = getDbGain();
peqL.setCoeffsPEQ(fn, Q, g) ;
peqR.setCoeffsPEQ(fn, Q, g) ;
// process
int size = buffer.getSize();
float* left = buffer.getSamples(0);
peqL.process(size, left);
float* right = buffer.getSamples(1);
peqR.process(size, right);
}
void BufferedAudioSource::setPosition(double seconds)
{
seconds = seconds < 0 ? 0.0f : seconds;
seconds = seconds > getLength() ? getLength() : seconds;
RScopedLock l(&mLock);
Int64 frames = (Int64)(seconds * getSampleRate());
if(!isLoadedInMemory())
{
mBuffer.clear();
setDecoderPosition(frames);
BufferedAudioSourceThread::getInstance()->readMore();
}
}
