hxwinver.cpp

linux下的一款播放器

 *      const char* HXGetOSName( ULONG32 nPlatformID)
 *
 *  PARAMETERS:
 *              nPlatformID:    A platformID (defined in hxwinver.h)
 *
 *  DESCRIPTION:
 *              Returns an OS string. Indicates the OS, not the build of
 *      the player.
 *
 *  RETURNS:
 *              pointer to static const buffer containing OS string.
 */
const char* HXGetOSName(ULONG32 nPlatformID)
{
    const char* strResult = NULL;

    switch (nPlatformID)
    {
       case (HX_PLATFORM_WIN16) :
           strResult="Win16";
           break;

       case (HX_PLATFORM_WIN32S) :
           strResult="Win32S";
           break;

       case (HX_PLATFORM_WIN95) :
           strResult="Win95";
           break;

       case (HX_PLATFORM_WIN98) :
           strResult="Win98";
           break;

       case (HX_PLATFORM_WINNT) :
           strResult="WinNT";
           break;

       case (HX_PLATFORM_MACOT) :
           strResult="MacOT";
           break;

       case (HX_PLATFORM_MACTCP) :
           strResult="MacTCP";
           break;

       case (HX_PLATFORM_LINUX) :
           strResult="Linux";
           break;

       case (HX_PLATFORM_SOLARIS) :
           strResult="Solaris";
           break;

       case (HX_PLATFORM_IRIX) :
           strResult="Irix";
           break;

       case (HX_PLATFORM_SUNOS) :
           strResult="SunOS";
           break;

       case (HX_PLATFORM_SYMBIAN):
           strResult="Symbian";
           break;

       case (HX_PLATFORM_UNKNOWN) :
       default:
           strResult="UNK";
           break;
    }

    return(strResult);
}


/*
 *      const char* HXGetMachName(ULONG32 nMachineType)
 *
 *  PARAMETERS:
 *              nMachineType:   A machine ID (defined in hxwinver.h)
 *
 *  DESCRIPTION:
 *              Returns a Machine string. Indicates the installed CPU,
 *      not the build of the player.
 *
 *  RETURNS:
 *              pointer to static const buffer containing Machine string.
 */
const char* HXGetMachName(ULONG32 nMachineType)
{
    const char* pProcName = NULL;

    switch (nMachineType)
    {
       case HX_MACHINE_486:
           pProcName = "486";
           break;

       case HX_MACHINE_586:
           pProcName = "586";
           break;

       case HX_MACHINE_686:
           pProcName = "686";
           break;

       case HX_MACHINE_PPC:
           pProcName = "PPC";
           break;

       case HX_MACHINE_68K:
           pProcName = "68K";
           break;

       case HX_MACHINE_ALPHA:
           pProcName = "Alpha";
           break;

       case HX_MACHINE_MIPS:
           pProcName = "Mips";
           break;

       case HX_MACHINE_SPARC:
           pProcName = "Sparc";
           break;

       case HX_MACHINE_TOOSLOW:
           pProcName = "SLOW";
           break;

       case HX_MACHINE_ARM:
           pProcName = "ARM";
           break;

       case HX_MACHINE_SYMEMULATOR:
           pProcName = "SymbianEmulator";
           break;
 
       case HX_MACHINE_UNKNOWN:
       default:
           pProcName = "UNK";
           break;
    }

    return(pProcName);
}

/*
 *      const char* HXGetVerEncodedName( HXVERSIONINFO* pVersionInfo,
 *                                      const char* pProductName, const char* pProductVer,
 *                                      const char* pDistCode)
 *
 *  PARAMETERS:
 *              pVersionInfo :  A pointer to the version info struct to receive the
 *                                              results.
 *
 *              pProductName :  A pointer to the name of the product like play16 for
 *                                              the 16bit compiled player or plug32 for the 32bit
 *                                              compiled plugin.
 *
 *              pProductVer :   A pointer to the string form of the version of the
 *                                              product like 2.0b3.
 *
 *              pDistCode       :       A pointer to the string form of the version of the
 *                                              distribution code like PN01 for the player.
 *
 *  DESCRIPTION:    

 *              Returns a standard formatted encoded platform string.
 *
 *  RETURNS:
 *              pointer to temporary buffer containing the encoded string.
 */
