cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/pa-qt.cpp

@@ -0,0 +1,261 @@
+/************************************************************************
+ 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 pa-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 <iostream>
+
+#include "faust/dsp/timed-dsp.h"
+#include "faust/gui/PathBuilder.h"
+#include "faust/gui/FUI.h"
+#include "faust/gui/JSONUI.h"
+#include "faust/gui/QTUI.h"
+#include "faust/misc.h"
+#include "faust/audio/portaudio-dsp.h"
+
+#ifdef OSCCTRL
+#include "faust/gui/OSCUI.h"
+#endif
+
+#ifdef HTTPCTRL
+#include "faust/gui/httpdUI.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
+
+using namespace std;
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ 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
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+
+dsp* DSP;
+
+list<GUI*> GUI::fGuiList;
+ztimedmap GUI::gTimedZoneMap;
+
+/******************************************************************************
+*******************************************************************************
+
+                                MAIN PLAY THREAD
+
+*******************************************************************************
+*******************************************************************************/
+
+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;
+    
+    mydsp* tmp_dsp = new mydsp();
+    MidiMeta::analyse(tmp_dsp, midi_sync, nvoices);
+    delete tmp_dsp;
+
+    snprintf(name, 256, "%s", basename(argv[0]));
+    snprintf(rcfilename, 256, "%s/.%src", home, name);
+    
+    if (isopt(argv, "-h")) {
+        cout << argv[0] << " [--frequency <val>] [--buffer <val>] [--nvoices <num>] [--control <0/1>] [--group <0/1>] [--virtual-midi <0/1>]\n";
+        exit(1);
+    }
+
+    long srate = (long)lopt(argv, "--frequency", 44100);
+    int fpb = lopt(argv, "--buffer", 128);
+    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);
+    cout << "nvoices  " << nvoices << " voices\n";
+    
+    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	= new FUI();
+    DSP->buildUserInterface(interface);
+    DSP->buildUserInterface(finterface);
+
+#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
+
+#ifdef OSCCTRL
+    GUI* oscinterface = new OSCUI(name, argc, argv);
+    DSP->buildUserInterface(oscinterface);
+#endif
+
+    portaudio audio(srate, fpb);
+    if (!audio.init(name, DSP)) {
+        cerr << "Unable to init audio" << endl;
+        exit(1);
+    }
+    finterface->recallState(rcfilename);
+    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\n";
+    }
+#endif
+    interface->run();
+
+    myApp.setStyleSheet(interface->styleSheet());
+    myApp.exec();
+    interface->stop();
+
+#ifdef MIDICTRL
+    midiinterface.stop();
+#endif
+
+    audio.stop();
+    finterface->saveState(rcfilename);
+    return 0;
+}
+
+/******************* END pa-qt.cpp ****************/

cyfaust/resources/architecture/path-printer.cpp

@@ -0,0 +1,100 @@
+/************************************************************************
+ 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 path-printer.cpp ****************/
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2003-2021 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 <cmath>
+#include <cstring>
+
+#include "faust/misc.h"
+#include "faust/dsp/dsp.h"
+#include "faust/gui/meta.h"
+#include "faust/gui/DecoratorUI.h"
+#include "faust/gui/JSONUIDecoder.h"
+
+#ifdef SOUNDFILE
+#include "faust/gui/SoundUI.h"
+#endif
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ 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/faust-poly-engine.h"
+#include "faust/audio/dummy-audio.h"
+
+std::list<GUI*> GUI::fGuiList;
+ztimedmap GUI::gTimedZoneMap;
+
+int main(int argc, char* argv[])
+{
+    FaustPolyEngine fPolyEngine(new mydsp(), new dummyaudio());
+
+    std::cout << "## Parameters List\n\n";
+    std::cout << "### Main Parameters\n\n";
+    for(int i = 0; i < fPolyEngine.getParamsCount(); i++) {
+        std::cout << "* **" << i << "**: `" << fPolyEngine.getParamAddress(i) << "`" << "\n";
+    }
+    std::cout << "\n";
+
+    #if POLY_VOICES
+    // kind of funny, but it's the fastest way
+    MapUI* idpVoice = fPolyEngine.keyOn(100,100);
+
+    std::cout << "### Independent Voice" << "\n\n";
+    for(int i = 0; i < idpVoice->getParamsCount(); i++) {
+        std::cout << "* **" << i << "**: `" << idpVoice->getParamAddress(i) << "`" << "\n";
+    }
+
+    fPolyEngine.keyOff(100); // just to be really clean...
+    #endif
+
+    return 0;
+}
+
+/******************* END path-printer.cpp ****************/
+

cyfaust/resources/architecture/plot.cpp

