Refactored types under AudioFileConverter namespace

Author: orchetect

Sources/SwiftAudioFileConverter/AudioFileConverter/AudioFileConverter+ExtAudioFile.swift

@@ -14,14 +14,14 @@ extension AudioFileConverter {
     @concurrent nonisolated static func performExtAudioFileConversion(
         from inputURL: URL,
         to outputURL: URL,
-        settings: AudioFileSettings
+        settings: Settings
     ) async throws {
         // 1. Open the input file
         var inputFile: ExtAudioFileRef?
         var result = ExtAudioFileOpenURL(inputURL as CFURL, &inputFile)
         try checkError(result)
         guard let inputFile = inputFile else {
-            throw SwiftAudioFileConverterError.unableToOpenFile(inputURL)
+            throw ConverterError.unableToOpenFile(inputURL)
         }
 
         // 2. Prepare an AudioStreamBasicDescription for the *destination* format
@@ -42,15 +42,15 @@ extension AudioFileConverter {
 
         try checkError(result)
         guard let outputFile = outputFile else {
-            throw SwiftAudioFileConverterError.unableToOpenFile(outputURL)
+            throw ConverterError.unableToOpenFile(outputURL)
         }
 
         // 4. We’ll set a “client format” to read and write in a consistent format (e.g., float32 PCM).
         //    Even for compressed output like AAC, we often use a PCM client format for reading/writing.
         let channels = (settings.channelFormat == .mono) ? UInt32(1) : UInt32(2)
 
         var clientFormat = AudioStreamBasicDescription(
-            mSampleRate: settings.sampleRate.rawValue,
+            mSampleRate: settings.sampleRate.hzDouble,
             mFormatID: kAudioFormatLinearPCM,
             mFormatFlags: kLinearPCMFormatFlagIsFloat | kLinearPCMFormatFlagIsPacked,
             mBytesPerPacket: 4 * channels,
@@ -123,13 +123,13 @@ extension AudioFileConverter {
     /// Returns a tuple of (destination AudioStreamBasicDescription, destination AudioFileTypeID)
     /// based on the user’s desired FileFormat in `AudioFileSettings`.
     nonisolated private static func audioFormat(
-        for settings: AudioFileSettings
+        for settings: Settings
     ) throws -> (AudioStreamBasicDescription, AudioFileTypeID) {
         let channels = (settings.channelFormat == .mono) ? UInt32(1) : UInt32(2)
 
         // Base description; we’ll adjust for each format
         var asbd = AudioStreamBasicDescription()
-        asbd.mSampleRate = settings.sampleRate.rawValue
+        asbd.mSampleRate = settings.sampleRate.hzDouble
         asbd.mChannelsPerFrame = channels
 
         switch settings.fileFormat {
@@ -169,7 +169,7 @@ extension AudioFileConverter {
 
         case .mp3, .flac:
             // We should never get here, because we throw for unsupported
-            throw SwiftAudioFileConverterError.unsupportedConversion(settings.fileFormat)
+            throw ConverterError.unsupportedConversion(settings.fileFormat)
         }
     }
 
@@ -202,7 +202,7 @@ extension AudioFileConverter {
     /// Throws a Swift error if the OSStatus indicates failure.
     nonisolated static func checkError(_ status: OSStatus) throws {
         guard status == noErr else {
-            throw SwiftAudioFileConverterError.coreAudioError(CoreAudioError(status: status))
+            throw ConverterError.coreAudioError(CoreAudioError(status: status))
         }
     }
 }

Sources/SwiftAudioFileConverter/AudioFileConverter/AudioFileConverter+FLAC.swift

@@ -13,14 +13,14 @@ extension AudioFileConverter {
     @concurrent nonisolated static func performFlacConversion(
         from inputURL: URL,
         to outputURL: URL,
-        settings: AudioFileSettings
+        settings: Settings
     ) async throws {
         // 1) Open the input file with ExtAudioFile
         var inputFile: ExtAudioFileRef?
         var result = ExtAudioFileOpenURL(inputURL as CFURL, &inputFile)
         try checkError(result)
         guard let inputFile = inputFile else {
-            throw SwiftAudioFileConverterError.unableToOpenFile(inputURL)
+            throw ConverterError.unableToOpenFile(inputURL)
         }
         defer { ExtAudioFileDispose(inputFile) }
 
@@ -30,7 +30,7 @@ extension AudioFileConverter {
         // 3) We want 16-bit interleaved PCM from ExtAudioFile
         //    because FLAC expects integer samples
         var clientFormat = AudioStreamBasicDescription(
-            mSampleRate: settings.sampleRate.rawValue,
+            mSampleRate: settings.sampleRate.hzDouble,
             mFormatID: kAudioFormatLinearPCM,
             mFormatFlags: kAudioFormatFlagsNativeEndian
                 | kLinearPCMFormatFlagIsPacked
@@ -54,14 +54,14 @@ extension AudioFileConverter {
 
         // 4) Create and configure the FLAC encoder
         guard let flacEncoder = FLAC__stream_encoder_new() else {
-            throw SwiftAudioFileConverterError.unsupportedConversion(.flac)
+            throw ConverterError.unsupportedConversion(.flac)
         }
         defer { FLAC__stream_encoder_delete(flacEncoder) }
 
         // Set basic FLAC encoder properties
         // Sample rate, channels, bits per sample
         FLAC__stream_encoder_set_channels(flacEncoder, channels)
-        FLAC__stream_encoder_set_sample_rate(flacEncoder, UInt32(settings.sampleRate.rawValue))
+        FLAC__stream_encoder_set_sample_rate(flacEncoder, UInt32(settings.sampleRate.hzInt))
         FLAC__stream_encoder_set_bits_per_sample(flacEncoder, 16)
 
         // Optionally set a compression level (0 = fastest, 8 = slowest/best)
@@ -72,7 +72,7 @@ extension AudioFileConverter {
             FLAC__stream_encoder_init_file(flacEncoder, pathCstr, nil, nil)
         }
         if initStatus != FLAC__STREAM_ENCODER_INIT_STATUS_OK {
-            throw SwiftAudioFileConverterError.unsupportedConversion(.flac)
+            throw ConverterError.unsupportedConversion(.flac)
         }
 
         // 6) Read PCM in chunks, pass to FLAC
@@ -139,14 +139,14 @@ extension AudioFileConverter {
             }
 
             if ok == 0  {
-                throw SwiftAudioFileConverterError.flacConversionUnknownError
+                throw ConverterError.flacConversionUnknownError
             }
         }
 
         // 7) Finish/flush the encoder
         let finishOK = FLAC__stream_encoder_finish(flacEncoder)
         if finishOK == 0 {
-            throw SwiftAudioFileConverterError.flacConversionUnknownError
+            throw ConverterError.flacConversionUnknownError
         }
 
         // 8) The output FLAC file now exists at outputURL

Sources/SwiftAudioFileConverter/AudioFileConverter/AudioFileConverter+LAME.swift

@@ -13,14 +13,14 @@ extension AudioFileConverter {
     @concurrent nonisolated static func performLameConversion(
         from inputURL: URL,
         to outputURL: URL,
-        settings: AudioFileSettings
+        settings: Settings
     ) async throws {
         // 1) Open the input file using ExtAudioFile
         var inputFile: ExtAudioFileRef?
         var result = ExtAudioFileOpenURL(inputURL as CFURL, &inputFile)
         try checkError(result)
         guard let inputFile = inputFile else {
-            throw SwiftAudioFileConverterError.unableToOpenFile(inputURL)
+            throw ConverterError.unableToOpenFile(inputURL)
         }
         defer {
             ExtAudioFileDispose(inputFile)
@@ -32,7 +32,7 @@ extension AudioFileConverter {
         // 3) We want 32-bit float interleaved PCM for reading from ExtAudioFile
         //    Build a client format describing float PCM.
         var clientFormat = AudioStreamBasicDescription(
-            mSampleRate: settings.sampleRate.rawValue,
+            mSampleRate: settings.sampleRate.hzDouble,
             mFormatID: kAudioFormatLinearPCM,
             mFormatFlags: kLinearPCMFormatFlagIsFloat
                 | kAudioFormatFlagsNativeEndian
@@ -56,18 +56,18 @@ extension AudioFileConverter {
 
         // 4) Prepare LAME for float input
         guard let lame = lame_init() else {
-            throw SwiftAudioFileConverterError.unsupportedConversion(.mp3)
+            throw ConverterError.unsupportedConversion(.mp3)
         }
         lame_set_num_channels(lame, Int32(channels))
-        lame_set_in_samplerate(lame, Int32(settings.sampleRate.rawValue))
+        lame_set_in_samplerate(lame, Int32(settings.sampleRate.hzInt))
 
         // Example settings:
         lame_set_brate(lame, 128) // 128 kbps
         lame_set_quality(lame, 2) // quality scale: 0=best, 9=worst
 
         if lame_init_params(lame) < 0 {
             lame_close(lame)
-            throw SwiftAudioFileConverterError.unsupportedConversion(.mp3)
+            throw ConverterError.unsupportedConversion(.mp3)
         }
         defer { lame_close(lame) }
 
@@ -77,10 +77,10 @@ extension AudioFileConverter {
             try fileManager.removeItem(at: outputURL)
         }
         guard fileManager.createFile(atPath: outputURL.path, contents: nil) else {
-            throw SwiftAudioFileConverterError.fileIsNotWritable(outputURL)
+            throw ConverterError.fileIsNotWritable(outputURL)
         }
         guard let fileHandle = FileHandle(forWritingAtPath: outputURL.path) else {
-            throw SwiftAudioFileConverterError.fileIsNotWritable(outputURL)
+            throw ConverterError.fileIsNotWritable(outputURL)
         }
         defer { try? fileHandle.close() }
 
@@ -156,7 +156,7 @@ extension AudioFileConverter {
             }
 
             if encodedBytes < 0 {
-                throw SwiftAudioFileConverterError.unsupportedConversion(.mp3)
+                throw ConverterError.unsupportedConversion(.mp3)
             }
 
             // 6d) Write the MP3 bytes to the output file

Sources/SwiftAudioFileConverter/AudioFileConverter/AudioFileConverter.swift

@@ -13,29 +13,29 @@ public enum AudioFileConverter {
     @concurrent nonisolated static public func convert(
         from inputURL: URL,
         to outputURL: URL,
-        with settings: AudioFileSettings
+        with settings: Settings
     ) async throws {
         // Check if the input file extension is a known audio format
         guard FileFormat.allCases.map(\.rawValue).contains(inputURL.pathExtension.lowercased()) else {
-            throw SwiftAudioFileConverterError.unsupportedAudioFileExtension(inputURL)
+            throw ConverterError.unsupportedAudioFileExtension(inputURL)
         }
 
         // Check read permissions on the input file
         guard FileManager.default.isReadableFile(atPath: inputURL.path) else {
-            throw SwiftAudioFileConverterError.fileIsNotReadable(inputURL)
+            throw ConverterError.fileIsNotReadable(inputURL)
         }
 
         // Check write permissions on the output (directory must be writable)
         //    NOTE: For a brand new file, `isWritableFile(atPath:)` can be misleading.
         //    Often, you'll want to check if the directory is writable instead.
         let outputDirectory = outputURL.deletingLastPathComponent()
         guard FileManager.default.isWritableFile(atPath: outputDirectory.path) else {
-            throw SwiftAudioFileConverterError.fileIsNotWritable(outputURL)
+            throw ConverterError.fileIsNotWritable(outputURL)
         }
 
         // Check if output extension matches `settings.fileFormat`
         guard outputURL.pathExtension.lowercased() == settings.fileFormat.rawValue else {
-            throw SwiftAudioFileConverterError.audioFileExtensionSettingsMismatch(outputURL, settings)
+            throw ConverterError.audioFileExtensionSettingsMismatch(outputURL, settings)
         }
 
         // Dispatch the conversion based on the requested format

Sources/SwiftAudioFileConverter/Errors/SwiftAudioFileConverterError.swift renamed to Sources/SwiftAudioFileConverter/AudioFileConverter/Errors/ConverterError.swift

@@ -1,32 +1,34 @@
 //
-//  SwiftAudioFileConverterError.swift
+//  ConverterError.swift
 //  SwiftAudioFileConverter
 //
 //  Created by Devin Roth on 2025-04-03.
 //
 
 import Foundation
 
-public enum SwiftAudioFileConverterError: LocalizedError {
-    case invalidAudioFileSettings(AudioFileSettings)
-    case unsupportedAudioFileExtension(URL)
-    case audioFileExtensionSettingsMismatch(URL, AudioFileSettings)
-    case fileDoesNotExist(URL)
-    case fileIsNotReadable(URL)
-    case unableToOpenFile(URL)
-    case fileIsNotWritable(URL)
-    case unsupportedConversion(FileFormat)
-    case coreAudioError(CoreAudioError)
-    case flacConversionUnknownError
+extension AudioFileConverter {
+    public enum ConverterError: Error {
+        case invalidAudioFileSettings(Settings)
+        case unsupportedAudioFileExtension(URL)
+        case audioFileExtensionSettingsMismatch(URL, Settings)
+        case fileDoesNotExist(URL)
+        case fileIsNotReadable(URL)
+        case unableToOpenFile(URL)
+        case fileIsNotWritable(URL)
+        case unsupportedConversion(FileFormat)
+        case coreAudioError(CoreAudioError)
+        case flacConversionUnknownError
+    }
 }
 
-extension SwiftAudioFileConverterError: Equatable { }
+extension AudioFileConverter.ConverterError: Equatable { }
 
-extension SwiftAudioFileConverterError: Hashable { }
+extension AudioFileConverter.ConverterError: Hashable { }
 
-extension SwiftAudioFileConverterError: Sendable { }
+extension AudioFileConverter.ConverterError: Sendable { }
 
-extension SwiftAudioFileConverterError {
+extension AudioFileConverter.ConverterError: LocalizedError {
     public var errorDescription: String? {
         switch self {
         case let .invalidAudioFileSettings(audioFileSettings):

Sources/SwiftAudioFileConverter/AudioFileConverter/Errors/CoreAudioError.swift

@@ -0,0 +1,67 @@
+//
+//  CoreAudioError.swift
+//  SwiftAudioFileConverter
+//
+//  Created by Devin Roth on 2025-04-03.
+//
+
+import Foundation
+import AudioToolbox
+
+extension AudioFileConverter {
+    public enum CoreAudioError: Error {
+        case formatNotSupported
+        case unspecified
+        case unsupportedProperty
+        case badPropertySize
+        case badSpecifierSize
+        case unknownFormat
+        case unknownError(OSStatus)
+        
+        public init(status: OSStatus) {
+            switch status {
+            case kAudioFormatUnsupportedDataFormatError:
+                self = .formatNotSupported
+            case kAudioFormatUnspecifiedError:
+                self = .unspecified
+            case kAudioFormatUnsupportedPropertyError:
+                self = .unsupportedProperty
+            case kAudioFormatBadPropertySizeError:
+                self = .badPropertySize
+            case kAudioFormatBadSpecifierSizeError:
+                self = .badSpecifierSize
+            case kAudioFormatUnknownFormatError:
+                self = .unknownFormat
+            default:
+                self = .unknownError(status)
+            }
+        }
+    }
+}
+
+extension AudioFileConverter.CoreAudioError: Equatable { }
+
+extension AudioFileConverter.CoreAudioError: Hashable { }
+
+extension AudioFileConverter.CoreAudioError: Sendable { }
+
+extension AudioFileConverter.CoreAudioError: LocalizedError {
+    public var errorDescription: String? {
+        switch self {
+        case .formatNotSupported:
+            "Format not supported."
+        case .unspecified:
+            "Unspecified error."
+        case .unsupportedProperty:
+            "Unsupported property."
+        case .badPropertySize:
+            "Bad property size."
+        case .badSpecifierSize:
+            "Bad specifier size."
+        case .unknownFormat:
+            "Unknown format."
+        case let .unknownError(osStatus):
+            "Unknown error (OSStatus \(osStatus))"
+        }
+    }
+}

Sources/SwiftAudioFileConverter/AudioFileConverter/Settings/BitDepth.swift

@@ -0,0 +1,37 @@
+//
+//  BitDepth.swift
+//  SwiftAudioFileConverter
+//
+//  Created by Devin Roth on 2025-04-03.
+//
+
+import Foundation
+
+extension AudioFileConverter {
+    public enum BitDepth {
+        case int16
+        case int24
+        case float32
+    }
+}
+
+extension AudioFileConverter.BitDepth: Equatable { }
+
+extension AudioFileConverter.BitDepth: Hashable { }
+
+extension AudioFileConverter.BitDepth: Sendable { }
+
+extension AudioFileConverter.BitDepth: CaseIterable { }
+
+extension AudioFileConverter.BitDepth: CustomStringConvertible {
+    public var description: String {
+        switch self {
+        case .int16:
+            "16-bit Int"
+        case .int24:
+            "24-bit Int"
+        case .float32:
+            "32-bit Float"
+        }
+    }
+}