hxmisus.cpp

linux下的一款播放器

	 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->GetPreferredFormat(ulType))
		{
		    HX_RELEASE(pTempSurface);
		    retVal = HXR_OK;
		    break;
		}
		HX_RELEASE(pTempSurface);
	    }
	}
     }
    return retVal;
}


/*
 * IHXVideoSurface2 methods 
 */
STDMETHODIMP 
CHXMultiInstanceSiteUserSupplier::SetProperties
(
    HXBitmapInfoHeader *bmi, REF(UINT32) ulNumBuffers, IHXRenderTimeLine *pClock
)
{
    HX_RESULT result = HXR_OK;

    for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
	 i!= m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
            IHXVideoSurface* pVideoSurface;
	    if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
	    {
                IHXVideoSurface2* pVideoSurface2;
                if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
                                                            (void**) &pVideoSurface2)))
                {
                    // Propagate all failures:
                    HX_RESULT localResult = pVideoSurface2->SetProperties(bmi,
                                                                          ulNumBuffers,
                                                                          pClock);
                    if (SUCCEEDED(result))
                    {
                        result = localResult;    
                    }
                    
                    HX_RELEASE(pVideoSurface2);
                }
                HX_RELEASE(pVideoSurface);
            }
        }
    }

    return result;
}


STDMETHODIMP_(void) 
CHXMultiInstanceSiteUserSupplier::Flush()    
{
    for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
	 i!= m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
            IHXVideoSurface* pVideoSurface;
	    if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
	    {
                IHXVideoSurface2* pVideoSurface2;
                if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
                                                            (void**) &pVideoSurface2)))
                {
                    pVideoSurface2->Flush();
                    HX_RELEASE(pVideoSurface2);
                }
                HX_RELEASE(pVideoSurface);
            }
        }
    }
}

STDMETHODIMP   
CHXMultiInstanceSiteUserSupplier::ReleaseVideoMem(VideoMemStruct* pVidMem)
{
    HX_RESULT result = HXR_FAIL;

    for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
	 i!= m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
            IHXVideoSurface* pVideoSurface;
	    if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
	    {
                IHXVideoSurface2* pVideoSurface2;
                if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
                                                            (void**) &pVideoSurface2)))
                {
                    // We just need one success:
                    result = pVideoSurface2->ReleaseVideoMem(pVidMem);

                    HX_RELEASE(pVideoSurface2);
                    if (SUCCEEDED(result))
                    {
                        break;   
                    }
                }
                HX_RELEASE(pVideoSurface);
            }
        }
    }

    return result;
}

                                 
STDMETHODIMP   
CHXMultiInstanceSiteUserSupplier::ColorConvert
(
    INT32 cidIn, 
    HXxSize *pSrcSize,
    HXxRect *prSrcRect,
    SourceInputStruct *pInput,
    INT32 cidOut,
    UCHAR *pDestBuffer, 
    HXxSize *pDestSize, 
    HXxRect *prDestRect, 
    int nDestPitch
)
{
    HX_RESULT result = HXR_FAIL;

    for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
	 i!= m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
            IHXVideoSurface* pVideoSurface;
	    if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
	    {
                IHXVideoSurface2* pVideoSurface2;
                if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
                                                            (void**) &pVideoSurface2)))
                {
                    // We just need one success:
                    result = pVideoSurface2->ColorConvert( cidIn,
                                                           pSrcSize,
                                                           prSrcRect,
                                                           pInput,
                                                           cidOut,
                                                           pDestBuffer,
                                                           pDestSize,
                                                           prDestRect,
                                                           nDestPitch
                                                           );
                    
                    HX_RELEASE(pVideoSurface2);
                    if (SUCCEEDED(result))
                    {
                        break;   
                    }
                }
                HX_RELEASE(pVideoSurface);
            }
        }
    }

    return result;
}

                                 
STDMETHODIMP   
CHXMultiInstanceSiteUserSupplier::GetVideoMem
(
    VideoMemStruct* pVidMem,
    UINT32 ulFlags
)
{
    HX_RESULT result = HXR_FAIL;

    for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
	 i!= m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
            IHXVideoSurface* pVideoSurface;
	    if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
	    {
                IHXVideoSurface2* pVideoSurface2;
                if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
                                                            (void**) &pVideoSurface2)))
                {
                    // We just need one success:
                    result = pVideoSurface2->GetVideoMem(pVidMem, ulFlags);

                    HX_RELEASE(pVideoSurface2);
                    if (SUCCEEDED(result))
                    {
                        break;   
                    }
                }
                HX_RELEASE(pVideoSurface);
            }
        }
    }

    return result;
}
                                 
