/////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////
////																					 ////
////																					 ////
////								  - SCOLSound.cpp -									 ////
////																					 ////
////																					 ////
////				Implémentation des fonctions SCOL de la librairie sonore			 ////
////									 Version  1.0									 ////
////																					 ////
////								  Hilaire Verschuere								 ////
////																					 ////
////																					 ////
/////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////


typedef int (*constantes)(struct Mmachine *);
#include "../winuser.h"
#include <stdlib.h>


//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndCreate 														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [Chn I] AsSnd
int asSndCreate(mmachine m)
{
    MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndDestroy														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd] I
int asSndDestroy (mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;
}






//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndCopy 														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [Chn AsSnd] AsSnd
int asSndCopy (mmachine m)
{
    MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;
}




//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndInit 
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd I I I I] AsSnd
int asSndInit (mmachine m)
{
	MMpull(m) ;
	MMpull(m) ;
	MMpull(m) ;
	MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}




//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndFeed 
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd S I] AsSnd
int asSndFeed (mmachine m)
{
	MMpull(m) ;
	MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}




//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndLoad														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd P I] AsSnd
int asSndLoad (mmachine m)
{	
    MMpull(m) ;
	MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}




///////////////////////////////////////////////////////////////////////////////////////////////
///		asSndPlay														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd I] AsSnd
int asSndPlay (mmachine m)
{
	MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndStop														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd] AsSnd
int asSndStop (mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndIsPlaying
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd] I
int asSndIsPlaying (mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}





