Working towards cross-platform compatability by implementing vDSP functions in plain Swift

Author: ConnorGibbons

Sources/SignalTools/Correlation.swift

@@ -17,7 +17,7 @@ public func slidingCorrelation(signal: [Float], template: [Float]) -> [Float]? {
         template.withUnsafeBufferPointer { templatePtr in
             let signalBasePointer = signalPtr.baseAddress!
             let templateBasePointer = templatePtr.baseAddress!
-            vDSP_conv(signalBasePointer, vDSP_Stride(1), templateBasePointer, vDSP_Stride(1), &result, vDSP_Stride(1), vDSP_Length(outputCount), vDSP_Length(template.count))
+            DSP.convolve(signalBasePointer, 1, templateBasePointer, 1, &result, 1, outputCount, template.count)
         }
     }
     return result

Sources/SignalTools/DSPBackend.swift

@@ -9,28 +9,36 @@ import Foundation
 
 #if canImport(Accelerate)
 import Accelerate
-public typealias ComplexSignal = DSPComplex
-public typealias SplitComplexSignal = DSPSplitComplex
+public typealias ComplexSample = DSPComplex
+public typealias SplitComplexSamples = DSPSplitComplex
 #else
 struct ComplexSignal: Equatable {
     var real: Float
     var imag: Float
 }
 
 struct SplitComplexSignal {
-    var real: UnsafeMutablePointer<Float>
-    var imag: UnsafeMutablePointer<Float>
+    var realp: UnsafeMutablePointer<Float>
+    var imagp: UnsafeMutablePointer<Float>
 }
 #endif
 
