expo-juce 0.3.1 → 0.3.2

package/ios/BeeperAudioEngine.mm

@@ -0,0 +1,352 @@
+#import "BeeperAudioEngine.h"
+#import <AVFoundation/AVFoundation.h>
+#include "JuceConfig.h"
+#include <juce_audio_devices/juce_audio_devices.h>
+#include <juce_audio_processors/juce_audio_processors.h>
+#include "PolySynthProcessor.h"
+#include "TransportEngine.h"
+
+// Lightweight AudioIODeviceCallback that drives an AudioProcessorGraph.
+// Replaces juce::AudioProcessorPlayer (from juce_audio_utils, which we don't use).
+class GraphPlayer : public juce::AudioIODeviceCallback {
+public:
+    void setProcessor(juce::AudioProcessor* p) { processor = p; }
+
+    void audioDeviceIOCallbackWithContext(const float* const* inputChannelData,
+                                          int numInputChannels,
+                                          float* const* outputChannelData,
+                                          int numOutputChannels,
+                                          int numSamples,
+                                          const juce::AudioIODeviceCallbackContext& context) override {
+        juce::ignoreUnused(inputChannelData, numInputChannels, context);
+        if (!processor) {
+            for (int i = 0; i < numOutputChannels; ++i)
+                juce::FloatVectorOperations::clear(outputChannelData[i], numSamples);
+            return;
+        }
+
+        buffer.setSize(numOutputChannels, numSamples, false, false, true);
+        buffer.clear();
+        juce::MidiBuffer midi;
+        processor->processBlock(buffer, midi);
+        for (int i = 0; i < numOutputChannels; ++i)
+            juce::FloatVectorOperations::copy(outputChannelData[i], buffer.getReadPointer(i), numSamples);
+    }
+
+    void audioDeviceAboutToStart(juce::AudioIODevice* device) override {
+        if (processor) {
+            processor->setPlayConfigDetails(0, device->getActiveOutputChannels().countNumberOfSetBits(),
+                                            device->getCurrentSampleRate(),
+                                            device->getCurrentBufferSizeSamples());
+            processor->prepareToPlay(device->getCurrentSampleRate(),
+                                     device->getCurrentBufferSizeSamples());
+        }
+    }
+
+    void audioDeviceStopped() override {
+        if (processor)
+            processor->releaseResources();
+    }
+
+private:
+    juce::AudioProcessor* processor = nullptr;
+    juce::AudioBuffer<float> buffer;
+};
+
+@interface BeeperAudioEngine ()
+@property (nonatomic, assign) bool isReady;
+@property (nonatomic, copy) BeatCallback beatCallback;
+@property (nonatomic, strong) dispatch_source_t beatTimer;
+@end
+
+// C++ members stored as raw pointers (ObjC class can't have C++ members inline)
+static juce::AudioDeviceManager* sDeviceManager = nullptr;
+static GraphPlayer* sPlayer = nullptr;
+static std::unique_ptr<juce::AudioProcessorGraph> sGraph;
+static PolySynthProcessor* sSynth = nullptr; // owned by graph
+static TransportEngine* sTransport = nullptr;
+static juce::AudioProcessorGraph::Node::Ptr sSynthNode;
+static juce::AudioProcessorGraph::Node::Ptr sOutputNode;
+
+@implementation BeeperAudioEngine
+
++ (instancetype)sharedInstance {
+    static BeeperAudioEngine *instance = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        instance = [[self alloc] init];
+    });
+    return instance;
+}
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _isReady = false;
+    }
+    return self;
+}
+
+- (void)setup {
+    NSAssert([NSThread isMainThread], @"setup() must be called on main thread");
+
+    if (self.isReady) {
+        NSLog(@"[BeeperAudioEngine] Already initialized, skipping");
+        return;
+    }
+
+    NSLog(@"[BeeperAudioEngine] Initializing JUCE audio stack...");
+
+    // 0. Configure AVAudioSession before JUCE takes over
+    NSError *sessionError = nil;
+    AVAudioSession *session = [AVAudioSession sharedInstance];
+    [session setCategory:AVAudioSessionCategoryPlayAndRecord
+             withOptions:(AVAudioSessionCategoryOptionMixWithOthers |
+                          AVAudioSessionCategoryOptionDefaultToSpeaker)
+                   error:&sessionError];
+    if (sessionError) {
+        NSLog(@"[BeeperAudioEngine] AVAudioSession category error: %@", sessionError);
+    }
+    sessionError = nil;
+    [session setActive:YES error:&sessionError];
+    if (sessionError) {
+        NSLog(@"[BeeperAudioEngine] AVAudioSession activation error: %@", sessionError);
+    }
+
+    // 1. Initialize MessageManager (attaches to existing CFRunLoop)
+    juce::MessageManager::getInstance();
+
+    // 2. Create transport
+    sTransport = new TransportEngine();
+
+    // 3. Create AudioDeviceManager
+    sDeviceManager = new juce::AudioDeviceManager();
+
+    // 4. Initialize device: 0 inputs, 2 outputs (stereo)
+    juce::String error = sDeviceManager->initialise(0, 2, nullptr, true);
+    if (error.isNotEmpty()) {
+        NSLog(@"[BeeperAudioEngine] AudioDeviceManager init failed: %s", error.toRawUTF8());
+        delete sDeviceManager;
+        sDeviceManager = nullptr;
+        delete sTransport;
+        sTransport = nullptr;
+        return;
+    }
+
+    // 5. Create AudioProcessorGraph
+    sGraph = std::make_unique<juce::AudioProcessorGraph>();
+    sGraph->setPlayConfigDetails(0, 2, sDeviceManager->getAudioDeviceSetup().sampleRate,
+                                  sDeviceManager->getAudioDeviceSetup().bufferSize);
+    sGraph->prepareToPlay(sDeviceManager->getAudioDeviceSetup().sampleRate,
+                           sDeviceManager->getAudioDeviceSetup().bufferSize);
+
+    // 6. Add PolySynthProcessor node
+    auto synthProcessor = std::make_unique<PolySynthProcessor>();
+    sSynth = synthProcessor.get();
+    sSynth->setTransport(sTransport);
+    sSynthNode = sGraph->addNode(std::move(synthProcessor));
+
+    // 7. Add output node
+    sOutputNode = sGraph->addNode(
+        std::make_unique<juce::AudioProcessorGraph::AudioGraphIOProcessor>(
+            juce::AudioProcessorGraph::AudioGraphIOProcessor::audioOutputNode));
+
+    // 8. Connect synth → output (stereo: channels 0 and 1)
+    sGraph->addConnection({
+        {sSynthNode->nodeID, 0},
+        {sOutputNode->nodeID, 0}
+    });
+    sGraph->addConnection({
+        {sSynthNode->nodeID, 1},
+        {sOutputNode->nodeID, 1}
+    });
+
+    // 9. Create player and attach to device
+    sPlayer = new GraphPlayer();
+    sPlayer->setProcessor(sGraph.get());
+    sDeviceManager->addAudioCallback(sPlayer);
+
+    self.isReady = true;
+    NSLog(@"[BeeperAudioEngine] JUCE audio stack initialized (sr=%.0f, buf=%d)",
+          sDeviceManager->getAudioDeviceSetup().sampleRate,
+          sDeviceManager->getAudioDeviceSetup().bufferSize);
+}
+
+- (void)shutdown {
+    NSAssert([NSThread isMainThread], @"shutdown() must be called on main thread");
+
+    if (!self.isReady) return;
+
+    NSLog(@"[BeeperAudioEngine] Shutting down...");
+
+    [self stopBeatTimer];
+
+    if (sSynth) {
+        sSynth->allNotesOff();
+    }
+
+    if (sDeviceManager && sPlayer) {
+        sDeviceManager->removeAudioCallback(sPlayer);
+    }
+
+    if (sPlayer) {
+        sPlayer->setProcessor(nullptr);
+        delete sPlayer;
+        sPlayer = nullptr;
+    }
+
+    sSynthNode = nullptr;
+    sOutputNode = nullptr;
+    sSynth = nullptr;
+    sGraph.reset();
+
+    if (sDeviceManager) {
+        sDeviceManager->closeAudioDevice();
+        delete sDeviceManager;
+        sDeviceManager = nullptr;
+    }
+
+    if (sTransport) {
+        delete sTransport;
+        sTransport = nullptr;
+    }
+
+    self.isReady = false;
+    NSLog(@"[BeeperAudioEngine] Shutdown complete");
+}
+
+// ── Synth forwarding ──
+
+- (void)noteOn:(int)note velocity:(int)velocity {
+    if (!self.isReady || !sSynth) {
+        NSLog(@"[BeeperAudioEngine] noteOn ignored — engine not initialized. Call setup() first.");
+        return;
+    }
+    sSynth->noteOn(note, velocity);
+}
+
+- (void)noteOff:(int)note {
+    if (!self.isReady || !sSynth) {
+        NSLog(@"[BeeperAudioEngine] noteOff ignored — engine not initialized.");
+        return;
+    }
+    sSynth->noteOff(note);
+}
+
+- (void)allNotesOff {
+    if (!self.isReady || !sSynth) return;
+    sSynth->allNotesOff();
+}
+
+- (void)setWaveform:(NSString *)waveform {
+    if (!self.isReady || !sSynth) return;
+    if ([waveform isEqualToString:@"square"]) {
+        sSynth->setWaveform(Waveform::Square);
+    } else if ([waveform isEqualToString:@"saw"]) {
+        sSynth->setWaveform(Waveform::Saw);
+    } else if ([waveform isEqualToString:@"triangle"]) {
+        sSynth->setWaveform(Waveform::Triangle);
+    } else {
+        sSynth->setWaveform(Waveform::Sine);
+    }
+}
+
+- (void)setFilterCutoff:(double)hz {
+    if (self.isReady && sSynth) sSynth->setFilterCutoff(hz);
+}
+
+- (void)setFilterResonance:(double)q {
+    if (self.isReady && sSynth) sSynth->setFilterResonance(q);
+}
+
+- (void)setAttack:(double)ms {
+    if (self.isReady && sSynth) sSynth->setAttack(ms);
+}
+
+- (void)setDecay:(double)ms {
+    if (self.isReady && sSynth) sSynth->setDecay(ms);
+}
+
+- (void)setSustain:(double)level {
+    if (self.isReady && sSynth) sSynth->setSustain(level);
+}
+
+- (void)setRelease:(double)ms {
+    if (self.isReady && sSynth) sSynth->setRelease(ms);
+}
+
+- (void)setDetune:(double)cents {
+    if (self.isReady && sSynth) sSynth->setDetune(cents);
+}
+
+- (void)setMasterLevel:(double)level {
+    if (self.isReady && sSynth) sSynth->setMasterLevel(level);
+}
+
+// ── Transport ──
+
+- (void)startTransport {
+    if (self.isReady && sTransport) sTransport->start();
+}
+
+- (void)stopTransport {
+    if (self.isReady && sTransport) sTransport->stop();
+}
+
+- (void)setTempo:(double)bpm {
+    if (self.isReady && sTransport) sTransport->setTempo(bpm);
+}
+
+- (void)setTransportPosition:(double)beat {
+    if (self.isReady && sTransport) sTransport->setPosition(beat);
+}
+
+- (double)getTransportPosition {
+    return (self.isReady && sTransport) ? sTransport->getPosition() : 0.0;
+}
+
+- (double)getTempo {
+    return (self.isReady && sTransport) ? sTransport->getTempo() : 120.0;
+}
+
+- (BOOL)isTransportPlaying {
+    return (self.isReady && sTransport) ? sTransport->isPlaying() : NO;
+}
+
+// ── Beat events ──
+
+- (void)setBeatCallback:(BeatCallback)callback {
+    self.beatCallback = callback;
+}
+
+- (void)startBeatTimer {
+    if (self.beatTimer) return;
+    if (!sSynth) return;
+
+    self.beatTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());
+    dispatch_source_set_timer(self.beatTimer, DISPATCH_TIME_NOW, 16 * NSEC_PER_MSEC, 1 * NSEC_PER_MSEC);
+    __weak BeeperAudioEngine *weakSelf = self;
+    dispatch_source_set_event_handler(self.beatTimer, ^{
+        BeeperAudioEngine *strongSelf = weakSelf;
+        if (!strongSelf || !sSynth) return;
+        BeatCallback cb = strongSelf.beatCallback;
+        if (sSynth->beatState.crossed.exchange(false) && cb) {
+            cb(sSynth->beatState.beat.load(), sSynth->beatState.bpm.load());
+        }
+    });
+    dispatch_resume(self.beatTimer);
+}
+
+- (void)stopBeatTimer {
+    if (self.beatTimer) {
+        dispatch_source_cancel(self.beatTimer);
+        self.beatTimer = nil;
+    }
+    self.beatCallback = nil;
+}
+
+- (void)dealloc {
+    [self shutdown];
+}
+
+@end

