using Chronos.Core.Archiving;
using Chronos.Data.Archiving;
using Chronos.Testing;
using static Chronos.Data.Tests.Archiving.ArchiveFixture;
namespace Chronos.Data.Tests.Archiving;
///
/// Thumbnail and proxy passes working on several photos at once (owner review 1, R2: the parallelism decides how many
/// photos the running job processes at once): the same images as one at a time, written in frame order, and checkpoints
/// that still mean every frame before them is done.
///
[Category("archive")]
public sealed class ParallelPassTests(TestContext context)
{
[Test]
public async Task SeveralPhotosAtOnceDrawTheSameThumbnailsInFrameOrder()
{
await using var fx = await CreateAsync(context);
// The pass commits its pack and checkpoints every 200 frames.
Photos.WriteSeries(Path.Combine(fx.Paths.Root, "a"), Start, 430);
await fx.ScanAsync();
var location = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single();
var sequence = (await fx.Db.Sequences.GetAsync(location.Id))!;
var folder = fx.Paths.Sequence("a");
var parallel = new ArchiveService(fx.Db, new ArchiveServiceOptions { Owner = "test", Parallelism = () => 4 });
var checkpoints = new List<(int Next, int Total)>();
var result = await parallel.Images.BuildThumbnailsAsync(fx.Archive, sequence, false, 0, (next, total) =>
{
checkpoints.Add((next, total));
return ValueTask.CompletedTask;
}, fx.Ct);
Assert.Equal((430, 0, 0), (result.Built, result.Reused, result.Undecodable));
Assert.SequenceEqual([(200, 430), (400, 430)], checkpoints);
Dictionary drawn;
using (var pack = ThumbPackReader.Open(folder.ThumbsPackPath))
{
var entries = pack.Entries.Values.OrderBy(e => e.FrameIndex).ToList();
Assert.Count(430, entries);
// Appended in frame order, as one at a time.
Assert.SequenceEqual(entries.Select(e => e.Offset).Order(), entries.Select(e => e.Offset));
drawn = entries.ToDictionary(e => e.FrameIndex, e => pack.Read(e.FrameIndex)!);
}
var single = new ArchiveService(fx.Db, new ArchiveServiceOptions { Owner = "test", Parallelism = () => 1 });
await single.Images.BuildThumbnailsAsync(fx.Archive, sequence, force: true, 0, (_, _) => ValueTask.CompletedTask, fx.Ct);
using (var pack = ThumbPackReader.Open(folder.ThumbsPackPath))
{
foreach (var (index, jpeg) in drawn) Assert.SequenceEqual(jpeg, pack.Read(index)!);
}
}
[Test]
public async Task SeveralPhotosAtOnceWriteEveryProxyAndAResumedPassChecksWhatTheEarlierRunDid()
{
await using var fx = await CreateAsync(context);
Photos.WriteSeries(Path.Combine(fx.Paths.Root, "a"), Start, 24);
await fx.ScanAsync();
var location = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single();
var sequence = (await fx.Db.Sequences.GetAsync(location.Id))!;
var folder = fx.Paths.Sequence("a");
var parallel = new ArchiveService(fx.Db, new ArchiveServiceOptions { Owner = "test", Parallelism = () => 6 });
// Resumed at frame 10: it makes the proxies from there on, and those before it, which the earlier run should have
// made, are missing, so the sequence is not built.
var resumed = await parallel.Images.BuildProxiesAsync(fx.Archive, sequence, false, 10, (_, _) => ValueTask.CompletedTask, fx.Ct);
Assert.Equal((14, 0, 0), (resumed.Built, resumed.Reused, resumed.Undecodable));
Assert.FileMissing(folder.Proxy(0));
Assert.FileExists(folder.Proxy(10));
Assert.False((await fx.Db.Sequences.GetAsync(location.Id))!.Status.HasFlag(Chronos.Core.Model.SequenceStatus.ProxiesBuilt), "not built");
var full = await parallel.Images.BuildProxiesAsync(fx.Archive, sequence, false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct);
Assert.Equal((10, 14), (full.Built, full.Reused));
foreach (var frame in ManifestStore.ReadSequence(folder.ManifestPath).Frames)
Assert.True(ArchiveImages.IsProxyOf(folder.Proxy(frame.I), frame.CapturedAt, frame.W, frame.H, null), $"proxy of {frame.File}");
Assert.True((await fx.Db.Sequences.GetAsync(location.Id))!.Status.HasFlag(Chronos.Core.Model.SequenceStatus.ProxiesBuilt), "built");
}
[Test]
public void LargeOriginalsDecodeFewerAtOnceWithinTheMemoryBudget()
{
// 24 MP takes some 768 MB while it is decoded.
const long sensor24 = 6000 * 4000;
Assert.Equal(2, DecodeBudget.PhotosAtOnce(8, 2L << 30, sensor24));
Assert.Equal(1, DecodeBudget.PhotosAtOnce(8, 512L << 20, sensor24));
Assert.Equal(8, DecodeBudget.PhotosAtOnce(8, 64L << 30, sensor24));
Assert.Equal(1, DecodeBudget.PhotosAtOnce(1, 64L << 30, sensor24));
// Small photos all fit; an unknown size counts as 24 MP.
Assert.Equal(8, DecodeBudget.PhotosAtOnce(8, 2L << 30, 48 * 32));
Assert.Equal(2, DecodeBudget.PhotosAtOnce(8, 2L << 30, 0));
// The size a damaged file claims never overflows: one decode at a time.
Assert.Equal(1, DecodeBudget.PhotosAtOnce(8, 64L << 30, 1L << 59));
Assert.Equal(1, DecodeBudget.PhotosAtOnce(8, 64L << 30, long.MaxValue));
}
}