3ìDò22-2  SINEWAVE
SINEWAVE.C
/*-------------------------------------------------------------------------
   	SINEWAVE.C -- 		Multimedia Windows Sine Wave Generator
                 							(c) Charles Petzold, 1998
--------------------------------------------------------------------------*/

#include <windows.h>
#include <math.h>
#include "resource.h"

#define 		SAMPLE_RATE     		11025	
#define 		FREQ_MIN           	    20	
#define 		FREQ_MAX         		5000	
#define 		FREQ_INIT         		440
#define 		OUT_BUFFER_SIZE  	    4096
#define 		PI                  	3.14159

BOOL CALLBACK DlgProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName [] = TEXT ("SineWave") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	if (-1 == DialogBox (hInstance, szAppName, NULL, DlgProc))
	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
	}
     	return 0 ;
}

VOID FillBuffer (PBYTE pBuffer, int iFreq)
{
     	static double 		fAngle ;
     	int    					i ;

     	for (i = 0 ; i < OUT_BUFFER_SIZE ; i++)
     	{
          		pBuffer [i] = (BYTE) (127 + 127 * sin (fAngle)) ;
          		fAngle += 2 * PI * iFreq / SAMPLE_RATE ;
     		if (	fAngle > 2 * PI)
               				fAngle -= 2 * PI ;
     }
}

BOOL CALLBACK DlgProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static 	BOOL         					bShutOff, bClosing ;
     	static 	HWAVEOUT     				hWaveOut ;
     	static 	HWND         					hwndScroll ;
     	static 	int          					iFreq = FREQ_INIT ;
     	static 	PBYTE        					pBuffer1, pBuffer2 ;
     	static 	PWAVEHDR     				pWaveHdr1, pWaveHdr2 ;
     	static 	WAVEFORMATEX 		waveformat ;
     	int                 								iDummy ;

     	switch (message)
     	{
     	case 	WM_INITDIALOG:
          			hwndScroll = 	GetDlgItem (hwnd, IDC_SCROLL) ;
          			SetScrollRange	(hwndScroll, SB_CTL, FREQ_MIN, FREQ_MAX, FALSE) ;
          			SetScrollPos 	(hwndScroll, SB_CTL, FREQ_INIT, TRUE) ;
          			SetDlgItemInt	(hwnd, IDC_TEXT, FREQ_INIT, FALSE) ;

          			return TRUE ;

     	case 	WM_HSCROLL:
          			switch (LOWORD (wParam))
          			{
          			case 	SB_LINELEFT:  		iFreq -=  1 ;  break ;
          			case 	SB_LINERIGHT: 		iFreq +=  1 ;  break ;
          			case 	SB_PAGELEFT:  		iFreq /=  2 ;  break ;
          			case 	SB_PAGERIGHT: 	iFreq *=  2 ;  break ;

          			case 	SB_THUMBTRACK:
               					iFreq = HIWORD (wParam) ;
               					break ;

          			case 	SB_TOP:
               					GetScrollRange (hwndScroll, SB_CTL, &iFreq, &iDummy) ;
               					break ;

          			case 	SB_BOTTOM:
               					GetScrollRange (hwndScroll, SB_CTL, &iDummy, &iFreq) ;
               					break ;
          			}

          			iFreq = max (FREQ_MIN, min (FREQ_MAX, iFreq)) ;
          			SetScrollPos (hwndScroll, SB_CTL, iFreq, TRUE) ;
          			SetDlgItemInt (hwnd, IDC_TEXT, iFreq, FALSE) ;
          			return TRUE ;

     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDC_ONOFF:
                    					// If turning on waveform, hWaveOut is NULL

               					if (hWaveOut == NULL)
               					{
                      // Allocate memory for 2 headers and 2 buffers

                    	pWaveHdr1 	= malloc (sizeof (WAVEHDR)) ;
                    	pWaveHdr2 	= malloc (sizeof (WAVEHDR)) ;
                    	pBuffer1  		= malloc (OUT_BUFFER_SIZE) ;
                    	pBuffer2  		= malloc (OUT_BUFFER_SIZE) ;

          if (!pWaveHdr1 || !pWaveHdr2 || !pBuffer1 || !pBuffer2)
                  {
          if (!pWaveHdr1) free (pWaveHdr1) ;
          if (!pWaveHdr2) free (pWaveHdr2) ;
          if (!pBuffer1)  free (pBuffer1) ;
          if (!pBuffer2)  free (pBuffer2) ;

          MessageBeep (MB_ICONEXCLAMATION) ;
          MessageBox (hwnd, TEXT ("Error allocating memory!"),
                      szAppName, MB_ICONEXCLAMATION | MB_OK) ;
          return TRUE ;
         }

                         	// Variable to indicate Off button pressed

                   							bShutOff = FALSE ;

                         	// Open waveform audio for output

     waveformat.wFormatTag      				= WAVE_FORMAT_PCM ;
     waveformat.nChannels   					= 1 ;
     waveformat.nSamplesPerSec  			    = SAMPLE_RATE ;
     waveformat.nAvgBytesPerSec 		        = SAMPLE_RATE ;
     waveformat.nBlockAlign     				= 1 ;
     waveformat.wBitsPerSample  			    = 8 ;
     waveformat.cbSize          				= 0 ;

     if (waveOutOpen (&hWaveOut, WAVE_MAPPER, &waveformat,
 DWORD) hwnd, 0, CALLBACK_WINDOW)!= MMSYSERR_NOERROR)
                    					{
          free (pWaveHdr1) ;
          free (pWaveHdr2) ;
          free (pBuffer1) ;
          free (pBuffer2) ;

          hWaveOut = NULL ;
          MessageBeep (MB_ICONEXCLAMATION) ;
          MessageBox (hwnd, TEXT ("Error opening waveform audio device!"),
                      szAppName, MB_ICONEXCLAMATION | MB_OK) ;
         return TRUE ;
         }

         // Set up headers and prepare them

         pWaveHdr1->lpData          					= pBuffer1 ;
         pWaveHdr1->dwBufferLength  					= OUT_BUFFER_SIZE ;
         pWaveHdr1->dwBytesRecorded 					= 0 ;
         pWaveHdr1->dwUser          					= 0 ;
         pWaveHdr1->dwFlags         					= 0 ;
         pWaveHdr1->dwLoops         					= 1 ;
         pWaveHdr1->lpNext          					= NULL ;
         pWaveHdr1->reserved        					= 0 ;

         waveOutPrepareHeader (hWaveOut, pWaveHdr1, sizeof (WAVEHDR)) ;

         pWaveHdr2->lpData          					= pBuffer2 ;
         pWaveHdr2->dwBufferLength  					= OUT_BUFFER_SIZE ;
         pWaveHdr2->dwBytesRecorded 					= 0 ;
         pWaveHdr2->dwUser          					= 0 ;
         pWaveHdr2->dwFlags         					= 0 ;
         pWaveHdr2->dwLoops         					= 1 ;
         pWaveHdr2->lpNext          					= NULL ;
         pWaveHdr2->reserved        					= 0 ;

        waveOutPrepareHeader (hWaveOut, pWaveHdr2, sizeof (WAVEHDR)) ;
               					}
        // If turning off waveform, reset waveform audio
               	else
               					{
                    						bShutOff = TRUE ;
                    						waveOutReset (hWaveOut) ;
               					}
               					return TRUE ;
          			}
          			break ;

               				// Message generated from waveOutOpen call

     	case 	MM_WOM_OPEN:
          			SetDlgItemText (hwnd, IDC_ONOFF, TEXT ("Turn Off")) ;

               						// Send two buffers to waveform output device

          			FillBuffer (pBuffer1, iFreq) ;
          			waveOutWrite (hWaveOut, pWaveHdr1, sizeof (WAVEHDR)) ;

          			FillBuffer (pBuffer2, iFreq) ;
          			waveOutWrite (hWaveOut, pWaveHdr2, sizeof (WAVEHDR)) ;
          			return TRUE ;

               						// Message generated when a buffer is finished

     	case 	MM_WOM_DONE:
          			if (bShutOff)
          			{
               				waveOutClose (hWaveOut) ;
               				return TRUE ;
          			}

               				// Fill and send out a new buffer

          			FillBuffer (((PWAVEHDR) lParam)->lpData, iFreq) ;
          			waveOutWrite (hWaveOut, (PWAVEHDR) lParam, sizeof (WAVEHDR)) ;
          			return TRUE ;

     	case 	MM_WOM_CLOSE:
          			waveOutUnprepareHeader (hWaveOut, pWaveHdr1, sizeof (WAVEHDR)) ;
          			waveOutUnprepareHeader (hWaveOut, pWaveHdr2, sizeof (WAVEHDR)) ;

          			free (pWaveHdr1) ;
          			free (pWaveHdr2) ;
          			free (pBuffer1) ;
          			free (pBuffer2) ;

          			hWaveOut = NULL ;
          			SetDlgItemText (hwnd, IDC_ONOFF, TEXT ("Turn On")) ;

          			if (bClosing)
               					EndDialog (hwnd, 0) ;

          			return TRUE ;

     	case 	WM_SYSCOMMAND:
          			switch (wParam)
          			{
          			case SC_CLOSE:
               					if (hWaveOut != NULL)
               					{
                    						bShutOff = TRUE ;
                    						bClosing = TRUE ;

                    						waveOutReset (hWaveOut) ;
               					}
               					else
                    						EndDialog (hwnd, 0) ;

               					return TRUE ;
          			}
          			break ;
     		}
     		return FALSE ;
}

 SINEWAVE.RC ￡¨?a??￡?
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Dialog
SINEWAVE 		DIALOG DISCARDABLE  100, 100, 200, 50
STYLE 			WS_MINIMIZEBOX | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION 		"Sine Wave Generator"
FONT 8, 		"MS Sans Serif"
BEGIN
    	SCROLLBAR       			IDC_SCROLL,8,8,150,12
    	RTEXT           					"440",IDC_TEXT,160,10,20,8
    	LTEXT           					"Hz",IDC_STATIC,182,10,12,8
    	PUSHBUTTON      			"Turn On",IDC_ONOFF,80,28,40,14