package/ios/ExpoJuce.podspec

@@ -10,24 +10,48 @@ Pod::Spec.new do |s|
   s.license        = package['license']
   s.author         = package['author']
   s.homepage       = package['homepage']
-  s.platforms      = { :ios => '13.4', :tvos => '13.4' }
+  s.platforms      = { :ios => '13.4' }
   s.swift_version  = '5.4'
   s.source         = { git: 'https://github.com/Beeper-buzz/expo-juce' }
   s.static_framework = true
 
   s.dependency 'ExpoModulesCore'
 
-  # Our source files: Swift module, ObjC bridge, C++ tone generator, JUCE compilation unit
   s.source_files = "*.{h,m,mm,swift}"
-  s.requires_arc = true
 
-  # JUCE modules compiled: juce_core, juce_audio_basics, juce_audio_formats, juce_dsp
-  # NOT compiled: juce_events, juce_data_structures (static initializer conflicts with RN)
-  # JuceModules.mm is a single translation unit that #includes the JUCE .cpp files.
+  # Per-file ARC control: JuceModule_*.mm files compile JUCE source which uses
+  # manual retain/release. Only files listed here get ARC enabled.
+  s.requires_arc = [
+    'ExpoJuceModule.swift',
+    'ExpoJuceView.swift',
+    'ExpoJuceBridge.m',
+    'BeeperAudioEngine.mm',
+    'PolySynthProcessor.mm',
+    'Voice.mm',
+    'VoiceAllocator.mm',
+    'TransportEngine.mm',
+    'ExpoJuce-Bridging-Header.h',
+  ]
+
+  # C++ headers must be private — they include <atomic>, <algorithm>, etc.
+  # which fail when compiled as Objective-C through the module map.
+  s.private_header_files = [
+    "JuceConfig.h",
+    "Voice.h",
+    "VoiceAllocator.h",
+    "PolySynthProcessor.h",
+    "TransportEngine.h",
+  ]
+
+  # JUCE modules: each compiled as its own translation unit (separate .mm file)
+  # to avoid static symbol collisions between modules.
   s.preserve_paths = ["juce_modules/**"]
 
   s.frameworks = 'AVFoundation', 'AudioToolbox', 'CoreAudio',
