home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume6 / glib / part03 / d10rsu.mnu next >
Encoding:
Text File  |  1989-05-14  |  8.0 KB  |  453 lines
  1. /* $Id: d10rsu.mnu,v 1.6 89/05/06 17:13:15 lee Exp $
  2.  * GLIB - a Generic LIBrarian and editor for synths
  3.  *
  4.  * D10 Rhythm Setup Librarian
  5.  *
  6.  * Code started 1 FEB 89 --  Michael R. Kesti mrk@gvgspd.GVG.TEK.COM
  7.  * modified by Greg Lee
  8.  * $Log:    d10rsu.mnu,v $
  9.  * Revision 1.6  89/05/06  17:13:15  lee
  10.  * rel. to comp.sources.misc
  11.  * 
  12.  */
  13.  
  14. #include "glib.h"
  15. #include "vis.h"
  16.  
  17. #define D10RSUSIZE 4
  18. #define RSUBASEADDR 0x090000
  19. #define RESERVESIZE 20
  20.  
  21. char *visnum(), *visonoff();
  22.  
  23.  
  24. /* This array contains arbitrary screen labels */
  25. struct labelinfo Ldrsu[] = {
  26. #MENU
  27.  
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  
  35.                          Tone Select     %
  36.                          Level           %
  37.                          Pan             %
  38.                          Reverb Switch   %
  39.  
  40.  
  41.  
  42.  
  43.  
  44.  
  45.  
  46.  
  47.  
  48.  
  49.  
  50.  Press SPACE BAR to sound note %   at volume %   for duration %  on channel % .
  51. #END
  52. -1,-1,NULL
  53. };
  54.  
  55. struct paraminfo  Pdrsu[] =  {
  56. /*
  57. NAME        TYPE        POS    MAX    OFFSET    MASK    SHIFT    ADHOC
  58.  */
  59. #O tone        rtone        %%    127    0
  60. #O level    patchlevel    %%    100    1
  61. #O pan        pan        %%    14    2
  62. #O reverbsw    onoff        %%    1    3
  63. #O autopitch    num        %%    127    -60
  64. #O autovol    num        %%    127    -63
  65. #O autodur    num        %%    20    -5    *5
  66. #O autochan    num        %%    16    -1    *5
  67. NULL,NULL,-1,-1,-1,-1,visnum,0,0,0,0
  68. };
  69.  
  70. /*
  71.  * drsunum
  72.  *
  73.  * Convert a voice number (0 to 84) to the string displayed in the
  74.  * librarian (ie. 01 to 85).
  75.  */
  76.  
  77. char *
  78. drsunum(n)
  79. {
  80.     static char v[3];
  81.  
  82.     sprintf(v, "%02d", n + 1);
  83.     return(v);
  84. }
  85.  
  86. /*
  87.  * dnumrsu
  88.  *
  89.  * Convert a display-style voice number (01 to 85) to internal
  90.  * format (0 to 84).
  91.  */
  92.  
  93. dnumrsu(n)
  94. int n;
  95. {
  96.     return(n-1);
  97. }
  98.  
  99. /*
  100.  * drsudin
  101.  *
  102.  * Take library bank 'data' and stuff values in the P array, by using
  103.  * the setval function.
  104.  */
  105.  
  106. drsudin(data)
  107. char *data;
  108. {
  109.     /* The first RESERVESIZE bytes are reserved (arbitrarily) for the voice name */
  110. #SETVAL
  111. }
  112.  
  113. /*
  114.  * drsudout
  115.  *
  116.  * Take (possibly changed) parameters values out of the P array and
  117.  * put them back into the library bank 'data'.
  118.  */
  119.  
  120. drsudout(data)
  121. char *data;
  122. {
  123. #GETVAL
  124. }
  125.  
  126. /*
  127.  * drsusedit
  128.  *
  129.  * Send a single voice to the edit buffer of the D10.  This will be whatever
  130.  * voice is currently selected.
  131.  */
  132.  
  133. drsusedit(data)
  134. char *data;
  135. {
  136.     int n;
  137.     int cksum;
  138.     
  139.     sendmidi(0xf0);
  140.     sendmidi(0x41);
  141.     sendmidi(0x10);
  142.     sendmidi(0x16);
  143.     sendmidi(0x12);        /* DT1 - Data set 1 command */
  144.     sendmidi(0x03);        /* address msb */
  145.     cksum = 0x03;
  146.     sendmidi(0x01);
  147.     cksum += 0x01;
  148.     sendmidi(0x10);        /* address lsb */
  149.     cksum += 0x10;
  150.     for(n = 0; n < D10RSUSIZE; n++) {
  151.         sendmidi(data[n + RESERVESIZE] & 0x7f);
  152.         cksum += data[n + RESERVESIZE] & 0x7f;
  153.     }
  154.     sendmidi((-cksum) & 0x7f);    /* checksum */
  155.     sendmidi(EOX);
  156. }
  157.  
  158. /*
  159.  * drsunof
  160.  *
  161.  * Return a pointer to the voice name buried in library bank data.
  162.  */
  163. char *
  164. drsunof(data)
  165. char *data;
  166. {
  167.  
  168.     static char buf[4];
  169.     int n;
  170.  
  171.     for(n = 0; n < D10RSUSIZE; n++)
  172.         if ( data[n + RESERVESIZE] != 0 ) break;
  173.     if ( n != D10RSUSIZE ) {
  174.         strcpy(buf, visrtone(data[RESERVESIZE + 0]));
  175.     } else
  176.         strcpy(buf, "   ");
  177.  
  178.     return(buf);
  179. }
  180.  
  181. /*
  182.  * drsusnof
  183.  *
  184.  * Set the voice name buried in data to name.
  185.  */
  186. drsusnof(data,name)
  187. char *data;
  188. char *name;
  189. {
  190. }
  191.  
  192. /* drsusone - send a single voice to the D10 */
  193. drsusone(iv, data)
  194. int iv;
  195. char *data;
  196. {
  197.     int n;
  198.     int cksum;
  199.     long curadd;
  200.     int addbyte;
  201.  
  202.     curadd = RSUBASEADDR;
  203.  
  204.     for(n = 0; n < iv; n++) {
  205.         curadd += D10RSUSIZE;
  206.         if((curadd & 0x80) != 0) {
  207.             curadd &= 0x7fff7f;
  208.             curadd += 0x100;
  209.         }
  210.         if((curadd & 0x8000) != 0) {
  211.             curadd &= 0x7f7f7f;
  212.             curadd += 0x10000;
  213.         }
  214.     }
  215.  
  216.     sendmidi(0xf0);
  217.     sendmidi(0x41);
  218.     sendmidi(0x10);
  219.     sendmidi(0x16);
  220.     sendmidi(0x12);        /* DT1 - Data set 1 command */
  221.     addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
  222.     sendmidi(addbyte);
  223.     cksum = addbyte;
  224.     addbyte = ((curadd >> 8) & 0x7f);
  225.     sendmidi(addbyte);
  226.     cksum += addbyte;
  227.     addbyte = (curadd & 0x7f);        /* address lsb */
  228.     sendmidi(addbyte);
  229.     cksum += addbyte;
  230.     for(n = 0; n < D10RSUSIZE; n++) {
  231.         sendmidi(data[n + RESERVESIZE] & 0x7f);
  232.         cksum += data[n + RESERVESIZE] & 0x7f;
  233.     }
  234.     sendmidi((-cksum) & 0x7f);    /* checksum */
  235.     sendmidi(EOX);
  236.  
  237.     return(0);
  238. }
  239.  
  240. /* drsugbulk - Request and read a bulk dump from the D10 */
  241. drsugbulk(data)
  242. char *data;
  243. {
  244.     static    char Buff[BUFSIZ];
  245.     int n, v, b2, ret = 1;
  246.     long begin, toolong;
  247.     long curadd;
  248.     int addbyte;
  249.     int cksum;
  250.     
  251.     sprintf(Buff,"\n");
  252.     windstr(Buff);
  253.  
  254.     curadd = RSUBASEADDR;
  255.  
  256.     for(v = 0; v < Nvoices; v++) {
  257.  
  258.         flushmidi();
  259.  
  260.         if((v % 10) != 0) {
  261.             sprintf(Buff, ".");
  262.         } else {
  263.             sprintf(Buff,"%d", (v / 10));
  264.         }
  265.         windstr(Buff);
  266.  
  267.     /* request the voice */
  268.         sendmidi(0xf0);
  269.         sendmidi(0x41);
  270.         sendmidi(0x10);
  271.         sendmidi(0x16);
  272.         sendmidi(0x11);        /* RQ1 - Data request 1 command */
  273.  
  274.         addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
  275.         sendmidi(addbyte);
  276.         cksum = addbyte;
  277.         addbyte = ((curadd >> 8) & 0x7f);
  278.         sendmidi(addbyte);
  279.         cksum += addbyte;
  280.         addbyte = (curadd & 0x7f);        /* address lsb */
  281.         sendmidi(addbyte);
  282.         cksum += addbyte;
  283.  
  284.         sendmidi(0x00);        /* length msb */
  285.         cksum += 0x00;
  286.         sendmidi(0x00);
  287.         cksum += 0x00;
  288.         sendmidi(D10RSUSIZE);    /* length lsb */
  289.         cksum += D10RSUSIZE;
  290.  
  291.         sendmidi((-cksum) & 0x7f);    /* checksum */
  292.         sendmidi(EOX);
  293.     
  294.     /* set up timeout */
  295.         begin = milliclock();
  296.         toolong = begin + (1000 * TIMEOUT);
  297.     
  298.     /* read header */
  299.         for(n = 0; n < 8; ) {
  300.             if ( STATMIDI ) {
  301.                 b2 = (getmidi() & 0xff);
  302.                 /* burn active sensing and timing clock */
  303.                 if((b2 != 0xfe) && (b2 != 0xf8))
  304.                     n++;
  305.             } else {
  306.                 if ( milliclock() > toolong ) {
  307.                     Reason = "Timeout waiting for header";
  308.                     goto getout;
  309.                 }
  310.             }
  311.         }
  312.  
  313.     /* read data */
  314.         for(n = 0; n < D10RSUSIZE; ) {
  315.             if ( STATMIDI ) {
  316.                 b2 = (getmidi() & 0xff);
  317.                 /* burn active sensing and timing clock */
  318.                 if((b2 != 0xfe) && (b2 != 0xf8)) {
  319.                     VOICEBYTE(data,v,n + RESERVESIZE) = b2;
  320.                     n++;
  321.                 }
  322.             } else {
  323.                 if ( milliclock() > toolong ) {
  324.                     Reason = "Timeout reading data";
  325.                     goto timeout;
  326.                 }
  327.             }
  328.         }
  329.  
  330.     timeout:
  331.         if ( n != D10RSUSIZE ) {
  332.             Reason = "Timeout reading data!";
  333.             goto getout;
  334.         }
  335.  
  336.     /* read checksum */
  337.         for(n = 0; n < 1; ) {
  338.             if ( STATMIDI ) {
  339.                 b2 = (getmidi() & 0xff);
  340.                 /* burn active sensing and timing clock */
  341.                 if((b2 != 0xfe) && (b2 != 0xf8))
  342.                     n++;
  343.             } else {
  344.                 if ( milliclock() > toolong ) {
  345.                     Reason = "Timeout reading checksum";
  346.                     goto getout;
  347.                 }
  348.             }
  349.         }
  350.  
  351.     /* read EOX */
  352.         for(n = 0; n < 1; ) {
  353.             if ( STATMIDI ) {
  354.                 b2 = (getmidi() & 0xff);
  355.                 /* burn active sensing and timing clock */
  356.                 if((b2 != 0xfe) && (b2 != 0xf8))
  357.                     if ( b2 != EOX ) {
  358.                         sprintf(Buff,"EOX not received (%X)\n", b2);
  359.                         Reason = Buff;
  360.                         goto getout;
  361.                     }
  362.                     n++;
  363.             } else {
  364.                 if ( milliclock() > toolong ) {
  365.                     Reason = "Timeout reading EOX";
  366.                     goto getout;
  367.                 }
  368.             }
  369.         }
  370.  
  371.         curadd += D10RSUSIZE;
  372.         if((curadd & 0x80) != 0) {
  373.             curadd &= 0x7fff7f;
  374.             curadd += 0x100;
  375.         }
  376.         if((curadd & 0x8000) != 0) {
  377.             curadd &= 0x7f7f7f;
  378.             curadd += 0x10000;
  379.         }
  380.  
  381.  
  382.     } /* go back for another voice */
  383.  
  384.     Reason = "";
  385.     ret = 0;    /* all's well */
  386.  
  387. getout:
  388.     return(ret);
  389. }
  390.  
  391. /* drsusbulk - send a bulk dump to the D10 */
  392. drsusbulk(data)
  393. char *data;
  394. {
  395.     static char Buff[BUFSIZ];
  396.     int v, n;
  397.     int cksum;
  398.     long curadd;
  399.     int addbyte, databyte;
  400.     int curoff;
  401.  
  402.     curadd = RSUBASEADDR;
  403.     curoff = 0;    
  404.     sprintf(Buff,"\n");
  405.     windstr(Buff);
  406.  
  407.     for(v = 0; v <Nvoices ; v++) {
  408.         if((v % 10) != 0) {
  409.             sprintf(Buff, ".");
  410.         } else {
  411.             sprintf(Buff,"%d", (v / 10));
  412.         }
  413.  
  414.         windstr(Buff);
  415.         sendmidi(0xf0);
  416.         sendmidi(0x41);
  417.         sendmidi(0x10);
  418.         sendmidi(0x16);
  419.         sendmidi(0x12);        /* DT1 - Data set 1 command */
  420.         addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
  421.         sendmidi(addbyte);
  422.         cksum = addbyte;
  423.         addbyte = ((curadd >> 8) & 0x7f);
  424.         sendmidi(addbyte);
  425.         cksum += addbyte;
  426.         addbyte = (curadd & 0x7f);        /* address lsb */
  427.         sendmidi(addbyte);
  428.         cksum += addbyte;
  429.  
  430.         for(n = 0; n < D10RSUSIZE; n++) {
  431.             databyte = data[curoff + n + RESERVESIZE] & 0x7f;
  432.             sendmidi(databyte);
  433.             cksum += databyte;
  434.         }
  435.         sendmidi((-cksum) & 0x7f);    /* checksum */
  436.         sendmidi(EOX);
  437.  
  438.         curadd += D10RSUSIZE;
  439.         if((curadd & 0x80) != 0) {
  440.             curadd &= 0x7fff7f;
  441.             curadd += 0x100;
  442.         }
  443.         if((curadd & 0x8000) != 0) {
  444.             curadd &= 0x7f7f7f;
  445.             curadd += 0x10000;
  446.         }
  447.         curoff += (D10RSUSIZE + RESERVESIZE);
  448.     }
  449.     return(0);
  450. }
  451.  
  452. /* end */
  453.