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; /// A source whose renders are made otherwise than from the project as the editor holds it (a workspace project: at its home). public interface IProjectRenders { /// The jobs that render of (the editor's settings, positions on the source's frames). IReadOnlyList RenderRequests(Sequence sequence, ProjectSettings project, ExportSettings export, int sourceWidth, int sourceHeight); } /// /// 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 (media/media.json, the proxies), the project /// from its working state (project.chronos, positions placed on those frames), saved there atomically under the /// project's lease and merged against the basis like (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 /// (). 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 /// () until the editor has read them again and moved its positions by frame. /// 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 _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; } /// The project's folder in the workspace. public WorkspaceProject Project => _sync.Store.Project(ProjectId); /// The workspace section of the project file as read last (name, Main, home, base, media); null before the first read. public BundleWorkspace? Workspace => Volatile.Read(ref _workspace); /// The frames version of the home the media read last were copied at; -1 before the first read. public int MediaFramesVersion => Volatile.Read(ref _framesVersion); /// The photos of the media read last, in frame order (what positions name). public FramePhotos Photos => Volatile.Read(ref _photos); public bool IsRemote => false; /// Settings of a newer Chronos: shown, never saved. public bool IsReadOnly => Volatile.Read(ref _readOnly); public bool IsOutdated => false; /// A workspace project's read-only state is known when it opens. public event Action? ReadOnlyChanged { add { } remove { } } public event Action? JobChanged; /// The workspace holds no media for the project (copy them again), or the project is gone. public async Task 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 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); } /// Only a copy job changes the workspace's frames (Update media): its media index is compared with the one read last. public Task 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); /// Whether the home's frames moved past those the workspace holds (frames added or removed there): "Update media" copies them again. public async Task 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 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); } /// The project is read-only, or its media are gone. /// The media changed since they were read (a copy job): read them again first. public Task 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 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> 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); /// /// 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). /// public IReadOnlyList 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 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(); } } /// /// 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. /// 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; } } /// /// 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. /// 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); } /// /// 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. /// 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); }