text: //========= Copyright Valve Corporation, All rights reserved. ============//
  //
  //=======================================================================================//
  
  #include "cbase.h"
  
  #if defined( REPLAY_ENABLED )
  
  #include "replaybrowserrenderdialog.h"
  #include "vgui_controls/TextImage.h"
  #include "vgui_controls/CheckButton.h"
  #include "vgui_controls/TextEntry.h"
  #include "vgui/IInput.h"
  #include "replay/genericclassbased_replay.h"
  #include "ienginevgui.h"
  #include "replayrenderoverlay.h"
  #include "replay/ireplaymanager.h"
  #include "replay/ireplaymoviemanager.h"
  #include "video/ivideoservices.h"
  #include "confirm_dialog.h"
  #include "replay/replayrenderer.h"
  
  #include "replay/performance.h"
  #include "replay/replayvideo.h"
  #include "replay_gamestats_shared.h"
  
  #include "econ/econ_controls.h"
  
  // memdbgon must be the last include file in a .cpp file!!!
  #include <tier0/memdbgon.h>
  
  //-----------------------------------------------------------------------------
  
  extern IReplayMovieManager *g_pReplayMovieManager;
  
  //-----------------------------------------------------------------------------
  
  ConVar replay_rendersetting_quitwhendone( "replay_rendersetting_quitwhendone", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD, "Quit after rendering is completed.", true, 0.0f, true, 1.0f );
  ConVar replay_rendersetting_exportraw( "replay_rendersetting_exportraw", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD | FCVAR_ARCHIVE, "Export raw TGA frames and a .wav file, instead of encoding a movie file.", true, 0.0f, true, 1.0f );
  ConVar replay_rendersetting_motionblurquality( "replay_rendersetting_motionblurquality", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD, "Motion blur quality.", true, 0, true, MAX_MOTION_BLUR_QUALITY );
  ConVar replay_rendersetting_motionblurenabled( "replay_rendersetting_motionblurenabled", "1", FCVAR_CLIENTDLL | FCVAR_DONTRECORD, "Motion blur enabled/disabled.", true, 0.0f, true, 1.0f );
  ConVar replay_rendersetting_encodingquality( "replay_rendersetting_encodingquality", "100", FCVAR_CLIENTDLL | FCVAR_DONTRECORD, "Render quality: the higher the quality, the larger the resulting movie file size.", true, 0, true, 100 );
  ConVar replay_rendersetting_motionblur_can_toggle( "replay_rendersetting_motionblur_can_toggle", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD, "" );
  ConVar replay_rendersetting_renderglow( "replay_rendersetting_renderglow", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD | FCVAR_ARCHIVE, "Glow effect enabled/disabled.", true, 0.0f, true, 1.0f );
  
  //-----------------------------------------------------------------------------
  
  CReplayRenderDialog::CReplayRenderDialog( Panel *pParent, ReplayHandle_t hReplay, bool bSetQuit, int iPerformance )
  :	BaseClass( pParent, "RenderDialog" ),
  	m_bShowAdvancedOptions( false ),
  	m_hReplay( hReplay ),
  	m_bSetQuit( bSetQuit ),
  	m_iPerformance( iPerformance ),
  	m_pVideoModesCombo( NULL ),
  	m_pCodecCombo( NULL ),
  	m_pPlayVoiceCheck( NULL ),
  	m_pShowAdvancedOptionsCheck( NULL ),
  	m_pQuitWhenDoneCheck( NULL ),
  	m_pExportRawCheck( NULL ),
  	m_pTitleText( NULL ),
  	m_pResolutionNoteLabel( NULL ),
  	m_pEnterANameLabel( NULL ),
  	m_pVideoModeLabel( NULL ),
  	m_pCodecLabel( NULL ),
  	m_pMotionBlurLabel( NULL ),
  	m_pMotionBlurSlider( NULL ),
  	m_pQualityLabel( NULL ),
  	m_pQualitySlider( NULL ),
  	m_pTitleLabel( NULL ),
  	m_pCancelButton( NULL ),
  	m_pRenderButton( NULL ),
  	m_pBgPanel( NULL ),
  	m_pMotionBlurCheck( NULL ),
  	m_pQualityPresetLabel( NULL ),
  	m_pQualityPresetCombo( NULL ),
  	m_pSeparator( NULL ),
  	m_pGlowEnabledCheck( NULL )
  {
  	m_iQualityPreset = ReplayVideo_GetDefaultQualityPreset();
  }
  
  void CReplayRenderDialog::UpdateControlsValues()
  {
  	ConVarRef replay_voice_during_playback( "replay_voice_during_playback" );
  
  	m_pQuitWhenDoneCheck->SetSelected( replay_rendersetting_quitwhendone.GetBool() );
  	m_pExportRawCheck->SetSelected( replay_rendersetting_exportraw.GetBool() );
  	m_pShowAdvancedOptionsCheck->SetSelected( m_bShowAdvancedOptions );
  	m_pMotionBlurSlider->SetValue( replay_rendersetting_motionblurquality.GetInt() );
  	m_pMotionBlurCheck->SetSelected( replay_rendersetting_motionblurenabled.GetBool() );
  	m_pQualitySlider->SetValue( replay_rendersetting_encodingquality.GetInt() / ReplayVideo_GetQualityInterval() );
  
  	if ( m_pGlowEnabledCheck )
  	{
  		m_pGlowEnabledCheck->SetSelected( replay_rendersetting_renderglow.GetBool() );
  	}
  
  	if ( replay_voice_during_playback.IsValid() )
  	{
  		m_pPlayVoiceCheck->SetSelected( replay_voice_during_playback.GetBool() );
  	}
  	else
  	{
  		m_pPlayVoiceCheck->SetEnabled( false );
  	}
  }
  
  void CReplayRenderDialog::AddControlToAutoLayout( Panel *pPanel, bool bAdvanced )
  {
  	LayoutInfo_t *pNewLayoutInfo = new LayoutInfo_t;
  	pNewLayoutInfo->pPanel = pPanel;
  
  	// Use the positions from the .res file as relative positions for auto-layout
  	pPanel->GetPos( pNewLayoutInfo->nOffsetX, pNewLayoutInfo->nOffsetY );
  	
  	pNewLayoutInfo->bAdvanced = bAdvanced;
  
  	// Add to the list
  	m_lstControls.AddToTail( pNewLayoutInfo );
  }
  
  void CReplayRenderDialog::SetValuesFromQualityPreset()
  {
  	const ReplayQualityPreset_t &preset = ReplayVideo_GetQualityPreset( m_iQualityPreset );
  	replay_rendersetting_motionblurquality.SetValue( preset.m_iMotionBlurQuality );
  	replay_rendersetting_motionblurenabled.SetValue( (int)preset.m_bMotionBlurEnabled );
  	replay_rendersetting_encodingquality.SetValue( preset.m_iQuality );
  	for ( int i = 0; i < ReplayVideo_GetCodecCount(); ++i )
  	{
  		const ReplayCodec_t &CurCodec = ReplayVideo_GetCodec( i );
  		if ( CurCodec.m_nCodecId == preset.m_nCodecId )
  		{
  			m_pCodecCombo->ActivateItem( m_pCodecCombo->GetItemIDFromRow( i ) );
  			break;
  		}
  	}
  	UpdateControlsValues();
  	InvalidateLayout();
  }
  
  void CReplayRenderDialog::ApplySchemeSettings( vgui::IScheme *pScheme )
  {
  	int i;
  
  	// Link in TF scheme
  	extern IEngineVGui *enginevgui;
  	vgui::HScheme pTFScheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ClientScheme.res", "ClientScheme" );
  	SetScheme( pTFScheme );
  	SetProportional( true );
  
  	BaseClass::ApplySchemeSettings( vgui::scheme()->GetIScheme( pTFScheme ) );
  
  	LoadControlSettings( "resource/ui/replaybrowser/renderdialog.res", "GAME" );
  
  	// retrieve controls
  	m_pPlayVoiceCheck = dynamic_cast< CheckButton * >( FindChildByName( "PlayVoice" ) );
  	m_pShowAdvancedOptionsCheck = dynamic_cast< CheckButton * >( FindChildByName( "ShowAdvancedOptions" ) );
  	m_pQuitWhenDoneCheck = dynamic_cast< CheckButton * >( FindChildByName( "QuitWhenDone" ) );
  	m_pExportRawCheck = dynamic_cast< CheckButton * >( FindChildByName( "ExportRaw" ) );
  	m_pTitleText = dynamic_cast< TextEntry * >( FindChildByName( "TitleInput" ) );
  	m_pResolutionNoteLabel = dynamic_cast< CExLabel * >( FindChildByName( "ResolutionNoteLabel" ) );
  	m_pEnterANameLabel = dynamic_cast< CExLabel * >( FindChildByName( "EnterANameLabel" ) );
  	m_pVideoModeLabel = dynamic_cast< CExLabel * >( FindChildByName( "VideoModeLabel" ) );
  	m_pCodecLabel = dynamic_cast< CExLabel * >( FindChildByName( "CodecLabel" ) );
  	m_pMotionBlurLabel = dynamic_cast< CExLabel * >( FindChildByName( "MotionBlurLabel" ) );
  	m_pMotionBlurSlider = dynamic_cast< Slider * >( FindChildByName( "MotionBlurSlider" ) );
  	m_pQualityLabel = dynamic_cast< CExLabel * >( FindChildByName( "QualityLabel" ) );
  	m_pQualitySlider = dynamic_cast< Slider * >( FindChildByName( "QualitySlider" ) );
  	m_pTitleLabel = dynamic_cast< CExLabel * >( FindChildByName( "TitleLabel" ) );
  	m_pRenderButton = dynamic_cast< CExButton * >( FindChildByName( "RenderButton" ) );
  	m_pCancelButton = dynamic_cast< CExButton * >( FindChildByName( "CancelButton" ) );
  	m_pBgPanel = dynamic_cast< EditablePanel * >( FindChildByName( "BGPanel" ) );
  	m_pMotionBlurCheck = dynamic_cast< CheckButton * >( FindChildByName( "MotionBlurEnabled" ) );
  	m_pQualityPresetLabel = dynamic_cast< CExLabel * >( FindChildByName( "QualityPresetLabel" ) );
  	m_pQualityPresetCombo = dynamic_cast< vgui::ComboBox * >( FindChildByName( "QualityPresetCombo" ) );
  	m_pCodecCombo = dynamic_cast< vgui::ComboBox * >( FindChildByName( "CodecCombo" ) );
  	m_pVideoModesCombo = dynamic_cast< vgui::ComboBox * >( FindChildByName( "VideoModeCombo" ) );
  	m_pEstimateTimeLabel = dynamic_cast< CExLabel * >( FindChildByName( "EstimateTimeLabel" ) );
  	m_pEstimateFileLabel = dynamic_cast< CExLabel * >( FindChildByName( "EstimateFileLabel" ) );
  	m_pSeparator = FindChildByName( "SeparatorLine" );
  	m_pGlowEnabledCheck = dynamic_cast< CheckButton * >( FindChildByName( "GlowEnabled" ) );
  	m_pLockWarningLabel = dynamic_cast< CExLabel * >( FindChildByName( "LockWarningLabel" ) );
  
  #if defined( TF_CLIENT_DLL )
  	if ( m_pBgPanel )
  	{
  		m_pBgPanel->SetPaintBackgroundType( 2 );	// Rounded.
  	}
  #endif
  
  	AddControlToAutoLayout( m_pTitleLabel, false );
  
  	// The replay may be REPLAY_HANDLE_INVALID in the case that we are about to render all unrendered replays
  	if ( m_hReplay != REPLAY_HANDLE_INVALID )
  	{
  		CGenericClassBasedReplay *pReplay = GetGenericClassBasedReplay( m_hReplay );
  		m_pTitleText->SetText( pReplay->m_wszTitle );
  		m_pTitleText->SetVisible( true );
  		m_pTitleLabel->SetText( "#Replay_RenderReplay" );
  		m_pEnterANameLabel->SetVisible( true );
  
  		AddControlToAutoLayout( m_pEnterANameLabel, false );
  	}
  	else
  	{
  		m_pTitleLabel->SetText( "#Replay_RenderReplays" );
  	}
  
  	m_pTitleText->SelectAllOnFocusAlways( true );
  
  	AddControlToAutoLayout( m_pTitleText, false );
  
  	// Update controls based on preset
  	SetValuesFromQualityPreset();
  
  	// Set quit button if necessary
  	if ( m_bSetQuit )
  	{
  		m_pQuitWhenDoneCheck->SetSelected( true );
  	}
  
  	m_pPlayVoiceCheck->SetProportional( false );
  	m_pQuitWhenDoneCheck->SetProportional( false );
  	m_pShowAdvancedOptionsCheck->SetProportional( false );
  	m_pMotionBlurCheck->SetProportional( false );
  	m_pMotionBlurSlider->InvalidateLayout( false, true );	// Without this, the range labels show up with "..." because of an invalid font in TextImage::ApplySchemeSettings().
  	m_pExportRawCheck->SetProportional( false );
  	m_pQualitySlider->InvalidateLayout( false, true );	// Without this, the range labels show up with "..." because of an invalid font in TextImage::ApplySchemeSettings().
  
  	if ( m_pGlowEnabledCheck )
  	{
  		m_pGlowEnabledCheck->SetProportional( false );
  	}
  
  	// Fill in combo box with preset quality levels
  	const int nQualityPresetCount = ReplayVideo_GetQualityPresetCount();
  	m_pQualityPresetCombo->SetNumberOfEditLines( nQualityPresetCount );
  	for ( i = 0; i < nQualityPresetCount; ++i )
  	{
  		const ReplayQualityPreset_t &CurQualityPreset = ReplayVideo_GetQualityPreset( i );
  		m_pQualityPresetCombo->AddItem( CurQualityPreset.m_pName, NULL );
  		m_pQualityPresetCombo->SetItemEnabled( i, true );
  	}
  	m_pQualityPresetCombo->ActivateItem( m_pQualityPresetCombo->GetItemIDFromRow( m_iQualityPreset ) );
  
  	// Fill in combo box with video modes
  	int nScreenW = ScreenWidth();
  	int nScreenH = ScreenHeight();
  	const int nVidModeCount = ReplayVideo_GetVideoModeCount();
  	m_pVideoModesCombo->SetNumberOfEditLines( nVidModeCount );
  	bool bAtLeastOneVideoModeAdded = false;
  	bool bEnable = false;
  	bool bSkipped = false;
  	
  	for ( i = 0; i < nVidModeCount; ++i )
  	{
  		// Only offer display modes less than the current window size
  		const ReplayVideoMode_t	&CurVideoMode = ReplayVideo_GetVideoMode( i );
  
  		int nMw = CurVideoMode.m_nWidth;
  		int nMh = CurVideoMode.m_nHeight;
  
  		// Only display modes that fit in the current window
  		bEnable =  ( nMw <= nScreenW && nMh <= nScreenH );
  		if (!bEnable)
  			bSkipped = true;
  		
  		m_pVideoModesCombo->AddItem( CurVideoMode.m_pName, NULL );
  		m_pVideoModesCombo->SetItemEnabled( i, bEnable );
  
  		if (bEnable)
  			bAtLeastOneVideoModeAdded = true;
  	}
  	if ( bAtLeastOneVideoModeAdded )
  	{
  		m_pVideoModesCombo->ActivateItem( m_pVideoModesCombo->GetItemIDFromRow( 0 ) );
  	}
  
  	// fill in the combo box with codecs
  	const int nNumCodecs = ReplayVideo_GetCodecCount();
  	m_pCodecCombo->SetNumberOfEditLines( nNumCodecs );
  	for ( i = 0; i < nNumCodecs; ++i )
  	{
  		const ReplayCodec_t &CurCodec = ReplayVideo_GetCodec( i );
  		m_pCodecCombo->AddItem( CurCodec.m_pName, NULL );
  		m_pCodecCombo->SetItemEnabled( i, true );
  	}
  	m_pCodecCombo->ActivateItem( m_pCodecCombo->GetItemIDFromRow( 0 ) );
  
  	// now layout
  
  	// simplified options
  	AddControlToAutoLayout( m_pVideoModeLabel, false );
  	AddControlToAutoLayout( m_pVideoModesCombo, false );
  	// Show the note about "not all resolutions are available?"
  	if ( bSkipped && m_pResolutionNoteLabel )
  	{
  		m_pResolutionNoteLabel->SetVisible( true );
  		AddControlToAutoLayout( m_pResolutionNoteLabel, false );
  	}
  	// other simplified options
  	AddControlToAutoLayout( m_pQualityPresetLabel, false );
  	AddControlToAutoLayout( m_pQualityPresetCombo, false );
  	AddControlToAutoLayout( m_pEstimateTimeLabel, false );
  	AddControlToAutoLayout( m_pEstimateFileLabel, false );
  	AddControlToAutoLayout( m_pPlayVoiceCheck, false );
  	AddControlToAutoLayout( m_pShowAdvancedOptionsCheck, false );
  	AddControlToAutoLayout( m_pQuitWhenDoneCheck, false );
  
  	AddControlToAutoLayout( m_pLockWarningLabel, false );
  
  	// now advanced options
  	AddControlToAutoLayout( m_pSeparator, true );
  
  	AddControlToAutoLayout( m_pCodecLabel, true );
  	AddControlToAutoLayout( m_pCodecCombo, true );
  
  	if ( replay_rendersetting_motionblur_can_toggle.GetBool() )
  	{
  		AddControlToAutoLayout( m_pMotionBlurCheck, true );
  	}
  	else
  	{
  		m_pMotionBlurCheck->SetVisible( false );
  	}
  	AddControlToAutoLayout( m_pMotionBlurLabel, true );
  	AddControlToAutoLayout( m_pMotionBlurSlider, true );
  
  	AddControlToAutoLayout( m_pQualityLabel, true );
  	AddControlToAutoLayout( m_pQualitySlider, true );
  
  	AddControlToAutoLayout( m_pExportRawCheck, true );
  
  	if ( m_pGlowEnabledCheck )
  	{
  		AddControlToAutoLayout( m_pGlowEnabledCheck, true );
  	}
  
  	// these buttons always show up
  	AddControlToAutoLayout( m_pRenderButton, false );
  	AddControlToAutoLayout( m_pCancelButton, false );
  }
  
  void CReplayRenderDialog::PerformLayout()
  {
  	BaseClass::PerformLayout();
  
  	m_pResolutionNoteLabel->SizeToContents();	// Get the proper height
  
  	int nY = m_nStartY;
  	Panel *pPrevPanel = NULL;
  	int nLastCtrlHeight = 0;
  
  	FOR_EACH_LL( m_lstControls, i )
  	{
  		LayoutInfo_t *pLayoutInfo = m_lstControls[ i ];
  		Panel *pPanel = pLayoutInfo->pPanel;
  
  		// should an advanced option be shown?
  		if ( pLayoutInfo->bAdvanced )
  		{
  			if ( pPanel->IsVisible() != m_bShowAdvancedOptions )
  			{
  				pPanel->SetVisible( m_bShowAdvancedOptions );
  			}
  		}
  
  		if ( !pPanel->IsVisible() )
  			continue;
  
  		if ( pPrevPanel && pLayoutInfo->nOffsetY >= 0 )
  		{
  			nY += pPrevPanel->GetTall() + pLayoutInfo->nOffsetY + m_nVerticalBuffer;
  		}
  
  		pPanel->SetPos( pLayoutInfo->nOffsetX ? pLayoutInfo->nOffsetX : m_nDefaultX, nY );
  
  		pPrevPanel = pPanel;
  		nLastCtrlHeight = pPanel->GetTall();
  	}
  
  	m_pBgPanel->SetTall( nY + nLastCtrlHeight + 2 * m_nVerticalBuffer );
  }
  
  void CReplayRenderDialog::Close()
  {
  	SetVisible( false );
  	MarkForDeletion();
  	TFModalStack()->PopModal( this );
  }
  
  void CReplayRenderDialog::OnCommand( const char *pCommand )
  {
  	if ( FStrEq( pCommand, "cancel" ) )
  	{
  		Close();
  	}
  	else if ( FStrEq( pCommand, "render" ) )
  	{
  		Close();
  		Render();
  	}
  	else
  	{
  		engine->ClientCmd( const_cast<char *>( pCommand ) );
  	}
  
  	BaseClass::OnCommand( pCommand );
  }
  
  void CReplayRenderDialog::Render()
  {
  	// Only complain about QuickTime if we aren't exporting raw TGA's/WAV
  	if ( !m_pExportRawCheck->IsSelected() )
  	{
  #ifndef USE_WEBM_FOR_REPLAY
  		if ( !g_pVideo || !g_pVideo->IsVideoSystemAvailable( VideoSystem::QUICKTIME ) )
  		{
  			ShowMessageBox( "#Replay_QuicktimeTitle", "#Replay_NeedQuicktime", "#GameUI_OK" );
  			return;
  		}
  		
  		if ( g_pVideo->GetVideoSystemStatus( VideoSystem::QUICKTIME ) != VideoSystemStatus::OK )
  		{
  			if ( g_pVideo->GetVideoSystemStatus( VideoSystem::QUICKTIME ) == VideoSystemStatus::NOT_CURRENT_VERSION )
  			{
  				ShowMessageBox( "#Replay_QuicktimeTitle", "#Replay_NeedQuicktimeNewer", "#GameUI_OK" );
  				return;	
  			}
  		
  			ShowMessageBox( "#Replay_QuicktimeTitle", "#Replay_Err_QT_FailedToLoad", "#GameUI_OK" );
  			return;
  		}
  #endif
  	}
  	
  	// Update convars from settings
  	const int nMotionBlurQuality = clamp( m_pMotionBlurSlider->GetValue(), 0, MAX_MOTION_BLUR_QUALITY );
  	replay_rendersetting_quitwhendone.SetValue( (int)m_pQuitWhenDoneCheck->IsSelected() );
  	replay_rendersetting_exportraw.SetValue( (int)m_pExportRawCheck->IsSelected() );
  	replay_rendersetting_motionblurquality.SetValue( nMotionBlurQuality );
  	replay_rendersetting_motionblurenabled.SetValue( replay_rendersetting_motionblur_can_toggle.GetBool() ? (int)m_pMotionBlurCheck->IsSelected() : 1 );
  	replay_rendersetting_encodingquality.SetValue( clamp( m_pQualitySlider->GetValue() * ReplayVideo_GetQualityInterval(), 0, 100 ) );
  
  	if ( m_pGlowEnabledCheck )
  	{
  		replay_rendersetting_renderglow.SetValue( m_pGlowEnabledCheck->IsSelected() );
  	}
  
  	ConVarRef replay_voice_during_playback( "replay_voice_during_playback" );
  	if ( replay_voice_during_playback.IsValid() && m_pPlayVoiceCheck->IsEnabled() )
  	{
  		replay_voice_during_playback.SetValue( (int)m_pPlayVoiceCheck->IsSelected() );
  	}
  
  	// Setup parameters for render
  	RenderMovieParams_t params;
  	params.m_hReplay = m_hReplay;
  	params.m_iPerformance = m_iPerformance;	// Use performance passed in from details panel
  	params.m_bQuitWhenFinished = m_pQuitWhenDoneCheck->IsSelected();
  	params.m_bExportRaw = m_pExportRawCheck->IsSelected();
  	m_pTitleText->GetText( params.m_wszTitle, sizeof( params.m_wszTitle ) );
  #ifdef USE_WEBM_FOR_REPLAY
  	V_strcpy( params.m_szExtension, ".webm" );	// Use .webm
  #else
  	V_strcpy( params.m_szExtension, ".mov" );	// Use .mov for Quicktime
  #endif
  
  	const int iRes = m_pVideoModesCombo->GetActiveItem();
  	const ReplayVideoMode_t &VideoMode = ReplayVideo_GetVideoMode( iRes );
  
  	params.m_Settings.m_bMotionBlurEnabled = replay_rendersetting_motionblurenabled.GetBool();
  	params.m_Settings.m_bAAEnabled = replay_rendersetting_motionblurenabled.GetBool();
  	params.m_Settings.m_nMotionBlurQuality = nMotionBlurQuality;
  	params.m_Settings.m_nWidth = VideoMode.m_nWidth;
  	params.m_Settings.m_nHeight = VideoMode.m_nHeight;
  	params.m_Settings.m_FPS.SetFPS( VideoMode.m_nBaseFPS, VideoMode.m_bNTSCRate );
  	params.m_Settings.m_Codec = ReplayVideo_GetCodec( m_pCodecCombo->GetActiveItem() ).m_nCodecId;
  	params.m_Settings.m_nEncodingQuality = replay_rendersetting_encodingquality.GetInt();
  	params.m_Settings.m_bRaw = m_pExportRawCheck->IsSelected();
  
  	// Calculate the framerate for the engine - for each engine frame, we need the # of motion blur timesteps,
  	// x 2, since the shutter is open for nNumMotionBlurTimeSteps and closed for nNumMotionBlurTimeSteps,
  	// with the engine frame centered in the shutter open state (ie when we're half way through the motion blur
  	// timesteps).  Antialiasing does not factor in here because it doesn't require extra frames - the AA jitter
  	// is interwoven in with the motion sub-frames.
  	const int nNumMotionBlurTimeSteps = ( params.m_Settings.m_bMotionBlurEnabled ) ? CReplayRenderer::GetNumMotionBlurTimeSteps( params.m_Settings.m_nMotionBlurQuality ) : 1;
  	
  	if ( params.m_Settings.m_bMotionBlurEnabled )
  	{
  	 	params.m_flEngineFps = 2 * nNumMotionBlurTimeSteps * params.m_Settings.m_FPS.GetFPS();
  	}
  	else
  	{
  		Assert( nNumMotionBlurTimeSteps == 1 );
  		params.m_flEngineFps = params.m_Settings.m_FPS.GetFPS();
  	}
  
  	// Close the browser
  	extern void ReplayUI_CloseReplayBrowser();
  	ReplayUI_CloseReplayBrowser();
  
  	// Hide the console
  	engine->ExecuteClientCmd( "hideconsole" );
  
  	// Stats tracking.
  	GetReplayGameStatsHelper().SW_ReplayStats_WriteRenderDataStart( params, this );
  
  	// Render the movie
  	g_pReplayMovieManager->RenderMovie( params );
  }
  
  void CReplayRenderDialog::OnKeyCodeTyped( vgui::KeyCode code )
  {
  	if( code == KEY_ENTER )
  	{
  		OnCommand( "render" );
  	}
  	else if ( code == KEY_ESCAPE )
  	{
  		MarkForDeletion();
  	}
  	else
  	{
  		BaseClass::OnKeyCodeTyped( code );
  	}
  }
  
  void CReplayRenderDialog::OnThink()
  {
  	if ( m_pEstimateTimeLabel == NULL || m_pEstimateFileLabel == NULL )
  		return;
  
  	// The replay may be NULL if this dialog is created by 'save all' from the quit confirmation dialog.  In this
  	// case, we don't want to a replay-specific time estimate anyway, so we can just early out here.
  	CGenericClassBasedReplay *pReplay = ToGenericClassBasedReplay( g_pReplayManager->GetReplay( m_hReplay) );
  	if ( !pReplay )
  		return;
  
  	const int nMotionBlurQuality = clamp( m_pMotionBlurSlider->GetValue(), 0, MAX_MOTION_BLUR_QUALITY );
  	const int nCodecQuality = clamp( m_pQualitySlider->GetValue(), 0, ReplayVideo_GetQualityRange() );
  	VideoEncodeCodec::EVideoEncodeCodec_t eCodec = ReplayVideo_GetCodec( m_pCodecCombo->GetActiveItem() ).m_nCodecId;
  
  	// fFrameSize is the scale factor based on the size of the rendered frame.  
  	const int iRes = m_pVideoModesCombo->GetActiveItem();
  	const ReplayVideoMode_t &VideoMode = ReplayVideo_GetVideoMode( iRes );
  	float fFrameSize = (float)(VideoMode.m_nWidth * VideoMode.m_nHeight)/(float)(640*480);
  	
  
  	float flEstimatedFileSize = 0;
  	float flEstimatedRenderTime_Min = 0;
  
  	static float mjpegToMotionBlurMultiplierTable[] = { 2.0f, 3.0f, 5.5f, 12.0f };
  	static float h264ToMotionBlurMultiplierTable[] = { 2.8f, 4.2f, 6.4f, 13.0f };
  	static float webmToMotionBlurMultiplierTable[] = { 2.8f, 4.2f, 6.4f, 13.0f };
  
  	static float mjpegToQualityMultiplierTable[] = { 620.0f, 736.0f, 1284.0f, 2115.0f, 3028.0f };
  	static float h264ToQualityMultiplierTable[] = { 276.0f, 384.0f, 595.0f, 1026.0f, 1873.0f };
  	static float webmToQualityMultiplierTable[] = { 125.0f, 250.0f, 312.0f, 673.0f, 1048.0f };
  
  	switch ( eCodec )
  	{
  	case VideoEncodeCodec::WEBM_CODEC:
  		flEstimatedFileSize			= pReplay->m_flLength * webmToQualityMultiplierTable[nCodecQuality]*fFrameSize;
  		flEstimatedRenderTime_Min	= pReplay->m_flLength * webmToMotionBlurMultiplierTable[nMotionBlurQuality];
  		break;
  	case VideoEncodeCodec::H264_CODEC:
  		flEstimatedFileSize			= pReplay->m_flLength * h264ToQualityMultiplierTable[nCodecQuality];
  		flEstimatedRenderTime_Min	= pReplay->m_flLength * h264ToMotionBlurMultiplierTable[nMotionBlurQuality];
  		break;
  	case VideoEncodeCodec::MJPEG_A_CODEC:
  		flEstimatedFileSize			= pReplay->m_flLength * mjpegToQualityMultiplierTable[nCodecQuality];
  		flEstimatedRenderTime_Min	= pReplay->m_flLength * mjpegToMotionBlurMultiplierTable[nMotionBlurQuality];
  		break;
  	}
  
  	float flEstimatedRenderTime_Max = flEstimatedRenderTime_Min * 3.0f;
  
  	// @todo Tom Bui: if this goes into hours, we are in trouble...
  	wchar_t wzFileSize[64];
  	_snwprintf( wzFileSize, ARRAYSIZE( wzFileSize ), L"%d", (int)flEstimatedFileSize );
  	wchar_t wzTimeMin[64];
  	wchar_t wzTimeMax[64];
  	g_pVGuiLocalize->ConvertANSIToUnicode( CReplayTime::FormatTimeString( flEstimatedRenderTime_Min ), wzTimeMin, sizeof( wzTimeMin ) );
  	g_pVGuiLocalize->ConvertANSIToUnicode( CReplayTime::FormatTimeString( flEstimatedRenderTime_Max ), wzTimeMax, sizeof( wzTimeMax ) );
  
  	wchar_t wzText[256] = L"";
  
  	g_pVGuiLocalize->ConstructString( wzText, sizeof( wzText ), g_pVGuiLocalize->Find( "#Replay_RenderEstimate_File" ), 1, 
  									  wzFileSize,
  									  wzTimeMin,
  									  wzTimeMax );
  	m_pEstimateFileLabel->SetText( wzText );
  
  	g_pVGuiLocalize->ConstructString( wzText, sizeof( wzText ), g_pVGuiLocalize->Find( "#Replay_RenderEstimate_Time" ), 2, 
  									  wzTimeMin,
  									  wzTimeMax );
  	m_pEstimateTimeLabel->SetText( wzText );
  }
  
  void CReplayRenderDialog::OnTextChanged( KeyValues *data )
  {
  	Panel *pPanel = reinterpret_cast<vgui::Panel *>( data->GetPtr("panel") );
  	vgui::ComboBox *pComboBox = dynamic_cast<vgui::ComboBox *>( pPanel );
  
  	if ( pComboBox == m_pQualityPresetCombo )
  	{
  		m_iQualityPreset = m_pQualityPresetCombo->GetActiveItem();
  		SetValuesFromQualityPreset();
  	}
  }
  
  void CReplayRenderDialog::OnCheckButtonChecked( vgui::Panel *panel )
  {
  	if ( panel == m_pShowAdvancedOptionsCheck )
  	{
  		m_bShowAdvancedOptions = m_pShowAdvancedOptionsCheck->IsSelected();
  		InvalidateLayout( true, false );
  	}
  }
  
  void CReplayRenderDialog::OnSetFocus()
  {
  	m_pTitleText->RequestFocus();
  }
  
  void ReplayUI_ShowRenderDialog( Panel* pParent, ReplayHandle_t hReplay, bool bSetQuit, int iPerformance )
  {
  	CReplayRenderDialog *pRenderDialog = vgui::SETUP_PANEL( new CReplayRenderDialog( pParent, hReplay, bSetQuit, iPerformance ) );
  
  	pRenderDialog->SetVisible( true );
  	pRenderDialog->MakePopup();
  	pRenderDialog->MoveToFront();
  	pRenderDialog->SetKeyBoardInputEnabled( true );
  	pRenderDialog->SetMouseInputEnabled( true );
  	TFModalStack()->PushModal( pRenderDialog );
  }
  
  #endif
  