CI / Build and test (push) Successful in 9m43s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 27s
CI / PostgreSQL 16 integration (push) Failing after 8m41s
CI / PostgreSQL 17 integration (push) Successful in 12m37s
CI / Docker image (push) Successful in 56s
Release / Build, test and publish (push) Successful in 14m59s
Release / Server image (push) Successful in 1m51s
Edit opens a sequence as a project of a workspace folder outside the library. Projects have linear version histories kept as sidecars in .chronos/projects/, Main mirrors the sequence's settings, and sync merges setting by setting. Migration 0009, JobKind.WorkspaceCopy = 20, Settings › Workspace, and 241 new strings in 38 languages. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
224 lines
12 KiB
C#
224 lines
12 KiB
C#
using System.Text.Json;
|
||
using System.Text.Json.Nodes;
|
||
using System.Text.Json.Serialization;
|
||
using Chronos.Core.Export;
|
||
using Chronos.Core.Localization;
|
||
using Chronos.Core.Model;
|
||
using Chronos.Core.Project;
|
||
using Chronos.Core.Video;
|
||
using Chronos.Data.Archiving.Jobs;
|
||
using Chronos.Protocol;
|
||
|
||
namespace Chronos.Data.Processing;
|
||
|
||
/// <summary>
|
||
/// Builds the analysis and render jobs; enqueue them with <see cref="Archiving.ArchiveJobs.EnqueueAsync"/> (local
|
||
/// engine) or post the same kind, targets and parameters to <c>/api/v1/jobs</c> (server).
|
||
/// </summary>
|
||
public static class ProcessingJobs
|
||
{
|
||
/// <summary><see cref="JobKind.LightAnalyse"/>: targets = sequences; no parameters.</summary>
|
||
public static ArchiveJobRequest LightAnalysis(IReadOnlyList<Guid> sequenceIds, string? label = null) =>
|
||
new(JobKind.LightAnalyse, sequenceIds, label, null, JobPriority.Background);
|
||
|
||
/// <summary><see cref="JobKind.DeepAnalyse"/>: targets = sequences; no parameters.</summary>
|
||
public static ArchiveJobRequest DeepAnalysis(IReadOnlyList<Guid> sequenceIds, string? label = null) =>
|
||
new(JobKind.DeepAnalyse, sequenceIds, label, null, JobPriority.User);
|
||
|
||
/// <summary>
|
||
/// <see cref="JobKind.Render"/> of one sequence. <paramref name="export"/> (preset, overrides, name template,
|
||
/// folder, batch) replaces the project's export section; <paramref name="project"/> embeds the settings to render,
|
||
/// null renders the sequence's current project. <paramref name="sourceWidth"/>×<paramref name="sourceHeight"/>
|
||
/// stands in for a preset without a fixed size, so render nodes can match the job by resolution.
|
||
/// </summary>
|
||
public static ArchiveJobRequest Render(Sequence sequence, ExportSettings export, int sourceWidth, int sourceHeight, ProjectSettings? project = null,
|
||
bool useProxies = false)
|
||
{
|
||
ArgumentNullException.ThrowIfNull(sequence);
|
||
ArgumentNullException.ThrowIfNull(export);
|
||
var parameters = Parameters(export, sourceWidth, sourceHeight, project?.ToJson(), useProxies);
|
||
return new ArchiveJobRequest(JobKind.Render, [sequence.Id], RenderLabel(sequence.DisplayTitle, parameters.PresetName),
|
||
JsonSerializer.Serialize(parameters, ProtocolJson.Default.RenderJobParameters), JobPriority.User);
|
||
}
|
||
|
||
/// <summary>
|
||
/// <see cref="JobKind.Render"/> of a project version (owner review 2, R8) on the sequence's home: the version's portable
|
||
/// settings, placed on the sequence's frames by the render, with <paramref name="export"/> as their export section; the
|
||
/// render records the project and the version. One job per preset, as <see cref="RenderEach"/>.
|
||
/// </summary>
|
||
public static IReadOnlyList<ArchiveJobRequest> RenderVersion(Sequence sequence, ProjectVersion version, ExportSettings export, int sourceWidth, int sourceHeight,
|
||
bool useProxies = false)
|
||
{
|
||
ArgumentNullException.ThrowIfNull(sequence);
|
||
ArgumentNullException.ThrowIfNull(version);
|
||
ArgumentNullException.ThrowIfNull(export);
|
||
return
|
||
[
|
||
VersionJob(sequence, version, export with { Batch = [] }, sourceWidth, sourceHeight, useProxies),
|
||
.. BatchPresets(export).Select(id => VersionJob(sequence, version, BatchExport(export, id), sourceWidth, sourceHeight, useProxies)),
|
||
];
|
||
}
|
||
|
||
private static ArchiveJobRequest VersionJob(Sequence sequence, ProjectVersion version, ExportSettings export, int sourceWidth, int sourceHeight, bool useProxies)
|
||
{
|
||
var parameters = Parameters(export, sourceWidth, sourceHeight, version.SettingsJson, useProxies) with
|
||
{
|
||
ProjectId = version.ProjectId,
|
||
ProjectVersionId = version.Id,
|
||
};
|
||
return new ArchiveJobRequest(JobKind.Render, [sequence.Id], RenderLabel(sequence.DisplayTitle, parameters.PresetName),
|
||
JsonSerializer.Serialize(parameters, ProtocolJson.Default.RenderJobParameters), JobPriority.User);
|
||
}
|
||
|
||
/// <summary>
|
||
/// The label of a render job, "Harbour sunset → 4K HEVC". It is stored as written, in the language of the moment like
|
||
/// the preset name: its arrow points from the sequence to the preset in that language's reading direction.
|
||
/// </summary>
|
||
public static string RenderLabel(string title, string presetName) =>
|
||
Loc.L(Loc.IsRightToLeft ? "Jobs.Target.RenderRtl" : "Jobs.Target.Render", title, presetName);
|
||
|
||
/// <summary>
|
||
/// A posted render job as one job per preset, as <see cref="RenderEach"/> makes them (a render node uploads one file
|
||
/// per job): the job itself when it has no batch; otherwise its own preset, then each batch preset with its own values,
|
||
/// all with the job's project and proxy choice. <paramref name="sourceWidth"/>×<paramref name="sourceHeight"/> stands in
|
||
/// for a batch preset without a fixed size.
|
||
/// </summary>
|
||
/// <exception cref="InvalidDataException">The preset JSON is not an export section.</exception>
|
||
public static IReadOnlyList<RenderJobParameters> Split(RenderJobParameters parameters, int sourceWidth, int sourceHeight)
|
||
{
|
||
ArgumentNullException.ThrowIfNull(parameters);
|
||
var export = ReadExport(parameters.PresetJson);
|
||
var batch = BatchPresets(export).ToList();
|
||
if (batch.Count == 0) return [parameters];
|
||
return
|
||
[
|
||
parameters with { PresetJson = JsonSerializer.Serialize(export with { Batch = [] }, ProcessingJson.Default.ExportSettings) },
|
||
.. batch.Select(id => Parameters(BatchExport(export, id), sourceWidth, sourceHeight, parameters.SettingsJson, parameters.UseProxies) with
|
||
{
|
||
ProjectId = parameters.ProjectId,
|
||
ProjectVersionId = parameters.ProjectVersionId,
|
||
}),
|
||
];
|
||
}
|
||
|
||
/// <summary>
|
||
/// One <see cref="Render"/> job per preset of <paramref name="export"/>: its preset, then each batch preset with its
|
||
/// own values. For a server: a render node uploads one file per job, so a batch must not travel as one job.
|
||
/// </summary>
|
||
public static IReadOnlyList<ArchiveJobRequest> RenderEach(Sequence sequence, ExportSettings export, int sourceWidth, int sourceHeight,
|
||
ProjectSettings? project = null, bool useProxies = false)
|
||
{
|
||
ArgumentNullException.ThrowIfNull(export);
|
||
return
|
||
[
|
||
Render(sequence, export with { Batch = [] }, sourceWidth, sourceHeight, project, useProxies),
|
||
.. BatchPresets(export).Select(id => Render(sequence, BatchExport(export, id), sourceWidth, sourceHeight, project, useProxies)),
|
||
];
|
||
}
|
||
|
||
/// <summary>The batch presets of an export besides its own, each once (blank entries of a hand-written batch are skipped).</summary>
|
||
internal static IEnumerable<string> BatchPresets(ExportSettings export)
|
||
{
|
||
var main = ExportResolver.Resolve(export).BasePresetId;
|
||
return export.Batch.Where(id => !string.IsNullOrWhiteSpace(id)).Distinct(StringComparer.OrdinalIgnoreCase)
|
||
.Where(id => !id.Equals(main, StringComparison.OrdinalIgnoreCase));
|
||
}
|
||
|
||
/// <summary>A batch preset rendered with its own values, named and placed like the export it belongs to.</summary>
|
||
internal static ExportSettings BatchExport(ExportSettings export, string presetId) =>
|
||
new() { Preset = new Auto<string>().WithManual(presetId), NameTemplate = export.NameTemplate, Folder = export.Folder };
|
||
|
||
private static RenderJobParameters Parameters(ExportSettings export, int sourceWidth, int sourceHeight, string? settingsJson, bool useProxies)
|
||
{
|
||
var resolved = ExportResolver.Resolve(export);
|
||
return new RenderJobParameters(PresetName(resolved), JsonSerializer.Serialize(export, ProcessingJson.Default.ExportSettings), CodecName(resolved.Codec),
|
||
resolved.Width > 0 ? resolved.Width : sourceWidth, resolved.Height > 0 ? resolved.Height : sourceHeight, useProxies, settingsJson);
|
||
}
|
||
|
||
/// <summary>Codec name in job parameters and render-node capabilities ("h264", "hevc", "mjpeg", "pngsequence"…).</summary>
|
||
public static string CodecName(VideoCodec codec) => codec.ToString().ToLowerInvariant();
|
||
|
||
/// <summary>Display name of an export's preset in the current language ("Custom" when the values match none).</summary>
|
||
public static string PresetName(ResolvedExport export)
|
||
{
|
||
ArgumentNullException.ThrowIfNull(export);
|
||
return Loc.L(export.NameKey ?? "Export.Preset.Custom");
|
||
}
|
||
|
||
/// <summary>The parameters of a render job and the export they select.</summary>
|
||
/// <exception cref="InvalidDataException">The job has no valid render parameters.</exception>
|
||
public static (RenderJobParameters Parameters, ExportSettings Export) ReadRender(string? parametersJson)
|
||
{
|
||
var parameters = ReadParameters(parametersJson);
|
||
return (parameters, ReadExport(parameters.PresetJson));
|
||
}
|
||
|
||
/// <summary>The protocol record of a render job, without reading its export.</summary>
|
||
/// <exception cref="InvalidDataException">The job has no valid render parameters.</exception>
|
||
internal static RenderJobParameters ReadParameters(string? parametersJson)
|
||
{
|
||
try
|
||
{
|
||
if (parametersJson is { Length: > 0 } && JsonSerializer.Deserialize(parametersJson, ProtocolJson.Default.RenderJobParameters)
|
||
is { PresetName.Length: > 0, PresetJson.Length: > 0, Codec.Length: > 0 } parameters)
|
||
return parameters;
|
||
}
|
||
catch (JsonException ex)
|
||
{
|
||
throw new InvalidDataException(Loc.L("Errors.Render.Parameters"), ex);
|
||
}
|
||
throw new InvalidDataException(Loc.L("Errors.Render.Parameters"));
|
||
}
|
||
|
||
/// <summary>The export section in a render job's preset JSON; values it leaves out take their defaults.</summary>
|
||
/// <exception cref="InvalidDataException">The JSON is not an export section.</exception>
|
||
internal static ExportSettings ReadExport(string? presetJson)
|
||
{
|
||
try
|
||
{
|
||
// Read as the export section of a project, so missing values keep their defaults (ProjectSettings.FromJson).
|
||
var project = new JsonObject { ["export"] = JsonNode.Parse(presetJson ?? string.Empty) };
|
||
return ProjectSettings.FromJson(project.ToJsonString()).Export;
|
||
}
|
||
catch (JsonException ex)
|
||
{
|
||
throw new InvalidDataException(Loc.L("Errors.Render.Parameters"), ex);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Resume point of a render job: the batch targets already recorded, and the output a crashed attempt was writing
|
||
/// (its leftovers are removed before that target renders again) with the sequence's archive-relative folder when it
|
||
/// chose that output (null in checkpoints written before it was kept), so the leftovers are found after a Reorganize.
|
||
/// </summary>
|
||
internal sealed record RenderCheckpoint(IReadOnlyList<int> Done, int? Pending, string? PendingOutput, string? Folder = null)
|
||
{
|
||
public static RenderCheckpoint Empty { get; } = new([], null, null);
|
||
|
||
public static RenderCheckpoint Parse(string? json)
|
||
{
|
||
if (string.IsNullOrEmpty(json)) return Empty;
|
||
try
|
||
{
|
||
return JsonSerializer.Deserialize(json, ProcessingJson.Default.RenderCheckpoint) ?? Empty;
|
||
}
|
||
catch (JsonException)
|
||
{
|
||
return Empty;
|
||
}
|
||
}
|
||
|
||
public string ToJson() => JsonSerializer.Serialize(this, ProcessingJson.Default.RenderCheckpoint);
|
||
}
|
||
|
||
/// <summary>JSON written into render jobs: presets (the export section of <c>project.json</c>) and checkpoints.</summary>
|
||
[JsonSourceGenerationOptions(
|
||
PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
|
||
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
|
||
UseStringEnumConverter = true,
|
||
PropertyNameCaseInsensitive = true)]
|
||
[JsonSerializable(typeof(ExportSettings))]
|
||
[JsonSerializable(typeof(RenderCheckpoint))]
|
||
internal sealed partial class ProcessingJson : JsonSerializerContext;
|