Initial version of AudioKitEX separated from AudioKit

Author: aure

.gitignore

@@ -88,3 +88,11 @@ fastlane/test_output
 # https://github.com/johnno1962/injectionforxcode
 
 iOSInjectionProject/
+
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+xcuserdata/
+DerivedData/
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata

Package.resolved

@@ -0,0 +1,18 @@
+// swift-tools-version:5.3
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "AudioKitEX",
+    platforms: [.macOS(.v10_13), .iOS(.v11), .tvOS(.v11)],
+    products: [.library(name: "AudioKitEX", targets: ["AudioKitEX"])],
+    dependencies: [.package(url: "https://github.com/AudioKit/AudioKit", .branch("swift-only"))],
+    targets: [
+        .target(name: "AudioKitEX", dependencies: ["AudioKit", "CAudioKitEX"]),
+        .target(name: "CAudioKitEX", cxxSettings: [.headerSearchPath(".")]),
+        .testTarget(name: "AudioKitEXTests", dependencies: ["AudioKitEX"], resources: [.copy("TestResources/")])
+    ],
+    cxxLanguageStandard: .cxx14
+)
+

Package.swift

@@ -0,0 +1,196 @@
+// Copyright AudioKit. All Rights Reserved. Revision History at http://github.com/AudioKit/AudioKit/
+
+import AudioToolbox
+import AVFoundation
+import CAudioKitEX
+import AudioKit
+
+/// AudioUnit which instantiates a DSP kernel based on the componentSubType.
+open class AudioKitAU: AUAudioUnit {
+    // MARK: AUAudioUnit Overrides
+    
+    private var inputBusArray: [AUAudioUnitBus] = []
+    private var outputBusArray: [AUAudioUnitBus] = []
+    private var internalBuffers: [AVAudioPCMBuffer] = []
+
+    // Default supported channel capabilities
+    public var supportedLeftChannelCount: NSNumber = 2
+    public var supportedRightChannelCount: NSNumber = 2
+
+    override public var channelCapabilities: [NSNumber]? {
+        return [supportedLeftChannelCount, supportedRightChannelCount]
+    }
+    
+    /// Allocate the render resources
+    override public func allocateRenderResources() throws {
+        try super.allocateRenderResources()
+        
+        if let inputFormat = inputBusArray.first?.format {
+            
+            // we don't need to allocate a buffer if we can process in place
+            if !canProcessInPlace || inputBusArray.count > 1 {
+                for i in inputBusArray.indices {
+                    if let buffer = AVAudioPCMBuffer(pcmFormat: inputFormat, frameCapacity: maximumFramesToRender) {
+                        setBufferDSP(dsp, buffer.mutableAudioBufferList, i)
+                        internalBuffers.append(buffer)
+                    }
+                }
+            }
+        }
+        
+        if let outputFormat = outputBusArray.first?.format {
+            allocateRenderResourcesDSP(dsp, outputFormat.channelCount, outputFormat.sampleRate)
+        }
+    }
+    
+    /// Delllocate Render Resources
+    override public func deallocateRenderResources() {
+        super.deallocateRenderResources()
+        deallocateRenderResourcesDSP(dsp)
+        internalBuffers = []
+    }
+    
+    /// Reset the DSP
+    override public func reset() {
+        resetDSP(dsp)
+    }
+    
+    private lazy var auInputBusArray: AUAudioUnitBusArray = {
+        AUAudioUnitBusArray(audioUnit: self, busType: .input, busses: inputBusArray)
+    }()
+    
+    /// Input busses
+    override public var inputBusses: AUAudioUnitBusArray {
+        return auInputBusArray
+    }
+    
+    private lazy var auOutputBusArray: AUAudioUnitBusArray = {
+        AUAudioUnitBusArray(audioUnit: self, busType: .output, busses: outputBusArray)
+    }()
+    
+    /// Output bus array
+    override public var outputBusses: AUAudioUnitBusArray {
+        return auOutputBusArray
+    }
+    
+    /// Internal render block
+    override public var internalRenderBlock: AUInternalRenderBlock {
+        internalRenderBlockDSP(dsp)
+    }
+    
+    private var _parameterTree: AUParameterTree?
+    
+    /// Parameter tree
+    override public var parameterTree: AUParameterTree? {
+        get { return _parameterTree }
+        set {
+            _parameterTree = newValue
+            
+            _parameterTree?.implementorValueObserver = { [unowned self] parameter, value in
+                setParameterValueDSP(self.dsp, parameter.address, value)
+            }
+            
+            _parameterTree?.implementorValueProvider = { [unowned self] parameter in
+                getParameterValueDSP(self.dsp, parameter.address)
+            }
+            
+            _parameterTree?.implementorStringFromValueCallback = { parameter, value in
+                if let value = value {
+                    return String(format: "%.2f", value.pointee)
+                } else {
+                    return "Invalid"
+                }
+            }
+        }
+    }
+    
+    /// Whether the unit can process in place
+    override public var canProcessInPlace: Bool {
+        return canProcessInPlaceDSP(dsp)
+    }
+    
+    /// Set in order to bypass processing
+    override public var shouldBypassEffect: Bool {
+        get { return getBypassDSP(dsp) }
+        set { setBypassDSP(dsp, newValue) }
+    }
+    
+    // MARK: Lifecycle
+    
+    /// DSP Reference
+    public private(set) var dsp: DSPRef?
+    
+    /// Initialize with component description and options
+    /// - Parameters:
+    ///   - componentDescription: Audio Component Description
+    ///   - options: Audio Component Instantiation Options
+    /// - Throws: error
+    override public init(componentDescription: AudioComponentDescription,
+                         options: AudioComponentInstantiationOptions = []) throws {
+        try super.init(componentDescription: componentDescription, options: options)
+        
+        // Create pointer to C++ DSP code.
+        dsp = akCreateDSP(componentDescription.componentSubType)
+        assert(dsp != nil)
+        
+        // create audio bus connection points
+        let format = AVAudioFormat(standardFormatWithSampleRate: 44100, channels: 2)!
+        for _ in 0..<inputBusCountDSP(dsp) {
+            inputBusArray.append(try AUAudioUnitBus(format: format))
+        }
+        
+        // All AudioKit nodes have one output bus.
+        outputBusArray.append(try AUAudioUnitBus(format: format))
+        
+        parameterTree = AUParameterTree.createTree(withChildren: [])
+        
+    }
+    
+    deinit {
+        deleteDSP(dsp)
+    }
+    
+    // MARK: AudioKit
+    
+    /// Trigger something within the audio unit
+    public func trigger(note: MIDINoteNumber, velocity: MIDIVelocity) {
+        #if !os(tvOS)
+        guard let midiBlock = scheduleMIDIEventBlock else {
+            fatalError("Attempt to trigger audio unit which doesn't respond to MIDI.")
+        }
+        let event = MIDIEvent(noteOn: note, velocity: velocity, channel: 0)
+        event.data.withUnsafeBufferPointer { ptr in
+            guard let ptr = ptr.baseAddress else { return }
+            midiBlock(AUEventSampleTimeImmediate, 0, event.data.count, ptr)
+        }
+        #endif
+    }
+    
+    /// Trigger something within the audio unit
+    public func trigger() {
+        trigger(note: 64, velocity: 127)
+    }
+    
+    /// Turn off the the trigger for a gate
+    public func detrigger() {
+        trigger(note: 64, velocity: 0)
+    }
+    
+    
+    /// Create an array of values to use as waveforms or other things inside an audio unit
+    /// - Parameters:
+    ///   - wavetable: Array of float values
+    ///   - index: Optional index at which to set the table (useful for multiple waveform audio units)
+    public func setWavetable(_ wavetable: [AUValue], index: Int = 0) {
+        setWavetableDSP(dsp, wavetable, wavetable.count, Int32(index))
+    }
+    
+    /// Set wave table
+    /// - Parameters:
+    ///   - data: A pointer to the data
+    ///   - size: Size of the table
+    ///   - index: Index at which to set the value
+    public func setWavetable(data: UnsafePointer<AUValue>?, size: Int, index: Int = 0) {
+        setWavetableDSP(dsp, data, size, Int32(index))
+    }
+}

