home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume6 / glib / part07 / d10urp.mnu < prev    next >
Encoding:
Text File  |  1989-05-14  |  13.2 KB  |  711 lines
  1. /* $Id: d10urp.mnu,v 1.6 89/05/06 17:13:19 lee Exp $
  2.  * GLIB - a Generic LIBrarian and editor for synths
  3.  *
  4.  * D10 User Rhythm Pattern Librarian
  5.  *
  6.  * Code started 31 JAN 89 --  Michael R. Kesti mrk@gvgspd.GVG.TEK.COM
  7.  * modified by Greg Lee
  8.  * 
  9.  */
  10.  
  11. #include "glib.h"
  12. #include "vis.h"
  13.  
  14. #define D10URPSIZE 588
  15. #define URPBASEADDR 0x0a0000
  16. #define RESERVESIZE 20
  17.  
  18. char *visnum(), *visonoff();
  19.  
  20.  
  21. /* This array contains arbitrary screen labels */
  22. struct labelinfo Ldurp[] = {
  23. #MENU
  24.  
  25.  
  26.  
  27.  
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  
  35.  
  36.                No User Rhythm Pattern editing is supported.
  37.  
  38.  
  39.  
  40.  
  41.  
  42.  
  43.  
  44.  
  45.  
  46.  
  47.  Press SPACE BAR to sound note %   at volume %   for duration %  on channel % .
  48. #END
  49. -1,-1,NULL
  50. };
  51.  
  52. struct paraminfo  Pdurp[] =  {
  53. /*
  54. NAME        TYPE        POS    MAX    OFFSET    MASK    SHIFT    ADHOC
  55.  */
  56. #O autopitch    num        %%    127    -60
  57. #O autovol    num        %%    127    -63
  58. #O autodur    num        %%    20    -5    *5
  59. #O autochan    num        %%    16    -1    *5
  60. NULL,NULL,-1,-1,-1,-1,visnum,0,0,0,0
  61. };
  62.  
  63.  
  64. /*
  65.  * durpnum
  66.  *
  67.  * Convert a voice number (0 to 31) to the string displayed in the
  68.  * librarian (ie. 51 to 88).
  69.  */
  70.  
  71. char *
  72. durpnum(n)
  73. {
  74.     static char v[3];
  75.  
  76.     if ( n < 0 || n > 31 )
  77.         return("??");
  78.  
  79.     v[0] = n/8 + '5';
  80.     v[1] = n%8 + '1';
  81.     v[2] = '\0';
  82.     return(v);
  83. }
  84.  
  85. /*
  86.  * dnumurp
  87.  *
  88.  * Convert a display-style voice number (55 to 88) to internal
  89.  * format (0 to 31).
  90.  */
  91.  
  92. dnumurp(n)
  93. int n;
  94. {
  95.     int ld, rd;
  96.     
  97.     /* crack out the digits as octal codes */
  98.     ld = (n / 10) - 1; /* middle digit */
  99.     rd = (n % 10) - 1; /* right digit */
  100.  
  101.     if(ld < 4 || ld > 7 || rd < 0 || rd > 7) {
  102.         return(-1);
  103.     } else {
  104.         return(((ld - 4) * 8) + rd); /* combine as octal */
  105.     }
  106. }
  107.  
  108. /*
  109.  * durpdin
  110.  *
  111.  * Take library bank 'data' and stuff values in the P array, by using
  112.  * the setval function.
  113.  */
  114.  
  115. durpdin(data)
  116. char *data;
  117. {
  118.     /* The first RESERVESIZE bytes are reserved (arbitrarily) for the voice name */
  119. }
  120.  
  121. /*
  122.  * durpdout
  123.  *
  124.  * Take (possibly changed) parameters values out of the P array and
  125.  * put them back into the library bank 'data'.
  126.  */
  127.  
  128. durpdout(data)
  129. char *data;
  130. {
  131. }
  132.  
  133. /*
  134.  * durpsedit
  135.  *
  136.  * Send a single voice to the edit buffer of the D10.  This will be whatever
  137.  * voice is currently selected.
  138.  */
  139.  
  140. durpsedit(data)
  141. char *data;
  142. {
  143. }
  144.  
  145. /*
  146.  * durpnof
  147.  *
  148.  * Return a pointer to the voice name buried in library bank data.
  149.  */
  150. char *
  151. durpnof(data)
  152. char *data;
  153. {
  154.     static char buf[10];
  155.     int n, v;
  156.  
  157.     for(n = 0; n < D10URPSIZE; n++)
  158.         if ( data[n + RESERVESIZE] != 0 ) break;
  159.     if ( n != D10URPSIZE ) {
  160.         v = data[RESERVESIZE + 2] + (16 * data[RESERVESIZE + 3]);
  161.         sprintf(buf, "%2d events", v);
  162.     }
  163.     else
  164.         strcpy(buf, "         ");
  165.     return(buf);
  166. }
  167.  
  168. /*
  169.  * durpsnof
  170.  *
  171.  * Set the voice name buried in data to name.
  172.  */
  173. durpsnof(data,name)
  174. char *data;
  175. char *name;
  176. {
  177. }
  178.  
  179. /* durpsone - send a single voice to the D10 */
  180. durpsone(iv, data)
  181. int iv;
  182. char *data;
  183. {
  184.     int n;
  185.     int cksum;
  186.     long curadd;
  187.     int addbyte;
  188.  
  189.     curadd = URPBASEADDR;
  190.  
  191.     for(n = 0; n < iv; n++) {
  192.         curadd += 0x44c;    /* D10URPSIZE */
  193.  
  194.         if((curadd & 0x80) != 0) {
  195.             curadd &= 0x7fff7f;
  196.             curadd += 0x100;
  197.         }
  198.         if((curadd & 0x8000) != 0) {
  199.             curadd &= 0x7f7f7f;
  200.             curadd += 0x10000;
  201.         }
  202.     }
  203.  
  204.     sendmidi(0xf0);
  205.     sendmidi(0x41);
  206.     sendmidi(0x10);
  207.     sendmidi(0x16);
  208.     sendmidi(0x12);        /* DT1 - Data set 1 command */
  209.  
  210.     addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
  211.     sendmidi(addbyte);
  212.     cksum = addbyte;
  213.     addbyte = ((curadd >> 8) & 0x7f);
  214.     sendmidi(addbyte);
  215.     cksum += addbyte;
  216.     addbyte = (curadd & 0x7f);        /* address lsb */
  217.     sendmidi(addbyte);
  218.     cksum += addbyte;
  219.  
  220.     for(n = 0; n < 256; n++) {
  221.         sendmidi(data[n + RESERVESIZE] & 0x7f);
  222.         cksum += data[n + RESERVESIZE] & 0x7f;
  223.     }
  224.     sendmidi((-cksum) & 0x7f);    /* checksum */
  225.     sendmidi(EOX);
  226.  
  227.     curadd += 256;
  228.  
  229.     if((curadd & 0x8000) != 0) {
  230.         curadd &= 0x7f7f7f;
  231.         curadd += 0x10000;
  232.     }
  233.     sendmidi(0xf0);
  234.     sendmidi(0x41);
  235.     sendmidi(0x10);
  236.     sendmidi(0x16);
  237.     sendmidi(0x12);        /* DT1 - Data set 1 command */
  238.  
  239.     addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
  240.     sendmidi(addbyte);
  241.     cksum = addbyte;
  242.     addbyte = ((curadd >> 8) & 0x7f);
  243.     sendmidi(addbyte);
  244.     cksum += addbyte;
  245.     addbyte = (curadd & 0x7f);        /* address lsb */
  246.     sendmidi(addbyte);
  247.     cksum += addbyte;
  248.  
  249.     for(n = 256; n < 512; n++) {
  250.         sendmidi(data[n + RESERVESIZE] & 0x7f);
  251.         cksum += data[n + RESERVESIZE] & 0x7f;
  252.     }
  253.     sendmidi((-cksum) & 0x7f);    /* checksum */
  254.     sendmidi(EOX);
  255.  
  256.  
  257.     curadd += 256;
  258.  
  259.     if((curadd & 0x8000) != 0) {
  260.         curadd &= 0x7f7f7f;
  261.         curadd += 0x10000;
  262.     }
  263.  
  264.     sendmidi(0xf0);
  265.     sendmidi(0x41);
  266.     sendmidi(0x10);
  267.     sendmidi(0x16);
  268.     sendmidi(0x12);        /* DT1 - Data set 1 command */
  269.  
  270.     addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
  271.     sendmidi(addbyte);
  272.     cksum = addbyte;
  273.     addbyte = ((curadd >> 8) & 0x7f);
  274.     sendmidi(addbyte);
  275.     cksum += addbyte;
  276.     addbyte = (curadd & 0x7f);        /* address lsb */
  277.     sendmidi(addbyte);
  278.     cksum += addbyte;
  279.  
  280.     for(n = 512; n < (D10URPSIZE - 512); n++) {
  281.         sendmidi(data[n + RESERVESIZE] & 0x7f);
  282.         cksum += data[n + RESERVESIZE] & 0x7f;
  283.     }
  284.     sendmidi((-cksum) & 0x7f);    /* checksum */
  285.     sendmidi(EOX);
  286.  
  287.     return(0);
  288. }
  289.  
  290. /* durpgbulk - Request and read a bulk dump from the D10 */
  291. durpgbulk(data)
  292. char *data;
  293. {
  294.     static    char Buff[BUFSIZ];
  295.     int n, v, b2, ret = 1;
  296.     long begin, toolong;
  297.     long curadd;
  298.     int addbyte;
  299.     int cksum;
  300.     
  301.     sprintf(Buff,"\n");
  302.     windstr(Buff);
  303.     
  304.     curadd = URPBASEADDR;
  305.  
  306.     for(v = 0; v < Nvoices; v++) {
  307.  
  308.         flushmidi();
  309.  
  310.         if(v % 10 != 0) {
  311.             sprintf(Buff, ".");
  312.         } else {
  313.             sprintf(Buff,"%d", (v / 10));
  314.         }
  315.         windstr(Buff);
  316.  
  317.     /* request the voice */
  318.         sendmidi(0xf0);
  319.         sendmidi(0x41);
  320.         sendmidi(0x10);
  321.         sendmidi(0x16);
  322.         sendmidi(0x11);        /* RQ1 - Data request 1 command */
  323.  
  324.         addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
  325.         sendmidi(addbyte);
  326.         cksum = addbyte;
  327.         addbyte = ((curadd >> 8) & 0x7f);
  328.         sendmidi(addbyte);
  329.         cksum += addbyte;
  330.         addbyte = (curadd & 0x7f);        /* address lsb */
  331.         sendmidi(addbyte);
  332.         cksum += addbyte;
  333.  
  334.         sendmidi(0x00);        /* length msb */
  335.         cksum += 0x00;
  336.         sendmidi(0x04);        /* should be D10URPSIZE */
  337.         cksum += 0x04;
  338.         sendmidi(0x4c);        /* length lsb */
  339.         cksum += 0x4c;
  340.  
  341.         sendmidi((-cksum) & 0x7f);    /* checksum */
  342.         sendmidi(EOX);
  343.     
  344.     /* set up timeout */
  345.         begin = milliclock();
  346.         toolong = begin + (1000 * TIMEOUT);
  347.  
  348.     /* read header */
  349.         for(n = 0; n < 8; ) {
  350.             if ( STATMIDI ) {
  351.                 b2 = (getmidi() & 0xff);
  352.                 /* burn active sensing and timing clock */
  353.                 if((b2 != 0xfe) && (b2 != 0xf8))
  354.                     n++;
  355.             } else {
  356.                 if ( milliclock() > toolong ) {
  357.                     Reason = "Timeout waiting for header";
  358.                     goto getout;
  359.                 }
  360.             }
  361.         }
  362.  
  363.     /* read data */
  364.         for(n = 0; n < 256; ) {
  365.             if ( STATMIDI ) {
  366.                 b2 = (getmidi() & 0xff);
  367.                 /* burn active sensing and timing clock */
  368.                 if((b2 != 0xfe) && (b2 != 0xf8)) {
  369.                     VOICEBYTE(data,v,n + RESERVESIZE) = b2;
  370.                     n++;
  371.                 }
  372.             } else {
  373.                 if ( milliclock() > toolong ) {
  374.                     Reason = "Timeout reading data";
  375.                     goto timeout0;
  376.                 }
  377.             }
  378.         }
  379.  
  380.     timeout0:
  381.         if ( n != 256 ) {
  382.             Reason = "Timeout reading data!";
  383.             goto getout;
  384.         }
  385.  
  386.     /* read checksum */
  387.         for(n = 0; n < 1; ) {
  388.             if ( STATMIDI ) {
  389.                 b2 = (getmidi() & 0xff);
  390.                 /* burn active sensing and timing clock */
  391.                 if((b2 != 0xfe) && (b2 != 0xf8))
  392.                     n++;
  393.             } else {
  394.                 if ( milliclock() > toolong ) {
  395.                     Reason = "Timeout reading checksum";
  396.                     goto getout;
  397.                 }
  398.             }
  399.         }
  400.  
  401.     /* read EOX */
  402.         for(n = 0; n < 1; ) {
  403.             if ( STATMIDI ) {
  404.                 b2 = (getmidi() & 0xff);
  405.                 /* burn active sensing and timing clock */
  406.                 if((b2 != 0xfe) && (b2 != 0xf8))
  407.                     if ( b2 != EOX ) {
  408.                         sprintf(Buff,"EOX not received (%X)\n", b2);
  409.                         Reason = Buff;
  410.                         goto getout;
  411.                     }
  412.                     n++;
  413.             } else {
  414.                 if ( milliclock() > toolong ) {
  415.                     Reason = "Timeout reading EOX";
  416.                     goto getout;
  417.                 }
  418.             }
  419.         }
  420.  
  421.     /* read header */
  422.         for(n = 0; n < 8; ) {
  423.             if ( STATMIDI ) {
  424.                 b2 = (getmidi() & 0xff);
  425.                 /* burn active sensing and timing clock */
  426.                 if((b2 != 0xfe) && (b2 != 0xf8))
  427.                     n++;
  428.             } else {
  429.                 if ( milliclock() > toolong ) {
  430.                     Reason = "Timeout waiting for header";
  431.                     goto getout;
  432.                 }
  433.             }
  434.         }
  435.  
  436.     /* read data */
  437.         for(n = 0; n < 256; ) {
  438.             if ( STATMIDI ) {
  439.                 b2 = (getmidi() & 0xff);
  440.                 /* burn active sensing and timing clock */
  441.                 if((b2 != 0xfe) && (b2 != 0xf8)) {
  442.                     VOICEBYTE(data,v,n + RESERVESIZE + 256) = b2;
  443.                     n++;
  444.                 }
  445.             } else {
  446.                 if ( milliclock() > toolong ) {
  447.                     Reason = "Timeout reading data";
  448.                     goto timeout1;
  449.                 }
  450.             }
  451.         }
  452.  
  453.     timeout1:
  454.         if ( n != 256 ) {
  455.             Reason = "Timeout reading data!";
  456.             goto getout;
  457.         }
  458.  
  459.     /* read checksum */
  460.         for(n = 0; n < 1; ) {
  461.             if ( STATMIDI ) {
  462.                 b2 = (getmidi() & 0xff);
  463.                 /* burn active sensing and timing clock */
  464.                 if((b2 != 0xfe) && (b2 != 0xf8))
  465.                     n++;
  466.             } else {
  467.                 if ( milliclock() > toolong ) {
  468.                     Reason = "Timeout reading checksum";
  469.                     goto getout;
  470.                 }
  471.             }
  472.         }
  473.  
  474.     /* read EOX */
  475.         for(n = 0; n < 1; ) {
  476.             if ( STATMIDI ) {
  477.                 b2 = (getmidi() & 0xff);
  478.                 /* burn active sensing and timing clock */
  479.                 if((b2 != 0xfe) && (b2 != 0xf8))
  480.                     if ( b2 != EOX ) {
  481.                         sprintf(Buff,"EOX not received (%X)\n", b2);
  482.                         Reason = Buff;
  483.                         goto getout;
  484.                     }
  485.                     n++;
  486.             } else {
  487.                 if ( milliclock() > toolong ) {
  488.                     Reason = "Timeout reading EOX";
  489.                     goto getout;
  490.                 }
  491.             }
  492.         }
  493.  
  494.     /* read header */
  495.         for(n = 0; n < 8; ) {
  496.             if ( STATMIDI ) {
  497.                 b2 = (getmidi() & 0xff);
  498.                 /* burn active sensing and timing clock */
  499.                 if((b2 != 0xfe) && (b2 != 0xf8))
  500.                     n++;
  501.             } else {
  502.                 if ( milliclock() > toolong ) {
  503.                     Reason = "Timeout waiting for header";
  504.                     goto getout;
  505.                 }
  506.             }
  507.         }
  508.  
  509.     /* read data */
  510.         for(n = 0; n < 76; ) {
  511.             if ( STATMIDI ) {
  512.                 b2 = (getmidi() & 0xff);
  513.                 /* burn active sensing and timing clock */
  514.                 if((b2 != 0xfe) && (b2 != 0xf8)) {
  515.                     VOICEBYTE(data,v,n + RESERVESIZE + 512) = b2;
  516.                     n++;
  517.                 }
  518.             } else {
  519.                 if ( milliclock() > toolong ) {
  520.                     Reason = "Timeout reading data";
  521.                     goto timeout2;
  522.                 }
  523.             }
  524.         }
  525.  
  526.     timeout2:
  527.         if ( n != 76 ) {
  528.             Reason = "Timeout reading data!";
  529.             goto getout;
  530.         }
  531.  
  532.     /* read checksum */
  533.         for(n = 0; n < 1; ) {
  534.             if ( STATMIDI ) {
  535.                 b2 = (getmidi() & 0xff);
  536.                 /* burn active sensing and timing clock */
  537.                 if((b2 != 0xfe) && (b2 != 0xf8))
  538.                     n++;
  539.             } else {
  540.                 if ( milliclock() > toolong ) {
  541.                     Reason = "Timeout reading checksum";
  542.                     goto getout;
  543.                 }
  544.             }
  545.         }
  546.  
  547.     /* read EOX */
  548.         for(n = 0; n < 1; ) {
  549.             if ( STATMIDI ) {
  550.                 b2 = (getmidi() & 0xff);
  551.                 /* burn active sensing and timing clock */
  552.                 if((b2 != 0xfe) && (b2 != 0xf8))
  553.                     if ( b2 != EOX ) {
  554.                         sprintf(Buff,"EOX not received (%X)\n", b2);
  555.                         Reason = Buff;
  556.                         goto getout;
  557.                     }
  558.                     n++;
  559.             } else {
  560.                 if ( milliclock() > toolong ) {
  561.                     Reason = "Timeout reading EOX";
  562.                     goto getout;
  563.                 }
  564.             }
  565.         }
  566.  
  567.         curadd += 0x44c;        /* D10URPSIZE */
  568.  
  569.         if((curadd & 0x80) != 0) {
  570.             curadd &= 0x7fff7f;
  571.             curadd += 0x100;
  572.         }
  573.         if((curadd & 0x8000) != 0) {
  574.             curadd &= 0x7f7f7f;
  575.             curadd += 0x10000;
  576.         }
  577.  
  578.     } /* go back for another voice */
  579.  
  580.     Reason = "";
  581.     ret = 0;    /* all's well */
  582.  
  583. getout:
  584.     return(ret);
  585. }
  586.  
  587. /* durpsbulk - send a bulk dump to the D10 */
  588. durpsbulk(data)
  589. char *data;
  590. {
  591.     static char Buff[BUFSIZ];
  592.     int v, n;
  593.     int cksum;
  594.     long curadd, intadd;
  595.     int addbyte, databyte;
  596.     int curoff;
  597.  
  598.     curadd = URPBASEADDR;
  599.     curoff = 0;    
  600.     sprintf(Buff,"\n");
  601.     windstr(Buff);
  602.  
  603.     for(v = 0; v <Nvoices ; v++) {
  604.         if((((v > 63) ? (v - 64) : v) % 10) != 0) {
  605.             sprintf(Buff, ".");
  606.         } else {
  607.             sprintf(Buff,"%d", (((v > 63) ? (v - 64) : v) / 10));
  608.         }
  609.  
  610.         windstr(Buff);
  611.  
  612.         sendmidi(0xf0);
  613.         sendmidi(0x41);
  614.         sendmidi(0x10);
  615.         sendmidi(0x16);
  616.         sendmidi(0x12);        /* DT1 - Data set 1 command */
  617.         addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
  618.         sendmidi(addbyte);
  619.         cksum = addbyte;
  620.         addbyte = ((curadd >> 8) & 0x7f);
  621.         sendmidi(addbyte);
  622.         cksum += addbyte;
  623.         addbyte = (curadd & 0x7f);        /* address lsb */
  624.         sendmidi(addbyte);
  625.         cksum += addbyte;
  626.  
  627.         for(n = 0; n < 256; n++) {
  628.             databyte = data[curoff + n + RESERVESIZE] & 0x7f;
  629.             sendmidi(databyte);
  630.             cksum += databyte;
  631.         }
  632.         sendmidi((-cksum) & 0x7f);    /* checksum */
  633.         sendmidi(EOX);
  634.  
  635.         intadd = curadd + 256;
  636.  
  637.         if((intadd & 0x8000) != 0) {
  638.             intadd &= 0x7f7f7f;
  639.             intadd += 0x10000;
  640.         }
  641.  
  642.         sendmidi(0xf0);
  643.         sendmidi(0x41);
  644.         sendmidi(0x10);
  645.         sendmidi(0x16);
  646.         sendmidi(0x12);        /* DT1 - Data set 1 command */
  647.         addbyte = ((intadd >> 16) & 0x7f);    /* address msb */
  648.         sendmidi(addbyte);
  649.         cksum = addbyte;
  650.         addbyte = ((intadd >> 8) & 0x7f);
  651.         sendmidi(addbyte);
  652.         cksum += addbyte;
  653.         addbyte = (intadd & 0x7f);        /* address lsb */
  654.         sendmidi(addbyte);
  655.         cksum += addbyte;
  656.  
  657.         for(n = 256; n < 512; n++) {
  658.             databyte = data[curoff + n + RESERVESIZE] & 0x7f;
  659.             sendmidi(databyte);
  660.             cksum += databyte;
  661.         }
  662.         sendmidi((-cksum) & 0x7f);    /* checksum */
  663.         sendmidi(EOX);
  664.  
  665.         intadd += 256;
  666.  
  667.         if((intadd & 0x8000) != 0) {
  668.             intadd &= 0x7f7f7f;
  669.             intadd += 0x10000;
  670.         }
  671.  
  672.         sendmidi(0xf0);
  673.         sendmidi(0x41);
  674.         sendmidi(0x10);
  675.         sendmidi(0x16);
  676.         sendmidi(0x12);        /* DT1 - Data set 1 command */
  677.         addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
  678.         sendmidi(addbyte);
  679.         cksum = addbyte;
  680.         addbyte = ((curadd >> 8) & 0x7f);
  681.         sendmidi(addbyte);
  682.         cksum += addbyte;
  683.         addbyte = (curadd & 0x7f);        /* address lsb */
  684.         sendmidi(addbyte);
  685.         cksum += addbyte;
  686.  
  687.         for(n = 512; n < (D10URPSIZE - 512); n++) {
  688.             databyte = data[curoff + n + RESERVESIZE] & 0x7f;
  689.             sendmidi(databyte);
  690.             cksum += databyte;
  691.         }
  692.         sendmidi((-cksum) & 0x7f);    /* checksum */
  693.         sendmidi(EOX);
  694.  
  695.         curadd += 0x44c;        /* D10URPSIZE */
  696.  
  697.         if((curadd & 0x80) != 0) {
  698.             curadd &= 0x7fff7f;
  699.             curadd += 0x100;
  700.         }
  701.         if((curadd & 0x8000) != 0) {
  702.             curadd &= 0x7f7f7f;
  703.             curadd += 0x10000;
  704.         }
  705.         curoff += (D10URPSIZE + RESERVESIZE);
  706.     }
  707.     return(0);
  708. }
  709.  
  710. /* end */
  711.