// increment static void op_adc_inc_fn(op_adc_t* adc, const s16 idx, const io_t inc) { io_t val; switch(idx) { case 0: // enable (toggle) if(adc->enable) { val = 0; op_adc_in_enable(adc, val); } else { val = OP_ONE; op_adc_in_enable(adc, val); } break; case 1: // period val = op_sadd(adc->period, inc); op_adc_in_period(adc, val); break; /* case 2: // val0 */ /* val = op_sadd(adc->val0, inc); */ /* op_adc_in_val0(adc, val); */ /* break; */ /* case 3: // val1 */ /* val = op_sadd(adc->val1, inc); */ /* op_adc_in_val1(adc, val); */ /* break; */ /* case 4: // val2 */ /* val = op_sadd(adc->val2, inc); */ /* op_adc_in_val2(adc, val); */ /* break; */ /* case 5: // val3 */ /* val = op_sadd(adc->val3, inc); */ /* op_adc_in_val3(adc, val); */ /* break; */ } }
// increment input by pointer, return value s32 scaler_svf_fc_inc(void* scaler, io_t* pin, io_t inc ) { ParamScaler* sc = (ParamScaler*)scaler; // this speeds up the knob a great deal. #if 0 s32 sinc; // scale up to smallest significant abscissa: // check for 16b overflow sinc = (s32)inc << inRshift; if(sinc > 0x3fff) { inc = (io_t)0x3fff; } else if (sinc < (s32)0xffffc000) { inc = (io_t)0xc000; } #endif // use saturation *pin = op_sadd(*pin, inc); if(*pin < sc->inMin) { *pin = sc->inMin; } if(*pin > sc->inMax) { *pin = sc->inMax; } // scale and return. // ignoring ranges in descriptor at least for now. return scaler_svf_fc_val(sc, *pin); }
// increment input by pointer, return value s32 scaler_amp_inc(void* scaler, io_t* pin, io_t inc ) { ParamScaler* sc = (ParamScaler*)scaler; // this speeds up the knob a great deal. #if 0 s32 sinc; // scale up to smallest significant abscissa: // check for 16b overflow sinc = (s32)inc << inRshift; if(sinc > 0x3fff) { inc = (io_t)0x3fff; } else if (sinc < (s32)0xffffc000) { inc = (io_t)0xc000; } #endif // use saturation *pin = op_sadd(*pin, inc); if(*pin < sc->inMin) { *pin = sc->inMin; } if(*pin > sc->inMax) { *pin = sc->inMax; } // FIXME: no customization of output range. return scaler_amp_val(sc, *pin); }
// increment static void op_route_inc(op_route_t* route, const s16 idx, const io_t inc) { io_t val; switch(idx) { case 0: break; case 1: // multiplier val = op_sadd(route->to, inc); op_route_in_to(route, val); break; } }
// increment input value void op_inc_in_val(op_t* op, const s16 idx, const io_t inc) { /* print_dbg("\r\n op_inc_in_val, "); */ /* print_dbg(" op @ 0x"); */ /* print_dbg_hex((u32)op); */ /* print_dbg(" old : 0x"); */ /* print_dbg_hex((u32)op_get_in_val(op, idx)); */ /* print_dbg(" inc : 0x"); */ /* print_dbg_hex((u32)inc); */ /* print_dbg(" new : 0x"); */ /* print_dbg_hex( (u32)op_sadd( op_get_in_val(op, idx), inc) ); */ op_set_in_val( op, idx, op_sadd( op_get_in_val(op, idx), inc) ); }
//===== UI input static void op_enc_inc_input(op_enc_t* enc, const s16 idx, const io_t inc) { io_t val; switch(idx) { /* case 0: // move */ /* op_enc_in_move(enc, inc); */ /* break; */ case 0: // min val = op_sadd(enc->min, inc); op_enc_in_min(enc, val); break; case 1: // max val = op_sadd(enc->max, inc); op_enc_in_max(enc, val); break; case 2: // step val = op_sadd(enc->step, inc); op_enc_in_step(enc, val); break; case 3: // wrap mode op_enc_in_wrap(enc, inc); break; } }
// increment static void op_sw_inc(op_sw_t* sw, const s16 idx, const io_t inc) { io_t val; // print_dbg("\r\n op_sw_inc"); switch(idx) { /* case 0: // current value */ /* op_sw_in_state(sw, inc); */ /* break; */ case 0: // toggle mode op_sw_in_tog(sw, inc); break; case 1: // multiplier val = op_sadd(sw->mul, inc); op_sw_in_mul(sw, val); break; } }
// input increment static void op_accum_in_inc(op_accum_t* accum, const io_t v) { accum->inc = v; accum->val = op_sadd(accum->val, v); op_accum_wrap_out(accum); }