home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga Shareware Floppies / ma58.dms / ma58.adf / superplay-lib_DEV / Programmers / Example_SPObjects / SPO / SP_WriteSubs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-27  |  6.0 KB  |  168 lines
  1.  
  2.  /* SP_WriteSubs.c
  3.     - Functions for Writing of SPO-Files
  4.     (c) 1990-94 by Andreas R. Kleinert
  5.     Last changes : 21.07.1994
  6.  */
  7.  
  8. #include "spobject.h"
  9.  
  10.  
  11.  /* PUBLIC functions */
  12.  
  13. ULONG __saveds __asm SPO_Write( register __a1 struct SPObjectHandle *SPObjectHandle_a1,
  14.                                 register __a2 struct SPObjectBase   *SPO_SourceBase,
  15.                                 register __a3 struct SPObjectHandle *source_handle);
  16.  
  17.  
  18. ULONG __saveds __stdargs SPLI_SaveSample(struct SPObjectHandle *SPObjectHandle,
  19.                                          UBYTE *destname,
  20.                                          UBYTE *buffer, ULONG buffersize,
  21.                                          ULONG samplespersec, ULONG volume,
  22.                                          ULONG samplebits);
  23.  
  24. /* *************************************************** */
  25. /* *                             * */
  26. /* * SPO_Write : ...                                 * */
  27. /* *                             * */
  28. /* *************************************************** */
  29.  
  30. /* Use these because of unwished interferences because of same-named
  31.    functions inside this library */
  32. ULONG SPO2_GetSampleBuffer(  APTR handle, UBYTE **buffer, ULONG *buffersize);
  33. ULONG SPO2_GetSampleInfo(    APTR handle, ULONG *samplesPerSec, ULONG *volume, APTR future);
  34. ULONG SPO2_GetSampleList(    APTR handle, struct SPO_SampleList **samplelist);
  35.  
  36.  
  37. #pragma libcall SPObjectBase2 SPO2_GetSampleBuffer  84 ba903
  38. #pragma libcall SPObjectBase2 SPO2_GetSampleInfo    8a 1ba904
  39. #pragma libcall SPObjectBase2 SPO2_GetSampleList    90 a902
  40.  
  41.  
  42. ULONG __saveds __asm SPO_Write( register __a1 struct SPObjectHandle *SPObjectHandle_a1,
  43.                                 register __a2 struct SPObjectBase   *SPO_SourceBase,
  44.                                 register __a3 struct SPObjectHandle *source_handle)
  45. {
  46.  struct SPObjectHandle *SPObjectHandle = SPObjectHandle_a1;
  47.  ULONG retval = SPERR_NO_ERROR;
  48.  
  49.  struct SPObjectBase    *SPObjectBase2 = SPO_SourceBase;
  50.  struct SPO_SampleList  *SampleList = N;
  51.  struct SPO_SampleEntry *entry;
  52.  ULONG                   count = N;
  53.  char                filename [256];
  54.  UBYTE                   name [256];
  55.  
  56.  
  57.  if(!SPObjectHandle) return(SPERR_NO_HANDLE);
  58.  
  59.  if(SPObjectHandle->ah_Medium != SPO_MEDIUM_DISK) return(SPERR_ACTION_NOT_SUPPORTED);
  60.  
  61.  if(strlen(SPObjectHandle->ah_WriteName) > 4)
  62.   {
  63.    if(!stricmp(&SPObjectHandle->ah_WriteName[strlen(SPObjectHandle->ah_WriteName)-4], ".spo"))
  64.     {
  65.           strcpy(filename,     SPObjectHandle->ah_WriteName);
  66.           filename[strlen(filename)-4] = (char) 0;
  67.     }else strcpy(filename,     SPObjectHandle->ah_WriteName);
  68.   }else   strcpy(filename,     SPObjectHandle->ah_WriteName);
  69.  
  70.  if(!SPObjectHandle->ah_SaveSampleList)
  71.   {
  72.    if(!SPO_SourceBase) return(SPERR_ILLEGAL_ACCESS);
  73.    if(!source_handle)  return(SPERR_NO_HANDLE);
  74.  
  75.    if(LibVer(SPO_SourceBase) < 2)
  76.     {
  77.      UBYTE *buffer;
  78.      ULONG  buffersize, spsec, volume;
  79.  
  80.                  retval = SPO2_GetSampleBuffer(source_handle, &buffer, &buffersize);
  81.      if(!retval) retval = SPO2_GetSampleInfo(source_handle, &spsec, &volume, N);
  82.      if(!retval) retval = SPLI_SaveSample(SPObjectHandle,
  83.                                           filename,
  84.                                           buffer,
  85.                                           buffersize,
  86.                                           spsec,
  87.                                           volume,
  88.                                           8);
  89.  
  90.      return(retval);
  91.  
  92.    } /* ELSE : */
  93.  
  94.    retval = SPO2_GetSampleList(source_handle, &SampleList);
  95.    if(retval) return(retval);
  96.  
  97.   }else SampleList = SPObjectHandle->ah_SaveSampleList;
  98.  
  99.  if(!SampleList) return(SPERR_ILLEGAL_ACCESS);
  100.  
  101.  SPObjectHandle->ah_SPOHeader = (struct SPOHeader *) AllocVec(sizeof(struct SPOHeader), (MEMF_CLEAR|MEMF_PUBLIC));
  102.  if(!SPObjectHandle->ah_SPOHeader) return(SPERR_NO_MEMORY);
  103.  
  104.  for(entry=(APTR) SampleList->sl_EntryList.lh_Head;(entry)&&(entry!=(APTR) &(SampleList->sl_EntryList.lh_Tail));)
  105.   {
  106.    if(entry->se_Type == SE_TYPE_SAMPLE)
  107.     {
  108.      SPO_FreeResources(SPObjectHandle);
  109.  
  110.      strcpy(name, filename);
  111.  
  112.      if(count++ > 0) sprintf(&name[strlen(name)], "_%ld", count);
  113.  
  114.      retval = SPLI_SaveSample(SPObjectHandle,
  115.                               name,
  116.                               entry->se_SampleBuffer,
  117.                               entry->se_SampleSize,
  118.                               entry->se_SamplesPerSec,
  119.                               entry->se_Volume,
  120.                               entry->se_SampleBits);
  121.  
  122.      if(retval) break;
  123.     }
  124.  
  125.    entry = (APTR) entry->se_Node.ln_Succ;
  126.   }
  127.  
  128.  return(retval);
  129. }
  130.  
  131. ULONG __saveds __stdargs SPLI_SaveSample(struct SPObjectHandle *SPObjectHandle,
  132.                                          UBYTE *destname,
  133.                                          UBYTE *buffer, ULONG buffersize,
  134.                                          ULONG samplespersec, ULONG volume,
  135.                                          ULONG samplebits)
  136. {
  137.  ULONG retval = SPERR_NO_ERROR;
  138.  char destname_spo [256];
  139.  
  140.  strcpy(destname_spo, destname);
  141.  strcat(destname_spo, ".spo");
  142.  
  143.  SPObjectHandle->ah_filehandle_dest = Open(destname_spo, MODE_NEWFILE);
  144.  if(!SPObjectHandle->ah_filehandle_dest) return(SPERR_NO_FILE);
  145.  
  146.  SPObjectHandle->ah_filehandle_dest2 = Open(destname, MODE_NEWFILE);
  147.  if(!SPObjectHandle->ah_filehandle_dest2) return(SPERR_NO_FILE);
  148.  
  149.  SPObjectHandle->ah_ramhandle = AIM_GetMemList();
  150.  if(!SPObjectHandle->ah_ramhandle) return(SPERR_NO_MEMORY);
  151.  
  152.  strcpy(SPObjectHandle->ah_SPOHeader->spo_ID, SPO_ID);
  153.  
  154.  SPObjectHandle->ah_SPOHeader->spo_SampleBits = (UBYTE) samplebits;
  155.  SPObjectHandle->ah_SPOHeader->spo_StereoFlag = (UBYTE) FALSE;
  156.  
  157.  SPObjectHandle->ah_SPOHeader->spo_Channels   = (UBYTE) 15;
  158.  SPObjectHandle->ah_SPOHeader->spo_Frequency  = (ULONG) samplespersec;
  159.  SPObjectHandle->ah_SPOHeader->spo_Volume     = (ULONG) volume;
  160.  
  161.  SPObjectHandle->ah_SPOHeader->spo_SampleLength = buffersize;
  162.  
  163.  Write(SPObjectHandle->ah_filehandle_dest,  SPObjectHandle->ah_SPOHeader, SPOHEADER_SIZE);
  164.  Write(SPObjectHandle->ah_filehandle_dest2,                       buffer,     buffersize);
  165.  
  166.  return(retval);
  167. }
  168.