hxcleng.cpp

linux下的一款播放器

#if defined(HELIX_FEATURE_PROXYMGR)
    || !m_pProxyManager 
#endif /* HELIX_FEATURE_PROXYMGR */
#if defined(HELIX_FEATURE_SMARTERNETWORK)
    || !m_pPreferredTransportManager
#endif /* HELIX_FEATURE_SMARTERNETWORK */
    )
    {
    m_LastError = HXR_OUTOFMEMORY;
    }

    if (!m_LastError)
    {
#ifdef _MEDIUM_BLOCK
    m_pAllocator->AddRef();
#endif
    HX_ADDREF(m_pCommonClassFactory);
    HX_ADDREF(m_pScheduler);
#if defined(HELIX_FEATURE_OPTIMIZED_SCHEDULER)
    HX_ADDREF(m_pOptimizedScheduler);
#endif /* HELIX_FEATURE_OPTIMIZED_SCHEDULER */
#if defined(HELIX_FEATURE_PREFERENCES)
    HX_ADDREF(m_pOrigPreferences);
#endif /* HELIX_FEATURE_PREFERENCES */
#if defined(HELIX_FEATURE_REGISTRY)
    HX_ADDREF(m_pRegistry);
#endif /* HELIX_FEATURE_REGISTRY */
#if defined(HELIX_FEATURE_PLAYBACK_NET)
    HX_ADDREF(m_pOrigNetworkServices);
#endif /* HELIX_FEATURE_PLAYBACK_NET */
#if defined(HELIX_FEATURE_HYPER_NAVIGATE)
    HX_ADDREF(m_pOrigHyperNavigate);
#endif /* HELIX_FEATURE_HYPER_NAVIGATE */
#if defined(HELIX_FEATURE_ASM)
    HX_ADDREF(m_pASM);
#endif /* HELIX_FEATURE_ASM */
    HX_ADDREF(m_pPlayerSinkControl);
#if defined(HELIX_FEATURE_AUTHENTICATION)
    HX_ADDREF(m_pCredentialsCache);
#endif /* HELIX_FEATURE_AUTHENTICATION */
#if defined(HELIX_FEATURE_XMLPARSER)
    HX_ADDREF(m_pXMLParser);
#endif /* HELIX_FEATURE_XMLPARSER */
#if defined(HELIX_FEATURE_SYSTEMREQUIRED)
    HX_ADDREF(m_pSystemRequired);
#endif /* HELIX_FEATURE_SYSTEMREQUIRED */
#if defined(HELIX_FEATURE_PROXYMGR)
    HX_ADDREF(m_pProxyManager);
#endif /* HELIX_FEATURE_PROXYMGR */
#if defined(HELIX_FEATURE_SMARTERNETWORK)
    HX_ADDREF(m_pPreferredTransportManager);
#endif /* HELIX_FEATURE_SMARTERNETWORK */
#if defined(HELIX_FEATURE_OVERLAYMGR)
    HX_ADDREF(m_pOverlayManager);
#endif /* HELIX_FEATURE_OVERLAYMGR */

#if defined(HELIX_FEATURE_HYPER_NAVIGATE)
#if !defined(_WINCE) || (_WIN32_WCE >= 400)
    m_pOrigHyperNavigate->QueryInterface(IID_IHXHyperNavigate, 
                         (void**) &m_pHyperNavigate);
#endif
#endif /* defined(HELIX_FEATURE_HYPER_NAVIGATE) */
#if defined(HELIX_FEATURE_PREFERENCES)
    if (m_pOrigPreferences)
    {
	m_pOrigPreferences->QueryInterface(IID_IHXPreferences, 
					   (void**) &m_pPreferences);
    }
#endif /* HELIX_FEATURE_PREFERENCES */
#if defined(HELIX_FEATURE_PLAYBACK_NET)
    m_pOrigNetworkServices->QueryInterface(IID_IHXNetworkServices, 
                         (void**) &m_pNetworkServices);
#endif /* HELIX_FEATURE_PLAYBACK_NET */
    }

    if (!m_LastError)
    {
    // Assemble registry's key for the preferences 
    char* pCompanyName = new char[strlen(HXVER_COMMUNITY) + 1];
    strcpy(pCompanyName, HXVER_COMMUNITY); /* Flawfinder: ignore */

    char* pProductName = new char[strlen(HXVER_SDK_PRODUCT) + 1];
    strcpy(pProductName, HXVER_SDK_PRODUCT); /* Flawfinder: ignore */

    const ULONG32 nProdMajorVer = TARVER_MAJOR_VERSION;
    const ULONG32 nProdMinorVer = TARVER_MINOR_VERSION;

    char * pComa = HXFindChar(pCompanyName, ',');
    if(pComa)
    {
        *pComa = 0;   
    }

    pComa = HXFindChar(pProductName, ',');
    if(pComa)
    {
        *pComa = 0;   
    }

#if defined(HELIX_FEATURE_PREFERENCES)
#if defined(HELIX_FEATURE_NO_INTERNAL_PREFS)
    HX_RESULT theErr = HXR_OK;
#elif defined(HELIX_FEATURE_LITEPREFS)
    HX_RESULT theErr = m_pOrigPreferences->Open( 
        (const char*) pCompanyName, (const char*) pProductName, nProdMajorVer, nProdMinorVer);
    if( theErr != HXR_OUTOFMEMORY )
    {
       // HXR_FAIL probably just means the prefs file does not exist. We will
       // auto-create it when we do our first write.
       theErr = HXR_OK;
    }
#else
    HX_RESULT theErr = m_pOrigPreferences->OpenUserPref( 
        (const char*) pCompanyName, (const char*) pProductName, nProdMajorVer, nProdMinorVer);
#endif

    if (theErr)
    {
        HX_RELEASE(m_pOrigPreferences);
        HX_RELEASE(m_pPreferences);
    }

    // Read any paths from preferences that weren't set by our loader
    if (HXR_OK == theErr && m_pOrigPreferences)
    {
        ReadUnsetPathsFromPrefs();
    }
#endif /* HELIX_FEATURE_PREFERENCES */

    HX_VECTOR_DELETE(pCompanyName);
    HX_VECTOR_DELETE(pProductName);

#ifndef _VXWORKS
    // Set the Plugin and Codec directories if they are not yet set
    if (!GetDLLAccessPath()->GetPath(DLLTYPE_PLUGIN))
    {
        CreatePluginDir();
    }
    if (!GetDLLAccessPath()->GetPath(DLLTYPE_CODEC))
    {
        CreateCodecDir();
    }
#endif // _VXWORKS
    }

    if (!m_LastError)
    {
#if defined(_STATICALLY_LINKED) || !defined(HELIX_FEATURE_PLUGINHANDLER2)
#if defined(HELIX_CONFIG_CONSOLIDATED_CORE)
    m_pPlugin2Handler = new BaseHandler();
#else /* HELIX_CONFIG_CONSOLIDATED_CORE */
    m_pPlugin2Handler = new HXPluginManager();
#endif /* HELIX_CONFIG_CONSOLIDATED_CORE */
#else
    m_pPlugin2Handler = new Plugin2Handler();
#endif /* _STATICALLY_LINKED */

    if (m_pPlugin2Handler)
    {
        m_pPlugin2Handler->AddRef();
    }
    else
    {
        m_LastError = HXR_OUTOFMEMORY;
    }
    }

