00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef RESID_FILTER_H
00021 #define RESID_FILTER_H
00022
00023 #include "resid-config.h"
00024
00025 namespace reSID
00026 {
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314 template<int i>
00315 struct summer_offset
00316 {
00317 enum { value = summer_offset<i - 1>::value + ((2 + i - 1) << 16) };
00318 };
00319
00320 template<>
00321 struct summer_offset<0>
00322 {
00323 enum { value = 0 };
00324 };
00325
00326
00327 template<int i>
00328 struct mixer_offset
00329 {
00330 enum { value = mixer_offset<i - 1>::value + ((i - 1) << 16) };
00331 };
00332
00333 template<>
00334 struct mixer_offset<1>
00335 {
00336 enum { value = 1 };
00337 };
00338
00339 template<>
00340 struct mixer_offset<0>
00341 {
00342 enum { value = 0 };
00343 };
00344
00345
00346 class Filter
00347 {
00348 public:
00349 Filter();
00350
00351 void enable_filter(bool enable);
00352 void adjust_filter_bias(double dac_bias);
00353 void set_chip_model(chip_model model);
00354 void set_voice_mask(reg4 mask);
00355
00356 void clock(int voice1, int voice2, int voice3);
00357 void clock(cycle_count delta_t, int voice1, int voice2, int voice3);
00358 void reset();
00359
00360
00361 void writeFC_LO(reg8);
00362 void writeFC_HI(reg8);
00363 void writeRES_FILT(reg8);
00364 void writeMODE_VOL(reg8);
00365
00366
00367 void input(short sample);
00368
00369
00370 short output();
00371
00372 protected:
00373 void set_sum_mix();
00374 void set_w0();
00375 void set_Q();
00376
00377
00378 bool enabled;
00379
00380
00381 reg12 fc;
00382
00383
00384 reg8 res;
00385
00386
00387 reg8 filt;
00388
00389
00390 reg4 mode;
00391
00392
00393 reg4 vol;
00394
00395
00396
00397 reg8 voice_mask;
00398
00399
00400
00401 reg8 sum;
00402 reg8 mix;
00403
00404
00405 int Vhp;
00406 int Vbp;
00407 int Vbp_x, Vbp_vc;
00408 int Vlp;
00409 int Vlp_x, Vlp_vc;
00410
00411 int ve;
00412 int v3;
00413 int v2;
00414 int v1;
00415
00416
00417 int Vddt_Vw_2, Vw_bias;
00418 int _8_div_Q;
00419
00420 int w0;
00421 int _1024_div_Q;
00422
00423 chip_model sid_model;
00424
00425 typedef struct {
00426 int vo_N16;
00427 int kVddt;
00428 int n_snake;
00429 int voice_scale_s14;
00430 int voice_DC;
00431 int ak;
00432 int bk;
00433 int vc_min;
00434 int vc_max;
00435
00436
00437 unsigned short opamp_rev[1 << 16];
00438
00439 unsigned short summer[summer_offset<5>::value];
00440 unsigned short gain[16][1 << 16];
00441 unsigned short mixer[mixer_offset<8>::value];
00442
00443 unsigned short f0_dac[1 << 11];
00444 } model_filter_t;
00445
00446 int solve_gain(int* opamp, int n, int vi_t, int& x, model_filter_t& mf);
00447 int solve_integrate_6581(int dt, int vi_t, int& x, int& vc, model_filter_t& mf);
00448
00449
00450 static unsigned short vcr_kVg[1 << 16];
00451 static unsigned short vcr_n_Ids_term[1 << 16];
00452
00453 static model_filter_t model_filter[2];
00454
00455 friend class SID;
00456 };
00457
00458
00459
00460
00461
00462
00463
00464
00465 #if RESID_INLINING || defined(RESID_FILTER_CC)
00466
00467
00468
00469
00470 RESID_INLINE
00471 void Filter::clock(int voice1, int voice2, int voice3)
00472 {
00473 model_filter_t& f = model_filter[sid_model];
00474
00475 v1 = (voice1*f.voice_scale_s14 >> 18) + f.voice_DC;
00476 v2 = (voice2*f.voice_scale_s14 >> 18) + f.voice_DC;
00477 v3 = (voice3*f.voice_scale_s14 >> 18) + f.voice_DC;
00478
00479
00480 int Vi = 0;
00481 int offset = 0;
00482
00483 switch (sum & 0xf) {
00484 case 0x0:
00485 Vi = 0;
00486 offset = summer_offset<0>::value;
00487 break;
00488 case 0x1:
00489 Vi = v1;
00490 offset = summer_offset<1>::value;
00491 break;
00492 case 0x2:
00493 Vi = v2;
00494 offset = summer_offset<1>::value;
00495 break;
00496 case 0x3:
00497 Vi = v2 + v1;
00498 offset = summer_offset<2>::value;
00499 break;
00500 case 0x4:
00501 Vi = v3;
00502 offset = summer_offset<1>::value;
00503 break;
00504 case 0x5:
00505 Vi = v3 + v1;
00506 offset = summer_offset<2>::value;
00507 break;
00508 case 0x6:
00509 Vi = v3 + v2;
00510 offset = summer_offset<2>::value;
00511 break;
00512 case 0x7:
00513 Vi = v3 + v2 + v1;
00514 offset = summer_offset<3>::value;
00515 break;
00516 case 0x8:
00517 Vi = ve;
00518 offset = summer_offset<1>::value;
00519 break;
00520 case 0x9:
00521 Vi = ve + v1;
00522 offset = summer_offset<2>::value;
00523 break;
00524 case 0xa:
00525 Vi = ve + v2;
00526 offset = summer_offset<2>::value;
00527 break;
00528 case 0xb:
00529 Vi = ve + v2 + v1;
00530 offset = summer_offset<3>::value;
00531 break;
00532 case 0xc:
00533 Vi = ve + v3;
00534 offset = summer_offset<2>::value;
00535 break;
00536 case 0xd:
00537 Vi = ve + v3 + v1;
00538 offset = summer_offset<3>::value;
00539 break;
00540 case 0xe:
00541 Vi = ve + v3 + v2;
00542 offset = summer_offset<3>::value;
00543 break;
00544 case 0xf:
00545 Vi = ve + v3 + v2 + v1;
00546 offset = summer_offset<4>::value;
00547 break;
00548 }
00549
00550
00551 if (sid_model == 0) {
00552
00553 Vlp = solve_integrate_6581(1, Vbp, Vlp_x, Vlp_vc, f);
00554 Vbp = solve_integrate_6581(1, Vhp, Vbp_x, Vbp_vc, f);
00555 Vhp = f.summer[offset + f.gain[_8_div_Q][Vbp] + Vlp + Vi];
00556 }
00557 else {
00558
00559
00560
00561
00562
00563 int dVbp = w0*(Vhp >> 4) >> 16;
00564 int dVlp = w0*(Vbp >> 4) >> 16;
00565 Vbp -= dVbp;
00566 Vlp -= dVlp;
00567 Vhp = (Vbp*_1024_div_Q >> 10) - Vlp - Vi;
00568 }
00569 }
00570
00571
00572
00573
00574 RESID_INLINE
00575 void Filter::clock(cycle_count delta_t, int voice1, int voice2, int voice3)
00576 {
00577 model_filter_t& f = model_filter[sid_model];
00578
00579 v1 = (voice1*f.voice_scale_s14 >> 18) + f.voice_DC;
00580 v2 = (voice2*f.voice_scale_s14 >> 18) + f.voice_DC;
00581 v3 = (voice3*f.voice_scale_s14 >> 18) + f.voice_DC;
00582
00583
00584
00585
00586
00587 if (unlikely(!enabled)) {
00588 return;
00589 }
00590
00591
00592 int Vi = 0;
00593 int offset = 0;
00594
00595 switch (sum & 0xf) {
00596 case 0x0:
00597 Vi = 0;
00598 offset = summer_offset<0>::value;
00599 break;
00600 case 0x1:
00601 Vi = v1;
00602 offset = summer_offset<1>::value;
00603 break;
00604 case 0x2:
00605 Vi = v2;
00606 offset = summer_offset<1>::value;
00607 break;
00608 case 0x3:
00609 Vi = v2 + v1;
00610 offset = summer_offset<2>::value;
00611 break;
00612 case 0x4:
00613 Vi = v3;
00614 offset = summer_offset<1>::value;
00615 break;
00616 case 0x5:
00617 Vi = v3 + v1;
00618 offset = summer_offset<2>::value;
00619 break;
00620 case 0x6:
00621 Vi = v3 + v2;
00622 offset = summer_offset<2>::value;
00623 break;
00624 case 0x7:
00625 Vi = v3 + v2 + v1;
00626 offset = summer_offset<3>::value;
00627 break;
00628 case 0x8:
00629 Vi = ve;
00630 offset = summer_offset<1>::value;
00631 break;
00632 case 0x9:
00633 Vi = ve + v1;
00634 offset = summer_offset<2>::value;
00635 break;
00636 case 0xa:
00637 Vi = ve + v2;
00638 offset = summer_offset<2>::value;
00639 break;
00640 case 0xb:
00641 Vi = ve + v2 + v1;
00642 offset = summer_offset<3>::value;
00643 break;
00644 case 0xc:
00645 Vi = ve + v3;
00646 offset = summer_offset<2>::value;
00647 break;
00648 case 0xd:
00649 Vi = ve + v3 + v1;
00650 offset = summer_offset<3>::value;
00651 break;
00652 case 0xe:
00653 Vi = ve + v3 + v2;
00654 offset = summer_offset<3>::value;
00655 break;
00656 case 0xf:
00657 Vi = ve + v3 + v2 + v1;
00658 offset = summer_offset<4>::value;
00659 break;
00660 }
00661
00662
00663
00664 cycle_count delta_t_flt = 3;
00665
00666 if (sid_model == 0) {
00667
00668 while (delta_t) {
00669 if (unlikely(delta_t < delta_t_flt)) {
00670 delta_t_flt = delta_t;
00671 }
00672
00673
00674 Vlp = solve_integrate_6581(delta_t_flt, Vbp, Vlp_x, Vlp_vc, f);
00675 Vbp = solve_integrate_6581(delta_t_flt, Vhp, Vbp_x, Vbp_vc, f);
00676 Vhp = f.summer[offset + f.gain[_8_div_Q][Vbp] + Vlp + Vi];
00677
00678 delta_t -= delta_t_flt;
00679 }
00680 }
00681 else {
00682
00683 while (delta_t) {
00684 if (delta_t < delta_t_flt) {
00685 delta_t_flt = delta_t;
00686 }
00687
00688
00689
00690
00691
00692
00693 int w0_delta_t = w0*delta_t_flt >> 2;
00694
00695 int dVbp = w0_delta_t*(Vhp >> 4) >> 14;
00696 int dVlp = w0_delta_t*(Vbp >> 4) >> 14;
00697 Vbp -= dVbp;
00698 Vlp -= dVlp;
00699 Vhp = (Vbp*_1024_div_Q >> 10) - Vlp - Vi;
00700
00701 delta_t -= delta_t_flt;
00702 }
00703 }
00704 }
00705
00706
00707
00708
00709
00710 RESID_INLINE
00711 void Filter::input(short sample)
00712 {
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722 model_filter_t& f = model_filter[sid_model];
00723 ve = (sample*f.voice_scale_s14*3 >> 14) + f.mixer[0];
00724 }
00725
00726
00727
00728
00729
00730 RESID_INLINE
00731 short Filter::output()
00732 {
00733 model_filter_t& f = model_filter[sid_model];
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754
00755 int Vi = 0;
00756 int offset = 0;
00757
00758 switch (mix & 0x7f) {
00759 case 0x00:
00760 Vi = 0;
00761 offset = mixer_offset<0>::value;
00762 break;
00763 case 0x01:
00764 Vi = v1;
00765 offset = mixer_offset<1>::value;
00766 break;
00767 case 0x02:
00768 Vi = v2;
00769 offset = mixer_offset<1>::value;
00770 break;
00771 case 0x03:
00772 Vi = v2 + v1;
00773 offset = mixer_offset<2>::value;
00774 break;
00775 case 0x04:
00776 Vi = v3;
00777 offset = mixer_offset<1>::value;
00778 break;
00779 case 0x05:
00780 Vi = v3 + v1;
00781 offset = mixer_offset<2>::value;
00782 break;
00783 case 0x06:
00784 Vi = v3 + v2;
00785 offset = mixer_offset<2>::value;
00786 break;
00787 case 0x07:
00788 Vi = v3 + v2 + v1;
00789 offset = mixer_offset<3>::value;
00790 break;
00791 case 0x08:
00792 Vi = ve;
00793 offset = mixer_offset<1>::value;
00794 break;
00795 case 0x09:
00796 Vi = ve + v1;
00797 offset = mixer_offset<2>::value;
00798 break;
00799 case 0x0a:
00800 Vi = ve + v2;
00801 offset = mixer_offset<2>::value;
00802 break;
00803 case 0x0b:
00804 Vi = ve + v2 + v1;
00805 offset = mixer_offset<3>::value;
00806 break;
00807 case 0x0c:
00808 Vi = ve + v3;
00809 offset = mixer_offset<2>::value;
00810 break;
00811 case 0x0d:
00812 Vi = ve + v3 + v1;
00813 offset = mixer_offset<3>::value;
00814 break;
00815 case 0x0e:
00816 Vi = ve + v3 + v2;
00817 offset = mixer_offset<3>::value;
00818 break;
00819 case 0x0f:
00820 Vi = ve + v3 + v2 + v1;
00821 offset = mixer_offset<4>::value;
00822 break;
00823 case 0x10:
00824 Vi = Vlp;
00825 offset = mixer_offset<1>::value;
00826 break;
00827 case 0x11:
00828 Vi = Vlp + v1;
00829 offset = mixer_offset<2>::value;
00830 break;
00831 case 0x12:
00832 Vi = Vlp + v2;
00833 offset = mixer_offset<2>::value;
00834 break;
00835 case 0x13:
00836 Vi = Vlp + v2 + v1;
00837 offset = mixer_offset<3>::value;
00838 break;
00839 case 0x14:
00840 Vi = Vlp + v3;
00841 offset = mixer_offset<2>::value;
00842 break;
00843 case 0x15:
00844 Vi = Vlp + v3 + v1;
00845 offset = mixer_offset<3>::value;
00846 break;
00847 case 0x16:
00848 Vi = Vlp + v3 + v2;
00849 offset = mixer_offset<3>::value;
00850 break;
00851 case 0x17:
00852 Vi = Vlp + v3 + v2 + v1;
00853 offset = mixer_offset<4>::value;
00854 break;
00855 case 0x18:
00856 Vi = Vlp + ve;
00857 offset = mixer_offset<2>::value;
00858 break;
00859 case 0x19:
00860 Vi = Vlp + ve + v1;
00861 offset = mixer_offset<3>::value;
00862 break;
00863 case 0x1a:
00864 Vi = Vlp + ve + v2;
00865 offset = mixer_offset<3>::value;
00866 break;
00867 case 0x1b:
00868 Vi = Vlp + ve + v2 + v1;
00869 offset = mixer_offset<4>::value;
00870 break;
00871 case 0x1c:
00872 Vi = Vlp + ve + v3;
00873 offset = mixer_offset<3>::value;
00874 break;
00875 case 0x1d:
00876 Vi = Vlp + ve + v3 + v1;
00877 offset = mixer_offset<4>::value;
00878 break;
00879 case 0x1e:
00880 Vi = Vlp + ve + v3 + v2;
00881 offset = mixer_offset<4>::value;
00882 break;
00883 case 0x1f:
00884 Vi = Vlp + ve + v3 + v2 + v1;
00885 offset = mixer_offset<5>::value;
00886 break;
00887 case 0x20:
00888 Vi = Vbp;
00889 offset = mixer_offset<1>::value;
00890 break;
00891 case 0x21:
00892 Vi = Vbp + v1;
00893 offset = mixer_offset<2>::value;
00894 break;
00895 case 0x22:
00896 Vi = Vbp + v2;
00897 offset = mixer_offset<2>::value;
00898 break;
00899 case 0x23:
00900 Vi = Vbp + v2 + v1;
00901 offset = mixer_offset<3>::value;
00902 break;
00903 case 0x24:
00904 Vi = Vbp + v3;
00905 offset = mixer_offset<2>::value;
00906 break;
00907 case 0x25:
00908 Vi = Vbp + v3 + v1;
00909 offset = mixer_offset<3>::value;
00910 break;
00911 case 0x26:
00912 Vi = Vbp + v3 + v2;
00913 offset = mixer_offset<3>::value;
00914 break;
00915 case 0x27:
00916 Vi = Vbp + v3 + v2 + v1;
00917 offset = mixer_offset<4>::value;
00918 break;
00919 case 0x28:
00920 Vi = Vbp + ve;
00921 offset = mixer_offset<2>::value;
00922 break;
00923 case 0x29:
00924 Vi = Vbp + ve + v1;
00925 offset = mixer_offset<3>::value;
00926 break;
00927 case 0x2a:
00928 Vi = Vbp + ve + v2;
00929 offset = mixer_offset<3>::value;
00930 break;
00931 case 0x2b:
00932 Vi = Vbp + ve + v2 + v1;
00933 offset = mixer_offset<4>::value;
00934 break;
00935 case 0x2c:
00936 Vi = Vbp + ve + v3;
00937 offset = mixer_offset<3>::value;
00938 break;
00939 case 0x2d:
00940 Vi = Vbp + ve + v3 + v1;
00941 offset = mixer_offset<4>::value;
00942 break;
00943 case 0x2e:
00944 Vi = Vbp + ve + v3 + v2;
00945 offset = mixer_offset<4>::value;
00946 break;
00947 case 0x2f:
00948 Vi = Vbp + ve + v3 + v2 + v1;
00949 offset = mixer_offset<5>::value;
00950 break;
00951 case 0x30:
00952 Vi = Vbp + Vlp;
00953 offset = mixer_offset<2>::value;
00954 break;
00955 case 0x31:
00956 Vi = Vbp + Vlp + v1;
00957 offset = mixer_offset<3>::value;
00958 break;
00959 case 0x32:
00960 Vi = Vbp + Vlp + v2;
00961 offset = mixer_offset<3>::value;
00962 break;
00963 case 0x33:
00964 Vi = Vbp + Vlp + v2 + v1;
00965 offset = mixer_offset<4>::value;
00966 break;
00967 case 0x34:
00968 Vi = Vbp + Vlp + v3;
00969 offset = mixer_offset<3>::value;
00970 break;
00971 case 0x35:
00972 Vi = Vbp + Vlp + v3 + v1;
00973 offset = mixer_offset<4>::value;
00974 break;
00975 case 0x36:
00976 Vi = Vbp + Vlp + v3 + v2;
00977 offset = mixer_offset<4>::value;
00978 break;
00979 case 0x37:
00980 Vi = Vbp + Vlp + v3 + v2 + v1;
00981 offset = mixer_offset<5>::value;
00982 break;
00983 case 0x38:
00984 Vi = Vbp + Vlp + ve;
00985 offset = mixer_offset<3>::value;
00986 break;
00987 case 0x39:
00988 Vi = Vbp + Vlp + ve + v1;
00989 offset = mixer_offset<4>::value;
00990 break;
00991 case 0x3a:
00992 Vi = Vbp + Vlp + ve + v2;
00993 offset = mixer_offset<4>::value;
00994 break;
00995 case 0x3b:
00996 Vi = Vbp + Vlp + ve + v2 + v1;
00997 offset = mixer_offset<5>::value;
00998 break;
00999 case 0x3c:
01000 Vi = Vbp + Vlp + ve + v3;
01001 offset = mixer_offset<4>::value;
01002 break;
01003 case 0x3d:
01004 Vi = Vbp + Vlp + ve + v3 + v1;
01005 offset = mixer_offset<5>::value;
01006 break;
01007 case 0x3e:
01008 Vi = Vbp + Vlp + ve + v3 + v2;
01009 offset = mixer_offset<5>::value;
01010 break;
01011 case 0x3f:
01012 Vi = Vbp + Vlp + ve + v3 + v2 + v1;
01013 offset = mixer_offset<6>::value;
01014 break;
01015 case 0x40:
01016 Vi = Vhp;
01017 offset = mixer_offset<1>::value;
01018 break;
01019 case 0x41:
01020 Vi = Vhp + v1;
01021 offset = mixer_offset<2>::value;
01022 break;
01023 case 0x42:
01024 Vi = Vhp + v2;
01025 offset = mixer_offset<2>::value;
01026 break;
01027 case 0x43:
01028 Vi = Vhp + v2 + v1;
01029 offset = mixer_offset<3>::value;
01030 break;
01031 case 0x44:
01032 Vi = Vhp + v3;
01033 offset = mixer_offset<2>::value;
01034 break;
01035 case 0x45:
01036 Vi = Vhp + v3 + v1;
01037 offset = mixer_offset<3>::value;
01038 break;
01039 case 0x46:
01040 Vi = Vhp + v3 + v2;
01041 offset = mixer_offset<3>::value;
01042 break;
01043 case 0x47:
01044 Vi = Vhp + v3 + v2 + v1;
01045 offset = mixer_offset<4>::value;
01046 break;
01047 case 0x48:
01048 Vi = Vhp + ve;
01049 offset = mixer_offset<2>::value;
01050 break;
01051 case 0x49:
01052 Vi = Vhp + ve + v1;
01053 offset = mixer_offset<3>::value;
01054 break;
01055 case 0x4a:
01056 Vi = Vhp + ve + v2;
01057 offset = mixer_offset<3>::value;
01058 break;
01059 case 0x4b:
01060 Vi = Vhp + ve + v2 + v1;
01061 offset = mixer_offset<4>::value;
01062 break;
01063 case 0x4c:
01064 Vi = Vhp + ve + v3;
01065 offset = mixer_offset<3>::value;
01066 break;
01067 case 0x4d:
01068 Vi = Vhp + ve + v3 + v1;
01069 offset = mixer_offset<4>::value;
01070 break;
01071 case 0x4e:
01072 Vi = Vhp + ve + v3 + v2;
01073 offset = mixer_offset<4>::value;
01074 break;
01075 case 0x4f:
01076 Vi = Vhp + ve + v3 + v2 + v1;
01077 offset = mixer_offset<5>::value;
01078 break;
01079 case 0x50:
01080 Vi = Vhp + Vlp;
01081 offset = mixer_offset<2>::value;
01082 break;
01083 case 0x51:
01084 Vi = Vhp + Vlp + v1;
01085 offset = mixer_offset<3>::value;
01086 break;
01087 case 0x52:
01088 Vi = Vhp + Vlp + v2;
01089 offset = mixer_offset<3>::value;
01090 break;
01091 case 0x53:
01092 Vi = Vhp + Vlp + v2 + v1;
01093 offset = mixer_offset<4>::value;
01094 break;
01095 case 0x54:
01096 Vi = Vhp + Vlp + v3;
01097 offset = mixer_offset<3>::value;
01098 break;
01099 case 0x55:
01100 Vi = Vhp + Vlp + v3 + v1;
01101 offset = mixer_offset<4>::value;
01102 break;
01103 case 0x56:
01104 Vi = Vhp + Vlp + v3 + v2;
01105 offset = mixer_offset<4>::value;
01106 break;
01107 case 0x57:
01108 Vi = Vhp + Vlp + v3 + v2 + v1;
01109 offset = mixer_offset<5>::value;
01110 break;
01111 case 0x58:
01112 Vi = Vhp + Vlp + ve;
01113 offset = mixer_offset<3>::value;
01114 break;
01115 case 0x59:
01116 Vi = Vhp + Vlp + ve + v1;
01117 offset = mixer_offset<4>::value;
01118 break;
01119 case 0x5a:
01120 Vi = Vhp + Vlp + ve + v2;
01121 offset = mixer_offset<4>::value;
01122 break;
01123 case 0x5b:
01124 Vi = Vhp + Vlp + ve + v2 + v1;
01125 offset = mixer_offset<5>::value;
01126 break;
01127 case 0x5c:
01128 Vi = Vhp + Vlp + ve + v3;
01129 offset = mixer_offset<4>::value;
01130 break;
01131 case 0x5d:
01132 Vi = Vhp + Vlp + ve + v3 + v1;
01133 offset = mixer_offset<5>::value;
01134 break;
01135 case 0x5e:
01136 Vi = Vhp + Vlp + ve + v3 + v2;
01137 offset = mixer_offset<5>::value;
01138 break;
01139 case 0x5f:
01140 Vi = Vhp + Vlp + ve + v3 + v2 + v1;
01141 offset = mixer_offset<6>::value;
01142 break;
01143 case 0x60:
01144 Vi = Vhp + Vbp;
01145 offset = mixer_offset<2>::value;
01146 break;
01147 case 0x61:
01148 Vi = Vhp + Vbp + v1;
01149 offset = mixer_offset<3>::value;
01150 break;
01151 case 0x62:
01152 Vi = Vhp + Vbp + v2;
01153 offset = mixer_offset<3>::value;
01154 break;
01155 case 0x63:
01156 Vi = Vhp + Vbp + v2 + v1;
01157 offset = mixer_offset<4>::value;
01158 break;
01159 case 0x64:
01160 Vi = Vhp + Vbp + v3;
01161 offset = mixer_offset<3>::value;
01162 break;
01163 case 0x65:
01164 Vi = Vhp + Vbp + v3 + v1;
01165 offset = mixer_offset<4>::value;
01166 break;
01167 case 0x66:
01168 Vi = Vhp + Vbp + v3 + v2;
01169 offset = mixer_offset<4>::value;
01170 break;
01171 case 0x67:
01172 Vi = Vhp + Vbp + v3 + v2 + v1;
01173 offset = mixer_offset<5>::value;
01174 break;
01175 case 0x68:
01176 Vi = Vhp + Vbp + ve;
01177 offset = mixer_offset<3>::value;
01178 break;
01179 case 0x69:
01180 Vi = Vhp + Vbp + ve + v1;
01181 offset = mixer_offset<4>::value;
01182 break;
01183 case 0x6a:
01184 Vi = Vhp + Vbp + ve + v2;
01185 offset = mixer_offset<4>::value;
01186 break;
01187 case 0x6b:
01188 Vi = Vhp + Vbp + ve + v2 + v1;
01189 offset = mixer_offset<5>::value;
01190 break;
01191 case 0x6c:
01192 Vi = Vhp + Vbp + ve + v3;
01193 offset = mixer_offset<4>::value;
01194 break;
01195 case 0x6d:
01196 Vi = Vhp + Vbp + ve + v3 + v1;
01197 offset = mixer_offset<5>::value;
01198 break;
01199 case 0x6e:
01200 Vi = Vhp + Vbp + ve + v3 + v2;
01201 offset = mixer_offset<5>::value;
01202 break;
01203 case 0x6f:
01204 Vi = Vhp + Vbp + ve + v3 + v2 + v1;
01205 offset = mixer_offset<6>::value;
01206 break;
01207 case 0x70:
01208 Vi = Vhp + Vbp + Vlp;
01209 offset = mixer_offset<3>::value;
01210 break;
01211 case 0x71:
01212 Vi = Vhp + Vbp + Vlp + v1;
01213 offset = mixer_offset<4>::value;
01214 break;
01215 case 0x72:
01216 Vi = Vhp + Vbp + Vlp + v2;
01217 offset = mixer_offset<4>::value;
01218 break;
01219 case 0x73:
01220 Vi = Vhp + Vbp + Vlp + v2 + v1;
01221 offset = mixer_offset<5>::value;
01222 break;
01223 case 0x74:
01224 Vi = Vhp + Vbp + Vlp + v3;
01225 offset = mixer_offset<4>::value;
01226 break;
01227 case 0x75:
01228 Vi = Vhp + Vbp + Vlp + v3 + v1;
01229 offset = mixer_offset<5>::value;
01230 break;
01231 case 0x76:
01232 Vi = Vhp + Vbp + Vlp + v3 + v2;
01233 offset = mixer_offset<5>::value;
01234 break;
01235 case 0x77:
01236 Vi = Vhp + Vbp + Vlp + v3 + v2 + v1;
01237 offset = mixer_offset<6>::value;
01238 break;
01239 case 0x78:
01240 Vi = Vhp + Vbp + Vlp + ve;
01241 offset = mixer_offset<4>::value;
01242 break;
01243 case 0x79:
01244 Vi = Vhp + Vbp + Vlp + ve + v1;
01245 offset = mixer_offset<5>::value;
01246 break;
01247 case 0x7a:
01248 Vi = Vhp + Vbp + Vlp + ve + v2;
01249 offset = mixer_offset<5>::value;
01250 break;
01251 case 0x7b:
01252 Vi = Vhp + Vbp + Vlp + ve + v2 + v1;
01253 offset = mixer_offset<6>::value;
01254 break;
01255 case 0x7c:
01256 Vi = Vhp + Vbp + Vlp + ve + v3;
01257 offset = mixer_offset<5>::value;
01258 break;
01259 case 0x7d:
01260 Vi = Vhp + Vbp + Vlp + ve + v3 + v1;
01261 offset = mixer_offset<6>::value;
01262 break;
01263 case 0x7e:
01264 Vi = Vhp + Vbp + Vlp + ve + v3 + v2;
01265 offset = mixer_offset<6>::value;
01266 break;
01267 case 0x7f:
01268 Vi = Vhp + Vbp + Vlp + ve + v3 + v2 + v1;
01269 offset = mixer_offset<7>::value;
01270 break;
01271 }
01272
01273
01274 if (sid_model == 0) {
01275 return (short)(f.gain[vol][f.mixer[offset + Vi]] - (1 << 15));
01276 }
01277 else {
01278
01279 return Vi*vol >> 4;
01280 }
01281 }
01282
01283
01284
01285
01286
01287
01288
01289
01290
01291
01292
01293
01294
01295
01296
01297
01298
01299
01300
01301
01302
01303
01304
01305
01306
01307
01308
01309
01310
01311
01312
01313
01314
01315
01316
01317
01318
01319
01320
01321
01322 RESID_INLINE
01323 int Filter::solve_gain(int* opamp, int n, int vi, int& x, model_filter_t& mf)
01324 {
01325
01326
01327
01328
01329
01330
01331
01332 int ak = mf.ak, bk = mf.bk;
01333
01334 int a = n + (1 << 7);
01335 int b = mf.kVddt;
01336 int b_vi = b - vi;
01337 if (b_vi < 0) b_vi = 0;
01338 int c = n*int(unsigned(b_vi)*unsigned(b_vi) >> 12);
01339
01340 for (;;) {
01341 int xk = x;
01342
01343
01344 int vx_dvx = opamp[x];
01345 int vx = vx_dvx & 0xffff;
01346 int dvx = vx_dvx >> 16;
01347
01348
01349
01350
01351 int vo = vx + (x << 1) - (1 << 16);
01352 if (vo >= (1 << 16)) {
01353 vo = (1 << 16) - 1;
01354 }
01355 else if (vo < 0) {
01356 vo = 0;
01357 }
01358 int b_vx = b - vx;
01359 if (b_vx < 0) b_vx = 0;
01360 int b_vo = b - vo;
01361 if (b_vo < 0) b_vo = 0;
01362
01363 int f = a*int(unsigned(b_vx)*unsigned(b_vx) >> 12) - c - int(unsigned(b_vo)*unsigned(b_vo) >> 5);
01364
01365 int df = (b_vo*(dvx + (1 << 11)) - a*(b_vx*dvx >> 7)) >> 15;
01366
01367
01368
01369 x -= f/df;
01370 if (unlikely(x == xk)) {
01371
01372 return vo;
01373 }
01374
01375
01376 if (f < 0) {
01377
01378 ak = xk;
01379 }
01380 else {
01381
01382 bk = xk;
01383 }
01384
01385 if (unlikely(x <= ak) || unlikely(x >= bk)) {
01386
01387 x = (ak + bk) >> 1;
01388 if (unlikely(x == ak)) {
01389
01390 return vo;
01391 }
01392 }
01393 }
01394 }
01395
01396
01397
01398
01399
01400
01401
01402
01403
01404
01405
01406
01407
01408
01409
01410
01411
01412
01413
01414
01415
01416
01417
01418
01419
01420
01421
01422
01423
01424
01425
01426
01427
01428
01429
01430
01431
01432
01433
01434
01435
01436
01437
01438
01439
01440
01441
01442
01443
01444
01445
01446
01447
01448
01449
01450
01451
01452
01453
01454
01455
01456
01457
01458
01459
01460
01461
01462
01463
01464
01465
01466
01467
01468
01469
01470
01471
01472
01473
01474
01475
01476
01477
01478
01479
01480
01481
01482
01483
01484
01485
01486
01487
01488
01489
01490
01491
01492
01493
01494
01495
01496
01497
01498
01499
01500
01501
01502
01503
01504
01505
01506
01507
01508
01509
01510
01511
01512
01513
01514
01515
01516 RESID_INLINE
01517 int Filter::solve_integrate_6581(int dt, int vi, int& vx, int& vc,
01518 model_filter_t& mf)
01519 {
01520
01521
01522
01523
01524
01525 int kVddt = mf.kVddt;
01526
01527
01528 unsigned int Vgst = kVddt - vx;
01529 unsigned int Vgdt = kVddt - vi;
01530 unsigned int Vgdt_2 = Vgdt*Vgdt;
01531
01532
01533 int n_I_snake = mf.n_snake*(int(Vgst*Vgst - Vgdt_2) >> 15);
01534
01535
01536
01537 int kVg = vcr_kVg[(Vddt_Vw_2 + (Vgdt_2 >> 1)) >> 16];
01538
01539
01540 int Vgs = kVg - vx;
01541 if (Vgs < 0) Vgs = 0;
01542 int Vgd = kVg - vi;
01543 if (Vgd < 0) Vgd = 0;
01544
01545
01546 int n_I_vcr = (vcr_n_Ids_term[Vgs] - vcr_n_Ids_term[Vgd]) << 15;
01547
01548
01549 vc -= (n_I_snake + n_I_vcr)*dt;
01550
01551
01552
01553
01554
01555
01556
01557
01558
01559
01560
01561
01562 vx = mf.opamp_rev[(vc >> 15) + (1 << 15)];
01563
01564
01565 return vx + (vc >> 14);
01566 }
01567
01568 #endif // RESID_INLINING || defined(RESID_FILTER_CC)
01569
01570 }
01571
01572 #endif // not RESID_FILTER_H