A push now moves the base before its local file reads as sent; a replay journals itself in sync.json, writes the replayed versions, then the base (the commit point), and only then sets the old ones aside and adopts the local commits the home already held; a conflict met past such commits moves the base onto them first. A save-both journals its copy and the ids it sends under, so a retry completes the same copy instead of making another. The next push, pull or resolve finishes or undoes whatever a cut left, so no version is orphaned and no false conflict appears. The editor reads the working state and the media index under the project lease; workspace.json is written whole and moved into place (an empty one is made again); project files may hold 64 MiB and one that would be larger is refused before it is written, so large projects check out. The workspace copy checks the drive's free space before and during the copy, keeps the folder in its checkpoint and stores a reset when a pass starts again, and runs at High level in the priority queue. Renders record a version only when the index holds it with the settings rendered; an unsent version renders as the project. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
347 lines
17 KiB
C#
347 lines
17 KiB
C#
using System.IO;
|
|
using System.Text.Json;
|
|
using Chronos.Core.Advice;
|
|
using Chronos.Core.Analysis;
|
|
using Chronos.Core.Analysis.Deep;
|
|
using Chronos.Core.Archiving;
|
|
using Chronos.Core.Diagnostics;
|
|
using Chronos.Core.Export;
|
|
using Chronos.Core.Imaging;
|
|
using Chronos.Core.Localization;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Core.Project;
|
|
using Chronos.Core.Render;
|
|
using Chronos.Data;
|
|
using Chronos.Data.Archiving;
|
|
using Chronos.Data.Archiving.Jobs;
|
|
using Chronos.Data.Jobs;
|
|
using Chronos.Data.Processing;
|
|
using Chronos.Data.Projects;
|
|
using Chronos.Data.Workspaces;
|
|
using Chronos.Protocol;
|
|
|
|
namespace Chronos.App.Editor;
|
|
|
|
/// <summary>A source whose renders are made otherwise than from the project as the editor holds it (a workspace project: at its home).</summary>
|
|
public interface IProjectRenders
|
|
{
|
|
/// <summary>The jobs that render <paramref name="export"/> of <paramref name="project"/> (the editor's settings, positions on the source's frames).</summary>
|
|
IReadOnlyList<ArchiveJobRequest> RenderRequests(Sequence sequence, ProjectSettings project, ExportSettings export, int sourceWidth, int sourceHeight);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A workspace project open in the editor (owner review 2, R8: editing happens in the workspace, never inside the
|
|
/// library): the frames and pixels of the media the workspace holds (<c>media/media.json</c>, the proxies), the project
|
|
/// from its working state (<c>project.chronos</c>, positions placed on those frames), saved there atomically under the
|
|
/// project's lease and merged against the basis like <see cref="LocalSequenceSource"/> (a pull or a copy job writes it
|
|
/// too). Jobs run on this PC's engine against the home's sequence (same id): an analysis reads the home's originals, a
|
|
/// render renders the home's originals with the project's portable settings and records the project and the version
|
|
/// (<see cref="RenderRequests"/>). The deep report is the home's while its frames are the media's, else the copy the
|
|
/// workspace took. A copy job that changed the media (Update media) makes saves made against the frames read before refused
|
|
/// (<see cref="FramesChangedException"/>) until the editor has read them again and moved its positions by frame.
|
|
/// </summary>
|
|
public sealed class WorkspaceSequenceSource : ISequenceSource, IProjectRenders
|
|
{
|
|
private const int JobsListed = 200;
|
|
|
|
private readonly WorkspaceSync _sync;
|
|
private readonly ChronosDatabase _db;
|
|
private readonly ImageDecoder _decoder;
|
|
private readonly JobEngine? _engine;
|
|
private readonly Lock _gate = new();
|
|
private readonly List<IRenderFrameSource> _retired = [];
|
|
private IRenderFrameSource? _frames;
|
|
private IFrameSource? _pixels;
|
|
private int _frameCount;
|
|
private int _framesVersion = -1;
|
|
private Guid[] _frameIds = [];
|
|
private FramePhotos _photos = new([]);
|
|
private BundleWorkspace? _workspace;
|
|
private bool _readOnly;
|
|
private int _disposed;
|
|
|
|
public WorkspaceSequenceSource(WorkspaceSync sync, Guid projectId, ChronosDatabase db, ImageDecoder decoder, JobEngine? engine)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(sync);
|
|
ArgumentNullException.ThrowIfNull(db);
|
|
ArgumentNullException.ThrowIfNull(decoder);
|
|
_sync = sync;
|
|
_db = db;
|
|
_decoder = decoder;
|
|
_engine = engine;
|
|
ProjectId = projectId;
|
|
if (engine is not null) engine.JobChanged += OnJobChanged;
|
|
}
|
|
|
|
public Guid ProjectId { get; }
|
|
|
|
/// <summary>The project's folder in the workspace.</summary>
|
|
public WorkspaceProject Project => _sync.Store.Project(ProjectId);
|
|
|
|
/// <summary>The workspace section of the project file as read last (name, Main, home, base, media); null before the first read.</summary>
|
|
public BundleWorkspace? Workspace => Volatile.Read(ref _workspace);
|
|
|
|
/// <summary>The frames version of the home the media read last were copied at; -1 before the first read.</summary>
|
|
public int MediaFramesVersion => Volatile.Read(ref _framesVersion);
|
|
|
|
/// <summary>The photos of the media read last, in frame order (what positions name).</summary>
|
|
public FramePhotos Photos => Volatile.Read(ref _photos);
|
|
|
|
public bool IsRemote => false;
|
|
|
|
/// <summary>Settings of a newer Chronos: shown, never saved.</summary>
|
|
public bool IsReadOnly => Volatile.Read(ref _readOnly);
|
|
|
|
public bool IsOutdated => false;
|
|
|
|
/// <summary>A workspace project's read-only state is known when it opens.</summary>
|
|
public event Action? ReadOnlyChanged
|
|
{
|
|
add { }
|
|
remove { }
|
|
}
|
|
|
|
public event Action<Job>? JobChanged;
|
|
|
|
/// <exception cref="EditorException">The workspace holds no media for the project (copy them again), or the project is gone.</exception>
|
|
public async Task<SequenceContent> LoadAsync(CancellationToken cancellationToken)
|
|
{
|
|
WorkspaceSession session;
|
|
try
|
|
{
|
|
session = await _sync.OpenAsync(ProjectId, cancellationToken);
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
throw new EditorException(Loc.L("Errors.Workspace.NotCheckedOut"), ex);
|
|
}
|
|
catch (InvalidDataException ex)
|
|
{
|
|
throw new EditorException(Loc.L("Editor.Error.Project"), ex);
|
|
}
|
|
if (session is not { Sequence: { } media, Media: { } index }) throw new EditorException(Loc.L("Errors.Workspace.MediaMissing"));
|
|
var home = session.Bundle.Workspace!.Home;
|
|
var row = await _db.Sequences.GetAsync(home.SequenceId, cancellationToken);
|
|
var archive = row is null ? null : await _db.Archives.GetAsync(row.ArchiveId, cancellationToken);
|
|
IReadOnlyList<Render> renders = row is null ? [] : await _db.Renders.ListBySequenceAsync(home.SequenceId, cancellationToken);
|
|
return await Task.Run(() =>
|
|
{
|
|
var frames = media.Frames;
|
|
Swap(media, index, session.Bundle.Workspace!, session.IsReadOnly);
|
|
var times = frames.Where(f => f.CapturedAt is not null).Select(f => f.CapturedAt!.Value).Order().ToList();
|
|
// The home's row (camera, interval, tags) with the frames this workspace holds.
|
|
var sequence = (row ?? media.Sequence) with
|
|
{
|
|
FrameCount = frames.Count,
|
|
FramesVersion = index.FramesVersion,
|
|
FirstCapture = times.Count > 0 ? times[0] : null,
|
|
LastCapture = times.Count > 0 ? times[^1] : null,
|
|
SettingsJson = session.Working.ToJson(),
|
|
};
|
|
var folder = archive is null ? null : new ArchivePaths(archive.RootPath).Sequence(row!.Folder);
|
|
var (deep, otherFrames) = ReadReport(folder, row?.FramesVersion == index.FramesVersion, session.Project.AnalysisPath, frames.Count);
|
|
var context = SequenceContext.FromFrames(frames);
|
|
return new SequenceContent(sequence, frames, session.Working, LightAnalyzer.Analyze(frames), deep, context.SourceWidth, context.SourceHeight,
|
|
folder?.Exports, [.. renders.OrderByDescending(r => r.Created)], [])
|
|
{
|
|
DeepOfOtherFrames = otherFrames,
|
|
};
|
|
}, cancellationToken);
|
|
}
|
|
|
|
/// <remarks>Only a copy job changes the workspace's frames (Update media): its media index is compared with the one read last.</remarks>
|
|
public Task<bool> FramesCurrentAsync(CancellationToken cancellationToken) => Task.Run(() =>
|
|
{
|
|
var (framesVersion, ids) = (Volatile.Read(ref _framesVersion), Volatile.Read(ref _frameIds));
|
|
try
|
|
{
|
|
return Project.ReadMedia() is { } media && media.FramesVersion == framesVersion && media.Frames.Select(f => f.Id).SequenceEqual(ids);
|
|
}
|
|
catch (InvalidDataException ex)
|
|
{
|
|
Log.Warning("editor", $"The media index of workspace project {ProjectId} cannot be read", ex);
|
|
return false;
|
|
}
|
|
}, cancellationToken);
|
|
|
|
/// <summary>Whether the home's frames moved past those the workspace holds (frames added or removed there): "Update media" copies them again.</summary>
|
|
public async Task<bool> HomeFramesChangedAsync(CancellationToken cancellationToken)
|
|
{
|
|
if (Workspace is not { } workspace || MediaFramesVersion < 0) return false;
|
|
return await _db.Sequences.GetAsync(workspace.Home.SequenceId, cancellationToken) is { } row && row.FramesVersion != MediaFramesVersion;
|
|
}
|
|
|
|
public async ValueTask<ImageBuffer?> DecodeAsync(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken)
|
|
{
|
|
IFrameSource? pixels;
|
|
int count;
|
|
lock (_gate) (pixels, count) = (_pixels, _frameCount);
|
|
if (pixels is null || (uint)index >= (uint)count) return null;
|
|
// The loader decodes synchronously: an async delegate keeps a superseded decode's cancellation in user code (R4).
|
|
return await Task.Run(async () => await pixels.LoadAsync(index, maxLongEdge, cancellationToken).ConfigureAwait(false), cancellationToken);
|
|
}
|
|
|
|
/// <exception cref="EditorException">The project is read-only, or its media are gone.</exception>
|
|
/// <exception cref="FramesChangedException">The media changed since they were read (a copy job): read them again first.</exception>
|
|
public Task<ProjectSettings> SaveProjectAsync(ProjectSettings project, ProjectSettings basis, CancellationToken cancellationToken)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(project);
|
|
ArgumentNullException.ThrowIfNull(basis);
|
|
var framesVersion = Volatile.Read(ref _framesVersion);
|
|
if (framesVersion < 0) throw new InvalidOperationException("LoadAsync first.");
|
|
var folder = Project;
|
|
return Task.Run(async () =>
|
|
{
|
|
using (await folder.LockAsync(_sync.LockWait, cancellationToken))
|
|
{
|
|
var bundle = folder.ReadBundle();
|
|
if (bundle.IsReadOnly || project.IsNewerFormat) throw new EditorException(Loc.L("Errors.Workspace.ReadOnly"));
|
|
var media = folder.ReadMedia() ?? throw new EditorException(Loc.L("Errors.Workspace.MediaMissing"));
|
|
// A copy job moved the working state onto other frames: the editor reads them and moves its positions first.
|
|
if (media.FramesVersion != framesVersion) throw new FramesChangedException(Loc.L("Errors.Workspace.MediaChanged"));
|
|
var stored = ProjectSettings.FromJson(ProjectContent.Place(bundle.Project.ToJson(), media.Photos), allowNewer: true);
|
|
var merged = ProjectMerge.SameValues(stored, basis) ? project : ProjectMerge.Merge(basis, project, stored);
|
|
if (ProjectMerge.SameValues(merged, stored)) return merged;
|
|
folder.WriteBundle(bundle with { Project = merged, Saved = DateTimeOffset.UtcNow });
|
|
return merged;
|
|
}
|
|
}, cancellationToken);
|
|
}
|
|
|
|
public async Task<Guid> SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken)
|
|
{
|
|
if (_engine is null) throw new InvalidOperationException(Loc.L("Editor.Error.NoEngine"));
|
|
var job = await _engine.EnqueueAsync(request, cancellationToken: cancellationToken);
|
|
return job.Id;
|
|
}
|
|
|
|
public async Task<IReadOnlyList<Job>> ListJobsAsync(CancellationToken cancellationToken) =>
|
|
(await _db.Jobs.ListAsync(null, JobsListed, null, cancellationToken)).Items;
|
|
|
|
public Task CancelJobAsync(Guid jobId, CancellationToken cancellationToken) =>
|
|
(_engine ?? throw new InvalidOperationException(Loc.L("Editor.Error.NoEngine"))).CancelAsync(jobId, cancellationToken);
|
|
|
|
public Task RetryJobAsync(Guid jobId, CancellationToken cancellationToken) =>
|
|
(_engine ?? throw new InvalidOperationException(Loc.L("Editor.Error.NoEngine"))).ResumeAsync(jobId, cancellationToken);
|
|
|
|
/// <summary>
|
|
/// The render at the home (owner review 2, R8: edit with proxies, render where the originals are): one job of this PC's
|
|
/// engine per preset, with the project's portable settings (positions parked by photo, placed on the home's frames by
|
|
/// the render) and the project recorded on the render; the version too when the settings are those of the last
|
|
/// version the home holds (an unsaved working state, or one saved here and not sent yet, renders as it is, without a version).
|
|
/// </summary>
|
|
public IReadOnlyList<ArchiveJobRequest> RenderRequests(Sequence sequence, ProjectSettings project, ExportSettings export, int sourceWidth, int sourceHeight)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(sequence);
|
|
ArgumentNullException.ThrowIfNull(project);
|
|
ArgumentNullException.ThrowIfNull(export);
|
|
var portable = ProjectContent.ToPortable(project with { Export = export }, Photos);
|
|
var hash = ProjectContent.Hash(portable);
|
|
var (tipId, tipHash) = Tip();
|
|
var version = new ProjectVersion
|
|
{
|
|
Id = tipId ?? Guid.Empty,
|
|
ProjectId = ProjectId,
|
|
Number = 0,
|
|
SettingsJson = portable,
|
|
ContentHash = hash,
|
|
};
|
|
var requests = ProcessingJobs.RenderVersion(sequence, version, export, sourceWidth, sourceHeight);
|
|
if (tipId is not null && string.Equals(tipHash, hash, StringComparison.OrdinalIgnoreCase)) return requests;
|
|
return [.. requests.Select(r => r with { ParametersJson = WithoutVersion(r.ParametersJson) })];
|
|
}
|
|
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
if (Interlocked.Exchange(ref _disposed, 1) == 1) return;
|
|
if (_engine is not null) _engine.JobChanged -= OnJobChanged;
|
|
List<IRenderFrameSource> sources;
|
|
lock (_gate)
|
|
{
|
|
sources = [.. _retired];
|
|
if (_frames is not null) sources.Add(_frames);
|
|
_retired.Clear();
|
|
(_frames, _pixels) = (null, null);
|
|
}
|
|
foreach (var source in sources)
|
|
{
|
|
if (source is IAsyncDisposable disposable) await disposable.DisposeAsync();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Takes the media read now: a frame source over them when they differ from those read before (the old one is disposed
|
|
/// with this source, as a decode may still read it), their frames and photos, the project's workspace section.
|
|
/// </summary>
|
|
private void Swap(WorkspaceSequence media, WorkspaceMedia index, BundleWorkspace workspace, bool readOnly)
|
|
{
|
|
var ids = media.Frames.Select(f => f.Id).ToArray();
|
|
lock (_gate)
|
|
{
|
|
if (_frames is null || index.FramesVersion != _framesVersion || !ids.AsSpan().SequenceEqual(_frameIds))
|
|
{
|
|
if (_frames is not null) _retired.Add(_frames);
|
|
_frames = media.OpenFrames(_decoder);
|
|
_pixels = (IFrameSource)_frames;
|
|
_frameCount = media.Frames.Count;
|
|
}
|
|
_frameIds = ids;
|
|
_framesVersion = index.FramesVersion;
|
|
_photos = index.Photos;
|
|
_workspace = workspace;
|
|
_readOnly = readOnly;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The version a render may name, with its content hash: the base, which the home holds, while no version waits to be
|
|
/// sent; none otherwise. A version not sent yet may never reach the home under its id (a replay or a save-both sends it
|
|
/// under another), so a render of it names the project alone.
|
|
/// </summary>
|
|
private (Guid? Id, string? Hash) Tip()
|
|
{
|
|
try
|
|
{
|
|
if (_sync.Unpushed(ProjectId).Count > 0) return (null, null);
|
|
return Project.ReadBundle().Workspace?.Base is { } basis ? (basis.VersionId, basis.ContentHash) : (null, null);
|
|
}
|
|
catch (Exception ex) when (ex is IOException or InvalidDataException or InvalidOperationException)
|
|
{
|
|
Log.Warning("editor", $"The versions of workspace project {ProjectId} cannot be read; the render names none", ex);
|
|
return (null, null);
|
|
}
|
|
}
|
|
|
|
private static string? WithoutVersion(string? parametersJson)
|
|
{
|
|
if (parametersJson is null || JsonSerializer.Deserialize(parametersJson, ProtocolJson.Default.RenderJobParameters) is not { } parameters) return parametersJson;
|
|
return JsonSerializer.Serialize(parameters with { ProjectVersionId = null }, ProtocolJson.Default.RenderJobParameters);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The deep report the editor shows: the home's while its frames are the workspace's, else the copy the workspace took;
|
|
/// whether one of another number of frames was read instead.
|
|
/// </summary>
|
|
private static (DeepAnalysisReport? Report, bool OtherFrames) ReadReport(SequencePaths? home, bool sameFrames, string copied, int frameCount)
|
|
{
|
|
var otherFrames = false;
|
|
foreach (var path in new[] { sameFrames ? home?.AnalysisPath : null, copied })
|
|
{
|
|
if (path is null || !File.Exists(path)) continue;
|
|
try
|
|
{
|
|
var report = DeepAnalysisReport.Load(path);
|
|
if (report.FrameCount == frameCount) return (report, false);
|
|
otherFrames = true;
|
|
}
|
|
catch (Exception ex) when (ex is IOException or InvalidDataException or JsonException or UnauthorizedAccessException)
|
|
{
|
|
Log.Warning("editor", $"{path} cannot be read", ex);
|
|
}
|
|
}
|
|
return (null, otherFrames);
|
|
}
|
|
|
|
private void OnJobChanged(Job job) => JobChanged?.Invoke(job);
|
|
}
|