static uint32_t synthSound (B3S *instance, uint32_t written, uint32_t nframes, float **out) {
B3S* b3s = (B3S*)instance;
while (written < nframes) {
int nremain = nframes - written;
if (b3s->boffset >= BUFFER_SIZE_SAMPLES) {
b3s->boffset = 0;
oscGenerateFragment (instance->inst->synth, b3s->bufA, BUFFER_SIZE_SAMPLES);
preamp (instance->inst->preamp, b3s->bufA, b3s->bufB, BUFFER_SIZE_SAMPLES);
reverb (instance->inst->reverb, b3s->bufB, b3s->bufC, BUFFER_SIZE_SAMPLES);
#ifdef WITH_SIGNATURE
scramble (b3s, b3s->bufC, BUFFER_SIZE_SAMPLES);
#endif
whirlProc3(instance->inst->whirl, b3s->bufC, b3s->bufL[0], b3s->bufL[1], b3s->bufD[0], b3s->bufD[1], BUFFER_SIZE_SAMPLES);
}
int nread = MIN(nremain, (BUFFER_SIZE_SAMPLES - b3s->boffset));
memcpy(&out[0][written], &b3s->bufL[0][b3s->boffset], nread*sizeof(float));
memcpy(&out[1][written], &b3s->bufL[1][b3s->boffset], nread*sizeof(float));
written+=nread;
b3s->boffset+=nread;
}
return written;
}
int REVERBIT::run()
{
int samps = framesToRun() * inputChannels();
if (currentFrame() < insamps)
rtgetin(in, this, samps);
for (int i = 0; i < samps; i += inputChannels()) {
if (--branch <= 0) {
doupdate();
branch = getSkip();
}
float insig[2], out[2];
if (currentFrame() < insamps) { // still taking input from file
insig[0] = in[i] * amp;
insig[1] = (inputChannels() == 2) ? in[i + 1] * amp : insig[0];
}
else // in ring-down phase
insig[0] = insig[1] = 0.0;
float rvbsig = -reverbpct * reverb(insig[0] + insig[1], rvbarray);
if (usefilt)
rvbsig = tone(rvbsig, tonedata);
delput(rvbsig, delarray, deltabs);
float delsig = delget(delarray, rtchan_delaytime, deltabs);
out[0] = insig[0] + rvbsig;
out[1] = insig[1] + delsig;
if (dcblock) {
float tmp_in[2];
tmp_in[0] = out[0];
tmp_in[1] = out[1];
out[0] = tmp_in[0] - prev_in[0] + (0.99 * prev_out[0]);
prev_in[0] = tmp_in[0];
prev_out[0] = out[0];
out[1] = tmp_in[1] - prev_in[1] + (0.99 * prev_out[1]);
prev_in[1] = tmp_in[1];
prev_out[1] = out[1];
}
rtaddout(out);
increment();
}
return framesToRun();
}
static void
run(LV2_Handle instance, uint32_t n_samples)
{
B3R* b3r = (B3R*)instance;
const float* const input = b3r->input;
float* const output = b3r->output;
if(b3r->mix)
setReverbMix (b3r->instance, *(b3r->mix));
if(b3r->gain_in)
setReverbInputGain (b3r->instance, *(b3r->gain_in));
if(b3r->gain_out)
setReverbOutputGain (b3r->instance, *(b3r->gain_out));
reverb(b3r->instance, input, output, n_samples);
}
QVariant Part::getProperty(P_ID id) const
{
switch (id) {
case P_ID::VISIBLE:
return QVariant(_show);
case P_ID::USE_DRUMSET:
return instrument()->useDrumset();
case P_ID::PART_VOLUME:
return volume();
case P_ID::PART_MUTE:
return mute();
case P_ID::PART_PAN:
return pan();
case P_ID::PART_REVERB:
return reverb();
case P_ID::PART_CHORUS:
return chorus();
default:
return QVariant();
}
}
/* ------------------------------------------------------------------ run --- */
int MROOM::run()
{
const int samps = framesToRun() * inputChannels();
rtgetin(in, this, samps);
for (int i = 0; i < samps; i += inputChannels()) {
float insig, delval = 0.0, rvbsig = 0.0;
if (currentFrame() < insamps) { /* still taking input */
if (--branch <= 0) {
if (amparray)
aamp = tablei(currentFrame(), amparray, amptabs) * ovamp;
branch = skip;
}
if (--quantbranch <= 0) {
float xposit = tablei(currentFrame(), xpos, xpostabs);
float yposit = tablei(currentFrame(), ypos, ypostabs);
distndelset(xposit, yposit, xdim, ydim, innerwidth, reflect);
quantbranch = quantskip;
}
if (inchan == AVERAGE_CHANS) {
insig = 0.0;
for (int n = 0; n < inputChannels(); n++)
insig += in[i + n];
insig /= (float)inputChannels();
}
else
insig = in[i + inchan];
insig *= aamp;
}
else /* in ring-down phase */
insig = 0.0;
DELPUT(insig, delayline, deltabs);
float rout = 0.0;
for (int m = 1; m < NTAPS; m += 2) {
#ifdef INTERP_GET
DLIGET(delayline, del[m], deltabs, delval);
#else
DELGET(delayline, del[m], deltabs, delval);
#endif
rout += delval * amp[m];
if (m < 2)
rvbsig = -rout;
}
rvbsig += rout;
float out[2];
out[0] = rout + reverb(rvbsig, rvbarrayr);
float lout = 0.0;
for (int m = 0; m < NTAPS; m += 2) {
#ifdef INTERP_GET
DLIGET(delayline, del[m], deltabs, delval);
#else
DELGET(delayline, del[m], deltabs, delval);
#endif
lout += delval * amp[m];
if (m < 2)
rvbsig = -lout;
}
rvbsig += lout;
out[1] = lout + reverb(rvbsig, rvbarrayl);
rtaddout(out);
increment();
}
return framesToRun();
}
int jack_audio_callback (jack_nframes_t nframes, void *arg) {
jack_default_audio_sample_t **out = j_output_bufferptrs;
int i;
void *jack_midi_buf = NULL;
int midi_events = 0;
jack_nframes_t midi_tme_proc = 0;
if (!synth_ready) {
for (i=0;i<AUDIO_CHANNELS;i++) {
out[i] = (jack_default_audio_sample_t*) jack_port_get_buffer (j_output_port[i], nframes);
memset(out[i], 0, nframes*sizeof(jack_default_audio_sample_t));
}
return (0);
}
if (use_jack_midi) {
jack_midi_buf = jack_port_get_buffer(jack_midi_port, nframes);
midi_events = jack_midi_get_event_count(jack_midi_buf);
}
for (i=0;i<AUDIO_CHANNELS;i++) {
out[i] = (jack_default_audio_sample_t*) jack_port_get_buffer (j_output_port[i], nframes);
}
static int boffset = BUFFER_SIZE_SAMPLES;
jack_nframes_t written = 0;
while (written < nframes) {
int nremain = nframes - written;
if (boffset >= BUFFER_SIZE_SAMPLES) {
if (use_jack_midi) {
for (i=0; i<midi_events; i++) {
jack_midi_event_t ev;
jack_midi_event_get(&ev, jack_midi_buf, i);
if (ev.time >= written && ev.time < (written + BUFFER_SIZE_SAMPLES))
parse_raw_midi_data(arg, ev.buffer, ev.size);
}
midi_tme_proc = written + BUFFER_SIZE_SAMPLES;
}
boffset = 0;
oscGenerateFragment (inst.synth, bufA, BUFFER_SIZE_SAMPLES);
preamp (inst.preamp, bufA, bufB, BUFFER_SIZE_SAMPLES);
reverb (inst.reverb, bufB, bufC, BUFFER_SIZE_SAMPLES);
#ifdef HAVE_ZITACONVOLVE
whirlProc2(inst.whirl,
bufC,
NULL, NULL,
bufH[0], bufH[1],
bufD[0], bufD[1],
BUFFER_SIZE_SAMPLES);
const float *horn[2] = { bufH[0], bufH[1] };
const float *drum[2] = { bufD[0], bufD[1] };
float *out[2] = { bufJ[0], bufJ[1] };
convolve(horn, out, 2, BUFFER_SIZE_SAMPLES);
mixdown(out, drum, AUDIO_CHANNELS, BUFFER_SIZE_SAMPLES);
#else
whirlProc(inst.whirl, bufC, bufJ[0], bufJ[1], BUFFER_SIZE_SAMPLES);
#endif
}
int nread = MIN(nremain, (BUFFER_SIZE_SAMPLES - boffset));
for (i=0;i< AUDIO_CHANNELS; i++) {
memcpy(&out[i][written], &bufJ[i][boffset], nread*sizeof(float));
}
written+=nread;
boffset+=nread;
}
if (use_jack_midi) {
/* process remaining MIDI events
* IF nframes < BUFFER_SIZE_SAMPLES OR nframes != N * BUFFER_SIZE_SAMPLES
*/
for (i=0; i<midi_events; i++) {
jack_midi_event_t ev;
jack_midi_event_get(&ev, jack_midi_buf, i);
if (ev.time >= midi_tme_proc)
parse_raw_midi_data(arg, ev.buffer, ev.size);
}
}
return(0);
}
