@siteed/audio-studio 3.0.0

package/ios/AudioStudioTests/TestAudioGenerator.swift

@@ -0,0 +1,75 @@
+import Foundation
+import AVFoundation
+import Accelerate
+
+class TestAudioGenerator {
+    
+    /// Generate a sine wave tone
+    static func generateTone(frequency: Double, duration: TimeInterval, sampleRate: Double = 44100) -> AVAudioPCMBuffer? {
+        let frameCount = AVAudioFrameCount(duration * sampleRate)
+        
+        guard let buffer = AVAudioPCMBuffer(pcmFormat: AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 1)!, frameCapacity: frameCount) else {
+            return nil
+        }
+        
+        buffer.frameLength = frameCount
+        
+        let channelData = buffer.floatChannelData![0]
+        let angleIncrement = 2.0 * .pi * frequency / sampleRate
+        
+        for frame in 0..<Int(frameCount) {
+            channelData[frame] = Float(sin(Double(frame) * angleIncrement))
+        }
+        
+        return buffer
+    }
+    
+    /// Generate white noise
+    static func generateWhiteNoise(duration: TimeInterval, sampleRate: Double = 44100) -> AVAudioPCMBuffer? {
+        let frameCount = AVAudioFrameCount(duration * sampleRate)
+        
+        guard let buffer = AVAudioPCMBuffer(pcmFormat: AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 1)!, frameCapacity: frameCount) else {
+            return nil
+        }
+        
+        buffer.frameLength = frameCount
+        
+        let channelData = buffer.floatChannelData![0]
+        
+        for frame in 0..<Int(frameCount) {
+            channelData[frame] = Float.random(in: -1...1)
+        }
+        
+        return buffer
+    }
+    
+    /// Load test asset from bundle
+    static func loadTestAsset(named name: String) -> AVAudioFile? {
+        guard let url = Bundle(for: TestAudioGenerator.self).url(forResource: name, withExtension: "wav") else {
+            return nil
+        }
+        
+        return try? AVAudioFile(forReading: url)
+    }
+    
+    /// Convert AVAudioPCMBuffer to Data
+    static func bufferToData(_ buffer: AVAudioPCMBuffer) -> Data? {
+        guard let channelData = buffer.floatChannelData else { return nil }
+        
+        let channelCount = Int(buffer.format.channelCount)
+        let frameLength = Int(buffer.frameLength)
+        let bytesPerFrame = 2 * channelCount // 16-bit audio
+        
+        var data = Data(capacity: frameLength * bytesPerFrame)
+        
+        for frame in 0..<frameLength {
+            for channel in 0..<channelCount {
+                let sample = channelData[channel][frame]
+                let int16Sample = Int16(max(-32768, min(32767, sample * 32767)))
+                data.append(contentsOf: withUnsafeBytes(of: int16Sample) { Array($0) })
+            }
+        }
+        
+        return data
+    }
+} 

package/ios/DataPoint.swift

@@ -0,0 +1,54 @@
+//
+//  DataPoint.swift
+//  AudioStudio
+//
+//  Created by Arthur Breton on 23/6/2024.
+//
+
+import Foundation
+
+public struct SpeechFeatures {
+    public var isActive: Bool
+    public var speakerId: Int?
+    
+    func toDictionary() -> [String: Any] {
+        return [
+            "isActive": isActive,
+            "speakerId": speakerId as Any
+        ]
+    }
+}
+
+public struct DataPoint {
+    public var id: Int
+    public var amplitude: Float
+    public var rms: Float
+    public var dB: Float
+    public var silent: Bool
+    public var features: Features?
+    public var speech: SpeechFeatures?
+    public let startTime: Float // in seconds
+    public let endTime: Float   // in seconds
+    public let startPosition: Int // byte position in audio file
+    public let endPosition: Int   // byte position in audio file
+    public let samples: Int       // number of samples in segment
+}
+
+extension DataPoint {
+    func toDictionary() -> [String: Any] {
+        return [
+            "id": id,
+            "amplitude": amplitude,
+            "rms": rms,
+            "dB": dB,
+            "silent": silent,
+            "features": features?.toDictionary() ?? [:],
+            "speech": speech?.toDictionary() ?? [:],
+            "startTime": startTime,
+            "endTime": endTime,
+            "startPosition": startPosition,
+            "endPosition": endPosition,
+            "samples": samples
+        ]
+    }
+}

