Windows/Windows-classic-samples
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Windows-classic-samples/Samples/Win7Samples/multimedia/directshow/vmr9/vmr9compositor/MyCompositor9.cpp
Raten 12d6772ad2 new
2025-11-28 00:35:46 +09:00

480 lines
13 KiB
C++
Raw Blame History

//////////////////////////////////////////////////////////////////////////
// MyCompositor.cpp : Defines the custom compositor
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//////////////////////////////////////////////////////////////////////////
#include "vmr9compositor.h"
#include "MyCompositor9.h"
#include <strsafe.h>
#define _USE_MATH_DEFINES
#include <math.h>
#define D3DFVF_CUSTOMVERTEX ( D3DFVF_XYZ | D3DFVF_TEX1 )
// Matrix functions
D3DMATRIX* MatrixPerspectiveFovLH(
D3DMATRIX * pOut,
FLOAT fovy,
FLOAT Aspect,
FLOAT zn,
FLOAT zf
);
D3DMATRIX* MatrixLookAtLH(
D3DMATRIX *pOut,
const D3DVECTOR *pEye,
const D3DVECTOR *pAt,
const D3DVECTOR *pUp
);
CMyCompositor9::CMyCompositor9(void)
: m_refCount( 1 )
, m_needTurn( true ) // first turn needs to happen
, m_x( 0 )
, m_y( 0 )
, m_createTexture(false)
{
m_vertices[0].position = CUSTOMVERTEX::Position( -1.0f, 0.0f, -1.0f); // - forward bottom left
m_vertices[1].position = CUSTOMVERTEX::Position( 0.0f, 2.0f, 0.0f); // - tip
m_vertices[2].position = CUSTOMVERTEX::Position( 1.0f, 0.0f, -1.0f); // - forward bottom right
m_vertices[3].position = CUSTOMVERTEX::Position( 1.0f, 0.0f, 1.0f); // - back bottom right
m_vertices[4].position = CUSTOMVERTEX::Position( -1.0f, 0.0f, -1.0f ); // - forward bottom left
m_vertices[5].position = CUSTOMVERTEX::Position( 0.0f, 2.0f, 0.0f ); // - tip
m_vertices[6].position = CUSTOMVERTEX::Position( -1.0f, 0.0f, 1.0f); // - back bottom left
m_vertices[7].position = CUSTOMVERTEX::Position( 1.0f, 0.0f, 1.0f); // - back bottom right
m_vertices[8].position = CUSTOMVERTEX::Position( -1.0f, 0.0f, -1.0f ); // - forward
m_vertices[9].position = CUSTOMVERTEX::Position( -1.0f, 0.0f, 1.0f ); // - back
m_vertices[10].position = CUSTOMVERTEX::Position( 1.0f, 0.0f, -1.0f ); // - forward
m_vertices[11].position = CUSTOMVERTEX::Position( 1.0f, 0.0f, 1.0f ); // - back
// set up texture coordinates
m_vertices[0].tu = 0.0f; m_vertices[0].tv = 0.0f; // low left
m_vertices[1].tu = 0.0f; m_vertices[1].tv = 1.0f; // high left
m_vertices[2].tu = 1.0f; m_vertices[2].tv = 0.0f; // low right
m_vertices[3].tu = 1.0f; m_vertices[3].tv = 1.0f; // high right
m_vertices[4].tu = 0.0f; m_vertices[4].tv = 0.0f;
m_vertices[5].tu = 0.0f; m_vertices[5].tv = 1.0f;
m_vertices[6].tu = 1.0f; m_vertices[6].tv = 0.0f;
m_vertices[7].tu = 1.0f; m_vertices[7].tv = 1.0f;
m_vertices[8].tu = 0.0f; m_vertices[8].tv = 0.0f;
m_vertices[9].tu = 0.0f; m_vertices[9].tv = 1.0f;
m_vertices[10].tu = 1.0f; m_vertices[10].tv = 0.0f;
m_vertices[11].tu = 1.0f; m_vertices[11].tv = 1.0f;
}
CMyCompositor9::~CMyCompositor9(void)
{
}
// IVMRImageCompositor9
HRESULT STDMETHODCALLTYPE CMyCompositor9::InitCompositionDevice(
/* [in] */ IUnknown *pD3DDevice)
{
HRESULT hr;
SmartPtr<IDirect3DDevice9> d3ddev;
hr = pD3DDevice->QueryInterface(__uuidof(IDirect3DDevice9), (void**)&d3ddev);
ASSERT( d3ddev );
//FAIL_RET( SetUpFog( d3ddev ) );
//
// Set the projection matrix
//
SmartPtr<IDirect3DSurface9> backBuffer;
FAIL_RET( d3ddev->GetRenderTarget( 0, &backBuffer ) );
D3DSURFACE_DESC backBufferDesc;
backBuffer->GetDesc( & backBufferDesc );
FAIL_RET( AdjustViewMatrix( d3ddev ) );
D3DMATRIX matProj;
FLOAT fAspect = backBufferDesc.Width /
(float)backBufferDesc.Height;
MatrixPerspectiveFovLH( &matProj, (float)M_PI_4, fAspect,
1.0f, 100.0f );
FAIL_RET( d3ddev->SetTransform( D3DTS_PROJECTION, &matProj ) );
//
// vertex buffer
//
m_vertexBuffer = NULL;
FAIL_RET( d3ddev->CreateVertexBuffer(sizeof(m_vertices),D3DUSAGE_WRITEONLY,
D3DFVF_CUSTOMVERTEX,D3DPOOL_MANAGED,& m_vertexBuffer, NULL ) );
if( m_createTexture ) {
FAIL_RET( CreateTexture( d3ddev, backBufferDesc.Width, backBufferDesc.Height ) );
}
m_zSurface = NULL;
FAIL_RET( d3ddev->CreateDepthStencilSurface( backBufferDesc.Width, backBufferDesc.Height,
D3DFMT_D16, D3DMULTISAMPLE_NONE, 0, TRUE, &m_zSurface, NULL ) );
return S_OK;
}
HRESULT CMyCompositor9::CreateTexture( IDirect3DDevice9* d3ddev, DWORD x, DWORD y )
{
ASSERT( d3ddev );
HRESULT hr;
D3DDISPLAYMODE dm;
FAIL_RET( d3ddev->GetDisplayMode(NULL, & dm ) );
m_texture = NULL;
// create the private texture
FAIL_RET( d3ddev->CreateTexture(x, y,
1,
D3DUSAGE_RENDERTARGET,
dm.Format,
D3DPOOL_DEFAULT /* default pool - usually video memory */,
& m_texture, NULL ) );
return hr;
}
HRESULT CMyCompositor9::SetUpFog( IDirect3DDevice9* d3ddev )
{
HRESULT hr;
float fogStart = 2.0;
float fogEnd = 6.0;
FAIL_RET( d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE ));
FAIL_RET( d3ddev->SetRenderState( D3DRS_FOGCOLOR, 0x00001020));
FAIL_RET( d3ddev->SetRenderState( D3DRS_FOGSTART, DWORD( fogStart ) ));
FAIL_RET( d3ddev->SetRenderState( D3DRS_FOGEND, DWORD( fogEnd ) ));
return hr;
}
HRESULT STDMETHODCALLTYPE CMyCompositor9::TermCompositionDevice(
/* [in] */ IUnknown *pD3DDevice)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMyCompositor9::SetStreamMediaType(
/* [in] */ DWORD dwStrmID,
/* [in] */ AM_MEDIA_TYPE *pmt,
/* [in] */ BOOL fTexture)
{
m_createTexture = ! fTexture;
// ok it's not a texture.
// we need to create one
return S_OK;
}
SmartPtr<IDirect3DTexture9> CMyCompositor9::GetTexture(
IDirect3DDevice9* d3ddev,
VMR9VideoStreamInfo *pVideoStreamInfo
)
{
SmartPtr<IDirect3DTexture9> texture;
HRESULT hr = pVideoStreamInfo->pddsVideoSurface->GetContainer( __uuidof(IDirect3DTexture9), (LPVOID*) & texture );
if( FAILED ( hr ) ) {
SmartPtr<IDirect3DSurface9> surface;
if( FAILED( m_texture->GetSurfaceLevel( 0 , & surface ) ) ) {
return NULL;
}
// copy the full surface onto the texture's surface
if( FAILED( d3ddev->StretchRect( pVideoStreamInfo->pddsVideoSurface, NULL,
surface, NULL,
D3DTEXF_NONE ) )) {
return NULL;
}
texture = m_texture;
}
return texture;
}
HRESULT STDMETHODCALLTYPE CMyCompositor9::CompositeImage(
/* [in] */ IUnknown *pD3DDevice,
/* [in] */ IDirect3DSurface9 *pddsRenderTarget,
/* [in] */ AM_MEDIA_TYPE *pmtRenderTarget,
/* [in] */ REFERENCE_TIME rtStart,
/* [in] */ REFERENCE_TIME rtEnd,
/* [in] */ D3DCOLOR dwClrBkGnd,
/* [in] */ VMR9VideoStreamInfo *pVideoStreamInfo,
/* [in] */ UINT cStreams)
{
ASSERT( pD3DDevice );
if( pD3DDevice == NULL ) {
return E_POINTER;
}
HRESULT hr;
SmartPtr<IDirect3DDevice9> d3ddev;
pD3DDevice->QueryInterface(__uuidof(IDirect3DDevice9), (void**)&d3ddev);
ASSERT( d3ddev );
FAIL_RET( d3ddev->SetRenderState( D3DRS_AMBIENT, 0x00202020 ) );
FAIL_RET( d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE ) );
FAIL_RET( d3ddev->SetRenderState( D3DRS_CULLMODE,D3DCULL_NONE));
FAIL_RET( d3ddev->SetRenderState( D3DRS_ZENABLE,TRUE));
FAIL_RET( AdjustViewMatrix( d3ddev ) );
// write the new vertex information into the buffer
void* pData;
FAIL_RET( m_vertexBuffer->Lock(0, sizeof m_vertices, &pData,0) );
memcpy(pData,m_vertices,sizeof(m_vertices));
FAIL_RET( m_vertexBuffer->Unlock() );
FAIL_RET( d3ddev->SetDepthStencilSurface( m_zSurface) );
// clear the scene so we don't have any articats left
d3ddev->Clear( 0L, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
D3DCOLOR_XRGB(128,128,255), 1.0f, 0L );
FAIL_RET( d3ddev->BeginScene() );
FAIL_RET( d3ddev->SetStreamSource(0, m_vertexBuffer, 0, sizeof( CUSTOMVERTEX) ) );
FAIL_RET( d3ddev->SetFVF( D3DFVF_CUSTOMVERTEX ) );
FAIL_RET( d3ddev->SetTexture( 0, GetTexture( d3ddev, pVideoStreamInfo + 0 % cStreams ) ) );
FAIL_RET( d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP,0,2) );
FAIL_RET( d3ddev->SetTexture( 0, GetTexture( d3ddev, pVideoStreamInfo + 1 % cStreams ) ) );
FAIL_RET( d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP,4,2) );
FAIL_RET( d3ddev->SetTexture( 0, GetTexture( d3ddev, pVideoStreamInfo + 2 % cStreams ) ) );
FAIL_RET( d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP,8,2) );
FAIL_RET( d3ddev->EndScene());
return S_OK;
}
// IUnknown
HRESULT STDMETHODCALLTYPE CMyCompositor9::QueryInterface(
REFIID riid,
void** ppvObject)
{
HRESULT hr = E_NOINTERFACE;
if( ppvObject == NULL ) {
hr = E_POINTER;
}
else if( riid == IID_IVMRImageCompositor9 ) {
*ppvObject = static_cast<IVMRImageCompositor9*>( this );
AddRef();
hr = S_OK;
}
else if( riid == IID_IUnknown ) {
*ppvObject =
static_cast<IUnknown*>( this );
AddRef();
hr = S_OK;
}
return hr;
}
ULONG STDMETHODCALLTYPE CMyCompositor9::AddRef()
{
return InterlockedIncrement(& m_refCount);
}
ULONG STDMETHODCALLTYPE CMyCompositor9::Release()
{
ULONG ret = InterlockedDecrement(& m_refCount);
if( ret == 0 )
{
delete this;
}
return ret;
}
void CMyCompositor9::ChangeX( int X )
{
m_needTurn = true;
m_x = X;
}
void CMyCompositor9::ChangeY( int Y )
{
m_needTurn = true;
m_y = Y;
}
HRESULT CMyCompositor9::AdjustViewMatrix( IDirect3DDevice9* d3ddev )
{
ASSERT( d3ddev );
HRESULT hr;
if( m_needTurn == false ) {
return S_FALSE;
}
//
// view matrix
//
float x, y;
x = float( m_x ) / 100 ;
y = float( m_y ) / 100 ;
D3DVECTOR from = { x, y, -4.0f };
D3DVECTOR at = { 0.0f, 1.0f, 0.0f };
D3DVECTOR up = { 0.0f, 1.0f, 0.0f };
D3DMATRIX matView;
MatrixLookAtLH(&matView, &from, &at, &up);
FAIL_RET( d3ddev->SetTransform( D3DTS_VIEW, &matView ) );
m_needTurn = false;
return hr;
}
//////////////////////////////////////////////////////////////////////
//
// Matrix functions
//
// The purpose of these functions is to remove any dependencies on
// the D3DX utility library from this sample. The functions are
// modeled after the equivalent D3DX functions. In a real application,
// you should use the D3DX library instead.
//
//////////////////////////////////////////////////////////////////////
template <class T>
inline T SQUARED(T x)
{
return x * x;
}
D3DVECTOR* VecSubtract(D3DVECTOR *pOut, const D3DVECTOR *pV1, const D3DVECTOR *pV2)
{
pOut->x = pV1->x - pV2->x;
pOut->y = pV1->y - pV2->y;
pOut->z = pV1->z - pV2->z;
return pOut;
}
D3DVECTOR* VecNormalize(D3DVECTOR *pOut, const D3DVECTOR *pV1)
{
FLOAT norm_sq = SQUARED(pV1->x) + SQUARED(pV1->y) + SQUARED(pV1->z);
if (norm_sq > FLT_MIN)
{
FLOAT f = sqrtf(norm_sq);
pOut->x = pV1->x / f;
pOut->y = pV1->y / f;
pOut->z = pV1->z / f;
}
else
{
pOut->x = 0.0f;
pOut->y = 0.0f;
pOut->z = 0.0f;
}
return pOut;
}
D3DVECTOR* VecCross(D3DVECTOR *pOut, const D3DVECTOR *pV1, const D3DVECTOR *pV2)
{
pOut->x = pV1->y * pV2->z - pV1->z * pV2->y;
pOut->y = pV1->z * pV2->x - pV1->x * pV2->z;
pOut->z = pV1->x * pV2->y - pV1->y * pV2->x;
return pOut;
}
FLOAT VecDot(const D3DVECTOR *pV1, const D3DVECTOR *pV2)
{
return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z;
}
// MatrixLookAtLH: Approximately equivalent to D3DXMatrixLookAtLH.
D3DMATRIX* MatrixLookAtLH(
D3DMATRIX *pOut,
const D3DVECTOR *pEye,
const D3DVECTOR *pAt,
const D3DVECTOR *pUp
)
{
D3DVECTOR vecX, vecY, vecZ;
// Compute direction of gaze. (+Z)
VecSubtract(&vecZ, pAt, pEye);
VecNormalize(&vecZ, &vecZ);
// Compute orthogonal axes from cross product of gaze and pUp vector.
VecCross(&vecX, pUp, &vecZ);
VecNormalize(&vecX, &vecX);
VecCross(&vecY, &vecZ, &vecX);
// Set rotation and translate by pEye
pOut->_11 = vecX.x;
pOut->_21 = vecX.y;
pOut->_31 = vecX.z;
pOut->_41 = -VecDot(&vecX, pEye);
pOut->_12 = vecY.x;
pOut->_22 = vecY.y;
pOut->_32 = vecY.z;
pOut->_42 = -VecDot(&vecY, pEye);
pOut->_13 = vecZ.x;
pOut->_23 = vecZ.y;
pOut->_33 = vecZ.z;
pOut->_43 = -VecDot(&vecZ, pEye);
pOut->_14 = 0.0f;
pOut->_24 = 0.0f;
pOut->_34 = 0.0f;
pOut->_44 = 1.0f;
return pOut;
}
// MatrixPerspectiveFovLH: Approximately equivalent to D3DXMatrixPerspectiveFovLH.
D3DMATRIX* MatrixPerspectiveFovLH(
D3DMATRIX * pOut,
FLOAT fovy,
FLOAT Aspect,
FLOAT zn,
FLOAT zf
)
{
// yScale = cot(fovy/2)
FLOAT yScale = cosf(fovy * 0.5f) / sinf(fovy * 0.5f);
FLOAT xScale = yScale / Aspect;
ZeroMemory(pOut, sizeof(D3DMATRIX));
pOut->_11 = xScale;
pOut->_22 = yScale;
pOut->_33 = zf / (zf - zn);
pOut->_34 = 1.0f;
pOut->_43 = -pOut->_33 * zn;
return pOut;
}
Reference in New Issue View Git Blame Copy Permalink