-                 'Foundation', 'Accelerate', 'CoreMIDI'
+                 'Foundation', 'Accelerate', 'CoreMIDI',
+                 'CoreGraphics', 'CoreImage', 'CoreText',
+                 'QuartzCore', 'UIKit', 'WebKit', 'Metal', 'MetalKit'
+  s.weak_frameworks = 'UserNotifications'
   s.libraries = 'c++'
 
   s.pod_target_xcconfig = {
@@ -35,7 +59,6 @@ Pod::Spec.new do |s|
     'SWIFT_COMPILATION_MODE' => 'wholemodule',
     'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
     'HEADER_SEARCH_PATHS' => '"$(PODS_TARGET_SRCROOT)" "$(PODS_TARGET_SRCROOT)/juce_modules"',
-    # Suppress JUCE deprecation warnings and implicit conversion warnings in vendored code
     'GCC_WARN_ABOUT_DEPRECATED_DECLARATIONS' => 'NO',
     'OTHER_CPLUSPLUSFLAGS' => '-Wno-shorten-64-to-32 -Wno-comma -Wno-deprecated-declarations',
   }

package/ios/ExpoJuceBridge.h

@@ -11,23 +11,23 @@ typedef void(^ExpoJuceBeatBlock)(double beat, double bpm);
 + (void)startBeatTimer;
 + (void)stopBeatTimer;
 