package/ios/DecodingConfig.swift

@@ -0,0 +1,59 @@
+//
+//  DecodingConfig.swift
+//  Pods
+//
+//  Created by Arthur Breton on 24/2/2025.
+//
+
+import AVFoundation
+
+public struct DecodingConfig {
+    public let targetSampleRate: Double?
+    public let targetChannels: Int?
+    public let targetBitDepth: Int?
+    public let normalizeAudio: Bool
+    
+    public init(
+        targetSampleRate: Double?,
+        targetChannels: Int?,
+        targetBitDepth: Int?,
+        normalizeAudio: Bool = false
+    ) {
+        self.targetSampleRate = targetSampleRate
+        self.targetChannels = targetChannels
+        self.targetBitDepth = targetBitDepth
+        self.normalizeAudio = normalizeAudio
+    }
+    
+    public static func fromDictionary(_ dict: [String: Any]?) -> DecodingConfig {
+        guard let dict = dict else {
+            return DecodingConfig.default
+        }
+        
+        return DecodingConfig(
+            targetSampleRate: dict["targetSampleRate"] as? Double,
+            targetChannels: dict["targetChannels"] as? Int,
+            targetBitDepth: dict["targetBitDepth"] as? Int,
+            normalizeAudio: dict["normalizeAudio"] as? Bool ?? false
+        )
+    }
+    
+    public static var `default`: DecodingConfig {
+        return DecodingConfig(
+            targetSampleRate: nil,
+            targetChannels: nil,
+            targetBitDepth: nil,
+            normalizeAudio: false
+        )
+    }
+    
+    public func toAudioFormat(baseFormat: AVAudioFormat) -> AVAudioFormat {
+        let sampleRate = targetSampleRate ?? baseFormat.sampleRate
+        let channels = targetChannels ?? Int(baseFormat.channelCount)
+        
+        return AVAudioFormat(
+            standardFormatWithSampleRate: sampleRate,
+            channels: AVAudioChannelCount(channels)
+        )!
+    }
+}

package/ios/FFT.swift

@@ -0,0 +1,62 @@
+//
+//  FFT.swift
+//  Pods
+//
+//  Created by Arthur Breton on 20/2/2025.
+//
+
+import Accelerate
+
+class FFT {
+    private let length: Int
+    private var setup: vDSP_DFT_Setup?
+    
+    init(_ length: Int) {
+        self.length = length
+        self.setup = vDSP_DFT_zop_CreateSetup(
+            nil,
+            vDSP_Length(length),
+            vDSP_DFT_Direction.FORWARD
+        )
+    }
+    
+    deinit {
+        if let setup = setup {
+            vDSP_DFT_DestroySetup(setup)
+        }
+    }
+    
+    func realForward(_ data: inout [Float]) {
+        var realIn = data
+        var imagIn = [Float](repeating: 0.0, count: length)
+        var realOut = [Float](repeating: 0.0, count: length)
+        var imagOut = [Float](repeating: 0.0, count: length)
+        
+        // Perform FFT
+        vDSP_DFT_Execute(setup!,
+                        &realIn,
+                        &imagIn,
+                        &realOut,
+                        &imagOut)
+        
+        // Ensure data array has enough space for both real and imaginary parts
+        if data.count < 2 * length {
+            data.append(contentsOf: [Float](repeating: 0.0, count: 2 * length - data.count))
+        }
+        
+        // Combine real and imaginary parts
+        for i in 0..<length {
+            let j = i * 2
+            data[j] = realOut[i]
+            data[j + 1] = imagOut[i]
+        }
+    }
+    
+    func processSegment(_ segment: [Float]) -> [Float] {
+        var fftData = segment.count < length ?
+            segment + [Float](repeating: 0, count: length - segment.count) :
+            Array(segment.prefix(length))
+        realForward(&fftData)
+        return fftData
+    }
+}

package/ios/Features.swift

