cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/libraries/examples/smartKeyboard/acGuitar.dsp

@@ -0,0 +1,100 @@
+//############################### acGuitar.dsp #################################
+// Faust instrument specifically designed for `faust2smartkeyb` where 6 virtual
+// nylon strings can be strummed and plucked using a dedicated keyboard. The
+// extra "strumming keyboard" could be easily replaced by an external strumming
+// interface while the touch screen could keep being used to change the pitch
+// of the strings.
+//
+// ## `SmartKeyboard` Use Strategy
+//
+// The first 6 keyboards implement each individual string of the instrument. A
+// seventh keybaord is used a strumming/plucking interface. As mentionned
+// previously, it could be easily replaced by an external interface.
+//
+// ## Compilation Instructions
+//
+// This Faust code will compile fine with any of the standard Faust targets.
+// However it was specifically designed to be used with `faust2smartkeyb`. For
+// best results, we recommend to use the following parameters to compile it:
+//
+// ```
+// faust2smartkeyb [-ios/-android] -effect reverb.dsp acGuitar.dsp
+// ```
+//
+// ## Version/Licence
+//
+// Version 0.0, Aug. 2017
+// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017
+// MIT Licence: https://opensource.org/licenses/MIT
+//##############################################################################
+
+declare interface "SmartKeyboard{
+    'Number of Keyboards':'7',
+    'Max Keyboard Polyphony':'0',
+    'Rounding Mode':'2',
+    'Keyboard 0 - Number of Keys':'14',
+    'Keyboard 1 - Number of Keys':'14',
+    'Keyboard 2 - Number of Keys':'14',
+    'Keyboard 3 - Number of Keys':'14',
+    'Keyboard 4 - Number of Keys':'14',
+    'Keyboard 5 - Number of Keys':'14',
+    'Keyboard 6 - Number of Keys':'6',
+    'Keyboard 0 - Lowest Key':'52',
+    'Keyboard 1 - Lowest Key':'57',
+    'Keyboard 2 - Lowest Key':'62',
+    'Keyboard 3 - Lowest Key':'67',
+    'Keyboard 4 - Lowest Key':'71',
+    'Keyboard 5 - Lowest Key':'76',
+    'Keyboard 0 - Send Keyboard Freq':'1',
+    'Keyboard 1 - Send Keyboard Freq':'1',
+    'Keyboard 2 - Send Keyboard Freq':'1',
+    'Keyboard 3 - Send Keyboard Freq':'1',
+    'Keyboard 4 - Send Keyboard Freq':'1',
+    'Keyboard 5 - Send Keyboard Freq':'1',
+    'Keyboard 6 - Piano Keyboard':'0',
+    'Keyboard 6 - Send Key Status':'1',
+    'Keyboard 6 - Key 0 - Label':'S0',
+    'Keyboard 6 - Key 1 - Label':'S1',
+    'Keyboard 6 - Key 2 - Label':'S2',
+    'Keyboard 6 - Key 3 - Label':'S3',
+    'Keyboard 6 - Key 4 - Label':'S4',
+    'Keyboard 6 - Key 5 - Label':'S5'
+}";
+
+import("stdfaust.lib");
+
+// SMARTKEYBOARD PARAMS
+kbfreq(0) = hslider("kb0freq",164.8,20,10000,0.01);
+kbbend(0) = hslider("kb0bend",1,ma.EPSILON,10,0.01);
+kbfreq(1) = hslider("kb1freq",220,20,10000,0.01);
+kbbend(1) = hslider("kb1bend",1,ma.EPSILON,10,0.01);
+kbfreq(2) = hslider("kb2freq",293.7,20,10000,0.01);
+kbbend(2) = hslider("kb2bend",1,ma.EPSILON,10,0.01);
+kbfreq(3) = hslider("kb3freq",392,20,10000,0.01);
+kbbend(3) = hslider("kb3bend",1,ma.EPSILON,10,0.01);
+kbfreq(4) = hslider("kb4freq",493.9,20,10000,0.01);
+kbbend(4) = hslider("kb4bend",1,ma.EPSILON,10,0.01);
+kbfreq(5) = hslider("kb5freq",659.2,20,10000,0.01);
+kbbend(5) = hslider("kb5bend",1,ma.EPSILON,10,0.01);
+kb6kstatus(0) = hslider("kb6k0status",0,0,1,1) <: ==(1) | ==(4) : int;
+kb6kstatus(1) = hslider("kb6k1status",0,0,1,1) <: ==(1) | ==(4) : int;
+kb6kstatus(2) = hslider("kb6k2status",0,0,1,1) <: ==(1) | ==(4) : int;
+kb6kstatus(3) = hslider("kb6k3status",0,0,1,1) <: ==(1) | ==(4) : int;
+kb6kstatus(4) = hslider("kb6k4status",0,0,1,1) <: ==(1) | ==(4) : int;
+kb6kstatus(5) = hslider("kb6k5status",0,0,1,1) <: ==(1) | ==(4) : int;
+
+// MODEL PARAMETERS
+// strings length
+sl(i) = kbfreq(i)*kbbend(i) : pm.f2l : si.smoo;
+// pluck position is controlled by the x axis of the accel
+pluckPosition =
+    hslider("pluckPosition[acc: 1 0 -10 0 10]",0.5,0,1,0.01) : si.smoo;
+
+// ASSEMBLING MODELS
+// number of strings
+nStrings = 6;
+guitar = par(i,nStrings,
+    kb6kstatus(i) : ba.impulsify : // using "raw" impulses to drive the models
+    pm.nylonGuitarModel(sl(i),pluckPosition)) :> _;
+
+process = guitar <: _,_;

