// 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);
}
