using Titano.Core.Codecs.Jpeg; using Titano.Core.Codecs.Raw; using Titano.Core.Imaging; using Titano.Core.Imaging.Decoders; using Titano.Core.Imaging.Thumbnails; using Titano.Core.Metadata; using Titano.Core.Model; using Titano.Core.Tests.Raw; using Titano.Testing; namespace Titano.Core.Tests.Decoding; /// format behaviour, and . public sealed class ThumbnailTests(TestContext context) { private readonly string _dir = context.CreateTempDirectory(); private static ImageBuffer Frame(int seed, int width = 400, int height = 300) { var image = new ImageBuffer(width, height); for (var y = 0; y < height; y++) { for (var x = 0; x < width; x++) { image[0, x, y] = (x + seed * 13) % 97 / 96f; image[1, x, y] = (y + seed * 7) % 89 / 88f; image[2, x, y] = seed % 5 / 5f; } } return image; } /// Small distinct JPEGs (cheap to make in bulk). private static byte[] Jpeg(int seed) { using var image = Frame(seed, 40, 30); return JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 80 }); } private static Guid Id(int i) => new(i, 0, 0, [0, 0, 0, 0, 0, 0, 0, 1]); [Test] public void RoundTripAppendAndReplace() { var path = Path.Combine(_dir, "thumbs.pack"); using (var pack = ThumbnailPack.Open(path)) { for (var i = 0; i < 20; i++) { using var frame = Frame(i); var e = pack.Add(Id(i), frame); Assert.Equal(320, e.Width); Assert.Equal(240, e.Height); } } using (var pack = ThumbnailPack.Open(path)) { Assert.Equal(20, pack.Count); Assert.Empty(pack.Warnings); for (var i = 20; i < 25; i++) pack.AddJpeg(Id(i), Jpeg(i), 40, 30); pack.AddJpeg(Id(3), Jpeg(1000), 40, 30); } using var reader = ThumbnailPack.Open(path, writable: false); Assert.Equal(25, reader.Count); Assert.BytesEqual(Jpeg(1000), reader.ReadJpeg(Id(3))); Assert.BytesEqual(Jpeg(22), reader.ReadJpeg(Id(22))); var thumb = Thumbnail.FromJpeg(reader.ReadJpeg(Id(7))!); Assert.Equal(320, thumb.Width); Assert.Null(reader.ReadJpeg(Id(99))); Assert.Greater(reader.WastedBytes, 0); } [Test] public void EntriesAfterTheLastIndexAreRecovered() { var path = Path.Combine(_dir, "crash.pack"); var copy = Path.Combine(_dir, "crash-copy.pack"); var count = ThumbnailPack.IndexInterval + 6; using (var pack = ThumbnailPack.Open(path)) { for (var i = 0; i < count; i++) pack.AddJpeg(Id(i), Jpeg(i), 40, 30); // Simulated crash: the file as it is before the closing index write. File.Copy(path, copy); } using var recovered = ThumbnailPack.Open(copy, writable: false); Assert.Equal(count, recovered.Count); Assert.Contains(recovered.Warnings, w => w.Contains("Recovered 6")); Assert.BytesEqual(Jpeg(count - 1), recovered.ReadJpeg(Id(count - 1))); } [Test] public void TruncatedAndDamagedFilesOpen() { var path = Path.Combine(_dir, "full.pack"); using (var pack = ThumbnailPack.Open(path)) { for (var i = 0; i < 40; i++) pack.AddJpeg(Id(i), Jpeg(i), 40, 30); } var bytes = File.ReadAllBytes(path); for (var cut = 0; cut <= 40; cut++) { var file = Path.Combine(_dir, $"cut{cut}.pack"); File.WriteAllBytes(file, bytes[..(int)((long)bytes.Length * cut / 40)]); using var pack = ThumbnailPack.Open(file, writable: false); foreach (var id in pack.FrameIds) Assert.NotNull(pack.ReadJpeg(id)); Assert.LessOrEqual(pack.Count, 40); } // A damaged newest header slot falls back to the other one (or a scan). var damaged = (byte[])bytes.Clone(); for (var i = 0; i < 128; i++) damaged[i] ^= 0x5A; var damagedPath = Path.Combine(_dir, "damaged.pack"); File.WriteAllBytes(damagedPath, damaged); using (var pack = ThumbnailPack.Open(damagedPath, writable: false)) { Assert.Equal(40, pack.Count); Assert.Contains(pack.Warnings, w => w.Contains("No valid header")); } // A flipped JPEG byte is caught by its CRC on read. var flipped = (byte[])bytes.Clone(); flipped[128 + 40] ^= 0xFF; var flippedPath = Path.Combine(_dir, "flipped.pack"); File.WriteAllBytes(flippedPath, flipped); using var f = ThumbnailPack.Open(flippedPath, writable: false); Assert.Null(f.ReadJpeg(Id(0))); Assert.NotNull(f.ReadJpeg(Id(1))); } [Test] public void CompactionDropsDeadEntries() { var path = Path.Combine(_dir, "compact.pack"); using var pack = ThumbnailPack.Open(path); for (var i = 0; i < 30; i++) pack.AddJpeg(Id(i), Jpeg(i), 40, 30); for (var i = 0; i < 10; i++) pack.AddJpeg(Id(i), Jpeg(i + 500), 40, 30); for (var i = 25; i < 30; i++) Assert.True(pack.Remove(Id(i))); pack.Flush(); var before = new FileInfo(path).Length; var wasted = pack.WastedBytes; pack.Compact(); var after = new FileInfo(path).Length; context.Log($"compaction {before} → {after} bytes (wasted {wasted})"); Assert.Less(after, before - wasted / 2); Assert.Equal(25, pack.Count); Assert.Null(pack.ReadJpeg(Id(27))); Assert.BytesEqual(Jpeg(503), pack.ReadJpeg(Id(3))); pack.AddJpeg(Id(100), Jpeg(100), 40, 30); pack.Flush(); using var reopened = ThumbnailPack.Open(path, writable: false); Assert.Equal(26, reopened.Count); Assert.Empty(reopened.Warnings); Assert.BytesEqual(Jpeg(15), reopened.ReadJpeg(Id(15))); } [Test] [Timeout(20_000)] public async Task ConcurrentReadsWhileWriting() { var path = Path.Combine(_dir, "concurrent.pack"); var jpegs = Enumerable.Range(0, 200).Select(Jpeg).ToArray(); using var pack = ThumbnailPack.Open(path); for (var i = 0; i < 10; i++) pack.AddJpeg(Id(i), jpegs[i], 40, 30); pack.Flush(); using var done = new CancellationTokenSource(); var writer = Task.Run(() => { for (var i = 10; i < 200; i++) pack.AddJpeg(Id(i), jpegs[i], 40, 30); pack.Flush(); done.Cancel(); }); var readers = Enumerable.Range(0, 4).Select(r => Task.Run(() => { var random = new Random(r); var reads = 0; while (!done.IsCancellationRequested || reads < 50) { var ids = pack.FrameIds.ToArray(); var id = ids[random.Next(ids.Length)]; var data = pack.ReadJpeg(id); Assert.NotNull(data); Assert.BytesEqual(jpegs[id.ToByteArray()[0] | id.ToByteArray()[1] << 8], data); reads++; } return reads; })).ToArray(); var other = Task.Run(() => { using var view = ThumbnailPack.Open(path, writable: false); while (!done.IsCancellationRequested) { view.Refresh(); foreach (var id in view.FrameIds) Assert.NotNull(view.ReadJpeg(id)); } }); await Task.WhenAll([writer, other, .. readers]); Assert.Equal(200, pack.Count); context.Log($"reads: {string.Join(", ", readers.Select(r => r.Result))}"); } [Test] public async Task CacheEvictsLeastRecentlyUsedAndCoalescesLoads() { var cache = new ThumbnailCache(3 * (300 + 64)); Thumbnail T() => new(10, 10, new byte[300]); cache.Set(1, T()); cache.Set(2, T()); cache.Set(3, T()); Assert.True(cache.TryGet(1, out _)); cache.Set(4, T()); Assert.False(cache.TryGet(2, out _)); Assert.True(cache.TryGet(1, out _)); Assert.Equal(3, cache.Count); Assert.LessOrEqual(cache.Bytes, cache.Budget); cache.Set(5, new Thumbnail(100, 100, new byte[30000])); Assert.False(cache.TryGet(5, out _)); var loads = 0; var gate = new TaskCompletionSource(); async Task Loader(int key, CancellationToken ct) { Interlocked.Increment(ref loads); await gate.Task; return Thumbnail.FromJpeg(Jpeg(key)); } var large = new ThumbnailCache(1 << 20); var requests = Enumerable.Range(0, 10).Select(_ => large.GetOrLoadAsync(42, Loader)).ToArray(); gate.SetResult(); var results = await Task.WhenAll(requests); Assert.Equal(1, loads); Assert.True(results.All(r => ReferenceEquals(r, results[0]))); Assert.Equal(40, results[0]!.Width); Assert.True(large.TryGet(42, out _)); } [Test] public void ProxyCarriesUprightPixelsAndCaptureExif() { var captured = new DateTime(2025, 7, 14, 21, 3, 9, DateTimeKind.Unspecified).AddTicks(4_500_000); var metadata = new FrameMetadata { Make = "TestCam", Model = "T1", Orientation = 6, CapturedAt = captured, UtcOffsetMinutes = 120, Iso = 800, ExposureTime = 1 / 250.0 }; using var image = Frame(1, 2000, 1500); var exif = ExifWriter.BuildTiff(metadata); var source = Path.Combine(_dir, "src.jpg"); File.WriteAllBytes(source, JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 90, App1Segments = [[.. "Exif\0\0"u8, .. exif]] })); var proxy = ProxyBuilder.Write(DecoderFactory.CreateServer(), source, Path.Combine(_dir, "proxy.jpg"), ProxySize.Edge1280); Assert.NotNull(proxy); Assert.Equal(960, proxy!.Width); Assert.Equal(1280, proxy.Height); Assert.Equal(DecodeTier.Native, proxy.Tier); var back = MetadataReader.Read(Path.Combine(_dir, "proxy.jpg")); Assert.Equal(captured, back.CapturedAt); Assert.Equal(120, back.UtcOffsetMinutes); Assert.Equal(TimestampSource.ExifOriginal, back.TimestampSource); Assert.Equal(1, back.Orientation); Assert.Equal("TestCam", back.Make); Assert.Equal(800, back.Iso); Assert.Equal(960, back.Width); Assert.Equal(1280, back.Height); var info = JpegDecoder.ReadInfo(proxy.Jpeg); Assert.Equal(960, info.Width); var full = ProxyBuilder.Build(DecoderFactory.CreateServer(), source, ProxySize.Full); Assert.Equal(1500, full!.Width); } [Test] public void ProxyOfAnUnsupportedRawUsesThePreviewTier() { using var scene = SyntheticRaw.Smooth(96, 64); var active = new RawRect(24, 4, 120, 68); var cr2 = NativeRawWriters.Cr2(NativeRawWriters.Sensor(scene, "Canon EOS 5D Mark III", CfaPattern.Bayer("RGGB"), 128, 72, 24, 4, 2048, 16383), active, 1, "Canon EOS R99"); var path = Path.Combine(_dir, "x.cr2"); File.WriteAllBytes(path, cr2); var proxy = ProxyBuilder.Build(DecoderFactory.CreateServer(), path); Assert.Equal(DecodeTier.EmbeddedPreview, proxy!.Tier); Assert.Equal(64, proxy.Width); } }