hxmisus.cpp

linux下的一款播放器

    pMISU->QueryInterface(IID_IHXSiteUser,(void**)&pSiteUser);

    m_SiteUsers.AddTail(pSiteUser);

    pSiteUser->AddRef(); // this is for the caller
    
    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXSiteUserSupplier::DestroySiteUser
 */
STDMETHODIMP
CHXMultiInstanceSiteUserSupplier::DestroySiteUser
(
    IHXSiteUser* /*IN*/ pSiteUser
)
{
    LISTPOSITION pos = m_SiteUsers.Find(pSiteUser);
    if (!pos)
    {
        return HXR_INVALID_PARAMETER;
    }
    m_SiteUsers.RemoveAt(pos);
    pSiteUser->Release();

    // If this is the last of the multi-instance sites, then
    // tell the real site user to detach.
    if (m_SiteUsers.IsEmpty())
    {
	AddRef();
	IHXSiteUser* pSingleUser = m_pSingleUser;
	pSingleUser->AddRef();
        m_pSingleUser->DetachSite();
	pSingleUser->Release();
	m_bIsAttached = FALSE;
	Release();
    }
    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXSiteUserSupplier::NeedsWindowedSites
 */
STDMETHODIMP_(BOOL)
CHXMultiInstanceSiteUserSupplier::NeedsWindowedSites()
{
    return FALSE;
}

/************************************************************************
 *  Method:
 *    IHXSite::AttachWatcher
 */
STDMETHODIMP 
CHXMultiInstanceSiteUserSupplier::AttachWatcher(IHXSiteWatcher* /*IN*/ pWatcher)
{
    return HXR_NOTIMPL;
}

/************************************************************************
 *  Method:
 *    IHXSite::DetachWatcher
 */
STDMETHODIMP 
CHXMultiInstanceSiteUserSupplier::DetachWatcher()
{
    return HXR_NOTIMPL;
}

/************************************************************************
 *  Method:
 *    IHXSite2::UpdateSiteWindow
 */
STDMETHODIMP
CHXMultiInstanceSiteUserSupplier::UpdateSiteWindow(HXxWindow* /*IN*/ pWindow)
{
    CHXSimpleList::Iterator i = m_SiteUsers.Begin();
    for ( ; i != m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = 
		    (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
	    pSiteUser->m_pSite2->UpdateSiteWindow(pWindow);
	}
    }
    
    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXSite2::ShowSite
 */
STDMETHODIMP
CHXMultiInstanceSiteUserSupplier::ShowSite(BOOL bShow)
{
    return HXR_NOTIMPL;
}

/************************************************************************
 *  Method:
 *    IHXSite2::IsSiteVisible
 */
STDMETHODIMP_(BOOL)
CHXMultiInstanceSiteUserSupplier::IsSiteVisible()
{
    // Not implemented
    HX_ASSERT(0);
    return FALSE;
}

/************************************************************************
 *  Method:
 *    IHXSite2::SetZOrder
 */
STDMETHODIMP
CHXMultiInstanceSiteUserSupplier::SetZOrder(INT32 lZOrder)
{
    m_bSetZOrderHasBeenCalled = TRUE;
    m_zorder = lZOrder;
    
    CHXSimpleList::Iterator i = m_SiteUsers.Begin();
    for ( ; i != m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = 
		    (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
	    pSiteUser->m_pSite2->SetZOrder(lZOrder);
	}
    }
    
    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXSite2::GetZOrder
 */
STDMETHODIMP
CHXMultiInstanceSiteUserSupplier::GetZOrder(REF(INT32) lZOrder)
{
    return HXR_NOTIMPL;
}

/************************************************************************
 *  Method:
 *    IHXSite2::MoveSiteToTop
 */
STDMETHODIMP
CHXMultiInstanceSiteUserSupplier::MoveSiteToTop()
{
    CHXSimpleList::Iterator i = m_SiteUsers.Begin();
    for ( ; i != m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = 
		    (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
	    pSiteUser->m_pSite2->MoveSiteToTop();
	}
    }
    
    return HXR_OK;
}

#if 0 
/************************************************************************
 *  Method:
 *    IHXSite2::GetVideoSurface
 */
STDMETHODIMP
CHXMultiInstanceSiteUserSupplier::GetVideoSurface(REF(IHXVideoSurface*) pSurface)
{
    CHXSimpleList::Iterator i = m_SiteUsers.Begin();
    CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
    if (pSiteUser->m_pSite2)
    {
	return pSiteUser->m_pSite2->GetVideoSurface(pSurface);
    }
    
    return HXR_FAIL;
}
#endif

/************************************************************************
 *  Method:
 *    IHXSite2::GetVideoSurface
 */
STDMETHODIMP
CHXMultiInstanceSiteUserSupplier::GetVideoSurface(REF(IHXVideoSurface*) pSurface)
{
    // check to see if we have a video surface in any of our 
    // sites 
    IHXVideoSurface* pTempSurface;

    for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
	 i!= m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
	    if (HXR_OK == pSiteUser->m_pSite2->GetVideoSurface(pTempSurface))
	    {
		// so we have a video sufrface in one of our sites 
		// good enough return HXR_OK.
		HX_RELEASE(pTempSurface);
		QueryInterface(IID_IHXVideoSurface, (void**) &pSurface);
		return HXR_OK;
	    }
	}
     }
	    
    return HXR_FAIL;
}

/************************************************************************
 *  Method:
 *    IHXSite2::GetNumberOfChildSites
 */
STDMETHODIMP_(UINT32)
CHXMultiInstanceSiteUserSupplier::GetNumberOfChildSites()
{
    UINT32 ulChildSites = 0;

    CHXSimpleList::Iterator i = m_SiteUsers.Begin();
    for ( ; i != m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = 
		    (CHXMultiInstanceSiteUser*)(*i);
	ulChildSites += pSiteUser->m_pSite2->GetNumberOfChildSites();
    }

    return ulChildSites;
}

/************************************************************************
 *  Method:
 *    IHXSite2::AddPassiveSiteWatcher
 */
STDMETHODIMP
CHXMultiInstanceSiteUserSupplier::AddPassiveSiteWatcher
(
    IHXPassiveSiteWatcher* pWatcher
)
{
    HX_ASSERT(pWatcher);

    pWatcher->AddRef();
    m_PassiveSiteWatchers.AddTail(pWatcher);
    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXSite2::DetachPassiveSiteWatcher
 */
STDMETHODIMP
CHXMultiInstanceSiteUserSupplier::RemovePassiveSiteWatcher
(
    IHXPassiveSiteWatcher* pWatcher
)
{
    LISTPOSITION pos = m_PassiveSiteWatchers.GetHeadPosition();
    while(pos)
    {
	IHXPassiveSiteWatcher* pThisWatcher = 
	    (IHXPassiveSiteWatcher*)m_PassiveSiteWatchers.GetAt(pos);
	if(pWatcher == pThisWatcher)
	{
	    pWatcher->Release();
	    m_PassiveSiteWatchers.RemoveAt(pos);
	    break;
	}
	m_PassiveSiteWatchers.GetNext(pos);
    }
    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXSite2::SetCursor
 */
STDMETHODIMP
CHXMultiInstanceSiteUserSupplier::SetCursor
(
    HXxCursor cursor,
    REF(HXxCursor) oldCursor
)
{
    return HXR_NOTIMPL;
}

/*
 * IHXSiteEnumerator methods 
 */

STDMETHODIMP 
CHXMultiInstanceSiteUserSupplier::GetFirstSite  
(
    REF(IHXSite*) /* OUT */ pFirstSite,
    REF(IHXSiteEnumerator::SitePosition) /* OUT */ nextPosition
)
{
    nextPosition = m_SiteUsers.GetHeadPosition();  
    if (nextPosition)
    {
        pFirstSite = ((CHXMultiInstanceSiteUser*) m_SiteUsers.GetNext(nextPosition))->m_pSite; 

        if (pFirstSite)
        {        
            HX_ADDREF(pFirstSite);
            return HXR_OK;
        }
    }

    return HXR_FAIL;
}

STDMETHODIMP 
CHXMultiInstanceSiteUserSupplier::GetNextSite   
(
    REF(IHXSite*) pNextSite,
    REF(IHXSiteEnumerator::SitePosition) /* IN/OUT */ nextPosition
)
{
    if (nextPosition)
    {
        pNextSite = ((CHXMultiInstanceSiteUser*) m_SiteUsers.GetNext(nextPosition))->m_pSite; 

        if (pNextSite)
        {
            HX_ADDREF(pNextSite);
            return HXR_OK;
        }
    }

    return HXR_FAIL;
}


/************************************************************************
 *  Method:
 *    IHXVideoSurface::Blt
 */
STDMETHODIMP 
CHXMultiInstanceSiteUserSupplier::Blt
(UCHAR*			/*IN*/	pImageBits, 
HXBitmapInfoHeader*    /*IN*/	pBitmapInfo,			
REF(HXxRect)		/*IN*/	rDestRect, 
REF(HXxRect)		/*IN*/	rSrcRect) 
{           
    HX_ASSERT(0);
    return HXR_NOTIMPL;
}

/************************************************************************
 *  Method:
 *    IHXVideoSurface::BeginOptimizedBlt
 */
STDMETHODIMP
CHXMultiInstanceSiteUserSupplier::BeginOptimizedBlt
(
HXBitmapInfoHeader*    /*IN*/	pBitmapInfo
) 
{
    if (!pBitmapInfo)
	return HXR_FAIL;

    HX_DELETE(m_pSurfaceBitmapInfo);
    m_pSurfaceBitmapInfo = new HXBitmapInfoHeader;
    memcpy(m_pSurfaceBitmapInfo, pBitmapInfo, sizeof(HXBitmapInfoHeader)); /* Flawfinder: ignore */
    
    HX_RESULT retVal = HXR_FAIL;
    IHXVideoSurface* pTempSurface;

    for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
	 i!= m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
	    if (HXR_OK == pSiteUser->m_pSite2->GetVideoSurface(pTempSurface))
	    {
		// so we have a video sufrface in one of our sites 
		// good enough return HXR_OK.
		if (HXR_OK == pTempSurface->BeginOptimizedBlt(pBitmapInfo))
		{
		    retVal = HXR_OK;
		}
		HX_RELEASE(pTempSurface);
	    }
	}
     }
    return retVal;
}

/************************************************************************
 *  Method:
 *    IHXVideoSurface::OptimizedBlt
 */
STDMETHODIMP 
CHXMultiInstanceSiteUserSupplier::OptimizedBlt	
(
UCHAR*			/*IN*/	pImageBits,			
REF(HXxRect)		/*IN*/	rDestRect, 
REF(HXxRect)		/*IN*/	rSrcRect
)
{
    HX_ASSERT(0);
    return HXR_NOTIMPL;
}

/************************************************************************
 *  Method:
 *    IHXVideoSurface::EndOptimizedBlt
 */
STDMETHODIMP 
CHXMultiInstanceSiteUserSupplier::EndOptimizedBlt ()
{
    HX_RESULT retVal = HXR_FAIL;
    IHXVideoSurface* pTempSurface;

    for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
	 i!= m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
	    if (HXR_OK == pSiteUser->m_pSite2->GetVideoSurface(pTempSurface))
	    {
		// so we have a video sufrface in one of our sites 
		// good enough return HXR_OK.
		if (HXR_OK == pTempSurface->EndOptimizedBlt())
		{
		    HX_RELEASE(pTempSurface);
		    retVal = HXR_OK;
		    break;
		}
		HX_RELEASE(pTempSurface);
	    }
	}
     }
    return retVal;
}

