winawe32.c

汇编源码大全 有各种汇编源码 希望对你有所帮助

			MessageBox(NULL, "Set MT-32 failed.\0", "Error\0", MB_OK);
		    SetCursor(hCursor);
		    break;

		case ID_SETTINGS_REVERB_ROOM1 :
		case ID_SETTINGS_REVERB_ROOM2 :
		case ID_SETTINGS_REVERB_ROOM3 :
		case ID_SETTINGS_REVERB_HALL1 :
		case ID_SETTINGS_REVERB_HALL2 :
		case ID_SETTINGS_REVERB_PLATE :
		case ID_SETTINGS_REVERB_DELAY :
		case ID_SETTINGS_REVERB_PANNINGDELAY :
		    SetReverb(wParam);
		    break;

		case ID_SETTINGS_CHORUS_CHORUS1 :
		case ID_SETTINGS_CHORUS_CHORUS2 :
		case ID_SETTINGS_CHORUS_CHORUS3 :
		case ID_SETTINGS_CHORUS_CHORUS4 :
		case ID_SETTINGS_CHORUS_FEEBACKCHORUS :
		case ID_SETTINGS_CHORUS_FLANGER :
		case ID_SETTINGS_CHORUS_SHORTDELAY :
		case ID_SETTINGS_CHORUS_SHORTDELAYFB :
		    SetChorus(wParam);
		    break;
	    }
	    break;
	}
	break;

	case WM_DESTROY:
	    if ( bIsMIDIPlaying == TRUE ) {
		if ( MCIEndPlay(wMCIDeviceID) )
		    MessageBox(NULL, "Error stop playing MCISEQ.\0", "Error.\0", MB_OK|MB_ICONSTOP);
		if ( MCICloseDevice(wMCIDeviceID) )
		    MessageBox(NULL, "Error closing MCISEQ.\0", "Error.\0", MB_OK|MB_ICONSTOP);
	    }

	    if ( bIsUserBankLoaded == TRUE ) {
		if ( lpAWEManager(hAWEHandle, AWE_CLEAR_USER_BANK, USER_BANK_NUM, NULL) != AWE_NO_ERR )
		    MessageBox(NULL, "Error clearing user bank\0", "Error\0", MB_OK|MB_ICONHAND);
	    }

	    if ( CloseAWEMAN() == FALSE )
		MessageBox(NULL, "Error closing AWEMAN\0", "Error", MB_OK|MB_ICONSTOP);

	    FreeLibrary(hAWEMANDLL);
	    FreeLibrary(hAWEGUIDLL);

	    PostQuitMessage(0);
	    break;

	default:
	    return (DefWindowProc(hWnd, message, wParam, lParam));
    }
    return (NULL);
}


BOOL __export CALLBACK About(HWND	hDlg,
			     unsigned	message,
			     WORD	wParam,
			     LPARAM	lParam)
{
    switch (message)
    {
	case WM_INITDIALOG:
	    return (TRUE);

	case WM_COMMAND:
	    if (wParam == IDOK
		|| wParam == IDCANCEL)
	    {
		EndDialog(hDlg, TRUE);
		return (TRUE);
	    }
	    break;
    }
    return (FALSE);
}

