RiskYourLife/Client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5d3cd64a2585d4240fd9ac17917af05aa7ee326a
Client/Library/dxx8/samples/Multimedia/DirectShow_WinXP/VMR/VMRXcl/Utils.cpp
LGram16 e067522598 Initial commit: ROW Client source code 
Game client codebase including:
- CharacterActionControl: Character and creature management
- GlobalScript: Network, items, skills, quests, utilities
- RYLClient: Main client application with GUI and event handlers
- Engine: 3D rendering engine (RYLGL)
- MemoryManager: Custom memory allocation
- Library: Third-party dependencies (DirectX, boost, etc.)
- Tools: Development utilities

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
2025-11-29 16:24:34 +09:00

562 lines
18 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// File: Utils.h
//
// Desc: DirectShow sample code
// External (global) utilities specific for VMRXcl app
//
// Copyright (c) 2000-2001 Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
#include "project.h"
#include "utils.h"
//-----------------------------------------------------------------------------------------
// Function: hresultNameLookup
// Purpose: returns a string value for the given hresult
// Arguments: HRESULT that needs verifying
// Returns: string
//-----------------------------------------------------------------------------------------*/
const char * hresultNameLookup(HRESULT hres)
{
switch(hres)
{
case VFW_E_CANNOT_RENDER:
return "VFW_E_CANNOT_RENDER";
break;
case VFW_E_INVALID_FILE_FORMAT:
return "VFW_E_INVALID_FILE_FORMAT";
break;
case VFW_E_NOT_FOUND:
return "VFW_E_NOT_FOUND";
break;
case VFW_E_NOT_IN_GRAPH:
return "VFW_E_NOT_IN_GRAPH";
break;
case VFW_E_UNKNOWN_FILE_TYPE:
return "VFW_E_UNKNOWN_FILE_TYPE";
break;
case VFW_E_UNSUPPORTED_STREAM:
return "VFW_E_UNSUPPORTED_STREAM";
break;
case VFW_E_CANNOT_CONNECT:
return "VFW_E_CANNOT_CONNECT";
break;
case VFW_E_CANNOT_LOAD_SOURCE_FILTER:
return "VFW_E_CANNOT_LOAD_SOURCE_FILTER";
break;
case VFW_S_PARTIAL_RENDER:
return "VFW_S_PARTIAL_RENDER";
break;
case VFW_S_VIDEO_NOT_RENDERED:
return "VFW_S_VIDEO_NOT_RENDERED";
break;
case VFW_S_AUDIO_NOT_RENDERED:
return "VFW_S_AUDIO_NOT_RENDERED";
break;
case VFW_S_DUPLICATE_NAME:
return "VFW_S_DUPLICATE_NAME";
break;
case VFW_S_MEDIA_TYPE_IGNORED:
return "VFW_S_MEDIA_TYPE_IGNORED";
break;
case E_INVALIDARG:
return "E_INVALIDARG";
break;
case DDERR_INCOMPATIBLEPRIMARY:
return "DDERR_INCOMPATIBLEPRIMARY";
break;
case DDERR_INVALIDCAPS:
return "DDERR_INVALIDCAPS";
break;
case DDERR_INVALIDOBJECT :
return "DDERR_INVALIDOBJECT";
break;
case DDERR_INVALIDPIXELFORMAT:
return "DDERR_INVALIDPIXELFORMAT";
break;
case DDERR_NOALPHAHW :
return "DDERR_NOALPHAHW";
break;
case DDERR_NOCOOPERATIVELEVELSET :
return "DDERR_NOCOOPERATIVELEVELSET";
break;
case DDERR_NODIRECTDRAWHW :
return "DDERR_NODIRECTDRAWHW";
break;
case DDERR_NOEMULATION :
return "DDERR_NOEMULATION";
break;
case VFW_E_BUFFERS_OUTSTANDING:
return "VFW_E_BUFFERS_OUTSTANDING";
break;
case DDERR_NOEXCLUSIVEMODE :
return "DDERR_NOEXCLUSIVEMODE ";
break;
case DDERR_NOFLIPHW:
return "DDERR_NOFLIPHW";
break;
case DDERR_NOMIPMAPHW:
return "DDERR_NOMIPMAPHW";
break;
case DDERR_NOOVERLAYHW :
return "DDERR_NOOVERLAYHW ";
break;
case E_OUTOFMEMORY:
return "E_OUTOFMEMORY";
break;
case VFW_E_NO_DISPLAY_PALETTE:
return "VFW_E_NO_DISPLAY_PALETTE";
break;
case VFW_E_NO_COLOR_KEY_FOUND:
return "VFW_E_NO_COLOR_KEY_FOUND";
break;
case VFW_E_PALETTE_SET:
return "VFW_E_PALETTE_SET";
break;
case DDERR_NOZBUFFERHW :
return "DDERR_NOZBUFFERHW ";
break;
case DDERR_OUTOFVIDEOMEMORY :
return "DDERR_OUTOFVIDEOMEMORY";
break;
case DDERR_PRIMARYSURFACEALREADYEXISTS:
return "DDERR_PRIMARYSURFACEALREADYEXISTS ";
break;
case DDERR_UNSUPPORTEDMODE:
return "DDERR_UNSUPPORTEDMODE";
break;
case VFW_E_NO_ADVISE_SET:
return "VFW_E_NO_ADVISE_SET";
break;
case S_OK:
return "S_OK";
break;
case S_FALSE:
return "S_FALSE";
break;
case VFW_S_CONNECTIONS_DEFERRED:
return "VFW_S_CONNECTIONS_DEFERRED";
break;
case 0x80040154:
return "Class not registered";
break;
case E_FAIL:
return "E_FAIL";
break;
case VFW_E_DVD_OPERATION_INHIBITED:
return "VFW_E_DVD_OPERATION_INHIBITED";
break;
case VFW_E_DVD_INVALIDDOMAIN:
return "VFW_E_DVD_INVALIDDOMAIN";
break;
case E_NOTIMPL:
return "E_NOTIMPL";
break;
case VFW_E_WRONG_STATE:
return "VFW_E_WRONG_STATE";
break;
case E_PROP_SET_UNSUPPORTED:
return "E_PROP_SET_UNSUPPORTED";
break;
case VFW_E_NO_PALETTE_AVAILABLE:
return "VFW_E_NO_PALETTE_AVAILABLE";
break;
case E_UNEXPECTED:
return "E_UNEXPECTED";
break;
case VFW_E_DVD_NO_BUTTON:
return "VFW_E_DVD_NO_BUTTON";
break;
case VFW_E_DVD_GRAPHNOTREADY:
return "VFW_E_DVD_GRAPHNOTREADY";
break;
case VFW_E_NOT_OVERLAY_CONNECTION:
return "VFW_E_NOT_OVERLAY_CONNECTION";
break;
case VFW_E_DVD_RENDERFAIL:
return "VFW_E_DVD_RENDERFAIL";
break;
case VFW_E_NOT_CONNECTED:
return "VFW_E_NOT_CONNECTED";
break;
case E_NOINTERFACE:
return "E_NOINTERFACE";
break;
case VFW_E_NO_COLOR_KEY_SET :
return "VFW_E_NO_COLOR_KEY_SET ";
break;
case VFW_E_NO_INTERFACE:
return "VFW_E_NO_INTERFACE";
break;
case 0x8004020c:
return "VFW_E_BUFFER_NOTSET";
break;
case 0x80040225:
return "VFW_E_NOT_PAUSED";
case 0x80070002:
return "System cannot find the file specified";
break;
case 0x80070003:
return "System cannot find the path specified";
break;
case VFW_E_DVD_DECNOTENOUGH:
return "VFW_E_DVD_DECNOTENOUGH";
break;
case VFW_E_ADVISE_ALREADY_SET:
return "VFW_E_ADVISE_ALREADY_SET";
break;
case VFW_E_DVD_CMD_CANCELLED:
return "VFW_E_DVD_CMD_CANCELLED";
break;
case VFW_E_DVD_MENU_DOES_NOT_EXIST:
return "VFW_E_DVD_MENU_DOES_NOT_EXIST";
break;
case VFW_E_DVD_WRONG_SPEED:
return "VFW_E_DVD_WRONG_SPEED";
break;
case VFW_S_DVD_NON_ONE_SEQUENTIAL:
return "VFW_S_DVD_NON_ONE_SEQUENTIAL";
break;
case E_POINTER:
return "E_POINTER";
break;
case VFW_E_DVD_NOT_IN_KARAOKE_MODE:
return "VFW_E_DVD_NOT_IN_KARAOKE_MODE";
break;
case VFW_E_DVD_INVALID_DISC:
return "VFW_E_DVD_INVALID_DISC";
break;
case VFW_E_DVD_STREAM_DISABLED:
return "VFW_E_DVD_STREAM_DISABLED";
break;
case VFW_E_NOT_STOPPED:
return "VFW_E_NOT_STOPPED";
break;
default:
return "Unrecognized";
break;
}
}
/*-----------------------------------------------------------------------------------------
| Function: MySleep
| Purpose: if the application is in automated mode, then sleep func is turned off
| Arguments: checks m_bAutomatedStatus to see if the func is in automation
| Returns: true if automated, false otherwist
\-----------------------------------------------------------------------------------------*/
bool MySleep(DWORD dwTime)
{
HANDLE hNeverHappensEvent;
hNeverHappensEvent = CreateEvent(NULL, FALSE, FALSE, "EVENTTHATNEVERHAPPENS");
WaitForSingleObject( hNeverHappensEvent, dwTime);
return false;
} // end of checkHResult method
void ReportDDrawSurfDesc( DDSURFACEDESC2 ddsd)
{
char szFlags[4096];
char szMsg[4096];
OutputDebugString("*** Surface description ***\n");
SurfaceDescHelper( ddsd.dwFlags, szFlags);
OutputDebugString(szFlags);
sprintf( szMsg, " dwWidth x dwHeight: %ld x %ld\n", ddsd.dwWidth, ddsd.dwHeight);
OutputDebugString(szMsg);
sprintf( szMsg, " lPitch: %ld\n", ddsd.lPitch);
OutputDebugString(szMsg);
OutputDebugString(" (dwLinearSize)\n");
sprintf( szMsg, " dwBackBufferCount: %ld\n", ddsd.dwBackBufferCount);
OutputDebugString(szMsg);
sprintf( szMsg, " dwMipMapCount: %ld\n", ddsd.dwMipMapCount);
OutputDebugString(szMsg);
OutputDebugString(" (dwRefreshRate)");
sprintf( szMsg, " dwAlphaBitDepth: %ld\n", (LONG)ddsd.dwAlphaBitDepth);
OutputDebugString(szMsg);
sprintf( szMsg, " lpSurface: %x\n", (LONG_PTR)(ddsd.lpSurface));
OutputDebugString(szMsg);
ReportPixelFormat( ddsd.ddpfPixelFormat );
ReportDDSCAPS2( ddsd.ddsCaps );
sprintf( szMsg, " dwTextureStage: %ld\n", ddsd.dwTextureStage);
OutputDebugString(szMsg);
OutputDebugString("***************************\n");
}
void ReportDDSCAPS2( DDSCAPS2 ddscaps )
{
char sz[4096];
strcpy( sz, " DDSCAPS2::dwCaps: ");
if( ddscaps.dwCaps & DDSCAPS_3DDEVICE ) strcat( sz, "DDSCAPS_3DDEVICE, ");
if( ddscaps.dwCaps & DDSCAPS_ALLOCONLOAD ) strcat( sz, "DDSCAPS_ALLOCONLOAD, ");
if( ddscaps.dwCaps & DDSCAPS_ALPHA ) strcat( sz, "DDSCAPS_ALPHA, ");
if( ddscaps.dwCaps & DDSCAPS_BACKBUFFER ) strcat( sz, "DDSCAPS_BACKBUFFER, ");
if( ddscaps.dwCaps & DDSCAPS_COMPLEX ) strcat( sz, "DDSCAPS_COMPLEX, ");
if( ddscaps.dwCaps & DDSCAPS_FLIP ) strcat( sz, "DDSCAPS_FLIP, ");
if( ddscaps.dwCaps & DDSCAPS_FRONTBUFFER ) strcat( sz, "DDSCAPS_FRONTBUFFER, ");
if( ddscaps.dwCaps & DDSCAPS_HWCODEC ) strcat( sz, "DDSCAPS_HWCODEC, ");
if( ddscaps.dwCaps & DDSCAPS_LIVEVIDEO ) strcat( sz, "DDSCAPS_LIVEVIDEO, ");
if( ddscaps.dwCaps & DDSCAPS_LOCALVIDMEM ) strcat( sz, "DDSCAPS_LOCALVIDMEM, ");
if( ddscaps.dwCaps & DDSCAPS_MIPMAP ) strcat( sz, "DDSCAPS_MIPMAP, ");
if( ddscaps.dwCaps & DDSCAPS_MODEX ) strcat( sz, "DDSCAPS_MODEX, ");
if( ddscaps.dwCaps & DDSCAPS_NONLOCALVIDMEM ) strcat( sz, "DDSCAPS_NONLOCALVIDMEM, ");
if( ddscaps.dwCaps & DDSCAPS_OFFSCREENPLAIN ) strcat( sz, "DDSCAPS_OFFSCREENPLAIN, ");
if( ddscaps.dwCaps & DDSCAPS_OPTIMIZED ) strcat( sz, "DDSCAPS_OPTIMIZED, ");
if( ddscaps.dwCaps & DDSCAPS_OVERLAY ) strcat( sz, "DDSCAPS_OVERLAY, ");
if( ddscaps.dwCaps & DDSCAPS_OWNDC ) strcat( sz, "DDSCAPS_OWNDC, ");
if( ddscaps.dwCaps & DDSCAPS_PALETTE ) strcat( sz, "DDSCAPS_PALETTE, ");
if( ddscaps.dwCaps & DDSCAPS_PRIMARYSURFACE ) strcat( sz, "DDSCAPS_PRIMARYSURFACE, ");
if( ddscaps.dwCaps & DDSCAPS_STANDARDVGAMODE ) strcat( sz, "DDSCAPS_STANDARDVGAMODE, ");
if( ddscaps.dwCaps & DDSCAPS_SYSTEMMEMORY ) strcat( sz, "DDSCAPS_SYSTEMMEMORY, ");
if( ddscaps.dwCaps & DDSCAPS_TEXTURE ) strcat( sz, "DDSCAPS_TEXTURE, ");
if( ddscaps.dwCaps & DDSCAPS_VIDEOMEMORY ) strcat( sz, "DDSCAPS_VIDEOMEMORY, ");
if( ddscaps.dwCaps & DDSCAPS_VIDEOPORT ) strcat( sz, "DDSCAPS_VIDEOPORT, ");
if( ddscaps.dwCaps & DDSCAPS_VISIBLE ) strcat( sz, "DDSCAPS_VISIBLE, ");
if( ddscaps.dwCaps & DDSCAPS_WRITEONLY ) strcat( sz, "DDSCAPS_WRITEONLY, ");
if( ddscaps.dwCaps & DDSCAPS_ZBUFFER ) strcat( sz, "DDSCAPS_ZBUFFER, ");
strcat( sz, "\n");
OutputDebugString(sz);
strcpy( sz, " DDSCAPS2::dwCaps2: ");
if( ddscaps.dwCaps2 & DDSCAPS2_CUBEMAP ) strcat( sz, "DDSCAPS2_CUBEMAP, ");
if( ddscaps.dwCaps2 & DDSCAPS2_CUBEMAP_POSITIVEX ) strcat( sz, "DDSCAPS2_CUBEMAP_POSITIVEX, ");
if( ddscaps.dwCaps2 & DDSCAPS2_CUBEMAP_NEGATIVEX ) strcat( sz, "DDSCAPS2_CUBEMAP_NEGATIVEX, ");
if( ddscaps.dwCaps2 & DDSCAPS2_CUBEMAP_POSITIVEY ) strcat( sz, "DDSCAPS2_CUBEMAP_POSITIVEY, ");
if( ddscaps.dwCaps2 & DDSCAPS2_CUBEMAP_NEGATIVEY ) strcat( sz, "DDSCAPS2_CUBEMAP_NEGATIVEY, ");
if( ddscaps.dwCaps2 & DDSCAPS2_CUBEMAP_POSITIVEZ ) strcat( sz, "DDSCAPS2_CUBEMAP_POSITIVEZ, ");
if( ddscaps.dwCaps2 & DDSCAPS2_CUBEMAP_NEGATIVEZ ) strcat( sz, "DDSCAPS2_CUBEMAP_NEGATIVEZ, ");
if( ddscaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES ) strcat( sz, "DDSCAPS2_CUBEMAP_ALLFACES, ");
if( ddscaps.dwCaps2 & DDSCAPS2_D3DTEXTUREMANAGE ) strcat( sz, "DDSCAPS2_D3DTEXTUREMANAGE, ");
if( ddscaps.dwCaps2 & DDSCAPS2_DONOTPERSIST ) strcat( sz, "DDSCAPS2_DONOTPERSIST, ");
if( ddscaps.dwCaps2 & DDSCAPS2_HARDWAREDEINTERLACE ) strcat( sz, "DDSCAPS2_HARDWAREDEINTERLACE, ");
if( ddscaps.dwCaps2 & DDSCAPS2_HINTANTIALIASING ) strcat( sz, "DDSCAPS2_HINTANTIALIASING, ");
if( ddscaps.dwCaps2 & DDSCAPS2_HINTDYNAMIC ) strcat( sz, "DDSCAPS2_HINTDYNAMIC, ");
if( ddscaps.dwCaps2 & DDSCAPS2_HINTSTATIC ) strcat( sz, "DDSCAPS2_HINTSTATIC, ");
if( ddscaps.dwCaps2 & DDSCAPS2_MIPMAPSUBLEVEL ) strcat( sz, "DDSCAPS2_MIPMAPSUBLEVEL, ");
if( ddscaps.dwCaps2 & DDSCAPS2_OPAQUE ) strcat( sz, "DDSCAPS2_OPAQUE, ");
if( ddscaps.dwCaps2 & DDSCAPS2_STEREOSURFACELEFT ) strcat( sz, "DDSCAPS2_STEREOSURFACELEFT, ");
if( ddscaps.dwCaps2 & DDSCAPS2_TEXTUREMANAGE ) strcat( sz, "DDSCAPS2_TEXTUREMANAGE, ");
strcat( sz, "\n");
OutputDebugString(sz);
}
void ReportPixelFormat( DDPIXELFORMAT ddpf)
{
char szFlags[4096];
char szMsg[MAX_PATH];
PixelFormatHelper( ddpf.dwFlags, szFlags);
OutputDebugString(szFlags);
sprintf( szMsg, " dwFourCC: %ld\n", ddpf.dwFourCC);
OutputDebugString(szMsg);
sprintf( szMsg, " dwRGBBitCount: %ld\n", ddpf.dwRGBBitCount);
OutputDebugString(szMsg);
OutputDebugString(" (dwYUVBitCount, dwZBufferBitDepth, dwAlphaBitDepth, dwLuminanceBitCount, dwBumpBitCount)\n");
sprintf( szMsg, " dwRBitMask: %ld\n", ddpf.dwRBitMask);
OutputDebugString(szMsg);
OutputDebugString(" (dwYBitMask, dwStencilBitDepth, dwLuminanceBitMask, dwBumpDuBitMask)\n");
sprintf( szMsg, " dwGBitMask: %ld\n", ddpf.dwGBitMask);
OutputDebugString(szMsg);
OutputDebugString(" (dwUBitMask, dwZBitMask, dwBumpDvBitMask)\n");
sprintf( szMsg, " dwBBitMask: %ld\n", ddpf.dwBBitMask);
OutputDebugString(szMsg);
OutputDebugString(" (dwVBitMask, dwStencilBitMask, dwBumpLuminanceBitMask)\n");
sprintf( szMsg, " dwRGBAlphaBitMask: %ld\n", ddpf.dwRGBAlphaBitMask);
OutputDebugString(szMsg);
OutputDebugString(" (dwYUVAlphaBitMask, dwLuminanceAlphaBitMask, dwRGBZBitMask, dwYUVZBitMask)\n");
}
void SurfaceDescHelper( DWORD dwFlags, char * pszFlags )
{
if( !pszFlags )
{
return;
}
strcpy( pszFlags, " dwFlags: ");
if( dwFlags & DDSD_ALL )
strcat( pszFlags, "DDSD_ALL\n");
if( dwFlags & DDSD_ALPHABITDEPTH )
strcat( pszFlags, "DDSD_ALPHABITDEPTH\n");
if( dwFlags & DDSD_BACKBUFFERCOUNT )
strcat( pszFlags, "DDSD_BACKBUFFERCOUNT\n");
if( dwFlags & DDSD_CAPS )
strcat( pszFlags, "DDSD_CAPS\n");
if( dwFlags & DDSD_CKDESTBLT )
strcat( pszFlags, "DDSD_CKDESTBLT\n");
if( dwFlags & DDSD_CKDESTOVERLAY )
strcat( pszFlags, "DDSD_CKDESTOVERLAY\n");
if( dwFlags & DDSD_CKSRCBLT )
strcat( pszFlags, "DDSD_CKSRCBLT\n");
if( dwFlags & DDSD_CKSRCOVERLAY )
strcat( pszFlags, "DDSD_CKSRCOVERLAY\n");
if( dwFlags & DDSD_HEIGHT )
strcat( pszFlags, "DDSD_HEIGHT\n");
if( dwFlags & DDSD_LINEARSIZE )
strcat( pszFlags, "DDSD_LINEARSIZE\n");
if( dwFlags & DDSD_LPSURFACE )
strcat( pszFlags, "DDSD_LPSURFACE\n");
if( dwFlags & DDSD_MIPMAPCOUNT )
strcat( pszFlags, "DDSD_MIPMAPCOUNT\n");
if( dwFlags & DDSD_PITCH )
strcat( pszFlags, "DDSD_PITCH\n");
if( dwFlags & DDSD_PIXELFORMAT )
strcat( pszFlags, "DDSD_PIXELFORMAT\n");
if( dwFlags & DDSD_REFRESHRATE )
strcat( pszFlags, "DDSD_REFRESHRATE\n");
if( dwFlags & DDSD_TEXTURESTAGE )
strcat( pszFlags, "DDSD_TEXTURESTAGE\n");
if( dwFlags & DDSD_WIDTH )
strcat( pszFlags, "DDSD_WIDTH\n");
strcat(pszFlags, "\n");
}
void PixelFormatHelper( DWORD dwFlags, char * pszFlags)
{
if( !pszFlags )
{
return;
}
strcpy( pszFlags, " dwFlags: ");
if( dwFlags & DDPF_ALPHA )
strcat( pszFlags, "DDPF_ALPHA, ");
if( dwFlags & DDPF_ALPHAPIXELS )
strcat( pszFlags, "DDPF_ALPHAPIXELS, ");
if( dwFlags & DDPF_ALPHAPREMULT )
strcat( pszFlags, "DDPF_ALPHAPREMULT, ");
if( dwFlags & DDPF_BUMPLUMINANCE )
strcat( pszFlags, "DDPF_BUMPLUMINANCE, ");
if( dwFlags & DDPF_BUMPDUDV )
strcat( pszFlags, "DDPF_BUMPDUDV, ");
if( dwFlags & DDPF_COMPRESSED )
strcat( pszFlags, "DDPF_COMPRESSED, ");
if( dwFlags & DDPF_FOURCC )
strcat( pszFlags, "DDPF_FOURCC, ");
if( dwFlags & DDPF_LUMINANCE )
strcat( pszFlags, "DDPF_LUMINANCE, ");
if( dwFlags & DDPF_PALETTEINDEXED1 )
strcat( pszFlags, "DDPF_PALETTEINDEXED1, ");
if( dwFlags & DDPF_PALETTEINDEXED2 )
strcat( pszFlags, "DDPF_PALETTEINDEXED2, ");
if( dwFlags & DDPF_PALETTEINDEXED4 )
strcat( pszFlags, "DDPF_PALETTEINDEXED4, ");
if( dwFlags & DDPF_PALETTEINDEXED8 )
strcat( pszFlags, "DDPF_PALETTEINDEXED8, ");
if( dwFlags & DDPF_PALETTEINDEXEDTO8 )
strcat( pszFlags, "DDPF_PALETTEINDEXEDTO8, ");
if( dwFlags & DDPF_RGB )
strcat( pszFlags, "DDPF_RGB, ");
if( dwFlags & DDPF_RGBTOYUV )
strcat( pszFlags, "DDPF_RGBTOYUV, ");
if( dwFlags & DDPF_STENCILBUFFER )
strcat( pszFlags, "DDPF_STENCILBUFFER, ");
if( dwFlags & DDPF_YUV )
strcat( pszFlags, "DDPF_YUV, ");
if( dwFlags & DDPF_ZBUFFER )
strcat( pszFlags, "DDPF_ZBUFFER, ");
if( dwFlags & DDPF_ZPIXELS )
strcat( pszFlags, "DDPF_ZPIXELS, ");
strcat( pszFlags, "\n");
}
/*****************************Private*Routine******************************\
* VerifyVMR
*
\**************************************************************************/
BOOL VerifyVMR(void)
{
HRESULT hres;
CoInitialize(NULL);
// Verify that the VMR exists on this system
IBaseFilter* pBF = NULL;
hres = CoCreateInstance(CLSID_VideoMixingRenderer,
NULL,
CLSCTX_INPROC,
IID_IBaseFilter,
(LPVOID *)&pBF);
if(SUCCEEDED(hres))
{
pBF->Release();
CoUninitialize();
return TRUE;
}
else
{
MessageBox(hwndApp,
TEXT("This application requires the Video Mixing Renderer, which is present\r\n")
TEXT("only on Windows XP.\r\n\r\n")
TEXT("The Video Mixing Renderer (VMR) is also not enabled when viewing a \r\n")
TEXT("remote Windows XP machine through a Remote Desktop session.\r\n")
TEXT("You can run VMR-enabled applications only on your local machine.")
TEXT("\r\n\r\nThis sample will now exit."),
TEXT("Video Mixing Renderer capabilities are required"), MB_OK);
CoUninitialize();
return FALSE;
}
}
Reference in New Issue View Git Blame Copy Permalink