const char* HXGetVerEncodedName
(
    HXVERSIONINFO* pVersionInfo,
    const char* pProductName,
    const char* pProductVer,
    const char* pLanguage,
    const char* pDistCode
    )
{
#if defined(HELIX_CONFIG_NOSTATICS)
    static const char _szEncodedName = '\0';
    char*& szEncodedName = HXGlobalCharArray::Get(&_szEncodedName, MAX_ENCODED_NAME, "" );
#else
    static char szEncodedName[MAX_ENCODED_NAME]; /* Flawfinder: ignore */
#endif        

    HX_ASSERT_VALID_READ_PTR(pVersionInfo);
    HX_ASSERT_VALID_READ_PTR(pProductName);
    HX_ASSERT_VALID_READ_PTR(pProductVer);
    HX_ASSERT_VALID_READ_PTR(pLanguage);
    HX_ASSERT_VALID_READ_PTR(pDistCode);

    const char* pOSName = "UNK";
    const char* pProcName = "UNK";

    // Calculate OS Name from
    pOSName = HXGetOSName(pVersionInfo->dwPlatformId);

    // CPU/Process/machine. same thing...
    pProcName = HXGetMachName(pVersionInfo->dwMachineType);

#ifdef _MACINTOSH
    // Macintosh OS version currently includes a wReleaseVersion number.
    SafeSprintf(szEncodedName,MAX_ENCODED_NAME,"%s_%d.%d.%d_%s_%s_%s_%s_%s%s",
                pOSName,
                pVersionInfo->wMajorVersion,
                pVersionInfo->wMinorVersion,
                pVersionInfo->wReleaseVersion,
                pProductVer,
                pProductName,
                pDistCode,
                pLanguage,
                pProcName,
                (pVersionInfo->bFPUAvailable ? "" : "_No-FPU")
                );
#else
    // WINDOWS and UNIX
    SafeSprintf(szEncodedName,MAX_ENCODED_NAME, "%s_%d.%d_%s_%s_%s_%s_%s%s",
                pOSName,
                pVersionInfo->wMajorVersion,
                pVersionInfo->wMinorVersion,
                pProductVer,
                pProductName,
                pDistCode,
                pLanguage,
                pProcName,
                (pVersionInfo->bFPUAvailable ? "" : "_No-FPU")
                );

#endif

    return szEncodedName;
};

//      Code From:
//
//      PSS ID Number: Q124207
//
//      Authored 21-Dec-1994                    Last modified 05-Jan-1995
//
//      The information in this article applies to:
//
//      - Microsoft Win32 Software Development Kit (SDK) for Windows NT
//      versions 3.1 and 3.5
#if defined(_WIN32) 
BOOL IsCoProcessorPresentInWinNT(void)
{
#if !defined(WIN32_PLATFORM_PSPC)
    HKEY hKey;
    SYSTEM_INFO SystemInfo;
    
    // return FALSE if we are not running under Windows NT
    // this should be expanded to cover alternative Win32 platforms
    
    if(!(GetVersion() & 0x7FFFFFFF))
    {
        return(FALSE); // We can't tell, assume it doesn't
    }
    
    // we return TRUE if we're not running on x86
    // other CPUs have built in floating-point, with no registry entry
    GetSystemInfo(&SystemInfo);
    if(SystemInfo.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_INTEL)
    {
        return(TRUE);
    }

    if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                    "HARDWARE\\DESCRIPTION\\System\\FloatingPointProcessor",
                    0,
                    KEY_EXECUTE,
                    &hKey) != ERROR_SUCCESS)
    {

        // GetLastError() will indicate ERROR_RESOURCE_DATA_NOT_FOUND
        // if we can't find the key.  This indicates no coprocessor present
        return(FALSE);
    }

    RegCloseKey(hKey);
    return(TRUE);