cyfaust/resources/libraries/examples/smartKeyboard/associatedEffects/elecGuitarEffect.dsp

@@ -0,0 +1,8 @@
+// a stereo distortion effect connected to a stereo reverb
+
+import("stdfaust.lib");
+
+distDrive = 0.8;
+distOffset = 0;
+
+process = par(i,2,ef.cubicnl(distDrive,distOffset)) : dm.zita_rev1;

cyfaust/resources/libraries/examples/smartKeyboard/associatedEffects/myEffect.dsp

@@ -0,0 +1,5 @@
+// Just calling zita_rev1 from demo.lib
+
+import("stdfaust.lib");
+
+process = dm.zita_rev1;

cyfaust/resources/libraries/examples/smartKeyboard/associatedEffects/reverb.dsp

@@ -0,0 +1,5 @@
+// Just calling zita_rev1 from demo.lib
+
+import("stdfaust.lib");
+
+process = dm.zita_rev1;

cyfaust/resources/libraries/examples/smartKeyboard/bells.dsp

@@ -0,0 +1,80 @@
+//################################ bells.dsp ###################################
+// Faust instrument specifically designed for `faust2smartkeyb` where the
+// physical models of 4 different bells can be played using screen pads. The
+// models are taken from `physmodels.lib`.
+//
+// ## `SmartKeyboard` Use Strategy
+//
+// The `SmartKeyboard` interface is used to implement percussion pads where
+// the X/Y position of fingers is retrieved to control the strike position on
+// the bells.
+//
+// ## Compilation Instructions
+//
+// This Faust code will compile fine with any of the standard Faust targets.
+// However it was specifically designed to be used with `faust2smartkeyb`. For
+// best results, we recommend to use the following parameters to compile it:
+//
+// ```
+// faust2smartkeyb [-ios/-android] -effect reverb.dsp bells.dsp
+// ```
+//
+// ## Version/Licence
+//
+// Version 0.0, Aug. 2017
+// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017
+// MIT Licence: https://opensource.org/licenses/MIT
+//##############################################################################
+
+declare interface "SmartKeyboard{
+	'Number of Keyboards':'2',
+	'Max Keyboard Polyphony':'0',
+	'Keyboard 0 - Number of Keys':'2',
+  'Keyboard 1 - Number of Keys':'2',
+	'Keyboard 0 - Send Freq':'0',
+  'Keyboard 1 - Send Freq':'0',
+	'Keyboard 0 - Piano Keyboard':'0',
+  'Keyboard 1 - Piano Keyboard':'0',
+	'Keyboard 0 - Send Key Status':'1',
+	'Keyboard 1 - Send Key Status':'1',
+	'Keyboard 0 - Send X':'1',
+	'Keyboard 0 - Send Y':'1',
+	'Keyboard 1 - Send X':'1',
+	'Keyboard 1 - Send Y':'1',
+	'Keyboard 0 - Key 0 - Label':'English Bell',
+	'Keyboard 0 - Key 1 - Label':'French Bell',
+	'Keyboard 1 - Key 0 - Label':'German Bell',
+	'Keyboard 1 - Key 1 - Label':'Russian Bell'
+}";
+
+import("stdfaust.lib");
+
+// SMARTKEYBOARD PARAMS
+kb0k0status = hslider("kb0k0status",0,0,1,1) : min(1) : int;
+kb0k1status = hslider("kb0k1status",0,0,1,1) : min(1) : int;
+kb1k0status = hslider("kb1k0status",0,0,1,1) : min(1) : int;
+kb1k1status = hslider("kb1k1status",0,0,1,1) : min(1) : int;
+x = hslider("x",1,0,1,0.001);
+y = hslider("y",1,0,1,0.001);
+
+// MODEL PARAMETERS
+strikeCutoff = 6500;
+strikeSharpness = 0.5;
+strikeGain = 1;
+// synthesize 10 modes out of 50
+nModes = 10;
+// resonance duration is 30s
+t60 = 30;
+// number of excitation pos (retrieved from model)
+nExPos = 7;
+// computing excitation position from X and Y
+exPos = min((x*2-1 : abs),(y*2-1 : abs))*(nExPos-1) : int;
+
+// ASSEMBLING MODELS
+bells =
+	(kb0k0status : pm.strikeModel(10,strikeCutoff,strikeSharpness,strikeGain) : pm.englishBellModel(nModes,exPos,t60,1,3)) +
+	(kb0k1status : pm.strikeModel(10,strikeCutoff,strikeSharpness,strikeGain) : pm.frenchBellModel(nModes,exPos,t60,1,3)) +
+	(kb1k0status : pm.strikeModel(10,strikeCutoff,strikeSharpness,strikeGain) : pm.germanBellModel(nModes,exPos,t60,1,2.5)) +
+	(kb1k1status : pm.strikeModel(10,strikeCutoff,strikeSharpness,strikeGain) : pm.russianBellModel(nModes,exPos,t60,1,3)) :> *(0.2);
+
+process = bells <: _,_;

