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