20 #ifndef RESID_FILTER_H 21 #define RESID_FILTER_H 23 #include "resid-config.h" 317 enum { value =
summer_offset<i - 1>::value + ((2 + i - 1) << 16) };
330 enum { value =
mixer_offset<i - 1>::value + ((i - 1) << 16) };
351 void enable_filter(
bool enable);
352 void adjust_filter_bias(
double dac_bias);
353 void set_chip_model(chip_model model);
354 void set_voice_mask(reg4 mask);
356 void clock(
int voice1,
int voice2,
int voice3);
357 void clock(cycle_count delta_t,
int voice1,
int voice2,
int voice3);
361 void writeFC_LO(reg8);
362 void writeFC_HI(reg8);
363 void writeRES_FILT(reg8);
364 void writeMODE_VOL(reg8);
367 void input(
short sample);
417 int Vddt_Vw_2, Vw_bias;
423 chip_model sid_model;
442 unsigned short opamp_rev[1 << 16];
445 unsigned short gain[16][1 << 16];
448 unsigned short f0_dac[1 << 11];
452 int solve_integrate_6581(
int dt,
int vi_t,
int& x,
int& vc,
model_filter_t& mf);
455 static unsigned short vcr_kVg[1 << 16];
456 static unsigned short vcr_n_Ids_term[1 << 16];
470 #if RESID_INLINING || defined(RESID_FILTER_CC) 476 void Filter::clock(
int voice1,
int voice2,
int voice3)
480 v1 = (voice1*f.voice_scale_s14 >> 18) + f.voice_DC;
481 v2 = (voice2*f.voice_scale_s14 >> 18) + f.voice_DC;
482 v3 = (voice3*f.voice_scale_s14 >> 18) + f.voice_DC;
550 Vi = ve + v3 + v2 + v1;
556 if (sid_model == 0) {
558 Vlp = solve_integrate_6581(1, Vbp, Vlp_x, Vlp_vc, f);
559 Vbp = solve_integrate_6581(1, Vhp, Vbp_x, Vbp_vc, f);
560 Vhp = f.summer[offset + f.gain[_8_div_Q][Vbp] + Vlp + Vi];
568 int dVbp = w0*(Vhp >> 4) >> 16;
569 int dVlp = w0*(Vbp >> 4) >> 16;
572 Vhp = (Vbp*_1024_div_Q >> 10) - Vlp - Vi;
580 void Filter::clock(cycle_count delta_t,
int voice1,
int voice2,
int voice3)
584 v1 = (voice1*f.voice_scale_s14 >> 18) + f.voice_DC;
585 v2 = (voice2*f.voice_scale_s14 >> 18) + f.voice_DC;
586 v3 = (voice3*f.voice_scale_s14 >> 18) + f.voice_DC;
592 if (unlikely(!enabled)) {
662 Vi = ve + v3 + v2 + v1;
669 cycle_count delta_t_flt = 3;
671 if (sid_model == 0) {
674 if (unlikely(delta_t < delta_t_flt)) {
675 delta_t_flt = delta_t;
679 Vlp = solve_integrate_6581(delta_t_flt, Vbp, Vlp_x, Vlp_vc, f);
680 Vbp = solve_integrate_6581(delta_t_flt, Vhp, Vbp_x, Vbp_vc, f);
681 Vhp = f.summer[offset + f.gain[_8_div_Q][Vbp] + Vlp + Vi];
683 delta_t -= delta_t_flt;
689 if (delta_t < delta_t_flt) {
690 delta_t_flt = delta_t;
698 int w0_delta_t = w0*delta_t_flt >> 2;
700 int dVbp = w0_delta_t*(Vhp >> 4) >> 14;
701 int dVlp = w0_delta_t*(Vbp >> 4) >> 14;
704 Vhp = (Vbp*_1024_div_Q >> 10) - Vlp - Vi;
706 delta_t -= delta_t_flt;
716 void Filter::input(
short sample)
728 ve = (sample*f.voice_scale_s14*3 >> 14) + f.mixer[0];
736 short Filter::output()
763 switch (mix & 0x7f) {
825 Vi = ve + v3 + v2 + v1;
857 Vi = Vlp + v3 + v2 + v1;
873 Vi = Vlp + ve + v2 + v1;
881 Vi = Vlp + ve + v3 + v1;
885 Vi = Vlp + ve + v3 + v2;
889 Vi = Vlp + ve + v3 + v2 + v1;
921 Vi = Vbp + v3 + v2 + v1;
937 Vi = Vbp + ve + v2 + v1;
945 Vi = Vbp + ve + v3 + v1;
949 Vi = Vbp + ve + v3 + v2;
953 Vi = Vbp + ve + v3 + v2 + v1;
969 Vi = Vbp + Vlp + v2 + v1;
977 Vi = Vbp + Vlp + v3 + v1;
981 Vi = Vbp + Vlp + v3 + v2;
985 Vi = Vbp + Vlp + v3 + v2 + v1;
993 Vi = Vbp + Vlp + ve + v1;
997 Vi = Vbp + Vlp + ve + v2;
1001 Vi = Vbp + Vlp + ve + v2 + v1;
1005 Vi = Vbp + Vlp + ve + v3;
1009 Vi = Vbp + Vlp + ve + v3 + v1;
1013 Vi = Vbp + Vlp + ve + v3 + v2;
1017 Vi = Vbp + Vlp + ve + v3 + v2 + v1;
1049 Vi = Vhp + v3 + v2 + v1;
1065 Vi = Vhp + ve + v2 + v1;
1073 Vi = Vhp + ve + v3 + v1;
1077 Vi = Vhp + ve + v3 + v2;
1081 Vi = Vhp + ve + v3 + v2 + v1;
1089 Vi = Vhp + Vlp + v1;
1093 Vi = Vhp + Vlp + v2;
1097 Vi = Vhp + Vlp + v2 + v1;
1101 Vi = Vhp + Vlp + v3;
1105 Vi = Vhp + Vlp + v3 + v1;
1109 Vi = Vhp + Vlp + v3 + v2;
1113 Vi = Vhp + Vlp + v3 + v2 + v1;
1117 Vi = Vhp + Vlp + ve;
1121 Vi = Vhp + Vlp + ve + v1;
1125 Vi = Vhp + Vlp + ve + v2;
1129 Vi = Vhp + Vlp + ve + v2 + v1;
1133 Vi = Vhp + Vlp + ve + v3;
1137 Vi = Vhp + Vlp + ve + v3 + v1;
1141 Vi = Vhp + Vlp + ve + v3 + v2;
1145 Vi = Vhp + Vlp + ve + v3 + v2 + v1;
1153 Vi = Vhp + Vbp + v1;
1157 Vi = Vhp + Vbp + v2;
1161 Vi = Vhp + Vbp + v2 + v1;
1165 Vi = Vhp + Vbp + v3;
1169 Vi = Vhp + Vbp + v3 + v1;
1173 Vi = Vhp + Vbp + v3 + v2;
1177 Vi = Vhp + Vbp + v3 + v2 + v1;
1181 Vi = Vhp + Vbp + ve;
1185 Vi = Vhp + Vbp + ve + v1;
1189 Vi = Vhp + Vbp + ve + v2;
1193 Vi = Vhp + Vbp + ve + v2 + v1;
1197 Vi = Vhp + Vbp + ve + v3;
1201 Vi = Vhp + Vbp + ve + v3 + v1;
1205 Vi = Vhp + Vbp + ve + v3 + v2;
1209 Vi = Vhp + Vbp + ve + v3 + v2 + v1;
1213 Vi = Vhp + Vbp + Vlp;
1217 Vi = Vhp + Vbp + Vlp + v1;
1221 Vi = Vhp + Vbp + Vlp + v2;
1225 Vi = Vhp + Vbp + Vlp + v2 + v1;
1229 Vi = Vhp + Vbp + Vlp + v3;
1233 Vi = Vhp + Vbp + Vlp + v3 + v1;
1237 Vi = Vhp + Vbp + Vlp + v3 + v2;
1241 Vi = Vhp + Vbp + Vlp + v3 + v2 + v1;
1245 Vi = Vhp + Vbp + Vlp + ve;
1249 Vi = Vhp + Vbp + Vlp + ve + v1;
1253 Vi = Vhp + Vbp + Vlp + ve + v2;
1257 Vi = Vhp + Vbp + Vlp + ve + v2 + v1;
1261 Vi = Vhp + Vbp + Vlp + ve + v3;
1265 Vi = Vhp + Vbp + Vlp + ve + v3 + v1;
1269 Vi = Vhp + Vbp + Vlp + ve + v3 + v2;
1273 Vi = Vhp + Vbp + Vlp + ve + v3 + v2 + v1;
1279 if (sid_model == 0) {
1280 return (
short)(f.gain[vol][f.mixer[offset + Vi]] - (1 << 15));
1286 int tmp = Vi*(int)vol >> 4;
1287 if (tmp < -32768) tmp = -32768;
1288 if (tmp > 32767) tmp = 32767;
1289 return (
short)tmp; }
1341 int ak = mf.ak, bk = mf.bk;
1343 int a = n + (1 << 7);
1346 if (b_vi < 0) b_vi = 0;
1347 int c = n*int(
unsigned(b_vi)*
unsigned(b_vi) >> 12);
1353 int vx = opamp[x].vx;
1354 int dvx = opamp[x].dvx;
1359 int vo = vx + (x << 1) - (1 << 16);
1360 if (vo >= (1 << 16)) {
1367 if (b_vx < 0) b_vx = 0;
1369 if (b_vo < 0) b_vo = 0;
1371 int f = a*int(
unsigned(b_vx)*
unsigned(b_vx) >> 12) - c - int(
unsigned(b_vo)*
unsigned(b_vo) >> 5);
1373 int df = (b_vo*(dvx + (1 << 11)) - a*(b_vx*dvx >> 7)) >> 15;
1381 if (unlikely(x == xk)) {
1396 if (unlikely(x <= ak) || unlikely(x >= bk)) {
1399 if (unlikely(x == ak)) {
1528 int Filter::solve_integrate_6581(
int dt,
int vi,
int& vx,
int& vc,
model_filter_t& mf)
1535 int kVddt = mf.kVddt;
1538 unsigned int Vgst = kVddt - vx;
1539 unsigned int Vgdt = kVddt - vi;
1540 unsigned int Vgdt_2 = Vgdt*Vgdt;
1543 int n_I_snake = mf.n_snake*(int(Vgst*Vgst - Vgdt_2) >> 15);
1547 int kVg = vcr_kVg[(Vddt_Vw_2 + (Vgdt_2 >> 1)) >> 16];
1551 if (Vgs < 0) Vgs = 0;
1553 if (Vgd < 0) Vgd = 0;
1556 int n_I_vcr = int(
unsigned(vcr_n_Ids_term[Vgs] - vcr_n_Ids_term[Vgd]) << 15);
1559 vc -= (n_I_snake + n_I_vcr)*dt;
1572 vx = mf.opamp_rev[(vc >> 15) + (1 << 15)];
1575 return vx + (vc >> 14);
1578 #endif // RESID_INLINING || defined(RESID_FILTER_CC) 1582 #endif // not RESID_FILTER_H