cyfaust/resources/libraries/examples/smartKeyboard/bowed.dsp

@@ -0,0 +1,87 @@
+//##################################### bowed.dsp ########################################
+// Faust instrument specifically designed for `faust2smartkeyb` implementing a
+// non-polyphonic synthesizer (e.g., physical model; etc.) using a combination of
+// different types of UI elements.
+//
+// ## `SmartKeyboard` Use Strategy
+//
+// 5 keyboards are declared (4 actual keyboards and 1 control surface). We want to
+// disable the voice allocation system and we want to activate a voice on start-up
+// so that all strings are constantly running so we set `Max Keyboard Polyphony` to
+// 0. Since we don't want the first 4 keyboards to send the X and Y position of
+// fingers on the screen, we set `Send X` and `Send Y` to 0 for all these keyboards.
+// Similarly, we don't want the fifth keyboard to send pitch information to the synth
+// so we set `Send Freq` to 0 for that keyboard. Finally, we deactivate piano keyboard
+// mode for the fifth keyboard to make sure that color doesn't change when the key is
+// touch and that note names are not displayed.
+//
+// ## Compilation Instructions
+//
+// This Faust code will compile fine with any of the standard Faust targets. However
+// it was specifically designed to be used with `faust2smartkeyb`. For best results,
+// we recommend to use the following parameters to compile it:
+//
+// ```
+// faust2smartkeyb [-ios/-android] -effect reverb.dsp midiOnly.dsp
+// ```
+//
+// ## Version/Licence
+//
+// Version 0.0, Feb. 2017
+// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017
+// MIT Licence: https://opensource.org/licenses/MIT
+//########################################################################################
+
+declare interface "SmartKeyboard{
+	'Number of Keyboards':'5',
+	'Max Keyboard Polyphony':'0',
+	'Rounding Mode':'1',
+	'Keyboard 0 - Number of Keys':'19',
+	'Keyboard 1 - Number of Keys':'19',
+	'Keyboard 2 - Number of Keys':'19',
+	'Keyboard 3 - Number of Keys':'19',
+	'Keyboard 4 - Number of Keys':'1',
+	'Keyboard 4 - Send Freq':'0',
+	'Keyboard 0 - Send X':'0',
+	'Keyboard 1 - Send X':'0',
+	'Keyboard 2 - Send X':'0',
+	'Keyboard 3 - Send X':'0',
+	'Keyboard 0 - Send Y':'0',
+	'Keyboard 1 - Send Y':'0',
+	'Keyboard 2 - Send Y':'0',
+	'Keyboard 3 - Send Y':'0',
+	'Keyboard 0 - Lowest Key':'55',
+	'Keyboard 1 - Lowest Key':'62',
+	'Keyboard 2 - Lowest Key':'69',
+	'Keyboard 3 - Lowest Key':'76',
+	'Keyboard 4 - Piano Keyboard':'0',
+	'Keyboard 4 - Key 0 - Label':'Bow'
+}";
+
+import("stdfaust.lib");
+
+// parameters
+f = hslider("freq",400,50,2000,0.01);
+bend = hslider("bend",1,0,10,0.01);
+keyboard = hslider("keyboard",0,0,5,1) : int;
+key = hslider("key",0,0,18,1) : int;
+x = hslider("x",0.5,0,1,0.01) : si.smoo;
+y = hslider("y",0,0,1,0.01) : si.smoo;
+
+// mapping
+freq = f*bend;
+// dirty motion tracker
+velocity = x-x' : abs : an.amp_follower_ar(0.1,1) : *(8000) : min(1);
+
+// 4 "strings"
+synthSet = par(i,4,synth(localFreq(i),velocity)) :> _
+with{
+	localFreq(i) = freq : ba.sAndH(keyboard == i) : si.smoo;
+	synth(freq,velocity) = sy.fm((freq,freq + freq*modFreqRatio),index*velocity)*velocity
+	with{
+		index = 1000;
+		modFreqRatio = y*0.3;
+	};
+};
+
+process = synthSet <: _,_;

