home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Sound / MidI / SYNTHLIB.LHA / Synth_Librarian / sources / Electone / Electone.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-23  |  9.1 KB  |  368 lines
  1. #include <proto/exec.h>
  2. #include <stdlib.h>
  3. #include <math.h>
  4. #include <string.h>
  5. #include <stdio.h>
  6.  
  7. #include "SynthLib.h"
  8. #include <libraries/locale.h>
  9. #include <proto/locale.h>
  10. #define CATCOMP_BLOCK
  11. #define CATCOMP_NUMBERS
  12. #include "ElectoneLoc.h"
  13.  
  14. #define BUFFER_SIZE         40000L
  15.  
  16. struct LocaleInfo DLi;
  17. #ifndef DEBUG_SL
  18. struct Library * LocaleBase;
  19. struct DosBase *DOSBase;
  20. struct ExecBase *SysBase;
  21. #endif
  22.  
  23. char Message[256];
  24. char ModelID=0x70;
  25. unsigned char ElecHeader[]={0xF0,0x43,0x70,0x00,0x00,0xF7};
  26. unsigned char AnswerElec[5];
  27.  
  28. #define STEPD_SEND_BLOCK 1
  29. #define STEPD_SEND_END 2
  30. #define STEPD_WAIT_SYSEX 3
  31. #define STEPD_WAIT_YAMAHA 4
  32. #define STEPD_CHECK_YAMAHA 5
  33. #define STEPD_GET_BLOCK 6
  34. #define STEPD_SEND_WAIT_ANSWER 7
  35. #define STEPD_SEND_GET_ANSWER 8
  36. static struct DriverData DD;
  37. extern struct MinList ElectoneTypesList;
  38. struct Node ElectoneTypesNodes[] = {
  39.         &ElectoneTypesNodes[1], ( struct Node * )&ElectoneTypesList.mlh_Head, 0, 0, "Elec All",
  40.         &ElectoneTypesNodes[2], &ElectoneTypesNodes[0], 0, 0, "Elec presets",
  41.         &ElectoneTypesNodes[3], &ElectoneTypesNodes[1], 0, 0, "Elec CSP/RSP",
  42.         &ElectoneTypesNodes[4], &ElectoneTypesNodes[2], 0, 0, "Elec FMP",
  43.         &ElectoneTypesNodes[5], &ElectoneTypesNodes[3], 0, 0, "Elec rythms",
  44.         &ElectoneTypesNodes[6], &ElectoneTypesNodes[4], 0, 0, "Elec arpegios",
  45.         ( struct Node * )&ElectoneTypesList.mlh_Tail, &ElectoneTypesNodes[5], 0, 0, "Elec voices" };
  46.  
  47.  
  48. struct MinList ElectoneTypesList = {
  49.         ( struct MinNode * )&ElectoneTypesNodes[0], ( struct MinNode * )NULL, ( struct MinNode * )&ElectoneTypesNodes[6] };
  50.  
  51. struct DriverData * InitDriver(ULONG (*GetData)(ULONG Number));
  52. void Close(void);
  53. STRPTR GetStringD(struct LocaleInfo *li, LONG stringNum);
  54. ULONG Driver(ULONG *StepPtr,struct Exchange *Ex);
  55. STRPTR About(void);
  56. UBYTE FindType(STRPTR TypeStr);
  57.  
  58. __saveds struct DriverData *InitDriver(ULONG (*GetData)(ULONG Number))
  59.  {
  60. #ifndef DEBUG_SL
  61.   DOSBase=(struct DosBase *)GetData(GTD_DosBase);
  62.   SysBase=(struct ExecBase *)GetData(GTD_ExecBase);
  63.   LocaleBase=(struct LocaleBase *)GetData(GTD_LocaleBase);
  64. #endif
  65.  
  66.   if (DLi.li_LocaleBase=LocaleBase)
  67.     DLi.li_Catalog=OpenCatalog(NULL,"SynthLib/Electone.catalog",OC_BuiltInLanguage,"english",TAG_DONE);
  68.  
  69.   DD.Flags=0;
  70.   DD.Driver=Driver;
  71.   DD.Close=Close;
  72.   DD.About=About;
  73.   DD.TypeList=&ElectoneTypesList;
  74.   DD.Recognize=0;
  75.  
  76.   return(&DD);
  77.  }
  78.  
  79. __saveds void Close(void)
  80.  {if (LocaleBase)
  81.     CloseCatalog(DLi.li_Catalog);
  82.  }
  83.  
  84. __saveds STRPTR About()
  85.  {return(GetStringD(&DLi,MSGD_ABOUT));
  86.  }
  87.  
  88. __saveds ULONG Driver(ULONG *StepPtr,struct Exchange *Ex)
  89.  {static UBYTE * BufferElectone;
  90.   static StepD;
  91.   static UBYTE Type;
  92.   static ULONG DataLength;
  93.   static struct DumpNode *Node;
  94.   ULONG ReturnCode=0;
  95.  
  96.   switch(*StepPtr)
  97.    {
  98.     case STEP_INIT_DRIVER:
  99.  
  100.       BufferElectone=NULL;
  101.  
  102.       break;
  103.  
  104.     case STEP_EXIT_DRIVER:
  105.     case STEP_ABORT:
  106.       if (BufferElectone)
  107.        {BufferElectone=0;
  108.         FreeMem(BufferElectone,BUFFER_SIZE);
  109.        }
  110.  
  111.     break;
  112.  
  113.     case STEP_START:
  114.     case STEP_CONTINUE:
  115.  
  116.       *StepPtr=STEP_WAIT;
  117.  
  118.       break;
  119.  
  120.     case STEP_SEND_ABORT:
  121.  
  122.     break;
  123.  
  124.     case STEP_SEND_START:
  125.       Node=Ex->Node;
  126.       Type=FindType(Node->Type);
  127.  
  128.       if (Type!=255)
  129.        {Ex->Message=GetStringD(&DLi,MSGD_SEND_TYPE0+Type);
  130.         ElecHeader[3]=ModelID;
  131.         ElecHeader[4]=Type+0x20;
  132.         Ex->DataPtr=ElecHeader;
  133.         Ex->Length=6;
  134.         *StepPtr=STEP_SEND_SEND;
  135.         StepD=STEPD_SEND_BLOCK;
  136.        }
  137.        else
  138.        {Ex->Message=GetStringD(&DLi,MSGD_UNKNOWN_TYPE);
  139.         ReturnCode=1;
  140.         *StepPtr=STEP_SEND_COMPLETE;
  141.        }
  142.  
  143.       break;
  144.  
  145.     case STEP_SEND_CONTINUE:
  146.       switch(StepD)
  147.        {case STEPD_SEND_BLOCK:
  148.           Ex->DataPtr=Node->Dump;
  149.           Ex->Length=Node->DumpLength;
  150.           *StepPtr=STEP_SEND_SEND;
  151. #ifdef WAIT_ELEC
  152.           StepD=STEPD_SEND_WAIT_ANSWER;
  153. #else
  154.           StepD=STEPD_SEND_END;
  155. #endif
  156.           break;
  157.           
  158. #ifdef WAIT_ELEC
  159.         case STEPD_SEND_WAIT_ANSWER:
  160.           *StepPtr=STEP_SEND_WAIT;
  161.           StepD=STEPD_SEND_GET_ANSWER;
  162.           
  163.           break;
  164.           
  165.         case STEPD_SEND_GET_ANSWER:
  166.           Ex->DataPtr=AnswerElec;
  167.           Ex->Length=6;
  168.           *StepPtr=STEP_SEND_RECIEVE_EOF;
  169.           StepD=STEPD_SEND_END;
  170.                     
  171.         case STEPD_SEND_END:
  172.           *StepPtr=STEP_SEND_COMPLETE;
  173.           if (!memcmp(AnswerElec,"\0x43\0x70\0x70\0x38",4))
  174.            {if (AnswerElec[4]==0x7F)
  175.              {Ex->Message=Message;
  176.               sprintf(Message,GetStringD(&DLi,MSGD_SEND_END),Node->Name);
  177.              }
  178.              else
  179.              {Ex->Message=GetStringD(&DLi,MSGD_SEND_ERROR);
  180.               ReturnCode=1;
  181.              }
  182.            }
  183.            else
  184.            {Ex->Message=Message;
  185.             sprintf(Message,GetStringD(&DLi,MSGD_SEND_END),Node->Name);
  186.            }
  187.    
  188.           break;
  189. #else
  190.         case STEPD_SEND_END:
  191.           *StepPtr=STEP_SEND_COMPLETE;
  192.           Ex->Message=Message;
  193.           sprintf(Message,GetStringD(&DLi,MSGD_SEND_END),Node->Name);
  194.           
  195.           break;
  196. #endif
  197.          
  198.        }
  199.  
  200.       break;
  201.  
  202.     case STEP_REQ_START:
  203.       Node=Ex->Node;
  204.  
  205.       Type=FindType(((struct Node *)Node)->ln_Name);
  206.  
  207.       if (Type!=255)
  208.        {Ex->Message=GetStringD(&DLi,MSGD_REQUEST_TYPE0+Type);
  209.         Ex->Length=6;
  210.         ElecHeader[3]=ModelID;
  211.         ElecHeader[4]=Type+0x10;
  212.         Ex->DataPtr=ElecHeader;
  213.  
  214.         *StepPtr=STEP_REQ_SEND;
  215.         StepD=STEPD_WAIT_SYSEX;
  216.        }
  217.        else
  218.        {Ex->Message=GetStringD(&DLi,MSGD_UNKNOWN_TYPE);
  219.         ReturnCode=1;
  220.         Ex->Node=NULL;
  221.         *StepPtr=STEP_REQ_COMPLETE;
  222.        }
  223.  
  224.       break;
  225.  
  226.     case STEP_REQ_ABORT:
  227.       if (BufferElectone)
  228.        {BufferElectone=0;
  229.         FreeMem(BufferElectone,BUFFER_SIZE);
  230.        }
  231.  
  232.       break;
  233.  
  234.     case STEP_REQ_CONTINUE:
  235.       switch(StepD)
  236.        {
  237.         case STEPD_WAIT_SYSEX:
  238.           if (!BufferElectone)
  239.             BufferElectone=AllocMem(BUFFER_SIZE,0L);
  240.           if (!BufferElectone)
  241.            {Ex->Message=GetStringD(&DLi,MSGD_OUT_OF_MEMORY);
  242.             Ex->Node=NULL;
  243.             ReturnCode=1;
  244.             *StepPtr=STEP_REQ_COMPLETE;
  245.            }
  246.            else
  247.            {*StepPtr=STEP_REQ_WAIT;
  248.             StepD=STEPD_WAIT_YAMAHA;
  249.            }
  250.  
  251.           break;
  252.  
  253.         case STEPD_WAIT_YAMAHA:
  254.           BufferElectone[0]=0xF0;
  255.           Ex->DataPtr=BufferElectone+1;
  256.           Ex->Length=4;
  257.           *StepPtr=STEP_REQ_RECIEVE;
  258.           StepD=STEPD_CHECK_YAMAHA;
  259.  
  260.           break;
  261.  
  262.         case STEPD_CHECK_YAMAHA:
  263.           if (Ex->DataPtr[-4]==0x43 && Ex->DataPtr[-3]==0x70 && !Ex->DataPtr[-1])
  264.            {StepD=STEPD_GET_BLOCK;
  265.             Ex->Length=BUFFER_SIZE-5;
  266.             Ex->Data1=0xF7F7F7F7;
  267.             *StepPtr=STEP_REQ_RECIEVE_EOF;
  268.            }
  269.            else
  270.            {
  271.             Ex->Node=NULL;
  272.             *StepPtr=STEP_REQ_COMPLETE;
  273.             Ex->Message=GetStringD(&DLi,MSGD_UNEXPECTED_ANSWER);
  274.             ReturnCode=1;
  275.            }
  276.  
  277.           break;
  278.  
  279.         case STEPD_GET_BLOCK:
  280.  
  281.           if (Ex->DataPtr[-1]!=0xF7)
  282.            {Ex->Message=GetStringD(&DLi,MSGD_TOO_MANY_DATAS);
  283.             Ex->Node=NULL;
  284.             ReturnCode=1;
  285.             *StepPtr=STEP_REQ_COMPLETE;
  286.            }
  287.            else
  288.            {DataLength=Ex->DataPtr-BufferElectone;
  289.             if (Node=AllocMem(sizeof(struct DumpNode),0L))
  290.              {Node->DNode.ln_Type=0;
  291.               Node->DNode.ln_Name=Node->Name;
  292.               Node->Data=NULL;
  293.               Node->DataLength=0;
  294.               Node->DumpLength=DataLength;
  295.               Node->Name[0]='\0';
  296.               Node->Flags=0;
  297.               Ex->Node=Node;
  298.               strcpy(Node->Type,ElectoneTypesNodes[Type].ln_Name);
  299.  
  300.               if (Node->Dump=AllocMem(DataLength,0L))
  301.                {memcpy(Node->Dump,BufferElectone,DataLength);
  302.  
  303.                 Ex->DataPtr=(APTR)Node;
  304.                 *StepPtr=STEP_REQ_COMPLETE;
  305.                 Ex->Message=GetStringD(&DLi,MSGD_RECIEVED_TYPE0+Type);
  306.                }
  307.                else
  308.                {Ex->Message=GetStringD(&DLi,MSGD_OUT_OF_MEMORY);
  309.                 Ex->Node=NULL;
  310.                 ReturnCode=1;
  311.                 *StepPtr=STEP_REQ_COMPLETE;
  312.                 FreeMem(Node,sizeof(struct DumpNode));
  313.                }
  314.              }
  315.              else
  316.              {Ex->Message=GetStringD(&DLi,MSGD_OUT_OF_MEMORY);
  317.               Ex->Node=NULL;
  318.               ReturnCode=1;
  319.               *StepPtr=STEP_REQ_COMPLETE;
  320.              }
  321.             FreeMem(BufferElectone,BUFFER_SIZE);
  322.             BufferElectone=0;
  323.            }
  324.  
  325.           break;
  326.        }
  327.       break;
  328.  
  329.    }
  330.   return(ReturnCode);
  331. }
  332.  
  333. UBYTE FindType(STRPTR TypeStr)
  334.  {UBYTE Type=0;
  335.   BOOL Flag=FALSE;
  336.  
  337.   while (!Flag && (Type<7))
  338.     if (!strcmp(TypeStr,ElectoneTypesNodes[Type].ln_Name))
  339.       Flag=TRUE;
  340.      else
  341.       Type++;
  342.  
  343.   if (!Flag)
  344.     Type=255;
  345.  
  346.   return(Type);
  347.  }
  348.  
  349. STRPTR GetStringD(struct LocaleInfo *li, LONG stringNum)
  350. {
  351. LONG   *l;
  352. UWORD  *w;
  353. STRPTR  builtIn;
  354.  
  355.     l = (LONG *)CatCompBlock;
  356.  
  357.     while (*l != stringNum)
  358.     {
  359.         w = (UWORD *)((ULONG)l + 4);
  360.         l = (LONG *)((ULONG)l + (ULONG)*w + 6);
  361.     }
  362.     builtIn = (STRPTR)((ULONG)l + 6);
  363.  
  364.     if (LocaleBase)
  365.         return(GetCatalogStr(li->li_Catalog,stringNum,builtIn));
  366.     return(builtIn);
  367. }
  368.