home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 242.lha / GenericLIBrarian / source / yama_com.c < prev   
Encoding:
C/C++ Source or Header  |  1989-04-07  |  29.5 KB  |  895 lines
  1. /*
  2.  * GLIB - a Generic LIBrarian and editor for synths
  3.  *
  4.  * Yamaha Common Routines
  5.  */
  6.  
  7. #define OVERLAY1
  8.  
  9. #include "glib.h"
  10. #include <ctype.h>
  11.  
  12. #define DX100VSIZE 128
  13. #define DX100NSIZE 17
  14.  
  15. char *visnum(), *visonoff(), *vism3num(), *viswave(), *vismono();
  16. char *visfreq(), *visdx1a();
  17. extern int Tx81;
  18.  
  19. int *txindex = NULL;
  20. int txleng = 0;
  21.  
  22.  
  23. extern int Dopmap[];
  24.  
  25. int Tx81 = 0;   /* 1 means we're talking to the TX81Z */
  26. int Dopmap[] = { 3,1,2,0 };
  27.  
  28. int txfreq[] = {
  29. 50, 56, 62, 69, 75, 81, 87, 93,
  30.      100, 106, 112, 118, 124, 131, 137, 143,
  31. 71, 80, 88, 97, 106, 115, 123, 132,
  32.      141, 149, 158, 167, 176, 184, 193, 202,
  33. 78, 88, 98, 107, 117, 127, 137, 147,
  34.      156, 166, 176, 186, 196, 205, 215, 225,
  35. 87, 98, 108, 119, 130, 141, 151, 162,
  36.      173, 183, 194, 205, 216, 226, 237, 248,
  37. 100, 106, 112, 119, 125, 131, 137, 143,
  38.      149, 156, 162, 168, 174, 180, 187, 193,
  39. 141, 150, 159, 167, 176, 185, 194, 203,
  40.      211, 220, 229, 238, 247, 255, 264, 273,
  41. 157, 167, 177, 186, 196, 206, 216, 226,
  42.      235, 245, 255, 265, 275, 284, 294, 304,
  43. 173, 184, 195, 205, 216, 227, 238, 249,
  44.      259, 270, 281, 292, 303, 313, 324, 335,
  45. 200, 206, 212, 218, 225, 231, 237, 243,
  46.      249, 256, 262, 268, 274, 280, 287, 293,
  47. 282, 291, 300, 308, 317, 326, 335, 344,
  48.      352, 361, 370, 379, 388, 396, 405, 414,
  49. 300, 306, 312, 318, 325, 331, 337, 343,
  50.      349, 356, 362, 368, 374, 380, 387, 393,
  51. 314, 324, 334, 343, 353, 363, 373, 383,
  52.      392, 402, 412, 422, 432, 441, 451, 461,
  53. 346, 357, 368, 378, 389, 400, 411, 422,
  54.      432, 443, 454, 465, 476, 486, 497, 508,
  55. 400, 406, 412, 418, 425, 431, 437, 443,
  56.      449, 456, 462, 468, 474, 480, 487, 493,
  57. 424, 433, 441, 450, 459, 468, 476, 485,
  58.      494, 503, 511, 520, 529, 537, 546, 555,
  59. 471, 481, 491, 500, 510, 520, 530, 539,
  60.      549, 559, 569, 579, 588, 598, 608, 618,
  61. 500, 506, 512, 519, 525, 531, 537, 543,
  62.      550, 556, 562, 568, 574, 581, 587, 593,
  63. 519, 530, 540, 551, 562, 573, 584, 594,
  64.      605, 616, 627, 638, 648, 659, 670, 681,
  65. 565, 574, 582, 591, 600, 609, 617, 626,
  66.      635, 644, 652, 661, 670, 678, 687, 696,
  67. 600, 606, 612, 619, 625, 631, 637, 643,
  68.      650, 656, 662, 668, 674, 681, 687, 693,
  69. 628, 638, 647, 657, 667, 677, 687, 696,
  70.      706, 716, 726, 736, 745, 755, 765, 775,
  71. 692, 703, 713, 724, 735, 746, 757, 767,
  72.      778, 789, 800, 811, 821, 832, 843, 854,
  73. 700, 706, 712, 719, 725, 731, 737, 743,
  74.      750, 756, 762, 768, 774, 781, 787, 793,
  75. 707, 716, 724, 733, 742, 750, 759, 768,
  76.      776, 785, 794, 802, 811, 820, 828, 837,
  77. 785, 795, 804, 814, 824, 834, 844, 853,
  78.      863, 873, 883, 893, 902, 912, 922, 932,
  79. 800, 806, 812, 819, 825, 831, 837, 843,
  80.      850, 856, 862, 868, 874, 881, 887, 893,
  81. 848, 857, 865, 874, 883, 891, 900, 909,
  82.      917, 926, 935, 943, 952, 961, 969, 978,
  83. 865, 876, 886, 897, 908, 919, 930, 940,
  84.      951, 962, 973, 984, 994, 1005, 1016, 1027,
  85. 900, 906, 912, 919, 925, 931, 937, 943,
  86.      950, 956, 962, 968, 974, 981, 987, 993,
  87. 942, 952, 961, 971, 981, 991, 1001, 1010,
  88.      1020, 1030, 1040, 1050, 1059, 1069, 1079, 1089,
  89. 989, 998, 1006, 1015, 1024, 1032, 1041, 1050,
  90.      1058, 1067, 1076, 1084, 1093, 1102, 1110, 1119,
  91. 1000, 1006, 1012, 1019, 1025, 1031, 1037, 1043,
  92.      1050, 1056, 1062, 1068, 1074, 1081, 1087, 1093,
  93. 1038, 1049, 1060, 1070, 1081, 1092, 1103, 1113,
  94.      1124, 1135, 1146, 1157, 1167, 1178, 1189, 1200,
  95. 1099, 1109, 1119, 1128, 1138, 1148, 1158, 1167,
  96.      1177, 1187, 1197, 1207, 1216, 1226, 1236, 1246,
  97. 1100, 1106, 1112, 1119, 1125, 1131, 1137, 1143,
  98.      1150, 1156, 1162, 1168, 1174, 1181, 1187, 1193,
  99. 1130, 1139, 1147, 1156, 1165, 1173, 1182, 1191,
  100.      1199, 1208, 1217, 1225, 1234, 1243, 1251, 1260,
  101. 1200, 1206, 1212, 1219, 1225, 1231, 1237, 1243,
  102.      1250, 1256, 1262, 1268, 1274, 1281, 1287, 1293,
  103. 1211, 1222, 1233, 1243, 1254, 1265, 1276, 1286,
  104.      1297, 1308, 1319, 1330, 1340, 1351, 1362, 1373,
  105. 1256, 1266, 1276, 1285, 1295, 1305, 1315, 1324,
  106.      1334, 1344, 1354, 1364, 1373, 1383, 1393, 1403,
  107. 1272, 1281, 1289, 1298, 1306, 1315, 1323, 1332,
  108.      1341, 1349, 1358, 1366, 1375, 1384, 1392, 1401,
  109. 1300, 1306, 1312, 1319, 1325, 1331, 1337, 1343,
  110.      1350, 1356, 1362, 1368, 1374, 1381, 1387, 1393,
  111. 1384, 1395, 1406, 1416, 1427, 1438, 1449, 1459,
  112.      1470, 1481, 1492, 1503, 1513, 1524, 1535, 1546,
  113. 1400, 1406, 1412, 1419, 1425, 1431, 1437, 1443,
  114.      1450, 1456, 1462, 1468, 1474, 1481, 1487, 1493,
  115. 1410, 1419, 1428, 1436, 1445, 1454, 1463, 1471,
  116.      1480, 1489, 1498, 1507, 1515, 1524, 1533, 1542,
  117. 1413, 1423, 1433, 1442, 1452, 1462, 1472, 1481,
  118.      1491, 1501, 1511, 1521, 1530, 1540, 1550, 1560,
  119. 1500, 1506, 1512, 1519, 1525, 1531, 1537, 1543,
  120.      1550, 1556, 1562, 1568, 1574, 1581, 1587, 1593,
  121. 1555, 1563, 1572, 1581, 1589, 1598, 1606, 1615,
  122.      1623, 1632, 1640, 1649, 1657, 1666, 1674, 1683,
  123. 1557, 1568, 1579, 1589, 1600, 1611, 1622, 1632,
  124.      1643, 1654, 1665, 1676, 1686, 1697, 1708, 1719,
  125. 1570, 1580, 1590, 1599, 1609, 1619, 1629, 1638,
  126.      1648, 1658, 1668, 1678, 1687, 1697, 1707, 1717,
  127. 1696, 1704, 1713, 1722, 1730, 1739, 1747, 1756,
  128.      1764, 1773, 1781, 1790, 1798, 1807, 1815, 1824,
  129. 1727, 1737, 1747, 1756, 1766, 1776, 1786, 1795,
  130.      1805, 1815, 1825, 1835, 1844, 1854, 1864, 1874,
  131. 1730, 1741, 1752, 1762, 1773, 1784, 1795, 1805,
  132.      1816, 1827, 1838, 1849, 1859, 1870, 1881, 1892,
  133. 1837, 1845, 1854, 1863, 1871, 1880, 1888, 1897,
  134.      1905, 1914, 1922, 1931, 1939, 1948, 1956, 1965,
  135. 1884, 1894, 1904, 1913, 1923, 1933, 1943, 1952,
  136.      1962, 1972, 1982, 1992, 2001, 2011, 2021, 2031,
  137. 1903, 1914, 1925, 1935, 1946, 1957, 1968, 1978,
  138.      1989, 2000, 2011, 2022, 2032, 2043, 2054, 2065,
  139. 1978, 1986, 1995, 2004, 2012, 2021, 2029, 2038,
  140.      2046, 2055, 2063, 2072, 2080, 2089, 2097, 2106,
  141. 2041, 2051, 2061, 2070, 2080, 2090, 2100, 2110,
  142.      2119, 2129, 2139, 2149, 2159, 2168, 2178, 2188,
  143. 2076, 2087, 2098, 2108, 2119, 2130, 2141, 2152,
  144.      2162, 2173, 2184, 2195, 2206, 2216, 2227, 2238,
  145. 2120, 2128, 2137, 2145, 2154, 2162, 2171, 2179,
  146.      2188, 2196, 2205, 2213, 2222, 2230, 2238, 2247,
  147. 2198, 2208, 2218, 2227, 2237, 2247, 2257, 2267,
  148.      2276, 2286, 2296, 2306, 2316, 2325, 2335, 2345,
  149. 2249, 2260, 2271, 2281, 2292, 2303, 2314, 2325,
  150.      2335, 2346, 2357, 2368, 2379, 2389, 2400, 2411,
  151. 2355, 2365, 2375, 2384, 2394, 2404, 2414, 2424,
  152.      2433, 2443, 2453, 2463, 2473, 2482, 2492, 2502,
  153. 2422, 2433, 2444, 2454, 2465, 2476, 2487, 2498,
  154.      2508, 2519, 2530, 2541, 2552, 2562, 2573, 2584,
  155. 2595, 2606, 2617, 2627, 2638, 2649, 2660, 2671,
  156.      2681, 2692, 2703, 2714, 2725, 2735, 2746, 2757
  157. };
  158.  
  159. /*
  160.  * dxtxdin
  161.  *
  162.  * Take info from 'data' and stuff values in the P array, by using
  163.  * the setval (and setopval) functions.  'data' is the Yamaha VMEM format.
  164.  * This function works for both the dx100 and tx81z.
  165.  */
  166.  
  167. dxtxdin(data)
  168. char *data;
  169. {
  170.         int dop, adop, n, crs, fin, v;
  171.  
  172.         setdxtx();
  173.         if ( Tx81 )
  174.                 txinit();
  175.         for ( n=1; n<=4; n++ ) {
  176.                 dop = Dopmap[n-1]*10;
  177.                 adop = Dopmap[n-1]*2;
  178.                 setopval(n,"attack",data[0+dop]);
  179.                 setopval(n,"decay1",data[1+dop]);
  180.                 setopval(n,"level1",data[4+dop]);
  181.                 setopval(n,"decay2",data[2+dop]);
  182.                 setopval(n,"release",data[3+dop]);
  183.                 setopval(n,"keyscale",data[5+dop]);
  184.                 setopval(n,"ampmod",(data[6+dop]>>6)&01);
  185.                 setopval(n,"egbias",(data[6+dop]>>3)&07);
  186.                 setopval(n,"velocity",data[6+dop]&07);
  187.                 setopval(n,"outlevel",data[7+dop]);
  188.  
  189.                 if ( Tx81 ) {
  190.                         crs = data[8+dop];
  191.                         fin = (data[74+adop]) & 017;
  192.                         v = freqin(crs,fin);
  193.                         setopval(n,"freq",v);
  194.                 }
  195.                 else
  196.                         setopval(n,"freq",data[8+dop]);
  197.  
  198.                 setopval(n,"keyrate",data[9+dop]>>3);
  199.                 setopval(n,"detune",data[9+dop]&07);
  200.  
  201.                 if ( Tx81 ) {
  202.                         setopval(n,"egsft",(data[73+adop]>>4)&03);
  203.                         setopval(n,"fix",(data[73+adop]>>3)&01);
  204.                         setopval(n,"wave",(data[74+adop]>>4)&07);
  205.                 }
  206.         }
  207.         setval("lfosync",(data[40]>>6)&01);
  208.         setval("feedback",(data[40]>>3)&07);
  209.         setval("algorithm",data[40]&07);
  210.         setval("lfospeed",data[41]);
  211.         setval("lfodelay",data[42]);
  212.         setval("pmoddepth",data[43]);
  213.         setval("amoddepth",data[44]);
  214.         setval("pmodsens",(data[45]>>4)&07);
  215.         setval("amodsens",(data[45]>>2)&03);
  216.         setval("lfowave",data[45]&03);
  217.         setval("transpose",data[46]);
  218.         setval("pitchbend",data[47]);
  219.         setval("portatime",data[49]);
  220.         setval("modprange",data[51]);
  221.         setval("modarange",data[52]);
  222.         setval("breathprange",data[53]);
  223.         setval("breatharange",data[54]);
  224.         setval("breathpbias",data[55]);
  225.         setval("breathegbias",data[56]);
  226.         setval("playmode",(data[48]>>3)&01);
  227.         setval("susfoot",(data[48]>>2)&01);
  228.         setval("portfoot",(data[48]>>1)&01);
  229.         setval("portmode",data[48]&01);
  230.         setval("autochan",Channel);
  231.         if ( Tx81 ) {
  232.                 setval("reverbrate",data[81]&07);
  233.                 setval("fcpitch",data[82]);
  234.                 setval("fcamp",data[83]);
  235.         }
  236. }
  237.  
  238. /*
  239.  * dxtxdout
  240.  *
  241.  * Take (possibly changed) parameters values out of the P array and
  242.  * put them back into 'data'.  'data' is in the Yamaha VMEM format.
  243.  * This works for both the dx100 and tx81z.
  244.  */
  245.  
  246. dxtxdout(data)
  247. char *data;
  248. {
  249.         int dop, n, crs, fin;
  250.  
  251.         for ( n=1; n<=4; n++ ) {
  252.                 dop = Dopmap[n-1]*10;
  253.                 data[0+dop] = getopval(n,"attack");
  254.                 data[1+dop] = getopval(n,"decay1");
  255.                 data[4+dop] = getopval(n,"level1");
  256.                 data[2+dop] = getopval(n,"decay2");
  257.                 data[3+dop] = getopval(n,"release");
  258.                 data[5+dop] = getopval(n,"keyscale");
  259.                 data[6+dop] = getopval(n,"ampmod")<<6
  260.                                 | getopval(n,"egbias")<<3
  261.                                 | getopval(n,"velocity");
  262.                 data[7+dop] = getopval(n,"outlevel");
  263.                 data[9+dop] = getopval(n,"keyrate")<<3 | getopval(n,"detune");
  264.  
  265.                 if ( ! Tx81 ) {
  266.                         data[8+dop] = getopval(n,"freq");
  267.                 }
  268.                 else {
  269.                         freqout(getopval(n,"freq"),&crs,&fin);
  270.                         data[8+dop] = crs;
  271.  
  272.                         dop = Dopmap[n-1]*2;
  273.                         data[73+dop] = getopval(n,"egsft")<<4
  274.                                         | getopval(n,"fix")<<3
  275.                                         /* | getopval(n,"fixrg") */;
  276.                         data[74+dop] = getopval(n,"wave")<<4 | fin;
  277.                 }
  278.         }
  279.         data[40] = getval("lfosync")<<6
  280.                 | getval("feedback")<<3
  281.                 | getval("algorithm");
  282.         data[41] = getval("lfospeed");
  283.         data[42] = getval("lfodelay");
  284.         data[43] = getval("pmoddepth");
  285.         data[44] = getval("amoddepth");
  286.         data[45] = getval("pmodsens")<<4 | getval("amodsens")<<2
  287.                 | getval("lfowave");
  288.         data[46] = getval("transpose");
  289.         data[47] = getval("pitchbend");
  290.         data[49] = getval("portatime");
  291.         data[51] = getval("modprange");
  292.         data[52] = getval("modarange");
  293.         data[53] = getval("breathprange");
  294.         data[54] = getval("breatharange");
  295.         data[55] = getval("breathpbias");
  296.         data[56] = getval("breathegbias");
  297.         data[48] = (unsigned) ( getval("playmode")<<3
  298.                 | getval("susfoot")<<2
  299.                 | getval("portfoot")<<1
  300.                 | getval("portmode"));
  301.  
  302.         if ( Tx81 ) {
  303.                 data[81] = getval("reverbrate");
  304.                 data[82] = getval("fcpitch");
  305.                 data[83] = getval("fcamp");
  306.         }
  307.  
  308.         Channel = getval("autochan");
  309. }
  310.  
  311. setdxtx()
  312. {
  313.         if ( strcmp(Synthname,"DX-100")==0 )
  314.                 Tx81 = 0;
  315.         else
  316.                 Tx81 = 1;
  317. }
  318.  
  319. setopval(n,str,v)
  320. char *str;
  321. {
  322.         char buff[32];
  323.         sprintf(buff,"op%d%s",n,str);
  324.         setval(buff,v);
  325. }
  326.  
  327. getopval(n,str)
  328. char *str;
  329. {
  330.         char buff[32];
  331.         sprintf(buff,"op%d%s",n,str);
  332.         return(getval(buff));
  333. }
  334.  
  335. /*
  336.  * The routines below are used (in the P array) for printing the
  337.  * values of various parameters (e.g. the vism3num routine prints
  338.  * the value-3, which is appropriate for the 'detune' parameter.
  339.  */
  340.  
  341. char Numbuff[8];
  342.  
  343. char *visnum();
  344.  
  345. char *
  346. vis1num(v)
  347. {
  348.         sprintf(Numbuff,"%d",v+1);
  349.         return(Numbuff);
  350. }
  351.  
  352. char *
  353. vism3num(v)
  354. {
  355.         sprintf(Numbuff,"%d",v-3);
  356.         return(Numbuff);
  357. }
  358.  
  359. char *visonoff();
  360.  
  361. char *
  362. vismono(v)
  363. {
  364.         if ( v==0 )
  365.                 return("poly");
  366.         else
  367.                 return("mono");
  368. }
  369.  
  370. /*
  371.             4    2  4    2         4                             4
  372.             |    |  |    |         |               4             |
  373.         2---3    ---3    3  4   2  3   1  4     ___|___    1  2  3
  374.         |           |    |  |   |  |   |  |     |  |  |    |__|__|
  375.         1           1    1---   1---   2  3     1  2  3
  376.                                        |__|     |__|__|
  377.                                                              1  2  3  4
  378.                                                              |__|__|__|
  379.  */
  380.  
  381. char *Algostr[] = {
  382.         "1     ~d2---3~u~l|~u~l4~d~d~d~l~l~l~l~l|~l~d1",
  383.         "2     ~d---3~l~l~l~l~u|  |~l~l~l~l~u2  4~l~d~d~d|~l~d1",
  384.         "3     ~d3  4~l~l~l~l~u|~l~u2~l~d~d~d|  |~d~l~l~l~l1---",
  385.         "4     ~d2  3~l~u|~u~l4~l~d~d~d~l~l~l|  |~l~l~l~l~d1---",
  386.         "5     ~d~u1  4~d~l~l~l~l|  |~d~l~l~l~l2  3~d~l~l~l~l----",
  387.         "6     ~d|  |  |~u~l~l~l~l~l~l~l___|___~u~l~l~l~l4~l~d~d~d~l~l~l1  2  3~d~l~l~l~l~l~l~l|__|__|",
  388.         "7     ~d1  2  3~u~l|~u~l4~l~d~d~d~l~l~l~l~l~l|__|__|",
  389.         "8     ~d1  2  3  4~d~l~l~l~l~l~l~l~l~l~l|__|__|__|"
  390. };
  391.  
  392. char *
  393. visdx1a(v)
  394. {
  395.         if ( v >= 0 && v <= 7 )
  396.                 return(Algostr[v]);
  397.         else
  398.                 return("????");
  399. }
  400.  
  401. char *
  402. viswave(v)
  403. {
  404.         switch(v){
  405.         case 0: return("saw up");
  406.         case 1: return("square");
  407.         case 2: return("triangle");
  408.         case 3: return("s/hold");
  409.         default: return("???");
  410.         }
  411. }
  412.  
  413. char *Freqstr[] = {     /* values from 0 to 63 */
  414.         "0.50 ", "0.71 ", "0.78 ", "0.87 ", "1.00 ",
  415.         "1.41 ", "1.57 ", "1.73 ", "2.00 ", "2.82 ",
  416.         "3.00 ", "3.14 ", "3.46 ", "4.00 ", "4.24 ",
  417.         "4.71 ", "5.00 ", "5.19 ", "5.65 ", "6.00 ",
  418.         "6.28 ", "6.92 ", "7.00 ", "7.07 ", "7.85 ",
  419.         "8.00 ", "8.48 ", "8.65 ", "9.00 ", "9.42 ",
  420.         "9.89 ", "10.00", "10.38", "10.99", "11.00",
  421.         "11.30", "12.00", "12.11", "12.56", "12.72",
  422.         "13.00", "13.84", "14.00", "14.10", "14.13",
  423.         "15.00", "15.55", "15.57", "15.70", "16.96",
  424.         "17.27", "17.30", "18.37", "18.84", "19.03",
  425.         "19.78", "20.41", "20.76", "21.20", "21.98",
  426.         "22.49", "23.55", "24.22", "25.95"
  427. };
  428.  
  429. char *
  430. visfreq(v)
  431. {
  432.         if ( v >=0 && v <= 63 )
  433.                 return ( Freqstr[v] );
  434.         else
  435.                 return("????");
  436. }
  437.  
  438. /*
  439.  * dx1sedit
  440.  *
  441.  * Send a single voice to the edit buffer of the DX.
  442.  */
  443. dx1sedit(data)
  444. char *data;
  445. {
  446.         setdxtx();
  447.         if ( Tx81 )
  448.                 sendaced(data);
  449.         sendvced(data);
  450. }
  451.  
  452. sendvced(data)
  453. char *data;
  454. {
  455.         char vdata[DX100VSIZE];
  456.         int n, cksum, c;
  457.  
  458.         clrdata(vdata,DX100VSIZE);
  459.         vmemtovced(data,vdata);
  460.         sendmidi(0xf0);
  461.         sendmidi(0x43);
  462.         sendmidi(Channel-1);    /* channel # */
  463.         sendmidi(0x03);         /* format type */
  464.         sendmidi(0x00);         /* byte count */
  465.         sendmidi(0x5d);         /* byte count */
  466.         cksum = 0;
  467.         for ( n=0; n<93; n++ ) {
  468.                 sendmidi(c = (int)(vdata[n]));
  469.                 cksum += c;
  470.         }
  471.         sendmidi((-cksum) & 0x7f);
  472.         sendmidi(EOX);
  473. }
  474.  
  475. sendaced(data)
  476. char *data;
  477. {
  478.         char *p, vdata[DX100VSIZE];
  479.         int n, cksum, c;
  480.  
  481.         clrdata(vdata,DX100VSIZE);
  482.         vmemtoaced(data,vdata);
  483.         sendmidi(0xf0);
  484.         sendmidi(0x43);
  485.         sendmidi(Channel-1);    /* channel # */
  486.         sendmidi(0x7e);         /* format type */
  487.         sendmidi(0x00);         /* byte count */
  488.         sendmidi(0x21);         /* byte count */
  489.         p = "LM  8976AE";
  490.         cksum = 0;
  491.         while ( (c=(int)(*p++)) != '\0' ) {
  492.                 sendmidi(c);
  493.                 cksum += c;
  494.         }
  495.         for ( n=0; n<23; n++ ) {
  496.                 sendmidi(c=(int)(vdata[n]));
  497.                 cksum += c;
  498.         }
  499.         sendmidi((-cksum) & 0x7f);
  500.         sendmidi(EOX);
  501. }
  502.  
  503. /*
  504.  * vmemtovced
  505.  *
  506.  * convert a vmem format voice to vced format.
  507.  */
  508.  
  509. vmemtovced(data,vdata)
  510. char *data;
  511. char *vdata;
  512. {
  513.         int vop, dop, n;
  514.  
  515.         for ( n=0; n<4; n++ ) {
  516.                 /* vop = Dopmap[n]*13; */
  517.                 vop = Dopmap[n]*13;
  518.                 dop = Dopmap[n]*10;
  519.                 vdata[vop+0] = data[dop+0];     /* attack rate */
  520.                 vdata[vop+1] = data[dop+1];     /* decay 1 rate */
  521.                 vdata[vop+2] = data[dop+2];     /* decay 2 rate */
  522.                 vdata[vop+3] = data[dop+3];     /* release rate */
  523.                 vdata[vop+4] = data[dop+4];     /* decal 1 level */
  524.                 vdata[vop+5] = data[dop+5];     /* keyboard scaling level */
  525.                 vdata[vop+6] = (data[dop+9]>>3);/* keyboard scaling rate */
  526.                 vdata[vop+7] = (data[dop+6]>>3)&7;      /* eg bias sens. */
  527.                 vdata[vop+8] = (data[dop+6]>>6)&1;      /* amp. mod. enable */
  528.                 vdata[vop+9] = (data[dop+6]&7); /* key velocity */
  529.                 vdata[vop+10] = data[dop+7];    /* output level */
  530.                 vdata[vop+11] = data[dop+8];    /* osc. frequency */
  531.                 vdata[vop+12] = (data[dop+9]&7);        /* detune */
  532.         }
  533.         vdata[52] = (data[40]&7);       /* algorithm */
  534.         vdata[53] = (data[40]>>3)&7;    /* feedback level */
  535.         vdata[54] = data[41];           /* lfo speed */
  536.         vdata[55] = data[42];           /* lfo delay */
  537.         vdata[56] = data[43];           /* pitch modulation depth */
  538.         vdata[57] = data[44];           /* amplitude modulation depth */
  539.         vdata[58] = (data[40]>>6)&1;    /* lfo sync */
  540.         vdata[59] = data[45]&3;         /* lfo wave */
  541.         vdata[60] = (data[45]>>4)&7;            /* pitch modulation sens. */
  542.         vdata[61] = (data[45]>>2)&3;            /* amp. modulation sens. */
  543.         vdata[62] = data[46];           /* transpose */
  544.         vdata[63] = (data[48]>>3)&1;    /* play mode (poly/mono) */
  545.         vdata[64] = data[47];           /* pitch bend range */
  546.         vdata[65] = (data[48]&1);       /* portamento mode */
  547.         vdata[66] = data[49];           /* portamento time */
  548.         vdata[67] = data[50];           /* foot volume range */
  549.         vdata[68] = (data[48]>>2)&1;    /* sustain foot switch */
  550.         vdata[69] = (data[48]>>1)&1;    /* portamento foot switch */
  551.         vdata[70] = (data[48]>>4)&1;    /* chorus switch */
  552.         vdata[71] = data[51];           /* mod. wheel pitch mod. range */
  553.         vdata[72] = data[52];           /* mod. wheel ampli. mod. range */
  554.         vdata[73] = data[53];           /* breath pitch mod. range */
  555.         vdata[74] = data[54];           /* breath ampli. mod. range */
  556.         vdata[75] = data[55];           /* breath control pitch bias range */
  557.         vdata[76] = data[56];           /* breath control EG bias range */
  558.         for ( n=77; n<93; n++ )         /* voice name AND pitch EG rates */
  559.                 vdata[n] = data[n-20];
  560. }
  561.  
  562. /*
  563.  * vmemtoaced
  564.  *
  565.  * Convert a vmem format voice to aced format (TX81Z).
  566.  */
  567.  
  568. vmemtoaced(data,adata)
  569. char *data;
  570. char *adata;
  571. {
  572.         int vop, aop, n;
  573.  
  574.         for ( n=0; n<4; n++ ) {
  575.             vop = 73 + Dopmap[n]*2;
  576.             aop = Dopmap[n]*5;
  577.             adata[0+aop] = (data[vop]>>3) & 01;    /* fixed freq (0,1) */
  578.             adata[1+aop] = data[vop] & 07;         /* fixed freq range (0-7) */
  579.             adata[2+aop] = data[vop+1] & 017;      /* freq range fine (0-15) */
  580.             adata[3+aop] = (data[vop+1]>>4) & 07;  /* op. waveform (0-7) */
  581.             adata[4+aop] = (data[vop]>>3) & 03;   /* EG shift (0-3) */
  582.         }
  583.         adata[20] = data[81] & 07;      /* reverb rate */
  584.         adata[21] = data[82];   /* Foot controller pitch */
  585.         adata[22] = data[83];   /* Foot controller amp. */
  586. }
  587.  
  588. #ifdef OLD
  589. /*
  590.  * Send a single parameter value.
  591.  */
  592. sendparam(param,val)
  593. {
  594.         sendmidi(0xf0);
  595.         sendmidi(0x43);
  596.         sendmidi(0x10); /* Channel? */
  597.         sendmidi(0x12);
  598.         sendmidi(param);
  599.         sendmidi(val);
  600.         sendmidi(EOX);
  601. }
  602.  
  603. /*
  604.  * remotely press a key on the DX
  605.  */
  606. presskey(key,val)
  607. {
  608.         sendmidi(0xf0);
  609.         sendmidi(0x43);
  610.         sendmidi(0x10); /* Channel? */
  611.         sendmidi(0x08);
  612.         sendmidi(key);
  613.         sendmidi(val);
  614.         sendmidi(EOX);
  615. }
  616.  
  617. /*
  618.  * tovmem
  619.  *
  620.  * convert a vced format voice to vmem format.
  621.  */
  622.  
  623. tovmem(vdata,data)
  624. char *vdata;    /* vced format data */
  625. char *data;     /* vmem format */
  626. {
  627.         int vop, dop, n;
  628.  
  629.         for ( n=0; n<4; n++ ) {
  630.                 vop = Dopmap[n]*13;
  631.                 dop = Dopmap[n]*10;
  632.                 data[dop+0] = vdata[vop+0];     /* attack rate */
  633.                 data[dop+1] = vdata[vop+1];     /* decay 1 rate */
  634.                 data[dop+2] = vdata[vop+2];     /* decay 2 rate */
  635.                 data[dop+3] = vdata[vop+3];     /* release rate */
  636.                 data[dop+4] = vdata[vop+4];     /* decal 1 level */
  637.                 data[dop+5] = vdata[vop+5];     /* keyboard scaling level */
  638.                                 /* amp. mod. enab/eg bias sens/key velocity */
  639.                 data[dop+6]=(vdata[vop+8]<<6) | (vdata[vop+7]<<3) | vdata[vop+9];
  640.                 data[dop+7] = vdata[vop+10];    /* output level */
  641.                 data[dop+8] = vdata[vop+11];    /* osc. frequency */
  642.                                 /* key scaling rate/detune */
  643.                 data[dop+9] = (vdata[vop+6]<<3) | vdata[vop+12];
  644.         }
  645.                 /* lfo sync/feedback level/algorithm */
  646.         data[40] = (vdata[58]<<6) | (vdata[53]<<3) | vdata[52];
  647.         data[41] = vdata[54];           /* lfo speed */
  648.         data[42] = vdata[55];           /* lfo delay */
  649.         data[43] = vdata[56];           /* pitch modulation depth */
  650.         data[44] = vdata[57];           /* amplitude modulation depth */
  651.                 /* pitch mod. sens/amp. mod. sens/lfo wave */
  652.         data[45] = (vdata[60]<<4) | (vdata[61]<<2) | vdata[59];
  653.         data[46] = vdata[62];           /* transpose */
  654.  
  655.                 /* chorus/playmode/sustain/portamento-foot/portamento-mode */
  656.         data[48] = (vdata[70]<<4)|(vdata[63]<<3)|(vdata[68]<<2)|(vdata[69]<<1)
  657.                 | vdata[65];
  658.  
  659.         data[47] = vdata[64];           /* pitch bend range */
  660.         data[49] = vdata[66];           /* portamento time */
  661.         data[50] = vdata[67];           /* foot volume range */
  662.         data[51] = vdata[71];           /* mod. wheel pitch mod. range */
  663.         data[52] = vdata[72];           /* mod. wheel ampli. mod. range */
  664.         data[53] = vdata[73];           /* breath pitch mod. range */
  665.         data[54] = vdata[74];           /* breath ampli. mod. range */
  666.         data[55] = vdata[75];           /* breath control pitch bias range */
  667.         data[56] = vdata[76];           /* breath control EG bias range */
  668.         for ( n=77; n<93; n++ )         /* voice name AND pitch EG rates */
  669.                 data[n-20] = vdata[n];
  670. }
  671. #endif
  672.  
  673. /* dx1nof - return a pointer to the voice name buried in data */
  674. char *
  675. dx1nof(data)
  676. char *data;
  677. {
  678.         static char currbuff[DX100NSIZE+1];
  679.         char *p;
  680.         int m;
  681.  
  682.         p = currbuff;
  683.         for ( m=0; m<10; m++ )
  684.                 *p++ = data[57+m];
  685.         *p = '\0';
  686.         return(currbuff);
  687. }
  688.  
  689. /* dx1snof - set the voice name buried in data to name */
  690. dx1snof(data,name)
  691. char *data;
  692. char *name;
  693. {
  694.         char *p;
  695.         int m;
  696.  
  697.         for ( p=name,m=0; *p!='\0' && m<10; p++,m++ )
  698.                 data[57+m] = *p;
  699.         for ( ; m<10; m++ )
  700.                 data[57+m] = ' ';
  701. }
  702.  
  703. /* dx1sbulk - send a bulk dump to the DX-100 */
  704. dx1sbulk(data)
  705. char *data;
  706. {
  707.         int c, v, n, cksum;
  708.  
  709.         sendmidi(0xf0);
  710.         sendmidi(0x43);
  711.         sendmidi(Channel-1);    /* Channel # */
  712.         sendmidi(0x04);
  713.         sendmidi(0x20);
  714.         sendmidi(0x00);
  715.         cksum = 0;
  716.         /* send 32 voices worth of data */
  717.         for ( v=0; v<32; v++ ) {
  718.                 for ( n=0; n<DX100VSIZE; n++ ) {
  719.                         /* The DX100 can only handle 24 voices (but needs */
  720.                         /* to have 32 voices worth of data sent, anyway) */
  721.                         if ( v >= 24 && ( ! Tx81 ) )
  722.                                 c = 0;
  723.                         else
  724.                                 c = VOICEBYTE(data,v,n);
  725.                         sendmidi(c & 0xff);
  726.                         cksum += c;
  727.                 }
  728.         }
  729.         sendmidi((-cksum) & 0x7f);
  730.         sendmidi(0xf7);
  731. }
  732.  
  733. /* dx1gbulk - Request and read a bulk dump from the DX-100 */
  734. dx1gbulk(data)
  735. char *data;
  736. {
  737.         int c, n, v, b1, b2, cksum, ret = 1;
  738.         long begin, toolong;
  739.  
  740.         setdxtx();
  741.         flushmidi();
  742.  
  743.         sendmidi(0xf0);
  744.         sendmidi(0x43);
  745.         sendmidi(0x20 | (Channel-1) );  /* Channel # */
  746.         sendmidi(4);                    /* 4 == 32 voice bulk dump */
  747.         sendmidi(EOX);                  /* EOX */
  748.  
  749.         begin = milliclock();
  750.         toolong = begin + 1000 * TIMEOUT;
  751.  
  752.         /* wait for the x43 byte starting the dump */
  753.         while ( milliclock() < toolong ) {
  754.                 if ( STATMIDI && (c=(getmidi() & 0xff)) == 0x43 )
  755.                         break;
  756.         }
  757.         if ( c != 0x43 ) {
  758.                 Reason = "Timeout waiting for 0x43";
  759.                 goto getout;
  760.         }
  761.         getmidi();      /* channel # */
  762.         getmidi();      /* format # */
  763.         getmidi();      /* byte count high byte */
  764.         getmidi();      /* byte count low byte */
  765.  
  766.         cksum = 0;
  767.         /* 32 voices are dumped */
  768.         for ( v=0; v<32; v++ ) {
  769.                 for ( n=0; n<DX100VSIZE; n++ ) {
  770.                         /* twiddle your thumbs, but not forever */
  771.                         while ( ! STATMIDI ) {
  772.                                 if ( milliclock() > toolong )
  773.                                         goto timeout;   /* the end of an era */
  774.                         }
  775.                         c = (getmidi() & 0xff);
  776.                         /* Ignore non-data bytes ? */
  777.                         if ( c & 0x80 )
  778.                                 continue;
  779.                         /* compute checksum */
  780.                         cksum += c;
  781.                         /* Only 24 voices are used on the DX100 */
  782.                         if ( v < 24 || Tx81 )
  783.                                 VOICEBYTE(data,v,n) = c;
  784.                 }
  785.         }
  786. timeout:
  787.         if ( v < 32 ) {
  788.                 Reason = "Timeout while reading!";
  789.                 goto getout;
  790.         }
  791.         b1 = (getmidi() & 0xff);        /* Checksum */
  792.         b2 = (getmidi() & 0xff);        /* EOX */
  793.         cksum = (-cksum) & 0x7f;        /* convert to what we must match */
  794.         if ( b2 != EOX )
  795.                 Reason = "EOX not received";
  796.         else if ( b1 != cksum ) {
  797.                 static char ckbuff[80];
  798.                 sprintf(ckbuff,"Checksum doesn't match (got %d expected %d)",b1,cksum);
  799.                 /* Reason = "Checksum doesn't match"; */
  800.                 Reason = ckbuff;
  801.         }
  802.         else {
  803.                 Reason = "";
  804.                 ret = 0;        /* all's well */
  805.         }
  806. getout:
  807.         return(ret);
  808. }
  809.  
  810. #ifdef OLDSTUFF
  811. dxchecksum(data)
  812. char *data;
  813. {
  814.         int v, n, s=0;
  815.  
  816.         for ( v=0; v<DX100NVOICES; v++ ) {
  817.                 for ( n=0; n<DX100VSIZE; n++ ) {
  818.                         s += (int)(VOICEBYTE(data,v,n));
  819.                         while ( s > 128 )
  820.                                 s -= 128;
  821.                 }
  822.         }
  823.         return(128-s);
  824. }
  825. #endif
  826.  
  827. freqin(crs,fin)
  828. {
  829.         int n, f;
  830.  
  831.         txinit();
  832.         f = txfreq[crs*16+fin];
  833.         for ( n=0; n<txleng; n++ ) {
  834.                 if ( txfreq[txindex[n]] == f )
  835.                         return(n);
  836.         }
  837.         return(0);
  838. }
  839.  
  840. freqout(v,acrs,afin)
  841. int *acrs;
  842. int *afin;
  843. {
  844.         int i;
  845.  
  846.         i = txindex[v];
  847.         *acrs = i/16;
  848.         *afin = i%16;
  849. }
  850.  
  851. txinit()
  852. {
  853.         int n, k;
  854.         char *parm;
  855.  
  856.         if ( txindex != NULL )
  857.                 return;
  858.         /* create an array of indexes into txfreq, giving a sorted */
  859.         /* list of unique frequencies. */
  860.         txindex = (int *) alloc(sizeof(int) * 64 * 16);
  861.         for ( n=0; n<64; n++ ) {
  862.                 for ( k=0; k<16; k++ ) {
  863.                         int freq = txfreq[n*16+k];
  864.                         register int i, f;
  865.                         register int *p, *endp;
  866.  
  867.                         /* insertion sort, starting from top of already */
  868.                         /* sorted list, since the values we're inserting */
  869.                         /* are almost sorted already. */
  870.                         for ( i=txleng-1; i>=0; i-- ) {
  871.                                 if ( (f=txfreq[txindex[i]]) < freq )
  872.                                         break;
  873.                                 if ( f == freq )
  874.                                         goto dontadd;
  875.                         }
  876.                         i++;
  877.                         /* shift everything up one */
  878.                         p = &txindex[txleng];
  879.                         endp = &txindex[i];
  880.                         for ( ; p>endp; p-- )
  881.                                 *p = *(p-1);
  882.                         txindex[i] = 16*n+k;
  883.                         txleng++;
  884.                     dontadd: ;
  885.                 }
  886.         }
  887.         /* set the maximum value for the frequency parameters */
  888.         parm = "op#freq";
  889.         for ( n=1; n<=4; n++ ) {
  890.                 parm[2] = '0' + n;
  891.                 if ( (k=parmindex(parm)) >= 0 )
  892.                         P[k].p_max = txleng-1;
  893.         }
  894. }
  895.