cyfaust/resources/libraries/examples/smartKeyboard/brass.dsp

@@ -0,0 +1,82 @@
+//############################### brass.dsp ###################################
+// Faust instrument specifically designed for `faust2smartkeyb` where a
+// trumpet physical model is controlled using some of the built-in sensors of
+// the device and the touchscreen. Some of these elements could be replaced by
+// external controllers (e.g., breath/mouth piece controller).
+//
+// ## `SmartKeyboard` Use Strategy
+//
+// 1 keyboard is used to implement the pistons of the trumpet (3 keys) and the
+// other allows to control the lips tension.
+//
+// ## Compilation Instructions
+//
+// This Faust code will compile fine with any of the standard Faust targets.
+// However it was specifically designed to be used with `faust2smartkeyb`. For
+// best results, we recommend to use the following parameters to compile it:
+//
+// ```
+// faust2smartkeyb [-ios/-android] -effect reverb.dsp brass.dsp
+// ```
+//
+// ## Version/Licence
+//
+// Version 0.0, Aug. 2017
+// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017
+// MIT Licence: https://opensource.org/licenses/MIT
+//##############################################################################
+
+declare interface "SmartKeyboard{
+	'Number of Keyboards':'2',
+	'Max Keyboard Polyphony':'0',
+	'Keyboard 0 - Number of Keys':'1',
+  'Keyboard 1 - Number of Keys':'3',
+	'Keyboard 0 - Send Freq':'0',
+  'Keyboard 1 - Send Freq':'0',
+	'Keyboard 0 - Piano Keyboard':'0',
+  'Keyboard 1 - Piano Keyboard':'0',
+	'Keyboard 0 - Send Key X':'1',
+	'Keyboard 1 - Send Key Status':'1',
+	'Keyboard 0 - Static Mode':'1',
+	'Keyboard 0 - Key 0 - Label':'Lips Tension',
+	'Keyboard 1 - Key 0 - Label':'P1',
+	'Keyboard 1 - Key 1 - Label':'P2',
+	'Keyboard 1 - Key 2 - Label':'P3'
+}";
+
+import("stdfaust.lib");
+
+// SMARTKEYBOARD PARAMS
+kb0k0x = hslider("kb0k0x",0,0,1,1);
+kb1k0status = hslider("kb1k0status",0,0,1,1) : min(1) : int;
+kb1k1status = hslider("kb1k1status",0,0,1,1) : min(1) : int;
+kb1k2status = hslider("kb1k2status",0,0,1,1) : min(1) : int;
+
+// MODEL PARAMETERS
+// pressure is controlled by accelerometer
+pressure = hslider("pressure[acc: 1 1 -10 0 10]",0,0,1,0.01) : si.smoo;
+breathGain = 0.005; breathCutoff = 2000;
+vibratoFreq = 5; vibratoGain = 0;
+//pitch when no pistons are pushed
+basePitch = 48; // C4
+// calculate pitch shift in function of piston combination
+pitchShift =
+  ((kb1k0status == 0) & (kb1k1status == 1) & (kb1k2status == 0))*(1) +
+  ((kb1k0status == 1) & (kb1k1status == 0) & (kb1k2status == 0))*(2) +
+  ((kb1k0status == 1) & (kb1k1status == 1) & (kb1k2status == 0))*(3) +
+  ((kb1k0status == 0) & (kb1k1status == 1) & (kb1k2status == 1))*(4) +
+  ((kb1k0status == 1) & (kb1k1status == 0) & (kb1k2status == 1))*(5) +
+  ((kb1k0status == 1) & (kb1k1status == 1) & (kb1k2status == 1))*(6);
+// tube length is calculated based on piston combination
+tubeLength = basePitch-pitchShift : ba.midikey2hz : pm.f2l : si.smoo;
+// lips tension is controlled using pad on screen
+lipsTension = kb0k0x : si.smoo;
+// default mute value
+mute = 0.5;
+
+// ASSEMBLING MODEL
+model =
+	pm.blower(pressure,breathGain,breathCutoff,vibratoFreq,vibratoGain) :
+  pm.brassModel(tubeLength,lipsTension,mute);
+
+process = model <: _,_;

