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