├── TryashtarUtils.Music.csproj
├── SharedIO.cs
├── PictureExtensions.cs
├── LanguageExtensions.cs
├── Chapters.cs
├── .gitignore
├── Lyrics.cs
├── ChaptersIO.cs
└── LyricsIO.cs


/TryashtarUtils.Music.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>net6.0</TargetFramework>
 5 |     <nullable>enable</nullable>
 6 |   </PropertyGroup>
 7 |   <PropertyGroup>
 8 |     <RootNamespace>TryashtarUtils.Music</RootNamespace>
 9 |     <AssemblyName>TryashtarUtils.Music</AssemblyName>
10 |   </PropertyGroup>
11 |   <ItemGroup>
12 |     <ProjectReference Include="..\taglib-sharp\src\TaglibSharp\TaglibSharp.csproj" />
13 |     <ProjectReference Include="..\utils.utility\TryashtarUtils.Utility.csproj" />
14 |   </ItemGroup>
15 |   <ItemGroup>
16 |     <Compile Remove="Properties\**" />
17 |     <EmbeddedResource Remove="Properties\**" />
18 |     <None Remove="**/desktop.ini" />
19 |     <None Remove="Properties\**" />
20 |   </ItemGroup>
21 | </Project>


--------------------------------------------------------------------------------
/SharedIO.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text.RegularExpressions;
 4 | 
 5 | namespace TryashtarUtils.Music
 6 | {
 7 |     internal static class SharedIO
 8 |     {
 9 |         public static readonly Regex LrcRegex = new(@"\[(?<time>.+)\](?<line>.+)");
10 |         public static readonly string[] TimespanFormats = new string[] { @"h\:mm\:ss\.FFF", @"mm\:ss\.FFF", @"m\:ss\.FFF", @"h\:mm\:ss", @"mm\:ss", @"m\:ss" };
11 | 
12 |         public static T? FromMany<T>(IEnumerable<Func<T?>> methods) where T : class
13 |         {
14 |             foreach (var method in methods)
15 |             {
16 |                 var item = method();
17 |                 if (item != null)
18 |                     return item;
19 |             }
20 |             return null;
21 |         }
22 | 
23 |         public static Func<U?> MethodAttempt<T, U>(Func<T?> setup, Func<T, U?> getter) where U : class
24 |         {
25 |             return () =>
26 |             {
27 |                 var item = setup();
28 |                 if (item == null)
29 |                     return null;
30 |                 return getter(item);
31 |             };
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/PictureExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Linq;
 3 | using TagLib;
 4 | using TagLib.Id3v2;
 5 | 
 6 | namespace TryashtarUtils.Music
 7 | {
 8 |     public static class PictureExtensions
 9 |     {
10 |         public static IPicture? Get(TagLib.Id3v2.Tag tag)
11 |         {
12 |             return tag.GetFrames<AttachmentFrame>().FirstOrDefault();
13 |         }
14 | 
15 |         public static IPicture? Get(TagLib.Flac.Metadata tag)
16 |         {
17 |             return tag.Pictures.FirstOrDefault();
18 |         }
19 | 
20 |         public static bool Set(TagLib.Id3v2.Tag tag, IPicture? picture)
21 |         {
22 |             var existing = tag.GetFrames<AttachmentFrame>().ToList();
23 |             foreach (var frame in existing)
24 |             {
25 |                 tag.RemoveFrame(frame);
26 |             }
27 | 
28 |             if (picture == null)
29 |                 return existing.Count > 0;
30 |             var attachment = new AttachmentFrame(picture);
31 |             tag.AddFrame(attachment);
32 |             return existing.Count != 1 || existing[0].Data == picture.Data;
33 |         }
34 | 
35 |         public static bool Set(TagLib.Flac.Metadata tag, IPicture? picture)
36 |         {
37 |             var existing = tag.Pictures;
38 | 
39 |             if (picture == null)
40 |             {
41 |                 tag.Pictures = Array.Empty<IPicture>();
42 |                 return existing.Length > 0;
43 |             }
44 | 
45 |             tag.Pictures = new[] { picture };
46 |             return existing.Length != 1 || existing[0].Data == picture.Data;
47 |         }
48 |     }
49 | }


--------------------------------------------------------------------------------
/LanguageExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Linq;
 3 | using System.Text;
 4 | using TagLib;
 5 | using TagLib.Id3v2;
 6 | 
 7 | namespace TryashtarUtils.Music
 8 | {
 9 |     public static class LanguageExtensions
10 |     {
11 |         public const string ID3_LANGUAGE_TAG = "TLAN";
12 |         public const string XIPH_LANGUAGE_TAG = "LANGUAGE";
13 | 
14 |         public static string? GetId3v2(TagLib.Id3v2.Tag tag)
15 |         {
16 |             return tag.GetFrames<TextInformationFrame>()
17 |                 .FirstOrDefault(x => x.FrameId.ToString() == ID3_LANGUAGE_TAG && x.Text.Length > 0)?.Text[0];
18 |         }
19 | 
20 |         public static string? GetXiph(TagLib.Ogg.XiphComment tag)
21 |         {
22 |             return tag.GetFirstField(XIPH_LANGUAGE_TAG);
23 |         }
24 | 
25 |         public static bool SetId3v2(TagLib.Id3v2.Tag tag, string? value)
26 |         {
27 |             var existing = tag.GetFrames<TextInformationFrame>().Where(x => x.FrameId.ToString() == ID3_LANGUAGE_TAG)
28 |                 .ToList();
29 |             if (value != null)
30 |             {
31 |                 var lang = new TextInformationFrame(ByteVector.FromString(ID3_LANGUAGE_TAG, StringType.UTF8))
32 |                 {
33 |                     Text = new[] { value },
34 |                     TextEncoding = StringType.UTF16
35 |                 };
36 |                 if (existing.Count == 1 && existing[0].Render(4) == lang.Render(4))
37 |                     return false;
38 |                 foreach (var frame in existing)
39 |                 {
40 |                     tag.RemoveFrame(frame);
41 |                 }
42 | 
43 |                 tag.AddFrame(lang);
44 |                 return true;
45 |             }
46 |             else
47 |             {
48 |                 foreach (var frame in existing)
49 |                 {
50 |                     tag.RemoveFrame(frame);
51 |                 }
52 | 
53 |                 return existing.Count > 0;
54 |             }
55 |         }
56 | 
57 |         public static bool SetXiph(TagLib.Ogg.XiphComment tag, string? value)
58 |         {
59 |             var existing = tag.GetField(XIPH_LANGUAGE_TAG);
60 |             tag.SetField(XIPH_LANGUAGE_TAG, value);
61 |             if (value == null)
62 |                 return existing.Length != 0;
63 |             else
64 |                 return existing.Length != 1 || existing[0] != value;
65 |         }
66 |     }
67 | }


--------------------------------------------------------------------------------
/Chapters.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Collections.ObjectModel;
  4 | using System.ComponentModel;
  5 | using System.Linq;
  6 | using System.Text.Json.Serialization;
  7 | using TryashtarUtils.Utility;
  8 | 
  9 | namespace TryashtarUtils.Music
 10 | {
 11 |     public class ChapterCollection : INotifyPropertyChanged
 12 |     {
 13 |         [JsonInclude]
 14 |         [JsonPropertyName("chapters")]
 15 |         // should be private, except JSON requires public
 16 |         public List<Chapter> Entries { get; private set; } = new();
 17 | 
 18 |         public event PropertyChangedEventHandler? PropertyChanged;
 19 | 
 20 |         // always presents results in order
 21 |         // previously used SortedList, but that doesn't work with mutable chapters
 22 |         [JsonIgnore]
 23 |         public ReadOnlyCollection<Chapter> Chapters => new(Entries.OrderBy(x => x, ChapterComparer.Instance).ToList());
 24 | 
 25 |         public ChapterCollection(IEnumerable<Chapter> entries)
 26 |         {
 27 |             Entries.AddRange(entries);
 28 |         }
 29 | 
 30 |         public ChapterCollection()
 31 |         {
 32 |         }
 33 | 
 34 |         public void Add(Chapter chapter)
 35 |         {
 36 |             Entries.Add(chapter);
 37 |             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Chapters)));
 38 |         }
 39 | 
 40 |         public bool Remove(Chapter chapter)
 41 |         {
 42 |             if (Entries.Remove(chapter))
 43 |             {
 44 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Chapters)));
 45 |                 return true;
 46 |             }
 47 | 
 48 |             return false;
 49 |         }
 50 | 
 51 |         public void Clear()
 52 |         {
 53 |             if (Entries.Count > 0)
 54 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Chapters)));
 55 |             Entries.Clear();
 56 |         }
 57 | 
 58 |         public IEnumerable<Chapter> ChaptersAtTime(TimeSpan time)
 59 |         {
 60 |             // use "Chapters" not "Entries" so results appear in order
 61 |             foreach (var chapter in Chapters)
 62 |             {
 63 |                 if (time >= chapter.Start && time <= chapter.End)
 64 |                     yield return chapter;
 65 |             }
 66 |         }
 67 | 
 68 |         public IEnumerable<TimeSpan> UniqueSegments()
 69 |         {
 70 |             return Entries.Select(x => x.Start).Concat(Entries.Select(x => x.End)).Distinct().OrderBy(x => x);
 71 |         }
 72 | 
 73 |         public string[] ToChp()
 74 |         {
 75 |             return Chapters.Select(x => x.ToChpEntry()).ToArray();
 76 |         }
 77 | 
 78 |         public override string ToString()
 79 |         {
 80 |             return String.Join("\n", Chapters);
 81 |         }
 82 |     }
 83 | 
 84 |     public class Chapter : INotifyPropertyChanged
 85 |     {
 86 |         public event PropertyChangedEventHandler? PropertyChanged;
 87 |         private string title;
 88 | 
 89 |         [JsonPropertyName("title")]
 90 |         public string Title
 91 |         {
 92 |             get => title;
 93 |             set
 94 |             {
 95 |                 title = value;
 96 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Title)));
 97 |             }
 98 |         }
 99 | 