cyfaust/resources/libraries/examples/smartKeyboard/clarinet.dsp

@@ -0,0 +1,113 @@
+//############################### clarinet.dsp #################################
+// Faust instrument specifically designed for `faust2smartkeyb` where a
+// clarinet physical model is controlled by an interface implementing
+// fingerings similar to that of a the real instrument. The pressure of the
+// breath in the mouthpiece of the clarinet is controlled by blowing on the
+// built-in microphone of the device.
+//
+// ## `SmartKeyboard` Use Strategy
+//
+// The device is meant to be held with 2 hands vertically in order to put all
+// fingers on the screen at the same time. Key combinations determine the
+// pitch of the instrument. A single voice is constantly ran.
+//
+// ## Compilation Instructions
+//
+// This Faust code will compile fine with any of the standard Faust targets.
+// However it was specifically designed to be used with `faust2smartkeyb`. For
+// best results, we recommend to use the following parameters to compile it:
+//
+// ```
+// faust2smartkeyb [-ios/-android] clarinet.dsp
+// ```
+//
+// ## Version/Licence
+//
+// Version 0.0, Aug. 2017
+// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017
+// MIT Licence: https://opensource.org/licenses/MIT
+//##############################################################################
+
+declare interface "SmartKeyboard{
+	'Number of Keyboards':'2',
+	'Max Keyboard Polyphony':'0',
+	'Keyboard 0 - Number of Keys':'4',
+  'Keyboard 1 - Number of Keys':'5',
+	'Keyboard 0 - Send Freq':'0',
+  'Keyboard 1 - Send Freq':'0',
+	'Keyboard 0 - Piano Keyboard':'0',
+  'Keyboard 1 - Piano Keyboard':'0',
+	'Keyboard 0 - Send Key Status':'1',
+	'Keyboard 1 - Send Key Status':'1',
+	'Keyboard 0 - Key 3 - Label':'O+',
+	'Keyboard 1 - Key 4 - Label':'O-'
+}";
+
+import("stdfaust.lib");
+
+// SMARTKEYBOARD PARAMS
+kb0k0status = hslider("kb0k0status",0,0,1,1) : min(1) : int;
+kb0k1status = hslider("kb0k1status",0,0,1,1) : min(1) : int;
+kb0k2status = hslider("kb0k2status",0,0,1,1) : min(1) : int;
+kb0k3status = hslider("kb0k3status",0,0,1,1) : min(1) : int;
+kb1k0status = hslider("kb1k0status",0,0,1,1) : min(1) : int;
+kb1k1status = hslider("kb1k1status",0,0,1,1) : min(1) : int;
+kb1k2status = hslider("kb1k2status",0,0,1,1) : min(1) : int;
+kb1k3status = hslider("kb1k3status",0,0,1,1) : min(1) : int;
+kb1k4status = hslider("kb1k4status",0,0,1,1) : min(1) : int;
+
+// MODEL PARAMETERS
+reedStiffness = hslider("reedStiffness[acc: 1 1 -10 0 10]",0,0,1,0.01) : si.smoo;
+basePitch = 73; // C#4
+pitchShift = // calculate pitch shfit in function of "keys" combination
+  ((kb0k0status == 0) & (kb0k1status == 1) & (kb0k2status == 0) &
+		(kb1k0status == 0) & (kb1k1status == 0) & (kb1k2status == 0) &
+		(kb1k3status == 0))*(-1) + // C
+	((kb0k0status == 1) & (kb0k1status == 0) & (kb0k2status == 0) &
+		(kb1k0status == 0) & (kb1k1status == 0) & (kb1k2status == 0) &
+		(kb1k3status == 0))*(-2) + // B
+	((kb0k0status == 1) & (kb0k1status == 0) & (kb0k2status == 1) &
+		(kb1k0status == 0) & (kb1k1status == 0) & (kb1k2status == 0) &
+		(kb1k3status == 0))*(-3) + // Bb
+	((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 0) &
+		(kb1k0status == 0) & (kb1k1status == 0) & (kb1k2status == 0) &
+		(kb1k3status == 0))*(-4) + // A
+	((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 0) &
+		(kb1k0status == 1) & (kb1k1status == 0) & (kb1k2status == 0) &
+		(kb1k3status == 0))*(-5) + // G#
+	((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) &
+		(kb1k0status == 0) & (kb1k1status == 0) & (kb1k2status == 0) &
+		(kb1k3status == 0))*(-6) + // G
+	((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) &
+		(kb1k0status == 0) & (kb1k1status == 1) & (kb1k2status == 0) &
+		(kb1k3status == 0))*(-7) + // F#
+	((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) &
+		(kb1k0status == 1) & (kb1k1status == 0) & (kb1k2status == 0) &
+		(kb1k3status == 0))*(-8) + // F
+	((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) &
+		(kb1k0status == 1) & (kb1k1status == 1) & (kb1k2status == 0) &
+		(kb1k3status == 0))*(-9) + // E
+	((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) &
+		(kb1k0status == 1) & (kb1k1status == 1) & (kb1k2status == 0) &
+		(kb1k3status == 1))*(-10) + // Eb
+	((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) &
+		(kb1k0status == 1) & (kb1k1status == 1) & (kb1k2status == 1) &
+		(kb1k3status == 0))*(-11) + // D
+	((kb0k0status == 0) & (kb0k1status == 0) & (kb0k2status == 0) &
+		(kb1k0status == 0) & (kb1k1status == 0) & (kb1k2status == 0) &
+		(kb1k3status == 1))*(-12) + // C#
+	((kb0k0status == 1) & (kb0k1status == 1) & (kb0k2status == 1) &
+		(kb1k0status == 1) & (kb1k1status == 1) & (kb1k2status == 1) &
+		(kb1k3status == 1))*(-13); // C
+octaveShiftUp = +(kb0k3status : ba.impulsify)~_; // counting up
+octaveShiftDown = +(kb1k4status : ba.impulsify)~_; // counting down
+octaveShift = (octaveShiftUp-octaveShiftDown)*(12);
+// tube length is just smoothed: could be improved
+tubeLength = basePitch+pitchShift+octaveShift : ba.midikey2hz : pm.f2l : si.smoo;
+bellOpening = 0.5;
+
+// ASSEMBLING MODEL
+model(pressure) = pm.clarinetModel(tubeLength,pressure,reedStiffness,bellOpening);
+
+// pressure is estimated from mic signal
+process = an.amp_follower_ud(0.02,0.02)*0.7 : model <: _,_;

