hxcleng.cpp

linux下的一款播放器

    {
#if defined(HELIX_FEATURE_REGISTRY)
    m_pRegistry->Init((IUnknown*) (IHXClientEngine*)this); 
#endif /* HELIX_FEATURE_REGISTRY */

    // Init the plugin handler. 
    m_pPlugin2Handler->Init((IUnknown*) (IHXClientEngine*)this);   

#if defined(HELIX_FEATURE_PLUGINHANDLER2)
    ULONG32 unTotalPlugins = m_pPlugin2Handler->GetNumOfPlugins2();

    // The basic idea of this for loop is that we want to loop
    // through the list of plugins and load all of the plugins that
    // are non multi-load plugins.

    for (;unTotalPlugins; unTotalPlugins--)
    {
        IHXValues* pPluginProps = NULL;
        ULONG32 isMultiple = 0;
        if (SUCCEEDED(m_pPlugin2Handler->GetPluginInfo((unTotalPlugins-1),
                                                       pPluginProps)) &&
            pPluginProps)
        {
            pPluginProps->GetPropertyULONG32(PLUGIN_LOADMULTIPLE, isMultiple);
            pPluginProps->Release();
        }        

        if(!isMultiple)
        {
        IUnknown* pInstance = NULL;
        m_pPlugin2Handler->GetInstance(unTotalPlugins-1, pInstance);
           
        //If we got an instance of the plugin
        if(pInstance)
        {
            HX_RESULT res;
            IHXPlugin* pFPlugin = 0;
            
            res = pInstance->QueryInterface(IID_IHXPlugin,
                            (void**)&pFPlugin);
            
            //The Plugin should be an IHXPlugin so we should get 
            //an interface.
            if(res == HXR_OK)
            {
              //Finally init the plugin.
              pFPlugin->InitPlugin((IUnknown*) (IHXClientEngine*) this);

              if (!m_pSingleLoadPlugins)
              {
                  m_pSingleLoadPlugins = new CHXSimpleList();
              }

              if (m_pSingleLoadPlugins)
              {
                  //Add this plugin to the Plugin List
                  m_pSingleLoadPlugins->AddTail((void*)pFPlugin);
              }
            } //End of if res==HX_PK statement
            
            //Release
            HX_RELEASE(pInstance);
        
        } //End of if pInstance statement
        } //End of if Plugin is multiload
    }//End of for-loop
#endif /* HELIX_FEATURE_PLUGINHANDLER2 */
    } //End of outer if statement

    // get the resource manager instance
#if defined(HELIX_FEATURE_RESOURCEMGR)
    m_pExternalResourceManager = HXExternalResourceManager::Instance((IUnknown*)(IHXClientEngine*)this);
    m_pResMgr = new CHXResMgr((IUnknown*)(IHXClientEngine*)this);
#endif /* HELIX_FEATURE_RESOURCEMGR */

#if defined(_UNIX) || defined(__TCS__)
    m_pSiteEventHandler = NULL;
    IHXCommonClassFactory* pCCF = NULL;
    if (QueryInterface(IID_IHXCommonClassFactory, (void**) &pCCF) == HXR_OK)
    {
        pCCF->CreateInstance(IID_IHXSiteEventHandler, (void**) &m_pSiteEventHandler);
    }
    HX_RELEASE(pCCF);
#endif

#if defined(HELIX_FEATURE_PROXYMGR)
    m_pProxyManager->Initialize((IUnknown*)(IHXClientEngine*)this);
#endif /* HELIX_FEATURE_PROXYMGR */

#if defined(HELIX_FEATURE_OVERLAYMGR)
    m_pOverlayManager->Initialize();
#endif /* HELIX_FEATURE_OVERLAYMGR */

    if (!m_LastError)
    {
    m_bInitialized = TRUE;
    }
}

/*
 * IUnknown methods
 */


