www.pudn.com > vc++shipinkaifa.rar > dxutil.cpp, change:2004-07-11,size:25606b


#ifndef STRICT 
#define STRICT 
#endif  
#include <windows.h> 
#include <mmsystem.h> 
#include <tchar.h> 
#include <stdio.h>  
#include <stdarg.h> 
#include "DXUtil.h" 
#ifdef UNICODE 
    typedef HINSTANCE (WINAPI* LPShellExecute)(HWND hwnd, LPCWSTR lpOperation, LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd); 
#else 
    typedef HINSTANCE (WINAPI* LPShellExecute)(HWND hwnd, LPCSTR lpOperation, LPCSTR lpFile, LPCSTR lpParameters, LPCSTR lpDirectory, INT nShowCmd); 
#endif 
#ifndef UNDER_CE 
HRESULT DXUtil_GetDXSDKMediaPathCch( TCHAR* strDest, int cchDest ) 
{ 
    if( strDest == NULL || cchDest < 1 ) 
        return E_INVALIDARG; 
    lstrcpy( strDest, TEXT("") ); 
     
    HKEY  hKey; 
    LONG lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE, 
                                _T("Software\\Microsoft\\DirectX SDK"), 
                                0, KEY_READ, &hKey ); 
    if( ERROR_SUCCESS != lResult ) 
        return E_FAIL; 
    DWORD dwType; 
    DWORD dwSize = cchDest * sizeof(TCHAR); 
    lResult = RegQueryValueEx( hKey, _T("DX9SDK Samples Path"), NULL, 
                              &dwType, (BYTE*)strDest, &dwSize ); 
    strDest[cchDest-1] = 0;  
    RegCloseKey( hKey ); 
    if( ERROR_SUCCESS != lResult ) 
        return E_FAIL; 
    const TCHAR* strMedia = _T("\\Media\\"); 
    if( lstrlen(strDest) + lstrlen(strMedia) < cchDest ) 
        _tcscat( strDest, strMedia ); 
    else 
        return E_INVALIDARG; 
    return S_OK; 
} 
#endif  
#ifndef UNDER_CE 
HRESULT DXUtil_FindMediaFileCch( TCHAR* strDestPath, int cchDest, TCHAR* strFilename ) 
{ 
    HRESULT hr; 
    HANDLE file; 
    TCHAR* strShortNameTmp = NULL; 
    TCHAR strShortName[MAX_PATH]; 
    int cchPath; 
    if( NULL==strFilename || NULL==strDestPath || cchDest < 1 ) 
        return E_INVALIDARG; 
    lstrcpy( strDestPath, TEXT("") ); 
    lstrcpy( strShortName, TEXT("") ); 
     
    cchPath = GetFullPathName(strFilename, cchDest, strDestPath, &strShortNameTmp); 
    if ((cchPath == 0) || (cchDest <= cchPath)) 
        return E_FAIL; 
    if( strShortNameTmp ) 
        lstrcpyn( strShortName, strShortNameTmp, MAX_PATH ); 
     
    file = CreateFile( strDestPath, GENERIC_READ, FILE_SHARE_READ, NULL,  
                       OPEN_EXISTING, 0, NULL ); 
    if( INVALID_HANDLE_VALUE != file ) 
    { 
        CloseHandle( file ); 
        return S_OK; 
    } 
     
     
    file = CreateFile( strShortName, GENERIC_READ, FILE_SHARE_READ, NULL,  
                       OPEN_EXISTING, 0, NULL ); 
    if( INVALID_HANDLE_VALUE != file ) 
    { 
        _tcsncpy( strDestPath, strShortName, cchDest ); 
        strDestPath[cchDest-1] = 0;  
        CloseHandle( file ); 
        return S_OK; 
    } 
     
     
    if( FAILED( hr = DXUtil_GetDXSDKMediaPathCch( strDestPath, cchDest ) ) ) 
        return hr; 
    if( lstrlen(strDestPath) + lstrlen(strShortName) < cchDest ) 
        lstrcat( strDestPath, strShortName ); 
    else 
        return E_INVALIDARG; 
    file = CreateFile( strDestPath, GENERIC_READ, FILE_SHARE_READ, NULL,  
                       OPEN_EXISTING, 0, NULL ); 
    if( INVALID_HANDLE_VALUE != file ) 
    { 
        CloseHandle( file ); 
        return S_OK; 
    } 
     
    _tcsncpy( strDestPath, strFilename, cchDest ); 
    strDestPath[cchDest-1] = 0;  
    return HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND ); 
} 
#endif  
HRESULT DXUtil_ReadStringRegKeyCch( HKEY hKey, TCHAR* strRegName, TCHAR* strDest,  
                                    DWORD cchDest, TCHAR* strDefault ) 
{ 
    DWORD dwType; 
    DWORD cbDest = cchDest * sizeof(TCHAR); 
    if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType,  
                                          (BYTE*)strDest, &cbDest ) ) 
    { 
        _tcsncpy( strDest, strDefault, cchDest ); 
        strDest[cchDest-1] = 0; 
        if( dwType != REG_SZ ) 
            return E_FAIL; 
        return S_OK; 
    } 
    return E_FAIL; 
} 
HRESULT DXUtil_WriteStringRegKey( HKEY hKey, TCHAR* strRegName, 
                                  TCHAR* strValue ) 
{ 
    if( NULL == strValue ) 
        return E_INVALIDARG; 
         
    DWORD cbValue = ((DWORD)_tcslen(strValue)+1) * sizeof(TCHAR); 
    if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_SZ,  
                                        (BYTE*)strValue, cbValue ) ) 
        return E_FAIL; 
    return S_OK; 
} 
HRESULT DXUtil_ReadIntRegKey( HKEY hKey, TCHAR* strRegName, DWORD* pdwDest,  
                              DWORD dwDefault ) 
{ 
    DWORD dwType; 
    DWORD dwLength = sizeof(DWORD); 
    if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType,  
                                          (BYTE*)pdwDest, &dwLength ) ) 
    { 
        *pdwDest = dwDefault; 
        if( dwType != REG_DWORD ) 
            return E_FAIL; 
        return S_OK; 
    } 
    return E_FAIL; 
} 
HRESULT DXUtil_WriteIntRegKey( HKEY hKey, TCHAR* strRegName, DWORD dwValue ) 
{ 
    if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_DWORD,  
                                        (BYTE*)&dwValue, sizeof(DWORD) ) ) 
        return E_FAIL; 
    return S_OK; 
} 
HRESULT DXUtil_ReadBoolRegKey( HKEY hKey, TCHAR* strRegName, BOOL* pbDest,  
                              BOOL bDefault ) 
{ 
    DWORD dwType; 
    DWORD dwLength = sizeof(BOOL); 
    if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType,  
                                          (BYTE*)pbDest, &dwLength ) ) 
    { 
        *pbDest = bDefault; 
        if( dwType != REG_DWORD ) 
            return E_FAIL; 
        return S_OK; 
    } 
    return E_FAIL; 
} 
HRESULT DXUtil_WriteBoolRegKey( HKEY hKey, TCHAR* strRegName, BOOL bValue ) 
{ 
    if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_DWORD,  
                                        (BYTE*)&bValue, sizeof(BOOL) ) ) 
        return E_FAIL; 
    return S_OK; 
} 
HRESULT DXUtil_ReadGuidRegKey( HKEY hKey, TCHAR* strRegName, GUID* pGuidDest,  
                               GUID& guidDefault ) 
{ 
    DWORD dwType; 
    DWORD dwLength = sizeof(GUID); 
    if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType,  
                                          (LPBYTE) pGuidDest, &dwLength ) ) 
    { 
        *pGuidDest = guidDefault; 
        if( dwType != REG_BINARY ) 
            return E_FAIL; 
        return S_OK; 
    } 
    return E_FAIL; 
} 
HRESULT DXUtil_WriteGuidRegKey( HKEY hKey, TCHAR* strRegName, GUID guidValue ) 
{ 
    if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_BINARY,  
                                        (BYTE*)&guidValue, sizeof(GUID) ) ) 
        return E_FAIL; 
    return S_OK; 
} 
FLOAT __stdcall DXUtil_Timer( TIMER_COMMAND command ) 
{ 
    static BOOL     m_bTimerInitialized = FALSE; 
    static BOOL     m_bUsingQPF         = FALSE; 
    static BOOL     m_bTimerStopped     = TRUE; 
    static LONGLONG m_llQPFTicksPerSec  = 0; 
     
    if( FALSE == m_bTimerInitialized ) 
    { 
        m_bTimerInitialized = TRUE; 
         
         
        LARGE_INTEGER qwTicksPerSec; 
        m_bUsingQPF = QueryPerformanceFrequency( &qwTicksPerSec ); 
        if( m_bUsingQPF ) 
            m_llQPFTicksPerSec = qwTicksPerSec.QuadPart; 
    } 
    if( m_bUsingQPF ) 
    { 
        static LONGLONG m_llStopTime        = 0; 
        static LONGLONG m_llLastElapsedTime = 0; 
        static LONGLONG m_llBaseTime        = 0; 
        double fTime; 
        double fElapsedTime; 
        LARGE_INTEGER qwTime; 
         
         
         
        if( m_llStopTime != 0 && command != TIMER_START && command != TIMER_GETABSOLUTETIME) 
            qwTime.QuadPart = m_llStopTime; 
        else 
            QueryPerformanceCounter( &qwTime ); 
         
        if( command == TIMER_GETELAPSEDTIME ) 
        { 
            fElapsedTime = (double) ( qwTime.QuadPart - m_llLastElapsedTime ) / (double) m_llQPFTicksPerSec; 
            m_llLastElapsedTime = qwTime.QuadPart; 
            return (FLOAT) fElapsedTime; 
        } 
     
         
        if( command == TIMER_GETAPPTIME ) 
        { 
            double fAppTime = (double) ( qwTime.QuadPart - m_llBaseTime ) / (double) m_llQPFTicksPerSec; 
            return (FLOAT) fAppTime; 
        } 
     
         
        if( command == TIMER_RESET ) 
        { 
            m_llBaseTime        = qwTime.QuadPart; 
            m_llLastElapsedTime = qwTime.QuadPart; 
            m_llStopTime        = 0; 
            m_bTimerStopped     = FALSE; 
            return 0.0f; 
        } 
     
         
        if( command == TIMER_START ) 
        { 
            if( m_bTimerStopped ) 
                m_llBaseTime += qwTime.QuadPart - m_llStopTime; 
            m_llStopTime = 0; 
            m_llLastElapsedTime = qwTime.QuadPart; 
            m_bTimerStopped = FALSE; 
            return 0.0f; 
        } 
     
         
        if( command == TIMER_STOP ) 
        { 
            if( !m_bTimerStopped ) 
            { 
                m_llStopTime = qwTime.QuadPart; 
                m_llLastElapsedTime = qwTime.QuadPart; 
                m_bTimerStopped = TRUE; 
            } 
            return 0.0f; 
        } 
     
         
        if( command == TIMER_ADVANCE ) 
        { 
            m_llStopTime += m_llQPFTicksPerSec/10; 
            return 0.0f; 
        } 
        if( command == TIMER_GETABSOLUTETIME ) 
        { 
            fTime = qwTime.QuadPart / (double) m_llQPFTicksPerSec; 
            return (FLOAT) fTime; 
        } 
        return -1.0f;  
    } 
    else 
    { 
         
        static double m_fLastElapsedTime  = 0.0; 
        static double m_fBaseTime         = 0.0; 
        static double m_fStopTime         = 0.0; 
        double fTime; 
        double fElapsedTime; 
         
         
         
        if( m_fStopTime != 0.0 && command != TIMER_START && command != TIMER_GETABSOLUTETIME) 
            fTime = m_fStopTime; 
        else 
            fTime = GETTIMESTAMP() * 0.001; 
     
         
        if( command == TIMER_GETELAPSEDTIME ) 
        {    
            fElapsedTime = (double) (fTime - m_fLastElapsedTime); 
            m_fLastElapsedTime = fTime; 
            return (FLOAT) fElapsedTime; 
        } 
     
         
        if( command == TIMER_GETAPPTIME ) 
        { 
            return (FLOAT) (fTime - m_fBaseTime); 
        } 
     
         
        if( command == TIMER_RESET ) 
        { 
            m_fBaseTime         = fTime; 
            m_fLastElapsedTime  = fTime; 
            m_fStopTime         = 0; 
            m_bTimerStopped     = FALSE; 
            return 0.0f; 
        } 
     
         
        if( command == TIMER_START ) 
        { 
            if( m_bTimerStopped ) 
                m_fBaseTime += fTime - m_fStopTime; 
            m_fStopTime = 0.0f; 
            m_fLastElapsedTime  = fTime; 
            m_bTimerStopped = FALSE; 
            return 0.0f; 
        } 
     
         
        if( command == TIMER_STOP ) 
        { 
            if( !m_bTimerStopped ) 
            { 
                m_fStopTime = fTime; 
                m_fLastElapsedTime  = fTime; 
                m_bTimerStopped = TRUE; 
            } 
            return 0.0f; 
        } 
     
         
        if( command == TIMER_ADVANCE ) 
        { 
            m_fStopTime += 0.1f; 
            return 0.0f; 
        } 
        if( command == TIMER_GETABSOLUTETIME ) 
        { 
            return (FLOAT) fTime; 
        } 
        return -1.0f;  
    } 
} 
HRESULT DXUtil_ConvertAnsiStringToWideCch( WCHAR* wstrDestination, const CHAR* strSource,  
                                     int cchDestChar ) 
{ 
    if( wstrDestination==NULL || strSource==NULL || cchDestChar < 1 ) 
        return E_INVALIDARG; 
    int nResult = MultiByteToWideChar( CP_ACP, 0, strSource, -1,  
                                       wstrDestination, cchDestChar ); 
    wstrDestination[cchDestChar-1] = 0; 
     
    if( nResult == 0 ) 
        return E_FAIL; 
    return S_OK; 
} 
HRESULT DXUtil_ConvertWideStringToAnsiCch( CHAR* strDestination, const WCHAR* wstrSource,  
                                     int cchDestChar ) 
{ 
    if( strDestination==NULL || wstrSource==NULL || cchDestChar < 1 ) 
        return E_INVALIDARG; 
    int nResult = WideCharToMultiByte( CP_ACP, 0, wstrSource, -1, strDestination,  
                                       cchDestChar*sizeof(CHAR), NULL, NULL ); 
    strDestination[cchDestChar-1] = 0; 
     
    if( nResult == 0 ) 
        return E_FAIL; 
    return S_OK; 
} 
HRESULT DXUtil_ConvertGenericStringToAnsiCch( CHAR* strDestination, const TCHAR* tstrSource,  
                                           int cchDestChar ) 
{ 
    if( strDestination==NULL || tstrSource==NULL || cchDestChar < 1 ) 
        return E_INVALIDARG; 
#ifdef _UNICODE 
    return DXUtil_ConvertWideStringToAnsiCch( strDestination, tstrSource, cchDestChar ); 
#else 
    strncpy( strDestination, tstrSource, cchDestChar ); 
    strDestination[cchDestChar-1] = '\0'; 
    return S_OK; 
#endif    
} 
HRESULT DXUtil_ConvertGenericStringToWideCch( WCHAR* wstrDestination, const TCHAR* tstrSource,  
                                           int cchDestChar ) 
{ 
    if( wstrDestination==NULL || tstrSource==NULL || cchDestChar < 1 ) 
        return E_INVALIDARG; 
#ifdef _UNICODE 
    wcsncpy( wstrDestination, tstrSource, cchDestChar ); 
    wstrDestination[cchDestChar-1] = L'\0'; 
    return S_OK; 
#else 
    return DXUtil_ConvertAnsiStringToWideCch( wstrDestination, tstrSource, cchDestChar ); 
#endif     
} 
HRESULT DXUtil_ConvertAnsiStringToGenericCch( TCHAR* tstrDestination, const CHAR* strSource,  
                                           int cchDestChar ) 
{ 
    if( tstrDestination==NULL || strSource==NULL || cchDestChar < 1 ) 
        return E_INVALIDARG; 
         
#ifdef _UNICODE 
    return DXUtil_ConvertAnsiStringToWideCch( tstrDestination, strSource, cchDestChar ); 
#else 
    strncpy( tstrDestination, strSource, cchDestChar ); 
    tstrDestination[cchDestChar-1] = '\0'; 
    return S_OK; 
#endif     
} 
HRESULT DXUtil_ConvertWideStringToGenericCch( TCHAR* tstrDestination, const WCHAR* wstrSource,  
                                           int cchDestChar ) 
{ 
    if( tstrDestination==NULL || wstrSource==NULL || cchDestChar < 1 ) 
        return E_INVALIDARG; 
#ifdef _UNICODE 
    wcsncpy( tstrDestination, wstrSource, cchDestChar ); 
    tstrDestination[cchDestChar-1] = L'\0';     
    return S_OK; 
#else 
    return DXUtil_ConvertWideStringToAnsiCch( tstrDestination, wstrSource, cchDestChar ); 
#endif 
} 
VOID DXUtil_LaunchReadme( HWND hWnd, TCHAR* strLoc ) 
{ 
#ifdef UNDER_CE 
     
    MessageBox( hWnd, TEXT("For operating instructions, please open the ") 
                      TEXT("readme.txt file included with the project."), 
                TEXT("DirectX SDK Sample"), MB_ICONWARNING | MB_OK ); 
    return; 
#else  
    bool bSuccess = false; 
    bool bFound = false; 
    TCHAR strReadmePath[1024]; 
    TCHAR strExeName[MAX_PATH]; 
    TCHAR strExePath[MAX_PATH]; 
    TCHAR strSamplePath[MAX_PATH]; 
    TCHAR* strLastSlash = NULL; 
    lstrcpy( strReadmePath, TEXT("") ); 
    lstrcpy( strExePath, TEXT("") ); 
    lstrcpy( strExeName, TEXT("") ); 
    lstrcpy( strSamplePath, TEXT("") ); 
     
    if( strLoc ) 
    { 
        HKEY  hKey; 
        LONG lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE, 
                                    _T("Software\\Microsoft\\DirectX SDK"), 
                                    0, KEY_READ, &hKey ); 
        if( ERROR_SUCCESS == lResult ) 
        { 
            DWORD dwType; 
            DWORD dwSize = MAX_PATH * sizeof(TCHAR); 
            lResult = RegQueryValueEx( hKey, _T("DX9SDK Samples Path"), NULL, 
                                      &dwType, (BYTE*)strSamplePath, &dwSize ); 
            strSamplePath[MAX_PATH-1] = 0;  
             
            if( ERROR_SUCCESS == lResult ) 
            { 
                _sntprintf( strReadmePath, 1023, TEXT("%s\\C++\\%s\\readme.txt"),  
                            strSamplePath, strLoc ); 
                strReadmePath[1023] = 0; 
                if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF ) 
                    bFound = TRUE; 
            } 
        } 
        RegCloseKey( hKey ); 
    } 
     
    GetModuleFileName( NULL, strExePath, MAX_PATH ); 
    strExePath[MAX_PATH-1]=0; 
    strLastSlash = _tcsrchr( strExePath, TEXT('\\') ); 
    if( strLastSlash ) 
    { 
        _tcsncpy( strExeName, &strLastSlash[1], MAX_PATH ); 
        strExeName[MAX_PATH-1]=0; 
         
        *strLastSlash = 0; 
         
        strLastSlash = _tcsrchr( strExeName, TEXT('.') ); 
        if( strLastSlash ) 
            *strLastSlash = 0; 
    } 
    if( !bFound ) 
    { 
         
        _tcscpy( strReadmePath, strExePath ); 
        strLastSlash = _tcsrchr( strReadmePath, TEXT('\\') ); 
        if( strLastSlash ) 
            *strLastSlash = 0; 
        lstrcat( strReadmePath, TEXT("\\") ); 
        lstrcat( strReadmePath, strExeName ); 
        lstrcat( strReadmePath, TEXT("\\readme.txt") ); 
        if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF ) 
            bFound = TRUE; 
    } 
    if( !bFound ) 
    { 
         
        _tcscpy( strReadmePath, strExePath ); 
        lstrcat( strReadmePath, TEXT("\\readme.txt") ); 
        if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF ) 
            bFound = TRUE; 
    } 
    if( !bFound ) 
    { 
         
        _tcscpy( strReadmePath, strExePath ); 
        strLastSlash = _tcsrchr( strReadmePath, TEXT('\\') ); 
        if( strLastSlash ) 
            *strLastSlash = 0; 
        lstrcat( strReadmePath, TEXT("\\readme.txt") ); 
        if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF ) 
            bFound = TRUE; 
    } 
    if( !bFound ) 
    { 
         
        _tcscpy( strReadmePath, strExePath ); 
        strLastSlash = _tcsrchr( strReadmePath, TEXT('\\') ); 
        if( strLastSlash ) 
            *strLastSlash = 0; 
        strLastSlash = _tcsrchr( strReadmePath, TEXT('\\') ); 
        if( strLastSlash ) 
            *strLastSlash = 0; 
        lstrcat( strReadmePath, TEXT("\\readme.txt") ); 
        if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF ) 
            bFound = TRUE; 
    } 
    if( bFound ) 
    { 
         
         
        LPShellExecute pShellExecute = NULL; 
        HINSTANCE hInstShell32 = LoadLibrary(TEXT("shell32.dll")); 
        if (hInstShell32 != NULL) 
        { 
#ifdef UNICODE 
            pShellExecute = (LPShellExecute)GetProcAddress(hInstShell32, _TWINCE("ShellExecuteW")); 
#else 
            pShellExecute = (LPShellExecute)GetProcAddress(hInstShell32, _TWINCE("ShellExecuteA")); 
#endif 
            if( pShellExecute != NULL ) 
            { 
                if( pShellExecute( hWnd, TEXT("open"), strReadmePath, NULL, NULL, SW_SHOW ) > (HINSTANCE) 32 ) 
                    bSuccess = true; 
            } 
            FreeLibrary(hInstShell32); 
        } 
    } 
    if( !bSuccess ) 
    { 
         
        MessageBox( hWnd, TEXT("Could not find readme.txt"),  
                    TEXT("DirectX SDK Sample"), MB_ICONWARNING | MB_OK ); 
    } 
