📄 hxmisus.cpp
字号:
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;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -