hxplay.cpp

linux下的一款播放器

    {
        m_pGroupManager->SetMasterTAC(m_pMasterTAC);
    }
#endif /* HELIX_FEATURE_ADVANCEDGROUPMGR && HELIX_FEATURE_MASTERTAC */

#if defined(HELIX_FEATURE_NESTEDMETA)
    m_pPersistentComponentManager->AddRef();
    if (m_pGroupManager)
    {
        m_pGroupManager->AddSink(m_pPersistentComponentManager);
    }
#endif /* HELIX_FEATURE_NESTEDMETA */

#if defined(HELIX_FEATURE_AUTOUPGRADE)
    m_pUpgradeCollection = new HXUpgradeCollection;
    m_pUpgradeCollection->AddRef();
#endif /* HELIX_FEATURE_AUTOUPGRADE */

#if defined(HELIX_FEATURE_EVENTMANAGER)
    // Get our own IUnknown interface
    IUnknown* pUnknown = NULL;
    QueryInterface(IID_IUnknown, (void**) &pUnknown);
    if (pUnknown)
    {
        // Initialize the renderer event manager
        m_pEventManager = new CRendererEventManager(pUnknown);
        if (m_pEventManager) m_pEventManager->AddRef();
    }
    HX_RELEASE(pUnknown);
#endif /* #if defined(HELIX_FEATURE_EVENTMANAGER) */
}

HXPlayer::~HXPlayer()
{
    CloseAllRenderers(m_nCurrentGroup);
    ResetPlayer();
    Close();
    HX_DELETE(m_pSourceMap);
    HX_DELETE(m_pSharedWallClocks);
}

