home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Sound / MidI / SYNTHLIB.LHA / Synth_Librarian / sources / SynthLib / FileOp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-18  |  14.1 KB  |  568 lines
  1. /**************************************************************/
  2. /* $VER: FileOp.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. /* Synth librarian part for I/O with files */
  11. #include <libraries/asl.h>
  12. #include <proto/asl.h>
  13. #include <stdio.h>
  14. #include <string.h>
  15. #include <dos.h>
  16. #include <proto/exec.h>
  17. #include <errno.h>
  18. #include <libraries/iffparse.h>
  19. #include <exec/memory.h>
  20. #include <libraries/locale.h>
  21. #include <proto/locale.h>
  22. #include <proto/dos.h>
  23.  
  24. #define CATCOMP_NUMBERS
  25. #include "SynthLibLoc.h"
  26. #include "SynthLib.h"
  27. #include "SynthLibInt.h"
  28.  
  29. #define ID_MDDP MAKE_ID('M','D','D','P')
  30. #define ID_HEAD MAKE_ID('H','E','A','D')
  31. #define ID_MIDI MAKE_ID('M','I','D','I')
  32. #define ID_DATA MAKE_ID('D','A','T','A')
  33.  
  34. extern struct LocaleInfo MLi;
  35. extern char MainCatBlock[];
  36. static struct FileRequester *AslFR,*DriFR;
  37. FILE *F;
  38.  
  39. STRPTR GetString(struct LocaleInfo *li, LONG stringNum,char *CatCompBlock);
  40. BPTR GetDriverSeg(void);
  41. int FileOpInit(void);
  42. void FileOpClose(void);
  43. int SaveOne(struct DumpNode *Node1);
  44. void SaveAll(void);
  45. int LoadIff(ULONG *Length);
  46. int LoadRaw(void);
  47. int ReadRaw(ULONG start,ULONG end,FILE *fp);
  48.  
  49.  
  50. int FileOpInit(void)
  51.  {int ReturnCode;
  52.  
  53.   AslBase=NULL;
  54.   AslFR=NULL;
  55.   DriFR=NULL;
  56.  
  57.   if (AslBase=OpenLibrary("asl.library",0L))
  58.     if (AslFR=AllocAslRequestTags(ASL_FileRequest,ASL_Dir,"PROGDIR:",TAG_DONE))
  59.       if (DriFR=AllocAslRequestTags(ASL_FileRequest,ASL_Dir,"PROGDIR:SLDrivers",TAG_DONE))
  60.         ReturnCode=0;
  61.        else
  62.         ReturnCode=3;
  63.      else
  64.       ReturnCode=1;
  65.    else
  66.     ReturnCode=2;
  67.  
  68.   return(ReturnCode);
  69.  }
  70.  
  71. void FileOpClose(void)
  72.  {if (AslFR)
  73.     FreeAslRequest(AslFR);
  74.   if (DriFR)
  75.     FreeAslRequest(DriFR);
  76.   if (AslBase)
  77.     CloseLibrary(AslBase);
  78.  }
  79.  
  80. BPTR GetDriverSeg(void)
  81.  {BPTR DSeg=NULL;
  82.  
  83.   if (AslRequestTags(DriFR,TAG_DONE))
  84.     if (!chdir(DriFR->rf_Dir))
  85.      {
  86.       if (!(DSeg=LoadSeg(DriFR->rf_File)))
  87.         NewMessage(GetString(&MLi,MG_DRIVER_IO_ERROR,MainCatBlock),1);
  88.      }
  89.      else
  90.        NewMessage(GetString(&MLi,MG_FILE_NODIR,MainCatBlock),1);
  91.   return(DSeg);
  92.  }
  93.  
  94. int SaveDumpLib(void)
  95.  {if (SelectedDump)
  96.    {
  97.     if (AslRequestTags(AslFR,ASL_FuncFlags,FILF_SAVE,TAG_DONE))
  98.       if (!chdir(AslFR->rf_Dir))
  99.         if (F=fopen(AslFR->rf_File,"wb"))
  100.          {errno=SaveOne(SelectedDump);
  101.           if (errno)
  102.             NewMessage(GetString(&MLi,MG_FILE_IO_ERROR,MainCatBlock),1);
  103.           fclose (F);
  104.          }
  105.          else
  106.           NewMessage(GetString(&MLi,MG_FILE_NOFILE,MainCatBlock),1);
  107.        else
  108.         NewMessage(GetString(&MLi,MG_FILE_NODIR,MainCatBlock),1);
  109.    }
  110.    else
  111.     NewMessage(GetString(&MLi,MG_FILE_NODATA,MainCatBlock),1);
  112.   return(0);
  113.  }
  114.  
  115. int OpenLib(void)
  116.  {int Error;
  117.   ULONG Dummy;
  118.  
  119.   if (AslRequestTags(AslFR,ASL_FuncFlags,0L,TAG_DONE))
  120.     if (!chdir(AslFR->rf_Dir))
  121.       if (F=fopen(AslFR->rf_File,"rb"))
  122.        {Error=LoadIff(&Dummy);
  123.         if (Error)
  124.           NewMessage(GetString(&MLi,Error,MainCatBlock),1);
  125.         fclose (F);
  126.        }
  127.        else
  128.         NewMessage(GetString(&MLi,MG_FILE_NOFILE,MainCatBlock),1);
  129.      else
  130.       NewMessage(GetString(&MLi,MG_FILE_NODIR,MainCatBlock),1);
  131.   return(0);
  132.  }
  133.  
  134. int OpenLibRaw(void)
  135.  {int Error;
  136.  
  137.   if (AslRequestTags(AslFR,ASL_FuncFlags,0L,TAG_DONE))
  138.     if (!chdir(AslFR->rf_Dir))
  139.       if (F=fopen(AslFR->rf_File,"rb"))
  140.        {Error=LoadRaw();
  141.         if (Error)
  142.           NewMessage(GetString(&MLi,Error,MainCatBlock),1);
  143.         fclose (F);
  144.        }
  145.        else
  146.         NewMessage(GetString(&MLi,MG_FILE_NOFILE,MainCatBlock),1);
  147.      else
  148.       NewMessage(GetString(&MLi,MG_FILE_NODIR,MainCatBlock),1);
  149.   return(0);
  150.  }
  151.  
  152. int SaveAsLib(void)
  153.  {if (DumpList.lh_Head->ln_Succ)
  154.    {
  155.     if (AslRequestTags(AslFR,ASL_FuncFlags,FILF_SAVE,TAG_DONE))
  156.      {Flags|=MAIN_FLAGS_NAMED;
  157.       SaveAll();
  158.      }
  159.    }
  160.    else
  161.     NewMessage(GetString(&MLi,MG_FILE_NODATA,MainCatBlock),1);
  162.   return(0);
  163.  }
  164.  
  165. int SaveLib(void)
  166.  {if (Flags & MAIN_FLAGS_NAMED)
  167.     SaveAll();
  168.    else
  169.     SaveAsLib();
  170.   return(0);
  171.  }
  172.  
  173. void SaveAll(void)
  174.  {errno=0;
  175.   if (DumpList.lh_Head->ln_Succ)
  176.     if (!chdir(AslFR->rf_Dir))
  177.       if (F=fopen(AslFR->rf_File,"wb"))
  178.        {/* Evaluation de la taille du fichier */
  179.         ULONG Total=0;
  180.         ULONG Number=0;
  181.  
  182.         struct DumpNode *Node1,*Node2;
  183.         errno=0;
  184.  
  185.         Node1=(struct DumpNode *)DumpList.lh_Head;
  186.  
  187.         while (Node2=(struct DumpNode *)Node1->DNode.ln_Succ)
  188.          {Number++;
  189.           Total+=12+58;
  190.           Total+=8+Node1->DumpLength;
  191.           if (Total & 1)
  192.             Total++;
  193.           if (Node1->Data)
  194.            {
  195.             Total+=8+Node1->DataLength;
  196.             if (Total & 1)
  197.               Total++;
  198.            }
  199.           Node1=Node2;
  200.          }
  201.  
  202.         if (Number>1)
  203.          {
  204.           fwrite("LIST",1,4,F);
  205.           if (!errno)
  206.             fwrite(&Total,4,1,F);
  207.           if (!errno)
  208.             fwrite("MDDP",1,4,F);
  209.          }
  210.  
  211.         Node1=(struct DumpNode *)DumpList.lh_Head;
  212.  
  213.         while ((Node2=(struct DumpNode *)Node1->DNode.ln_Succ) && !errno)
  214.          {
  215.           errno=SaveOne(Node1);
  216.           Node1=Node2;
  217.          }
  218.  
  219.         if (errno)
  220.           NewMessage(GetString(&MLi,MG_FILE_IO_ERROR,MainCatBlock),1);
  221.         fclose (F);
  222.        }
  223.        else
  224.         NewMessage(GetString(&MLi,MG_FILE_NOFILE,MainCatBlock),1);
  225.      else
  226.       NewMessage(GetString(&MLi,MG_FILE_NODIR,MainCatBlock),1);
  227.    else
  228.     NewMessage(GetString(&MLi,MG_FILE_NODATA,MainCatBlock),1);
  229.  }
  230.  
  231. int SaveOne(struct DumpNode *Node1)
  232.  {ULONG Length,BLength;
  233.   Length=58;
  234.  
  235.   BLength=Node1->DumpLength;
  236.   if (BLength & 1)
  237.     BLength++;
  238.  
  239.   Length+=8+BLength;
  240.  
  241.   BLength=Node1->DataLength;
  242.   if (BLength & 1)
  243.     BLength++;
  244.  
  245.   if (BLength)
  246.     Length+=8+BLength;
  247.  
  248.   fwrite("FORM",4,1,F);
  249.   if (!errno)
  250.     fwrite(&Length,4,1,F);
  251.   if (!errno)
  252.     fwrite("MDDP",4,1,F);
  253.  
  254.   if (!errno)
  255.     fwrite("HEAD\0\0\0\x32",4,2,F);
  256.   if (!errno)
  257.     fwrite(&Node1->Flags,50,1,F);
  258.  
  259.   if (!errno)
  260.     fwrite("MIDI",4,1,F);
  261.   if (!errno)
  262.     fwrite(&Node1->DumpLength,4,1,F);
  263.   if (!errno)
  264.     fwrite(Node1->Dump,1,Node1->DumpLength,F);
  265.   if (!errno && (Node1->DumpLength & 1))
  266.     fputc(0,F);
  267.  
  268.   if (Node1->DataLength)
  269.    {
  270.     if (!errno)
  271.       fwrite("DRIV",4,1,F);
  272.     if (!errno)
  273.       fwrite(&Node1->DataLength,4,1,F);
  274.     if (!errno)
  275.       fwrite(Node1->Data,1,Node1->DataLength,F);
  276.     if (!errno && (Node1->DataLength & 1))
  277.       fputc(0,F);
  278.    }
  279.   return (errno);
  280.  }
  281.  
  282. int LoadRaw()
  283.  {
  284.   ULONG index=0,start,end;
  285.   int c,stop=0,returnCode=0;
  286.  
  287.   fseek(F,0,SEEK_SET);
  288.  
  289.   c=fgetc(F);
  290.   if (c==EOF)
  291.     stop=1;
  292.  
  293.   while (c!=EOF && !returnCode)
  294.    {
  295.     while ((c!=0xF0) && (c!=EOF))
  296.      {
  297.       index++;
  298.       c=fgetc(F);
  299.      }
  300.     if (c==0xF0)
  301.       start=index;
  302.  
  303.     index++;
  304.     c=fgetc(F);
  305.  
  306.     while (!(c & 0x80) && (c!=EOF))
  307.      {
  308.       index++;
  309.       c=fgetc(F);
  310.      }
  311.     if (c==0xF7)
  312.      {
  313.       end=index;
  314.       returnCode=ReadRaw(start,end,F);
  315.      }
  316.    }
  317.   return (returnCode);
  318.  }
  319.  
  320. int ReadRaw(ULONG start,ULONG end,FILE *fp)
  321.  {struct DumpNode *Node;
  322.   int returnCode=0;
  323.  
  324.   if (!fseek(fp,start,SEEK_SET))
  325.    {
  326.     if (Node=AllocMem(sizeof(struct DumpNode),MEMF_CLEAR))
  327.      {
  328.       if (Node->Dump=AllocMem((end-start+1),0L))
  329.        {
  330.         Node->DumpLength=(end-start+1);
  331.         if ((end-start+1)==fread(Node->Dump,1,end-start+1,fp))
  332.          { Node->Name[0]=0;
  333.            Node->Type[0]=0;
  334.            AddDumpToList(Node);
  335.          }
  336.          else
  337.          {
  338.           returnCode=MG_FILE_IO_ERROR;
  339.           FreeMem(Node->Dump,(end-start+1));
  340.           FreeMem(Node,sizeof(struct DumpNode));
  341.          }
  342.        }
  343.        else
  344.        {
  345.         returnCode=MG_FI_OUT_OF_MEMORY;
  346.         FreeMem(Node,sizeof(struct DumpNode));
  347.        }
  348.      }
  349.      else
  350.       returnCode=MG_FI_OUT_OF_MEMORY;
  351.    }
  352.  
  353.   return (returnCode);
  354.  }
  355.  
  356. int LoadIff(ULONG *Length)
  357.  {ULONG ID,BR,FSize,FLength,CSize;
  358.   int ReturnCode=0;
  359.   struct DumpNode* Node;
  360.  
  361.   BR=fread(&ID,4,1,F);
  362.   *Length+=4;
  363.  
  364.   if (BR==1)
  365.    {BR=fread(&FSize,4,1,F);
  366.     *Length+=4;
  367.    }
  368.    else
  369.     BR=0;
  370.  
  371.   if (BR==1)
  372.     switch(ID)
  373.      {case ID_FORM:
  374.  
  375.         BR=fread(&ID,4,1,F);
  376.         *Length+=4;
  377.         FLength=4;
  378.  
  379.         if (BR==1)
  380.           if (ID==ID_MDDP)
  381.            {
  382.             if (Node=AllocMem(sizeof(struct DumpNode),MEMF_CLEAR))
  383.               do
  384.                {
  385.                 BR=fread(&ID,4,1,F);
  386.                 *Length+=4;
  387.                 FLength+=4;
  388.  
  389.                 if (BR==1)
  390.                   switch(ID)
  391.                    {case ID_HEAD:
  392.                       BR=fread(&CSize,4,1,F);
  393.                       *Length+=4;
  394.                       FLength+=4;
  395.                       if ((BR==1) && (CSize>=0x32))
  396.                        {BR=fread(&(Node->Flags),50,1,F);
  397.                         if (BR==1)
  398.                          {*Length+=CSize;
  399.                           FLength+=CSize;
  400.                           if (CSize & 1)
  401.                             CSize++;
  402.                           if (CSize>0x32)
  403.                             if (fseek(F,CSize-0x32,SEEK_CUR))
  404.                               BR=0;
  405.                          }
  406.                          else
  407.                            BR=0;
  408.                        }
  409.                        else
  410.                          BR=0;
  411.                       break;
  412.  
  413.                     case ID_MIDI:
  414.                       BR=fread(&CSize,4,1,F);
  415.                       if (BR==1)
  416.                        {
  417.                         *Length+=4;
  418.                         FLength+=4;
  419.                         if (Node->Dump)
  420.                          {if (CSize & 1)
  421.                             CSize++;
  422.                           *Length+=CSize;
  423.                           FLength+=CSize;
  424.                           if (fseek(F,CSize,SEEK_CUR))
  425.                             BR=0;
  426.                          }
  427.                          else
  428.                           if (Node->Dump=AllocMem(CSize,0L))
  429.                            {
  430.                             Node->DumpLength=CSize;
  431.                             BR=fread(Node->Dump,1,CSize,F);
  432.                             if (BR==CSize)
  433.                              {*Length+=CSize;
  434.                               FLength+=CSize;
  435.                               if (CSize & 1)
  436.                                {CSize++;
  437.                                 *Length++;
  438.                                 FLength++;
  439.                                 if (fseek(F,1,SEEK_CUR))
  440.                                   BR=0;
  441.                                }
  442.                              }
  443.                              else
  444.                               BR=0;
  445.                            }
  446.                            else
  447.                            {ReturnCode=MG_FI_OUT_OF_MEMORY;
  448.                             BR=0;
  449.                            }
  450.                        }
  451.                       break;
  452.  
  453.                     case ID_DATA:
  454.                       BR=fread(&CSize,4,1,F);
  455.                       if (BR==1)
  456.                        {
  457.                         *Length+=4;
  458.                         FLength+=4;
  459.                         if (Node->Data)
  460.                          {if (CSize & 1)
  461.                             CSize++;
  462.                           *Length+=CSize;
  463.                           FLength+=CSize;
  464.                           if (fseek(F,CSize,SEEK_CUR))
  465.                             BR=0;
  466.                          }
  467.                          else
  468.                           if (Node->Data=AllocMem(CSize,0L))
  469.                            {Node->DataLength=CSize;
  470.                             BR=fread(Node->Data,1,CSize,F);
  471.                             if (BR==CSize)
  472.                              {*Length+=CSize;
  473.                               FLength+=CSize;
  474.                               if (CSize & 1)
  475.                                {CSize++;
  476.                                 *Length++;
  477.                                 FLength++;
  478.                                 if (fseek(F,1,SEEK_CUR))
  479.                                   BR=0;
  480.                                }
  481.                              }
  482.                              else
  483.                               BR=0;
  484.                            }
  485.                            else
  486.                            {ReturnCode=MG_FI_OUT_OF_MEMORY;
  487.                             BR=0;
  488.                            }
  489.                        }
  490.                       break;
  491.  
  492.                     default:
  493.                       BR=fread(&CSize,4,1,F);
  494.                       if (BR==1)
  495.                        {
  496.                         if (CSize & 1)
  497.                           CSize++;
  498.                         *Length+=4+CSize;
  499.                         FLength+=4+CSize;
  500.                         if (fseek(F,CSize,SEEK_CUR))
  501.                           BR=0;
  502.                        }
  503.                    }
  504.                }
  505.               while (BR && (FLength<FSize));
  506.              else
  507.              {ReturnCode=MG_FI_OUT_OF_MEMORY;
  508.               BR=0;
  509.              }
  510.             if (!BR && Node)
  511.              {if (Node->Dump)
  512.                 FreeMem(Node->Dump,Node->DumpLength);
  513.               if (Node->Data)
  514.                 FreeMem(Node->Data,Node->DataLength);
  515.               FreeMem(Node,sizeof(struct DumpNode));
  516.              }
  517.             if (Node)
  518.               AddDumpToList(Node);
  519.            }
  520.            else
  521.            {
  522.             if (FSize & 1)
  523.               FSize++;
  524.             if (fseek(F,FSize-4,SEEK_CUR))
  525.               BR=0;
  526.            }
  527.          else
  528.           BR=0;
  529.  
  530.         break;
  531.  
  532.       case ID_LIST:
  533.       case ID_CAT:
  534.  
  535.         BR=fread(&ID,4,1,F);
  536.         *Length+=4;
  537.         FLength=4;
  538.  
  539.         if (BR==1)
  540.           if ((ID==ID_MDDP) || (ID==ID_NULL))
  541.             do
  542.               if (ReturnCode=LoadIff(&FLength))
  543.                 BR=0;
  544.             while ((FLength<FSize) && BR);
  545.            else
  546.            {
  547.             if (FSize & 1)
  548.               FSize++;
  549.             if (fseek(F,FSize-4,SEEK_CUR))
  550.               BR=0;
  551.            }
  552.          else
  553.           BR=0;
  554.         break;
  555.  
  556.       default:
  557.  
  558.         ReturnCode=MG_FI_NOTIFF;
  559.  
  560.         break;
  561.  
  562.      }
  563.   if (!BR && ReturnCode)
  564.     ReturnCode=MG_FILE_IO_ERROR;
  565.  
  566.   return(ReturnCode);
  567.  }
  568.