cyfaust/resources/libraries/examples/smartKeyboard/crazyGuiro.dsp

@@ -0,0 +1,96 @@
+//################################### crazyGuiro.dsp #####################################
+// A simple smart phone "Guiro" where the touch screen is used to drive the instrument and
+// select its pitch and where the x and y axis of the accelerometer control the
+// resonance properties of the instrument.
+//
+// ## `SmartKeyboard` Use Strategy
+//
+// Since the sounds generated by this synth are very short, the strategy here is to take
+// advantage of the polyphony capabilities of the iOSKeyboard architecture by creating
+// a new voice every time a new key is pressed. Since the `SmartKeyboard` interface has a
+// large number of keys here (128), lots of sounds are generated when sliding a
+// finger across the keyboard. Also, it's interesting to notice that the `freq` parameter
+// is not used here. Instead `keyboard` and `key` are used which allows us to easily
+// make custom mappings.
+//
+// ## Compilation Instructions
+//
+// This Faust code will compile fine with any of the standard Faust targets. However
+// it was specifically designed to be used with `faust2smartkeyb`. For best results,
+// we recommend to use the following parameters to compile it:
+//
+// ```
+// faust2smartkeyb [-ios/-android] crazyGuiro.dsp
+// ```
+//
+// ## Version/Licence
+//
+// Version 0.0, Feb. 2017
+// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017
+// MIT Licence: https://opensource.org/licenses/MIT
+//########################################################################################
+
+import("stdfaust.lib");
+
+
+//========================= Smart Keyboard Configuration =================================
+// 8 keyboards, each has 16 keys, none of them display key names.
+//========================================================================================
+
+declare interface "SmartKeyboard{
+	'Number of Keyboards':'8',
+	'Keyboard 0 - Number of Keys':'16',
+	'Keyboard 1 - Number of Keys':'16',
+	'Keyboard 2 - Number of Keys':'16',
+	'Keyboard 3 - Number of Keys':'16',
+	'Keyboard 4 - Number of Keys':'16',
+	'Keyboard 5 - Number of Keys':'16',
+	'Keyboard 6 - Number of Keys':'16',
+	'Keyboard 7 - Number of Keys':'16',
+	'Keyboard 0 - Piano Keyboard':'0',
+	'Keyboard 1 - Piano Keyboard':'0',
+	'Keyboard 2 - Piano Keyboard':'0',
+	'Keyboard 3 - Piano Keyboard':'0',
+	'Keyboard 4 - Piano Keyboard':'0',
+	'Keyboard 5 - Piano Keyboard':'0',
+	'Keyboard 6 - Piano Keyboard':'0',
+	'Keyboard 7 - Piano Keyboard':'0'
+}";
+
+
+//================================ Instrument Parameters =================================
+// Creates the connection between the synth and the mobile device
+//========================================================================================
+
+// the current keyboard
+keyboard = hslider("keyboard",0,0,2,1);
+// the current key of the current keyboard
+key = hslider("key",0,0,2,1);
+// the wet factor of the reverb
+wet = hslider("wet[acc: 0 0 -10 0 10]",0,0,1,0.01);
+// the resonance factor of the reverb
+res = hslider("res[acc: 1 0 -10 0 10]",0.5,0,1,0.01);
+// smart keyboard gate parameter
+gate = button("gate");
+
+
+//=================================== Parameters Mapping =================================
+//========================================================================================
+
+// the resonance frequency of each click of the Guiro changes in function of
+// the selected keyboard and key on it
+minKey = 50; // min key of lowest keyboard
+keySkipKeyboard = 8; // key skip per keyboard
+drumResFreq = (key+minKey)+(keyboard*keySkipKeyboard) : ba.midikey2hz;
+reverbWet = wet : si.smoo;
+reverbRes = wet : si.smoo;
+
+// filter q
+q = 8;
+
+//============================================ DSP =======================================
+//========================================================================================
+
+reverb(wet,res)  =  _ <: *(1-wet),(*(wet) : re.mono_freeverb(res, 0.5, 0.5, 0)) :> _;
+
+process = sy.popFilterDrum(drumResFreq,q,gate) : reverb(wet,res) <: _,_;