/////////////////////////////////////////////////////////////////////////
//      Method:
//              IUnknown::QueryInterface
//      Purpose:
//              Implement this to export the interfaces supported by your
//              object.
//
STDMETHODIMP HXPlayer::QueryInterface(REFIID riid, void** ppvObj)
{
#if defined(HELIX_FEATURE_PACKETHOOKMGR)
    // create the following objects only if needed
    if (!m_pPacketHookManager && IsEqualIID(riid, IID_IHXPacketHookManager))
    {
        m_pPacketHookManager = new PacketHookManager(this);

        if (m_pPacketHookManager)
        {
            m_pPacketHookManager->AddRef();
        }
    }
#endif /* HELIX_FEATURE_PACKETHOOKMGR */

    QInterfaceList qiList[] =
        {
            { GET_IIDHANDLE(IID_IHXPlayer), (IHXPlayer*)this },
            { GET_IIDHANDLE(IID_IHXPlayer2), (IHXPlayer2*)this },
            { GET_IIDHANDLE(IID_IHXPendingStatus), (IHXPendingStatus*)this },
#if defined(HELIX_FEATURE_AUTHENTICATION)
            { GET_IIDHANDLE(IID_IHXAuthenticationManager), (IHXAuthenticationManager*)this },
            { GET_IIDHANDLE(IID_IHXAuthenticationManager2), (IHXAuthenticationManager2*)this },
#endif /* HELIX_FEATURE_AUTHENTICATION */
            { GET_IIDHANDLE(IID_IHXGroupSink), (IHXGroupSink*)this },
            { GET_IIDHANDLE(IID_IHXAudioPlayerResponse), (IHXAudioPlayerResponse*)this },
            { GET_IIDHANDLE(IID_IHXRegistryID), (IHXRegistryID*)this },
            { GET_IIDHANDLE(IID_IHXErrorMessages), (IHXErrorMessages*)this },
            { GET_IIDHANDLE(IID_IHXLayoutSiteGroupManager), (IHXLayoutSiteGroupManager*)this },
#if defined(HELIX_FEATURE_NESTEDMETA)
            { GET_IIDHANDLE(IID_IHXPersistenceManager), (IHXPersistenceManager*)this },
#endif /* HELIX_FEATURE_NESTEDMETA */
            { GET_IIDHANDLE(IID_IHXDriverStreamManager), (IHXDriverStreamManager*)this },
            { GET_IIDHANDLE(IID_IHXRendererUpgrade), (IHXRendererUpgrade*)this },
            { GET_IIDHANDLE(IID_IHXInternalReset), (IHXInternalReset*)this },
            { GET_IIDHANDLE(IID_IHXPlayerState), (IHXPlayerState*)this },
#if defined(HELIX_FEATURE_PLAYERNAVIGATOR)
            { GET_IIDHANDLE(IID_IHXPlayerNavigator), (IHXPlayerNavigator*)this },
#endif /* HELIX_FEATURE_PLAYERNAVIGATOR */
            { GET_IIDHANDLE(IID_IHXClientStatisticsGranularity), (IHXClientStatisticsGranularity*)this },
            { GET_IIDHANDLE(IID_IHXPlayerPresentation), (IHXPlayerPresentation*)this },
#if defined(HELIX_FEATURE_RECORDCONTROL)
            { GET_IIDHANDLE(IID_IHXRecordManager), (IHXRecordManager*)this },
#endif /* HELIX_FEATURE_RECORDCONTROL */
            { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXPlayer*)this },
            { GET_IIDHANDLE(IID_IHXOverrideDefaultServices), (IHXOverrideDefaultServices*)this },
        };
    HX_RESULT res = ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
    
    // if it succeeded, return immediately...
    if (res == HXR_OK)
    {
        return res;
    }
    // ...otherwise continue onward
    
    if (m_pClientViewSource &&
             IsEqualIID(riid, IID_IHXViewSourceCommand))
    {
        AddRef();
        *ppvObj = (IHXViewSourceCommand*)this;
        return HXR_OK;
    }
    else if (m_pErrorSinkControl &&
             m_pErrorSinkControl->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
    else if (m_pAdviseSink &&
             m_pAdviseSink->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
    else if (m_pAudioPlayer &&
             m_pAudioPlayer->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
#if defined(HELIX_FEATURE_PREFERENCES)
    else if (m_pPreferences &&
             m_pPreferences->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
#endif /* HELIX_FEATURE_PREFERENCES */
#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 */
#if defined(HELIX_FEATURE_ASM)
    /* m_pASM will be available on a per player basis ONLY under Load testing */
    else if (m_pASM &&
             m_pASM->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
#endif /* HELIX_FEATURE_ASM */
#if defined(HELIX_FEATURE_VIDEO)
    else if (m_pSiteManager &&
             m_pSiteManager->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
#endif /* HELIX_FEATURE_VIDEO */
#if defined(HELIX_FEATURE_AUTOUPGRADE)
    else if (m_pUpgradeCollection &&
             m_pUpgradeCollection->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
#endif /* HELIX_FEATURE_AUTOUPGRADE */
#if defined(HELIX_FEATURE_PACKETHOOKMGR)
    else if (m_pPacketHookManager &&
             m_pPacketHookManager->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
#endif /* HELIX_FEATURE_PACKETHOOKMGR */
#if defined(HELIX_FEATURE_BASICGROUPMGR)
    else if (m_pGroupManager &&
             m_pGroupManager->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
#endif /* HELIX_FEATURE_BASICGROUPMGR */
    else if (m_pViewPortManager &&
             m_pViewPortManager->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
#if defined(HELIX_FEATURE_MEDIAMARKER)
    else if (m_pMediaMarkerManager &&
             m_pMediaMarkerManager->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
#endif /* #if defined(HELIX_FEATURE_MEDIAMARKER) */
#if defined(HELIX_FEATURE_EVENTMANAGER)
    else if (m_pEventManager &&
             m_pEventManager->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
#endif /* #if defined(HELIX_FEATURE_EVENTMANAGER) */
#if defined(HELIX_FEATURE_NESTEDMETA)
    else if (m_pPersistentComponentManager &&
             m_pPersistentComponentManager->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
#endif /* HELIX_FEATURE_NESTEDMETA */
    else if (m_pPlugin2Handler &&
             m_pPlugin2Handler->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
    else if (m_pClient &&
             m_pClient->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
    else if (m_pEngine &&
             m_pEngine->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
    /* DO NOT ADD ANY MROE QIs HERE. ADD IT BEFORE m_pClient QI*/

    *ppvObj = NULL;
    return HXR_NOINTERFACE;
}

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

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

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

// *** IHXPlayer methods ***

/************************************************************************
 *      Method:
 *              IHXPlayer::GetClientEngine
 *      Purpose:
 *              Get the interface to the client engine object of which the player
 *              is a part of.
 *
 */
STDMETHODIMP HXPlayer::GetClientEngine(IHXClientEngine* &pEngine)
{
    pEngine = m_pEngine;

    if (pEngine)
    {
        pEngine->AddRef();
    }

    return HXR_OK;
}

/************************************************************************
 *      Method:
 *              IHXPlayer::Begin
 *      Purpose:
 *              Tell the player to begin playback of all its sources.
 *
 */
STDMETHODIMP HXPlayer::Begin(void)
{
    HX_RESULT theErr = HXR_OK;

    m_bCoreLocked = TRUE;
    m_pCoreMutex->Lock();
    theErr = BeginPlayer();
    m_pCoreMutex->Unlock();
    m_bCoreLocked = FALSE;

    return theErr;
}

HX_RESULT
HXPlayer::BeginPlayer(void)
{
    HX_RESULT   theErr = HXR_OK;

    m_bUserHasCalledBegin   = TRUE;
    m_bFastStartInProgress  = FALSE;

    if (!m_bInternalPauseResume && !m_bIsFirstBegin && !m_bPaused)
    {
        return HXR_OK;
    }

    if (m_bIsLive && m_bPaused && m_bLiveSeekToBeDone)
    {
        m_ulElapsedPauseTime = CALCULATE_ELAPSED_TICKS(m_ulTimeOfPause, HX_GET_TICKCOUNT());

        /* This is an internal seek due to live pause */
        theErr = SeekPlayer(m_ulLiveSeekTime + m_ulElapsedPauseTime);
    }

    m_bPaused = FALSE;

    if (m_bIsFirstBegin)
    {
        UpdateSourceActive();
    }

    if (!theErr)
    {
        theErr = UpdateStatistics();
    }

    if (!theErr)
    {
        UpdateCurrentPlayTime( m_pAudioPlayer->GetCurrentPlayBackTime() );
    }

    /* Unregister all the sources that are not currently active */
    UnregisterNonActiveSources();

    if (!m_bIsDone)
    {
        CheckSourceRegistration();

        CHXMapPtrToPtr::Iterator ndxSources = m_pSourceMap->Begin();
        /* Check if we are done. This may be TRUE for empty files */
        for (;  !theErr && ndxSources != m_pSourceMap->End(); ++ndxSources)
        {
            SourceInfo* pSourceInfo = (SourceInfo*) (*ndxSources);
            theErr = pSourceInfo->Begin();
        }
    }

    /* Only send this OnBegin()'s if not the first begin. In the case
     * of the first begin, these are actually sent after the header's
     * arrive...
     */
    if (!theErr && !m_bIsFirstBegin && !m_bInternalPauseResume && !m_bInternalReset && m_pAdviseSink)
    {
        m_pAdviseSink->OnBegin(m_ulCurrentPlayTime);
    }

    m_bIsFirstBegin = FALSE;
    m_bBeginPending = TRUE;

    m_bFastStartInProgress  = FALSE;

    if (!m_ToBeginRendererList.IsEmpty())
    {
        CheckBeginList();
    }

    return (theErr);
}

/************************************************************************
 *      Method:
 *              IHXPlayer::Stop
 *      Purpose:
 *              Tell the player to stop playback of all its sources.
 *
 */
STDMETHODIMP HXPlayer::Stop(void)
{
    // we want to protect against the TLC opening another URL
    if (m_bSetModal)
    {
        return HXR_OK;
    }

    m_bCoreLocked = TRUE;
    m_pCoreMutex->Lock();
    StopPlayer(END_STOP);
    m_pCoreMutex->Unlock();
    m_bCoreLocked = FALSE;

    return HXR_OK;
}

void
HXPlayer::StopPlayer(EndCode endCode)
{
    StopAllStreams(endCode);
    /* Reset player condition */
    ResetPlayer();
}


/************************************************************************
 *      Method:
 *              IHXPlayer::Pause
 *      Purpose:
 *              Tell the player to pause playback of all its sources.
 *
 */
STDMETHODIMP HXPlayer::Pause(void)
{
    HX_RESULT theErr = HXR_OK;

    m_bCoreLocked = TRUE;
    m_pCoreMutex->Lock();
    theErr = PausePlayer();
    m_pCoreMutex->Unlock();
    m_bCoreLocked = FALSE;

    return theErr;
}

HX_RESULT
HXPlayer::PausePlayer(BOOL bNotifyTLC /* = TRUE*/)
{
    HX_RESULT theErr = HXR_OK;

    if (m_bIsDone)
    {
        return HXR_UNEXPECTED;
    }