/* Automatically generated header! Do not edit! */

#ifndef _PPCPRAGMA_AHI_H
#define _PPCPRAGMA_AHI_H
#ifdef __GNUC__
#ifndef _PPCINLINE__AHI_H
#include <powerup/ppcinline/ahi.h>
#endif
#else

#ifndef POWERUP_PPCLIB_INTERFACE_H
#include <powerup/ppclib/interface.h>
#endif

#ifndef POWERUP_GCCLIB_PROTOS_H
#include <powerup/gcclib/powerup_protos.h>
#endif

#ifndef NO_PPCINLINE_STDARG
#define NO_PPCINLINE_STDARG
#endif/* SAS C PPC inlines */

#ifndef AHI_BASE_NAME
#define AHI_BASE_NAME AHIBase
#endif /* !AHI_BASE_NAME */

#define	AHI_AddAudioMode(Private)	_AHI_AddAudioMode(AHI_BASE_NAME, Private)

static __inline ULONG
_AHI_AddAudioMode(void *AHIBase, struct TagItem *Private)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) Private;
	MyCaos.caos_Un.Offset	=	(-150);
	MyCaos.a6		=(ULONG) AHIBase;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define AHI_AddAudioModeTags(tags...) \
	({ULONG _tags[] = { tags }; AHI_AddAudioMode((struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	AHI_AllocAudioA(tagList)	_AHI_AllocAudioA(AHI_BASE_NAME, tagList)

static __inline struct AHIAudioCtrl *
_AHI_AllocAudioA(void *AHIBase, struct TagItem *tagList)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a1		=(ULONG) tagList;
	MyCaos.caos_Un.Offset	=	(-42);
	MyCaos.a6		=(ULONG) AHIBase;	
	return((struct AHIAudioCtrl *)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define AHI_AllocAudio(tags...) \
	({ULONG _tags[] = { tags }; AHI_AllocAudioA((struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	AHI_AllocAudioRequestA(tagList)	_AHI_AllocAudioRequestA(AHI_BASE_NAME, tagList)

static __inline struct AHIAudioModeRequester *
_AHI_AllocAudioRequestA(void *AHIBase, struct TagItem *tagList)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) tagList;
	MyCaos.caos_Un.Offset	=	(-120);
	MyCaos.a6		=(ULONG) AHIBase;	
	return((struct AHIAudioModeRequester *)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define AHI_AllocAudioRequest(tags...) \
	({ULONG _tags[] = { tags }; AHI_AllocAudioRequestA((struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	AHI_AudioRequestA(Requester, tagList)	_AHI_AudioRequestA(AHI_BASE_NAME, Requester, tagList)

static __inline BOOL
_AHI_AudioRequestA(void *AHIBase, struct AHIAudioModeRequester *Requester, struct TagItem *tagList)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) Requester;
	MyCaos.a1		=(ULONG) tagList;
	MyCaos.caos_Un.Offset	=	(-126);
	MyCaos.a6		=(ULONG) AHIBase;	
	return((BOOL)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define AHI_AudioRequest(a0, tags...) \
	({ULONG _tags[] = { tags }; AHI_AudioRequestA((a0), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	AHI_BestAudioIDA(tagList)	_AHI_BestAudioIDA(AHI_BASE_NAME, tagList)

static __inline ULONG
_AHI_BestAudioIDA(void *AHIBase, struct TagItem *tagList)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a1		=(ULONG) tagList;
	MyCaos.caos_Un.Offset	=	(-114);
	MyCaos.a6		=(ULONG) AHIBase;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define AHI_BestAudioID(tags...) \
	({ULONG _tags[] = { tags }; AHI_BestAudioIDA((struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	AHI_ControlAudioA(AudioCtrl, tagList)	_AHI_ControlAudioA(AHI_BASE_NAME, AudioCtrl, tagList)

static __inline ULONG
_AHI_ControlAudioA(void *AHIBase, struct AHIAudioCtrl *AudioCtrl, struct TagItem *tagList)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a2		=(ULONG) AudioCtrl;
	MyCaos.a1		=(ULONG) tagList;
	MyCaos.caos_Un.Offset	=	(-60);
	MyCaos.a6		=(ULONG) AHIBase;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define AHI_ControlAudio(a0, tags...) \
	({ULONG _tags[] = { tags }; AHI_ControlAudioA((a0), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	AHI_FreeAudio(AudioCtrl)	_AHI_FreeAudio(AHI_BASE_NAME, AudioCtrl)

static __inline void
_AHI_FreeAudio(void *AHIBase, struct AHIAudioCtrl *AudioCtrl)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a2		=(ULONG) AudioCtrl;
	MyCaos.caos_Un.Offset	=	(-48);
	MyCaos.a6		=(ULONG) AHIBase;	
	PPCCallOS(&MyCaos);
}

#define	AHI_FreeAudioRequest(Requester)	_AHI_FreeAudioRequest(AHI_BASE_NAME, Requester)

static __inline void
_AHI_FreeAudioRequest(void *AHIBase, struct AHIAudioModeRequester *Requester)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) Requester;
	MyCaos.caos_Un.Offset	=	(-132);
	MyCaos.a6		=(ULONG) AHIBase;	
	PPCCallOS(&MyCaos);
}

#define	AHI_GetAudioAttrsA(ID, Audioctrl, tagList)	_AHI_GetAudioAttrsA(AHI_BASE_NAME, ID, Audioctrl, tagList)

static __inline BOOL
_AHI_GetAudioAttrsA(void *AHIBase, ULONG ID, struct AHIAudioCtrl *Audioctrl, struct TagItem *tagList)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.d0		=(ULONG) ID;
	MyCaos.a2		=(ULONG) Audioctrl;
	MyCaos.a1		=(ULONG) tagList;
	MyCaos.caos_Un.Offset	=	(-108);
	MyCaos.a6		=(ULONG) AHIBase;	
	return((BOOL)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define AHI_GetAudioAttrs(a0, a1, tags...) \
	({ULONG _tags[] = { tags }; AHI_GetAudioAttrsA((a0), (a1), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	AHI_KillAudio()	_AHI_KillAudio(AHI_BASE_NAME)

static __inline void
_AHI_KillAudio(void *AHIBase)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.caos_Un.Offset	=	(-54);
	MyCaos.a6		=(ULONG) AHIBase;	
	PPCCallOS(&MyCaos);
}

#define	AHI_LoadModeFile(Private)	_AHI_LoadModeFile(AHI_BASE_NAME, Private)

static __inline ULONG
_AHI_LoadModeFile(void *AHIBase, STRPTR Private)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) Private;
	MyCaos.caos_Un.Offset	=	(-162);
	MyCaos.a6		=(ULONG) AHIBase;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#define	AHI_LoadSound(Sound, Type, Info, AudioCtrl)	_AHI_LoadSound(AHI_BASE_NAME, Sound, Type, Info, AudioCtrl)

static __inline ULONG
_AHI_LoadSound(void *AHIBase, UWORD Sound, ULONG Type, APTR Info, struct AHIAudioCtrl *AudioCtrl)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.d0		=(ULONG) Sound;
	MyCaos.d1		=(ULONG) Type;
	MyCaos.a0		=(ULONG) Info;
	MyCaos.a2		=(ULONG) AudioCtrl;
	MyCaos.caos_Un.Offset	=	(-90);
	MyCaos.a6		=(ULONG) AHIBase;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#define	AHI_NextAudioID(Last_ID)	_AHI_NextAudioID(AHI_BASE_NAME, Last_ID)

static __inline ULONG
_AHI_NextAudioID(void *AHIBase, ULONG Last_ID)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.d0		=(ULONG) Last_ID;
	MyCaos.caos_Un.Offset	=	(-102);
	MyCaos.a6		=(ULONG) AHIBase;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#define	AHI_PlayA(Audioctrl, tagList)	_AHI_PlayA(AHI_BASE_NAME, Audioctrl, tagList)

static __inline void
_AHI_PlayA(void *AHIBase, struct AHIAudioCtrl *Audioctrl, struct TagItem *tagList)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a2		=(ULONG) Audioctrl;
	MyCaos.a1		=(ULONG) tagList;
	MyCaos.caos_Un.Offset	=	(-138);
	MyCaos.a6		=(ULONG) AHIBase;	
	PPCCallOS(&MyCaos);
}

#ifndef NO_PPCINLINE_STDARG
#define AHI_Play(a0, tags...) \
	({ULONG _tags[] = { tags }; AHI_PlayA((a0), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	AHI_RemoveAudioMode(Private)	_AHI_RemoveAudioMode(AHI_BASE_NAME, Private)

static __inline ULONG
_AHI_RemoveAudioMode(void *AHIBase, ULONG Private)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.d0		=(ULONG) Private;
	MyCaos.caos_Un.Offset	=	(-156);
	MyCaos.a6		=(ULONG) AHIBase;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#define	AHI_SampleFrameSize(SampleType)	_AHI_SampleFrameSize(AHI_BASE_NAME, SampleType)

static __inline ULONG
_AHI_SampleFrameSize(void *AHIBase, ULONG SampleType)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.d0		=(ULONG) SampleType;
	MyCaos.caos_Un.Offset	=	(-144);
	MyCaos.a6		=(ULONG) AHIBase;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#define	AHI_SetEffect(Effect, AudioCtrl)	_AHI_SetEffect(AHI_BASE_NAME, Effect, AudioCtrl)

static __inline ULONG
_AHI_SetEffect(void *AHIBase, APTR Effect, struct AHIAudioCtrl *AudioCtrl)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) Effect;
	MyCaos.a2		=(ULONG) AudioCtrl;
	MyCaos.caos_Un.Offset	=	(-84);
	MyCaos.a6		=(ULONG) AHIBase;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#define	AHI_SetFreq(Channel, Freq, AudioCtrl, Flags)	_AHI_SetFreq(AHI_BASE_NAME, Channel, Freq, AudioCtrl, Flags)

static __inline void
_AHI_SetFreq(void *AHIBase, UWORD Channel, ULONG Freq, struct AHIAudioCtrl *AudioCtrl, ULONG Flags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.d0		=(ULONG) Channel;
	MyCaos.d1		=(ULONG) Freq;
	MyCaos.a2		=(ULONG) AudioCtrl;
	MyCaos.d2		=(ULONG) Flags;
	MyCaos.caos_Un.Offset	=	(-72);
	MyCaos.a6		=(ULONG) AHIBase;	
	PPCCallOS(&MyCaos);
}

#define	AHI_SetSound(Channel, Sound, Offset, Length, AudioCtrl, Flags)	_AHI_SetSound(AHI_BASE_NAME, Channel, Sound, Offset, Length, AudioCtrl, Flags)

static __inline void
_AHI_SetSound(void *AHIBase, UWORD Channel, UWORD Sound, ULONG Offset, LONG Length, struct AHIAudioCtrl *AudioCtrl, ULONG Flags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.d0		=(ULONG) Channel;
	MyCaos.d1		=(ULONG) Sound;
	MyCaos.d2		=(ULONG) Offset;
	MyCaos.d3		=(ULONG) Length;
	MyCaos.a2		=(ULONG) AudioCtrl;
	MyCaos.d4		=(ULONG) Flags;
	MyCaos.caos_Un.Offset	=	(-78);
	MyCaos.a6		=(ULONG) AHIBase;	
	PPCCallOS(&MyCaos);
}

#define	AHI_SetVol(Channel, Volume, Pan, AudioCtrl, Flags)	_AHI_SetVol(AHI_BASE_NAME, Channel, Volume, Pan, AudioCtrl, Flags)

static __inline void
_AHI_SetVol(void *AHIBase, UWORD Channel, Fixed Volume, sposition Pan, struct AHIAudioCtrl *AudioCtrl, ULONG Flags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.d0		=(ULONG) Channel;
	MyCaos.d1		=(ULONG) Volume;
	MyCaos.d2		=(ULONG) Pan;
	MyCaos.a2		=(ULONG) AudioCtrl;
	MyCaos.d3		=(ULONG) Flags;
	MyCaos.caos_Un.Offset	=	(-66);
	MyCaos.a6		=(ULONG) AHIBase;	
	PPCCallOS(&MyCaos);
}

#define	AHI_UnloadSound(Sound, Audioctrl)	_AHI_UnloadSound(AHI_BASE_NAME, Sound, Audioctrl)

static __inline void
_AHI_UnloadSound(void *AHIBase, UWORD Sound, struct AHIAudioCtrl *Audioctrl)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.d0		=(ULONG) Sound;
	MyCaos.a2		=(ULONG) Audioctrl;
	MyCaos.caos_Un.Offset	=	(-96);
	MyCaos.a6		=(ULONG) AHIBase;	
	PPCCallOS(&MyCaos);
}

#endif /* SASC Pragmas */
#endif /* !_PPCPRAGMA_AHI_H */