SEALÉùÒôº¯ÊýÊÖ²á
·­Ò룺Фô´(xiaoge@21cn.com)
/*------------------------------------------------------------------------------------*/
/*ÉùÒôÉ豸º¯Êý                                                                        */
/*------------------------------------------------------------------------------------*/
//±¾³ÌÐò¿â´ø32ÉùµÀ»ìÒô
/*---------------------------------------------------------------------*/
UINT AIAPI AInitialize(void)				//³õʼ»¯,DOSϱØÐë
/*---------------------------------------------------------------------*/
UINT AIAPI AGetAudioDevCaps(UINT nDeviceId, LPAUDIOCAPS lpCaps)
//µÃµ½ÉùÒôÉ豸µÄÐÅÏ¢(³É¹¦·µ»Ø0)
nDeviceId		ÉùÒôÉ豸ʶ±ðºÅ
lpCaps		Ò»¸öAUDIOCAPS½á¹¹µÄµØÖ·Ö¸Õë
///////////////////////////////////////////
VOID PrintAudioDevs(VOID)
{
	AUDIOCAPS caps;
	UINT nDeviceId;

	/* show all the installed device drivers */
	for (nDeviceId = 0; nDeviceId < AGetAudioNumDevs(); nDeviceId++) 
	{
		AGetAudioDevCaps(nDeviceId, &caps);
		printf(nDeviceId=%d wProductId=%d szProductName=%s\n”,
		nDeviceId, caps.wProductId, caps.szProductName);
	}
}
/*---------------------------------------------------------------------*/
AUDIOCAPS½á¹¹	//˵Ã÷ÉùÒôÉ豸µÄÄÜÁ¦
typedef struct 
{
    WORD    wProductId;
    CHAR    szProductName[30];
    DWORD   dwFormats;
} AUDIOCAPS, *LPAUDIOCAPS;
///////////////////////////////////////////
wProductId	//Ó²¼þ±êʶ,¾ßÓÐÒÔÏÂÖµ

Value					Description
AUDIO_PRODUCT_NONE		Virtual silence device
AUDIO_PRODUCT_SB		Sound Blaster 1.0 device
AUDIO_PRODUCT_SB15		Sound Blaster 1.5 device
AUDIO_PRODUCT_SB20		Sound Blaster 2.0 device
AUDIO_PRODUCT_SBPRO		Sound Blaster Pro I or II device
AUDIO_PRODUCT_SB16		Sound Blaster 16/ASP device
AUDIO_PRODUCT_AWE32		Sound Blaster AWE32 device
AUDIO_PRODUCT_WSS		Windows Sound System device

AUDIO_PRODUCT_ESS		Ensoniq Soundscape (Elite) device
AUDIO_PRODUCT_GUS		Gravis Ultrasound (GF1) device
AUDIO_PRODUCT_GUSDB		Gravis Ultrasound Daughterboard device
AUDIO_PRODUCT_GUSMAX	Gravis Ultrasound Max (CS4231) device
AUDIO_PRODUCT_IWAVE		AMD Interwave-based device
AUDIO_PRODUCT_PAS		Pro Audio Spectrum (Plus) device
AUDIO_PRODUCT_PAS16		Pro Audio Spectrum 16 device

AUDIO_PRODUCT_ARIA		Sierra Semiconductors Aria Sound device
AUDIO_PRODUCT_WINDOWS	Microsoft Windows WAVE device
AUDIO_PRODUCT_DSOUND	Microsoft Windows DirectSound device
AUDIO_PRODUCT_LINUX		UNIX Sound System for Linux device
AUDIO_PRODUCT_SPARC		SPARC workstation 8-bit ulaw or dbri device
AUDIO_PRODUCT_SGI		Silicon Graphics Indigo Audio Ports device
///////////////////////////////////////////
szProductName
Ó²¼þ²úÆ·Ãû³Æ×Ö·û´®,NULL½áÊø
///////////////////////////////////////////
dwFormats
²úÆ·»Ø·ÅÄÜÁ¦±êʾ

Value				Description
AUDIO_FORMAT_1M08	8-bit mono 11025 Hz
AUDIO_FORMAT_1S08	8-bit stereo 11025 Hz
AUDIO_FORMAT_1M16	16-bit mono 11025 Hz
AUDIO_FORMAT_1S16	16-bit stereo 11025 Hz
AUDIO_FORMAT_2M08	8-bit mono 22050 Hz
AUDIO_FORMAT_2S08	8-bit stereo 22050 Hz
AUDIO_FORMAT_2M16	16-bit mono 22050 Hz
AUDIO_FORMAT_2S16	16-bit stereo 22050 Hz
AUDIO_FORMAT_4M08	8-bit mono 44100 Hz
AUDIO_FORMAT_4S08	8-bit stereo 44100 Hz