BOOL __export CALLBACK TriggerMe(HWND	    hDlg,
				 unsigned   message,
				 WORD	    wParam,
				 LPARAM     lParam)
{

    #define BIG_ON	0x007F3C90
    #define BIG_OFF	0x00003C90
    #define PATCH_SET	0x00007FC0

    DWORD   dwErr;
    char    ach[128];
    DWORD   dwPresetNumber;
    static DWORD   dwMIDINumber = 0xF;
    BOOL    fTranslated;

    switch (message)
    {
	case WM_INITDIALOG:
	    // Set to preset 1 on startup, MIDI channel 16
	    SetDlgItemInt(hDlg, IDC_PC, 0x0, FALSE);
	    SetDlgItemInt(hDlg, IDC_MIDI, 0xF, FALSE);
	    return (TRUE);

	case WM_COMMAND:
	    switch ( wParam ) {
		case IDOK:
		    EndDialog(hDlg, TRUE);
		    return TRUE;

		case IDC_BIGON:
		    dwErr = lpAWEManager(hAWEHandle, AWE_SEND_MIDI, BIG_ON+dwMIDINumber, NULL);
		    if ( dwErr != AWE_NO_ERR ) {
			(void)wsprintf(ach, "Error code = %d\0", (WORD)dwErr);
			MessageBox(NULL, ach, "Error\0", MB_OK|MB_ICONSTOP);
		    }
		    return TRUE;

		case IDC_BIGOFF:
		    dwErr = lpAWEManager(hAWEHandle, AWE_SEND_MIDI, BIG_OFF+dwMIDINumber, NULL);
		    if ( dwErr != AWE_NO_ERR ) {
			(void)wsprintf(ach, "Error code = %d\0", (WORD)dwErr);
			MessageBox(NULL, ach, "Error\0", MB_OK|MB_ICONSTOP);
		    }
		    return TRUE;

		case IDC_SETPATCH:
		    // Get the patch number
		    dwPresetNumber = (DWORD)GetDlgItemInt(hDlg, IDC_PC, (BOOL FAR*)&fTranslated, FALSE);
		    if ( dwPresetNumber > 0x7F )
			dwPresetNumber = 0x7F;
		    dwPresetNumber = (dwPresetNumber << 8) + dwMIDINumber + 0xC0;

		    dwErr = lpAWEManager(hAWEHandle, AWE_SEND_MIDI, dwPresetNumber, NULL);
		    if ( dwErr != AWE_NO_ERR ) {
			(void)wsprintf(ach, "Error code = %d\0", (WORD)dwErr);
			MessageBox(NULL, ach, "Error\0", MB_OK|MB_ICONSTOP);
		    }
		    return TRUE;

		case IDC_SETMIDI:
		    // Get the MIDI channel
		    dwMIDINumber = (DWORD)GetDlgItemInt(hDlg, IDC_MIDI, (BOOL FAR*)&fTranslated, FALSE);
		    if ( dwMIDINumber > 0xF )
			dwMIDINumber = 0xF;
		    return TRUE;
	    }
	    break;
    }
    return (FALSE);
}

BOOL InitAWEDLL(void)
{
    hAWEGUIDLL = LoadLibrary("AWEGUI.DLL");
    if ( hAWEGUIDLL > HINSTANCE_ERROR ) {
	lpControlPanel = (LPCONTROLPANEL)GetProcAddress(hAWEGUIDLL, "AWEControlPanel");
	lpControllerBob = (LPCONTROLPANEL)GetProcAddress(hAWEGUIDLL, "AWEControllerBob");
	if ( lpControlPanel == NULL || lpControllerBob == NULL )
	    return FALSE;
    }
    hAWEMANDLL = LoadLibrary("AWEMAN.DLL");
    if ( hAWEGUIDLL > HINSTANCE_ERROR ) {
	lpAWEManager = (LPFNAWEMANAGER)GetProcAddress(hAWEMANDLL, "AWEManager");
	if ( lpAWEManager == NULL)
	    return FALSE;
    }
    return TRUE;
}


BOOL OpenAWEMAN()
{
    if ( lpAWEManager(NULL, AWE_OPEN, (LPARAM)(LPSTR)&hAWEHandle, NULL) == AWE_NO_ERR )
	return TRUE;
    else
	return FALSE;
}


BOOL CloseAWEMAN()
{
    if ( lpAWEManager(hAWEHandle, AWE_CLOSE, NULL, NULL ) == AWE_NO_ERR )
	return TRUE;
    else
	return FALSE;
}


