home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Sound / MidI / SYNTHLIB.LHA / Synth_Librarian / sources / TG33 / TG33.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-22  |  18.4 KB  |  701 lines
  1. /**************************************************************/
  2. /* $VER: TG33.c Revison 1.1                                   */
  3. /* This file is part of Synth Librarian v1.1                  */
  4. /* ©1993-1994 Jean-Alexis MONTIGNIES                          */
  5. /* This file must not be distributed modified or separatly    */
  6. /* without my written permission                              */
  7. /* See Synth_Librarian.guide for more details                 */
  8. /**************************************************************/
  9.  
  10. #include <proto/exec.h>
  11. #include <stdlib.h>
  12. #include <math.h>
  13. #include <string.h>
  14. #include <stdio.h>
  15. #include <intuition/intuition.h>
  16. #include <proto/intuition.h>
  17.  
  18. #include "SynthLib.h"
  19. #include <libraries/locale.h>
  20. #include <proto/locale.h>
  21. #define CATCOMP_BLOCK
  22. #define CATCOMP_NUMBERS
  23. #include "TG33loc.h"
  24.  
  25. #define STEPD_CHECK_YAMAHA   0
  26. #define STEPD_G1P            1
  27. #define STEPD_G1P_DATA      2
  28. #define STEPD_GP_LENGTH      3
  29. #define STEPD_GP_DATA       4
  30.  
  31. #define STEPD_WAIT_SYSEX     5
  32. #define STEPD_WAIT_YAMAHA    6
  33.  
  34. #define STEPD_WAIT100         0
  35. #define STEPD_S1P             1
  36. #define STEPD_SEND_END        2
  37.  
  38. #define TYPE_VOICE           &TG33TypesNodes[0]
  39. #define TYPE_ALL             &TG33TypesNodes[1]
  40. #define TYPE_22VOICE         &TG33TypesNodes[2]
  41.  
  42. #define BUFFER_SIZE         40000L
  43.  
  44. struct LocaleInfo DLi;
  45. #ifndef DEBUG_SL
  46. struct Library *LocaleBase;
  47. struct DosBase *DOSBase;
  48. struct ExecBase *SysBase;
  49. struct IntuitionBase *IntuitionBase ;
  50. #endif
  51.  
  52. char Message[256];
  53. static struct DriverData DD;
  54. extern struct MinList TG33TypesList;
  55.  
  56. extern struct MinList TG33TypesListHidden;
  57.  
  58. struct Node TG33TypesNodes[] = {
  59.         &TG33TypesNodes[1], ( struct Node * )&TG33TypesList.mlh_Head, 0, 0, "TG33 Voice",
  60.         ( struct Node * )&TG33TypesList.mlh_Tail, &TG33TypesNodes[0], 0, 0, "TG33 64 Voices",
  61.           ( struct Node * )&TG33TypesListHidden.mlh_Head,
  62.           ( struct Node * )&TG33TypesListHidden.mlh_Tail,0,0,"SY22 Voice" };
  63.  
  64.  
  65. struct MinList TG33TypesList = {
  66.         ( struct MinNode * )&TG33TypesNodes[0], ( struct MinNode * )NULL, ( struct MinNode * )&TG33TypesNodes[1] };
  67.  
  68. struct MinList TG33TypesListHidden = {
  69.         ( struct MinNode * )&TG33TypesNodes[2], ( struct MinNode * )NULL, ( struct MinNode * )&TG33TypesNodes[2] };
  70.  
  71. struct EasyStruct AboutES_TG33 = {
  72.     sizeof (struct EasyStruct),
  73.     0,
  74.     NULL,
  75.     NULL,
  76.     NULL
  77.  };
  78.  
  79.  
  80. struct DriverData * InitDriver(ULONG (*GetData)(ULONG Number));
  81. void Close(void);
  82. STRPTR GetString_TG33(struct LocaleInfo *li, LONG stringNum);
  83. ULONG Driver(ULONG *StepPtr,struct Exchange *Ex);
  84. STRPTR About(void);
  85. struct Node* RecognizeNode2(struct DumpNode *Node,int *Error);
  86. struct Node* RecognizeNode(struct DumpNode *Node);
  87. int CheckYamaha(struct DumpNode *Node);
  88.  
  89. __saveds struct DriverData *InitDriver(ULONG (*GetData)(ULONG Number))
  90.  {
  91. #ifndef DEBUG_SL
  92.   DOSBase=(struct DosBase *)GetData(GTD_DosBase);
  93.   SysBase=(struct ExecBase *)GetData(GTD_ExecBase);
  94.   LocaleBase=(struct LocaleBase *)GetData(GTD_LocaleBase);
  95.   IntuitionBase=(struct IntuitionBase *)GetData(GTD_IntuitionBase);
  96. #endif
  97.  
  98.   if (DLi.li_LocaleBase=LocaleBase)
  99.     DLi.li_Catalog=OpenCatalog(NULL,"SynthLib/TG33.catalog",OC_BuiltInLanguage,"english",TAG_DONE);
  100.  
  101.   DD.Flags=0;
  102.   DD.Driver=Driver;
  103.   DD.Close=Close;
  104.   DD.About=About;
  105.   DD.TypeList=&TG33TypesList;
  106.   DD.Recognize=RecognizeNode;
  107.  
  108.   return(&DD);
  109.  }
  110.  
  111. __saveds void Close(void)
  112.  {if (LocaleBase)
  113.     CloseCatalog(DLi.li_Catalog);
  114.  }
  115.  
  116. __saveds STRPTR About()
  117.  {return(GetString_TG33(&DLi,MSGD_ABOUT));
  118.  }
  119.  
  120. __saveds ULONG Driver(ULONG *StepPtr,struct Exchange *Ex)
  121.  {static UBYTE * BufferTG33;
  122.   static StepD;
  123.   static USHORT PacketLength;
  124.   static struct Node *Type;
  125.   static struct DumpNode *Node;
  126.   static UBYTE NPackets;
  127.   static ULONG DataLength;
  128.   static UBYTE * DataPtr;
  129.   ULONG ReturnCode=0;
  130.   int Error;
  131.  
  132.   switch(*StepPtr)
  133.    {
  134.     case STEP_INIT_DRIVER:
  135.  
  136.       BufferTG33=NULL;
  137.  
  138.       break;
  139.  
  140.     case STEP_EXIT_DRIVER:
  141.     case STEP_ABORT:
  142.       if (BufferTG33)
  143.        {BufferTG33=0;
  144.         FreeMem(BufferTG33,BUFFER_SIZE);
  145.        }
  146.  
  147.     break;
  148.  
  149.     case STEP_START:
  150.       if (!BufferTG33)
  151.         BufferTG33=AllocMem(BUFFER_SIZE,0L);
  152.       if (BufferTG33)
  153.        {
  154.         BufferTG33[0]=0xF0;
  155.         Ex->DataPtr=BufferTG33+1;
  156.         Ex->Length=3;
  157.         *StepPtr=STEP_RECIEVE;
  158.         StepD=STEPD_CHECK_YAMAHA;
  159.        }
  160.        else
  161.        {Ex->Message=GetString_TG33(&DLi,ERRORD_OUT_OF_MEMORY);
  162.         ReturnCode=1;
  163.         *StepPtr=STEP_WAIT;
  164.        }
  165.  
  166.       break;
  167.  
  168.     case STEP_CONTINUE:
  169.       switch(StepD)
  170.        {case STEPD_CHECK_YAMAHA:
  171.           if (Ex->DataPtr[-3]==0x43 && !(Ex->DataPtr[-2]&0xF0) && Ex->DataPtr[-1]==0x7E)
  172.            {StepD=STEPD_G1P;
  173.             Ex->Length=2;
  174.             *StepPtr=STEP_RECIEVE;
  175.            }
  176.            else
  177.             *StepPtr=STEP_WAIT;
  178.  
  179.           break;
  180.  
  181.         case STEPD_G1P:
  182.           PacketLength=(((UWORD)Ex->DataPtr[-2])<<7)+Ex->DataPtr[-1];
  183.  
  184.           if (BUFFER_SIZE+(BufferTG33-Ex->DataPtr)<PacketLength+1)
  185.            {Ex->Message=GetString_TG33(&DLi,ERRORD_TOO_MANY_DATA);
  186.             ReturnCode=1;
  187.             *StepPtr=STEP_WAIT;
  188.            }
  189.            else
  190.            {*StepPtr=STEP_RECIEVE;
  191.             Ex->Length=PacketLength+1;
  192.             StepD=STEPD_G1P_DATA;
  193.             sprintf(Message,GetString_TG33(&DLi,MSGD_RECIEVEPACKET),1);
  194.             Ex->Message=Message;
  195.            }
  196.  
  197.           break;
  198.  
  199.         case STEPD_G1P_DATA:
  200.           Type=0;
  201.           NPackets=1;
  202.  
  203.           if (!memcmp(&(Ex->DataPtr[-PacketLength-1]),"LM  0012VE",10))
  204.             Type=TYPE_VOICE;
  205.            else
  206.             if (!memcmp(&(Ex->DataPtr[-PacketLength-1]),"LM  0012VC",10))
  207.               Type=TYPE_ALL;
  208.  
  209.           if (Type)
  210.            {
  211.             *StepPtr=STEP_RECIEVE_EOF;
  212.             Ex->Length=2;
  213.             Ex->Data1=0xF7F7F7F7;
  214.             StepD=STEPD_GP_LENGTH;
  215.            }
  216.            else
  217.            {*StepPtr=STEP_WAIT;
  218.             Ex->Message=GetString_TG33(&DLi,ERRORD_UNKNOWN_FORMAT);
  219.             ReturnCode=1;
  220.            }
  221.  
  222.           break;
  223.  
  224.         case STEPD_GP_LENGTH:
  225.  
  226.           if (Ex->DataPtr[-1]!=0xF7)
  227.            {PacketLength=(((UWORD)Ex->DataPtr[-2])<<7)+Ex->DataPtr[-1];
  228.  
  229.             if (BUFFER_SIZE+(BufferTG33-Ex->DataPtr)<PacketLength+1)
  230.              {Ex->Message=GetString_TG33(&DLi,ERRORD_TOO_MANY_DATA);
  231.               ReturnCode=1;
  232.               *StepPtr=STEP_WAIT;
  233.              }
  234.              else
  235.              {*StepPtr=STEP_RECIEVE;
  236.               Ex->Length=PacketLength+1;
  237.               StepD=STEPD_GP_DATA;
  238.               sprintf(Message,GetString_TG33(&DLi,MSGD_RECIEVEPACKET),NPackets+1);
  239.               Ex->Message=Message;
  240.              }
  241.            }
  242.            else
  243.            {DataLength=Ex->DataPtr-BufferTG33;
  244.             if (Node=AllocMem(sizeof(struct DumpNode),0L))
  245.              {
  246.               Node->Data=NULL;
  247.               Node->DataLength=0;
  248.               Node->DumpLength=DataLength;
  249.               Node->Name[0]='\0';
  250.               Node->Flags=0;
  251.               Ex->Node=Node;
  252.               strcpy(Node->Type,Type->ln_Name);
  253.               if (Type==TYPE_VOICE)
  254.                {Ex->Message=GetString_TG33(&DLi,MSGD_RECIEVEENDVOICE);
  255.                 memcpy(Node->Name,BufferTG33+19,8);
  256.                 Node->Name[8]='\0';
  257.                }
  258.               if (Type==TYPE_ALL)
  259.                {Ex->Message=GetString_TG33(&DLi,MSGD_RECIEVEENDALL);
  260.                }
  261.               if (Node->Dump=AllocMem(DataLength,0L))
  262.                {memcpy(Node->Dump,BufferTG33,DataLength);
  263.  
  264.                 Ex->DataPtr=(APTR)Node;
  265.                 *StepPtr=STEP_RECIEVE_COMPLETE;
  266.                }
  267.                else
  268.                {Ex->Message=GetString_TG33(&DLi,ERRORD_OUT_OF_MEMORY);
  269.                 ReturnCode=1;
  270.                 *StepPtr=STEP_WAIT;
  271.                 FreeMem(Node,sizeof(struct DumpNode));
  272.                }
  273.              }
  274.              else
  275.              {Ex->Message=GetString_TG33(&DLi,ERRORD_OUT_OF_MEMORY);
  276.               ReturnCode=1;
  277.               *StepPtr=STEP_WAIT;
  278.              }
  279.             FreeMem(BufferTG33,BUFFER_SIZE);
  280.             BufferTG33=0;
  281.            }
  282.  
  283.           break;
  284.  
  285.         case STEPD_GP_DATA:
  286.           NPackets++;
  287.  
  288.           *StepPtr=STEP_RECIEVE_EOF;
  289.           Ex->Length=2;
  290.           Ex->Data1=0xF7F7F7F7;
  291.           StepD=STEPD_GP_LENGTH;
  292.  
  293.           break;
  294.        }
  295.       break;
  296.  
  297.     case STEP_SEND_ABORT:
  298.  
  299.     break;
  300.  
  301.  
  302.     case STEP_SEND_START:
  303.       Node=(struct DumpNode *)Ex->Node;
  304.       Type=0;
  305.       NPackets=0;
  306.  
  307.       Type=RecognizeNode2(Node,&Error);
  308.  
  309.       if (Error)
  310.         { Ex->Message=GetString_TG33(&DLi,Error);
  311.           ReturnCode=1;
  312.           *StepPtr=STEP_SEND_COMPLETE;
  313.         }
  314.  
  315.       if (Type==TYPE_VOICE)
  316.        {sprintf(Message,GetString_TG33(&DLi,MSGD_SENDVOICE),Node->Name);
  317.         Ex->Message=Message;
  318.        }
  319.         
  320.       if (Type==TYPE_22VOICE)
  321.        {sprintf(Message,GetString_TG33(&DLi,MSGD_SEND22VOICE),Node->Name);
  322.         Ex->Message=Message;
  323.        }
  324.  
  325.       if (Type==TYPE_ALL)
  326.        {sprintf(Message,GetString_TG33(&DLi,MSGD_SENDALLPACKET),1);
  327.         Ex->Message=Message;
  328.        }
  329.  
  330.       if (Type)
  331.        {DataPtr=Node->Dump;
  332.         Ex->DataPtr=DataPtr;
  333.         PacketLength=(((UWORD)Ex->DataPtr[4])<<7)+Ex->DataPtr[5];
  334.         Ex->Length=PacketLength+7;
  335.         DataPtr+=Ex->Length;
  336.         *StepPtr=STEP_SEND_SEND;
  337.         StepD=STEPD_WAIT100;
  338.        }
  339.        
  340.        break;
  341.  
  342.     case STEP_SEND_CONTINUE:
  343.       switch(StepD)
  344.        {case STEPD_WAIT100:
  345.  
  346.           NPackets++;
  347.  
  348.           if (DataPtr[0]==0xF7)
  349.            {Ex->Length=1;
  350.             Ex->DataPtr=DataPtr;
  351.             *StepPtr=STEP_SEND_SEND;
  352.             StepD=STEPD_SEND_END;
  353.            }
  354.            else
  355.            {
  356.             Ex->Data1=100000;
  357.             *StepPtr=STEP_SEND_DELAY;
  358.             StepD=STEPD_S1P;
  359.            }
  360.  
  361.           break;
  362.  
  363.         case STEPD_S1P:
  364.           PacketLength=(((UWORD)DataPtr[0])<<7)+DataPtr[1];
  365.           Ex->Length=PacketLength+3;
  366.           Ex->DataPtr=DataPtr;
  367.           DataPtr+=Ex->Length;
  368.  
  369.           Ex->Message=Message;
  370.           sprintf(Message,GetString_TG33(&DLi,MSGD_SENDALLPACKET),NPackets+1);
  371.  
  372.           *StepPtr=STEP_SEND_SEND;
  373.           StepD=STEPD_WAIT100;
  374.  
  375.           break;
  376.  
  377.         case STEPD_SEND_END:
  378.           *StepPtr=STEP_SEND_COMPLETE;
  379.           Ex->Message=Message;
  380.           sprintf(Message,GetString_TG33(&DLi,MSGD_SENDEND),Node->Name);
  381.  
  382.        }
  383.       break;
  384.  
  385.     case STEP_REQ_START:
  386.       Node=Ex->Node;
  387.       Ex->Node=NULL;
  388.       Type=0;
  389.       NPackets=0;
  390.  
  391.       if (!strcmp(((struct Node *)Node)->ln_Name,"TG33 Voice"))
  392.        {Ex->DataPtr="\xF0\x43 \x7ELM  0012VE\xF7";
  393.         Type=TYPE_VOICE;
  394.        }
  395.        else
  396.         if (!strcmp(((struct Node *)Node)->ln_Name,"TG33 All"))
  397.          {Ex->DataPtr="\xF0\x43 \x7ELM  0012VC\xF7";
  398.           Type=TYPE_ALL;
  399.          }
  400.  
  401.       if (Type)
  402.        {
  403.         Ex->Length=15;
  404.         *StepPtr=STEP_REQ_SEND;
  405.         StepD=STEPD_WAIT_SYSEX;
  406.        }
  407.        else
  408.        {Ex->Message=GetString_TG33(&DLi,ERRORD_UNKNOWN_TYPE);
  409.         ReturnCode=1;
  410.         *StepPtr=STEP_REQ_COMPLETE;
  411.        }
  412.  
  413.       break;
  414.  
  415.     case STEP_REQ_ABORT:
  416.       if (BufferTG33)
  417.        {BufferTG33=0;
  418.         FreeMem(BufferTG33,BUFFER_SIZE);
  419.        }
  420.  
  421.       break;
  422.  
  423.     case STEP_REQ_CONTINUE:
  424.       switch(StepD)
  425.        {
  426.         case STEPD_WAIT_SYSEX:
  427.           if (!BufferTG33)
  428.             BufferTG33=AllocMem(BUFFER_SIZE,0L);
  429.           if (!BufferTG33)
  430.            {Ex->Message=GetString_TG33(&DLi,ERRORD_OUT_OF_MEMORY);
  431.             ReturnCode=1;
  432.             *StepPtr=STEP_REQ_COMPLETE;
  433.            }
  434.            else
  435.            {*StepPtr=STEP_REQ_WAIT;
  436.             StepD=STEPD_WAIT_YAMAHA;
  437.            }
  438.  
  439.           break;
  440.  
  441.         case STEPD_WAIT_YAMAHA:
  442.           BufferTG33[0]=0xF0;
  443.           Ex->DataPtr=BufferTG33+1;
  444.           Ex->Length=3;
  445.           *StepPtr=STEP_REQ_RECIEVE;
  446.           StepD=STEPD_CHECK_YAMAHA;
  447.  
  448.           break;
  449.  
  450.         case STEPD_CHECK_YAMAHA:
  451.           if (Ex->DataPtr[-3]==0x43 && !(Ex->DataPtr[-2]&0xF0) && Ex->DataPtr[-1]==0x7E)
  452.            {StepD=STEPD_G1P;
  453.             Ex->Length=2;
  454.             *StepPtr=STEP_REQ_RECIEVE;
  455.            }
  456.            else
  457.            {
  458.             *StepPtr=STEP_REQ_COMPLETE;
  459.             Ex->Message=GetString_TG33(&DLi,ERRORD_UNEXPECTED_ANSWER);
  460.             ReturnCode=1;
  461.            }
  462.  
  463.           break;
  464.  
  465.         case STEPD_G1P:
  466.           PacketLength=(((UWORD)Ex->DataPtr[-2])<<7)+Ex->DataPtr[-1];
  467.  
  468.           if (BUFFER_SIZE+(BufferTG33-Ex->DataPtr)<PacketLength+1)
  469.            {
  470.             Ex->Message=GetString_TG33(&DLi,ERRORD_TOO_MANY_DATA);
  471.             ReturnCode=1;
  472.             *StepPtr=STEP_REQ_COMPLETE;
  473.            }
  474.            else
  475.            {*StepPtr=STEP_REQ_RECIEVE;
  476.             Ex->Length=PacketLength+1;
  477.             StepD=STEPD_G1P_DATA;
  478.             Ex->Message=Message;
  479.             sprintf(Message,GetString_TG33(&DLi,MSGD_RECIEVEPACKET),1);
  480.            }
  481.  
  482.           break;
  483.  
  484.         case STEPD_G1P_DATA:
  485.           NPackets=1;
  486.  
  487.           if (Type==TYPE_VOICE)
  488.             if (memcmp(&(Ex->DataPtr[-PacketLength-1]),"LM  0012VE",10))
  489.               Type=0;
  490.  
  491.           if (Type==TYPE_ALL)
  492.             if (memcmp(&(Ex->DataPtr[-PacketLength-1]),"LM  0012VC",10))
  493.               Type=0;
  494.  
  495.           if (Type)
  496.            {
  497.             *StepPtr=STEP_REQ_RECIEVE_EOF;
  498.             Ex->Length=2;
  499.             Ex->Data1=0xF7F7F7F7;
  500.             StepD=STEPD_GP_LENGTH;
  501.            }
  502.            else
  503.            {*StepPtr=STEP_REQ_COMPLETE;
  504.             ReturnCode=1;
  505.             Ex->Message=GetString_TG33(&DLi,ERRORD_UNEXPECTED_ANSWER);
  506.            }
  507.  
  508.           break;
  509.  
  510.         case STEPD_GP_LENGTH:
  511.  
  512.           if (Ex->DataPtr[-1]!=0xF7)
  513.            {PacketLength=(((UWORD)Ex->DataPtr[-2])<<7)+Ex->DataPtr[-1];
  514.  
  515.             if (BUFFER_SIZE+(BufferTG33-Ex->DataPtr)<PacketLength+1)
  516.              {Ex->Message=GetString_TG33(&DLi,ERRORD_TOO_MANY_DATA);
  517.               ReturnCode=1;
  518.               *StepPtr=STEP_REQ_COMPLETE;
  519.              }
  520.              else
  521.              {*StepPtr=STEP_REQ_RECIEVE;
  522.               Ex->Length=PacketLength+1;
  523.               StepD=STEPD_GP_DATA;
  524.               Ex->Message=Message;
  525.               sprintf(Message,GetString_TG33(&DLi,MSGD_RECIEVEPACKET),NPackets+1);
  526.              }
  527.            }
  528.            else
  529.            {DataLength=Ex->DataPtr-BufferTG33;
  530.             if (Node=AllocMem(sizeof(struct DumpNode),0L))
  531.              {
  532.               Node->Data=NULL;
  533.               Node->DataLength=0;
  534.               Node->DumpLength=DataLength;
  535.               Node->Name[0]='\0';
  536.               Node->Flags=0;
  537.               Ex->Node=Node;
  538.               strcpy(Node->Type,Type->ln_Name);
  539.               if (Type==TYPE_VOICE)
  540.                {Ex->Message=GetString_TG33(&DLi,MSGD_RECIEVEENDVOICE);
  541.                 memcpy(Node->Name,BufferTG33+19,8);
  542.                 Node->Name[8]='\0';
  543.                }
  544.               if (Type==TYPE_ALL)
  545.                {Ex->Message=GetString_TG33(&DLi,MSGD_RECIEVEENDALL);
  546.                }
  547.               if (Node->Dump=AllocMem(DataLength,0L))
  548.                {memcpy(Node->Dump,BufferTG33,DataLength);
  549.  
  550.                 Ex->DataPtr=(APTR)Node;
  551.                 *StepPtr=STEP_REQ_COMPLETE;
  552.                }
  553.                else
  554.                {Ex->Message=GetString_TG33(&DLi,ERRORD_OUT_OF_MEMORY);
  555.                 ReturnCode=1;
  556.                 *StepPtr=STEP_REQ_COMPLETE;
  557.                 FreeMem(Node,sizeof(struct DumpNode));
  558.                }
  559.              }
  560.              else
  561.              {Ex->Message=GetString_TG33(&DLi,ERRORD_OUT_OF_MEMORY);
  562.               ReturnCode=1;
  563.               *StepPtr=STEP_REQ_COMPLETE;
  564.              }
  565.             FreeMem(BufferTG33,BUFFER_SIZE);
  566.             BufferTG33=0;
  567.            }
  568.  
  569.           break;
  570.  
  571.         case STEPD_GP_DATA:
  572.           NPackets++;
  573.  
  574.           *StepPtr=STEP_REQ_RECIEVE_EOF;
  575.           Ex->Length=2;
  576.           Ex->Data1=0xF7F7F7F7;
  577.           StepD=STEPD_GP_LENGTH;
  578.  
  579.           break;
  580.        }
  581.       break;
  582.  
  583.    }
  584.   return(ReturnCode);
  585. }
  586.  
  587. __saveds struct Node* RecognizeNode(struct DumpNode *Node)
  588. {
  589.   int Dummy;
  590.  
  591.   return (RecognizeNode2(Node,&Dummy));
  592. }
  593.  
  594. struct Node* RecognizeNode2(struct DumpNode *Node,int *Error)
  595. {
  596.   struct Node *Type=NULL;
  597.  
  598.   if (!(*Error=CheckYamaha(Node)))
  599.     if (Node->DumpLength>=18)
  600.       {
  601.         if (!memcmp(&(Node->Dump[6]),"LM  0012VE",10))
  602.             Type=TYPE_VOICE;
  603.            else
  604.             if (!memcmp(&(Node->Dump[6]),"LM  0012VC",10))
  605.               Type=TYPE_ALL;
  606.              else
  607.               if (!memcmp(&(Node->Dump[6]),"PK  2203AE",10))
  608.                 Type=TYPE_22VOICE;
  609.                else
  610.                 *Error=ERRORD_UNKNOWN_TYPE;
  611.       }
  612.  
  613.   return (Type);
  614. }
  615.  
  616. int CheckYamaha(struct DumpNode *Node)
  617. {
  618.   char *Dump;
  619.   char CheckSum;
  620.   short Length;
  621.   char *End;
  622.   int ReturnCode=0;
  623.   int Stop=0;
  624.   long i;
  625.  
  626.   if (Node)
  627.     {
  628.       Dump=Node->Dump;
  629.  
  630.       if (Dump)
  631.         { End=Dump+Node->DumpLength;
  632.           
  633.           if (Node->DumpLength>7)
  634.             if (Dump[1]==0x43)
  635.               if (!(Dump[2]&0xF))
  636.                 if (Dump[3]==0x7E)
  637.                   { Dump+=4;
  638.                     do
  639.                       {
  640.                         CheckSum=0;
  641.                         if (Dump+2<=End)
  642.                           { Length=Dump[1]+(Dump[0]<<7);
  643.                             Dump+=2;
  644.  
  645.                             if (Dump+Length+2<=End)
  646.                               {
  647.                                 for (i=0;i<Length;i++)
  648.                                   CheckSum+=Dump[i];
  649.  
  650.                                 Dump+=Length;
  651.                                 if ((*(Dump++)+CheckSum)& 0x7F)
  652.                                   ReturnCode=ERRORD_BAD_CHECKSUM;
  653.  
  654.                                 if (*Dump=='\xF7')
  655.                                   Stop=1;
  656.                               }
  657.                              else
  658.                               ReturnCode=ERRORD_UNKNOWN_TYPE;
  659.                           }
  660.                          else
  661.                           ReturnCode=ERRORD_UNKNOWN_TYPE;
  662.                       }
  663.                     while (!ReturnCode && !Stop);
  664.                   }
  665.                  else
  666.                   ReturnCode=ERRORD_UNKNOWN_TYPE;
  667.                else
  668.                 ReturnCode=ERRORD_UNKNOWN_TYPE;
  669.              else
  670.               ReturnCode=ERRORD_UNKNOWN_TYPE;
  671.            else
  672.             ReturnCode=ERRORD_UNKNOWN_TYPE;
  673.         }
  674.     }
  675.    else
  676.     ReturnCode=ERRORD_UNKNOWN_TYPE;
  677.  
  678.   return ReturnCode;
  679. }
  680.  
  681. STRPTR GetString_TG33(struct LocaleInfo *li, LONG stringNum)
  682. {
  683. LONG   *l;
  684. UWORD  *w;
  685. STRPTR  builtIn;
  686.  
  687.     l = (LONG *)CatCompBlock;
  688.  
  689.     while (*l != stringNum)
  690.     {
  691.         w = (UWORD *)((ULONG)l + 4);
  692.         l = (LONG *)((ULONG)l + (ULONG)*w + 6);
  693.     }
  694.     builtIn = (STRPTR)((ULONG)l + 6);
  695.  
  696.     if (LocaleBase)
  697.         return(GetCatalogStr(li->li_Catalog,stringNum,builtIn));
  698.  
  699.     return(builtIn);
  700. }
  701.