#endif  
} 
VOID DXUtil_Trace( TCHAR* strMsg, ... ) 
{ 
#if defined(DEBUG) | defined(_DEBUG) 
    TCHAR strBuffer[512]; 
     
    va_list args; 
    va_start(args, strMsg); 
    _vsntprintf( strBuffer, 512, strMsg, args ); 
    va_end(args); 
    OutputDebugString( strBuffer ); 
#else 
    UNREFERENCED_PARAMETER(strMsg); 
#endif 
} 
HRESULT DXUtil_ConvertStringToGUID( const TCHAR* strSrc, GUID* pGuidDest ) 
{ 
    UINT aiTmp[10]; 
    if( _stscanf( strSrc, TEXT("{%8X-%4X-%4X-%2X%2X-%2X%2X%2X%2X%2X%2X}"), 
                    &pGuidDest->Data1,  
                    &aiTmp[0], &aiTmp[1],  
                    &aiTmp[2], &aiTmp[3], 
                    &aiTmp[4], &aiTmp[5], 
                    &aiTmp[6], &aiTmp[7], 
                    &aiTmp[8], &aiTmp[9] ) != 11 ) 
    { 
        ZeroMemory( pGuidDest, sizeof(GUID) ); 
        return E_FAIL; 
    } 
    else 
    { 
        pGuidDest->Data2       = (USHORT) aiTmp[0]; 
        pGuidDest->Data3       = (USHORT) aiTmp[1]; 
        pGuidDest->Data4[0]    = (BYTE) aiTmp[2]; 
        pGuidDest->Data4[1]    = (BYTE) aiTmp[3]; 
        pGuidDest->Data4[2]    = (BYTE) aiTmp[4]; 
        pGuidDest->Data4[3]    = (BYTE) aiTmp[5]; 
        pGuidDest->Data4[4]    = (BYTE) aiTmp[6]; 
        pGuidDest->Data4[5]    = (BYTE) aiTmp[7]; 
        pGuidDest->Data4[6]    = (BYTE) aiTmp[8]; 
        pGuidDest->Data4[7]    = (BYTE) aiTmp[9]; 
        return S_OK; 
    } 
} 
HRESULT DXUtil_ConvertGUIDToStringCch( const GUID* pGuidSrc, TCHAR* strDest, int cchDestChar ) 
{ 
    int nResult = _sntprintf( strDest, cchDestChar, TEXT("{%0.8X-%0.4X-%0.4X-%0.2X%0.2X-%0.2X%0.2X%0.2X%0.2X%0.2X%0.2X}"), 
               pGuidSrc->Data1, pGuidSrc->Data2, pGuidSrc->Data3, 
               pGuidSrc->Data4[0], pGuidSrc->Data4[1], 
               pGuidSrc->Data4[2], pGuidSrc->Data4[3], 
               pGuidSrc->Data4[4], pGuidSrc->Data4[5], 
               pGuidSrc->Data4[6], pGuidSrc->Data4[7] ); 
    if( nResult < 0 ) 
        return E_FAIL; 
    return S_OK; 
} 
CArrayList::CArrayList( ArrayListType Type, UINT BytesPerEntry ) 
{ 
    if( Type == AL_REFERENCE ) 
        BytesPerEntry = sizeof(void*); 
    m_ArrayListType = Type; 
    m_pData = NULL; 
    m_BytesPerEntry = BytesPerEntry; 
    m_NumEntries = 0; 
    m_NumEntriesAllocated = 0; 
} 
CArrayList::~CArrayList( void ) 
{ 
    if( m_pData != NULL ) 
        delete[] m_pData; 
} 
HRESULT CArrayList::Add( void* pEntry ) 
{ 
    if( m_BytesPerEntry == 0 ) 
        return E_FAIL; 
    if( m_pData == NULL || m_NumEntries + 1 > m_NumEntriesAllocated ) 
    { 
        void* pDataNew; 
        UINT NumEntriesAllocatedNew; 
        if( m_NumEntriesAllocated == 0 ) 
            NumEntriesAllocatedNew = 16; 
        else 
            NumEntriesAllocatedNew = m_NumEntriesAllocated * 2; 
        pDataNew = new BYTE[NumEntriesAllocatedNew * m_BytesPerEntry]; 
        if( pDataNew == NULL ) 
            return E_OUTOFMEMORY; 
        if( m_pData != NULL ) 
        { 
            CopyMemory( pDataNew, m_pData, m_NumEntries * m_BytesPerEntry ); 
            delete[] m_pData; 
        } 
        m_pData = pDataNew; 
        m_NumEntriesAllocated = NumEntriesAllocatedNew; 
    } 
    if( m_ArrayListType == AL_VALUE ) 
        CopyMemory( (BYTE*)m_pData + (m_NumEntries * m_BytesPerEntry), pEntry, m_BytesPerEntry ); 
    else 
        *(((void**)m_pData) + m_NumEntries) = pEntry; 
    m_NumEntries++; 
    return S_OK; 
} 
void CArrayList::Remove( UINT Entry ) 
{ 
     
    m_NumEntries--; 
     
    BYTE* pData = (BYTE*)m_pData + (Entry * m_BytesPerEntry); 
     
    MoveMemory( pData, pData + m_BytesPerEntry, ( m_NumEntries - Entry ) * m_BytesPerEntry ); 
} 
void* CArrayList::GetPtr( UINT Entry ) 
{ 
    if( m_ArrayListType == AL_VALUE ) 
        return (BYTE*)m_pData + (Entry * m_BytesPerEntry); 
    else 
        return *(((void**)m_pData) + Entry); 
} 
bool CArrayList::Contains( void* pEntryData ) 
{ 
    for( UINT iEntry = 0; iEntry < m_NumEntries; iEntry++ ) 
    { 
        if( m_ArrayListType == AL_VALUE ) 
        { 
            if( memcmp( GetPtr(iEntry), pEntryData, m_BytesPerEntry ) == 0 ) 
                return true; 
        } 
        else 
        { 
            if( GetPtr(iEntry) == pEntryData ) 
                return true; 
        } 
    } 
    return false; 
} 
HRESULT DXUtil_ConvertAnsiStringToWideCb( WCHAR* wstrDestination, const CHAR* strSource, int cbDestChar ) 
{ 
    return DXUtil_ConvertAnsiStringToWideCch( wstrDestination, strSource, cbDestChar / sizeof(WCHAR) ); 
} 
HRESULT DXUtil_ConvertWideStringToAnsiCb( CHAR* strDestination, const WCHAR* wstrSource, int cbDestChar ) 
{ 
    return DXUtil_ConvertWideStringToAnsiCch( strDestination, wstrSource, cbDestChar / sizeof(CHAR) ); 
} 
HRESULT DXUtil_ConvertGenericStringToAnsiCb( CHAR* strDestination, const TCHAR* tstrSource, int cbDestChar ) 
{ 
    return DXUtil_ConvertGenericStringToAnsiCch( strDestination, tstrSource, cbDestChar / sizeof(CHAR) ); 
} 
HRESULT DXUtil_ConvertGenericStringToWideCb( WCHAR* wstrDestination, const TCHAR* tstrSource, int cbDestChar ) 
{ 
    return DXUtil_ConvertGenericStringToWideCch( wstrDestination, tstrSource, cbDestChar / sizeof(WCHAR) ); 
} 
HRESULT DXUtil_ConvertAnsiStringToGenericCb( TCHAR* tstrDestination, const CHAR* strSource, int cbDestChar ) 
{ 
    return DXUtil_ConvertAnsiStringToGenericCch( tstrDestination, strSource, cbDestChar / sizeof(TCHAR) ); 
} 
HRESULT DXUtil_ConvertWideStringToGenericCb( TCHAR* tstrDestination, const WCHAR* wstrSource, int cbDestChar ) 
{ 
    return DXUtil_ConvertWideStringToGenericCch( tstrDestination, wstrSource, cbDestChar / sizeof(TCHAR) ); 
} 
HRESULT DXUtil_ReadStringRegKeyCb( HKEY hKey, TCHAR* strRegName, TCHAR* strDest, DWORD cbDest, TCHAR* strDefault ) 
{ 
    return DXUtil_ReadStringRegKeyCch( hKey, strRegName, strDest, cbDest / sizeof(TCHAR), strDefault ); 
} 
HRESULT DXUtil_ConvertGUIDToStringCb( const GUID* pGuidSrc, TCHAR* strDest, int cbDestChar ) 
{ 
    return DXUtil_ConvertGUIDToStringCch( pGuidSrc, strDest, cbDestChar / sizeof(TCHAR) ); 
} 
#ifndef UNDER_CE 
HRESULT DXUtil_GetDXSDKMediaPathCb( TCHAR* szDest, int cbDest ) 
{ 
    return DXUtil_GetDXSDKMediaPathCch( szDest, cbDest / sizeof(TCHAR) ); 
} 
HRESULT DXUtil_FindMediaFileCb( TCHAR* szDestPath, int cbDest, TCHAR* strFilename ) 
{ 
    return DXUtil_FindMediaFileCch( szDestPath, cbDest / sizeof(TCHAR), strFilename ); 
} 
#endif