BOOL FetchMIDIFile(HWND hWnd)
{

    char	    szMIDIExt[] = "MIDI\0*.MID; *.RMI\0";
    WORD	    wReturnVal = 0;
    DWORD	    dwErrorVal = 0;
    OPENFILENAME    ofnMIDI;
    // char	       szInitFile[128]

    strcpy(szFileName, szBareName);

    // szFileName[0] = 0;

    ofnMIDI.lStructSize 		= sizeof(OPENFILENAME);
    ofnMIDI.hwndOwner			= hWnd;
    ofnMIDI.hInstance			= hInst;
    ofnMIDI.lpstrFilter 		= szMIDIExt;
    ofnMIDI.lpstrCustomFilter		= NULL;
    ofnMIDI.nMaxCustFilter		= 0L;
    ofnMIDI.nFilterIndex		= 1L;
    ofnMIDI.lpstrFile			= (LPSTR)szFileName;
    ofnMIDI.nMaxFile			= 128;
    ofnMIDI.lpstrInitialDir		= NULL;
    ofnMIDI.lpstrTitle			= NULL;
    ofnMIDI.lpstrFileTitle		= (LPSTR)szBareName;
    ofnMIDI.lpstrDefExt 		= NULL;
    ofnMIDI.Flags			= 0;

    wReturnVal = GetOpenFileName((LPOPENFILENAME)&ofnMIDI);
    if ( wReturnVal > 0 )
	 return TRUE;
    else
	return FALSE;

}

BOOL FetchUserBankFile(HWND hWnd)
{

    char	    szSBKExt[] = "SoundFont Bank\0*.SBK\0";
    WORD	    wReturnVal = 0;
    DWORD	    dwErrorVal = 0;
    OPENFILENAME    ofnSBK;

    ofnSBK.lStructSize		       = sizeof(OPENFILENAME);
    ofnSBK.hwndOwner		       = hWnd;
    ofnSBK.hInstance		       = hInst;
    ofnSBK.lpstrFilter		       = szSBKExt;
    ofnSBK.lpstrCustomFilter	       = NULL;
    ofnSBK.nMaxCustFilter	       = 0L;
    ofnSBK.nFilterIndex 	       = 1L;
    ofnSBK.lpstrFile		       = (LPSTR)szUserBankName;
    ofnSBK.nMaxFile		       = 128;
    ofnSBK.lpstrInitialDir	       = NULL;
    ofnSBK.lpstrTitle		       = NULL;
    ofnSBK.lpstrFileTitle	       = NULL;
    ofnSBK.lpstrDefExt		       = NULL;
    ofnSBK.Flags		       = 0;

    wReturnVal = GetOpenFileName((LPOPENFILENAME)&ofnSBK);
    if ( wReturnVal > 0 )
	 return TRUE;
    else
	return FALSE;

}

void SetReverb(WORD wParam)
{

    CParamObject	 param;
    enum TYPEINDEX	 m_CurEfxType;
    enum VARIINDEX	 m_CurTypeVari[2];

    param.m_VariIndex[REVERB] = param.m_VariIndex[CHORUS] = 0;

    lpAWEManager(hAWEHandle, AWE_GET_EFX, (LPARAM)(LPSTR)&param, (LPARAM)0L);
    m_CurEfxType = (enum TYPEINDEX)param.m_TypeIndex;

    if ( m_CurEfxType == REVERB_CHORUS ) {
	// Correct !
	m_CurTypeVari[REVERB] = (enum VARIINDEX)param.m_VariIndex[REVERB];
	m_CurTypeVari[CHORUS] = (enum VARIINDEX)param.m_VariIndex[CHORUS];

	// Now issue selection on REVERB
	switch ( wParam ) {
	    case ID_SETTINGS_REVERB_ROOM1 :
		param.m_VariIndex[REVERB] = (enum VARIINDEX)ROOM_1; break;

	    case ID_SETTINGS_REVERB_ROOM2 :
		param.m_VariIndex[REVERB] = (enum VARIINDEX)ROOM_2; break;

	    case ID_SETTINGS_REVERB_ROOM3 :
		param.m_VariIndex[REVERB] = (enum VARIINDEX)ROOM_3; break;

	    case ID_SETTINGS_REVERB_HALL1 :
		param.m_VariIndex[REVERB] = (enum VARIINDEX)HALL_1; break;

	    case ID_SETTINGS_REVERB_HALL2 :
		param.m_VariIndex[REVERB] = (enum VARIINDEX)HALL_2; break;

	    case ID_SETTINGS_REVERB_PLATE :
		param.m_VariIndex[REVERB] = (enum VARIINDEX)PLATE; break;

	    case ID_SETTINGS_REVERB_DELAY :
		param.m_VariIndex[REVERB] = (enum VARIINDEX)DELAY; break;

	    case ID_SETTINGS_REVERB_PANNINGDELAY :
		param.m_VariIndex[REVERB] = (enum VARIINDEX)PANNING_DELAY; break;
	}
	if ( lpAWEManager(hAWEHandle, AWE_SELECT_EFX, (LPARAM)(LPSTR)&param, (LPARAM)0L) != AWE_NO_ERR ) {
	    MessageBox(NULL, "Error in setting effect.\0",
			     "Error\0",
			     MB_OK|MB_ICONSTOP);
	}
	else {
	    MessageBox(NULL, "Effect setting successful.\0",
			     "OK !\0",
			     MB_OK|MB_ICONINFORMATION);
	}
    }
    else {
	MessageBox(NULL, "Current effect type is not Reverb/Chorus.\0",
			 "Error\0",
			 MB_OK|MB_ICONSTOP);
    }
}


