wehub-resource-sync
602 lines
25 KiB
C#
602 lines
25 KiB
C#
using System.Threading;
|
|
using Sdcb.FFmpeg.Raw;
|
|
using Sdcb.FFmpeg.Utils;
|
|
using SharpDX.Direct3D11;
|
|
using SharpDX.DXGI;
|
|
using T3.Core.Logging;
|
|
using T3.Core.Resource;
|
|
using T3.Core.Video;
|
|
using CoreTexture2D = T3.Core.DataTypes.Texture2D;
|
|
|
|
namespace T3.VideoServices;
|
|
|
|
/// <summary>
|
|
/// Drives playback of one video for one operator instance. Decoding and YUV→RGBA conversion run on a
|
|
/// dedicated worker thread so they never block the render thread; the render thread only uploads the most
|
|
/// recent converted frame into the output <see cref="CoreTexture2D"/> (the D3D immediate context must stay
|
|
/// on the render thread). The last-valid texture is retained, so a not-yet-ready frame never blanks output.
|
|
///
|
|
/// The worker decodes toward the latest requested time (stale requests are discarded), advancing
|
|
/// sequentially when the target is just ahead and exact-seeking on a discontinuity. Forward playback and
|
|
/// export therefore stay on the fast sequential path.
|
|
/// </summary>
|
|
public sealed class VideoPlaybackController : IDisposable
|
|
{
|
|
public CoreTexture2D? Texture { get; private set; }
|
|
public float Duration { get; private set; }
|
|
public bool HasCompleted { get; private set; }
|
|
|
|
/// <summary>False until the requested frame is on screen (drives export-gated <c>Playback.OpNotReady</c>).</summary>
|
|
public bool IsReady { get; private set; }
|
|
|
|
/// <summary>Non-null when the file can't be opened or FFmpeg is unavailable.</summary>
|
|
public string? ErrorMessage { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Posts the requested time to the decode worker and uploads the latest ready frame. Returns true when a
|
|
/// new frame was uploaded this call. Runs on the render thread; never blocks on decoding.
|
|
/// </summary>
|
|
public bool Update(string absolutePath, double requestedSeconds, bool loop, bool renderingToFile,
|
|
VideoPlaybackOptimization optimization)
|
|
{
|
|
EnsureWorkerStarted();
|
|
|
|
lock (_lock)
|
|
{
|
|
_requestedUrl = absolutePath;
|
|
_requestedSeconds = requestedSeconds;
|
|
_requestedLoop = loop;
|
|
_requestedMode = optimization;
|
|
}
|
|
|
|
_wake.Set();
|
|
|
|
// Export is not real-time and must be frame-exact, so block until the worker has produced the
|
|
// requested frame. (Realtime playback stays asynchronous and shows the last-valid texture meanwhile.)
|
|
if (renderingToFile)
|
|
WaitForRequestedFrame(requestedSeconds, loop);
|
|
|
|
var produced = false;
|
|
var gotGpuFrame = false;
|
|
double duration;
|
|
bool isOpen;
|
|
long readyTarget;
|
|
lock (_lock)
|
|
{
|
|
if (_zeroCopy)
|
|
{
|
|
if (_hasPendingGpuFrame)
|
|
{
|
|
unsafe { ffmpeg.av_frame_move_ref(_renderGpuFrame, _pendingGpuFrame); }
|
|
_lastUploadedTarget = _pendingTarget;
|
|
_hasPendingGpuFrame = false;
|
|
gotGpuFrame = true;
|
|
// This frame's surface belongs to the current session. Claim it so a concurrent mode/source
|
|
// switch on the worker can't dispose that session while Convert is reading the surface below.
|
|
_renderConverting = true;
|
|
}
|
|
}
|
|
else if (_hasPendingFrame)
|
|
{
|
|
UploadPendingFrame();
|
|
_lastUploadedTarget = _pendingTarget;
|
|
_hasPendingFrame = false;
|
|
produced = true;
|
|
}
|
|
|
|
duration = _duration;
|
|
isOpen = _isOpen;
|
|
ErrorMessage = _errorMessage;
|
|
|
|
readyTarget = isOpen && _timeBaseDen > 0
|
|
? TimeToFrameMapper.SecondsToFramePts(
|
|
TimeToFrameMapper.ResolvePlaybackSeconds(requestedSeconds, duration, loop),
|
|
_streamStartPts, _timeBaseNum, _timeBaseDen, _frameRate)
|
|
: 0;
|
|
}
|
|
|
|
if (gotGpuFrame)
|
|
{
|
|
// Convert on the render thread's immediate context (outside the lock). The converter owns the output
|
|
// texture; Texture just points at it.
|
|
_hardwareConverter ??= new HardwareFrameConverter();
|
|
try
|
|
{
|
|
var converted = _hardwareConverter.Convert(_renderGpuFrame, _renderGpuFrame.Width, _renderGpuFrame.Height);
|
|
if (converted != null)
|
|
{
|
|
Texture = converted;
|
|
produced = true;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
// A convert can transiently fail right after a source/mode switch — a frame whose decoder session is
|
|
// being torn down, or the shared device mid-reconfigure. Keep the last valid texture rather than
|
|
// nulling the output or letting the exception surface as an operator error; the next frame recovers.
|
|
Log.Debug($"Zero-copy convert skipped (transient): {e.Message}");
|
|
}
|
|
finally
|
|
{
|
|
_renderGpuFrame.Unref();
|
|
lock (_lock)
|
|
{
|
|
_renderConverting = false;
|
|
Monitor.PulseAll(_lock); // release a worker waiting in OpenSource to tear the session down
|
|
}
|
|
}
|
|
}
|
|
|
|
Duration = (float)duration;
|
|
HasCompleted = isOpen && !loop && requestedSeconds >= duration - FrameEpsilonSeconds;
|
|
IsReady = Texture != null && isOpen && _lastUploadedTarget == readyTarget;
|
|
return produced;
|
|
}
|
|
|
|
// Blocks the render thread until the worker has decoded the requested frame (export only). Bounded by a
|
|
// timeout so a decode failure can't freeze the export — it just yields and the exporter retries.
|
|
private void WaitForRequestedFrame(double requestedSeconds, bool loop)
|
|
{
|
|
var deadline = Environment.TickCount64 + ExportFrameTimeoutMs;
|
|
while (Environment.TickCount64 < deadline)
|
|
{
|
|
lock (_lock)
|
|
{
|
|
if (_errorMessage != null)
|
|
return;
|
|
|
|
if (_isOpen && _timeBaseDen > 0)
|
|
{
|
|
var target = TimeToFrameMapper.SecondsToFramePts(
|
|
TimeToFrameMapper.ResolvePlaybackSeconds(requestedSeconds, _duration, loop),
|
|
_streamStartPts, _timeBaseNum, _timeBaseDen, _frameRate);
|
|
|
|
if (_lastUploadedTarget == target || (_hasPendingFrame && _pendingTarget == target))
|
|
return;
|
|
}
|
|
}
|
|
|
|
_framePublished.Wait(20);
|
|
_framePublished.Reset();
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_cancellation.Cancel();
|
|
_wake.Set();
|
|
_worker?.Join(TimeSpan.FromSeconds(2));
|
|
|
|
// The worker has exited, so its resources can be released without racing it.
|
|
_hardwareConverter?.Dispose();
|
|
_pendingGpuFrame.Dispose();
|
|
_renderGpuFrame.Dispose();
|
|
_converter?.Dispose();
|
|
_session?.Dispose();
|
|
_cache?.Dispose();
|
|
_softwareTexture?.Dispose(); // the zero-copy output texture is owned (and disposed) by the converter above
|
|
Texture = null;
|
|
_wake.Dispose();
|
|
_framePublished.Dispose();
|
|
_cancellation.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Assigns this stream's frame-cache budget — the engine's share of the shared global budget. Safe to
|
|
/// call from the engine's eval thread; the worker applies it to its cache on the next request.
|
|
/// </summary>
|
|
public void SetCacheBudget(long bytes) => Volatile.Write(ref _cacheBudget, bytes);
|
|
|
|
// ---- render thread ----
|
|
|
|
private void EnsureWorkerStarted()
|
|
{
|
|
if (_worker != null)
|
|
return;
|
|
|
|
_worker = new Thread(WorkerLoop) { IsBackground = true, Name = "FFmpeg decode" };
|
|
_worker.Start();
|
|
}
|
|
|
|
private unsafe void UploadPendingFrame()
|
|
{
|
|
var format = _pendingIsHdr ? Format.R16G16B16A16_UNorm : Format.R8G8B8A8_UNorm;
|
|
var bytesPerPixel = _pendingIsHdr ? 8 : 4;
|
|
|
|
// Own a dedicated software-upload texture, separate from the zero-copy converter's output. The two used to
|
|
// alias through Texture, so switching zero-copy → software disposed the converter's output behind its back;
|
|
// switching back then threw "COM object null" when EnsureOutput read the freed texture's description.
|
|
if (_softwareTexture == null || _softwareTexture.Description.Width != _pendingWidth
|
|
|| _softwareTexture.Description.Height != _pendingHeight || _softwareTexture.Description.Format != format)
|
|
{
|
|
_softwareTexture?.Dispose();
|
|
_softwareTexture = CoreTexture2D.CreateTexture2D(new Texture2DDescription
|
|
{
|
|
Width = _pendingWidth,
|
|
Height = _pendingHeight,
|
|
ArraySize = 1,
|
|
MipLevels = 1,
|
|
Format = format,
|
|
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget | BindFlags.UnorderedAccess,
|
|
CpuAccessFlags = CpuAccessFlags.None,
|
|
OptionFlags = ResourceOptionFlags.None,
|
|
Usage = ResourceUsage.Default,
|
|
SampleDescription = new SampleDescription(1, 0),
|
|
});
|
|
}
|
|
|
|
fixed (byte* pixels = _pendingBuffer)
|
|
{
|
|
var dataBox = new SharpDX.DataBox((IntPtr)pixels, _pendingWidth * bytesPerPixel, 0);
|
|
ResourceManager.Device.ImmediateContext.UpdateSubresource(dataBox, _softwareTexture, 0);
|
|
}
|
|
|
|
Texture = _softwareTexture;
|
|
}
|
|
|
|
// ---- worker thread ----
|
|
|
|
private void WorkerLoop()
|
|
{
|
|
while (!_cancellation.IsCancellationRequested)
|
|
{
|
|
_wake.WaitOne();
|
|
if (_cancellation.IsCancellationRequested)
|
|
break;
|
|
|
|
try
|
|
{
|
|
ProcessLatestRequest();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
// An unhandled exception on a background thread would terminate the editor process, so a
|
|
// transient decode/convert failure is contained and surfaced as an operator error instead.
|
|
lock (_lock)
|
|
{
|
|
_errorMessage = "Video decoding failed: " + e.Message;
|
|
}
|
|
|
|
Log.Warning("FFmpeg decode worker error: " + e);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ProcessLatestRequest()
|
|
{
|
|
string? url;
|
|
double seconds;
|
|
bool loop;
|
|
VideoPlaybackOptimization mode;
|
|
lock (_lock)
|
|
{
|
|
url = _requestedUrl;
|
|
seconds = _requestedSeconds;
|
|
loop = _requestedLoop;
|
|
mode = _requestedMode;
|
|
}
|
|
|
|
if (url == null)
|
|
return;
|
|
|
|
if (url != _workerUrl || mode != _workerMode)
|
|
OpenSource(url, mode);
|
|
|
|
if (_session == null)
|
|
return;
|
|
|
|
_cache?.SetBudget(Volatile.Read(ref _cacheBudget));
|
|
|
|
var playSeconds = TimeToFrameMapper.ResolvePlaybackSeconds(seconds, _session.DurationSeconds, loop);
|
|
var target = TimeToFrameMapper.SecondsToFramePts(playSeconds, _session.StreamStartPts,
|
|
_session.TimeBaseNum, _session.TimeBaseDen, _session.FrameRate);
|
|
|
|
if (target == _workerLastTarget)
|
|
return;
|
|
|
|
Frame frameToPublish;
|
|
if (_cache != null && _cache.TryGet(FrameIndexForTime(playSeconds), out var cachedFrame))
|
|
{
|
|
frameToPublish = cachedFrame;
|
|
}
|
|
else
|
|
{
|
|
if (!DecodeTo(target))
|
|
return;
|
|
|
|
frameToPublish = _session!.CurrentFrame;
|
|
}
|
|
|
|
PublishFrame(frameToPublish, target);
|
|
_workerLastTarget = target;
|
|
PrefetchAhead(target);
|
|
}
|
|
|
|
private void OpenSource(string url, VideoPlaybackOptimization mode)
|
|
{
|
|
_workerUrl = url;
|
|
_workerMode = mode;
|
|
|
|
// Both GPU frames referencing the previous session's surfaces must be released before we dispose it, or a
|
|
// convert on the render thread reads freed D3D resources. The still-queued frame we can drop here; a frame
|
|
// already handed to the render thread (mid-Convert) we must WAIT for — its convert AddRefs the surface, and
|
|
// on a freed resource that's an AccessViolationException, which a normal try/catch can't contain.
|
|
lock (_lock)
|
|
{
|
|
if (_hasPendingGpuFrame)
|
|
{
|
|
_pendingGpuFrame.Unref();
|
|
_hasPendingGpuFrame = false;
|
|
}
|
|
|
|
while (_renderConverting)
|
|
Monitor.Wait(_lock);
|
|
}
|
|
|
|
_converter?.Dispose();
|
|
_converter = null;
|
|
_session?.Dispose();
|
|
_session = null;
|
|
_cache?.Dispose();
|
|
_cache = null;
|
|
_workerLastTarget = NotSet;
|
|
_workerLastDecodedPts = NotSet;
|
|
|
|
var session = VideoDecoderSession.TryOpen(url, mode, out var error);
|
|
lock (_lock)
|
|
{
|
|
_errorMessage = error;
|
|
_isOpen = session != null;
|
|
_zeroCopy = session?.UsesZeroCopy ?? false;
|
|
_duration = session?.DurationSeconds ?? 0;
|
|
_timeBaseNum = session?.TimeBaseNum ?? 0;
|
|
_timeBaseDen = session?.TimeBaseDen ?? 0;
|
|
_streamStartPts = session?.StreamStartPts ?? 0;
|
|
_frameRate = session?.FrameRate ?? 0;
|
|
}
|
|
|
|
if (session == null)
|
|
return;
|
|
|
|
_session = session;
|
|
var path = session.UsesZeroCopy ? "D3D11VA hardware (zero-copy)"
|
|
: session.UsesHardwareDecode ? "D3D11VA hardware (CPU read-back)" : "software";
|
|
Log.Gated.VideoRender($"Video decode path: {path} — {session.Width}x{session.Height} {session.PixelFormat}");
|
|
|
|
// ~0.5 s prefetch lead. Forward catch-up seeks only past this; it grows to the observed GOP depth so
|
|
// decoding forward inside one long GOP never re-seeks the keyframe (starts at ~0.5 s before learning).
|
|
_workerSequentialThreshold = session.TimeBaseDen / (2L * Math.Max(1, session.TimeBaseNum));
|
|
_workerForwardSeekThreshold = _workerSequentialThreshold;
|
|
|
|
// Zero-copy converts on the render thread straight from the GPU surface, so it uses neither the swscale
|
|
// converter nor the RAM frame cache (the decoder's fixed texture pool can't be retained).
|
|
if (!session.UsesZeroCopy)
|
|
{
|
|
_converter = new SoftwareFrameConverter(session.IsHdr);
|
|
_cache = new VideoFrameCache(Volatile.Read(ref _cacheBudget));
|
|
_cachedFrameBytes = ffmpeg.av_image_get_buffer_size(session.PixelFormat, session.Width, session.Height, 1);
|
|
}
|
|
}
|
|
|
|
// Cache key for a decoded frame: the frame-grid-snapped PTS of the frame containing it — the same value the
|
|
// render thread asks for (SecondsToFramePts). Keying by the raw decode PTS instead misses on every lookup
|
|
// (the snapped target rarely equals the frame's exact PTS, e.g. 41 vs 42 at 23.976 fps), which forces a
|
|
// re-decode — and, since prefetch has run the decoder ahead, a backward seek + GOP re-decode — every frame.
|
|
// Cache key = integer frame index. The render thread asks for the frame at a time via FLOOR (the frame whose
|
|
// display interval contains it); a decoded frame reports which frame it IS via ROUND (its PTS sits on a frame
|
|
// boundary, so rounding avoids the float-edge off-by-one a floor would hit). Both yield the same index for one
|
|
// frame, so forward playback hits the prefetched cache instead of re-decoding (and backward-seeking) at stray
|
|
// indices. Falls back to raw PTS only when the frame rate is unknown.
|
|
private long FrameIndexForTime(double seconds)
|
|
{
|
|
var fps = _session!.FrameRate;
|
|
return fps > 0 ? (long)Math.Floor(seconds * fps) : 0;
|
|
}
|
|
|
|
private long FrameIndexForPts(long pts)
|
|
{
|
|
var fps = _session!.FrameRate;
|
|
if (fps <= 0)
|
|
return pts;
|
|
|
|
var seconds = TimeToFrameMapper.PtsToSeconds(pts, _session.StreamStartPts, _session.TimeBaseNum, _session.TimeBaseDen);
|
|
return (long)Math.Round(seconds * fps);
|
|
}
|
|
|
|
// Decodes forward to the target frame, caching every frame read so the surrounding GOP is available for
|
|
// cheap scrub-back. Seeks to the preceding keyframe first unless the target is a short hop ahead of the
|
|
// decoder's current position. Returns false if the stream ends before reaching the target.
|
|
private bool DecodeTo(long target)
|
|
{
|
|
var known = _workerLastDecodedPts != NotSet;
|
|
var delta = known ? target - _workerLastDecodedPts : 0;
|
|
|
|
// Seek only when the target is behind the decoder (no backward decode) or far enough ahead to likely cross
|
|
// into a later GOP, where a keyframe seek skips real decode work. A forward target inside the current GOP
|
|
// decodes forward instead — seeking back to the keyframe and re-running the whole GOP on every catch-up
|
|
// frame is what stops long-GOP playback from ever converging.
|
|
var seeking = !known || delta < 0 || delta > _workerForwardSeekThreshold;
|
|
|
|
if (seeking)
|
|
_session!.SeekToKeyframeBefore(target);
|
|
|
|
var firstPts = NotSet;
|
|
var decodedPts = _workerLastDecodedPts;
|
|
var reached = false;
|
|
while (_session!.TryReadNextFrame(out var pts))
|
|
{
|
|
if (firstPts == NotSet)
|
|
firstPts = pts;
|
|
_cache?.Add(FrameIndexForPts(pts), _session.CurrentFrame, _cachedFrameBytes);
|
|
decodedPts = pts;
|
|
if (pts >= target)
|
|
{
|
|
reached = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// After a seek the first decoded frame is the GOP keyframe, so keyframe→target is a live GOP-depth sample.
|
|
// Grow the forward-seek threshold to the deepest seen, so forward catch-up within one GOP stays sequential.
|
|
if (seeking && reached && firstPts != NotSet && target - firstPts > _workerForwardSeekThreshold)
|
|
_workerForwardSeekThreshold = target - firstPts;
|
|
|
|
if (!reached)
|
|
return false;
|
|
|
|
_workerLastDecodedPts = decodedPts;
|
|
return true;
|
|
}
|
|
|
|
// After serving the requested frame, decodes a short way past it into the cache so forward playback rides
|
|
// on cache hits and absorbs decode jitter. Only runs when the decoder is already at or ahead of the shown
|
|
// frame (the normal forward case) — it never seeks — and bails the instant the requested frame changes,
|
|
// so scrubbing stays responsive. Only caches; never publishes.
|
|
private void PrefetchAhead(long displayTarget)
|
|
{
|
|
if (_session == null || _cache == null || _workerLastDecodedPts == NotSet || _workerLastDecodedPts < displayTarget)
|
|
return;
|
|
|
|
var leadTarget = displayTarget + _workerSequentialThreshold;
|
|
for (var i = 0; i < PrefetchMaxFramesPerCycle && _workerLastDecodedPts < leadTarget; i++)
|
|
{
|
|
if (CurrentRequestTarget() != displayTarget)
|
|
return;
|
|
|
|
if (!_session.TryReadNextFrame(out var pts))
|
|
return;
|
|
|
|
_cache.Add(FrameIndexForPts(pts), _session.CurrentFrame, _cachedFrameBytes);
|
|
_workerLastDecodedPts = pts;
|
|
}
|
|
}
|
|
|
|
// The frame the render thread currently wants, recomputed from the latest posted request, so the prefetch
|
|
// loop can bail the moment the user scrubs. Returns NotSet if the source changed or isn't open.
|
|
private long CurrentRequestTarget()
|
|
{
|
|
string? url;
|
|
double seconds;
|
|
bool loop;
|
|
lock (_lock)
|
|
{
|
|
url = _requestedUrl;
|
|
seconds = _requestedSeconds;
|
|
loop = _requestedLoop;
|
|
}
|
|
|
|
if (url != _workerUrl || _session == null)
|
|
return NotSet;
|
|
|
|
var playSeconds = TimeToFrameMapper.ResolvePlaybackSeconds(seconds, _session.DurationSeconds, loop);
|
|
return TimeToFrameMapper.SecondsToFramePts(playSeconds, _session.StreamStartPts, _session.TimeBaseNum, _session.TimeBaseDen, _session.FrameRate);
|
|
}
|
|
|
|
private unsafe void PublishFrame(Frame frame, long target)
|
|
{
|
|
if (_zeroCopy)
|
|
{
|
|
lock (_lock)
|
|
{
|
|
_pendingGpuFrame.Unref(); // drop the previous un-shown frame (latest-wins)
|
|
ffmpeg.av_frame_ref(_pendingGpuFrame, frame); // pin the decoder's GPU surface for the render thread
|
|
_pendingTarget = target;
|
|
_hasPendingGpuFrame = true;
|
|
}
|
|
|
|
_framePublished.Set();
|
|
return;
|
|
}
|
|
|
|
var rgba = _converter!.Convert(frame);
|
|
var byteCount = rgba.Width * rgba.Height * _converter.BytesPerPixel;
|
|
|
|
lock (_lock)
|
|
{
|
|
if (_pendingBuffer == null || _pendingBuffer.Length < byteCount)
|
|
_pendingBuffer = new byte[byteCount];
|
|
|
|
rgba.FillImageBuffer(_pendingBuffer, 1);
|
|
_pendingWidth = rgba.Width;
|
|
_pendingHeight = rgba.Height;
|
|
_pendingIsHdr = _session!.IsHdr;
|
|
_pendingTarget = target;
|
|
_hasPendingFrame = true;
|
|
}
|
|
|
|
_framePublished.Set();
|
|
}
|
|
|
|
private const long NotSet = long.MinValue;
|
|
private const double FrameEpsilonSeconds = 1.0 / 1000.0;
|
|
private const int ExportFrameTimeoutMs = 5000;
|
|
|
|
// Default cache budget until the engine assigns this stream a share of the shared global budget.
|
|
private const long CacheBudgetBytes = 512L * 1024 * 1024;
|
|
|
|
// Cap on frames read ahead per cycle, so the first prefetch after a seek can't monopolize the worker; the
|
|
// lead distance itself is bounded by the sequential threshold (~0.5 s of video).
|
|
private const int PrefetchMaxFramesPerCycle = 90;
|
|
|
|
private readonly object _lock = new();
|
|
private readonly AutoResetEvent _wake = new(false);
|
|
private readonly ManualResetEventSlim _framePublished = new(false);
|
|
private readonly CancellationTokenSource _cancellation = new();
|
|
private Thread? _worker;
|
|
|
|
// Request (render thread → worker), guarded by _lock.
|
|
private string? _requestedUrl;
|
|
private double _requestedSeconds;
|
|
private bool _requestedLoop;
|
|
private VideoPlaybackOptimization _requestedMode;
|
|
|
|
// Source metadata (worker → render thread), guarded by _lock.
|
|
private bool _isOpen;
|
|
private string? _errorMessage;
|
|
private double _duration;
|
|
private int _timeBaseNum;
|
|
private int _timeBaseDen;
|
|
private long _streamStartPts;
|
|
private double _frameRate;
|
|
|
|
// Converted-frame handoff (worker → render thread), guarded by _lock.
|
|
private byte[]? _pendingBuffer;
|
|
private int _pendingWidth;
|
|
private int _pendingHeight;
|
|
private bool _pendingIsHdr;
|
|
private long _pendingTarget;
|
|
private bool _hasPendingFrame;
|
|
|
|
// Zero-copy GPU handoff (worker → render thread). _zeroCopy is set at open under _lock; the pending GPU
|
|
// frame is ref'd by the worker and moved out by the render thread, both under _lock.
|
|
private bool _zeroCopy;
|
|
private readonly Frame _pendingGpuFrame = new();
|
|
private bool _hasPendingGpuFrame;
|
|
|
|
// True while the render thread is converting _renderGpuFrame; OpenSource waits on it (under _lock) before
|
|
// disposing the session whose surface that frame references.
|
|
private bool _renderConverting;
|
|
|
|
// Render-thread only.
|
|
private long _lastUploadedTarget = NotSet;
|
|
private HardwareFrameConverter? _hardwareConverter;
|
|
private CoreTexture2D? _softwareTexture; // software/read-back upload target; the zero-copy output is the converter's.
|
|
private readonly Frame _renderGpuFrame = new();
|
|
|
|
// Cache budget assigned by the engine (its share of the shared global budget); the eval thread writes it,
|
|
// the worker reads it when creating or refreshing the cache.
|
|
private long _cacheBudget = CacheBudgetBytes;
|
|
|
|
// Worker-thread only.
|
|
private VideoDecoderSession? _session;
|
|
private SoftwareFrameConverter? _converter;
|
|
private VideoFrameCache? _cache;
|
|
private int _cachedFrameBytes;
|
|
private string? _workerUrl;
|
|
private VideoPlaybackOptimization _workerMode;
|
|
private long _workerLastTarget = NotSet;
|
|
private long _workerLastDecodedPts = NotSet;
|
|
private long _workerSequentialThreshold = 1;
|
|
private long _workerForwardSeekThreshold = 1;
|
|
}
|