cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/ca-qt.cpp

@@ -0,0 +1,424 @@
+/************************************************************************
+ IMPORTANT NOTE : this file contains two clearly delimited sections :
+ the ARCHITECTURE section (in two parts) and the USER section. Each section
+ is governed by its own copyright and license. Please check individually
+ each section for license and copyright information.
+ *************************************************************************/
+
+/******************* BEGIN ca-qt.cpp ****************/
+
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2003-2019 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This Architecture section is free software; you can redistribute it
+ and/or modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 3 of
+ the License, or (at your option) any later version.
+ 
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with this program; If not, see <http://www.gnu.org/licenses/>.
+ 
+ EXCEPTION : As a special exception, you may create a larger work
+ that contains this FAUST architecture section and distribute
+ that work under terms of your choice, so long as this FAUST
+ architecture section is not modified.
+ 
+ ************************************************************************
+ ************************************************************************/
+
+#include <libgen.h>
+#include <stdlib.h>
+#include <iostream>
+#include <string>
+#include <list>
+
+#include "faust/dsp/proxy-dsp.h"
+#include "faust/dsp/timed-dsp.h"
+#include "faust/dsp/dsp-adapter.h"
+#include "faust/gui/FUI.h"
+#include "faust/gui/JSONUI.h"
+#include "faust/gui/PresetUI.h"
+#include "faust/gui/QTUI.h"
+#include "faust/audio/audio.h"
+#include "faust/misc.h"
+
+#ifdef IOS
+#include "faust/gui/APIUI.h"
+#include "faust/audio/coreaudio-ios-dsp.h"
+#else
+#include "faust/audio/coreaudio-dsp.h"
+#endif
+
+#ifdef OSCCTRL
+#include "faust/gui/OSCUI.h"
+static void osc_compute_callback(void* arg)
+{
+    static_cast<OSCUI*>(arg)->endBundle();
+}
+#endif
+
+#ifdef HTTPCTRL
+#include "faust/gui/httpdUI.h"
+#endif
+
+#ifdef SOUNDFILE
+#include "faust/gui/SoundUI.h"
+#endif
+
+// Always include this file, otherwise -nvoices only mode does not compile....
+#include "faust/gui/MidiUI.h"
+
+#ifdef MIDICTRL
+#include "faust/midi/rt-midi.h"
+#include "faust/midi/RtMidi.cpp"
+#endif
+
+#define stringify_literal(x) #x
+#define stringify_expanded(x) stringify_literal(x)
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ VECTOR INTRINSICS
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+<<includeIntrinsic>>
+
+/********************END ARCHITECTURE SECTION (part 1/2)****************/
+
+/**************************BEGIN USER SECTION **************************/
+
+<<includeclass>>
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+
+#include "faust/dsp/poly-dsp.h"
+
+#ifdef POLY2
+#include "faust/dsp/dsp-combiner.h"
+#include "effect.h"
+#endif
+
+using namespace std;
+
+dsp* DSP;
+
+list<GUI*> GUI::fGuiList;
+ztimedmap GUI::gTimedZoneMap;
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ Sensors section
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+#ifdef IOS
+#include <QAccelerometer>
+#include <QGyroscope>
+#include <QAccelerometerReading>
+#include <QGyroscopeReading>
+#include <QTimer>
+
+//------------------------------------------------------------------------
+class Sensor
+{
+    private:
+        
+        QSensor* fSensor;
+        int fType;
+        QSensorReading* fReader;
+        QSensor* create(int type) const;
+        
+    public:
+        enum { kSensorStart = 1, kAccelerometer = 1, kGyroscope, kSensorMax };
+        
+        Sensor(int type) : fSensor(0), fType(type), fReader(0)
+        { fSensor = create (type); fSensor->connectToBackend(); }
+        virtual ~Sensor() { if (available()) activate (false); delete fSensor; }
+        
+        int isAccel() const { return fType == kAccelerometer; }
+        int isGyro () const { return fType == kGyroscope; }
+        bool available() const { return fSensor->isConnectedToBackend(); }
+        bool active() const { return fSensor->isActive(); }
+        void activate(bool state){ fSensor->setActive(state); fReader = fSensor->reading(); }
+        int count() { return fReader ? fReader->valueCount() : 0; }
+        float value(int i) const { return fReader->value(i).value<float>(); }
+};
+
+//------------------------------------------------------------------------
+QSensor* Sensor::create(int type) const
+{
+    switch (type) {
+        case kAccelerometer: return new QAccelerometer();
+        case kGyroscope: return new QGyroscope();
+        default: cerr << "unknown sensor type " << type << endl;
+    }
+    return 0;
+}
+
+//------------------------------------------------------------------------
+class Sensors : public QObject
+{
+    private:
+        
+        APIUI* fUI;
+        Sensor fAccel, fGyro;
+        int fTimerID;
+        
+    public:
+        
+        typedef map<int, Sensor*> TSensors;
+        Sensors(APIUI* ui)
+        : fUI(ui), fAccel(Sensor::kAccelerometer), fGyro(Sensor::kGyroscope), fTimerID(0) {}
+        virtual ~Sensors() { killTimer(fTimerID); }
+        void start();
+        
+    protected:
+        
+        void timerEvent(QTimerEvent*);
+};
+
+//------------------------------------------------------------------------
+void Sensors::timerEvent(QTimerEvent*)
+{
+    if (fAccel.active()) {
+        int count = fAccel.count();
+        for (int i = 0; (i< count) && (i < 3); i++) {
+            fUI->propagateAcc(i, fAccel.value(i));
+        }
+    }
+    if (fGyro.active()) {
+        int count = fGyro.count();
+        for (int i = 0; (i< count) && (i < 3); i++) {
+            fUI->propagateGyr(i, fGyro.value(i));
+        }
+    }
+}
+
+//------------------------------------------------------------------------
+void Sensors::start()
+{
+    bool activate = false;
+    if (fAccel.available()) { fAccel.activate(true); activate = true; }
+    if (fGyro.available()) { fGyro.activate(true); activate = true; }
+    if (activate) fTimerID = startTimer(10);
+}
+#endif
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ MAIN PLAY THREAD
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+#ifdef IOS
+#define lopt(a,b,val)	val
+#define coreaudio		iosaudio
+#endif
+
+int main(int argc, char* argv[])
+{
+    char name[256];
+    char rcfilename[256];
+    char* home = getenv("HOME");
+    bool midi_sync = false;
+    int nvoices = 0;
+    bool control = true;
+    
+    if (isopt(argv, "-help") || isopt(argv, "-h")) {
+        cout << argv[0] << " [--frequency <val>] [--buffer <val>] [--nvoices <val>] [--control <0/1>] [--group <0/1>] [--virtual-midi <0/1>]\n";
+        exit(1);
+    }
+    
+    mydsp* tmp_dsp = new mydsp();
+    MidiMeta::analyse(tmp_dsp, midi_sync, nvoices);
+    delete tmp_dsp;
+    
+#ifdef IOS
+    APIUI apiui;
+    Sensors sensors(&apiui);
+#endif
+    
+    snprintf(name, 256, "%s", basename(argv[0]));
+    snprintf(rcfilename, 256, "%s/.%src", home, name);
+     
+    long srate = (long)lopt(argv, "--frequency", -1);
+    int fpb = lopt(argv, "--buffer", 512);
+    bool is_virtual = lopt(argv, "--virtual-midi", false);
+    
+#ifdef POLY2
+    nvoices = lopt(argv, "--nvoices", nvoices);
+    control = lopt(argv, "--control", control);
+    int group = lopt(argv, "--group", 1);
+    
+    cout << "Started with " << nvoices << " voices\n";
+    DSP = new mydsp_poly(new mydsp(), nvoices, control, group);
+    
+#if MIDICTRL
+    if (midi_sync) {
+        DSP = new timed_dsp(new dsp_sequencer(DSP, new effect()));
+    } else {
+        DSP = new dsp_sequencer(DSP, new effect());
+    }
+#else
+    DSP = new dsp_sequencer(DSP, new effect());
+#endif
+    
+#else
+    nvoices = lopt(argv, "--nvoices", nvoices);
+    control = lopt(argv, "--control", control);
+    int group = lopt(argv, "--group", 1);
+    
+    if (nvoices > 0) {
+        cout << "Started with " << nvoices << " voices\n";
+        DSP = new mydsp_poly(new mydsp(), nvoices, control, group);
+        
+#if MIDICTRL
+        if (midi_sync) {
+            DSP = new timed_dsp(DSP);
+        }
+#endif
+        
+    } else {
+#if MIDICTRL
+        if (midi_sync) {
+            DSP = new timed_dsp(new mydsp());
+        } else {
+            DSP = new mydsp();
+        }
+#else
+        // We possibly have a file...
+        /*
+         try {
+            DSP = new dsp_sequencer(new sound_player(stringify_expanded(SOUND_FILE)), new mydsp());
+         } catch (...) {
+            DSP = new mydsp();
+         }
+         */
+        DSP = new mydsp();
+#endif
+    }
+    
+#endif
+    
+    if (!DSP) {
+        cerr << "Unable to allocate Faust DSP object" << endl;
+        exit(1);
+    }
+    
+    QApplication myApp(argc, argv);
+    
+    QTGUI* interface = new QTGUI();
+    FUI finterface;
+    
+#ifdef PRESETUI
+    PresetUI pinterface(interface, string(PRESETDIR) + string(name) + ((nvoices > 0) ? "_poly" : ""));
+    DSP->buildUserInterface(&pinterface);
+#else
+    DSP->buildUserInterface(interface);
+    DSP->buildUserInterface(&finterface);
+#endif
+    
+#ifdef IOS
+    DSP->buildUserInterface(&apiui);
+#endif
+    
+#ifdef MIDICTRL
+    rt_midi midi_handler(name, is_virtual);
+    MidiUI midiinterface(&midi_handler);
+    DSP->buildUserInterface(&midiinterface);
+    cout << "MIDI is on" << endl;
+#endif
+    
+#ifdef HTTPCTRL
+    httpdUI httpdinterface(name, DSP->getNumInputs(), DSP->getNumOutputs(), argc, argv);
+    DSP->buildUserInterface(&httpdinterface);
+    cout << "HTTPD is on" << endl;
+#endif
+    
+    coreaudio audio(srate, fpb);
+    if (!audio.init(name, DSP)) {
+        cerr << "Unable to init audio" << endl;
+        exit(1);
+    }
+   
+// After audio init to get SR
+#ifdef SOUNDFILE
+    // Use bundle path
+    SoundUI soundinterface(SoundUI::getBinaryPath() + "/Contents/Resources/", audio.getSampleRate());
+    DSP->buildUserInterface(&soundinterface);
+#endif
+    
+#ifdef IOS
+    sensors.start();
+#endif
+    
+#ifdef OSCCTRL
+    OSCUI oscinterface(name, argc, argv);
+    DSP->buildUserInterface(&oscinterface);
+    cout << "OSC is on" << endl;
+    audio.addControlCallback(osc_compute_callback, &oscinterface);
+#endif
+    
+    if (!audio.start()) {
+        cerr << "Unable to start audio" << endl;
+        exit(1);
+    }
+    
+    cout << "ins " << audio.getNumInputs() << endl;
+    cout << "outs " << audio.getNumOutputs() << endl;
+    
+#ifdef HTTPCTRL
+    httpdinterface.run();
+#ifdef QRCODECTRL
+    interface->displayQRCode(httpdinterface.getTCPPort());
+#endif
+#endif
+    
+#ifdef OSCCTRL
+    oscinterface.run();
+#endif
+    
+#ifdef MIDICTRL
+    if (!midiinterface.run()) {
+        cerr << "MidiUI run error " << endl;
+    }
+#endif
+    
+    // After the allocation of controllers
+    finterface.recallState(rcfilename);
+ 
+    interface->run();
+    
+    myApp.setStyleSheet(interface->styleSheet());
+    myApp.exec();
+    
+#ifdef MIDICTRL
+    midiinterface.stop();
+#endif
+    interface->stop();
+    
+    audio.stop();
+    finterface.saveState(rcfilename);
+    
+    delete DSP;
+    
+    return 0;
+}
+
+/******************** END ca-qt.cpp ****************/
+

