From 730e4969335a5faf5f73f918b1f99f1887f4e87e Mon Sep 17 00:00:00 2001 From: Stephen Shaw Date: Tue, 17 Nov 2026 09:35:00 -0700 Subject: [PATCH 1/2] fix: Keep saves from dropping bytes they still claim A Matroska position edit refreshes the nested CRC before the parent. Setting a tag value keeps its sort name and the other languages. A save with no filesystem uses the one the file was read with. A short WAV reload, and a sample buffer that cannot be allocated, fail without writing. A RIFF size of 0xFFFFFFFF is read through to the end of the stream. A stream past 2 GiB returns a failure instead of throwing. --- src/TagLibSharp2/Aiff/AiffFile.cs | 2 + src/TagLibSharp2/Core/MediaFile.cs | 26 +- src/TagLibSharp2/Dff/DffFile.cs | 3 + src/TagLibSharp2/Dsf/DsfFile.cs | 2 + src/TagLibSharp2/Matroska/MatroskaFile.cs | 2 + src/TagLibSharp2/Matroska/MatroskaRewrite.cs | 9 +- src/TagLibSharp2/Matroska/MatroskaTag.cs | 99 +++++-- src/TagLibSharp2/Mp4/Mp4File.cs | 2 + src/TagLibSharp2/Mpeg/Mp3File.cs | 2 + src/TagLibSharp2/Ogg/OggOpusFile.cs | 2 + src/TagLibSharp2/Ogg/OggVorbisFile.cs | 2 + src/TagLibSharp2/Riff/RiffFile.cs | 4 +- src/TagLibSharp2/Riff/WavFile.cs | 27 +- src/TagLibSharp2/Xiph/FlacFile.cs | 2 + .../Core/WindowedReadEdgeTests.cs | 244 ++++++++++++++++++ .../Matroska/MatroskaSaveTests.cs | 122 +++++++++ 16 files changed, 520 insertions(+), 30 deletions(-) diff --git a/src/TagLibSharp2/Aiff/AiffFile.cs b/src/TagLibSharp2/Aiff/AiffFile.cs index 5529d30..a00e283 100644 --- a/src/TagLibSharp2/Aiff/AiffFile.cs +++ b/src/TagLibSharp2/Aiff/AiffFile.cs @@ -422,6 +422,7 @@ public BinaryData Render () public FileWriteResult SaveToFile (string path, IFileSystem? fileSystem = null) { var data = Render (); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.Write (path, data.Span, fileSystem); } @@ -438,6 +439,7 @@ public Task SaveToFileAsync ( CancellationToken cancellationToken = default) { var data = Render (); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.WriteAsync (path, data.Memory, fileSystem, cancellationToken); } diff --git a/src/TagLibSharp2/Core/MediaFile.cs b/src/TagLibSharp2/Core/MediaFile.cs index cad0bac..d0f31df 100644 --- a/src/TagLibSharp2/Core/MediaFile.cs +++ b/src/TagLibSharp2/Core/MediaFile.cs @@ -180,7 +180,11 @@ public static MediaFileResult Read (Stream stream, string? pathHint = null) #else ArgumentNullException.ThrowIfNull (stream); #endif - return Read (stream, pathHint, sourcePath: null, fileSystem: null); + try { + return Read (stream, pathHint, sourcePath: null, fileSystem: null); + } catch (IOException ex) { + return MediaFileResult.Failure (ex.Message); + } } /// @@ -240,7 +244,17 @@ public static Task ReadAsync ( #else ArgumentNullException.ThrowIfNull (stream); #endif - return ReadAsync (stream, pathHint, sourcePath: null, fileSystem: null, cancellationToken); + return ReadStreamAsync (stream, pathHint, cancellationToken); + } + + static async Task ReadStreamAsync (Stream stream, string? pathHint, CancellationToken cancellationToken) + { + try { + return await ReadAsync (stream, pathHint, sourcePath: null, fileSystem: null, cancellationToken) + .ConfigureAwait (false); + } catch (IOException ex) { + return MediaFileResult.Failure (ex.Message); + } } static MediaFileResult Read (Stream stream, string? pathHint, string? sourcePath, IFileSystem? fileSystem) @@ -336,9 +350,9 @@ static MediaFileResult FromWav (WavFileReadResult result) /// Optional file path hint for extension-based detection. /// A result containing the parsed file or an error. public static MediaFileResult ReadFromData (ReadOnlyMemory data, string? pathHint = null) => - ReadCore (data, pathHint, sourceFileSystem: null, rememberPath: false); + ReadCore (data, pathHint); - static MediaFileResult ReadCore (ReadOnlyMemory data, string? pathHint, IFileSystem? sourceFileSystem, bool rememberPath) + static MediaFileResult ReadCore (ReadOnlyMemory data, string? pathHint) { var format = DetectFormat (data.Span, pathHint); @@ -361,10 +375,6 @@ static MediaFileResult ReadCore (ReadOnlyMemory data, string? pathHint, IF _ => MediaFileResult.Failure ($"Unknown or unsupported file format{(pathHint is not null ? $": {pathHint}" : "")}") }; - // ReadFromData's path is only an extension hint. A path read can save Matroska back to that file. - if (rememberPath && result.IsSuccess && pathHint is not null && result.File is MatroskaFile matroska) - matroska.SetSourcePath (pathHint, sourceFileSystem); - return result; } diff --git a/src/TagLibSharp2/Dff/DffFile.cs b/src/TagLibSharp2/Dff/DffFile.cs index 817d631..64a92e7 100644 --- a/src/TagLibSharp2/Dff/DffFile.cs +++ b/src/TagLibSharp2/Dff/DffFile.cs @@ -586,6 +586,7 @@ public FileWriteResult SaveToFile (string path, ReadOnlySpan originalData, try { var rendered = Render (); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.Write (path, rendered.Span, fileSystem); } catch (Exception ex) { return FileWriteResult.Failure ($"Failed to save file: {ex.Message}"); @@ -623,6 +624,7 @@ public FileWriteResult SaveToFile (string path, IFileSystem? fileSystem = null) try { var rendered = Render (); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.Write (path, rendered.Span, fileSystem); } catch (Exception ex) { return FileWriteResult.Failure ($"Failed to save file: {ex.Message}"); @@ -687,6 +689,7 @@ private async Task SaveToFileAsyncCore ( { try { var rendered = Render (); + fileSystem ??= _sourceFileSystem; return await AtomicFileWriter.WriteAsync (path, rendered.Memory, fileSystem, cancellationToken) .ConfigureAwait (false); } catch (Exception ex) { diff --git a/src/TagLibSharp2/Dsf/DsfFile.cs b/src/TagLibSharp2/Dsf/DsfFile.cs index 9429141..4f7fa0e 100644 --- a/src/TagLibSharp2/Dsf/DsfFile.cs +++ b/src/TagLibSharp2/Dsf/DsfFile.cs @@ -494,6 +494,7 @@ public FileWriteResult SaveToFile (string path, ReadOnlySpan originalData, if (rendered.IsEmpty) return FileWriteResult.Failure ("Failed to render DSF file"); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.Write (path, rendered.Span, fileSystem); } @@ -520,6 +521,7 @@ public Task SaveToFileAsync ( if (rendered.IsEmpty) return Task.FromResult (FileWriteResult.Failure ("Failed to render DSF file")); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.WriteAsync (path, rendered.Memory, fileSystem, cancellationToken); } diff --git a/src/TagLibSharp2/Matroska/MatroskaFile.cs b/src/TagLibSharp2/Matroska/MatroskaFile.cs index c07c761..283c40e 100644 --- a/src/TagLibSharp2/Matroska/MatroskaFile.cs +++ b/src/TagLibSharp2/Matroska/MatroskaFile.cs @@ -216,6 +216,7 @@ public FileWriteResult SaveToFile (string path, ReadOnlySpan originalData, if (!MatroskaRewrite.TryRewrite (originalData, Tag, out var rewritten, out var error)) return FileWriteResult.Failure (error); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.Write (path, rewritten, fileSystem); } @@ -252,6 +253,7 @@ public Task SaveToFileAsync ( if (!MatroskaRewrite.TryRewrite (originalData.Span, Tag, out var rewritten, out var error)) return Task.FromResult (FileWriteResult.Failure (error)); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.WriteAsync (path, rewritten, fileSystem, cancellationToken); } diff --git a/src/TagLibSharp2/Matroska/MatroskaRewrite.cs b/src/TagLibSharp2/Matroska/MatroskaRewrite.cs index e82db8e..b528308 100644 --- a/src/TagLibSharp2/Matroska/MatroskaRewrite.cs +++ b/src/TagLibSharp2/Matroska/MatroskaRewrite.cs @@ -348,6 +348,7 @@ static bool TryPatchSeek (byte[] body, EbmlElement seek, Plan plan, ref bool cha if (positionElement.DataLength is > 0 and <= 8 && TryWriteUnsigned (body, positionElement.DataOffset, (int)positionElement.DataLength, desired)) { changed = true; + UpdateElementCrc (body, seek.Position, seek.End); if (isTags) referenced = true; return true; @@ -490,8 +491,14 @@ static bool TryPatchCueValues (byte[] body, int offset, int end, Plan plan, ref changed = true; } } else if (element.Id is MatroskaIds.CuePoint or MatroskaIds.CueTrackPositions or MatroskaIds.Cues) { - if (!TryPatchCueValues (body, element.DataOffset, element.End, plan, ref changed)) + var nested = false; + if (!TryPatchCueValues (body, element.DataOffset, element.End, plan, ref nested)) return false; + if (nested) { + changed = true; + if (element.Id != MatroskaIds.Cues) + UpdateElementCrc (body, element.Position, element.End); + } } offset = element.End; diff --git a/src/TagLibSharp2/Matroska/MatroskaTag.cs b/src/TagLibSharp2/Matroska/MatroskaTag.cs index d0f1474..646eb40 100644 --- a/src/TagLibSharp2/Matroska/MatroskaTag.cs +++ b/src/TagLibSharp2/Matroska/MatroskaTag.cs @@ -594,31 +594,94 @@ void SetAt (ulong level, string name, string? value) void SetAtValues (ulong level, string name, string[]? values) { - SimpleTag? previous = null; - foreach (var existing in _blocks) { - if (!existing.IsFileLevel || existing.Level != level) + var matches = new List (); + foreach (var block in _blocks) { + if (!block.IsFileLevel || block.Level != level) continue; - foreach (var tag in existing.Tags) { - if (tag.Name != name) - continue; - previous = tag; - break; + foreach (var tag in block.Tags) { + if (tag.Name == name) + matches.Add (tag); } } - RemoveAt (level, name); - if (values is null || values.Length == 0) + var preferDefault = false; + foreach (var tag in matches) { + if (tag.IsDefault) + preferDefault = true; + } + + var primary = new List (); + foreach (var tag in matches) { + if (!preferDefault || tag.IsDefault) + primary.Add (tag); + } + + var incoming = new List (); + if (values is not null) { + foreach (var value in values) { + if (!string.IsNullOrEmpty (value)) + incoming.Add (value); + } + } + + if (incoming.Count == 0) { + RemoveTags (primary); return; + } + + if (primary.Count == 0) { + var block = FileBlock (level); + foreach (var value in incoming) + block.Tags.Add (new SimpleTag (name, value)); + return; + } + + var home = BlockContaining (primary[0]); + ReplaceTag (primary[0], CopyTag (primary[0], incoming[0])); + if (primary.Count > 1) + RemoveTags (primary.GetRange (1, primary.Count - 1)); + for (var i = 1; i < incoming.Count; i++) { + var source = i < primary.Count ? primary[i] : primary[0]; + home.Tags.Add (CopyTag (source, incoming[i])); + } + } - var block = FileBlock (level); - foreach (var value in values) { - if (string.IsNullOrEmpty (value)) + static SimpleTag CopyTag (SimpleTag previous, string text) + { + var tag = new SimpleTag (previous.Name, text, previous.IsDefault) { + Language = previous.Language, + LanguageBcp47 = previous.LanguageBcp47, + Binary = previous.Binary + }; + tag.Children.AddRange (previous.Children); + return tag; + } + + void ReplaceTag (SimpleTag previous, SimpleTag replacement) + { + foreach (var block in _blocks) { + var index = block.Tags.IndexOf (previous); + if (index < 0) continue; - block.Tags.Add (new SimpleTag (name, value) { - Language = previous?.Language, - LanguageBcp47 = previous?.LanguageBcp47, - Binary = previous?.Binary - }); + block.Tags[index] = replacement; + return; + } + } + + TagBlock BlockContaining (SimpleTag tag) + { + foreach (var block in _blocks) { + if (block.Tags.Contains (tag)) + return block; + } + + return FileBlock (ItemLevel); + } + + void RemoveTags (List tags) + { + foreach (var block in _blocks) { + block.Tags.RemoveAll (tag => tags.Contains (tag)); } } diff --git a/src/TagLibSharp2/Mp4/Mp4File.cs b/src/TagLibSharp2/Mp4/Mp4File.cs index 10f8dcd..1d242f3 100644 --- a/src/TagLibSharp2/Mp4/Mp4File.cs +++ b/src/TagLibSharp2/Mp4/Mp4File.cs @@ -2135,6 +2135,7 @@ public FileWriteResult SaveToFile (string path, ReadOnlySpan originalData, if (rendered.IsEmpty) return FileWriteResult.Failure ("Failed to render MP4 file"); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.Write (path, rendered.Span, fileSystem); } @@ -2156,6 +2157,7 @@ public Task SaveToFileAsync ( if (rendered.IsEmpty) return Task.FromResult (FileWriteResult.Failure ("Failed to render MP4 file")); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.WriteAsync (path, rendered.Memory, fileSystem, cancellationToken); } diff --git a/src/TagLibSharp2/Mpeg/Mp3File.cs b/src/TagLibSharp2/Mpeg/Mp3File.cs index 402821c..cea88c4 100644 --- a/src/TagLibSharp2/Mpeg/Mp3File.cs +++ b/src/TagLibSharp2/Mpeg/Mp3File.cs @@ -655,6 +655,7 @@ public FileWriteResult SaveToFile (string path, ReadOnlySpan originalData, if (rendered.IsEmpty) return FileWriteResult.Failure ("Failed to render MP3 file"); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.Write (path, rendered.Span, fileSystem); } @@ -676,6 +677,7 @@ public Task SaveToFileAsync ( if (rendered.IsEmpty) return Task.FromResult (FileWriteResult.Failure ("Failed to render MP3 file")); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.WriteAsync (path, rendered.Memory, fileSystem, cancellationToken); } diff --git a/src/TagLibSharp2/Ogg/OggOpusFile.cs b/src/TagLibSharp2/Ogg/OggOpusFile.cs index de72bcb..5246441 100644 --- a/src/TagLibSharp2/Ogg/OggOpusFile.cs +++ b/src/TagLibSharp2/Ogg/OggOpusFile.cs @@ -585,6 +585,7 @@ public FileWriteResult SaveToFile (string path, ReadOnlySpan originalData, if (rendered.IsEmpty) return FileWriteResult.Failure ("Failed to render Ogg Opus file"); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.Write (path, rendered.Span, fileSystem); } @@ -606,6 +607,7 @@ public Task SaveToFileAsync ( if (rendered.IsEmpty) return Task.FromResult (FileWriteResult.Failure ("Failed to render Ogg Opus file")); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.WriteAsync (path, rendered.Memory, fileSystem, cancellationToken); } diff --git a/src/TagLibSharp2/Ogg/OggVorbisFile.cs b/src/TagLibSharp2/Ogg/OggVorbisFile.cs index 42bc077..d15223a 100644 --- a/src/TagLibSharp2/Ogg/OggVorbisFile.cs +++ b/src/TagLibSharp2/Ogg/OggVorbisFile.cs @@ -495,6 +495,7 @@ public FileWriteResult SaveToFile (string path, ReadOnlySpan originalData, if (rendered.IsEmpty) return FileWriteResult.Failure ("Failed to render Ogg Vorbis file"); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.Write (path, rendered.Span, fileSystem); } @@ -516,6 +517,7 @@ public Task SaveToFileAsync ( if (rendered.IsEmpty) return Task.FromResult (FileWriteResult.Failure ("Failed to render Ogg Vorbis file")); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.WriteAsync (path, rendered.Memory, fileSystem, cancellationToken); } diff --git a/src/TagLibSharp2/Riff/RiffFile.cs b/src/TagLibSharp2/Riff/RiffFile.cs index 46f3c91..fb4df81 100644 --- a/src/TagLibSharp2/Riff/RiffFile.cs +++ b/src/TagLibSharp2/Riff/RiffFile.cs @@ -214,7 +214,9 @@ internal static bool TryRead (Stream stream, out RiffFile file, out List && ((_keepUnparsedBext && BextTag is null) || (ReferenceEquals (BextTag, _parsedBext) && BextTag is { } tag && tag.MatchesSource ())); + static uint MaxSampleBytes { + get { +#if NET8_0_OR_GREATER + return (uint)Array.MaxLength; +#else + return 0x7FFFFFC7; +#endif + } + } + bool TryLoadSkippedSamples (out string? error) { error = null; @@ -564,7 +574,7 @@ bool TryLoadSkippedSamples (out string? error) return true; foreach (var chunk in _skippedChunks) { - if (chunk.PresentBytes > int.MaxValue) { + if (chunk.PresentBytes > MaxSampleBytes) { error = "Cannot save a WAV file whose sample data does not fit in memory."; return false; } @@ -584,11 +594,22 @@ bool TryLoadSkippedSamples (out string? error) } } + var loaded = new List (_skippedChunks.Count); foreach (var chunk in _skippedChunks) { stream.Position = chunk.Offset; var samples = StreamBytes.ReadAtMost (stream, (int)chunk.PresentBytes); + if (samples.Length != chunk.PresentBytes) { + error = "Cannot save a WAV file whose sample data is no longer in the source file."; + return false; + } + + loaded.Add (samples); + } + + for (var i = 0; i < _skippedChunks.Count; i++) { + var chunk = _skippedChunks[i]; var fourCC = _riff.AllChunks[chunk.Index].FourCC; - _riff.ReplaceChunkAt (chunk.Index, new RiffChunk (fourCC, new BinaryData (samples))); + _riff.ReplaceChunkAt (chunk.Index, new RiffChunk (fourCC, new BinaryData (loaded[i]))); } _skippedChunks.Clear (); @@ -620,6 +641,7 @@ public FileWriteResult SaveToFile (string path, IFileSystem? fileSystem = null) return FileWriteResult.Failure (skipped!); var data = Render (); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.Write (path, data.Span, fileSystem); } @@ -644,6 +666,7 @@ public Task SaveToFileAsync ( return Task.FromResult (FileWriteResult.Failure (skipped!)); var data = Render (); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.WriteAsync (path, data.Memory, fileSystem, cancellationToken); } diff --git a/src/TagLibSharp2/Xiph/FlacFile.cs b/src/TagLibSharp2/Xiph/FlacFile.cs index bb32252..42ef057 100644 --- a/src/TagLibSharp2/Xiph/FlacFile.cs +++ b/src/TagLibSharp2/Xiph/FlacFile.cs @@ -635,6 +635,7 @@ public FileWriteResult SaveToFile (string path, ReadOnlySpan originalData, if (rendered.IsEmpty) return FileWriteResult.Failure ("Failed to render FLAC file"); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.Write (path, rendered.Span, fileSystem); } @@ -656,6 +657,7 @@ public Task SaveToFileAsync ( if (rendered.IsEmpty) return Task.FromResult (FileWriteResult.Failure ("Failed to render FLAC file")); + fileSystem ??= _sourceFileSystem; return AtomicFileWriter.WriteAsync (path, rendered.Memory, fileSystem, cancellationToken); } diff --git a/tests/TagLibSharp2.Tests/Core/WindowedReadEdgeTests.cs b/tests/TagLibSharp2.Tests/Core/WindowedReadEdgeTests.cs index eea3fcc..9b0e1b5 100644 --- a/tests/TagLibSharp2.Tests/Core/WindowedReadEdgeTests.cs +++ b/tests/TagLibSharp2.Tests/Core/WindowedReadEdgeTests.cs @@ -358,6 +358,90 @@ public void Read_FlacBlockCutOff_Stops () Assert.IsFalse (result.IsSuccess); } + [TestMethod] + public void Save_ShortSampleReload_DoesNotWrite () + { + var samples = new byte[] { 1, 2, 3, 4 }; + var original = WavWithTitle ("Keep", samples); + var fs = new ShortReloadFileSystem (); + fs.AddFile ("/song.wav", original); + var opened = MediaFile.Read ("/song.wav", fs); + Assert.IsTrue (opened.IsSuccess, opened.Error); + var wav = opened.GetFileAs (); + Assert.IsNotNull (wav); + + var saved = wav!.SaveToFile ("/song.wav", fs); + + Assert.IsFalse (saved.IsSuccess, saved.Error); + CollectionAssert.AreEqual (original, fs.ReadAllBytes ("/song.wav")); + } + + [TestMethod] + public void Read_UnknownRiffSize_ReadsTheChunkPastFourGigabytes () + { + const long Cap = 4294967295L + 8; + var list = ListChunk ("Past"); + var dataSize = (uint)(Cap - 44); + var prefix = WavPrefix (dataSize); + var listAt = 44L + dataSize + ((dataSize & 1) == 1 ? 1 : 0); + var stream = new SparseStream (listAt + list.Length, prefix, listAt, list); + + var opened = MediaFile.Read (stream, "song.wav"); + + Assert.IsTrue (opened.IsSuccess, opened.Error); + Assert.IsNotNull (opened.Tag, opened.Error); + Assert.AreEqual ("Past", opened.Tag!.Title); + } + + [TestMethod] + public void Save_DataChunkJustOverTheArrayLimit_FailsClosed () + { + var count = (uint)Array.MaxLength + 1; + var prefix = WavPrefix (count); + var streamLength = prefix.Length + count; + var fs = new SparseFileSystem (streamLength, prefix); + var opened = WavFile.Read (fs.OpenRead ("/huge.wav"), "/huge.wav", fs); + Assert.IsTrue (opened.IsSuccess, opened.Error); + + FileWriteResult saved; + try { + saved = opened.File!.SaveToFile ("/huge.wav", fs); + } catch (Exception ex) { + Assert.Fail ("Save threw " + ex.GetType ().Name + " instead of returning a failure"); + return; + } + + Assert.IsFalse (saved.IsSuccess, saved.Error); + Assert.AreEqual (0, fs.Writes); + } + + [TestMethod] + public void Read_StreamLongerThanAnArray_ReturnsFailure () + { + using var stream = new ReportedLengthStream ((long)int.MaxValue + 8); + + var opened = MediaFile.Read (stream, "clip.mkv"); + + Assert.IsFalse (opened.IsSuccess); + StringAssert.Contains (opened.Error, "too large"); + } + + [TestMethod] + public void Save_Mp3Parameterless_WritesTheFileSystemFromRead () + { + var original = TinyMp3 (800); + var fs = new MockFileSystem (); + fs.AddFile ("/virtual.mp3", original); + var opened = Mp3File.ReadFromFile ("/virtual.mp3", fs); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.Title = "Stored"; + + var saved = opened.File.SaveToFile (); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Stored", Mp3File.Read (fs.ReadAllBytes ("/virtual.mp3")).File!.Tag!.Title); + } + [TestMethod] public async Task ReadAsync_FlacHeaderTooShort_Stops () { @@ -426,6 +510,47 @@ static byte[] WavWithTitle (string title, byte[]? samples) static byte[] Riff (BinaryDataBuilder body) => Riff (body.ToBinaryData ().Span); + static byte[] WavPrefix (uint dataSize) + { + using var body = new BinaryDataBuilder (); + body.AddStringLatin1 ("WAVE"); + body.AddStringLatin1 ("fmt "); + body.AddUInt32LE (16); + body.AddUInt16LE (1); + body.AddUInt16LE (1); + body.AddUInt32LE (8000); + body.AddUInt32LE (8000); + body.AddUInt16LE (1); + body.AddUInt16LE (8); + body.AddStringLatin1 ("data"); + body.AddUInt32LE (dataSize); + var form = body.ToBinaryData ().Span; + var file = new byte[8 + form.Length]; + "RIFF"u8.CopyTo (file); + file[4] = 0xFF; + file[5] = 0xFF; + file[6] = 0xFF; + file[7] = 0xFF; + form.CopyTo (file.AsSpan (8)); + return file; + } + + static byte[] ListChunk (string title) + { + var text = System.Text.Encoding.ASCII.GetBytes (title + "\0"); + using var info = new BinaryDataBuilder (); + info.AddStringLatin1 ("INFO"); + info.AddStringLatin1 ("INAM"); + info.AddUInt32LE ((uint)text.Length); + info.Add (text); + var list = info.ToBinaryData (); + var chunk = new byte[8 + list.Length]; + "LIST"u8.CopyTo (chunk); + BitConverter.GetBytes ((uint)list.Length).CopyTo (chunk, 4); + list.Span.CopyTo (chunk.AsSpan (8)); + return chunk; + } + static byte[] Riff (ReadOnlySpan body) { var file = new byte[8 + body.Length]; @@ -479,6 +604,125 @@ public override void Flush () { } public override void Write (byte[] buffer, int offset, int count) => throw new NotSupportedException (); } + sealed class ShortReloadFileSystem : IFileSystem + { + readonly MockFileSystem _files = new (); + int _opens; + + public void AddFile (string path, byte[] data) => _files.AddFile (path, data); + + public bool FileExists (string path) => _files.FileExists (path); + + public Stream OpenRead (string path) + { + var data = _files.ReadAllBytes (path); + if (_opens++ == 0) + return new MemoryStream (data, writable: false); + return new ReportedLengthStream (data.Length); + } + + public Stream OpenReadWrite (string path) => _files.OpenReadWrite (path); + public Stream Create (string path) => _files.Create (path); + public byte[] ReadAllBytes (string path) => _files.ReadAllBytes (path); + public Task ReadAllBytesAsync (string path, CancellationToken cancellationToken = default) => + _files.ReadAllBytesAsync (path, cancellationToken); + public void WriteAllBytes (string path, ReadOnlySpan data) => _files.WriteAllBytes (path, data); + public Task WriteAllBytesAsync (string path, ReadOnlyMemory data, CancellationToken cancellationToken = default) => + _files.WriteAllBytesAsync (path, data, cancellationToken); + public void Delete (string path) => _files.Delete (path); + public void Move (string sourcePath, string destinationPath) => _files.Move (sourcePath, destinationPath); + public string? GetDirectoryName (string path) => _files.GetDirectoryName (path); + public string GetFileName (string path) => _files.GetFileName (path); + public string CombinePath (string path1, string path2) => _files.CombinePath (path1, path2); + } + + sealed class SparseFileSystem : IFileSystem + { + readonly long _length; + readonly byte[] _head; + public int Writes { get; private set; } + + public SparseFileSystem (long length, byte[] head) + { + _length = length; + _head = head; + } + + public bool FileExists (string path) => true; + public Stream OpenRead (string path) => new SparseStream (_length, _head, _length, Array.Empty ()); + public Stream OpenReadWrite (string path) => throw new NotSupportedException (); + public Stream Create (string path) + { + Writes++; + return new MemoryStream (); + } + + public byte[] ReadAllBytes (string path) => _head; + public Task ReadAllBytesAsync (string path, CancellationToken cancellationToken = default) => + Task.FromResult (_head); + public void WriteAllBytes (string path, ReadOnlySpan data) => Writes++; + public Task WriteAllBytesAsync (string path, ReadOnlyMemory data, CancellationToken cancellationToken = default) + { + Writes++; + return Task.CompletedTask; + } + + public void Delete (string path) { } + public void Move (string sourcePath, string destinationPath) => Writes++; + public string? GetDirectoryName (string path) => "/"; + public string GetFileName (string path) => "huge.wav"; + public string CombinePath (string path1, string path2) => path1 + path2; + } + + sealed class SparseStream : Stream + { + readonly byte[] _head; + readonly long _tailAt; + readonly byte[] _tail; + + public SparseStream (long length, byte[] head, long tailAt, byte[] tail) + { + Length = length; + _head = head; + _tailAt = tailAt; + _tail = tail; + } + + public override bool CanRead => true; + public override bool CanSeek => true; + public override bool CanWrite => false; + public override long Length { get; } + public override long Position { get; set; } + public override void Flush () { } + public override long Seek (long offset, SeekOrigin origin) => Position = origin switch { + SeekOrigin.Current => Position + offset, + SeekOrigin.End => Length + offset, + _ => offset + }; + + public override void SetLength (long value) => throw new NotSupportedException (); + public override void Write (byte[] buffer, int offset, int count) => throw new NotSupportedException (); + + public override int Read (byte[] buffer, int offset, int count) + { + var read = 0; + while (read < count && Position < Length) { + int value; + if (Position < _head.Length) + value = _head[Position]; + else if (Position >= _tailAt && Position < _tailAt + _tail.Length) + value = _tail[Position - _tailAt]; + else + value = 0; + buffer[offset + read] = (byte)value; + Position++; + read++; + } + + return read; + } + } + sealed class NonSeekableStream : Stream { readonly Stream _inner; diff --git a/tests/TagLibSharp2.Tests/Matroska/MatroskaSaveTests.cs b/tests/TagLibSharp2.Tests/Matroska/MatroskaSaveTests.cs index 899172e..fd3b3ad 100644 --- a/tests/TagLibSharp2.Tests/Matroska/MatroskaSaveTests.cs +++ b/tests/TagLibSharp2.Tests/Matroska/MatroskaSaveTests.cs @@ -370,6 +370,85 @@ public void Save_UnknownSizeThatCannotBeBounded_DoesNotWrite () Assert.IsTrue (original.AsSpan ().SequenceEqual (fs.ReadAllBytes ("/bad.mkv"))); } + [TestMethod] + public void Save_InPlaceSeekAndCue_KeepsNestedCrc32 () + { + var marker = new byte[] { 0xC0, 0x1A }; + var info = Master (0x1549A966, Element (0x7BA9, "I"u8)); + var cues = CueTreeWithCrc (0); + var seek = SeekHeadWithNestedCrc (0); + ulong clusterPos = 0; + for (var i = 0; i < 6; i++) { + clusterPos = (ulong)(seek.Length + info.Length + cues.Length); + cues = CueTreeWithCrc (clusterPos); + seek = SeekHeadWithNestedCrc (clusterPos); + } + + Assert.IsTrue (clusterPos is > 0 and < 0x80); + var cluster = Concat (new byte[] { 0x1F, 0x43, 0xB6, 0x75, 0xFF }, Element (0xEC, marker)); + var original = FileWith (seek, info, cues, cluster); + Assert.IsTrue (EveryCrcMatches (original)); + var parsed = MatroskaFile.Read (original).File!; + parsed.Tag.Title = "Moved"; + + var fs = new MockFileSystem (); + fs.AddFile ("/crc.mkv", original); + var saved = parsed.SaveToFile ("/crc.mkv", original, fs); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + var bytes = fs.ReadAllBytes ("/crc.mkv"); + Assert.AreEqual ("Moved", MatroskaFile.Read (bytes).File!.Tag.Title); + Assert.AreEqual (1, CountOf (bytes, marker)); + Assert.IsTrue (EveryCrcMatches (bytes), "A Seek or cue CRC no longer matches its element"); + } + + [TestMethod] + public void Save_SettingTitle_KeepsSortAndOtherLanguages () + { + var french = Master (0x67C8, Concat ( + Element (0x45A3, "TITLE"u8), + Element (0x447A, "fre"u8), + Element (0x4484, new byte[] { 0 }), + Element (0x4487, "Bonjour"u8))); + var original = FileWith ( + Tags (Tag (30, french, SimpleSorted ("TITLE", "Hello", "Sort"))), + Master (0x1F43B675, new byte[] { 1 })); + var parsed = MatroskaFile.Read (original).File!; + Assert.AreEqual ("Hello", parsed.Tag.Title); + Assert.AreEqual ("Sort", parsed.Tag.TitleSort); + parsed.Tag.Title = "Hi"; + + var fs = new MockFileSystem (); + fs.AddFile ("/lang.mkv", original); + var saved = parsed.SaveToFile ("/lang.mkv", original, fs); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + var bytes = fs.ReadAllBytes ("/lang.mkv"); + var again = MatroskaFile.Read (bytes).File!; + Assert.AreEqual ("Hi", again.Tag.Title); + Assert.AreEqual ("Sort", again.Tag.TitleSort); + Assert.IsTrue (CountOf (bytes, "Bonjour"u8.ToArray ()) == 1); + } + + [TestMethod] + public void Save_Parameterless_WritesTheFileSystemFromRead () + { + var original = FileWith (Tags (Tag (30, Simple ("TITLE", "Media"))), Master (0x1F43B675, new byte[] { 1 })); + var fs = new MockFileSystem (); + fs.AddFile ("/virtual.mkv", original); + var opened = MediaFile.Read ("/virtual.mkv", fs); + Assert.IsTrue (opened.IsSuccess, opened.Error); + var file = opened.GetFileAs (); + Assert.IsNotNull (file); + file!.Tag.Album = "Stored"; + + var saved = file.SaveToFile (); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Stored", MatroskaFile.Read (fs.ReadAllBytes ("/virtual.mkv")).File!.Tag.Album); + Assert.AreEqual ("Media", MatroskaFile.Read (fs.ReadAllBytes ("/virtual.mkv")).File!.Tag.Title); + } + [TestMethod] public void Save_MediaFileRead_SetsSourcePath () { @@ -902,6 +981,49 @@ static byte[] CueElement (ulong clusterPos) return WithCrc (MatroskaIds.Cues, inner); } + static byte[] SeekHeadWithNestedCrc (ulong clusterPos) => + WithCrc (MatroskaIds.SeekHead, WithCrc (0x4DBB, Concat ( + Element (0x53AB, Id (MatroskaIds.Cluster)), + Element (0x53AC, UIntBytes (clusterPos))))); + + static byte[] CueTreeWithCrc (ulong clusterPos) + { + var positions = WithCrc (0xB7, Concat ( + Element (0xF7, new byte[] { 1 }), + Element (0xF1, UIntBytes (clusterPos)))); + var point = WithCrc (0xBB, Concat (Element (0xB3, new byte[] { 0 }), positions)); + return WithCrc (MatroskaIds.Cues, point); + } + + static bool EveryCrcMatches (byte[] file) + { + if (!TrySegmentBody (file, out var body, out _)) + return false; + return CrcTreeMatches (body); + } + + static bool CrcTreeMatches (ReadOnlySpan body) + { + var offset = 0; + while (offset < body.Length) { + if (!EbmlReader.TryRead (body, offset, body.Length, out var element) || element.UnknownSize) + return true; + var payload = body.Slice (element.DataOffset, (int)element.DataLength); + if (payload.Length > 0 && EbmlReader.TryRead (payload, 0, payload.Length, out var first) && first.Id == MatroskaIds.Crc32) { + if (!CrcMatches (payload)) + return false; + if (!CrcTreeMatches (payload.Slice (first.End))) + return false; + } else if (!CrcTreeMatches (payload)) { + return false; + } + + offset = element.End; + } + + return true; + } + static byte[] SeekHeadWithCrc (ulong infoAt, ulong tagsAt) => WithCrc (MatroskaIds.SeekHead, Concat ( SeekEntry (MatroskaIds.Info, infoAt), From 4230e882607bd0d676148b603937f6f73add307e Mon Sep 17 00:00:00 2001 From: Stephen Shaw Date: Tue, 17 Nov 2026 23:36:45 -0700 Subject: [PATCH 2/2] test: Cover the save and Matroska branches the patch check missed --- .../Core/SaveThroughReadFileSystemTests.cs | 293 ++++++++++++++++++ .../Core/WindowedReadEdgeTests.cs | 11 + .../Matroska/MatroskaFileTests.cs | 56 ++++ .../Matroska/MatroskaSaveTests.cs | 29 ++ 4 files changed, 389 insertions(+) create mode 100644 tests/TagLibSharp2.Tests/Core/SaveThroughReadFileSystemTests.cs diff --git a/tests/TagLibSharp2.Tests/Core/SaveThroughReadFileSystemTests.cs b/tests/TagLibSharp2.Tests/Core/SaveThroughReadFileSystemTests.cs new file mode 100644 index 0000000..5b36e01 --- /dev/null +++ b/tests/TagLibSharp2.Tests/Core/SaveThroughReadFileSystemTests.cs @@ -0,0 +1,293 @@ +// Copyright (c) 2025-2026 Stephen Shaw and contributors +// Licensed under the MIT License. See LICENSE file in the project root for full license information. + +using TagLibSharp2.Aiff; +using TagLibSharp2.Core; +using TagLibSharp2.Dff; +using TagLibSharp2.Dsf; +using TagLibSharp2.Id3.Id3v2; +using TagLibSharp2.Matroska; +using TagLibSharp2.Mp4; +using TagLibSharp2.Mpeg; +using TagLibSharp2.Ogg; +using TagLibSharp2.Riff; +using TagLibSharp2.Xiph; + +namespace TagLibSharp2.Tests.Core; + +[TestClass] +[TestCategory ("Unit")] +public class SaveThroughReadFileSystemTests +{ + [TestMethod] + public void Aiff_SaveWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var files = Stored ("/song.aiff", TestBuilders.Aiff.CreateMinimal ()); + var opened = AiffFile.ReadFromFile ("/song.aiff", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.Tag = Titled ("Aiff"); + + var saved = opened.File.SaveToFile ("/copy.aiff"); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + var again = AiffFile.ReadFromFile ("/copy.aiff", files); + Assert.IsTrue (again.IsSuccess, again.Error); + Assert.AreEqual ("Aiff", again.File!.Tag!.Title); + } + + [TestMethod] + public async Task Aiff_SaveAsyncWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var files = Stored ("/song.aiff", TestBuilders.Aiff.CreateMinimal ()); + var opened = AiffFile.ReadFromFile ("/song.aiff", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.Tag = Titled ("Aiff Async"); + + var saved = await opened.File.SaveToFileAsync ("/copy.aiff"); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Aiff Async", AiffFile.ReadFromFile ("/copy.aiff", files).File!.Tag!.Title); + } + + [TestMethod] + public void Wav_SaveWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var files = Stored ("/song.wav", TestBuilders.Wav.CreateMinimal ()); + var opened = WavFile.ReadFromFile ("/song.wav", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.Id3v2Tag = Titled ("Wav"); + + var saved = opened.File.SaveToFile ("/copy.wav"); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Wav", WavFile.ReadFromFile ("/copy.wav", files).File!.Id3v2Tag!.Title); + } + + [TestMethod] + public async Task Wav_SaveAsyncWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var files = Stored ("/song.wav", TestBuilders.Wav.CreateMinimal ()); + var opened = WavFile.ReadFromFile ("/song.wav", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.Id3v2Tag = Titled ("Wav Async"); + + var saved = await opened.File.SaveToFileAsync ("/copy.wav"); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Wav Async", WavFile.ReadFromFile ("/copy.wav", files).File!.Id3v2Tag!.Title); + } + + [TestMethod] + public void Flac_SaveWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var original = TestBuilders.Flac.CreateMinimal (); + var files = Stored ("/song.flac", original); + var opened = FlacFile.ReadFromFile ("/song.flac", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.Title = "Flac"; + + var saved = opened.File.SaveToFile ("/copy.flac", original); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Flac", FlacFile.ReadFromFile ("/copy.flac", files).File!.Title); + } + + [TestMethod] + public async Task Flac_SaveAsyncWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var original = TestBuilders.Flac.CreateMinimal (); + var files = Stored ("/song.flac", original); + var opened = FlacFile.ReadFromFile ("/song.flac", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.Title = "Flac Async"; + + var saved = await opened.File.SaveToFileAsync ("/copy.flac", original); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Flac Async", FlacFile.ReadFromFile ("/copy.flac", files).File!.Title); + } + + [TestMethod] + public void Mp4_SaveWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var original = TestBuilders.Mp4.CreateMinimalM4a (Mp4CodecType.Aac); + var files = Stored ("/song.m4a", original); + var opened = Mp4File.ReadFromFile ("/song.m4a", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.Title = "Mp4"; + + var saved = opened.File.SaveToFile ("/copy.m4a", original); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Mp4", Mp4File.ReadFromFile ("/copy.m4a", files).File!.Title); + } + + [TestMethod] + public async Task Mp4_SaveAsyncWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var original = TestBuilders.Mp4.CreateMinimalM4a (Mp4CodecType.Aac); + var files = Stored ("/song.m4a", original); + var opened = Mp4File.ReadFromFile ("/song.m4a", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.Title = "Mp4 Async"; + + var saved = await opened.File.SaveToFileAsync ("/copy.m4a", original); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Mp4 Async", Mp4File.ReadFromFile ("/copy.m4a", files).File!.Title); + } + + [TestMethod] + public void Vorbis_SaveWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var original = TestBuilders.Ogg.CreateMinimalFile (); + var files = Stored ("/song.ogg", original); + var opened = OggVorbisFile.ReadFromFile ("/song.ogg", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.Title = "Vorbis"; + + var saved = opened.File.SaveToFile ("/copy.ogg", original); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Vorbis", OggVorbisFile.ReadFromFile ("/copy.ogg", files).File!.Title); + } + + [TestMethod] + public async Task Mp3_SaveAsyncWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var original = TinyMp3 (); + var files = Stored ("/song.mp3", original); + var opened = Mp3File.ReadFromFile ("/song.mp3", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.Title = "Mp3"; + + var saved = await opened.File.SaveToFileAsync ("/copy.mp3", original); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Mp3", Mp3File.ReadFromFile ("/copy.mp3", files).File!.Title); + } + + [TestMethod] + public void Dsf_SaveWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var original = TestBuilders.Dsf.CreateMinimal (); + var files = Stored ("/song.dsf", original); + var opened = DsfFile.ReadFromFile ("/song.dsf", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.EnsureId3v2Tag ().Title = "Dsf"; + + var saved = opened.File.SaveToFile ("/copy.dsf", original); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Dsf", DsfFile.ReadFromFile ("/copy.dsf", files).File!.Id3v2Tag!.Title); + } + + [TestMethod] + public void Dff_SaveOfOriginalBytesWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var original = TestBuilders.Dff.CreateMinimal (); + var files = Stored ("/song.dff", original); + var opened = DffFile.ReadFromFile ("/song.dff", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.EnsureId3v2Tag ().Title = "Dff"; + + var saved = opened.File.SaveToFile ("/copy.dff", original); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Dff", DffFile.ReadFromFile ("/copy.dff", files).File!.Id3v2Tag!.Title); + } + + [TestMethod] + public async Task Dff_SaveAsyncWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var files = Stored ("/song.dff", TestBuilders.Dff.CreateMinimal ()); + var opened = DffFile.ReadFromFile ("/song.dff", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.EnsureId3v2Tag ().Title = "Dff Async"; + + var saved = await opened.File.SaveToFileAsync ("/copy.dff"); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Dff Async", DffFile.ReadFromFile ("/copy.dff", files).File!.Id3v2Tag!.Title); + } + + [TestMethod] + public async Task Matroska_SaveAsyncOfOriginalBytesWithoutAFileSystem_WritesThroughTheOneFromRead () + { + var original = AlbumOnly (); + var files = Stored ("/song.mkv", original); + var opened = MatroskaFile.ReadFromFile ("/song.mkv", files); + Assert.IsTrue (opened.IsSuccess, opened.Error); + opened.File!.Tag.Title = "Matroska"; + + var saved = await opened.File.SaveToFileAsync ("/copy.mkv", original); + + Assert.IsTrue (saved.IsSuccess, saved.Error); + Assert.AreEqual ("Matroska", MatroskaFile.ReadFromFile ("/copy.mkv", files).File!.Tag.Title); + } + + static MockFileSystem Stored (string path, byte[] data) + { + var files = new MockFileSystem (); + files.AddFile (path, data); + return files; + } + + static Id3v2Tag Titled (string title) + { + var tag = new Id3v2Tag (); + tag.Title = title; + return tag; + } + + static byte[] TinyMp3 () + { + Assert.IsTrue (MpegFrame.TryParse (new BinaryData (new byte[] { 0xFF, 0xFB, 0x90, 0x00 }), 0, out var frame)); + var audio = new byte[frame!.FrameSize]; + new byte[] { 0xFF, 0xFB, 0x90, 0x00 }.CopyTo (audio, 0); + return audio; + } + + static byte[] AlbumOnly () + { + var title = Element (0x67C8, Concat (Element (0x45A3, "TITLE"u8), Element (0x4487, "Album"u8))); + var targets = Element (0x63C0, Element (0x68CA, new byte[] { 50 })); + var tag = Element (0x7373, Concat (targets, title)); + var tags = Element (0x1254C367, tag); + var segment = Element (0x18538067, tags); + var ebml = Element (0x1A45DFA3, Element (0x4282, "matroska"u8)); + return Concat (ebml, segment); + } + + static byte[] Element (ulong id, ReadOnlySpan payload) + { + var size = new[] { (byte)(0x80 | payload.Length) }; + var idBytes = new byte[4]; + for (var i = 3; i >= 0; i--) { + idBytes[i] = (byte)id; + id >>= 8; + } + + var width = idBytes[0] == 0 ? idBytes[1] == 0 ? idBytes[2] == 0 ? 1 : 2 : 3 : 4; + var result = new byte[width + size.Length + payload.Length]; + idBytes.AsSpan (4 - width).CopyTo (result); + size.CopyTo (result, width); + payload.CopyTo (result.AsSpan (width + size.Length)); + return result; + } + + static byte[] Concat (params byte[][] parts) + { + var length = 0; + foreach (var part in parts) + length += part.Length; + var result = new byte[length]; + var offset = 0; + foreach (var part in parts) { + part.CopyTo (result, offset); + offset += part.Length; + } + + return result; + } +} diff --git a/tests/TagLibSharp2.Tests/Core/WindowedReadEdgeTests.cs b/tests/TagLibSharp2.Tests/Core/WindowedReadEdgeTests.cs index 9b0e1b5..4cb4491 100644 --- a/tests/TagLibSharp2.Tests/Core/WindowedReadEdgeTests.cs +++ b/tests/TagLibSharp2.Tests/Core/WindowedReadEdgeTests.cs @@ -426,6 +426,17 @@ public void Read_StreamLongerThanAnArray_ReturnsFailure () StringAssert.Contains (opened.Error, "too large"); } + [TestMethod] + public async Task ReadAsync_StreamLongerThanAnArray_ReturnsFailure () + { + using var stream = new ReportedLengthStream ((long)int.MaxValue + 8); + + var opened = await MediaFile.ReadAsync (stream, "clip.mkv"); + + Assert.IsFalse (opened.IsSuccess); + StringAssert.Contains (opened.Error, "too large"); + } + [TestMethod] public void Save_Mp3Parameterless_WritesTheFileSystemFromRead () { diff --git a/tests/TagLibSharp2.Tests/Matroska/MatroskaFileTests.cs b/tests/TagLibSharp2.Tests/Matroska/MatroskaFileTests.cs index 4a60622..7844eb0 100644 --- a/tests/TagLibSharp2.Tests/Matroska/MatroskaFileTests.cs +++ b/tests/TagLibSharp2.Tests/Matroska/MatroskaFileTests.cs @@ -68,6 +68,62 @@ public void Read_SeveralArtistsAtTheTrack_StaySeparate () Assert.AreEqual ("Bea", tag.Performers[1]); } + [TestMethod] + public void Performers_ReplacingTwoArtists_DropsTheExtraName () + { + var file = FileWith (Tags ( + Tag (50, Simple ("TITLE", "Album")), + Tag (30, Simple ("ARTIST", "Ada"), Simple ("ARTIST", "Bea")))); + var tag = MatroskaFile.Read (file).File!.Tag; + + tag.Performers = new[] { "Cara" }; + + Assert.AreEqual ("Cara", tag.Artist); + Assert.AreEqual (1, tag.Performers.Length); + Assert.AreEqual ("Cara", tag.Performers[0]); + Assert.AreEqual ("Album", tag.Album); + } + + [TestMethod] + public void Performers_TwoNewNames_KeepBothWhenOneArtistWasStored () + { + var file = FileWith (Tags (Tag (30, Simple ("ARTIST", "Ada")))); + var tag = MatroskaFile.Read (file).File!.Tag; + + tag.Performers = new[] { "Cara", "Dee" }; + + Assert.AreEqual (2, tag.Performers.Length); + Assert.AreEqual ("Cara", tag.Performers[0]); + Assert.AreEqual ("Dee", tag.Performers[1]); + } + + [TestMethod] + public void Performers_Blank_RemovesTheStoredArtists () + { + var file = FileWith (Tags (Tag (30, Simple ("ARTIST", "Ada"), Simple ("ARTIST", "Bea")))); + var tag = MatroskaFile.Read (file).File!.Tag; + + tag.Performers = new[] { "", null! }; + + Assert.AreEqual (0, tag.Performers.Length); + Assert.IsNull (tag.Artist); + } + + [TestMethod] + public void AlbumArtists_Empty_RemovesTheAlbumArtist () + { + var file = FileWith (Tags ( + Tag (50, Simple ("ARTIST", "Album Artist"), Simple ("TITLE", "Album")), + Tag (30, Simple ("TITLE", "Track")))); + var tag = MatroskaFile.Read (file).File!.Tag; + + tag.AlbumArtists = Array.Empty (); + + Assert.AreEqual (0, tag.AlbumArtists.Length); + Assert.AreEqual ("Album", tag.Album); + Assert.AreEqual ("Track", tag.Title); + } + [TestMethod] public void Read_ChapterTitle_IsNotTheFileTitle () { diff --git a/tests/TagLibSharp2.Tests/Matroska/MatroskaSaveTests.cs b/tests/TagLibSharp2.Tests/Matroska/MatroskaSaveTests.cs index fd3b3ad..857a8a4 100644 --- a/tests/TagLibSharp2.Tests/Matroska/MatroskaSaveTests.cs +++ b/tests/TagLibSharp2.Tests/Matroska/MatroskaSaveTests.cs @@ -402,6 +402,35 @@ public void Save_InPlaceSeekAndCue_KeepsNestedCrc32 () Assert.IsTrue (EveryCrcMatches (bytes), "A Seek or cue CRC no longer matches its element"); } + [TestMethod] + public void CrcCheck_RejectsAChecksumThatDoesNotMatch () + { + var wrapped = WithCrc (0x1549A966, Element (0x7BA9, "Title"u8)); + wrapped[^1] ^= 0xFF; + + Assert.IsFalse (EveryCrcMatches (FileWith (wrapped))); + Assert.IsFalse (EveryCrcMatches (new byte[] { 1, 2, 3, 4 })); + } + + [TestMethod] + public void CrcCheck_RejectsABrokenChecksumInsideAValidOne () + { + var inner = WithCrc (0x1549A966, Element (0x7BA9, "Title"u8)); + inner[^1] ^= 0xFF; + var outer = WithCrc (0x7373, inner); + + Assert.IsFalse (EveryCrcMatches (FileWith (outer))); + } + + [TestMethod] + public void CrcCheck_RejectsABrokenChecksumUnderAnElementWithoutOne () + { + var inner = WithCrc (0x1549A966, Element (0x7BA9, "Title"u8)); + inner[^1] ^= 0xFF; + + Assert.IsFalse (EveryCrcMatches (FileWith (Master (0x7373, inner)))); + } + [TestMethod] public void Save_SettingTitle_KeepsSortAndOtherLanguages () {