void SetChorus(WORD wParam)
{
    CParamObject	 param;
    enum TYPEINDEX	 m_CurEfxType;
    enum VARIINDEX	 m_CurTypeVari[2];

    param.m_VariIndex[REVERB] = param.m_VariIndex[CHORUS] = 0;

    lpAWEManager(hAWEHandle, AWE_GET_EFX, (LPARAM)(LPSTR)&param, 0L);
    m_CurEfxType = (enum TYPEINDEX)param.m_TypeIndex;

    if ( m_CurEfxType == REVERB_CHORUS ) {
	// Correct !
	m_CurTypeVari[REVERB] = (enum VARIINDEX)param.m_VariIndex[REVERB];
	m_CurTypeVari[CHORUS] = (enum VARIINDEX)param.m_VariIndex[CHORUS];

	// Now issue selection on CHORUS
	switch ( wParam ) {
	    case ID_SETTINGS_CHORUS_CHORUS1 :
		param.m_VariIndex[CHORUS] = (enum VARIINDEX)CHORUS_1; break;

	    case ID_SETTINGS_CHORUS_CHORUS2 :
		param.m_VariIndex[CHORUS] = (enum VARIINDEX)CHORUS_2; break;

	    case ID_SETTINGS_CHORUS_CHORUS3 :
		param.m_VariIndex[CHORUS] = (enum VARIINDEX)CHORUS_3; break;

	    case ID_SETTINGS_CHORUS_CHORUS4 :
		param.m_VariIndex[CHORUS] = (enum VARIINDEX)CHORUS_4; break;

	    case ID_SETTINGS_CHORUS_FEEBACKCHORUS :
		param.m_VariIndex[CHORUS] = (enum VARIINDEX)FEEDBACK_DELAY; break;

	    case ID_SETTINGS_CHORUS_FLANGER :
		param.m_VariIndex[CHORUS] = (enum VARIINDEX)FLANGER; break;

	    case ID_SETTINGS_CHORUS_SHORTDELAY :
		param.m_VariIndex[CHORUS] = (enum VARIINDEX)SHORT_DELAY; break;

	    case ID_SETTINGS_CHORUS_SHORTDELAYFB :
		param.m_VariIndex[CHORUS] = (enum VARIINDEX)SHORT_DELAY_FB; break;

	}
	if ( lpAWEManager(hAWEHandle, AWE_SELECT_EFX, (LPARAM)(LPSTR)&param, 0L) != AWE_NO_ERR ) {
	    MessageBox(NULL, "Error in setting effect.\0",
			     "Error\0",
			     MB_OK|MB_ICONSTOP);
	}
	else {
	    MessageBox(NULL, "Effect setting successful.\0",
			     "OK !\0",
			     MB_OK|MB_ICONINFORMATION);
	}
    }
    else {
	MessageBox(NULL, "Current effect type is not Reverb/Chorus.\0",
			 "Error\0",
			 MB_OK|MB_ICONSTOP);
    }

}