END

 RESOURCE.H ￡¨?a??￡?
// Microsoft Developer Studio generated include file.
// Used by SineWave.rc

#define IDC_STATIC                      							-1
#define IDC_SCROLL                      						1000
#define IDC_TEXT                        						1001
#define IDC_ONOFF                       						1002

waveOutOpen (&hWaveOut, wDeviceID, &waveformat, dwCallBack,
             				dwCallBackData, dwFlags) ;

typedef struct waveformat_tag
{
     	WORD  	wFormatTag ;             // waveform format = WAVE_FORMAT_PCM
     	WORD  	nChannels ;         		// number of channels = 1 or 2
     	DWORD 	nSamplesPerSec ;    		// sample rate
     	DWORD 	nAvgBytesPerSec ; 	    // bytes per second
     	WORD  	nBlockAlign ;       		// block alignment
     	WORD  	wBitsPerSample ;    		// bits per samples = 8 or 16
     	WORD  	cbSize ;            		// 0 for PCM
}
WAVEFORMATEX, * PWAVEFORMATEX ;

waveOutOpen (	&hWaveOut, WAVE_MAPPER, &waveformat,
             	 (DWORD) hwnd, 0, CALLBACK_WINDOW)

typedef struct wavehdr_tag
{
    	LPSTR lpData;                    				// pointer to data buffer
	    DWORD dwBufferLength;            				// length of data buffer
    	DWORD dwBytesRecorded;      				 	// used for recorded
    	DWORD dwUser;                    				// for program use
    	DWORD dwFlags;                   				// flags
    	DWORD dwLoops;                   				// number of repetitions
    	struct wavehdr_tag FAR *lpNext;  		        // reserved
    	DWORD reserved;                  				// reserved
}
WAVEHDR, *PWAVEHDR ;

 3ìDò22-3  RECORD1