/////////////////////////////////////////////////////////////////////////
//  Method:
//      IUnknown::QueryInterface
//  Purpose:
//      Implement this to export the interfaces supported by your 
//      object.
//
STDMETHODIMP HXClientEngine::QueryInterface(REFIID riid, void** ppvObj)
{
    // might be memory error in constructor...
    if (m_LastError)
    return m_LastError;

    // create the following objects only if needed
    if (!m_pCookiesHelper && IsEqualIID(riid, IID_IHXCookiesHelper))
    {        
#if defined(HELIX_FEATURE_COOKIES)
    m_pCookiesHelper = new HXCookiesHelper();

    if (m_pCookiesHelper)
    {
        m_pCookiesHelper->AddRef();
    }
#endif /* defined(HELIX_FEATURE_COOKIES) */
    }
#if defined(HELIX_FEATURE_META)
    else if (!m_pValidator && IsEqualIID(riid, IID_IHXValidator))
    {
    m_pValidator = new HXValidator((IUnknown*) (IHXClientEngine*)this);
    
    if (m_pValidator)
    {
        m_pValidator->AddRef();
    }
    }
#endif /* HELIX_FEATURE_META */
#if defined(HELIX_FEATURE_VIEWSOURCE)
    else if (!m_pViewSource && IsEqualIID(riid, IID_IHXClientViewSourceSink))
    {
    m_pViewSource = new HXViewSource((IUnknown*) (IHXClientEngine*)this);

    if ( m_pViewSource )
    {
        m_pViewSource->AddRef();
    }
    }
#endif /* HELIX_FEATURE_VIEWSOURCE */
#if defined(HELIX_FEATURE_NETINTERFACES)
    else if (!m_pNetInterfaces && IsEqualIID(riid, IID_IHXNetInterfaces))
    {
    m_pNetInterfaces = new HXNetInterface((IUnknown*)(IHXClientEngine*)this);
    HX_ADDREF(m_pNetInterfaces);
    }
#endif /* HELIX_FEATURE_NETINTERFACES */
#if defined(HELIX_FEATURE_PAC) && defined(HELIX_FEATURE_PLUGINHANDLER2)
    else if (!m_pProxyAutoConfig && IsEqualIID(riid, IID_IHXProxyAutoConfig))
    {
        IUnknown*   pUnknown = NULL;
        if (HXR_OK == m_pPlugin2Handler->FindPluginUsingStrings(PLUGIN_CLASS, 
                                                                PLUGIN_PAC_TYPE, 
                                                                NULL,
                                                                NULL, 
                                                                NULL, 
                                                                NULL, 
                                                                pUnknown))
        {
            pUnknown->QueryInterface(IID_IHXProxyAutoConfig, (void**)&m_pProxyAutoConfig);
            m_pProxyAutoConfig->Init((IUnknown*) (IHXClientEngine*) this);
        }
        HX_RELEASE(pUnknown);
    }
#endif /* HELIX_FEATURE_PAC && HELIX_FEATURE_PLUGINHANDLER2 */
#if defined(_MACINTOSH) && defined(_CARBON) && defined(THREADS_SUPPORTED)
    else if (!m_pMacBlitMutex && IsEqualIID(riid, IID_IHXMacBlitMutex))
    {
    HXMutex::MakeMutex(m_pMacBlitMutex);
    }
#endif
#if defined (HELIX_FEATURE_COOKIES)
    else if (!m_pCookies && (IsEqualIID(riid, IID_IHXCookies) || IsEqualIID(riid, IID_IHXCookies2)))
    {
	m_pCookies = NewCookies();
	HX_ADDREF(m_pCookies);
    }
#endif /* defined (HELIX_FEATURE_COOKIES) */

    QInterfaceList qiList[] =
        {
            { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXClientEngine*)this },
            { GET_IIDHANDLE(IID_IHXClientEngine), (IHXClientEngine*)this },
            { GET_IIDHANDLE(IID_IHXClientEngineMapper), (IHXClientEngineMapper*)this },
#if defined(_UNIX) && !defined(_VXWORKS)
            { GET_IIDHANDLE(IID_IHXClientEngineSelector), (IHXClientEngineSelector*)this },
#endif
            { GET_IIDHANDLE(IID_IHXClientEngineSetup), (IHXClientEngineSetup*)this },
            { GET_IIDHANDLE(IID_IHXInterruptState), (IHXInterruptState*)this },
            { GET_IIDHANDLE(IID_IHXShutDownEverything), (IHXShutDownEverything*)this },
            { GET_IIDHANDLE(IID_IHXOverrideDefaultServices), (IHXOverrideDefaultServices*)this },
            { GET_IIDHANDLE(IID_IHXErrorMessages), (IHXErrorMessages*)this },
            { GET_IIDHANDLE(IID_IHXCoreMutex), (IHXCoreMutex*)this }
        };
    HX_RESULT retval = ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
    if (retval == HXR_OK)
    {
        return retval;
    }
    
#if defined _UNIX && !defined _VXWORKS
    else if (IsEqualIID(riid, IID_IHXAsyncIOSelection))
    {
        if (m_pAsyncIOSelection) 
        {
        m_pAsyncIOSelection->AddRef();
            *ppvObj = m_pAsyncIOSelection;  
        return HXR_OK;
        }
    AddRef();
    *ppvObj = (IHXAsyncIOSelection*)this;
    return HXR_OK;
    }
#endif

#if defined(_MACINTOSH) && defined(_CARBON) && defined(THREADS_SUPPORTED)

    else if (IsEqualIID(riid, IID_IHXMacBlitMutex))
    {
    AddRef();
    *ppvObj = (IHXMacBlitMutex*)this;
    return HXR_OK;
    }

