d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
366 Commits
25 Branches
6 Tags
221 MiB
Tree: 80c9ef37d7
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '80c9ef37d7'
${ noResults }
source-engine/video/videoservices.cpp

1465 lines
44 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "filesystem.h"
#include "tier1/strtools.h"
#include "tier1/utllinkedlist.h"
#include "tier1/KeyValues.h"
#include "materialsystem/imaterial.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/MaterialSystemUtil.h"
#include "materialsystem/itexture.h"
#include "vgui/ILocalize.h"
#include "vtf/vtf.h"
#include "pixelwriter.h"
#include "tier3/tier3.h"
#include "platform.h"
#include "videoservices.h"
#include "video_macros.h"
#include "tier0/memdbgon.h"
#if defined( WIN32 )
#include <windows.h>
#elif defined( OSX )
#include <Carbon/Carbon.h>
#endif
#if defined( USE_SDL )
#include "SDL.h"
#include "appframework/ilaunchermgr.h"
#endif
//-----------------------------------------------------------------------------
// Platform specific video system controls & definitions
//-----------------------------------------------------------------------------
enum EPlatform_t
{
PLATFORM_NONE = 0,
PLATFORM_WIN32 = 0x01,
PLATFORM_OSX = 0x02,
PLATFORM_XBOX_360 = 0x04,
PLATFORM_PS3 = 0x08,
PLATFORM_LINUX = 0x10
};
DEFINE_ENUM_BITWISE_OPERATORS( EPlatform_t );
#if defined( IS_WINDOWS_PC )
const EPlatform_t thisPlatform = PLATFORM_WIN32;
#elif defined( OSX )
const EPlatform_t thisPlatform = PLATFORM_OSX;
#elif defined( _X360 )
const EPlatform_t thisPlatform = PLATFORM_XBOX_360;
#elif defined( _PS3 )
const EPlatform_t thisPlatform = PLATFORM_PS3;
#elif defined ( _LINUX )
const EPlatform_t thisPlatform = PLATFORM_LINUX;
#else
#error "UNABLE TO DETERMINE PLATFORM"
#endif
#if defined( OSX ) || defined( LINUX )
ILauncherMgr *g_pLauncherMgr = NULL;
#endif
struct VideoSystemInfo_t
{
VideoSystem_t m_SystemID;
EPlatform_t m_Platforms;
const char *m_pModuleName;
const char *m_pInterfaceName;
};
static VideoSystemInfo_t s_VideoAppSystems[] =
{
{ VideoSystem::QUICKTIME, PLATFORM_WIN32 | PLATFORM_OSX, "video_quicktime", VIDEO_SUBSYSTEM_INTERFACE_VERSION },
{ VideoSystem::BINK, PLATFORM_WIN32 | PLATFORM_OSX | PLATFORM_XBOX_360 | PLATFORM_LINUX, "video_bink", VIDEO_SUBSYSTEM_INTERFACE_VERSION },
//{ VideoSystem::AVI, PLATFORM_WIN32, "avi", VIDEO_SUBSYSTEM_INTERFACE_VERSION },
//{ VideoSystem::WMV, PLATFORM_WIN32, "wmv", VIDEO_SUBSYSTEM_INTERFACE_VERSION },
{ VideoSystem::WEBM, PLATFORM_LINUX, "video_webm", VIDEO_SUBSYSTEM_INTERFACE_VERSION },
{ VideoSystem::NONE, PLATFORM_NONE, nullptr, nullptr } // Required to terminate the list
};
//-----------------------------------------------------------------------------
// Setup Singleton for accessing Valve Video Services
//-----------------------------------------------------------------------------
static CValveVideoServices g_VALVeVIDEO;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CValveVideoServices, IVideoServices, VIDEO_SERVICES_INTERFACE_VERSION, g_VALVeVIDEO );
static CVideoCommonServices g_VALVEVIDEOCommon;
//-----------------------------------------------------------------------------
// Valve Video Services implementation
//-----------------------------------------------------------------------------
CValveVideoServices::CValveVideoServices() :
m_nInstalledSystems( 0 ),
m_bInitialized( false ),
m_nMaterialCount( 0 )
{
for ( int i = 0; i < VideoSystem::VIDEO_SYSTEM_COUNT; i++ )
{
m_VideoSystemModule[i] = nullptr;
m_VideoSystems[i] = nullptr;
m_VideoSystemType[i] = VideoSystem::NONE;
m_VideoSystemFeatures[i] = VideoSystemFeature::NO_FEATURES;
}
}
CValveVideoServices::~CValveVideoServices()
{
DisconnectVideoLibraries( );
}
bool CValveVideoServices::Connect( CreateInterfaceFn factory )
{
if ( !BaseClass::Connect( factory ) )
{
return false;
}
if ( g_pFullFileSystem == nullptr || materials == nullptr )
{
Msg( "Valve Video Services unable to connect due to missing dependent system\n" );
return false;
}
#if defined( USE_SDL )
g_pLauncherMgr = (ILauncherMgr *)factory( SDLMGR_INTERFACE_VERSION, NULL );
#endif
if ( !ConnectVideoLibraries( factory ) )
{
return false;
}
return ( true );
}
void CValveVideoServices::Disconnect()
{
DisconnectVideoLibraries();
}
void* CValveVideoServices::QueryInterface( const char *pInterfaceName )
{
if ( Q_strncmp( pInterfaceName, VIDEO_SERVICES_INTERFACE_VERSION, Q_strlen( VIDEO_SERVICES_INTERFACE_VERSION ) + 1) == 0 )
{
return (IVideoServices*) this;
}
return nullptr;
}
bool CValveVideoServices::ConnectVideoLibraries( CreateInterfaceFn factory )
{
// Don't connect twice..
AssertExitF( m_bInitialized == false );
int n = 0;
while ( IS_NOT_EMPTY( s_VideoAppSystems[n].m_pModuleName ) && s_VideoAppSystems[n].m_SystemID != VideoSystem::NONE )
{
if (BITFLAGS_SET( s_VideoAppSystems[n].m_Platforms, thisPlatform ) )
{
bool success = false;
CSysModule *pModule = Sys_LoadModule(s_VideoAppSystems[n].m_pModuleName );
if( pModule != nullptr )
{
CreateInterfaceFn fn = Sys_GetFactory( pModule );
if ( fn != nullptr )
{
IVideoSubSystem *pVideoSystem = (IVideoSubSystem*) fn( s_VideoAppSystems[n].m_pInterfaceName, NULL );
if ( pVideoSystem != nullptr && pVideoSystem->Connect( factory ) )
{
if ( pVideoSystem->InitializeVideoSystem( &g_VALVEVIDEOCommon ) )
{
int slotNum = (int) pVideoSystem->GetSystemID();
if ( IS_IN_RANGECOUNT( slotNum, VideoSystem::VIDEO_SYSTEM_FIRST, VideoSystem::VIDEO_SYSTEM_COUNT ) )
{
Assert( m_VideoSystemModule[slotNum] == nullptr );
m_VideoSystemModule[slotNum] = pModule;
m_VideoSystems[slotNum] = pVideoSystem;
m_nInstalledSystems++;
success = true;
}
}
}
}
if ( success == false )
{
Msg( "Error occurred while attempting to load and initialize Video Subsystem\n Video Subsystem module '%s'\n Video Subsystem Interface '%s'", s_VideoAppSystems[n].m_pModuleName, s_VideoAppSystems[n].m_pInterfaceName );
Sys_UnloadModule( pModule );
}
}
}
n++;
}
// now we query each video system for its capabilities, and supported file extensions
for ( int i = VideoSystem::VIDEO_SYSTEM_FIRST; i < VideoSystem::VIDEO_SYSTEM_COUNT; i++ )
{
IVideoSubSystem *pSubSystem = m_VideoSystems[i];
if ( pSubSystem != nullptr )
{
m_VideoSystemType[i] = pSubSystem->GetSystemID();
m_VideoSystemFeatures[i] = pSubSystem->GetSupportedFeatures();
// get every file extension it handles, and the info about it
int eCount = pSubSystem->GetSupportedFileExtensionCount();
Assert( eCount > 0 );
for ( int n = 0; n < eCount; n++ )
{
VideoFileExtensionInfo_t extInfoRec;
extInfoRec.m_FileExtension = pSubSystem->GetSupportedFileExtension( n );
extInfoRec.m_VideoSubSystem = pSubSystem->GetSystemID();
extInfoRec.m_VideoFeatures = pSubSystem->GetSupportedFileExtensionFeatures( n );
AssertPtr( extInfoRec.m_FileExtension );
m_ExtInfo.AddToTail( extInfoRec );
}
}
}
m_bInitialized = true;
return true;
}
bool CValveVideoServices::DisconnectVideoLibraries()
{
if ( !m_bInitialized )
{
return false;
}
// free up any objects/resources still out there
DestroyAllVideoInterfaces();
for ( int i = 0; i < VideoSystem::VIDEO_SYSTEM_COUNT; i++ )
{
if ( m_VideoSystems[i] != nullptr )
{
m_VideoSystems[i]->ShutdownVideoSystem();
m_VideoSystems[i]->Disconnect();
m_VideoSystems[i] = nullptr;
}
if ( m_VideoSystemModule[i] != nullptr )
{
Sys_UnloadModule( m_VideoSystemModule[i] );
m_VideoSystemModule[i] = nullptr;
}
m_VideoSystemType[i] = VideoSystem::NONE;
m_VideoSystemFeatures[i] = VideoSystemFeature::NO_FEATURES;
}
m_bInitialized = false;
return true;
}
int CValveVideoServices::DestroyAllVideoInterfaces()
{
int n = m_RecorderList.Count() + m_MaterialList.Count();
for ( int i = m_RecorderList.Count() -1; i >= 0; i-- )
{
DestroyVideoRecorder( (IVideoRecorder*) m_RecorderList[i].m_pObject );
}
for ( int i = m_MaterialList.Count() -1; i >= 0; i-- )
{
DestroyVideoMaterial( (IVideoMaterial*) m_MaterialList[i].m_pObject );
}
return n;
}
InitReturnVal_t CValveVideoServices::Init()
{
InitReturnVal_t nRetVal = BaseClass::Init();
if ( nRetVal != INIT_OK )
{
return nRetVal;
}
// Initialize all loaded subsystems
for ( int n = VideoSystem::VIDEO_SYSTEM_FIRST; n < VideoSystem::VIDEO_SYSTEM_COUNT; n++ )
{
if ( m_VideoSystems[n] != nullptr )
{
nRetVal = m_VideoSystems[n]->Init();
if ( nRetVal != INIT_OK )
{
return nRetVal;
}
}
}
return INIT_OK;
}
void CValveVideoServices::Shutdown()
{
DestroyAllVideoInterfaces();
// Shutdown all loaded subsystems
for ( int n = VideoSystem::VIDEO_SYSTEM_FIRST; n < VideoSystem::VIDEO_SYSTEM_COUNT; n++ )
{
if ( m_VideoSystems[n] != nullptr )
{
m_VideoSystems[n]->Shutdown();
}
}
BaseClass::Shutdown();
}
// ===========================================================================
// Inherited from IVideoServices
// ===========================================================================
// Query the available video systems
int CValveVideoServices::GetAvailableVideoSystemCount()
{
return m_nInstalledSystems;
}
// returns the enumerated video system, *IF* it is installed and working
VideoSystem_t CValveVideoServices::GetAvailableVideoSystem( int n )
{
if ( n< 0 || n >= m_nInstalledSystems )
{
return VideoSystem::NONE;
}
for ( int i = VideoSystem::VIDEO_SYSTEM_FIRST, c = 0; i < VideoSystem::VIDEO_SYSTEM_COUNT; i++ )
{
if ( m_VideoSystems[i] != nullptr )
{
if ( c == n )
{
return m_VideoSystemType[i];
}
c++;
}
}
return VideoSystem::NONE;
}
// ===========================================================================
// returns the index for the video system...
// ... provided that system is installed and available to do something
// ===========================================================================
int CValveVideoServices::GetIndexForSystem( VideoSystem_t n )
{
if ( n >= VideoSystem::VIDEO_SYSTEM_FIRST && n < VideoSystem::VIDEO_SYSTEM_COUNT && m_nInstalledSystems > 0 )
{
int i = (int) n;
if ( m_VideoSystems[i] != nullptr && m_VideoSystemFeatures[i] != VideoSystemFeature::NO_FEATURES )
{
return i;
}
}
return SYSTEM_NOT_FOUND;
}
VideoSystem_t CValveVideoServices::GetSystemForIndex( int n )
{
if ( n >= VideoSystem::VIDEO_SYSTEM_FIRST && n < VideoSystem::VIDEO_SYSTEM_COUNT && m_nInstalledSystems > 0 )
{
if ( m_VideoSystems[n] != nullptr && m_VideoSystemFeatures[n] != VideoSystemFeature::NO_FEATURES )
{
return (VideoSystem_t) n;
}
}
return VideoSystem::NONE;
}
// ===========================================================================
// video system query functions
// ===========================================================================
bool CValveVideoServices::IsVideoSystemAvailable( VideoSystem_t videoSystem )
{
int n = GetIndexForSystem( videoSystem );
return ( n != SYSTEM_NOT_FOUND ) ? true : false;
}
VideoSystemStatus_t CValveVideoServices::GetVideoSystemStatus( VideoSystem_t videoSystem )
{
int n = GetIndexForSystem( videoSystem );
return ( n!= SYSTEM_NOT_FOUND ) ? m_VideoSystems[n]->GetSystemStatus() : VideoSystemStatus::NOT_INSTALLED;
}
VideoSystemFeature_t CValveVideoServices::GetVideoSystemFeatures( VideoSystem_t videoSystem )
{
int n = GetIndexForSystem( videoSystem );
return ( n!= SYSTEM_NOT_FOUND ) ? m_VideoSystemFeatures[n] : VideoSystemFeature::NO_FEATURES;
}
const char *CValveVideoServices::GetVideoSystemName( VideoSystem_t videoSystem )
{
int n = GetIndexForSystem( videoSystem );
return ( n!= SYSTEM_NOT_FOUND ) ? m_VideoSystems[n]->GetVideoSystemName() : nullptr;
}
VideoSystem_t CValveVideoServices::FindNextSystemWithFeature( VideoSystemFeature_t features, VideoSystem_t startAfter )
{
if ( ( features & VideoSystemFeature::ALL_VALID_FEATURES ) == 0 )
{
return VideoSystem::NONE;
}
int start = VideoSystem::VIDEO_SYSTEM_FIRST;
if ( startAfter != VideoSystem::NONE && IS_IN_RANGECOUNT( startAfter, VideoSystem::VIDEO_SYSTEM_FIRST, VideoSystem::VIDEO_SYSTEM_COUNT ) )
{
start = (int) startAfter;
}
for ( int i = start; i < VideoSystem::VIDEO_SYSTEM_COUNT; i++ )
{
if ( m_VideoSystems[i] != nullptr && BITFLAGS_SET( m_VideoSystemFeatures[i], features ) )
{
return (VideoSystem_t) i;
}
}
return VideoSystem::NONE;
}
// ===========================================================================
// video services status functions
// ===========================================================================
VideoResult_t CValveVideoServices::GetLastResult()
{
return m_LastResult;
}
VideoResult_t CValveVideoServices::SetResult( VideoResult_t resultCode )
{
m_LastResult = resultCode;
return resultCode;
}
// ===========================================================================
// deal with video file extensions and video system mappings
// ===========================================================================
int CValveVideoServices::GetSupportedFileExtensionCount( VideoSystem_t videoSystem )
{
int n = GetIndexForSystem( videoSystem );
return ( n == SYSTEM_NOT_FOUND ) ? 0 : m_VideoSystems[n]->GetSupportedFileExtensionCount();
}
const char *CValveVideoServices::GetSupportedFileExtension( VideoSystem_t videoSystem, int extNum )
{
int n = GetIndexForSystem( videoSystem );
int c = ( n == SYSTEM_NOT_FOUND ) ? 0 : m_VideoSystems[n]->GetSupportedFileExtensionCount();;
return ( extNum < 0 || extNum >= c ) ? nullptr : m_VideoSystems[n]->GetSupportedFileExtension( extNum );
}
VideoSystemFeature_t CValveVideoServices::GetSupportedFileExtensionFeatures( VideoSystem_t videoSystem, int extNum )
{
int n = GetIndexForSystem( videoSystem );
int c = ( n == SYSTEM_NOT_FOUND ) ? 0 : m_VideoSystems[n]->GetSupportedFileExtensionCount();
return ( extNum < 0 || extNum >= c ) ? VideoSystemFeature::NO_FEATURES : m_VideoSystems[n]->GetSupportedFileExtensionFeatures( extNum );
}
VideoSystem_t CValveVideoServices::LocateVideoSystemForPlayingFile( const char *pFileName, VideoSystemFeature_t playMode )
{
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitV( IS_NOT_EMPTY( pFileName ), VideoSystem::NONE );
VideoSystem_t theSystem = LocateSystemAndFeaturesForFileName( pFileName, nullptr, playMode );
SetResult( VideoResult::SUCCESS );
return theSystem;
}
// ===========================================================================
// Given a video file name, possibly with a set extension, locate the file
// or a suitable substitute that is playable on the current system
// ===========================================================================
VideoResult_t CValveVideoServices::LocatePlayableVideoFile( const char *pSearchFileName, const char *pPathID, VideoSystem_t *pPlaybackSystem, char *pPlaybackFileName, int fileNameMaxLen, VideoSystemFeature_t playMode )
{
AssertExitV( IS_NOT_EMPTY( pSearchFileName ) || pPlaybackSystem == nullptr || pPlaybackSystem == nullptr || fileNameMaxLen <= 0, SetResult( VideoResult::BAD_INPUT_PARAMETERS ) );
VideoResult_t Status = ResolveToPlayableVideoFile( pSearchFileName, pPathID, VideoSystem::DETERMINE_FROM_FILE_EXTENSION, playMode,
true, pPlaybackFileName, fileNameMaxLen, pPlaybackSystem );
return SetResult( Status );
}
// ===========================================================================
// Create/destroy a video material
// ===========================================================================
IVideoMaterial* CValveVideoServices::CreateVideoMaterial( const char *pMaterialName, const char *pVideoFileName, const char *pPathID, VideoPlaybackFlags_t playbackFlags, VideoSystem_t videoSystem, bool PlayAlternateIfNotAvailable )
{
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitV( IS_NOT_EMPTY( pVideoFileName ), nullptr );
AssertExitV( videoSystem == VideoSystem::DETERMINE_FROM_FILE_EXTENSION || IS_IN_RANGECOUNT( videoSystem, VideoSystem::VIDEO_SYSTEM_FIRST, VideoSystem::VIDEO_SYSTEM_COUNT ), nullptr );
// We need to resolve the filename and video system
char ResolvedFilePath[MAX_PATH];
VideoSystem_t actualVideoSystem = videoSystem;
VideoResult_t Status = ResolveToPlayableVideoFile( pVideoFileName, pPathID, videoSystem, VideoSystemFeature::PLAY_VIDEO_FILE_IN_MATERIAL, PlayAlternateIfNotAvailable,
ResolvedFilePath, sizeof(ResolvedFilePath), &actualVideoSystem );
SetResult( Status );
if ( Status != VideoResult::SUCCESS )
{
return nullptr;
}
int sysIndex = GetIndexForSystem( actualVideoSystem );
if ( sysIndex == SYSTEM_NOT_FOUND )
{
SetResult( VideoResult::SYSTEM_ERROR_OCCURED );
return nullptr;
}
// Create the video material
IVideoMaterial *pMaterial = m_VideoSystems[sysIndex]->CreateVideoMaterial( pMaterialName, ResolvedFilePath, playbackFlags );
// Update our list, and return
if ( pMaterial != nullptr )
{
CActiveVideoObjectRecord_t info;
info.m_pObject = pMaterial;
info.m_VideoSystem = sysIndex;
m_MaterialList.AddToTail( info );
}
SetResult( m_VideoSystems[sysIndex]->GetLastResult() );
return pMaterial;
}
VideoResult_t CValveVideoServices::DestroyVideoMaterial( IVideoMaterial* pVideoMaterial )
{
AssertPtrExitV( pVideoMaterial, SetResult( VideoResult::BAD_INPUT_PARAMETERS ) );
for ( int i = 0; i < m_MaterialList.Count(); i++ )
{
if ( m_MaterialList[i].m_pObject == pVideoMaterial )
{
VideoResult_t Status = m_VideoSystems[ m_MaterialList[i].m_VideoSystem ]->DestroyVideoMaterial( pVideoMaterial );
m_MaterialList.Remove( i );
return SetResult( Status );
}
}
return SetResult( VideoResult::RECORDER_NOT_FOUND );
return VideoResult::SUCCESS;
}
int CValveVideoServices::GetUniqueMaterialID()
{
m_nMaterialCount++;
return m_nMaterialCount;
}
// ===========================================================================
// Query availabilily of codec for encoding video
// ===========================================================================
VideoResult_t CValveVideoServices::IsRecordCodecAvailable( VideoSystem_t videoSystem, VideoEncodeCodec_t codec )
{
AssertExitV( codec >= VideoEncodeCodec::DEFAULT_CODEC && codec < VideoEncodeCodec::CODEC_COUNT, SetResult( VideoResult::BAD_INPUT_PARAMETERS ) );
int n = GetIndexForSystem( videoSystem );
if ( n == SYSTEM_NOT_FOUND )
{
return SetResult( VideoResult::SYSTEM_NOT_AVAILABLE );
}
return m_VideoSystems[n]->CheckCodecAvailability( codec );
}
// ===========================================================================
// Create/destroy a video encoder
// ===========================================================================
IVideoRecorder* CValveVideoServices::CreateVideoRecorder( VideoSystem_t videoSystem )
{
int n = GetIndexForSystem( videoSystem );
if ( n == SYSTEM_NOT_FOUND )
{
SetResult( VideoResult::SYSTEM_NOT_AVAILABLE );
return nullptr;
}
if ( !BITFLAGS_SET( m_VideoSystemFeatures[n], VideoSystemFeature::ENCODE_VIDEO_TO_FILE ) )
{
SetResult( VideoResult::FEATURE_NOT_AVAILABLE );
return nullptr;
}
IVideoRecorder *pRecorder = m_VideoSystems[n]->CreateVideoRecorder();
if ( pRecorder != nullptr )
{
CActiveVideoObjectRecord_t info;
info.m_pObject = pRecorder;
info.m_VideoSystem = n;
m_RecorderList.AddToTail( info );
}
SetResult( m_VideoSystems[n]->GetLastResult() );
return pRecorder;
}
VideoResult_t CValveVideoServices::DestroyVideoRecorder( IVideoRecorder *pVideoRecorder )
{
AssertPtrExitV( pVideoRecorder, SetResult( VideoResult::BAD_INPUT_PARAMETERS ) );
for ( int i = 0; i < m_RecorderList.Count(); i++ )
{
if ( m_RecorderList[i].m_pObject == pVideoRecorder )
{
VideoResult_t Status = m_VideoSystems[ m_RecorderList[i].m_VideoSystem ]->DestroyVideoRecorder( pVideoRecorder );
m_RecorderList.Remove( i );
return SetResult( Status );
}
}
return SetResult( VideoResult::RECORDER_NOT_FOUND );
}
// ===========================================================================
// Plays a given video file until it completes or the user aborts
// ===========================================================================
VideoResult_t CValveVideoServices::PlayVideoFileFullScreen( const char *pFileName, const char *pPathID, void *mainWindow, int windowWidth, int windowHeight, int desktopWidth, int desktopHeight, bool windowed, float forcedMinTime, VideoPlaybackFlags_t playbackFlags, VideoSystem_t videoSystem, bool PlayAlternateIfNotAvailable )
{
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitV( IS_NOT_EMPTY( pFileName ), VideoResult::BAD_INPUT_PARAMETERS );
AssertExitV( videoSystem == VideoSystem::DETERMINE_FROM_FILE_EXTENSION || IS_IN_RANGECOUNT( videoSystem, VideoSystem::VIDEO_SYSTEM_FIRST, VideoSystem::VIDEO_SYSTEM_COUNT ), VideoResult::BAD_INPUT_PARAMETERS );
char ResolvedFilePath[MAX_PATH];
VideoSystem_t actualVideoSystem = videoSystem;
VideoResult_t Status = ResolveToPlayableVideoFile( pFileName, pPathID, videoSystem, VideoSystemFeature::PLAY_VIDEO_FILE_FULL_SCREEN, PlayAlternateIfNotAvailable,
ResolvedFilePath, sizeof(ResolvedFilePath), &actualVideoSystem );
if ( Status != VideoResult::SUCCESS )
{
return Status;
}
int sysIndex = GetIndexForSystem( actualVideoSystem );
if ( sysIndex != SYSTEM_NOT_FOUND )
{
return SetResult( m_VideoSystems[sysIndex]->PlayVideoFileFullScreen( ResolvedFilePath, mainWindow, windowWidth, windowHeight, desktopWidth, desktopHeight, windowed, forcedMinTime, playbackFlags ) );
}
else
{
return SetResult( VideoResult::SYSTEM_ERROR_OCCURED );
}
}
// ===========================================================================
// Functions to connect sound systems to video systems
// ===========================================================================
VideoResult_t CValveVideoServices::SoundDeviceCommand( VideoSoundDeviceOperation_t operation, void *pDevice, void *pData, VideoSystem_t videoSystem )
{
AssertExitV( IS_IN_RANGECOUNT( operation, 0, VideoSoundDeviceOperation::OPERATION_COUNT ), SetResult( VideoResult::BAD_INPUT_PARAMETERS ) );
AssertExitV( videoSystem == VideoSystem::ALL_VIDEO_SYSTEMS || IS_IN_RANGECOUNT( videoSystem, VideoSystem::VIDEO_SYSTEM_FIRST, VideoSystem::VIDEO_SYSTEM_COUNT ), SetResult( VideoResult::BAD_INPUT_PARAMETERS ) );
int startIdx = (int) VideoSystem::VIDEO_SYSTEM_FIRST;
int lastIdx = (int) VideoSystem::VIDEO_SYSTEM_COUNT - 1;
if ( videoSystem != VideoSystem::ALL_VIDEO_SYSTEMS )
{
startIdx = lastIdx = GetIndexForSystem( videoSystem );
if ( startIdx == SYSTEM_NOT_FOUND )
{
return SetResult( VideoResult::SYSTEM_NOT_AVAILABLE );
}
}
VideoResult_t result = VideoResult::SYSTEM_NOT_AVAILABLE;
for ( int i = startIdx; i <= lastIdx; i++ )
{
int n = GetIndexForSystem( (VideoSystem_t) i );
if ( n != SYSTEM_NOT_FOUND )
{
result = m_VideoSystems[n]->VideoSoundDeviceCMD( operation, pDevice, pData );
}
}
return SetResult( result );
}
// ===========================================================================
// Sets the sound devices that the video will decode to
// ===========================================================================
const wchar_t *CValveVideoServices::GetCodecName( VideoEncodeCodec_t nCodec )
{
static const char *s_pCodecLookup[VideoEncodeCodec::CODEC_COUNT] =
{
"#Codec_MPEG2",
"#Codec_MPEG4",
"#Codec_H261",
"#Codec_H263",
"#Codec_H264",
"#Codec_MJPEG_A",
"#Codec_MJPEG_B",
"#Codec_SORENSON3",
"#Codec_CINEPACK",
"#Codec_WEBM",
};
if ( nCodec < 0 || nCodec >= VideoEncodeCodec::CODEC_COUNT )
{
AssertMsg( 0, "Invalid codec in CValveVideoServices::GetCodecName()" );
return NULL;
}
return g_pVGuiLocalize->Find( s_pCodecLookup[ nCodec ] );
}
// ===========================================================================
// Functions to determine which file and video system to use
// ===========================================================================
VideoResult_t CValveVideoServices::ResolveToPlayableVideoFile( const char *pFileName, const char *pPathID, VideoSystem_t videoSystem, VideoSystemFeature_t requiredFeature,
bool PlayAlternateIfNotAvailable, char *pResolvedFileName, int resolvedFileNameMaxLen, VideoSystem_t *pResolvedVideoSystem )
{
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitV( IS_NOT_EMPTY( pFileName ), VideoResult::BAD_INPUT_PARAMETERS );
AssertExitV( videoSystem == VideoSystem::DETERMINE_FROM_FILE_EXTENSION || IS_IN_RANGECOUNT( videoSystem, VideoSystem::VIDEO_SYSTEM_FIRST, VideoSystem::VIDEO_SYSTEM_COUNT ), VideoResult::BAD_INPUT_PARAMETERS );
AssertExitV( requiredFeature != VideoSystemFeature::NO_FEATURES, VideoResult::BAD_INPUT_PARAMETERS );
AssertExitV( pResolvedFileName != nullptr && resolvedFileNameMaxLen > 0 && pResolvedVideoSystem != nullptr, VideoResult::BAD_INPUT_PARAMETERS );
// clear results should we return failure
pResolvedFileName[0] = nullchar;
*pResolvedVideoSystem = VideoSystem::NONE;
int sysIdx = SYSTEM_NOT_FOUND;
VideoSystemFeature_t sysFeatures = VideoSystemFeature::NO_FEATURES;
// check the file extension to see if it specifies searching for any compatible video files
// if so, override a couple input values
if ( !IsMatchAnyExtension( pFileName ) )
{
goto search_for_video;
}
// is the requested video system available?
// We start with either the specified video system.. OR.. we choose the system based on the file extension
// Get the system and if it's valid, it's available features
if ( videoSystem != VideoSystem::DETERMINE_FROM_FILE_EXTENSION )
{
sysIdx = GetIndexForSystem( videoSystem ); // Caller specified the video system
sysFeatures = ( sysIdx != SYSTEM_NOT_FOUND ) ? m_VideoSystemFeatures[sysIdx] : VideoSystemFeature::NO_FEATURES;
}
else
{
// We need to determine the system to use based on filename
sysIdx = GetIndexForSystem( LocateSystemAndFeaturesForFileName( pFileName, &sysFeatures, requiredFeature ) );
}
// if we don't have a system to play this video.. and aren't allowed to look for an alternative...
if ( sysIdx == SYSTEM_NOT_FOUND && PlayAlternateIfNotAvailable == false )
{
return SetResult( VideoResult::VIDEO_SYSTEM_NOT_FOUND ); // return failure
}
char ActualFilePath[MAX_PATH];
// Examine the requested of inferred video system to see if it can do what we want,
// and if so, see if the corresponding file is actually found (we support search paths)
// Decision Path for when we have a preferred/specified video system specified to use
if ( sysIdx != SYSTEM_NOT_FOUND )
{
bool fileFound = false;
// if the request system can do the task, see if we can find the file as supplied by the caller
if ( BITFLAGS_SET( sysFeatures, requiredFeature ) )
{
if ( V_IsAbsolutePath( pFileName ) )
{
V_strncpy( ActualFilePath, pFileName, sizeof( ActualFilePath ) );
fileFound = g_pFullFileSystem->FileExists( pFileName, nullptr );
}
else
{
fileFound = ( g_pFullFileSystem->RelativePathToFullPath( pFileName, pPathID, ActualFilePath, sizeof( ActualFilePath ) ) != nullptr );
}
}
else // The specified video system does not support this (required) feature
{
// if we can't search for an alternative file, tell them we don't support this
if ( !PlayAlternateIfNotAvailable )
{
return SetResult( VideoResult::FEATURE_NOT_AVAILABLE );
}
}
// We found the specified file, and the video system has the feature support
if ( fileFound )
{
// copy the resolved filename and system and report success
V_strncpy( pResolvedFileName, ActualFilePath, resolvedFileNameMaxLen );
*pResolvedVideoSystem = GetSystemForIndex( sysIdx );
return SetResult( VideoResult::SUCCESS );
}
// ok, we have the feature support but didn't find the file to use...
if ( !PlayAlternateIfNotAvailable )
{
// if we can't search for an alternate file, so report file not found
return SetResult( VideoResult::VIDEO_FILE_NOT_FOUND );
}
}
// Ok, we didn't find the file and a system that could handle it
// but hey, we are allowed to look for an alternate video file and system
search_for_video:
// start with the passed in filespec, and change the extension to wildcard
char SearchFileSpec[MAX_PATH];
V_strncpy( SearchFileSpec, pFileName, sizeof(SearchFileSpec) );
V_SetExtension( SearchFileSpec, ".*", sizeof(SearchFileSpec) );
FileFindHandle_t searchHandle = 0;
const char *pMatchingFile = g_pFullFileSystem->FindFirstEx( SearchFileSpec, pPathID, &searchHandle );
while ( pMatchingFile != nullptr )
{
const char *pExt = GetFileExtension( pMatchingFile );
if ( pExt != nullptr )
{
// compare file extensions
for ( int i = 0; i < m_ExtInfo.Count(); i++ )
{
// do we match a known extension?
if ( stricmp( pExt, m_ExtInfo[i].m_FileExtension ) == STRINGS_MATCH )
{
// do we support the requested feature?
if ( BITFLAGS_SET( m_ExtInfo[i].m_VideoFeatures, requiredFeature ) )
{
// Make sure it's a valid system
sysIdx = GetIndexForSystem( m_ExtInfo[i].m_VideoSubSystem );
if ( sysIdx != SYSTEM_NOT_FOUND )
{
// Start with any optional path we got...
V_ExtractFilePath( pFileName, ActualFilePath, sizeof( ActualFilePath ) );
// Append the search match file
V_strncat( ActualFilePath, pMatchingFile, sizeof( ActualFilePath ) );
if ( V_IsAbsolutePath( ActualFilePath ) )
{
V_strncpy( pResolvedFileName, ActualFilePath, resolvedFileNameMaxLen );
}
else
{
g_pFullFileSystem->RelativePathToFullPath( ActualFilePath, pPathID, pResolvedFileName, resolvedFileNameMaxLen );
}
// Return the system
*pResolvedVideoSystem = GetSystemForIndex( sysIdx );
g_pFullFileSystem->FindClose( searchHandle );
return SetResult( VideoResult::SUCCESS );
}
}
}
}
}
// not usable.. keep searching
pMatchingFile = g_pFullFileSystem->FindNext( searchHandle );
}
// we didn't find anything we could use
g_pFullFileSystem->FindClose( searchHandle );
return SetResult( VideoResult::VIDEO_FILE_NOT_FOUND );
}
VideoSystem_t CValveVideoServices::LocateSystemAndFeaturesForFileName( const char *pFileName, VideoSystemFeature_t *pFeatures, VideoSystemFeature_t requiredFeatures )
{
if ( pFeatures != nullptr)
{
*pFeatures = VideoSystemFeature::NO_FEATURES;
}
AssertExitV( IS_NOT_EMPTY( pFileName ), VideoSystem::NONE );
if ( m_ExtInfo.Count() < 1 )
{
return VideoSystem::NONE;
}
// extract the file extension
char fileExt[MAX_PATH];
const char *pExt = GetFileExtension( pFileName );
if ( pExt == nullptr )
{
return VideoSystem::NONE;
}
// lowercase it so we can compare
V_strncpy( fileExt, pExt, sizeof(fileExt) );
V_strlower( fileExt );
for ( int i = 0; i < m_ExtInfo.Count(); i++ )
{
if ( V_stricmp( fileExt, m_ExtInfo[i].m_FileExtension ) == STRINGS_MATCH )
{
// must it have certain feature support?
if ( requiredFeatures != VideoSystemFeature::NO_FEATURES )
{
if ( !BITFLAGS_SET( m_ExtInfo[i].m_VideoFeatures, requiredFeatures ) )
{
continue;
}
}
if ( pFeatures != nullptr)
{
*pFeatures = m_ExtInfo[i].m_VideoFeatures;
}
return m_ExtInfo[i].m_VideoSubSystem;
}
}
return VideoSystem::NONE;
}
bool CValveVideoServices::IsMatchAnyExtension( const char *pFileName )
{
if ( IS_EMPTY_STR( pFileName ) )
{
return false;
}
const char* pExt = GetFileExtension( pFileName );
if ( pExt == nullptr )
{
return false;
}
return ( V_stricmp( pExt, FILE_EXTENSION_ANY_MATCHING_VIDEO ) == STRINGS_MATCH );
}
const char *CValveVideoServices::GetFileExtension( const char *pFileName )
{
if ( pFileName == nullptr )
{
return nullptr;
}
const char *pExt = V_GetFileExtension( pFileName );
if ( pExt == nullptr )
{
return nullptr;
}
if ( pExt != pFileName && *( pExt - 1 ) == '.' )
{
pExt--;
}
return pExt;
}
// ===========================================================================
// CVideoCommonServices - services used by any/multiple videoSubsystems
// Functions are put here to avoid duplication and ensure they stay
// consistant across all installed subsystems
// ===========================================================================
#ifdef WIN32
typedef SHORT (WINAPI *GetAsyncKeyStateFn_t)( int vKey );
static HINSTANCE s_UserDLLhInst = nullptr;
GetAsyncKeyStateFn_t s_pfnGetAsyncKeyState = nullptr;
#endif
CVideoCommonServices::CVideoCommonServices()
{
ResetInputHandlerState();
}
CVideoCommonServices::~CVideoCommonServices()
{
if ( m_bInputHandlerInitialized )
{
TerminateFullScreenPlaybackInputHandler();
}
}
void CVideoCommonServices::ResetInputHandlerState()
{
m_bInputHandlerInitialized = false;
m_bScanAll = false;
m_bScanEsc = false;
m_bScanReturn = false;
m_bScanSpace = false;
m_bPauseEnabled = false;
m_bAbortEnabled = false;
m_bEscLast = false;
m_bReturnLast = false;
m_bSpaceLast = false;
m_bForceMinPlayTime = false;
m_bWindowed = false;
m_playbackFlags = VideoPlaybackFlags::NO_PLAYBACK_OPTIONS;
m_forcedMinTime = 0.0f;
m_StartTime = 0;
#ifdef WIN32
s_UserDLLhInst = nullptr;
s_pfnGetAsyncKeyState = nullptr;
#endif
}
// ===========================================================================
// Calculate the proper dimensions to play a video in full screen mode
// uses the playback flags to supply rules for streaching, scaling and
// centering the video
// ===========================================================================
bool CVideoCommonServices::CalculateVideoDimensions( int videoWidth, int videoHeight, int displayWidth, int displayHeight, VideoPlaybackFlags_t playbackFlags,
int *pOutputWidth, int *pOutputHeight, int *pXOffset, int *pYOffset )
{
AssertExitF( pOutputWidth != nullptr && pOutputHeight != nullptr && pXOffset != nullptr && pYOffset != nullptr );
AssertExitF( videoWidth >= 16 && videoHeight >= 16 && displayWidth > 64 && displayHeight > 64 );
// extract relevant options
bool bFillWindow = BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::FILL_WINDOW );
bool bLockAspect = BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::LOCK_ASPECT_RATIO );
bool bIntegralScale = BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::INTEGRAL_SCALE );
bool bCenterVideo = BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::CENTER_VIDEO_IN_WINDOW );
int curWidth = videoWidth;
int curHeight = videoHeight;
// Try and just play it actual size?
if ( !bFillWindow )
{
// is the window the same size or larger?
if ( curWidth <= displayWidth && curHeight <= displayHeight )
{
goto finish;
}
else // we need to shrink the video output
{
// if we aren't locking the aspect ratio, just shrink each axis until it fits
if ( !bLockAspect )
{
while ( curWidth > displayWidth)
{
curWidth = ( bIntegralScale ) ? curWidth >> 1 : displayWidth;
}
while ( curHeight > displayHeight )
{
curHeight = ( bIntegralScale ) ? curHeight >> 1 : displayHeight;
}
goto finish;
}
else // we are locking the aspect ratio, and need to shrink the video
{
// integral scale only....
if ( bIntegralScale )
{
while ( curWidth > displayWidth || curHeight > displayHeight)
{
curWidth >>= 1;
curHeight >>= 1;
}
goto finish;
}
else // can scale variably..
{
float Xfactor = ( displayWidth / curWidth );
float Yfactor = ( displayHeight / curHeight );
float scale = MIN( Xfactor, Yfactor );
curWidth = (int) ( curWidth * scale + 0.35f );
curHeight = (int) ( curHeight * scale + 0.35f );
clamp( curWidth, 0, displayWidth );
clamp( curHeight, 0, displayHeight );
goto finish;
}
}
}
}
// ok.. we are wanting to fill the window....
if ( bFillWindow )
{
// are we locking the aspect ratio?
if ( bLockAspect )
{
// are we only allowed to scale integrally?
if ( bIntegralScale )
{
while ( (curWidth << 1) <= displayWidth && (curHeight << 1) <= displayHeight )
{
curWidth <<= 1;
curHeight <<= 1;
}
goto finish;
}
else
{
float Xfactor = ( (float)displayWidth / curWidth );
float Yfactor = ( (float)displayHeight / curHeight );
float scale = MIN( Xfactor, Yfactor );
curWidth = (int) ( curWidth * scale + 0.35f );
curHeight = (int) ( curHeight * scale + 0.35f );
clamp( curWidth, 0, displayWidth );
clamp( curHeight, 0, displayHeight );
goto finish;
}
}
else // we are not locking the aspect ratio...
{
if ( bIntegralScale )
{
while ( (curWidth << 1) <= displayWidth )
{
curWidth <<= 1;
}
while ( (curHeight << 1) <= displayHeight )
{
curHeight <<= 1;
}
goto finish;
}
else
{
curWidth = displayWidth;
curHeight = displayHeight;
goto finish;
}
}
}
finish:
AssertExitF( displayWidth >= curWidth && displayHeight >= curHeight );
if ( bCenterVideo )
{
*pXOffset = ( displayWidth - curWidth ) >> 1;
*pYOffset = ( displayHeight - curHeight ) >> 1;
}
else
{
*pXOffset = 0;
*pYOffset = 0;
}
*pOutputWidth = curWidth;
*pOutputHeight = curHeight;
return true;
}
float CVideoCommonServices::GetSystemVolume()
{
ConVarRef volumeConVar( "volume" );
float sysVolume = volumeConVar.IsValid() ? volumeConVar.GetFloat() : 1.0f;
clamp( sysVolume, 0.0f, 1.0f);
return sysVolume;
}
// ===========================================================================
// Sets up the state machine to receive messages and poll the keyboard
// while a full-screen video is playing
// ===========================================================================
VideoResult_t CVideoCommonServices::InitFullScreenPlaybackInputHandler( VideoPlaybackFlags_t playbackFlags, float forcedMinTime, bool windowed )
{
// already initialized?
if ( m_bInputHandlerInitialized )
{
WarningAssert( "called twice" );
return VideoResult::OPERATION_ALREADY_PERFORMED;
}
#ifdef WIN32
// We need to be able to poll the state of the input device, but we're not completely setup yet, so this spoofs the ability
HINSTANCE m_UserDLLhInst = LoadLibrary( "user32.dll" );
if ( m_UserDLLhInst == NULL )
{
return VideoResult::SYSTEM_ERROR_OCCURED;
}
s_pfnGetAsyncKeyState = (GetAsyncKeyStateFn_t) GetProcAddress( m_UserDLLhInst, "GetAsyncKeyState" );
if ( s_pfnGetAsyncKeyState == NULL )
{
FreeLibrary( m_UserDLLhInst );
return VideoResult::SYSTEM_ERROR_OCCURED;
}
#endif
// save off playback options
m_playbackFlags = playbackFlags;
m_forcedMinTime = forcedMinTime;
m_bWindowed = windowed;
// process the pause and abort options
m_bScanAll = ANY_BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::PAUSE_ON_ANY_KEY | VideoPlaybackFlags::ABORT_ON_ANY_KEY );
m_bScanEsc = m_bScanAll || ANY_BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::PAUSE_ON_ESC | VideoPlaybackFlags::ABORT_ON_ESC );
m_bScanReturn = m_bScanAll || ANY_BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::PAUSE_ON_RETURN | VideoPlaybackFlags::ABORT_ON_RETURN );
m_bScanSpace = m_bScanAll || ANY_BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::PAUSE_ON_SPACE | VideoPlaybackFlags::ABORT_ON_SPACE );
m_bPauseEnabled = ANY_BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::PAUSE_ON_ESC | VideoPlaybackFlags::PAUSE_ON_RETURN | VideoPlaybackFlags::PAUSE_ON_SPACE | VideoPlaybackFlags::PAUSE_ON_ANY_KEY );
m_bAbortEnabled = ANY_BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::ABORT_ON_ESC | VideoPlaybackFlags::ABORT_ON_RETURN | VideoPlaybackFlags::ABORT_ON_SPACE | VideoPlaybackFlags::ABORT_ON_ANY_KEY );
// Setup the scan options
m_bEscLast = false;
m_bReturnLast = false;
m_bSpaceLast = false;
// Other Movie playback state init
m_bForceMinPlayTime = BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::FORCE_MIN_PLAY_TIME ) && ( forcedMinTime > 0.0f );
// Note the start time
m_StartTime = Plat_FloatTime();
// and we're on
m_bInputHandlerInitialized = true;
return VideoResult::SUCCESS;
}
// ===========================================================================
// Pumps the message loops and checks for a supported event
// returns true if there is an event to check
// ===========================================================================
bool CVideoCommonServices::ProcessFullScreenInput( bool &bAbortEvent, bool &bPauseEvent, bool &bQuitEvent )
{
bAbortEvent = false;
bPauseEvent = false;
bQuitEvent = false;
if ( !m_bInputHandlerInitialized )
{
WarningAssert( "Not Initialized to call" );
return false;
}
// Pump OS Messages
#if defined( WIN32 )
MSG msg;
while ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
// did we get a quit message?
if ( msg.message == WM_QUIT )
{
::PostQuitMessage( msg.wParam );
return true;
}
// todo - look for alt-tab events, etc?
TranslateMessage( &msg );
DispatchMessage( &msg );
}
// Escape, return, or space stops or pauses the playback
bool bEscPressed = ( m_bScanEsc ) ? ( s_pfnGetAsyncKeyState( VK_ESCAPE ) & 0x8000 ) != 0 : false;
bool bReturnPressed = ( m_bScanReturn ) ? ( s_pfnGetAsyncKeyState( VK_RETURN ) & 0x8000 ) != 0 : false;
bool bSpacePressed = ( m_bScanSpace ) ? ( s_pfnGetAsyncKeyState( VK_SPACE ) & 0x8000 ) != 0 : false;
#elif defined(OSX)
g_pLauncherMgr->PumpWindowsMessageLoop();
// Escape, return, or space stops or pauses the playback
bool bEscPressed = ( m_bScanEsc ) ? CGEventSourceKeyState( kCGEventSourceStateCombinedSessionState, kVK_Escape ) : false;
bool bReturnPressed = ( m_bScanReturn ) ? CGEventSourceKeyState( kCGEventSourceStateCombinedSessionState, kVK_Return ) : false;
bool bSpacePressed = ( m_bScanSpace ) ? CGEventSourceKeyState( kCGEventSourceStateCombinedSessionState, kVK_Space ) : false;
#elif defined(LINUX)
g_pLauncherMgr->PumpWindowsMessageLoop();
// Escape, return, or space stops or pauses the playback
bool bEscPressed = false;
bool bReturnPressed = false;
bool bSpacePressed = false;
g_pLauncherMgr->PeekAndRemoveKeyboardEvents( &bEscPressed, &bReturnPressed, &bSpacePressed );
#endif
// Manual debounce of the keys, only interested in unpressed->pressed transitions
bool bEscEvent = ( bEscPressed != m_bEscLast ) && bEscPressed;
bool bReturnEvent = ( bReturnPressed != m_bReturnLast ) && bReturnPressed;
bool bSpaceEvent = ( bSpacePressed != m_bSpaceLast ) && bSpacePressed;
bool bAnyKeyEvent = bEscEvent || bReturnEvent || bSpaceEvent;
m_bEscLast = bEscPressed;
m_bReturnLast = bReturnPressed;
m_bSpaceLast = bSpacePressed;
// Are we forcing a minimum playback time?
// if so, no Abort or Pause events until the necessary time has elasped
if ( m_bForceMinPlayTime )
{
double elapsedTime = Plat_FloatTime() - m_StartTime;
if ( (float) elapsedTime > m_forcedMinTime )
{
m_bForceMinPlayTime = false; // turn off forced minimum
}
}
// any key events to check? ( provided minimum enforced playback has occurred )
if ( m_bForceMinPlayTime == false && bAnyKeyEvent )
{
// check for aborting the movie
if ( m_bAbortEnabled )
{
bAbortEvent = ( bAnyKeyEvent && BITFLAGS_SET( m_playbackFlags, VideoPlaybackFlags::ABORT_ON_ANY_KEY ) ) ||
( bEscEvent && BITFLAGS_SET( m_playbackFlags, VideoPlaybackFlags::ABORT_ON_ESC ) ) ||
( bReturnEvent && BITFLAGS_SET( m_playbackFlags, VideoPlaybackFlags::ABORT_ON_RETURN ) ) ||
( bSpaceEvent && BITFLAGS_SET( m_playbackFlags, VideoPlaybackFlags::ABORT_ON_SPACE ) );
}
// check for pausing the movie?
if ( m_bPauseEnabled )
{
bPauseEvent = ( bAnyKeyEvent && BITFLAGS_SET( m_playbackFlags, VideoPlaybackFlags::PAUSE_ON_ANY_KEY ) ) ||
( bEscEvent && BITFLAGS_SET( m_playbackFlags, VideoPlaybackFlags::PAUSE_ON_ESC ) ) ||
( bReturnEvent && BITFLAGS_SET( m_playbackFlags, VideoPlaybackFlags::PAUSE_ON_RETURN ) ) ||
( bSpaceEvent && BITFLAGS_SET( m_playbackFlags, VideoPlaybackFlags::PAUSE_ON_SPACE ) );
}
}
// notify if any events triggered
return ( bAbortEvent || bPauseEvent );
}
VideoResult_t CVideoCommonServices::TerminateFullScreenPlaybackInputHandler()
{
if ( !m_bInputHandlerInitialized )
{
WarningAssert( "Not Initialized to call" );
return VideoResult::OPERATION_OUT_OF_SEQUENCE;
}
#if defined ( WIN32 )
FreeLibrary( s_UserDLLhInst ); // and free the dll we needed
#endif
ResetInputHandlerState();
return VideoResult::SUCCESS;
}