#if defined(HELIX_FEATURE_HYPER_NAVIGATE)
#if !defined(_WINCE) || (_WIN32_WCE >= 400)
    m_pOrigHyperNavigate->Init((IUnknown*) (IHXClientEngine*)this);
#endif
#endif /* defined(HELIX_FEATURE_HYPER_NAVIGATE) */

#ifdef _UNIX
    m_select_callbacks = new CHXSimpleList;
#endif

#if defined(HELIX_FEATURE_PLAYBACK_NET)
#ifdef THREADS_SUPPORTED
    /* Start network thread here */
    ThreadEngine::GetThreadEngine();
#endif /*THREADS_SUPPORTED*/
#endif /* HELIX_FEATURE_PLAYBACK_NET */

#if defined(_MACINTOSH) && defined(_CARBON) && defined(THREADS_SUPPORTED) && defined(HELIX_FEATURE_PREFERENCES)
    ReadPrefBOOL(m_pPreferences, "UseMacOptimizedBlitting", m_bUseMacBlitMutex);
#endif
}

HXClientEngine::~HXClientEngine() 
{
    Close();
}

void
HXClientEngine::CreatePrefIfNoExist(const char* pName, const char* pValue)
{
#if defined(HELIX_FEATURE_PREFERENCES)
    IHXBuffer* pBuffer = NULL;

    if (m_pPreferences && m_pPreferences->ReadPref(pName, pBuffer) != HXR_OK)
    {
    pBuffer = new CHXBuffer();
    pBuffer->AddRef();
    
    pBuffer->Set((const unsigned char*)pValue, strlen(pValue) + 1);     

    m_pPreferences->WritePref(pName, pBuffer);
    }
    HX_RELEASE(pBuffer);
#endif
}