@@ -0,0 +1,95 @@
+//
+//  Features.swift
+//  AudioStudio
+//
+//  Created by Arthur Breton on 23/6/2024.
+//
+
+import Foundation
+
+public struct Features {
+    var energy: Float
+    var mfcc: [Float]
+    var rms: Float
+    var minAmplitude: Float
+    var maxAmplitude: Float
+    var zcr: Float
+    var spectralCentroid: Float
+    var spectralFlatness: Float
+    var spectralRolloff: Float?
+    var spectralBandwidth: Float?
+    var chromagram: [Float]?
+    var tempo: Float?
+    var hnr: Float?
+    var melSpectrogram: [Float]?
+    var spectralContrast: [Float]?
+    var tonnetz: [Float]?
+    var pitch: Float?
+    var crc32: UInt32?
+    
+    init(
+        energy: Float = 0,
+        mfcc: [Float] = [],
+        rms: Float = 0,
+        minAmplitude: Float = 0,
+        maxAmplitude: Float = 0,
+        zcr: Float = 0,
+        spectralCentroid: Float = 0,
+        spectralFlatness: Float = 0,
+        spectralRolloff: Float? = nil,
+        spectralBandwidth: Float? = nil,
+        chromagram: [Float]? = nil,
+        tempo: Float? = nil,
+        hnr: Float? = nil,
+        melSpectrogram: [Float]? = nil,
+        spectralContrast: [Float]? = nil,
+        tonnetz: [Float]? = nil,
+        pitch: Float? = nil,
+        crc32: UInt32? = nil
+    ) {
+        self.energy = energy
+        self.mfcc = mfcc
+        self.rms = rms
+        self.minAmplitude = minAmplitude
+        self.maxAmplitude = maxAmplitude
+        self.zcr = zcr
+        self.spectralCentroid = spectralCentroid
+        self.spectralFlatness = spectralFlatness
+        self.spectralRolloff = spectralRolloff
+        self.spectralBandwidth = spectralBandwidth
+        self.chromagram = chromagram
+        self.tempo = tempo
+        self.hnr = hnr
+        self.melSpectrogram = melSpectrogram
+        self.spectralContrast = spectralContrast
+        self.tonnetz = tonnetz
+        self.pitch = pitch
+        self.crc32 = crc32
+    }
+}
+
+extension Features {
+    func toDictionary() -> [String: Any] {
+        let dict: [String: Any] = [
+            "energy": energy,
+            "mfcc": mfcc,
+            "rms": rms,
+            "minAmplitude": minAmplitude,
+            "maxAmplitude": maxAmplitude,
+            "zcr": zcr,
+            "spectralCentroid": spectralCentroid,
+            "spectralFlatness": spectralFlatness,
+            "spectralRolloff": spectralRolloff ?? 0,
+            "spectralBandwidth": spectralBandwidth ?? 0,
+            "chromagram": chromagram ?? [],
+            "tempo": tempo ?? 0,
+            "hnr": hnr ?? 0,
+            "melSpectrogram": melSpectrogram ?? [],
+            "spectralContrast": spectralContrast ?? [],
+            "tonnetz": tonnetz ?? [],
+            "pitch": pitch ?? 0,
+            "crc32": crc32 ?? 0
+        ]
+        return dict
+    }
+}

package/ios/ISSUE_IOS.md