-public extension ComplexSignal {
+public extension ComplexSample {
     func magnitude() -> Float {
         return ((real * real) + (imag * imag)).squareRoot()
     }
+    
+    func conjugate() -> ComplexSample {
+        return ComplexSample(real: real, imag: -imag)
+    }
 }
 
-public extension [ComplexSignal] {
+public extension [ComplexSample] {
     func magnitude() -> [Float] {
-        return self.map({$0.magnitude()})
+        return self.map { $0.magnitude() }
+    }
+    
+    func conjugate() -> [ComplexSample] {
+        return self.map { $0.conjugate() }
     }
 }

Sources/SignalTools/DSPTypes.swift

@@ -10,7 +10,7 @@ import Foundation
 
 /// This function will do FM demodulation, but much slower than demodulateFM 
 /// Here for conceptual understanding.
-public func demodulateFMSlow(_ samples: [DSPComplex]) -> [Float] {
+public func demodulateFMSlow(_ samples: [ComplexSample]) -> [Float] {
     var diffs =  [Float].init(repeating: 0.0, count: samples.count - 1)
     for i in 1..<samples.count {
         let i0 = samples[i-1].real
@@ -26,8 +26,8 @@ public func demodulateFMSlow(_ samples: [DSPComplex]) -> [Float] {
 }
 
 /// Demodulates FM by mutliplying each sample by the conjugate of the preceding sample, providing phase in radians.
-public func demodulateFM(_ samples: [DSPComplex]) -> [Float] {
-    let n = vDSP_Length(samples.count - 1)
+public func demodulateFM(_ samples: [ComplexSample]) -> [Float] {
+    let n = samples.count - 1
     var diffs = [Float].init(repeating: 0.0, count: samples.count - 1)
     samples.withUnsafeBufferPointer { samplesPtr in
         let basePointer = samplesPtr.baseAddress!
@@ -39,15 +39,15 @@ public func demodulateFM(_ samples: [DSPComplex]) -> [Float] {
             var tempReal = [Float].init(repeating: 0.0, count: samples.count - 1)
             var tempIm = [Float].init(repeating: 0.0, count: samples.count - 1)
 
-            let stride = vDSP_Stride(2) // One IQSample struct's worth of memory should be 2 floats
-            let shortStride = vDSP_Stride(1)
+            let stride = 2
+            let shortStride = 1
             tempReal.withUnsafeMutableBufferPointer { tempRealPtr in
                 tempIm.withUnsafeMutableBufferPointer { tempImPtr in
-                    var A: DSPSplitComplex = .init(realp: UnsafeMutablePointer(mutating: i0), imagp: UnsafeMutablePointer(mutating: q0)) // prev
-                    var B: DSPSplitComplex = .init(realp: UnsafeMutablePointer(mutating: i1), imagp: UnsafeMutablePointer(mutating: q1)) // curr
-                    var C: DSPSplitComplex = .init(realp: tempRealPtr.baseAddress!, imagp: tempImPtr.baseAddress!)
-                    vDSP_zvmul(&A, stride, &B, stride, &C, 1, n, -1)
-                    vDSP_zvphas(&C, shortStride, &diffs, shortStride, n)
+                    var A: SplitComplexSamples = .init(realp: UnsafeMutablePointer(mutating: i0), imagp: UnsafeMutablePointer(mutating: q0)) // prev
+                    var B: SplitComplexSamples = .init(realp: UnsafeMutablePointer(mutating: i1), imagp: UnsafeMutablePointer(mutating: q1)) // curr
+                    var C: SplitComplexSamples = .init(realp: tempRealPtr.baseAddress!, imagp: tempImPtr.baseAddress!)
+                    DSP.multiplyComplexVectors(&A, stride, &B, stride, &C, 1, n, true)
+                    DSP.phase(&C, shortStride, &diffs, shortStride, n)
                 }
             }
         }

Sources/SignalTools/Demodulation/Analog/FM.swift

@@ -4,14 +4,15 @@
 //
 //  Created by Connor Gibbons  on 6/24/25.
 //
+import Foundation
 
 public class Downsampler {
     private var decimationFactor: Int
     private var filter: [Float]
 
     // State
     private var realContext: [Float]
-    private var complexContext: [DSPComplex]
+    private var complexContext: [ComplexSample]
     private var realSkipCount: Int
     private var complexSkipCount: Int
 

Sources/SignalTools/Downsample.swift

@@ -11,10 +11,10 @@ import Foundation
 /// Read IQ Samples from a .wav where samples are stored as 16-bit integers.
 /// Samples are expected to be interleaved IQ.
 /// Samples are adjusted to be in range [-1,1]
-public func readIQFromWAV16Bit(fileURL: URL) throws -> [DSPComplex] {
+public func readIQFromWAV16Bit(fileURL: URL) throws -> [ComplexSample] {
     let data = try Data(contentsOf: fileURL)
 
-    var iqOutput: [DSPComplex] = []
+    var iqOutput: [ComplexSample] = []
 
     let iqData = data.dropFirst(44)
     guard iqData.count % 4 == 0 else {
@@ -28,14 +28,14 @@ public func readIQFromWAV16Bit(fileURL: URL) throws -> [DSPComplex] {
         while currOffset < int16ArrayBasePointer.count {
             let realSample = Float(int16ArrayBasePointer[currOffset]) / 32768.0
             let imagSample = Float(int16ArrayBasePointer[currOffset + 1]) / 32768.0
-            iqOutput.append(DSPComplex(real: realSample, imag: imagSample))
+            iqOutput.append(ComplexSample(real: realSample, imag: imagSample))
             currOffset += 2
         }
     }
 
     return iqOutput
 }
-public func readIQFromWAV16Bit(filePath: String) throws -> [DSPComplex] {
+public func readIQFromWAV16Bit(filePath: String) throws -> [ComplexSample] {
     let fileURL = URL(fileURLWithPath: filePath)
     return try readIQFromWAV16Bit(fileURL: fileURL)
 }

Sources/SignalTools/File Utilities/Read/wav.swift

@@ -51,7 +51,7 @@ public func writeAudioToFile(_ audio: [Float], path: String = "") {
 
 /// Write samples to specified path in .csv format.
 /// Each line is as follows: I,Q\n
-public func samplesToCSV(_ samples: [ComplexSignal], path: String) {
+public func samplesToCSV(_ samples: [ComplexSample], path: String) {
     var csvText = "I,Q\n"
     for sample in samples {
         csvText.append("\(sample.real),\(sample.imag)\n")

Sources/SignalTools/File Utilities/Write/csv.swift

@@ -7,7 +7,7 @@
 
 public protocol Filter {
     func filteredSignal( _ input: inout [Float])
-    func filteredSignal(_ input: inout [ComplexSignal])
+    func filteredSignal(_ input: inout [ComplexSample])
 }
 
 public enum FilterType {
@@ -48,7 +48,7 @@ public class IIRFilter: Filter {
         biquad!.apply(input: input, output: &input)
     }
 
-    public func filteredSignal(_ input: inout [ComplexSignal]) {
+    public func filteredSignal(_ input: inout [ComplexSample]) {
         if biquad == nil {
             initBiquad()
         }
@@ -90,7 +90,7 @@ public class FIRFilter: Filter {
     var taps: [Float]
     var tapsLength: Int
     var stateBuffer: UnsafeMutableBufferPointer<Float> // Last 'tapsLength - 1' values from previous buffer, need for convolution
-    var complexStateBuffer: UnsafeMutableBufferPointer<ComplexSignal>
+    var complexStateBuffer: UnsafeMutableBufferPointer<ComplexSample>
 
     public init(type: FilterType, cutoffFrequency: Double, sampleRate: Int, tapsLength: Int, windowFunc: vDSP.WindowSequence = .hamming) throws {
         var generatedFilter: [Float]
@@ -104,7 +104,7 @@ public class FIRFilter: Filter {
         stateBuffer = .allocate(capacity: tapsLength - 1)
         stateBuffer.initialize(repeating: 0.0)
         complexStateBuffer = .allocate(capacity: tapsLength - 1)
-        complexStateBuffer.initialize(repeating: ComplexSignal(real: 0, imag: 0))
+        complexStateBuffer.initialize(repeating: ComplexSample(real: 0, imag: 0))
     }
 
     public init(taps: [Float]) {
@@ -113,7 +113,7 @@ public class FIRFilter: Filter {
         stateBuffer = .allocate(capacity: tapsLength - 1)
         stateBuffer.initialize(repeating: 0.0)
         complexStateBuffer = .allocate(capacity: tapsLength - 1)
-        complexStateBuffer.initialize(repeating: ComplexSignal(real: 0, imag: 0))
+        complexStateBuffer.initialize(repeating: ComplexSample(real: 0, imag: 0))
     }
 
     deinit {
@@ -137,8 +137,8 @@ public class FIRFilter: Filter {
         input = tempOutputBuffer
     }
 
-    public func filteredSignal(_ input: inout [ComplexSignal]) {
-        let workingBuffer = UnsafeMutableBufferPointer<ComplexSignal>.allocate(capacity: input.count + tapsLength - 1)
+    public func filteredSignal(_ input: inout [ComplexSample]) {
+        let workingBuffer = UnsafeMutableBufferPointer<ComplexSample>.allocate(capacity: input.count + tapsLength - 1)
         defer {
             workingBuffer.deallocate()
         }
@@ -166,9 +166,9 @@ public class FIRFilter: Filter {
         vDSP.convert(splitComplexVector: splitComplexOutputBuffer, toInterleavedComplexVector: &input)
     }
 
-    public func filtfilt(_ input: inout [ComplexSignal]) {
+    public func filtfilt(_ input: inout [ComplexSample]) {
         self.filteredSignal(&input)
-        var reversedFilteredSignal: [ComplexSignal] = input.reversed()
+        var reversedFilteredSignal: [ComplexSample] = input.reversed()
         let freshFilter = FIRFilter(taps: self.taps)
         freshFilter.filteredSignal(&reversedFilteredSignal)
         input = reversedFilteredSignal.reversed()
@@ -191,7 +191,7 @@ public class FIRFilter: Filter {
         _ = stateBuffer.update(fromContentsOf: input.dropFirst(input.count - tapsLength + 1))
     }
 
-    private func copyToComplexStateBuffer(_ input: inout [ComplexSignal]) {
+    private func copyToComplexStateBuffer(_ input: inout [ComplexSample]) {
         _ = complexStateBuffer.update(fromContentsOf: input.dropFirst(input.count - tapsLength + 1))
     }
 

Sources/SignalTools/Filter.swift

@@ -7,15 +7,15 @@
 
 // Frequency Shifting
 
-public func shiftFrequencyToBaseband(rawIQ: [ComplexSignal], result: inout [ComplexSignal], frequency: Float, sampleRate: Int) {
+public func shiftFrequencyToBaseband(rawIQ: [ComplexSample], result: inout [ComplexSample], frequency: Float, sampleRate: Int) {
     guard rawIQ.count == result.count else {
         return
     }
 
     let sampleCount = rawIQ.count
     let complexMixerArray = (0..<sampleCount).map{ index in
         let angle = -2 * Float.pi * frequency * Float(index) / Float(sampleRate)
-        return ComplexSignal(real: cos(angle), imag: sin(angle))
+        return ComplexSample(real: cos(angle), imag: sin(angle))
     }
 
     var splitInputBuffer = DSPSplitComplex(realp: .allocate(capacity: sampleCount), imagp: .allocate(capacity: sampleCount))
@@ -38,7 +38,7 @@ public func shiftFrequencyToBaseband(rawIQ: [ComplexSignal], result: inout [Comp
 
 /// I've found that without using Double internally, weird artifacts can occur.
 /// Fair warning, this is probably a lot slower than the regular shift to baseband function.
-public func shiftFrequencyToBasebandHighPrecision(rawIQ: [ComplexSignal], result: inout [ComplexSignal], frequency: Float, sampleRate: Int) {
+public func shiftFrequencyToBasebandHighPrecision(rawIQ: [ComplexSample], result: inout [ComplexSample], frequency: Float, sampleRate: Int) {
     guard rawIQ.count == result.count else {
         return
     }
@@ -101,7 +101,7 @@ public func radToFrequency(radDiffs: [Float], sampleRate: Int) -> [Float] {
 }
 
 /// Calculates angle (radians) for each entry in an array of IQ samples.
-public func calculateAngle(rawIQ: [ComplexSignal], result: inout [Float]) {
+public func calculateAngle(rawIQ: [ComplexSample], result: inout [Float]) {
     let sampleCount = rawIQ.count
     guard sampleCount == result.count && !rawIQ.isEmpty else {
         return
@@ -179,7 +179,7 @@ public func valsAreClose(_ arr1: [Float], _ arr2: [Float], threshold: Float = 0.
 }
 
 /// Determines if all elements at the same index across two arrays are within a provided threshold.
-public func valsAreClose(_ arr1: [ComplexSignal],_ arr2: [ComplexSignal], threshold: Float = 0.001) -> Bool {
+public func valsAreClose(_ arr1: [ComplexSample],_ arr2: [ComplexSample], threshold: Float = 0.001) -> Bool {
     guard arr1.count == arr2.count else { return false }
     for i in 0..<arr1.count {
         if abs(arr1[i].imag - arr2[i].imag) > threshold {