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

#ifndef _PPCPRAGMA_SNDFILE_H
#define _PPCPRAGMA_SNDFILE_H

#ifdef __GNUC__
#ifndef _PPCINLINE__SNDFILE_H
#include <powerup/ppcinline/sndfile.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 SNDFILE_BASE_NAME
#define SNDFILE_BASE_NAME SndFileBase
#endif /* !SNDFILE_BASE_NAME */

#define	SF_GetLibVersion(buffer, bufferlen)	_SF_GetLibVersion(SNDFILE_BASE_NAME, buffer, bufferlen)

static __inline size_t
_SF_GetLibVersion(void *SndFileBase, char *buffer, size_t bufferlen)
{
	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) buffer;
	MyCaos.d0		= (ULONG) bufferlen;
	MyCaos.caos_Un.Offset	= -30;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_OpenRead(path, wfinfo)	_SF_OpenRead(SNDFILE_BASE_NAME, path, wfinfo)

static __inline SNDFILE *
_SF_OpenRead(void *SndFileBase, const char *path, SF_INFO *wfinfo)
{
	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) path;
	MyCaos.a1		= (ULONG) wfinfo;
	MyCaos.caos_Un.Offset	= -36;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((SNDFILE *)PPCCallOS(&MyCaos));
}

#define	SF_OpenWrite(path, wfinfo)	_SF_OpenWrite(SNDFILE_BASE_NAME, path, wfinfo)

static __inline SNDFILE *
_SF_OpenWrite(void *SndFileBase, const char *path, const SF_INFO *wfinfo)
{
	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) path;
	MyCaos.a1		= (ULONG) wfinfo;
	MyCaos.caos_Un.Offset	= -42;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((SNDFILE *)PPCCallOS(&MyCaos));
}

#define	SF_Close(sndfile)	_SF_Close(SNDFILE_BASE_NAME, sndfile)

static __inline int
_SF_Close(void *SndFileBase, SNDFILE *sndfile)
{
	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) sndfile;
	MyCaos.caos_Un.Offset	= -48;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((int)PPCCallOS(&MyCaos));
}

#define	SF_ReadRaw(sndfile, ptr, bytes)	_SF_ReadRaw(SNDFILE_BASE_NAME, sndfile, ptr, bytes)

static __inline size_t
_SF_ReadRaw(void *SndFileBase, SNDFILE *sndfile, void *ptr, size_t bytes)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) bytes;
	MyCaos.caos_Un.Offset	= -54;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_WriteRaw(sndfile, ptr, bytes)	_SF_WriteRaw(SNDFILE_BASE_NAME, sndfile, ptr, bytes)

static __inline size_t
_SF_WriteRaw(void *SndFileBase, SNDFILE *sndfile, void *ptr, size_t bytes)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) bytes;
	MyCaos.caos_Un.Offset	= -60;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_ReadChar(sndfile, ptr, items)	_SF_ReadChar(SNDFILE_BASE_NAME, sndfile, ptr, items)

static __inline size_t
_SF_ReadChar(void *SndFileBase, SNDFILE *sndfile, char *ptr, size_t items)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) items;
	MyCaos.caos_Un.Offset	= -66;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_WriteChar(sndfile, ptr, items)	_SF_WriteChar(SNDFILE_BASE_NAME, sndfile, ptr, items)

static __inline size_t
_SF_WriteChar(void *SndFileBase, SNDFILE *sndfile, char *ptr, size_t items)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) items;
	MyCaos.caos_Un.Offset	= -72;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_ReadShort(sndfile, ptr, items)	_SF_ReadShort(SNDFILE_BASE_NAME, sndfile, ptr, items)

static __inline size_t
_SF_ReadShort(void *SndFileBase, SNDFILE *sndfile, short *ptr, size_t items)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) items;
	MyCaos.caos_Un.Offset	= -78;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_WriteShort(sndfile, ptr, items)	_SF_WriteShort(SNDFILE_BASE_NAME, sndfile, ptr, items)

