SHA256
1528 lines
66 KiB
C#
1528 lines
66 KiB
C#
using System;
|
||
using System.Collections;
|
||
using System.Collections.Generic;
|
||
using System.IO;
|
||
using System.Threading;
|
||
using System.Buffers;
|
||
using System.Diagnostics;
|
||
using ADOFAIRenderer.API;
|
||
using ADOFAIRenderer.Core.Data;
|
||
using ADOFAIRenderer.Data;
|
||
using ADOFAIRenderer.Patch.Engine;
|
||
using ADOFAIRenderer.UI;
|
||
using ADOFAIRenderer.UI.Window;
|
||
using ADOFAIRenderer.Util;
|
||
using ADOFAIRenderer.Util.Audio;
|
||
using ADOFAIRenderer.Util.FFmpeg;
|
||
using ADOFAIRenderer.Util.OS;
|
||
using FFmpeg.AutoGen;
|
||
using HarmonyLib;
|
||
using MelonLoader;
|
||
using UnityEngine;
|
||
using UnityEngine.Rendering;
|
||
using Random = UnityEngine.Random;
|
||
using ThreadPriority = System.Threading.ThreadPriority;
|
||
|
||
namespace ADOFAIRenderer.Core;
|
||
|
||
/// <summary>
|
||
/// Progress of the current render (RenderManager.stage). Values are ordered: checks use comparisons such as
|
||
/// stage >= OnScene.
|
||
/// <list type="bullet">
|
||
/// <item><c>None</c>: no render. Set at start-up and whenever a render ends, is cancelled or fails (ResetRenderState).</item>
|
||
/// <item><c>Load</c>: RenderSession.Start was called; the game scene (scnGame) is being loaded.</item>
|
||
/// <item><c>OnScene</c>: the game scene has loaded (RenderManager.Update set up the scene): the frame counter runs, the
|
||
/// 3-second countdown is shown, input is ignored. Nothing is captured yet. RenderManager.IsActive is true from this stage.</item>
|
||
/// <item><c>Render</c>: the encoder and render thread run and frames are captured (set by SetupPlay after the countdown).
|
||
/// RenderManager.IsCapturingActive is true; the time patches replace Unity's clock with the render clock.</item>
|
||
/// </list>
|
||
/// </summary>
|
||
internal enum RenderStage
|
||
{
|
||
None, Load, OnScene, Render
|
||
}
|
||
|
||
/// <summary>
|
||
/// Options of the current render, copied from a <see cref="RenderSession"/> by RenderSession.Start and read by
|
||
/// RenderManager and the Harmony patches. <see cref="Reset"/> restores the defaults when the render environment is
|
||
/// restored (RenderManager.RestoreRenderEnvironment). Main thread only.
|
||
/// </summary>
|
||
internal static class RenderContext
|
||
{
|
||
/// <summary>Value assigned to RDC.auto (the game's autoplay flag) when the game scene of the render has loaded.</summary>
|
||
public static bool Auto = true;
|
||
|
||
/// <summary>
|
||
/// Enables the time patches (Time.time / unscaledTime / deltaTime / frameCount, AudioSettings.dspTime) while capturing,
|
||
/// which drive the game by the render clock (frameCount / RenderFPS) instead of real time.
|
||
/// </summary>
|
||
public static bool TimePatch = true;
|
||
|
||
/// <summary>Enables the Screen.width / Screen.height patches (report the render resolution) while the render is active.</summary>
|
||
public static bool ScreenPatch = true;
|
||
|
||
/// <summary>Output file path of the render, or null for a time-stamped file in GlobalSettings.EffectiveOutputDirectory.</summary>
|
||
public static string? OutputPath;
|
||
|
||
/// <summary>Whether the default OnComplete callback shows an OS notification after a successful render.</summary>
|
||
public static bool Notification = true;
|
||
|
||
/// <summary>Frame hooks of the current session, run before the global hooks (see RenderSession.AddFrameHook).</summary>
|
||
public static readonly List<Action<FrameHookContext>> SessionFrameHooks = new();
|
||
|
||
/// <summary>Default end condition: the level is cleared (scrController state Won).</summary>
|
||
private static readonly Func<bool> EndConditionDefault = () => scrController.instance.state == States.Won;
|
||
|
||
/// <summary>
|
||
/// Polled by RenderManager.Update every frame from the OnScene stage. When it first returns true, the render
|
||
/// continues for RenderConfig.DelayAfterEnd seconds of render time and then ends successfully.
|
||
/// </summary>
|
||
public static Func<bool> EndCondition = EndConditionDefault;
|
||
|
||
/// <summary>Default completion callback: shows an OS notification for a successful render when Notification is true.</summary>
|
||
private static readonly Action<RenderResult> OnCompleteDefault = result =>
|
||
{
|
||
if (result.Success && Notification)
|
||
{
|
||
var fileString = !string.IsNullOrEmpty(RenderManager.Instance.CurrentOutPath) ?
|
||
$"'{Path.GetFileName(RenderManager.Instance.CurrentOutPath)}'" : "Video";
|
||
|
||
var renderFolder = Path.GetDirectoryName(RenderManager.Instance.CurrentOutPath);
|
||
OSNotification.Show("Rendering Complete!", $"{fileString} saved successfully.", renderFolder);
|
||
}
|
||
};
|
||
/// <summary>
|
||
/// Called once on the main Unity thread when the render finishes (success) or is cancelled or fails.
|
||
/// A session callback replaces the default one, so no notification is shown when a session sets OnComplete.
|
||
/// Exceptions are caught and logged (RenderManager.TriggerOnComplete).
|
||
/// </summary>
|
||
public static Action<RenderResult> OnComplete = OnCompleteDefault;
|
||
|
||
private static readonly Action OnLastUpdateDefault = () => { };
|
||
|
||
/// <summary>
|
||
/// Called on the main Unity thread every frame after all other LateUpdate calls, through PostRenderHook (attached when the
|
||
/// game scene of the render has loaded) while the stage is Load or later.
|
||
/// Exceptions are caught and logged (RenderManager.TriggerOnLastUpdate).
|
||
/// </summary>
|
||
public static Action OnLastUpdate = OnLastUpdateDefault;
|
||
|
||
/// <summary>Restores every option to its default and clears the session frame hooks.</summary>
|
||
public static void Reset()
|
||
{
|
||
Auto = true;
|
||
TimePatch = true; ScreenPatch = true;
|
||
OutputPath = null;
|
||
|
||
Notification = true;
|
||
SessionFrameHooks.Clear();
|
||
|
||
EndCondition = EndConditionDefault;
|
||
OnComplete = OnCompleteDefault;
|
||
OnLastUpdate = OnLastUpdateDefault;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Drives a render from scene setup to the finished video file. Singleton MonoBehaviour on a DontDestroyOnLoad object
|
||
/// created by RenderMod.
|
||
///
|
||
/// Flow: RenderSession.Start (stage Load) → SetupGameScene loads scnGame → Update sets up the loaded scene
|
||
/// (stage OnScene, 3-second countdown) → SetupPlay starts the encoder and the render thread (stage Render) →
|
||
/// every frame OnPreUpdate advances frameCount, OnPostFrame queues the audio commands and requests the GPU capture of
|
||
/// the frame (FrameReader, AsyncGPUReadback) → readback completions add frames to ImageQueue → the render thread
|
||
/// (RunRenderThread) encodes them in frame order together with the audio of each frame.
|
||
///
|
||
/// End: success (EndCondition plus DelayAfterEnd) → StopFFmpeg(true) → StopRenderCoroutine waits for the render
|
||
/// thread to finish the file → EndRender. Cancel (ESC) or failure → StopFFmpeg(false) → EndRender, which deletes the
|
||
/// unfinished file. Encoder initialization failure → StopFFmpeg(false) → RestoreRenderEnvironment and an error dialog.
|
||
///
|
||
/// Threads: the main Unity thread runs every public method unless noted otherwise. The render thread reads
|
||
/// ImageQueue (lock on ImageQueue), passCount (render thread only while it runs), endRequested / endSuccessful
|
||
/// (volatile), the abort state (volatile, written under _abortStateLock) and lastRequestedVideoFrameIndex
|
||
/// (Volatile.Read/Write). FrameAvailableEvent wakes the render thread, FrameDequeuedEvent wakes the throttle loop.
|
||
/// </summary>
|
||
internal class RenderManager : MonoBehaviour
|
||
{
|
||
/// <summary>The single instance, set in Awake. Unity null checks (<c>if (Instance)</c>) are used before access.</summary>
|
||
public static RenderManager Instance { get; private set; } = null!;
|
||
|
||
/// <summary>True from the OnScene stage (scene set up, countdown running) until the render ends.</summary>
|
||
public static bool IsActive => Instance && Instance.stage >= RenderStage.OnScene;
|
||
|
||
/// <summary>True while frames are captured and encoded (Render stage). The time patches apply only then.</summary>
|
||
public static bool IsCapturingActive => Instance && Instance.stage >= RenderStage.Render;
|
||
|
||
/// <summary>
|
||
/// Maximum number of frames in ImageQueue. The main Unity thread waits (throttles) while the queue holds more frames.
|
||
/// </summary>
|
||
public const int MaxQueuedFrames = 64;
|
||
|
||
/// <summary>
|
||
/// Upper bound of the readback buffer bytes of the frames in ImageQueue (4 GiB).
|
||
/// The frame limit becomes min(MaxQueuedFrames, MaxQueuedBytes / bytes per frame) (see ComputeQueueFrameLimit),
|
||
/// so it only lowers the frame count at resolutions where MaxQueuedFrames frames exceed this size.
|
||
/// </summary>
|
||
public const long MaxQueuedBytes = 4L * 1024 * 1024 * 1024;
|
||
|
||
/// <summary>
|
||
/// Wait time of the throttle loop (OnPostFrame) for the render thread to take a frame from ImageQueue.
|
||
/// When it elapses without a dequeue, AsyncGPUReadback.WaitAllRequests() is called once so the readbacks
|
||
/// still in flight complete (the render thread may be waiting for one of them to fill a gap in ImageQueue).
|
||
/// </summary>
|
||
private const int ThrottleWaitMilliseconds = 10;
|
||
|
||
/// <summary>Frame limit of ImageQueue applied by the last throttle check (MaxQueuedFrames or lower).</summary>
|
||
public int QueueFrameLimit { get; private set; } = MaxQueuedFrames;
|
||
|
||
// Statistics
|
||
|
||
/// <summary>
|
||
/// Number of video frames sent to the encoder in this render. Incremented by the render thread (Interlocked),
|
||
/// read with Interlocked.Read by the main Unity thread (result, debug monitor). Reset in SetupPlay.
|
||
/// </summary>
|
||
public long framesSent;
|
||
|
||
/// <summary>Wall-clock time of the render from the end of the countdown (SetupPlay) to BuildResult.</summary>
|
||
private readonly Stopwatch _renderStopwatch = new();
|
||
|
||
// Core Render Configuration and Path
|
||
|
||
/// <summary>
|
||
/// Seconds left in the countdown before capture starts (3 when the scene is set up, decremented once per real-time
|
||
/// second by SetupPlay). Shown by scrShowIfDebugPatch and read by scrPlayerManagerPatch.
|
||
/// </summary>
|
||
public int countdown;
|
||
|
||
/// <summary>
|
||
/// Render frame counter: incremented once per Unity frame by OnPreUpdate from the OnScene stage and reset to 0 when
|
||
/// capture starts (SetupPlay). The render clock is frameCount / RenderFPS seconds (AudioTime, time patches).
|
||
/// Main thread only.
|
||
/// </summary>
|
||
public long frameCount;
|
||
|
||
/// <summary>
|
||
/// Set by SetupGameScene; scrPressToStartPatch consumes it (sets it back to false) to skip the press-to-start
|
||
/// screen once. Cleared by StopFFmpeg.
|
||
/// </summary>
|
||
public bool skipPressToStart;
|
||
|
||
/// <summary>Path of the level file to render (ADOBase.levelPath of the editor, or the path given to RenderSession.Start).</summary>
|
||
public string levelPath = "";
|
||
|
||
/// <summary>Serializes changes of the abort state (_isRenderCancelled, _renderFailed, _failureReason).</summary>
|
||
private readonly object _abortStateLock = new();
|
||
|
||
/// <summary>The render was cancelled (ESC, or a non-successful stop). Written under _abortStateLock, read by any thread.</summary>
|
||
private volatile bool _isRenderCancelled;
|
||
|
||
/// <summary>The render failed (MarkFailed). Written under _abortStateLock, read by any thread.</summary>
|
||
private volatile bool _renderFailed;
|
||
|
||
/// <summary>Reason given to the first MarkFailed call of this render; null when the render has not failed.</summary>
|
||
private volatile string? _failureReason;
|
||
|
||
/// <summary>True when the render was cancelled. Thread-safe read.</summary>
|
||
// ReSharper disable once MemberCanBePrivate.Global
|
||
public bool IsRenderCancelled => _isRenderCancelled;
|
||
|
||
/// <summary>True when the render failed. Thread-safe read.</summary>
|
||
public bool IsRenderFailed => _renderFailed;
|
||
|
||
/// <summary>
|
||
/// True when the render was cancelled or failed (the two are mutually exclusive) and must stop.
|
||
/// Read by the render thread before each frame and by readback completions. Thread-safe read.
|
||
/// </summary>
|
||
public bool IsRenderAborted => _isRenderCancelled || _renderFailed;
|
||
|
||
/// <summary>Marks the render as cancelled unless it has already failed (a failure keeps its reason).</summary>
|
||
private void MarkCancelled()
|
||
{
|
||
lock (_abortStateLock)
|
||
{
|
||
if (!_renderFailed) _isRenderCancelled = true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Marks the render as failed with <paramref name="reason"/> (shown in the result message as "Rendering failed: reason").
|
||
/// The first failure reason wins; ignored once the render is already cancelled or failed. Callable from any thread.
|
||
/// </summary>
|
||
private void MarkFailed(string reason)
|
||
{
|
||
lock (_abortStateLock)
|
||
{
|
||
if (_isRenderCancelled || _renderFailed) return;
|
||
_failureReason = reason;
|
||
_renderFailed = true;
|
||
}
|
||
}
|
||
|
||
/// <summary>Clears cancelled, failed and the failure reason. Called when a new encoder starts (StartFFmpegThread).</summary>
|
||
private void ClearAbortState()
|
||
{
|
||
lock (_abortStateLock)
|
||
{
|
||
_isRenderCancelled = false;
|
||
_renderFailed = false;
|
||
_failureReason = null;
|
||
}
|
||
}
|
||
|
||
/// <summary>Error message of the RenderResult of an aborted render (failure reason, or the cancel message).</summary>
|
||
private string BuildAbortMessage() => IsRenderFailed
|
||
? $"Rendering failed: {_failureReason ?? "unknown error"}"
|
||
: "Rendering was cancelled by user.";
|
||
|
||
/// <summary>
|
||
/// Configuration of the current render: a copy made by RenderSession.Start, so values adjusted during the render
|
||
/// (the audio sample rate in SetupPlay) do not change the caller's object. Read by the main Unity thread, the render
|
||
/// thread (audio settings) and the patches. Null until the first render starts.
|
||
/// </summary>
|
||
public RenderConfig Configuration = null!;
|
||
|
||
// Render Sessions State (OOP Instance Fields)
|
||
|
||
/// <summary>Current stage of the render. Written on the main Unity thread; read by the render thread in TryDequeueNextFrame.</summary>
|
||
public RenderStage stage = RenderStage.None;
|
||
|
||
/// <summary>Time.timeAsDouble when capture started. The time patch returns timeBase + frameCount / RenderFPS.</summary>
|
||
public double timeBase;
|
||
|
||
/// <summary>Time.unscaledTimeAsDouble when capture started. The time patch returns unscaledTimeBase + frameCount / RenderFPS.</summary>
|
||
public double unscaledTimeBase;
|
||
|
||
/// <summary>
|
||
/// AudioSettings.dspTime when capture started (seconds). The dspTime patch returns dspTimeBase + frameCount / RenderFPS;
|
||
/// audio command times are stored relative to it (scheduled dspTime - dspTimeBase).
|
||
/// </summary>
|
||
public double dspTimeBase;
|
||
|
||
/// <summary>Time.frameCount when capture started. The frameCount patch returns frameCountBase + frameCount.</summary>
|
||
public int frameCountBase;
|
||
|
||
/// <summary>
|
||
/// Offline mixer of the song and sound effects of this render; null when audio is not rendered or no render runs.
|
||
/// Created in SetupPlay. Commands are added on the main Unity thread (OnPostFrame, audio patches), mixing runs on the
|
||
/// render thread (WriteAudioForFrame); the mixer synchronizes the two internally.
|
||
/// </summary>
|
||
public OfflineAudioMixer? AudioMixer { get; private set; }
|
||
|
||
/// <summary>Render time of the current frame in seconds (frameCount / RenderFPS), the time base of audio commands.</summary>
|
||
public double AudioTime => frameCount / Configuration.RenderFPS;
|
||
/// <summary>
|
||
/// Number of audio samples (per channel) to write after each video frame, so that the audio stays aligned with
|
||
/// the video frame times at the effective video frame rate. Created in SetupPlay when audio is rendered;
|
||
/// used by the render thread only.
|
||
/// </summary>
|
||
private AudioSyncCalculator? SyncCalculator { get; set; }
|
||
|
||
/// <summary>GPU capture of frames (color conversion and AsyncGPUReadback). Created in SetupPlay after the encoder started.</summary>
|
||
private FrameReader? _frameReader;
|
||
|
||
/// <summary>Frame hook runner of this render. Created in SetupPlay, disposed by ResetFrameHookState.</summary>
|
||
private FrameHookPipeline? _frameHookPipeline;
|
||
|
||
/// <summary>Session hooks followed by global hooks, rebuilt when the global hook version changes.</summary>
|
||
private readonly List<Action<FrameHookContext>> _activeHooksCache = new();
|
||
|
||
/// <summary>RenderSession.GlobalHooksVersion the cache was built for; -1 forces a rebuild.</summary>
|
||
private int _cachedGlobalHooksVersion = -1;
|
||
|
||
/// <summary>True when _activeHooksCache is not empty.</summary>
|
||
private bool _hasActiveHooksCached;
|
||
|
||
/// <summary>True when at least one session or global frame hook is registered. Main thread.</summary>
|
||
public bool HasActiveFrameHooks
|
||
{
|
||
get
|
||
{
|
||
EnsureActiveHooksUpToDate();
|
||
return _hasActiveHooksCached;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Rebuilds the active hook list when the global hook registrations changed since the last build.
|
||
/// Session hooks are only read on a rebuild; SetupPlay forces one (version -1) at the start of capture, so changes to
|
||
/// RenderContext.SessionFrameHooks after that are picked up only together with a global hook change.
|
||
/// </summary>
|
||
private void EnsureActiveHooksUpToDate()
|
||
{
|
||
var globalVersion = RenderSession.GlobalHooksVersion;
|
||
if (_cachedGlobalHooksVersion == globalVersion) return;
|
||
|
||
_cachedGlobalHooksVersion = globalVersion;
|
||
_activeHooksCache.Clear();
|
||
if (RenderContext.SessionFrameHooks.Count > 0)
|
||
{
|
||
_activeHooksCache.AddRange(RenderContext.SessionFrameHooks);
|
||
}
|
||
RenderSession.CopyGlobalFrameHooksTo(_activeHooksCache);
|
||
_hasActiveHooksCached = _activeHooksCache.Count > 0;
|
||
}
|
||
|
||
/// <summary>Returns the cached active hook list (session hooks first, then global hooks). The list is reused.</summary>
|
||
private List<Action<FrameHookContext>> GetActiveFrameHooks()
|
||
{
|
||
EnsureActiveHooksUpToDate();
|
||
return _activeHooksCache;
|
||
}
|
||
|
||
/// <summary>Disposes the frame hook pipeline (ping-pong buffers) and clears the hook cache.</summary>
|
||
private void ResetFrameHookState()
|
||
{
|
||
_frameHookPipeline?.Dispose();
|
||
_frameHookPipeline = null;
|
||
_activeHooksCache.Clear();
|
||
_cachedGlobalHooksVersion = -1;
|
||
_hasActiveHooksCached = false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Number of game frames offered for capture since capture started (OnPostFrame with a texture, after throttling).
|
||
/// The value before the increment is the render frame index of the current frame. Main thread only.
|
||
/// </summary>
|
||
public long frameCountForVideo;
|
||
|
||
/// <summary>
|
||
/// Video frame index of the last captured frame (-1 before the first). A game frame is captured only when its video
|
||
/// frame index (render frame index × effective video FPS / RenderFPS, rounded down) is greater. Main thread only.
|
||
/// </summary>
|
||
public long lastVideoFrameIndex = -1;
|
||
|
||
/// <summary>
|
||
/// Video frame index of the last capture request (-1 before the first). Written on the main Unity thread, read by the
|
||
/// render thread to know when every requested frame has been sent after endRequested.
|
||
/// </summary>
|
||
// long cannot be volatile: access via Volatile.Read/Write (written on main Unity thread, read on render thread)
|
||
public long lastRequestedVideoFrameIndex = -1;
|
||
|
||
/// <summary>
|
||
/// Number of GPU readbacks that failed and were replaced by a black frame (shown by the debug monitor).
|
||
/// Incremented in the readback completion callback.
|
||
/// </summary>
|
||
public int readbackFailureCount;
|
||
|
||
/// <summary>Number of frames on which the main Unity thread had to wait for the render thread (throttle loop entries).</summary>
|
||
public int throttleCount;
|
||
|
||
/// <summary>True while the main Unity thread is inside the throttle wait of OnPostFrame.</summary>
|
||
public bool isThrottling;
|
||
|
||
/// <summary>
|
||
/// One frame waiting in ImageQueue: either a native readback buffer (owned by ReadbackState until it is recycled)
|
||
/// or a managed buffer rented from ArrayPool<byte>.Shared (black frame for a failed readback).
|
||
/// The data is YUV 4:2:0 in the encoder's pixel format when IsColorConverted, RGBA otherwise.
|
||
/// </summary>
|
||
internal struct CapturedFrame
|
||
{
|
||
/// <summary>Start of the native frame data (ReadbackState.NativeBuffer); zero for a managed frame.</summary>
|
||
public IntPtr NativePointer;
|
||
|
||
/// <summary>Number of valid bytes of the frame data.</summary>
|
||
public int Length;
|
||
|
||
/// <summary>Managed frame data rented from ArrayPool<byte>.Shared (may be longer than Length); null for a native frame.</summary>
|
||
public byte[]? ManagedBuffer; // Non-null if it's a managed buffer (e.g. black frame)
|
||
|
||
/// <summary>Readback state owning NativePointer; returned to the FrameReader pool after the frame is encoded or dropped.</summary>
|
||
public ReadbackRequestState? ReadbackState; // Associated state to recycle
|
||
|
||
/// <summary>True when the GPU converted the frame to the encoder's YUV format; false for RGBA data.</summary>
|
||
public bool IsColorConverted;
|
||
}
|
||
|
||
// Thread and Queue State
|
||
|
||
/// <summary>
|
||
/// Captured frames waiting for the render thread, keyed by video frame index. Readbacks may complete in any order;
|
||
/// the render thread takes them in index order (passCount). Every access locks the list itself.
|
||
/// Frames are added by readback completions (main Unity thread) and removed by the render thread, or released by the
|
||
/// cleanup in StopFFmpeg / RestoreRenderEnvironment.
|
||
/// </summary>
|
||
internal SortedList<long, CapturedFrame> ImageQueue = new();
|
||
|
||
/// <summary>Set when a frame is added to ImageQueue or the end is requested; the render thread waits on it.</summary>
|
||
internal AutoResetEvent FrameAvailableEvent = new(false);
|
||
|
||
/// <summary>Set by the render thread each time it takes a frame from ImageQueue; the throttle loop waits on it.</summary>
|
||
internal AutoResetEvent FrameDequeuedEvent = new(false);
|
||
|
||
/// <summary>The render thread of the current render (background, AboveNormal priority); null before the first render.</summary>
|
||
public Thread? RenderThread;
|
||
|
||
/// <summary>
|
||
/// Video frame index the render thread sends next. Reset by StartFFmpegThread before the thread starts; afterwards
|
||
/// read and written only by the render thread, under the ImageQueue lock.
|
||
/// </summary>
|
||
public long passCount;
|
||
|
||
/// <summary>Set by StopFFmpeg: no more frames will be captured; the render thread drains the queue and stops.</summary>
|
||
public volatile bool endRequested;
|
||
|
||
/// <summary>Set by the render thread after the output file was finished and the encoder released without an abort.</summary>
|
||
public volatile bool endSuccessful;
|
||
|
||
/// <summary>
|
||
/// frameCount at which EndCondition first returned true; -1 until then. The render ends DelayAfterEnd seconds of
|
||
/// render time later.
|
||
/// </summary>
|
||
public long endFrame = -1;
|
||
|
||
// Private Instance Fields
|
||
|
||
/// <summary>Encoder of the current render; null when none runs. Cleared when the render thread releases it.</summary>
|
||
private FFmpegNativeEncoder? _activeVideoFFmpeg;
|
||
|
||
/// <summary>
|
||
/// Every encoder created and not yet released, disposed by CleanUpActiveRender on exit. Locked on the list itself
|
||
/// (the render thread removes its encoder when it finishes).
|
||
/// </summary>
|
||
private readonly List<FFmpegNativeEncoder> _allVideoFFmpegInstances = new();
|
||
|
||
/// <summary>The user's input offset (scrConductor.currentPreset.inputOffset), set to 0 during the render and restored afterwards.</summary>
|
||
private int _originalInputOffset;
|
||
|
||
/// <summary>Debug monitor overlay object, created when the encoder starts and destroyed when the render ends.</summary>
|
||
private GameObject? _debugMonitorObj;
|
||
|
||
/// <summary>ESC handler overlay object (cancels the render), created when the scene is set up and destroyed by StopFFmpeg.</summary>
|
||
private GameObject? _escapeHandlerObj;
|
||
|
||
/// <summary>
|
||
/// Output file path of the current or last render. Set when the encoder starts; set to null when an aborted render's
|
||
/// file was deleted.
|
||
/// </summary>
|
||
internal string? CurrentOutPath;
|
||
|
||
// Output file of the current render that is not finished yet.
|
||
// Set just before the encoder opens the file, cleared by the render thread after the encoder finished the file (End).
|
||
// Only this file is deleted when a render is cancelled, fails or the game exits (DeleteIncompleteOutputFile).
|
||
private string? _incompleteOutputPath;
|
||
|
||
/// <summary>
|
||
/// True from SetupGameScene until Update has set up the loaded game scene (or the render stops). While true, Update
|
||
/// hides the difficulty UI and waits for scnGame to finish loading.
|
||
/// </summary>
|
||
private bool _renderSetup;
|
||
|
||
private void Awake()
|
||
{
|
||
Instance = this;
|
||
}
|
||
|
||
private void OnDestroy()
|
||
{
|
||
CleanUpActiveRender();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Sets the stage to None. <paramref name="success"/> true clears the cancelled flag; false marks the render as
|
||
/// cancelled (unless it already failed). Called at every end path before StopFFmpeg.
|
||
/// </summary>
|
||
public void ResetRenderState(bool success)
|
||
{
|
||
if (success) _isRenderCancelled = false;
|
||
else MarkCancelled();
|
||
stage = RenderStage.None;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Emergency cleanup when the game quits or this object is destroyed: marks a running render as failed, releases
|
||
/// the audio, the frame hooks and every encoder, waits up to 200 ms for the render thread, and deletes the
|
||
/// unfinished output file. Does not restore the game scene or settings. Main thread.
|
||
/// </summary>
|
||
public void CleanUpActiveRender()
|
||
{
|
||
if (stage != RenderStage.None)
|
||
MarkFailed("the game exited or RenderManager was destroyed during rendering.");
|
||
ResetRenderState(success: false);
|
||
|
||
AudioSpectrumGenerator.Clear();
|
||
// Cancels the render thread's audio waits, then releases the clip store (decoder thread, readers, chunks).
|
||
AudioMixer?.Dispose(); AudioMixer = null;
|
||
|
||
ResetFrameHookState();
|
||
|
||
if (_activeVideoFFmpeg != null)
|
||
{
|
||
Melon<RenderMod>.Logger.Msg("Game exit or RenderManager destruction detected: Disposing FFmpeg native encoder resources.");
|
||
_activeVideoFFmpeg.Dispose();
|
||
_activeVideoFFmpeg = null;
|
||
}
|
||
|
||
lock (_allVideoFFmpegInstances)
|
||
{
|
||
if (_allVideoFFmpegInstances.Count > 0)
|
||
{
|
||
Melon<RenderMod>.Logger.Msg($"Game exit detected: Cleaning up and disposing all created FFmpeg encoder instances ({_allVideoFFmpegInstances.Count}).");
|
||
foreach (var instance in _allVideoFFmpegInstances)
|
||
{
|
||
try
|
||
{
|
||
instance.Dispose();
|
||
}
|
||
catch
|
||
{
|
||
// ignored
|
||
}
|
||
}
|
||
_allVideoFFmpegInstances.Clear();
|
||
}
|
||
}
|
||
|
||
if (RenderThread is { IsAlive: true })
|
||
{
|
||
RenderThread.Join(200);
|
||
}
|
||
|
||
// The encoders are disposed above, which closes the output file. An unfinished file of this render is deleted.
|
||
DeleteIncompleteOutputFile();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Deletes the output file of the current render when the render did not finish it (_incompleteOutputPath).
|
||
/// Files of earlier, finished renders are never deleted.
|
||
/// Returns true when a file was deleted.
|
||
/// </summary>
|
||
private bool DeleteIncompleteOutputFile()
|
||
{
|
||
var path = Interlocked.Exchange(ref _incompleteOutputPath, null);
|
||
if (string.IsNullOrEmpty(path) || !File.Exists(path)) return false;
|
||
|
||
try
|
||
{
|
||
File.Delete(path);
|
||
Melon<RenderMod>.Logger.Msg($"[File Cleanup] Deleted incomplete video: {path}");
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Melon<RenderMod>.Logger.Error($"[File Cleanup] Failed to delete incomplete video: {ex.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Main thread, every frame.
|
||
/// 1. While the game scene of a render loads: hides the difficulty UI of the press-to-start screen.
|
||
/// 2. Once scnGame has finished loading: sets up the scene for rendering and starts SetupPlay (stage OnScene).
|
||
/// 3. From the OnScene stage: fails the render when the render thread died, the level failed or the controller is
|
||
/// gone; ends it successfully DelayAfterEnd seconds (render time) after EndCondition first returned true.
|
||
/// </summary>
|
||
private void Update()
|
||
{
|
||
// scrPressToStart reads lm.hideDifficultyUI to decide whether the difficulty UI is shown (scrPressToStart.cs).
|
||
if (_renderSetup && ADOBase.lm)
|
||
{
|
||
ADOBase.lm.hideDifficultyUI = true;
|
||
}
|
||
|
||
if (_renderSetup && scnGame.instance && !scnGame.instance.isLoading)
|
||
{
|
||
_renderSetup = false;
|
||
// scrCamera.Awake calls SetupRTCam(enable: true) when forceRTCam is set (scrCamera.cs), so the flag applies to
|
||
// the next scrCamera.Awake. scnGame also calls SetupRTCam(enable: true) when it starts playing (scnGame.cs).
|
||
scrCamera.instance.forceRTCam = true;
|
||
|
||
if (!scrCamera.instance.gameObject.GetComponent<PostRenderHook>())
|
||
scrCamera.instance.gameObject.AddComponent<PostRenderHook>();
|
||
|
||
// The input offset shifts the song position (calibration_i = inputOffset / 1000 in scrConductor);
|
||
// the render runs with 0 so audio and visuals follow the level timing exactly. Restored by RestoreRenderEnvironment.
|
||
_originalInputOffset = scrConductor.currentPreset.inputOffset;
|
||
scrConductor.currentPreset.inputOffset = 0;
|
||
|
||
// Autoplay; disableCongratsMessage clears the "congratulations" text shown on the win screen (scrController.cs).
|
||
RDC.auto = RenderContext.Auto;
|
||
AccessTools.Field(typeof(scrController), "disableCongratsMessage")
|
||
.SetValue(scrController.instance, true);
|
||
|
||
// No-fail with an infinite hit margin, so a missed hit does not fail the level during the render.
|
||
if (scrController.instance)
|
||
{
|
||
scrController.instance.noFail = true;
|
||
scrController.instance.noFailInfiniteMargin = true;
|
||
}
|
||
|
||
stage = RenderStage.OnScene;
|
||
countdown = 3; endFrame = -1;
|
||
|
||
if (!_escapeHandlerObj)
|
||
{
|
||
_escapeHandlerObj = new GameObject("EscapeHandlerCanvas");
|
||
_escapeHandlerObj.AddComponent<EscapeHandlerUI>();
|
||
DontDestroyOnLoad(_escapeHandlerObj);
|
||
}
|
||
|
||
// While non-zero, Unity advances Time.time by exactly this interval per frame regardless of real time,
|
||
// so the game simulation steps 1 / RenderFPS seconds per frame. Reset to 0 by RestoreRenderEnvironment.
|
||
// Reference: https://docs.unity3d.com/ScriptReference/Time-captureDeltaTime.html
|
||
Time.captureDeltaTime = (float)(1 / Configuration.RenderFPS);
|
||
scrController.instance!.StartCoroutine(SetupPlay());
|
||
}
|
||
|
||
if (Instance.stage < RenderStage.OnScene) return;
|
||
if (stage >= RenderStage.Render && RenderThread is not { IsAlive: true })
|
||
{
|
||
MarkFailed("the render thread terminated unexpectedly.");
|
||
CancelRender();
|
||
return;
|
||
}
|
||
if (!scrController.instance || scrController.instance.state == States.Fail || scrController.instance.state == States.Fail2)
|
||
{
|
||
MarkFailed("the level failed or the game controller was lost during rendering.");
|
||
ResetRenderState(success: false);
|
||
StopFFmpeg(false);
|
||
EndRender();
|
||
}
|
||
else if (RenderContext.EndCondition())
|
||
{
|
||
// The first frame the end condition holds starts the DelayAfterEnd period; afterwards the end condition is
|
||
// still polled every frame, but endFrame is kept.
|
||
if (endFrame == -1)
|
||
{
|
||
endFrame = frameCount;
|
||
}
|
||
|
||
var extraFrames = (long)Math.Ceiling(Configuration.DelayAfterEnd * Configuration.RenderFPS);
|
||
|
||
if (frameCount - endFrame < extraFrames) return;
|
||
ResetRenderState(success: true);
|
||
StopFFmpeg(true);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Called by FirstUpdateHook before every other Update of the frame. Advances frameCount by one from the OnScene stage.
|
||
/// </summary>
|
||
public void OnPreUpdate()
|
||
{
|
||
if (Instance.stage < RenderStage.OnScene) return;
|
||
frameCount++;
|
||
}
|
||
|
||
// Floors that own a hold renderer, collected from scrLevelMaker.listFloors (see RefreshHoldFloors).
|
||
private readonly List<scrFloor> _holdFloors = new();
|
||
private List<scrFloor>? _holdFloorsSource;
|
||
private int _holdFloorsSourceCount = -1;
|
||
|
||
/// <summary>
|
||
/// Called by PostRenderHook after every other LateUpdate of the frame, from the Load stage.
|
||
/// Hides the hold meshes when AdvancedConfig.NonTile is set, then runs RenderContext.OnLastUpdate.
|
||
/// </summary>
|
||
public void OnLastUpdate()
|
||
{
|
||
if (Instance.stage < RenderStage.Load) return;
|
||
|
||
if (Configuration.AdvancedConfig.NonTile)
|
||
{
|
||
// scrHoldRenderer.UpdateColor sets m_meshRenderer.enabled = true every time it runs
|
||
// (scrHoldRenderer.cs, called from scrPlanet/scrPlayer), so the hold meshes are disabled again every frame.
|
||
RefreshHoldFloors();
|
||
foreach (var floor in _holdFloors)
|
||
{
|
||
if (!floor || !floor.holdRenderer) continue;
|
||
var meshRenderer = floor.holdRenderer.m_meshRenderer;
|
||
if (meshRenderer && meshRenderer.enabled) meshRenderer.enabled = false;
|
||
}
|
||
}
|
||
|
||
TriggerOnLastUpdate();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Rebuilds the hold floor list when scrLevelMaker.listFloors is a different list or has a different count
|
||
/// (hold renderers are created together with the floors in scrLevelMaker).
|
||
/// </summary>
|
||
private void RefreshHoldFloors()
|
||
{
|
||
var floors = scrLevelMaker.instance.listFloors;
|
||
if (ReferenceEquals(floors, _holdFloorsSource) && floors.Count == _holdFloorsSourceCount) return;
|
||
|
||
_holdFloors.Clear();
|
||
foreach (var floor in floors)
|
||
{
|
||
if (floor && floor.holdRenderer) _holdFloors.Add(floor);
|
||
}
|
||
_holdFloorsSource = floors;
|
||
_holdFloorsSourceCount = floors.Count;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Frame limit of ImageQueue for the given capture texture: MaxQueuedBytes divided by the readback bytes of
|
||
/// one frame (YUV 4:2:0 when the GPU conversion is active, RGBA otherwise), within 4 to MaxQueuedFrames.
|
||
/// </summary>
|
||
private int ComputeQueueFrameLimit(RenderTexture texture)
|
||
{
|
||
var frameBytes = _frameReader?.GetFrameBufferBytes(texture.width, texture.height)
|
||
?? (long)texture.width * texture.height * 4;
|
||
if (frameBytes <= 0) return MaxQueuedFrames;
|
||
|
||
return (int)Math.Min(MaxQueuedFrames, Math.Max(4, MaxQueuedBytes / frameBytes));
|
||
}
|
||
|
||
/// <summary>
|
||
/// Called by PostRenderHook at the end of every frame (after rendering) with the frame texture. In the Render stage:
|
||
/// 1. Audio: updates the song voice, commits the audio commands of this frame, and deactivates the effect
|
||
/// AudioSources that were mapped to mixer voices.
|
||
/// 2. Throttle: blocks while ImageQueue holds more than QueueFrameLimit frames (render thread behind).
|
||
/// 3. Capture: when this game frame starts a new video frame, runs the frame hooks and requests the GPU readback.
|
||
/// With RenderFPS above the effective video FPS, only some game frames are captured.
|
||
/// </summary>
|
||
/// <param name="texture">Frame shown by the camera quad; null skips throttling and capture.</param>
|
||
// ReSharper disable once Unity.IncorrectMethodSignature
|
||
public void OnPostFrame(RenderTexture? texture)
|
||
{
|
||
if (Instance.stage < RenderStage.Render) return;
|
||
|
||
// Audio commands of this frame are queued: update the song voice and let the render thread mix up to the next frame.
|
||
if (AudioMixer != null)
|
||
{
|
||
AudioMixer.UpdateBGM(AudioTime, dspTimeBase);
|
||
AudioMixer.Commit((frameCount + 1) / Configuration.RenderFPS);
|
||
EffectSource.DeactivateMappedSources(AudioMixer);
|
||
}
|
||
|
||
if (!texture) return;
|
||
|
||
// [Backpressure Throttling]
|
||
// The main Unity thread waits while ImageQueue holds more than QueueFrameLimit frames. Only the render thread
|
||
// removes frames, and it signals FrameDequeuedEvent for each one. The wait has a timeout so that the loop
|
||
// re-checks the render thread state and pumps pending readback completions (see ThrottleWaitMilliseconds).
|
||
isThrottling = false;
|
||
var frameLimit = QueueFrameLimit = ComputeQueueFrameLimit(texture!);
|
||
|
||
while (Instance.stage >= RenderStage.Render)
|
||
{
|
||
if (RenderThread is not { IsAlive: true })
|
||
{
|
||
isThrottling = false;
|
||
return;
|
||
}
|
||
|
||
int count;
|
||
lock (ImageQueue)
|
||
{
|
||
count = ImageQueue.Count;
|
||
}
|
||
|
||
if (count <= frameLimit) break;
|
||
|
||
if (!isThrottling)
|
||
{
|
||
isThrottling = true;
|
||
throttleCount++;
|
||
}
|
||
|
||
if (!FrameDequeuedEvent.WaitOne(ThrottleWaitMilliseconds))
|
||
{
|
||
AsyncGPUReadback.WaitAllRequests();
|
||
}
|
||
}
|
||
isThrottling = false;
|
||
|
||
var currentFrame = frameCountForVideo++;
|
||
|
||
// The video cannot have more frames per second than the game renders: effective video FPS = min(VideoFPS, RenderFPS).
|
||
var renderFPS = Configuration.RenderFPS;
|
||
var videoFps = Configuration.VideoFPS;
|
||
var effectiveVideoFps = Math.Min(videoFps, renderFPS);
|
||
|
||
// Video frame that contains this game frame's time (currentFrame / renderFPS seconds), rounded down.
|
||
// Only the first game frame of each video frame is captured.
|
||
var videoFrameIndex = (long)(currentFrame * effectiveVideoFps / renderFPS);
|
||
|
||
if (videoFrameIndex > lastVideoFrameIndex)
|
||
{
|
||
lastVideoFrameIndex = videoFrameIndex;
|
||
Volatile.Write(ref lastRequestedVideoFrameIndex, videoFrameIndex);
|
||
|
||
var targetTexture = texture;
|
||
if (HasActiveFrameHooks && _frameHookPipeline != null)
|
||
{
|
||
var videoTime = effectiveVideoFps > 0 ? videoFrameIndex / effectiveVideoFps : 0.0;
|
||
targetTexture = _frameHookPipeline.Process(
|
||
texture,
|
||
videoFrameIndex,
|
||
currentFrame,
|
||
videoTime,
|
||
renderFPS,
|
||
effectiveVideoFps,
|
||
GetActiveFrameHooks()
|
||
) ?? texture;
|
||
}
|
||
|
||
_frameReader?.RequestFrameCapture(targetTexture, videoFrameIndex);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Handler of the render button in the level editor (added by scnEditorPatch).
|
||
/// When the level has no file path, scnEditor.TryQuitToMenu is called and no render starts.
|
||
/// Otherwise, after the editor's unsaved-changes prompt, removes scnEditor.TryApplicationQuit from
|
||
/// Application.wantsToQuit (it would block quitting with an unsaved-changes prompt; scnEditor registers it again
|
||
/// when the editor starts) and opens the render configuration window. Main thread.
|
||
/// </summary>
|
||
public static void StartRender()
|
||
{
|
||
var targetMethod = typeof(scnEditor).GetMethod("TryApplicationQuit",
|
||
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
|
||
|
||
if (targetMethod == null || !scnEditor.instance) return;
|
||
if (ADOBase.levelPath.IsNullOrEmpty())
|
||
{
|
||
scnEditor.instance.TryQuitToMenu();
|
||
return;
|
||
}
|
||
|
||
if (Instance) Instance.levelPath = ADOBase.levelPath;
|
||
scnEditor.instance.CheckUnsavedChanges(() =>
|
||
{
|
||
var quitDelegate =
|
||
(Func<bool>)Delegate.CreateDelegate(typeof(Func<bool>), scnEditor.instance, targetMethod);
|
||
|
||
Application.wantsToQuit -= quitDelegate;
|
||
RenderConfigWindow.CreateWindow();
|
||
});
|
||
}
|
||
|
||
/// <summary>Creates the default output directory (GlobalSettings.EffectiveOutputDirectory) when it does not exist.</summary>
|
||
public void SetupCaptureDirectory()
|
||
{
|
||
var renderDir = GlobalSettings.EffectiveOutputDirectory;
|
||
FileUtil.CreateDirectory(renderDir);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Loads scnGame with levelPath as the only custom level (checkpoint 0, speed trial multiplier 1) and arms the
|
||
/// press-to-start skip and the scene setup in Update. Seeds UnityEngine.Random when AdvancedConfig.RandomSeed is set,
|
||
/// so random effects repeat between renders. Called by RenderSession.Start.
|
||
/// </summary>
|
||
public void SetupGameScene()
|
||
{
|
||
GCS.customLevelPaths = new[] { levelPath };
|
||
GCS.checkpointNum = 0;
|
||
GCS.customLevelId = "";
|
||
GCS.nextSpeedRun = 1;
|
||
GCS.customLevelIndex = 0;
|
||
|
||
if (Configuration.AdvancedConfig.RandomSeed.HasValue) Random.InitState(Configuration.AdvancedConfig.RandomSeed.Value);
|
||
ADOBase.loader.LoadSceneWithTransition(WipeDirection.StartsFromRight, "scnGame");
|
||
skipPressToStart = true;
|
||
_renderSetup = true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Coroutine started on scrController when the game scene is set up (stage OnScene).
|
||
/// Waits the countdown (real-time seconds), sets the time bases, starts the encoder, the render thread and the
|
||
/// frame reader, switches to the Render stage, starts the level without the press-to-start wait, and creates the
|
||
/// offline audio mixer and spectrum generator. Stops without starting when the render was aborted during the
|
||
/// countdown. On an encoder initialization error, the render fails, the environment is restored and an error
|
||
/// dialog returns to the editor.
|
||
/// </summary>
|
||
private IEnumerator SetupPlay()
|
||
{
|
||
// The audio sample rate must be one the audio codec paired with the video codec supports
|
||
// (CodecUtil.AudioCodecMatch, CodecUtil.AvailableSampleRate); otherwise 48000 Hz is used.
|
||
if (Configuration.AudioConfig.RenderAudio)
|
||
{
|
||
if (!CodecUtil.AvailableSampleRate[CodecUtil.AudioCodecMatch[Configuration.VideoConfig.Codec]].Contains(Configuration.AudioConfig.AudioSampleRate))
|
||
Configuration.AudioConfig.AudioSampleRate = 48000; // most compatible value
|
||
}
|
||
|
||
for (; countdown > 0; countdown--)
|
||
{
|
||
yield return new WaitForSecondsRealtime(1);
|
||
}
|
||
|
||
// Cancelled or failed during the countdown: do not start the encoder
|
||
if (stage != RenderStage.OnScene) yield break;
|
||
|
||
frameCount = 0; framesSent = 0;
|
||
_renderStopwatch.Restart();
|
||
|
||
// Clock values at the start of capture. The time patches are not active yet (stage OnScene), so these are
|
||
// Unity's own values; from the Render stage the patched clocks continue from them at frameCount / RenderFPS.
|
||
timeBase = Time.timeAsDouble;
|
||
unscaledTimeBase = Time.unscaledTimeAsDouble;
|
||
dspTimeBase = AudioSettings.dspTime;
|
||
frameCountBase = Time.frameCount;
|
||
|
||
_frameReader?.Dispose();
|
||
_frameReader = null;
|
||
_frameHookPipeline?.Dispose();
|
||
_frameHookPipeline = new FrameHookPipeline();
|
||
_cachedGlobalHooksVersion = -1;
|
||
EnsureActiveHooksUpToDate();
|
||
// The frame reader converts on the GPU to the pixel format of the encoder that was actually opened.
|
||
try
|
||
{
|
||
StartFFmpegThread();
|
||
_frameReader = _activeVideoFFmpeg != null ? new FrameReader(_activeVideoFFmpeg.SelectedPixelFormat) : new FrameReader(AVPixelFormat.AV_PIX_FMT_YUV420P);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Melon<RenderMod>.Logger.Error($"Encoder initialization error: {ex}");
|
||
|
||
// Release the encoder/thread and restore time, input offset, stage and hooks before showing the dialog
|
||
MarkFailed($"failed to initialize the video encoder: {ex.Message}");
|
||
ResetRenderState(success: false);
|
||
StopFFmpeg(false);
|
||
RestoreRenderEnvironment();
|
||
|
||
CommonWarningDialogUI.ShowDialog(
|
||
"Encoder Error",
|
||
$"Failed to initialize video encoder.\nError: {ex.Message}",
|
||
new DialogButton("OK", () =>
|
||
{
|
||
ADOBase.loader.LoadSceneWithTransition(WipeDirection.StartsFromRight, "scnEditor");
|
||
Cursor.visible = true;
|
||
})
|
||
);
|
||
yield break;
|
||
}
|
||
|
||
Instance.stage = RenderStage.Render;
|
||
// levelWasSkipped ends the press-to-start wait loop of scrController (scrController.cs, WaitForStartCo).
|
||
scrController.instance.paused = scrController.instance.audioPaused = false;
|
||
scrController.instance.levelWasSkipped = true;
|
||
|
||
if (!scrConductor.instance || !scrConductor.instance.song) yield break;
|
||
if (Configuration.AudioConfig.RenderAudio)
|
||
{
|
||
AudioMixer = new OfflineAudioMixer(Configuration.AudioConfig.AudioChannels, Configuration.AudioConfig.AudioSampleRate);
|
||
AudioMixer.InitializeBGM(scrConductor.instance.song.clip);
|
||
|
||
var effectiveVideoFps = Math.Min(Configuration.VideoFPS, Configuration.RenderFPS);
|
||
SyncCalculator = new AudioSyncCalculator(Configuration.AudioConfig.AudioSampleRate, effectiveVideoFps);
|
||
}
|
||
|
||
if (Configuration.AdvancedConfig.ProcessAudio)
|
||
{
|
||
AudioSpectrumGenerator.Initialize(scrConductor.instance.song.clip, AudioMixer);
|
||
}
|
||
|
||
// The song is played by the offline mixer only: the clip is removed from the game's song AudioSource so Unity
|
||
// does not play it.
|
||
scrConductor.instance.song.clip = null;
|
||
scrConductor.instance.song.time = -1000;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Resets the queue and render thread state, opens the encoder on the output file (RenderContext.OutputPath, or
|
||
/// "yyyy-MM-dd HH-mm-ss.ext" in the output directory with the configured extension), and starts the render thread.
|
||
/// The output path is registered as incomplete before the encoder opens the file.
|
||
/// </summary>
|
||
/// <exception cref="Exception">The encoder could not be created or started; it is disposed before the exception is rethrown.</exception>
|
||
private void StartFFmpegThread()
|
||
{
|
||
if (!_debugMonitorObj)
|
||
{
|
||
_debugMonitorObj = new GameObject("DebugMonitorCanvas");
|
||
_debugMonitorObj.AddComponent<DebugMonitorUI>();
|
||
DontDestroyOnLoad(_debugMonitorObj);
|
||
}
|
||
|
||
lock (ImageQueue)
|
||
{
|
||
ImageQueue.Clear();
|
||
}
|
||
passCount = 0;
|
||
ClearAbortState();
|
||
frameCountForVideo = 0;
|
||
lastVideoFrameIndex = -1;
|
||
Volatile.Write(ref lastRequestedVideoFrameIndex, -1);
|
||
endRequested = false;
|
||
endSuccessful = false;
|
||
FrameAvailableEvent.Reset();
|
||
FrameDequeuedEvent.Reset();
|
||
|
||
var renderFPS = Configuration.RenderFPS;
|
||
var videoFPS = Configuration.VideoFPS;
|
||
|
||
var startTime = DateTime.Now;
|
||
if (RenderContext.OutputPath != null) CurrentOutPath = RenderContext.OutputPath;
|
||
else {
|
||
var fileName = startTime.ToString("yyyy-MM-dd HH-mm-ss") +
|
||
$".{Configuration.AdvancedConfig.FileExtension.TrimStart('.').ToLower()}";
|
||
CurrentOutPath = Path.Combine(GlobalSettings.EffectiveOutputDirectory, fileName);
|
||
}
|
||
|
||
FFmpegNativeEncoder? videoFFmpeg = null;
|
||
try
|
||
{
|
||
var effectiveVideoFps = Math.Min(videoFPS, renderFPS);
|
||
var codecId = CodecUtil.AudioCodecMatch[Configuration.VideoConfig.Codec];
|
||
var settings = new FFmpegNativeEncoder.EncoderSettings
|
||
{
|
||
Width = Configuration.RenderWidth,
|
||
Height = Configuration.RenderHeight,
|
||
FPS = effectiveVideoFps,
|
||
Codec = Configuration.VideoConfig.Codec,
|
||
Mode = Configuration.VideoConfig.RateControlMode,
|
||
QualityValue = Configuration.VideoConfig.QP,
|
||
TargetBitrate = Configuration.VideoConfig.Bitrate,
|
||
MaxBitrate = Configuration.VideoConfig.MaxBitrate,
|
||
GopSize = Configuration.VideoConfig.KeyframeInterval,
|
||
ForceSoftware = Configuration.VideoConfig.ForceSoftwareEncoder,
|
||
Audio = Configuration.AudioConfig.RenderAudio ? new FFmpegNativeEncoder.AudioSettings
|
||
{
|
||
SampleRate = Configuration.AudioConfig.AudioSampleRate,
|
||
Channels = Configuration.AudioConfig.AudioChannels,
|
||
InputSampleFormat = AVSampleFormat.AV_SAMPLE_FMT_FLT,
|
||
AudioCodecId = codecId,
|
||
Bitrate = Configuration.AudioConfig.AudioBitrate
|
||
} : null
|
||
};
|
||
|
||
videoFFmpeg = new FFmpegNativeEncoder(settings);
|
||
|
||
_activeVideoFFmpeg = videoFFmpeg;
|
||
lock (_allVideoFFmpegInstances)
|
||
{
|
||
_allVideoFFmpegInstances.Add(videoFFmpeg);
|
||
}
|
||
Volatile.Write(ref _incompleteOutputPath, CurrentOutPath);
|
||
videoFFmpeg.Start(CurrentOutPath);
|
||
}
|
||
catch (Exception)
|
||
{
|
||
if (videoFFmpeg != null)
|
||
{
|
||
lock (_allVideoFFmpegInstances)
|
||
{
|
||
_allVideoFFmpegInstances.Remove(videoFFmpeg);
|
||
}
|
||
videoFFmpeg.Dispose();
|
||
}
|
||
_activeVideoFFmpeg = null;
|
||
throw;
|
||
}
|
||
|
||
// Background thread: it does not keep the process alive when the game quits.
|
||
var encoder = videoFFmpeg;
|
||
RenderThread = new Thread(() => RunRenderThread(encoder))
|
||
{
|
||
IsBackground = true,
|
||
Priority = ThreadPriority.AboveNormal
|
||
};
|
||
|
||
RenderThread.Start();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Body of the render thread. Sends queued frames and their audio to the encoder until the render ends,
|
||
/// finishes the output file, and releases the encoder. An exception is handled as a render failure.
|
||
/// </summary>
|
||
private void RunRenderThread(FFmpegNativeEncoder videoFFmpeg)
|
||
{
|
||
try
|
||
{
|
||
EncodeQueuedFrames(videoFFmpeg);
|
||
|
||
if (!IsRenderAborted)
|
||
{
|
||
// End throws when the file cannot be finished (e.g. the trailer cannot be written),
|
||
// which is handled as a render failure by the catch block below.
|
||
videoFFmpeg.End();
|
||
Volatile.Write(ref _incompleteOutputPath, null);
|
||
}
|
||
videoFFmpeg.Dispose();
|
||
UnregisterEncoder(videoFFmpeg);
|
||
|
||
endSuccessful = !IsRenderAborted;
|
||
}
|
||
catch (OperationCanceledException) when (IsRenderAborted)
|
||
{
|
||
// Audio waits end with OperationCanceledException when the render is cancelled or has failed (OfflineAudioMixer.Cancel).
|
||
Melon<RenderMod>.Logger.Msg("Render thread stopped: the render was aborted.");
|
||
DisposeEncoderAfterStop(videoFFmpeg);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Melon<RenderMod>.Logger.Error($"FFmpeg rendering thread error: {ex}");
|
||
|
||
MarkFailed("encoder thread error. See the log for details.");
|
||
DisposeEncoderAfterStop(videoFFmpeg);
|
||
}
|
||
}
|
||
|
||
/// <summary>Releases the encoder after the render thread stopped early (abort or error) and removes it from the encoder list.</summary>
|
||
private void DisposeEncoderAfterStop(FFmpegNativeEncoder videoFFmpeg)
|
||
{
|
||
try
|
||
{
|
||
videoFFmpeg.Dispose();
|
||
}
|
||
catch (Exception disposeEx)
|
||
{
|
||
Melon<RenderMod>.Logger.Error($"Encoder dispose after the render thread stopped also failed: {disposeEx.Message}");
|
||
}
|
||
UnregisterEncoder(videoFFmpeg);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Takes frames from ImageQueue in passCount order and sends each one to the encoder, followed by the audio
|
||
/// samples of that frame. Waits on FrameAvailableEvent (50ms) while no frame is ready.
|
||
/// Returns when the render is aborted (checked before every frame, frames left in ImageQueue are released
|
||
/// by the cleanup after the thread ends) or all requested frames have been sent after endRequested.
|
||
/// </summary>
|
||
private void EncodeQueuedFrames(FFmpegNativeEncoder videoFFmpeg)
|
||
{
|
||
while (true)
|
||
{
|
||
if (IsRenderAborted) return;
|
||
|
||
if (TryDequeueNextFrame(out var frame))
|
||
{
|
||
FrameDequeuedEvent.Set();
|
||
SendVideoFrame(videoFFmpeg, frame);
|
||
WriteAudioForFrame(videoFFmpeg);
|
||
continue;
|
||
}
|
||
|
||
if (ShouldStopEncodeLoop()) return;
|
||
|
||
FrameAvailableEvent.WaitOne(50);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Removes the frame whose key equals passCount from ImageQueue and advances passCount. Render thread.
|
||
/// While the stage is below Render, passCount jumps forward to the first queued key when that key is greater:
|
||
/// frames are only captured in the Render stage, so this happens after the stage was set back to None at the end
|
||
/// of the render while the thread drains the queue, and a frame whose readback has not arrived yet is skipped.
|
||
/// Returns false when the queue is empty or the next frame has not arrived yet.
|
||
/// </summary>
|
||
private bool TryDequeueNextFrame(out CapturedFrame frame)
|
||
{
|
||
frame = default;
|
||
lock (ImageQueue)
|
||
{
|
||
if (ImageQueue.Count == 0) return false;
|
||
|
||
var firstKey = ImageQueue.Keys[0];
|
||
if (firstKey > passCount && Instance.stage < RenderStage.Render)
|
||
{
|
||
passCount = firstKey;
|
||
}
|
||
|
||
if (firstKey != passCount) return false;
|
||
|
||
frame = ImageQueue[firstKey];
|
||
ImageQueue.RemoveAt(0);
|
||
passCount++;
|
||
return true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Sends one captured frame to the encoder and releases its buffer (managed: ArrayPool, native: readback state).
|
||
/// A frame without data is skipped (not counted in framesSent). Render thread.
|
||
/// </summary>
|
||
private void SendVideoFrame(FFmpegNativeEncoder videoFFmpeg, in CapturedFrame frame)
|
||
{
|
||
if (frame.ManagedBuffer != null)
|
||
{
|
||
if (frame.ManagedBuffer.Length == 0) return;
|
||
|
||
videoFFmpeg.SendDataFromBuffer(frame.ManagedBuffer, frame.Length, frame.IsColorConverted);
|
||
Interlocked.Increment(ref framesSent);
|
||
|
||
ArrayPool<byte>.Shared.Return(frame.ManagedBuffer);
|
||
return;
|
||
}
|
||
|
||
if (frame.NativePointer == IntPtr.Zero || frame.Length <= 0) return;
|
||
|
||
videoFFmpeg.SendDataFromNativeBuffer(frame.NativePointer, frame.Length, frame.IsColorConverted);
|
||
Interlocked.Increment(ref framesSent);
|
||
|
||
if (frame.ReadbackState != null)
|
||
{
|
||
_frameReader?.RecycleState(frame.ReadbackState);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Mixes the audio of the frame that was just sent (index passCount - 1) and writes it to the encoder.
|
||
/// The sample count per frame comes from SyncCalculator (sample rate / effective video FPS, with the remainder
|
||
/// carried to later frames). Mixing waits until the main Unity thread has committed the audio commands up to that time.
|
||
/// Does nothing when audio rendering is off. Render thread.
|
||
/// </summary>
|
||
/// <exception cref="OperationCanceledException">The mixer was cancelled (render aborted) while waiting.</exception>
|
||
private void WriteAudioForFrame(FFmpegNativeEncoder videoFFmpeg)
|
||
{
|
||
if (!Configuration.AudioConfig.RenderAudio || SyncCalculator is not { } syncCalculator) return;
|
||
|
||
var channels = Configuration.AudioConfig.AudioChannels;
|
||
var samplesNeeded = syncCalculator.GetNextFrameSamples();
|
||
|
||
var audioBuffer = ArrayPool<float>.Shared.Rent(samplesNeeded * channels);
|
||
try
|
||
{
|
||
AudioMixer?.GenerateAudioForFrame(audioBuffer, samplesNeeded);
|
||
videoFFmpeg.WriteAudioSamples(audioBuffer, samplesNeeded);
|
||
}
|
||
finally
|
||
{
|
||
ArrayPool<float>.Shared.Return(audioBuffer);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// True when the render is aborted, or when the end was requested and every requested frame has been sent.
|
||
/// </summary>
|
||
private bool ShouldStopEncodeLoop()
|
||
{
|
||
if (IsRenderAborted) return true;
|
||
|
||
return endRequested && passCount > Volatile.Read(ref lastRequestedVideoFrameIndex);
|
||
}
|
||
|
||
/// <summary>Removes the encoder from the cleanup list and clears _activeVideoFFmpeg. Called by the render thread when it finishes.</summary>
|
||
private void UnregisterEncoder(FFmpegNativeEncoder videoFFmpeg)
|
||
{
|
||
lock (_allVideoFFmpegInstances)
|
||
{
|
||
_allVideoFFmpegInstances.Remove(videoFFmpeg);
|
||
}
|
||
_activeVideoFFmpeg = null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Stops the render without finishing the file (cancelled, or failed when MarkFailed was called first), deletes
|
||
/// the unfinished file, reports the result through OnComplete, restores the environment and returns to the editor.
|
||
/// Called by the ESC handler and on failures. Main thread.
|
||
/// </summary>
|
||
public void CancelRender()
|
||
{
|
||
ResetRenderState(success: false);
|
||
|
||
StopFFmpeg(false);
|
||
EndRender();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Requests the end of encoding. Main thread.
|
||
/// <paramref name="success"/> true: completes the audio commands and starts StopRenderCoroutine, which waits for
|
||
/// the render thread to send the remaining frames and finish the file.
|
||
/// <paramref name="success"/> false: marks the render as cancelled (unless failed), cancels the audio waits, waits up
|
||
/// to 2 s for the render thread, disposes the encoder, releases the queued frames, the frame reader, the hooks and
|
||
/// the debug monitor, restores the camera and no-fail flags, deletes the unfinished file and calls OnComplete with
|
||
/// a failure result. Does not restore time, input offset or the scene (EndRender / RestoreRenderEnvironment do).
|
||
/// </summary>
|
||
private void StopFFmpeg(bool success)
|
||
{
|
||
endRequested = true;
|
||
if (!success)
|
||
{
|
||
MarkCancelled();
|
||
}
|
||
// The abort state is set first: the render thread reads it when its audio wait is cancelled.
|
||
if (success) AudioMixer?.Complete();
|
||
else AudioMixer?.Cancel();
|
||
FrameAvailableEvent.Set();
|
||
skipPressToStart = false;
|
||
_renderSetup = false;
|
||
if (_escapeHandlerObj)
|
||
{
|
||
Destroy(_escapeHandlerObj);
|
||
_escapeHandlerObj = null;
|
||
}
|
||
|
||
if (success) StartCoroutine(StopRenderCoroutine());
|
||
else
|
||
{
|
||
var reason = IsRenderFailed ? $"FAILED ({_failureReason})" : "CANCELLED";
|
||
Melon<RenderMod>.Logger.Error($"Rendering {reason}. Safely cleaning up state and resources.");
|
||
|
||
// 1. Wait (up to 2s) for the render background thread to see the abort flag and terminate
|
||
if (RenderThread is { IsAlive: true })
|
||
{
|
||
RenderThread.Join(2000);
|
||
}
|
||
|
||
// 2. Release the encoder. The render thread normally released it already (_activeVideoFFmpeg is then null).
|
||
// When the thread is still running after the 2 s wait, the encoder is disposed while that thread may still use it.
|
||
if (_activeVideoFFmpeg != null)
|
||
{
|
||
_activeVideoFFmpeg.Dispose();
|
||
_activeVideoFFmpeg = null;
|
||
}
|
||
|
||
// 3. Memory leak prevention: Return rented temporary frame buffer pool in queue and clear
|
||
lock (ImageQueue)
|
||
{
|
||
foreach (var kvp in ImageQueue.Values)
|
||
{
|
||
if (kvp.ManagedBuffer is { Length: > 0 })
|
||
{
|
||
ArrayPool<byte>.Shared.Return(kvp.ManagedBuffer);
|
||
}
|
||
if (kvp.ReadbackState != null)
|
||
{
|
||
_frameReader?.RecycleState(kvp.ReadbackState);
|
||
}
|
||
}
|
||
ImageQueue.Clear();
|
||
}
|
||
|
||
_frameReader?.Dispose();
|
||
ResetFrameHookState();
|
||
|
||
// Clean up Debug Monitor UI
|
||
if (_debugMonitorObj)
|
||
{
|
||
Destroy(_debugMonitorObj);
|
||
_debugMonitorObj = null;
|
||
}
|
||
|
||
// 4. Safely restore in-game camera and RTCam state for rendering
|
||
if (scrCamera.instance)
|
||
{
|
||
scrCamera.instance.forceRTCam = false;
|
||
scrCamera.instance.SetupRTCam(false);
|
||
|
||
var hook = scrCamera.instance.GetComponent<PostRenderHook>();
|
||
if (hook) Destroy(hook);
|
||
}
|
||
|
||
// 5. Restore in-game no-fail flags
|
||
if (scrController.instance)
|
||
{
|
||
scrController.instance.noFail = false;
|
||
scrController.instance.noFailInfiniteMargin = false;
|
||
}
|
||
|
||
// 6. Immediately delete the incomplete video file of this render
|
||
if (DeleteIncompleteOutputFile())
|
||
{
|
||
CurrentOutPath = null;
|
||
}
|
||
|
||
var result = BuildResult(false, BuildAbortMessage());
|
||
TriggerOnComplete(result);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Successful end: waits (one check per frame) until the render thread reports endSuccessful or has died.
|
||
/// On success calls OnComplete with a success result and EndRender; when the thread died without finishing
|
||
/// the file, the render fails and is cancelled (file deleted).
|
||
/// </summary>
|
||
private IEnumerator StopRenderCoroutine()
|
||
{
|
||
yield return new WaitUntil(() => endSuccessful || RenderThread is not { IsAlive: true });
|
||
if (!endSuccessful)
|
||
{
|
||
MarkFailed("the render thread terminated unexpectedly.");
|
||
CancelRender();
|
||
yield break;
|
||
}
|
||
|
||
var result = BuildResult(success: true);
|
||
TriggerOnComplete(result);
|
||
|
||
EndRender();
|
||
}
|
||
|
||
/// <summary>Restores the render environment and loads the level editor (scnEditor).</summary>
|
||
private void EndRender()
|
||
{
|
||
RestoreRenderEnvironment();
|
||
|
||
ADOBase.loader.LoadSceneWithTransition(WipeDirection.StartsFromRight, "scnEditor");
|
||
Cursor.visible = true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Undoes what the render setup changed (time scale and capture delta time, input offset, autoplay, custom level
|
||
/// paths, queued frames, frame reader, frame hooks, audio mixer and spectrum, RenderContext options), without
|
||
/// leaving the scene.
|
||
/// </summary>
|
||
private void RestoreRenderEnvironment()
|
||
{
|
||
Time.timeScale = 1f;
|
||
Time.captureDeltaTime = 0f;
|
||
|
||
if (_debugMonitorObj)
|
||
{
|
||
Destroy(_debugMonitorObj);
|
||
_debugMonitorObj = null;
|
||
}
|
||
|
||
RDC.auto = false;
|
||
scrConductor.currentPreset.inputOffset = _originalInputOffset;
|
||
GCS.customLevelPaths = null;
|
||
GCS.customLevelId = null;
|
||
|
||
lock (ImageQueue)
|
||
{
|
||
foreach (var kvp in ImageQueue.Values)
|
||
{
|
||
if (kvp.ManagedBuffer is { Length: > 0 })
|
||
{
|
||
ArrayPool<byte>.Shared.Return(kvp.ManagedBuffer);
|
||
}
|
||
if (kvp.ReadbackState != null)
|
||
{
|
||
_frameReader?.RecycleState(kvp.ReadbackState);
|
||
}
|
||
}
|
||
ImageQueue.Clear();
|
||
}
|
||
|
||
_frameReader?.Dispose();
|
||
ResetFrameHookState();
|
||
AudioSpectrumGenerator.Clear();
|
||
AudioMixer?.Dispose(); AudioMixer = null;
|
||
SyncCalculator = null;
|
||
|
||
RenderContext.Reset();
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Stops the render stopwatch and creates the result: frames sent, video duration (frames / effective video FPS),
|
||
/// wall-clock render time, and the output path and file size on success.
|
||
/// </summary>
|
||
private RenderResult BuildResult(bool success, string? errorMessage = null)
|
||
{
|
||
_renderStopwatch.Stop();
|
||
var effectiveFps = Math.Min(Configuration.VideoFPS, Configuration.RenderFPS);
|
||
var sent = Interlocked.Read(ref framesSent);
|
||
|
||
return success
|
||
? RenderResult.CreateSuccess(CurrentOutPath ?? string.Empty, sent, effectiveFps, _renderStopwatch.Elapsed)
|
||
: RenderResult.CreateFailure(errorMessage, sent, effectiveFps, _renderStopwatch.Elapsed);
|
||
}
|
||
|
||
/// <summary>Invokes RenderContext.OnComplete; an exception from the callback is logged.</summary>
|
||
private static void TriggerOnComplete(RenderResult result)
|
||
{
|
||
try
|
||
{
|
||
RenderContext.OnComplete.Invoke(result);
|
||
}
|
||
catch (Exception err)
|
||
{
|
||
Melon<RenderMod>.Logger.Error($"OnComplete callback caused error: {err}");
|
||
}
|
||
}
|
||
|
||
/// <summary>Invokes RenderContext.OnLastUpdate; an exception from the callback is logged.</summary>
|
||
private static void TriggerOnLastUpdate()
|
||
{
|
||
try
|
||
{
|
||
RenderContext.OnLastUpdate.Invoke();
|
||
}
|
||
catch (Exception err)
|
||
{
|
||
Melon<RenderMod>.Logger.Error($"OnLastUpdate callback caused error: {err}");
|
||
}
|
||
}
|
||
} |