AUDIO_FORMAT_4M16	16-bit mono 44100 Hz
AUDIO_FORMAT_4S16	16-bit stereo 44100 Hz
/*---------------------------------------------------------------------*/
UINT AIAPI AGetAudioNumDevs(VOID)
//·µ»Ø°²×°µÄÉùÒôÉ豸¸öÊý
/*---------------------------------------------------------------------*/
UINT AIAPI APingAudio(LPUINT lpnDeviceId)
//×Ô¶¯·¢ÏÖÉùÒôÉ豸
lpnDeviceId		ÎÞ·ûºÅÕûÊýÖ¸Õë,Ö¸ÏòID
///////////////////////////////////////////
VOID DetectAudioDevice(VOID)
{
	AUDIOCAPS caps;
	UINT nDeviceId;
	if (APingAudio(&nDeviceId) != AUDIO_ERROR_NONE)
	{
		printf(“no audio device found.\n”);
	}
	else 
	{
		AGetAudioDevCaps(nDeviceId, &caps);
		printf(“%s device found.\n”, caps.szProductName);
	}
}
/*---------------------------------------------------------------------*/
UINT AIAPI AOpenAudio(LPAUDIOINFO lpInfo)
//´ò¿ªÉùÒôÉ豸,³É¹¦·µ»Ø0
lpInfo	 AUDIOINFO½á¹¹Ö¸Õë,É趨»Ø·Å²ÎÊý
///////////////////////////////////////////
VOID InitializeAudio(VOID)
{
	AUDIOINFO info;
	info.nDeviceId = AUDIO_DEVICE_MAPPER;
	info.wFormat = AUDIO_FORMAT_16BITS | AUDIO_FORMAT_STEREO;
	info.nSampleRate = 44100;
	if (AOpenAudio(&info) != AUDIO_ERROR_NONE)
	{
		printf("Audio initialization failed.\n");
		exit(1);
	}
	else
	{
		printf("Audio device initialized at %d bits %s %u Hz\n",
		info.wFormat & AUDIO_FORMAT_16BITS?"16:8",
		info.wFormat & AUDIO_FORMAT_STEREO?"stereo:mono",info.nSampleRate);
	}
}
/*---------------------------------------------------------------------*/
typedef struct		//ÉùÒô»Ø·ÅÉ趨
{
    UINT    nDeviceId;
    WORD    wFormat;
    WORD    nSampleRate;
} AUDIOINFO, *LPAUDIOINFO;
///////////////////////////////////////////
nDeviceId
//Ö¸¶¨ÎÒÃÇÏ£Íû»Ø·ÅµÄÉ豸
Value				Description
AUDIO_DEVICE_NONE	Silence device driver
AUDIO_DEVICE_MAPPER	Audio mapper driver
///////////////////////////////////////////
wFormat
//»Ø·Å¸ñʽ
Value				Description
AUDIO_FORMAT_8BITS	8 bits per sample
AUDIO_FORMAT_16BITS	16 bits per sample
AUDIO_FORMAT_MONO	Monophonic output
AUDIO_FORMAT_STEREO	Stereo output
AUDIO_FORMAT_FILTER	Enable filtering
///////////////////////////////////////////
nSampleRate
//»Ø·ÅƵÂÊ,ÍƼöʹÓÃ11025,22050,44100Hz
/*---------------------------------------------------------------------*/
UINT AIAPI AUpdateAudio(VOID)
//ÏòÉùÒôÉ豸ËÍÉùÒôÖµ(·µ0³É¹¦),DOSϱØÐë
//±ØÐëÖÜÆÚÐԵĵ÷ÓÃ(ÖÁÉÙÿÃëÖÓµ÷ÓÃÒ»´Î)
/*---------------------------------------------------------------------*/
UINT AIAPI ACloseAudio(VOID)
//¹Ø±ÕÉùÒôÉ豸(·µ0³É¹¦)
/*---------------------------------------------------------------------*/
//////////////////////////ʱÖÓÖжϷþÎñ///////////////////////////////////
/*---------------------------------------------------------------------*/
UINT AIAPI ASetAudioTimerProc(LPFNAUDIOTIMER lpfnAudioTimer)
//°²×°Ê±ÖÓ·þÎñ³ÌÐò(·µ0³É¹¦),ºǫ́»Ø·Å,Óû§³ÌÐò²»¿ÉÔÙÓÃ
lpfnAudioTimer	ʱÖÓ´¦Àí³ÌÐòµØÖ·
///////////////////////////////////////////
volatile UINT nTickCounter = 0;

