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.
962 lines
27 KiB
962 lines
27 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 "vtf/vtf.h" |
|
#include "pixelwriter.h" |
|
#include "tier3/tier3.h" |
|
#include "platform.h" |
|
|
|
|
|
#include "quicktime_material.h" |
|
|
|
#if defined ( WIN32 ) |
|
#include <WinDef.h> |
|
#include <../dx9sdk/include/dsound.h> |
|
#endif |
|
|
|
#include "tier0/memdbgon.h" |
|
|
|
|
|
// =========================================================================== |
|
// CQuicktimeMaterialRGBTextureRegenerator - Inherited from ITextureRegenerator |
|
// Copies and converts the buffer bits to texture bits |
|
// Currently only supports 32-bit BGRA |
|
// =========================================================================== |
|
CQuicktimeMaterialRGBTextureRegenerator::CQuicktimeMaterialRGBTextureRegenerator() : |
|
m_SrcGWorld( nullptr ), |
|
m_nSourceWidth( 0 ), |
|
m_nSourceHeight( 0 ) |
|
{ |
|
} |
|
|
|
|
|
CQuicktimeMaterialRGBTextureRegenerator::~CQuicktimeMaterialRGBTextureRegenerator() |
|
{ |
|
// nothing to do |
|
} |
|
|
|
|
|
void CQuicktimeMaterialRGBTextureRegenerator::SetSourceGWorld( GWorldPtr theGWorld, int nWidth, int nHeight ) |
|
{ |
|
m_SrcGWorld = theGWorld; |
|
m_nSourceWidth = nWidth; |
|
m_nSourceHeight = nHeight; |
|
} |
|
|
|
|
|
void CQuicktimeMaterialRGBTextureRegenerator::RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pRect ) |
|
{ |
|
AssertExit( pVTFTexture != nullptr ); |
|
|
|
// Error condition, should only have 1 frame, 1 face, 1 mip level |
|
if ( ( pVTFTexture->FrameCount() > 1 ) || ( pVTFTexture->FaceCount() > 1 ) || ( pVTFTexture->MipCount() > 1 ) || ( pVTFTexture->Depth() > 1 ) ) |
|
{ |
|
WarningAssert( "Texture Properties Incorrect "); |
|
memset( pVTFTexture->ImageData(), 0xAA, pVTFTexture->ComputeTotalSize() ); |
|
return; |
|
} |
|
|
|
// Make sure we have a valid video image source |
|
if ( m_SrcGWorld == nullptr ) |
|
{ |
|
WarningAssert( "Video texture source not set" ); |
|
memset( pVTFTexture->ImageData(), 0xCC, pVTFTexture->ComputeTotalSize() ); |
|
return; |
|
} |
|
|
|
// Verify the destination texture is set up correctly |
|
Assert( pVTFTexture->Format() == IMAGE_FORMAT_BGRA8888 ); |
|
Assert( pVTFTexture->RowSizeInBytes( 0 ) >= pVTFTexture->Width() * 4 ); |
|
Assert( pVTFTexture->Width() >= m_nSourceWidth ); |
|
Assert( pVTFTexture->Height() >= m_nSourceHeight ); |
|
|
|
// Copy directly from the Quicktime GWorld |
|
PixMapHandle thePixMap = GetGWorldPixMap( m_SrcGWorld ); |
|
|
|
if ( LockPixels( thePixMap ) ) |
|
{ |
|
BYTE *pImageData = pVTFTexture->ImageData(); |
|
int dstStride = pVTFTexture->RowSizeInBytes( 0 ); |
|
BYTE *pSrcData = (BYTE*) GetPixBaseAddr( thePixMap ); |
|
long srcStride = QTGetPixMapHandleRowBytes( thePixMap ); |
|
int rowSize = m_nSourceWidth * 4; |
|
|
|
for (int y = 0; y < m_nSourceHeight; y++ ) |
|
{ |
|
memcpy( pImageData, pSrcData, rowSize ); |
|
pImageData+= dstStride; |
|
pSrcData+= srcStride; |
|
} |
|
|
|
UnlockPixels( thePixMap ); |
|
} |
|
else |
|
{ |
|
WarningAssert( "LockPixels Failed" ); |
|
} |
|
} |
|
|
|
|
|
void CQuicktimeMaterialRGBTextureRegenerator::Release() |
|
{ |
|
// we don't invoke the destructor here, we're not using the no-release extensions |
|
} |
|
|
|
|
|
|
|
// =========================================================================== |
|
// CQuickTimeMaterial class - creates a material, opens a QuickTime movie |
|
// and plays the movie onto the material |
|
// =========================================================================== |
|
|
|
//----------------------------------------------------------------------------- |
|
// CQuickTimeMaterial Constructor |
|
//----------------------------------------------------------------------------- |
|
CQuickTimeMaterial::CQuickTimeMaterial() : |
|
m_pFileName( nullptr ), |
|
m_MovieGWorld( nullptr ), |
|
m_QTMovie( nullptr ), |
|
m_AudioContext( nullptr ), |
|
m_bInitCalled( false ) |
|
{ |
|
Reset(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// CQuickTimeMaterial Destructor |
|
//----------------------------------------------------------------------------- |
|
CQuickTimeMaterial::~CQuickTimeMaterial() |
|
{ |
|
Reset(); |
|
} |
|
|
|
|
|
void CQuickTimeMaterial::Reset() |
|
{ |
|
SetQTFileName( nullptr ); |
|
|
|
DestroyProceduralTexture(); |
|
DestroyProceduralMaterial(); |
|
|
|
m_TexCordU = 0.0f; |
|
m_TexCordV = 0.0f; |
|
|
|
m_VideoFrameWidth = 0; |
|
m_VideoFrameHeight = 0; |
|
|
|
m_PlaybackFlags = VideoPlaybackFlags::NO_PLAYBACK_OPTIONS; |
|
|
|
m_bMovieInitialized = false; |
|
m_bMoviePlaying = false; |
|
m_bMovieFinishedPlaying = false; |
|
m_bMoviePaused = false; |
|
m_bLoopMovie = false; |
|
|
|
m_bHasAudio = false; |
|
m_bMuted = false; |
|
|
|
m_CurrentVolume = 0.0f; |
|
|
|
m_QTMovieTimeScale = 0; |
|
m_QTMovieDuration = 0; |
|
m_QTMovieDurationinSec = 0.0f; |
|
m_QTMovieFrameRate.SetFPS( 0, false ); |
|
|
|
SAFE_RELEASE_AUDIOCONTEXT( m_AudioContext ); |
|
SAFE_DISPOSE_GWORLD( m_MovieGWorld ); |
|
SAFE_DISPOSE_MOVIE( m_QTMovie ); |
|
|
|
m_LastResult = VideoResult::SUCCESS; |
|
} |
|
|
|
|
|
void CQuickTimeMaterial::SetQTFileName( const char *theQTMovieFileName ) |
|
{ |
|
SAFE_DELETE_ARRAY( m_pFileName ); |
|
|
|
if ( theQTMovieFileName != nullptr ) |
|
{ |
|
AssertMsg( V_strlen( theQTMovieFileName ) <= MAX_QT_FILENAME_LEN, "Bad Quicktime Movie Filename" ); |
|
m_pFileName = COPY_STRING( theQTMovieFileName ); |
|
} |
|
|
|
} |
|
|
|
|
|
VideoResult_t CQuickTimeMaterial::SetResult( VideoResult_t status ) |
|
{ |
|
m_LastResult = status; |
|
return status; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Video information functions |
|
//----------------------------------------------------------------------------- |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns the resolved filename of the video, as it might differ from |
|
// what the user supplied, (also with absolute path) |
|
//----------------------------------------------------------------------------- |
|
const char *CQuickTimeMaterial::GetVideoFileName() |
|
{ |
|
return m_pFileName; |
|
} |
|
|
|
|
|
VideoFrameRate_t &CQuickTimeMaterial::GetVideoFrameRate() |
|
{ |
|
return m_QTMovieFrameRate; |
|
} |
|
|
|
|
|
VideoResult_t CQuickTimeMaterial::GetLastResult() |
|
{ |
|
return m_LastResult; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Audio Functions |
|
//----------------------------------------------------------------------------- |
|
bool CQuickTimeMaterial::HasAudio() |
|
{ |
|
return m_bHasAudio; |
|
} |
|
|
|
|
|
bool CQuickTimeMaterial::SetVolume( float fVolume ) |
|
{ |
|
clamp( fVolume, 0.0f, 1.0f ); |
|
|
|
m_CurrentVolume = fVolume; |
|
|
|
if ( m_AudioContext != nullptr && m_bHasAudio ) |
|
{ |
|
short movieVolume = (short) ( m_CurrentVolume * 256.0f ); |
|
|
|
SetMovieVolume( m_QTMovie, movieVolume ); |
|
|
|
SetResult( VideoResult::SUCCESS ); |
|
return true; |
|
} |
|
|
|
SetResult( VideoResult::AUDIO_ERROR_OCCURED ); |
|
return false; |
|
} |
|
|
|
|
|
float CQuickTimeMaterial::GetVolume() |
|
{ |
|
return m_CurrentVolume; |
|
} |
|
|
|
|
|
void CQuickTimeMaterial::SetMuted( bool bMuteState ) |
|
{ |
|
AssertExitFunc( m_bMoviePlaying, SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE) ); |
|
|
|
SetResult( VideoResult::SUCCESS ); |
|
|
|
if ( bMuteState == m_bMuted ) // no change? |
|
{ |
|
return; |
|
} |
|
|
|
m_bMuted = bMuteState; |
|
|
|
if ( m_bHasAudio ) |
|
{ |
|
OSStatus result = SetMovieAudioMute( m_QTMovie, m_bMuted, 0 ); |
|
AssertExitFunc( result == noErr, SetResult( VideoResult::AUDIO_ERROR_OCCURED) ); |
|
} |
|
|
|
SetResult( VideoResult::SUCCESS ); |
|
} |
|
|
|
|
|
bool CQuickTimeMaterial::IsMuted() |
|
{ |
|
return m_bMuted; |
|
} |
|
|
|
|
|
VideoResult_t CQuickTimeMaterial::SoundDeviceCommand( VideoSoundDeviceOperation_t operation, void *pDevice, void *pData ) |
|
{ |
|
AssertExitV( m_bMovieInitialized || m_bMoviePlaying, VideoResult::OPERATION_OUT_OF_SEQUENCE ); |
|
|
|
switch( operation ) |
|
{ |
|
// On win32, we try and create an audio context from a GUID |
|
case VideoSoundDeviceOperation::SET_DIRECT_SOUND_DEVICE: |
|
{ |
|
#if defined ( WIN32 ) |
|
SAFE_RELEASE_AUDIOCONTEXT( m_AudioContext ); |
|
return ( CreateMovieAudioContext( m_bHasAudio, m_QTMovie, &m_AudioContext ) ? SetResult( VideoResult::SUCCESS ) : SetResult( VideoResult::AUDIO_ERROR_OCCURED ) ); |
|
#else |
|
// On any other OS, we don't support this operation |
|
return SetResult( VideoResult::OPERATION_NOT_SUPPORTED ); |
|
#endif |
|
} |
|
case VideoSoundDeviceOperation::SET_SOUND_MANAGER_DEVICE: |
|
{ |
|
#if defined ( OSX ) |
|
SAFE_RELEASE_AUDIOCONTEXT( m_AudioContext ); |
|
return ( CreateMovieAudioContext( m_bHasAudio, m_QTMovie, &m_AudioContext ) ? SetResult( VideoResult::SUCCESS ) : SetResult( VideoResult::AUDIO_ERROR_OCCURED ) ); |
|
#else |
|
// On any other OS, we don't support this operation |
|
return SetResult( VideoResult::OPERATION_NOT_SUPPORTED ); |
|
#endif |
|
} |
|
|
|
case VideoSoundDeviceOperation::SET_LIB_AUDIO_DEVICE: |
|
case VideoSoundDeviceOperation::HOOK_X_AUDIO: |
|
case VideoSoundDeviceOperation::SET_MILES_SOUND_DEVICE: |
|
{ |
|
return SetResult( VideoResult::OPERATION_NOT_SUPPORTED ); |
|
} |
|
default: |
|
{ |
|
return SetResult( VideoResult::BAD_INPUT_PARAMETERS ); |
|
} |
|
} |
|
|
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Initializes the video material |
|
//----------------------------------------------------------------------------- |
|
bool CQuickTimeMaterial::Init( const char *pMaterialName, const char *pFileName, VideoPlaybackFlags_t flags ) |
|
{ |
|
SetResult( VideoResult::BAD_INPUT_PARAMETERS ); |
|
AssertExitF( IS_NOT_EMPTY( pFileName ) ); |
|
AssertExitF( m_bInitCalled == false ); |
|
|
|
m_PlaybackFlags = flags; |
|
|
|
OpenQTMovie( pFileName ); // Open up the Quicktime file |
|
|
|
if ( !m_bMovieInitialized ) |
|
{ |
|
return false; // Something bad happened when we went to open |
|
} |
|
|
|
// Now we can properly setup our regenerators |
|
m_TextureRegen.SetSourceGWorld( m_MovieGWorld, m_VideoFrameWidth, m_VideoFrameHeight ); |
|
|
|
CreateProceduralTexture( pMaterialName ); |
|
CreateProceduralMaterial( pMaterialName ); |
|
|
|
// Start movie playback |
|
if ( !BITFLAGS_SET( m_PlaybackFlags, VideoPlaybackFlags::DONT_AUTO_START_VIDEO ) ) |
|
{ |
|
StartVideo(); |
|
} |
|
|
|
m_bInitCalled = true; // Look, if you only got one shot... |
|
|
|
return true; |
|
} |
|
|
|
|
|
void CQuickTimeMaterial::Shutdown( void ) |
|
{ |
|
StopVideo(); |
|
Reset(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Video playback state functions |
|
//----------------------------------------------------------------------------- |
|
bool CQuickTimeMaterial::IsVideoReadyToPlay() |
|
{ |
|
return m_bMovieInitialized; |
|
} |
|
|
|
|
|
bool CQuickTimeMaterial::IsVideoPlaying() |
|
{ |
|
return m_bMoviePlaying; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Checks to see if the video has a new frame ready to be rendered and |
|
// downloaded into the texture and eventually display |
|
//----------------------------------------------------------------------------- |
|
bool CQuickTimeMaterial::IsNewFrameReady( void ) |
|
{ |
|
// Are we waiting to start playing the first frame? if so, tell them we are ready! |
|
if ( m_bMovieInitialized == true ) |
|
{ |
|
return true; |
|
} |
|
|
|
// We better be playing the movie |
|
AssertExitF( m_bMoviePlaying ); |
|
|
|
// paused? |
|
if ( m_bMoviePaused ) |
|
{ |
|
return false; |
|
} |
|
|
|
TimeValue curMovieTime = GetMovieTime( m_QTMovie, nullptr ); |
|
|
|
if ( curMovieTime >= m_QTMovieDuration || m_NextInterestingTimeToPlay == NO_MORE_INTERESTING_TIMES ) |
|
{ |
|
// if we are looping, we have another frame, otherwise no |
|
return m_bLoopMovie; |
|
} |
|
|
|
// Enough time passed to get to next frame?? |
|
if ( curMovieTime < m_NextInterestingTimeToPlay ) |
|
{ |
|
// nope.. use the previous frame |
|
return false; |
|
} |
|
|
|
// we have a new frame we want then.. |
|
return true; |
|
} |
|
|
|
|
|
bool CQuickTimeMaterial::IsFinishedPlaying() |
|
{ |
|
return m_bMovieFinishedPlaying; |
|
} |
|
|
|
|
|
void CQuickTimeMaterial::SetLooping( bool bLoopVideo ) |
|
{ |
|
m_bLoopMovie = bLoopVideo; |
|
} |
|
|
|
|
|
bool CQuickTimeMaterial::IsLooping() |
|
{ |
|
return m_bLoopMovie; |
|
} |
|
|
|
|
|
void CQuickTimeMaterial::SetPaused( bool bPauseState ) |
|
{ |
|
if ( !m_bMoviePlaying || m_bMoviePaused == bPauseState ) |
|
{ |
|
Assert( m_bMoviePlaying ); |
|
return; |
|
} |
|
|
|
if ( bPauseState ) // Pausing the movie? |
|
{ |
|
// Save off current time and set paused state |
|
m_MoviePauseTime = GetMovieTime( m_QTMovie, nullptr ); |
|
StopMovie( m_QTMovie ); |
|
} |
|
else // unpausing the movie |
|
{ |
|
// Reset the movie to the paused time |
|
SetMovieTimeValue( m_QTMovie, m_MoviePauseTime ); |
|
StartMovie( m_QTMovie ); |
|
Assert( GetMoviesError() == noErr ); |
|
} |
|
|
|
m_bMoviePaused = bPauseState; |
|
} |
|
|
|
|
|
bool CQuickTimeMaterial::IsPaused() |
|
{ |
|
return ( m_bMoviePlaying ) ? m_bMoviePaused : false; |
|
} |
|
|
|
|
|
// Begins playback of the movie |
|
bool CQuickTimeMaterial::StartVideo() |
|
{ |
|
if ( !m_bMovieInitialized ) |
|
{ |
|
Assert( false ); |
|
SetResult( VideoResult::OPERATION_ALREADY_PERFORMED ); |
|
return false; |
|
} |
|
|
|
// Start the movie playing at the first frame |
|
SetMovieTimeValue( m_QTMovie, m_MovieFirstFrameTime ); |
|
Assert( GetMoviesError() == noErr ); |
|
|
|
StartMovie( m_QTMovie ); |
|
Assert( GetMoviesError() == noErr ); |
|
|
|
// Transition to playing state |
|
m_bMovieInitialized = false; |
|
m_bMoviePlaying = true; |
|
|
|
// Deliberately set the next interesting time to the current time to |
|
// insure that the ::update() call causes the textures to be downloaded |
|
m_NextInterestingTimeToPlay = m_MovieFirstFrameTime; |
|
Update(); |
|
|
|
return true; |
|
} |
|
|
|
|
|
// stops movie for good, frees resources, but retains texture & material of last frame rendered |
|
bool CQuickTimeMaterial::StopVideo() |
|
{ |
|
if ( !m_bMoviePlaying ) |
|
{ |
|
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE ); |
|
return false; |
|
} |
|
|
|
StopMovie( m_QTMovie ); |
|
|
|
m_bMoviePlaying = false; |
|
m_bMoviePaused = false; |
|
m_bMovieFinishedPlaying = true; |
|
|
|
// free resources |
|
CloseQTFile(); |
|
|
|
SetResult( VideoResult::SUCCESS ); |
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Updates our scene |
|
// Output : true = movie playing ok, false = time to end movie |
|
// supposed to be: Returns true on a new frame of video being downloaded into the texture |
|
//----------------------------------------------------------------------------- |
|
bool CQuickTimeMaterial::Update( void ) |
|
{ |
|
AssertExitF( m_bMoviePlaying ); |
|
|
|
OSType qTypes[1] = { VisualMediaCharacteristic }; |
|
|
|
// are we paused? can't update if so... |
|
if ( m_bMoviePaused ) |
|
{ |
|
return true; // reuse the last frame |
|
} |
|
|
|
// Get current time in the movie |
|
TimeValue curMovieTime = GetMovieTime( m_QTMovie, nullptr ); |
|
|
|
// Did we hit the end of the movie? |
|
if ( curMovieTime >= m_QTMovieDuration ) |
|
{ |
|
// If we're not looping, then report that we are done updating |
|
if ( m_bLoopMovie == false ) |
|
{ |
|
StopVideo(); |
|
return false; |
|
} |
|
|
|
// Reset the movie to the start time |
|
SetMovieTimeValue( m_QTMovie, m_MovieFirstFrameTime ); |
|
AssertExitF( GetMoviesError() == noErr ); |
|
|
|
// Assure fall through to render a new frame |
|
m_NextInterestingTimeToPlay = m_MovieFirstFrameTime; |
|
} |
|
|
|
// Are we on the last frame of the movie? (but not past the end of any audio?) |
|
if ( m_NextInterestingTimeToPlay == NO_MORE_INTERESTING_TIMES ) |
|
{ |
|
return true; // reuse last frame |
|
} |
|
|
|
// Enough time passed to get to next frame? |
|
if ( curMovieTime < m_NextInterestingTimeToPlay ) |
|
{ |
|
// nope.. use the previous frame |
|
return true; |
|
} |
|
|
|
// move the movie along |
|
UpdateMovie( m_QTMovie ); |
|
AssertExitF( GetMoviesError() == noErr ); |
|
|
|
// Let QuickTime render the frame |
|
MoviesTask( m_QTMovie, 0L ); |
|
AssertExitF( GetMoviesError() == noErr ); |
|
|
|
// Get the next frame after the current time (the movie may have advanced a bit during UpdateMovie() and MovieTasks() |
|
GetMovieNextInterestingTime( m_QTMovie, nextTimeStep | nextTimeEdgeOK, 1, qTypes, GetMovieTime( m_QTMovie, nullptr ), fixed1, &m_NextInterestingTimeToPlay, nullptr ); |
|
|
|
// hit the end of the movie? |
|
if ( GetMoviesError() == invalidTime || m_NextInterestingTimeToPlay == END_OF_QUICKTIME_MOVIE ) |
|
{ |
|
m_NextInterestingTimeToPlay = NO_MORE_INTERESTING_TIMES; |
|
} |
|
|
|
// Regenerate our texture, it'll grab from the GWorld Directly |
|
m_Texture->Download(); |
|
|
|
SetResult( VideoResult::SUCCESS ); |
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns the material |
|
//----------------------------------------------------------------------------- |
|
IMaterial *CQuickTimeMaterial::GetMaterial() |
|
{ |
|
return m_Material; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns the texcoord range |
|
//----------------------------------------------------------------------------- |
|
void CQuickTimeMaterial::GetVideoTexCoordRange( float *pMaxU, float *pMaxV ) |
|
{ |
|
AssertExit( pMaxU != nullptr && pMaxV != nullptr ); |
|
|
|
if ( m_Texture == nullptr ) // no texture? |
|
{ |
|
*pMaxU = *pMaxV = 1.0f; |
|
return; |
|
} |
|
|
|
*pMaxU = m_TexCordU; |
|
*pMaxV = m_TexCordV; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns the frame size of the QuickTime Video in pixels |
|
//----------------------------------------------------------------------------- |
|
void CQuickTimeMaterial::GetVideoImageSize( int *pWidth, int *pHeight ) |
|
{ |
|
Assert( pWidth != nullptr && pHeight != nullptr ); |
|
|
|
*pWidth = m_VideoFrameWidth; |
|
*pHeight = m_VideoFrameHeight; |
|
} |
|
|
|
|
|
float CQuickTimeMaterial::GetVideoDuration() |
|
{ |
|
return m_QTMovieDurationinSec; |
|
} |
|
|
|
|
|
int CQuickTimeMaterial::GetFrameCount() |
|
{ |
|
return m_QTMovieFrameCount; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Sets the frame for an QuickTime Material (use instead of SetTime) |
|
//----------------------------------------------------------------------------- |
|
bool CQuickTimeMaterial::SetFrame( int FrameNum ) |
|
{ |
|
if ( !m_bMoviePlaying ) |
|
{ |
|
Assert( false ); |
|
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE ); |
|
return false; |
|
} |
|
|
|
float theTime = (float) FrameNum * m_QTMovieFrameRate.GetFPS(); |
|
return SetTime( theTime ); |
|
} |
|
|
|
|
|
int CQuickTimeMaterial::GetCurrentFrame() |
|
{ |
|
AssertExitV( m_bMoviePlaying, -1 ); |
|
|
|
TimeValue curTime = m_bMoviePaused ? m_MoviePauseTime : GetMovieTime( m_QTMovie, nullptr ); |
|
|
|
return curTime / m_QTMovieFrameRate.GetUnitsPerFrame(); |
|
} |
|
|
|
|
|
float CQuickTimeMaterial::GetCurrentVideoTime() |
|
{ |
|
AssertExitV( m_bMoviePlaying, -1.0f ); |
|
|
|
TimeValue curTime = m_bMoviePaused ? m_MoviePauseTime : GetMovieTime( m_QTMovie, nullptr ); |
|
|
|
return curTime / m_QTMovieFrameRate.GetUnitsPerSecond(); |
|
} |
|
|
|
|
|
bool CQuickTimeMaterial::SetTime( float flTime ) |
|
{ |
|
AssertExitF( m_bMoviePlaying ); |
|
AssertExitF( flTime >= 0 && flTime < m_QTMovieDurationinSec ); |
|
|
|
TimeValue newTime = (TimeValue) ( flTime * m_QTMovieFrameRate.GetUnitsPerSecond() + 0.5f) ; |
|
|
|
clamp( newTime, m_MovieFirstFrameTime, m_QTMovieDuration ); |
|
|
|
// Are we paused? |
|
if ( m_bMoviePaused ) |
|
{ |
|
m_MoviePauseTime = newTime; |
|
return true; |
|
} |
|
|
|
TimeValue curMovieTime = GetMovieTime( m_QTMovie, nullptr ); |
|
|
|
// Don't stop and reset movie if we are within 1 frame of the requested time |
|
if ( newTime <= curMovieTime - m_QTMovieFrameRate.GetUnitsPerFrame() || newTime >= curMovieTime + m_QTMovieFrameRate.GetUnitsPerFrame() ) |
|
{ |
|
// Reset the movie to the requested time |
|
StopMovie( m_QTMovie ); |
|
SetMovieTimeValue( m_QTMovie, newTime ); |
|
StartMovie( m_QTMovie ); |
|
|
|
Assert( GetMoviesError() == noErr ); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Initializes, shuts down the procedural texture |
|
//----------------------------------------------------------------------------- |
|
void CQuickTimeMaterial::CreateProceduralTexture( const char *pTextureName ) |
|
{ |
|
AssertIncRange( m_VideoFrameWidth, cMinVideoFrameWidth, cMaxVideoFrameWidth ); |
|
AssertIncRange( m_VideoFrameHeight, cMinVideoFrameHeight, cMaxVideoFrameHeight ); |
|
AssertStr( pTextureName ); |
|
|
|
// Either make the texture the same dimensions as the video, |
|
// or choose power-of-two textures which are at least as big as the video |
|
bool actualSizeTexture = BITFLAGS_SET( m_PlaybackFlags, VideoPlaybackFlags::TEXTURES_ACTUAL_SIZE ); |
|
|
|
int nWidth = ( actualSizeTexture ) ? ALIGN_VALUE( m_VideoFrameWidth, TEXTURE_SIZE_ALIGNMENT ) : ComputeGreaterPowerOfTwo( m_VideoFrameWidth ); |
|
int nHeight = ( actualSizeTexture ) ? ALIGN_VALUE( m_VideoFrameHeight, TEXTURE_SIZE_ALIGNMENT ) : ComputeGreaterPowerOfTwo( m_VideoFrameHeight ); |
|
|
|
// initialize the procedural texture as 32-it RGBA, w/o mipmaps |
|
m_Texture.InitProceduralTexture( pTextureName, "VideoCacheTextures", nWidth, nHeight, |
|
IMAGE_FORMAT_BGRA8888, TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_NOMIP | |
|
TEXTUREFLAGS_PROCEDURAL | TEXTUREFLAGS_SINGLECOPY | TEXTUREFLAGS_NOLOD ); |
|
|
|
// Use this to get the updated frame from the remote connection |
|
m_Texture->SetTextureRegenerator( &m_TextureRegen /* , false */ ); |
|
|
|
// compute the texcoords |
|
int nTextureWidth = m_Texture->GetActualWidth(); |
|
int nTextureHeight = m_Texture->GetActualHeight(); |
|
|
|
m_TexCordU = ( nTextureWidth > 0 ) ? (float) m_VideoFrameWidth / (float) nTextureWidth : 0.0f; |
|
m_TexCordV = ( nTextureHeight > 0 ) ? (float) m_VideoFrameHeight / (float) nTextureHeight : 0.0f; |
|
} |
|
|
|
|
|
void CQuickTimeMaterial::DestroyProceduralTexture() |
|
{ |
|
if ( m_Texture != nullptr ) |
|
{ |
|
// DO NOT Call release on the Texture Regenerator, as it will destroy this object! bad bad bad |
|
// instead we tell it to assign a NULL regenerator and flag it to not call release |
|
m_Texture->SetTextureRegenerator( nullptr /*, false */ ); |
|
// Texture, texture go away... |
|
m_Texture.Shutdown( true ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Initializes, shuts down the procedural material |
|
//----------------------------------------------------------------------------- |
|
void CQuickTimeMaterial::CreateProceduralMaterial( const char *pMaterialName ) |
|
{ |
|
// create keyvalues if necessary |
|
KeyValues *pVMTKeyValues = new KeyValues( "UnlitGeneric" ); |
|
{ |
|
pVMTKeyValues->SetString( "$basetexture", m_Texture->GetName() ); |
|
pVMTKeyValues->SetInt( "$nobasetexture", 1 ); |
|
pVMTKeyValues->SetInt( "$nofog", 1 ); |
|
pVMTKeyValues->SetInt( "$spriteorientation", 3 ); |
|
pVMTKeyValues->SetInt( "$translucent", 1 ); |
|
pVMTKeyValues->SetInt( "$nolod", 1 ); |
|
pVMTKeyValues->SetInt( "$nomip", 1 ); |
|
pVMTKeyValues->SetInt( "$gammacolorread", 0 ); |
|
} |
|
|
|
// FIXME: gak, this is backwards. Why doesn't the material just see that it has a funky basetexture? |
|
m_Material.Init( pMaterialName, pVMTKeyValues ); |
|
m_Material->Refresh(); |
|
} |
|
|
|
|
|
void CQuickTimeMaterial::DestroyProceduralMaterial() |
|
{ |
|
// Store the internal material pointer for later use |
|
IMaterial *pMaterial = m_Material; |
|
m_Material.Shutdown(); |
|
materials->UncacheUnusedMaterials(); |
|
|
|
// Now be sure to free that material because we don't want to reference it again later, we'll recreate it! |
|
if ( pMaterial != nullptr ) |
|
{ |
|
pMaterial->DeleteIfUnreferenced(); |
|
} |
|
} |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Opens a movie file using quicktime |
|
//----------------------------------------------------------------------------- |
|
void CQuickTimeMaterial::OpenQTMovie( const char *theQTMovieFileName ) |
|
{ |
|
AssertExit( IS_NOT_EMPTY( theQTMovieFileName ) ); |
|
|
|
// Set graphics port |
|
#if defined ( WIN32 ) |
|
SetGWorld ( (CGrafPtr) GetNativeWindowPort( nil ), nil ); |
|
#elif defined ( OSX ) |
|
SetGWorld( nil, nil ); |
|
#endif |
|
|
|
SetQTFileName( theQTMovieFileName ); |
|
|
|
Handle MovieFileDataRef = nullptr; |
|
OSType MovieFileDataRefType = 0; |
|
|
|
CFStringRef imageStrRef = CFStringCreateWithCString ( NULL, theQTMovieFileName, 0 ); |
|
AssertExitFunc( imageStrRef != nullptr, SetResult( VideoResult::SYSTEM_ERROR_OCCURED ) ); |
|
|
|
OSErr status = QTNewDataReferenceFromFullPathCFString( imageStrRef, (QTPathStyle) kQTNativeDefaultPathStyle, 0, &MovieFileDataRef, &MovieFileDataRefType ); |
|
AssertExitFunc( status == noErr, SetResult( VideoResult::FILE_ERROR_OCCURED ) ); |
|
|
|
CFRelease( imageStrRef ); |
|
|
|
status = NewMovieFromDataRef( &m_QTMovie, newMovieActive, nil, MovieFileDataRef, MovieFileDataRefType ); |
|
SAFE_DISPOSE_HANDLE( MovieFileDataRef ); |
|
|
|
if ( status != noErr ) |
|
{ |
|
Assert( false ); |
|
Reset(); |
|
SetResult( VideoResult::VIDEO_ERROR_OCCURED ); |
|
return; |
|
} |
|
|
|
// disabling audio? |
|
if ( BITFLAGS_SET( m_PlaybackFlags, VideoPlaybackFlags::NO_AUDIO ) ) |
|
{ |
|
m_bHasAudio = false; |
|
} |
|
else |
|
{ |
|
// does movie have audio? |
|
Track audioTrack = GetMovieIndTrackType( m_QTMovie, 1, SoundMediaType, movieTrackMediaType ); |
|
m_bHasAudio = ( audioTrack != nullptr ); |
|
} |
|
|
|
// Now we need to extract the time info from the QT Movie |
|
m_QTMovieTimeScale = GetMovieTimeScale( m_QTMovie ); |
|
m_QTMovieDuration = GetMovieDuration( m_QTMovie ); |
|
|
|
// compute movie duration |
|
m_QTMovieDurationinSec = float ( double( m_QTMovieDuration ) / double( m_QTMovieTimeScale ) ); |
|
if ( !MovieGetStaticFrameRate( m_QTMovie, m_QTMovieFrameRate ) ) |
|
{ |
|
WarningAssert( "Couldn't Get Frame Rate" ); |
|
} |
|
|
|
// and get an estimated frame count |
|
m_QTMovieFrameCount = m_QTMovieDuration / m_QTMovieTimeScale; |
|
|
|
if ( m_QTMovieFrameRate.GetUnitsPerSecond() == m_QTMovieTimeScale ) |
|
{ |
|
m_QTMovieFrameCount = m_QTMovieDuration / m_QTMovieFrameRate.GetUnitsPerFrame(); |
|
} |
|
else |
|
{ |
|
m_QTMovieFrameCount = (int) ( (float) m_QTMovieDurationinSec * m_QTMovieFrameRate.GetFPS() + 0.5f ); |
|
} |
|
|
|
// what size do we set the output rect to? |
|
GetMovieNaturalBoundsRect(m_QTMovie, &m_QTMovieRect); |
|
|
|
m_VideoFrameWidth = m_QTMovieRect.right; |
|
m_VideoFrameHeight = m_QTMovieRect.bottom; |
|
|
|
// Sanity check... |
|
AssertExitFunc( m_QTMovieRect.top == 0 && m_QTMovieRect.left == 0 && |
|
m_QTMovieRect.right >= cMinVideoFrameWidth && m_QTMovieRect.right <= cMaxVideoFrameWidth && |
|
m_QTMovieRect.bottom >= cMinVideoFrameHeight && m_QTMovieRect.bottom <= cMaxVideoFrameHeight && |
|
m_QTMovieRect.right % 4 == 0, |
|
SetResult( VideoResult::VIDEO_ERROR_OCCURED ) ); |
|
|
|
// Setup the QuiuckTime Graphics World for the Movie |
|
status = QTNewGWorld( &m_MovieGWorld, k32BGRAPixelFormat, &m_QTMovieRect, nil, nil, 0 ); |
|
AssertExit( status == noErr ); |
|
|
|
// Setup the playback gamma according to the convar |
|
SetGWorldDecodeGamma( m_MovieGWorld, VideoPlaybackGamma::USE_GAMMA_CONVAR ); |
|
|
|
// Assign the GWorld to this movie |
|
SetMovieGWorld( m_QTMovie, m_MovieGWorld, nil ); |
|
|
|
// Setup Movie Audio, unless suppressed |
|
if ( !CreateMovieAudioContext( m_bHasAudio, m_QTMovie, &m_AudioContext, true, &m_CurrentVolume ) ) |
|
{ |
|
SetResult( VideoResult::AUDIO_ERROR_OCCURED ); |
|
WarningAssert( "Couldn't Set Audio" ); |
|
} |
|
|
|
// Get the time of the first frame |
|
OSType qTypes[1] = { VisualMediaCharacteristic }; |
|
short qFlags = nextTimeStep | nextTimeEdgeOK; // use nextTimeStep instead of nextTimeMediaSample for MPEG 1-2 compatibility |
|
|
|
GetMovieNextInterestingTime( m_QTMovie, qFlags, 1, qTypes, (TimeValue) 0, fixed1, &m_MovieFirstFrameTime, NULL ); |
|
AssertExitFunc( GetMoviesError() == noErr, SetResult( VideoResult::VIDEO_ERROR_OCCURED ) ); |
|
|
|
// Preroll the movie |
|
if ( BITFLAGS_SET( m_PlaybackFlags, VideoPlaybackFlags::PRELOAD_VIDEO ) ) |
|
{ |
|
Fixed playRate = GetMoviePreferredRate( m_QTMovie ); |
|
status = PrerollMovie( m_QTMovie, m_MovieFirstFrameTime, playRate ); |
|
AssertExitFunc( status == noErr, SetResult( VideoResult::VIDEO_ERROR_OCCURED ) ); |
|
} |
|
|
|
m_bMovieInitialized = true; |
|
} |
|
|
|
|
|
void CQuickTimeMaterial::CloseQTFile() |
|
{ |
|
if ( m_QTMovie == nullptr ) |
|
{ |
|
return; |
|
} |
|
|
|
SAFE_RELEASE_AUDIOCONTEXT( m_AudioContext ); |
|
SAFE_DISPOSE_GWORLD( m_MovieGWorld ); |
|
SAFE_DISPOSE_MOVIE( m_QTMovie ); |
|
|
|
SetQTFileName( nullptr ); |
|
} |
|
|
|
|
|
|