/************************************************************************
 *  Method:
 *    IHXVideoSurface::GetOptimizedFormat
 */
STDMETHODIMP 
CHXMultiInstanceSiteUserSupplier::GetOptimizedFormat
(
    REF(HX_COMPRESSION_TYPE) /*OUT*/ ulType
)
{
    if (m_SiteUsers.IsEmpty())
	return HXR_FAIL;

    HX_RESULT retVal = HXR_FAIL;
    IHXVideoSurface* pTempSurface;

    for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
	 i!= m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
	    if (HXR_OK == pSiteUser->m_pSite2->GetVideoSurface(pTempSurface))
	    {
		// so we have a video sufrface in one of our sites 
		// good enough return HXR_OK.
		if (HXR_OK == pTempSurface->GetOptimizedFormat(ulType))
		{
		    retVal = HXR_OK;
		}
		HX_RELEASE(pTempSurface);
	    }
	}
     }
    return retVal;
}


/************************************************************************
 *  Method:
 *    IHXVideoSurface::GetPreferredFormat
 */
STDMETHODIMP 
CHXMultiInstanceSiteUserSupplier::GetPreferredFormat
(
REF(HX_COMPRESSION_TYPE) /*OUT*/ ulType
)
{
    if (m_SiteUsers.IsEmpty())
	return HXR_FAIL;

    HX_RESULT retVal = HXR_FAIL;
    IHXVideoSurface* pTempSurface;

    for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();