-// ── Synth ─────────────────────────────────────────────────────────
-+ (void)playToneWithFrequency:(double)frequency duration:(double)duration;
-+ (void)setFrequency:(double)frequency;
-+ (void)setLevel:(double)level;
-+ (void)setWaveform:(NSString *)waveform;
-+ (void)setHarmonicLevels:(NSArray<NSNumber *> *)levels;
-+ (void)noteOn;
-+ (void)noteOff;
+// ── Synth (MIDI-style) ───────────────────────────────────────────
++ (void)noteOn:(int)note velocity:(int)velocity;
++ (void)noteOff:(int)note;
++ (void)allNotesOff;
 
-// ── DSP Params ────────────────────────────────────────────────────
-+ (void)setAttack:(double)ms;
-+ (void)setRelease:(double)ms;
+// ── Global Synth Params ──────────────────────────────────────────
++ (void)setWaveform:(NSString *)waveform;
 + (void)setFilterCutoff:(double)hz;
 + (void)setFilterResonance:(double)q;
++ (void)setAttack:(double)ms;
++ (void)setDecay:(double)ms;
++ (void)setSustain:(double)level;
++ (void)setRelease:(double)ms;
 + (void)setDetune:(double)cents;
++ (void)setMasterLevel:(double)level;
 
-// ── Transport ─────────────────────────────────────────────────────
+// ── Transport ────────────────────────────────────────────────────
 + (void)startTransport;
 + (void)stopTransport;
 + (void)setTempo:(double)bpm;

