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.
1464 lines
44 KiB
1464 lines
44 KiB
//========= 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;
|
|
|
|
}
|