playhpnv.cpp

linux下的一款播放器

    // if alternate hypernavigation says it doesn't implement
    if (hxrResult != HXR_NOTIMPL)
	return(hxrResult);

    return HandleCommands(pURL, pTargetInstance, pParams);
}

STDMETHODIMP 
PlayerHyperNavigate::Hint(const char* pURL,
                          const char* pTarget,
                          IHXValues*  pParams)
{
    HX_RESULT		    hxrResult = HXR_NOTIMPL;
    IHXHyperNavigateHint*   pHyperNavigateHint = NULL;

    if (m_pHyperNavigateWithContext)
    {
	m_pHyperNavigateWithContext->QueryInterface(IID_IHXHyperNavigateHint, (void**) &pHyperNavigateHint);
    }

    if (!pHyperNavigateHint && m_pHyperNavigate)
    {
	m_pHyperNavigate->QueryInterface(IID_IHXHyperNavigateHint, (void**) &pHyperNavigateHint);
    }

    if (pHyperNavigateHint)
    {
	hxrResult = pHyperNavigateHint->Hint(pURL, pTarget, pParams);
	HX_RELEASE(pHyperNavigateHint);
    }

    return hxrResult;
}

HX_RESULT
PlayerHyperNavigate::HandleCommands(const char* pURL, const char* pTarget, IHXValues* pParams)
{
    HX_RESULT	hxrResult = HXR_NOTIMPL;
    char*	pArgument = NULL;

    //
    // Check for player commands.
    //
    if (strnicmp(pURL, URL_COMMAND, sizeof(URL_COMMAND) - 1) == 0)
    {
	const char *pOpen = HXFindChar(pURL, '(');
	const char *pClose = HXReverseFindChar(pURL, ')');

	if (! pOpen || ! pClose || (pOpen > pClose))
	{
	    return HXR_FAILED;
	}

	// beginning of actual player command
	const char* pCommand = pURL + sizeof(URL_COMMAND) - 1;

	int   iLength = pClose - (pOpen + 1);

	if (strnicmp(pCommand, URL_COMMAND_SEEK, sizeof(URL_COMMAND_SEEK) - 1) == 0)
	{
	    if (m_pPlayer)
	    {
		pArgument = new_string(pOpen + 1, iLength);
		if (!pArgument)
		{
		    return HXR_OUTOFMEMORY;
		}

		NPTime  time(pArgument);

		hxrResult = m_pPlayer->Seek(time);
	    }
	}
	else if (strnicmp(pCommand, URL_COMMAND_PLAY, sizeof(URL_COMMAND_PLAY) - 1) == 0)
	{
	    if ((iLength == 0) && m_pPlayer)
	    {
		hxrResult = m_pPlayer->Begin();
	    }
	}
	else if (strnicmp(pCommand, URL_COMMAND_PAUSE, sizeof(URL_COMMAND_PAUSE) - 1) == 0)
	{
	    if ((iLength == 0) && m_pPlayer)
	    {
		hxrResult = m_pPlayer->Pause();
	    }
	}
	else if (strnicmp(pCommand, URL_COMMAND_STOP, sizeof(URL_COMMAND_STOP) - 1) == 0)
	{
	    if ((iLength == 0) && m_pPlayer)
	    {
		hxrResult = m_pPlayer->Stop();
	    }
	}
	else if (strnicmp(pCommand, URL_COMMAND_PREVIOUSCLIP, sizeof(URL_COMMAND_PREVIOUSCLIP) - 1) == 0)
	{
	    if ((iLength == 0) && m_pGroupManager)
	    {
		UINT16  iCurrent = 0;
		
		m_pGroupManager->GetCurrentGroup(iCurrent);

		// play previous clip if one exists
		if ((iCurrent > 0) && ((iCurrent - 1) < m_pGroupManager->GetGroupCount()))
		{
		    hxrResult = m_pGroupManager->SetCurrentGroup(iCurrent - 1);
		}
	    }
	}
	else if (strnicmp(pCommand, URL_COMMAND_NEXTCLIP, sizeof(URL_COMMAND_NEXTCLIP) - 1) == 0)
	{
	    if ((iLength == 0) && m_pGroupManager)
	    {
		UINT16  iCurrent = 0;
		
		m_pGroupManager->GetCurrentGroup(iCurrent);

		// play next clip if one exists
		if (iCurrent < m_pGroupManager->GetGroupCount())
		{
		    hxrResult = m_pGroupManager->SetCurrentGroup(iCurrent + 1);
		}
	    }
	}
	else if (strnicmp(pCommand, URL_COMMAND_ADSCOOKIES, sizeof(URL_COMMAND_ADSCOOKIES) - 1) == 0)
	{
	    pArgument = new_string(pOpen + 1, iLength);
	    if (!pArgument)
	    {
		return HXR_OUTOFMEMORY;
	    }

	    hxrResult = SendAdsCookies(pArgument);
	}

	HX_VECTOR_DELETE(pArgument);
	return hxrResult;
    }
    else if (pTarget && stricmp(pTarget, "_player") == 0)
    {
	/* we want to unwind the stack...since it may come from
	 * an OnTimeSync() into syncMM renderer...and if we call 
	 * OpenURL() syncronously, bad things happen in the
	 * core (srcinfo gets deleted).
	 * use our friendly scheduler...
	 */
	HX_RELEASE(m_pPendingRequest);
	IHXCommonClassFactory* pCommonClassFactory = NULL;
	m_pPlayer->QueryInterface(IID_IHXCommonClassFactory,
						(void**)&pCommonClassFactory);
	if (pCommonClassFactory)
	{
	    pCommonClassFactory->CreateInstance(IID_IHXRequest, (void**) &m_pPendingRequest);
	    HX_ASSERT(m_pPendingRequest);

	    if (m_pPendingRequest)
	    {
		m_pPendingRequest->SetURL(pURL);
		if (pParams)
		{
		    m_pPendingRequest->SetRequestHeaders(pParams);
		}
	    }

	    HX_RELEASE(pCommonClassFactory);
	}

	if (m_pScheduler && m_pPendingRequest)
	{
	    if (!m_CallbackHandle)
	    {
		m_CallbackHandle = m_pScheduler->RelativeEnter((IHXCallback*) this, 0);
	    }
	}
	else
	{
	    Func();
	}

	return HXR_OK;
    }

    return HXR_FAILED;
}
/////////////////////////////////////////////////////////////////////////
//  Method:
//  	IHXHyperNavigateRedirectResponse::RedirectDone
//
STDMETHODIMP
PlayerHyperNavigate::RedirectDone(IHXBuffer*   pBuffer)
{
    if (pBuffer && m_pHyperNavigate)
    {
	// deligate to alternate hypernavigation interface
	return m_pHyperNavigate->GoToURL((const char*)pBuffer->GetBuffer(), NULL);
    }

    return HXR_OK;
}

