Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

2146 lines
63 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
//----------------------------------------------------------------------------------------
#define WIN32_LEAN_AND_MEAN
#include "quicktime_recorder.h"
#include "filesystem.h"
#ifdef _WIN32
#include "windows.h"
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#define SAFE_DISPOSE_HANDLE( _handle ) if ( _handle != nullptr ) { DisposeHandle( (Handle) _handle ); _handle = nullptr; }
#define SAFE_DISPOSE_GWORLD( _gworld ) if ( _gworld != nullptr ) { DisposeGWorld( _gworld ); _gworld = nullptr; }
#define SAFE_DISPOSE_MOVIE( _movie ) if ( _movie != nullptr ) { DisposeMovie( _movie ); ThreadSleep(10); Assert( GetMoviesError() == noErr ); _movie = nullptr; }
// Platform check
#if defined ( OSX ) || defined ( WIN32 )
// platform is supported
#else
#error "Unsupported Platform for QuickTime"
#endif
//-----------------------------------------------------------------------------
// Helper functions for copying and converting bitmaps
//-----------------------------------------------------------------------------
enum PixelComponent_t
{
RED = 0,
GREEN,
BLUE,
ALPHA
};
int GetBytesPerPixel( OSType pixelFormat )
{
int bpp = ( pixelFormat == k24BGRPixelFormat || pixelFormat == k24RGBPixelFormat ) ? 3 :
( pixelFormat == k32BGRAPixelFormat || pixelFormat == k32RGBAPixelFormat ) ? 4 : 0;
Assert( bpp > 0 );
return bpp;
}
int GetPixelCompnentByteOffset( OSType format, PixelComponent_t component )
{
if ( component == RED )
{
return ( format == k24RGBPixelFormat || format == k32RGBAPixelFormat ) ? 0 :
( format == k24BGRPixelFormat || format == k32BGRAPixelFormat ) ? 2 : -1;
}
if ( component == GREEN )
{
return ( format == k24RGBPixelFormat || format == k32RGBAPixelFormat ) ? 1 :
( format == k24BGRPixelFormat || format == k32BGRAPixelFormat ) ? 1 : -1;
}
if ( component == BLUE )
{
return ( format == k24RGBPixelFormat || format == k32RGBAPixelFormat ) ? 2 :
( format == k24BGRPixelFormat || format == k32BGRAPixelFormat ) ? 0 : -1;
}
if ( component == ALPHA )
{
return ( format == k32BGRAPixelFormat || format == k32RGBAPixelFormat ) ? 3 : -1;
}
Assert( false );
return -1;
}
bool CopyBitMapPixels( int width, int height, OSType srcFmt, byte *srcBase, int srcStride, OSType dstFmt, byte *dstBase, int dstStride )
{
AssertExitF( width > 0 && height > 0 && srcBase != nullptr && srcStride > 0 && dstBase != nullptr && dstStride > 0 );
// copy the bitmap pixels into our GWorld
if ( srcFmt == dstFmt ) // identical formats, memcopy each line
{
int srcLineSize = width * GetBytesPerPixel( srcFmt );
AssertExitF( srcLineSize <= dstStride && srcLineSize <= srcStride );
for ( int y = 0; y < height; y++ )
{
byte *src = srcBase + srcStride * y;
byte *dst = dstBase + dstStride * y;
memcpy( dst, src, srcLineSize );
}
return true;
}
// ok, we got some byte swizzling to do.. get the info we need
int srcBPP = GetBytesPerPixel( srcFmt );
int dstBPP = GetBytesPerPixel( dstFmt );
int rSrcIndex = GetPixelCompnentByteOffset( srcFmt, RED );
int gSrcIndex = GetPixelCompnentByteOffset( srcFmt, GREEN );
int bSrcIndex = GetPixelCompnentByteOffset( srcFmt, BLUE );
int aSrcIndex = GetPixelCompnentByteOffset( srcFmt, ALPHA );
int rDstIndex = GetPixelCompnentByteOffset( dstFmt, RED );
int gDstIndex = GetPixelCompnentByteOffset( dstFmt, GREEN );
int bDstIndex = GetPixelCompnentByteOffset( dstFmt, BLUE );
int aDstIndex = GetPixelCompnentByteOffset( dstFmt, ALPHA );
Assert( rSrcIndex >= 0 && gSrcIndex >= 0 && bSrcIndex >= 0 );
// 3 byte format to 3 byte format or a 4 byte format to a 3 byte format?
if ( dstBPP == 3 )
{
for ( int y = 0; y < height; y++ )
{
byte *src = srcBase + srcStride * y;
byte *dst = dstBase + dstStride * y;
for ( int x = 0; x < width; x++, dst+=dstBPP, src+=srcBPP )
{
dst[rDstIndex] = src[rSrcIndex];
dst[gDstIndex] = src[gSrcIndex];
dst[bDstIndex] = src[bSrcIndex];
}
}
return true;
}
AssertExitF( aDstIndex >= 0 );
// 3 byte format to 4 byte format?
if ( srcBPP == 3 && dstBPP == 4 )
{
for ( int y = 0; y < height; y++ )
{
byte *src = srcBase + srcStride * y;
byte *dst = dstBase + dstStride * y;
for ( int x = 0; x < width; x++, dst+=dstBPP, src+=srcBPP )
{
dst[rDstIndex] = src[rSrcIndex];
dst[gDstIndex] = src[gSrcIndex];
dst[bDstIndex] = src[bSrcIndex];
dst[aDstIndex] = 0xFF;
}
}
return true;
}
// 4 byte format to 4 byte format?
if ( srcBPP == 4 && dstBPP == 4 )
{
for ( int y = 0; y < height; y++ )
{
byte *src = srcBase + srcStride * y;
byte *dst = dstBase + dstStride * y;
for ( int x = 0; x < width; x++, dst+=dstBPP, src+=srcBPP )
{
dst[rDstIndex] = src[rSrcIndex];
dst[gDstIndex] = src[gSrcIndex];
dst[bDstIndex] = src[bSrcIndex];
dst[aDstIndex] = src[aSrcIndex];
}
}
return true;
}
// didn't find the format?
Assert( false );
return false;
}
//-----------------------------------------------------------------------------
// Utility functions to save targa images
//-----------------------------------------------------------------------------
#pragma pack( push, 1 )
struct TGA_Header
{
public:
byte identsize; // size of ID field that follows 18 byte header (0 usually)
byte colourmaptype; // type of colour map 0=none, 1=has palette
byte imagetype; // type of image 0=none,1=indexed,2=rgb,3=grey,+8=rle packed
short colourmapstart; // first colour map entry in palette
short colourmaplength; // number of colours in palette
byte colourmapbits; // number of bits per palette entry 15,16,24,32
short xstart; // image x origin
short ystart; // image y origin
short width; // image width in pixels
short height; // image height in pixels
byte bits; // image bits per pixel 8,16,24,32
byte descriptor; // image descriptor bits (vh flip bits)
// pixel data follows header
};
#pragma pack(pop)
void SaveToTargaFile( int frameNum, const char* pBaseFileName, int width, int height, void *pPixels, OSType PixelFormat, int strideAdjust )
{
if ( pBaseFileName == nullptr || pPixels== nullptr ) return;
Assert( sizeof( TGA_Header ) == 18 );
TGA_Header theHeader;
ZeroVar( theHeader );
int BytesPerPixel = GetBytesPerPixel( PixelFormat );
Assert( BytesPerPixel > 0 );
theHeader.imagetype = 2;
theHeader.width = (short) width;
theHeader.height = (short) height;
theHeader.colourmapbits = BytesPerPixel * 8;
theHeader.bits = BytesPerPixel * 8;
theHeader.descriptor = ( BytesPerPixel == 4) ? ( 8 | 32 ) : 32; // Targa32, Upper Left Origin, attribute (alpha) bits in bits 0-3
char TGAFileName[MAX_PATH];
V_snprintf( TGAFileName, MAX_PATH, "%s%.4d.tga", pBaseFileName, frameNum );
FileHandle_t TGAFile = g_pFullFileSystem->Open( TGAFileName, "wb" );
g_pFullFileSystem->Write( &theHeader, sizeof( theHeader ), TGAFile );
// is the buffer in BGR format?
if ( PixelFormat == k24BGRPixelFormat || PixelFormat == k32BGRAPixelFormat )
{
if ( strideAdjust == 0 )
{
g_pFullFileSystem->Write( pPixels, width * height * BytesPerPixel, TGAFile );
}
else
{
int lineWidth = width * BytesPerPixel;
int lineOffset = lineWidth + strideAdjust;
for ( int y = 0; y < height; y++ )
{
byte *pData = (byte*) pPixels + ( y * lineOffset );
g_pFullFileSystem->Write( pData, lineWidth, TGAFile );
}
}
}
else // we need to convert the bits from RGB to BGR
{
byte *pData = new byte[width * height * BytesPerPixel];
OSType tgaFormat = ( PixelFormat == k24RGBPixelFormat ) ? k24BGRPixelFormat :
( PixelFormat == k32RGBAPixelFormat ) ? k32BGRAPixelFormat : 0;
CopyBitMapPixels( width, height, PixelFormat, (byte*) pPixels, width * BytesPerPixel + strideAdjust, tgaFormat, pData, width * BytesPerPixel );
g_pFullFileSystem->Write( pData, width * height * BytesPerPixel, TGAFile );
delete [] pData;
}
g_pFullFileSystem->Close( TGAFile );
}
// ===========================================================================
// Data tables used to estimate file size
// ===========================================================================
enum EstVideoEncodeQuality_t
{
cVEQuality_Min = 0,
cVEQuality_Low = 25,
cVEQuality_Normal = 50,
cVEQuality_High = 75,
cVEQuality_Max = 100
};
struct EncodingDataRateInfo_t
{
EstVideoEncodeQuality_t m_QualitySetting;
int m_XResolution;
int m_YResolution;
float m_DataRate; // in MBits / second
};
struct VideoRes_t
{
int X, Y;
};
static EstVideoEncodeQuality_t s_QualityPresets[] =
{
cVEQuality_Min,
cVEQuality_Low,
cVEQuality_Normal,
cVEQuality_High,
cVEQuality_Max
};
static VideoRes_t s_ResolutionPresets[] =
{
{ 16, 16 },
{ 720, 480 },
{ 640, 960 },
{ 960, 640 },
{ 1280, 720 },
{ 1920, 1080 },
{ 2048, 2048 },
};
static EncodingDataRateInfo_t s_H264EncodeRates[] =
{
{ cVEQuality_Min, 16, 160, 2.00f },
{ cVEQuality_Min, 720, 480, 2.26f },
{ cVEQuality_Min, 640, 960, 2.73f },
{ cVEQuality_Min, 960, 640, 2.91f },
{ cVEQuality_Min, 1280, 720, 3.56f },
{ cVEQuality_Min, 1920, 1080, 5.6f },
{ cVEQuality_Min, 2048, 2048, 6.6f },
{ cVEQuality_Low, 16, 160, 3.00f },
{ cVEQuality_Low, 720, 480, 3.65f },
{ cVEQuality_Low, 640, 960, 4.57f },
{ cVEQuality_Low, 960, 640, 5.03f },
{ cVEQuality_Low, 1280, 720, 6.41f },
{ cVEQuality_Low, 1920, 1080, 10.57f },
{ cVEQuality_Low, 2048, 2048, 13.0f },
{ cVEQuality_Normal, 16, 160, 5.00f },
{ cVEQuality_Normal, 720, 480, 6.4f },
{ cVEQuality_Normal, 640, 960, 8.25f },
{ cVEQuality_Normal, 960, 640, 9.24f },
{ cVEQuality_Normal, 1280, 720, 12.1f },
{ cVEQuality_Normal, 1920, 1080, 20.64f },
{ cVEQuality_Normal, 2048, 2048, 25.0f },
{ cVEQuality_High, 16, 160, 9.50f },
{ cVEQuality_High, 720, 480, 11.3f },
{ cVEQuality_High, 640, 960, 15.06f },
{ cVEQuality_High, 960, 640, 16.9f },
{ cVEQuality_High, 1280, 720, 22.72 },
{ cVEQuality_High, 1920, 1080, 40.06f },
{ cVEQuality_High, 2048, 2048, 52.5f },
{ cVEQuality_Max, 16, 160, 15.50f },
{ cVEQuality_Max, 720, 480, 19.33f },
{ cVEQuality_Max, 640, 960, 29.89f },
{ cVEQuality_Max, 960, 640, 26.82f },
{ cVEQuality_Max, 1280, 720, 41.08f },
{ cVEQuality_Max, 1920, 1080, 75.14f },
{ cVEQuality_Max, 2048, 2048, 90.0f },
};
// ===========================================================================
// CQuickTimeVideoRecorder class - implements IVideoRecorder interface for
// QuickTime, and buffers commands to the actual encoder object
// ===========================================================================
CQuickTimeVideoRecorder::CQuickTimeVideoRecorder() :
m_pEncoder( nullptr ),
m_LastResult( VideoResult::SUCCESS ),
m_bHasAudio( false ),
m_bMovieFinished( false )
{
}
CQuickTimeVideoRecorder::~CQuickTimeVideoRecorder()
{
if ( m_pEncoder != nullptr )
{
// Abort any encoding in progress
if ( !m_bMovieFinished )
{
AbortMovie();
}
SAFE_DELETE( m_pEncoder );
}
}
bool CQuickTimeVideoRecorder::CreateNewMovieFile( const char *pFilename, bool hasAudio )
{
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitF( IS_NOT_EMPTY( pFilename ) );
SetResult( VideoResult::OPERATION_ALREADY_PERFORMED );
AssertExitF( m_pEncoder == nullptr && !m_bMovieFinished );
// Create new video recorder
m_pEncoder = new CQTVideoFileComposer();
if ( !m_pEncoder->CreateNewMovie( pFilename, hasAudio ) )
{
SetResult( m_pEncoder->GetResult() ); // save the error result for after the encoder goes poof
SAFE_DELETE( m_pEncoder );
return false;
}
m_bHasAudio = hasAudio;
SetResult( VideoResult::SUCCESS );
return true;
}
bool CQuickTimeVideoRecorder::SetMovieVideoParameters( VideoEncodeCodec_t theCodec, int videoQuality, int movieFrameWidth, int movieFrameHeight, VideoFrameRate_t movieFPS, VideoEncodeGamma_t gamma )
{
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitF( IS_IN_RANGECOUNT( theCodec, VideoEncodeCodec::DEFAULT_CODEC, VideoEncodeCodec::CODEC_COUNT ) );
AssertExitF( IS_IN_RANGE( videoQuality, VideoEncodeQuality::MIN_QUALITY, VideoEncodeQuality::MAX_QUALITY ) );
AssertExitF( IS_IN_RANGE( movieFrameWidth, cMinVideoFrameWidth, cMaxVideoFrameWidth ) && IS_IN_RANGE( movieFrameHeight, cMinVideoFrameHeight, cMaxVideoFrameHeight ) );
AssertExitF( IS_IN_RANGE( movieFPS.GetFPS(), cMinFPS, cMaxFPS ) );
AssertExitF( IS_IN_RANGECOUNT( gamma, VideoEncodeGamma::NO_GAMMA_ADJUST, VideoEncodeGamma::GAMMA_COUNT ) );
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( m_pEncoder != nullptr && !m_bMovieFinished );
return m_pEncoder->SetMovieVideoParameters( movieFrameWidth, movieFrameHeight, movieFPS, theCodec, videoQuality, gamma );
}
bool CQuickTimeVideoRecorder::SetMovieSourceImageParameters( VideoEncodeSourceFormat_t srcImageFormat, int imgWidth, int imgHeight )
{
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitF( IS_IN_RANGECOUNT( srcImageFormat, VideoEncodeSourceFormat::VIDEO_FORMAT_FIRST, VideoEncodeSourceFormat::VIDEO_FORMAT_COUNT ) );
AssertExitF( IS_IN_RANGE( imgWidth, cMinVideoFrameWidth, cMaxVideoFrameWidth ) && IS_IN_RANGE( imgHeight, cMinVideoFrameHeight, cMaxVideoFrameHeight ) );
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( m_pEncoder != nullptr && !m_bMovieFinished );
return m_pEncoder->SetMovieSourceImageParameters( imgWidth, imgHeight, srcImageFormat );
}
bool CQuickTimeVideoRecorder::SetMovieSourceAudioParameters( AudioEncodeSourceFormat_t srcAudioFormat, int audioSampleRate, AudioEncodeOptions_t audioOptions, int audioSampleGroupSize )
{
SetResult( VideoResult::ILLEGAL_OPERATION );
AssertExitF( m_bHasAudio );
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitF( IS_IN_RANGECOUNT( srcAudioFormat, AudioEncodeSourceFormat::AUDIO_NONE, AudioEncodeSourceFormat::AUDIO_FORMAT_COUNT ) );
AssertExitF( audioSampleRate == 0 || IS_IN_RANGE( audioSampleRate, cMinSampleRate, cMaxSampleRate ) );
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( m_pEncoder != nullptr && !m_bMovieFinished );
bool result = m_pEncoder->SetMovieSourceAudioParameters( srcAudioFormat, audioSampleRate, audioOptions, audioSampleGroupSize );
m_bHasAudio = m_pEncoder->HasAudio(); // Audio can be turned off after specifying, so reload status
return result;
}
bool CQuickTimeVideoRecorder::IsReadyToRecord()
{
return ( m_pEncoder == nullptr || m_bMovieFinished ) ? false : m_pEncoder->IsReadyToRecord();
}
VideoResult_t CQuickTimeVideoRecorder::GetLastResult()
{
return ( m_pEncoder == nullptr ) ? m_LastResult : m_pEncoder->GetResult();
}
void CQuickTimeVideoRecorder::SetResult( VideoResult_t resultCode )
{
m_LastResult = resultCode;
if ( m_pEncoder != nullptr )
{
m_pEncoder->SetResult( resultCode );
}
}
bool CQuickTimeVideoRecorder::AppendVideoFrame( void *pFrameBuffer, int nStrideAdjustBytes )
{
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitF( pFrameBuffer != nullptr );
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( IsReadyToRecord() );
return m_pEncoder->AppendVideoFrameToMedia( pFrameBuffer, nStrideAdjustBytes );
}
bool CQuickTimeVideoRecorder::AppendAudioSamples( void *pSampleBuffer, size_t sampleSize )
{
SetResult( VideoResult::ILLEGAL_OPERATION );
AssertExitF( m_bHasAudio );
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitF( pSampleBuffer != nullptr );
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( IsReadyToRecord() );
return m_pEncoder->AppendAudioSamplesToMedia( pSampleBuffer, sampleSize );
}
int CQuickTimeVideoRecorder::GetFrameCount()
{
return ( m_pEncoder == nullptr ) ? 0 : m_pEncoder->GetFrameCount();
}
int CQuickTimeVideoRecorder::GetSampleCount()
{
return ( m_pEncoder == nullptr ) ? 0 : m_pEncoder->GetSampleCount();
}
VideoFrameRate_t CQuickTimeVideoRecorder::GetFPS()
{
return ( m_pEncoder == nullptr ) ? VideoFrameRate_t( 0 ) : m_pEncoder->GetFPS();
}
int CQuickTimeVideoRecorder::GetSampleRate()
{
return ( m_pEncoder == nullptr ) ? 0 : m_pEncoder->GetSampleRate();
}
bool CQuickTimeVideoRecorder::AbortMovie()
{
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( m_pEncoder != nullptr && !m_bMovieFinished );
m_bMovieFinished = true;
return m_pEncoder->AbortMovie();
}
bool CQuickTimeVideoRecorder::FinishMovie( bool SaveMovieToDisk )
{
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( m_pEncoder != nullptr && !m_bMovieFinished );
m_bMovieFinished = true;
return m_pEncoder->FinishMovie( SaveMovieToDisk );
}
#ifdef ENABLE_EXTERNAL_ENCODER_LOGGING
bool CQuickTimeVideoRecorder::LogMessage( const char *pMsg )
{
if ( m_pEncoder != nullptr )
{
m_pEncoder->LogMessage( pMsg );
}
return true;
}
#endif
bool CQuickTimeVideoRecorder::EstimateMovieFileSize( size_t *pEstSize, int movieWidth, int movieHeight, VideoFrameRate_t movieFps, float movieDuration, VideoEncodeCodec_t theCodec, int videoQuality, AudioEncodeSourceFormat_t srcAudioFormat, int audioSampleRate )
{
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertPtrExitF( pEstSize );
*pEstSize = 0;
AssertExitF( IS_IN_RANGE( movieWidth, cMinVideoFrameWidth, cMaxVideoFrameWidth ) && IS_IN_RANGE( movieHeight, cMinVideoFrameHeight, cMaxVideoFrameHeight ) );
AssertExitF( IS_IN_RANGE( movieFps.GetFPS(), cMinFPS, cMaxFPS ) && movieDuration > 0.0f );
AssertExitF( IS_IN_RANGECOUNT( theCodec, VideoEncodeCodec::DEFAULT_CODEC, VideoEncodeCodec::CODEC_COUNT ) );
AssertExitF( IS_IN_RANGE( videoQuality, VideoEncodeQuality::MIN_QUALITY, VideoEncodeQuality::MAX_QUALITY ) );
AssertExitF( IS_IN_RANGECOUNT( srcAudioFormat, AudioEncodeSourceFormat::AUDIO_NONE, AudioEncodeSourceFormat::AUDIO_FORMAT_COUNT ) );
AssertExitF( audioSampleRate == 0 || IS_IN_RANGE( audioSampleRate, cMinSampleRate, cMaxSampleRate ) );
// Determine the Quality LERP
int Q1 = VideoEncodeQuality::MIN_QUALITY, Q2 = VideoEncodeQuality::MAX_QUALITY;
float Qlerp = 0.0f;
bool bQLerp = true;
for ( int i = 0; i < ARRAYSIZE( s_QualityPresets ); i++ )
{
if ( s_QualityPresets[i] == videoQuality )
{
Q1 = videoQuality;
Q2 = videoQuality;
Qlerp = 0.0f;
bQLerp = false;
break;
}
else if ( s_QualityPresets[i] < videoQuality && s_QualityPresets[i] > Q1 )
{
Q1 = s_QualityPresets[i];
}
else if ( s_QualityPresets[i] > videoQuality && s_QualityPresets[i] < Q2 )
{
Q2 = s_QualityPresets[i];
}
}
if ( bQLerp )
{
Qlerp = ( (float) videoQuality - (float) Q1 ) / ( (float) Q2 - (float) Q1 ) ;
}
// determine the resolution lerp
VideoRes_t RES1 = { cMinVideoFrameWidth, cMinVideoFrameHeight }, RES2 = { cMaxVideoFrameWidth, cMaxVideoFrameHeight };
float RLerp = 0.0f;
bool bRLerp = true;
int nPixels = movieHeight * movieWidth;
int R1pixels = RES1.X * RES1.Y;
int R2pixels = RES2.X * RES2.Y;
for ( int i = 0; i < ARRAYSIZE( s_ResolutionPresets ); i++ )
{
if ( s_ResolutionPresets[i].X == movieWidth && s_ResolutionPresets[i].Y == movieHeight )
{
RES1 = s_ResolutionPresets[i];
RES2 = s_ResolutionPresets[i];
RLerp = 0.0f;
bRLerp = false;
break;
}
int rPixels = s_ResolutionPresets[i].X * s_ResolutionPresets[i].Y;
if ( rPixels <= nPixels && rPixels > R1pixels )
{
RES1 = s_ResolutionPresets[i];
R1pixels = rPixels;
}
else if ( rPixels > nPixels && rPixels < R2pixels )
{
RES2 = s_ResolutionPresets[i];
R2pixels = rPixels;
}
}
if ( bRLerp )
{
RLerp = (float) (nPixels - R1pixels) / (float) ( R2pixels - R1pixels );
}
// Now we see what we need to do
// We determine the estimated Data Rate
float DR = 0.0f;
if ( bQLerp == false && bRLerp == false )
{
DR = GetDataRate( videoQuality, movieWidth, movieHeight );
}
else if ( bQLerp == true && bRLerp == false )
{
float D1 = GetDataRate( Q1, movieWidth, movieHeight );
float D2 = GetDataRate( Q2, movieWidth, movieHeight );
DR = D1 + Qlerp * ( D2 - D1 );
}
else if ( bQLerp == false && bRLerp == true )
{
float D1 = GetDataRate( videoQuality, RES1.X, RES1.Y );
float D2 = GetDataRate( videoQuality, RES2.X, RES2.Y );
DR = D1 + RLerp * ( D2 - D1 );
}
else // need the full filter
{
float D1 = GetDataRate( Q1, RES1.X, RES1.Y );
float D2 = GetDataRate( Q1, RES2.X, RES2.Y );
float D3 = GetDataRate( Q2, RES1.X, RES1.Y );
float D4 = GetDataRate( Q2, RES2.X, RES2.Y );
float I1 = D1 + Qlerp * ( D3 - D1 );
float I2 = D2 + Qlerp * ( D4 - D2 );
DR = I1 + RLerp * ( I2 - I1 );
}
// Now do the big computation
// should this be 1024 * 1024?
double VideoData = DR * 1000000 / 8 * movieDuration ;
// Quick hack to guess at audio data size
double audioData = 0;
if ( srcAudioFormat == AudioEncodeSourceFormat::AUDIO_16BIT_PCMStereo )
{
audioData = ( audioSampleRate * 2 ) * ( 0.05 * DR );
}
*pEstSize = (size_t) VideoData + (size_t) audioData;
SetResult( VideoResult::SUCCESS );
return true;
}
float CQuickTimeVideoRecorder::GetDataRate( int quality, int width, int height )
{
for (int i = 0; i < ARRAYSIZE( s_H264EncodeRates ); i++ )
{
if ( s_H264EncodeRates[i].m_QualitySetting == quality && s_H264EncodeRates[i].m_XResolution == width && s_H264EncodeRates[i].m_YResolution == height )
{
return s_H264EncodeRates[i].m_DataRate;
}
}
Assert( false );
return 0.0f;
}
// ------------------------------------------------------------------------
// CQTVideoFileComposer - Class to encapsulate the creation of a QuickTime
// Movie from a sequence of uncompressed images and (future) audio samples
// ------------------------------------------------------------------------
CQTVideoFileComposer::CQTVideoFileComposer() :
m_LastResult( VideoResult::SUCCESS ),
m_bMovieCreated( false ),
m_bHasAudioTrack( false ),
m_bMovieConfigured( false ),
m_bSourceImagesConfigured( false ),
m_bSourceAudioConfigured( false ),
m_bComposingMovie( false ),
m_bMovieCompleted( false ),
m_nFramesAdded( 0 ),
m_nAudioFramesAdded( 0 ),
m_nSamplesAdded( 0 ),
m_nSamplesAddedToMedia( 0 ),
m_MovieFrameWidth( 0 ),
m_MovieFrameHeight( 0 ),
m_MovieTimeScale( 0 ),
m_DurationPerFrame( 0 ),
m_AudioOptions( AudioEncodeOptions::NO_AUDIO_OPTIONS ),
m_SampleGrouping( AG_NONE ),
m_nAudioSampleGroupSize( 0 ),
m_AudioSourceFrequency( 0 ),
m_AudioBytesPerSample( 0 ),
m_bBufferSourceAudio( false ),
m_bLimitAudioDurationToVideo( false ),
m_srcAudioBuffer( nullptr ),
m_srcAudioBufferSize( 0 ),
m_srcAudioBufferCurrentSize( 0 ),
m_AudioSampleFrameCounter( 0 ),
m_FileName( nullptr ),
m_SrcImageWidth( 0 ),
m_SrcImageHeight( 0 ),
m_ScrImageMaxCompressedSize( 0 ),
m_SrcImageBuffer( nullptr ),
m_SrcImageCompressedBuffer( nullptr ),
m_SrcPixelFormat( 0 ),
m_SrcBytesPerPixel( 0 ),
m_GWorldPixelFormat( 0 ),
m_GWorldBytesPerPixel( 0 ),
m_GWorldImageWidth( 0 ),
m_GWorldImageHeight( 0 ),
m_srcSoundDescription( nullptr ),
m_EncodeQuality( CQTVideoFileComposer::DEFAULT_ENCODE_QUALITY ),
m_VideoCodecToUse( CQTVideoFileComposer::DEFAULT_CODEC ),
m_EncodeGamma( CQTVideoFileComposer::DEFAULT_GAMMA ),
m_theSrcGWorld( nullptr ),
m_MovieFileDataRef( nullptr ),
m_MovieFileDataRefType( 0 ),
m_MovieFileDataHandler( nullptr ),
m_theMovie( nullptr ),
m_theVideoTrack( nullptr),
m_theAudioTrack( nullptr ),
m_theVideoMedia( nullptr ),
m_theAudioMedia( nullptr )
#ifdef LOG_ENCODER_OPERATIONS
,m_LogFile( FILESYSTEM_INVALID_HANDLE )
#endif
{
m_MovieRecordFPS.SetFPS( 0, false );
m_GWorldRect.top = m_GWorldRect.left = m_GWorldRect.bottom = m_GWorldRect.right = 0;
#ifdef LOG_FRAMES_TO_TGA
ZeroVar( m_TGAFileBase );
#endif
}
CQTVideoFileComposer::~CQTVideoFileComposer()
{
if ( m_bComposingMovie )
{
AbortMovie();
}
#ifdef LOG_ENCODER_OPERATIONS
if ( m_LogFile != FILESYSTEM_INVALID_HANDLE )
{
g_pFullFileSystem->Close( m_LogFile );
m_LogFile = FILESYSTEM_INVALID_HANDLE;
}
#endif
SAFE_DELETE_ARRAY( m_FileName );
SAFE_DELETE_ARRAY( m_SrcImageBuffer );
SAFE_DELETE_ARRAY( m_srcAudioBuffer );
SAFE_DISPOSE_HANDLE( m_MovieFileDataRef );
SAFE_DISPOSE_HANDLE( m_srcSoundDescription );
SAFE_DISPOSE_HANDLE( m_SrcImageCompressedBuffer );
SAFE_DISPOSE_GWORLD( m_theSrcGWorld );
}
#ifdef LOG_ENCODER_OPERATIONS
void CQTVideoFileComposer::LogMsg( const char* pMsg, ... )
{
const int MAX_TEXT = 8192;
static char messageBuf[MAX_TEXT];
if ( m_LogFile == FILESYSTEM_INVALID_HANDLE || pMsg == nullptr )
{
return;
}
va_list marker;
va_start( marker, pMsg );
#ifdef _WIN32
int len = _vsnprintf( messageBuf, MAX_TEXT, pMsg, marker );
#elif POSIX
int len = vsnprintf( messageBuf, MAX_TEXT, pMsg, marker );
#else
#error "define vsnprintf type."
#endif
// Len < 0 represents an overflow
if( len < 0 )
{
((char*) pMsg)[MAX_TEXT-1] = nullchar;
}
va_end( marker );
g_pFullFileSystem->Write( messageBuf, V_strlen( messageBuf ), m_LogFile );
}
#endif
bool CQTVideoFileComposer::CreateNewMovie( const char *fileName, bool hasAudio )
{
// Validate input and state
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitF( IS_NOT_EMPTY( fileName ) );
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( !m_bMovieCreated && !m_bMovieCompleted );
#ifdef LOG_ENCODER_OPERATIONS
char logFileName[MAX_PATH];
V_strncpy( logFileName, fileName, MAX_PATH );
V_SetExtension( logFileName, ".log", MAX_PATH );
m_LogFile = g_pFullFileSystem->Open( logFileName, "wb" );
const char* aMsg = (hasAudio) ? "HAS" : "DOES NOT HAVE";
LogMsg( "Creating Video File: '%s' - %s AUDIO TRACK\n", fileName, aMsg );
#endif
// now create the movie file
OSErr status = noErr;
OSType movieType = FOUR_CHAR_CODE('TVOD'); // todo - change movie type??
m_MovieFileDataRef = nullptr;
m_MovieFileDataRefType = 0;
m_MovieFileDataHandler = nullptr;
CFStringRef imageStrRef = CFStringCreateWithCString ( NULL, fileName, 0 );
status = QTNewDataReferenceFromFullPathCFString( imageStrRef, (QTPathStyle) kQTNativeDefaultPathStyle, 0, &m_MovieFileDataRef, &m_MovieFileDataRefType );
AssertExitF( status == noErr );
status = CreateMovieStorage( m_MovieFileDataRef, m_MovieFileDataRefType, movieType, smCurrentScript, createMovieFileDeleteCurFile | createMovieFileDontCreateResFile, &m_MovieFileDataHandler, &m_theMovie );
AssertExitF( status == noErr );
CFRelease( imageStrRef );
m_FileName = COPY_STRING( fileName );
#ifdef LOG_FRAMES_TO_TGA
V_strncpy( m_TGAFileBase, m_FileName, sizeof( m_TGAFileBase ) );
V_StripExtension( m_TGAFileBase, m_TGAFileBase, sizeof( m_TGAFileBase ) );
#endif
// we did it! party on...
SetResult( VideoResult::SUCCESS );
m_bMovieCreated = true;
m_bHasAudioTrack = hasAudio;
return m_bMovieCreated;
}
bool CQTVideoFileComposer::SetMovieVideoParameters( int width, int height, VideoFrameRate_t movieFPS, VideoEncodeCodec_t desiredCodec, int encodeQuality, VideoEncodeGamma_t gamma )
{
// Validate input and state
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitF( IS_IN_RANGE( width, cMinVideoFrameWidth, cMaxVideoFrameWidth ) && IS_IN_RANGE( height, cMinVideoFrameHeight, cMaxVideoFrameHeight ) );
AssertExitF( IS_IN_RANGE( movieFPS.GetFPS(), cMinFPS, cMaxFPS ) );
AssertExitF( IS_IN_RANGECOUNT( desiredCodec, VideoEncodeCodec::DEFAULT_CODEC, VideoEncodeCodec::CODEC_COUNT ) );
AssertExitF( IS_IN_RANGE( encodeQuality, VideoEncodeQuality::MIN_QUALITY, VideoEncodeQuality::MAX_QUALITY ) );
AssertExitF( IS_IN_RANGECOUNT( gamma, VideoEncodeGamma::NO_GAMMA_ADJUST, VideoEncodeGamma::GAMMA_COUNT ) );
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( m_bMovieCreated && !m_bMovieConfigured );
// Configure video parameters
m_MovieFrameWidth = width;
m_MovieFrameHeight = height;
// map the requested codec in
switch( desiredCodec )
{
case VideoEncodeCodec::MPEG2_CODEC:
{
m_VideoCodecToUse = kMpegYUV420CodecType;
break;
}
case VideoEncodeCodec::MPEG4_CODEC:
{
m_VideoCodecToUse = kMPEG4VisualCodecType;
break;
}
case VideoEncodeCodec::H261_CODEC:
{
m_VideoCodecToUse = kH261CodecType;
break;
}
case VideoEncodeCodec::H263_CODEC:
{
m_VideoCodecToUse = kH263CodecType;
break;
}
case VideoEncodeCodec::H264_CODEC:
{
m_VideoCodecToUse = kH264CodecType;
break;
}
case VideoEncodeCodec::MJPEG_A_CODEC:
{
m_VideoCodecToUse = kMotionJPEGACodecType;
break;
}
case VideoEncodeCodec::MJPEG_B_CODEC:
{
m_VideoCodecToUse = kMotionJPEGBCodecType;
break;
}
case VideoEncodeCodec::SORENSON3_CODEC:
{
m_VideoCodecToUse = kSorenson3CodecType;
break;
}
case VideoEncodeCodec::CINEPACK_CODEC:
{
m_VideoCodecToUse = kCinepakCodecType;
break;
}
default: // should never hit this because we are already range checked
{
m_VideoCodecToUse = CQTVideoFileComposer::DEFAULT_CODEC;
break;
}
}
// Determine if codec is available...
CodecInfo theInfo;
OSErr status = GetCodecInfo( &theInfo, m_VideoCodecToUse, 0 );
if ( status == noCodecErr )
{
SetResult( VideoResult::CODEC_NOT_AVAILABLE );
return false;
}
AssertExitF( status == noErr );
#ifdef LOG_ENCODER_OPERATIONS
char codecName[64];
ZeroVar( codecName );
V_memcpy( codecName, &theInfo.typeName[1], (int) theInfo.typeName[0] );
LogMsg( "Video Image Size is (%d x %d)\n", m_MovieFrameWidth, m_MovieFrameHeight );
LogMsg( "Codec selected is %s\n", codecName );
LogMsg( "Encoding Quality = %d\n", (int) encodeQuality );
LogMsg( "Encode Gamma = %d\n", (int) gamma );
#endif
// convert encoding quality into quicktime specific value
int Q = (int) encodeQuality; - (int) VideoEncodeQuality::MIN_QUALITY;
int MaxQ = (int) VideoEncodeQuality::MAX_QUALITY - (int) VideoEncodeQuality::MIN_QUALITY;
m_EncodeQuality = codecLosslessQuality * ( (float) Q / (float) MaxQ ) ;
clamp( m_EncodeQuality, codecMinQuality, codecMaxQuality );
// convert the gamma correction value into quicktime specific values
switch( gamma )
{
case VideoEncodeGamma::NO_GAMMA_ADJUST:
{
m_EncodeGamma = kQTUseSourceGammaLevel;
break;
}
case VideoEncodeGamma::PLATFORM_STANDARD_GAMMA:
{
m_EncodeGamma = kQTUsePlatformDefaultGammaLevel;
break;
}
case VideoEncodeGamma::GAMMA_1_8:
{
m_EncodeGamma = 0x0001CCCC; // (Fixed) Gamma 1.8
break;
}
case VideoEncodeGamma::GAMMA_2_2:
{
m_EncodeGamma = kQTCCIR601VideoGammaLevel;
break;
}
case VideoEncodeGamma::GAMMA_2_5:
{
m_EncodeGamma = 0x00028000; // (Fixed) Gamma 2.5
break;
}
default:
{
m_EncodeGamma = CQTVideoFileComposer::DEFAULT_GAMMA;
break;
}
}
// Process the framerate into usable values
m_MovieRecordFPS = movieFPS;
m_DurationPerFrame = m_MovieRecordFPS.GetUnitsPerFrame();
m_MovieTimeScale = m_MovieRecordFPS.GetUnitsPerSecond();
AssertExitF( m_DurationPerFrame > 0 && m_MovieTimeScale > 0 );
/* if ( movieFPS.IsNTSCRate() )
{
m_MovieTimeScale = movieFPS.GetIntFPS() * 1000;
m_DurationPerFrame = 1001;
}
else if ( movieFPS.GetUnitsPerSecond() % movieFPS.GetUnitsPerFrame() == 0 ) // integer frame rate?
{
m_MovieTimeScale = movieFPS.GetIntFPS() * 1000;
m_DurationPerFrame = 1000;
}
else // round to nearest .001 second
{
m_MovieTimeScale = (int) ( movieFPS.GetFPS() * 1000 );
m_DurationPerFrame = 1000;
}
*/
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "Video Frame Rate = %f FPS\n %d time units per second\n %d time units per frame\n", m_MovieRecordFPS.GetFPS(), m_MovieRecordFPS.GetUnitsPerSecond(), m_MovieRecordFPS.GetUnitsPerFrame() );
if ( m_MovieRecordFPS.IsNTSCRate() )
LogMsg( " IS CONSIDERED NTSC RATE\n");
LogMsg( "MovieTimeScale is being set to %d\nDuration Per Frame is %d\n\n", m_MovieTimeScale, m_DurationPerFrame );
#endif
// Create the video track and media
SetResult( VideoResult::VIDEO_ERROR_OCCURED );
m_theVideoTrack = NewMovieTrack( m_theMovie, FixRatio( width, 1 ), FixRatio( height, 1 ), kNoVolume );
AssertExitF( GetMoviesError() == noErr );
m_theVideoMedia = NewTrackMedia( m_theVideoTrack, VideoMediaType, m_MovieTimeScale, NULL, 0 );
AssertExitF( GetMoviesError() == noErr );
// we have successfully configured the output movie
SetResult( VideoResult::SUCCESS );
m_bMovieConfigured = true;
return true;
}
bool CQTVideoFileComposer::SetMovieSourceImageParameters( int srcWidth, int srcHeight, VideoEncodeSourceFormat_t srcImageFormat )
{
// Validate input and state
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitF( IS_IN_RANGE( srcWidth, cMinVideoFrameWidth, cMaxVideoFrameWidth ) && IS_IN_RANGE( srcHeight, cMinVideoFrameHeight, cMaxVideoFrameHeight ) );
AssertExitF( IS_IN_RANGECOUNT( srcImageFormat, VideoEncodeSourceFormat::VIDEO_FORMAT_FIRST, VideoEncodeSourceFormat::VIDEO_FORMAT_COUNT ) );
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( m_bMovieCreated && !m_bMovieCompleted && m_bMovieConfigured && !m_bSourceImagesConfigured );
// Setup source image format related stuff
m_SrcPixelFormat = ( srcImageFormat == VideoEncodeSourceFormat::BGRA_32BIT ) ? k32BGRAPixelFormat :
( srcImageFormat == VideoEncodeSourceFormat::BGR_24BIT ) ? k24BGRPixelFormat :
( srcImageFormat == VideoEncodeSourceFormat::RGB_24BIT ) ? k24RGBPixelFormat :
( srcImageFormat == VideoEncodeSourceFormat::RGBA_32BIT ) ? k32RGBAPixelFormat : 0;
m_SrcBytesPerPixel = GetBytesPerPixel( m_SrcPixelFormat );
// Setup source image size related stuff
m_SrcImageWidth = srcWidth;
m_SrcImageHeight = srcHeight;
m_SrcImageSize = srcWidth * srcHeight * m_SrcBytesPerPixel;
// Setup the GWorld to hold the frame to video compress
m_GWorldPixelFormat = k32BGRAPixelFormat; // can use k24BGRPixelFormat on Win32.. but it compresses wrong on OSX?
m_GWorldBytesPerPixel = 4;
m_GWorldImageWidth = CONTAINING_MULTIPLE_OF( srcWidth, 4 ); // make sure the encoded surface is a multiple of 4 in each dimensions
m_GWorldImageHeight = CONTAINING_MULTIPLE_OF( srcHeight, 4 );
m_GWorldRect.top = m_GWorldRect.left = 0;
m_GWorldRect.bottom = m_GWorldImageHeight;
m_GWorldRect.right = m_GWorldImageWidth;
// Setup the QuiuckTime Graphics World for incoming frames of video
// Always use a 32-bit GWORD to avoid encoding bugs
SetResult( VideoResult::VIDEO_ERROR_OCCURED );
OSErr status = QTNewGWorld( &m_theSrcGWorld, m_GWorldPixelFormat, &m_GWorldRect, nil, nil, 0 );
AssertExitF( status == noErr );
PixMapHandle thePixMap = GetGWorldPixMap( m_theSrcGWorld );
AssertPtrExitF( thePixMap );
status = QTSetPixMapHandleRequestedGammaLevel( thePixMap, m_EncodeGamma );
AssertExitF( status == noErr );
// Set encoding buffer to max size at max quality
// Should we try it with the actual quality setting?
status = GetMaxCompressionSize( thePixMap, &m_GWorldRect, 0, m_EncodeQuality, m_VideoCodecToUse,
(CompressorComponent)anyCodec, (long*) &m_ScrImageMaxCompressedSize );
AssertExitF( status == noErr && m_ScrImageMaxCompressedSize > 0 );
// allocated buffers for the uncompressed and compressed images
m_SrcImageBuffer = new byte[ m_SrcImageSize ];
m_SrcImageCompressedBuffer = NewHandle( m_ScrImageMaxCompressedSize );
// we have successfully configured the video input images
SetResult( VideoResult::SUCCESS );
m_bSourceImagesConfigured = true;
return CheckForReadyness(); // We are ready to go if audio is...
}
bool CQTVideoFileComposer::SetMovieSourceAudioParameters( AudioEncodeSourceFormat_t srcAudioFormat, int audioSampleRate, AudioEncodeOptions_t audioOptions, int audioSampleGroupSize )
{
SetResult( VideoResult::ILLEGAL_OPERATION );
AssertExitF( m_bHasAudioTrack );
// Validate input and state
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitF( IS_IN_RANGECOUNT( srcAudioFormat, AudioEncodeSourceFormat::AUDIO_NONE, AudioEncodeSourceFormat::AUDIO_FORMAT_COUNT ) );
AssertExitF( audioSampleRate == 0 || IS_IN_RANGE( audioSampleRate, cMinSampleRate, cMaxSampleRate ) );
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( m_bMovieCreated && !m_bMovieCompleted && m_bMovieConfigured && !m_bSourceAudioConfigured );
// it is possible to disable audio here by passing in AudioEncodeSourceFormat::AUDIO_NONE even
// if the movie was created with the hasHadio flag set to true, or by setting the sample rate to 0
if ( srcAudioFormat == AudioEncodeSourceFormat::AUDIO_NONE || audioSampleRate == 0 )
{
m_bHasAudioTrack = false;
}
else
{
m_AudioOptions = audioOptions;
// Setup the audio frequency
m_AudioSourceFrequency = audioSampleRate;
// Create the audio track and media
SetResult( VideoResult::AUDIO_ERROR_OCCURED );
m_theAudioTrack = NewMovieTrack( m_theMovie, 0, 0, kFullVolume );
AssertExitF( GetMoviesError() == noErr );
m_theAudioMedia = NewTrackMedia( m_theAudioTrack, SoundMediaType, (TimeScale) audioSampleRate, NULL, 0 );
AssertExitF( GetMoviesError() == noErr );
// Setup the Audio Sound description
AudioStreamBasicDescription inASBD;
switch( srcAudioFormat )
{
case AudioEncodeSourceFormat::AUDIO_16BIT_PCMStereo:
{
inASBD.mSampleRate = Float64( audioSampleRate );
inASBD.mFormatID = kAudioFormatLinearPCM;
inASBD.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
inASBD.mBytesPerPacket = 4;
inASBD.mFramesPerPacket = 1;
inASBD.mBytesPerPacket = 4;
inASBD.mChannelsPerFrame = 2;
inASBD.mBitsPerChannel = 16;
inASBD.mReserved = 0;
break;
}
default:
{
Assert( false ); // Impossible.. we hope
return false;
}
}
m_AudioBytesPerSample = inASBD.mBytesPerPacket;
OSStatus result = QTSoundDescriptionCreate( &inASBD, NULL, 0, NULL, 0, kQTSoundDescriptionKind_Movie_LowestPossibleVersion, (SoundDescriptionHandle*) &m_srcSoundDescription );
AssertExitF( result == noErr );
// Setup audio sample buffering if needed
m_bLimitAudioDurationToVideo = BITFLAGS_SET( audioOptions, AudioEncodeOptions::LIMIT_AUDIO_TRACK_TO_VIDEO_DURATION );
m_SampleGrouping = ( BITFLAGS_SET( audioOptions, AudioEncodeOptions::GROUP_SIZE_IS_VIDEO_FRAME ) ) ? CQTVideoFileComposer::AG_PER_FRAME :
( BITFLAGS_SET( audioOptions, AudioEncodeOptions::USE_AUDIO_ENCODE_GROUP_SIZE ) ) ? CQTVideoFileComposer::AG_FIXED_SIZE : AG_NONE;
// check for invalid sample grouping duration
if ( m_SampleGrouping == AG_FIXED_SIZE && ( audioSampleGroupSize < MIN_AUDIO_SAMPLE_GROUP_SIZE || audioSampleGroupSize > MAX_AUDIO_GROUP_SIZE_IN_SEC * m_AudioSourceFrequency ) )
{
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
Assert( false );
return false;
}
m_bBufferSourceAudio = ( m_SampleGrouping != AG_NONE ) || m_bLimitAudioDurationToVideo;
// Set up an audio buffer than can hold the maxium specified duration
if ( m_bBufferSourceAudio )
{
m_srcAudioBufferSize = m_AudioSourceFrequency * m_AudioBytesPerSample * MAX_AUDIO_GROUP_SIZE_IN_SEC;
m_srcAudioBuffer = new byte[m_srcAudioBufferSize];
m_srcAudioBufferCurrentSize = 0;
}
if ( m_SampleGrouping == AG_FIXED_SIZE )
{
// Set up to emit audio after fixed number of samples
m_nAudioSampleGroupSize = audioSampleGroupSize;
}
if ( m_SampleGrouping == AG_PER_FRAME )
{
m_AudioSampleFrameCounter = 0;
}
m_bSourceAudioConfigured = true;
}
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Audio Sample Grouping Mode = %d\nSample Group Size = %d \n", (int) m_SampleGrouping, m_nAudioSampleGroupSize );
LogMsg( "Audio Track Sample Rate is %d samples per second\n", m_AudioSourceFrequency );
LogMsg( "Estimated Samples per frame = %d\n\n", (int) ( m_AudioSourceFrequency / m_MovieRecordFPS.GetFPS() ) );
#endif
// finish up
SetResult( VideoResult::SUCCESS );
return CheckForReadyness(); // We are ready to go if video is...
}
// Returns true if we are not ready, or if we began movie creation successfully
// This ONLY returns false if it tried to begin the movie creation process and failed
bool CQTVideoFileComposer::CheckForReadyness()
{
return ( m_bMovieCreated && !m_bMovieCompleted && !m_bComposingMovie && m_bMovieConfigured && m_bSourceImagesConfigured &&
m_bSourceAudioConfigured == m_bHasAudioTrack ) ? BeginMovieCreation() : true;
}
bool CQTVideoFileComposer::BeginMovieCreation()
{
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( m_bMovieCreated && !m_bMovieCompleted && !m_bComposingMovie &&
m_bMovieConfigured && m_bSourceImagesConfigured && m_bSourceAudioConfigured == m_bHasAudioTrack );
// Open the tracks up for editing
SetResult( VideoResult::VIDEO_ERROR_OCCURED );
OSErr status = BeginMediaEdits( m_theVideoMedia );
AssertExitF( status == noErr );
if ( m_bHasAudioTrack )
{
OSErr status = BeginMediaEdits( m_theAudioMedia );
AssertExitF( status == noErr );
}
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "Media Tracks opened for editing\n\n" );
#endif
// We are now ready to take in data to make a movie with
SetResult( VideoResult::SUCCESS );
m_bComposingMovie = true;
return true;
}
bool CQTVideoFileComposer::AppendVideoFrameToMedia( void *ImageBuffer, int strideAdjustBytes )
{
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "AppendVideoFrameToMedia( %8.8x ) called for %d --- ", ImageBuffer, m_nFramesAdded+1 );
#endif
// Validate input and state
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitF( ImageBuffer != nullptr );
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( m_bComposingMovie && !m_bMovieCompleted );
SetResult( VideoResult::VIDEO_ERROR_OCCURED );
// Get the pixmap
PixMapHandle thePixMap = GetGWorldPixMap( m_theSrcGWorld );
AssertPtrExitF( thePixMap );
// copy the raw image into our bitmap
AssertExitF( LockPixels( thePixMap ) );
byte *srcBase = (byte*) ImageBuffer;
int srcStride = m_SrcImageWidth * m_SrcBytesPerPixel + strideAdjustBytes;
byte *dstBase = nullptr;
int dstStride = 0;
#if defined ( WIN32 )
// Get the HBITMAP of our GWorld
HBITMAP theHBITMAP = (HBITMAP) GetPortHBITMAP( (GrafPtr) m_theSrcGWorld );
// retrieve the bitmap info header information
BITMAP bmp;
AssertExitF( GetObject( theHBITMAP, sizeof(BITMAP), (LPSTR) &bmp) );
// validate the BMP we just got
AssertExitF( bmp.bmWidth == m_SrcImageWidth && bmp.bmHeight == m_SrcImageHeight && bmp.bmBitsPixel == 8 * m_GWorldBytesPerPixel );
// setup the pixel copy info
dstBase = (byte*)bmp.bmBits;
dstStride = bmp.bmWidthBytes;
#elif defined ( OSX )
// setup the pixel copy info
dstBase = (byte*) GetPixBaseAddr( thePixMap );
dstStride = GetPixRowBytes( thePixMap );
#endif
AssertExitF( dstBase != nullptr && dstStride > 0 );
// save a TGA if we are running diagnostics
#if defined ( LOG_FRAMES_TO_TGA )
if ( ( m_nFramesAdded % LOG_FRAMES_TO_TGA_INTERVAL ) == 0 )
{
SaveToTargaFile( m_nFramesAdded, m_TGAFileBase, m_SrcImageWidth, m_SrcImageHeight, srcBase, m_SrcPixelFormat, strideAdjustBytes );
}
#endif
// copy the supplied pixel buffer into our GWORLD data
if ( !CopyBitMapPixels( m_SrcImageWidth, m_SrcImageHeight,
m_SrcPixelFormat, srcBase, srcStride,
m_GWorldPixelFormat, dstBase, dstStride ) )
{
Assert( false );
return false;
}
// You are now free to move about the cabin...
UnlockPixels( thePixMap );
// allocate a handle which CompressImage will resize...
ImageDescriptionHandle theImageDescHandle = (ImageDescriptionHandle) NewHandle( sizeof(ImageDescriptionHandle) );
AssertExitF( theImageDescHandle != nullptr );
// compress the single image
OSErr status = CompressImage( thePixMap, &m_GWorldRect, m_EncodeQuality,
m_VideoCodecToUse, theImageDescHandle, *m_SrcImageCompressedBuffer );
if ( status != noErr )
{
Assert( false ); // tell the user
SAFE_DISPOSE_HANDLE( theImageDescHandle );
return false;
}
TimeValue addedTime = 0;
// Lets add gamma info the image description
if ( m_EncodeGamma != kQTUseSourceGammaLevel )
{
Fixed newGamma = m_EncodeGamma;
status = ICMImageDescriptionSetProperty( theImageDescHandle, kQTPropertyClass_ImageDescription, kICMImageDescriptionPropertyID_GammaLevel, sizeof( newGamma ), &newGamma );
AssertExitF( status == noErr );
}
// add the compressed image to the movie stream
status = AddMediaSample( m_theVideoMedia, m_SrcImageCompressedBuffer, 0, (**theImageDescHandle).dataSize, m_DurationPerFrame,
(SampleDescriptionHandle) theImageDescHandle, 1, 0, &addedTime );
if ( status != noErr )
{
Assert( false ); // tell the user
SAFE_DISPOSE_HANDLE( theImageDescHandle );
return false;
}
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "Video Frame %d added to Video Media: Duration = %d, Inserted at Time %d\n", m_nFramesAdded+1, m_DurationPerFrame, addedTime );
#endif
// free up dynamic resources
SAFE_DISPOSE_HANDLE( theImageDescHandle );
// Report success
SetResult( VideoResult::SUCCESS );
m_nFramesAdded++;
return true;
}
int CQTVideoFileComposer::GetAudioSampleCountThruFrame( int frameNo )
{
if ( frameNo < 1 )
{
return 0;
}
double secondsSoFar = (double) ( frameNo * m_DurationPerFrame ) / (double) m_MovieTimeScale;
int nAudioSamples = (int) floor( secondsSoFar * (double) m_AudioSourceFrequency );
return nAudioSamples;
}
bool CQTVideoFileComposer::AppendAudioSamplesToMedia( void *soundBuffer, size_t bufferSize )
{
SetResult( VideoResult::ILLEGAL_OPERATION );
AssertExitF( m_bHasAudioTrack );
// Validate input and state
SetResult( VideoResult::BAD_INPUT_PARAMETERS );
AssertExitF( soundBuffer != nullptr && bufferSize % m_AudioBytesPerSample == 0 );
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( m_bComposingMovie && !m_bMovieCompleted );
int nSamples = bufferSize / m_AudioBytesPerSample;
Assert( bufferSize % m_AudioBytesPerSample == 0 );
TimeValue64 insertTime64 = 0;
OSErr status = noErr;
bool retest;
int samplesToEmit, MaxCanAdd, nSamplesAvailable;
m_nSamplesAdded+= nSamples; // track samples given to encoder
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "%d Audio Samples Submitted (%d total) -- ", nSamples, m_nSamplesAdded );
#endif
// We can pass in 0 bytes to trigger a flush...
if ( nSamples == 0 )
{
if ( !m_bBufferSourceAudio || m_srcAudioBufferCurrentSize == 0 )
{
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "NO SAMPLES TO PROCESS. EXIT\n" );
#endif
goto finish_up;
}
}
// Are we not buffering audio?
if ( !m_bBufferSourceAudio && nSamples > 0 )
{
SetResult( VideoResult::AUDIO_ERROR_OCCURED );
status = AddMediaSample2( m_theAudioMedia, (const UInt8 *) soundBuffer, (ByteCount) bufferSize,
(TimeValue64) 1, (TimeValue64) 0, (SampleDescriptionHandle) m_srcSoundDescription,
(ItemCount) nSamples, 0, &insertTime64 );
AssertExitF( status == noErr );
m_nSamplesAddedToMedia+= nSamples;
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "%d samples (%d total) inserted into Video at time %ld\n", nSamples, m_nSamplesAddedToMedia, insertTime64 );
#endif
goto finish_up;
}
// Buffering audio ....
if ( nSamples > 0 )
{
memaddr_t pSrc = (memaddr_t) soundBuffer;
size_t bytesToCopy = nSamples * m_AudioBytesPerSample;
// Is buffer big enough to hold it all?
if ( m_srcAudioBufferCurrentSize + bytesToCopy > m_srcAudioBufferSize )
{
// get a bigger buffer
size_t newBufferSize = m_srcAudioBufferSize * 2 + bytesToCopy;
byte *newBuffer = new byte[newBufferSize];
// copy buffered sound and swap out buffers
V_memcpy( newBuffer, m_srcAudioBuffer, m_srcAudioBufferCurrentSize );
delete[] m_srcAudioBuffer;
m_srcAudioBuffer = newBuffer;
m_srcAudioBufferSize = newBufferSize;
}
// Append samples to buffer
V_memcpy( m_srcAudioBuffer + m_srcAudioBufferCurrentSize, pSrc, bytesToCopy );
m_srcAudioBufferCurrentSize += bytesToCopy;
}
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "%d Samples buffered. Buffer=%d Samples -- ", nSamples, ( m_srcAudioBufferCurrentSize / m_AudioBytesPerSample ) );
#endif
retest_here:
nSamplesAvailable = m_srcAudioBufferCurrentSize / m_AudioBytesPerSample;
samplesToEmit = 0;
retest = false;
MaxCanAdd = ( m_bLimitAudioDurationToVideo ) ? ( GetAudioSampleCountThruFrame( m_nFramesAdded ) - m_nSamplesAddedToMedia ) : INT32_MAX;
if ( MaxCanAdd <= 0 )
{
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Can't Add Audio Now.\n" );
#endif
goto finish_up;
}
// Now.. we determine if we are ready to insert the audio samples into the media..and if so, how much...
if ( m_SampleGrouping == AG_NONE )
{
// are we keeping audio from getting ahead of video?
Assert( m_bLimitAudioDurationToVideo );
samplesToEmit = MIN( MaxCanAdd, nSamplesAvailable );
}
else if ( m_SampleGrouping == AG_FIXED_SIZE )
{
// do we have enough to emit a sample?
if ( ( nSamplesAvailable < m_nAudioSampleGroupSize ) || ( m_bLimitAudioDurationToVideo && ( MaxCanAdd < m_nAudioSampleGroupSize ) ) )
{
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
if ( nSamplesAvailable < m_nAudioSampleGroupSize )
LogMsg( "Need %d Samples to emit sample group\n", m_nAudioSampleGroupSize );
else
LogMsg( "Audio is caught up to Video (can add %d) \n", MaxCanAdd );
#endif
goto finish_up;
}
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "emitting 1 group of audio (%d samples)\n", m_nAudioSampleGroupSize );
#endif
samplesToEmit = m_nAudioSampleGroupSize;
retest = true;
}
else if ( m_SampleGrouping == AG_PER_FRAME )
{
// is the audio already caught up with the current video frame?
if ( m_bLimitAudioDurationToVideo && m_AudioSampleFrameCounter >= m_nFramesAdded )
{
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Audio is caught up to Video\n" );
#endif
goto finish_up;
}
int curSampleCount = GetAudioSampleCountThruFrame( m_AudioSampleFrameCounter );
int nextSampleCount = GetAudioSampleCountThruFrame( m_AudioSampleFrameCounter+1 );
int thisGroupSize = nextSampleCount - curSampleCount;
Assert( m_nSamplesAddedToMedia == curSampleCount );
if ( nSamplesAvailable < thisGroupSize )
{
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Not enough samples to fill video frame (need %d)\n", thisGroupSize );
#endif
goto finish_up;
}
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "emitting 1 video frame of audio (%d samples)\n", thisGroupSize );
#endif
samplesToEmit = thisGroupSize;
m_AudioSampleFrameCounter++;
retest = true;
}
else
{
Assert( false );
}
if ( samplesToEmit > 0 )
{
SetResult( VideoResult::AUDIO_ERROR_OCCURED );
status = AddMediaSample2( m_theAudioMedia, (const UInt8 *) m_srcAudioBuffer, (ByteCount) samplesToEmit * m_AudioBytesPerSample,
(TimeValue64) 1, (TimeValue64) 0, (SampleDescriptionHandle) m_srcSoundDescription,
(ItemCount) samplesToEmit, 0, &insertTime64 );
AssertExitF( status == noErr );
m_nSamplesAddedToMedia+= samplesToEmit;
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "%d samples inserted into Video (%d total) at time %ld -- ", samplesToEmit, m_nSamplesAddedToMedia, insertTime64 );
#endif
// remove added samples from sound buffer
// (this really should be a circular buffer.. but that has its own problems)
m_srcAudioBufferCurrentSize -= samplesToEmit * m_AudioBytesPerSample;
nSamplesAvailable -= samplesToEmit;
if ( nSamplesAvailable > 0 )
{
V_memcpy( m_srcAudioBuffer, m_srcAudioBuffer + (samplesToEmit * m_AudioBytesPerSample), nSamplesAvailable * m_AudioBytesPerSample );
}
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Buffer now =%d samples", nSamplesAvailable );
#endif
if ( retest )
{
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( " -- rechecking -- " );
#endif
goto retest_here;
}
}
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "\n" );
#endif
finish_up:
// Report success
SetResult( VideoResult::SUCCESS );
return true;
}
bool CQTVideoFileComposer::SyncAndFlushAudio()
{
if ( !m_bHasAudioTrack )
{
return false;
}
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Resolving Audio Track...\n" );
#endif
restart_sync:
bool bPadWithSilence = BITFLAGS_SET( m_AudioOptions, AudioEncodeOptions::PAD_AUDIO_WITH_SILENCE );
int VideoDurationInSamples = GetAudioSampleCountThruFrame( m_nFramesAdded );
int CurShortfall = VideoDurationInSamples - m_nSamplesAddedToMedia;
int SilenceToEmit = 0;
bool forceFlush = false;
bool forcePartialGroupFlush = false;
int nSamplesInBuffer = ( m_bBufferSourceAudio ) ? m_srcAudioBufferCurrentSize / m_AudioBytesPerSample : 0;
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Video duration is %d frames, which is %d Audio Samples\n", m_nFramesAdded, VideoDurationInSamples );
LogMsg( "%d Samples emitted to Audio track so far. %d samples remain in audio buffer\n", m_nSamplesAddedToMedia, nSamplesInBuffer );
LogMsg( "Delta to sync end of audio to end of video is %d Samples\n", CurShortfall );
LogMsg( "Pad With Silence Mode = %d, Align End of Audio With Video Mode = %d\n", (int) bPadWithSilence, (int) m_bLimitAudioDurationToVideo );
#endif
// not grouping samples mode
if ( m_SampleGrouping == AG_NONE )
{
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "No sample grouping Mode\n" );
#endif
Assert( m_bLimitAudioDurationToVideo == m_bBufferSourceAudio ); // if we're not limiting, we're not buffering
if ( m_bLimitAudioDurationToVideo && CurShortfall > 0 && bPadWithSilence )
{
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Padding with %d samples to match video duration", CurShortfall );
#endif
SilenceToEmit = CurShortfall; // pad with silence
}
if ( nSamplesInBuffer > 0 || SilenceToEmit > 0 ) // force if we have something to add
{
forceFlush = true;
}
}
// Fixed sized grouping (and buffering)
if ( m_SampleGrouping == AG_FIXED_SIZE )
{
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Fixed sample grouping mode. Group size of %d\n", m_nAudioSampleGroupSize );
#endif
// No matter what, if we have a partially filled buffer, we add silence to it to make a complete group
// do we have a partially full buffer? if so pad with silence to make a full group
if ( nSamplesInBuffer > 0 && nSamplesInBuffer % m_nAudioSampleGroupSize != 0 )
{
SilenceToEmit = m_nAudioSampleGroupSize - ( nSamplesInBuffer % m_nAudioSampleGroupSize );
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Adding %d silence samples to complete group\n", SilenceToEmit );
#endif
}
int bufferedSamples = nSamplesInBuffer + SilenceToEmit;
int newShortFall = VideoDurationInSamples - m_nSamplesAddedToMedia - bufferedSamples;
if ( bPadWithSilence && newShortFall > 0 )
{
SilenceToEmit += newShortFall; // pad with silence until audio matches video duration
forceFlush = true;
forcePartialGroupFlush = true;
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Adding %d silence samples to pad to match audio to video duration\n", newShortFall );
#endif
}
}
if ( m_SampleGrouping == AG_PER_FRAME )
{
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Video Frame duraiton Audio grouping mode\n" );
#endif
// Have we already enough audio to match the video
if ( m_bLimitAudioDurationToVideo && m_AudioSampleFrameCounter >= m_nFramesAdded )
{
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Audio is caught up to Video\n" );
#endif
goto audio_complete;
}
// if we have anything in the buffer... pad it out with zeros
if ( nSamplesInBuffer > 0 )
{
// get the group size for the video frame the audio is currently on
int thisGroupSize = GetAudioSampleCountThruFrame( m_AudioSampleFrameCounter+1 ) - GetAudioSampleCountThruFrame( m_AudioSampleFrameCounter );
Assert( m_nSamplesAddedToMedia == GetAudioSampleCountThruFrame( m_AudioSampleFrameCounter ) );
// if we already have 1 (or more) groups in the buffer.. emit them, and restart
if ( nSamplesInBuffer >= thisGroupSize )
{
char n = nullchar;
AppendAudioSamplesToMedia( &n, 0 );
goto restart_sync;
}
SilenceToEmit = thisGroupSize - nSamplesInBuffer;
forceFlush = true;
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Adding %d silence samples to pad current group to match video frame duration\n", SilenceToEmit );
#endif
}
// with the output being aligned to a video frame, do we need to add more to pad to end of the video
int bufferedSamples = nSamplesInBuffer + SilenceToEmit;
int newShortFall = VideoDurationInSamples - m_nSamplesAddedToMedia - bufferedSamples;
if ( bPadWithSilence && newShortFall > 0 )
{
SilenceToEmit += newShortFall; // pad with silence until audio matches video duration
forceFlush = true;
forcePartialGroupFlush = true;
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Adding %d silence samples to pad audio to match video duration", newShortFall );
#endif
}
}
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "\n" );
#endif
// now we append any needed silence to the audio stream...
if ( SilenceToEmit > 0 )
{
int bufferSize = SilenceToEmit * m_AudioBytesPerSample;
byte *pSilenceBuf = new byte[ bufferSize ];
V_memset( pSilenceBuf, nullchar, bufferSize );
#ifdef LOG_ENCODER_AUDIO_OPERATIONS
LogMsg( "Appending %d Silence samples\n", SilenceToEmit );
#endif
AppendAudioSamplesToMedia( pSilenceBuf, bufferSize );
}
else
{
if ( forceFlush )
{
char n = nullchar;
AppendAudioSamplesToMedia( &n, 0 );
}
}
if ( forcePartialGroupFlush && m_srcAudioBufferCurrentSize >0 )
{
int nSamplesThisAdd = m_srcAudioBufferCurrentSize / m_AudioBytesPerSample;
TimeValue64 insertTime64 = 0;
OSErr status = AddMediaSample2( m_theAudioMedia, (const UInt8 *) m_srcAudioBuffer, (ByteCount) m_srcAudioBufferCurrentSize,
(TimeValue64) 1, (TimeValue64) 0, (SampleDescriptionHandle) m_srcSoundDescription,
(ItemCount) nSamplesThisAdd, 0, &insertTime64 );
AssertExitF( status == noErr );
m_srcAudioBufferCurrentSize = 0;
m_nSamplesAddedToMedia+= nSamplesThisAdd;
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "FORCED FLUSH - Audio Samples added to media. %d added, %d total samples, inserted at time %ld\n", nSamplesThisAdd, m_nSamplesAddedToMedia, insertTime64 );
#endif
}
audio_complete:
return true;
}
bool CQTVideoFileComposer::EndMovieCreation( bool saveMovieData )
{
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "\nEndMovieCreation Called Composing=%d Completed=%d\n\n", (int) m_bComposingMovie, (int) m_bMovieCompleted );
#endif
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( m_bComposingMovie && !m_bMovieCompleted );
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "\nEndMovieCreation Called\n\n" );
#endif
// Stop adding to and (optionally) save the video media into the file
SetResult( VideoResult::VIDEO_ERROR_OCCURED );
if ( m_nFramesAdded > 0 )
{
TimeValue VideoDuration = GetMediaDuration( m_theVideoMedia );
AssertExitF( VideoDuration == m_nFramesAdded * m_DurationPerFrame );
OSErr status = EndMediaEdits( m_theVideoMedia );
AssertExitF( status == noErr );
if ( saveMovieData )
{
status = InsertMediaIntoTrack( m_theVideoTrack, 0, 0, VideoDuration, fixed1 );
Assert( status == noErr );
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "\nVideo Media inserted into Track\n" );
#endif
}
}
// Stop adding to and (optionally) save the audio media into the file
SetResult( VideoResult::AUDIO_ERROR_OCCURED );
if ( m_bHasAudioTrack && m_nSamplesAdded > 0 )
{
// flush any remaining samples in the buffer to the media
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "Calling SyncAndFlushAudio()\n" );
#endif
SyncAndFlushAudio();
TimeValue AudioDuration = GetMediaDuration( m_theAudioMedia );
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "Audio Duration = %d nSamples Added = %d\n", AudioDuration, m_nSamplesAdded );
#endif
// AssertExitF( AudioDuration == m_nSamplesAdded );
OSErr status = EndMediaEdits( m_theAudioMedia );
AssertExitF( status == noErr );
if ( saveMovieData )
{
status = InsertMediaIntoTrack( m_theAudioTrack, 0, 0, AudioDuration, fixed1 );
AssertExitF( status == noErr );
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "\nAudio Media inserted into Track\n" );
#endif
}
}
if ( saveMovieData )
{
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "Saving Movie Data...\n" );
#endif
SetResult( VideoResult::FILE_ERROR_OCCURED );
OSErr status = AddMovieToStorage( m_theMovie, m_MovieFileDataHandler );
AssertExitF( status == noErr );
if ( status != noErr )
{
DataHDeleteFile( m_MovieFileDataHandler );
}
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "\nMovie Resource added to file. Returned Status = %d\n", (int) status );
#endif
}
// free our resources
if ( m_MovieFileDataHandler != nullptr )
{
OSErr status = CloseMovieStorage( m_MovieFileDataHandler );
m_MovieFileDataHandler = nullptr;
AssertExitF( status == noErr );
}
SAFE_DISPOSE_HANDLE( m_MovieFileDataRef );
SAFE_DISPOSE_HANDLE( m_SrcImageCompressedBuffer );
SAFE_DISPOSE_GWORLD( m_theSrcGWorld );
SAFE_DISPOSE_HANDLE( m_srcSoundDescription );
SetResult( VideoResult::SUCCESS );
m_bComposingMovie = false;
return true;
}
// The movie can be aborted at any time before completion
bool CQTVideoFileComposer::AbortMovie()
{
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( !m_bMovieCompleted );
// Shut down the movie if we are recording
if ( m_bComposingMovie )
{
if ( !EndMovieCreation( false ) )
{
return false;
}
}
if ( m_bMovieCreated )
{
if ( m_MovieFileDataHandler != nullptr )
{
SetResult( VideoResult::FILE_ERROR_OCCURED );
OSErr status = CloseMovieStorage( m_MovieFileDataHandler );
AssertExitF( status == noErr );
m_MovieFileDataHandler = nullptr;
}
SAFE_DISPOSE_HANDLE( m_MovieFileDataRef );
SAFE_DISPOSE_MOVIE( m_theMovie );
}
if ( m_FileName )
{
g_pFullFileSystem->RemoveFile( m_FileName );
}
SetResult( VideoResult::SUCCESS );
m_bMovieCompleted = true;
return true;
}
bool CQTVideoFileComposer::FinishMovie( bool SaveMovieToDisk )
{
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "\nFinish Movie Called\n" );
#endif
SetResult( VideoResult::OPERATION_OUT_OF_SEQUENCE );
AssertExitF( m_bComposingMovie && !m_bMovieCompleted );
// Shutdown movie creation
if ( !EndMovieCreation( SaveMovieToDisk ) )
{
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "\nEndMovieCreation Aborted\n" );
#endif
return false;
}
// todo: check on Disposing of theMovie and theMedia
if ( m_MovieFileDataHandler != nullptr )
{
SetResult( VideoResult::FILE_ERROR_OCCURED );
OSErr status = CloseMovieStorage( m_MovieFileDataHandler );
AssertExitF( status == noErr );
m_MovieFileDataHandler = nullptr;
#ifdef LOG_ENCODER_OPERATIONS
LogMsg( "Movie File Closed\n" );
#endif
}
SAFE_DISPOSE_HANDLE( m_MovieFileDataRef );
SAFE_DISPOSE_MOVIE( m_theMovie );
// if no frames have been added.. delete files
if ( SaveMovieToDisk == false || ( m_nFramesAdded <= 0 && m_nSamplesAdded <= 0) )
{
g_pFullFileSystem->RemoveFile( m_FileName );
}
SetResult( VideoResult::SUCCESS );
m_bMovieCompleted = true;
#ifdef LOG_ENCODER_OPERATIONS
g_pFullFileSystem->Close( m_LogFile );
m_LogFile = FILESYSTEM_INVALID_HANDLE;
#endif
return true;
}
void CQTVideoFileComposer::SetResult( VideoResult_t status )
{
m_LastResult = status;
}
VideoResult_t CQTVideoFileComposer::GetResult()
{
return m_LastResult;
}
bool CQTVideoFileComposer::IsReadyToRecord()
{
return ( m_bComposingMovie && !m_bMovieCompleted );
}
#ifdef ENABLE_EXTERNAL_ENCODER_LOGGING
bool CQTVideoFileComposer::LogMessage( const char *msg )
{
#ifdef LOG_ENCODER_OPERATIONS
if ( IS_NOT_EMPTY(msg) && m_LogFile != FILESYSTEM_INVALID_HANDLE )
{
g_pFullFileSystem->Write( msg, V_strlen( msg ), m_LogFile );
}
#endif
return true;
}
#endif