STDMETHODIMP   
CHXMultiInstanceSiteUserSupplier::Present
(
    VideoMemStruct* pVidMem,
    INT32 lTime,
    UINT32 ulFlags,
    HXxRect* prDestRect,
    HXxRect* prSrcRect
)
{
    HX_RESULT result = HXR_OK;

    for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
	 i!= m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
            IHXVideoSurface* pVideoSurface;
	    if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
	    {
                IHXVideoSurface2* pVideoSurface2;
                if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
                                                            (void**) &pVideoSurface2)))
                {
                    // Propagate all failures:
                    HX_RESULT localResult = pVideoSurface2->Present(pVidMem,
                                                                    lTime,
                                                                    ulFlags,
                                                                    prDestRect,
                                                                    prSrcRect);
                    if (SUCCEEDED(result))
                    {
                        result = localResult;    
                    }
                    
                    HX_RELEASE(pVideoSurface2);
                }
                HX_RELEASE(pVideoSurface);
            }
        }
    }

    return result;
}
                                 
STDMETHODIMP   
CHXMultiInstanceSiteUserSupplier::PresentIfReady()
{
    HX_RESULT result = HXR_OK;

    for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
	 i!= m_SiteUsers.End(); ++i)
    {
	CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
	if (pSiteUser->m_pSite2)
	{
            IHXVideoSurface* pVideoSurface;
	    if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
	    {
                IHXVideoSurface2* pVideoSurface2;
                if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
                                                            (void**) &pVideoSurface2)))
                {
                    // Propagate all failures:
                    HX_RESULT localResult = pVideoSurface2->PresentIfReady();
                    if (SUCCEEDED(result))
                    {
                        result = localResult;    
                    }
                    HX_RELEASE(pVideoSurface2);
                }
                HX_RELEASE(pVideoSurface);
            }
        }
    }     

    return result;
}

/*
 *  IHXInterruptSafe methods
 */

/************************************************************************
 *	Method:
 *	    IHXInterruptSafe::IsInterruptSafe
 *	Purpose:
 *	    This is the function that will be called to determine if
 *	    interrupt time execution is supported.
 */
STDMETHODIMP_(BOOL)
CHXMultiInstanceSiteUserSupplier::IsInterruptSafe(void)
{
    return m_bIsInterrupSafe;
}

/************************************************************************
 *  Method:
 *    Constructor
 */
CHXMultiInstanceSiteUser::CHXMultiInstanceSiteUser
(
    CHXMultiInstanceSiteUserSupplier* pMISUS
)
    : m_lRefCount(0)
    , m_pMISUS(pMISUS)
    , m_pSite(NULL)
    , m_pSite2(NULL)
{
};

/************************************************************************
 *  Method:
 *    Destructor
 */
CHXMultiInstanceSiteUser::~CHXMultiInstanceSiteUser()
{
}

/************************************************************************
 *  Method:
 *    IUnknown::QueryInterface
 */
STDMETHODIMP 
CHXMultiInstanceSiteUser::QueryInterface(REFIID riid, void** ppvObj)
{
    if (IsEqualIID(riid, IID_IHXSiteUser))
    {
	AddRef();
	*ppvObj = (IHXSiteUser*)this;
	return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IUnknown))
    {
	AddRef();
	*ppvObj = (IUnknown*)(IHXSiteUser*)this;
	return HXR_OK;
    }

    *ppvObj = NULL;
    return HXR_NOINTERFACE;
}