#endif

    // We support Scheduler and Preferences Interface also in the HXClientEngine..
    else if (m_pCommonClassFactoryOverride &&
         m_pCommonClassFactoryOverride->
            QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
    else if (m_pCommonClassFactory &&
         m_pCommonClassFactory->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
    else if (m_pScheduler &&
         m_pScheduler->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#ifdef HELIX_FEATURE_OPTIMIZED_SCHEDULER
    else if (m_pOptimizedScheduler &&
         m_pOptimizedScheduler->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_OPTIMIZED_SCHEDULER */
#if defined(HELIX_FEATURE_PLAYBACK_NET)
    else if (m_pNetworkServices &&
         m_pNetworkServices->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_PLAYBACK_NET */
#if defined(HELIX_FEATURE_REGISTRY)
    else if (m_pRegistry &&
         m_pRegistry->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_REGISTRY */
#if defined(HELIX_FEATURE_AUDIO)
    else if (m_pAudioSession && 
         m_pAudioSession->QueryInterface(riid,ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_AUDIO */
#if defined(HELIX_FEATURE_PREFERENCES)
    else if (m_pPreferences &&
         m_pPreferences->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_AUDIO */
#if defined(HELIX_FEATURE_HYPER_NAVIGATE)
    else if (m_pHyperNavigate &&
         m_pHyperNavigate->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_HYPER_NAVIGATE */
    else if (m_pPlugin2Handler &&
         m_pPlugin2Handler->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
    else if (m_pPlayerSinkControl &&
         m_pPlayerSinkControl->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#if defined(HELIX_FEATURE_ASM)
    else if (m_pASM &&
         m_pASM->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_ASM */
#if defined(HELIX_FEATURE_META)
    else if (m_pValidator &&
         m_pValidator->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_META */
#if defined(HELIX_FEATURE_RESOURCEMGR)
    else if (m_pExternalResourceManager &&
         m_pExternalResourceManager->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_RESOURCEMGR */
#if defined(HELIX_FEATURE_AUTHENTICATION)
    else if (m_pCredentialsCache &&
         m_pCredentialsCache->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_AUTHENTICATION */
#if defined(HELIX_FEATURE_XMLPARSER)
    else if (m_pXMLParser &&
         m_pXMLParser->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_XMLPARSER */
#if defined (HELIX_FEATURE_COOKIES)
    else if (m_pCookies &&
         m_pCookies->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
    else if (m_pCookiesHelper &&
         m_pCookiesHelper->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_COOKIES */
#if defined(_MEDIUM_BLOCK)
    else if (m_pAllocator &&
     m_pAllocator->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* _MEDIUM_BLOCK */
#if defined(HELIX_FEATURE_VIEWSOURCE)
    else if (m_pViewSource &&
    m_pViewSource->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_VIEWSOURCE */
#if defined(HELIX_FEATURE_SYSTEMREQUIRED)
    else if (m_pSystemRequired && 
        m_pSystemRequired->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_SYSTEMREQUIRED */
#if defined(HELIX_FEATURE_PROXYMGR)
    else if (m_pProxyManager &&
         m_pProxyManager->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }    
#endif /* HELIX_FEATURE_PROXYMGR */
#if defined(HELIX_FEATURE_SMARTERNETWORK)
    else if (m_pPreferredTransportManager &&
         m_pPreferredTransportManager->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_SMARTERNETWORK */
#if defined(HELIX_FEATURE_OVERLAYMGR)
    else if (m_pOverlayManager &&
         m_pOverlayManager->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_OVERLAYMGR */
    else if (m_pMultiPlayPauseSupport && IsEqualIID(riid, IID_IHXMultiPlayPauseSupport) &&
    m_pMultiPlayPauseSupport->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#if defined(HELIX_FEATURE_NETINTERFACES)
    else if (m_pNetInterfaces &&
         m_pNetInterfaces->QueryInterface(riid, ppvObj) == HXR_OK)
    {
    return HXR_OK;
    }
#endif /* HELIX_FEATURE_NETINTERFACES */
#if defined(HELIX_FEATURE_PAC)
    else if (m_pProxyAutoConfig &&
         m_pProxyAutoConfig->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
#endif /* HELIX_FEATURE_PAC */

    *ppvObj = NULL;
    return HXR_NOINTERFACE;
}

/////////////////////////////////////////////////////////////////////////
//  Method:
//      IUnknown::AddRef
//  Purpose:
//      Everyone usually implements this the same... feel free to use
//      this implementation.
//
STDMETHODIMP_(ULONG32) HXClientEngine::AddRef()
{
    return InterlockedIncrement(&m_lRefCount);
}

/////////////////////////////////////////////////////////////////////////
//  Method:
//      IUnknown::Release
//  Purpose:
//      Everyone usually implements this the same... feel free to use
//      this implementation.
//
STDMETHODIMP_(ULONG32) HXClientEngine::Release()
{
    if (InterlockedDecrement(&m_lRefCount) > 0)
    {
    return m_lRefCount;
    }

    if(m_lRefCount == 0)
    {
    delete this;
    }

    return 0;
}


/*
 * IHXClientEngine methods
 */

/************************************************************************
 *  Method:
 *      IHXClientEngine::CreatePlayer
 *  Purpose:
 *      TBD.
 *
 */
STDMETHODIMP HXClientEngine::CreatePlayer(IHXPlayer* &pPlayer)
{
    if (!m_bInitialized)
    {
        _Initialize();
    }