void
HXClientEngine::CreatePluginDir()
{
#if !defined(_VXWORKS) && !defined(__TCS__)
    char pPluginDir[_MAX_PATH + 1] = ""; /* Flawfinder: ignore */

#ifdef _WINCE
    SafeStrCpy(pPluginDir, "\\", _MAX_PATH + 1);
#elif defined (_WINDOWS) || defined (_WIN32)    
    if (!GetSystemDirectory(pPluginDir, _MAX_PATH))
    {
        SafeStrCpy(pPluginDir, "", _MAX_PATH + 1);
    }

    if (strlen(pPluginDir) > 0 && pPluginDir[strlen(pPluginDir) - 1] != '\\')
    {
        SafeStrCat(pPluginDir, "\\", _MAX_PATH + 1);
    }

    SafeStrCat(pPluginDir, "Real", _MAX_PATH + 1);
#elif defined (_UNIX)
    SafeStrCpy(pPluginDir, getenv("HOME"), _MAX_PATH+1);
    SafeStrCat(pPluginDir, "/Real", _MAX_PATH+1 - strlen(pPluginDir));
#elif defined (_MACINTOSH)

    // xxxbobclark this assumes that the shared libraries live right
    // next to the executable. It's highly recommended that if you're
    // writing a TLC, you call SetPath yourself...
    SafeStrCpy(pPluginDir, "", _MAX_PATH + 1);

#endif // defined (_WINDOWS) || defined (_WIN32)

    // Set the Path
    GetDLLAccessPath()->SetPath(DLLTYPE_PLUGIN, pPluginDir);
#endif // _VXWORKS
}

void
HXClientEngine::CreateCodecDir()
{
#if !defined(_VXWORKS) && !defined(__TCS__)
    const char* pPath = NULL;
    CHXString codecDir;

    pPath = GetDLLAccessPath()->GetPath(DLLTYPE_PLUGIN);

    if (pPath) codecDir = pPath;

    // xxxbobclark this assumes that the codecs live right next
    // to the executable. It's highly recommended that if you're
    // writing a TLC, you call SetPath yourself...
#ifndef _MACINTOSH
    if (strcmp((const char*)codecDir.Right(1), OS_SEPARATOR_STRING))
    {
    codecDir += OS_SEPARATOR_STRING;
    }
    
    codecDir += "Codecs";
#endif

    // Set the Path
    GetDLLAccessPath()->SetPath(DLLTYPE_CODEC, (const char*)codecDir);
#endif // _VXWORKS
}