//////////////////////////////////////////////////////////////////////////////////////////////
///		asEnableAllSnd														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [] I
int asEnableAllSnd (mmachine m)
{
	MMpush(m,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asDisableAllSnd														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [] I
int asDisableAllSnd (mmachine m)
{
	MMpush(m,NIL) ;
	return 0 ;	
}




//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndReset														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd] AsSnd
int asSndReset (mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndGetSize														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd] I
int asSndGetSize (mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndSetTime														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd I I] AsSnd
int asSndSetTime (mmachine m)
{
	MMpull(m) ;
	MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndGetTime														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd] I
int asSndGetTime (mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSetVolume 														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [I] I
int asSetVolume  (mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}




//////////////////////////////////////////////////////////////////////////////////////////////
///		asGetVolume 														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [] I
int asGetVolume  (mmachine m)
{
	MMpush(m,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndSetVolume														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd I] AsSnd
int asSndSetVolume (mmachine m)
{
	MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndGetVolume														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd] I
int asSndGetVolume (mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndSetPan 														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd I] AsSnd
int asSndSetPan  (mmachine m)
{
	MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndGetPan														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd] I
int asSndGetPan (mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndSetFrequency														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd I] AsSnd
int asSndSetFrequency (mmachine m)
{
	MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndGetFrequency														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd] I
int asSndGetFrequency (mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asSndSetCallBackTime														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsSnd fun [AsSnd u0] u1 u0 [I r1]] AsSnd
int asSndSetCallBackTime(mmachine m)
{
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}







//////////////////////////////////////////////////////////////////////////////////////////////
///		as3dSndCreate														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [S3d AsSnd I] H3d
int as3dSndCreate(mmachine m)
{
    MMpull(m) ;
    MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}





//////////////////////////////////////////////////////////////////////////////////////////////
///		as3dSndSetDistance
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [S3d H3d I I] H3d
int as3dSndSetDistance(mmachine m)
{
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}

	


//////////////////////////////////////////////////////////////////////////////////////////////
///		as3dSndGetDistance
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [S3d H3d] [I I]
int as3dSndGetDistance(mmachine m)
{
    MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}


	

//////////////////////////////////////////////////////////////////////////////////////////////
///		as3dSndSetCone														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [S3d H3d [I I] I] H3d
int as3dSndSetCone(mmachine m)
{
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		as3dSndGetCone														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [S3d H3d] [I I I]
int as3dSndGetCone(mmachine m)
{
    MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}




//////////////////////////////////////////////////////////////////////////////////////////////
///		as3dSndEnable														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [S3d H3d] H3d
int as3dSndEnable(mmachine m)
{
	MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		as3dSndDisable														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [S3d H3d] H3d
int as3dSndDisable(mmachine m)
{
	MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}




//////////////////////////////////////////////////////////////////////////////////////////////
///		as3dListenerCreate 														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [S3d] H3d
int as3dListenerCreate (mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}




//////////////////////////////////////////////////////////////////////////////////////////////
///		as3dListenerSetActive														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [S3d H3d] H3d
int as3dListenerSetActive(mmachine m)
{
	MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}




//////////////////////////////////////////////////////////////////////////////////////////////
///		as3dListenerSetRollOff													
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [S3d H3d I] H3d
int as3dListenerSetRollOff(mmachine m)
{
    MMpull(m) ;
    MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}




//////////////////////////////////////////////////////////////////////////////////////////////
///		as3dListenerGetRollOff													
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [S3d H3d] I
int as3dListenerGetRollOff(mmachine m)
{
    MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}





////////////////////////////////////////////////////////////////////////////// RECORDING SOUND


//////////////////////////////////////////////////////////////////////////////////////////////
///		asRecorderCreate														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [Chn] AsRecorder
int asRecorderCreate(mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asRecorderDestroy														
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsRecorder] I
int asRecorderDestroy(mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}





//////////////////////////////////////////////////////////////////////////////////////////////
///		asRecorderInit													
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsRecorder fun [AsRecorder u0 S] u1 u0 I I I I I I] AsRecorder
int asRecorderInit(mmachine m)
{
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;	
}





//////////////////////////////////////////////////////////////////////////////////////////////
///		asRecorderStart													
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsRecorder] AsRecorder
int asRecorderStart(mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asRecorderStop													
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [AsRecorder] AsRecorder
int asRecorderStop(mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;	
}




// fun [Chn I I I I] SoundPlay
int _sndPlayStart( mmachine m )
{
	MMpull(m) ;
	MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
    MMset(m,0,NIL) ;
    return 0 ;
}




// fun [] I	
int _sndPlayStop( mmachine m )
{
	MMpush( m, NIL ) ;
	return 0 ;
}




// fun [SoundPlay fun [SoundPlay u0] u1 u0] SoundPlay
int _sndSetRflxPlayClose( mmachine m )
{
    MMpull(m) ;
    MMpull(m) ;
    MMset(m,0,NIL) ;
    return 0 ;
}


// fun [SoundPlay fun [SoundPlay u0] u1 u0] SoundPlay
int _sndSetRflxPlayOpen( mmachine m )
{
	MMpull(m) ;
	MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;
}




// fun [SoundPlay fun [SoundPlay u0 I] S u0] SoundPlay
int  _sndSetRflxPlayBuf( mmachine m )
{
	MMpull(m) ;
	MMpull(m) ;
	MMset(m,0,NIL) ;
	return 0 ;
}





// fun [] I
int _sndSetPending( mmachine m)
{
	MMpush( m, NIL ) ;
	return 0 ;
}


// fun [] I
int _sndUnsetPending( mmachine m )
{
	MMpush( m, NIL ) ;
	return 0 ;
}



////////////////////////////////////////////////////////////////////////// Old Easy Sound Recording

// fun [Chn I I I I] SoundRec
int _sndRecStart( mmachine m )
{
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
    MMset(m,0,NIL) ;
    return 0 ;
}





// fun [] I
int _sndRecStop( mmachine m )
{
	MMpush( m, NIL ) ;
	return 0 ;
}



// fun [SoundRec fun [SoundRec u0 S I] u1 u0] SoundRec
int _sndSetRflxRecBuf( mmachine m)
{
	MMpull(m) ; 
	MMpull(m) ; 
	MMset(m,0,NIL) ;
	return 0;
}






// fun [SoundRec fun [SoundRec u0] u1 u0] SoundRec
int _sndSetRflxRecClose( mmachine m)
{
	MMpull(m) ; 
	MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}


//fun [SoundRec fun [SoundRec u0] u1 u0] SoundRec
int _sndSetRflxRecOpen( mmachine m )
{ 
	MMpull(m) ; 
	MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asMp3Create													
//////////////////////////////////////////////////////////////////////////////////////////////
//fun [Chn] AsMp3
int asMp3Create(mmachine m)
{
	MMset(m,0,NIL) ; 
	return MERRMEM ;
}


//////////////////////////////////////////////////////////////////////////////////////////////
///		asMp3Destroy													
//////////////////////////////////////////////////////////////////////////////////////////////
//fun [AsMp3] I
int asMp3Destroy(mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}






//////////////////////////////////////////////////////////////////////////////////////////////
///		asMp3GetFrameInfo													
//////////////////////////////////////////////////////////////////////////////////////////////
//fun [S] [I I I I]
int asMp3GetFrameInfo(mmachine m)
{	
	MMset(m,0,NIL) ; 
	return 0 ;
}






//////////////////////////////////////////////////////////////////////////////////////////////
///		asMp3Decode													
//////////////////////////////////////////////////////////////////////////////////////////////
//fun [AsMp3 S] S
int asMp3Decode(mmachine m)
{
	MMpull(m);
	MMset(m,0,NIL);
	return 0 ;
}




//////////////////////////////////////////////////////////////////////////////////////////////
///		asWaveGetInfo													
//////////////////////////////////////////////////////////////////////////////////////////////
//fun [P] [I I I I]
int asWaveGetInfo(mmachine m)
{
	MMset(m,0,NIL);
	return 0 ;
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		asWaveCreate													
//////////////////////////////////////////////////////////////////////////////////////////////
//fun [Chn P] AsWave
int asWaveCreate(mmachine m)
{
    MMpull(m) ;
	MMset(m,0,NIL);
	return 0 ;
}


//////////////////////////////////////////////////////////////////////////////////////////////
///		asWaveDestroy 													
//////////////////////////////////////////////////////////////////////////////////////////////
//fun [AsWave] I
int asWaveDestroy (mmachine m)
{
	MMset(m,0,NIL) ;
	return 0 ;
}






//////////////////////////////////////////////////////////////////////////////////////////////
///		asWaveRead													
//////////////////////////////////////////////////////////////////////////////////////////////
//fun [AsWave I I I] S
int asWaveRead(mmachine m)
{
    MMpull(m) ;
	MMpull(m) ;
	MMpull(m) ;
	MMset(m,0,NIL);
	return 0 ;
}




int _CreateDirectSound (mmachine m)
{
	MMpull(m) ; 
	MMpull(m) ; 
	MMpull(m) ; 
	MMpull(m) ; 
	MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}





int _InitDirectSound (mmachine m)
{
	MMpush( m, MMget(m, 0) ) ;
	MMset( m, 1, MMget( m, 2 ) );
	MMset( m, 2, MMget( m, 3 ) );
	MMset( m, 3, MMget( m, 4 ) );
	MMset( m, 4, MMget( m, 5 ) );
	MMset( m, 5, MMgetglobal( m, OFFSCCUR ) ) ;

	return _CreateDirectSound( m ) ;
}




int _ReleaseDirectSound (mmachine m)
{
	MMset(m,0,0);
	return 0;
}





int createSoundBuffer( mmachine m, bool is3D )
{	
	MMpull(m) ; 
	MMpull(m) ; 
	MMpull(m) ; 
	MMpull(m) ; 
	MMpull(m) ; 
	MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _CreateSoundBuffer (mmachine m)
{
	return createSoundBuffer( m, false ) ;
}


int _CRSoundBuffer (mmachine m)
{
	MMpush( m, MMget(m, 0) ) ;
	MMset( m, 1, MMget( m, 2 ) );
	MMset( m, 2, MMget( m, 3 ) );
	MMset( m, 3, MMget( m, 4 ) );
	MMset( m, 4, MMget( m, 5 ) );
	MMset( m, 5, MMget( m, 6 ) );
	MMset( m, 6, MMgetglobal( m, OFFSCCUR ) ) ;

	return createSoundBuffer( m, false ) ;
}


int _CreateSoundBuffer3D (mmachine m)
{
	return createSoundBuffer( m, true ) ;
}



int _CRSoundBuffer3D(mmachine m)
{
	MMpush( m, MMget(m, 0) ) ;
	MMset( m, 1, MMget( m, 2 ) );
	MMset( m, 2, MMget( m, 3 ) );
	MMset( m, 3, MMget( m, 4 ) );
	MMset( m, 4, MMget( m, 5 ) );
	MMset( m, 5, MMget( m, 6 ) );
	MMset( m, 6, MMgetglobal( m, OFFSCCUR ) ) ;

	return createSoundBuffer( m, true ) ;
}




int _DSSoundBuffer (mmachine m)
{
    MMset(m,0,NIL) ; 
    return 0 ;
}






int _CopySoundBuffer(mmachine m)
{
	MMpull(m) ; 
	MMpull(m) ;
	MMset(m,0,NIL) ; 
	return 0 ;
}




int _DUPSoundBuffer(mmachine m)
{
	MMpush( m, MMget(m, 0) ) ;
	MMset( m, 1, MMget( m, 2 ) );
	MMset( m, 2, MMgetglobal( m, OFFSCCUR ) ) ;

	return _CopySoundBuffer( m ) ;
}




int _CreateListener3D (mmachine m)
{
	MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}



int _CRListener3D(mmachine m)
{
	MMpush( m, MMget(m, 0) ) ;
	MMset( m, 1, MMgetglobal( m, OFFSCCUR ) ) ;

	return _CreateListener3D( m ) ;
}



int _DSListener (mmachine m)
{
    MMset(m,0,NIL) ; 
    return 0 ;
}






int _SETSoundBuffer (mmachine m)
{
	MMpull(m) ; 
	MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}




int _SETVolume (mmachine m)
{
	MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _SETPan (mmachine m)
{
    MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}



int _SETPlayPosition (mmachine m)
{
    MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _SETOperationMode (mmachine m)
{
    MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _SETConeOutsideVolume (mmachine m)
{
    MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}





int _GETVolume (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _GETPan (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _GETPlayPosition (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _GETWritePosition (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _GETOperationMode (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _GETConeOutsideVolume (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}






int _SETMinDistance (mmachine m)
{
    MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _SETMaxDistance (mmachine m)
{
    MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _SETDistanceFactor (mmachine m)
{
    MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _SETDopplerFactor (mmachine m)
{
    MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _SETRollOffFactor (mmachine m)
{
    MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}





int _SETPosition3D (mmachine m)
{
    MMpull(m) ;
    MMpull(m) ;
	MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _SETVelocity3D (mmachine m)
{
	MMpull(m) ;
    MMpull(m) ;
	MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _SETConeOrientation (mmachine m)
{
	MMpull(m) ;
    MMpull(m) ;
	MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _SETListenerPosition3D (mmachine m)
{
	MMpull(m) ;
    MMpull(m) ;
	MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _SETListenerVelocity3D (mmachine m)
{
    MMpull(m) ;
    MMpull(m) ;
	MMpull(m) ; 
	MMset(m,0,NIL) ; 
	return 0 ;
}






int _GETMinDistance (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _GETMaxDistance (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _GETDistanceFactor (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _GETDopplerFactor (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _GETRollOffFactor (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}




int _GETPosition3D (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _GETVelocity3D (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _GETConeOrientation (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _GETListenerPosition3D (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}


int _GETListenerVelocity3D (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}





int _GETListenerOrientation3D (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}




int _SETConeAngles (mmachine m)
{
    MMpull(m) ;
    MMpull(m) ;
	MMset(m,0,NIL) ; 
	return 0 ;
}




int _GETConeAngles (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}




int _SETListenerOrientation (mmachine m)
{
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
	MMset(m,0,NIL) ; 
	return 0 ;
}






int _COMMITSoundSettings (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}





int _CreateSoundStream(mmachine m)
{
	MMpull( m ) ;
	MMpull( m ) ;
	MMpull( m ) ;
	MMset( m, 0, NIL ) ;

	return 0 ;
}

int _CRSoundStream(mmachine m)
{
	MMpull( m ) ;
	MMpull( m ) ;
	MMset( m, 0, NIL ) ;

	return 0 ;
}





/////////////////////////////////////////////////////// WAVE I/O
int _OPENwave( mmachine m )
{
	MMpush( m, MMget(m,0)) ;
	MMset( m, 1, MMgetglobal( m, OFFSCCUR ) ) ;
	
	return asWaveCreate( m ) ;
}





int _SETSoundBufferFromWave (mmachine m)
{
    MMpull(m) ;
    MMpull(m) ;
    MMpull(m) ;
	MMpull(m) ;
	MMpull(m) ;
	MMset(m,0,NIL) ; 
	return 0 ;
}




//////////////////////////////////////////////////////////////////////////////////////////////
///		_GETwaveData													
//////////////////////////////////////////////////////////////////////////////////////////////
// fun [P] S
int _GETwaveData (mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}



//////////////////////////////////////////////////////////////////////////////////////////////
///		_SEEKwave													
//////////////////////////////////////////////////////////////////////////////////////////////
//fun [Wave I I] I
int _SEEKwave (mmachine m)
{
    MMpull(m) ;
    MMpull(m) ;
	MMset(m,0,NIL) ; 
	return 0 ;
}




//////////////////////////////////////////////////////////////////////////////////////////////
///		_GetMP3FrameInfo													
//////////////////////////////////////////////////////////////////////////////////////////////
//fun [S] [I I I I I I]
int _GetMP3FrameInfo(mmachine m)
{
	MMset(m,0,NIL) ; 
	return 0 ;
}





/////////////////////////////////////////////////////// DEFINITIONS
#define NBSOUNDPKG 153

char* SOUNDname [ NBSOUNDPKG ] = 
{
	"AsSnd",						// AsSnd,
	"AsRecorder",					// AsRecorder,

	"AS_SND_STATIC",				// AS_SND_STATIC,
	"AS_SND_STREAMING",				// AS_SND_STREAMING,								

	"AS_SND_BEGIN",					// AS_SND_BEGIN,
	"AS_SND_CURRENT",				// AS_SND_CURRENT,
	"AS_SND_END",					// AS_SND_END,
		
	"AS_SND_CTRL3D",				// AS_SND_CTRL3D,
	"AS_SND_CTRLFREQUENCY",			// AS_SND_CTRLFREQUENCY,
	"AS_SND_CTRLPAN",				// AS_SND_CTRLPAN,

	"AS_SND_LINEAR",				// AS_SND_LINEAR
	"AS_SND_CIRCULAR",				// AS_SND_CIRCULAR

	"AS_SND_END_REFLEX",			// AS_SND_END_REFLEX
	"AS_SND_LOOP",					// AS_SND_LOOP
	"AS_SND_LINKED_TO_H3D",			// AS_SND_LINKED_TO_H3D

	// Son 2D et 3D			
	"asSndCreate",					// asSndCreate,
	"asSndDestroy",					// asSndDestroy,
	"asSndInit",					// asSndInit ,
	"asSndFeed",					// asSndFeed ,
	"asSndLoad",					// asSndLoad,
	"asSndCopy",					// asSndCopy 
	"asSndPlay",					// asSndPlay,
	"asSndStop",					// asSndStop,
	"asSndIsPlaying",				// asSndIsPlaying
	"asEnableAllSnd",				// asEnableAllSnd,
	"asDisableAllSnd",				// asDisableAllSndAllSnd,
	"asSndReset",					// asSndReset,
	"asSndGetSize",					// asSndGetSize,
	"asSndSetTime",					// asSndSetTime,
	"asSndGetTime",					// asSndGetTime
	"asSndSetVolume",				// asSndSetVolume,
	"asSndGetVolume",				// asSndGetVolume,
	"asSetVolume",					// asSetVolume ,
	"asGetVolume",					// asGetVolume ,
	"asSndSetPan",					// asSndSetPan ,
	"asSndGetPan",					// asSndGetPan
	"asSndSetFrequency",			// asSndSetFrequency
	"asSndGetFrequency",			// asSndGetFrequency
	"asSndSetCallBackTime",			// asSndSetCallBackTime

	// Son 3D				
	"as3dListenerCreate",			// as3dListenerCreate 
	"as3dListenerSetActive",		// as3dListenerSetActive
	"as3dListenerSetRollOff",		// as3dListenerSetRollOff
	"as3dListenerGetRollOff",		// as3dListenerGetRollOff
	"as3dSndCreate",				// as3dSndCreate,
	"as3dSndSetCone",				// as3dSndSetCone
	"as3dSndGetCone",				// as3dSndGetCone
	"as3dSndSetDistance",			// as3dSndSetDistance
	"as3dSndGetDistance",			// as3dSndGetDistance
	"as3dSndEnable",				// as3dSndEnable
	"as3dSndDisable",				// as3dSndDisable

	// Enregistrement
	"asRecorderCreate",				// asRecorderCreate,
	"asRecorderDestroy",			// asRecorderDestroy,
	"asRecorderInit",				// asRecorderInit,
	"asRecorderStart",				// asRecorderStart,
	"asRecorderStop",				// asRecorderStop,
	
	// wave Lib
	"AsWave",               //  AsWave,

	// WAVE I/O
	"asWaveGetInfo",		// asWaveGetInfo
	"asWaveCreate",			// asWaveCreate
	"asWaveDestroy ",		// asWaveDestroy 
	"asWaveRead",			// asWaveRead
	
	
	////// MP3 lib
	"AsMp3",                  //  AsMp3,                   

	////// AsMp3 I/O
	"asMp3Create",			// asMp3Create
	"asMp3Destroy",			// asMp3Destroy
	"asMp3GetFrameInfo",	// asMp3GetFrameInfo
	"asMp3Decode",			// asMp3Decode
	
	
	// easy sound library
	"SoundPlay",					// SoundPlay
	"SoundRec",						// SoundRec
	
	"_sndPlayStart",				// _sndPlayStart				 
	"_sndPlayStop",					// _sndPlayStop				 
	"_sndRecStart",					// _sndRecStart
	"_sndRecStop",					// _sndRecStop				
	"_sndSetPending",				// _sndSetPending			
	"_sndSetRflxPlayBuf",			// _sndSetRflxPlayBuf			
	"_sndSetRflxPlayClose",			// _sndSetRflxPlayClose		
	"_sndSetRflxPlayOpen",			// _sndSetRflxPlayOpen
	"_sndSetRflxRecBuf",			// _sndSetRflxRecBuf	
	"_sndSetRflxRecClose",			// _sndSetRflxRecClose	 
	"_sndSetRflxRecOpen",			// _sndSetRflxRecOpen	
	"_sndUnsetPending",				// _sndUnsetPending		
	
	
	// SDsound Lib
    "DS",                           //  DS,                   
    "DSBuffer",                     //  DSBuffer,                   
    "DSListener3D",                 //  DSListener3D,
    "MP3",		                  //  MP3,      
    "Wave",						  //  Wave
    
    "DSSCL_NORMAL",				  //  DSSCL_NORMAL
    "DSSCL_PRIORITY",				  //  DSSCL_PRIORITY
    "DSSCL_EXCLUSIVE",			  //  DSSCL_EXCLUSIVE
    
    "_CreateDirectSound",           //  _CreateDirectSound,
    "_InitDirectSound",			  //  _InitDirectSound,
    "_ReleaseDirectSound",          //  _ReleaseDirectSound,    
    ////////////////////////////////////////////////////////// 2D     
    "_CreateSoundBuffer",           //  _CreateSoundBuffer,
    "_CRSoundBuffer",				  //  _CRSoundBuffer,
    "_CopySoundBuffer",             //  _CopySoundBuffer,
    "_DUPSoundBuffer",			  //  _DUPSoundBuffer,
    "_DSSoundBuffer",               //  _DSSoundBuffer,         
    "_PLAYSoundBuffer",             //  _PLAYSoundBuffer,       
    "_STOPSoundBuffer",             //  _STOPSoundBuffer,       
    "_SETVolume",                   //  _SETVolume,             
    "_SETFrequency",                //  _SETFrequency,          
    "_SETPan",                      //  _SETPan,                
    "_GETVolume",                   //  _GETVolume,             
    "_GETFrequency",                //  _GETFrequency,          
    "_GETPan",                      //  _GETPan,                
    "_SETSoundBuffer",              //  _SETSoundBuffer,        
    "_GETPlayPosition",             //  _GETPlayPosition,       
    "_GETWritePosition",            //  _GETWritePosition,      
    "_SETPlayPosition",             //  _SETPlayPosition,       
    ///////////////////////////////////////////////////// 3D     
    "_CreateSoundBuffer3D",         //  _CreateSoundBuffer3D,
    "_CRSoundBuffer3D",			  //  _CRSoundBuffer3D,
    ////////////////////////////////////////////////////                          
    "_SETMinDistance",              //  _SETMinDistance,                     
    "_SETMaxDistance",              //  _SETMaxDistance,                     
    "_SETOperationMode",            //  _SETOperationMode,                   
    "_SETPosition3D",               //  _SETPosition3D,                      
    "_SETVelocity3D",               //  _SETVelocity3D,                      
    "_SETConeAngles",               //  _SETConeAngles,                      
    "_SETConeOrientation",          //  _SETConeOrientation,                 
    "_SETConeOutsideVolume",        //  _SETConeOutsideVolume,               
    ///////////////////////////////////////////////////////////////////    
    "_GETMinDistance",              //  _GETMinDistance,                     
    "_GETMaxDistance",              //  _GETMaxDistance,                     
    "_GETOperationMode",            //  _GETOperationMode,                   
    "_GETPosition3D",               //  _GETPosition3D,                      
    "_GETVelocity3D",               //  _GETVelocity3D,                      
    "_GETConeAngles",               //  _GETConeAngles,                      
    "_GETConeOrientation",          //  _GETConeOrientation,                 
    "_GETConeOutsideVolume",        //  _GETConeOutsideVolume                
    /////////////////////////////////////////////////////// 3D LISTENER
    "_CreateListener3D",            //  _CreateListener3D,         
    "_DSListener3D",                //  _DSListener3D,         
    "_SETDistanceFactor",           //  _SETDistanceFactor           
    "_SETDopplerFactor",            //  _SETDopplerFactor            
    "_SETRollOffFactor",            //  _SETRollOffFactor            
    "_SETListenerPosition3D",       //  _SETListenerPosition3D       
    "_SETListenerVelocity3D",       //  _SETListenerVelocity3D       
    "_SETListenerOrientation",      //  _SETListenerOrientation      
    "_GETDistanceFactor",           //  _GETDistanceFactor           
    "_GETDopplerFactor",            //  _GETDopplerFactor            
    "_GETRollOffFactor",            //  _GETRollOffFactor            
    "_GETListenerPosition3D",       //  _GETListenerPosition3D       
    "_GETListenerVelocity3D",       //  _GETListenerVelocity3D       
    "_GETListenerOrientation3D",    //  _GETListenerOrientation3D    
    "_COMMITSoundSettings",         //  _COMMITSoundSettings
    //////////////////////////////////////////// WAVE IO
    "_GETwaveInfo",				  //  _GETwaveInfo
    "_READwave",				      //  _READwave
    "_GETwaveData",				  //  _GETwaveData
    "_OPENwave",                    //  _OPENwave
    "_CLOSEwave",                   //  _CLOSEwave
    "_SEEKwave",					  //  _SEEKwave
    "_SETSoundBufferFromWave",      //  _SETSoundBufferFromWave  
    
    //////////////////////////////////////////// MP3!
    "_CRmp3",						  // _CRmp3
    "_DSmp3",						  // _DSmp3
    "_DecodeMp3",
    "_GetMP3FrameInfo",
    
    /////////////////////////////////////////// STREAM
    "_CreateSoundStream",			  //  _CreateSoundStream
    "_CRSoundStream",				  //  _CRSoundStream

	
} ;

char * SOUNDtype [ NBSOUNDPKG ] = 
{
////// TYPES                          
	NULL,																	// AsSnd,
	NULL,																	// AsRecorder,
																					
	"I",																	// AS_SND_STATIC,
	"I",																	// AS_SND_STREAMING,
																					
	"I",																	// AS_SND_BEGIN,
	"I",																	// AS_SND_CURRENT,
	"I",																	// AS_SND_END,
																				
	"I",																	// AS_SND_CTRL3D,
	"I",																	// AS_SND_CTRLFREQUENCY,
	"I",																	// AS_SND_CTRLPAN,
																			
	"I",																	// AS_SND_LINEAR
	"I",																	// AS_SND_CIRCULAR
																			
	"I",																	// AS_SND_END_REFLEX
	"I",																	// AS_SND_LOOP
	"I",																	// AS_SND_LINKED_TO_H3D
																			
	// Son 2D et 3D																	
	"fun [Chn I] AsSnd",													// asSndCreate,
	"fun [AsSnd] [I]",														// asSndDestroy,																				
	"fun [AsSnd I I I I] AsSnd",											// asSndInit ,
	"fun [AsSnd S I] AsSnd",												// asSndFeed 																						
	"fun [AsSnd P I] AsSnd",												// asSndLoad,
	"fun [Chn AsSnd] AsSnd",												// asSndCopy 																			
	"fun [AsSnd I] I",														// asSndPlay,
	"fun [AsSnd] AsSnd",													// asSndStop,
	"fun [AsSnd] I",														// asSndIsPlaying
	"fun [] I",																// asEnableAllSnd,
	"fun [] I",																// asDisableAllSnd,
	"fun [AsSnd] AsSnd",													// asSndReset,
	"fun [AsSnd] I",														// asSndGetSize,
	"fun [AsSnd I I] AsSnd",												// asSndSetTime,
	"fun [AsSnd] I",														// asSndGetTime
	"fun [AsSnd I] AsSnd",													// asSndSetVolume,
	"fun [AsSnd] I",														// asSndGetVolume
	"fun [I] I",															// asSetVolume ,
	"fun [] I",																// asGetVolume ,
	"fun [AsSnd I] AsSnd",													// asSndSetPan ,
	"fun [AsSnd] I",														// asSndGetPan,
	"fun [AsSnd I] AsSnd",													// asSndSetFrequency,
	"fun [AsSnd] I",														// asSndGetFrequency,
	"fun [AsSnd fun [AsSnd u0] u1 u0 [I r1]] AsSnd",						// asSndSetCallBackTime
																				
	// Son 3D																	
	"fun [S3d] H3d",														// as3dListenerCreate 
	"fun [S3d H3d] H3d",													// as3dListenerSetActive
	"fun [S3d H3d I] H3d",													// as3dListenerSetRollOff
	"fun [S3d H3d] I",														// as3dListenerGetRollOff
	"fun [S3d AsSnd I] H3d",												// as3dSndCreate,
	"fun [S3d H3d [I I] I] H3d",											// as3dSndSetCone,
	"fun [S3d H3d] [I I I]",												// as3dSndGetCone
	"fun [S3d H3d I I] H3d",												// as3dSndSetDistance,
	"fun [S3d H3d] [I I]",													// as3dSndGetDistance,
	"fun [S3d H3d] H3d",													// as3dSndEnable
	"fun [S3d H3d] H3d",													// as3dSndDisable
																			
	// Enregistrement														
	"fun [Chn I] AsRecorder",												// asRecorderCreate,
	"fun [AsRecorder] I",													// asRecorderDestroy,
	"fun [AsRecorder fun [AsRecorder u0 S] u1 u0 I I I I I I] AsRecorder",	// asRecorderInit,
	"fun [AsRecorder] AsRecorder",											// asRecorderStart,,
	"fun [AsRecorder] AsRecorder",											// asRecorderStop,
	
	
	// wave lib
	NULL,					// AsWave,

	// WAVE I/O
	"fun [P] [I I I I]",	// asWaveGetInfo
	"fun [Chn P] AsWave",	// asWaveCreate
	"fun [AsWave] I",		// asWaveDestroy 
	"fun [AsWave I I I] S",	// asWaveRead
	
	
	////// Mp3 Lib
	NULL,                   //  AsMp3,                           

	////// AsMp3 I/O
	"fun [Chn] AsMp3",		// asMp3Create,
	"fun [AsMp3] I",			// asMp3Destroy,
	"fun [S] [I I I I]",	// asMp3GetFrameInfo,
	"fun [AsMp3 S] S",		// asMp3Decode 
	
	
	
	// easy sound library
    NULL,													// SoundPlay
	NULL,													// SoundRec

	"fun [Chn I I I I] SoundPlay",							// _sndPlayStart				 
	"fun [] I",												// _sndPlayStop				 
	"fun [Chn I I I I] SoundRec",							// _sndRecStart
	"fun [] I",												// _sndRecStop				
	"fun [] I",												// _sndSetPending			
	"fun [SoundPlay fun [SoundPlay u0 I] S u0] SoundPlay",	// _sndSetRflxPlayBuf			
	"fun [SoundPlay fun [SoundPlay u0] u1 u0] SoundPlay",	// _sndSetRflxPlayClose		
	"fun [SoundPlay fun [SoundPlay u0] u1 u0] SoundPlay",	// _sndSetRflxPlayOpen
	"fun [SoundRec fun [SoundRec u0 S I] u1 u0] SoundRec",	// _sndSetRflxRecBuf	
	"fun [SoundRec fun [SoundRec u0] u1 u0] SoundRec",		// _sndSetRflxRecClose	 
	"fun [SoundRec fun [SoundRec u0] u1 u0] SoundRec",		// _sndSetRflxRecOpen	
	"fun [] I",												// _sndUnsetPending	
	
	
	// SDsound Lib                                     
    NULL,                               //  DS,                            
    NULL,                               //  DSBuffer,                      
    NULL,                               //  DSListener3D,
    NULL,				                  //  MP3,      
    NULL,				                  //  Wave,  
    
    "I",								  //  DSSCL_NORMAL
    "I",								  //  DSSCL_PRIORITY
    "I",								  //  DSSCL_EXCLUSIVE
    
    "fun [Chn I I I I ObjWin] DS",      //  _CreateDirectSound,
    "fun [I I I I ObjWin] DS",		  //  _InitDirectSound
    "fun [DS] I",                       //  _ReleaseDirectSound,    
    ///// 2D ////////////////////////////////////////////// 2D     
    "fun [Chn DS I I I I I] DSBuffer",  //  _CreateSoundBuffer,
    "fun [DS I I I I I] DSBuffer",	  //  _CRSoundBuffer
    "fun [Chn DS DSBuffer] DSBuffer",   //  _CopySoundBuffer,
    "fun [DS DSBuffer] DSBuffer",		  //  _DUPSoundBuffer,
    "fun [DSBuffer] I",                 //  _DSSoundBuffer,         
    "fun [DSBuffer I] DSBuffer",        //  _PLAYSoundBuffer,       
    "fun [DSBuffer] DSBuffer",          //  _STOPSoundBuffer,       
    "fun [DSBuffer I] DSBuffer",        //  _SETVolume,             
    "fun [DSBuffer I] DSBuffer",        //  _SETFrequency,          
    "fun [DSBuffer I] DSBuffer",        //  _SETPan,                
    "fun [DSBuffer] I",                 //  _GETVolume,             
    "fun [DSBuffer] I",                 //  _GETFrequency,          
    "fun [DSBuffer] I",                 //  _GETPan,                
    "fun [DSBuffer S I] DSBuffer",      //  _SETSoundBuffer,       
    "fun [DSBuffer] I",                 //  _GETPlayPosition,       
    "fun [DSBuffer] I",                 //  _GETWritePosition,      
    "fun [DSBuffer I] DSBuffer",        //  _SETPlayPosition,       
    ///// 3D STANDARDS /////////////////////////////////// 3D     
    "fun [Chn DS I I I I I] DSBuffer",  //  _CreateSoundBuffer3D,
    "fun [DS I I I I I] DSBuffer",	  //  _CRSoundBuffer3D  
    ////// 3D SPECS ////////////////////////////////////////                          
    "fun [DSBuffer F] DSBuffer",		//  _SETMinDistance
    "fun [DSBuffer F] DSBuffer",		//  _SETMaxDistance
    "fun [DSBuffer I] DSBuffer",		//  _SETOperationMode
    "fun [DSBuffer F F F] DSBuffer",	//  _SETPosition3D
    "fun [DSBuffer F F F] DSBuffer",	//  _SETVelocity3D
    "fun [DSBuffer I I] DSBuffer",	//  _SETConeAngles
    "fun [DSBuffer F F F] DSBuffer",	//  _SETConeOrientation
    "fun [DSBuffer I] DSBuffer",		//  _SETConeOutsideVolume
    /////////////////////////////////////////////////////////////
    "fun [DSBuffer] I",               //  _GETMinDistance
    "fun [DSBuffer] I",               //  _GETMaxDistance
    "fun [DSBuffer] I",               //  _GETOperationMode
    "fun [DSBuffer] [F F F]",         //  _GETPosition3D
    "fun [DSBuffer] [F F F]",         //  _GETVelocity3D
    "fun [DSBuffer] [I I]",           //  _GETConeAngles
    "fun [DSBuffer] [F F F]",         //  _GETConeOrientation
    "fun [DSBuffer] I",               //  _GETConeOutsideVolume
    //////////////////////////////////////// 3D LISTENER 
    "fun [Chn DS] DSListener3D",            //  _CreateListener3D,         
    "fun [DSListener3D] I",              //  _DSListener3D,         
    "fun [DSListener3D F] DSListener3D",//  _SETDistanceFactor           
    "fun [DSListener3D F] DSListener3D",//  _SETDopplerFactor            
    "fun [DSListener3D F] DSListener3D",//  _SETRollOffFactor            
    "fun [DSListener3D F F F] DSListener3D",  //  _SETListenerPosition3D       
    "fun [DSListener3D F F F] DSListener3D",        //  _SETListenerVelocity3D       
    "fun [DSListener3D F F F F F F] DSListener3D",        //  _SETListenerOrientation      
    "fun [DSListener3D] F",             //  _GETDistanceFactor           
    "fun [DSListener3D] F",             //  _GETDopplerFactor            
    "fun [DSListener3D] F",             //  _GETRollOffFactor            
    "fun [DSListener3D] [F F F]",       //  _GETListenerPosition3D       
    "fun [DSListener3D] [F F F]",       //  _GETListenerVelocity3D       
    "fun [DSListener3D] [F F F]",       //  _GETListenerOrientation3D    
    "fun [DSListener3D] I",             //  _COMMITSoundSettings
    //////////////////////////////////////////// WAVE IO
    "fun [P] [I I I I]",				  //  _GETwaveInfo
    "fun [Wave I I I] S",				  //  _READwave
    "fun [P] S",						  //  _GETwaveData
    "fun [P] Wave",                     //  _OPENwave
    "fun [Wave] I",                     //  _CLOSEwave
    "fun [Wave I I] I",				  //  _SEEKwave
    "fun [DSBuffer I Wave I I I] DSBuffer",      //  _SETSoundBufferFromWave
    //////////////////////////////////////////// MP3!
    "fun [Chn] MP3",				      //  _CRmp3,
    "fun [MP3] I",					  //  _DSmp3,
    "fun [MP3 S] S",					  //  _DecodeMp3,
    "fun [S] [I I I I I I]",            //  _GetMP3FrameInfo,
    
    "fun [Chn DS P I] DSStream",		  //  _CreateSoundStream
    "fun [DS P I] DSStream",			  //  _CRSoundStream
} ;


int SOUNDnarg [ NBSOUNDPKG ] = 
{
	TYPTYPE,						// AsSnd,
	TYPTYPE,						// AsRecorder,

	TYPVAR,							// AS_SND_STATIC,
	TYPVAR,							// AS_SND_STREAMING,
	
	TYPVAR,							// AS_SND_BEGIN,
	TYPVAR,							// AS_SND_CURRENT,
	TYPVAR,							// AS_SND_END,

	TYPVAR,							// AS_SND_CTRL3D,
	TYPVAR,							// AS_SND_CTRLFREQUENCY,
	TYPVAR,							// AS_SND_CTRLPAN,

	TYPVAR,							// AS_SND_LINEAR
	TYPVAR,							// AS_SND_CIRCULAR

	TYPVAR,							// AS_SND_END_REFLEX
	TYPVAR,							// AS_SND_LOOP
	TYPVAR,							// AS_SND_LINKED_TO_H3D

	// Son 2D et 3D
	2,								// asSndCreate,
	1,								// asSndDestroy,
	5,								// asSndInit 
	3,								// asSndFeed 
	3,								// asSndLoad,
	2,								// asSndCopy 
	2,								// asSndPlay,
	1,								// asSndStop,
	1,								// asSndIsPlaying
	0,								// asEnableAllSnd,
	0,								// asDisableAllSnd,
	1,								// asSndReset,
	1,								// asSndGetSize,
	3,								// asSndSetTime,
	1,								// asSndGetTime,
	2,								// asSndSetVolume,
	1,								// asSndGetVolume
	1,								// asSetVolume ,
	0,								// asGetVolume ,
	2,								// asSndSetPan ,
	1,								// asSndGetPan,
	2,								// asSndSetFrequency,
	1,								// asSndGetFrequency,
	4,								// asSndSetCallBackTime

	// Son 3D
	1,								// as3dListenerCreate 
	2,								// as3dListenerSetActive
	3,								// as3dListenerSetRollOff,
	2,								// as3dListenerGetRollOff,
	3,								// as3dSndCreate,
	4,								// as3dSndSetCone
	2,								// as3dSndGetCone
	4,								// as3dSndSetDistance
	2,								// as3dSndGetDistance
	2,								// as3dSndEnable
	2,								// as3dSndDisable

	//Enregistrement
	2,								// asRecorderCreate,
	1,								// asRecorderDestroy,
	9,								// asRecorderInit,
	1,								// asRecorderStart,
	1,								// asRecorderStop,
	
	
	
	// wave lib
	TYPTYPE,						// AsWave,

	// WAVE I/O
	1,								// asWaveGetInfo
	2,								// asWaveCreate
	1,								// asWaveDestroy 
	4,								// asWaveRead
	
	
	
	// Mp3 Lib
	TYPTYPE,  //  AsMp3,                           

	////// AsMp3 I/O
	1,      // _CRMp3
	1,      // asMp3Destroy
	1,		// asMp3GetFrameInfo
	2,		// asMp3Decode 
	
	
	// easy sound library
	TYPTYPE,	// SoundPlay
	TYPTYPE,	// SoundRec
	
	5,			// _sndPlayStart				 
	0,			// _sndPlayStop				 
	5,			// _sndRecStart
	0,			// _sndRecStop				
	0,			// _sndSetPending			
	3,			// _sndSetRflxPlayBuf			
	3,			// _sndSetRflxPlayClose		
	3,			// _sndSetRflxPlayOpen
	3,			// _sndSetRflxRecBuf	
	3,			// _sndSetRflxRecClose	 
	3,			// _sndSetRflxRecOpen	
	0,			// _sndUnsetPending	
	
	
	// SDsound Lib
    TYPTYPE,  //  DS,                            
    TYPTYPE,  //  DSBuffer,                      
    TYPTYPE,  //  DSListener3D,
    TYPTYPE,  //  MP3,
    TYPTYPE,  //  Wave,
    
    TYPVAR,   //  DSSL_NORMAL
    TYPVAR,   //  DSSL_PRIORITY
    TYPVAR,   //  DSSCL_EXCLUSIVE
    
    6,        //  _CreateDirectSound,
    5,		//	_InitDirectSound
    1,        //  _ReleaseDirectSound,    
    //////////////////////////// 2D     
    7,        //  _CreateSoundBuffer,
    6,		//  _CRSoundBuffer,
    3,        //  _CopySoundBuffer,
    2,		//  _DUPSoundBuffer,
    1,        //  _DSSoundBuffer,         
    2,        //  _PLAYSoundBuffer,       
    1,        //  _STOPSoundBuffer,       
    2,        //  _SETVolume,             
    2,        //  _SETFrequency,          
    2,        //  _SETPan,                
    1,        //  _GETVolume,             
    1,        //  _GETFrequency,          
    1,        //  _GETPan,                
    3,        //  _SETSoundBuffer,        
    1,        //  _GETPlayPosition,       
    1,        //  _GETWritePosition,      
    2,        //  _SETPlayPosition,       
    ///////////////////////////// 3D     
    7,        //  _CreateSoundBuffer3D,
    6,		//  _CRSoundBuffer3D,
    /////////////////////////////                          
    2,        //  _SETMinDistance
    2,        //  _SETMaxDistance
    2,        //  _SETOperationMode
    4,        //  _SETPosition3D
    4,        //  _SETVelocity3D
    3,        //  _SETConeAngles
    4,        //  _SETConeOrientation
    2,        //  _SETConeOutsideVolume
    /////////////////////////////////
    1,        //  _GETMinDistance
    1,        //  _GETMaxDistance
    1,        //  _GETOperationMode
    1,        //  _GETPosition3D
    1,        //  _GETVelocity3D
    1,        //  _GETConeAngles
    1,        //  _GETConeOrientation
    1,        //  _GETConeOutsideVolume
    //////////////////////////////////////// 3D LISTENER 
    2,        //  _CreateListener3D,         
    1,        //  _DSListener3D,         
    2,        //  _SETDistanceFactor           
    2,        //  _SETDopplerFactor            
    2,        //  _SETRollOffFactor            
    4,        //  _SETListenerPosition3D       
    4,        //  _SETListenerVelocity3D       
    7,        //  _SETListenerOrientation      
    1,        //  _GETDistanceFactor           
    1,        //  _GETDopplerFactor            
    1,        //  _GETRollOffFactor            
    1,        //  _GETListenerPosition3D       
    1,        //  _GETListenerVelocity3D       
    1,        //  _GETListenerOrientation3D    
    1,        //  _COMMITSoundSettings
    //////////////////////////////////////////// WAVE IO
    1,		// _GETwaveInfo
    4,		// _READwave
    1,		//  _GETwaveData
    1,        //  _OPENwave
    1,        //  _CLOSEwave
    3,		//  _SEEKwave
    6,        //  _SETSoundBufferFromWave 
    //////////////////////////////////////////// MP3!
    1,        // _CRMp3
    1,        // _DSmp3
    2,        //  _DecodeMP3
    1,        //  _GetMP3FrameInfo
    
    4,		//  _CreateSoundStream
    3,		//  _CRSoundStream
} ;



int (*SOUNDfun[NBSOUNDPKG])(mmachine m)= 
{
	NULL,															// AsSnd,
	NULL,															// AsRecorder,
																	
	constantes(0),			// AS_SND_STATIC,
	constantes(0),		// AS_SND_STREAMING,
																	
	constantes(0),				// AS_SND_BEGIN,
	constantes(0),				// AS_SND_CURRENT,
	constantes(0),				// AS_SND_END,
																	
	constantes(0),				// AS_SND_CTRL3D,
	constantes(0),	// AS_SND_CTRLFREQUENCY,
	constantes(0),		// AS_SND_CTRLPAN,

	constantes(0),			// AS_SND_LINEAR
	constantes(0),		// AS_SND_CIRCULAR

	constantes(0),		// AS_SND_END_REFLEX
	constantes(0),			// AS_SND_LOOP
	constantes(0),	// AS_SND_LINKED_TO_H3D
 
	// Son 2D et 3D													
	asSndCreate,													// asSndCreate,
	asSndDestroy,													// asSndDestroy,
	asSndInit,														// asSndInit 
	asSndFeed,														// asSndFeed 
	asSndLoad,														// asSndLoad,
	asSndCopy,														// asSndCopy 
	asSndPlay,														// asSndPlay,
	asSndStop,														// asSndStop,
	asSndIsPlaying,													// asSndIsPlaying,
	asEnableAllSnd,													// asEnableAllSnd,
	asDisableAllSnd,												// asDisableAllSnd,
	asSndReset,														// asSndReset,
	asSndGetSize,													// asSndGetSize,
	asSndSetTime,													// asSndSetTime,
	asSndGetTime,													// asSndGetTime,
	asSndSetVolume,													// asSndSetVolume,
	asSndGetVolume,													// asSndGetVolume,
	asSetVolume,													// asSetVolume ,
	asGetVolume,													// asGetVolume ,
	asSndSetPan,													// asSndSetPan ,
	asSndGetPan,													// asSndGetPan,
	asSndSetFrequency,												// asSndSetFrequency,
	asSndGetFrequency,												// asSndGetFrequency,
	asSndSetCallBackTime,											// asSndSetCallBackTime
																	
	// Son 3D														
	as3dListenerCreate ,											// as3dListenerCreate 
	as3dListenerSetActive,											// as3dListenerSetActive
	as3dListenerSetRollOff,											// as3dListenerSetRollOff
	as3dListenerGetRollOff,											// as3dListenerGetRollOff
	as3dSndCreate,													// as3dSndCreate,
	as3dSndSetCone,													// as3dSndSetCone
	as3dSndGetCone,													// as3dSndGetCone
	as3dSndSetDistance,												// as3dSndSetDistance
	as3dSndGetDistance,												// as3dSndGetDistance
	as3dSndEnable,													// as3dSndEnable
	as3dSndDisable,													// as3dSndDisable

	// Enregistrement
	asRecorderCreate,												// asRecorderCreate,
	asRecorderDestroy,												// asRecorderDestroy,
	asRecorderInit,													// asRecorderInit,
	asRecorderStart,												// asRecorderStart,
	asRecorderStop,													// asRecorderStop,
	
	
	// wave lib
	NULL,															// AsWave,

	// WAVE I/O
	asWaveGetInfo,													// asWaveGetInfo
	asWaveCreate,													// asWaveCreate
	asWaveDestroy ,													// asWaveDestroy 
	asWaveRead,														// asWaveRead
	
	
	
	// Mp3 lib
	NULL,				//  AsMp3,                          

	////// AsMp3 I/O
	asMp3Create,				// asMp3Create
	asMp3Destroy,				// asMp3Destroy
	asMp3GetFrameInfo,	// asMp3GetFrameInfo
	asMp3Decode,			// asMp3Decode
	
	
	// easy sound library
	NULL,					// SoundPlay
	NULL,					// SoundRec
	
	_sndPlayStart,			// _sndPlayStart				 
	_sndPlayStop,			// _sndPlayStop				 
	_sndRecStart,			// _sndRecStart
	_sndRecStop,			// _sndRecStop				
	_sndSetPending,			// _sndSetPending			
	_sndSetRflxPlayBuf,		// _sndSetRflxPlayBuf			
	_sndSetRflxPlayClose,	// _sndSetRflxPlayClose		
	_sndSetRflxPlayOpen,	// _sndSetRflxPlayOpen
	_sndSetRflxRecBuf,		// _sndSetRflxRecBuf	
	_sndSetRflxRecClose,	// _sndSetRflxRecClose	 
	_sndSetRflxRecOpen,		// _sndSetRflxRecOpen	
	_sndUnsetPending,		// _sndUnsetPending		
	
    // SDsound Lib
    NULL,														//  DS,                           
    NULL,														//  DSBuffer,                     
    NULL,														//  DSListener3D,                 
    NULL,														//  MP3,   
    NULL,														//  Wave,   
    
    constantes(0),		//  DSSL_NORMAL
    constantes(0),	//  DSSL_PRIORITY
    constantes(0),	//  DSSCL_EXCLUSIVE
    
    _CreateDirectSound,										//  _CreateDirectSound,
    _InitDirectSound,											//  _InitDirectSound,
    _ReleaseDirectSound,										//  _ReleaseDirectSound,    
    ////////////////// 2D ////////////////////////////////// 2D     
    _CreateSoundBuffer,										//  _CreateSoundBuffer,
    _CRSoundBuffer,											//  _CRSoundBuffer
    _CopySoundBuffer,											//  _CopySoundBuffer, 
    _DUPSoundBuffer,											//  _DUPSoundBuffer
    _DSSoundBuffer,											//  _DSSoundBuffer,         
    asSndPlay,												//  _PLAYSoundBuffer,       
    asSndStop,												//  _STOPSoundBuffer,       
    asSndSetVolume,											//  _SETVolume,             
    asSndSetFrequency,										//  _SETFrequency,          
    asSndSetPan,												//  _SETPan,                
    asSndGetVolume,											//  _GETVolume,             
    asSndGetFrequency,										//  _GETFrequency,          
    asSndGetPan,												//  _GETPan,                
    _SETSoundBuffer,											//  _SETSoundBuffer,        
    _GETPlayPosition,											//  _GETPlayPosition,       
    _GETWritePosition,										//  _GETWritePosition,      
    _SETPlayPosition,											//  _SETPlayPosition,       
    ////////////////// 3D //////////////////////////////////// 3D     
    _CreateSoundBuffer3D,										//  _CreateSoundBuffer3D,
    _CRSoundBuffer3D,											//  _CRSoundBuffer3D,
    ////////////////////////////////////////////////////////////////////
    _SETMinDistance,											//  _SETMinDistance,
    _SETMaxDistance,											//  _SETMaxDistance,
    _SETOperationMode,										//  _SETOperationMode,
    _SETPosition3D,											//  _SETPosition3D,
    _SETVelocity3D,											//  _SETVelocity3D,
    _SETConeAngles,											//  _SETConeAngles,
    _SETConeOrientation,										//  _SETConeOrientation,
    _SETConeOutsideVolume,									//  _SETConeOutsideVolume,
    ////////////////////////////////////////////////////////////////////
    _GETMinDistance,											//  _GETMinDistance,
    _GETMaxDistance,											//  _GETMaxDistance,
    _GETOperationMode,										//  _GETOperationMode,
    _GETPosition3D,											//  _GETPosition3D,
    _GETVelocity3D,											//  _GETVelocity3D,
    _GETConeAngles,											//  _GETConeAngles,
    _GETConeOrientation,										//  _GETConeOrientation,
    _GETConeOutsideVolume,									//  _GETConeOutsideVolume
    //////////////////////////////////////// 3D LISTENER 
    _CreateListener3D,										//  _CreateListener3D,         
    _DSListener,												//  _DSListener3D,         
    _SETDistanceFactor,										//  _SETDistanceFactor           
    _SETDopplerFactor,										//  _SETDopplerFactor            
    _SETRollOffFactor,										//  _SETRollOffFactor            
    _SETListenerPosition3D,									//  _SETListenerPosition3D       
    _SETListenerVelocity3D,									//  _SETListenerVelocity3D       
    _SETListenerOrientation,									//  _SETListenerOrientation      
    _GETDistanceFactor,										//  _GETDistanceFactor           
    _GETDopplerFactor,										//  _GETDopplerFactor            
    _GETRollOffFactor,										//  _GETRollOffFactor            
    _GETListenerPosition3D,									//  _GETListenerPosition3D       
    _GETListenerVelocity3D,									//  _GETListenerVelocity3D       
    _GETListenerOrientation3D,								//  _GETListenerOrientation3D    
    _COMMITSoundSettings ,									//  _COMMITSoundSettings
    //////////////////////////////////////////// WAVE IO
    asWaveGetInfo,											//  _GETwaveInfo
    asWaveRead,												//  _READwave
    _GETwaveData,												//  _GETwaveData
    _OPENwave,												//  _OPENwave
    asWaveDestroy,											//  _CLOSEwave
    _SEEKwave,												//  _SEEKwave
    _SETSoundBufferFromWave,									//  _SETSoundBufferFromWave 
    //////////////////////////////////////////// MP3!
    asMp3Create,												// _CRmp3
    asMp3Destroy,												// _DSmp3
    asMp3Decode,
    _GetMP3FrameInfo,											// _GetMP3FrameInfo
    
    ///////////////////////////////////////////// STREAM
    _CreateSoundStream,									    // _CreateSoundStream
    _CRSoundStream,											// _CRSoundStream
} ;







extern "C" int SCOLloadSound(mmachine m)
{
	return PKhardpak(m,"Audio System",NBSOUNDPKG,SOUNDname,SOUNDfun,SOUNDnarg,SOUNDtype);
}