static __inline size_t
_SF_WriteShort(void *SndFileBase, SNDFILE *sndfile, short *ptr, size_t items)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) items;
	MyCaos.caos_Un.Offset	= -84;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_ReadInt(sndfile, ptr, items)	_SF_ReadInt(SNDFILE_BASE_NAME, sndfile, ptr, items)

static __inline size_t
_SF_ReadInt(void *SndFileBase, SNDFILE *sndfile, int *ptr, size_t items)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) items;
	MyCaos.caos_Un.Offset	= -90;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_WriteInt(sndfile, ptr, items)	_SF_WriteInt(SNDFILE_BASE_NAME, sndfile, ptr, items)

static __inline size_t
_SF_WriteInt(void *SndFileBase, SNDFILE *sndfile, int *ptr, size_t items)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) items;
	MyCaos.caos_Un.Offset	= -96;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_ReadDouble(sndfile, ptr, items, normalize)	_SF_ReadDouble(SNDFILE_BASE_NAME, sndfile, ptr, items, normalize)

static __inline size_t
_SF_ReadDouble(void *SndFileBase, SNDFILE *sndfile, double *ptr, size_t items, int normalize)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) items;
	MyCaos.d1		= (ULONG) normalize;
	MyCaos.caos_Un.Offset	= -102;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_WriteDouble(sndfile, ptr, items, normalize)	_SF_WriteDouble(SNDFILE_BASE_NAME, sndfile, ptr, items, normalize)

static __inline size_t
_SF_WriteDouble(void *SndFileBase, SNDFILE *sndfile, double *ptr, size_t items, int normalize)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) items;
	MyCaos.d1		= (ULONG) normalize;
	MyCaos.caos_Un.Offset	= -108;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_ReadFChar(sndfile, ptr, frames)	_SF_ReadFChar(SNDFILE_BASE_NAME, sndfile, ptr, frames)

static __inline size_t
_SF_ReadFChar(void *SndFileBase, SNDFILE *sndfile, char *ptr, size_t frames)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) frames;
	MyCaos.caos_Un.Offset	= -114;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_WriteFChar(sndfile, ptr, frames)	_SF_WriteFChar(SNDFILE_BASE_NAME, sndfile, ptr, frames)

static __inline size_t
_SF_WriteFChar(void *SndFileBase, SNDFILE *sndfile, char *ptr, size_t frames)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) frames;
	MyCaos.caos_Un.Offset	= -120;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_ReadFShort(sndfile, ptr, frames)	_SF_ReadFShort(SNDFILE_BASE_NAME, sndfile, ptr, frames)

static __inline size_t
_SF_ReadFShort(void *SndFileBase, SNDFILE *sndfile, short *ptr, size_t frames)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) frames;
	MyCaos.caos_Un.Offset	= -126;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_WriteFShort(sndfile, ptr, frames)	_SF_WriteFShort(SNDFILE_BASE_NAME, sndfile, ptr, frames)

static __inline size_t
_SF_WriteFShort(void *SndFileBase, SNDFILE *sndfile, short *ptr, size_t frames)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) frames;
	MyCaos.caos_Un.Offset	= -132;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_ReadFInt(sndfile, ptr, frames)	_SF_ReadFInt(SNDFILE_BASE_NAME, sndfile, ptr, frames)

static __inline size_t
_SF_ReadFInt(void *SndFileBase, SNDFILE *sndfile, int *ptr, size_t frames)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) frames;
	MyCaos.caos_Un.Offset	= -138;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_WriteFInt(sndfile, ptr, frames)	_SF_WriteFInt(SNDFILE_BASE_NAME, sndfile, ptr, frames)

static __inline size_t
_SF_WriteFInt(void *SndFileBase, SNDFILE *sndfile, int *ptr, size_t frames)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) frames;
	MyCaos.caos_Un.Offset	= -144;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_ReadFDouble(sndfile, ptr, frames, normalize)	_SF_ReadFDouble(SNDFILE_BASE_NAME, sndfile, ptr, frames, normalize)

