cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/jack-qt-chain-header.cpp

@@ -0,0 +1,92 @@
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2003-2017 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 <vector>
+#include <utility>
+#include <string>
+#include <libgen.h>
+
+#include "faust/dsp/dsp.h"
+#include "faust/gui/GUI.h"
+#include "faust/audio/jack-dsp.h"
+#include "faust/misc.h"
+#include "faust/gui/QTUI.h"
+#include "faust/gui/FUI.h"
+
+#ifdef OSCCTRL
+#include "faust/gui/OSCUI.h"
+#endif
+
+#ifdef HTTPCTRL
+#include "faust/gui/httpdUI.h"
+#endif
+
+// DSP chain
+std::vector< std::pair<std::string, dsp*> > dsp_chain;
+
+// Combine UIs
+static void combineUI(const std::vector< std::pair<std::string, dsp*> >& chain, UI* interface)
+{
+    interface->openTabBox("Chain");
+    for (int i = 0; i < chain.size(); i++) {
+        chain[i].second->buildUserInterface(interface);
+    }
+    interface->closeBox();
+}
+
+// Create and init JACK clients
+static std::vector<audio*> initJACKClients(const std::vector< std::pair<std::string, dsp*> >& chain)
+{
+    std::vector<audio*> res;
+    
+    for (int i = 0; i < chain.size(); i++) {
+        jackaudio* audio = new jackaudio();
+        audio->init(chain[i].first.c_str(), chain[i].second);
+        res.push_back(audio);
+    }
+    
+    return res;
+}
+
+// Start JACK clients
+static void startJACKClients(std::vector<audio*> chain)
+{
+    for (int i = 0; i < chain.size(); i++) {
+        chain[i]->start();
+    }
+}
+
+// Close and delete JACK clients
+static void stopJACKClients(const std::vector<audio*>& chain)
+{
+    for (int i = 0; i < chain.size(); i++) {
+        chain[i]->stop();
+        delete chain[i];
+    }
+}
+
+// Globals
+std::list<GUI*> GUI::fGuiList;
+ztimedmap GUI::gTimedZoneMap;
+
+

cyfaust/resources/architecture/jack-qt.cpp

@@ -0,0 +1,281 @@
+/************************************************************************
+ 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 jack-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 <list>
+
+#include "faust/dsp/timed-dsp.h"
+#include "faust/gui/FUI.h"
+#include "faust/gui/JSONUI.h"
+#include "faust/gui/PresetUI.h"
+#include "faust/misc.h"
+#include "faust/gui/QTUI.h"
+#include "faust/audio/jack-dsp.h"
+
+#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
+
+#if SOUNDFILE
+#include "faust/gui/SoundUI.h"
+#endif
+
+// Always include this file, otherwise -nvoices only mode does not compile....
+#include "faust/gui/MidiUI.h"
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ 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;
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ 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] << " [--nvoices <val>] [--control <0/1>] [--group <0/1>]\n";
+        exit(1);
+    }
+    
+#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
+        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
+    string preset_dir = PresetUI::getPresetDir();
+    cout << "Final preset_dir: " << preset_dir << endl;
+    PresetUI::tryCreateDirectory(preset_dir);
+    PresetUI pinterface(interface, preset_dir + "/" + ((nvoices > 0) ? "poly_" : ""));
+    DSP->buildUserInterface(&pinterface);
+#else
+    DSP->buildUserInterface(interface);
+    DSP->buildUserInterface(&finterface);
+#endif
+
+#ifdef HTTPCTRL
+    httpdUI httpdinterface(name, DSP->getNumInputs(), DSP->getNumOutputs(), argc, argv);
+    DSP->buildUserInterface(&httpdinterface);
+    cout << "HTTPD is on" << endl;
+#endif
+    
+#ifdef MIDICTRL
+    jackaudio_midi audio;
+#else
+    jackaudio audio;
+#endif
+    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 OSCCTRL
+    OSCUI oscinterface(name, argc, argv);
+    DSP->buildUserInterface(&oscinterface);
+    cout << "OSC is on" << endl;
+    audio.addControlCallback(osc_compute_callback, &oscinterface);
+#endif
+    
+#ifdef MIDICTRL
+    MidiUI* midiinterface = new MidiUI(&audio);
+    cout << "JACK MIDI is used" << endl;
+    DSP->buildUserInterface(midiinterface);
+    cout << "MIDI is on" << endl;
+#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();
+    interface->stop();
+    
+#ifdef MIDICTRL
+    midiinterface->stop();
+#endif
+    
+    audio.stop();
+    finterface.saveState(rcfilename);
+    
+    delete DSP;
+#ifdef MIDICTRL
+    delete midiinterface;
+#endif
+    
+    return 0;
+}
+
+/******************* END jack-qt.cpp ****************/