100 |         private TimeSpan start;
101 | 
102 |         [JsonPropertyName("start")]
103 |         public TimeSpan Start
104 |         {
105 |             get => start;
106 |             set
107 |             {
108 |                 start = value;
109 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Start)));
110 |             }
111 |         }
112 | 
113 |         private TimeSpan end;
114 | 
115 |         [JsonPropertyName("end")]
116 |         public TimeSpan End
117 |         {
118 |             get => end;
119 |             set
120 |             {
121 |                 end = value;
122 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(End)));
123 |             }
124 |         }
125 |         
126 |         public Chapter(string title, TimeSpan start, TimeSpan end)
127 |         {
128 |             this.title = title;
129 |             this.start = start;
130 |             this.end = end;
131 |         }
132 | 
133 |         public string ToChpEntry()
134 |         {
135 |             string time_str = StringUtils.TimeSpan(Start);
136 |             return $"[{time_str}]{Title}";
137 |         }
138 | 
139 |         public override string ToString()
140 |         {
141 |             return $"[{Start}]-[{End}]: {Title}";
142 |         }
143 |     }
144 | 
145 |     public class ChapterComparer : IComparer<Chapter>
146 |     {
147 |         public static readonly ChapterComparer Instance = new();
148 | 
149 |         public int Compare(Chapter? x, Chapter? y)
150 |         {
151 |             if (x == null && y == null)
152 |                 return 0;
153 |             else if (x == null)
154 |                 return -1;
155 |             else if (y == null)
156 |                 return 1;
157 |             int start = x.Start.CompareTo(y.Start);
158 |             if (start != 0)
159 |                 return start;
160 |             int end = x.End.CompareTo(y.End);
161 |             if (end != 0)
162 |                 return end;
163 |             return String.CompareOrdinal(x.Title, y.Title);
164 |         }
165 |     }
166 | }


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | 
  4 | # User-specific files
  5 | *.suo
  6 | *.user
  7 | *.userosscache
  8 | *.sln.docstates
  9 | 
 10 | # User-specific files (MonoDevelop/Xamarin Studio)
 11 | *.userprefs
 12 | 
 13 | # Build results
 14 | [Dd]ebug/
 15 | [Dd]ebugPublic/
 16 | [Rr]elease/
 17 | [Rr]eleases/
 18 | x64/
 19 | x86/
 20 | bld/
 21 | [Bb]in/
 22 | [Oo]bj/
 23 | [Ll]og/
 24 | 
 25 | # Visual Studio 2015 cache/options directory
 26 | .vs/
 27 | # Uncomment if you have tasks that create the project's static files in wwwroot
 28 | #wwwroot/
 29 | 
 30 | # MSTest test Results
 31 | [Tt]est[Rr]esult*/
 32 | [Bb]uild[Ll]og.*
 33 | 
 34 | # NUNIT
 35 | *.VisualState.xml
 36 | TestResult.xml
 37 | 
 38 | # Build Results of an ATL Project
 39 | [Dd]ebugPS/
 40 | [Rr]eleasePS/
 41 | dlldata.c
 42 | 
 43 | # DNX
 44 | project.lock.json
 45 | project.fragment.lock.json
 46 | artifacts/
 47 | 
 48 | *_i.c
 49 | *_p.c
 50 | *_i.h
 51 | *.ilk
 52 | *.meta
 53 | *.obj
 54 | *.pch
 55 | *.pdb
 56 | *.pgc
 57 | *.pgd
 58 | *.rsp
 59 | *.sbr
 60 | *.tlb
 61 | *.tli
 62 | *.tlh
 63 | *.tmp
 64 | *.tmp_proj
 65 | *.log
 66 | *.vspscc
 67 | *.vssscc
 68 | .builds
 69 | *.pidb
 70 | *.svclog
 71 | *.scc
 72 | 
 73 | # Chutzpah Test files
 74 | _Chutzpah*
 75 | 
 76 | # Visual C++ cache files
 77 | ipch/
 78 | *.aps
 79 | *.ncb
 80 | *.opendb
 81 | *.opensdf
 82 | *.sdf
 83 | *.cachefile
 84 | *.VC.db
 85 | *.VC.VC.opendb
 86 | 
 87 | # Visual Studio profiler
 88 | *.psess
 89 | *.vsp
 90 | *.vspx
 91 | *.sap
 92 | 
 93 | # TFS 2012 Local Workspace
 94 | $tf/
 95 | 
 96 | # Guidance Automation Toolkit
 97 | *.gpState
 98 | 
 99 | # ReSharper is a .NET coding add-in