cyfaust/resources/architecture/cpal.rs

@@ -0,0 +1,195 @@
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2003-2019 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This Architecture section is free software; you can redistribute it
+ and/or modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 3 of
+ the License, or (at your option) any later version.
+ 
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with this program; If not, see <http://www.gnu.org/licenses/>.
+ 
+ EXCEPTION : As a special exception, you may create a larger work
+ that contains this FAUST architecture section and distribute
+ that work under terms of your choice, so long as this FAUST
+ architecture section is not modified.
+ 
+ ************************************************************************
+ ************************************************************************/
+
+#![allow(unused_parens)]
+#![allow(non_snake_case)]
+#![allow(non_camel_case_types)]
+#![allow(dead_code)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(non_upper_case_globals)]
+
+//! Faust CPAL architecture file
+extern crate anyhow;
+extern crate cpal;
+use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
+use std::io;
+extern crate libm;
+
+type F32 = f32;
+type F64 = f64;
+
+#[derive(Copy, Clone)]
+pub struct ParamIndex(pub i32);
+
+pub struct Soundfile<'a,T> {
+    fBuffers: &'a&'a T,
+    fLength: &'a i32,
+    fSR: &'a i32,
+    fOffset: &'a i32,
+    fChannels: i32
+}
+
+pub trait FaustDsp {
+    type T;
+
+    fn new() -> Self where Self: Sized;
+    fn metadata(&self, m: &mut dyn Meta);
+    fn get_sample_rate(&self) -> i32;
+    fn get_num_inputs(&self) -> i32;
+    fn get_num_outputs(&self) -> i32;
+    fn class_init(sample_rate: i32) where Self: Sized;
+    fn instance_reset_params(&mut self);
+    fn instance_clear(&mut self);
+    fn instance_constants(&mut self, sample_rate: i32);
+    fn instance_init(&mut self, sample_rate: i32);
+    fn init(&mut self, sample_rate: i32);
+    fn build_user_interface(&self, ui_interface: &mut dyn UI<Self::T>);
+    fn build_user_interface_static(ui_interface: &mut dyn UI<Self::T>) where Self: Sized;
+    fn get_param(&self, param: ParamIndex) -> Option<Self::T>;
+    fn set_param(&mut self, param: ParamIndex, value: Self::T);
+    fn compute(&mut self, count: i32, inputs: &[&[Self::T]], outputs: &mut[&mut[Self::T]]);
+}
+
+pub trait Meta {
+    // -- metadata declarations
+    fn declare(&mut self, key: &str, value: &str);
+}
+
+pub trait UI<T> {
+    // -- widget's layouts
+    fn open_tab_box(&mut self, label: &str);
+    fn open_horizontal_box(&mut self, label: &str);
+    fn open_vertical_box(&mut self, label: &str);
+    fn close_box(&mut self);
+
+    // -- active widgets
+    fn add_button(&mut self, label: &str, param: ParamIndex);
+    fn add_check_button(&mut self, label: &str, param: ParamIndex);
+    fn add_vertical_slider(&mut self, label: &str, param: ParamIndex, init: T, min: T, max: T, step: T);
+    fn add_horizontal_slider(&mut self, label: &str, param: ParamIndex, init: T, min: T, max: T, step: T);
+    fn add_num_entry(&mut self, label: &str, param: ParamIndex, init: T, min: T, max: T, step: T);
+
+    // -- passive widgets
+    fn add_horizontal_bargraph(&mut self, label: &str, param: ParamIndex, min: T, max: T);
+    fn add_vertical_bargraph(&mut self, label: &str, param: ParamIndex, min: T, max: T);
+
+    // -- metadata declarations
+    fn declare(&mut self, param: Option<ParamIndex>, key: &str, value: &str);
+}
+
+<<includeIntrinsic>>
+<<includeclass>>
+
+fn main() -> Result<(), anyhow::Error> {
+
+    // Allocation DSP on the heap
+    let mut dsp;
+    #[cfg(feature = "default-boxed")]
+    {
+        use default_boxed::DefaultBoxed;
+        dsp = mydsp::default_boxed();
+    }
+
+    #[cfg(not(feature = "default-boxed"))]
+    {
+        dsp = Box::new(mydsp::new());
+    }
+
+    println!("get_num_inputs: {}", dsp.get_num_inputs());
+    println!("get_num_outputs: {}", dsp.get_num_outputs());
+
+    //println!("Faust Rust code running with CPAL: sample-rate = {} buffer-size = {}", client.sample_rate(), client.buffer_size());
+
+    println!("Supported hosts:\n  {:?}", cpal::ALL_HOSTS);
+    let available_hosts = cpal::available_hosts();
+    println!("Available hosts:\n  {:?}", available_hosts);
+
+    for host_id in available_hosts {
+        println!("{}", host_id.name());
+        let host = cpal::host_from_id(host_id)?;
+
+        let default_in = host.default_input_device().map(|e| e.name().unwrap());
+        let default_out = host.default_output_device().map(|e| e.name().unwrap());
+        println!("  Default Input Device:\n    {:?}", default_in);
+        println!("  Default Output Device:\n    {:?}", default_out);
+
+        /*
+        let devices = host.devices()?;
+        println!("  Devices: ");
+        for (device_index, device) in devices.enumerate() {
+            println!("  {}. \"{}\"", device_index + 1, device.name()?);
+
+            // Input configs
+            if let Ok(conf) = device.default_input_config() {
+                println!("    Default input stream config:\n      {:?}", conf);
+            }
+            let input_configs = match device.supported_input_configs() {
+                Ok(f) => f.collect(),
+                Err(e) => {
+                    println!("    Error getting supported input configs: {:?}", e);
+                    Vec::new()
+                }
+            };
+            if !input_configs.is_empty() {
+                println!("    All supported input stream configs:");
+                for (config_index, config) in input_configs.into_iter().enumerate() {
+                    println!(
+                        "      {}.{}. {:?}",
+                        device_index + 1,
+                        config_index + 1,
+                        config
+                    );
+                }
+            }
+
+            // Output configs
+            if let Ok(conf) = device.default_output_config() {
+                println!("    Default output stream config:\n      {:?}", conf);
+            }
+            let output_configs = match device.supported_output_configs() {
+                Ok(f) => f.collect(),
+                Err(e) => {
+                    println!("    Error getting supported output configs: {:?}", e);
+                    Vec::new()
+                }
+            };
+            if !output_configs.is_empty() {
+                println!("    All supported output stream configs:");
+                for (config_index, config) in output_configs.into_iter().enumerate() {
+                    println!(
+                        "      {}.{}. {:?}",
+                        device_index + 1,
+                        config_index + 1,
+                        config
+                    );
+                }
+            }
+        }
+        */
+    }
+
+    Ok(())
+}