add M4A, FLAC, OGG audio types and IsAudio() extension methods

FileTypeChecker.Tests/FileTypeChecker.Tests.csproj

@@ -131,5 +131,14 @@
     <None Update="files\file_example_WAV_1MG.wav">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
+    <None Update="files\test.m4a">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="files\test.flac">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="files\test.ogg">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
 </Project>

FileTypeChecker.Tests/FileTypeValidatorAsyncTests.cs

@@ -59,6 +59,9 @@ public async Task IsTypeRecognizableAsync_ShouldReturnFalseIfFormatIsUnknown()
         [TestCase("test.mp4")]
         [TestCase("file_example_AVI_480_750kB.avi")]
         [TestCase("file_example_WAV_1MG.wav")]
+        [TestCase("test.m4a")]
+        [TestCase("test.flac")]
+        [TestCase("test.ogg")]
         public async Task IsTypeRecognizableAsync_ShouldReturnTrueIfFileIsRecognized(string fileName)
         {
             await using var fileStream = File.OpenRead(Path.Combine(FilesPath, fileName));
@@ -104,6 +107,9 @@ public void GetFileTypeAsync_ShouldThrowTypeNotFoundExceptionWhenTypeIsNotRegist
         [TestCase("test-issue-41.xlsx", typeof(MicrosoftOffice365Document))]
         [TestCase("file_example_AVI_480_750kB.avi", typeof(AudioVideoInterleaveVideoFormat))]
         [TestCase("file_example_WAV_1MG.wav", typeof(WaveformAudioFileFormat))]
+        [TestCase("test.m4a", typeof(M4a))]
+        [TestCase("test.flac", typeof(Flac))]
+        [TestCase("test.ogg", typeof(Ogg))]
         public async Task GetFileTypeAsync_ShouldReturnAccurateType(string fileName, Type expectedType)
         {
             await using var fileStream = File.OpenRead(Path.Combine(FilesPath, fileName));

FileTypeChecker.Tests/FileTypeValidatorTests.cs

@@ -60,6 +60,9 @@ public void IsTypeRecognizable_ShouldReturnFalseIfFormatIsUnknown()
         [TestCase("test.mp4")]
         [TestCase("file_example_AVI_480_750kB.avi")]
         [TestCase("file_example_WAV_1MG.wav")]
+        [TestCase("test.m4a")]
+        [TestCase("test.flac")]
+        [TestCase("test.ogg")]
         public void IsTypeRecognizable_ShouldReturnTrueIfFileIsRecognized(string filePath)
         {
             using var fileStream = File.OpenRead(Path.Combine(FilesPath, filePath));
@@ -95,6 +98,9 @@ public void IsTypeRecognizable_ShouldReturnTrueIfFileIsRecognized(string filePat
         [TestCase("FileTypeCheckerLogo-150.heic", HighEfficiencyImageFile.TypeMimeType)]
         [TestCase("file_example_AVI_480_750kB.avi", AudioVideoInterleaveVideoFormat.TypeMimeType)]
         [TestCase("file_example_WAV_1MG.wav", WaveformAudioFileFormat.TypeMimeType)]
+        [TestCase("test.m4a", M4a.TypeMimeType)]
+        [TestCase("test.flac", Flac.TypeMimeType)]
+        [TestCase("test.ogg", Ogg.TypeMimeType)]
         public void GetFileType_ShouldReturnFileMimeType(string filePath, string expectedFileExtension)
         {
             using var fileStream = File.OpenRead(Path.Combine(FilesPath, filePath));
@@ -128,6 +134,9 @@ public void GetFileType_ShouldReturnFileMimeType(string filePath, string expecte
         [TestCase("FileTypeCheckerLogo-150.heic", HighEfficiencyImageFile.TypeMimeType)]
         [TestCase("file_example_AVI_480_750kB.avi", AudioVideoInterleaveVideoFormat.TypeMimeType)]
         [TestCase("file_example_WAV_1MG.wav", WaveformAudioFileFormat.TypeMimeType)]
+        [TestCase("test.m4a", M4a.TypeMimeType)]
+        [TestCase("test.flac", Flac.TypeMimeType)]
+        [TestCase("test.ogg", Ogg.TypeMimeType)]
         public void TryGetFileType_ShouldReturnFileMimeType(string filePath, string expectedFileExtension)
         {
             using var fileStream = File.OpenRead(Path.Combine(FilesPath, filePath));
@@ -160,6 +169,9 @@ public void TryGetFileType_ShouldReturnFileMimeType(string filePath, string expe
         [TestCase("FileTypeCheckerLogo-150.heic", HighEfficiencyImageFile.TypeExtension)]
         [TestCase("file_example_AVI_480_750kB.avi", AudioVideoInterleaveVideoFormat.TypeExtension)]
         [TestCase("file_example_WAV_1MG.wav", WaveformAudioFileFormat.TypeExtension)]
+        [TestCase("test.m4a", M4a.TypeExtension)]
+        [TestCase("test.flac", Flac.TypeExtension)]
+        [TestCase("test.ogg", Ogg.TypeExtension)]
         public void GetFileType_ShouldReturnFileExtension(string filePath, string expectedFileExtension)
         {
             using var fileStream = File.OpenRead(Path.Combine(FilesPath, filePath));
@@ -194,6 +206,9 @@ public void GetFileType_ShouldReturnFileExtension(string filePath, string expect
         [TestCase("test-offset.mp4", M4V.TypeExtension)]
         [TestCase("file_example_AVI_480_750kB.avi", AudioVideoInterleaveVideoFormat.TypeExtension)]
         [TestCase("file_example_WAV_1MG.wav", WaveformAudioFileFormat.TypeExtension)]
+        [TestCase("test.m4a", M4a.TypeExtension)]
+        [TestCase("test.flac", Flac.TypeExtension)]
+        [TestCase("test.ogg", Ogg.TypeExtension)]
         public void TryGetFileType_ShouldReturnFileExtension(string filePath, string expectedFileExtension)
         {
             using var fileStream = File.OpenRead(Path.Combine(FilesPath, filePath));
@@ -274,6 +289,9 @@ public void TryGetFileType_TypeShouldBeNullWhenNotMatching()
         [TestCase("FileTypeCheckerLogo-150.heic", HighEfficiencyImageFile.TypeName)]
         [TestCase("file_example_AVI_480_750kB.avi", AudioVideoInterleaveVideoFormat.TypeName)]
         [TestCase("file_example_WAV_1MG.wav", WaveformAudioFileFormat.TypeName)]
+        [TestCase("test.m4a", M4a.TypeName)]
+        [TestCase("test.flac", Flac.TypeName)]
+        [TestCase("test.ogg", Ogg.TypeName)]
         public void GetFileType_ShouldReturnFileName(string filePath, string expectedFileTypeName)
         {
             using var fileStream = File.OpenRead(Path.Combine(FilesPath, filePath));
@@ -342,6 +360,9 @@ public void Is_ShouldReturnFalseIfTypesDidNotMatch()
         [TestCase("test-issue-41.xlsx", typeof(MicrosoftOffice365Document))]
         [TestCase("file_example_AVI_480_750kB.avi", typeof(AudioVideoInterleaveVideoFormat))]
         [TestCase("file_example_WAV_1MG.wav", typeof(WaveformAudioFileFormat))]
+        [TestCase("test.m4a", typeof(M4a))]
+        [TestCase("test.flac", typeof(Flac))]
+        [TestCase("test.ogg", typeof(Ogg))]
         public void GetFileType_ShouldReturnAccurateTypeWhenUsingBytes(string fileName, Type expectedType)
         {
             var buffer = GetFileBytes(fileName);

FileTypeChecker/Extensions/ByteExtensions.cs

@@ -97,6 +97,20 @@ public static bool IsArchive(this byte[] content)
             || content.Is<LZipFile>()
             || content.Is<XzFile>();
 
+        /// <summary>
+        /// Validates that the current file is an audio file.
+        /// </summary>
+        /// <param name="content">File content as byte array.</param>
+        /// <returns>Returns true if the provided file is an audio file otherwise returns false. Supported audio types are: MP3, WAV, FLAC, OGG, M4A, and WMA.</returns>
+        public static bool IsAudio(this byte[] content)
+            => content.Is<Mp3>()
+            || content.Is<MpegAudio>()
+            || content.Is<WaveformAudioFileFormat>()
+            || content.Is<Flac>()
+            || content.Is<Ogg>()
+            || content.Is<M4a>()
+            || content.Is<WindowsAudio>();
+
         /// <summary>
         /// Validates that the current file is executable or executable and linkable.
         /// </summary>
@@ -173,6 +187,21 @@ public static bool IsArchive(this ReadOnlySpan<byte> content)
             || content.Is<LZipFile>()
             || content.Is<XzFile>();
 
+        /// <summary>
+        /// Validates that the current file is an audio file using high-performance ReadOnlySpan.
+        /// This overload avoids memory allocations and provides optimal performance.
+        /// </summary>
+        /// <param name="content">File content as ReadOnlySpan of bytes.</param>
+        /// <returns>Returns true if the provided file is an audio file otherwise returns false. Supported audio types are: MP3, WAV, FLAC, OGG, M4A, and WMA.</returns>
+        public static bool IsAudio(this ReadOnlySpan<byte> content)
+            => content.Is<Mp3>()
+            || content.Is<MpegAudio>()
+            || content.Is<WaveformAudioFileFormat>()
+            || content.Is<Flac>()
+            || content.Is<Ogg>()
+            || content.Is<M4a>()
+            || content.Is<WindowsAudio>();
+
         /// <summary>
         /// Validates that the current file is executable or executable and linkable using high-performance ReadOnlySpan.
         /// This overload avoids memory allocations and provides optimal performance.

FileTypeChecker/Extensions/StreamExtensions.cs

@@ -59,6 +59,20 @@ public static bool IsArchive(this Stream fileContent)
             || fileContent.Is<LZipFile>()
             || fileContent.Is<XzFile>();
 
+        /// <summary>
+        /// Validates that the current file is an audio file.
+        /// </summary>
+        /// <param name="fileContent">File to check as a stream.</param>
+        /// <returns>True if the provided file is an audio file; otherwise, false. Supported audio types include: MP3, WAV, FLAC, OGG, M4A, and WMA.</returns>
+        public static bool IsAudio(this Stream fileContent)
+            => fileContent.Is<Mp3>()
+            || fileContent.Is<MpegAudio>()
+            || fileContent.Is<WaveformAudioFileFormat>()
+            || fileContent.Is<Flac>()
+            || fileContent.Is<Ogg>()
+            || fileContent.Is<M4a>()
+            || fileContent.Is<WindowsAudio>();
+
         /// <summary>
         /// Validates that the current file is an executable.
         /// </summary>
@@ -139,6 +153,23 @@ public static async Task<bool> IsArchiveAsync(this Stream fileContent, Cancellat
             || await fileContent.IsAsync<XzFile>(cancellationToken).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Asynchronously validates that the current file is an audio file.
+        /// </summary>
+        /// <param name="fileContent">File to check as a stream.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
+        /// <returns>A task that represents the asynchronous operation. The task result contains true if the provided file is an audio file; otherwise, false. Supported audio types include: MP3, WAV, FLAC, OGG, M4A, and WMA.</returns>
+        public static async Task<bool> IsAudioAsync(this Stream fileContent, CancellationToken cancellationToken = default)
+        {
+            return await fileContent.IsAsync<Mp3>(cancellationToken).ConfigureAwait(false)
+            || await fileContent.IsAsync<MpegAudio>(cancellationToken).ConfigureAwait(false)
+            || await fileContent.IsAsync<WaveformAudioFileFormat>(cancellationToken).ConfigureAwait(false)
+            || await fileContent.IsAsync<Flac>(cancellationToken).ConfigureAwait(false)
+            || await fileContent.IsAsync<Ogg>(cancellationToken).ConfigureAwait(false)
+            || await fileContent.IsAsync<M4a>(cancellationToken).ConfigureAwait(false)
+            || await fileContent.IsAsync<WindowsAudio>(cancellationToken).ConfigureAwait(false);
+        }
+
         /// <summary>
         /// Asynchronously validates that the current file is an executable.
         /// </summary>

FileTypeChecker/FileTypeValidator.cs

@@ -156,6 +156,14 @@ public static void RegisterCustomTypes(params Assembly[] assemblies)
         public static bool Is<T>(Stream fileContent) where T : FileType, IFileType, new()
             => fileContent.Is<T>();
 
+        /// <summary>
+        /// Validates that the current file is an audio file.
+        /// </summary>
+        /// <param name="fileContent">File to check as a stream.</param>
+        /// <returns>Returns true if the provided file is an audio file otherwise returns false. Supported audio types are: MP3, WAV, FLAC, OGG, M4A, and WMA.</returns>
+        public static bool IsAudio(Stream fileContent)
+            => fileContent.IsAudio();
+
         /// <summary>
         /// Validates that the current file is an image.
         /// </summary>
@@ -181,6 +189,14 @@ public static bool IsArchive(Stream fileContent)
         public static bool Is<T>(byte[] fileContent) where T : FileType, IFileType, new()
             => fileContent.Is<T>();
 
+        /// <summary>
+        /// Validates that the current file is an audio file.
+        /// </summary>
+        /// <param name="fileContent">File bytes.</param>
+        /// <returns>Returns true if the provided file is an audio file otherwise returns false. Supported audio types are: MP3, WAV, FLAC, OGG, M4A, and WMA.</returns>
+        public static bool IsAudio(byte[] fileContent)
+            => fileContent.IsAudio();
+
         /// <summary>
         /// Validates that the current file is an image.
         /// </summary>
@@ -274,6 +290,15 @@ public static async Task<MatchResult> TryGetFileTypeAsync(Stream fileContent, Ca
         public static async Task<bool> IsAsync<T>(Stream fileContent, CancellationToken cancellationToken = default) where T : FileType, IFileType, new()
             => await fileContent.IsAsync<T>(cancellationToken).ConfigureAwait(false);
 
+        /// <summary>
+        /// Asynchronously validates that the current file is an audio file.
+        /// </summary>
+        /// <param name="fileContent">File to check as a stream.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
+        /// <returns>A task that represents the asynchronous operation. The task result contains true if the provided file is an audio file; otherwise, false. Supported audio types include: MP3, WAV, FLAC, OGG, M4A, and WMA.</returns>
+        public static async Task<bool> IsAudioAsync(Stream fileContent, CancellationToken cancellationToken = default)
+            => await fileContent.IsAudioAsync(cancellationToken).ConfigureAwait(false);
+
         /// <summary>
         /// Asynchronously validates that the current file is an image.
         /// </summary>
@@ -362,6 +387,15 @@ public static MatchResult TryGetFileType(ReadOnlySpan<byte> fileContent)
         public static bool Is<T>(ReadOnlySpan<byte> fileContent) where T : FileType, IFileType, new()
             => fileContent.Is<T>();
 
+        /// <summary>
+        /// Validates that the current file is an audio file using high-performance ReadOnlySpan.
+        /// This overload avoids memory allocations and provides optimal performance.
+        /// </summary>
+        /// <param name="fileContent">File content as ReadOnlySpan of bytes.</param>
+        /// <returns>True if the provided file is an audio file; otherwise, false. Supported audio types include: MP3, WAV, FLAC, OGG, M4A, and WMA.</returns>
+        public static bool IsAudio(ReadOnlySpan<byte> fileContent)
+            => fileContent.IsAudio();
+
         /// <summary>
         /// Validates that the current file is an image using high-performance ReadOnlySpan.
         /// This overload avoids memory allocations and provides optimal performance.

FileTypeChecker/Types/Flac.cs

@@ -0,0 +1,19 @@
+namespace FileTypeChecker.Types
+{
+    using Abstracts;
+
+    /// <summary>
+    /// Free Lossless Audio Codec file. Identified by the fLaC magic marker.
+    /// </summary>
+    public class Flac : FileType, IFileType
+    {
+        public const string TypeName = "FLAC audio file";
+        public const string TypeMimeType = "audio/flac";
+        public const string TypeExtension = "flac";
+        private static readonly byte[] MagicBytes = { 0x66, 0x4C, 0x61, 0x43 }; // fLaC
+
+        public Flac() : base(TypeName, TypeMimeType, TypeExtension, MagicBytes)
+        {
+        }
+    }
+}

FileTypeChecker/Types/M4a.cs

@@ -0,0 +1,23 @@
+using FileTypeChecker.Abstracts;
+
+namespace FileTypeChecker.Types
+{
+    /// <summary>
+    /// MPEG-4 audio file (AAC). Identified by ftyp box with M4A or M4B brand.
+    /// </summary>
+    public class M4a : FileType, IFileType
+    {
+        public const string TypeName = "MPEG-4 audio file";
+        public const string TypeMimeType = "audio/mp4";
+        public const string TypeExtension = "m4a";
+        private static readonly MagicSequence[] MagicBytesSequence =
+        {
+            new(new byte[] { 0x66, 0x74, 0x79, 0x70, 0x4D, 0x34, 0x41, 0x20 }, 4), // ftypM4A
+            new(new byte[] { 0x66, 0x74, 0x79, 0x70, 0x4D, 0x34, 0x42, 0x20 }, 4), // ftypM4B
+        };
+
+        public M4a() : base(TypeName, TypeMimeType, TypeExtension, MagicBytesSequence)
+        {
+        }
+    }
+}

FileTypeChecker/Types/Ogg.cs

@@ -0,0 +1,19 @@
+namespace FileTypeChecker.Types
+{
+    using Abstracts;
+
+    /// <summary>
+    /// Ogg container file (Vorbis, Opus, FLAC). Identified by the OggS capture pattern.
+    /// </summary>
+    public class Ogg : FileType, IFileType
+    {
+        public const string TypeName = "Ogg audio file";
+        public const string TypeMimeType = "audio/ogg";
+        public const string TypeExtension = "ogg";
+        private static readonly byte[] MagicBytes = { 0x4F, 0x67, 0x67, 0x53 }; // OggS
+
+        public Ogg() : base(TypeName, TypeMimeType, TypeExtension, MagicBytes)
+        {
+        }
+    }
+}