commit 0416b62bc3963dbd4c169da6a6027ad561cb3412
parent e3bf586c3083f50c2461b9b9ce520ff2b4149da4
Author: Isabel Kaspriskie <ikaspriskie@gmail.com>
Date: Sun, 2 May 2021 21:03:34 -0500
Include gigaverb exports
Diffstat:
2 files changed, 651 insertions(+), 0 deletions(-)
diff --git a/gen/exports/gigaverb.cpp b/gen/exports/gigaverb.cpp
@@ -0,0 +1,602 @@
+#include "gigaverb.h"
+
+namespace gigaverb {
+
+/*******************************************************************************************************************
+Cycling '74 License for Max-Generated Code for Export
+Copyright (c) 2016 Cycling '74
+The code that Max generates automatically and that end users are capable of exporting and using, and any
+ associated documentation files (the “Software”) is a work of authorship for which Cycling '74 is the author
+ and owner for copyright purposes. A license is hereby granted, free of charge, to any person obtaining a
+ copy of the Software (“Licensee”) to use, copy, modify, merge, publish, and distribute copies of the Software,
+ and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The Software is licensed to Licensee only for non-commercial use. Users who wish to make commercial use of the
+ Software must contact the copyright owner to determine if a license for commercial use is available, and the
+ terms and conditions for same, which may include fees or royalties. For commercial use, please send inquiries
+ to licensing (at) cycling74.com. The determination of whether a use is commercial use or non-commercial use is based
+ upon the use, not the user. The Software may be used by individuals, institutions, governments, corporations, or
+ other business whether for-profit or non-profit so long as the use itself is not a commercialization of the
+ materials or a use that generates or is intended to generate income, revenue, sales or profit.
+The above copyright notice and this license shall be included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ DEALINGS IN THE SOFTWARE.
+*******************************************************************************************************************/
+
+// global noise generator
+Noise noise;
+static const int GENLIB_LOOPCOUNT_BAIL = 100000;
+
+
+// The State struct contains all the state and procedures for the gendsp kernel
+typedef struct State {
+ CommonState __commonstate;
+ Delay m_delay_11;
+ Delay m_delay_10;
+ Delay m_delay_12;
+ Delay m_delay_6;
+ Delay m_delay_7;
+ Delay m_delay_8;
+ Delay m_delay_13;
+ Delay m_delay_15;
+ Delay m_delay_14;
+ Delay m_delay_17;
+ Delay m_delay_16;
+ Delay m_delay_9;
+ int __exception;
+ int vectorsize;
+ t_sample m_tail_20;
+ t_sample m_roomsize_19;
+ t_sample m_early_24;
+ t_sample m_bandwidth_21;
+ t_sample m_revtime_23;
+ t_sample m_damping_22;
+ t_sample m_history_5;
+ t_sample m_dry_18;
+ t_sample m_history_1;
+ t_sample m_history_4;
+ t_sample samplerate;
+ t_sample m_history_3;
+ t_sample m_history_2;
+ t_sample m_spread_25;
+ // re-initialize all member variables;
+ inline void reset(t_param __sr, int __vs) {
+ __exception = 0;
+ vectorsize = __vs;
+ samplerate = __sr;
+ m_history_1 = ((int)0);
+ m_history_2 = ((int)0);
+ m_history_3 = ((int)0);
+ m_history_4 = ((int)0);
+ m_history_5 = ((int)0);
+ m_delay_6.reset("m_delay_6", ((int)5000));
+ m_delay_7.reset("m_delay_7", ((int)7000));
+ m_delay_8.reset("m_delay_8", ((int)15000));
+ m_delay_9.reset("m_delay_9", ((int)16000));
+ m_delay_10.reset("m_delay_10", ((int)6000));
+ m_delay_11.reset("m_delay_11", ((int)10000));
+ m_delay_12.reset("m_delay_12", ((int)12000));
+ m_delay_13.reset("m_delay_13", ((int)48000));
+ m_delay_14.reset("m_delay_14", ((int)48000));
+ m_delay_15.reset("m_delay_15", ((int)48000));
+ m_delay_16.reset("m_delay_16", ((int)48000));
+ m_delay_17.reset("m_delay_17", ((int)48000));
+ m_dry_18 = ((int)1);
+ m_roomsize_19 = ((int)75);
+ m_tail_20 = ((t_sample)0.25);
+ m_bandwidth_21 = ((t_sample)0.5);
+ m_damping_22 = ((t_sample)0.7);
+ m_revtime_23 = ((int)11);
+ m_early_24 = ((t_sample)0.25);
+ m_spread_25 = ((int)23);
+ genlib_reset_complete(this);
+
+ };
+ // the signal processing routine;
+ inline int perform(t_sample ** __ins, t_sample ** __outs, int __n) {
+ vectorsize = __n;
+ const t_sample * __in1 = __ins[0];
+ const t_sample * __in2 = __ins[1];
+ t_sample * __out1 = __outs[0];
+ t_sample * __out2 = __outs[1];
+ if (__exception) {
+ return __exception;
+
+ } else if (( (__in1 == 0) || (__in2 == 0) || (__out1 == 0) || (__out2 == 0) )) {
+ __exception = GENLIB_ERR_NULL_BUFFER;
+ return __exception;
+
+ };
+ t_sample expr_165 = ((m_roomsize_19 * samplerate) * ((t_sample)0.0029411764705882));
+ t_sample expr_164 = safepow(((t_sample)0.001), safediv(((int)1), (m_revtime_23 * samplerate)));
+ t_sample mul_144 = (expr_165 * ((t_sample)0.7071));
+ t_sample expr_157 = (-safepow(expr_164, mul_144));
+ t_sample add_69 = (expr_165 + ((int)5));
+ t_sample expr_159 = safepow(expr_164, add_69);
+ t_sample mul_146 = (expr_165 * ((int)1));
+ t_sample expr_163 = (-safepow(expr_164, mul_146));
+ t_sample mul_143 = (expr_165 * ((t_sample)0.63245));
+ t_sample expr_156 = (-safepow(expr_164, mul_143));
+ t_sample mul_145 = (expr_165 * ((t_sample)0.81649));
+ t_sample expr_158 = (-safepow(expr_164, mul_145));
+ t_sample rsub_154 = (((int)1) - m_bandwidth_21);
+ t_sample mul_75 = (expr_165 * ((t_sample)0.41));
+ t_sample add_72 = (mul_75 + ((int)5));
+ t_sample expr_162 = safepow(expr_164, add_72);
+ t_sample mul_74 = (expr_165 * ((t_sample)0.3));
+ t_sample add_71 = (mul_74 + ((int)5));
+ t_sample expr_161 = safepow(expr_164, add_71);
+ t_sample mul_73 = (expr_165 * ((t_sample)0.155));
+ t_sample add_70 = (mul_73 + ((int)5));
+ t_sample expr_160 = safepow(expr_164, add_70);
+ t_sample mul_140 = (expr_165 * ((t_sample)0.000527));
+ int int_139 = int(mul_140);
+ t_sample mul_80 = (m_spread_25 * (-0.380445));
+ t_sample add_79 = (mul_80 + ((int)931));
+ t_sample rsub_76 = (((int)1341) - add_79);
+ t_sample mul_89 = (int_139 * rsub_76);
+ t_sample mul_108 = (m_spread_25 * ((t_sample)0.376623));
+ t_sample add_107 = (mul_108 + ((int)931));
+ t_sample rsub_104 = (((int)1341) - add_107);
+ t_sample mul_115 = (int_139 * rsub_104);
+ t_sample mul_138 = (expr_165 * ((t_sample)0.110732));
+ t_sample mul_82 = (m_spread_25 * (-0.568366));
+ t_sample add_78 = (mul_82 + ((int)369));
+ t_sample rsub_77 = (add_79 - add_78);
+ t_sample mul_96 = (int_139 * rsub_77);
+ t_sample mul_124 = (m_spread_25 * ((t_sample)0.125541));
+ t_sample add_106 = (mul_124 + ((int)369));
+ t_sample rsub_105 = (add_107 - add_106);
+ t_sample mul_122 = (int_139 * rsub_105);
+ t_sample add_81 = (mul_82 + ((int)159));
+ t_sample mul_103 = (int_139 * add_81);
+ t_sample add_123 = (mul_124 + ((int)159));
+ t_sample mul_131 = (int_139 * add_123);
+ // the main sample loop;
+ while ((__n--)) {
+ const t_sample in1 = (*(__in1++));
+ const t_sample in2 = (*(__in2++));
+ t_sample mul_1 = (in2 * m_dry_18);
+ t_sample mul_13 = (in1 * m_dry_18);
+ t_sample mul_3 = ((in1 + in2) * ((t_sample)0.707));
+ t_sample mix_203 = (mul_3 + (rsub_154 * (m_history_5 - mul_3)));
+ t_sample mix_153 = mix_203;
+ t_sample tap_49 = m_delay_17.read_linear(mul_144);
+ t_sample mul_45 = (tap_49 * expr_157);
+ t_sample mix_204 = (mul_45 + (m_damping_22 * (m_history_4 - mul_45)));
+ t_sample mix_47 = mix_204;
+ t_sample tap_151 = m_delay_16.read_linear(mul_146);
+ t_sample mul_142 = (tap_151 * expr_163);
+ t_sample mix_205 = (mul_142 + (m_damping_22 * (m_history_3 - mul_142)));
+ t_sample mix_149 = mix_205;
+ t_sample tap_55 = m_delay_15.read_linear(mul_145);
+ t_sample mul_51 = (tap_55 * expr_158);
+ t_sample mix_206 = (mul_51 + (m_damping_22 * (m_history_2 - mul_51)));
+ t_sample mix_53 = mix_206;
+ t_sample tap_43 = m_delay_14.read_linear(mul_143);
+ t_sample mul_39 = (tap_43 * expr_156);
+ t_sample mix_207 = (mul_39 + (m_damping_22 * (m_history_1 - mul_39)));
+ t_sample mix_41 = mix_207;
+ t_sample tap_57 = m_delay_13.read_linear(add_72);
+ t_sample tap_58 = m_delay_13.read_linear(add_71);
+ t_sample tap_59 = m_delay_13.read_linear(add_70);
+ t_sample tap_60 = m_delay_13.read_linear(add_69);
+ t_sample mul_63 = (tap_59 * expr_160);
+ t_sample mul_67 = (tap_57 * expr_162);
+ t_sample mul_65 = (tap_58 * expr_161);
+ t_sample mul_61 = (tap_60 * expr_159);
+ t_sample tap_88 = m_delay_12.read_linear(mul_89);
+ t_sample mul_86 = (tap_88 * ((t_sample)0.625));
+ t_sample tap_114 = m_delay_11.read_linear(mul_115);
+ t_sample mul_112 = (tap_114 * ((t_sample)0.625));
+ t_sample add_33 = (mix_149 + mix_53);
+ t_sample add_31 = (mix_47 + mix_41);
+ t_sample sub_30 = (add_33 - add_31);
+ t_sample mul_12 = (sub_30 * ((t_sample)0.5));
+ t_sample add_37 = (mul_12 + mul_67);
+ t_sample add_26 = (add_33 + add_31);
+ t_sample mul_9 = (add_26 * ((t_sample)0.5));
+ t_sample add_34 = (mul_9 + mul_61);
+ t_sample sub_32 = (mix_149 - mix_53);
+ t_sample sub_29 = (mix_47 - mix_41);
+ t_sample sub_28 = (sub_32 - sub_29);
+ t_sample mul_11 = (sub_28 * ((t_sample)0.5));
+ t_sample add_36 = (mul_11 + mul_65);
+ t_sample add_27 = (sub_32 + sub_29);
+ t_sample rsub_25 = (((int)0) - add_27);
+ t_sample mul_10 = (rsub_25 * ((t_sample)0.5));
+ t_sample add_35 = (mul_10 + mul_63);
+ t_sample tap_137 = m_delay_10.read_linear(mul_138);
+ t_sample tap_95 = m_delay_9.read_linear(mul_96);
+ t_sample mul_93 = (tap_95 * ((t_sample)0.625));
+ t_sample tap_121 = m_delay_8.read_linear(mul_122);
+ t_sample mul_119 = (tap_121 * ((t_sample)0.625));
+ t_sample mul_135 = (tap_137 * ((t_sample)0.75));
+ t_sample sub_134 = (mix_153 - mul_135);
+ t_sample mul_133 = (sub_134 * ((t_sample)0.75));
+ t_sample add_132 = (mul_133 + tap_137);
+ t_sample tap_102 = m_delay_7.read_linear(mul_103);
+ t_sample mul_100 = (tap_102 * ((t_sample)0.75));
+ t_sample tap_130 = m_delay_6.read_linear(mul_131);
+ t_sample mul_128 = (tap_130 * ((t_sample)0.75));
+ t_sample mul_24 = (mul_12 * m_tail_20);
+ t_sample mul_22 = (mul_10 * m_tail_20);
+ t_sample add_8 = (mul_24 + mul_22);
+ t_sample mul_23 = (mul_11 * m_tail_20);
+ t_sample mul_21 = (mul_9 * m_tail_20);
+ t_sample add_7 = (mul_23 + mul_21);
+ t_sample sub_16 = (add_8 - add_7);
+ t_sample mul_20 = (mul_67 * m_early_24);
+ t_sample mul_18 = (mul_63 * m_early_24);
+ t_sample add_6 = (mul_20 + mul_18);
+ t_sample mul_19 = (mul_65 * m_early_24);
+ t_sample mul_17 = (mul_61 * m_early_24);
+ t_sample add_5 = (mul_19 + mul_17);
+ t_sample sub_15 = (add_6 - add_5);
+ t_sample add_2 = (sub_16 + sub_15);
+ t_sample add_4 = (add_2 + in2);
+ t_sample sub_99 = (add_4 - mul_100);
+ t_sample mul_98 = (sub_99 * ((t_sample)0.75));
+ t_sample add_97 = (mul_98 + tap_102);
+ t_sample sub_92 = (add_97 - mul_93);
+ t_sample mul_91 = (sub_92 * ((t_sample)0.625));
+ t_sample add_90 = (mul_91 + tap_95);
+ t_sample sub_85 = (add_90 - mul_86);
+ t_sample mul_84 = (sub_85 * ((t_sample)0.625));
+ t_sample add_83 = (mul_84 + tap_88);
+ t_sample out2 = (mul_1 + add_83);
+ t_sample add_14 = (add_2 + in1);
+ t_sample sub_127 = (add_14 - mul_128);
+ t_sample mul_126 = (sub_127 * ((t_sample)0.75));
+ t_sample add_125 = (mul_126 + tap_130);
+ t_sample sub_118 = (add_125 - mul_119);
+ t_sample mul_117 = (sub_118 * ((t_sample)0.625));
+ t_sample add_116 = (mul_117 + tap_121);
+ t_sample sub_111 = (add_116 - mul_112);
+ t_sample mul_110 = (sub_111 * ((t_sample)0.625));
+ t_sample add_109 = (mul_110 + tap_114);
+ t_sample out1 = (mul_13 + add_109);
+ t_sample history_152_next_166 = fixdenorm(mix_153);
+ t_sample history_46_next_167 = fixdenorm(mix_47);
+ t_sample history_148_next_168 = fixdenorm(mix_149);
+ t_sample history_52_next_169 = fixdenorm(mix_53);
+ t_sample history_40_next_170 = fixdenorm(mix_41);
+ m_delay_17.write(add_35);
+ m_delay_16.write(add_37);
+ m_delay_15.write(add_36);
+ m_delay_14.write(add_34);
+ m_delay_13.write(add_132);
+ m_delay_12.write(sub_85);
+ m_delay_11.write(sub_111);
+ m_delay_10.write(sub_134);
+ m_delay_9.write(sub_92);
+ m_delay_8.write(sub_118);
+ m_delay_7.write(sub_99);
+ m_delay_6.write(sub_127);
+ m_history_5 = history_152_next_166;
+ m_history_4 = history_46_next_167;
+ m_history_3 = history_148_next_168;
+ m_history_2 = history_52_next_169;
+ m_history_1 = history_40_next_170;
+ m_delay_6.step();
+ m_delay_7.step();
+ m_delay_8.step();
+ m_delay_9.step();
+ m_delay_10.step();
+ m_delay_11.step();
+ m_delay_12.step();
+ m_delay_13.step();
+ m_delay_14.step();
+ m_delay_15.step();
+ m_delay_16.step();
+ m_delay_17.step();
+ // assign results to output buffer;
+ (*(__out1++)) = out1;
+ (*(__out2++)) = out2;
+
+ };
+ return __exception;
+
+ };
+ inline void set_dry(t_param _value) {
+ m_dry_18 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));
+ };
+ inline void set_roomsize(t_param _value) {
+ m_roomsize_19 = (_value < 0.1 ? 0.1 : (_value > 300 ? 300 : _value));
+ };
+ inline void set_tail(t_param _value) {
+ m_tail_20 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));
+ };
+ inline void set_bandwidth(t_param _value) {
+ m_bandwidth_21 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));
+ };
+ inline void set_damping(t_param _value) {
+ m_damping_22 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));
+ };
+ inline void set_revtime(t_param _value) {
+ m_revtime_23 = (_value < 0.1 ? 0.1 : (_value > 1 ? 1 : _value));
+ };
+ inline void set_early(t_param _value) {
+ m_early_24 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));
+ };
+ inline void set_spread(t_param _value) {
+ m_spread_25 = (_value < 0 ? 0 : (_value > 100 ? 100 : _value));
+ };
+
+} State;
+
+
+///
+/// Configuration for the genlib API
+///
+
+/// Number of signal inputs and outputs
+
+int gen_kernel_numins = 2;
+int gen_kernel_numouts = 2;
+
+int num_inputs() { return gen_kernel_numins; }
+int num_outputs() { return gen_kernel_numouts; }
+int num_params() { return 8; }
+
+/// Assistive lables for the signal inputs and outputs
+
+const char *gen_kernel_innames[] = { "in1", "in2" };
+const char *gen_kernel_outnames[] = { "out1", "out2" };
+
+/// Invoke the signal process of a State object
+
+int perform(CommonState *cself, t_sample **ins, long numins, t_sample **outs, long numouts, long n) {
+ State* self = (State *)cself;
+ return self->perform(ins, outs, n);
+}
+
+/// Reset all parameters and stateful operators of a State object
+
+void reset(CommonState *cself) {
+ State* self = (State *)cself;
+ self->reset(cself->sr, cself->vs);
+}
+
+/// Set a parameter of a State object
+
+void setparameter(CommonState *cself, long index, t_param value, void *ref) {
+ State *self = (State *)cself;
+ switch (index) {
+ case 0: self->set_bandwidth(value); break;
+ case 1: self->set_damping(value); break;
+ case 2: self->set_dry(value); break;
+ case 3: self->set_early(value); break;
+ case 4: self->set_revtime(value); break;
+ case 5: self->set_roomsize(value); break;
+ case 6: self->set_spread(value); break;
+ case 7: self->set_tail(value); break;
+
+ default: break;
+ }
+}
+
+/// Get the value of a parameter of a State object
+
+void getparameter(CommonState *cself, long index, t_param *value) {
+ State *self = (State *)cself;
+ switch (index) {
+ case 0: *value = self->m_bandwidth_21; break;
+ case 1: *value = self->m_damping_22; break;
+ case 2: *value = self->m_dry_18; break;
+ case 3: *value = self->m_early_24; break;
+ case 4: *value = self->m_revtime_23; break;
+ case 5: *value = self->m_roomsize_19; break;
+ case 6: *value = self->m_spread_25; break;
+ case 7: *value = self->m_tail_20; break;
+
+ default: break;
+ }
+}
+
+/// Get the name of a parameter of a State object
+
+const char *getparametername(CommonState *cself, long index) {
+ if (index >= 0 && index < cself->numparams) {
+ return cself->params[index].name;
+ }
+ return 0;
+}
+
+/// Get the minimum value of a parameter of a State object
+
+t_param getparametermin(CommonState *cself, long index) {
+ if (index >= 0 && index < cself->numparams) {
+ return cself->params[index].outputmin;
+ }
+ return 0;
+}
+
+/// Get the maximum value of a parameter of a State object
+
+t_param getparametermax(CommonState *cself, long index) {
+ if (index >= 0 && index < cself->numparams) {
+ return cself->params[index].outputmax;
+ }
+ return 0;
+}
+
+/// Get parameter of a State object has a minimum and maximum value
+
+char getparameterhasminmax(CommonState *cself, long index) {
+ if (index >= 0 && index < cself->numparams) {
+ return cself->params[index].hasminmax;
+ }
+ return 0;
+}
+
+/// Get the units of a parameter of a State object
+
+const char *getparameterunits(CommonState *cself, long index) {
+ if (index >= 0 && index < cself->numparams) {
+ return cself->params[index].units;
+ }
+ return 0;
+}
+
+/// Get the size of the state of all parameters of a State object
+
+size_t getstatesize(CommonState *cself) {
+ return genlib_getstatesize(cself, &getparameter);
+}
+
+/// Get the state of all parameters of a State object
+
+short getstate(CommonState *cself, char *state) {
+ return genlib_getstate(cself, state, &getparameter);
+}
+
+/// set the state of all parameters of a State object
+
+short setstate(CommonState *cself, const char *state) {
+ return genlib_setstate(cself, state, &setparameter);
+}
+
+/// Allocate and configure a new State object and it's internal CommonState:
+
+void *create(t_param sr, long vs) {
+ State *self = new State;
+ self->reset(sr, vs);
+ ParamInfo *pi;
+ self->__commonstate.inputnames = gen_kernel_innames;
+ self->__commonstate.outputnames = gen_kernel_outnames;
+ self->__commonstate.numins = gen_kernel_numins;
+ self->__commonstate.numouts = gen_kernel_numouts;
+ self->__commonstate.sr = sr;
+ self->__commonstate.vs = vs;
+ self->__commonstate.params = (ParamInfo *)genlib_sysmem_newptr(8 * sizeof(ParamInfo));
+ self->__commonstate.numparams = 8;
+ // initialize parameter 0 ("m_bandwidth_21")
+ pi = self->__commonstate.params + 0;
+ pi->name = "bandwidth";
+ pi->paramtype = GENLIB_PARAMTYPE_FLOAT;
+ pi->defaultvalue = self->m_bandwidth_21;
+ pi->defaultref = 0;
+ pi->hasinputminmax = false;
+ pi->inputmin = 0;
+ pi->inputmax = 1;
+ pi->hasminmax = true;
+ pi->outputmin = 0;
+ pi->outputmax = 1;
+ pi->exp = 0;
+ pi->units = ""; // no units defined
+ // initialize parameter 1 ("m_damping_22")
+ pi = self->__commonstate.params + 1;
+ pi->name = "damping";
+ pi->paramtype = GENLIB_PARAMTYPE_FLOAT;
+ pi->defaultvalue = self->m_damping_22;
+ pi->defaultref = 0;
+ pi->hasinputminmax = false;
+ pi->inputmin = 0;
+ pi->inputmax = 1;
+ pi->hasminmax = true;
+ pi->outputmin = 0;
+ pi->outputmax = 1;
+ pi->exp = 0;
+ pi->units = ""; // no units defined
+ // initialize parameter 2 ("m_dry_18")
+ pi = self->__commonstate.params + 2;
+ pi->name = "dry";
+ pi->paramtype = GENLIB_PARAMTYPE_FLOAT;
+ pi->defaultvalue = self->m_dry_18;
+ pi->defaultref = 0;
+ pi->hasinputminmax = false;
+ pi->inputmin = 0;
+ pi->inputmax = 1;
+ pi->hasminmax = true;
+ pi->outputmin = 0;
+ pi->outputmax = 1;
+ pi->exp = 0;
+ pi->units = ""; // no units defined
+ // initialize parameter 3 ("m_early_24")
+ pi = self->__commonstate.params + 3;
+ pi->name = "early";
+ pi->paramtype = GENLIB_PARAMTYPE_FLOAT;
+ pi->defaultvalue = self->m_early_24;
+ pi->defaultref = 0;
+ pi->hasinputminmax = false;
+ pi->inputmin = 0;
+ pi->inputmax = 1;
+ pi->hasminmax = true;
+ pi->outputmin = 0;
+ pi->outputmax = 1;
+ pi->exp = 0;
+ pi->units = ""; // no units defined
+ // initialize parameter 4 ("m_revtime_23")
+ pi = self->__commonstate.params + 4;
+ pi->name = "revtime";
+ pi->paramtype = GENLIB_PARAMTYPE_FLOAT;
+ pi->defaultvalue = self->m_revtime_23;
+ pi->defaultref = 0;
+ pi->hasinputminmax = false;
+ pi->inputmin = 0;
+ pi->inputmax = 1;
+ pi->hasminmax = true;
+ pi->outputmin = 0.1;
+ pi->outputmax = 1;
+ pi->exp = 0;
+ pi->units = ""; // no units defined
+ // initialize parameter 5 ("m_roomsize_19")
+ pi = self->__commonstate.params + 5;
+ pi->name = "roomsize";
+ pi->paramtype = GENLIB_PARAMTYPE_FLOAT;
+ pi->defaultvalue = self->m_roomsize_19;
+ pi->defaultref = 0;
+ pi->hasinputminmax = false;
+ pi->inputmin = 0;
+ pi->inputmax = 1;
+ pi->hasminmax = true;
+ pi->outputmin = 0.1;
+ pi->outputmax = 300;
+ pi->exp = 0;
+ pi->units = ""; // no units defined
+ // initialize parameter 6 ("m_spread_25")
+ pi = self->__commonstate.params + 6;
+ pi->name = "spread";
+ pi->paramtype = GENLIB_PARAMTYPE_FLOAT;
+ pi->defaultvalue = self->m_spread_25;
+ pi->defaultref = 0;
+ pi->hasinputminmax = false;
+ pi->inputmin = 0;
+ pi->inputmax = 1;
+ pi->hasminmax = true;
+ pi->outputmin = 0;
+ pi->outputmax = 100;
+ pi->exp = 0;
+ pi->units = ""; // no units defined
+ // initialize parameter 7 ("m_tail_20")
+ pi = self->__commonstate.params + 7;
+ pi->name = "tail";
+ pi->paramtype = GENLIB_PARAMTYPE_FLOAT;
+ pi->defaultvalue = self->m_tail_20;
+ pi->defaultref = 0;
+ pi->hasinputminmax = false;
+ pi->inputmin = 0;
+ pi->inputmax = 1;
+ pi->hasminmax = true;
+ pi->outputmin = 0;
+ pi->outputmax = 1;
+ pi->exp = 0;
+ pi->units = ""; // no units defined
+
+ return self;
+}
+
+/// Release all resources and memory used by a State object:
+
+void destroy(CommonState *cself) {
+ State *self = (State *)cself;
+ genlib_sysmem_freeptr(cself->params);
+
+ delete self;
+}
+
+
+} // gigaverb::
diff --git a/gen/exports/gigaverb.h b/gen/exports/gigaverb.h
@@ -0,0 +1,49 @@
+/*******************************************************************************************************************
+Cycling '74 License for Max-Generated Code for Export
+Copyright (c) 2016 Cycling '74
+The code that Max generates automatically and that end users are capable of exporting and using, and any
+ associated documentation files (the “Software”) is a work of authorship for which Cycling '74 is the author
+ and owner for copyright purposes. A license is hereby granted, free of charge, to any person obtaining a
+ copy of the Software (“Licensee”) to use, copy, modify, merge, publish, and distribute copies of the Software,
+ and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The Software is licensed to Licensee only for non-commercial use. Users who wish to make commercial use of the
+ Software must contact the copyright owner to determine if a license for commercial use is available, and the
+ terms and conditions for same, which may include fees or royalties. For commercial use, please send inquiries
+ to licensing (at) cycling74.com. The determination of whether a use is commercial use or non-commercial use is based
+ upon the use, not the user. The Software may be used by individuals, institutions, governments, corporations, or
+ other business whether for-profit or non-profit so long as the use itself is not a commercialization of the
+ materials or a use that generates or is intended to generate income, revenue, sales or profit.
+The above copyright notice and this license shall be included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ DEALINGS IN THE SOFTWARE.
+*******************************************************************************************************************/
+
+
+#include "genlib.h"
+#include "genlib_exportfunctions.h"
+#include "genlib_ops.h"
+
+namespace gigaverb {
+
+int num_inputs();
+int num_outputs();
+int num_params();
+int perform(CommonState *cself, t_sample **ins, long numins, t_sample **outs, long numouts, long n);
+void reset(CommonState *cself);
+void setparameter(CommonState *cself, long index, t_param value, void *ref);
+void getparameter(CommonState *cself, long index, t_param *value);
+const char *getparametername(CommonState *cself, long index);
+t_param getparametermin(CommonState *cself, long index);
+t_param getparametermax(CommonState *cself, long index);
+char getparameterhasminmax(CommonState *cself, long index);
+const char *getparameterunits(CommonState *cself, long index);
+size_t getstatesize(CommonState *cself);
+short getstate(CommonState *cself, char *state);
+short setstate(CommonState *cself, const char *state);
+void *create(t_param sr, long vs);
+void destroy(CommonState *cself);
+
+} // gigaverb::