/************************************************************************
 *  Method:
 *    IUnknown::AddRef
 */
STDMETHODIMP_(ULONG32) 
CHXMultiInstanceSiteUser::AddRef()
{
    return InterlockedIncrement(&m_lRefCount);
}

/************************************************************************
 *  Method:
 *    IUnknown::Release
 */
STDMETHODIMP_(ULONG32) 
CHXMultiInstanceSiteUser::Release()
{
    if (InterlockedDecrement(&m_lRefCount) > 0)
    {
        return m_lRefCount;
    }

    delete this;
    return 0;
}

/************************************************************************
 *  Method:
 *    IHXSiteUser::AttachSite
 */
STDMETHODIMP 
CHXMultiInstanceSiteUser::AttachSite(IHXSite* /*IN*/ pSite)
{
    if (m_pSite) return HXR_UNEXPECTED;
    if (!pSite)  return HXR_INVALID_PARAMETER;
    m_pSite = pSite;
    m_pSite->AddRef();


    IHXSite2* pSite2 = NULL;
    m_pSite->QueryInterface(IID_IHXSite2, (void**)&pSite2);
    if (pSite2)
    {
	m_pSite2 = pSite2;
    }

    if (!m_pMISUS->m_bIsAttached)
    {
	IHXInterruptSafe* pInterrupSafe = NULL;

	if (m_pSite->QueryInterface(IID_IHXInterruptSafe, 
				    (void**) &pInterrupSafe) == HXR_OK)
	{
	    m_pMISUS->m_bIsInterrupSafe = pInterrupSafe->IsInterruptSafe();
	    pInterrupSafe->Release();
	}

	m_pMISUS->m_pSingleUser->AttachSite((IHXSite*)m_pMISUS);
	m_pMISUS->m_bIsAttached = TRUE;
    }

    if (m_pMISUS->m_bSetSizeHasBeenCalled)
    {
	m_pSite->SetSize(m_pMISUS->m_size);
    }
    if (m_pMISUS->m_bSetPositionHasBeenCalled)
    {
	m_pSite->SetPosition(m_pMISUS->m_position);
    }
    if (m_pMISUS->m_bSetZOrderHasBeenCalled)
    {
	m_pSite2->SetZOrder(m_pMISUS->m_zorder);
    }


    HXBitmapInfoHeader* pHeader = m_pMISUS->GetBitmapInfoHeader();
    if (pHeader && m_pSite2)
    {
	IHXVideoSurface* pTempSurface;
	if (HXR_OK == m_pSite2->GetVideoSurface(pTempSurface))
	{
	    // so we have a video sufrface in one of our sites 
	    // good enough return HXR_OK.
	    pTempSurface->BeginOptimizedBlt(pHeader);
	    HX_RELEASE(pTempSurface);
	}
    }

    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXSiteUser::DetachSite
 */
STDMETHODIMP 
CHXMultiInstanceSiteUser::DetachSite()
{
    HX_ASSERT(m_pSite);
    HX_ASSERT(m_pMISUS);

    m_pMISUS->DestroySiteUser((IHXSiteUser*)this);

    HX_RELEASE(m_pSite);
    HX_RELEASE(m_pSite2);

    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXSiteUser::HandleEvent
 */
STDMETHODIMP 
CHXMultiInstanceSiteUser::HandleEvent(HXxEvent* /*IN*/ pEvent)
{
    if (m_pMISUS)
    {
	if (m_pMISUS->m_pSingleUser)
	{
	    return m_pMISUS->m_pSingleUser->HandleEvent(pEvent);
	}
    }
    return HXR_NOTIMPL;
}

/************************************************************************
 *  Method:
 *    IHXSiteUser::NeedsWindowedSites
 */
STDMETHODIMP_(BOOL)
CHXMultiInstanceSiteUser::NeedsWindowedSites()
{
    return FALSE;
}