RECORD1.C
/*---------------------------------------------------------------------------
   	RECORD1.C -- Waveform Audio Recorder
                						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include "resource.h"

#define INP_BUFFER_SIZE 16384
BOOL CALLBACK DlgProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName [] = TEXT ("Record1") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	if (-1 == DialogBox (hInstance, TEXT ("Record"), NULL, DlgProc))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
     	}
     	return 0 ;
}

void ReverseMemory (BYTE * pBuffer, int iLength)
{
     	BYTE 	b ;
     	int 	i ;

     	for (i = 0 ; i < iLength / 2 ; i++)
     	{
          		b = pBuffer [i] ;
          		pBuffer [i] = pBuffer [iLength - i - 1] ;
          		pBuffer [iLength - i - 1] = b ;
     	}
}

BOOL CALLBACK DlgProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static 	BOOL         			bRecording, bPlaying, bReverse, bPaused,
                         								bEnding, bTerminating ;
     	static 	DWORD        			dwDataLength, dwRepetitions = 1 ;
     	static 	HWAVEIN      		hWaveIn ;
     	static 	HWAVEOUT     		hWaveOut ;
     	static 	PBYTE        			pBuffer1, pBuffer2, pSaveBuffer, pNewBuffer ;
     	static 	PWAVEHDR     		pWaveHdr1, pWaveHdr2 ;
     	static 		TCHAR        		szOpenError[] = TEXT ("Error opening waveform audio!");
     	static 		TCHAR        		szMemError [] = TEXT ("Error allocating memory!") ;
     	static 	WAVEFORMATEX waveform ;

     	switch (message)
     {
     	case 	WM_INITDIALOG:
               				// Allocate memory for wave header

         		 	pWaveHdr1 = malloc (sizeof (WAVEHDR)) ;
          			pWaveHdr2 = malloc (sizeof (WAVEHDR)) ;

               				// Allocate memory for save buffer

          			pSaveBuffer = malloc (1) ;
          			return TRUE ;

     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDC_RECORD_BEG:
                    				// Allocate buffer memory

               				pBuffer1 = malloc (INP_BUFFER_SIZE) ;
               				pBuffer2 = malloc (INP_BUFFER_SIZE) ;

               				if (!pBuffer1 || !pBuffer2)
               				{
                    					if (pBuffer1) free (pBuffer1) ;
                    					if (pBuffer2) free (pBuffer2) ;

                    					MessageBeep (MB_ICONEXCLAMATION) ;
                    					MessageBox (hwnd, szMemError, szAppName,
                                      	MB_ICONEXCLAMATION | MB_OK) ;
                    					return TRUE ;
               				}

                    					// Open waveform audio for input

               				waveform.wFormatTag      				= WAVE_FORMAT_PCM ;
               				waveform.nChannels       				= 1 ;
               				waveform.nSamplesPerSec  		= 11025 ;
               				waveform.nAvgBytesPerSec 	= 11025 ;
               				waveform.nBlockAlign     		= 1 ;
               				waveform.wBitsPerSample  		= 8 ;
               				waveform.cbSize          		= 0 ;

               	if (waveInOpen (&hWaveIn, WAVE_MAPPER, &waveform,
                               (DWORD) hwnd, 0, CALLBACK_WINDOW))
               				{
                    					free (pBuffer1) ;
                    					free (pBuffer2) ;
                    					MessageBeep (MB_ICONEXCLAMATION) ;
                    					MessageBox (hwnd, szOpenError, szAppName,
                                      	MB_ICONEXCLAMATION | MB_OK) ;
               				}
                    					// Set up headers and prepare them

               				pWaveHdr1->lpData            = pBuffer1 ;
               				pWaveHdr1->dwBufferLength	= INP_BUFFER_SIZE ;
               				pWaveHdr1->dwBytesRecorded 	= 0 ;
               				pWaveHdr1->dwUser          	= 0 ;
               				pWaveHdr1->dwFlags         	= 0 ;
               				pWaveHdr1->dwLoops         	= 1 ;
               				pWaveHdr1->lpNext          	= NULL ;
               				pWaveHdr1->reserved        	= 0 ;
            waveInPrepareHeader (hWaveIn, pWaveHdr1, sizeof (WAVEHDR)) ;

              		 		pWaveHdr2->lpData          = pBuffer2 ;
               				pWaveHdr2->dwBufferLength  = INP_BUFFER_SIZE ;
               				pWaveHdr2->dwBytesRecorded 		= 0 ;
               				pWaveHdr2->dwUser          		= 0 ;
               				pWaveHdr2->dwFlags         		= 0 ;
               				pWaveHdr2->dwLoops         		= 1 ;
               				pWaveHdr2->lpNext          	= NULL ;
               				pWaveHdr2->reserved        		= 0 ;

               				waveInPrepareHeader (hWaveIn, pWaveHdr2, sizeof (WAVEHDR)) ;
               				return TRUE ;

          		case 	IDC_RECORD_END:
                    						// Reset input to return last buffer

               				bEnding = TRUE ;
               				waveInReset (hWaveIn) ;
               				return TRUE ;

          		case 	IDC_PLAY_BEG:
                    						// Open waveform audio for output

               				waveform.wFormatTag      				= WAVE_FORMAT_PCM ;
               				waveform.nChannels       	= 1 ;
               				waveform.nSamplesPerSec  		= 11025 ;
               				waveform.nAvgBytesPerSec 	= 11025 ;
               				waveform.nBlockAlign     		= 1 ;
               				waveform.wBitsPerSample  		= 8 ;
               				waveform.cbSize          		= 0 ;

               				if (waveOutOpen (&hWaveOut, WAVE_MAPPER, &waveform,
                               (DWORD) hwnd, 0, CALLBACK_WINDOW))
               				{
                    		MessageBeep (MB_ICONEXCLAMATION) ;
                    		MessageBox (hwnd,	szOpenError, szAppName,
                         	MB_ICONEXCLAMATION | MB_OK) ;
               				}
               				return TRUE ;

          		case 	IDC_PLAY_PAUSE:
                    						// Pause or restart output

               				if (!bPaused)
               				{
               waveOutPause (hWaveOut) ;
               SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Resume")) ;
                    			bPaused = TRUE ;
               				}
               				else
               				{
               waveOutRestart (hWaveOut) ;
               SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Pause")) ;
                    			bPaused = FALSE ;
               				}
               					return TRUE ;

          			case 	IDC_PLAY_END:
                    		// Reset output for close preparation

               					bEnding = TRUE ;
               					waveOutReset (hWaveOut) ;
               					return TRUE ;

          			case 	IDC_PLAY_REV:
                   						 // Reverse save buffer and play

               					bReverse = TRUE ;
               					ReverseMemory (pSaveBuffer, dwDataLength) ;

               					SendMessage (hwnd, WM_COMMAND, IDC_PLAY_BEG, 0) ;
               					return TRUE ;

          			case 	IDC_PLAY_REP:
                    						// Set infinite repetitions and play

               					dwRepetitions = -1 ;
               					SendMessage (hwnd, WM_COMMAND, IDC_PLAY_BEG, 0) ;
               					return TRUE ;

          			case 	IDC_PLAY_SPEED:
                    						// Open waveform audio for fast output

               					waveform.wFormatTag     = WAVE_FORMAT_PCM ;
               					waveform.nChannels      = 1 ;
               					waveform.nSamplesPerSec =22050 ;
               					waveform.nAvgBytesPerSec= 22050 ;
               					waveform.nBlockAlign    = 1 ;
               					waveform.wBitsPerSample = 8 ;
               					waveform.cbSize         = 0 ;
               	if (waveOutOpen (&hWaveOut,	0, &waveform, (DWORD) hwnd, 0,
                    CALLBACK_WINDOW))
               					{
                    essageBeep (MB_ICONEXCLAMATION) ;
        MessageBox (hwnd, szOpenError, szAppName, MB_ICONEXCLAMATION | MB_OK) ;
               				}
               		return TRUE ;
          			}
          			break ;

     	case 	MM_WIM_OPEN:
               						// Shrink down the save buffer

          			pSaveBuffer = realloc (pSaveBuffer, 1) ;

               						// Enable and disable buttons

          			EnableWindow (GetDlgItem (hwnd, IDC_RECORD_BEG), 	FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_RECORD_END), 	TRUE)  ;
          			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_BEG),   	FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_PAUSE), 	FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_END),   	FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_REV),   	FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_REP),   	FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_SPEED), 	FALSE) ;
          			SetFocus (GetDlgItem (hwnd, IDC_RECORD_END)) ;

               						// Add the buffers

          			waveInAddBuffer (hWaveIn, pWaveHdr1, sizeof (WAVEHDR)) ;
          			waveInAddBuffer (hWaveIn, pWaveHdr2, sizeof (WAVEHDR)) ;

               						// Begin sampling

          			bRecording = TRUE ;
          			bEnding = FALSE ;
          			dwDataLength = 0 ;
          			waveInStart (hWaveIn) ;
          			return TRUE ;

     	case 	MM_WIM_DATA:

               						// Reallocate save buffer memory

          			pNewBuffer = realloc (	pSaveBuffer, dwDataLength +
 ((PWAVEHDR) lParam)->dwBytesRecorded) ;

          			if (pNewBuffer == NULL)
          			{	
               					waveInClose 	(hWaveIn) ;
               					MessageBeep 	(MB_ICONEXCLAMATION) ;
               					MessageBox 	(hwnd, szMemError, szAppName,
                                MB_ICONEXCLAMATION | MB_OK) ;
               					return TRUE ;
          			}

          			pSaveBuffer = pNewBuffer ;
          			CopyMemory (pSaveBuffer + dwDataLength, ((PWAVEHDR) lParam)->lpData,
                    ((PWAVEHDR) lParam)->dwBytesRecorded) ;

          			dwDataLength += ((PWAVEHDR) lParam)->dwBytesRecorded ;

          			if (bEnding)
          			{
               				waveInClose (hWaveIn) ;
               				return TRUE ;
          			}

               			// Send out a new buffer

          			waveInAddBuffer (hWaveIn, (PWAVEHDR) lParam, sizeof (WAVEHDR)) ;
          			return TRUE ;

     	case 	MM_WIM_CLOSE:
               				// Free the buffer memory

          			waveInUnprepareHeader (hWaveIn, pWaveHdr1, sizeof (WAVEHDR)) ;
          			waveInUnprepareHeader (hWaveIn, pWaveHdr2, sizeof (WAVEHDR)) ;

          			free (pBuffer1) ;
          			free (pBuffer2) ;

               				// Enable and disable buttons

          			EnableWindow (GetDlgItem (hwnd, IDC_RECORD_BEG), TRUE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_RECORD_END), FALSE) ;
          			SetFocus (GetDlgItem (hwnd, IDC_RECORD_BEG)) ;

          			if (dwDataLength > 0)
          			{
               		EnableWindow (GetDlgItem (hwnd, IDC_PLAY_BEG),   	TRUE)  		;
               		EnableWindow (GetDlgItem (hwnd, IDC_PLAY_PAUSE), 	FALSE) 	;
               		EnableWindow (GetDlgItem (hwnd, IDC_PLAY_END),   	FALSE) 	;
               		EnableWindow (GetDlgItem (hwnd, IDC_PLAY_REP),   	TRUE)  		;
               		EnableWindow (GetDlgItem (hwnd, IDC_PLAY_REV),   	TRUE)  		;
               		EnableWindow (GetDlgItem (hwnd, IDC_PLAY_SPEED), 	TRUE)  		;
               		SetFocus (GetDlgItem (hwnd, IDC_PLAY_BEG)) ;
          			}
          			bRecording = FALSE ;

          			if (bTerminating)
               				SendMessage (hwnd, WM_SYSCOMMAND, SC_CLOSE, 0L) ;

          			return TRUE ;

     	case	MM_WOM_OPEN:
               				// Enable and disable buttons

          	EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_BEG), 	FALSE) 	;
          	EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_END), 	FALSE) 	;
          	EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_BEG),   	FALSE) 	;
          	EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_PAUSE),	    TRUE);
          	EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_END),   	TRUE);
          	EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_REP),  	FALSE) 	;
          	EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_REV),   	FALSE) 	;
          	EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_SPEED),	FALSE) 	;
          	SetFocus (GetDlgItem (hwnd, IDC_PLAY_END)) ;

               				// Set up header

          			pWaveHdr1->lpData          	= pSaveBuffer ;
          			pWaveHdr1->dwBufferLength  	= dwDataLength ;
          			pWaveHdr1->dwBytesRecorded 	= 0 ;
          			pWaveHdr1->dwUser          	= 0 ;
          			pWaveHdr1->dwFlags         	= WHDR_BEGINLOOP | WHDR_ENDLOOP ;
          			pWaveHdr1->dwLoops         	= dwRepetitions ;
          			pWaveHdr1->lpNext          	= NULL ;
          			pWaveHdr1->reserved        	= 0 ;

               				// Prepare and write

          			waveOutPrepareHeader (hWaveOut, pWaveHdr1, sizeof (WAVEHDR)) ;
          			waveOutWrite (hWaveOut, pWaveHdr1, sizeof (WAVEHDR)) ;

          			bEnding = FALSE ;
          			bPlaying = TRUE ;
          			return TRUE ;

     	case 	MM_WOM_DONE:
          			waveOutUnprepareHeader (hWaveOut, pWaveHdr1, sizeof (WAVEHDR)) ;
          			waveOutClose (hWaveOut) ;
          			return TRUE ;

     	case 	MM_WOM_CLOSE:
               				// Enable and disable buttons

          			EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_BEG), 	TRUE)  	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_END), 	TRUE)  	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_BEG),   		TRUE)  	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_PAUSE), 	FALSE) 	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_END),   		FALSE) 	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_REV),   		TRUE)  	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_REP),   		TRUE)  	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_SPEED), 	TRUE)  	;
          			SetFocus (GetDlgItem (hwnd, IDC_PLAY_BEG)) ;

          			SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Pause")) ;
          			bPaused = FALSE ;
          			dwRepetitions = 1 ;
          			bPlaying = FALSE ;

          			if (bReverse)
          			{
               				ReverseMemory (pSaveBuffer, dwDataLength) ;
               				bReverse = FALSE ;
          			}

          			if (bTerminating)
               				SendMessage (hwnd, WM_SYSCOMMAND, SC_CLOSE, 0L) ;

          			return TRUE ;

     	case 	WM_SYSCOMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	SC_CLOSE:
               					if (bRecording)
               					{
                    						bTerminating = TRUE ;
                    						bEnding = TRUE ;
                    						waveInReset (hWaveIn) ;
                    						return TRUE ;
               					}
               					if (bPlaying)
               					{
                    						bTerminating = TRUE ;
                    						bEnding = TRUE ;
                    						waveOutReset (hWaveOut) ;
                    						return TRUE ;
               					}

               					free (pWaveHdr1) ;
               					free (pWaveHdr2) ;
               					free (pSaveBuffer) ;
               					EndDialog (hwnd, 0) ;
               					return TRUE ;
          				}
          				break ;
     	}
     	return FALSE ;
}

 RECORD.RC ￡¨?a??￡?
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Dialog
RECORD 		DIALOG DISCARDABLE  100, 100, 152, 74
STYLE 			WS_MINIMIZEBOX | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION 		"Waveform Audio Recorder"
FONT 8, 		"MS Sans Serif"
BEGIN
    	PUSHBUTTON      		"Record",IDC_RECORD_BEG,28,8,40,14
    	PUSHBUTTON      		"End",IDC_RECORD_END,76,8,40,14,WS_DISABLED
    	PUSHBUTTON      		"Play",IDC_PLAY_BEG,8,30,40,14,WS_DISABLED
    	PUSHBUTTON      		"Pause",IDC_PLAY_PAUSE,56,30,40,14,WS_DISABLED
    	PUSHBUTTON      		"End",IDC_PLAY_END,104,30,40,14,WS_DISABLED
    	PUSHBUTTON      		"Reverse",IDC_PLAY_REV,8,52,40,14,WS_DISABLED
    	PUSHBUTTON      		"Repeat",IDC_PLAY_REP,56,52,40,14,WS_DISABLED
    	PUSHBUTTON      		"Speedup",IDC_PLAY_SPEED,104,52,40,14,WS_DISABLED
END

 RESOURCE.H ￡¨?a??￡?
// Microsoft Developer Studio generated include file.
// Used by Record.rc

#define 		IDC_RECORD_BEG                  					1000
#define 		IDC_RECORD_END                  					1001
#define 		IDC_PLAY_BEG                    					1002
#define 		IDC_PLAY_PAUSE                  					1003
#define 		IDC_PLAY_END                    					1004
#define 		IDC_PLAY_REV                    					1005
#define 		IDC_PLAY_REP                    					1006
#define 		IDC_PLAY_SPEED                  					1007

 3ìDò22-4  RECORD2
RECORD2.C
/*---------------------------------------------------------------------------
   	RECORD2.C -- Waveform Audio Recorder
                						(c) Charles Petzold, 1998
 ------------------------------------------------------------------------*/

