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;
437 unsigned short opamp_rev[1 << 16];
440 unsigned short gain[16][1 << 16];
443 unsigned short f0_dac[1 << 11];
446 int solve_gain(
int* opamp,
int n,
int vi_t,
int& x,
model_filter_t& mf);
447 int solve_integrate_6581(
int dt,
int vi_t,
int& x,
int& vc,
model_filter_t& mf);
450 static unsigned short vcr_kVg[1 << 16];
451 static unsigned short vcr_n_Ids_term[1 << 16];
465 #if RESID_INLINING || defined(RESID_FILTER_CC) 471 void Filter::clock(
int voice1,
int voice2,
int voice3)
475 v1 = (voice1*f.voice_scale_s14 >> 18) + f.voice_DC;
476 v2 = (voice2*f.voice_scale_s14 >> 18) + f.voice_DC;
477 v3 = (voice3*f.voice_scale_s14 >> 18) + f.voice_DC;
545 Vi = ve + v3 + v2 + v1;
551 if (sid_model == 0) {
553 Vlp = solve_integrate_6581(1, Vbp, Vlp_x, Vlp_vc, f);
554 Vbp = solve_integrate_6581(1, Vhp, Vbp_x, Vbp_vc, f);
555 Vhp = f.summer[offset + f.gain[_8_div_Q][Vbp] + Vlp + Vi];
563 int dVbp = w0*(Vhp >> 4) >> 16;
564 int dVlp = w0*(Vbp >> 4) >> 16;
567 Vhp = (Vbp*_1024_div_Q >> 10) - Vlp - Vi;
575 void Filter::clock(cycle_count delta_t,
int voice1,
int voice2,
int voice3)
579 v1 = (voice1*f.voice_scale_s14 >> 18) + f.voice_DC;
580 v2 = (voice2*f.voice_scale_s14 >> 18) + f.voice_DC;
581 v3 = (voice3*f.voice_scale_s14 >> 18) + f.voice_DC;
587 if (unlikely(!enabled)) {
657 Vi = ve + v3 + v2 + v1;
664 cycle_count delta_t_flt = 3;
666 if (sid_model == 0) {
669 if (unlikely(delta_t < delta_t_flt)) {
670 delta_t_flt = delta_t;
674 Vlp = solve_integrate_6581(delta_t_flt, Vbp, Vlp_x, Vlp_vc, f);
675 Vbp = solve_integrate_6581(delta_t_flt, Vhp, Vbp_x, Vbp_vc, f);
676 Vhp = f.summer[offset + f.gain[_8_div_Q][Vbp] + Vlp + Vi];
678 delta_t -= delta_t_flt;
684 if (delta_t < delta_t_flt) {
685 delta_t_flt = delta_t;
693 int w0_delta_t = w0*delta_t_flt >> 2;
695 int dVbp = w0_delta_t*(Vhp >> 4) >> 14;
696 int dVlp = w0_delta_t*(Vbp >> 4) >> 14;
699 Vhp = (Vbp*_1024_div_Q >> 10) - Vlp - Vi;
701 delta_t -= delta_t_flt;
711 void Filter::input(
short sample)
723 ve = (sample*f.voice_scale_s14*3 >> 14) + f.mixer[0];
731 short Filter::output()
758 switch (mix & 0x7f) {
820 Vi = ve + v3 + v2 + v1;
852 Vi = Vlp + v3 + v2 + v1;
868 Vi = Vlp + ve + v2 + v1;
876 Vi = Vlp + ve + v3 + v1;
880 Vi = Vlp + ve + v3 + v2;
884 Vi = Vlp + ve + v3 + v2 + v1;
916 Vi = Vbp + v3 + v2 + v1;
932 Vi = Vbp + ve + v2 + v1;
940 Vi = Vbp + ve + v3 + v1;
944 Vi = Vbp + ve + v3 + v2;
948 Vi = Vbp + ve + v3 + v2 + v1;
964 Vi = Vbp + Vlp + v2 + v1;
972 Vi = Vbp + Vlp + v3 + v1;
976 Vi = Vbp + Vlp + v3 + v2;
980 Vi = Vbp + Vlp + v3 + v2 + v1;
988 Vi = Vbp + Vlp + ve + v1;
992 Vi = Vbp + Vlp + ve + v2;
996 Vi = Vbp + Vlp + ve + v2 + v1;
1000 Vi = Vbp + Vlp + ve + v3;
1004 Vi = Vbp + Vlp + ve + v3 + v1;
1008 Vi = Vbp + Vlp + ve + v3 + v2;
1012 Vi = Vbp + Vlp + ve + v3 + v2 + v1;
1044 Vi = Vhp + v3 + v2 + v1;
1060 Vi = Vhp + ve + v2 + v1;
1068 Vi = Vhp + ve + v3 + v1;
1072 Vi = Vhp + ve + v3 + v2;
1076 Vi = Vhp + ve + v3 + v2 + v1;
1084 Vi = Vhp + Vlp + v1;
1088 Vi = Vhp + Vlp + v2;
1092 Vi = Vhp + Vlp + v2 + v1;
1096 Vi = Vhp + Vlp + v3;
1100 Vi = Vhp + Vlp + v3 + v1;
1104 Vi = Vhp + Vlp + v3 + v2;
1108 Vi = Vhp + Vlp + v3 + v2 + v1;
1112 Vi = Vhp + Vlp + ve;
1116 Vi = Vhp + Vlp + ve + v1;
1120 Vi = Vhp + Vlp + ve + v2;
1124 Vi = Vhp + Vlp + ve + v2 + v1;
1128 Vi = Vhp + Vlp + ve + v3;
1132 Vi = Vhp + Vlp + ve + v3 + v1;
1136 Vi = Vhp + Vlp + ve + v3 + v2;
1140 Vi = Vhp + Vlp + ve + v3 + v2 + v1;
1148 Vi = Vhp + Vbp + v1;
1152 Vi = Vhp + Vbp + v2;
1156 Vi = Vhp + Vbp + v2 + v1;
1160 Vi = Vhp + Vbp + v3;
1164 Vi = Vhp + Vbp + v3 + v1;
1168 Vi = Vhp + Vbp + v3 + v2;
1172 Vi = Vhp + Vbp + v3 + v2 + v1;
1176 Vi = Vhp + Vbp + ve;
1180 Vi = Vhp + Vbp + ve + v1;
1184 Vi = Vhp + Vbp + ve + v2;
1188 Vi = Vhp + Vbp + ve + v2 + v1;
1192 Vi = Vhp + Vbp + ve + v3;
1196 Vi = Vhp + Vbp + ve + v3 + v1;
1200 Vi = Vhp + Vbp + ve + v3 + v2;
1204 Vi = Vhp + Vbp + ve + v3 + v2 + v1;
1208 Vi = Vhp + Vbp + Vlp;
1212 Vi = Vhp + Vbp + Vlp + v1;
1216 Vi = Vhp + Vbp + Vlp + v2;
1220 Vi = Vhp + Vbp + Vlp + v2 + v1;
1224 Vi = Vhp + Vbp + Vlp + v3;
1228 Vi = Vhp + Vbp + Vlp + v3 + v1;
1232 Vi = Vhp + Vbp + Vlp + v3 + v2;
1236 Vi = Vhp + Vbp + Vlp + v3 + v2 + v1;
1240 Vi = Vhp + Vbp + Vlp + ve;
1244 Vi = Vhp + Vbp + Vlp + ve + v1;
1248 Vi = Vhp + Vbp + Vlp + ve + v2;
1252 Vi = Vhp + Vbp + Vlp + ve + v2 + v1;
1256 Vi = Vhp + Vbp + Vlp + ve + v3;
1260 Vi = Vhp + Vbp + Vlp + ve + v3 + v1;
1264 Vi = Vhp + Vbp + Vlp + ve + v3 + v2;
1268 Vi = Vhp + Vbp + Vlp + ve + v3 + v2 + v1;
1274 if (sid_model == 0) {
1275 return (
short)(f.gain[vol][f.mixer[offset + Vi]] - (1 << 15));
1281 int tmp = Vi*(int)vol >> 4;
1282 if (tmp < -32768) tmp = -32768;
1283 if (tmp > 32767) tmp = 32767;
1284 return (
short)tmp; }
1327 int Filter::solve_gain(
int* opamp,
int n,
int vi,
int& x,
model_filter_t& mf)
1336 int ak = mf.ak, bk = mf.bk;
1338 int a = n + (1 << 7);
1341 if (b_vi < 0) b_vi = 0;
1342 int c = n*int(
unsigned(b_vi)*
unsigned(b_vi) >> 12);
1348 int vx_dvx = opamp[x];
1349 int vx = vx_dvx & 0xffff;
1350 int dvx = vx_dvx >> 16;
1355 int vo = vx + (x << 1) - (1 << 16);
1356 if (vo >= (1 << 16)) {
1363 if (b_vx < 0) b_vx = 0;
1365 if (b_vo < 0) b_vo = 0;
1367 int f = a*int(
unsigned(b_vx)*
unsigned(b_vx) >> 12) - c - int(
unsigned(b_vo)*
unsigned(b_vo) >> 5);
1369 int df = (b_vo*(dvx + (1 << 11)) - a*(b_vx*dvx >> 7)) >> 15;
1374 if (unlikely(x == xk)) {
1389 if (unlikely(x <= ak) || unlikely(x >= bk)) {
1392 if (unlikely(x == ak)) {
1521 int Filter::solve_integrate_6581(
int dt,
int vi,
int& vx,
int& vc,
1529 int kVddt = mf.kVddt;
1532 unsigned int Vgst = kVddt - vx;
1533 unsigned int Vgdt = kVddt - vi;
1534 unsigned int Vgdt_2 = Vgdt*Vgdt;
1537 int n_I_snake = mf.n_snake*(int(Vgst*Vgst - Vgdt_2) >> 15);
1541 int kVg = vcr_kVg[(Vddt_Vw_2 + (Vgdt_2 >> 1)) >> 16];
1545 if (Vgs < 0) Vgs = 0;
1547 if (Vgd < 0) Vgd = 0;
1550 int n_I_vcr = (vcr_n_Ids_term[Vgs] - vcr_n_Ids_term[Vgd]) << 15;
1553 vc -= (n_I_snake + n_I_vcr)*dt;
1566 vx = mf.opamp_rev[(vc >> 15) + (1 << 15)];
1569 return vx + (vc >> 14);
1572 #endif // RESID_INLINING || defined(RESID_FILTER_CC) 1576 #endif // not RESID_FILTER_H