static __inline size_t
_SF_ReadFDouble(void *SndFileBase, SNDFILE *sndfile, double *ptr, size_t frames, int normalize)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) frames;
	MyCaos.d1		= (ULONG) normalize;
	MyCaos.caos_Un.Offset	= -150;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_WriteFDouble(sndfile, ptr, frames, normalize)	_SF_WriteFDouble(SNDFILE_BASE_NAME, sndfile, ptr, frames, normalize)

static __inline size_t
_SF_WriteFDouble(void *SndFileBase, SNDFILE *sndfile, double *ptr, size_t frames, int normalize)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) ptr;
	MyCaos.d0		= (ULONG) frames;
	MyCaos.d1		= (ULONG) normalize;
	MyCaos.caos_Un.Offset	= -156;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_Seek(sndfile, frames, whence)	_SF_Seek(SNDFILE_BASE_NAME, sndfile, frames, whence)

static __inline off_t
_SF_Seek(void *SndFileBase, SNDFILE *sndfile, off_t frames, int whence)
{
	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) sndfile;
	MyCaos.d0		= (ULONG) frames;
	MyCaos.d1		= (ULONG) whence;
	MyCaos.caos_Un.Offset	= -162;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((off_t)PPCCallOS(&MyCaos));
}

#define	SF_FormatCheck(info)	_SF_FormatCheck(SNDFILE_BASE_NAME, info)

static __inline int
_SF_FormatCheck(void *SndFileBase, const SF_INFO *info)
{
	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) info;
	MyCaos.caos_Un.Offset	= -168;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((int)PPCCallOS(&MyCaos));
}

#define	SF_SignalMax(sndfile)	_SF_SignalMax(SNDFILE_BASE_NAME, sndfile)

static __inline double *
_SF_SignalMax(void *SndFileBase, SNDFILE *sndfile)
{
	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) sndfile;
	MyCaos.caos_Un.Offset	= -174;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((double *)PPCCallOS(&MyCaos));
}

#define	SF_GetHeaderInfo(sndfile, buffer, bufferlen, offset)	_SF_GetHeaderInfo(SNDFILE_BASE_NAME, sndfile, buffer, bufferlen, offset)

static __inline size_t
_SF_GetHeaderInfo(void *SndFileBase, SNDFILE *sndfile, char *buffer, size_t bufferlen, size_t offset)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) buffer;
	MyCaos.d0		= (ULONG) bufferlen;
	MyCaos.d1		= (ULONG) offset;
	MyCaos.caos_Un.Offset	= -180;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((size_t)PPCCallOS(&MyCaos));
}

#define	SF_ErrorStr(sndfile, str, len)	_SF_ErrorStr(SNDFILE_BASE_NAME, sndfile, str, len)

static __inline int
_SF_ErrorStr(void *SndFileBase, SNDFILE *sndfile, char *str, size_t len)
{
	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) sndfile;
	MyCaos.a1		= (ULONG) str;
	MyCaos.d0		= (ULONG) len;
	MyCaos.caos_Un.Offset	= -186;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((int)PPCCallOS(&MyCaos));
}

#define	SF_ErrorNumber(errnum, str, len)	_SF_ErrorNumber(SNDFILE_BASE_NAME, errnum, str, len)

static __inline int
_SF_ErrorNumber(void *SndFileBase, int errnum, char *str, size_t len)
{
	struct Caos MyCaos;
	MyCaos.M68kCacheMode	= IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	= NULL;
//	MyCaos.M68kSize		= 0;
	MyCaos.PPCCacheMode	= IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		= NULL;
//	MyCaos.PPCSize		= 0;
	MyCaos.d1		= (ULONG) errnum;
	MyCaos.a1		= (ULONG) str;
	MyCaos.d0		= (ULONG) len;
	MyCaos.caos_Un.Offset	= -192;
	MyCaos.a6		= (ULONG) SndFileBase;
	return((int)PPCCallOS(&MyCaos));
}

#endif /* SASC Pragmas */
#endif /* !_PPCPRAGMA_SNDFILE_H */