#include <windows.h>
#include "..\\record1\\resource.h"

BOOL CALLBACK DlgProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName [] = TEXT ("Record2") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
	if (-1 == DialogBox (hInstance, TEXT ("Record"), NULL, DlgProc))
      	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
     	}
     	return 0 ;
}

void ShowError (HWND hwnd, DWORD dwError)
{
     	TCHAR szErrorStr [1024] ;
     	mciGetErrorString (dwError, szErrorStr, sizeof (szErrorStr) / sizeof (TCHAR)) ;
     	MessageBeep (MB_ICONEXCLAMATION) ;
     	MessageBox (hwnd, szErrorStr, szAppName, MB_OK | MB_ICONEXCLAMATION) ;
}

BOOL CALLBACK DlgProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static 	BOOL    bRecording, bPlaying, bPaused ;
     	static 	TCHAR   szFileName[] = TEXT ("record2.wav") ;
     	static 	WORD    wDeviceID ;
     	DWORD             		dwError ;
     	MCI_GENERIC_PARMS 		mciGeneric ;
     	MCI_OPEN_PARMS    		mciOpen ;
     	MCI_PLAY_PARMS    		mciPlay ;
     	MCI_RECORD_PARMS  		mciRecord ;
     	MCI_SAVE_PARMS    		mciSave ;

     	switch (message)
     {
     	case 	WM_COMMAND:
          			switch (wParam)
          			{
          			case 	IDC_RECORD_BEG:
                    						// Delete existing waveform file

               					DeleteFile (szFileName) ;

                    						// Open waveform audio

               					mciOpen.dwCallback       				= 0 ;
               					mciOpen.wDeviceID        					= 0 ;
               					mciOpen.lpstrDeviceType  		= TEXT ("waveaudio") ;
               					mciOpen.lpstrElementName 		= TEXT ("") ;
               					mciOpen.lpstrAlias       		= NULL ;
               					dwError = mciSendCommand (0, MCI_OPEN,
                                MCI_WAIT | MCI_OPEN_TYPE | MCI_OPEN_ELEMENT,
                                (DWORD) (LPMCI_OPEN_PARMS) &mciOpen) ;
               					if (dwError != 0)
               					{
                    						ShowError (hwnd, dwError) ;
                    						return TRUE ;
               					}
                    						// Save the Device ID

               					wDeviceID = mciOpen.wDeviceID ;

                    						// Begin recording

               					mciRecord.dwCallback 			= (DWORD) hwnd ;
               					mciRecord.dwFrom     				= 0 ;
               					mciRecord.dwTo       					= 0 ;

               					mciSendCommand (wDeviceID, MCI_RECORD, MCI_NOTIFY,
                               	 (DWORD) (LPMCI_RECORD_PARMS) &mciRecord) ;

                    			// Enable and disable buttons

               			EnableWindow (GetDlgItem (hwnd, IDC_RECORD_BEG), FALSE);
               			EnableWindow (GetDlgItem (hwnd, IDC_RECORD_END), TRUE) ;
               			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_BEG),   FALSE);
               			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_PAUSE), FALSE);
               			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_END),   FALSE);
               			SetFocus (GetDlgItem (hwnd, IDC_RECORD_END)) ;

               					bRecording = TRUE ;
               					return TRUE ;

          			case 	IDC_RECORD_END:
                    								// Stop recording

               		mciGeneric.dwCallback = 0 ;

               		mciSendCommand (wDeviceID, MCI_STOP, MCI_WAIT,
                    (DWORD) (LPMCI_GENERIC_PARMS) &mciGeneric) ;

                    								// Save the file

               		mciSave.dwCallback = 0 ;
               		mciSave.lpfilename = szFileName ;

               		mciSendCommand (wDeviceID, MCI_SAVE, MCI_WAIT | MCI_SAVE_FILE,
                    (DWORD) (LPMCI_SAVE_PARMS) &mciSave) ;

                    								// Close the waveform device

               		mciSendCommand (wDeviceID, MCI_CLOSE, MCI_WAIT,
                    (DWORD) (LPMCI_GENERIC_PARMS) &mciGeneric) ;

                    								// Enable and disable buttons

            EnableWindow 	(GetDlgItem 	(hwnd, IDC_RECORD_BEG), 	TRUE);
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_RECORD_END), 	FALSE);
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_PLAY_BEG),   	TRUE);
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_PLAY_PAUSE), 	FALSE);
            EnableWindow	(GetDlgItem 	(hwnd, IDC_PLAY_END),       FALSE);
            SetFocus 		 (GetDlgItem (hwnd, IDC_PLAY_BEG)) ;

            bRecording = FALSE ;
            return TRUE ;

          			case 	IDC_PLAY_BEG:
                    						// Open waveform audio

               					mciOpen.dwCallback      	 	= 0 ;
               					mciOpen.wDeviceID        		= 0 ;
               					mciOpen.lpstrDeviceType  		= NULL ;
               					mciOpen.lpstrElementName 		= szFileName ;
               					mciOpen.lpstrAlias       		= NULL ;

               					dwError = mciSendCommand (	0, MCI_OPEN,
                               MCI_WAIT | MCI_OPEN_ELEMENT,
                               (DWORD) (LPMCI_OPEN_PARMS) &mciOpen) ;

               					if (dwError != 0)
               					{
                    						ShowError (hwnd, dwError) ;
                    						return TRUE ;
               					}
                    							// Save the Device ID

               					wDeviceID = mciOpen.wDeviceID ;

                    							// Begin playing

               					mciPlay.dwCallback 		= (DWORD) hwnd ;
               					mciPlay.dwFrom     				= 0 ;
               					mciPlay.dwTo       				= 0 ;

               					mciSendCommand (wDeviceID, MCI_PLAY, MCI_NOTIFY,
                               	 (DWORD) (LPMCI_PLAY_PARMS) &mciPlay) ;

                    							// Enable and disable buttons

         	EnableWindow 	(GetDlgItem 	(hwnd, IDC_RECORD_BEG), FALSE);
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_RECORD_END), FALSE);
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_PLAY_BEG), 	FALSE);
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_PLAY_PAUSE), TRUE) ;
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_PLAY_END),   TRUE) ;
            SetFocus (GetDlgItem (hwnd, IDC_PLAY_END)) ;

            bPlaying = TRUE ;
            return TRUE ;

          			case 	IDC_PLAY_PAUSE:
               					if (!bPaused)
                         						// Pause the play
               				{
                    	mciGeneric.dwCallback = 0 ;

                    	mciSendCommand (wDeviceID, MCI_PAUSE, MCI_WAIT,
                        (DWORD) (LPMCI_GENERIC_PARMS) & mciGeneric);

           SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Resume")) ;
                    	Paused = TRUE ;
               				}
               				else
                         							// Begin playing again
               				{
                    		mciPlay.dwCallback 		= (DWORD) hwnd ;
                    		mciPlay.dwFrom     				= 0 ;
                    		mciPlay.dwTo       				= 0 ;

                    		mciSendCommand (wDeviceID, MCI_PLAY, MCI_NOTIFY,
                            (DWORD) (LPMCI_PLAY_PARMS) &mciPlay) ;

           SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Pause")) ;
                    		bPaused = FALSE ;
               				}

               				return TRUE ;

          		case 	IDC_PLAY_END:
                    						// Stop and close

               	mciGeneric.dwCallback = 0 ;

               	mciSendCommand (wDeviceID, MCI_STOP, MCI_WAIT,
                (DWORD) (LPMCI_GENERIC_PARMS) &mciGeneric) ;

               	mciSendCommand (wDeviceID, MCI_CLOSE, MCI_WAIT,
                (DWORD) (LPMCI_GENERIC_PARMS) &mciGeneric) ;

                 // Enable and disable buttons

               	EnableWindow 	(GetDlgItem	(hwnd, IDC_RECORD_BEG),	TRUE) ;
               	EnableWindow 	(GetDlgItem	(hwnd, IDC_RECORD_END),	FALSE);
               	EnableWindow 	(GetDlgItem	(hwnd, IDC_PLAY_BEG),	TRUE) ;
               	EnableWindow 	(GetDlgItem	(hwnd, IDC_PLAY_PAUSE),	FALSE);
               	EnableWindow 	(GetDlgItem	(hwnd, IDC_PLAY_END), 	FALSE);
               	SetFocus (GetDlgItem (hwnd, IDC_PLAY_BEG)) ;

               	bPlaying = FALSE ;
               	bPaused  = FALSE ;
               	return TRUE ;
          			}
          			break ;

     	case 	MM_MCINOTIFY:
          			switch (wParam)
          			{
          			case 	MCI_NOTIFY_SUCCESSFUL:
               					if (bPlaying)
                    SendMessage (hwnd, WM_COMMAND, IDC_PLAY_END, 0) ;

               					if (bRecording)
                    SendMessage (hwnd, WM_COMMAND, IDC_RECORD_END, 0);

               					return TRUE ;
          			}
          			break ;

     	case 	WM_SYSCOMMAND:
          			switch (wParam)
          			{
          			case 	SC_CLOSE:
               					if (bRecording)
                    		SendMessage (hwnd, WM_COMMAND, IDC_RECORD_END, 0L) ;
               					if (bPlaying)
                    		SendMessage (hwnd, WM_COMMAND, IDC_PLAY_END, 0L) ;

               					EndDialog (hwnd, 0) ;
               					return TRUE ;
          			}
          			break ;
     }
	return FALSE ;
}