Sources/AudioKitEX/AudioKitAU.swift

@@ -0,0 +1,119 @@
+// Copyright AudioKit. All Rights Reserved. Revision History at http://github.com/AudioKit/AudioKit/
+
+import AVFoundation
+import CAudioKitEX
+import Foundation
+
+/// An automation curve (with curved segments) suitable for any time varying parameter.
+/// Includes functions for manipulating automation curves and conversion to linear automation ramps
+/// used by DSP code.
+public struct AutomationCurve {
+    /// Shorter name
+    public typealias Point = ParameterAutomationPoint
+
+    /// Array of points that make up the curve
+    public var points: [Point]
+
+    /// Initialize with points
+    /// - Parameter points: Array of points
+    public init(points: [Point]) {
+        self.points = points
+    }
+
+    static func evalRamp(start: Float, segment: Point, time: Float, endTime: Float) -> Float {
+        let remain = endTime - time
+        let taper = segment.rampTaper
+        let goal = segment.targetValue
+
+        // x is normalized position in ramp segment
+        let x = (segment.rampDuration - remain) / segment.rampDuration
+        let taper1 = start + (goal - start) * pow(x, abs(taper))
+        let absxm1 = abs((segment.rampDuration - remain) / segment.rampDuration - 1.0)
+        let taper2 = start + (goal - start) * (1.0 - pow(absxm1, 1.0 / abs(taper)))
+
+        return taper1 * (1.0 - segment.rampSkew) + taper2 * segment.rampSkew
+    }
+
+    /// Returns a new piecewise-linear automation curve which can be handed off to the audio thread
+    /// for efficient processing.
+    ///
+    /// - Parameters:
+    ///   - initialValue: Starting point
+    ///   - resolution: Duration of each linear segment in seconds
+    ///
+    /// - Returns: A new array of piecewise linear automation points
+    public func evaluate(initialValue: AUValue, resolution: Float) -> [AutomationEvent] {
+        var result = [AutomationEvent]()
+
+        // The last evaluated value
+        var value = initialValue
+
+        for i in 0 ..< points.count {
+            let point = points[i]
+
+            if point.isLinear() {
+                result.append(AutomationEvent(targetValue: point.targetValue,
+                                              startTime: point.startTime,
+                                              rampDuration: point.rampDuration))
+                value = point.targetValue
+
+            } else {
+                // Cut off the end if another point comes along.
+                let nextPointStart = i < points.count - 1 ? points[i + 1].startTime
+                    : Float.greatestFiniteMagnitude
+                let endTime: Float = min(nextPointStart,
+                                         point.startTime + point.rampDuration)
+
+                var t = point.startTime
+                let start = value
+
+                // March t along the segment
+                // this is effectively `while t <= endTime - resolution` without potentional for rounding errors
+                for _ in 0 ..< Int(round(endTime / resolution)) {
+                    value = AutomationCurve.evalRamp(start: start,
+                                                     segment: point,
+                                                     time: t + resolution,
+                                                     endTime: point.startTime + point.rampDuration)
+
+                    result.append(AutomationEvent(targetValue: value,
+                                                  startTime: t,
+                                                  rampDuration: resolution))
+
+                    t += resolution
+
+                    // safety check to not run past the final target value
+                    if t >= endTime { break }
+                }
+            }
+        }
+
+        return result
+    }
+
+    /// Replaces automation over a time range.
+    ///
+    /// Use this when calculating a new automation curve after recording automation.
+    ///
+    /// - Parameters:
+    ///   - range: time range
+    ///   - withPoints: new automation events
+    /// - Returns: new automation curve
+    public func replace(range: ClosedRange<Float>, withPoints newPoints: [(Float, AUValue)]) -> AutomationCurve {
+        var result = points
+        let startTime = range.lowerBound
+        let stopTime = range.upperBound
+
+        // Clear existing points in segment range.
+        result.removeAll { point in point.startTime >= startTime && point.startTime <= stopTime }
+
+        // Append recorded points.
+        result.append(contentsOf: newPoints.map { point in
+            Point(targetValue: point.1, startTime: point.0, rampDuration: 0.01)
+        })
+
+        // Sort vector by time.
+        result.sort { $0.startTime < $1.startTime }
+
+        return AutomationCurve(points: result)
+    }
+}