wehub-resource-sync
723 lines
29 KiB
C#
723 lines
29 KiB
C#
#nullable enable
|
||
using System.IO;
|
||
using T3.Core.Animation;
|
||
using T3.Core.Audio;
|
||
using T3.Core.DataTypes;
|
||
using T3.Core.DataTypes.Vector;
|
||
using T3.Core.Utils;
|
||
using T3.Core.Video;
|
||
using T3.Editor.Gui.Interaction;
|
||
using T3.Editor.Gui.Interaction.Keyboard;
|
||
using T3.Editor.Gui.UiHelpers;
|
||
using T3.Editor.Gui.Windows.Layouts;
|
||
using T3.Editor.Gui.Windows.Output;
|
||
using T3.Editor.UiModel;
|
||
using T3.Editor.UiModel.ProjectHandling;
|
||
|
||
namespace T3.Editor.Gui.Windows.RenderExport;
|
||
|
||
internal static class RenderProcess
|
||
{
|
||
public static OutputWindow? OutputWindow;
|
||
public static Type? MainOutputType { get; private set; }
|
||
public static Texture2D? MainOutputTexture;
|
||
|
||
public static bool IsExporting => State == States.Exporting;
|
||
public static States State;
|
||
|
||
public enum States
|
||
{
|
||
Undefined,
|
||
NoOutputWindow,
|
||
NoValidOutputType,
|
||
NoValidOutputTexture,
|
||
ReadyForExport,
|
||
Exporting,
|
||
}
|
||
|
||
public static string LastHelpString { get; private set; } = string.Empty;
|
||
public static string LastTargetDirectory { get; private set; } = string.Empty;
|
||
|
||
/// <summary>Export progress in 0..1, or a negative value when the active export is open-ended
|
||
/// (<see cref="RenderSettings.TimeRanges.Continuous"/>) and has no determinate end — the footer shows an
|
||
/// activity indicator in that case.</summary>
|
||
public static double Progress => IsContinuousActive
|
||
? -1.0
|
||
: (_activeExportSession == null || _activeExportSession.FrameCount <= 1)
|
||
? 0.0
|
||
: (_activeExportSession.FrameIndex / (double)(_activeExportSession.FrameCount - 1));
|
||
|
||
/// <summary>True while an open-ended continuous capture is running.</summary>
|
||
public static bool IsContinuousActive
|
||
=> _activeExportSession is { Settings.TimeRange: RenderSettings.TimeRanges.Continuous };
|
||
|
||
/// <summary>Frames written so far by the active export (for the continuous-capture activity readout).</summary>
|
||
public static int CapturedFrameCount => _activeExportSession?.FrameIndex ?? 0;
|
||
|
||
/// <summary>Seconds since the active export began (0 when none is running).</summary>
|
||
public static double ExportElapsedSeconds
|
||
=> _activeExportSession == null ? 0.0 : Playback.RunTimeInSecs - _activeExportSession.ExportStartedTime;
|
||
|
||
#region main API methods
|
||
public static void TryRenderScreenShot()
|
||
{
|
||
if (MainOutputTexture == null) return;
|
||
|
||
var project = ProjectView.Focused?.OpenedProject;
|
||
if (project == null) return;
|
||
|
||
var projectFolder = project.Package.Folder;
|
||
var folder = Path.Combine(projectFolder, "Screenshots");
|
||
|
||
if (!Directory.Exists(folder))
|
||
Directory.CreateDirectory(folder);
|
||
|
||
var filename = Path.Join(folder, $"{DateTime.Now:yyyy_MM_dd-HH_mm_ss_fff}.png");
|
||
ScreenshotWriter.StartSavingToFile(RenderProcess.MainOutputTexture, filename, ScreenshotWriter.FileFormats.Png);
|
||
Log.Debug("Screenshot saved in: " + folder);
|
||
}
|
||
|
||
public static bool TryStartVideoExport()
|
||
{
|
||
if (MainOutputTexture == null || MainOutputTexture.IsDisposed)
|
||
return false;
|
||
|
||
var settings = RenderSettings.Current.Clone();
|
||
|
||
// Realtime continuous capture grabs the live output and doesn't take over playback, so there is no
|
||
// synced audio path yet — keep the writer audio-free regardless of the (greyed) checkbox.
|
||
if (settings.TimeRange == RenderSettings.TimeRanges.Continuous
|
||
&& settings.ContinuousClock == RenderSettings.ContinuousCaptureClock.Realtime)
|
||
{
|
||
settings.ExportAudio = false;
|
||
settings.ResolutionFactor = 1f; // realtime grabs the live texture as-is — capture at native size
|
||
}
|
||
|
||
if (State != States.ReadyForExport)
|
||
{
|
||
Log.Warning("Export not available");
|
||
return false;
|
||
}
|
||
|
||
var targetFilePath = GetTargetFilePath(settings.RenderMode);
|
||
|
||
var directory = string.Empty;
|
||
try
|
||
{
|
||
directory = Path.GetDirectoryName(targetFilePath) ?? string.Empty;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Log.Warning($"Can't get directory for path: {targetFilePath}:" + e.Message);
|
||
}
|
||
|
||
if (!RenderPaths.ValidateOrCreateTargetFolder(targetFilePath))
|
||
return false;
|
||
|
||
TryGetRenderResolution(settings, out var requestedResolution);
|
||
|
||
var newSession = new ExportSession
|
||
{
|
||
Settings = settings,
|
||
FrameCount = RenderTiming.ComputeFrameCount(settings),
|
||
ExportStartedTime = Playback.RunTimeInSecs,
|
||
FrameIndex = 0,
|
||
RenderToFileResolution = requestedResolution,
|
||
TargetFilePath = targetFilePath,
|
||
TargetDirectory = directory,
|
||
};
|
||
|
||
switch (newSession.Settings.RenderMode)
|
||
{
|
||
case RenderSettings.RenderModes.Video:
|
||
if (File.Exists(targetFilePath))
|
||
{
|
||
try
|
||
{
|
||
File.Delete(targetFilePath);
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Log.Warning($"Can't write {targetFilePath}:" + e.Message);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
Log.Gated.VideoRender($"""
|
||
Initializing video export with: path={targetFilePath}
|
||
renderedSize={newSession.RenderToFileResolution.Width}x{newSession.RenderToFileResolution.Height}
|
||
bitrate={settings.Bitrate}
|
||
framerate={settings.FrameRate}
|
||
audio={settings.ExportAudio}
|
||
channels={RenderAudioInfo.SoundtrackChannels()}
|
||
sampleRate={RenderAudioInfo.SoundtrackSampleRate()}
|
||
""");
|
||
break;
|
||
|
||
case RenderSettings.RenderModes.ImageSequence:
|
||
default:
|
||
|
||
ScreenshotWriter.ClearQueue();
|
||
break;
|
||
}
|
||
|
||
LastTargetDirectory = Path.GetDirectoryName(targetFilePath) ?? string.Empty;
|
||
|
||
State = States.Exporting;
|
||
|
||
LastHelpString = "Rendering...";
|
||
_activeExportSession = newSession;
|
||
return true;
|
||
}
|
||
|
||
public static void Cancel(string? reason = null)
|
||
{
|
||
if (_activeExportSession == null)
|
||
{
|
||
State = States.Undefined;
|
||
return;
|
||
}
|
||
|
||
var duration = Playback.RunTimeInSecs - _activeExportSession.ExportStartedTime;
|
||
LastHelpString = reason ?? $"Render cancelled after {StringUtils.HumanReadableDurationFromSeconds(duration)}";
|
||
CleanupSession();
|
||
}
|
||
|
||
/// <summary>Finalizes an open-ended continuous capture as a success — the file is muxed and kept, and the
|
||
/// version auto-increments like a normal render. (Unlike <see cref="Cancel"/>, which reads as discarded.)</summary>
|
||
public static void StopContinuous()
|
||
{
|
||
if (_activeExportSession == null)
|
||
{
|
||
State = States.Undefined;
|
||
return;
|
||
}
|
||
|
||
var session = _activeExportSession;
|
||
var settings = session.Settings;
|
||
var duration = Playback.RunTimeInSecs - session.ExportStartedTime;
|
||
LastHelpString = $"Captured {session.FrameIndex} frames ({StringUtils.HumanReadableDurationFromSeconds(duration)}) "
|
||
+ $"to {GetTargetFilePath(settings.RenderMode)}";
|
||
Log.Debug(LastHelpString);
|
||
|
||
if (settings.RenderMode == RenderSettings.RenderModes.Video && settings.AutoIncrementVersionNumber)
|
||
{
|
||
RenderPaths.TryIncrementVideoFileName();
|
||
ProjectView.Focused?.CompositionInstance?.Symbol.GetSymbolUi()?.FlagAsModified();
|
||
}
|
||
|
||
CleanupSession();
|
||
}
|
||
#endregion
|
||
|
||
private static bool TryInitVideoWriterWithFinalResolution(ExportSession session)
|
||
{
|
||
try
|
||
{
|
||
var codec = session.Settings.VideoCodec;
|
||
if (VideoEncoderAvailabilityCache.GetBlocking(codec).Kind == VideoEncoderKind.Unavailable)
|
||
{
|
||
LastHelpString = $"Can't render {codec}: this FFmpeg build has no encoder for it.";
|
||
Log.Warning(LastHelpString);
|
||
CleanupSession();
|
||
return false;
|
||
}
|
||
|
||
if (FfmpegVideoExportWriter.TryCreate(session, out var ffmpegError) is not { } ffmpegWriter)
|
||
{
|
||
LastHelpString = "Can't render: the FFmpeg video encoder is unavailable. " + ffmpegError;
|
||
Log.Error(LastHelpString);
|
||
CleanupSession();
|
||
return false;
|
||
}
|
||
|
||
session.VideoWriter = ffmpegWriter;
|
||
Log.Debug("Render-export: using the FFmpeg encoder.");
|
||
|
||
Log.Gated.VideoRender($"FFmpeg video writer initialized: " +
|
||
$"Codec={session.Settings.VideoCodec} " +
|
||
$"Bitrate={session.Settings.Bitrate} " +
|
||
$"Framerate={session.Settings.FrameRate} " +
|
||
$"Channels={RenderAudioInfo.SoundtrackChannels()} " +
|
||
$"SampleRate={RenderAudioInfo.SoundtrackSampleRate()}");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var msg = $"Failed to initialize the FFmpeg video writer: {ex.Message}\n{ex.StackTrace}";
|
||
Log.Error(msg);
|
||
LastHelpString = msg;
|
||
CleanupSession();
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Needs to be called once per frame
|
||
/// </summary>
|
||
public static void Update()
|
||
{
|
||
if (OutputWindow.TryGetPrimaryOutputWindow(out OutputWindow))
|
||
{
|
||
MainOutputTexture = OutputWindow.GetCurrentTexture();
|
||
MainOutputType = OutputWindow.ShownInstance?.Outputs.FirstOrDefault()?.ValueType;
|
||
}
|
||
else if (LayoutHandling.FocusMode && ProjectView.Focused?.GraphImageBackground is { IsActive: true } background)
|
||
{
|
||
// In focus mode the output window is hidden and the output renders into the graph background,
|
||
// so source the texture from there to keep render shortcuts working.
|
||
OutputWindow = null;
|
||
MainOutputTexture = background.GetCurrentTexture();
|
||
MainOutputType = background.OutputInstance?.Outputs.FirstOrDefault()?.ValueType;
|
||
}
|
||
else
|
||
{
|
||
State = States.NoOutputWindow;
|
||
return;
|
||
}
|
||
|
||
if (MainOutputTexture == null || MainOutputTexture.IsDisposed)
|
||
{
|
||
State = States.NoValidOutputTexture;
|
||
return;
|
||
}
|
||
|
||
if (MainOutputType != typeof(Texture2D))
|
||
{
|
||
State = States.NoValidOutputType;
|
||
return;
|
||
}
|
||
|
||
if (State != States.Exporting)
|
||
{
|
||
State = States.ReadyForExport;
|
||
}
|
||
|
||
HandleRenderShortCuts();
|
||
|
||
if (!IsExporting)
|
||
return;
|
||
|
||
if (_activeExportSession == null)
|
||
{
|
||
Log.Warning("Reverting inconsistent render export state");
|
||
State = States.Undefined;
|
||
return;
|
||
}
|
||
|
||
ExportOutputTexture(MainOutputTexture, _activeExportSession);
|
||
}
|
||
|
||
private static void ExportOutputTexture(Texture2D mainOutputTexture, ExportSession session)
|
||
{
|
||
var settings = session.Settings;
|
||
var savingSuccessful = false;
|
||
|
||
// Ensure resolution is valid
|
||
var currentResolution = new Int2(mainOutputTexture.Description.Width, mainOutputTexture.Description.Height);
|
||
var resolutionMatches = currentResolution == session.RenderToFileResolution;
|
||
|
||
if (!resolutionMatches)
|
||
{
|
||
if (++session.ResolutionMismatchCount < 2)
|
||
{
|
||
Log.Debug($"Waiting for resolution {session.RenderToFileResolution.ToResolutionString()}...");
|
||
return;
|
||
}
|
||
|
||
Log.Debug("Falling back to " + currentResolution.ToResolutionString());
|
||
session.RenderToFileResolution = currentResolution;
|
||
}
|
||
|
||
if (session.VideoWriter == null)
|
||
{
|
||
if (!TryInitVideoWriterWithFinalResolution(session))
|
||
return;
|
||
}
|
||
|
||
var isRealtimeContinuous = settings.TimeRange == RenderSettings.TimeRanges.Continuous
|
||
&& settings.ContinuousClock == RenderSettings.ContinuousCaptureClock.Realtime;
|
||
|
||
if (isRealtimeContinuous)
|
||
{
|
||
// Grab the live output without taking over playback, paced to the target FPS.
|
||
savingSuccessful = WriteRealtimeContinuousFrames(session, mainOutputTexture);
|
||
}
|
||
else
|
||
{
|
||
switch (settings.RenderMode)
|
||
{
|
||
case RenderSettings.RenderModes.Video:
|
||
{
|
||
var audioFrame = ComputeAudioBufferForVideoFrame(session);
|
||
savingSuccessful = SaveVideoFrameAndAdvance(session, mainOutputTexture, ref audioFrame, RenderAudioInfo.SoundtrackChannels(),
|
||
RenderAudioInfo.SoundtrackSampleRate());
|
||
break;
|
||
}
|
||
case RenderSettings.RenderModes.ImageSequence:
|
||
// Process audio for this frame to drive animations
|
||
var audioFrameFloat = AudioRendering.GetFullMixDownBuffer(1.0 / session.Settings.FrameRate);
|
||
|
||
// Update audio metering for UI/graph
|
||
double localFxTime = session.FrameIndex / session.Settings.FrameRate;
|
||
AudioRendering.EvaluateAllAudioMeteringOutputs(localFxTime, audioFrameFloat);
|
||
savingSuccessful = TrySaveImageFrameAndAdvance(mainOutputTexture);
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Open-ended capture has no frame-count target: it ends only on an error or the user's stop press.
|
||
if (settings.TimeRange == RenderSettings.TimeRanges.Continuous)
|
||
{
|
||
if (savingSuccessful)
|
||
return;
|
||
|
||
LastHelpString = "Continuous capture stopped after an error.";
|
||
Log.Warning(LastHelpString);
|
||
CleanupSession();
|
||
return;
|
||
}
|
||
|
||
// Update stats
|
||
var effectiveFrameCount = settings.RenderMode == RenderSettings.RenderModes.Video ? session.FrameCount : session.FrameCount + 2;
|
||
|
||
var exportedFrameIndex = session.FrameIndex - WarmupFramesToSkip;
|
||
|
||
var currentFrame = settings.RenderMode == RenderSettings.RenderModes.Video
|
||
? exportedFrameIndex
|
||
: session.FrameIndex + 1;
|
||
|
||
var completed = currentFrame >= effectiveFrameCount || !savingSuccessful;
|
||
if (!completed)
|
||
return;
|
||
|
||
var duration = Playback.RunTimeInSecs - session.ExportStartedTime;
|
||
var successful = savingSuccessful ? "successfully" : "unsuccessfully";
|
||
LastHelpString = $"Render {GetTargetFilePath(settings.RenderMode)} finished {successful} in {StringUtils.HumanReadableDurationFromSeconds(duration)}";
|
||
Log.Debug(LastHelpString);
|
||
|
||
if (savingSuccessful)
|
||
{
|
||
var incremented = false;
|
||
if (settings.RenderMode == RenderSettings.RenderModes.Video && settings.AutoIncrementVersionNumber)
|
||
{
|
||
RenderPaths.TryIncrementVideoFileName();
|
||
incremented = true;
|
||
}
|
||
else if (settings.RenderMode == RenderSettings.RenderModes.ImageSequence && settings.AutoIncrementSubFolder)
|
||
{
|
||
if (settings.CreateSubFolder)
|
||
{
|
||
RenderSettings.Current.SequenceFileName = RenderPaths.GetNextIncrementedPath(RenderSettings.Current.SequenceFileName);
|
||
}
|
||
else
|
||
{
|
||
RenderSettings.Current.SequencePrefix = RenderPaths.GetNextIncrementedPath(RenderSettings.Current.SequencePrefix);
|
||
}
|
||
incremented = true;
|
||
}
|
||
|
||
if (incremented)
|
||
{
|
||
ProjectView.Focused?.CompositionInstance?.Symbol.GetSymbolUi()?.FlagAsModified();
|
||
}
|
||
}
|
||
|
||
CleanupSession();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Computes the final render to file resolution from the current texture size and resolution scale factor.
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// Eventually this should also include rounding to even file sizes or clamping to the codec sizes provided in the setting.
|
||
/// </remarks>
|
||
public static bool TryGetRenderResolution(RenderSettings settings, out Int2 resolution)
|
||
{
|
||
resolution = Int2.Zero;
|
||
if (State != States.ReadyForExport && State != States.Exporting)
|
||
return false;
|
||
|
||
if (MainOutputTexture == null || MainOutputTexture.IsDisposed)
|
||
return false;
|
||
|
||
// TODO: clamp for valid encoding resolutions...
|
||
resolution = new Int2(
|
||
((int)(MainOutputTexture.Description.Width * settings.ResolutionFactor)).Clamp(1, 16384),
|
||
((int)(MainOutputTexture.Description.Height * settings.ResolutionFactor)).Clamp(1, 16384));
|
||
return true;
|
||
}
|
||
|
||
public static RenderSettings GetActiveOrRequestedSettings()
|
||
{
|
||
return State == States.Exporting && _activeExportSession != null
|
||
? _activeExportSession.Settings
|
||
: RenderSettings.Current;
|
||
}
|
||
|
||
public static bool TryGetActiveExportResolution(out Int2 resolution)
|
||
{
|
||
resolution = Int2.One;
|
||
if (State != States.Exporting || _activeExportSession == null)
|
||
return false;
|
||
|
||
resolution = _activeExportSession.RenderToFileResolution;
|
||
return true;
|
||
}
|
||
|
||
private static byte[] ComputeAudioBufferForVideoFrame(ExportSession session)
|
||
{
|
||
// Use the new full mixdown buffer for audio export
|
||
double localFxTime = session.FrameIndex / session.Settings.FrameRate;
|
||
Log.Gated.VideoRender($"Requested recording from {0.0000:F4} to {(session.FrameCount / session.Settings.FrameRate):F4} seconds");
|
||
Log.Gated.VideoRender($"Actually recording from {(session.FrameIndex / session.Settings.FrameRate):F4} to {((session.FrameIndex + 1) / session.Settings.FrameRate):F4} seconds due to frame raster");
|
||
var audioFrameFloat = AudioRendering.GetFullMixDownBuffer(1.0 / session.Settings.FrameRate);
|
||
|
||
// Safety: ensure audioFrameFloat is valid and sized
|
||
if (audioFrameFloat == null || audioFrameFloat.Length == 0)
|
||
{
|
||
Log.Error($"RenderProcess: AudioRendering.GetFullMixDownBuffer returned null or empty at frame {session.FrameIndex}");
|
||
var sampleRate = RenderAudioInfo.SoundtrackSampleRate();
|
||
var channels = RenderAudioInfo.SoundtrackChannels();
|
||
var floatCount = (int)Math.Max(Math.Round((1.0 / session.Settings.FrameRate) * sampleRate), 0.0) * channels;
|
||
audioFrameFloat = new float[floatCount]; // silence
|
||
}
|
||
|
||
// Convert float[] to byte[] for the writer
|
||
var audioFrame = new byte[audioFrameFloat.Length * sizeof(float)];
|
||
Buffer.BlockCopy(audioFrameFloat, 0, audioFrame, 0, audioFrame.Length);
|
||
|
||
// Force metering outputs to update for UI/graph
|
||
AudioRendering.EvaluateAllAudioMeteringOutputs(localFxTime, audioFrameFloat);
|
||
return audioFrame;
|
||
}
|
||
|
||
private static void HandleRenderShortCuts()
|
||
{
|
||
if (MainOutputTexture == null)
|
||
return;
|
||
|
||
if (UserActions.RenderAnimation.Triggered())
|
||
{
|
||
if (IsExporting)
|
||
{
|
||
// For continuous capture the second press is a normal stop (keep the file), not a cancel.
|
||
if (IsContinuousActive)
|
||
StopContinuous();
|
||
else
|
||
Cancel();
|
||
}
|
||
else
|
||
{
|
||
TryStartVideoExport();
|
||
}
|
||
}
|
||
|
||
if (UserActions.RenderScreenshot.Triggered())
|
||
{
|
||
TryRenderScreenShot();
|
||
}
|
||
}
|
||
|
||
private static string GetTargetFilePath(RenderSettings.RenderModes renderMode) => RenderPaths.GetTargetFilePath(renderMode);
|
||
|
||
private static void CleanupSession()
|
||
{
|
||
if (_activeExportSession == null)
|
||
return;
|
||
|
||
if (_activeExportSession.Settings.RenderMode == RenderSettings.RenderModes.Video)
|
||
{
|
||
try
|
||
{
|
||
_activeExportSession.VideoWriter?.Dispose();
|
||
_activeExportSession.VideoWriter = null;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Log.Debug("Failed to cleanup video writer: " + e.Message);
|
||
}
|
||
}
|
||
|
||
// Audio restoration is now handled automatically by AudioRendering.EndRecording()
|
||
// which is called during the rendering process
|
||
|
||
// Realtime continuous capture never takes over playback, so there is nothing to release — doing so
|
||
// would force PlaybackSpeed to 0 and yank the user's live playback when they stop the capture.
|
||
var wasRealtimeContinuous = _activeExportSession.Settings.TimeRange == RenderSettings.TimeRanges.Continuous
|
||
&& _activeExportSession.Settings.ContinuousClock == RenderSettings.ContinuousCaptureClock.Realtime;
|
||
if (!wasRealtimeContinuous)
|
||
{
|
||
// Release playback time before nulling _activeSession
|
||
RenderTiming.ReleasePlaybackTime(ref _activeExportSession.Settings, ref _activeExportSession.Runtime);
|
||
}
|
||
|
||
_activeExportSession = null;
|
||
|
||
State = States.ReadyForExport;
|
||
}
|
||
|
||
private static bool SaveVideoFrameAndAdvance(ExportSession session, Texture2D outputTexture, ref byte[] audioFrame, int channels, int sampleRate)
|
||
{
|
||
if (Playback.OpNotReady)
|
||
{
|
||
Log.Debug("Waiting for operators to complete");
|
||
return true;
|
||
}
|
||
|
||
try
|
||
{
|
||
if (UserSettings.Config.ShowRenderProfilingLogs)
|
||
{
|
||
Log.Debug($"""
|
||
SaveVideoFrameAndAdvance: frame={session.FrameIndex}
|
||
MainOutputTexture null? {MainOutputTexture == null}
|
||
audioFrame.Length={audioFrame.Length}
|
||
channels={channels}
|
||
sampleRate={sampleRate}
|
||
""");
|
||
}
|
||
|
||
RenderTiming.SetPlaybackTimeForFrame(session);
|
||
|
||
// Skip the warmup frame(s): the output texture needs one frame to settle on the new playback time.
|
||
if (session.FrameIndex >= WarmupFramesToSkip)
|
||
session.VideoWriter?.ProcessFrames(outputTexture, ref audioFrame, channels, sampleRate);
|
||
|
||
session.FrameIndex++;
|
||
return true;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
var wasFileWriteException = e is SharpDX.SharpDXException dxEx && (uint)dxEx.HResult == 0x80070020;
|
||
var msg = wasFileWriteException
|
||
? "The output file is in use by another process. Please close any application using it and try again."
|
||
: $"Exception in SaveVideoFrameAndAdvance at frame {session.FrameIndex}: {e.Message}\n{e.StackTrace}";
|
||
|
||
Log.Error(msg);
|
||
LastHelpString = msg;
|
||
CleanupSession();
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// Realtime continuous capture: write as many frames of the current live texture as the wall clock says are
|
||
// due, so the file stays at a constant target FPS even though the editor refresh rate varies. Playback is
|
||
// left untouched (the user controls it live).
|
||
private static bool WriteRealtimeContinuousFrames(ExportSession session, Texture2D texture)
|
||
{
|
||
var fps = session.Settings.FrameRate;
|
||
if (fps <= 0)
|
||
return false;
|
||
|
||
if (!session.RealtimeClockAnchored)
|
||
{
|
||
// Start the wall clock from the first frame the (lazily created) writer is ready for, so the
|
||
// init delay doesn't count as captured time.
|
||
session.ExportStartedTime = Playback.RunTimeInSecs;
|
||
session.RealtimeClockAnchored = true;
|
||
return true;
|
||
}
|
||
|
||
var elapsed = Playback.RunTimeInSecs - session.ExportStartedTime;
|
||
var framesDue = (int)(elapsed * fps);
|
||
var framesToWrite = framesDue - session.FrameIndex;
|
||
if (framesToWrite <= 0)
|
||
return true; // editor running faster than the target FPS — skip a grab this frame
|
||
|
||
try
|
||
{
|
||
// A long stall (modal open, editor paused) shouldn't flood the file with duplicates: write one
|
||
// frame and resync the wall-clock baseline rather than filling the whole gap.
|
||
const int maxCatchUpFrames = 4;
|
||
if (framesToWrite > maxCatchUpFrames)
|
||
{
|
||
WriteOneRealtimeFrame(session, texture);
|
||
session.ExportStartedTime = Playback.RunTimeInSecs - session.FrameIndex / fps;
|
||
return true;
|
||
}
|
||
|
||
for (var i = 0; i < framesToWrite; i++)
|
||
WriteOneRealtimeFrame(session, texture);
|
||
|
||
return true;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Log.Error($"Continuous capture failed at frame {session.FrameIndex}: {e.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private static void WriteOneRealtimeFrame(ExportSession session, Texture2D texture)
|
||
{
|
||
if (session.Settings.RenderMode == RenderSettings.RenderModes.Video)
|
||
{
|
||
var noAudio = Array.Empty<byte>();
|
||
session.VideoWriter?.ProcessFrames(texture, ref noAudio,
|
||
RenderAudioInfo.SoundtrackChannels(), RenderAudioInfo.SoundtrackSampleRate());
|
||
}
|
||
else
|
||
{
|
||
ScreenshotWriter.StartSavingToFile(texture, GetSequenceFilePath(), session.Settings.FileFormat);
|
||
}
|
||
|
||
session.FrameIndex++;
|
||
}
|
||
|
||
private static string GetSequenceFilePath()
|
||
{
|
||
var prefix = RenderPaths.SanitizeFilename(RenderSettings.Current.SequencePrefix);
|
||
return Path.Combine(_activeExportSession!.TargetDirectory,
|
||
$"{prefix}_{_activeExportSession.FrameIndex:0000}.{_activeExportSession.Settings.FileFormat.ToString().ToLower()}");
|
||
}
|
||
|
||
private static bool TrySaveImageFrameAndAdvance(Texture2D mainOutputTexture)
|
||
{
|
||
try
|
||
{
|
||
if (!ScreenshotWriter.StartSavingToFile(mainOutputTexture, GetSequenceFilePath(), _activeExportSession!.Settings.FileFormat))
|
||
return false;
|
||
|
||
_activeExportSession.FrameIndex++;
|
||
RenderTiming.SetPlaybackTimeForFrame(_activeExportSession);
|
||
return true;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Log.Warning(e.Message);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private static string ToResolutionString(this Int2 resolution)
|
||
{
|
||
return $"{resolution.Width}×{resolution.Height}";
|
||
}
|
||
|
||
internal sealed class ExportSession
|
||
{
|
||
public IRenderVideoWriter? VideoWriter;
|
||
public string TargetDirectory = string.Empty;
|
||
public string TargetFilePath = string.Empty;
|
||
public double ExportStartedTime;
|
||
public int FrameIndex;
|
||
public int FrameCount;
|
||
public RenderSettings Settings = null!;
|
||
public RenderTiming.Runtime Runtime;
|
||
public Int2 RenderToFileResolution;
|
||
|
||
public int ResolutionMismatchCount;
|
||
|
||
// Realtime continuous capture only: set once the writer is ready and the wall clock is anchored.
|
||
public bool RealtimeClockAnchored;
|
||
}
|
||
|
||
private static ExportSession? _activeExportSession;
|
||
|
||
// The output texture needs one frame to settle on each new playback time, so the first rendered frame is a
|
||
// warmup that isn't written. The frame-count math accounts for it.
|
||
private const int WarmupFramesToSkip = 1;
|
||
} |