#else /*!defined(WIN32_PLATFORM_PSPC) */
    return FALSE;
#endif /* !defined(WIN32_PLATFORM_PSPC) */
}
#endif

///////////////////////////////////////////////////////////////////////
//
//      FUNCTION:
//
//              HXExtractDistributionCode()
//
//      Description:
//
//              Extracts the distribution code resource from the version
//              information of the module.
//
//
BOOL HXExtractDistributionCode(char* pDistBuffer, UINT32 ulDistBufferLen, void* hMod)
{
    BOOL        bOk = FALSE;

#if (defined(_WIN32) || defined(_WINDOWS)) && !defined(WIN32_PLATFORM_PSPC)
    // load version.dll
    HINSTANCE               hLib = NULL;
    VERQUERYVALUE           _pVerQueryValue = NULL;
    GETFILEVERSIONINFO      _pGetFileVersionInfo = NULL;
    GETFILEVERSIONINFOSIZE  _pGetFileVersionInfoSize = NULL;

    if (hLib = HXLoadLibrary("version.dll"))
    {
        _pVerQueryValue = (VERQUERYVALUE)GetProcAddress(hLib, "VerQueryValueA");
        _pGetFileVersionInfo = (GETFILEVERSIONINFO)GetProcAddress(hLib, "GetFileVersionInfoA");
        _pGetFileVersionInfoSize = (GETFILEVERSIONINFOSIZE)GetProcAddress(hLib, "GetFileVersionInfoSizeA");
    }

    if (_pVerQueryValue         &&
        _pGetFileVersionInfo    &&
        _pGetFileVersionInfoSize)
    {
        HINSTANCE hModule = (HINSTANCE)(long)hMod;

        DWORD   dwVerInfoSize;
        DWORD   dwVerHnd;
        char    szFullPath[_MAX_PATH+1]; /* Flawfinder: ignore */

        if (GetModuleFileName(hModule,szFullPath, _MAX_PATH))
        {

            dwVerInfoSize = _pGetFileVersionInfoSize(szFullPath, &dwVerHnd);

            if (dwVerInfoSize)
            {
                LPSTR   lpstrVffInfo;             // Pointer to block to hold info
                HANDLE  hMem;                     // handle to mem alloc'ed

                // Get a block big enough to hold version info
                hMem          = GlobalAlloc(GMEM_MOVEABLE, dwVerInfoSize);
                lpstrVffInfo  = (char *)GlobalLock(hMem);

                if(_pGetFileVersionInfo(szFullPath, dwVerHnd, dwVerInfoSize, lpstrVffInfo ))
                {
                    char    szGetName[_MAX_PATH]; /* Flawfinder: ignore */
                    UINT    VersionLen;
                    LPSTR   lpVersion;
                    BOOL    bRetCode;

                    SafeStrCpy(szGetName, "\\VarFileInfo\\Translation", _MAX_PATH);
                    bRetCode = _pVerQueryValue(lpstrVffInfo, szGetName,
                                               (void FAR* FAR*)&lpVersion, &VersionLen);

                    char TransNumber[10]; /* Flawfinder: ignore */
                    wsprintf(TransNumber, "%8lx", *(long *)lpVersion);
                    char *pSpace = HXFindChar(TransNumber, ' ');
                    while(pSpace)
                    {
                        *pSpace = '0';
                        pSpace = (char*)HXFindChar(TransNumber, ' ');
                    }

                    SafeStrCpy(szGetName, "\\StringFileInfo\\", _MAX_PATH);
                    SafeStrCat(szGetName, TransNumber + 4, _MAX_PATH);
                    TransNumber[4] = 0;
                    SafeStrCat(szGetName, TransNumber, _MAX_PATH);
                    SafeStrCat(szGetName, "\\DistCode", _MAX_PATH);

                    bRetCode = _pVerQueryValue(lpstrVffInfo, szGetName,
                                               (void FAR* FAR*)&lpVersion, &VersionLen);

                    if ( bRetCode && VersionLen && lpVersion)
                    {
                        SafeStrCpy(pDistBuffer,lpVersion, ulDistBufferLen);
                        bOk = TRUE;
                    }
                }

                // Let go of the memory
                GlobalUnlock(hMem);
                GlobalFree(hMem);
            }
        }

        if (!bOk)
        {
            SafeStrCpy(pDistBuffer,"UNK", ulDistBufferLen);
        }
    }

    HXFreeLibrary("version.dll");

#elif defined (_MACINTOSH)
    // dist code stored in STR 1000 resource of application
    INT16 strResId = 1000;
    StringHandle hStr = ::GetString(strResId);
    if (hStr)
    {
        if ((*hStr)[0] < ulDistBufferLen)
        {
            strncpy(pDistBuffer,(char*)*hStr+1,(*hStr)[0]); /* Flawfinder: ignore */
            pDistBuffer[(*hStr)[0]] = 0;
        }
        ::ReleaseResource((Handle)hStr);
        bOk = TRUE;
    }
    else
    {
        SafeStrCpy(pDistBuffer,"UNK", ulDistBufferLen);
    }
    
#endif // defined(_WIN32) || defined(_WINDOWS)

    return bOk;
}



