1442 lines
36 KiB
C++
1442 lines
36 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
// smp.cpp : Main window procedure
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "resource.h"
|
|
#include "initguid.h"
|
|
#include "CWMPHost.h"
|
|
#include <commctrl.h>
|
|
#include <windows.h>
|
|
#include <psapi.h>
|
|
#include <math.h>
|
|
#include <cstdio>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <strstream>
|
|
#include <fstream>
|
|
|
|
|
|
#include "IceKey.h"
|
|
|
|
|
|
CComModule _Module;
|
|
|
|
BEGIN_OBJECT_MAP(ObjectMap)
|
|
END_OBJECT_MAP()
|
|
|
|
|
|
#define ID_SKIP_FADE_TIMER 1
|
|
#define ID_DRAW_TIMER 2
|
|
|
|
|
|
const float FADE_TIME = 1.0f;
|
|
const int MAX_BLUR_STEPS = 100;
|
|
|
|
HINSTANCE g_hInstance;
|
|
HWND g_hBlackFadingWindow = 0;
|
|
bool g_bFadeIn = true;
|
|
bool g_bFrameCreated = false;
|
|
CWMPHost g_frame;
|
|
CWMPHost *g_pFrame = NULL;
|
|
HDC g_hdcCapture = 0;
|
|
HDC g_hdcBlend = 0;
|
|
HBITMAP g_hbmCapture = 0;
|
|
HBITMAP g_hbmBlend = 0;
|
|
HMONITOR g_hMonitor = 0;
|
|
|
|
int g_screenWidth = 0;
|
|
int g_screenHeight = 0;
|
|
|
|
LPTSTR g_lpCommandLine = NULL;
|
|
std::string g_redirectTarget;
|
|
std::string g_URL;
|
|
bool g_bReportStats = false;
|
|
bool g_bUseLocalSteamServer = false;
|
|
|
|
double g_timeAtFadeStart = 0.0;
|
|
int g_nBlurSteps = 0;
|
|
|
|
|
|
void LogPlayerEvent( EventType_t e );
|
|
|
|
|
|
enum OSVersion
|
|
{
|
|
OSV_95,
|
|
OSV_95OSR2,
|
|
OSV_98,
|
|
OSV_98SE,
|
|
OSV_ME,
|
|
OSV_NT4,
|
|
OSV_2000,
|
|
OSV_SERVER2003,
|
|
OSV_XP,
|
|
OSV_XPSP1,
|
|
OSV_XPSP2,
|
|
OSV_XPSP3,
|
|
OSV_VISTA,
|
|
OSV_UNKNOWN,
|
|
};
|
|
|
|
OSVersion DetectOSVersion()
|
|
{
|
|
OSVERSIONINFO version;
|
|
version.dwOSVersionInfoSize = sizeof( version );
|
|
GetVersionEx( &version );
|
|
if ( version.dwPlatformId & VER_PLATFORM_WIN32_WINDOWS )
|
|
{
|
|
if ( version.dwMajorVersion != 4 )
|
|
return OSV_UNKNOWN;
|
|
|
|
switch ( version.dwMinorVersion )
|
|
{
|
|
case 0:
|
|
return strstr( version.szCSDVersion, _TEXT( " C" ) ) == version.szCSDVersion ? OSV_95OSR2 : OSV_95;
|
|
case 10:
|
|
return ( strstr( version.szCSDVersion, _TEXT( " A" ) ) == version.szCSDVersion ) || ( strstr( version.szCSDVersion, _TEXT( " B" ) ) == version.szCSDVersion ) ? OSV_98SE : OSV_98;
|
|
case 90:
|
|
return OSV_ME;
|
|
}
|
|
}
|
|
else if ( version.dwPlatformId & VER_PLATFORM_WIN32_NT )
|
|
{
|
|
if ( version.dwMajorVersion == 4 )
|
|
return OSV_NT4; // or mabye NT3.5???
|
|
|
|
if ( version.dwMajorVersion == 6 )
|
|
return OSV_VISTA;
|
|
|
|
if ( version.dwMajorVersion != 5 )
|
|
return OSV_UNKNOWN;
|
|
|
|
switch ( version.dwMinorVersion )
|
|
{
|
|
case 0:
|
|
return OSV_2000;
|
|
case 1:
|
|
{
|
|
if ( version.szCSDVersion == NULL )
|
|
return OSV_XP;
|
|
|
|
if ( strstr( version.szCSDVersion, _TEXT( "Service Pack 1" ) ) != NULL )
|
|
return OSV_XPSP1;
|
|
|
|
if ( strstr( version.szCSDVersion, _TEXT( "Service Pack 2" ) ) != NULL )
|
|
return OSV_XPSP2;
|
|
|
|
if ( strstr( version.szCSDVersion, _TEXT( "Service Pack 3" ) ) != NULL )
|
|
return OSV_XPSP3;
|
|
}
|
|
case 2:
|
|
return OSV_SERVER2003; // or maybe XP64???
|
|
}
|
|
}
|
|
|
|
return OSV_UNKNOWN;
|
|
}
|
|
|
|
const OSVersion g_osVersion = DetectOSVersion();
|
|
|
|
|
|
|
|
#define BLUR
|
|
|
|
#define USE_D3D8
|
|
#ifdef USE_D3D8
|
|
|
|
#include <d3d8.h>
|
|
IDirect3D8* g_pD3D = NULL;
|
|
IDirect3DDevice8* g_pd3dDevice = NULL;
|
|
IDirect3DVertexBuffer8* g_pDrawVB = NULL;
|
|
IDirect3DTexture8* g_pImg = NULL;
|
|
int g_nDrawStride = 0;
|
|
DWORD g_dwDrawFVF = 0;
|
|
|
|
#ifdef BLUR
|
|
|
|
int g_nBlurStride = 0;
|
|
DWORD g_dwBlurFVF = 0;
|
|
IDirect3DVertexBuffer8* g_pBlurVB = NULL;
|
|
IDirect3DTexture8* g_pTex = NULL;
|
|
IDirect3DTexture8* g_pRT = NULL;
|
|
IDirect3DSurface8* g_pBackBuf = NULL;
|
|
|
|
#endif // BLUR
|
|
|
|
#endif // USE_D3D8
|
|
|
|
|
|
DWORD g_dwUseVMROverlayOldValue = 0;
|
|
bool g_bUseVMROverlayValueExists = false;
|
|
|
|
|
|
void SetRegistryValue( const char *pKeyName, const char *pValueName, DWORD dwValue, DWORD &dwOldValue, bool &bValueExisted )
|
|
{
|
|
HKEY hKey = 0;
|
|
LONG rval = RegCreateKeyEx( HKEY_CURRENT_USER, pKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, NULL );
|
|
if ( rval != ERROR_SUCCESS )
|
|
{
|
|
OutputDebugString( "unable to open registry key: " );
|
|
OutputDebugString( pKeyName );
|
|
OutputDebugString( "\n" );
|
|
return;
|
|
}
|
|
|
|
DWORD dwType = 0;
|
|
DWORD dwSize = sizeof( dwOldValue );
|
|
|
|
// amusingly enough, if pValueName doesn't exist, RegQueryValueEx returns ERROR_FILE_NOT_FOUND
|
|
rval = RegQueryValueEx( hKey, pValueName, NULL, &dwType, ( LPBYTE )&dwOldValue, &dwSize );
|
|
bValueExisted = ( rval == ERROR_SUCCESS );
|
|
|
|
rval = RegSetValueEx( hKey, pValueName, 0, REG_DWORD, ( CONST BYTE* )&dwValue, sizeof( dwValue ) );
|
|
if ( rval != ERROR_SUCCESS )
|
|
{
|
|
OutputDebugString( "unable to write registry value " );
|
|
OutputDebugString( pValueName );
|
|
OutputDebugString( " in key " );
|
|
OutputDebugString( pKeyName );
|
|
OutputDebugString( "\n" );
|
|
}
|
|
|
|
RegCloseKey( hKey );
|
|
}
|
|
|
|
void RestoreRegistryValue( const char *pKeyName, const char *pValueName, DWORD dwOldValue, bool bValueExisted )
|
|
{
|
|
HKEY hKey = 0;
|
|
LONG rval = RegCreateKeyEx( HKEY_CURRENT_USER, pKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, NULL );
|
|
if ( rval != ERROR_SUCCESS )
|
|
{
|
|
OutputDebugString( "unable to open registry key: " );
|
|
OutputDebugString( pKeyName );
|
|
OutputDebugString( "\n" );
|
|
return;
|
|
}
|
|
|
|
if ( bValueExisted )
|
|
{
|
|
rval = RegSetValueEx( hKey, pValueName, 0, REG_DWORD, ( CONST BYTE* )&dwOldValue, sizeof( dwOldValue ) );
|
|
}
|
|
else
|
|
{
|
|
rval = RegDeleteValue( hKey, pValueName );
|
|
}
|
|
if ( rval != ERROR_SUCCESS )
|
|
{
|
|
OutputDebugString( "SetRegistryValue FAILED!\n" );
|
|
}
|
|
|
|
RegCloseKey( hKey );
|
|
}
|
|
|
|
bool GetRegistryString( const char *pKeyName, const char *pValueName, const char *pValueString, int nValueLen )
|
|
{
|
|
HKEY hKey = 0;
|
|
LONG rval = RegCreateKeyEx( HKEY_CURRENT_USER, pKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, NULL );
|
|
if ( rval != ERROR_SUCCESS )
|
|
{
|
|
OutputDebugString( "unable to open registry key: " );
|
|
OutputDebugString( pKeyName );
|
|
OutputDebugString( "\n" );
|
|
return false;
|
|
}
|
|
|
|
DWORD dwType = 0;
|
|
rval = RegQueryValueEx( hKey, pValueName, NULL, &dwType, ( LPBYTE )pValueString, ( DWORD* )&nValueLen );
|
|
|
|
RegCloseKey( hKey );
|
|
|
|
if ( rval != ERROR_SUCCESS || dwType != REG_SZ )
|
|
{
|
|
OutputDebugString( "unable to read registry string: " );
|
|
OutputDebugString( pValueName );
|
|
OutputDebugString( "\n" );
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
struct EventData_t
|
|
{
|
|
EventData_t( int t, float pos, EventType_t e )
|
|
: time( t ), position( pos ), event( e )
|
|
{
|
|
}
|
|
int time; // real time
|
|
float position; // movie position
|
|
EventType_t event; // event type
|
|
};
|
|
|
|
const char *GetEventName( EventType_t event )
|
|
{
|
|
switch ( event )
|
|
{
|
|
case ET_APPLAUNCH: return "al";
|
|
case ET_APPEXIT: return "ae";
|
|
case ET_CLOSE: return "cl";
|
|
case ET_FADEOUT: return "fo";
|
|
|
|
case ET_MEDIABEGIN: return "mb";
|
|
case ET_MEDIAEND: return "me";
|
|
|
|
case ET_JUMPHOME: return "jh";
|
|
case ET_JUMPEND: return "je";
|
|
|
|
case ET_PLAY: return "pl";
|
|
case ET_PAUSE: return "ps";
|
|
case ET_STOP: return "st";
|
|
case ET_SCRUBFROM: return "jf";
|
|
case ET_SCRUBTO: return "jt";
|
|
case ET_STEPFWD: return "sf";
|
|
case ET_STEPBCK: return "sb";
|
|
case ET_JUMPFWD: return "jf";
|
|
case ET_JUMPBCK: return "jb";
|
|
case ET_REPEAT: return "rp";
|
|
|
|
case ET_MAXIMIZE: return "mx";
|
|
case ET_MINIMIZE: return "mn";
|
|
case ET_RESTORE: return "rs";
|
|
|
|
default: return "<unknown>";
|
|
}
|
|
}
|
|
|
|
std::vector< EventData_t > g_events;
|
|
|
|
void LogPlayerEvent( EventType_t e, float pos )
|
|
{
|
|
if ( !g_bReportStats )
|
|
return;
|
|
|
|
static int s_firstTick = GetTickCount();
|
|
int time = GetTickCount() - s_firstTick;
|
|
|
|
#if 0
|
|
char msg[ 256 ];
|
|
sprintf( msg, "event %s at time %d and pos %d\n", GetEventName( e ), time, int( 1000 * pos ) );
|
|
OutputDebugString( msg );
|
|
#endif
|
|
|
|
bool bDropEvent = false;
|
|
|
|
int nEvents = g_events.size();
|
|
if ( ( e == ET_STEPFWD || e == ET_STEPBCK ) && nEvents >= 2 )
|
|
{
|
|
const EventData_t &e1 = g_events[ nEvents - 1 ];
|
|
const EventData_t &e2 = g_events[ nEvents - 2 ];
|
|
if ( ( e1.event == e || e1.event == ET_REPEAT ) && e2.event == e )
|
|
{
|
|
// only store starting and ending stepfwd or stepbck events, since there can be so many
|
|
// also keep events that are more than a second apart
|
|
if ( e1.event == ET_REPEAT )
|
|
{
|
|
// keep dropping events while e1 isn't before a gap
|
|
bDropEvent = time - e1.time < 1000;
|
|
}
|
|
else
|
|
{
|
|
// e2 was kept last time, so keep e1 if e2 was kept because it was before a gap
|
|
bDropEvent = e1.time - e2.time < 1000;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bDropEvent )
|
|
{
|
|
g_events[ nEvents - 1 ] = EventData_t( time, pos, ET_REPEAT );
|
|
}
|
|
else
|
|
{
|
|
g_events.push_back( EventData_t( time, pos, e ) );
|
|
}
|
|
}
|
|
|
|
char C2M_UPLOADDATA = 'q';
|
|
char C2M_UPLOADDATA_PROTOCOL_VERSION = 1;
|
|
char C2M_UPLOADDATA_DATA_VERSION = 1;
|
|
|
|
inline void WriteHexDigit( std::ostream &os, byte src )
|
|
{
|
|
os.put( ( src <= 9 ) ? src + '0' : src - 10 + 'A' );
|
|
}
|
|
|
|
inline void WriteByte( std::ostream &os, byte src )
|
|
{
|
|
WriteHexDigit( os, src >> 4 );
|
|
WriteHexDigit( os, src & 0xf );
|
|
}
|
|
|
|
inline void WriteShort( std::ostream &os, unsigned short src )
|
|
{
|
|
WriteByte( os, ( byte )( ( src >> 8 ) & 0xff ) );
|
|
WriteByte( os, ( byte )( src & 0xff ) );
|
|
}
|
|
|
|
inline void WriteInt24( std::ostream &os, int src )
|
|
{
|
|
WriteByte( os, ( byte )( ( src >> 16 ) & 0xff ) );
|
|
WriteByte( os, ( byte )( ( src >> 8 ) & 0xff ) );
|
|
WriteByte( os, ( byte )( src & 0xff ) );
|
|
}
|
|
|
|
inline void WriteInt( std::ostream &os, int src )
|
|
{
|
|
WriteByte( os, ( byte )( ( src >> 24 ) & 0xff ) );
|
|
WriteByte( os, ( byte )( ( src >> 16 ) & 0xff ) );
|
|
WriteByte( os, ( byte )( ( src >> 8 ) & 0xff ) );
|
|
WriteByte( os, ( byte )( src & 0xff ) );
|
|
}
|
|
|
|
inline void WriteFloat( std::ostream &os, float src )
|
|
{
|
|
WriteInt( os, *( int* )&src );
|
|
}
|
|
|
|
void WriteUUID( std::ostream &os, const UUID &uuid )
|
|
{
|
|
WriteInt( os, uuid.Data1 );
|
|
WriteShort( os, uuid.Data2 );
|
|
WriteShort( os, uuid.Data3 );
|
|
for ( int i = 0; i < 8; ++i )
|
|
{
|
|
WriteByte( os, uuid.Data4[ i ] );
|
|
}
|
|
}
|
|
|
|
bool QueryOrGenerateUserID( UUID &userId )
|
|
{
|
|
HKEY hKey = 0;
|
|
LONG rval = RegCreateKeyEx( HKEY_CURRENT_USER, "Software\\Valve\\Steam", 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, NULL );
|
|
if ( rval != ERROR_SUCCESS )
|
|
{
|
|
UuidCreate( &userId );
|
|
return false;
|
|
}
|
|
|
|
DWORD dwType = 0;
|
|
unsigned char idstr[ 40 ];
|
|
DWORD dwSize = sizeof( idstr );
|
|
|
|
rval = RegQueryValueEx( hKey, "smpid", NULL, &dwType, ( LPBYTE )idstr, &dwSize );
|
|
if ( rval != ERROR_SUCCESS || dwType != REG_SZ )
|
|
{
|
|
UuidCreate( &userId );
|
|
|
|
unsigned char *outstring = NULL;
|
|
UuidToString( &userId, &outstring );
|
|
if ( outstring == NULL || *outstring == '\0' )
|
|
{
|
|
RegCloseKey( hKey );
|
|
return false;
|
|
}
|
|
|
|
rval = RegSetValueEx( hKey, "smpid", 0, REG_SZ, ( CONST BYTE* )outstring, sizeof( idstr ) );
|
|
|
|
RpcStringFree( &outstring );
|
|
RegCloseKey( hKey );
|
|
|
|
return rval == ERROR_SUCCESS;
|
|
}
|
|
|
|
if ( RPC_S_OK != UuidFromString( idstr, &userId ) )
|
|
return false;
|
|
|
|
RegCloseKey( hKey );
|
|
return true;
|
|
}
|
|
|
|
void PrintStats( const char *pStatsFilename )
|
|
{
|
|
std::ofstream os( pStatsFilename, std::ios_base::out | std::ios_base::binary );
|
|
|
|
// user id
|
|
UUID userId;
|
|
QueryOrGenerateUserID( userId );
|
|
unsigned char *userIdStr;
|
|
UuidToStringA( &userId, &userIdStr );
|
|
os << userIdStr << "\n";
|
|
RpcStringFree( &userIdStr );
|
|
|
|
// filename
|
|
int nOffset = g_URL.find_last_of( "/\\" );
|
|
if ( nOffset == g_URL.npos )
|
|
nOffset = 0;
|
|
std::string filename = g_URL.substr( nOffset + 1 );
|
|
os << filename << '\n';
|
|
|
|
// number of events
|
|
int nEvents = g_events.size();
|
|
os << nEvents << "\n";
|
|
|
|
// event data (tab-delimited)
|
|
for ( int i = 0; i < nEvents; ++i )
|
|
{
|
|
os << GetEventName( g_events[ i ].event ) << "\t";
|
|
os << g_events[ i ].time << "\t";
|
|
os << int( 1000 * g_events[ i ].position ) << "\n";
|
|
}
|
|
}
|
|
|
|
void UploadStats()
|
|
{
|
|
char pathname[ 256 ];
|
|
if ( !GetRegistryString( "Software\\Valve\\Steam", "SteamExe", pathname, sizeof( pathname ) ) )
|
|
return;
|
|
|
|
char *pExeName = strrchr( pathname, '/' );
|
|
if ( !pExeName )
|
|
return;
|
|
|
|
*pExeName = '\0'; // truncate exe filename to just pathname
|
|
|
|
char filename[ 256 ];
|
|
sprintf( filename, "%s/smpstats.txt", pathname );
|
|
|
|
PrintStats( filename );
|
|
|
|
::ShellExecuteA( NULL, "open", "steam://smp/smpstats.txt", NULL, NULL, SW_SHOWNORMAL );
|
|
}
|
|
|
|
void RestoreRegistry()
|
|
{
|
|
static bool s_bDone = false;
|
|
if ( s_bDone )
|
|
return;
|
|
|
|
s_bDone = true;
|
|
RestoreRegistryValue( "Software\\Microsoft\\MediaPlayer\\Preferences\\VideoSettings", "UseVMROverlay", g_dwUseVMROverlayOldValue, g_bUseVMROverlayValueExists );
|
|
}
|
|
|
|
|
|
#ifdef USE_D3D8
|
|
|
|
void CleanupD3D()
|
|
{
|
|
if ( g_pDrawVB )
|
|
{
|
|
g_pDrawVB->Release();
|
|
g_pDrawVB = NULL;
|
|
}
|
|
if ( g_pImg )
|
|
{
|
|
g_pImg->Release();
|
|
g_pImg = NULL;
|
|
}
|
|
#ifdef BLUR
|
|
if ( g_pBackBuf )
|
|
{
|
|
g_pBackBuf->Release();
|
|
g_pBackBuf = NULL;
|
|
}
|
|
if ( g_pBlurVB )
|
|
{
|
|
g_pBlurVB->Release();
|
|
g_pBlurVB = NULL;
|
|
}
|
|
if ( g_pTex )
|
|
{
|
|
g_pTex->Release();
|
|
g_pTex = NULL;
|
|
}
|
|
if ( g_pRT )
|
|
{
|
|
g_pRT->Release();
|
|
g_pRT = NULL;
|
|
}
|
|
#endif // BLUR
|
|
if ( g_pd3dDevice )
|
|
{
|
|
g_pd3dDevice->Release();
|
|
g_pd3dDevice = NULL;
|
|
}
|
|
if ( g_pD3D )
|
|
{
|
|
g_pD3D->Release();
|
|
g_pD3D = NULL;
|
|
}
|
|
}
|
|
|
|
void InitTextureStageState( int nStage, DWORD dwColorOp, DWORD dwColorArg1, DWORD dwColorArg2, DWORD dwColorArg0 = D3DTA_CURRENT )
|
|
{
|
|
g_pd3dDevice->SetTextureStageState( nStage, D3DTSS_COLOROP, dwColorOp );
|
|
g_pd3dDevice->SetTextureStageState( nStage, D3DTSS_COLORARG1, dwColorArg1 );
|
|
g_pd3dDevice->SetTextureStageState( nStage, D3DTSS_COLORARG2, dwColorArg2 );
|
|
g_pd3dDevice->SetTextureStageState( nStage, D3DTSS_COLORARG0, dwColorArg0 );
|
|
g_pd3dDevice->SetTextureStageState( nStage, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
|
|
g_pd3dDevice->SetTextureStageState( nStage, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP );
|
|
g_pd3dDevice->SetTextureStageState( nStage, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP );
|
|
g_pd3dDevice->SetTextureStageState( nStage, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
|
|
g_pd3dDevice->SetTextureStageState( nStage, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
|
|
}
|
|
|
|
bool InitD3D( HWND hWnd, bool blur )
|
|
{
|
|
g_pD3D = Direct3DCreate8( D3D_SDK_VERSION );
|
|
if ( !g_pD3D )
|
|
{
|
|
OutputDebugString( "Direct3DCreate8 FAILED!\n" );
|
|
CleanupD3D();
|
|
return false;
|
|
}
|
|
|
|
D3DDISPLAYMODE d3ddm;
|
|
bool bFound = false;
|
|
int nAdapters = g_pD3D->GetAdapterCount();
|
|
int nAdapterIndex = 0;
|
|
for ( ; nAdapterIndex < nAdapters; ++nAdapterIndex )
|
|
{
|
|
if ( g_pD3D->GetAdapterMonitor( nAdapterIndex ) == g_hMonitor )
|
|
{
|
|
if ( FAILED( g_pD3D->GetAdapterDisplayMode( nAdapterIndex, &d3ddm ) ) )
|
|
{
|
|
OutputDebugString( "GetAdapterDisplayMode FAILED!\n" );
|
|
CleanupD3D();
|
|
return false;
|
|
}
|
|
|
|
MONITORINFO mi;
|
|
mi.cbSize = sizeof( mi );
|
|
GetMonitorInfo( g_hMonitor, &mi );
|
|
bFound = true;
|
|
break;
|
|
}
|
|
}
|
|
if ( !bFound )
|
|
{
|
|
OutputDebugString( "Starting monitor not found when creating D3D device!\n" );
|
|
CleanupD3D();
|
|
return false;
|
|
}
|
|
|
|
D3DPRESENT_PARAMETERS d3dpp;
|
|
ZeroMemory( &d3dpp, sizeof( d3dpp ) );
|
|
d3dpp.BackBufferWidth = g_screenWidth;
|
|
d3dpp.BackBufferHeight = g_screenHeight;
|
|
d3dpp.BackBufferFormat = d3ddm.Format;
|
|
d3dpp.BackBufferCount = 1;
|
|
d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
|
|
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
|
|
d3dpp.hDeviceWindow = NULL;
|
|
d3dpp.Windowed = FALSE;
|
|
d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
|
|
d3dpp.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_ONE;
|
|
|
|
if ( FAILED( g_pD3D->CreateDevice( nAdapterIndex, D3DDEVTYPE_HAL, hWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &g_pd3dDevice ) ) )
|
|
{
|
|
OutputDebugString( "CreateDevice FAILED!\n" );
|
|
CleanupD3D();
|
|
return false;
|
|
}
|
|
|
|
// create and fill vertex buffer(s)
|
|
float du = 0.5f / g_screenWidth;
|
|
float dv = 0.5f / g_screenHeight;
|
|
float u0 = du;
|
|
float u1 = 1.0f + du;
|
|
float v0 = dv;
|
|
float v1 = 1.0f + dv;
|
|
float drawverts[] =
|
|
{ // x, y, z, u, v
|
|
-1, -1, 0, u0, v0,
|
|
-1, 1, 0, u0, v1,
|
|
1, -1, 0, u1, v0,
|
|
1, 1, 0, u1, v1,
|
|
};
|
|
g_dwDrawFVF = D3DFVF_XYZ | D3DFVF_TEX1;
|
|
g_nDrawStride = sizeof( drawverts ) / 4;
|
|
|
|
if ( FAILED( g_pd3dDevice->CreateVertexBuffer( sizeof( drawverts ), D3DUSAGE_WRITEONLY, g_dwDrawFVF, D3DPOOL_MANAGED, &g_pDrawVB ) ) )
|
|
{
|
|
OutputDebugString( "CreateVertexBuffer( g_pDrawVB ) FAILED!\n" );
|
|
CleanupD3D();
|
|
return false;
|
|
}
|
|
|
|
BYTE* pDrawVBMem;
|
|
if ( FAILED( g_pDrawVB->Lock( 0, sizeof( drawverts ), &pDrawVBMem, 0 ) ) )
|
|
{
|
|
OutputDebugString( "g_pDrawVB->Lock FAILED!\n" );
|
|
CleanupD3D();
|
|
return false;
|
|
}
|
|
memcpy( pDrawVBMem, drawverts, sizeof( drawverts ) );
|
|
g_pDrawVB->Unlock();
|
|
|
|
g_pd3dDevice->SetStreamSource( 0, g_pDrawVB, g_nDrawStride );
|
|
g_pd3dDevice->SetVertexShader( g_dwDrawFVF );
|
|
#ifdef BLUR
|
|
if ( blur )
|
|
{
|
|
float f = 2.0f / ( 2.0f + sqrt( 2.0f ) );
|
|
float ds = 2.0f * f / g_screenWidth;
|
|
float dt = 2.0f * f / g_screenHeight;
|
|
float s0 = ( 0.5f - f ) / g_screenWidth;
|
|
float s1 = 1.0f + s0;
|
|
float t0 = ( 0.5f - f ) / g_screenHeight;
|
|
float t1 = 1.0f + t0;
|
|
float blurverts[] =
|
|
{ // x, y, z, u, v
|
|
-1, -1, 0, s0, t1, s0+ds, t1, s0, t1+dt, s0+ds, t1+dt,
|
|
-1, 1, 0, s0, t0, s0+ds, t0, s0, t0+dt, s0+ds, t0+dt,
|
|
1, -1, 0, s1, t1, s1+ds, t1, s1, t1+dt, s1+ds, t1+dt,
|
|
1, 1, 0, s1, t0, s1+ds, t0, s1, t0+dt, s1+ds, t0+dt,
|
|
};
|
|
g_dwBlurFVF = D3DFVF_XYZ | D3DFVF_TEX4;
|
|
g_nBlurStride = sizeof( blurverts ) / 4;
|
|
|
|
if ( FAILED( g_pd3dDevice->CreateVertexBuffer( sizeof( blurverts ), D3DUSAGE_WRITEONLY, g_dwBlurFVF, D3DPOOL_MANAGED, &g_pBlurVB ) ) )
|
|
{
|
|
OutputDebugString( "CreateVertexBuffer( g_pBlurVB ) FAILED!\n" );
|
|
CleanupD3D();
|
|
return false;
|
|
}
|
|
|
|
BYTE* pBlurVBMem;
|
|
if ( FAILED( g_pBlurVB->Lock( 0, sizeof( blurverts ), &pBlurVBMem, 0 ) ) )
|
|
{
|
|
OutputDebugString( "g_pBlurVB->Lock FAILED!\n" );
|
|
CleanupD3D();
|
|
return false;
|
|
}
|
|
memcpy( pBlurVBMem, blurverts, sizeof( blurverts ) );
|
|
g_pBlurVB->Unlock();
|
|
}
|
|
#endif // BLUR
|
|
|
|
// create and fill texture
|
|
if ( FAILED( g_pd3dDevice->CreateTexture( g_screenWidth, g_screenHeight, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &g_pImg ) ) )
|
|
{
|
|
OutputDebugString( "CreateTexture( g_pImg ) FAILED!\n" );
|
|
CleanupD3D();
|
|
return false;
|
|
}
|
|
|
|
D3DLOCKED_RECT lockedRect;
|
|
if ( FAILED( g_pImg->LockRect( 0, &lockedRect, NULL, 0 ) ) )
|
|
{
|
|
OutputDebugString( "g_pImg->LockRect FAILED!\n" );
|
|
CleanupD3D();
|
|
return false;
|
|
}
|
|
|
|
BITMAPINFO bitmapInfo;
|
|
bitmapInfo.bmiHeader.biSize = sizeof( bitmapInfo.bmiHeader );
|
|
bitmapInfo.bmiHeader.biWidth = g_screenWidth;
|
|
bitmapInfo.bmiHeader.biHeight = g_screenHeight;
|
|
bitmapInfo.bmiHeader.biPlanes = 1;
|
|
bitmapInfo.bmiHeader.biBitCount = 32;
|
|
bitmapInfo.bmiHeader.biCompression = BI_RGB;
|
|
bitmapInfo.bmiHeader.biSizeImage = 0;
|
|
bitmapInfo.bmiHeader.biXPelsPerMeter = 0;
|
|
bitmapInfo.bmiHeader.biYPelsPerMeter = 0;
|
|
bitmapInfo.bmiHeader.biClrUsed = 0;
|
|
bitmapInfo.bmiHeader.biClrImportant = 0;
|
|
|
|
if ( GetDIBits( g_hdcCapture, g_hbmCapture, 0, g_screenHeight, lockedRect.pBits, &bitmapInfo, DIB_RGB_COLORS ) != g_screenHeight )
|
|
{
|
|
OutputDebugString( "GetDIBits FAILED to get the full image!\n" );
|
|
}
|
|
|
|
g_pImg->UnlockRect( 0 );
|
|
|
|
#ifdef BLUR
|
|
if ( blur )
|
|
{
|
|
if ( FAILED( g_pd3dDevice->CreateTexture( g_screenWidth, g_screenHeight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &g_pTex ) ) )
|
|
{
|
|
OutputDebugString( "CreateTexture( g_pTex ) FAILED!\n" );
|
|
CleanupD3D();
|
|
return false;
|
|
}
|
|
|
|
if ( FAILED( g_pd3dDevice->CreateTexture( g_screenWidth, g_screenHeight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &g_pRT ) ) )
|
|
{
|
|
OutputDebugString( "CreateTexture( g_pRT ) FAILED!\n" );
|
|
CleanupD3D();
|
|
return false;
|
|
}
|
|
|
|
IDirect3DSurface8 *pTexSurf = NULL;
|
|
g_pTex->GetSurfaceLevel( 0, &pTexSurf );
|
|
IDirect3DSurface8 *pImgSurf = NULL;
|
|
g_pImg->GetSurfaceLevel( 0, &pImgSurf );
|
|
|
|
RECT rect = { 0, 0, g_screenWidth, g_screenHeight };
|
|
POINT pt = { 0, 0 };
|
|
g_pd3dDevice->CopyRects( pImgSurf, &rect, 1, pTexSurf, &pt );
|
|
|
|
pTexSurf->Release();
|
|
pImgSurf->Release();
|
|
}
|
|
#endif // BLUR
|
|
|
|
g_pd3dDevice->SetTexture( 0, g_pImg );
|
|
|
|
InitTextureStageState( 0, D3DTOP_MODULATE, D3DTA_TEXTURE, D3DTA_TFACTOR );
|
|
#ifdef BLUR
|
|
if ( blur )
|
|
{
|
|
g_pd3dDevice->SetTexture( 0, g_pTex );
|
|
// g_pd3dDevice->SetTexture( 1, g_pTex );
|
|
// g_pd3dDevice->SetTexture( 2, g_pTex );
|
|
// g_pd3dDevice->SetTexture( 3, g_pTex );
|
|
|
|
DWORD op = D3DTOP_DISABLE; // D3DTOP_MULTIPLYADD;
|
|
InitTextureStageState( 1, op, D3DTA_TEXTURE, D3DTA_TFACTOR, D3DTA_CURRENT );
|
|
InitTextureStageState( 2, op, D3DTA_TEXTURE, D3DTA_TFACTOR, D3DTA_CURRENT );
|
|
InitTextureStageState( 3, op, D3DTA_TEXTURE, D3DTA_TFACTOR, D3DTA_CURRENT );
|
|
}
|
|
#endif // BLUR
|
|
|
|
return true;
|
|
}
|
|
|
|
void DrawD3DFade( BYTE fade, bool blur )
|
|
{
|
|
if ( g_pd3dDevice )
|
|
{
|
|
#ifdef BLUR
|
|
if ( g_pTex )
|
|
{
|
|
if ( blur )
|
|
{
|
|
IDirect3DSurface8 *pRTSurf = NULL;
|
|
g_pRT->GetSurfaceLevel( 0, &pRTSurf );
|
|
g_pd3dDevice->SetRenderTarget( pRTSurf, NULL );
|
|
|
|
if ( g_pBackBuf )
|
|
{
|
|
g_pBackBuf->Release();
|
|
g_pBackBuf = NULL;
|
|
}
|
|
|
|
g_pd3dDevice->BeginScene();
|
|
|
|
g_pd3dDevice->SetTexture( 0, g_pTex );
|
|
g_pd3dDevice->SetTexture( 1, g_pTex );
|
|
g_pd3dDevice->SetTexture( 2, g_pTex );
|
|
g_pd3dDevice->SetTexture( 3, g_pTex );
|
|
|
|
g_pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MULTIPLYADD );
|
|
g_pd3dDevice->SetTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_MULTIPLYADD );
|
|
g_pd3dDevice->SetTextureStageState( 3, D3DTSS_COLOROP, D3DTOP_MULTIPLYADD );
|
|
|
|
g_pd3dDevice->SetStreamSource( 0, g_pBlurVB, g_nBlurStride );
|
|
g_pd3dDevice->SetVertexShader( g_dwBlurFVF );
|
|
|
|
DWORD quarter = 0x3f | ( 0x3f << 8 ) | ( 0x3f << 16 ) | ( 0x3f << 24 );
|
|
g_pd3dDevice->SetRenderState( D3DRS_TEXTUREFACTOR, quarter );
|
|
g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2 );
|
|
|
|
g_pd3dDevice->EndScene();
|
|
|
|
pRTSurf->Release();
|
|
|
|
g_pd3dDevice->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &g_pBackBuf );
|
|
g_pd3dDevice->SetRenderTarget( g_pBackBuf, NULL );
|
|
|
|
IDirect3DTexture8 *pTemp = g_pTex;
|
|
g_pTex = g_pRT;
|
|
g_pRT = pTemp;
|
|
|
|
g_pd3dDevice->SetTexture( 0, g_pTex );
|
|
g_pd3dDevice->SetTexture( 1, NULL );
|
|
g_pd3dDevice->SetTexture( 2, NULL );
|
|
g_pd3dDevice->SetTexture( 3, NULL );
|
|
|
|
g_pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
|
g_pd3dDevice->SetTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
|
g_pd3dDevice->SetTextureStageState( 3, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
|
|
|
g_pd3dDevice->SetStreamSource( 0, g_pDrawVB, g_nDrawStride );
|
|
g_pd3dDevice->SetVertexShader( g_dwDrawFVF );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
g_pd3dDevice->BeginScene();
|
|
|
|
// DWORD factor = 0xff | ( fade << 8 ) | ( fade << 16 ) | ( fade << 24 );
|
|
DWORD factor = fade | ( fade << 8 ) | ( fade << 16 ) | ( fade << 24 );
|
|
g_pd3dDevice->SetRenderState( D3DRS_TEXTUREFACTOR, factor );
|
|
g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2 );
|
|
|
|
g_pd3dDevice->EndScene();
|
|
g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
|
|
}
|
|
}
|
|
|
|
#endif // USE_D3D8
|
|
|
|
int g_nTimingIndex = 0;
|
|
double g_timings[ 65536 ];
|
|
|
|
LRESULT CALLBACK WinProc( HWND hWnd, UINT msg, WPARAM wparam, LPARAM lparam )
|
|
{
|
|
switch ( msg )
|
|
{
|
|
case WM_CREATE:
|
|
{
|
|
g_timeAtFadeStart = 0.0;
|
|
g_nBlurSteps = 0;
|
|
|
|
g_hBlackFadingWindow = hWnd;
|
|
|
|
#ifndef USE_D3D8
|
|
MONITORINFO mi;
|
|
mi.cbSize = sizeof( mi );
|
|
if ( GetMonitorInfo( g_hMonitor, &mi ) )
|
|
{
|
|
SetWindowPos( hWnd, HWND_TOPMOST, mi.rcMonitor.left, mi.rcMonitor.top, mi.rcMonitor.right - mi.rcMonitor.left, mi.rcMonitor.bottom - mi.rcMonitor.top, 0 );
|
|
}
|
|
#endif
|
|
|
|
#ifdef USE_D3D8
|
|
InitD3D( hWnd, true );
|
|
#endif // USE_D3D8
|
|
if ( !g_bFadeIn )
|
|
{
|
|
g_pFrame->ShowWindow( SW_HIDE );
|
|
g_pFrame->PostMessage( WM_DESTROY, 0, 0 );
|
|
}
|
|
|
|
InvalidateRect( hWnd, NULL, TRUE );
|
|
|
|
SetTimer( hWnd, ID_SKIP_FADE_TIMER, 1000, NULL ); // if the fade doesn't start in 1 second, then just jump to the video
|
|
SetTimer( hWnd, ID_DRAW_TIMER, 10, NULL ); // draw timer
|
|
}
|
|
break;
|
|
|
|
#ifdef USE_D3D8
|
|
case WM_TIMER: // WM_ERASEBKGND:
|
|
#else
|
|
case WM_TIMER: // WM_ERASEBKGND:
|
|
// case WM_NCPAINT:
|
|
#endif
|
|
if ( wparam == ID_DRAW_TIMER )
|
|
{
|
|
static LARGE_INTEGER s_nPerformanceFrequency;
|
|
if ( g_timeAtFadeStart == 0.0 )
|
|
{
|
|
LARGE_INTEGER nTimeAtFadeStart;
|
|
QueryPerformanceCounter( &nTimeAtFadeStart );
|
|
QueryPerformanceFrequency( &s_nPerformanceFrequency );
|
|
g_timeAtFadeStart = nTimeAtFadeStart.QuadPart / double( s_nPerformanceFrequency.QuadPart );
|
|
|
|
KillTimer( hWnd, ID_SKIP_FADE_TIMER );
|
|
SetTimer( hWnd, ID_SKIP_FADE_TIMER, 100 + UINT( FADE_TIME * 1000 ), NULL ); // restart skip fade timer and give it an extra 100ms to allow the fade to draw fully black once
|
|
}
|
|
|
|
LARGE_INTEGER time;
|
|
QueryPerformanceCounter( &time );
|
|
g_timings[ g_nTimingIndex++ ] = time.QuadPart / double( s_nPerformanceFrequency.QuadPart );
|
|
float dt = ( float )( time.QuadPart / double( s_nPerformanceFrequency.QuadPart ) - g_timeAtFadeStart );
|
|
|
|
bool bFadeFinished = dt >= FADE_TIME;
|
|
float fraction = bFadeFinished ? 1.0f : dt / FADE_TIME;
|
|
/*
|
|
char str[ 256 ];
|
|
sprintf( str, "A - dt = %f\t time = %f \tfade_finished = %s\n", dt, g_timings[ g_nTimingIndex - 1 ], bFadeFinished ? "true" : "false" );
|
|
OutputDebugString( str );
|
|
*/
|
|
bool blur = g_bFadeIn && ( int( fraction * MAX_BLUR_STEPS ) > g_nBlurSteps );
|
|
if ( blur )
|
|
{
|
|
++g_nBlurSteps;
|
|
}
|
|
|
|
BYTE fade = BYTE( fraction * 255.999f );
|
|
if ( g_bFadeIn )
|
|
{
|
|
fade = 255 - fade;
|
|
}
|
|
/*
|
|
char str[ 256 ];
|
|
sprintf( str, "fade = %d\n", fade );
|
|
OutputDebugString( str );
|
|
*/
|
|
#ifdef USE_D3D8
|
|
DrawD3DFade( fade, blur );
|
|
#else // USE_D3D8
|
|
// HDC hdc = GetDCEx( hWnd, ( HRGN )wparam, DCX_WINDOW | DCX_INTERSECTRGN );
|
|
|
|
if ( !PatBlt( g_hdcBlend, 0, 0, g_screenWidth, g_screenHeight, BLACKNESS ) )
|
|
{
|
|
OutputDebugString( "PatBlt FAILED!\n" );
|
|
}
|
|
|
|
// fade = 128;
|
|
BLENDFUNCTION blendfunc = { AC_SRC_OVER, 0, fade, 0 };
|
|
if ( !::AlphaBlend( g_hdcBlend, 0, 0, g_screenWidth, g_screenHeight, g_hdcCapture, 0, 0, g_screenWidth, g_screenHeight, blendfunc ) )
|
|
{
|
|
OutputDebugString( "AlphaBlend FAILED!\n" );
|
|
}
|
|
|
|
if ( !BitBlt( ( HDC )wparam, 0, 0, g_screenWidth, g_screenHeight, g_hdcBlend, 0, 0, SRCCOPY ) )
|
|
{
|
|
OutputDebugString( "BitBlt FAILED!\n" );
|
|
}
|
|
|
|
// ReleaseDC( hWnd, hdc );
|
|
// RedrawWindow( hWnd, NULL, NULL, RDW_FRAME | RDW_INVALIDATE );
|
|
#endif // USE_D3D8
|
|
/*
|
|
// char str[ 256 ];
|
|
sprintf( str, "B - dt = %f\t time = %f \tfade_finished = %s\n", dt, g_timings[ g_nTimingIndex - 1 ], bFadeFinished ? "true" : "false" );
|
|
OutputDebugString( str );
|
|
*/
|
|
if ( !bFadeFinished )
|
|
break;
|
|
|
|
// fall-through intentional
|
|
// OutputDebugString( "Fall-through from erase background\n" );
|
|
}
|
|
|
|
// case WM_TIMER:
|
|
{
|
|
if ( msg == WM_TIMER )
|
|
{
|
|
/*
|
|
char str[ 256 ];
|
|
sprintf( str, "Timer 0x%x triggered for window 0x%x\n", wparam, hWnd );
|
|
OutputDebugString( str );
|
|
*/
|
|
if ( wparam == ID_DRAW_TIMER )
|
|
{
|
|
// UpdateWindow( hWnd );
|
|
// InvalidateRect( hWnd, NULL, TRUE );
|
|
// break;
|
|
}
|
|
}
|
|
|
|
KillTimer( hWnd, ID_SKIP_FADE_TIMER );
|
|
KillTimer( hWnd, ID_DRAW_TIMER );
|
|
|
|
if ( !g_bFadeIn )
|
|
{
|
|
// OutputDebugString( "closing fade window\n" );
|
|
ShowWindow( hWnd, SW_HIDE );
|
|
PostMessage( hWnd, WM_CLOSE, 0, 0 );
|
|
return 1;
|
|
}
|
|
else if ( !g_bFrameCreated )
|
|
{
|
|
g_bFrameCreated = true;
|
|
#ifdef USE_D3D8
|
|
// OutputDebugString( "Cleanup D3D\n" );
|
|
CleanupD3D();
|
|
#endif
|
|
g_pFrame = &g_frame;
|
|
g_pFrame->GetWndClassInfo().m_wc.hIcon = LoadIcon( _Module.GetResourceInstance(), MAKEINTRESOURCE( IDI_ICON ) );
|
|
RECT rcPos = { CW_USEDEFAULT, 0, 0, 0 };
|
|
|
|
// OutputDebugString( "Create WMP frame\n" );
|
|
|
|
if ( g_osVersion < OSV_XP )
|
|
{
|
|
g_pFrame->Create( GetDesktopWindow(), rcPos, _T( "Steam Media Player" ), WS_OVERLAPPEDWINDOW, 0, ( UINT )0 );
|
|
}
|
|
else
|
|
{
|
|
g_pFrame->Create( GetDesktopWindow(), rcPos, _T( "Steam Media Player" ), WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0, ( UINT )0 );
|
|
|
|
g_pFrame->ShowWindow( SW_SHOW );
|
|
}
|
|
|
|
// OutputDebugString( "Create WMP frame - done\n" );
|
|
}
|
|
|
|
// close WMP window once we paint the fullscreen fade window
|
|
if ( !g_bFadeIn )
|
|
{
|
|
g_pFrame->ShowWindow( SW_HIDE );
|
|
}
|
|
}
|
|
return 1;
|
|
|
|
case WM_KEYDOWN:
|
|
if ( wparam == VK_ESCAPE )
|
|
{
|
|
::DestroyWindow( hWnd );
|
|
}
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
g_hBlackFadingWindow = NULL;
|
|
|
|
#ifdef USE_D3D8
|
|
CleanupD3D();
|
|
#endif
|
|
|
|
if ( g_bFrameCreated )
|
|
{
|
|
g_bFrameCreated = false;
|
|
|
|
g_pFrame->DestroyWindow();
|
|
g_pFrame = NULL;
|
|
}
|
|
|
|
::PostQuitMessage( 0 );
|
|
break;
|
|
}
|
|
|
|
return DefWindowProc( hWnd, msg, wparam, lparam );
|
|
}
|
|
|
|
bool ShowFadeWindow( bool bShow )
|
|
{
|
|
if ( bShow )
|
|
{
|
|
g_timeAtFadeStart = 0.0;
|
|
g_bFadeIn = false;
|
|
|
|
SetTimer( g_hBlackFadingWindow, ID_DRAW_TIMER, 10, NULL );
|
|
|
|
if ( g_pFrame )
|
|
{
|
|
g_pFrame->ShowWindow( SW_HIDE );
|
|
}
|
|
#ifdef USE_D3D8
|
|
if ( g_osVersion < OSV_XP )
|
|
{
|
|
::SetWindowPos( g_hBlackFadingWindow, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW );
|
|
}
|
|
InitD3D( g_hBlackFadingWindow, false );
|
|
#else // USE_D3D8
|
|
::SetWindowPos( g_hBlackFadingWindow, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW );
|
|
// ::ShowWindow( g_hBlackFadingWindow, SW_SHOWMAXIMIZED );
|
|
#endif // USE_D3D8
|
|
InvalidateRect( g_hBlackFadingWindow, NULL, TRUE );
|
|
}
|
|
else
|
|
{
|
|
if ( g_osVersion < OSV_XP )
|
|
{
|
|
// OutputDebugString( "hiding fade window\n" );
|
|
ShowWindow( g_hBlackFadingWindow, SW_HIDE );
|
|
}
|
|
else
|
|
{
|
|
// OutputDebugString( "Deferring erase on fade window\n" );
|
|
::SetWindowPos( g_hBlackFadingWindow, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOREDRAW | SWP_NOMOVE | SWP_NOSIZE | SWP_HIDEWINDOW | SWP_NOACTIVATE | SWP_DEFERERASE );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
HWND CreateFullscreenWindow( bool bFadeIn )
|
|
{
|
|
if ( g_hBlackFadingWindow )
|
|
return g_hBlackFadingWindow;
|
|
|
|
static s_bRegistered = false;
|
|
if ( !s_bRegistered )
|
|
{
|
|
WNDCLASS wc;
|
|
wc.style = CS_HREDRAW | CS_VREDRAW;
|
|
wc.lpfnWndProc = ( WNDPROC )WinProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = g_hInstance;
|
|
wc.hIcon = LoadIcon( NULL, IDI_APPLICATION );
|
|
wc.hCursor = NULL;
|
|
wc.hbrBackground = NULL;
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = "myclass";
|
|
|
|
if ( !RegisterClass( &wc ) )
|
|
return 0;
|
|
|
|
s_bRegistered = true;
|
|
}
|
|
|
|
g_bFadeIn = bFadeIn;
|
|
DWORD windowStyle = WS_POPUP;
|
|
#ifndef USE_D3D8
|
|
windowStyle |= WS_MAXIMIZE | WS_EX_TOPMOST | WS_VISIBLE;
|
|
#endif
|
|
if ( g_osVersion < OSV_XP )
|
|
{
|
|
windowStyle |= WS_MAXIMIZE | WS_EX_TOPMOST | WS_VISIBLE;
|
|
}
|
|
|
|
MONITORINFO mi;
|
|
mi.cbSize = sizeof( mi );
|
|
if ( !GetMonitorInfo( g_hMonitor, &mi ) )
|
|
{
|
|
GetClientRect( GetDesktopWindow(), &mi.rcMonitor );
|
|
}
|
|
|
|
g_hBlackFadingWindow = CreateWindow( "myclass", _T( "Steam Media Player" ), windowStyle, mi.rcMonitor.left, mi.rcMonitor.top, mi.rcMonitor.right - mi.rcMonitor.left, mi.rcMonitor.bottom - mi.rcMonitor.top, NULL, NULL, g_hInstance, NULL );
|
|
#ifndef USE_D3D8
|
|
ShowWindow( g_hBlackFadingWindow, SW_SHOWMAXIMIZED );
|
|
#endif
|
|
if ( g_osVersion < OSV_XP )
|
|
{
|
|
ShowWindow( g_hBlackFadingWindow, SW_SHOWMAXIMIZED );
|
|
}
|
|
|
|
while ( ShowCursor( FALSE ) >= 0 )
|
|
;
|
|
|
|
return g_hBlackFadingWindow;
|
|
}
|
|
|
|
bool CreateDesktopBitmaps()
|
|
{
|
|
MONITORINFOEX mi;
|
|
mi.cbSize = sizeof( mi );
|
|
if ( !GetMonitorInfo( g_hMonitor, &mi ) )
|
|
return false;
|
|
|
|
g_screenWidth = mi.rcMonitor.right - mi.rcMonitor.left;
|
|
g_screenHeight = mi.rcMonitor.bottom - mi.rcMonitor.top;
|
|
|
|
HDC hdcScreen = CreateDC( mi.szDevice, mi.szDevice, NULL, NULL );
|
|
if ( !hdcScreen )
|
|
return false;
|
|
|
|
g_hdcCapture = CreateCompatibleDC( hdcScreen );
|
|
g_hdcBlend = CreateCompatibleDC( hdcScreen );
|
|
if ( !g_hdcCapture || !g_hdcBlend )
|
|
return false;
|
|
|
|
if ( ( GetDeviceCaps( hdcScreen, SHADEBLENDCAPS ) & SB_CONST_ALPHA ) == 0 )
|
|
{
|
|
OutputDebugString( "display doesn't support AlphaBlend!\n" );
|
|
}
|
|
|
|
if ( ( GetDeviceCaps( hdcScreen, RASTERCAPS ) & RC_BITBLT ) == 0 )
|
|
{
|
|
OutputDebugString( "display doesn't support BitBlt!\n" );
|
|
}
|
|
|
|
if ( GetDeviceCaps( hdcScreen, BITSPIXEL ) < 32 )
|
|
{
|
|
OutputDebugString( "display doesn't support 32bpp!\n" );
|
|
}
|
|
|
|
if ( g_screenWidth != GetDeviceCaps( hdcScreen, HORZRES ) ||
|
|
g_screenHeight != GetDeviceCaps( hdcScreen, VERTRES ) )
|
|
{
|
|
OutputDebugString( "Screen DC size differs from monitor size!\n" );
|
|
}
|
|
|
|
g_hbmCapture = CreateCompatibleBitmap( hdcScreen, g_screenWidth, g_screenHeight );
|
|
g_hbmBlend = CreateCompatibleBitmap( hdcScreen, g_screenWidth, g_screenHeight );
|
|
if ( !g_hbmCapture || !g_hbmBlend )
|
|
return false;
|
|
|
|
HGDIOBJ oldCaptureObject = SelectObject( g_hdcCapture, g_hbmCapture );
|
|
HGDIOBJ oldBlendObject = SelectObject( g_hdcBlend, g_hbmBlend );
|
|
|
|
if ( !BitBlt( g_hdcCapture, 0, 0, g_screenWidth, g_screenHeight, hdcScreen, 0, 0, SRCCOPY ) )
|
|
return false;
|
|
|
|
SelectObject( g_hdcCapture, oldCaptureObject );
|
|
SelectObject( g_hdcBlend, oldBlendObject );
|
|
|
|
return true;
|
|
}
|
|
|
|
void PrintLastError( const char *pPrefix )
|
|
{
|
|
#ifdef _DEBUG
|
|
DWORD dw = GetLastError();
|
|
|
|
LPVOID lpMsgBuf;
|
|
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL, dw, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
|
|
( LPTSTR )&lpMsgBuf, 0, NULL );
|
|
|
|
OutputDebugString( pPrefix );
|
|
char msg[ 256 ];
|
|
sprintf( msg, "(%d) ", dw );
|
|
OutputDebugString( msg );
|
|
OutputDebugString( ( char * )lpMsgBuf );
|
|
|
|
LocalFree( lpMsgBuf );
|
|
#endif
|
|
}
|
|
|
|
void KillOtherSMPs()
|
|
{
|
|
DWORD nBytesReturned = 0;
|
|
DWORD procIds[ 1024 ];
|
|
if ( !EnumProcesses( procIds, sizeof( procIds ), &nBytesReturned ) )
|
|
{
|
|
PrintLastError( "EnumProcesses Error: " );
|
|
return;
|
|
}
|
|
|
|
DWORD dwCurrentProcessId = GetCurrentProcessId();
|
|
|
|
int nProcIds = nBytesReturned / sizeof( DWORD );
|
|
for ( int i = 0; i < nProcIds; ++i )
|
|
{
|
|
if ( procIds[ i ] == dwCurrentProcessId )
|
|
continue;
|
|
|
|
if ( procIds[ i ] == 0 ) // system idle process
|
|
continue;
|
|
|
|
HANDLE hProcess = OpenProcess( PROCESS_TERMINATE | PROCESS_VM_READ | PROCESS_QUERY_INFORMATION, FALSE, procIds[ i ] );
|
|
if ( !hProcess )
|
|
{
|
|
PrintLastError( "OpenProcess Error: " );
|
|
continue;
|
|
}
|
|
|
|
HMODULE hMod[ 1 ];
|
|
DWORD cbNeeded;
|
|
if ( !EnumProcessModules( hProcess, hMod, sizeof( hMod ), &cbNeeded ) )
|
|
{
|
|
PrintLastError( "EnumProcessModules Error: " );
|
|
continue;
|
|
}
|
|
|
|
char processName[ 1024 ];
|
|
int nChars = GetModuleBaseName( hProcess, hMod[ 0 ], processName, sizeof( processName ) / sizeof( char ) );
|
|
if ( nChars >= sizeof( processName ) )
|
|
{
|
|
PrintLastError( "GetModuleBaseName Error: " );
|
|
continue;
|
|
}
|
|
|
|
if ( strcmp( processName, "smp.exe" ) == 0 )
|
|
{
|
|
OutputDebugString( "!!! Killing smp.exe !!!\n" );
|
|
TerminateProcess( hProcess, 0 );
|
|
}
|
|
|
|
if ( !CloseHandle( hProcess ) )
|
|
{
|
|
PrintLastError( "CloseHandle Error: " );
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ParseCommandLine( const char *cmdline, std::vector< std::string > ¶ms )
|
|
{
|
|
params.push_back( "" );
|
|
|
|
bool quoted = false;
|
|
for ( const char *cp = cmdline; *cp; ++cp )
|
|
{
|
|
if ( *cp == '\"' )
|
|
{
|
|
quoted = !quoted;
|
|
}
|
|
else if ( isspace( *cp ) && !quoted )
|
|
{
|
|
if ( !params.back().empty() )
|
|
{
|
|
params.push_back( "" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
params.back().push_back( *cp );
|
|
}
|
|
}
|
|
|
|
if ( params.back().empty() )
|
|
{
|
|
params.pop_back();
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
extern "C" int WINAPI _tWinMain( HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpCmdLine, int /*nShowCmd*/ )
|
|
{
|
|
g_hInstance = hInstance;
|
|
|
|
KillOtherSMPs();
|
|
|
|
g_lpCommandLine = lpCmdLine;
|
|
if ( lpCmdLine == NULL || *lpCmdLine == '\0' )
|
|
return 0;
|
|
|
|
std::vector< std::string > params;
|
|
ParseCommandLine( lpCmdLine, params );
|
|
int nParams = params.size();
|
|
for ( int i = 0; i < nParams; ++i )
|
|
{
|
|
if ( params[ i ][ 0 ] == '-' || params[ i ][ 0 ] == '/' )
|
|
{
|
|
const char *pOption = params[ i ].c_str() + 1;
|
|
if ( strcmp( pOption, "reportstats" ) == 0 )
|
|
{
|
|
g_bReportStats = true;
|
|
}
|
|
else if ( strcmp( pOption, "localsteamserver" ) == 0 )
|
|
{
|
|
g_bUseLocalSteamServer = true;
|
|
}
|
|
else if ( strcmp( pOption, "redirect" ) == 0 )
|
|
{
|
|
++i;
|
|
g_redirectTarget = params[ i ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
g_URL = params[ i ];
|
|
}
|
|
}
|
|
|
|
SetRegistryValue( "Software\\Microsoft\\MediaPlayer\\Preferences\\VideoSettings", "UseVMROverlay", 0, g_dwUseVMROverlayOldValue, g_bUseVMROverlayValueExists );
|
|
atexit( RestoreRegistry );
|
|
|
|
LogPlayerEvent( ET_APPLAUNCH, 0.0f );
|
|
|
|
lpCmdLine = GetCommandLine(); //this line necessary for _ATL_MIN_CRT
|
|
|
|
CoInitialize( 0 );
|
|
_Module.Init( ObjectMap, hInstance, &LIBID_ATLLib );
|
|
|
|
::InitCommonControls();
|
|
|
|
POINT pt;
|
|
GetCursorPos( &pt );
|
|
g_hMonitor = MonitorFromPoint( pt, MONITOR_DEFAULTTONEAREST );
|
|
|
|
if ( !CreateDesktopBitmaps() )
|
|
{
|
|
OutputDebugString( "CreateDesktopBitmaps FAILED!\n" );
|
|
}
|
|
|
|
ShowCursor( FALSE );
|
|
CreateFullscreenWindow( true );
|
|
|
|
MSG msg;
|
|
while ( GetMessage( &msg, 0, 0, 0 ) )
|
|
{
|
|
TranslateMessage( &msg );
|
|
DispatchMessage( &msg );
|
|
}
|
|
|
|
LogPlayerEvent( ET_APPEXIT );
|
|
if ( g_bReportStats )
|
|
{
|
|
UploadStats();
|
|
}
|
|
|
|
if ( !g_redirectTarget.empty() )
|
|
{
|
|
::ShellExecuteA( NULL, "open", g_redirectTarget.c_str(), NULL, NULL, SW_SHOWNORMAL );
|
|
}
|
|
|
|
_Module.Term();
|
|
CoUninitialize();
|
|
|
|
RestoreRegistry();
|
|
|
|
return 0;
|
|
}
|