/************************************************************************
 *	Method:
 *	IHXFileSystemManagerResponse::InitDone
 *	Purpose:
 */
STDMETHODIMP
PlayerHyperNavigate::InitDone(HX_RESULT status)
{
    return HXR_OK;
}

STDMETHODIMP
PlayerHyperNavigate::FileObjectReady(HX_RESULT status,
				     IUnknown* pObject)
{   
    HX_RESULT		theErr = HXR_OK;
    IHXHTTPRedirect*	pRedirect = NULL;

    if (!pObject)
    {
	theErr = HXR_FAILED;
    }
    else if (HXR_OK != pObject->QueryInterface(IID_IHXFileObject, (void**)&m_pFileObject))
    {
	theErr = HXR_FAILED;
    }
    else if (HXR_OK != pObject->QueryInterface(IID_IHXHTTPRedirect, (void**)&pRedirect))
    {
	theErr = HXR_FAILED;
    }
    else
    {
	theErr = pRedirect->Init((IHXHTTPRedirectResponse*)this);
    }

    HX_RELEASE(pRedirect);

    return theErr;
}

/*
 * The following method is deprecated and should return HXR_NOTIMPL
 */
STDMETHODIMP
PlayerHyperNavigate::DirObjectReady(HX_RESULT status,
				    IUnknown* pDirObject)
{
    return HXR_NOTIMPL;
}

/*
 *	IHXCallback methods
 */
STDMETHODIMP
PlayerHyperNavigate::Func()
{
    m_CallbackHandle = 0;

    if (m_pPlayer && m_pPendingRequest)
    {
	IHXPlayer2* pPlayer2 = NULL;
	m_pPlayer->QueryInterface(IID_IHXPlayer2, (void**) &pPlayer2);
	pPlayer2->OpenRequest(m_pPendingRequest);
	m_pPlayer->Begin();
	pPlayer2->Release();
	HX_RELEASE(m_pPendingRequest);
    }

    return HXR_OK;
}

HX_RESULT
PlayerHyperNavigate::SendAdsCookies(char* pURL)
{
    HX_RESULT		    hr = HXR_OK;
    IHXRequest*	    pRequest = NULL;
    IHXFileSystemManager*  pFileSystemManager = NULL;
    IHXCommonClassFactory* pCommonClassFactory = NULL;

    if (HXR_OK != m_pPlayer->QueryInterface(IID_IHXCommonClassFactory,
					    (void**)&pCommonClassFactory))
    {
	hr = HXR_FAILED;
    }
    else if (HXR_OK != pCommonClassFactory->CreateInstance(CLSID_IHXFileSystemManager,
						     (void**)&pFileSystemManager))
    {
	hr = HXR_FAILED;
    }
    else if (HXR_OK != pFileSystemManager->Init((IHXFileSystemManagerResponse*)this))
    {
	hr = HXR_FAILED;
    }
    else
    {
	IHXPreferences* pPreferences = NULL;
	if (m_pPlayer->QueryInterface(IID_IHXPreferences, (void **) &pPreferences) == HXR_OK)
	{
	    IHXRegistry* pRegistry = NULL;   
	    m_pPlayer->QueryInterface(IID_IHXRegistry, (void**)&pRegistry);

	    ::SetRequest(pURL,
			 FALSE,
			 pPreferences,
			 pRegistry,
			 NULL,
			 pRequest);

	    HX_RELEASE(pRegistry);
	}
	HX_RELEASE(pPreferences);

	hr = pFileSystemManager->GetNewFileObject(pRequest, 0);
    }

    HX_RELEASE(pRequest);
    HX_RELEASE(pFileSystemManager);
    HX_RELEASE(pCommonClassFactory);

    return hr;	
}