error = mciSendCommand (wDeviceID, message, dwFlags, dwParam)

mciGetErrorString (error, szBuffer, dwLength)

bSuccess = mciExecute (szCommand) ;

 3ìDò22-5  RECORD3
RECORD3.C
/*---------------------------------------------------------------------------
   	RECORD3.C -- Waveform Audio Recorder
                						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include "..\\record1\\resource.h"

BOOL CALLBACK DlgProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName [] = TEXT ("Record3") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	if (-1 == DialogBox (hInstance, TEXT ("Record"), NULL, DlgProc))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
 	}
     	return 0 ;
}

BOOL mciExecute (LPCTSTR szCommand)
{
     	MCIERROR error ;
     	TCHAR    szErrorStr [1024] ;

     	if (error = mciSendString (szCommand, NULL, 0, NULL))
     	{
          		mciGetErrorString (error, szErrorStr, sizeof (szErrorStr) / sizeof (TCHAR)) ;
          		MessageBeep (MB_ICONEXCLAMATION) ;
          		MessageBox (	NULL, szErrorStr, TEXT ("MCI Error"),
                      							MB_OK | MB_ICONEXCLAMATION) ;
     	}
     	return error == 0 ;
}

BOOL CALLBACK DlgProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static BOOL bRecording, bPlaying, bPaused ;
     	switch (message)
     	{
     	case 	WM_COMMAND:
          			switch (wParam)
          			{
          			case 	IDC_RECORD_BEG:
                    						// Delete existing waveform file

               						DeleteFile (TEXT ("record3.wav")) ;

                    						// Open waveform audio and record

               					if (!mciExecute (TEXT ("open new type waveaudio alias mysound")))
                    						return TRUE ;

               					mciExecute (TEXT ("record mysound")) ;

                    						// Enable and disable buttons

               					EnableWindow (GetDlgItem (hwnd, IDC_RECORD_BEG), FALSE);
               					EnableWindow (GetDlgItem (hwnd, IDC_RECORD_END), TRUE) ;
               					EnableWindow (GetDlgItem (hwnd, IDC_PLAY_BEG),   FALSE);
               					EnableWindow (GetDlgItem (hwnd, IDC_PLAY_PAUSE), FALSE);
               					EnableWindow (GetDlgItem (hwnd, IDC_PLAY_END),   FALSE);
               					SetFocus (GetDlgItem (hwnd, IDC_RECORD_END)) ;

               					bRecording = TRUE ;
               					return TRUE ;

          			case	IDC_RECORD_END:
                    						// Stop, save, and close recording

               					mciExecute (TEXT ("stop mysound")) ;
               					mciExecute (TEXT ("save mysound record3.wav")) ;
               					mciExecute (TEXT ("close mysound")) ;

                    						// Enable and disable buttons

               					EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_BEG), 	TRUE) ;
               					EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_END), 	FALSE);
               					EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_BEG),  	TRUE) ;
               					EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_PAUSE), 	FALSE);
               					EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_END),   	FALSE);
               					SetFocus (GetDlgItem (hwnd, IDC_PLAY_BEG)) ;

               					bRecording = FALSE ;
               					return TRUE ;

          			case 	IDC_PLAY_BEG:
                    						// Open waveform audio and play

               					if (!mciExecute (TEXT ("open record3.wav alias mysound")))
                    						return TRUE ;

               					mciExecute (TEXT ("play mysound")) ;

                    						// Enable and disable buttons

              	EnableWindow (GetDlgItem 	(hwnd, IDC_RECORD_BEG), 	FALSE);
               	EnableWindow (GetDlgItem 	(hwnd, IDC_RECORD_END), 	FALSE);
               	EnableWindow (GetDlgItem 	(hwnd, IDC_PLAY_BEG), 		FALSE);
               	EnableWindow (GetDlgItem 	(hwnd, IDC_PLAY_PAUSE), 	TRUE) ;
               	EnableWindow (GetDlgItem 	(hwnd, IDC_PLAY_END), 		TRUE) ;
               	SetFocus (GetDlgItem (hwnd, IDC_PLAY_END)) ;

               	bPlaying = TRUE ;
                return TRUE ;

          			case 	IDC_PLAY_PAUSE:
               					if (!bPaused)
                         						// Pause the play
               					{
                    					mciExecute (TEXT ("pause mysound")) ;
                    					SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Resume")) ;
                    					bPaused = TRUE ;
               				}
               				else
                         						// Begin playing again
               				{
                    					mciExecute (TEXT ("play mysound")) ;
                    					SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Pause")) ;
                    					bPaused = FALSE ;
               				}

               				return TRUE ;

          			case 	IDC_PLAY_END:
                    						// Stop and close

               				mciExecute (TEXT ("stop mysound")) ;
               				mciExecute (TEXT ("close mysound")) ;

                    						// Enable and disable buttons
               				EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_BEG), TRUE) ;
               				EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_END), FALSE);
               				EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_BEG),   TRUE) ;
               				EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_PAUSE), FALSE);
               				EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_END),   FALSE);
               				SetFocus (GetDlgItem (hwnd, IDC_PLAY_BEG)) ;

               				bPlaying = FALSE ;
               				bPaused  = FALSE ;
               				return TRUE ;
          			}
          			break ;

     	case 	WM_SYSCOMMAND:
          			switch (wParam)
          			{
          			case 	SC_CLOSE:
               					if (bRecording)
                    		SendMessage (hwnd, WM_COMMAND, IDC_RECORD_END, 0L);

               					if (bPlaying)
                    		SendMessage (hwnd, WM_COMMAND, IDC_PLAY_END, 0L) ;

               					EndDialog (hwnd, 0) ;
               					return TRUE ;
          			}
          			break ;
  	}
     	return FALSE ;
}

 3ìDò22-6  ADDSYNTH
ADDSYNTH.C
/*--------------------------------------------------------------------------
   	ADDSYNTH.C -- Additive Synthesis Sound Generation
                 						(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
#include <math.h>
#include "addsynth.h"
#include "resource.h"

#define 		ID_TIMER           1
#define 		SAMPLE_RATE      	22050
#define 		MAX_PARTIALS     21
#define 		PI             		3.14159

BOOL CALLBACK DlgProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName [] = TEXT ("AddSynth") ;
// Sine wave generator
// -------------------

double SineGenerator (double dFreq, double * pdAngle)
{
     	double dAmp ;
     	dAmp = sin (* pdAngle) ;
     	* pdAngle += 2 * PI * dFreq / SAMPLE_RATE ;

     	if (* pdAngle >= 2 * PI)
          			* pdAngle -= 2 * PI ;

     	return dAmp ;
}

// Fill a buffer with composite waveform
// -------------------------------------

VOID FillBuffer (INS ins, PBYTE pBuffer, int iNumSamples)
{
     	static double 		dAngle [MAX_PARTIALS] ;
     	double        				dAmp, dFrq, dComp, dFrac ;
     	int           					i, iPrt, iMsecTime, iCompMaxAmp, iMaxAmp, iSmp ;
          				// Calculate the composite maximum amplitude

     	iCompMaxAmp = 0 ;
     	for (iPrt = 0 ; iPrt < ins.iNumPartials ; iPrt++)
     	{
          			iMaxAmp = 0 ;
          			for (i = 0 ; i < ins.pprt[iPrt].iNumAmp ; i++)
               					iMaxAmp = max (iMaxAmp, ins.pprt[iPrt].pEnvAmp[i].iValue) ;
          			iCompMaxAmp += iMaxAmp ;
	}

          				// Loop through each sample
     	for (iSmp = 0 ; iSmp < iNumSamples ; iSmp++)
     	{
          			dComp = 0 ;
          			iMsecTime = (int) (1000 * iSmp / SAMPLE_RATE) ;

               				// Loop through each partial
          			for (iPrt = 0 ; iPrt < ins.iNumPartials ; iPrt++)
          			{
               				dAmp = 0 ;
               				dFrq = 0 ;

               				for (i = 0 ; i < ins.pprt[iPrt].iNumAmp - 1 ; i++)
               				{
           if (iMsecTime >= ins.pprt[iPrt].pEnvAmp[i  ].iTime &&
           iMsecTime <= ins.pprt[iPrt].pEnvAmp[i+1].iTime)
                    		{
           dFrac = (double) (iMsecTime -
           ins.pprt[iPrt].pEnvAmp[i  ].iTime) /
           (ins.pprt[iPrt].pEnvAmp[i+1].iTime -
           ins.pprt[iPrt].pEnvAmp[i  ].iTime) ;

           dAmp = dFrac  * ins.pprt[iPrt].pEnvAmp[i+1].iValue +
           (1-dFrac) * ins.pprt[iPrt].pEnvAmp[i  ].iValue ;
           break ;
           }
           }

           for (i = 0 ; i < ins.pprt[iPrt].iNumFrq - 1 ; i++)
           {
          if (iMsecTime >= ins.pprt[iPrt].pEnvFrq[i  ].iTime &&
              iMsecTime <= ins.pprt[iPrt].pEnvFrq[i+1].iTime)
           {
              dFrac = (double) (iMsecTime -ins.pprt[iPrt].pEnvFrq[i  ].iTime) /
                              				(ins.pprt[iPrt].pEnvFrq[i+1].iTime -
                              				ins.pprt[iPrt].pEnvFrq[i  ].iTime) ;
              dFrq = dFrac  * ins.pprt[iPrt].pEnvFrq[i+1].iValue + (1-dFrac) *
ins.pprt[iPrt].pEnvFrq[i  ].iValue ;
            break ;
              }
              }
             dComp += dAmp * SineGenerator (dFrq, dAngle + iPrt) ;
          		}
          	pBuffer[iSmp] = (BYTE) (127 + 127 * dComp / iCompMaxAmp) ;
     	}
}

// Make a waveform file
// -------------------------------------------------------------------------

BOOL MakeWaveFile (INS ins, TCHAR * szFileName)
{
     	DWORD        				dwWritten ;
     	HANDLE       				hFile ;
     	int          				iChunkSize, iPcmSize, iNumSamples ;
     	PBYTE        				pBuffer ;
     	WAVEFORMATEX 		        waveform ;

     	hFile = CreateFile (szFileName, GENERIC_WRITE, 0, NULL,
                CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL) ;
	if (hFile == NULL)
          			return FALSE ;
     	iNumSamples = ((long) ins.iMsecTime * SAMPLE_RATE / 1000 + 1) / 2 * 2 ;
     	iPcmSize    = sizeof (PCMWAVEFORMAT) ;
     	iChunkSize 	= 12 + iPcmSize + 8 + iNumSamples ;

     	if (NULL == (pBuffer = malloc (iNumSamples)))
     	{
          		CloseHandle (hFile) ;
          		return FALSE ;
     	}

     	FillBuffer (ins, pBuffer, iNumSamples) ;
     	waveform.wFormatTag      			= WAVE_FORMAT_PCM ;
     	waveform.nChannels       			= 1 ;
     	waveform.nSamplesPerSec           	= SAMPLE_RATE ;
     	waveform.nAvgBytesPerSec            = SAMPLE_RATE ;
     	waveform.nBlockAlign     			= 1 ;
     	waveform.wBitsPerSample  = 8 ;
     	waveform.cbSize          = 0 ;

     	WriteFile 	(hFile, "RIFF", 4, &dwWritten, NULL) ;
     	WriteFile 	(hFile, &iChunkSize, 4, &dwWritten, NULL) ;
     	WriteFile 	(hFile, "WAVEfmt ", 8, &dwWritten, NULL) ;
     	WriteFile 	(hFile, &iPcmSize, 4, &dwWritten, NULL) ;
     	WriteFile 	 (hFile, &waveform, sizeof (WAVEFORMATEX) - 2, &dwWritten, NULL) ;
     	WriteFile 	(hFile, "data", 4, &dwWritten, NULL) ;
     	WriteFile 	(hFile, &iNumSamples, 4, &dwWritten, NULL) ;
     	WriteFile (hFile, pBuffer, 			iNumSamples,  &dwWritten, NULL) ;

     	CloseHandle (hFile) ;
     	free (pBuffer) ;

     	if ((int) dwWritten != iNumSamples)
     	{
          		DeleteFile (szFileName) ;
          		return FALSE ;
     	}
     	return TRUE ;
}

void TestAndCreateFile (	HWND hwnd, INS ins, TCHAR * szFileName,
									int idButton)
{
     	TCHAR szMessage [64] ;
     	if (-1 != GetFileAttributes (szFileName))
          			EnableWindow (GetDlgItem (hwnd, idButton), TRUE) ;
     	else
     	{
          		if (MakeWaveFile (ins, szFileName))
               				EnableWindow (GetDlgItem (hwnd, idButton), TRUE) ;
          		else
       		{
              			 	wsprintf (szMessage, TEXT ("Could not create %x."), szFileName) ;
               				MessageBeep (MB_ICONEXCLAMATION) ;
               				MessageBox (hwnd, 	szMessage, szAppName,
                            MB_OK | MB_ICONEXCLAMATION) ;
      		}
     	}
}

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	if (-1 == DialogBox (hInstance, szAppName, NULL, DlgProc))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
     	}
     	return 0 ;
}

BOOL CALLBACK DlgProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static TCHAR * szTrum = TEXT ("Trumpet.wav") ;
     	static TCHAR * szOboe = TEXT ("Oboe.wav") ;
     	static TCHAR * szClar = TEXT ("Clarinet.wav") ;

     	switch (message)
     	{
     	case 	WM_INITDIALOG:
          			SetTimer (hwnd, ID_TIMER, 1, NULL) ;
          			return TRUE ;

     	case 	WM_TIMER:
          			KillTimer (hwnd, ID_TIMER) ;
          			SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
          			ShowCursor (TRUE) ;

          			TestAndCreateFile (hwnd, insTrum, szTrum, IDC_TRUMPET) ;
          			TestAndCreateFile (hwnd, insOboe, szOboe, IDC_OBOE) ;
          			TestAndCreateFile (hwnd, insClar, szClar, IDC_CLARINET) ;

          			SetDlgItemText (hwnd, IDC_TEXT, TEXT (" ")) ;
          			SetFocus (GetDlgItem (hwnd, IDC_TRUMPET)) ;

          			ShowCursor (FALSE) ;
          			SetCursor (LoadCursor (NULL, IDC_ARROW)) ;
          			return TRUE ;

     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{		
          			case 	IDC_TRUMPET:
               					PlaySound (szTrum, NULL, SND_FILENAME | SND_SYNC) ;
               					return TRUE ;

          			case 	IDC_OBOE:
               					PlaySound (szOboe, NULL, SND_FILENAME | SND_SYNC) ;
               					return TRUE ;

          			case 	IDC_CLARINET:
               					PlaySound (szClar, NULL, SND_FILENAME |SND_SYNC) ;
               					return TRUE ;
          			}
          			break ;

     	case 	WM_SYSCOMMAND:
          			switch (LOWORD (wParam))
          			{
          			case SC_CLOSE:
               					EndDialog (hwnd, 0) ;
               					return TRUE ;
         	 		}
          			break ;
     	}
     	return FALSE ;
}

 ADDSYNTH.RC ￡¨?a??￡?
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Dialog
ADDSYNTH 		DIALOG DISCARDABLE  100, 100, 176, 49
STYLE 			WS_MINIMIZEBOX | WS_CAPTION | WS_SYSMENU
CAPTION 		"Additive Synthesis"
FONT 8, 		               "MS Sans Serif"
BEGIN
	PUSHBUTTON      			"Trumpet",IDC_TRUMPET,8,8,48,16
    	PUSHBUTTON      			"Oboe",IDC_OBOE,64,8,48,16
    	PUSHBUTTON      			"Clarinet",IDC_CLARINET,120,8,48,16
    	LTEXT           			"Preparing Data...",IDC_TEXT,8,32,100,8
END

 RESOURCE.H ￡¨?a??￡?
// Microsoft Developer Studio generated include file.
// Used by AddSynth.rc

#define 		IDC_TRUMPET                     			1000
#define 		IDC_OBOE                        			1001
#define 		IDC_CLARINET                    			1002
#define 		IDC_TEXT                        			1003

 3ìDò22-7  WAKEUP
WAKEUP.C
/*---------------------------------------------------------------------------
   	WAKEUP.C -- 	Alarm Clock Program
               						(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
#include <commctrl.h>

     		// ID values for 3 child windows
#define 		ID_TIMEPICK 		0
#define 		ID_CHECKBOX		1
#define 		ID_PUSHBTN		2

     		// Timer ID

#define 		ID_TIMER			1

     		// Number of 100-nanosecond increments (ie FILETIME ticks) in an hour
#define FTTICKSPERHOUR (60 * 60 * (LONGLONG) 10000000)
     		// Defines and structure for waveform "file"
#define 		SAMPRATE 		11025
#define 		NUMSAMPS 		(3 * SAMPRATE)
#define 		HALFSAMPS	(NUMSAMPS / 2)

typedef struct
{
     	char  		chRiff[4] ;
     	DWORD 		dwRiffSize ;
     	char  		chWave[4] ;
     	char  		chFmt [4] ;
     	DWORD 		dwFmtSize ;
     	PCMWAVEFORMAT pwf ;
     	char  		chData[4] ;
     	DWORD 		dwDataSize ;
     	BYTE  		byData[0] ;
}
WAVEFORM ;
     	// The window proc and the subclass proc
LRESULT 	CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
LRESULT 	CALLBACK SubProc (HWND, UINT, WPARAM, LPARAM) ;

     	// Original window procedure addresses for the subclassed windows

WNDPROC SubbedProc [3] ;

     	// The current child window with the input focus

HWND hwndFocus ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInst,
                    							PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR	szAppName [] = TEXT ("WakeUp") ;
     	HWND         				hwnd ;
     	MSG          				msg ;
     	WNDCLASS     			wndclass ;
	
     	wndclass.style         			= 0 ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) (1 + COLOR_BTNFACE) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;

     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
     	}

     	hwnd = CreateWindow (	szAppName, szAppName,
                          		WS_OVERLAPPED | WS_CAPTION |
                                WS_SYSMENU | WS_MINIMIZEBOX,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     {
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static HWND          		hwndDTP, hwndCheck, hwndPush ;
     	static WAVEFORM      		waveform = { "RIFF", NUMSAMPS + 0x24,
"WAVE", "fmt ",
            						sizeof (PCMWAVEFORMAT), 1, 1, SAMPRATE,
                                    SAMPRATE, 1, 8, "data", NUMSAMPS } ;
     	static WAVEFORM    			* pwaveform ;
     	FILETIME             		ft ;
     	HINSTANCE            		hInstance ;
     	INITCOMMONCONTROLSEX		icex ;
     	int                  		i, cxChar, cyChar ;
     	LARGE_INTEGER        		li ;
     	SYSTEMTIME           		st ;

     	switch (message)
     	{
     	case 	WM_CREATE:
               					// Some initialization stuff

          			hInstance = (HINSTANCE) GetWindowLong (hwnd, GWL_HINSTANCE) ;

          			icex.dwSize = sizeof (icex) ;
          			icex.dwICC  = ICC_DATE_CLASSES ;
          			InitCommonControlsEx (&icex) ;

               		// Create the waveform file with alternating square waves

          			pwaveform = malloc (sizeof (WAVEFORM) + NUMSAMPS) ;
          			* pwaveform = waveform ;

          			for (i = 0 ; i < HALFSAMPS ; i++)
               					if (i % 600 < 300)
                    			if (i % 16 < 8)
                    pwaveform->byData[i] = 25 ;
                    else
                    pwaveform->byData[i] = 230 ;
               		else
                    if (i % 8 < 4)
                    pwaveform->byData[i] = 25 ;
                    else
                    pwaveform->byData[i] = 230 ;
               		// Get character size and set a fixed window size.
          			cxChar = LOWORD (GetDialogBaseUnits ()) ;
          			cyChar = HIWORD (GetDialogBaseUnits ()) ;

			SetWindowPos (	hwnd, NULL, 0, 0, 42 * cxChar, 10 * cyChar / 3 + 2 *
GetSystemMetrics (SM_CYBORDER) +GetSystemMetrics (SM_CYCAPTION)
,SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE) ;

               					// Create the three child windows

          	hwndDTP = CreateWindow (DATETIMEPICK_CLASS, TEXT (""),
                      WS_BORDER | WS_CHILD | WS_VISIBLE | DTS_TIMEFORMAT,
                      2 * cxChar, cyChar, 12 * cxChar, 4 * cyChar / 3,
                      hwnd, (HMENU) ID_TIMEPICK, hInstance, NULL) ;
          	hwndCheck = CreateWindow (TEXT ("Button"), TEXT ("Set Alarm"),
                       WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX,
                       16 * cxChar, cyChar, 12 * cxChar, 4 * cyChar / 3,
                       hwnd, (HMENU) ID_CHECKBOX, hInstance, NULL) ;

          	hwndPush = CreateWindow (TEXT ("Button"), TEXT ("Turn Off"),
                       WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_DISABLED,
                       28 * cxChar, cyChar, 12 * cxChar, 4 * cyChar / 3,
                       hwnd, (HMENU) ID_PUSHBTN, hInstance, NULL) ;

         	 		hwndFocus = hwndDTP ;

               							// Subclass the three child windows

          			SubbedProc [ID_TIMEPICK] = (WNDPROC)
                    SetWindowLong (hwndDTP, GWL_WNDPROC, (LONG) SubProc) ;
          			SubbedProc [ID_CHECKBOX] = (WNDPROC)
                    SetWindowLong (hwndCheck, GWL_WNDPROC, (LONG) SubProc);
          			SubbedProc [ID_PUSHBTN] = (WNDPROC)
                    SetWindowLong (hwndPush, GWL_WNDPROC, (LONG) SubProc) ;

               			// Set the date and time picker control to the current time
               			// plus 9 hours, rounded down to next lowest hour

          			GetLocalTime (&st) ;
          			SystemTimeToFileTime (&st, &ft) ;
          			li = * (LARGE_INTEGER *) &ft ;
          			li.QuadPart += 9 * FTTICKSPERHOUR ;
          			ft = * (FILETIME *) &li ;
          			FileTimeToSystemTime (&ft, &st) ;
          			st.wMinute = st.wSecond = st.wMilliseconds = 0 ;
          			SendMessage (hwndDTP, DTM_SETSYSTEMTIME, 0, (LPARAM) &st) ;
          			return 0 ;

     	case 	WM_SETFOCUS:
          			SetFocus (hwndFocus) ;
          			return 0 ;

     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))      // control ID
          			{
          			case	ID_CHECKBOX:

                    					// When the user checks the "Set Alarm" button, get the
                    					// time in the date and time control and subtract from
                    					// it the current PC time.

               			if (SendMessage (hwndCheck, BM_GETCHECK, 0, 0))
               				{
                    						SendMessage (hwndDTP, DTM_GETSYSTEMTIME, 0, (LPARAM) &st) ;
                    						SystemTimeToFileTime (&st, &ft) ;
                    					li = * (LARGE_INTEGER *) &ft ;

                    					GetLocalTime (&st) ;
                    					SystemTimeToFileTime (&st, &ft) ;
                    					li.QuadPart -= ((LARGE_INTEGER *) &ft)->QuadPart ;

                         						// Make sure the time is between 0 and 24 hours!
                         						// These little adjustments let us completely ignore
                         						// the date part of the SYSTEMTIME structures.

                    					while	(	li.QuadPart < 0)
                         								li.QuadPart += 24 * FTTICKSPERHOUR ;

                    					li.QuadPart %= 24 * FTTICKSPERHOUR ;

                         						// Set a one-shot timer! (See you in the morning.)

                    					SetTimer (hwnd, ID_TIMER, (int) (li.QuadPart / 10000), 0) ;
               				}
                    						// If button is being unchecked, kill the timer.

              			else
                    					KillTimer (hwnd, ID_TIMER) ;

               			return 0 ;

               				// The "Turn Off" button turns off the ringing alarm, and also
               				// unchecks the "Set Alarm" button and disables itself.

          		case 	ID_PUSHBTN:
               	PlaySound (NULL, NULL, 0) ;
               	SendMessage (hwndCheck, BM_SETCHECK, 0, 0) ;
              	EnableWindow (hwndDTP, TRUE) ;
               	EnableWindow (hwndCheck, TRUE) ;
                EnableWindow (hwndPush, FALSE) ;
               	SetFocus (hwndDTP) ;
               	return 0 ;
          		}
		return 0 ;

               			// The WM_NOTIFY message comes from the date and time picker.
               			// If the user has checked "Set Alarm" and then gone back to
               			// change the alarm time, there might be a discrepancy between
               			// the displayed time and the one-shot timer. So the program
               			// unchecks "Set Alarm" and kills any outstanding timer.

     	case 	WM_NOTIFY:
          			switch (wParam)          			// control ID
          			{
          			case 	ID_TIMEPICK:
               		switch (((NMHDR *) lParam)->code) // notification code
               					{
               					case 	DTN_DATETIMECHANGE:
                    		if (SendMessage (hwndCheck, BM_GETCHECK, 0, 0))
                    		{
                         	KillTimer (hwnd, ID_TIMER) ;
                         	SendMessage (hwndCheck, BM_SETCHECK, 0, 0) ;
                    		}
                    		return 0 ;
               				}
          			}
          			return 0 ;

          			// The WM_COMMAND message comes from the two buttons. 		

     	case 	WM_TIMER:

               			// When the timer message comes, kill the timer (because we only
               			// want a one-shot) and start the annoying alarm noise going.

          			KillTimer (	hwnd, ID_TIMER) ;
          			PlaySound (	(PTSTR) pwaveform,  NULL,
                     								SND_MEMORY | SND_LOOP | SND_ASYNC);

               			// Let the sleepy user turn off the timer by slapping the
               			// space bar. If the window is minimized, it's restored; then
               			// it's brought to the forefront; then the pushbutton is enabled
               			// and given the input focus.

          			EnableWindow (hwndDTP, FALSE) ;
          			EnableWindow (hwndCheck, FALSE) ;
          			EnableWindow (hwndPush, TRUE) ;

          			hwndFocus = hwndPush ;
          			ShowWindow (hwnd, SW_RESTORE) ;
          			SetForegroundWindow (hwnd) ;
          			return 0 ;

          			// Clean up if the alarm is ringing or the timer is still set.

     	case 	WM_DESTROY:
          			free (pwaveform) ;

          			if (IsWindowEnabled (hwndPush))
               					PlaySound (NULL, NULL, 0) ;

          			if (SendMessage (hwndCheck, BM_GETCHECK, 0, 0))
               					KillTimer (hwnd, ID_TIMER) ;

          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

LRESULT CALLBACK SubProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	int idNext, id = GetWindowLong (hwnd, GWL_ID) ;
     	switch (message)
     	{
     	case 	WM_CHAR:
          			if (wParam == '\t')
          			{
               				idNext = id ;

               				do
                    					idNext = (idNext +
                         						(GetKeyState (VK_SHIFT) < 0 ? 2 : 1)) % 3 ;
               				while (!IsWindowEnabled (GetDlgItem (GetParent (hwnd), idNext)));

               				SetFocus (GetDlgItem (GetParent (hwnd), idNext)) ;
               				return 0 ;
          			}
          			break ;

     	case 	WM_SETFOCUS:
          			hwndFocus = hwnd ;
          			break ;
     	}
     	return CallWindowProc (	SubbedProc [id], hwnd, message, wParam,lParam) ;
}

type struct _FILETIME       			// ft
{
     	DWORD dwLowDateTime ;
     	DWORD dwHighDateTime ;
}
FILETIME ;

typedef __int64 LONGLONG ;
typedef unsigned __int64 DWORDLONG ;

typedef union _LARGE_INTEGER
{
     	struct
     	{
          		DWORD LowPart ;
          		LONG  HighPart ;
  	} ;
     	LONGLONG QuadPart ;
}
LARGE_INTEGER ;