home *** CD-ROM | disk | FTP | other *** search
/ Computer Club Elmshorn Atari PD / CCE_PD.iso / pc / 0600 / CCE_0616.ZIP / CCE_0616.PD / AUDIOFUN / SWK_BIND.C < prev   
C/C++ Source or Header  |  1993-05-30  |  11KB  |  296 lines
  1. /******************************************************************************/
  2. /*                                                                            */
  3. /*                                SWK_BIND.C                                  */
  4. /*                                ----------                                  */
  5. /*                                                                            */
  6. /*                       Binding für SOUNDWORKER V1.0                         */
  7. /*                                                                            */
  8. /*                            Sprache: Sozobon C                              */
  9. /*                                                                            */
  10. /******************************************************************************/
  11.  
  12. #ifndef ERRNO_H
  13. #include <errno.h>
  14. #endif
  15.  
  16. #ifndef STDIO_H
  17. #include <stdio.h>
  18. #endif
  19.  
  20. #ifndef STRING_H
  21. #include <string.h>
  22. #endif
  23.  
  24. #ifndef OSBIND_H
  25. #include <osbind.h>
  26. #endif
  27.  
  28.  
  29.  
  30. /******************************************************************************/
  31. /*                                                                            */
  32. /*   Wird das AUDIOFUN-File zum Programm gelinkt, muß folgende Struktur als   */
  33. /*    extern deklariert werden. Die Funktion SWK_LOAD kann dann entfallen.    */
  34. /*                                                                            */
  35. /******************************************************************************/
  36.  
  37. /* extern */ struct
  38. {
  39.    char id[18];
  40.    int in_out[3];
  41.    int time[3];
  42.    void *execute[3];
  43.    int last;
  44.    int ret_0;
  45.    int ret_1;
  46.    long swk_on;
  47.    long swk_off;
  48.    long joy_on;
  49.    long joy_off;
  50.    int swk_prog[2480];
  51. } swk;
  52.  
  53.  
  54.  
  55. /******************************************************************************/
  56. /*                                                                            */
  57. /*                                   SWK_LOAD                                 */
  58. /*                                                                            */
  59. /*                  Eingabe: char *filename                                   */
  60. /*                                                                            */
  61. /*                  Ausgabe:    TRUE -> Erfolgreich geladen                   */
  62. /*                             FALSE -> falsche Datei                         */
  63. /*                           negativ -> Fehler                                */
  64. /*                                                                            */
  65. /******************************************************************************/
  66.  
  67. int swk_load(filename)
  68. char *filename;
  69. {
  70.    register FILE *filepoin;
  71.    register int size, lret, errnum;
  72.  
  73.    size = sizeof(swk) / sizeof(int);
  74.  
  75.    filepoin = fopen(filename, "r");
  76.  
  77.    if(!filepoin)
  78.       errnum = errno;
  79.    else
  80.    {
  81.       lret = fread(&swk, sizeof(int), size, filepoin);
  82.       errnum = errno;
  83.       fclose(filepoin);
  84.  
  85.       if(lret != size)
  86.       {
  87.          if(errnum >= 0)
  88.             errnum = ENSMEM;
  89.       }
  90.       else
  91.       {
  92.          if(!strcmp(swk.id, "SOUNDWORKER V1.0"))
  93.             errnum = TRUE;
  94.          else
  95.             errnum = FALSE;
  96.       }
  97.    }
  98.    return(errnum);
  99. }
  100.  
  101.  
  102.  
  103. /******************************************************************************/
  104. /*                                                                            */
  105. /*                                   SWK_START                                */
  106. /*                                                                            */
  107. /******************************************************************************/
  108.  
  109. void swk_start()
  110. {
  111.    Supexec(&swk.swk_on);
  112. }
  113.  
  114.  
  115.  
  116. /******************************************************************************/
  117. /*                                                                            */
  118. /*                                   SWK_STOP                                 */
  119. /*                                                                            */
  120. /******************************************************************************/
  121.  
  122. void swk_stop()
  123. {
  124.    Supexec(&swk.swk_off);
  125. }
  126.  
  127.  
  128.  
  129. /******************************************************************************/
  130. /*                                                                            */
  131. /*                                   SWK_PLAY                                 */
  132. /*                                                                            */
  133. /*       Eingabe: channel ->     0 ... 2                                      */
  134. /*                   part -> +/- 1 ... 8 startet den Kanal                    */
  135. /*                                       sonst  stummschalten                 */
  136. /*                                                                            */
  137. /******************************************************************************/
  138.  
  139. void swk_play(channel, part)
  140. int channel, part;
  141. {
  142.    if((channel >= 0) && (channel <= 2))
  143.       swk.in_out[channel] = part;
  144. }
  145.  
  146.  
  147.  
  148. /******************************************************************************/
  149. /*                                                                            */
  150. /*                                   SWK_TILL                                 */
  151. /*                                                                            */
  152. /*        Eingabe: channel -> 0 ... 2                                         */
  153. /*                    last -> Anzahl der zu spielenden Töne                   */
  154. /*                                                                            */
  155. /******************************************************************************/
  156.  
  157. void swk_till(channel, last)
  158. int channel, last;
  159. {
  160.    if((channel >= 0) && (channel <= 2))
  161.       swk.time[channel] = last;
  162. }
  163.  
  164.  
  165.  
  166. /******************************************************************************/
  167. /*                                                                            */
  168. /*                                   SWK_EXEC                                 */
  169. /*                                                                            */
  170. /*     Eingabe: channel -> 0 ... 2                                            */
  171. /*                begin -> Taktnummer zum Starten der Routine                 */
  172. /*              routine -> Startadresse der Routine                           */
  173. /*                                                                            */
  174. /******************************************************************************/
  175.  
  176. void swk_exec(channel, begin, routine)
  177. int channel, begin;
  178. void *routine;
  179. {
  180.    if((channel >= 0) && (channel <= 2))
  181.    {
  182.       swk.time[channel] = begin;
  183.       swk.execute[channel] = routine;
  184.    }
  185. }
  186.  
  187.  
  188.  
  189. /******************************************************************************/
  190. /*                                                                            */
  191. /*                                   SWK_TIME                                 */
  192. /*                                                                            */
  193. /*          Eingabe: channel -> 0 ... 2                                       */
  194. /*                                                                            */
  195. /*          Ausgabe: momentan gespielter Takt oder Null, wenn stumm           */
  196. /*                                                                            */
  197. /******************************************************************************/
  198.  
  199. int swk_time(channel)
  200. int channel;
  201. {
  202.    if((channel >= 0) && (channel <= 2))
  203.       return(swk.in_out[channel] & 0x00FF);
  204. }
  205.  
  206.  
  207.  
  208. /******************************************************************************/
  209. /*                                                                            */
  210. /*                                   SWK_PART                                 */
  211. /*                                                                            */
  212. /*         Eingabe: channel -> 0 ... 2                                        */
  213. /*                                                                            */
  214. /*         Ausgabe: momentan gespielter Part oder Null, wenn stumm            */
  215. /*                                                                            */
  216. /******************************************************************************/
  217.  
  218. int swk_part(channel)
  219. int channel;
  220. {
  221.    if((channel >= 0) && (channel <= 2))
  222.       return(swk.in_out[channel] >> 8);
  223. }
  224.  
  225.  
  226.  
  227. /******************************************************************************/
  228. /*                                                                            */
  229. /*                                   JOY_START                                */
  230. /*                                                                            */
  231. /******************************************************************************/
  232.  
  233. void joy_start()
  234. {
  235.    Supexec(&swk.joy_on);
  236. }
  237.  
  238.  
  239.  
  240. /******************************************************************************/
  241. /*                                                                            */
  242. /*                                   JOY_STOP                                 */
  243. /*                                                                            */
  244. /******************************************************************************/
  245.  
  246. void joy_stop()
  247. {
  248.    Supexec(&swk.joy_off);
  249. }
  250.  
  251.  
  252.  
  253. /******************************************************************************/
  254. /*                                                                            */
  255. /*                                 JOY_LAST                                   */
  256. /*                                                                            */
  257. /******************************************************************************/
  258.  
  259. int joy_last()
  260. {
  261.    return(swk.last);
  262. }
  263.  
  264.  
  265.  
  266. /******************************************************************************/
  267. /*                                                                            */
  268. /*                                   JOY_0                                    */
  269. /*                                                                            */
  270. /******************************************************************************/
  271.  
  272. int joy_0()
  273. {
  274.    return(swk.ret_0);
  275. }
  276.  
  277.  
  278.  
  279.  
  280. /******************************************************************************/
  281. /*                                                                            */
  282. /*                                   JOY_1                                    */
  283. /*                                                                            */
  284. /******************************************************************************/
  285.  
  286. int joy_1()
  287. {
  288.    return(swk.ret_1);
  289. }
  290.  
  291.  
  292.  
  293.  
  294.  
  295. /* EOF */
  296.