@@ -0,0 +1,128 @@
+/************************************************************************
+ 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 plot.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 <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <math.h>
+#include <errno.h>
+#include <time.h>
+#include <ctype.h>
+#include <string>
+#include <iostream>
+#include <limits> 
+#include <iomanip>
+
+#include "faust/gui/console.h"
+#include "faust/dsp/dsp.h"
+#include "faust/misc.h"
+#include "faust/audio/channels.h"
+
+using namespace std;
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ VECTOR INTRINSICS
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+<<includeIntrinsic>>
+
+/********************END ARCHITECTURE SECTION (part 1/2)****************/
+
+/**************************BEGIN USER SECTION **************************/
+
+<<includeclass>>
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+					
+mydsp DSP;
+
+std::list<GUI*> GUI::fGuiList;
+ztimedmap GUI::gTimedZoneMap;
+
+#define kFrames 512
+	
+int main(int argc, char* argv[])
+{
+    FAUSTFLOAT fnbsamples;
+
+    CMDUI* interface = new CMDUI(argc, argv);
+    DSP.buildUserInterface(interface);
+    interface->addOption("-n", &fnbsamples, 16, 0.0, 100000000.0);
+
+    if (DSP.getNumInputs() > 0) {
+        fprintf(stderr, "no inputs allowed\n");
+        exit(1);
+    }
+    
+    // init signal processor and the user interface values
+    DSP.init(44100);
+
+    // modify the UI values according to the command line options
+    interface->process_command();
+
+    int nouts = DSP.getNumOutputs();
+    channels chan(kFrames, nouts);
+  
+    int nbsamples = int(fnbsamples);
+    cout << setprecision(numeric_limits<FAUSTFLOAT>::max_digits10);
+    while (nbsamples > kFrames) {
+        DSP.compute(kFrames, 0, chan.buffers());
+        for (int i = 0; i < kFrames; i++) {
+            for (int c = 0; c < nouts; c++) {
+                if (c) cout << "\t\t";
+                cout << chan.buffers()[c][i];
+            }
+            cout << endl;
+        }
+        nbsamples -= kFrames;
+    }
+
+    DSP.compute(nbsamples, 0, chan.buffers());
+    for (int i = 0; i < nbsamples; i++) {
+        for (int c = 0; c < nouts; c++) {
+            if (c) cout << "\t\t";
+            cout << chan.buffers()[c][i];
+        }
+        cout << endl;
+    }
+    return 0;
+}
+
+/******************* END plot.cpp ****************/

cyfaust/resources/architecture/portaudio.rs

@@ -0,0 +1,192 @@
+/************************************************************************
+ 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)]
+
+//! PortAudio architecture file
+extern crate portaudio;
+use portaudio as pa;
+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>>
+
+const CHANNELS: i32 = 2;
+const SAMPLE_RATE: f64 = 44_100.0;
+const FRAMES_PER_BUFFER: u32 = 64;
+
+fn main() {
+    run().unwrap()
+}
+
+fn run() -> Result<(), pa::Error> {
+
+    let pa = pa::PortAudio::new()?;
+
+    // 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!("Faust Rust code running with Portaudio: sample-rate = {} buffer-size = {}", SAMPLE_RATE, FRAMES_PER_BUFFER);
+
+    //Create a input/output stream with the same number of input and output channels
+    const INTERLEAVED: bool = false;// We want NON interleaved streams
+    let input_device = pa.default_input_device()?;
+    let output_device = pa.default_output_device()?;
+    let input_latency = pa.device_info(input_device)?.default_low_input_latency;
+    let output_latency = pa.device_info(output_device)?.default_low_input_latency;
+
+    let in_params = pa::StreamParameters::new(input_device, CHANNELS, INTERLEAVED, input_latency);
+    let out_params = pa::StreamParameters::new(output_device, CHANNELS, INTERLEAVED, output_latency);
+    let settings = pa::DuplexStreamSettings::new(in_params, out_params, SAMPLE_RATE, FRAMES_PER_BUFFER);
+    //This would have been interleaved:
+    //let mut settings = try!(pa.default_duplex_stream_settings(CHANNELS, CHANNELS, SAMPLE_RATE, FRAMES_PER_BUFFER));
+
+    println!("get_num_inputs: {}", dsp.get_num_inputs());
+    println!("get_num_outputs: {}", dsp.get_num_outputs());
+
+    // Init DSP with a given SR
+    dsp.init(SAMPLE_RATE as i32);
+
+    //settings.flags = pa::stream_flags::CLIP_OFF;
+
+    // This routine will be called by the PortAudio engine when audio is needed. It may called at
+    // interrupt level on some machines so don't do anything that could mess up the system like
+    // dynamic resource allocation or IO.
+    let callback = move |pa::DuplexStreamCallbackArgs { in_buffer, out_buffer, frames, time, .. } : pa::DuplexStreamCallbackArgs<f32, f32>| {
+        let out_buffr: &mut [*mut f32];
+        let in_buffr: & [*const f32];
+        //rust-portaudio does not support non-interleaved audio out of the box (but portaudio does)
+        unsafe {
+            let out_buffer: *mut *mut f32 = ::std::mem::transmute(out_buffer.get_unchecked_mut(0));
+            out_buffr = ::std::slice::from_raw_parts_mut(out_buffer, CHANNELS as usize);
+            let output0 = ::std::slice::from_raw_parts_mut(out_buffr[0], frames);
+            let output1 = ::std::slice::from_raw_parts_mut(out_buffr[1], frames);
+
+            let in_buffer: *const *const f32 = ::std::mem::transmute(in_buffer.get_unchecked(0));
+            in_buffr = ::std::slice::from_raw_parts(in_buffer, CHANNELS as usize);
+            let input0 = ::std::slice::from_raw_parts(in_buffr[0], frames);
+            let input1 = ::std::slice::from_raw_parts(in_buffr[1], frames);
+
+            let inputs = &[input0, input1];
+            let outputs = &mut [output0, output1];
+
+            dsp.compute(frames as i32, inputs, outputs);
+        }
+        pa::Continue
+    };
+
+    let mut stream = pa.open_non_blocking_stream(settings, callback)?;
+
+    stream.start()?;
+
+    // Wait for user input to quit
+    println!("Press enter/return to quit...");
+    let mut user_input = String::new();
+    io::stdin().read_line(&mut user_input).ok();
+
+    stream.stop()?;
+    stream.close()?;
+
+    Ok(())
+}