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