VOID AIAPI TimerHandler(VOID)
{
	nTickCounter++;
}

VOID InitTimerHandler(VOID)
{
	/* the handler will be called at 125 BPM (50 times per second) */
	ASetAudioTimerProc(TimerHandler);
	ASetAudioTimerRate(125);
}

VOID DoneTimerHandler(VOID)
{
	ASetAudioTimerProc(NULL);
}
/*---------------------------------------------------------------------*/
UINT AIAPI ASetAudioTimerRate(UINT nTimerRate)
//¸Ä±äʱÖÓƵÂÊ(·µ0³É¹¦)
nTimerRate	ÿ·ÖÖÓÅĽÚ(32-255)
/*---------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------*/
/*Voiceº¯Êý                                                                           */
/*------------------------------------------------------------------------------------*/
UINT AIAPI AOpenVoices(UINT nVoices)
//´ò¿ªÉùÒôÉ豸(0³É¹¦)
nVoices		×î´óÉùµÀÊý(1-32)(¿ÉÄÜÊÇ»ìÒôÉùµÀÊý)
/*---------------------------------------------------------------------*/
UINT AIAPI ACreateAudioVoice(LPHAC lphVoice)
//·ÖÅä1ÌõÉùµÀ(0³É¹¦)
lphVoice	ÉùµÀÍ·
///////////////////////////////////////////
VOID PlayWaveform(LPAUDIOWAVE lpWave)
{
	HAC hVoice;
	BOOL stopped;

	/* allocate an audio voice or channel */		
	if (ACreateAudioVoice(&hVoice) == AUDIO_ERROR_NONE)
	{

		/* play the waveform through the voice */
		APlayVoice(hVoice, lpWave);
		ASetVoiceVolume(hVoice, 64);
		ASetVoicePanning(hVoice, 128);

		/* wait until the wave finishes or a key is pressed */
		while (!kbhit())
		{
			AUpdateAudio();
			AGetVoiceStatus(hVoice, &stopped);
			if (stopped) break;
		}

		/* stop the voice (if already playing) */
		AStopVoice(hVoice);

		/* release the allocated voice */
		ADestroyAudioVoice(hVoice);
	}
}
/*---------------------------------------------------------------------*/
UINT AIAPI ADestroyAudioVoice(HAC hVoice)
//ÊÍ·ÅÒ»¸öÉùµÀ(ÿÌõÉùÒô²¥Íêºó±ØÐëÊÍ·Å)
hVoice	ÉùµÀÍ·
/*---------------------------------------------------------------------*/
UINT AIAPI ACloseVoices(VOID)
//¹Ø±ÕËùÓÐÉùÒô
/*---------------------------------------------------------------------*/
UINT AIAPI APlayVoice(HAC hVoice, LPAUDIOWAVE lpWave)
//¿ªÊ¼²¥·ÅÒ»Ìõ²¨ÐÎ
hVoice	ÉùµÀÍ·
lpWave	wave½á¹¹Ö¸Õë
/*---------------------------------------------------------------------*/
UINT AIAPI APrimeVoice(HAC hVoice, LPAUDIOWAVE lpWave)
//×¼±¸Ò»Ìõwaveµ½ÉùµÀÉÏ
hVoice	ÉùµÀÍ·
lpWave	wave½á¹¹Ö¸Õë
///////////////////////////////////////////
VOID PlayChord(HAC aVoices[3], LPAUDIOWAVE lpWave, LONG aFreqs[3])
{
	UINT n;

	/* first prepare the voices to play the waveform */
	for (n = 0 ; n < 3 ; n++)
	{
		APrimeVoice(aVoices[n], lpWave);
		ASetVoiceFrequency(aVoices[n], aFreqs[n]);
		ASetVoiceVolume(aVoices[n], 64);
	}

	/* now start playing all them simultaneously */
	for (n = 0 ; n < 3 ; n++)
	{
		AStartVoice(aVoices[n]);
	}
}
/*---------------------------------------------------------------------*/
UINT AIAPI AStartVoice(HAC hVoice)
//²¥·ÅÒ»¸öÉùµÀ,¿ÉÒÔÖ¸¶¨Á¬ÐøÑ­»·²¥·Å
hVoice	ÉùµÀÍ·
/*---------------------------------------------------------------------*/
UINT AIAPI AStopVoice(HAC hVoice)
//Í£Ö¹²¥·ÅÒ»¸öÉùµÀ
hVoice	ÉùµÀÍ·
/*---------------------------------------------------------------------*/
UINT AIAPI AGetVoicePosition(HAC hVoice, LPLONG lpdwPosition)
//·µ»ØÕýÔÚ²¥·ÅµÄÉùÒôλÖÃ(²¥·Åµã,×öÀ­ÌõÓÃ)
hVoice			//ѯÎʵÄÉùµÀÍ·
lpdwPosition	//³¤Ö¸Õë·µ»Ø²¥·Åµã
/*---------------------------------------------------------------------*/
UINT AIAPI ASetVoicePosition(HAC hVoice, LONG dwPosition)
//É趨ÕýÔÚ²¥·ÅµÄÉùÒôλÖÃ(²¥·Åµã,×öÀ­ÌõÓÃ)
hVoice			//É趨µÄÉùµÀÍ·
lpdwPosition	//³¤Ö¸ÕëÉ趨²¥·Åµã
///////////////////////////////////////////
VOID PlayEchoVoices(HAC aVoices[2], LPAUDIOWAVE lpWave, LONG dwDelay)
{
	/* prepare two voices with the same waveform */
	APrimeVoice(aVoices[0], lpWave);
	APrimeVoice(aVoices[1], lpWave);
	ASetVoiceFrequency(aVoices[0], lpWave->nSampleRate);
	ASetVoiceFrequency(aVoices[1], lpWave->nSampleRate);

	/* set voice volumes (the “echo” voice has a lower volume) */
	ASetVoiceVolume(aVoices[0], 64);
	ASetVoiceVolume(aVoices[1], 32);

	/* set the delay (measured in samples) for the “echo” voice */
	ASetVoicePosition(aVoices[1], dwDelay);

	/* start both voices as simultenously as possible */		
	AStartVoice(aVoices[0]);
	AStartVoice(aVoices[1]);
}
/*---------------------------------------------------------------------*/
UINT AIAPI AGetVoiceVolume(HAC hVoice, LPUINT lpnVolume)
//µÃµ½ÉùµÀµÄÒôÁ¿
hVoice			//ѯÎʵÄÉùµÀÍ·
lpdwPosition	//ÎÞ·ûºÅÕûÐÎÖ¸Õë·µ»ØÒôÁ¿
/*---------------------------------------------------------------------*/
UINT AIAPI ASetVoiceVolume(HAC hVoice, UINT nVolume)
//É趨ÉùµÀµÄÒôÁ¿
hVoice			//É趨µÄÉùµÀÍ·
lpdwPosition	//ÎÞ·ûºÅÕûÐÎÖ¸ÕëÉ趨ÒôÁ¿
/*---------------------------------------------------------------------*/
UINT AIAPI AGetVoiceFrequency(HAC hVoice, LPLONG lpdwFrequency)
//·µ»ØÉùµÀÈ¡ÑùƵÂÊ
lpdwFrequency	ÿÃëHzÊý
/*---------------------------------------------------------------------*/
UINT AIAPI ASetVoiceFrequency(HAC hVoice, LONG dwFrequency)
//É趨ÉùµÀÈ¡ÑùƵÂÊ
dwFrequency		ÿÃëHzÊý
///////////////////////////////////////////
VOID PlayVoiceStereo(HAC aVoices[2], LPAUDIOWAVE lpWave, LONG dwPitchShift)
{
	/* prepare two voices to play a waveform */
	APrimeVoice(aVoices[0], lpWave);
	APrimeVoice(aVoices[1], lpWave);
	ASetVoiceVolume(aVoices[0], 64);
	ASetVoiceVolume(aVoices[1], 64);

	/* slightly change the pitch of one of the voices */
	ASetVoiceFrequency(aVoices[0], lpWave->nSampleRate);
	ASetVoiceFrequency(aVoices[1], lpWave->nSampleRate +

	dwPitchShift);

	/* set the pan position of the voices to left and right */
	ASetVoicePanning(aVoices[0], 0);
	ASetVoicePanning(aVoices[1], 255);

	/* start both voices simultaneously */
	AStartVoice(aVoices[0]);
	AStartVoice(aVoices[1]);
}
/*---------------------------------------------------------------------*/
UINT AIAPI AGetVoicePanning(HAC hVoice, LPUINT lpnPanning)
//·µ»ØÁ¢ÌåÉùÃæ°å(?)λÖÃ
lpnPanning	unsigned integerÖ¸Õë
/*---------------------------------------------------------------------*/
UINT AIAPI ASetVoicePanning(HAC hVoice, UINT nPanning)
//¸Ä±äÁ¢ÌåÉùÃæ°å(?)λÖÃ
nPanning	Á¢ÌåÉùÃæ°åÖµ(0-255)
/*---------------------------------------------------------------------*/
UINT AIAPI AGetVoiceStatus(HAC hVoice, LPBOOL lpbStatus)
//·µ»Øµ±Ç°ÉùÒô״̬
///////////////////////////////////////////
lpbStatus	boolean±äÁ¿Ö¸Õë
VOID CheckVoice(HAC hVoice)
{
	BOOL stopped;
	AGetVoiceStatus(hVoice, &stopped);
	if (stopped)	printf("voice is stopped.\n");
}
/*------------------------------------------------------------------------------------*/
/*Waveº¯Êý                                                                            */
/*------------------------------------------------------------------------------------*/
UINT AIAPI ALoadWaveFile(LPSTR lpszFileName, LPAUDIOWAVE* lplpWave,DWORD dwOffset)
//LOADÒ»¸öRIFF/WAVEÎļþ
lpszFileName	Filename of the .WAV waveform file on disk.
lplpWave		Address of  a pointer to a waveform structure.
dwOffset		Starting file offset of the waveform file.
///////////////////////////////////////////
VOID PlayWaveFile(HAC hVoice, LPSTR lpszFileName)
{
	LPAUDIOWAVE lpWave;
	BOOL stopped;

	if (ALoadWaveFile(lpszFileName, &lpWave, 0L) == AUDIO_ERROR_NONE)
	{
		APlayVoice(hVoice, lpWave);
		ASetVoiceVolume(hVoice, 64);
		while (!kbhit())
		{
			AUpdateAudio();
			AGetVoiceStatus(hVoice, &stopped);
			if (stopped) break;
		}
		AFreeWaveFile(lpWave);
	}
}
/*---------------------------------------------------------------------*/
UINT AIAPI AFreeWaveFile(LPAUDIOWAVE lpWave)
//ÊÍ·ÅÒ»¸öWAVÎļþ
/*---------------------------------------------------------------------*/
UINT AIAPI ACreateAudioData(LPAUDIOWAVE lpWave)
//½¨Á¢Ò»¸öWAV¶ÔÏó
lpWave	Ö¸ÏòWAVE½á¹¹µÄÖ¸Õë
///////////////////////////////////////////
LPAUDIOWAVE CreateAudio8BitMono(WORD nSampleRate,LPBYTE lpData, DWORD dwLength)
{
	LPAUDIOWAVE lpWave;
	/* first allocate structure to hold the waveform object */
	if ((lpWave = (LPAUDIOWAVE) malloc(sizeof(AUDIOWAVE))) != NULL)
	{
		/* create a 8-bit mono one-shot waveform object */
		lpWave->wFormat = AUDIO_FORMAT_8BITS | AUDIO_FORMAT_MONO;
		lpWave->nSampleRate = nSampleRate;
		lpWave->dwLength = dwLength;
		lpWave->dwLoopStart = lpWave->dwLoopEnd = 0;
		if (ACreateAudioData(lpWave) != AUDIO_ERROR_NONE)
		{
			free(lpWave);
			return NULL;
		}
		/* copy the data into the waveform object */
		memcpy(lpWave->lpData, lpData, dwLength);
		/* upload the data to the audio DRAM local memory */
		AWriteAudioData(lpWave, 0L, dwLength);
	}
	return lpWave;
}
/*---------------------------------------------------------------------*/
UINT AIAPI ADestroyAudioData(LPAUDIOWAVE lpWave)
//ÊÍ·ÅÒ»¸öWAVE¶ÔÏó
/*---------------------------------------------------------------------*/
typedef struct		WAVE½á¹¹
{
    LPBYTE  lpData; 
    DWORD   dwHandle; 
    DWORD   dwLength; 
    DWORD   dwLoopStart; 
    DWORD   dwLoopEnd; 
    WORD    nSampleRate;
    WORD    wFormat;
} AUDIOWAVE, *LPAUDIOWAVE;
///////////////////////////////////////////
lpData   	Ö»¶Á,Êý¾ÝµØÖ·Ö¸Õë
///////////////////////////////////////////
dwHandle	Ö»¶Á,ÉùÒôÉ豸ʹÓõľä±ú
///////////////////////////////////////////
dwLength	Ö¸¶¨×Ö½ÚΪµ¥Î»µÄ²¨ÐÎÊý¾Ý³¤¶È
///////////////////////////////////////////
dwLoopStart	Ñ­»·Ä£Ê½ÏµÄÑ­»·Æðʼµã
///////////////////////////////////////////
dwLoopEnd	Ñ­»·Ä£Ê½ÏµÄÑ­»·½áÊøµã
///////////////////////////////////////////
nSampleEate	²¨ÐÎÊý¾ÝÔ¼¶¨µÄÈ¡ÑùƵÂÊ
///////////////////////////////////////////
wFormat		²¨ÐÎÊý¾Ý¸ñʽ
Value					Description
AUDIO_FORMAT_8BITS		8 bits per sample
AUDIO_FORMAT_16BITS		16 bits per sample
AUDIO_FORMAT_MONO		Monophonic output
AUDIO_FORMAT_STEREO		Stereo output
AUDIO_FORMAT_LOOP		Forward looping			ÏòÇ°Ñ­»·
AUDIO_FORMAT_BIDILOOP	Bidirectional looping	Ë«ÏòÑ­»·
AUDIO_FORMAT_REVERSE	Reverse playing			·´Ïò²¥·Å
/*------------------------------------------------------------------------------------*/
/*Musicº¯Êý                                                                           */
/*------------------------------------------------------------------------------------*/
UINT AIAPI ALoadModuleFile(LPSTR lpszFileName, LPAUDIOMODULE* lplpModule,DWORD dwOffset)
//µ÷ÈëÒ»¸öMOD/MTM/S3M/XMÎļþ
/*---------------------------------------------------------------------*/
UINT AIAPI AFreeModuleFile(LPAUDIOMODULE lpModule)
//ÊÍ·ÅÒ»¸öMOD/MTM/S3M/XMÎļþ
/*---------------------------------------------------------------------*/
UINT AIAPI APlayModule(LPAUDIOMODULE lpModule)
//²¥·ÅÒ»¸öÒôÀÖÎļþ
/*---------------------------------------------------------------------*/
UINT AIAPI AStopModule(VOID)
//Í£Ö¹²¥·ÅÒôÀÖÎļþ
/*---------------------------------------------------------------------*/
UINT AIAPI APauseModule(VOID)
//ÔÝÍ£²¥·ÅÒôÀÖÎļþ
/*---------------------------------------------------------------------*/
UINT AIAPI AResumeModule(VOID)
//ÖØпªÊ¼¼ÌÐø²¥·ÅÒôÀÖÎļþ
/*---------------------------------------------------------------------*/
UINT AIAPI AGetModulePosition(LPUINT lpnOrder, LPUINT lpnRow)
//·µ»ØÉùÒôÎļþ²¥·ÅλÖÃ
/*---------------------------------------------------------------------*/
UINT AIAPI ASetModulePosition(UINT nOrder, UINT nRow)
//¸Ä±äÉùÒôÎļþ²¥·ÅλÖÃ
/*---------------------------------------------------------------------*/
UINT AIAPI AGetModuleVolume(LPUINT lpnVolume)
//·µ»ØÉùÒôÎļþ²¥·ÅÒôÁ¿
/*---------------------------------------------------------------------*/
UINT AIAPI ASetModuleVolume(LPUINT lpnVolume)
//¸Ä±äÉùÒôÎļþ²¥·ÅÒôÁ¿(0-64)
/*---------------------------------------------------------------------*/
typedef struct		//ÒôÀֽṹ
{
    CHAR    szModuleName[32];
    WORD    wFlags;
    WORD    nOrders;
    WORD    nRestart;
    WORD    nTracks;
    WORD    nPatterns;
    WORD    nPatches;
    WORD    nTempo;
    WORD    nBPM;
    BYTE    aOrderTable[AUDIO_MAX_ORDERS];
    BYTE    aPanningTable[AUDIO_MAX_VOICES];
    LPAUDIOPATTERN aPatternTable;
    LPAUDIOPATCH aPatchTable;
} AUDIOMODULE, *LPAUDIOMODULE;
///////////////////////////////////////////
szModuleName	ÒôÀÖÄ£¿éÃû,×Ö·û´®(32×Ö½Ú)
///////////////////////////////////////////
wFlags			ÒôÀÖ¸ñʽ
Value					Description
AUDIO_MODULE_LINEAR		The module uses linear frequencies	ÏßÐÔ¸ñʽ
AUDIO_MODULE_AMIGA		Use Amiga logarithmic frequencies	¶ÔÊý¸ñʽ
AUDIO_MODULE_PANNING	Use pan position from instruments	·½Î»¸ñʽ
///////////////////////////////////////////
nOrders			´ÎÐò±í¸öÊý
///////////////////////////////////////////
nRestart		Öظ´Ê±µÄÆðµã
///////////////////////////////////////////
nTracks			ÒôÀÖÉùµÀÊý
///////////////////////////////////////////
nPatterns		ÒôÀÖÄ£ÐÍÊý
///////////////////////////////////////////
nPatches		ÐÞ²¹¹¤¾ßÊý
///////////////////////////////////////////
nTempo			½ÚÅÄËÙ¶È
///////////////////////////////////////////
nBPM			ÿ·ÖÖÓ½ÚÅÄÊý
///////////////////////////////////////////
aOrderTable		Ä£ÐͲ¥·Å´ÎÐò(ÒòΪ±¾³ÌÐò°ü²ÉÓò¨ÐÎÄ£Äⷽʽ,Ä£ÐÍÖ¸²¨ÐÎ)
///////////////////////////////////////////
aPanningTable	Á¢ÌåÉùλÖÃ
///////////////////////////////////////////
aPatternTable 	Ä£Ðͽṹ
///////////////////////////////////////////
aPatchTable		ÐÞ²¹Æ¬½á¹¹
/*---------------------------------------------------------------------*/
·µ»ØÂë
Value						Description
AUDIO_ERROR_NONE			No error		==0
AUDIO_ERROR_INVALHANDLE		Invalid voice or waveform handle
AUDIO_ERROR_INVALPARAM		Invalid parameter passed
AUDIO_ERROR_NOTSUPPORTED	Invalid audio system call
AUDIO_ERROR_BADDEVICEID		Invalid device identifier
AUDIO_ERROR_NODEVICE		No audio device found
AUDIO_ERROR_DEVICEBUSY		Audio device is busy
AUDIO_ERROR_BADFORMAT		Bad or unsupported audio playback format