@@ -0,0 +1,68 @@
+# iOS Recording Issue: No WAV Data/Analysis When Resampling (e.g., 16kHz) - RESOLVED
+
+## Problem Summary
+
+Initially, the iOS implementation failed to record WAV audio data or perform real-time analysis when the requested `sampleRate` (e.g., 16,000 Hz) differed from the hardware's native sample rate (e.g., 48,000 Hz), requiring resampling. Recording at the native hardware sample rate worked correctly.
+
+The primary symptom was that the tap installed on the `audioEngine.inputNode` using `installTap(onBus:bufferSize:format:)` was **not receiving any audio buffers** when resampling was required (i.e., requested rate != hardware rate). This resulted in:
+
+*   An empty WAV file (only the initial 44-byte header).
+*   No data being sent to the `AudioProcessor` for real-time analysis.
+*   No `AudioData` or `AudioAnalysis` events being emitted for the WAV stream.
+
+Parallel compressed recording (e.g., AAC) functioned correctly even when the WAV stream failed, indicating the audio engine *was* capturing audio but not delivering it to the tap.
+
+## Debugging History & Findings
+
+1.  **Initial State:** Empty WAV file at 16kHz, working AAC at 16kHz. Confirmed 48kHz WAV worked.
+2.  **Tap Installation Format:** Early attempts tried setting the tap format to the *requested* sample rate (16kHz), leading to `AVAudioIONodeImpl.mm:1334 Format mismatch` crashes because the tap format didn't match the actual hardware input format (often 48kHz).
+3.  **Using `inputNode.outputFormat`:** Switched to installing the tap using the format reported by `inputNode.outputFormat(forBus: 0)`, assuming this reflected the actual hardware format. Resampling was handled later in `processAudioBuffer`. This fixed the crash but **did not** fix the original issue – the tap still received no buffers at 16kHz.
+4.  **Race Condition:** Identified and fixed a race condition where `audioEngine.start()` was called before `isRecording` was set to `true`, causing the tap's initial guard check to fail. This allowed buffers to be processed *after* the flag was set, but the WAV file writing was still faulty (only the first buffer was written).
+5.  **Background File I/O Refactor:** Improved WAV file writing by keeping the `FileHandle` open during recording instead of opening/closing for each buffer in the background queue. This fixed the partial file writing issue but didn't solve the core "no buffers received at 16kHz" problem.
+6.  **Removing `setPreferredSampleRate`:** Tried removing the `session.setPreferredSampleRate` call, hoping the session would default to the hardware rate, allowing the 48kHz tap (based on `inputNode.outputFormat`) to receive buffers. This **worked** for the internal microphone but caused crashes with Bluetooth headsets, as the Bluetooth hardware *actually* operated at 16kHz, creating a new format mismatch.
+7.  **Using `session.sampleRate`:** Attempted to use `session.sampleRate` *after* session activation to determine the tap format. This also proved unreliable, sometimes reporting 16kHz for the session while `inputNode.outputFormat` still reported 48kHz, leading back to the format mismatch crash.
+8.  **Using `inputNode.inputFormat`:** After further analysis, discovered that `inputNode.inputFormat(forBus: 0)` gives the actual hardware input format, which may differ from the output format. This is the format that iOS strictly requires for a tap.
+
+## Root Cause
+
+The core issue stems from the unreliability and potential inconsistency between:
+
+*   `AVAudioSession.sampleRate` (especially after `setPreferredSampleRate` or device changes).
+*   `audioEngine.inputNode.outputFormat(forBus: 0)` (which might not immediately reflect the true hardware format).
+*   `audioEngine.inputNode.inputFormat(forBus: 0)` (which provides the hardware's actual input format).
+*   The actual sample rate the hardware is delivering to the audio engine.
+
+Attempting to force a specific sample rate via `setPreferredSampleRate` or relying solely on `session.sampleRate` post-activation can lead to situations where the format used to install the tap does not match the format the audio engine expects/receives from the hardware input, causing either a crash (`Format mismatch`) or the tap simply not receiving any buffers.
+
+## Final Solution
+
+The most robust solution was found to be:
+
+1.  **Configure Session:** Set up the `AVAudioSession` category, mode, and options as required. **Do not** call `setPreferredSampleRate`. Let the session negotiate the rate with the hardware.
+2.  **Activate Session:** Activate the audio session.
+3.  **Query Hardware Input Format (Just-In-Time):** Immediately **before** calling `installTap`, query the hardware's input format using `audioEngine.inputNode.inputFormat(forBus: 0)`. This provides the actual format that the hardware is delivering and that iOS requires for the tap.
+4.  **Install Tap:** Install the tap using the exact `AVAudioFormat` obtained from `inputNode.inputFormat(forBus: 0)` in the previous step.
+5.  **Resample in Tap:** Inside the tap's processing closure (`processAudioBuffer`), check if the received `buffer.format.sampleRate` differs from the `settings.sampleRate` requested by the user. If they differ, perform the resampling explicitly using `AVAudioConverter` (or a similar method) before writing the WAV data or performing analysis.
+
+This approach ensures the tap format always matches what the hardware requires, regardless of the device (internal mic, Bluetooth) or the requested output sample rate. Subsequent resampling handles the conversion to the user's desired format.
+
+## Additional Findings: Device Disconnection Handling
+
+During testing, we discovered an issue with device disconnection (particularly Bluetooth headsets):
+
+1. When a recording device disconnects, iOS reports a route change notification.
+2. If we attempt to resume recording after the device disconnection or switch to a new device, the app would crash with `Format mismatch: input hw <AVAudioFormat: 1 ch, 16000 Hz, Float32>, client format <AVAudioFormat: 1 ch, 48000 Hz, Float32>`.
+
+We implemented a robust solution with the following components:
+
+1. **Hardware Format Detection:** Created a shared `installTapWithHardwareFormat` method that always queries the current hardware input format using `inputNode.inputFormat(forBus: 0)` before installing a tap.
+
+2. **Format Verification on Resume:** When resuming recording after a pause (potentially due to device disconnect), we reinstall the tap with the current hardware format.
+
+3. **Fallback Device Handling:** Implemented a configurable device disconnection behavior:
+   - `pause`: Pause recording when the current device disconnects (default)
+   - `fallback`: Automatically switch to the default device (built-in mic) and continue recording
+
+4. **Size Tracking Preservation:** Ensured that during device transitions, the total audio data size is preserved to maintain continuity in the recording.
+
+These improvements ensure that when audio devices change during a recording session, the app can either pause gracefully or continue recording with a fallback device, without data loss or crashes due to format mismatches.

package/ios/Logger.swift

@@ -0,0 +1,39 @@
+class Logger {
+    // Similar to Android's TAG_PREFIX for consistent cross-platform logging
+    private static let TAG_PREFIX = "AudioStudio"
+    
+    static func debug(_ className: String, _ message: @autoclosure () -> String) {
+        #if DEBUG
+        print("[\(TAG_PREFIX):\(className)] [DEBUG] \(message())")
+        #endif
+    }
+
+    static func info(_ className: String, _ message: @autoclosure () -> String) {
+        print("[\(TAG_PREFIX):\(className)] [INFO] \(message())")
+    }
+
+    static func warn(_ className: String, _ message: @autoclosure () -> String) {
+        print("[\(TAG_PREFIX):\(className)] [WARN] ⚠️ \(message())")
+    }
+
+    static func error(_ className: String, _ message: @autoclosure () -> String) {
+        print("[\(TAG_PREFIX):\(className)] [ERROR] 🛑 \(message())")
+    }
+    
+    // For backward compatibility with code that doesn't specify a class name
+    static func debug(_ message: @autoclosure () -> String) {
+        debug("General", message())
+    }
+    
+    static func info(_ message: @autoclosure () -> String) {
+        info("General", message())
+    }
+    
+    static func warn(_ message: @autoclosure () -> String) {
+        warn("General", message())
+    }
+    
+    static func error(_ message: @autoclosure () -> String) {
+        error("General", message())
+    }
+}

package/ios/MelSpectrogramWrapper.h

@@ -0,0 +1,30 @@
+#import <Foundation/Foundation.h>
+
+@interface MelSpectrogramWrapper : NSObject
+
++ (nullable NSDictionary *)computeWithSamples:(const float *)samples
+                                   numSamples:(int)numSamples
+                                   sampleRate:(int)sampleRate
+                                    fftLength:(int)fftLength
+                            windowSizeSamples:(int)windowSizeSamples
+                             hopLengthSamples:(int)hopLengthSamples
+                                        nMels:(int)nMels
+                                         fMin:(float)fMin
+                                         fMax:(float)fMax
+                                   windowType:(int)windowType
+                                     logScale:(BOOL)logScale
+                                    normalize:(BOOL)normalize;
+
++ (void)initWithSampleRate:(int)sampleRate
+                 fftLength:(int)fftLength
+         windowSizeSamples:(int)windowSizeSamples
+          hopLengthSamples:(int)hopLengthSamples
+                     nMels:(int)nMels
+                      fMin:(float)fMin
+                      fMax:(float)fMax
+                windowType:(int)windowType;
+
++ (nullable NSArray<NSNumber *> *)computeFrameWithSamples:(const float *)samples
+                                                frameSize:(int)frameSize;
+
+@end

package/ios/MelSpectrogramWrapper.mm

@@ -0,0 +1,97 @@
+#import "MelSpectrogramWrapper.h"
+
+// Include C++ implementation directly since CocoaPods doesn't compile
+// source files from outside the pod's root directory (../cpp/)
+#include "kiss_fft/kiss_fft.c"
+#include "kiss_fft/kiss_fftr.c"
+#include "MelSpectrogram.cpp"
+#include "MelSpectrogramBridge.cpp"
+
+@implementation MelSpectrogramWrapper
+
++ (nullable NSDictionary *)computeWithSamples:(const float *)samples
+                                   numSamples:(int)numSamples
+                                   sampleRate:(int)sampleRate
+                                    fftLength:(int)fftLength
+                            windowSizeSamples:(int)windowSizeSamples
+                             hopLengthSamples:(int)hopLengthSamples
+                                        nMels:(int)nMels
+                                         fMin:(float)fMin
+                                         fMax:(float)fMax
+                                   windowType:(int)windowType
+                                     logScale:(BOOL)logScale
+                                    normalize:(BOOL)normalize
+{
+    CMelSpectrogramResult* result = mel_spectrogram_compute(
+        samples, numSamples, sampleRate,
+        fftLength, windowSizeSamples, hopLengthSamples,
+        nMels, fMin, fMax,
+        windowType, logScale ? 1 : 0, normalize ? 1 : 0);
+
+    if (!result) {
+        return nil;
+    }
+
+    // Convert flat float array to NSArray of NSArray<NSNumber>
+    NSMutableArray *spectrogram = [NSMutableArray arrayWithCapacity:result->timeSteps];
+    for (int i = 0; i < result->timeSteps; i++) {
+        NSMutableArray *row = [NSMutableArray arrayWithCapacity:result->nMels];
+        for (int j = 0; j < result->nMels; j++) {
+            [row addObject:@(result->data[i * result->nMels + j])];
+        }
+        [spectrogram addObject:row];
+    }
+
+    NSDictionary *dict = @{
+        @"spectrogram": spectrogram,
+        @"timeSteps": @(result->timeSteps),
+        @"nMels": @(result->nMels)
+    };
+
+    mel_spectrogram_free(result);
+
+    return dict;
+}
+
++ (void)initWithSampleRate:(int)sampleRate
+                 fftLength:(int)fftLength
+         windowSizeSamples:(int)windowSizeSamples
+          hopLengthSamples:(int)hopLengthSamples
+                     nMels:(int)nMels
+                      fMin:(float)fMin
+                      fMax:(float)fMax
+                windowType:(int)windowType
+{
+    mel_spectrogram_init(sampleRate, fftLength, windowSizeSamples,
+        hopLengthSamples, nMels, fMin, fMax, windowType);
+}
+
++ (nullable NSArray<NSNumber *> *)computeFrameWithSamples:(const float *)samples
+                                                frameSize:(int)frameSize
+{
+    int nMels = mel_spectrogram_get_n_mels();
+    if (nMels <= 0) {
+        return nil;
+    }
+
+    float* melOutput = (float*)malloc(nMels * sizeof(float));
+    if (!melOutput) {
+        return nil;
+    }
+
+    int success = mel_spectrogram_compute_frame(samples, frameSize, melOutput);
+    if (!success) {
+        free(melOutput);
+        return nil;
+    }
+
+    NSMutableArray<NSNumber *> *result = [NSMutableArray arrayWithCapacity:nMels];
+    for (int i = 0; i < nMels; i++) {
+        [result addObject:@(melOutput[i])];
+    }
+
+    free(melOutput);
+    return result;
+}
+
+@end

package/ios/NotificationExtension.swift

@@ -0,0 +1,15 @@
+//
+//  NotificationExtension.swift
+//  Pods
+//
+//  Created by Arthur Breton on 27/10/2024.
+//
+
+
+import Foundation
+
+extension Notification.Name {
+    static let pauseRecording = Notification.Name("PAUSE_RECORDING")
+    static let resumeRecording = Notification.Name("RESUME_RECORDING")
+    static let notificationActionTriggered = Notification.Name("notificationActionTriggered")
+}

package/ios/RecordingResult.swift

@@ -0,0 +1,22 @@
+// RecordingResult.swift
+
+struct RecordingResult {
+    var fileUri: String
+    var filename: String
+    var mimeType: String
+    var duration: Int64
+    var size: Int64
+    var channels: Int
+    var bitDepth: Int
+    var sampleRate: Double
+    var compression: CompressedRecordingInfo?
+}
+
+struct StartRecordingResult {
+    var fileUri: String
+    var mimeType: String
+    var channels: Int
+    var bitDepth: Int
+    var sampleRate: Double
+    var compression: CompressedRecordingInfo?
+}