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