#if defined(_MACINTOSH) || defined(_MAC_UNIX)

// Support functions for HXGetWinVer for Macintosh

#if !defined(_CARBON) && !defined(_MAC_UNIX) // Carbon code runs only on PPC processors with OT so runtime checks are pointless
BOOL
HasOpenTransport (void)
{
    OSErr   theErr = noErr;
    LONG32  result;
    Boolean hasOT = FALSE;

    theErr = Gestalt(gestaltOpenTpt, &result);
    hasOT = theErr == noErr &&
        (result & gestaltOpenTptPresentMask) != 0 &&
        (result & gestaltOpenTptTCPPresentMask) != 0;

    return hasOT;
}

BOOL
HasFPU(void)
{
    long    theFPU;

    /* Determine the coprocessor type */
    Gestalt(gestaltFPUType, &theFPU);

    if(theFPU == gestaltNoFPU)
        return FALSE;

    return TRUE;

}

BOOL
IsPPC(void) {
    long    theCPU;
    Gestalt(gestaltNativeCPUtype, &theCPU);
    if (theCPU >= gestaltCPU601) return(TRUE);
    return(FALSE);
}
#endif // !_CARBON

static UINT16 
BCDtoDecimal(UINT16 bcd)
{
    UINT16 decimal;
    decimal =            1 * ((bcd & 0x000F) >> 0)
        +   10 * ((bcd & 0x00F0) >> 4) 
        +  100 * ((bcd & 0x0F00) >> 8) 
        + 1000 * ((bcd & 0xF000) >> 12); 
    return decimal;
}

void
GetMacSystemVersion(UINT16 *major, UINT16 *minor, UINT16 *release)
{
    long    gestVer;
    UINT16  ver, bigRev, littleRev;

    OSErr err = Gestalt(gestaltSystemVersion, &gestVer); // returns a BCD number, like 0x00001015 for 10.1.5
    if (err == noErr)
    {
        ver =       BCDtoDecimal((gestVer & 0x0000FF00) >> 8);
        bigRev =    BCDtoDecimal((gestVer & 0x000000F0) >> 4);
        littleRev = BCDtoDecimal((gestVer & 0x0000000F));
    }
    else
    {
        ver = bigRev = littleRev = 0;
    }
        
//don't want to include mathlib in plugin
//      ::sprintf(s,"%ld.%ld.%ld",ver,majorRev,minorRev);
//      ver += 0x30; majorRev += 0x30; minorRev += 0x30;  // GR 7/4/02 why was this converting to ascii? (the conversion would fail for numbers over 9 anyway)

    if (major)      *major = ver;
    if (minor)      *minor = bigRev;
    if (release)    *release = littleRev;
}


#endif // _MACINTOSH