package/ios/ExpoJuceBridge.m

@@ -1,108 +1,43 @@
 #import "ExpoJuceBridge.h"
-#import "JuceToneGenerator.h"
+#import "BeeperAudioEngine.h"
 
 @implementation ExpoJuceBridge
 
-+ (void)setup {
-    [[JuceToneGenerator sharedInstance] initialize];
-}
-
-+ (void)shutdown {
-    [[JuceToneGenerator sharedInstance] shutdown];
-}
-
-+ (void)startBeatTimer {
-    [[JuceToneGenerator sharedInstance] startBeatTimer];
-}
-
-+ (void)stopBeatTimer {
-    [[JuceToneGenerator sharedInstance] stopBeatTimer];
-}
-
-// ── Synth ─────────────────────────────────────────────────────────
-
-+ (void)playToneWithFrequency:(double)frequency duration:(double)duration {
-    [[JuceToneGenerator sharedInstance] playToneWithFrequency:frequency duration:duration];
-}
-
-+ (void)setFrequency:(double)frequency {
-    [[JuceToneGenerator sharedInstance] setFrequency:frequency];
-}
-
-+ (void)setLevel:(double)level {
-    [[JuceToneGenerator sharedInstance] setLevel:level];
-}
-
-+ (void)setWaveform:(NSString *)waveform {
-    [[JuceToneGenerator sharedInstance] setWaveform:waveform];
-}
-
-+ (void)setHarmonicLevels:(NSArray<NSNumber *> *)levels {
-    [[JuceToneGenerator sharedInstance] setHarmonicLevels:levels];
-}
-
-+ (void)noteOn {
-    [[JuceToneGenerator sharedInstance] noteOn];
-}
-
-+ (void)noteOff {
-    [[JuceToneGenerator sharedInstance] noteOff];
-}
-
-// ── DSP Params ────────────────────────────────────────────────────
-
-+ (void)setAttack:(double)ms {
-    [[JuceToneGenerator sharedInstance] setAttack:ms];
-}
-
-+ (void)setRelease:(double)ms {
-    [[JuceToneGenerator sharedInstance] setRelease:ms];
-}
-
-+ (void)setFilterCutoff:(double)hz {
-    [[JuceToneGenerator sharedInstance] setFilterCutoff:hz];
-}
-
-+ (void)setFilterResonance:(double)q {
-    [[JuceToneGenerator sharedInstance] setFilterResonance:q];
-}
-
-+ (void)setDetune:(double)cents {
-    [[JuceToneGenerator sharedInstance] setDetune:cents];
-}
-
-// ── Transport ─────────────────────────────────────────────────────
-
-+ (void)startTransport {
-    [[JuceToneGenerator sharedInstance] startTransport];
-}
-
-+ (void)stopTransport {
-    [[JuceToneGenerator sharedInstance] stopTransport];
-}
-
-+ (void)setTempo:(double)bpm {
-    [[JuceToneGenerator sharedInstance] setTempo:bpm];
-}
-
-+ (void)setTransportPosition:(double)beat {
-    [[JuceToneGenerator sharedInstance] setTransportPosition:beat];
-}
-
-+ (double)getTransportPosition {
-    return [[JuceToneGenerator sharedInstance] getTransportPosition];
-}
-
-+ (double)getTempo {
-    return [[JuceToneGenerator sharedInstance] getTempo];
-}
-
-+ (BOOL)isTransportPlaying {
-    return [[JuceToneGenerator sharedInstance] isTransportPlaying];
-}
-
++ (void)setup { [[BeeperAudioEngine sharedInstance] setup]; }
++ (void)shutdown { [[BeeperAudioEngine sharedInstance] shutdown]; }
++ (void)startBeatTimer { [[BeeperAudioEngine sharedInstance] startBeatTimer]; }
++ (void)stopBeatTimer { [[BeeperAudioEngine sharedInstance] stopBeatTimer]; }
+
+// ── Synth ──
++ (void)noteOn:(int)note velocity:(int)velocity {
+    [[BeeperAudioEngine sharedInstance] noteOn:note velocity:velocity];
+}
++ (void)noteOff:(int)note {
+    [[BeeperAudioEngine sharedInstance] noteOff:note];
+}
++ (void)allNotesOff { [[BeeperAudioEngine sharedInstance] allNotesOff]; }
+
+// ── Global Params ──
++ (void)setWaveform:(NSString *)waveform { [[BeeperAudioEngine sharedInstance] setWaveform:waveform]; }
++ (void)setFilterCutoff:(double)hz { [[BeeperAudioEngine sharedInstance] setFilterCutoff:hz]; }
++ (void)setFilterResonance:(double)q { [[BeeperAudioEngine sharedInstance] setFilterResonance:q]; }
++ (void)setAttack:(double)ms { [[BeeperAudioEngine sharedInstance] setAttack:ms]; }
++ (void)setDecay:(double)ms { [[BeeperAudioEngine sharedInstance] setDecay:ms]; }
++ (void)setSustain:(double)level { [[BeeperAudioEngine sharedInstance] setSustain:level]; }
++ (void)setRelease:(double)ms { [[BeeperAudioEngine sharedInstance] setRelease:ms]; }
++ (void)setDetune:(double)cents { [[BeeperAudioEngine sharedInstance] setDetune:cents]; }
++ (void)setMasterLevel:(double)level { [[BeeperAudioEngine sharedInstance] setMasterLevel:level]; }
+
+// ── Transport ──
++ (void)startTransport { [[BeeperAudioEngine sharedInstance] startTransport]; }
++ (void)stopTransport { [[BeeperAudioEngine sharedInstance] stopTransport]; }
++ (void)setTempo:(double)bpm { [[BeeperAudioEngine sharedInstance] setTempo:bpm]; }
++ (void)setTransportPosition:(double)beat { [[BeeperAudioEngine sharedInstance] setTransportPosition:beat]; }
++ (double)getTransportPosition { return [[BeeperAudioEngine sharedInstance] getTransportPosition]; }
++ (double)getTempo { return [[BeeperAudioEngine sharedInstance] getTempo]; }
++ (BOOL)isTransportPlaying { return [[BeeperAudioEngine sharedInstance] isTransportPlaying]; }
 + (void)setBeatCallback:(ExpoJuceBeatBlock)callback {
-    [[JuceToneGenerator sharedInstance] setBeatCallback:callback];
+    [[BeeperAudioEngine sharedInstance] setBeatCallback:callback];
 }
 
 @end