cyfaust/resources/architecture/jack.rs

@@ -0,0 +1,171 @@
+/************************************************************************
+ 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 JACK architecture file
+extern crate jack;
+use jack::prelude as j;
+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() {
+
+    // Create JACK client
+    let (client, _status) = j::Client::new("faust_rust", j::client_options::NO_START_SERVER).unwrap();
+
+    // 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 JACK: sample-rate = {} buffer-size = {}", client.sample_rate(), client.buffer_size());
+
+    println!("get_num_inputs: {}", dsp.get_num_inputs());
+    println!("get_num_outputs: {}", dsp.get_num_outputs());
+
+    // Init DSP with a given SR
+    dsp.init(client.sample_rate() as i32);
+
+    // Register ports. They will be used in a callback that will be
+    // called when new data is available.
+
+    let in_a = client.register_port("in1", j::AudioInSpec::default()).unwrap();
+    let in_b = client.register_port("in2", j::AudioInSpec::default()).unwrap();
+
+    let mut out_a = client.register_port("out1", j::AudioOutSpec::default()).unwrap();
+    let mut out_b = client.register_port("out2", j::AudioOutSpec::default()).unwrap();
+
+    let process_callback = move |_: &j::Client, ps: &j::ProcessScope| -> j::JackControl {
+        let mut out_a_p = j::AudioOutPort::new(&mut out_a, ps);
+        let mut out_b_p = j::AudioOutPort::new(&mut out_b, ps);
+
+        let in_a_p = j::AudioInPort::new(&in_a, ps);
+        let in_b_p = j::AudioInPort::new(&in_b, ps);
+
+        let input0: &[f32] = &in_a_p;
+        let input1: &[f32] = &in_b_p;
+
+        let output0: &mut[f32] = &mut out_a_p;
+        let output1: &mut[f32] = &mut out_b_p;
+
+        let inputs = &[input0, input1];
+        let outputs = &mut[output0, output1];
+
+        dsp.compute(in_a_p.len() as i32, inputs, outputs);
+
+        j::JackControl::Continue
+    };
+    let process = j::ClosureProcessHandler::new(process_callback);
+
+    // Activate the client, which starts the processing.
+    let active_client = j::AsyncClient::new(client, (), process).unwrap();
+
+    // 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();
+
+    active_client.deactivate().unwrap();
+}

cyfaust/resources/architecture/juce/README.md

@@ -0,0 +1,84 @@
+# faust2juce
+
+The **faust2juce** tool transforms a Faust DSP program into a fully working JUCE standalone application or plugin, which can possibly be controlled with MIDI or OSC messages. Polyphonic instruments are automatically created from polyphonic aware Faust DSP code, which contains interface parameters with the following `freq`, `gain` and `gate` names. The metadata **declare nvoices "8";** kind of line with a desired value of voices can be added in the source code. See [Creating polyphonic instruments](https://faustdoc.grame.fr/manual/midi/#midi-polyphony-support). 
+
+Polyphonic synthesiser can be created using JUCE Synthesiser model or Faust own polyphonic architecture file (using the `mydsp_poly` class). The `-jsynth` parameter has to be used to choose the JUCE model.
+
+**faust2juce** uses several UI interfaces, subclasses of the base UI class (defined in the architecture/faust/gui/UI.h header) to link to various JUCE components:
+
+ - `JuceGUI.h`: contains the main JuceGUI class (and additional helpers classes) to display Faust UI components (buttons, sliders, bargraphs...) using JUCE widgets. The following `[style:knob]`, `[style:led]`, `[style:numerical]`, `[style:radio]`, `[style:menu]`, `[scale:log]`, `[scale:exp]`, `[tooltip:xx]`, `[hidden:0|1]` metadata are supported.
+ - `JuceOSCUI.h`: allows to link Faust UI components (buttons, sliders, bargraphs...) to the JUCE OSC messaging system, allowing to control them in both directions
+ - `JuceParameterUI.h`: allows to link Faust UI components (buttons, sliders, bargraphs...) with the JUCE AudioParameterFloat/AudioParameterBool classes
+ - `JuceStateUI.h`: allows to save/restore Faust UI components (buttons, sliders, bargraphs...) values using the JUCE state management system (MemoryInputStream/MemoryOutputStream classes)
+
+Some additional files are needed for soundfile and MIDI support:
+
+- `JuceReader.h`: contains code to load audio files using JUCE code, that will be used when the `soundfile` primitive is used in the Faust code
+- `juce-midi.h`: allows to link Faust UI components (buttons, sliders, bargraphs...) to the JUCE MIDI messaging system (for inputs and outputs) 
+
+Two different achitecture files will be used to glue the previously described files with the Faust C++ generated class: 
+- `juce-plugin.cpp`: is used to create a JUCE plugin
+- `juce-standalone.cpp`: is used to create a JUCE stanalone application
+
+## How to use
+
+**faust2juce** is used with the following command: 
+
+`faust2juce [-osc] [-midi] [-soundfile] [-nvoices <num>] [-effect auto|<effect.dsp>] [-standalone] [-jucemodulesdir <dir>] [-vst2sdkdir <dir>] [-disable-splash-screen] [-jsynth] [-llvm] [-magic] [additional Faust options (-vec -vs 8...)] file.dsp` 
+
+By default it will create a plugin project, with a folder named with the dsp file name, containing a .jucer project with a FaustPluginProcessor.cpp file to be used by JUCE.
+
+When using `-standalone` mode, it will create a standalone project, with a folder named with the dsp file name, containing a .jucer project with a FaustAudioApplication.cpp file to be used by JUCE.
+
+The resulting folder has to be moved on the "examples" folder of your JUCE installation, the .jucer file has to be opened, and projects for specific native platforms can be generated. Using the `-jucemodulesdir` allows to generate projects that can be used without moving them in JUCE installation.
+
+## Options
+
+Here are the available options:
+
+- `-osc` : activates OSC control
+- `-midi` : activates MIDI control
+- `-soundfile` : when compiling DSP using 'soundfile' primitive, to add needed resources
+- `-nvoices <num>` : to produce a polyphonic self-contained DSP with <num> voices, ready to be used with MIDI or OSC
+- `-effect <effect.dsp>` : to produce a polyphonic DSP connected to a global output effect, ready to be used with MIDI or OSC
+- `-effect auto` : to produce a polyphonic DSP connected to a global output effect defined as 'effect' in <file.dsp>, ready to be used with MIDI or OSC 
+- `-standalone` : to produce a standalone project, otherwise a plugin project is generated
+- `-jucemodulesdir <folder>` : to set JUCE modules directory to `<folder>`, such as ~/JUCE/modules
+- `-vst2sdkdir <folder>` : to set VST 2 Legacy Directory to `<folder>`. This is the directory that contains "plugininterfaces/vst2.x/aeffect.h".
+- `-disable-splash-screen` : to disable the JUCE splash screen (license is required).
+- `-jsynth` : to use JUCE polyphonic Synthesizer instead of Faust polyphonic code
+- `-llvm` : to use the LLVM compilation chain (OSX and Linux for now)
+---
+- `-magic` : to generate a project using the [PluginGuiMagic GUI builder](https://foleysfinest.com/developer/pluginguimagic/)
+Tested with PGM version 1.13. Support for Faust components is incomplete. Supporting some features (e.g. visualizers) in PGM requires editing the generated C++ code.
+
+This creates a preprocessor definition "PLUGIN_MAGIC" in the jucer file e.g. using VisualStudio 2019.
+
+![image](https://user-images.githubusercontent.com/3178344/125528513-d8f127a0-a896-4f50-8210-ba7b8dcf0386.png)
+
+There are a couple of other options as well:
+
+MAGIC_LOAD_BINARY 
+- adds generated code if defined. By default not defined, lets you "bake in" your XML file by adding it to your Jucer project and then defining this variable.  You'll also need to configure the foleys_gui_magic module in Jucer:
+
+ ![image](https://user-images.githubusercontent.com/3178344/126184481-b83ba2ff-46c4-4aa5-b010-2d2e87eb4e14.png)
+
+ You also have to change the names of the variables magic_xml and magic_xmlSize in the code to match your file name. If you don't you'll get a compilation error, so you'll know where to look.
+
+MAGIC_LEVEL_SOURCE
+- adds generated code if defined. By default not defined, just to show you where in the source code you would add hooks for a visualizer. These are PGM specific features not represented in Faust. Knowledge of how to use the PGM components is assumed.
+
+To use either of these options, either enter the option into the JUCER exporter settings page as shown, or add a `#define` line near the top of your FaustPluginProcessor.cpp.
+
+---
+- `-help or -h` : shows the different options 
+
+As usual with faust2xx tools, other Faust compiler specific options can be given to **faust2juce**, like `-vec -lv 1` to compile in vector mode.etc.
+
+## Latency setting
+
+Some plugins add latency in the signal path. A special global metadata can be used in the DSP code to define it, so that the C++ architecture file can extract it and use the JUCE `AudioProcessor::setLatencySamples()` method to have the plugin inform the host about its added latency. The following syntax can be used:
+
+- `declare latency_frames "7000";` (or alternatively `declare latency_samples "7000";`) to express the latency in samples/frames
+
+- `declare latency_sec "0.5";` to express the latency in seconds, to be converted internally in samples/frames using the host sample rate