void HXClientEngine::_Initialize(void)
{
    IHXBuffer* pValue = NULL;    

#if defined(HELIX_FEATURE_AUDIO)
    if (!m_pAudioSession)
    {
        m_pAudioSession = NewAudioSession();
        if( !m_pAudioSession )
        {
            m_LastError = HXR_OUTOFMEMORY;
            return;
        }
        HX_ADDREF(m_pAudioSession);
    }
#endif /* HELIX_FEATURE_AUDIO */

    // Init IHXRegistry entries
    InitializeRegistry();

#if defined(HELIX_FEATURE_PREFERENCES)
    if (!m_LastError)
    {

#if !defined(HELIX_FEATURE_NO_INTERNAL_PREFS)
    if (m_pOrigPreferences)
    {
        m_pOrigPreferences->SetContext((IUnknown*) (IHXClientEngine*)this);
    }
#endif /* !defined(HELIX_FEATURE_NO_INTERNAL_PREFS) */

    // generate GUID if it doesn't exist
    BOOL bRegenerate = TRUE;

    if (m_pPreferences &&
	m_pPreferences->ReadPref(CLIENT_GUID_REGNAME, pValue) == HXR_OK)
    {
        char* pszGUID = DeCipher((char*)pValue->GetBuffer());
        if(pszGUID && strlen(pszGUID) == 36)
        bRegenerate = FALSE;

        HX_RELEASE(pValue);
        if(pszGUID)
        delete[] pszGUID;
    }

    if(bRegenerate)
    {
        CHXString strGUID;
        char* pszGUIDMangled = NULL;
        uuid_tt tmpGUID;
            CHXuuid newGUID;

            newGUID.GetUuid(&tmpGUID);
            if(CHXuuid::HXUuidToString((const uuid_tt*)&tmpGUID, &strGUID) == HXR_OK)
            {
        // mangle the GUID for protection
        pszGUIDMangled = Cipher((char*)strGUID.GetBuffer(strGUID.GetLength()));

        CHXBuffer* lpBuffer = new CHXBuffer();
           
        lpBuffer->AddRef();
        lpBuffer->Set((const unsigned char*)pszGUIDMangled, strlen(pszGUIDMangled)+1);

	if (m_pPreferences)
	{
	    m_pPreferences->WritePref(CLIENT_GUID_REGNAME, lpBuffer);
	}

        HX_RELEASE(lpBuffer);

        delete[] pszGUIDMangled;
            }
    }

    // create/initialize the preferences which don't exist  
    CreatePrefIfNoExist("AutoTransport", "1");
    CreatePrefIfNoExist("SendStatistics", "1");

    CreatePrefIfNoExist("AttemptRTSPvMulticast", "1");
    CreatePrefIfNoExist("AttemptRTSPvUDP", "1");
    CreatePrefIfNoExist("AttemptRTSPvTCP", "1");
    CreatePrefIfNoExist("AttemptRTSPvHTTP", "1");
    
    CreatePrefIfNoExist("RTSPProxySupport", "0");
    CreatePrefIfNoExist("RTSPProxyHost", "");
    CreatePrefIfNoExist("RTSPProxyPort", "554");

    CreatePrefIfNoExist("AttemptPNAvMulticast", "1");
    CreatePrefIfNoExist("AttemptPNAvUDP", "1");
    CreatePrefIfNoExist("AttemptPNAvTCP", "1");
    CreatePrefIfNoExist("AttemptPNAvHTTP", "1");
    
    CreatePrefIfNoExist("PNAProxySupport", "0");
    CreatePrefIfNoExist("PNAProxyHost", "");
    CreatePrefIfNoExist("PNAProxyPort", "1090");

    CreatePrefIfNoExist("HTTPProxySupport", "0");
    CreatePrefIfNoExist("HTTPProxyHost", "");
    CreatePrefIfNoExist("HTTPProxyPort", "80");

    InitPaths();

    UINT32 ulMinBandwidth = DEFAULT_MAX_BANDWIDTH;
    /* Add default min/max bandwidth */

    if (m_pPreferences)
    {
	m_pPreferences->ReadPref("Bandwidth", pValue);
	if (!pValue || (atoi((const char*)pValue->GetBuffer()) == 0))
	{
	    HX_RELEASE(pValue);
	    
	    pValue = new CHXBuffer();
	    pValue->AddRef();
	    
	    pValue->SetSize(15);    
	    sprintf((char*)pValue->GetBuffer(), "%lu", DEFAULT_MAX_BANDWIDTH); /* Flawfinder: ignore */
	    m_pPreferences->WritePref("Bandwidth", pValue);
	}
	
	ulMinBandwidth = ::atoi((const char*)pValue->GetBuffer());

	HX_RELEASE(pValue);
    }

    UINT32 ulMaxBandwidth = 0;
    ReadPrefINT32(m_pPreferences, "MaxBandwidth", ulMaxBandwidth);

    if (ulMaxBandwidth < ulMinBandwidth)
    {
        /* If we did read some value from the pref but somehow
         * it was set lower to the Bandwidth value, we make
         * it equal to the Bandwidth value...else set it
         * to the default max bandwdith value.
         */
        if (ulMaxBandwidth > 0)
        {
        ulMaxBandwidth = ulMinBandwidth;
        }
        else
        {
        ulMaxBandwidth = DEFAULT_MAX_BANDWIDTH;
        }

        HX_RELEASE(pValue);

        pValue = new CHXBuffer();
        pValue->AddRef();       
        pValue->SetSize(15);    

        if (ulMaxBandwidth < ulMinBandwidth)
        {
        ulMaxBandwidth = ulMinBandwidth;
        }
	
	if (m_pPreferences)
	{
	    sprintf((char*)pValue->GetBuffer(), "%lu", ulMaxBandwidth); /* Flawfinder: ignore */
	    m_pPreferences->WritePref("MaxBandwidth", pValue);
	}
    }

    HX_RELEASE(pValue);
    }    
#endif /* HELIX_FEATURE_PREFERENCES */

#if defined(_WIN32) || defined(THREADS_SUPPORTED)
    if (!m_bUseCoreThreadExternallySet)
    {
        ReadPrefBOOL(m_pPreferences, "UseCoreThread", m_bUseCoreThread);  
    }
#endif /*_WIN32*/

#if defined(HELIX_FEATURE_AUDIO)
    if (!m_LastError)
    {
    m_LastError = m_pAudioSession->Init((IUnknown*) (IHXClientEngine*)this);
    m_pAudioSession->SetCoreMutex(m_pCoreMutex);
    }
#endif /* HELIX_FEATURE_AUDIO */

#if defined(HELIX_FEATURE_OPTIMIZED_SCHEDULER)
    if (m_pOptimizedScheduler)
    {
	m_pOptimizedScheduler->StartScheduler();
    }
#endif /* HELIX_FEATURE_OPTIMIZED_SCHEDULER */

    InitializeThreadedObjects();

    // load all the plugins 
    if (!m_LastError)