home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 15 / MA_Cover_15.iso / source / winquake / cdplayer_pragmas.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-25  |  6.9 KB  |  242 lines
  1. /* Pragmas for Amiga PPC interface to cdplayer.library */
  2.  
  3. #ifndef _PPCPRAGMA_CDPLAYER_H
  4. #define _PPCPRAGMA_CDPLAYER_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__ASL_H
  7. #include <ppcinline/asl.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef CDPLAYER_BASE_NAME
  24. #define CDPLAYER_BASE_NAME CDPlayerBase
  25. #endif /* !CDPLAYER_BASE_NAME */
  26.  
  27. #define CDEject(io_ptr) _CDEject(CDPLAYER_BASE_NAME,io_ptr)
  28.  
  29. static __inline BYTE _CDEject (void *CD_PLAYER_BASE, struct IOStdReq *io_ptr)
  30. {
  31. struct Caos    MyCaos;
  32.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  33. //    MyCaos.M68kStart    =    NULL;
  34. //    MyCaos.M68kSize        =    0;
  35.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  36. //    MyCaos.PPCStart        =    NULL;
  37. //    MyCaos.PPCSize        =    0;
  38.     MyCaos.a5        =(ULONG) io_ptr;
  39.     MyCaos.caos_Un.Offset    =    (-30);
  40.     MyCaos.a6        =(ULONG) CD_PLAYER_BASE;
  41.     return((BYTE)PPCCallOS(&MyCaos));
  42. }
  43.  
  44. #define CDPlay(starttrack,endtrack,io_ptr) _CDPlay(CDPLAYER_BASE_NAME,starttrack,endtrack,io_ptr)
  45.  
  46. static __inline BYTE _CDPlay (void *CD_PLAYER_BASE, UBYTE starttrack, UBYTE endtrack, struct IOStdReq *io_ptr)
  47. {
  48. struct Caos    MyCaos;
  49.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  50. //    MyCaos.M68kStart    =    NULL;
  51. //    MyCaos.M68kSize        =    0;
  52.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  53. //    MyCaos.PPCStart        =    NULL;
  54. //    MyCaos.PPCSize        =    0;
  55.     MyCaos.a0        =(ULONG) starttrack;
  56.     MyCaos.a1        =(ULONG) endtrack;
  57.     MyCaos.a5        =(ULONG) io_ptr;
  58.     MyCaos.caos_Un.Offset    =    (-36);
  59.     MyCaos.a6        =(ULONG) CD_PLAYER_BASE;    
  60.     return((BYTE)PPCCallOS(&MyCaos));
  61. }
  62.  
  63. #define CDResume(mode,io_ptr) _CDResume(CDPLAYER_BASE_NAME,mode,io_ptr)
  64.  
  65. static __inline BYTE _CDResume (void *CD_PLAYER_BASE, BOOL mode, struct IOStdReq *io_ptr)
  66. {
  67. struct Caos    MyCaos;
  68.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  69. //    MyCaos.M68kStart    =    NULL;
  70. //    MyCaos.M68kSize        =    0;
  71.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  72. //    MyCaos.PPCStart        =    NULL;
  73. //    MyCaos.PPCSize        =    0;
  74.     MyCaos.a0        =(ULONG) mode;
  75.     MyCaos.a5        =(ULONG) io_ptr;
  76.     MyCaos.caos_Un.Offset    =    (-42);
  77.     MyCaos.a6        =(ULONG) CD_PLAYER_BASE;    
  78.     return((BYTE)PPCCallOS(&MyCaos));
  79. }
  80.  
  81. #define CDStop(io_ptr) _CDStop(CDPLAYER_BASE_NAME,io_ptr)
  82.  
  83. static __inline BYTE _CDStop (void *CD_PLAYER_BASE, struct IOStdReq *io_ptr)
  84. {
  85. struct Caos    MyCaos;
  86.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  87. //    MyCaos.M68kStart    =    NULL;
  88. //    MyCaos.M68kSize        =    0;
  89.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  90. //    MyCaos.PPCStart        =    NULL;
  91. //    MyCaos.PPCSize        =    0;
  92.     MyCaos.a5        =(ULONG) io_ptr;
  93.     MyCaos.caos_Un.Offset    =    (-48);
  94.     MyCaos.a6        =(ULONG) CD_PLAYER_BASE;    
  95.     return((BYTE)PPCCallOS(&MyCaos));
  96. }
  97.  
  98. #define CDJump(blocks,io_ptr) _CDJump(CDPLAYER_BASE_NAME,blocks,io_ptr)
  99.  
  100. static __inline BYTE _CDJump (void *CD_PLAYER_BASE, ULONG blocks, struct IOStdReq *io_ptr)
  101. {
  102. struct Caos    MyCaos;
  103.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  104. //    MyCaos.M68kStart    =    NULL;
  105. //    MyCaos.M68kSize        =    0;
  106.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  107. //    MyCaos.PPCStart        =    NULL;
  108. //    MyCaos.PPCSize        =    0;
  109.     MyCaos.a0        =(ULONG) blocks;
  110.     MyCaos.a5        =(ULONG) io_ptr;
  111.     MyCaos.caos_Un.Offset    =    (-54);
  112.     MyCaos.a6        =(ULONG) CD_PLAYER_BASE;    
  113.     return((BYTE)PPCCallOS(&MyCaos));
  114. }
  115.  
  116. #define CDActive(io_ptr) _CDActive(CDPLAYER_BASE_NAME,io_ptr)
  117.  
  118. static __inline BOOL _CDActive (void *CD_PLAYER_BASE, struct IOStdReq *io_ptr)
  119. {
  120. struct Caos    MyCaos;
  121.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  122. //    MyCaos.M68kStart    =    NULL;
  123. //    MyCaos.M68kSize        =    0;
  124.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  125. //    MyCaos.PPCStart        =    NULL;
  126. //    MyCaos.PPCSize        =    0;
  127.     MyCaos.a5        =(ULONG) io_ptr;
  128.     MyCaos.caos_Un.Offset    =    (-60);
  129.     MyCaos.a6        =(ULONG) CD_PLAYER_BASE;    
  130.     return((BYTE)PPCCallOS(&MyCaos));
  131. }
  132.  
  133. #define CDCurrentTitle(io_ptr) _CDCurrentTitle(CDPLAYER_BASE_NAME,io_ptr)
  134.  
  135. static __inline ULONG _CDCurrentTitle (void *CD_PLAYER_BASE, struct IOStdReq *io_ptr)
  136. {
  137. struct Caos    MyCaos;
  138.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  139. //    MyCaos.M68kStart    =    NULL;
  140. //    MyCaos.M68kSize        =    0;
  141.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  142. //    MyCaos.PPCStart        =    NULL;
  143. //    MyCaos.PPCSize        =    0;
  144.     MyCaos.a5        =(ULONG) io_ptr;
  145.     MyCaos.caos_Un.Offset    =    (-66);
  146.     MyCaos.a6        =(ULONG) CD_PLAYER_BASE;    
  147.     return((ULONG)PPCCallOS(&MyCaos));
  148. }
  149.  
  150. #define CDTitleTime(cd_time,io_ptr) _CDTitleTime(CDPLAYER_BASE_NAME,cd_time,io_ptr)
  151.  
  152. static __inline BYTE _CDTitleTime (void *CD_PLAYER_BASE, struct CD_Time *cd_time, struct IOStdReq *io_ptr)
  153. {
  154. struct Caos    MyCaos;
  155.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  156. //    MyCaos.M68kStart    =    NULL;
  157. //    MyCaos.M68kSize        =    0;
  158.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  159. //    MyCaos.PPCStart        =    NULL;
  160. //    MyCaos.PPCSize        =    0;
  161.     MyCaos.a0        =(ULONG) cd_time;
  162.     MyCaos.a5        =(ULONG) io_ptr;
  163.     MyCaos.caos_Un.Offset    =    (-72);
  164.     MyCaos.a6        =(ULONG) CD_PLAYER_BASE;    
  165.     return((BYTE)PPCCallOS(&MyCaos));
  166. }
  167.  
  168. #define CDGetVolume(cd_volume,io_ptr) _CDGetVolume(CDPLAYER_BASE_NAME,cd_volume,io_ptr)
  169.  
  170. static __inline BYTE _CDGetVolume (void *CD_PLAYER_BASE, struct CD_Volume *cd_volume, struct IOStdReq *io_ptr)
  171. {
  172. struct Caos    MyCaos;
  173.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  174. //    MyCaos.M68kStart    =    NULL;
  175. //    MyCaos.M68kSize        =    0;
  176.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  177. //    MyCaos.PPCStart        =    NULL;
  178. //    MyCaos.PPCSize        =    0;
  179.     MyCaos.a0        =(ULONG) cd_volume;
  180.     MyCaos.a5        =(ULONG) io_ptr;
  181.     MyCaos.caos_Un.Offset    =    (-78);
  182.     MyCaos.a6        =(ULONG) CD_PLAYER_BASE;    
  183.     return((BYTE)PPCCallOS(&MyCaos));
  184. }
  185.  
  186. #define CDSetVolume(cd_volume,io_ptr) _CDSetVolume(CDPLAYER_BASE_NAME,cd_volume,io_ptr)
  187.  
  188. static __inline BYTE _CDSetVolume (void *CD_PLAYER_BASE, struct CD_Volume *cd_volume, struct IOStdReq *io_ptr)
  189. {
  190. struct Caos    MyCaos;
  191.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  192. //    MyCaos.M68kStart    =    NULL;
  193. //    MyCaos.M68kSize        =    0;
  194.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  195. //    MyCaos.PPCStart        =    NULL;
  196. //    MyCaos.PPCSize        =    0;
  197.     MyCaos.a0        =(ULONG) cd_volume;
  198.     MyCaos.a5        =(ULONG) io_ptr;
  199.     MyCaos.caos_Un.Offset    =    (-84);
  200.     MyCaos.a6        =(ULONG) CD_PLAYER_BASE;    
  201.     return((BYTE)PPCCallOS(&MyCaos));
  202. }
  203.  
  204. #define CDReadTOC(toc,io_ptr) _CDReadTOC(CDPLAYER_BASE_NAME,toc,io_ptr)
  205.  
  206. static __inline BYTE _CDReadTOC (void *CD_PLAYER_BASE, struct CD_TOC *toc, struct IOStdReq *io_ptr)
  207. {
  208. struct Caos    MyCaos;
  209.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  210. //    MyCaos.M68kStart    =    NULL;
  211. //    MyCaos.M68kSize        =    0;
  212.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  213. //    MyCaos.PPCStart        =    NULL;
  214. //    MyCaos.PPCSize        =    0;
  215.     MyCaos.a0        =(ULONG) toc;
  216.     MyCaos.a5        =(ULONG) io_ptr;
  217.     MyCaos.caos_Un.Offset    =    (-90);
  218.     MyCaos.a6        =(ULONG) CD_PLAYER_BASE;    
  219.     return((BYTE)PPCCallOS(&MyCaos));
  220. }
  221.  
  222. #define CDInfo (cd_info,io_ptr) _CDInfo (CDPLAYER_BASE,cd_info,io_ptr)
  223.  
  224. static __inline BYTE _CDInfo(void *CD_PLAYER_BASE, struct CD_Info *cd_info, struct IOStdReq *io_ptr)
  225. {
  226. struct Caos    MyCaos;
  227.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  228. //    MyCaos.M68kStart    =    NULL;
  229. //    MyCaos.M68kSize        =    0;
  230.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  231. //    MyCaos.PPCStart        =    NULL;
  232. //    MyCaos.PPCSize        =    0;
  233.     MyCaos.a0        =(ULONG) cd_info;
  234.     MyCaos.a5        =(ULONG) io_ptr;
  235.     MyCaos.caos_Un.Offset    =    (-96);
  236.     MyCaos.a6        =(ULONG) CD_PLAYER_BASE;    
  237.     return((BYTE)PPCCallOS(&MyCaos));
  238. }
  239.  
  240. #endif /* SASC Pragmas */
  241. #endif /* !_PPCPRAGMA_CDPLAYER_H */
  242.