home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume6 / glib / part03 / d10ton.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-05-14  |  7.1 KB  |  382 lines
  1. /* $Id: d10ton.c,v 1.6 89/05/06 17:13:16 lee Exp $
  2.  * GLIB - a Generic LIBrarian and editor for synths
  3.  *
  4.  * D10 Tone Librarian Common Functions
  5.  *
  6.  * Code started 3 FEB 89 --  Michael R. Kesti mrk@gvgspd.GVG.TEK.COM
  7.  * $Log:    d10ton.c,v $
  8.  * Revision 1.6  89/05/06  17:13:16  lee
  9.  * rel. to comp.sources.misc
  10.  * 
  11.  */
  12.  
  13. #include "glib.h"
  14.  
  15. #define D10TONSIZE 246
  16. #define TONBASEADDR 0x080000
  17. #define RESERVESIZE 20
  18.  
  19. /*
  20.  * dtonnum
  21.  *
  22.  * Convert a voice number (0 to 63) to the string displayed in the
  23.  * librarian (ie. 1 to 64).
  24.  */
  25.  
  26. char *
  27. dtonnum(n)
  28. {
  29.     static char v[3];
  30.  
  31.     if ( n < 0 || n > 63 )
  32.         return("??");
  33.  
  34.     v[0] = (n+1)/10 + '0';
  35.     v[1] = (n+1)%10 + '0';
  36.     v[2] = '\0';
  37.     return(v);
  38. }
  39.  
  40. /*
  41.  * dnumton
  42.  *
  43.  * Convert a display-style voice number (1 to 64) to internal
  44.  * format (0 to 63).
  45.  */
  46.  
  47. dnumton(n)
  48. int n;
  49. {
  50.     int ld, rd;
  51.     
  52.     /* crack out the digits as decimal codes */
  53.     ld = (n - 1) / 10; /* left digit */
  54.     rd = (n - 1) % 10; /* right digit */
  55.  
  56.     if(ld < 0 || ld > 6 || rd < 0 || rd > 9) {
  57.         return(-1);
  58.     } else {
  59.         return(n - 1);
  60.     }
  61. }
  62. /*
  63.  * dtonsedit
  64.  *
  65.  * Send a single voice to the edit buffer of the D10.  This will be whatever
  66.  * voice is currently selected.
  67.  */
  68.  
  69. dtonsedit(data)
  70. char *data;
  71. {
  72.     int n;
  73.     int cksum;
  74.     
  75.     sendmidi(0xf0);
  76.     sendmidi(0x41);
  77.     sendmidi(0x10);
  78.     sendmidi(0x16);
  79.     sendmidi(0x12);        /* DT1 - Data set 1 command */
  80.     sendmidi(0x04);        /* address msb */
  81.     cksum = 0x04;
  82.     sendmidi(0x00);
  83.     cksum += 0x00;
  84.     sendmidi(0x00);        /* address lsb */
  85.     cksum += 0x00;
  86.     for(n = 0; n < D10TONSIZE; n++) {
  87.         sendmidi(data[n + RESERVESIZE] & 0x7f);
  88.         cksum += data[n + RESERVESIZE] & 0x7f;
  89.     }
  90.     sendmidi((-cksum) & 0x7f);    /* checksum */
  91.     sendmidi(EOX);
  92. }
  93.  
  94. /*
  95.  * dtonnof
  96.  *
  97.  * Return a pointer to the voice name buried in library bank data.
  98.  */
  99. char *
  100. dtonnof(data)
  101. char *data;
  102. {
  103.     static char currbuff[11];
  104.     char *p;
  105.     int m;
  106.  
  107.     p = currbuff;
  108.     for ( m = 0 ; m < 10 ; m++ )
  109.         *p++ = data[m + RESERVESIZE];
  110.     *p = '\0';
  111.     return(currbuff);
  112. }
  113.  
  114. /*
  115.  * dtonsnof
  116.  *
  117.  * Set the voice name buried in data to name.
  118.  */
  119. dtonsnof(data,name)
  120. char *data;
  121. char *name;
  122. {
  123.     char *p;
  124.     int m;
  125.  
  126.     for ( p = name, m = 0 ; *p != '\0' && m < 10 ; p++, m++ )
  127.         data[m + RESERVESIZE] = *p;
  128.     for ( ; m < 10 ; m++ )
  129.         data[m + RESERVESIZE] = ' ';
  130. }
  131.  
  132. /* dtonsone - send a single voice to the D10 */
  133. dtonsone(iv, data)
  134. int iv;
  135. char *data;
  136. {
  137.     int n;
  138.     int cksum;
  139.     long curadd;
  140.     int addbyte;
  141.  
  142.     curadd = TONBASEADDR;
  143.  
  144.     for(n = 0; n < iv; n++) {
  145.         curadd += 0x200;
  146.         if((curadd & 0x8000) != 0) {
  147.             curadd &= 0x7f7f7f;
  148.             curadd += 0x10000;
  149.         }
  150.     }
  151.  
  152.     sendmidi(0xf0);
  153.     sendmidi(0x41);
  154.     sendmidi(0x10);
  155.     sendmidi(0x16);
  156.     sendmidi(0x12);        /* DT1 - Data set 1 command */
  157.     addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
  158.     sendmidi(addbyte);
  159.     cksum = addbyte;
  160.     addbyte = ((curadd >> 8) & 0x7f);
  161.     sendmidi(addbyte);
  162.     cksum += addbyte;
  163.     addbyte = (curadd & 0x7f);        /* address lsb */
  164.     sendmidi(addbyte);
  165.     cksum += addbyte;
  166.     for(n = 0; n < D10TONSIZE; n++) {
  167.         sendmidi(data[n + RESERVESIZE] & 0x7f);
  168.         cksum += data[n + RESERVESIZE] & 0x7f;
  169.     }
  170.     sendmidi((-cksum) & 0x7f);    /* checksum */
  171.     sendmidi(EOX);
  172.  
  173.     return(0);
  174. }
  175.  
  176. /* dtongbulk - Request and read a bulk dump from the D10 */
  177. dtongbulk(data)
  178. char *data;
  179. {
  180.     static    char Buff[BUFSIZ];
  181.     int c, n, v, b2, ret = 1;
  182.     long begin, toolong, wait;
  183.     long curadd;
  184.     int addbyte;
  185.     int cksum;
  186.     
  187.     sprintf(Buff,"\n");
  188.     windstr(Buff);
  189.     
  190.     curadd = TONBASEADDR;
  191.  
  192.     for(v = 0; v < Nvoices; v++) {
  193.  
  194.         flushmidi();
  195.  
  196.         if(v % 10 != 0) {
  197.             sprintf(Buff, ".");
  198.         } else {
  199.             sprintf(Buff,"%d", (v / 10));
  200.         }
  201.         windstr(Buff);
  202.  
  203.     /* request the voice */
  204.         sendmidi(0xf0);
  205.         sendmidi(0x41);
  206.         sendmidi(0x10);
  207.         sendmidi(0x16);
  208.         sendmidi(0x11);        /* RQ1 - Data request 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.         sendmidi(0x00);        /* length msb */
  221.         cksum += 0x00;
  222.         sendmidi(0x01);        /* should be D10TONSIZE */
  223.         cksum += 0x01;
  224.         sendmidi(0x76);        /* length lsb */
  225.         cksum += 0x76;
  226.  
  227.         sendmidi((-cksum) & 0x7f);    /* checksum */
  228.         sendmidi(EOX);
  229.     
  230.     /* set up timeout */
  231.         begin = milliclock();
  232.         toolong = begin + (1000 * TIMEOUT);
  233.     
  234.     /* read header */
  235.         for(n = 0; n < 8; ) {
  236.             if ( STATMIDI ) {
  237.                 b2 = (getmidi() & 0xff);
  238.                 /* burn active sensing and timing clock */
  239.                 if((b2 != 0xfe) && (b2 != 0xf8))
  240.                     n++;
  241.             } else {
  242.                 if ( milliclock() > toolong ) {
  243.                     Reason = "Timeout waiting for header";
  244.                     goto getout;
  245.                 }
  246.             }
  247.         }
  248.  
  249.     /* read data */
  250.         for(n = 0; n < D10TONSIZE; ) {
  251.             if ( STATMIDI ) {
  252.                 b2 = (getmidi() & 0xff);
  253.                 /* burn active sensing and timing clock */
  254.                 if((b2 != 0xfe) && (b2 != 0xf8)) {
  255.                     VOICEBYTE(data,v,n + RESERVESIZE) = b2;
  256.                     n++;
  257.                 }
  258.             } else {
  259.                 if ( milliclock() > toolong ) {
  260.                     Reason = "Timeout reading data";
  261.                     goto timeout;
  262.                 }
  263.             }
  264.         }
  265.  
  266.     timeout:
  267.         if ( n != D10TONSIZE ) {
  268.             Reason = "Timeout reading data!";
  269.             goto getout;
  270.         }
  271.  
  272.     /* read checksum */
  273.         for(n = 0; n < 1; ) {
  274.             if ( STATMIDI ) {
  275.                 b2 = (getmidi() & 0xff);
  276.                 /* burn active sensing and timing clock */
  277.                 if((b2 != 0xfe) && (b2 != 0xf8))
  278.                     n++;
  279.             } else {
  280.                 if ( milliclock() > toolong ) {
  281.                     Reason = "Timeout reading checksum";
  282.                     goto getout;
  283.                 }
  284.             }
  285.         }
  286.  
  287.     /* read EOX */
  288.         for(n = 0; n < 1; ) {
  289.             if ( STATMIDI ) {
  290.                 b2 = (getmidi() & 0xff);
  291.                 /* burn active sensing and timing clock */
  292.                 if((b2 != 0xfe) && (b2 != 0xf8))
  293.                     if ( b2 != EOX ) {
  294.                         sprintf(Buff,"EOX not received (%X)\n", b2);
  295.                         Reason = Buff;
  296.                         goto getout;
  297.                     }
  298.                     n++;
  299.             } else {
  300.                 if ( milliclock() > toolong ) {
  301.                     Reason = "Timeout reading EOX";
  302.                     goto getout;
  303.                 }
  304.             }
  305.         }
  306.         curadd += 0x200;        /* D10TONSIZE */
  307.  
  308.         if((curadd & 0x8000) != 0) {
  309.             curadd &= 0x7f7f7f;
  310.             curadd += 0x10000;
  311.         }
  312.  
  313.     } /* go back for another voice */
  314.  
  315.     Reason = "";
  316.     ret = 0;    /* all's well */
  317.  
  318. getout:
  319.     return(ret);
  320. }
  321.  
  322. /* dtonsbulk - send a bulk dump to the D10 */
  323. dtonsbulk(data)
  324. char *data;
  325. {
  326.     static char Buff[BUFSIZ];
  327.     int v, n;
  328.     int cksum;
  329.     long curadd;
  330.     int addbyte, databyte;
  331.     int curoff;
  332.  
  333.     curadd = TONBASEADDR;
  334.     curoff = 0;    
  335.     sprintf(Buff,"\nA: ");
  336.     windstr(Buff);
  337.  
  338.     for(v = 0; v <Nvoices ; v++) {
  339.         if(v == 64) {
  340.             sprintf(Buff,"\nB: ");
  341.             windstr(Buff);
  342.         }
  343.         if((((v > 63) ? (v - 64) : v) % 10) != 0) {
  344.             sprintf(Buff, ".");
  345.         } else {
  346.             sprintf(Buff,"%d", (((v > 63) ? (v - 64) : v) / 10));
  347.         }
  348.  
  349.         windstr(Buff);
  350.         sendmidi(0xf0);
  351.         sendmidi(0x41);
  352.         sendmidi(0x10);
  353.         sendmidi(0x16);
  354.         sendmidi(0x12);        /* DT1 - Data set 1 command */
  355.         addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
  356.         sendmidi(addbyte);
  357.         cksum = addbyte;
  358.         addbyte = ((curadd >> 8) & 0x7f);
  359.         sendmidi(addbyte);
  360.         cksum += addbyte;
  361.         addbyte = (curadd & 0x7f);        /* address lsb */
  362.         sendmidi(addbyte);
  363.         cksum += addbyte;
  364.  
  365.         for(n = 0; n < D10TONSIZE; n++) {
  366.             databyte = data[curoff + n + RESERVESIZE] & 0x7f;
  367.             sendmidi(databyte);
  368.             cksum += databyte;
  369.         }
  370.         sendmidi((-cksum) & 0x7f);    /* checksum */
  371.         sendmidi(EOX);
  372.  
  373.         curadd += 0x200;        /* D10TONSIZE */
  374.         if((curadd & 0x8000) != 0) {
  375.             curadd &= 0x7f7f7f;
  376.             curadd += 0x10000;
  377.         }
  378.         curoff += (D10TONSIZE + RESERVESIZE);
  379.     }
  380.     return(0);
  381. }
  382.