AUDIO_ERROR_NOMEMORY		Not enough system memory
AUDIO_ERROR_NODRAMMEMORY	Not enough onboard DRAM memory
AUDIO_ERROR_FILENOTFOUND	Module or waveform file not found
AUDIO_ERROR_BADFILEFORMAT	Invalid module or waveform file format
/*---------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------*/
ϵͳ·ÖÎö(Фô´):
1	ϵͳÒôÀÖÓÉMOD,S3M¸ñʽ²¥·Å,ÉùÒô²¥·ÅWAVÎļþ
2	ÒôÀÖ¿ÉÒÔÒ»´Î×°Èë¶à¸ö,°´µÀ¹ÜÀí,ÏñCDÒ»Ñù,ÉùÒô¿ÉÒÔÒ»´Î×°Èë¶à¸ö,ͨ¹ýÉùµÀ²¥·Å,32¸ö
	ÉùµÀ¿ÉÒÔ»ìÒô,ͬʱ,ÉùµÀ»¹±êʾÁ¢ÌåÉù²¥·ÅʱµÄ·½Î»
3	ϵͳÄÚ½¨ºǫ́²¥·Å,²ÉÓÃʱÖÓÖжÏ,µ«¿ÉÄÜÓëÎÒÃǵÄʱÖÓ³åÍ»,²»½¨ÒéʹÓÃ,¶øÓ¦¸ÃÔÚÎÒÃÇ
	µÄʱÖÓÖÐʹÓÃAUpdateAudioº¯Êý²¥·Å
4	ϵͳÄÚ½¨ÉùÒô/ÒôÀÖÎļþ¹ÜÀí,¿ÉÒÔʹÓÃ
/*------------------------------------------------------------------------------------*/