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

2146 lines
63 KiB
Raw Blame History

//========= 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