elements::Part part;
elements::PerformanceState state;

uint32_t seed = 0;
uint32_t resonator = 0;
bool panic = false;
float blow_in[BUFSIZE];
float strike_in[BUFSIZE];
float left[BUFSIZE];
float right[BUFSIZE];

const float kNoiseGateThreshold = 0.0001f;
float strike_in_level = 0.0f;
float blow_in_level = 0.0f;

inline float constrainQ27(int32_t v, float vMin, float vMax) {
  return std::max<float>(vMin, std::min<float>(vMax, q27_to_float(v)));
}

inline float constrain(float v, float vMin, float vMax) {
  return std::max<float>(vMin, std::min<float>(vMax, v));
}

const int SAMPLE_SZ = 256026;
const int NOISE_SZ = 81926;

bool r = false;
LogTextMessage("sdram_get_free %d", sdram_get_free());

int16_t *smp_sample_data = (int16_t *)sdram_malloc(SAMPLE_SZ);
if (!smp_sample_data)
  return;

r = loadElementsData(0, "/shared/elements/smp_sample_data.raw", smp_sample_data,
                     SAMPLE_SZ / 2);

int16_t *smp_noise_data = (int16_t *)sdram_malloc(NOISE_SZ);
if (!smp_noise_data)
  return;

if (r)
  r = loadElementsData(1, "/shared/elements/smp_noise_data.raw", smp_noise_data,
                       NOISE_SZ / 2);

if (r) {
  LogTextMessage("Elements loading sample complete, SDRAM free %d",
                 sdram_get_free());
}

const int ELEMENTS_SZ = 32768;
part.Init((uint16_t *)sdram_malloc(ELEMENTS_SZ));

LogTextMessage("Elements initialised, SDRAM free %d", sdram_get_free());

for (int i = 0; i < BUFSIZE; i++) {
  left[i] = 0.0f;
  right[i] = 0.0f;
}

seed = 0;
part.Seed(&seed, 1);

resonator = 0;
part.set_resonator_model(elements::ResonatorModel(resonator));
state.gate = false;
state.note = 0.0f;
state.modulation = 0.0f;
state.strength = 0.0f;

part.mutable_patch()->exciter_envelope_shape = constrainQ27(param_contour +
                                                                inlet_contour,
                                                            0.0f, 1.0f);

part.mutable_patch()->exciter_bow_level =
    constrainQ27(param_bow_space_level + inlet_bow_space_level, 0.0f, 1.0f);
part.mutable_patch()->exciter_bow_timbre = constrainQ27(
    param_bow_space_timbre + inlet_bow_space_timbre, 0.0f, 0.9995f);

part.mutable_patch()->exciter_blow_level =
    constrainQ27(param_blow_space_level + inlet_blow_space_level, 0.0f, 1.0f);
part.mutable_patch()->exciter_blow_meta =
    constrainQ27(param_blow_space_flow + inlet_blow_space_flow, 0.0f, 0.9995f);
part.mutable_patch()->exciter_blow_timbre = constrainQ27(
    param_blow_space_timbre + inlet_blow_space_timbre, 0.0f, 0.9995f);

part.mutable_patch()->exciter_strike_level = constrainQ27(
    param_strike_space_level + inlet_strike_space_level, 0.0f, 1.0f);
part.mutable_patch()->exciter_strike_meta = constrainQ27(
    param_strike_space_mallet + inlet_strike_space_mallet, 0.0f, 0.9995f);
part.mutable_patch()->exciter_strike_timbre = constrainQ27(
    param_strike_space_timbre + inlet_strike_space_timbre, 0.0f, 0.9995f);

part.mutable_patch()->resonator_geometry = constrainQ27(param_geometry +
                                                            inlet_geometry,
                                                        0.0f, 0.9995f);
part.mutable_patch()->resonator_brightness = constrainQ27(param_brightness +
                                                              inlet_brightness,
                                                          0.0f, 0.9995f);
part.mutable_patch()->resonator_damping = constrainQ27(param_damping +
                                                           inlet_damping,
                                                       0.0f, 0.9995f);
part.mutable_patch()->resonator_position = constrainQ27(param_position +
                                                            inlet_position,
                                                        0.0f, 0.9995f);

part.mutable_patch()->space =
    constrain(q27_to_float(param_space + inlet_space) * 2.0, 0.0f, 2.0f);

uint32_t nresonator = ((param_resonator + inlet_resonator) % 3);
if (resonator != nresonator) {
  resonator = nresonator;
  part.set_resonator_model(elements::ResonatorModel(resonator));
}

uint32_t nseed = param_seed + inlet_seed;
if (seed != nseed) {
  seed = nseed;
  part.Seed(&seed, 1);
}

part.set_bypass(param_bypass || inlet_bypass);
part.set_easter_egg(param_easter_space_egg || inlet_easter_space_egg);

int i;
for (i = 0; i < BUFSIZE; i++) {
  float blow_in_sample = q27_to_float(inlet_blow[i]);
  ;
  float strike_in_sample = q27_to_float(inlet_strike[i]);

  float error = 0.0f, gain = 1.0f;
  //    error = strike_in_sample * strike_in_sample - strike_in_level;
  //    strike_in_level += error * (error > 0.0f ? 0.1f : 0.0001f);
  //    gain = strike_in_level <= kNoiseGateThreshold
  //          ? (1.0f / kNoiseGateThreshold) * strike_in_level : 1.0f;
  strike_in[i] = gain * strike_in_sample;

  //    error = blow_in_sample * blow_in_sample - blow_in_level;
  //    blow_in_level += error * (error > 0.0f ? 0.1f : 0.0001f);
  //    gain = blow_in_level <= kNoiseGateThreshold
  //          ? (1.0f / kNoiseGateThreshold) * blow_in_level : 1.0f;
  blow_in[i] = gain * blow_in_sample;
}

state.gate = inlet_gate;
state.note =
    constrain(q27_to_float(param_pitch + inlet_pitch) * 64.0f, -64.0f, 64.0f);

state.strength =
    constrainQ27(param_mod_space_depth + inlet_mod_space_depth, 0.0f, 1.0f);
state.modulation = constrain(
    q27_to_float(param_mod_space_pitch + inlet_mod_space_pitch) * 60.0f, -60.0f,
    60.0f);

part.Process(state, blow_in, strike_in, left, right, BUFSIZE);

for (i = 0; i < BUFSIZE; i++) {
  outlet_l[i] = float_to_q27(left[i]);
  outlet_r[i] = float_to_q27(right[i]);
}