H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-23 06:36:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
991585bb98
source-engine/video/quicktime_video.cpp

1097 lines
32 KiB
C++
Raw Normal View History

1
2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "quicktime_video.h"
#include "quicktime_common.h"
#include "quicktime_material.h"
#include "quicktime_recorder.h"
#include "filesystem.h"
#include "tier0/icommandline.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 "vtf/vtf.h"
#include "pixelwriter.h"
#include "tier2/tier2.h"
#include "platform.h"
#if defined ( WIN32 )
#include <WinDef.h>
#include <../dx9sdk/include/dsound.h>
#endif
#include "tier0/memdbgon.h"
// ===========================================================================
// Singleton to expose Quicktime video subsystem
// ===========================================================================
static CQuickTimeVideoSubSystem g_QuickTimeSystem;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CQuickTimeVideoSubSystem, IVideoSubSystem, VIDEO_SUBSYSTEM_INTERFACE_VERSION, g_QuickTimeSystem );
// ===========================================================================
// Convars used by Quicktime
// - these need to be referenced somewhere to keep the compiler from
// optimizing them away
// ===========================================================================
ConVar QuickTime_EncodeGamma( "video_quicktime_encode_gamma", "3", FCVAR_ARCHIVE , "QuickTime Video Encode Gamma Target- 0=no gamma adjust 1=platform default gamma 2 = gamma 1.8 3 = gamma 2.2 4 = gamma 2.5", true, 0.0f, true, 4.0f );
ConVar QuickTime_PlaybackGamma( "video_quicktime_decode_gamma", "0", FCVAR_ARCHIVE , "QuickTime Video Playback Gamma Target- 0=no gamma adjust 1=platform default gamma 2 = gamma 1.8 3 = gamma 2.2 4 = gamma 2.5", true, 0.0f, true, 4.0f );
// ===========================================================================
// List of file extensions and features supported by this subsystem
// ===========================================================================
VideoFileExtensionInfo_t s_QuickTimeExtensions[] =
{
{ ".mov", VideoSystem::QUICKTIME, VideoSystemFeature::FULL_PLAYBACK | VideoSystemFeature::FULL_ENCODE },
{ ".mp4", VideoSystem::QUICKTIME, VideoSystemFeature::FULL_PLAYBACK | VideoSystemFeature::FULL_ENCODE },
};
const int s_QuickTimeExtensionCount = ARRAYSIZE( s_QuickTimeExtensions );
const VideoSystemFeature_t CQuickTimeVideoSubSystem::DEFAULT_FEATURE_SET = VideoSystemFeature::FULL_PLAYBACK | VideoSystemFeature::FULL_ENCODE;
#ifdef OSX
PFNGetGWorldPixMap GetGWorldPixMap = NULL;
PFNGetPixBaseAddr GetPixBaseAddr = NULL;
PFNLockPixels LockPixels = NULL;
PFNUnlockPixels UnlockPixels = NULL;
PFNDisposeGWorld DisposeGWorld = NULL;
PFNSetGWorld SetGWorld = NULL;
PFNGetPixRowBytes GetPixRowBytes = NULL;
#endif
// ===========================================================================
// CQuickTimeVideoSubSystem class
// ===========================================================================
CQuickTimeVideoSubSystem::CQuickTimeVideoSubSystem() :
m_bQuickTimeInitialized( false ),
m_LastResult( VideoResult::SUCCESS ),
m_CurrentStatus( VideoSystemStatus::NOT_INITIALIZED ),
m_AvailableFeatures( CQuickTimeVideoSubSystem::DEFAULT_FEATURE_SET ),
m_pCommonServices( nullptr )
{
}
CQuickTimeVideoSubSystem::~CQuickTimeVideoSubSystem()
{
ShutdownQuickTime(); // Super redundant safety check
}
// ===========================================================================
// IAppSystem methods
// ===========================================================================
bool CQuickTimeVideoSubSystem::Connect( CreateInterfaceFn factory )
{
if ( !BaseClass::Connect( factory ) )
{
return false;
}
if ( g_pFullFileSystem == nullptr || materials == nullptr )
{
Msg( "QuickTime video subsystem failed to connect to missing a required system\n" );
return false;
}
return true;
}
void CQuickTimeVideoSubSystem::Disconnect()
{
BaseClass::Disconnect();
}
void* CQuickTimeVideoSubSystem::QueryInterface( const char *pInterfaceName )
{
if ( IS_NOT_EMPTY( pInterfaceName ) )
{
if ( V_strncmp( pInterfaceName, VIDEO_SUBSYSTEM_INTERFACE_VERSION, Q_strlen( VIDEO_SUBSYSTEM_INTERFACE_VERSION ) + 1) == STRINGS_MATCH )
{
return (IVideoSubSystem*) this;
}
}
return nullptr;
}
InitReturnVal_t CQuickTimeVideoSubSystem::Init()
{
InitReturnVal_t nRetVal = BaseClass::Init();
if ( nRetVal != INIT_OK )
{
return nRetVal;
}
return INIT_OK;
}
void CQuickTimeVideoSubSystem::Shutdown()
{
// Make sure we shut down quicktime
ShutdownQuickTime();
BaseClass::Shutdown();
}
// ===========================================================================
// IVideoSubSystem identification methods
// ===========================================================================
VideoSystem_t CQuickTimeVideoSubSystem::GetSystemID()
{
return VideoSystem::QUICKTIME;
}
VideoSystemStatus_t CQuickTimeVideoSubSystem::GetSystemStatus()
{
return m_CurrentStatus;
}
VideoSystemFeature_t CQuickTimeVideoSubSystem::GetSupportedFeatures()
{
return m_AvailableFeatures;
}
const char* CQuickTimeVideoSubSystem::GetVideoSystemName()
{
return "Quicktime";
}
// ===========================================================================
// IVideoSubSystem setup and shutdown services
// ===========================================================================
bool CQuickTimeVideoSubSystem::InitializeVideoSystem( IVideoCommonServices *pCommonServices )
{
m_AvailableFeatures = DEFAULT_FEATURE_SET; // Put here because of issue with static const int, binary OR and DEBUG builds
AssertPtr( pCommonServices );
m_pCommonServices = pCommonServices;
#ifdef OSX
if ( !GetGWorldPixMap )
GetGWorldPixMap = (PFNGetGWorldPixMap)dlsym( RTLD_DEFAULT, "GetGWorldPixMap" );
if ( !GetPixBaseAddr )
GetPixBaseAddr = (PFNGetPixBaseAddr)dlsym( RTLD_DEFAULT, "GetPixBaseAddr" );
if ( !LockPixels )
LockPixels = (PFNLockPixels)dlsym( RTLD_DEFAULT, "LockPixels" );
if ( !UnlockPixels )
UnlockPixels = (PFNUnlockPixels)dlsym( RTLD_DEFAULT, "UnlockPixels" );
if ( !DisposeGWorld )
DisposeGWorld = (PFNDisposeGWorld)dlsym( RTLD_DEFAULT, "DisposeGWorld" );
if ( !SetGWorld )
SetGWorld = (PFNSetGWorld)dlsym( RTLD_DEFAULT, "SetGWorld" );
if ( !GetPixRowBytes )
GetPixRowBytes = (PFNGetPixRowBytes)dlsym( RTLD_DEFAULT, "GetPixRowBytes" );
if ( !GetGWorldPixMap || !GetPixBaseAddr || !LockPixels || !UnlockPixels || !DisposeGWorld || !SetGWorld || !GetPixRowBytes )
return false;
#endif
return ( m_bQuickTimeInitialized ) ? true : SetupQuickTime();
}
bool CQuickTimeVideoSubSystem::ShutdownVideoSystem()
{
return ( m_bQuickTimeInitialized ) ? ShutdownQuickTime() : true;
}
VideoResult_t CQuickTimeVideoSubSystem::VideoSoundDeviceCMD( VideoSoundDeviceOperation_t operation, void *pDevice, void *pData )
{
switch ( operation )
{
case VideoSoundDeviceOperation::SET_DIRECT_SOUND_DEVICE:
{
return SetResult( VideoResult::OPERATION_NOT_SUPPORTED );
}
case VideoSoundDeviceOperation::SET_MILES_SOUND_DEVICE:
case VideoSoundDeviceOperation::HOOK_X_AUDIO:
{
return SetResult( VideoResult::OPERATION_NOT_SUPPORTED );
}
default:
{
return SetResult( VideoResult::UNKNOWN_OPERATION );
}
}
}
// ===========================================================================
// IVideoSubSystem supported extensions & features
// ===========================================================================
int CQuickTimeVideoSubSystem::GetSupportedFileExtensionCount()
{
return s_QuickTimeExtensionCount;
}
const char* CQuickTimeVideoSubSystem::GetSupportedFileExtension( int num )
{
return ( num < 0 || num >= s_QuickTimeExtensionCount ) ? nullptr : s_QuickTimeExtensions[num].m_FileExtension;
}
VideoSystemFeature_t CQuickTimeVideoSubSystem::GetSupportedFileExtensionFeatures( int num )
{
return ( num < 0 || num >= s_QuickTimeExtensionCount ) ? VideoSystemFeature::NO_FEATURES : s_QuickTimeExtensions[num].m_VideoFeatures;
}
// ===========================================================================
// IVideoSubSystem Video Playback and Recording Services
// ===========================================================================
VideoResult_t CQuickTimeVideoSubSystem::PlayVideoFileFullScreen( const char *filename, void *mainWindow, int windowWidth, int windowHeight, int desktopWidth, int desktopHeight, bool windowed, float forcedMinTime, VideoPlaybackFlags_t playbackFlags )
{
OSErr status;
// See if the caller is asking for a feature we can not support....
VideoPlaybackFlags_t unsupportedFeatures = VideoPlaybackFlags::PRELOAD_VIDEO;
if ( playbackFlags & unsupportedFeatures )
{
return SetResult( VideoResult::FEATURE_NOT_AVAILABLE );
}
// Make sure we are initialized and ready
if ( !m_bQuickTimeInitialized )
{
SetupQuickTime();
}
AssertExitV( m_CurrentStatus == VideoSystemStatus::OK, SetResult( VideoResult::SYSTEM_NOT_AVAILABLE ) );
// Set graphics port
#if defined ( WIN32 )
SetGWorld ( (CGrafPtr) GetNativeWindowPort( nil ), nil );
#elif defined ( OSX )
SystemUIMode oldMode;
SystemUIOptions oldOptions;
GetSystemUIMode( &oldMode, &oldOptions );
if ( !windowed )
{
status = SetSystemUIMode( kUIModeAllHidden, (SystemUIOptions) 0 );
Assert( status == noErr );
}
SetGWorld( nil, nil );
#endif
// -------------------------------------------------
// Open the quicktime file with audio
Movie theQTMovie = NULL;
Rect theQTMovieRect;
QTAudioContextRef theAudioContext = NULL;
Handle MovieFileDataRef = nullptr;
OSType MovieFileDataRefType = 0;
CFStringRef imageStrRef = CFStringCreateWithCString ( NULL, filename, 0 );
AssertExitV( imageStrRef != nullptr, SetResult( VideoResult::SYSTEM_ERROR_OCCURED ) );
status = QTNewDataReferenceFromFullPathCFString( imageStrRef, (QTPathStyle) kQTNativeDefaultPathStyle, 0, &MovieFileDataRef, &MovieFileDataRefType );
AssertExitV( status == noErr, SetResult( VideoResult::FILE_ERROR_OCCURED ) );
CFRelease( imageStrRef );
status = NewMovieFromDataRef( &theQTMovie, newMovieActive, nil, MovieFileDataRef, MovieFileDataRefType );
SAFE_DISPOSE_HANDLE( MovieFileDataRef );
if ( status != noErr )
{
#if defined ( OSX )
SetSystemUIMode( oldMode, oldOptions );
#endif
Assert( false );
return SetResult( VideoResult::FILE_ERROR_OCCURED );
}
// Get info about the video
GetMovieNaturalBoundsRect(theQTMovie, &theQTMovieRect);
TimeValue theQTMovieDuration = GetMovieDuration( theQTMovie );
// what size do we set the output rect to?
// Integral scaling is much faster, so always scale the video as such
int nNewWidth = (int) theQTMovieRect.right;
int nNewHeight = (int) theQTMovieRect.bottom;
// Determine the window we are rendering video into
int displayWidth = windowWidth;
int displayHeight = windowHeight;
// on mac OSX, if we are fullscreen, quicktime is bypassing our targets and going to the display directly, so use its dimensions
if ( IsOSX() && windowed == false )
{
displayWidth = desktopWidth;
displayHeight = desktopHeight;
}
// get the size of the target video output
int nBufferWidth = nNewWidth;
int nBufferHeight = nNewHeight;
int displayXOffset = 0;
int displayYOffset = 0;
if ( !m_pCommonServices->CalculateVideoDimensions( nNewWidth, nNewHeight, displayWidth, displayHeight, playbackFlags, &nBufferWidth, &nBufferHeight, &displayXOffset, &displayYOffset ) )
{
#if defined ( OSX )
SetSystemUIMode( oldMode, oldOptions );
#endif
return SetResult( VideoResult::VIDEO_ERROR_OCCURED );
}
theQTMovieRect.left = (short) displayXOffset;
theQTMovieRect.right = (short) ( displayXOffset + nBufferWidth );
theQTMovieRect.top = (short) displayYOffset;
theQTMovieRect.bottom = (short) ( displayYOffset + nBufferHeight );
SetMovieBox( theQTMovie, &theQTMovieRect );
// Check to see if we should include audio playback
bool enableMovieAudio = !BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::NO_AUDIO );
if ( !CreateMovieAudioContext( enableMovieAudio, theQTMovie, &theAudioContext, true) )
{
#if defined ( OSX )
SetSystemUIMode( oldMode, oldOptions );
#endif
return SetResult( VideoResult::AUDIO_ERROR_OCCURED );
}
// need to get the graphics port associated with the main window
#if defined( WIN32 )
CreatePortAssociation( mainWindow, NULL, 0 );
GrafPtr theGrafPtr = GetNativeWindowPort( mainWindow );
#elif defined( OSX )
GrafPtr theGrafPtr = GetWindowPort( (OpaqueWindowPtr*)mainWindow );
#endif
// Setup the playback gamma according to the convar
SetGWorldDecodeGamma( (CGrafPtr) theGrafPtr, VideoPlaybackGamma::USE_GAMMA_CONVAR );
// Assign the GWorld to this movie
SetMovieGWorld( theQTMovie, (CGrafPtr) theGrafPtr, NULL );
// Setup the keyboard and message handler for fullscreen playback
if ( SetResult( m_pCommonServices->InitFullScreenPlaybackInputHandler( playbackFlags, forcedMinTime, windowed ) ) != VideoResult::SUCCESS )
{
#if defined ( OSX )
SetSystemUIMode( oldMode, oldOptions );
#endif
return GetLastResult();
}
// Other Movie playback state init
bool bPaused = false;
// Init Movie info
TimeRecord movieStartTime;
TimeRecord moviePauseTime;
GoToBeginningOfMovie( theQTMovie );
GetMovieTime( theQTMovie, &movieStartTime );
// Start movie playback
StartMovie( theQTMovie );
// loop while movie is playing
while ( true )
{
bool bAbortEvent, bPauseEvent, bQuitEvent;
if ( m_pCommonServices->ProcessFullScreenInput( bAbortEvent, bPauseEvent, bQuitEvent ) )
{
// check for aborting the movie
if ( bAbortEvent || bQuitEvent )
{
goto abort_playback;
}
// check for pausing the movie?
if ( bPauseEvent )
{
if ( bPaused == false ) // pausing the movie?
{
GetMovieTime( theQTMovie, &moviePauseTime );
StopMovie( theQTMovie );
bPaused = true;
}
else // unpause the movie
{
SetMovieTime( theQTMovie, &moviePauseTime );
StartMovie( theQTMovie );
bPaused = false;
}
}
}
// hit the end of the movie?
TimeValue now = GetMovieTime( theQTMovie, nullptr );
if ( now >= theQTMovieDuration )
{
// Loop this movie until aborted?
if ( playbackFlags & BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::LOOP_VIDEO ) )
{
Assert( ANY_BITFLAGS_SET( playbackFlags, VideoPlaybackFlags::ABORT_ON_ESC | VideoPlaybackFlags::ABORT_ON_RETURN | VideoPlaybackFlags::ABORT_ON_SPACE | VideoPlaybackFlags::ABORT_ON_ANY_KEY ) ); // Movie will loop forever otherwise
StopMovie( theQTMovie );
SetMovieTime( theQTMovie, &movieStartTime );
StartMovie( theQTMovie );
}
else
{
break; // finished actually, exit loop
}
}
// if the movie is paused, sleep for 5ms to keeps the CPU from spinning so hard
if ( bPaused )
{
ThreadSleep( 1 );
}
else
{
// Keep the movie running....
MoviesTask( theQTMovie, 0L );
}
}
// Close it all down
abort_playback:
StopMovie( theQTMovie );
SAFE_RELEASE_AUDIOCONTEXT( theAudioContext );
SAFE_DISPOSE_MOVIE( theQTMovie );
m_pCommonServices->TerminateFullScreenPlaybackInputHandler();
#if defined ( OSX )
SetSystemUIMode( oldMode, oldOptions );
#endif
return SetResult( VideoResult::SUCCESS );
}
// ===========================================================================
// IVideoSubSystem Video Material Services
// note that the filename is absolute and has already resolved any paths
// ===========================================================================
IVideoMaterial* CQuickTimeVideoSubSystem::CreateVideoMaterial( const char *pMaterialName, const char *pVideoFileName, VideoPlaybackFlags_t flags )
{
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitN( m_CurrentStatus == VideoSystemStatus::OK && IS_NOT_EMPTY( pMaterialName ) || IS_NOT_EMPTY( pVideoFileName ) );
CQuickTimeMaterial *pVideoMaterial = new CQuickTimeMaterial();
if ( pVideoMaterial == nullptr || pVideoMaterial->Init( pMaterialName, pVideoFileName, flags ) == false )
{
SAFE_DELETE( pVideoMaterial );
SetResult( VideoResult::VIDEO_ERROR_OCCURED );
return nullptr;
}
IVideoMaterial *pInterface = (IVideoMaterial*) pVideoMaterial;
m_MaterialList.AddToTail( pInterface );
SetResult( VideoResult::SUCCESS );
return pInterface;
}
VideoResult_t CQuickTimeVideoSubSystem::DestroyVideoMaterial( IVideoMaterial *pVideoMaterial )
{
AssertExitV( m_CurrentStatus == VideoSystemStatus::OK, SetResult( VideoResult::SYSTEM_NOT_AVAILABLE ) );
AssertPtrExitV( pVideoMaterial, SetResult( VideoResult::BAD_INPUT_PARAMETERS ) );
if ( m_MaterialList.Find( pVideoMaterial ) != -1 )
{
CQuickTimeMaterial *pObject = (CQuickTimeMaterial*) pVideoMaterial;
pObject->Shutdown();
delete pObject;
m_MaterialList.FindAndFastRemove( pVideoMaterial );
return SetResult( VideoResult::SUCCESS );
}
return SetResult (VideoResult::MATERIAL_NOT_FOUND );
}
// ===========================================================================
// IVideoSubSystem Video Recorder Services
// ===========================================================================
IVideoRecorder* CQuickTimeVideoSubSystem::CreateVideoRecorder()
{
SetResult( VideoResult::SYSTEM_NOT_AVAILABLE );
AssertExitN( m_CurrentStatus == VideoSystemStatus::OK );
CQuickTimeVideoRecorder *pVideoRecorder = new CQuickTimeVideoRecorder();
if ( pVideoRecorder != nullptr )
{
IVideoRecorder *pInterface = (IVideoRecorder*) pVideoRecorder;
m_RecorderList.AddToTail( pInterface );
SetResult( VideoResult::SUCCESS );
return pInterface;
}
SetResult( VideoResult::VIDEO_ERROR_OCCURED );
return nullptr;
}
VideoResult_t CQuickTimeVideoSubSystem::DestroyVideoRecorder( IVideoRecorder *pRecorder )
{
AssertExitV( m_CurrentStatus == VideoSystemStatus::OK, SetResult( VideoResult::SYSTEM_NOT_AVAILABLE ) );
AssertPtrExitV( pRecorder, SetResult( VideoResult::BAD_INPUT_PARAMETERS ) );
if ( m_RecorderList.Find( pRecorder ) != -1 )
{
CQuickTimeVideoRecorder *pVideoRecorder = (CQuickTimeVideoRecorder*) pRecorder;
delete pVideoRecorder;
m_RecorderList.FindAndFastRemove( pRecorder );
return SetResult( VideoResult::SUCCESS );
}
return SetResult( VideoResult::RECORDER_NOT_FOUND );
}
VideoResult_t CQuickTimeVideoSubSystem::CheckCodecAvailability( VideoEncodeCodec_t codec )
{
AssertExitV( m_CurrentStatus == VideoSystemStatus::OK, SetResult( VideoResult::SYSTEM_NOT_AVAILABLE ) );
AssertExitV( codec >= VideoEncodeCodec::DEFAULT_CODEC && codec < VideoEncodeCodec::CODEC_COUNT, SetResult( VideoResult::BAD_INPUT_PARAMETERS ) );
// map the requested codec in
CodecType theCodec;
switch( codec )
{
case VideoEncodeCodec::MPEG2_CODEC:
{
theCodec = kMpegYUV420CodecType;
break;
}
case VideoEncodeCodec::MPEG4_CODEC:
{
theCodec = kMPEG4VisualCodecType;
break;
}
case VideoEncodeCodec::H261_CODEC:
{
theCodec = kH261CodecType;
break;
}
case VideoEncodeCodec::H263_CODEC:
{
theCodec = kH263CodecType;
break;
}
case VideoEncodeCodec::H264_CODEC:
{
theCodec = kH264CodecType;
break;
}
case VideoEncodeCodec::MJPEG_A_CODEC:
{
theCodec = kMotionJPEGACodecType;
break;
}
case VideoEncodeCodec::MJPEG_B_CODEC:
{
theCodec = kMotionJPEGBCodecType;
break;
}
case VideoEncodeCodec::SORENSON3_CODEC:
{
theCodec = kSorenson3CodecType;
break;
}
case VideoEncodeCodec::CINEPACK_CODEC:
{
theCodec = kCinepakCodecType;
break;
}
default: // should never hit this because we are already range checked
{
theCodec = CQTVideoFileComposer::DEFAULT_CODEC;
break;
}
}
// Determine if codec is available...
CodecInfo theInfo;
OSErr status = GetCodecInfo( &theInfo, theCodec, 0 );
if ( status == noCodecErr )
{
return SetResult( VideoResult::CODEC_NOT_AVAILABLE );;
}
AssertExitV( status == noErr, SetResult( VideoResult::CODEC_NOT_AVAILABLE ) );
return SetResult( VideoResult::SUCCESS );
}
// ===========================================================================
// Status support
// ===========================================================================
VideoResult_t CQuickTimeVideoSubSystem::GetLastResult()
{
return m_LastResult;
}
VideoResult_t CQuickTimeVideoSubSystem::SetResult( VideoResult_t status )
{
m_LastResult = status;
return status;
}
// ===========================================================================
// Quicktime Initialization & Shutdown
// ===========================================================================
bool CQuickTimeVideoSubSystem::SetupQuickTime()
{
SetResult( VideoResult::INITIALIZATION_ERROR_OCCURED);
AssertExitF( m_bQuickTimeInitialized == false );
// This is set early to indicate we have already been through here, even if we error out for some reason
m_bQuickTimeInitialized = true;
m_CurrentStatus = VideoSystemStatus::NOT_INITIALIZED;
m_AvailableFeatures = VideoSystemFeature::NO_FEATURES;
if ( CommandLine()->FindParm( "-noquicktime" ) )
{
// Don't even try. leave status as NOT_INITIALIZED
return true;
}
// Windows PC build
#if defined ( WIN32 )
OSErr status = InitializeQTML( 0 );
// if -2903 (qtmlDllLoadErr) then quicktime not installed on this system
if ( status != noErr )
{
if ( status == qtmlDllLoadErr )
{
m_CurrentStatus = VideoSystemStatus::NOT_INITIALIZED;
return true;
}
Msg( "Unknown QuickTime Initialization Error = %d \n", (int) status );
Assert( false );
m_CurrentStatus = VideoSystemStatus::NOT_INITIALIZED;
return true;
}
// Make sure we have version 7.04 or greater of quicktime
long version = 0;
status = Gestalt( gestaltQuickTime, &version );
if ( ( status != noErr ) || ( version < 0x07608000 ) )
{
TerminateQTML();
m_CurrentStatus = VideoSystemStatus::NOT_CURRENT_VERSION;
Msg( "QuickTime Version reports to be ver= %8.8x, less than 7.6 (07608000) required\n", version );
Assert( false );
return true;
}
#endif
// Windows PC, or Mac OSX build
OSErr status2 = EnterMovies(); // Initialize QuickTime Movie Toolbox
if ( status2 != noErr )
{
// Windows PC -- shutdown Quicktime
#if defined ( WIN32 )
TerminateQTML();
#endif
Msg( "Quicktime Error when attempting to EnterMovies, err = %d \n", (int) status2 );
Assert( false );
m_CurrentStatus = VideoSystemStatus::INITIALIZATION_ERROR;
return true;
}
m_CurrentStatus = VideoSystemStatus::OK;
m_AvailableFeatures = DEFAULT_FEATURE_SET;
// if the Library load didn't hook up the compression functions, remove them from our feature list
#pragma warning ( disable : 4551 )
if ( !CompressImage )
{
m_AvailableFeatures = m_AvailableFeatures & ~( VideoSystemFeature::ENCODE_VIDEO_TO_FILE | VideoSystemFeature::ENCODE_AUDIO_TO_FILE );
}
#pragma warning ( default : 4551 )
// Note that we are now open for business....
m_bQuickTimeInitialized = true;
SetResult( VideoResult::SUCCESS );
return true;
}
bool CQuickTimeVideoSubSystem::ShutdownQuickTime()
{
if ( m_bQuickTimeInitialized && m_CurrentStatus == VideoSystemStatus::OK )
{
ExitMovies(); // Terminate QuickTime
// Windows PC only shutdown
#if defined ( WIN32 )
TerminateQTML(); // Terminate QTML
#endif
}
m_bQuickTimeInitialized = false;
m_CurrentStatus = VideoSystemStatus::NOT_INITIALIZED;
m_AvailableFeatures = VideoSystemFeature::NO_FEATURES;
SetResult( VideoResult::SUCCESS );
return true;
}
// ===========================================================================
// Functions defined in Quicktime Common
// ===========================================================================
// makes a copy of a string
char *COPY_STRING( const char *pString )
{
if ( pString == nullptr )
{
return nullptr;
}
size_t strLen = V_strlen( pString );
char *pNewStr = new char[ strLen+ 1 ];
if ( strLen > 0 )
{
V_memcpy( pNewStr, pString, strLen );
}
pNewStr[strLen] = nullchar;
return pNewStr;
}
//-----------------------------------------------------------------------------
// Adapted from QuickTime Frame Rate code from Apple OSX Reference Library
// found at http://developer.apple.com/library/mac/#qa/qa2001/qa1262.html
//-----------------------------------------------------------------------------
#define kCharacteristicHasVideoFrameRate FOUR_CHAR_CODE('vfrr')
#define kCharacteristicIsAnMpegTrack FOUR_CHAR_CODE('mpeg')
bool MediaGetStaticFrameRate( Media inMovieMedia, VideoFrameRate_t &theFrameRate, bool AssumeConstantIntervals );
//-----------------------------------------------------------------------------
bool MovieGetStaticFrameRate( Movie inMovie, VideoFrameRate_t &theFrameRate )
{
theFrameRate.Clear();
AssertExitF( inMovie != nullptr );
Boolean isMPEG = false;
Media movieMedia = nullptr;
MediaHandler movieMediaHandler = nullptr;
bool success = false;
// get the media identifier for the media that contains the first
// video track's sample data, and also get the media handler for this media.
Track videoTrack = GetMovieIndTrackType( inMovie, 1, kCharacteristicHasVideoFrameRate, movieTrackCharacteristic | movieTrackEnabledOnly ); // get first video track
if ( videoTrack == nullptr || GetMoviesError() != noErr )
goto error_out;
// get media ref. for track's sample data
movieMedia = GetTrackMedia( videoTrack );
if ( movieMedia == nullptr || GetMoviesError() != noErr )
goto error_out;
// get a reference to the media handler component
movieMediaHandler = GetMediaHandler( movieMedia );
if ( movieMediaHandler == nullptr || GetMoviesError() != noErr )
goto error_out;
// is this the MPEG-1/MPEG-2 media handler?
if ( MediaHasCharacteristic( movieMediaHandler, kCharacteristicIsAnMpegTrack, &isMPEG ) != noErr )
goto error_out;
if (isMPEG) // working with MPEG-1/MPEG-2 media
{
MHInfoEncodedFrameRateRecord encodedFrameRate;
Size encodedFrameRateSize = sizeof( encodedFrameRate );
// get the static frame rate
if ( MediaGetPublicInfo( movieMediaHandler, kMHInfoEncodedFrameRate, &encodedFrameRate, &encodedFrameRateSize ) != noErr )
goto error_out;
TimeScale MovieTimeScale = GetMovieTimeScale( inMovie );
Assert( MovieTimeScale > 0 && encodedFrameRate.encodedFrameRate > 0 );
theFrameRate.SetRaw( MovieTimeScale, int ( (double) MovieTimeScale / Fix2X( encodedFrameRate.encodedFrameRate ) + 0.5 ) );
}
else // working with non-MPEG-1/MPEG-2 media
{
if ( !MediaGetStaticFrameRate( movieMedia, theFrameRate, true ) )
goto error_out;
}
success = true;
error_out:
return success;
}
// ============================================================================
// Given a reference to the media that contains the sample data for a track,
// calculate the static frame rate.
// ============================================================================
bool MediaGetStaticFrameRate( Media inMovieMedia, VideoFrameRate_t &theFrameRate, bool AssumeConstantIntervals )
{
Assert( inMovieMedia != nullptr );
theFrameRate.Clear();
// Method #1 - from Apple
if ( !AssumeConstantIntervals )
{
// get the number of samples in the media
long sampleCount = GetMediaSampleCount( inMovieMedia );
if ( GetMoviesError() != noErr || sampleCount == 0 )
return false;
// find the media duration
TimeValue64 duration = GetMediaDisplayDuration( inMovieMedia );
if ( GetMoviesError() != noErr || duration == 0 )
return false;
// get the media time scale
TimeValue64 timeScale = GetMediaTimeScale( inMovieMedia );
if ( GetMoviesError() != noErr || timeScale == 0 )
return false;
// calculate the frame rate: = (sample count * media time scale) / media duration
float FPS = (double) sampleCount * (double) timeScale / (double) duration;
theFrameRate.SetFPS( FPS );
return true;
}
// FPS rate method #2 - assumes all frames are at a constant interval
// gets FPS in terms of units per second (preferred)
TimeValue64 sample_time = 0;
TimeValue64 sample_duration = -1;
GetMediaNextInterestingDisplayTime( inMovieMedia, nextTimeMediaSample | nextTimeEdgeOK, (TimeValue64) 0 , fixed1, &sample_time, &sample_duration );
if ( sample_time == -1 || sample_duration == 0 || GetMoviesError() != noErr )
return false;
TimeValue64 sample_time2 = 0;
TimeValue64 sample_duration2 = -1;
GetMediaNextInterestingDisplayTime( inMovieMedia, nextTimeMediaSample | nextTimeEdgeOK, sample_time + sample_duration , fixed1, &sample_time2, &sample_duration2 );
if ( sample_time2 == -1 || sample_duration2 == 0 || GetMoviesError() != noErr )
return false;
TimeScale MediaTimeScale = GetMediaTimeScale( inMovieMedia );
if ( MediaTimeScale <= 0 || GetMoviesError() != noErr )
return false;
Assert( sample_time2 == sample_time + sample_duration );
Assert( sample_duration == sample_duration2 );
theFrameRate.SetRaw( MediaTimeScale, (int) sample_duration );
return true;
}
// ============================================================================
// SetGWorldDecodeGamma - configure a GWorld to perform any needed gamma
// correction
//
// kQTUsePlatformDefaultGammaLevel = 0, /* When decompressing into this PixMap, gamma-correct to the platform's standard gamma. */
// kQTUseSourceGammaLevel = -1L, /* When decompressing into this PixMap, don't perform gamma-correction. */
// kQTCCIR601VideoGammaLevel = 0x00023333 /* 2.2, standard television video gamma.*/
// Fixed cGamma1_8 = 0x0001CCCC; // Gamma 1.8
// Fixed cGamma2_5 = 0x00028000; // Gamma 2.5
// ============================================================================
bool SetGWorldDecodeGamma( CGrafPtr theGWorld, VideoPlaybackGamma_t gamma )
{
AssertExitF( theGWorld != nullptr );
AssertIncRange( gamma, VideoPlaybackGamma::USE_GAMMA_CONVAR, VideoPlaybackGamma::GAMMA_2_5 );
Fixed decodeGamma = kQTUseSourceGammaLevel;
if ( gamma == VideoPlaybackGamma::USE_GAMMA_CONVAR )
{
int useGamma = QuickTime_PlaybackGamma.GetInt();
if ( useGamma < (int) VideoPlaybackGamma::NO_GAMMA_ADJUST || useGamma >= VideoPlaybackGamma::GAMMA_COUNT )
return false;
gamma = (VideoPlaybackGamma_t) useGamma;
}
switch( gamma )
{
case VideoPlaybackGamma::NO_GAMMA_ADJUST:
{
decodeGamma = kQTUseSourceGammaLevel;
break;
}
case VideoPlaybackGamma::PLATFORM_DEFAULT_GAMMMA:
{
decodeGamma = kQTUsePlatformDefaultGammaLevel;
break;
}
case VideoPlaybackGamma::GAMMA_1_8:
{
decodeGamma = 0x0001CCCC; // Gamma 1.8
break;
}
case VideoPlaybackGamma::GAMMA_2_2:
{
decodeGamma = 0x00023333; // Gamma 2.2
break;
}
case VideoPlaybackGamma::GAMMA_2_5:
{
decodeGamma = 0x00028000; // Gamma 2.5
break;
}
default:
{
Assert( false );
break;
}
}
// Get the pix map for the GWorld and adjust the gamma correction on it
PixMapHandle thePixMap = GetGWorldPixMap( theGWorld );
AssertExitF( thePixMap != nullptr );
// Set the Gamma level for the pixmap
OSErr Status = QTSetPixMapHandleGammaLevel( thePixMap, decodeGamma );
AssertExitF( Status == noErr );
// Set the Requested Gamma level for the pixmap
Status = QTSetPixMapHandleRequestedGammaLevel( thePixMap, decodeGamma );
AssertExitF( Status == noErr );
return true;
}
// ============================================================================
// Setup a quicktime Audio Context for a movie
// ============================================================================
bool CreateMovieAudioContext( bool enableAudio, Movie inMovie, QTAudioContextRef *pAudioContext, bool setVolume, float *pCurrentVolume )
{
AssertExitF( inMovie != nullptr && pAudioContext != nullptr );
if ( enableAudio )
{
#if defined ( WIN32 )
WCHAR strGUID[39];
int numBytes = StringFromGUID2( DSDEVID_DefaultPlayback, (LPOLESTR) strGUID, 39); // CLSID_DirectSound is not what you want here
// create the audio context
CFStringRef deviceNameStrRef = CFStringCreateWithCharacters(kCFAllocatorDefault, (const UniChar*) strGUID, (CFIndex) (numBytes -1) );
OSStatus result = QTAudioContextCreateForAudioDevice( NULL, deviceNameStrRef, NULL, pAudioContext );
AssertExitF( result == noErr );
SAFE_RELEASE_CFREF( deviceNameStrRef );
#elif defined ( OSX )
OSStatus result = QTAudioContextCreateForAudioDevice( NULL, NULL, NULL, pAudioContext );
AssertExitF( result == noErr );
#endif
// valid?
AssertPtr( *pAudioContext );
}
else // no audio
{
*pAudioContext = nullptr;
}
// Set the audio context
OSStatus result = SetMovieAudioContext( inMovie, *pAudioContext );
AssertExitF( result == noErr );
if ( setVolume && *pAudioContext != nullptr )
{
ConVarRef volumeConVar( "volume" );
float sysVolume = ( volumeConVar.IsValid() ) ? volumeConVar.GetFloat() : 1.0f;
clamp( sysVolume, 0.0f, 1.0f );
if ( pCurrentVolume != nullptr )
{
*pCurrentVolume = sysVolume;
}
short movieVolume = (short) ( sysVolume * 256.0f );
SetMovieVolume( inMovie, movieVolume );
}
return true;
}
Reference in New Issue Copy Permalink