home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume6 / glib / part08 / dep5.mnu next >
Encoding:
Text File  |  1989-05-14  |  18.4 KB  |  911 lines
  1. /* $Id: dep5.mnu,v 1.6 89/05/06 17:13:20 lee Exp $
  2.  * GLIB - a Generic LIBrarian and editor for synths
  3.  *
  4.  * DEP-5 routines.
  5.  * Tim Thompson
  6.  *
  7.  * The DEP-5 is a mess, the code below is likewise.  There are only 12
  8.  * parameters or so, but there are 11 algorithms, and different parameters
  9.  * have different meanings and ranges in each algorithm.  Also, the displayed
  10.  * values have NO regular relationship to the byte values of the parameters,
  11.  * hence the need for all the huge tables.
  12.  *
  13.  * modifications: Greg Lee
  14.  * $Log:    dep5.mnu,v $
  15.  * Revision 1.6  89/05/06  17:13:20  lee
  16.  * rel. to comp.sources.misc
  17.  * 
  18.  * 
  19.  */
  20.  
  21. #define OVERLAY2
  22.  
  23. #include "glib.h"
  24. #include <ctype.h>
  25.  
  26. #define DEP5VSIZE 42
  27. #define DEP5NSIZE 16
  28. #define DEP5NVOICES 99
  29. #define RESERVESIZE 0
  30.  
  31. char D5buff[16];
  32. int Alg;    /* current algorithm, 0-10 */
  33.  
  34. char *visnum(), *visonoff(), *vism3num(), *viswave(), *vismono();
  35. char *visd5alg(), *visdcr(), *visdcd(), *visdcf(), *visdrs(), *visd5pd();
  36. char *visd5rt(), *visd5hf(), *visd5no(), *visd5q(), *visd5fm(), *visd5bc();
  37.  
  38. struct numpair {
  39.     int np_byte;
  40.     int np_val;
  41. };
  42.  
  43. struct hfpair {
  44.     short hf_byte;
  45.     short hf_val;
  46. };
  47.  
  48.  
  49. #define NUMHF 96
  50. #define NUMCD 223
  51. #define NUMFREQ 128
  52. #define NUMGATE 256
  53. #define NUMCF 256
  54. #define NUMCR 97
  55. #define NUMNLRT 151
  56. #define NUMRT 153
  57. #define NUMDT 256
  58. #define NUMPD 256
  59. struct numpair *Revtime;
  60. struct numpair *Nlrevtime;
  61. struct hfpair *Hf;
  62. struct numpair *Chdepth;
  63. struct numpair *Chrate;
  64. int *Predly;
  65. int *Chfeed;
  66. int *Dtime;
  67. int *Freqmid;
  68. int *Gatetime;
  69.  
  70. /* This array contains arbitrary screen labels */
  71. struct labelinfo Ldep5[] = {
  72. #MENU
  73.  
  74.  
  75.                  Algorithm %
  76.                  ===========
  77.  
  78. <Equalizer>                       <Chorus>
  79.    Output Level        %                 Feedback of Chorus   %
  80.    Boost/Cut of Low    %                 Rate of Chorus       %
  81.    Boost/Cut of Mid    %                 Depth of Chorus      %
  82.    Boost/Cut of High   %          <Reverb>
  83.    Q of Mid            %                 Pre-Delay            %
  84.    Freq (KHz) of Mid   %                 Reverb Time          %
  85.                                          HF Damping           %
  86. -------------------------+               Reverb Selection     %
  87. N - set name  q - quit   |        <Non-Linear>
  88. h - left      j - down   |
  89. k - up        l - right  |
  90. J - decr      K - incr   |
  91. space = play auto-note   |
  92.                          |        <Delay>
  93. Auto-Note:               |
  94.    Pitch %    Vol  %     |
  95.    Dur   %    Chan %     |
  96.                          |
  97. #END
  98. -1,-1,NULL
  99. };
  100.  
  101. struct paraminfo  Pdep5[] =  {
  102. /*
  103. NAME        TYPE        POS    MAX    OFFSET    MASK    SHIFT    ADHOC
  104.  */
  105. #O algorithm    d5alg    %%    10    0
  106. #O chorfeed    dcf    %%    255    0
  107. #O outlev    num    %%    99    1
  108. #O chorrate    dcr    %%    96    0
  109. #O lowfilt    d5bc    %%    24    0
  110. #O chordepth    dcd    %%    222    0
  111. #O midfilt    d5bc    %%    24    0
  112. #O highfilt    d5bc    %%    24    0
  113. #O predelay    d5pd    %%    255    0
  114. #O q        d5q    %%    90    2
  115. #O reverbtime    d5rt    %%    152    0
  116. #O freqmid    d5fm    %%    127    3
  117. #O hfdamp    d5hf    %%    95    0
  118. #O reverbsel    drs    %%    21    0
  119. #O autovol    num    %%    127    -63
  120. #O autopitch    num    %%    127    -60
  121. #O autochan    num    %%    16    -1    *5
  122. #O autodur    num    %%    20    -5    *5
  123. NULL,NULL,-1,-1,-1,-1,visnum,0,0,0,0
  124. };
  125.  
  126.  
  127. /*
  128.  * dep5din
  129.  *
  130.  * Take info from 'data' and stuff values in the P array, by using
  131.  * the setval functionms.
  132.  */
  133.  
  134. dep5din(data)
  135. char *data;
  136. {
  137.     initdp5();
  138.  
  139.     Alg = d5algin(data[16] | ((data[17]&0xf)<<4));
  140.     setval("algorithm", Alg);
  141.  
  142.     setval("reverbsel",data[0]);
  143.     setval("outlev",data[1]);
  144.     setval("q",data[2]);
  145.     setval("freqmid",data[3]);
  146.     /* these parameters take up 2 bytes (4bits in each) */
  147.     setval("lowfilt", d5bcin(data[4] | ((data[5]&0xf)<<4)) );
  148.     setval("midfilt", d5bcin(data[6] | ((data[7]&0xf)<<4)) );
  149.     setval("highfilt", d5bcin(data[8] | ((data[9]&0xf)<<4)) );
  150.     setval("chorfeed", data[10] | ((data[11]&0xf)<<4) );
  151.     setval("chorrate",d5vin(Chrate,data[12] | ((data[13]&0xf)<<4)));
  152.     setval("chordepth",d5vin(Chdepth,data[14] | ((data[15]&0xf)<<4)));
  153.     setval("predelay", data[18] | ((data[19]&0xf)<<4) );
  154.     setval("reverbtime", d5rtin(data[20] | ((data[21]&0xf)<<4)) );
  155.     setval("hfdamp", d5hfin(data[22] | ((data[23]&0xf)<<4)) );
  156.  
  157.     setval("autochan",Channel);
  158.  
  159. }
  160.  
  161. /*
  162.  * dep5dout
  163.  *
  164.  * Take (possibly changed) parameters values out of the P array and
  165.  * put them back into 'data'.
  166.  */
  167.  
  168. dep5dout(data)
  169. char *data;
  170. {
  171.     int n, alg;
  172.  
  173.     alg = d5algout(getval("algorithm"));
  174.     data[16] = alg & 0xf;
  175.     data[17] = (alg >> 4) & 0xf;
  176.  
  177.     data[0] = getval("reverbsel");
  178.     data[1] = getval("outlev");
  179.     data[2] = getval("q");
  180.     data[3] = getval("freqmid");
  181.  
  182.     /* these parameters take up 2 bytes (4bits in each) */
  183.     n = d5bcout(getval("lowfilt"));
  184.     data[4] = n & 0xf;
  185.     data[5] = (n >> 4) & 0xf;
  186.     n = d5bcout(getval("midfilt"));
  187.     data[6] = n & 0xf;
  188.     data[7] = (n >> 4) & 0xf;
  189.     n = d5bcout(getval("highfilt"));
  190.     data[8] = n & 0xf;
  191.     data[9] = (n >> 4) & 0xf;
  192.     n = getval("chorfeed");
  193.     data[10] = n & 0xf;
  194.     data[11] = (n >> 4) & 0xf;
  195.     n = d5crout(getval("chorrate"));
  196.     data[12] = n & 0xf;
  197.     data[13] = (n >> 4) & 0xf;
  198.     n = d5cdout(getval("chordepth"));
  199.     data[14] = n & 0xf;
  200.     data[15] = (n >> 4) & 0xf;
  201.     n = getval("predelay");
  202.     data[18] = n & 0xf;
  203.     data[19] = (n >> 4) & 0xf;
  204.     n = d5rtout(getval("reverbtime"));
  205.     data[20] = n & 0xf;
  206.     data[21] = (n >> 4) & 0xf;
  207.     n = d5hfout(getval("hfdamp"));
  208.     data[22] = n & 0xf;
  209.     data[23] = (n >> 4) & 0xf;
  210.  
  211.     Channel = getval("autochan");
  212. }
  213.  
  214. /*
  215.  * dep5sedit
  216.  *
  217.  * Send a single voice to the edit buffer of the dep5.
  218.  */
  219. dep5sedit(data)
  220. char *data;
  221. {
  222.     dep5parms(data);
  223. }
  224.  
  225. dep5parms(data)
  226. char *data;
  227. {
  228.     int n;
  229.  
  230.     sendmidi(0xf0);
  231.     sendmidi(0x41);        /* Roland */
  232.     sendmidi(0x35);        /* operation code = APR (all parameters) */
  233.     sendmidi(Channel-1);    /* MIDI channel */
  234.     sendmidi(0x52);        /* format type */
  235.     sendmidi(0x20);        /* level # = 1 */
  236.     sendmidi(0x01);        /* group # = 1 */
  237.     /* send 24 bytes of parameter info */
  238.     for ( n=0; n<24; n++ ) {
  239.         sendmidi((int)(data[n]));
  240.     }
  241.     sendmidi(EOX);
  242. }
  243.  
  244. /* dep5nof - return a pointer to the voice name buried in data */
  245. char *
  246. dep5nof(data)
  247. char *data;
  248. {
  249.     static char currbuff[DEP5NSIZE+1];
  250.     char *p;
  251.     int m;
  252.  
  253.     p = currbuff;
  254.     for ( m=0; m<DEP5NSIZE; m++ )
  255.         *p++ = data[24+m];
  256.     *p = '\0';
  257.     return(currbuff);
  258. }
  259.  
  260. /* setnameof - set the voice name buried in data to name */
  261. dep5snof(data,name)
  262. char *data;
  263. char *name;
  264. {
  265.     char *p;
  266.     int m;
  267.  
  268.     for ( p=name,m=0; *p!='\0' && m<DEP5NSIZE; p++,m++ )
  269.         data[24+m] = *p;
  270.     for ( ; m<DEP5NSIZE; m++ )
  271.         data[24+m] = '\0';
  272. }
  273.  
  274. /* dep5sone - send and store one voice */
  275. dep5sone(voicenum,data)
  276. char *data;
  277. {
  278.     /* Send the parameters for this voice. */
  279.     dep5parms(data);
  280.  
  281.     /* now ask it to be stored into memory */
  282.     sendmidi(0xf0);
  283.     sendmidi(0x41);        /* Roland */
  284.     sendmidi(0x34);        /* operation code = PGR (program #) */
  285.     sendmidi(Channel-1);    /* MIDI channel */
  286.     sendmidi(0x52);        /* format type */
  287.     sendmidi(0x20);        /* level # = 1 */
  288.     sendmidi(0x00);        /* group # = 0 */
  289.     sendmidi(0x00);        /* extension = 0 */
  290.     sendmidi(voicenum & 0x7f);    /* memory number (minus 1) */
  291.     sendmidi(0x02);        /* writing data to memory */
  292.     sendmidi(EOX);
  293.     
  294.     Reason = "";
  295.     return(0);    /* can't fail */
  296. }
  297.  
  298. char *D5alg[] = {
  299. "1    ---EQ---Chorus---<~u/----~d~d~l~l~l~l~l\\----",
  300. "2    ---EQ---Reverb---<~u/----~d~d~l~l~l~l~l\\----",
  301. "3    ---EQ---Reverb(Mod)---<~u/----~d~d~l~l~l~l~l\\----",
  302. "4    ---EQ---Reverb(Mod)---Chorus---<~u/----~d~d~l~l~l~l~l\\----",
  303. "5    ---EQ-+-Reverb--<   +-Chorus---<~u/~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l\
  304. /~u/--------------+---~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~d~d~d~\
  305. l~l~l~l~l~l~l~l~l|__________\\__|~l~l~l~d\\--------------~l~u\\~d+---",
  306. "6    ---EQ---Reverb--<--Chorus---<~u/~l~l~l~l~l~l~l~l~l~l~l~l~l\
  307. /~u/-----------+---~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~d~d~d~\
  308. l\\~d\\-----------~l~u\\~d+---",
  309. "7    ---EQ---NLR---<~u/----~d~d~l~l~l~l~l\\----",
  310. "8    ---EQ---NLR(Mod)---<~u/----~d~d~l~l~l~l~l\\----",
  311. "9    ---EQ---NLR--<--Chorus---<~u/~l~l~l~l~l~l~l~l~l~l~l~l~l\
  312. /~u/-----------+---~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~d~d~d~\
  313. l\\~d\\-----------~l~u\\~d+---",
  314. "10   ---EQ---Delay--<--Chorus---<~u/~l~l~l~l~l~l~l~l~l~l~l~l~l\
  315. /~u/-----------+---~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~l~d~d~d~\
  316. l\\~d\\-----------~l~u\\~d+---",
  317. "11   ---EQ---NLR(Mod)---<~u/----~d~d~l~l~l~l~l\\----",
  318. };
  319.  
  320. #define NPARM 12
  321. char Algparms[][NPARM] = {
  322. 1,1,1,0,0,0,0,1,1,1,1,1,    /* alg 1 */
  323. 0,0,0,1,1,1,1,1,1,1,1,1,    /* alg 2 */
  324. 0,1,1,1,1,1,1,1,1,1,1,1,    /* alg 3 */
  325. 1,1,1,1,1,1,1,1,1,1,1,1,    /* alg 4 */
  326. 1,1,1,1,1,1,1,1,1,1,1,1,    /* alg 5 */
  327. 1,1,1,1,1,1,1,1,1,1,1,1,    /* alg 6 */
  328. 0,0,0,1,1,1,1,1,1,1,1,1,    /* alg 7 */
  329. 0,1,1,1,1,1,1,1,1,1,1,1,    /* alg 8 */
  330. 1,1,1,1,1,1,1,1,1,1,1,1,    /* alg 9 */
  331. 1,1,1,1,1,1,1,1,1,1,1,1,    /* alg 10 */
  332. 0,1,1,1,1,1,1,1,1,1,1,1        /* alg 11 */
  333. };
  334. /* for the parameters in the array above, Algmap gives the index in P */
  335. int Algmap[] = {1,2,3,4,5,6,7,8,9,10,11,12};
  336.  
  337. /*
  338.  * visd5alg
  339.  *
  340.  * Whenever the algorithm is changed, we have to change the
  341.  * meanings/locations/ranges of various parameters.
  342.  */
  343.  
  344. char *
  345. visd5alg(v)
  346. {
  347.     static int rt = -1, pd, hf, rs;
  348.     int n;
  349.  
  350.     if ( rt == -1 ) {
  351.         pd = parmindex("predelay");
  352.         hf = parmindex("hfdamp");
  353.         rt = parmindex("reverbtime");
  354.         rs = parmindex("reverbsel");
  355.     }
  356.     if ( v >= 0 && v <= 10 ){
  357.         Alg = v;
  358.         /* Enable the parameters that this algorithm uses */
  359.         for ( n=0; n<NPARM; n++ ) {
  360.             if ( Algparms[v][n] == 1 )
  361.                 enableparm(Algmap[n]);
  362.             else
  363.                 disableparm(Algmap[n]);
  364.         }
  365.         if ( v == 9 ) {
  366.             P[pd].p_vrow=P[pd].p_lrow=20;
  367.             P[pd].p_label = "Delay Time";
  368.  
  369.             P[rt].p_vrow=P[rt].p_lrow=21;
  370.             P[rt].p_label = "Delay Feedback";
  371.             P[rt].p_max = 255;
  372.  
  373.             P[hf].p_vrow=P[hf].p_lrow=22;
  374.             P[hf].p_label = "HF Damp";
  375.             P[hf].p_max = 95;
  376.  
  377.             P[rs].p_vrow=P[rs].p_lrow=23;
  378.             P[rs].p_label = "Delay Output";
  379.             P[rs].p_max = 2;
  380.         }
  381.         else if ( v<6 ) {
  382.             P[pd].p_vrow=P[pd].p_lrow=10;
  383.             P[pd].p_label = "Pre-Delay";
  384.  
  385.             P[rt].p_vrow=P[rt].p_lrow=11;
  386.             P[rt].p_label = "Reverb Time";
  387.             P[rt].p_max = 152;
  388.  
  389.             P[hf].p_vrow=P[hf].p_lrow=12;
  390.             P[hf].p_label = "HF Damp";
  391.             P[hf].p_max = 95;
  392.  
  393.             P[rs].p_vrow=P[rs].p_lrow=13;
  394.             P[rs].p_label = "Reverb Selection";
  395.             P[rs].p_max = 21;
  396.         }
  397.         else {
  398.             P[pd].p_vrow=P[pd].p_lrow=15;
  399.             P[pd].p_label = "NL Pre-Delay";
  400.  
  401.             P[rt].p_vrow=P[rt].p_lrow=16;
  402.             P[rt].p_label = "NL Reverb Time";
  403.             P[rt].p_max = 150;
  404.  
  405.             P[hf].p_vrow=P[hf].p_lrow=17;
  406.             P[hf].p_label = "NL Gate Time";
  407.             P[hf].p_max = 255;
  408.  
  409.             P[rs].p_vrow=P[rs].p_lrow=18;
  410.             P[rs].p_label = "NL Output";
  411.             P[rs].p_max = 2;
  412.         }
  413.         Redraw = 1;
  414.         return(D5alg[v]);
  415.     }
  416.     else
  417.         return("????");
  418. }
  419.  
  420. int Algval[] = { 0, 3, 31, 59, 87, 115, 143, 171, 199, 227, 255 };
  421.  
  422. d5algin(d)
  423. {
  424.     int n = 0;
  425.  
  426.     while ( d >= Algval[n] && n <= 10 )
  427.         n++;
  428.     return(n-1);
  429. }
  430.  
  431. d5algout(v)
  432. {
  433.     return(Algval[v]);
  434. }
  435.  
  436. d5vin(nparr,v)
  437. struct numpair *nparr;
  438. {
  439.     int n;
  440.  
  441.     for ( n=0; nparr[n].np_val >= 0; n++ ) {
  442.         if ( v <= nparr[n].np_byte )
  443.             return(n);
  444.     }
  445.     return(0);
  446. }
  447.  
  448. char *
  449. visdcr(v)
  450. {
  451.     if ( v >= 0 && v< NUMCR ) {
  452.         v = Chrate[v].np_val;
  453.         sprintf(D5buff,"%d.%d",v/10,v%10);
  454.         return(D5buff);
  455.     }
  456.     else
  457.         return("??");
  458. }
  459.  
  460. d5crout(v)
  461. {
  462.     if ( v >= 0 && v< NUMCR )
  463.         return(Chrate[v].np_byte);
  464.     else
  465.         return(0);
  466. }
  467.  
  468. char *
  469. visdcd(v)
  470. {
  471.     if ( v >= 0 && v< NUMCD ) {
  472.         v = Chdepth[v].np_val;
  473.         sprintf(D5buff,"%d.%d",v/10,v%10);
  474.         return(D5buff);
  475.     }
  476.     else
  477.         return("??");
  478. }
  479. d5cdout(v)
  480. {
  481.     if ( v >= 0 && v< NUMCD )
  482.         return(Chdepth[v].np_byte);
  483.     else
  484.         return(0);
  485. }
  486.  
  487.  
  488. char *
  489. visdcf(v)
  490. {
  491.     if ( v >= 0 && v< 256 ) {
  492.         v = Chfeed[v];
  493.         sprintf(D5buff,"%d.%d",v/10,v%10);
  494.         return(D5buff);
  495.     }
  496.     else
  497.         return("??");
  498. }
  499.  
  500. char *
  501. visd5no(v)
  502. {
  503.     char *p;
  504.     switch (v) {
  505.     case 0: p = "Normal"; break;
  506.     case 1: p = "Pan B to A"; break;
  507.     case 2: p = "Pan A to B"; break;
  508.     }
  509.     return(p);
  510. }
  511.  
  512. char *
  513. visddo(v)
  514. {
  515.     char *p;
  516.     switch (v) {
  517.     case 0: p = "Normal"; break;
  518.     case 1: p = "Invert Phase"; break;
  519.     case 2: p = "Pan A to B"; break;
  520.     }
  521.     return(p);
  522. }
  523.  
  524. char *Revsel[] = { "Special 1", "Special 2", "Plate 1", "Plate 2",
  525.   "Hall 14'","Hall 20'","Hall 27'","Hall 36'","Hall 48'","Hall 61'","Hall 76'",
  526.   "Room 0.3'","Room 1.4'","Room 3.1'","Room 8.2'","Room 14'","Room 20'",
  527.   "Room 27'","Room 36'","Room 48'","Room 61'","Room 76'"
  528. };
  529.  
  530. char *
  531. visdrs(v)
  532. {
  533.     /* For algorithms 6,7,8,10, the reverb select parameter */
  534.     /* is the NL output */
  535.     if ( Alg==6 || Alg==7 || Alg==8 || Alg==10 )
  536.         return(visd5no(v));
  537.     if ( Alg == 9 )
  538.         return(visddo(v));
  539.     if ( v>=0 && v<22 ) {
  540.         rtclip();
  541.         return(Revsel[v]);
  542.     }
  543.     return("??");
  544. }
  545.  
  546. char *
  547. visddt(v)
  548. {
  549.     int rem;
  550.  
  551.     if ( v < 0 || v >= NUMDT )
  552.         return("??");
  553.     v = Dtime[v];
  554.     if ( v < 1000 )
  555.         sprintf(D5buff,"%d",v);
  556.     else {
  557.         rem = (v%1000)/10;
  558.         sprintf(D5buff,(rem<10)?"%d.0%d":"%d.%d",v/1000,rem);
  559.     }
  560.     return(D5buff);
  561. }
  562.  
  563. char *
  564. visd5pd(v)
  565. {
  566.     if ( v < 0 || v >= NUMPD )
  567.         return("??");
  568.     /* For algorithm 9 (aka 10), the predelay parameter is the delay time*/
  569.     if ( Alg == 9 )
  570.         return(visddt(v));
  571.     else
  572.         sprintf(D5buff,"%d",(int)Predly[v]);
  573.     return(D5buff);
  574. }
  575.  
  576. d5rtin(v)
  577. {
  578.     register int n;
  579.  
  580.     if ( Alg==9 )
  581.         return(v);
  582.     else if ( Alg==6 || Alg==7 || Alg==8 || Alg==10 ) {
  583.         for ( n=0; n<NUMNLRT; n++ ) {
  584.             if ( v < Nlrevtime[n].np_byte )
  585.                 break;
  586.         }
  587.         return(n-1);
  588.     }
  589.     else {
  590.         for ( n=0; n<NUMRT; n++ ) {
  591.             if ( v < Revtime[n].np_byte )
  592.                 break;
  593.         }
  594.         return(n-1);
  595.     }
  596. }
  597.  
  598. d5rtout(v)
  599. {
  600.     if ( Alg==9 )
  601.         return(v);
  602.     else if ( Alg==6 || Alg==7 || Alg==8 || Alg==10 )
  603.         return(Nlrevtime[v].np_byte);
  604.     else
  605.         return(Revtime[v].np_byte);
  606. }
  607.  
  608. char *
  609. visd5rt(v)
  610. {
  611.     /* In algorithm 9 (aka 10), the reverb time parameter is */
  612.     /* the delay feedback. */
  613.     if ( Alg == 9 ) {
  614.         if ( v<0 || v>=NUMCF )
  615.             return("??");
  616.         else
  617.             return(visdcf(v));
  618.     }
  619.     else if ( Alg==6 || Alg==7 || Alg==8 || Alg == 10 ) {
  620.         if ( v<0 || v>=NUMNLRT )
  621.             return("??");
  622.         v = Nlrevtime[v].np_val;
  623.         if ( v < 0 )
  624.             sprintf(D5buff,"-0.%d",-v);
  625.         else if ( v < 10 )
  626.             sprintf(D5buff,"0.%d",v);
  627.         else if ( v < 100 )
  628.             sprintf(D5buff,"%d.%d",v/10,v%10);
  629.         else
  630.             sprintf(D5buff,"%d",v/10);
  631.         return(D5buff);
  632.     }
  633.     else if ( v >= 0 && v < NUMRT ) {
  634.         v = rtclip();
  635.         v = Revtime[v].np_val;
  636.         if ( v < 100 )
  637.             sprintf(D5buff,"%d.%d  ",v/10,v%10);
  638.         else
  639.             sprintf(D5buff,"%d  ",v/10);
  640.         return(D5buff);
  641.     }
  642.     else
  643.         return("??  ");
  644. }
  645.  
  646. char *
  647. visd5gt(v)
  648. {
  649.     if ( v >=0 && v < NUMGATE ) {
  650.         sprintf(D5buff,"%d",Gatetime[v]);
  651.         return(D5buff);
  652.     }
  653.     else
  654.         return("??");
  655. }
  656.  
  657.  
  658. char *
  659. visd5hf(v)
  660. {
  661.     if ( Alg==6 || Alg==7 || Alg==8 || Alg==10 ) {
  662.         return(visd5gt(v));
  663.     }
  664.     else if ( v >= 0 && v < NUMHF ) {
  665.         v = Hf[v].hf_val;
  666.         if ( v >= 10 )
  667.             sprintf(D5buff,"%d.%d",v/100,v%100);
  668.         else
  669.             sprintf(D5buff,"0.0%d",v%100);
  670.         return(D5buff);
  671.     }
  672.     else
  673.         return("??");
  674. }
  675.  
  676. d5hfout(v)
  677. {
  678.     if ( Alg==6 || Alg==7 || Alg==8 || Alg==10 )
  679.         return(v);
  680.     else
  681.         return(Hf[v].hf_byte);
  682. }
  683.  
  684. d5hfin(d)
  685. {
  686.     register int n;
  687.  
  688.     if ( Alg==6 || Alg==7 || Alg==8 || Alg==10 )
  689.         return(d);
  690.     for ( n=0; Hf[n].hf_byte >= 0 ; n++ ) {
  691.         if ( d < Hf[n].hf_byte )
  692.             break;
  693.     }
  694.     return(n-1);
  695. }
  696.  
  697. int Revmin[] = { 10,10,7,7,1,2,3,4,5,6,7,1,1,1,1,1,2,3,4,5,6,7 };
  698. int Revmax[] = { 990,990,990,990,200,400,720,990,990,990,990,
  699.   5,15,35,75,200,400,720,990,990,990,990
  700. };
  701.  
  702. rtclip()
  703. {
  704.     int rtval, rtype, origrtval;
  705.  
  706.     origrtval = rtval = getval("reverbtime");
  707.     rtype = getval("reverbsel");
  708.     while ( Revtime[rtval].np_val < Revmin[rtype] )
  709.         rtval++;
  710.     while ( Revtime[rtval].np_val > Revmax[rtype] )
  711.         rtval--;
  712.     if ( rtval != origrtval ) {
  713.         setval("reverbtime",rtval);
  714.         showparam(parmindex("reverbtime"),0);
  715.     }
  716.     return(rtval);
  717. }
  718.  
  719. #define NUMBOOST 25
  720. struct numpair Boost[] = {
  721. 0,-12, 11,-11, 21,-10, 31,-9, 41,-8,
  722. 52,-7, 62,-6, 72,-5, 82,-4, 92,-3,
  723. 103,-2, 113,-1, 123,0, 133,1, 143,2,
  724. 153,3, 164,4, 174,5, 184,6, 194,7,
  725. 204,8, 215,9, 225,10, 235,11, 245,12,
  726. -1, -1
  727. };
  728.  
  729. d5bcin(v)
  730. {
  731.     register int n;
  732.  
  733.     for ( n=0; Boost[n].np_byte >= 0 ; n++ ) {
  734.         if ( v < Boost[n].np_byte )
  735.             break;
  736.     }
  737.     return(n-1);
  738. }
  739. d5bcout(v)
  740. {
  741.     return(Boost[v].np_byte);
  742. }
  743.  
  744. char *
  745. visd5bc(v)
  746. {
  747.     if ( v >= 0 && v < NUMBOOST ) {
  748.         sprintf(D5buff,"%d",Boost[v].np_val);
  749.         return(D5buff);
  750.     }
  751.     else
  752.         return("??");
  753. }
  754.  
  755. char *
  756. visd5q(v)
  757. {
  758.     if ( v==0 )
  759.         return("0.2");
  760.     else if ( v <= 3 )
  761.         return("0.3");
  762.     else if ( v <= 90 ) {
  763.         sprintf(D5buff,"%d.%d",v/10,v%10);
  764.         return(D5buff);
  765.     }
  766.     else
  767.         return("??");
  768. }
  769.  
  770. char *
  771. visd5fm(v)
  772. {
  773.     int rem;
  774.  
  775.     if ( v < 0 || v > 127 )
  776.         return("??");
  777.     v = Freqmid[v];
  778.     if ( v < 100 )
  779.         sprintf(D5buff,"0.%d",v);
  780.     else if ( v < 1000 ) {
  781.         rem = v%100;
  782.         sprintf(D5buff,(rem<10)?"%d.0%d":"%d.%d",v/100,rem);
  783.     }
  784.     else
  785.         sprintf(D5buff,"%d.%d",v/100,(v/10)%10);
  786.     return(D5buff);
  787. }
  788.  
  789. initdp5()
  790. {
  791.     static int initdone = 0;
  792.     int n1, n2, n;
  793.     FILE *f;
  794.  
  795.     if ( initdone )
  796.         return;
  797.     initdone = 1;
  798.     printf("Reading data from 'glibinit.dp5' ...\n");
  799.  
  800.     Chdepth = (struct numpair *) alloc(NUMCD * sizeof(struct numpair));
  801.     Chrate = (struct numpair *) alloc(NUMCR * sizeof(struct numpair));
  802.     Chfeed = (int *) alloc(NUMCF * sizeof(int));
  803.     Nlrevtime = (struct numpair *) alloc(NUMNLRT * sizeof(struct numpair));
  804.     Revtime = (struct numpair *) alloc(NUMRT * sizeof(struct numpair));
  805.     Freqmid = (int *) alloc(NUMFREQ * sizeof(int));
  806.     Gatetime = (int *) alloc(NUMGATE * sizeof(int));
  807.     Hf = (struct hfpair *) alloc(NUMHF * sizeof(struct hfpair));
  808.     Dtime = (int *) alloc(NUMDT * sizeof(int));
  809.     Predly = (int *) alloc(NUMPD * sizeof(int));
  810.  
  811.     OPENTEXTFILE(f,"glibinit.dp5","r");
  812.     if ( f == NULL ) {
  813.         fprintf(stderr,"Hey, 'initdata.dp5' can't be opened!\n");
  814.         millisleep(2000);
  815.         return;
  816.     }
  817.  
  818.     if ( getcomment(f) )
  819.         goto err;
  820.     for ( n=0; n<NUMCD; n++ ) {
  821.         if ( fscanf(f,"%d,%d",&n1,&n2) != 2 )
  822.             goto err;
  823.         Chdepth[n].np_byte = n1;
  824.         Chdepth[n].np_val = n2;
  825.     }
  826.     if ( getcomment(f) )
  827.         goto err;
  828.     for ( n=0; n<NUMFREQ; n++ ) {
  829.         if ( fscanf(f,"%d",&n1) != 1 )
  830.             goto err;
  831.         Freqmid[n] = n1;
  832.     }
  833.     if ( getcomment(f) )
  834.         goto err;
  835.     for ( n=0; n<NUMHF; n++ ) {
  836.         if ( fscanf(f,"%d,%d",&n1,&n2) != 2 )
  837.             goto err;
  838.         Hf[n].hf_byte = n1;
  839.         Hf[n].hf_val = n2;
  840.     }
  841.     if ( getcomment(f) )
  842.         goto err;
  843.     for ( n=0; n<NUMGATE; n++ ) {
  844.         if ( fscanf(f,"%d",&n1) != 1 )
  845.             goto err;
  846.         Gatetime[n] = n1;
  847.     }
  848.     if ( getcomment(f) )
  849.         goto err;
  850.     for ( n=0; n<NUMCR; n++ ) {
  851.         if ( fscanf(f,"%d,%d",&n1,&n2) != 2 )
  852.             goto err;
  853.         Chrate[n].np_byte = n1;
  854.         Chrate[n].np_val = n2;
  855.     }
  856.     if ( getcomment(f) )
  857.         goto err;
  858.     for ( n=0; n<NUMNLRT; n++ ) {
  859.         if ( fscanf(f,"%d,%d",&n1,&n2) != 2 )
  860.             goto err;
  861.         Nlrevtime[n].np_byte = n1;
  862.         Nlrevtime[n].np_val = n2;
  863.     }
  864.     if ( getcomment(f) )
  865.         goto err;
  866.     for ( n=0; n<NUMCF; n++ ) {
  867.         if ( fscanf(f,"%d",&n1) != 1 )
  868.             goto err;
  869.         Chfeed[n] = n1;
  870.     }
  871.     if ( getcomment(f) )
  872.         goto err;
  873.     for ( n=0; n<NUMRT; n++ ) {
  874.         if ( fscanf(f,"%d,%d",&n1,&n2) != 2 )
  875.             goto err;
  876.         Revtime[n].np_byte = n1;
  877.         Revtime[n].np_val = n2;
  878.     }
  879.     if ( getcomment(f) )
  880.         goto err;
  881.     for ( n=0; n<NUMDT; n++ ) {
  882.         if ( fscanf(f,"%d",&n1) != 1 )
  883.             goto err;
  884.         Dtime[n] = n1;
  885.     }
  886.     if ( getcomment(f) )
  887.         goto err;
  888.     for ( n=0; n<NUMPD; n++ ) {
  889.         if ( fscanf(f,"%d",&n1) != 1 )
  890.             goto err;
  891.         Predly[n] = n1;
  892.     }
  893.     if ( getcomment(f) )
  894.         goto err;
  895.  
  896.     return;
  897.     err:
  898.     fprintf(stderr,"Hey, something's wrong with initdata.dp5!\n");
  899.     millisleep(2000);
  900.     return;
  901. }
  902. getcomment(f)
  903. FILE *f;
  904. {
  905.     char buff[BUFSIZ];
  906.  
  907.     if ( fscanf(f,"%s",buff) != 1 || *buff != '#' )
  908.         return(1);
  909.     return(0);
  910. }
  911.