cyfaust/resources/libraries/examples/smartKeyboard/drums.dsp

@@ -0,0 +1,74 @@
+//##################################### drums.dsp ########################################
+// Faust instrument specifically designed for `faust2smartkeyb` where 3 drums can
+// be controlled using pads. The X/Y postion of fingers is detected on each key
+// and use to control the strike postion on the virtual membrane.
+//
+// ## `SmartKeyboard` Use Strategy
+//
+// The drum physical model used here is implemented to be generic so that its
+// fundamental frequency can be changed for each voice. `SmartKeyboard` is used
+// in polyphonic mode so each new strike on the interface corresponds to a new
+// new voice.
+//
+// ## Compilation Instructions
+//
+// This Faust code will compile fine with any of the standard Faust targets. However
+// it was specifically designed to be used with `faust2smartkeyb`. For best results,
+// we recommend to use the following parameters to compile it:
+//
+// ```
+// faust2smartkeyb [-ios/-android] -effect reverb.dsp drums.dsp
+// ```
+//
+// ## Version/Licence
+//
+// Version 0.0, Feb. 2017
+// Copyright Romain Michon CCRMA (Stanford University)/GRAME 2017
+// MIT Licence: https://opensource.org/licenses/MIT
+//########################################################################################
+
+// Interface with 2 keyboards of 2 and 1 keys (3 pads)
+// Static mode is used so that keys don't change color when touched
+// Note labels are hidden
+// Piano Keyboard mode is deactivated so all the keys look the same
+declare interface "SmartKeyboard{
+	'Number of Keyboards':'2',
+	'Keyboard 0 - Number of Keys':'2',
+	'Keyboard 1 - Number of Keys':'1',
+	'Keyboard 0 - Static Mode':'1',
+	'Keyboard 1 - Static Mode':'1',
+	'Keyboard 0 - Send X':'1',
+	'Keyboard 0 - Send Y':'1',
+	'Keyboard 1 - Send X':'1',
+	'Keyboard 1 - Send Y':'1',
+	'Keyboard 0 - Piano Keyboard':'0',
+	'Keyboard 1 - Piano Keyboard':'0',
+	'Keyboard 0 - Key 0 - Label':'High',
+	'Keyboard 0 - Key 1 - Label':'Mid',
+	'Keyboard 1 - Key 0 - Label':'Low'
+}";
+
+import("stdfaust.lib");
+
+// standard parameters
+gate = button("gate");
+x = hslider("x",1,0,1,0.001);
+y = hslider("y",1,0,1,0.001);
+keyboard = hslider("keyboard",0,0,1,1) : int;
+key = hslider("key",0,0,1,1) : int;
+
+drumModel = pm.djembe(rootFreq,exPos,strikeSharpness,gain,gate)
+with{
+	// frequency of the lowest drum
+	bFreq = 60;
+	// retrieving pad ID (0-2)
+	padID = 2-(keyboard*2+key);
+	// drum root freq is computed in function of pad number
+	rootFreq = bFreq*(padID+1);
+	// excitation position
+	exPos = min((x*2-1 : abs),(y*2-1 : abs));
+	strikeSharpness = 0.5;
+	gain = 2;
+};
+
+process = drumModel <: _,_;