38 float NoiseGate::fnglevel = 0;
39 float NoiseGate::ngate = 1;
40 bool NoiseGate::off =
true;
48 inputdef.
id =
"noise_gate";
49 inputdef.
name =
N_(
"Noise Gate");
63 inline float sqrf(
float x) {
67 void NoiseGate::inputlevel_compute(
int count,
float *input,
float *output,
PluginDef*) {
69 for (
int i = 0; i < count; i++) {
70 sumnoise +=
sqrf(input[i]);
72 if (sumnoise/count >
sqrf(fnglevel * 0.01)) {
74 }
else if (ngate > 0.01) {
79 int NoiseGate::noisegate_register(
const ParamReg& reg) {
80 reg.
registerVar(
"noise_gate.threshold",
N_(
"Threshold"),
"S",
"", &fnglevel,
81 0.017f, 0.01f, 0.31f, 0.001f);
85 void NoiseGate::outputgate_compute(
int count,
float *input,
float *output,
PluginDef*) {
90 *output++ = ngate * *input++;
110 seqline = seqset.seqline;
118 for (
unsigned int i = 0; i < seqline.size(); i++) {
126 if (seqline != seqset.seqline) {
138 seqline.push_back(p);
162 :
Parameter(id,
"", tp_special, None, true, false),
168 std_value.seqline = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
184 value(&value_storage),
191 std_value.readJSON(jp);
194 "SeqParameter", Glib::ustring::compose(
"%1: unknown key: %2", _id, jp.
current_value()));
204 jw.
write_key(
"value"); value->writeJSON(jw);
205 jw.
write_key(
"std_value"); std_value.writeJSON(jw);
215 json_value = std_value;
220 value->writeJSON(jw);
224 json_value.readJSON(jp);
228 return json_value == *value;
260 fIRFile = jcset.fIRFile;
261 fIRDir = jcset.fIRDir;
263 fOffset = jcset.fOffset;
264 fLength = jcset.fLength;
265 fDelay = jcset.fDelay;
266 gainline = jcset.gainline;
267 fGainCor = jcset.fGainCor;
272 if (fIRFile.empty()) {
275 return Glib::build_filename(fIRDir, fIRFile);
280 fIRDir = Glib::path_get_dirname(name);
281 fIRFile= Glib::path_get_basename(name);
286 w.
write_kv(
"jconv.IRFile", fIRFile);
289 w.
write_kv(
"jconv.GainCor", fGainCor);
290 w.
write_kv(
"jconv.Offset", fOffset);
291 w.
write_kv(
"jconv.Length", fLength);
295 for (
unsigned int i = 0; i < gainline.size(); i++) {
297 w.
write(gainline[i].i);
298 w.
write(gainline[i].g);
306 if (fIRFile != jcset.fIRFile || fIRDir != jcset.fIRDir) {
309 if (fOffset != jcset.fOffset || fLength != jcset.fLength || fDelay != jcset.fDelay) {
312 if (fGainCor != jcset.fGainCor) {
315 if (fGainCor && std::abs(fGain - jcset.fGain) > 1e-4 * (fGain + jcset.fGain)) {
318 if (gainline == jcset.gainline) {
335 gainline.push_back(p);
344 if (jp.
read_kv(
"jconv.IRFile", fIRFile) ||
345 jp.
read_kv(
"jconv.IRDir", fIRDir) ||
346 jp.
read_kv(
"jconv.Gain", fGain) ||
347 jp.
read_kv(
"jconv.GainCor", fGainCor) ||
348 jp.
read_kv(
"jconv.Offset", fOffset) ||
349 jp.
read_kv(
"jconv.Length", fLength) ||
350 jp.
read_kv(
"jconv.Delay", fDelay)) {
361 if (!fIRFile.empty()) {
362 if (fIRDir.empty()) {
376 :
Parameter(id,
"", tp_special, None, true, false),
383 std_value.fGainCor =
true;
384 std_value.fGain = 0.598717;
385 const int ir_len = 112561;
386 std_value.fLength = ir_len;
387 static gain_points g[2] = {{0, 0}, {ir_len-1, 0}};
388 std_value.gainline = Gainline(g,
sizeof(g) /
sizeof(g[0]));
392 ParamMap &pmap,
const string&
id, ConvolverAdapter &conv, GxJConvSettings *v) {
406 value(&value_storage),
413 std_value.readJSON(jp);
416 "JConvParameter", Glib::ustring::compose(
"%1: unknown key: %2", _id, jp.
current_value()));
426 jw.
write_key(
"value"); value->writeJSON(jw);
427 jw.
write_key(
"std_value"); std_value.writeJSON(jw);
437 json_value = std_value;
442 value->writeJSON(jw);
446 json_value.readJSON(jp);
450 return json_value == *value;
471 #include "faust/jconv_post.cc"
472 #include "faust/jconv_post_mono.cc"
530 int policy, priority;
532 if (!rc || !
conv.
start(policy, priority)) {
562 int policy, priority;
586 void ConvolverStereoAdapter::convolver(
int count,
float *input0,
float *input1,
587 float *output0,
float *output1,
PluginDef* plugin) {
590 float conv_out0[count];
591 float conv_out1[count];
592 if (
self.
conv.
compute(count, input0, input1, conv_out0, conv_out1)) {
593 self.jc_post.compute(count, input0, input1,
594 conv_out0, conv_out1, output0, output1);
599 if (input0 != output0) {
600 memcpy(output0, input0, count *
sizeof(
float));
602 if (input1 != output1) {
603 memcpy(output1, input1, count *
sizeof(
float));
607 int ConvolverStereoAdapter::convolver_register(
const ParamReg& reg) {
610 self.jcp->signal_changed().connect(
613 return self.jc_post.register_par(reg);
616 void ConvolverStereoAdapter::convolver_init(
unsigned int samplingFreq,
PluginDef *p) {
620 self.conv.stop_process();
621 self.conv.set_samplerate(samplingFreq);
622 self.jc_post.init(samplingFreq);
624 self.conv.checkstate();
628 self.conv.set_samplerate(samplingFreq);
629 self.jc_post.init(samplingFreq);
645 self.activated =
start;
647 if (
self.jc_post.activate(
true) != 0) {
655 self.conv.stop_process();
656 self.jc_post.activate(
false);
680 void ConvolverMonoAdapter::convolver(
int count,
float *input,
float *output,
PluginDef* plugin) {
683 float conv_out[count];
685 self.jc_post_mono.compute(count, output, conv_out, output);
690 if (input != output) {
691 memcpy(output, input, count *
sizeof(
float));
695 int ConvolverMonoAdapter::convolver_register(
const ParamReg& reg) {
698 self.jcp->signal_changed().connect(
701 return self.jc_post_mono.register_par(reg);;
704 void ConvolverMonoAdapter::convolver_init(
unsigned int samplingFreq,
PluginDef *p) {
708 self.conv.stop_process();
709 self.conv.set_samplerate(samplingFreq);
711 self.conv.checkstate();
715 self.conv.set_samplerate(samplingFreq);
731 self.activated =
start;
737 self.conv.stop_process();
782 self.conv.set_samplerate(samplingFreq);
811 self.update_conn = Glib::signal_timeout().connect(
814 self.conv.stop_process();
816 self.activated =
start;
821 int policy, priority;
870 self.SamplingFreq = samplingFreq;
871 self.bz = 96000/samplingFreq;
872 self.conv.set_buffersize(
static_cast<int>(ceil((
self.
buffersize*
self.
bz))));
902 self.update_conn = Glib::signal_timeout().connect(
905 self.conv.stop_process();
907 self.activated =
start;
912 int policy, priority;
927 template <
int tab_size>
942 {
"4x12",
N_(
"4x12"), &
static_cast<CabDesc&
>(cab_data_4x12) },
943 {
"2x12",
N_(
"2x12"), &
static_cast<CabDesc&
>(cab_data_2x12) },
944 {
"1x12",
N_(
"1x12"), &
static_cast<CabDesc&
>(cab_data_1x12) },
945 {
"4x10",
N_(
"4x10"), &
static_cast<CabDesc&
>(cab_data_4x10) },
946 {
"2x10",
N_(
"2x10"), &
static_cast<CabDesc&
>(cab_data_2x10) },
947 {
"HighGain",
N_(
"HighGain Style"), &
static_cast<CabDesc&
>(cab_data_HighGain) },
948 {
"Twin",
N_(
"Twin Style"), &
static_cast<CabDesc&
>(cab_data_Twin) },
949 {
"Bassman",
N_(
"Bassman Style"), &
static_cast<CabDesc&
>(cab_data_Bassman) },
950 {
"Marshall",
N_(
"Marshall Style"), &
static_cast<CabDesc&
>(cab_data_Marshall) },
951 {
"AC-30",
N_(
"AC-30 Style"), &
static_cast<CabDesc&
>(cab_data_AC30) },
952 {
"Princeton",
N_(
"Princeton Style"), &
static_cast<CabDesc&
>(cab_data_Princeton) },
953 {
"A2",
N_(
"A2 Style"), &
static_cast<CabDesc&
>(cab_data_A2) },
954 {
"1x15",
N_(
"1x15"), &
static_cast<CabDesc&
>(cab_data_1x15) },
955 {
"Mesa Boogie",
N_(
"Mesa Boogie Style"), &
static_cast<CabDesc&
>(cab_data_mesa) },
956 {
"Briliant",
N_(
"Briliant"), &
static_cast<CabDesc&
>(cab_data_briliant) },
957 {
"Vitalize",
N_(
"Vitalize"), &
static_cast<CabDesc&
>(cab_data_vitalize) },
958 {
"Charisma",
N_(
"Charisma"), &
static_cast<CabDesc&
>(cab_data_charisma) },
962 static CabEntry& getCabEntry(
unsigned int n) {
963 if (n >= cab_table_size) {
964 n = cab_table_size - 1;
969 static const float no_sum = 1e10;
971 #include "faust/cabinet_impulse_former.cc"
973 static int cab_load_ui(
const UiBuilder& builder,
int format) {
1013 for (
unsigned int i = 0; i < cab_table_size; ++i) {
1018 cab_names[cab_table_size].
value_id = 0;
1032 bool CabinetConvolver::do_update() {
1033 bool configure = cabinet_changed();
1037 conv.stop_process();
1039 CabDesc& cab = *getCabEntry(cabinet).
data;
1040 if (current_cab == -1) {
1042 unsigned int sru = 96000;
1043 unsigned int fact = sru/sr;
1045 smp.
setup(sr, fact*sr);
1046 impf.init(cab.ir_sr);
1048 float cab_irdata_c[cab.ir_count];
1049 impf.clear_state_f();
1050 impf.compute(cab.ir_count,cab.ir_data,cab_irdata_c);
1053 if (!
conv.
configure(cab.ir_count, cab_irdata_c, cab.ir_sr)) {
1057 if (!
conv.
update(cab.ir_count, cab_irdata_c, cab.ir_sr)) {
1066 bool CabinetConvolver::start(
bool force) {
1070 if (cabinet_changed() || sum_changed()) {
1081 void CabinetConvolver::check_update() {
1082 if (cabinet_changed() || sum_changed()) {
1087 void CabinetConvolver::run_cab_conf(
int count,
float *input0,
float *output0,
PluginDef *p) {
1089 FAUSTFLOAT buf[
self.smp.max_out_count(count)];
1090 int ReCount =
self.smp.up(count, output0, buf);
1094 self.smp.down(buf, output0);
1097 int CabinetConvolver::register_cab(
const ParamReg& reg) {
1099 reg.
registerIEnumVar(
"cab.select",
"select",
"B",
"", cab.cab_names, &cab.cabinet, 0);
1100 reg.
registerVar(
"cab.Level",
N_(
"Level"),
"S",
N_(
"Level"), &cab.level, 1.0, 0.5, 5.0, 0.5);
1101 reg.
registerVar(
"cab.bass",
N_(
"Bass"),
"S",
N_(
"Bass"), &cab.bass, 0.0, -10.0, 10.0, 0.5);
1102 reg.
registerVar(
"cab.treble",
N_(
"Treble"),
"S",
N_(
"Treble"), &cab.treble, 0.0, -10.0, 10.0, 0.5);
1103 cab.impf.register_par(reg);
1108 #include "faust/cabinet_impulse_former_st.cc"
1110 static int cab_load_stereo_ui(
const UiBuilder& builder,
int format) {
1151 for (
unsigned int i = 0; i < cab_table_size; ++i) {
1156 cab_names[cab_table_size].
value_id = 0;
1170 bool CabinetStereoConvolver::do_update() {
1171 bool configure = cabinet_changed();
1175 conv.stop_process();
1177 CabDesc& cab = *getCabEntry(cabinet).
data;
1178 if (current_cab == -1) {
1180 unsigned int sru = 96000;
1181 unsigned int fact = sru/sr;
1183 smp.
setup(sr, fact*sr);
1184 smps.
setup(sr, fact*sr);
1185 impf.init(cab.ir_sr);
1187 float cab_irdata_c[cab.ir_count];
1188 impf.clear_state_f();
1189 impf.compute(cab.ir_count,cab.ir_data,cab_irdata_c);
1205 bool CabinetStereoConvolver::start(
bool force) {
1209 if (cabinet_changed() || sum_changed()) {
1220 void CabinetStereoConvolver::check_update() {
1221 if (cabinet_changed() || sum_changed()) {
1226 void CabinetStereoConvolver::run_cab_conf(
int count,
float *input0,
float *input1,
float *output0,
float *output1,
PluginDef *p) {
1228 FAUSTFLOAT buf[
self.smp.max_out_count(count)];
1229 FAUSTFLOAT buf1[
self.smps.max_out_count(count)];
1230 int ReCount =
self.smp.up(count, output0, buf);
1231 self.smps.up(count, output1, buf1);
1235 self.smp.down(buf, output0);
1236 self.smps.down(buf1, output1);
1239 int CabinetStereoConvolver::register_cab(
const ParamReg& reg) {
1241 reg.
registerIEnumVar(
"cab_st.select",
"select",
"B",
"", cab.cab_names, &cab.cabinet, 0);
1242 reg.
registerVar(
"cab_st.Level",
N_(
"Level"),
"S",
N_(
"Level"), &cab.level, 1.0, 0.5, 5.0, 0.5);
1243 reg.
registerVar(
"cab_st.bass",
N_(
"Bass"),
"S",
N_(
"Bass"), &cab.bass, 0.0, -10.0, 10.0, 0.5);
1244 reg.
registerVar(
"cab_st.treble",
N_(
"Treble"),
"S",
N_(
"Treble"), &cab.treble, 0.0, -10.0, 10.0, 0.5);
1245 cab.impf.register_par(reg);
1259 template <
int tab_size>
1274 {
"AC30",
N_(
"AC30 Style"), &
static_cast<PreDesc&
>(pre_data_ac30) },
1275 {
"Bassman",
N_(
"Bassman Style"), &
static_cast<PreDesc&
>(pre_data_bassman) },
1276 {
"Tube",
N_(
"Tube Style"), &
static_cast<PreDesc&
>(pre_data_tube) },
1277 {
"Fender",
N_(
"Fender Style"), &
static_cast<PreDesc&
>(pre_data_fender) },
1278 {
"JCM800",
N_(
"JCM800 Style"), &
static_cast<PreDesc&
>(pre_data_jcm800) },
1279 {
"JTM45",
N_(
"JTM45 Style"), &
static_cast<PreDesc&
>(pre_data_jtm45) },
1280 {
"Mesa Boogie",
N_(
"Mesa Boogie Style"), &
static_cast<PreDesc&
>(pre_data_mesaboogie) },
1281 {
"Boutique",
N_(
"Boutique Style"), &
static_cast<PreDesc&
>(pre_data_boutique) },
1282 {
"Ampeg",
N_(
"Ampeg Style"), &
static_cast<PreDesc&
>(pre_data_ampeg) },
1283 {
"Rectifier",
N_(
"Rectifier Style"), &
static_cast<PreDesc&
>(pre_data_rectifier) },
1287 static PreEntry& getPreEntry(
unsigned int n) {
1288 if (n >= pre_table_size) {
1289 n = pre_table_size - 1;
1294 #include "faust/preamp_impulse_former.cc"
1296 static int pre_load_ui(
const UiBuilder& builder,
int format) {
1336 for (
unsigned int i = 0; i < pre_table_size; ++i) {
1341 pre_names[pre_table_size].
value_id = 0;
1344 name =
N_(
"Amp Impulse");
1355 bool PreampConvolver::do_update() {
1356 bool configure = preamp_changed();
1360 conv.stop_process();
1362 PreDesc& pre = *getPreEntry(preamp).
data;
1363 if (current_pre == -1) {
1365 unsigned int sru = 96000;
1366 unsigned int fact = sru/sr;
1368 smp.
setup(sr, fact*sr);
1369 impf.init(pre.ir_sr);
1371 float pre_irdata_c[pre.ir_count];
1372 impf.clear_state_f();
1373 impf.compute(pre.ir_count,pre.ir_data,pre_irdata_c);
1376 if (!
conv.
configure(pre.ir_count, pre_irdata_c, pre.ir_sr)) {
1380 if (!
conv.
update(pre.ir_count, pre_irdata_c, pre.ir_sr)) {
1389 bool PreampConvolver::start(
bool force) {
1393 if (preamp_changed() || sum_changed()) {
1404 void PreampConvolver::check_update() {
1405 if (preamp_changed() || sum_changed()) {
1410 void PreampConvolver::run_pre_conf(
int count,
float *input0,
float *output0,
PluginDef *p) {
1412 FAUSTFLOAT buf[
self.smp.max_out_count(count)];
1413 int ReCount =
self.smp.up(count, output0, buf);
1417 self.smp.down(buf, output0);
1420 int PreampConvolver::register_pre(
const ParamReg& reg) {
1422 reg.
registerIEnumVar(
"pre.select",
"select",
"B",
"", pre.pre_names, &pre.preamp, 0);
1423 reg.
registerVar(
"pre.Level",
N_(
"Level"),
"S",
N_(
"Level"), &pre.level, 1.0, 0.1, 2.1, 0.1);
1424 reg.
registerVar(
"pre.bass",
N_(
"Bass"),
"S",
N_(
"Bass"), &pre.bass, 0.0, -10.0, 10.0, 0.5);
1425 reg.
registerVar(
"pre.treble",
N_(
"Treble"),
"S",
N_(
"Treble"), &pre.treble, 0.0, -10.0, 10.0, 0.5);
1426 pre.impf.register_par(reg);
1431 #include "faust/preamp_impulse_former_st.cc"
1433 static int pre_load_stereo_ui(
const UiBuilder& builder,
int format) {
1474 for (
unsigned int i = 0; i < pre_table_size; ++i) {
1479 pre_names[pre_table_size].
value_id = 0;
1482 name =
N_(
"Amp Impulse");
1493 bool PreampStereoConvolver::do_update() {
1494 bool configure = preamp_changed();
1498 conv.stop_process();
1500 PreDesc& pre = *getPreEntry(preamp).
data;
1501 if (current_pre == -1) {
1503 unsigned int sru = 96000;
1504 unsigned int fact = sru/sr;
1506 smp.
setup(sr, fact*sr);
1507 smps.
setup(sr, fact*sr);
1508 impf.init(pre.ir_sr);
1510 float pre_irdata_c[pre.ir_count];
1511 impf.clear_state_f();
1512 impf.compute(pre.ir_count,pre.ir_data,pre_irdata_c);
1528 bool PreampStereoConvolver::start(
bool force) {
1532 if (preamp_changed() || sum_changed()) {
1543 void PreampStereoConvolver::check_update() {
1544 if (preamp_changed() || sum_changed()) {
1549 void PreampStereoConvolver::run_pre_conf(
int count,
float *input0,
float *input1,
float *output0,
float *output1,
PluginDef *p) {
1551 FAUSTFLOAT buf[
self.smp.max_out_count(count)];
1552 FAUSTFLOAT buf1[
self.smps.max_out_count(count)];
1553 int ReCount =
self.smp.up(count, output0, buf);
1554 self.smps.up(count, output1, buf1);
1558 self.smp.down(buf, output0);
1559 self.smps.down(buf1, output1);
1562 int PreampStereoConvolver::register_pre(
const ParamReg& reg) {
1564 reg.
registerIEnumVar(
"pre_st.select",
"select",
"B",
"", pre.pre_names, &pre.preamp, 0);
1565 reg.
registerVar(
"pre_st.Level",
N_(
"Level"),
"SA",
N_(
"Level"), &pre.level, 1.0, 0.1, 2.1, 0.1);
1566 reg.
registerVar(
"pre_st.bass",
N_(
"Bass"),
"SA",
N_(
"Bass"), &pre.bass, 0.0, -10.0, 10.0, 0.5);
1567 reg.
registerVar(
"pre_st.treble",
N_(
"Treble"),
"SA",
N_(
"Treble"), &pre.treble, 0.0, -10.0, 10.0, 0.5);
1568 pre.impf.register_par(reg);
1576 #include "faust/presence_level.cc"
1586 name =
N_(
"Contrast convolver");
1594 bool ContrastConvolver::do_update() {
1595 bool configure = (sum == no_sum);
1599 conv.stop_process();
1603 unsigned int sru = 96000;
1604 unsigned int fact = sru/sr;
1606 smp.
setup(sr, fact*sr);
1607 presl.init(contrast_ir_desc.ir_sr);
1609 float contrast_irdata_c[contrast_ir_desc.ir_count];
1610 presl.compute(contrast_ir_desc.ir_count,contrast_ir_desc.ir_data,contrast_irdata_c);
1613 if (!
conv.
configure(contrast_ir_desc.ir_count, contrast_irdata_c, contrast_ir_desc.ir_sr)) {
1617 if (!
conv.
update(contrast_ir_desc.ir_count, contrast_irdata_c, contrast_ir_desc.ir_sr)) {
1625 bool ContrastConvolver::start(
bool force) {
1629 if (sum_changed()) {
1640 void ContrastConvolver::check_update() {
1641 if (sum_changed()) {
1646 int ContrastConvolver::register_con(
const ParamReg& reg) {
1648 reg.
registerVar(
"con.Level",
"",
"S",
"", &
self.level, 1.0, 0.5, 5.0, 0.5);
1649 self.presl.register_par(reg);
1653 void ContrastConvolver::run_contrast(
int count,
float *input0,
float *output0,
PluginDef *p) {
1655 FAUSTFLOAT buf[
self.smp.max_out_count(count)];
1656 int ReCount =
self.smp.up(count, output0, buf);
1660 self.smp.down(buf, output0);
1674 mem_allocated(false),
1680 name =
N_(
"Directoutputr");
1686 sigc::mem_fun(*
this, &Directout::change_buffersize));
1693 inline void Directout::init(
unsigned int samplingFreq)
1696 fSamplingFreq = samplingFreq;
1700 void Directout::init_static(
unsigned int samplingFreq,
PluginDef *p)
1702 static_cast<Directout*
>(p)->init(samplingFreq);
1705 void Directout::mem_alloc()
1721 void Directout::mem_free()
1727 void Directout::change_buffersize(
unsigned int size)
1736 void always_inline Directout::compute(
int count,
float *input0,
float *input1,
float *output0,
float *output1) {
1740 for (
int i=0; i<count; i++) {
1741 output0[i] = input0[i] +
outdata[i];
1742 output1[i] = input1[i] +
outdata[i];
1744 memset(
outdata,0,count*
sizeof(
float));
1754 static_cast<Directout*
>(p)->compute(count, input0, input1, output0, output1);
1774 #include "faust/drumseq.cc"
1777 float* Drumout::set = 0;
1778 float* Drumout::data = 0;
1779 bool Drumout::mb =
false;
1781 Plugin Drumout::input_drum = Plugin();
1794 void always_inline Drumout::outputdrum_compute(
int count,
float *input0,
float *input1,
float *output0,
float *output1,
PluginDef*) {
1795 if (!(*set) || !input_drum.
get_on_off() || !mb) {
1798 for (
int i=0; i<count; i++) {
1799 output0[i] = input0[i] + data[i];
1800 output1[i] = input1[i] + data[i];
1802 memset(data,0,count*
sizeof(
float));
1815 static const char* seq_groups[] = {
1816 "hat_closed.dsp",
N_(
"DrumSequencer"),
1817 "kick.dsp",
N_(
"DrumSequencer"),
1818 "snare.dsp",
N_(
"DrumSequencer"),
1819 "tom.dsp",
N_(
"DrumSequencer"),
1820 "sequencer",
N_(
"DrumSequencer"),
1833 mem_allocated(false),
1854 name =
N_(
"DrumSequencer");
1867 sigc::mem_fun(*
this, &DrumSequencer::change_buffersize));
1874 inline void DrumSequencer::init(
unsigned int samplingFreq)
1877 fSamplingFreq = samplingFreq;
1888 drums.init(samplingFreq);
1892 void DrumSequencer::init_static(
unsigned int samplingFreq,
PluginDef *p)
1897 void DrumSequencer::mem_alloc()
1899 if (mem_allocated) {
1905 outdata =
new float[bsize]();
1910 mem_allocated =
true;
1914 void DrumSequencer::mem_free()
1917 mem_allocated =
false;
1919 if (outdata) {
delete outdata; outdata = 0; }
1922 void DrumSequencer::change_buffersize(
unsigned int size)
1926 if (mem_allocated) {
1932 int DrumSequencer::min_seq_size(){
1933 int i =
min(
min(
min(Vectom.size(),Veckick.size()),
min(Vechat.size(),Vecsnare.size())),
min(Vectom1.size(),Vectom2.size()));
1937 void DrumSequencer::reset_tom() {
1939 seq_size = min_seq_size();
1942 void DrumSequencer::reset_tom1() {
1944 seq_size = min_seq_size();
1947 void DrumSequencer::reset_tom2() {
1949 seq_size = min_seq_size();
1952 void DrumSequencer::reset_kick() {
1954 seq_size = min_seq_size();
1957 void DrumSequencer::reset_hat() {
1959 seq_size = min_seq_size();
1962 void DrumSequencer::reset_snare() {
1964 seq_size = min_seq_size();
1975 double fSlow15 = (60.0/double(fsliderbpm*ftact))*fSamplingFreq;
1977 int iSlow15 = (int)fSlow15;
1979 if (counter >= iSlow15) {
1980 int istep = (int)step;
1981 fSlow1 = double(Vecsnare[istep]);
1983 if (iSlow15 > 4800) {
1984 fSlow3 = double(Vechat[istep]);
1986 fSlow5 = double(Veckick[istep]);
1988 if (Vectom2[istep]) {
1989 fSlow7 = double(Vectom2[istep]);
1992 }
else if (Vectom1[istep]) {
1993 fSlow7 = double(Vectom1[istep]);
1996 }
else if(Vectom[istep]) {
1997 fSlow7 = double(Vectom[istep]);
2002 int r = rand()%(m+1 - (-m))+ (-m);
2005 if (step<seq_size) step = fmin(seq_size,fmax(0,step + 1.0 +
int(r*fsliderhum)));
2007 if (step_orig<seq_size) step_orig += 1.0;
2008 else step_orig = 0.0;
2009 double ph1 = 2300.0/seq_size;
2010 position = fmin(2300,fmax(0,(step*ph1)));
2017 if (
int(fSlow22 && mem_allocated)) {
2018 memcpy(output0, input0, count *
sizeof(
float));
2019 drums.compute(count,outdata,outdata);
2021 drums.compute(count,input0,output0);
2027 static_cast<DrumSequencer*
>(p)->compute(count, input0, output0);
2030 int DrumSequencer::register_par(
const ParamReg& reg)
2037 reg.
registerVar(
"seq.tom.dsp.Gain",
"",
"S",
N_(
"Volume level in decibels"),&fSlow12, -2e+01, -6e+01, 4e+01, 0.1);
2038 reg.
registerVar(
"seq.tom.dsp.Gain1",
"",
"S",
N_(
"Volume level in decibels"),&fSlow14, -2e+01, -6e+01, 4e+01, 0.1);
2039 reg.
registerVar(
"seq.tom.dsp.Gain2",
"",
"S",
N_(
"Volume level in decibels"),&fSlow16, -2e+01, -6e+01, 4e+01, 0.1);
2041 reg.
registerVar(
"seq.bpm",
"",
"S",
N_(
"Beats per Minute"),&fsliderbpm, 120, 24, 360, 1);
2042 static const value_pair ftact_values[] = {{
"1/4"},{
"2/4"},{
"3/4"},{
"4/4"},{0}};
2043 reg.
registerEnumVar(
"seq.tact",
"",
"S",
N_(
"select tact"),ftact_values,&ftact, 4.0, 1.0, 4.0, 1.0);
2044 reg.
registerVar(
"seq.asequences",
"",
"S",
N_(
"Number of Sequences"),&fsec, 24.0, 24.0, 240.0, 4.0);
2045 reg.
registerVar(
"seq.hum",
"",
"B",
N_(
"Randomize Sequence"),&fsliderhum, 0.0, 0.0, 1.0, 1.0);
2046 reg.
registerVar(
"seq.npreset",
"",
"BO",
N_(
"Load next unit preset"),0, 0.0, 0.0, 1.0, 1.0);
2047 reg.
registerVar(
"seq.ppreset",
"",
"BO",
N_(
"Load previous unit preset"),0, 0.0, 0.0, 1.0, 1.0);
2051 reg.
registerVar(
"seq.set_step",
"",
"BO",
N_(
"Set stepper one Beat back"),0, 0.0, 0.0, 1.0, 1.0);
2052 reg.
registerVar(
"seq.set_fstep",
"",
"BO",
N_(
"Set stepper one Beat forward"),0, 0.0, 0.0, 1.0, 1.0);
2053 reg.
registerVar(
"seq.set_sync",
"",
"BO",
N_(
"Set stepper back on Beat "),0, 0.0, 0.0, 1.0, 1.0);
2054 reg.
registerVar(
"seq.reset_step",
"",
"BO",
N_(
"Set stepper one Start"),0, 0.0, 0.0, 1.0, 1.0);
2055 reg.
registerVar(
"seq.follow",
"",
"BO",
N_(
"follow playhead"),0, 0.0, 0.0, 1.0, 1.0);
2056 reg.
registerVar(
"seq.direct_out",
"",
"BA",
N_(
"bypass the rack for direct output"),&fSlow22, 0.0, 0.0, 1.0, 1.0);
2057 for (
int i=0; i<24; i++) Vectom.push_back(0);
2058 for (
int i=0; i<24; i++) Vectom1.push_back(0);
2059 for (
int i=0; i<24; i++) Vectom2.push_back(0);
2060 for (
int i=0; i<24; i++) Veckick.push_back(0);
2061 for (
int i=0; i<24; i++) Vechat.push_back(0);
2062 for (
int i=0; i<24; i++) Vecsnare.push_back(0);
2063 seq_size = min_seq_size();
2072 sigc::mem_fun(
this, &DrumSequencer::reset_tom)));
2075 sigc::mem_fun(
this, &DrumSequencer::reset_tom1)));
2078 sigc::mem_fun(
this, &DrumSequencer::reset_tom2)));
2081 sigc::mem_fun(
this, &DrumSequencer::reset_snare)));
2084 sigc::mem_fun(
this, &DrumSequencer::reset_hat)));
2087 sigc::mem_fun(
this, &DrumSequencer::reset_kick)));
2089 drums.register_par(reg);
2093 int DrumSequencer::register_params_static(
const ParamReg& reg)
2098 void DrumSequencer::del_instance(
PluginDef *p)
2125 bool smbPitchShift::setParameters(
int sampleRate_)
2128 fftFrameSize = numSampsToProcess/4;
2129 sampleRate = int(sampleRate_);
2130 assert(sampleRate>0);
2133 osamp2 = 2.*
M_PI*osamp1;
2134 mpi = (1./(2.*
M_PI)) * osamp;
2143 resamp.
setup(sampleRate,4);
2144 gRover = inFifoLatency;
2151 mem_allocated(false),
2166 id =
"smbPitchShift";
2180 sigc::mem_fun(*
this, &smbPitchShift::change_buffersize));
2183 void smbPitchShift::init(
unsigned int samplingFreq,
PluginDef *plugin) {
2188 void smbPitchShift::clear_state()
2190 stepSize = fftFrameSize/osamp;
2191 freqPerBin = (double)(sampleRate/4)/(double)fftFrameSize;
2192 freqPerBin1 = (1/freqPerBin)*osamp2;
2193 freqPerBin2 = freqPerBin*mpi;
2194 expct = 2.*
M_PI*(double)stepSize/(
double)fftFrameSize;
2195 inFifoLatency = fftFrameSize-stepSize;
2196 fftFrameSize3 = 2. * (1./ ((double)(fftFrameSize2)*osamp));
2197 fftFrameSize4 = 1./(double)fftFrameSize;
2209 for (k = 0; k < fftFrameSize2;k++) {
2210 fpb[k] = (double)k*freqPerBin;
2212 for (k = 0; k < fftFrameSize2;k++) {
2213 expect[k] = (double)k*expct;
2215 for (k = 0; k < fftFrameSize;k++) {
2216 hanning[k] = 0.5*(1-cos(2.*
M_PI*(
double)k/((
double)fftFrameSize)));
2218 for (k = 0; k < fftFrameSize;k++) {
2219 hanningd[k] = 0.5*(1-cos(2.*
M_PI*(
double)k * fftFrameSize4)) * fftFrameSize3;
2221 for (k = 0; k < fftFrameSize;k++) {
2224 for (k = 0; k < fftFrameSize;k++) {
2227 for (k = 0; k < fftFrameSize*4;k++) {
2230 for (k = 0; k < fftFrameSize*4;k++) {
2233 gRover = inFifoLatency;
2234 mem_allocated =
true;
2238 void smbPitchShift::mem_alloc()
2241 assert(numSampsToProcess>0);
2242 numSampsToResamp = numSampsToProcess/4;
2244 assert(sampleRate>0);
2248 if (numSampsToProcess <= 2048) {
2249 fftFrameSize = 512 ;
2251 fftFrameSize = numSampsToProcess*0.25 ;
2255 fftFrameSize = numSampsToProcess;
2258 fftFrameSize = numSampsToProcess*0.25;
2261 if (numSampsToProcess <= 2048) {
2262 fftFrameSize = 512 ;
2264 fftFrameSize = numSampsToProcess*0.25 ;
2268 fftFrameSize2 = fftFrameSize/2;
2272 ftPlanForward = fftwf_plan_dft_1d(fftFrameSize, fftw_in, fftw_out, FFTW_FORWARD, FFTW_ESTIMATE);
2273 ftPlanInverse = fftwf_plan_dft_1d(fftFrameSize, fftw_in, fftw_out, FFTW_BACKWARD, FFTW_ESTIMATE);
2275 fpb =
new float[fftFrameSize2];
2276 expect =
new float[fftFrameSize2];
2277 hanning =
new float[fftFrameSize];
2278 hanningd =
new float[fftFrameSize];
2279 resampin =
new float[fftFrameSize];
2280 resampin2 =
new float[fftFrameSize];
2281 resampout =
new float[fftFrameSize*4];
2282 indata2 =
new float[fftFrameSize*4];
2290 void smbPitchShift::mem_free()
2293 mem_allocated =
false;
2294 if (fpb) {
delete fpb; fpb = 0; }
2295 if (expect) {
delete expect; expect = 0; }
2296 if (hanning) {
delete hanning; hanning = 0; }
2297 if (hanningd) {
delete hanningd; hanningd = 0; }
2298 if (resampin) {
delete resampin; resampin = 0; }
2299 if (resampin2) {
delete resampin2; resampin2 = 0; }
2300 if (resampout) {
delete resampout; resampout = 0; }
2301 if (indata2) {
delete indata2; indata2 = 0; }
2303 {fftwf_destroy_plan(ftPlanForward);ftPlanForward = 0; }
2305 { fftwf_destroy_plan(ftPlanInverse);ftPlanInverse = 0; }
2308 int smbPitchShift::activate(
bool start)
2311 if (!mem_allocated) {
2314 }
else if (mem_allocated) {
2320 void smbPitchShift::change_buffersize(
unsigned int size)
2324 if (mem_allocated) {
2330 void smbPitchShift::change_latency()
2334 if (mem_allocated) {
2342 if (mem_allocated) {
2348 void __rt_func smbPitchShift::compute_static(
int count,
float *input0,
float *output0,
PluginDef *p)
2350 static_cast<smbPitchShift*
>(p)->PitchShift(count, input0, output0);
2354 void always_inline smbPitchShift::PitchShift(
int count,
float *indata,
float *outdata)
2357 if (!ready || count != numSampsToProcess) {
2358 if (indata != outdata)
2360 memcpy(outdata,indata,count*
sizeof(
float));
2365 resamp.
down(numSampsToResamp,indata,resampin);
2366 double fSlow0 = (0.01 * wet);
2367 double fSlow1 = (0.01 * dry);
2370 for (i = 0; i < count; i++){
2371 indata2[ii] = indata[i];
2375 for (i = 0; i < numSampsToResamp; i++){
2376 resampin2[ai] = resampin[i];
2380 if (ai>=fftFrameSize) {
2397 float pitchShift = pow(2., (semitones+tone)*0.0833333333);
2399 for (i = 0; i < fftFrameSize; i++){
2402 float fTemp = resampin2[i];
2403 gInFIFO[gRover] = fTemp;
2404 resampin2[i] = gOutFIFO[gRover-inFifoLatency];
2408 if (gRover >= fftFrameSize) {
2409 gRover = inFifoLatency;
2412 for (k = 0; k < fftFrameSize;k++) {
2413 fftw_in[k][0] = gInFIFO[k] * hanning[k];
2414 fftw_in[k][1] = 0.0;
2420 fftwf_execute(ftPlanForward);
2423 for (k = 0; k < fftFrameSize2; k++) {
2426 real = fftw_out[k][0];
2427 imag = fftw_out[k][1];
2430 magn = 2.*sqrt(real*real + imag*imag);
2431 phase = atan2(imag,real);
2434 tmp = phase - gLastPhase[k];
2435 gLastPhase[k] = phase;
2442 if (qpd >= 0) qpd += qpd&1;
2444 tmp -=
M_PI*(double)qpd;
2448 tmp = fpb[k] + tmp*freqPerBin2;
2458 memset(gSynMagn, 0, fftFrameSize*
sizeof(
float));
2459 memset(gSynFreq, 0, fftFrameSize*
sizeof(
float));
2460 for (k = 1; k < fftFrameSize2-2; k++) {
2461 index = k*pitchShift;
2462 if (index < fftFrameSize2) {
2463 if (index < fftFrameSize2*0.20)
2464 gSynMagn[index] += gAnaMagn[k]*a;
2465 else if (index < fftFrameSize2*0.45)
2466 gSynMagn[index] += gAnaMagn[k]*b;
2467 else if (index < fftFrameSize2*0.667)
2468 gSynMagn[index] += gAnaMagn[k]*c;
2470 gSynMagn[index] += gAnaMagn[k]*d;
2471 gSynFreq[index] = gAnaFreq[k] * pitchShift;
2477 for (k = 0; k < fftFrameSize2; k++) {
2487 tmp = ((gSynFreq[k] - fpb[k]) * freqPerBin1) + expect[k];
2490 gSumPhase[k] += tmp;
2491 phase = gSumPhase[k];
2492 if (magn == 0.0)
continue;
2495 fftw_in[k][0] = magn * cos (phase);
2496 fftw_in[k][1] = magn * sin (phase);
2500 fftwf_execute(ftPlanInverse);
2502 for(k=0; k < fftFrameSize; k++) {
2503 gOutputAccum[k] += hanningd[k] * fftw_out[ k][0] ;
2505 for (k = 0; k < stepSize; k++) gOutFIFO[k] = gOutputAccum[k];
2508 memmove(gOutputAccum, gOutputAccum+stepSize, fftFrameSize*
sizeof(
float));
2511 for (k = 0; k < inFifoLatency; k++) gInFIFO[k] = gInFIFO[k+stepSize];
2514 resamp.
up(fftFrameSize,resampin2,resampout);
2518 for (i = 0; i < count; i++){
2519 outdata[i] = ((fSlow0 * resampout[aio]) + (fSlow1 *indata2[aio]));
2523 for (i = 0; i < count; i++){
2524 outdata[i] = ((fSlow0 * resampout[aio]) + (fSlow1 *indata[i]));
2530 int smbPitchShift::register_par(
const ParamReg& reg)
2532 reg.
registerVar(
"smbPitchShift.semitone",
N_(
"Detune"),
"S",
"", &semitones, 0.0, -12., 12., 0.1);
2533 static const value_pair octave_values[] = {{
"unison"},{
"octave up"},{
"octave down"},{0}};
2534 reg.
registerIEnumVar(
"smbPitchShift.octave",
N_(
"add harmonics"),
"B",
N_(
"add harmonics"),octave_values,&octave, 0);
2535 static const value_pair latency_values[] = {{
"latency "},{
"compensate"},{0}};
2536 reg.
registerEnumVar(
"smbPitchShift.l",
N_(
"compensate latency"),
"S",
N_(
"compensate latency"),latency_values,&l, 0.0f, 0.0f, 1.0f, 1.0f);
2537 static const value_pair latency_set[] = {{
"high quality"},{
"low quality"},{
"realtime"},{0}};
2538 reg.
registerIEnumVar(
"smbPitchShift.latency",
N_(
"latency settings"),
"B",
N_(
"latency settings"),latency_set,&latency, 0);
2539 reg.
registerVar(
"smbPitchShift.wet",
N_(
"Wet"),
"S",
N_(
"Wet amount"), &wet, 50.0, 0.0, 100.0, 1);
2540 reg.
registerVar(
"smbPitchShift.dry",
N_(
"Dry"),
"S",
N_(
"Dry amount"), &dry, 50.0, 0.0, 100.0, 1);
2541 reg.
registerVar(
"smbPitchShift.a",
N_(
"low"),
"S",
N_(
"Sub"), &a, 1.0, 0.0, 2.0, 0.01);
2542 reg.
registerVar(
"smbPitchShift.b",
N_(
"middle low"),
"S",
N_(
"Low"), &b, 1.0, 0.0, 2.0, 0.01);
2543 reg.
registerVar(
"smbPitchShift.c",
N_(
"middle treble"),
"S",
N_(
"Mid"), &c, 1.0, 0.0, 2.0, 0.01);
2544 reg.
registerVar(
"smbPitchShift.d",
N_(
"treble"),
"S",
N_(
"Hi"), &d, 1.0, 0.0, 2.0, 0.01);
2545 param[
"smbPitchShift.latency"].signal_changed_int().connect(
2546 sigc::hide(sigc::mem_fun(
this, &smbPitchShift::change_latency)));
2550 int smbPitchShift::registerparam(
const ParamReg& reg)
2555 int smbPitchShift::load_ui_f(
const UiBuilder& b,
int form)
2610 int smbPitchShift::load_ui_f_static(
const UiBuilder& b,
int form)
2615 void smbPitchShift::del_instance(
PluginDef *p)