100 | _ReSharper*/
101 | *.[Rr]e[Ss]harper
102 | *.DotSettings.user
103 | 
104 | # JustCode is a .NET coding add-in
105 | .JustCode
106 | 
107 | # TeamCity is a build add-in
108 | _TeamCity*
109 | 
110 | # DotCover is a Code Coverage Tool
111 | *.dotCover
112 | 
113 | # NCrunch
114 | _NCrunch_*
115 | .*crunch*.local.xml
116 | nCrunchTemp_*
117 | 
118 | # MightyMoose
119 | *.mm.*
120 | AutoTest.Net/
121 | 
122 | # Web workbench (sass)
123 | .sass-cache/
124 | 
125 | # Installshield output folder
126 | [Ee]xpress/
127 | 
128 | # DocProject is a documentation generator add-in
129 | DocProject/buildhelp/
130 | DocProject/Help/*.HxT
131 | DocProject/Help/*.HxC
132 | DocProject/Help/*.hhc
133 | DocProject/Help/*.hhk
134 | DocProject/Help/*.hhp
135 | DocProject/Help/Html2
136 | DocProject/Help/html
137 | 
138 | # Click-Once directory
139 | publish/
140 | 
141 | # Publish Web Output
142 | *.[Pp]ublish.xml
143 | *.azurePubxml
144 | # TODO: Comment the next line if you want to checkin your web deploy settings
145 | # but database connection strings (with potential passwords) will be unencrypted
146 | #*.pubxml
147 | *.publishproj
148 | 
149 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
150 | # checkin your Azure Web App publish settings, but sensitive information contained
151 | # in these scripts will be unencrypted
152 | PublishScripts/
153 | 
154 | # NuGet Packages
155 | *.nupkg
156 | # The packages folder can be ignored because of Package Restore
157 | **/packages/*
158 | # except build/, which is used as an MSBuild target.
159 | !**/packages/build/
160 | # Uncomment if necessary however generally it will be regenerated when needed
161 | #!**/packages/repositories.config
162 | # NuGet v3's project.json files produces more ignoreable files
163 | *.nuget.props
164 | *.nuget.targets
165 | 
166 | # Microsoft Azure Build Output
167 | csx/
168 | *.build.csdef
169 | 
170 | # Microsoft Azure Emulator
171 | ecf/
172 | rcf/
173 | 
174 | # Windows Store app package directories and files
175 | AppPackages/
176 | BundleArtifacts/
177 | Package.StoreAssociation.xml
178 | _pkginfo.txt
179 | 
180 | # Visual Studio cache files
181 | # files ending in .cache can be ignored
182 | *.[Cc]ache
183 | # but keep track of directories ending in .cache
184 | !*.[Cc]ache/
185 | 
186 | # Others
187 | ClientBin/
188 | ~$*
189 | *~
190 | *.dbmdl
191 | *.dbproj.schemaview
192 | *.jfm
193 | *.pfx
194 | *.publishsettings
195 | node_modules/
196 | orleans.codegen.cs
197 | 
198 | # Since there are multiple workflows, uncomment next line to ignore bower_components
199 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
200 | #bower_components/
201 | 
202 | # RIA/Silverlight projects
203 | Generated_Code/
204 | 
205 | # Backup & report files from converting an old project file
206 | # to a newer Visual Studio version. Backup files are not needed,
207 | # because we have git ;-)
208 | _UpgradeReport_Files/
209 | Backup*/
210 | UpgradeLog*.XML
211 | UpgradeLog*.htm
212 | 
213 | # SQL Server files
214 | *.mdf
215 | *.ldf
216 | 
217 | # Business Intelligence projects
218 | *.rdl.data
219 | *.bim.layout
220 | *.bim_*.settings
221 | 
222 | # Microsoft Fakes
223 | FakesAssemblies/
224 | 
225 | # GhostDoc plugin setting file
226 | *.GhostDoc.xml
227 | 
228 | # Node.js Tools for Visual Studio
229 | .ntvs_analysis.dat
230 | 
231 | # Visual Studio 6 build log
232 | *.plg
233 | 
234 | # Visual Studio 6 workspace options file
235 | *.opt
236 | 
237 | # Visual Studio LightSwitch build output
238 | **/*.HTMLClient/GeneratedArtifacts
239 | **/*.DesktopClient/GeneratedArtifacts
240 | **/*.DesktopClient/ModelManifest.xml
241 | **/*.Server/GeneratedArtifacts
242 | **/*.Server/ModelManifest.xml
243 | _Pvt_Extensions
244 | 
245 | # Paket dependency manager
246 | .paket/paket.exe
247 | paket-files/
248 | 
249 | # FAKE - F# Make
250 | .fake/
251 | 
252 | # JetBrains Rider
253 | .idea/
254 | *.sln.iml
255 | 
256 | # CodeRush
257 | .cr/
258 | 
259 | # Python Tools for Visual Studio (PTVS)
260 | __pycache__/
261 | *.pyc


--------------------------------------------------------------------------------
/Lyrics.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Collections.ObjectModel;
  4 | using System.ComponentModel;
  5 | using System.Linq;
  6 | using System.Text.Json.Serialization;
  7 | using TagLib.Id3v2;
  8 | using TryashtarUtils.Utility;
  9 | 
 10 | namespace TryashtarUtils.Music
 11 | {
 12 |     public class Lyrics : INotifyPropertyChanged
 13 |     {
 14 |         public event PropertyChangedEventHandler? PropertyChanged;
 15 |         [JsonIgnore] public bool Synchronized { get; }
 16 | 
 17 |         [JsonInclude]
 18 |         [JsonPropertyName("channels")]
 19 |         // should be private, except JSON requires public
 20 |         public List<LyricsChannel> ChannelList { get; private set; } = new();
 21 | 
 22 |         [JsonIgnore]
 23 |         public ReadOnlyCollection<LyricsChannel> Channels =>
 24 |             new(ChannelList.OrderBy(x => x, ChannelComparer.Instance).ToList());
 25 | 
 26 |         // use "ChannelList" instead of "Channels" since we are sorting lyrics anyway, don't need sorted channels
 27 |         // this way, lyrics will show up in time order across channels, instead of all of one channel, then all of another
 28 |         [JsonIgnore]
 29 |         public IEnumerable<LyricsEntry> AllLyrics =>
 30 |             ChannelList.SelectMany(x => x.Lyrics).OrderBy(x => x, LyricsComparer.Instance);
 31 | 
 32 |         [JsonConstructor]
 33 |         public Lyrics(bool synchronized = true)
 34 |         {
 35 |             Synchronized = synchronized;
 36 |         }
 37 | 
 38 |         public Lyrics(IEnumerable<SynchedText> text, TimeSpan? duration = null)
 39 |         {
 40 |             Synchronized = true;
 41 |             var channel = new LyricsChannel();
 42 |             ChannelList.Add(channel);
 43 |             var list = text.ToArray();
 44 |             for (int i = 0; i < list.Length; i++)
 45 |             {
 46 |                 var start = TimeSpan.FromMilliseconds(list[i].Time);
 47 |                 TimeSpan end = start;
 48 |                 if (i < list.Length - 1)
 49 |                     end = TimeSpan.FromMilliseconds(list[i + 1].Time);
 50 |                 else if (duration != null)
 51 |                     end = duration.Value;
 52 |                 channel.Add(new LyricsEntry(list[i].Text, start, end));
 53 |             }
 54 |         }
 55 | 
 56 |         public Lyrics(IEnumerable<LyricsEntry> entries)
 57 |         {
 58 |             Synchronized = true;
 59 |             var channel = new LyricsChannel();
 60 |             ChannelList.Add(channel);
 61 |             foreach (var item in entries)
 62 |             {
 63 |                 channel.Add(item);
 64 |             }
 65 |         }
 66 | 
 67 |         public Lyrics(string lyrics)
 68 |         {
 69 |             Synchronized = false;
 70 |             var channel = new LyricsChannel();
 71 |             ChannelList.Add(channel);
 72 |             foreach (var line in StringUtils.SplitLines(lyrics))
 73 |             {
 74 |                 channel.Add(new LyricsEntry(line, TimeSpan.Zero, TimeSpan.Zero));
 75 |             }
 76 |         }
 77 | 
 78 |         public void AddChannel(LyricsChannel channel)
 79 |         {
 80 |             ChannelList.Add(channel);
 81 |             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Channels)));
 82 |         }
 83 | 
 84 |         public bool RemoveChannel(LyricsChannel channel)
 85 |         {
 86 |             if (ChannelList.Remove(channel))
 87 |             {
 88 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Channels)));
 89 |                 return true;
 90 |             }
 91 | 
 92 |             return false;
 93 |         }
 94 | 
 95 |         public void ClearChannels()
 96 |         {
 97 |             if (ChannelList.Count > 0)
 98 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Channels)));
 99 |             ChannelList.Clear();
100 |         }
101 | 
102 |         public IEnumerable<LyricsEntry> LyricsAtTime(TimeSpan time)
103 |         {
104 |             if (!Synchronized)
105 |                 yield break;
106 |             foreach (var channel in Channels)
107 |             {
108 |                 foreach (var line in channel.Lyrics)
109 |                 {
110 |                     if (time >= line.Start && time <= line.End)
111 |                         yield return line;
112 |                 }
113 |             }
114 |         }
115 | 
116 |         public SynchedText[] ToSynchedText()
117 |         {
118 |             return AllLyrics.Select(x => new SynchedText((long)x.Start.TotalMilliseconds, x.Text)).ToArray();
119 |         }
120 | 
121 |         public string ToSimple()
122 |         {
123 |             return String.Join("\n", AllLyrics.Select(x => x.Text));
124 |         }
125 | 
126 |         public string[] ToLrc()
127 |         {
128 |             return AllLyrics.Select(x => x.ToLrcEntry()).ToArray();
129 |         }
130 | 
131 |         public override string ToString()
132 |         {
133 |             return String.Join("\n", AllLyrics);
134 |         }
135 |     }
136 | 
137 |     public class LyricsChannel : INotifyPropertyChanged
138 |     {
139 |         private string? name;
140 | 
141 |         [JsonPropertyName("name")]
142 |         public string? Name
143 |         {
144 |             get => name;
145 |             set
146 |             {
147 |                 name = value;
148 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Name)));
149 |             }
150 |         }
151 | 
152 |         [JsonIgnore] public TimeSpan? Start => Entries.Count == 0 ? null : Entries.Min(x => x.Start);
153 |         [JsonIgnore] public TimeSpan? End => Entries.Count == 0 ? null : Entries.Max(x => x.End);
154 | 
155 |         public event PropertyChangedEventHandler? PropertyChanged;
156 | 
157 |         [JsonInclude]
158 |         [JsonPropertyName("lyrics")]
159 |         // should be private, except JSON requires public
160 |         public List<LyricsEntry> Entries { get; private set; } = new();
161 | 
162 |         [JsonIgnore]
163 |         public ReadOnlyCollection<LyricsEntry> Lyrics => new(Entries.OrderBy(x => x, LyricsComparer.Instance).ToList());
164 | 
165 |         [JsonConstructor]
166 |         public LyricsChannel(string? name = null)
167 |         {
168 |             this.name = name;
169 |         }
170 | 
171 |         public void Add(LyricsEntry entry)
172 |         {
173 |             Entries.Add(entry);
174 |             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Lyrics)));
175 |         }
176 | 
177 |         public bool Remove(LyricsEntry entry)
178 |         {
179 |             if (Entries.Remove(entry))
180 |             {
181 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Lyrics)));
182 |                 return true;
183 |             }
184 | 
185 |             return false;
186 |         }
187 | 
188 |         public void Clear()
189 |         {
190 |             if (Entries.Count > 0)
191 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Lyrics)));
192 |             Entries.Clear();
193 |         }
194 |     }
195 | 
196 |     public class LyricsEntry : INotifyPropertyChanged
197 |     {
198 |         public event PropertyChangedEventHandler? PropertyChanged;
199 |         private string text;
200 | 
201 |         [JsonPropertyName("text")]
202 |         public string Text
203 |         {
204 |             get => text;
205 |             set
206 |             {
207 |                 text = value;
208 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Text)));
209 |             }
210 |         }
211 | 
212 |         private TimeSpan start;
213 | 
214 |         [JsonPropertyName("start")]
215 |         public TimeSpan Start
216 |         {
217 |             get => start;
218 |             set
219 |             {
220 |                 start = value;
221 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Start)));
222 |             }
223 |         }
224 | 
225 |         private TimeSpan end;
226 | 
227 |         [JsonPropertyName("end")]
228 |         public TimeSpan End
229 |         {
230 |             get => end;
231 |             set
232 |             {
233 |                 end = value;
234 |                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(End)));
235 |             }
236 |         }
237 | 
238 |         [JsonConstructor]
239 |         public LyricsEntry(string text, TimeSpan start, TimeSpan end)
240 |         {
241 |             this.text = text;
242 |             this.start = start;
243 |             this.end = end;
244 |         }
245 | 
246 |         public string ToLrcEntry()
247 |         {
248 |             string time_str = StringUtils.TimeSpan(Start);
249 |             return $"[{time_str}]{Text}";
250 |         }
251 | 
252 |         public override string ToString()
253 |         {
254 |             return $"[{Start}]-[{End}]: {Text}";
255 |         }
256 |     }
257 | 
258 |     public class ChannelComparer : IComparer<LyricsChannel>
259 |     {
260 |         public static readonly ChannelComparer Instance = new();
261 | 
262 |         public int Compare(LyricsChannel? x, LyricsChannel? y)
263 |         {
264 |             if (x == null && y == null)
265 |                 return 0;
266 |             else if (x == null)
267 |                 return -1;
268 |             else if (y == null)
269 |                 return 1;
270 |             int start = (x.Start ?? TimeSpan.MaxValue).CompareTo(y.Start ?? TimeSpan.MaxValue);
271 |             if (start != 0)
272 |                 return start;
273 |             int end = (x.End ?? TimeSpan.MaxValue).CompareTo(y.End ?? TimeSpan.MaxValue);
274 |             if (end != 0)
275 |                 return end;
276 |             return String.CompareOrdinal(x.Name, y.Name);
277 |         }
278 |     }
279 | 
280 |     public class LyricsComparer : IComparer<LyricsEntry>
281 |     {
282 |         public static readonly LyricsComparer Instance = new();
283 | 
284 |         public int Compare(LyricsEntry? x, LyricsEntry? y)
285 |         {
286 |             if (x == null && y == null)
287 |                 return 0;
288 |             else if (x == null)
289 |                 return -1;
290 |             else if (y == null)
291 |                 return 1;
292 |             int start = x.Start.CompareTo(y.Start);
293 |             if (start != 0)
294 |                 return start;
295 |             int end = x.End.CompareTo(y.End);
296 |             if (end != 0)
297 |                 return end;
298 |             return String.CompareOrdinal(x.Text, y.Text);
299 |         }
300 |     }
301 | }


--------------------------------------------------------------------------------
/ChaptersIO.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text.Json;
  5 | using TagLib;
  6 | using TagLib.Id3v2;
  7 | using TryashtarUtils.Utility;
  8 | 
  9 | namespace TryashtarUtils.Music
 10 | {
 11 |     public static class ChaptersIO
 12 |     {
 13 |         public const uint MAX_OGG_CHAPTERS = 999;
 14 |         public const string OGG_CHAPTER_NAME = "NAME";
 15 |         public const string RICH_CHAPTERS = "RICH CHAPTERS";
 16 | 
 17 |         public static string ChapterTimeKey(uint num)
 18 |         {
 19 |             if (num > MAX_OGG_CHAPTERS)
 20 |                 throw new ArgumentOutOfRangeException(nameof(num));
 21 |             return "CHAPTER" + num.ToString("000");
 22 |         }
 23 | 
 24 |         private class ChapterFrameComparer : IEqualityComparer<ChapterFrame>
 25 |         {
 26 |             public static readonly ChapterFrameComparer Instance = new();
 27 | 
 28 |             private ChapterFrameComparer()
 29 |             {
 30 |             }
 31 | 
 32 |             public bool Equals(ChapterFrame? x, ChapterFrame? y)
 33 |             {
 34 |                 if (x == null)
 35 |                     return y == null;
 36 |                 if (y == null)
 37 |                     return false;
 38 |                 return x.Render(4) == y.Render(4);
 39 |             }
 40 | 
 41 |             public int GetHashCode(ChapterFrame obj)
 42 |             {
 43 |                 return obj.Render(4).GetHashCode();
 44 |             }
 45 |         }
 46 | 
 47 |         public static bool ToFile(File file, ChapterCollection? chapters, ChapterTypes types)
 48 |         {
 49 |             bool changed = false;
 50 |             var id3v2 = (TagLib.Id3v2.Tag)file.GetTag(TagTypes.Id3v2);
 51 |             var ogg = (TagLib.Ogg.XiphComment)file.GetTag(TagTypes.Xiph);
 52 | 
 53 |             if (id3v2 != null)
 54 |                 changed |= ToId3v2(id3v2, chapters, types);
 55 |             if (ogg != null)
 56 |                 changed |= ToXiph(ogg, chapters, types);
 57 | 
 58 |             return changed;
 59 |         }
 60 | 
 61 |         public static ChapterCollection? FromFile(File file, ChapterTypes type)
 62 |         {
 63 |             return SharedIO.FromMany(new[]
 64 |             {
 65 |                 SharedIO.MethodAttempt(() =>
 66 |                         (TagLib.Id3v2.Tag)file.GetTag(TagTypes.Id3v2),
 67 |                     x => FromId3v2(x, type)
 68 |                 ),
 69 |                 SharedIO.MethodAttempt(() =>
 70 |                         (TagLib.Ogg.XiphComment)file.GetTag(TagTypes.Xiph),
 71 |                     x => FromXiph(x, file.Properties.Duration, type)
 72 |                 )
 73 |             });
 74 |         }
 75 | 
 76 |         public static ChapterCollection? FromId3v2(TagLib.Id3v2.Tag tag, ChapterTypes type)
 77 |         {
 78 |             if (type.HasFlag(ChapterTypes.Rich))
 79 |             {
 80 |                 foreach (var frame in tag.GetFrames<UserTextInformationFrame>()
 81 |                              .Where(x => x.Description == RICH_CHAPTERS))
 82 |                 {
 83 |                     if (frame.Text.Length > 0)
 84 |                         return JsonSerializer.Deserialize<ChapterCollection>(frame.Text[0]);
 85 |                 }
 86 |             }
 87 | 
 88 |             if (type.HasFlag(ChapterTypes.Simple))
 89 |             {
 90 |                 var chapters = new List<Chapter>();
 91 |                 foreach (var frame in tag.GetFrames<ChapterFrame>())
 92 |                 {
 93 |                     var chapter = ChapterFromFrame(frame);
 94 |                     if (chapter != null)
 95 |                         chapters.Add(chapter);
 96 |                 }
 97 | 
 98 |                 if (chapters.Count != 0)
 99 |                     return new ChapterCollection(chapters);
100 |             }
101 | 
102 |             return null;
103 |         }
104 | 
105 |         public static bool ToId3v2(TagLib.Id3v2.Tag tag, ChapterCollection? chapters, ChapterTypes types)
106 |         {
107 |             bool changed = false;
108 |             if (types.HasFlag(ChapterTypes.Rich))
109 |             {
110 |                 var rich_frames = tag.GetFrames<UserTextInformationFrame>().Where(x => x.Description == RICH_CHAPTERS)
111 |                     .ToList();
112 |                 foreach (var frame in rich_frames)
113 |                 {
114 |                     tag.RemoveFrame(frame);
115 |                 }
116 | 
117 |                 if (chapters == null)
118 |                     changed = changed || rich_frames.Count > 0;
119 |                 else
120 |                 {
121 |                     var rich_frame = new UserTextInformationFrame(RICH_CHAPTERS, StringType.Latin1)
122 |                     {
123 |                         Text = new[] { JsonSerializer.Serialize(chapters, LyricsIO.SerializeOptions) }
124 |                     };
125 |                     tag.AddFrame(rich_frame);
126 |                     changed = changed || rich_frames.Count == 0 || !IdenticalFrames(rich_frames[0], rich_frame);
127 |                 }
128 |             }
129 | 
130 |             if (types.HasFlag(ChapterTypes.Simple))
131 |             {
132 |                 var simple_frames = tag.GetFrames<ChapterFrame>().ToList();
133 |                 foreach (var frame in simple_frames)
134 |                 {
135 |                     tag.RemoveFrame(frame);
136 |                 }
137 | 
138 |                 if (chapters == null)
139 |                     changed = changed || simple_frames.Count > 0;
140 |                 else
141 |                 {
142 |                     var new_frames = new List<ChapterFrame>();
143 |                     for (int i = 0; i < chapters.Chapters.Count; i++)
144 |                     {
145 |                         var chapter = chapters.Chapters[i];
146 |                         var new_frame = new ChapterFrame(ChapterTimeKey((uint)i), chapter.Title)
147 |                         {
148 |                             StartMilliseconds = (uint)chapter.Start.TotalMilliseconds,
149 |                             EndMilliseconds = (uint)chapter.End.TotalMilliseconds
150 |                         };
151 |                         tag.AddFrame(new_frame);
152 |                         new_frames.Add(new_frame);
153 |                     }
154 | 
155 |                     simple_frames.Sort((x, y) => String.CompareOrdinal(x.Id, y.Id));
156 |                     new_frames.Sort((x, y) => String.CompareOrdinal(x.Id, y.Id));
157 |                     changed = changed || !new_frames.SequenceEqual(simple_frames, ChapterFrameComparer.Instance);
158 |                 }
159 |             }
160 | 
161 |             return changed;
162 |         }
163 | 
164 |         private static bool IdenticalFrames(TextInformationFrame frame1, TextInformationFrame frame2)
165 |         {
166 |             return frame1.Render(4) == frame2.Render(4);
167 |         }
168 | 
169 |         public static Chapter? ChapterFromFrame(ChapterFrame frame)
170 |         {
171 |             var title = frame.SubFrames.OfType<TextInformationFrame>().FirstOrDefault();
172 |             if (title == null || title.Text == null || title.Text.Length == 0)
173 |                 return null;
174 |             return new Chapter(title.Text[0], TimeSpan.FromMilliseconds(frame.StartMilliseconds),
175 |                 TimeSpan.FromMilliseconds(frame.EndMilliseconds));
176 |         }
177 | 
178 |         public static ChapterCollection? FromXiph(TagLib.Ogg.XiphComment tag, TimeSpan duration, ChapterTypes type)
179 |         {
180 |             if (type.HasFlag(ChapterTypes.Rich))
181 |             {
182 |                 var rich = tag.GetFirstField(RICH_CHAPTERS);
183 |                 if (rich != null)
184 |                     return JsonSerializer.Deserialize<ChapterCollection>(rich);
185 |             }
186 | 
187 |             if (type.HasFlag(ChapterTypes.Simple))
188 |             {
189 |                 var chapters = new List<Chapter>();
190 |                 Action<TimeSpan> add_previous_chapter = _ => { };
191 |                 for (uint i = 0; i < MAX_OGG_CHAPTERS; i++)
192 |                 {
193 |                     string chapter_num = ChapterTimeKey(i);
194 |                     string time = tag.GetFirstField(chapter_num);
195 |                     if (time != null)
196 |                     {
197 |                         var time_real = TimeSpan.ParseExact(time, SharedIO.TimespanFormats, null);
198 |                         string title = tag.GetFirstField(chapter_num + OGG_CHAPTER_NAME) ?? "Chapter " + (i + 1);
199 |                         add_previous_chapter(time_real);
200 |                         add_previous_chapter = x => { chapters.Add(new Chapter(title, time_real, x)); };
201 |                     }
202 |                 }
203 | 
204 |                 add_previous_chapter(duration);
205 |                 if (chapters.Count > 0)
206 |                     return new ChapterCollection(chapters);
207 |             }
208 | 
209 |             return null;
210 |         }
211 | 
212 |         public static bool ToXiph(TagLib.Ogg.XiphComment tag, ChapterCollection? chapters, ChapterTypes types)
213 |         {
214 |             bool changed = false;
215 |             if (types.HasFlag(ChapterTypes.Simple))
216 |             {
217 |                 for (int i = 0; i < MAX_OGG_CHAPTERS; i++)
218 |                 {
219 |                     string chapter_num = ChapterTimeKey((uint)i);
220 |                     string? desired_time = null;
221 |                     string? desired_name = null;
222 |                     if (chapters != null && i < chapters.Chapters.Count)
223 |                     {
224 |                         desired_time = StringUtils.TimeSpan(chapters.Chapters[i].Start);
225 |                         desired_name = chapters.Chapters[i].Title;
226 |                     }
227 | 
228 |                     var current_time = tag.GetField(chapter_num);
229 |                     var current_name = tag.GetField(chapter_num + OGG_CHAPTER_NAME);
230 |                     tag.SetField(chapter_num, desired_time);
231 |                     tag.SetField(chapter_num + OGG_CHAPTER_NAME, desired_name);
232 |                     changed |= current_time.Length > 1 || (current_time.Length == 0) != (desired_time == null);
233 |                     changed |= current_name.Length > 1 || (current_name.Length == 0) != (desired_name == null);
234 |                 }
235 |             }
236 | 
237 |             if (types.HasFlag(ChapterTypes.Rich))
238 |             {
239 |                 var existing_rich = tag.GetField(RICH_CHAPTERS);
240 |                 if (chapters == null)
241 |                 {
242 |                     tag.RemoveField(RICH_CHAPTERS);
243 |                     changed = changed || existing_rich.Length > 0;
244 |                 }
245 |                 else
246 |                 {
247 |                     string rich = JsonSerializer.Serialize(chapters, LyricsIO.SerializeOptions);
248 |                     changed |= existing_rich.Length != 1 || existing_rich[0] != rich;
249 |                     tag.SetField(RICH_CHAPTERS, rich);
250 |                 }
251 |             }
252 | 
253 |             return changed;
254 |         }
255 | 
256 |         public static ChapterCollection FromChp(IEnumerable<string> lines, TimeSpan? duration = null)
257 |         {
258 |             var chapters = new List<Chapter>();
259 |             Action<TimeSpan> add_previous_chapter = _ => { };
260 |             foreach (var line in lines)
261 |             {
262 |                 var match = SharedIO.LrcRegex.Match(line);
263 |                 if (match.Success)
264 |                 {
265 |                     if (TimeSpan.TryParseExact(match.Groups["time"].Value, SharedIO.TimespanFormats, null,
266 |                             out var time))
267 |                     {
268 |                         string text = match.Groups["line"].Value;
269 |                         add_previous_chapter(time);
270 |                         duration ??= time;
271 |                         add_previous_chapter = x => { chapters.Add(new Chapter(text, time, x)); };
272 |                     }
273 |                 }
274 |             }
275 | 
276 |             if (duration != null)
277 |                 add_previous_chapter(duration.Value);
278 |             return new ChapterCollection(chapters);
279 |         }
280 |     }
281 | 
282 |     [Flags]
283 |     public enum ChapterTypes
284 |     {
285 |         Simple = 1,
286 |         Rich = 2
287 |     }
288 | }


--------------------------------------------------------------------------------
/LyricsIO.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text.Encodings.Web;
  5 | using System.Text.Json;
  6 | using System.Text.Unicode;
  7 | using TagLib;
  8 | using TagLib.Id3v2;
  9 | using TryashtarUtils.Utility;
 10 | 
 11 | namespace TryashtarUtils.Music
 12 | {
 13 |     public static class LyricsIO
 14 |     {
 15 |         public const string OGG_LYRICS = "LYRICS";
 16 |         public const string OGG_UNSYNCED_LYRICS = "UNSYNCED LYRICS";
 17 |         public const string RICH_LYRICS = "RICH LYRICS";
 18 | 
 19 |         public static readonly JsonSerializerOptions SerializeOptions = new()
 20 |         {
 21 |             Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
 22 |         };
 23 | 
 24 |         public static bool ToFile(File file, Lyrics? lyrics, LyricTypes types)
 25 |         {
 26 |             bool changed = false;
 27 | 
 28 |             var id3v2 = (TagLib.Id3v2.Tag)file.GetTag(TagTypes.Id3v2);
 29 |             var ogg = (TagLib.Ogg.XiphComment)file.GetTag(TagTypes.Xiph);
 30 |             var ape = (TagLib.Ape.Tag)file.GetTag(TagTypes.Ape);
 31 | 
 32 |             if (id3v2 != null)
 33 |                 changed |= ToId3v2(id3v2, lyrics, types);
 34 |             if (ape != null)
 35 |                 changed |= ToApe(ape, lyrics, types);
 36 |             if (ogg != null)
 37 |                 changed |= ToXiph(ogg, lyrics, types);
 38 | 
 39 |             return changed;
 40 |         }
 41 | 
 42 |         public static bool ToXiph(TagLib.Ogg.XiphComment tag, Lyrics? lyrics, LyricTypes types)
 43 |         {
 44 |             bool changed = false;
 45 |             if (types.HasFlag(LyricTypes.Synced))
 46 |             {
 47 |                 if (lyrics == null)
 48 |                 {
 49 |                     changed |= tag.GetFirstField(OGG_LYRICS) != null;
 50 |                     tag.RemoveField(OGG_LYRICS);
 51 |                 }
 52 |                 else
 53 |                 {
 54 |                     string lrc = String.Join("\n", lyrics.ToLrc());
 55 |                     var existing = tag.GetField(OGG_LYRICS);
 56 |                     changed |= existing.Length != 1 || existing[0] != lrc;
 57 |                     tag.SetField(OGG_LYRICS, lrc);
 58 |                 }
 59 |             }
 60 | 
 61 |             if (types.HasFlag(LyricTypes.Simple))
 62 |             {
 63 |                 if (lyrics == null)
 64 |                 {
 65 |                     changed |= tag.GetFirstField(OGG_UNSYNCED_LYRICS) != null;
 66 |                     tag.RemoveField(OGG_UNSYNCED_LYRICS);
 67 |                 }
 68 |                 else
 69 |                 {
 70 |                     string simple = lyrics.ToSimple();
 71 |                     var existing_unsynced = tag.GetField(OGG_UNSYNCED_LYRICS);
 72 |                     changed |= existing_unsynced.Length != 1 || existing_unsynced[0] != simple;
 73 |                     tag.SetField(OGG_UNSYNCED_LYRICS, simple);
 74 |                 }
 75 |             }
 76 | 
 77 |             if (types.HasFlag(LyricTypes.Rich))
 78 |             {
 79 |                 if (lyrics == null)
 80 |                 {
 81 |                     changed |= tag.GetFirstField(RICH_LYRICS) != null;
 82 |                     tag.RemoveField(RICH_LYRICS);
 83 |                 }
 84 |                 else
 85 |                 {
 86 |                     string rich = JsonSerializer.Serialize(lyrics, SerializeOptions);
 87 |                     var existing_rich = tag.GetField(RICH_LYRICS);
 88 |                     changed |= existing_rich.Length != 1 || existing_rich[0] != rich;
 89 |                     tag.SetField(RICH_LYRICS, rich);
 90 |                 }
 91 |             }
 92 | 
 93 |             return changed;
 94 |         }
 95 | 
 96 |         public static bool ToApe(TagLib.Ape.Tag tag, Lyrics? lyrics, LyricTypes types)
 97 |         {
 98 |             if (types.HasFlag(LyricTypes.Simple))
 99 |             {
100 |                 string? simple = lyrics?.ToSimple();
101 |                 bool changed = tag.Lyrics != simple;
102 |                 tag.Lyrics = simple;
103 |                 return changed;
104 |             }
105 | 
106 |             return false;
107 |         }
108 | 
109 |         public static bool ToId3v2(TagLib.Id3v2.Tag tag, Lyrics? lyrics, LyricTypes types)
110 |         {
111 |             bool changed = false;
112 |             string language = LanguageExtensions.GetId3v2(tag) ?? "XXX";
113 |             if (types.HasFlag(LyricTypes.Simple))
114 |             {
115 |                 var unsynced_frames = tag.GetFrames<UnsynchronisedLyricsFrame>().ToList();
116 |                 foreach (var frame in unsynced_frames)
117 |                 {
118 |                     tag.RemoveFrame(frame);
119 |                 }
120 | 
121 |                 if (lyrics == null)
122 |                     changed = changed || unsynced_frames.Count > 0;
123 |                 else
124 |                 {
125 |                     var unsynced_frame = new UnsynchronisedLyricsFrame("", language, StringType.Latin1)
126 |                     {
127 |                         Text = lyrics.ToSimple()
128 |                     };
129 |                     tag.AddFrame(unsynced_frame);
130 |                     changed = changed || unsynced_frames.Count != 1 ||
131 |                               !IdenticalFrames(unsynced_frames[0], unsynced_frame);
132 |                 }
133 |             }
134 | 
135 |             if (types.HasFlag(LyricTypes.Synced))
136 |             {
137 |                 var synced_frames = tag.GetFrames<SynchronisedLyricsFrame>().ToList();
138 |                 foreach (var frame in synced_frames)
139 |                 {
140 |                     tag.RemoveFrame(frame);
141 |                 }
142 | 
143 |                 if (lyrics == null)
144 |                     changed = changed || synced_frames.Count > 0;
145 |                 else
146 |                 {
147 |                     var synced_frame =
148 |                         new SynchronisedLyricsFrame("", language, SynchedTextType.Lyrics, StringType.Latin1)
149 |                         {
150 |                             Text = lyrics.ToSynchedText(),
151 |                             Format = TimestampFormat.AbsoluteMilliseconds
152 |                         };
153 |                     tag.AddFrame(synced_frame);
154 |                     changed = changed || synced_frames.Count != 1 || !IdenticalFrames(synced_frames[0], synced_frame);
155 |                 }
156 |             }
157 | 
158 |             if (types.HasFlag(LyricTypes.Rich))
159 |             {
160 |                 var rich_frames = tag.GetFrames<UserTextInformationFrame>().Where(x => x.Description == RICH_LYRICS)
161 |                     .ToList();
162 |                 foreach (var frame in rich_frames)
163 |                 {
164 |                     tag.RemoveFrame(frame);
165 |                 }
166 | 
167 |                 if (lyrics == null)
168 |                     changed = changed || rich_frames.Count > 0;
169 |                 else
170 |                 {
171 |                     var rich_frame = new UserTextInformationFrame(RICH_LYRICS, StringType.Latin1)
172 |                     {
173 |                         Text = new[] { JsonSerializer.Serialize(lyrics, SerializeOptions) }
174 |                     };
175 |                     tag.AddFrame(rich_frame);
176 |                     changed = changed || rich_frames.Count != 1 || !IdenticalFrames(rich_frames[0], rich_frame);
177 |                 }
178 |             }
179 | 
180 |             return changed;
181 |         }
182 | 
183 |         private static bool IdenticalFrames(SynchronisedLyricsFrame frame1, SynchronisedLyricsFrame frame2)
184 |         {
185 |             return frame1.Render(4) == frame2.Render(4);
186 |         }
187 | 
188 |         private static bool IdenticalFrames(UnsynchronisedLyricsFrame frame1, UnsynchronisedLyricsFrame frame2)
189 |         {
190 |             return frame1.Render(4) == frame2.Render(4);
191 |         }
192 | 
193 |         private static bool IdenticalFrames(TextInformationFrame frame1, TextInformationFrame frame2)
194 |         {
195 |             return frame1.Render(4) == frame2.Render(4);
196 |         }
197 | 
198 |         public static Lyrics? FromFile(File file, LyricTypes type)
199 |         {
200 |             return SharedIO.FromMany(new[]
201 |             {
202 |                 SharedIO.MethodAttempt(() =>
203 |                         (TagLib.Id3v2.Tag)file.GetTag(TagTypes.Id3v2),
204 |                     x => FromId3v2(x, file.Properties.Duration, type)
205 |                 ),
206 |                 SharedIO.MethodAttempt(() =>
207 |                         (TagLib.Ogg.XiphComment)file.GetTag(TagTypes.Xiph),
208 |                     x => FromXiph(x, file.Properties.Duration, type)
209 |                 )
210 |             });
211 |         }
212 | 
213 |         public static Lyrics? FromId3v2(TagLib.Id3v2.Tag tag, TimeSpan duration, LyricTypes type)
214 |         {
215 |             if (type.HasFlag(LyricTypes.Rich))
216 |             {
217 |                 foreach (var frame in tag.GetFrames<UserTextInformationFrame>()
218 |                              .Where(x => x.Description == RICH_LYRICS))
219 |                 {
220 |                     if (frame.Text.Length > 0)
221 |                         return JsonSerializer.Deserialize<Lyrics>(frame.Text[0]);
222 |                 }
223 |             }
224 | 
225 |             if (type.HasFlag(LyricTypes.Synced))
226 |             {
227 |                 foreach (var frame in tag.GetFrames<SynchronisedLyricsFrame>())
228 |                 {
229 |                     return new Lyrics(frame.Text, duration);
230 |                 }
231 |             }
232 | 
233 |             if (type.HasFlag(LyricTypes.Simple) && !String.IsNullOrEmpty(tag.Lyrics))
234 |                 return new Lyrics(tag.Lyrics);
235 | 
236 |             return null;
237 |         }
238 | 
239 |         public static Lyrics? FromXiph(TagLib.Ogg.XiphComment tag, TimeSpan duration, LyricTypes type)
240 |         {
241 |             if (type.HasFlag(LyricTypes.Rich))
242 |             {
243 |                 var rich = tag.GetFirstField(RICH_LYRICS);
244 |                 if (rich != null)
245 |                     return JsonSerializer.Deserialize<Lyrics>(rich);
246 |             }
247 |             
248 |             var text = tag.GetFirstField(OGG_LYRICS);
249 |             if (text != null)
250 |             {
251 |                 var lyrics = StringUtils.SplitLines(text).ToArray();
252 |                 if (type.HasFlag(LyricTypes.Synced) && TryFromLrc(lyrics, duration, out var result))
253 |                     return result;
254 |                 else if (type.HasFlag(LyricTypes.Simple))
255 |                     return new Lyrics(String.Join('\n', lyrics));
256 |             }
257 | 
258 |             if (type.HasFlag(LyricTypes.Simple))
259 |             {
260 |                 var unsynced = tag.GetFirstField(OGG_UNSYNCED_LYRICS);
261 |                 if (unsynced != null)
262 |                     return new Lyrics(String.Join('\n', unsynced));
263 |             }
264 | 
265 |             return null;
266 |         }
267 | 
268 |         private static SynchedText? ParseSynchedText(string line)
269 |         {
270 |             var match = SharedIO.LrcRegex.Match(line);
271 |             if (match.Success)
272 |             {
273 |                 if (TimeSpan.TryParseExact(match.Groups["time"].Value, SharedIO.TimespanFormats, null, out var time))
274 |                     return new SynchedText((long)time.TotalMilliseconds, match.Groups["line"].Value);
275 |             }
276 | 
277 |             return null;
278 |         }
279 | 
280 |         public static bool TryFromLrc(string[] lines, TimeSpan duration, out Lyrics? result)
281 |         {
282 |             result = null;
283 |             if (lines.Length > 0 && ParseSynchedText(lines[0]) == null)
284 |                 return false;
285 |             result = FromLrc(lines, duration);
286 |             return true;
287 |         }
288 | 
289 |         public static Lyrics FromLrc(IEnumerable<string> lines, TimeSpan? duration = null)
290 |         {
291 |             var results = new List<SynchedText>();
292 |             foreach (var line in lines)
293 |             {
294 |                 var text = ParseSynchedText(line);
295 |                 if (text != null)
296 |                     results.Add(text.Value);
297 |             }
298 | 
299 |             return new Lyrics(results, duration);
300 |         }
301 |     }
302 | 
303 |     [Flags]
304 |     public enum LyricTypes
305 |     {
306 |         Simple = 1,
307 |         Synced = 2,
308 |         Rich = 4
309 |     }
310 | }


--------------------------------------------------------------------------------