gentoo/boudigi
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

actually it uses MIDI SysEx...

Browse Source
This commit is contained in:
Tomasz Moń
2009-02-06 18:50:09 +01:00
parent 48100b42e1
commit f9d24bc6b9
8 changed files with 785 additions and 913 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@@ -1,7 +1,7 @@
CC = gcc
CFLAGS = `pkg-config --cflags glib-2.0 gtk+-2.0` -Wall -g
OFLAG = -o
LIBS = `pkg-config --libs glib-2.0 gtk+-2.0 libusb`
LIBS = `pkg-config --libs glib-2.0 gtk+-2.0 alsa`
.SUFFIXES : .o .c
.c.o :

3
README
View File

@@ -1,5 +1,4 @@
Requirments: libusb, gtk+, glib
Requirments: alsa, gtk+, glib
Getting started guide:
-disable snd_usb_audio (when it's loaded gdigi can't claim interface)
-make && ./gdigi

1
TODO
View File

@@ -1,5 +1,4 @@
-figure out all magic commands
-fix usb handling code
-make complete gui
-amp/cabinet models
-expression pedal options

880
gdigi.c
View File

File diff suppressed because it is too large Load Diff

102
gdigi.h
View File

@@ -17,8 +17,6 @@
#include <usb.h>
#include <glib.h>
extern struct usb_dev_handle *handle;
enum {
WAH_TYPE_CRY = 0,
WAH_TYPE_FULLRANGE,
@@ -344,53 +342,53 @@ enum {
#define EMT240_PLATE_LIVELINESS 0x0D
#define EMT240_PLATE_LEVEL 0x05
void set_wah_min(struct usb_dev_handle *handle, int level);
void set_wah_max(struct usb_dev_handle *handle, int level);
void set_wah_level(struct usb_dev_handle *handle, int level);
void set_wah_type(struct usb_dev_handle *handle, int type);
void set_wah_on_off(struct usb_dev_handle *handle, gboolean val);
void set_comp_sustain(struct usb_dev_handle *handle, int level);
void set_comp_tone(struct usb_dev_handle *handle, int level);
void set_comp_attack(struct usb_dev_handle *handle, int level);
void set_comp_level(struct usb_dev_handle *handle, int level);
void set_comp_type(struct usb_dev_handle *handle, int type);
void set_comp_on_off(struct usb_dev_handle *handle, gboolean val);
void switch_user_preset(struct usb_dev_handle *handle, int x);
void switch_system_preset(struct usb_dev_handle *handle, int x);
void set_pickup_type(struct usb_dev_handle *handle, int type);
void set_pickup_on_off(struct usb_dev_handle *handle, gboolean val);
void set_dist_type(struct usb_dev_handle *handle, int type);
void set_dist_option(struct usb_dev_handle *handle, char option, int value);
void set_dist_on_off(struct usb_dev_handle *handle, gboolean val);
void set_preset_level(struct usb_dev_handle *handle, int level);
void set_eq_type(struct usb_dev_handle *handle, int type);
void set_eq_gain(struct usb_dev_handle *handle, int x);
void set_eq_level(struct usb_dev_handle *handle, int x);
void set_eq_bass(struct usb_dev_handle *handle, int x);
void set_eq_mid(struct usb_dev_handle *handle, int x);
void set_eq_mid_hz(struct usb_dev_handle *handle, int x);
void set_eq_treble(struct usb_dev_handle *handle, int x);
void set_eq_treb_hz(struct usb_dev_handle *handle, int x);
void set_eq_on_off(struct usb_dev_handle *handle, gboolean val);
void set_noisegate_type(struct usb_dev_handle *handle, int type);
void set_gate_option(struct usb_dev_handle *handle, char option, int x);
void set_noisegate_on_off(struct usb_dev_handle *handle, gboolean val);
void set_chorusfx_option(struct usb_dev_handle *handle, char option, int x);
void set_flanger_option(struct usb_dev_handle *handle, char option, int x);
void set_vibrato_option(struct usb_dev_handle *handle, char option, int x);
void set_tremolo_option(struct usb_dev_handle *handle, char option, int x);
void set_envelope_option(struct usb_dev_handle *handle, char option, int x);
void set_ya_option(struct usb_dev_handle *handle, char option, int x);
void set_filter_option(struct usb_dev_handle *handle, char option, int x);
void set_whammy_option(struct usb_dev_handle *handle, char option, int x);
void set_pitch_option(struct usb_dev_handle *handle, char option, int x);
void set_ips_option(struct usb_dev_handle *handle, char option, int x);
void set_chorusfx_type(struct usb_dev_handle *handle, int type);
void set_chorusfx_on_off(struct usb_dev_handle *handle, gboolean val);
void set_delay_time(struct usb_dev_handle *handle, int x);
void set_delay_type(struct usb_dev_handle *handle, int type);
void set_delay_option(struct usb_dev_handle *handle, char option, int x);
void set_delay_on_off(struct usb_dev_handle *handle, gboolean val);
void set_reverb_option(struct usb_dev_handle *handle, char option, int x);
void set_reverb_type(struct usb_dev_handle *handle, int type);
void set_reverb_on_off(struct usb_dev_handle *handle, gboolean val);
void set_wah_min(int level);
void set_wah_max(int level);
void set_wah_level(int level);
void set_wah_type(int type);
void set_wah_on_off(gboolean val);
void set_comp_sustain(int level);
void set_comp_tone(int level);
void set_comp_attack(int level);
void set_comp_level(int level);
void set_comp_type(int type);
void set_comp_on_off(gboolean val);
void switch_user_preset(int x);
void switch_system_preset(int x);
void set_pickup_type(int type);
void set_pickup_on_off(gboolean val);
void set_dist_type(int type);
void set_dist_option(char option, int value);
void set_dist_on_off(gboolean val);
void set_preset_level(int level);
void set_eq_type(int type);
void set_eq_gain(int x);
void set_eq_level(int x);
void set_eq_bass(int x);
void set_eq_mid(int x);
void set_eq_mid_hz(int x);
void set_eq_treble(int x);
void set_eq_treb_hz(int x);
void set_eq_on_off(gboolean val);
void set_noisegate_type(int type);
void set_gate_option(char option, int x);
void set_noisegate_on_off(gboolean val);
void set_chorusfx_option(char option, int x);
void set_flanger_option(char option, int x);
void set_vibrato_option(char option, int x);
void set_tremolo_option(char option, int x);
void set_envelope_option(char option, int x);
void set_ya_option(char option, int x);
void set_filter_option(char option, int x);
void set_whammy_option(char option, int x);
void set_pitch_option(char option, int x);
void set_ips_option(char option, int x);
void set_chorusfx_type(int type);
void set_chorusfx_on_off(gboolean val);
void set_delay_time(int x);
void set_delay_type(int type);
void set_delay_option(char option, int x);
void set_delay_on_off(gboolean val);
void set_reverb_option(char option, int x);
void set_reverb_type(int type);
void set_reverb_on_off(gboolean val);

24
gui.c
View File

@@ -17,29 +17,29 @@
#include <gtk/gtk.h>
#include "gdigi.h"
void value_changed_cb(GtkSpinButton *spinbutton, void (*callback)(struct usb_dev_handle*, int))
void value_changed_cb(GtkSpinButton *spinbutton, void (*callback)(int))
{
int val = gtk_spin_button_get_value_as_int(spinbutton);
callback(handle, val);
callback(val);
}
void value_changed_option_cb(GtkSpinButton *spinbutton, void (*callback)(struct usb_dev_handle*, char, int))
void value_changed_option_cb(GtkSpinButton *spinbutton, void (*callback)(char, int))
{
int val = gtk_spin_button_get_value_as_int(spinbutton);
gint option = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(spinbutton), "option_id"));
callback(handle, (char)option, val);
callback((char)option, val);
}
void toggled_cb(GtkToggleButton *button, void (*callback)(struct usb_dev_handle*, gboolean))
void toggled_cb(GtkToggleButton *button, void (*callback)(gboolean))
{
gboolean val = gtk_toggle_button_get_active(button);
callback(handle, val);
callback(val);
}
typedef struct {
char *label;
void (*callback)(struct usb_dev_handle*, int);
void (*callback_with_option)(struct usb_dev_handle*, char, int);
void (*callback)(int);
void (*callback_with_option)(char, int);
gdouble min;
gdouble max;
gint option;
@@ -416,7 +416,7 @@ GtkWidget *create_table(SettingsWidget *widgets, gint amt)
return table;
}
GtkWidget *create_on_off_button(const gchar *label, gboolean state, void (*callback)(struct usb_dev_handle*, int))
GtkWidget *create_on_off_button(const gchar *label, gboolean state, void (*callback)(int))
{
GtkWidget *button = gtk_toggle_button_new_with_label(label);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), state);
@@ -427,7 +427,7 @@ GtkWidget *create_on_off_button(const gchar *label, gboolean state, void (*callb
typedef struct {
gint id;
gchar *label;
void (*callback)(struct usb_dev_handle*, int);
void (*callback)(int);
SettingsWidget *widgets;
gint widgets_amt;
GtkWidget *child; /* child widget - set inside create_widget_container */
@@ -521,7 +521,7 @@ void combo_box_changed_cb(GtkComboBox *widget, WidgetContainer *widgets)
vbox = g_object_get_data(G_OBJECT(widget), "vbox");
if (x != -1) {
widgets[x].callback(handle, widgets[x].id);
widgets[x].callback(widgets[x].id);
child = g_object_get_data(G_OBJECT(widget), "active_child");
if (child != NULL) {
gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(gtk_widget_get_parent(vbox))), child);
@@ -565,7 +565,7 @@ GtkWidget *create_widget_container(WidgetContainer *widgets, gint amt)
typedef struct {
char *label;
gboolean value;
void (*callback)(struct usb_dev_handle*, gboolean);
void (*callback)(gboolean);
WidgetContainer *widgets;
gint widgets_amt;
} VBoxWidget;

664
tests.c
View File

@@ -16,620 +16,620 @@
#include "gdigi.h"
void test_wah(struct usb_dev_handle *handle)
void test_wah()
{
int x;
set_wah_type(handle, WAH_TYPE_CRY);
set_wah_type(WAH_TYPE_CRY);
for (x=0; x<=99; x++)
set_wah_min(handle, x);
set_wah_min(x);
for (x=0; x<=99; x++)
set_wah_max(handle, x);
set_wah_max(x);
for (x=0; x<=12; x++)
set_wah_level(handle, x);
set_wah_level(x);
set_wah_type(handle, WAH_TYPE_FULLRANGE);
set_wah_type(WAH_TYPE_FULLRANGE);
for (x=0; x<=99; x++)
set_wah_min(handle, x);
set_wah_min(x);
for (x=0; x<=99; x++)
set_wah_max(handle, x);
set_wah_max(x);
for (x=0; x<=12; x++)
set_wah_level(handle, x);
set_wah_level(x);
set_wah_type(handle, WAH_TYPE_CLYDE);
set_wah_type(WAH_TYPE_CLYDE);
for (x=0; x<=99; x++)
set_wah_min(handle, x);
set_wah_min(x);
for (x=0; x<=99; x++)
set_wah_max(handle, x);
set_wah_max(x);
for (x=0; x<=12; x++)
set_wah_level(handle, x);
set_wah_level(x);
set_wah_on_off(handle, TRUE);
set_wah_on_off(handle, FALSE);
set_wah_on_off(TRUE);
set_wah_on_off(FALSE);
}
void test_compressor(struct usb_dev_handle *handle)
void test_compressor()
{
int x;
set_comp_type(handle, COMP_TYPE_DIGI);
set_comp_type(COMP_TYPE_DIGI);
for (x=0; x<=99; x++)
set_comp_sustain(handle, x);
set_comp_sustain(x);
for (x=0; x<=99; x++)
set_comp_tone(handle, x);
set_comp_tone(x);
for (x=0; x<=99; x++)
set_comp_attack(handle, x);
set_comp_attack(x);
for (x=0; x<=99; x++)
set_comp_level(handle, x);
set_comp_level(x);
set_comp_type(handle, COMP_TYPE_CS);
set_comp_type(COMP_TYPE_CS);
for (x=0; x<=99; x++)
set_comp_sustain(handle, x);
set_comp_sustain(x);
for (x=0; x<=99; x++)
set_comp_attack(handle, x);
set_comp_attack(x);
for (x=0; x<=99; x++)
set_comp_level(handle, x);
set_comp_level(x);
set_comp_on_off(handle, TRUE);
set_comp_on_off(handle, FALSE);
set_comp_on_off(TRUE);
set_comp_on_off(FALSE);
}
void test_dist(struct usb_dev_handle *handle)
void test_dist()
{
int x;
set_dist_type(handle, DIST_TYPE_SCREAMER);
set_dist_type(DIST_TYPE_SCREAMER);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_SCREAMER_DRIVE, x);
set_dist_option(DIST_SCREAMER_DRIVE, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_SCREAMER_TONE, x);
set_dist_option(DIST_SCREAMER_TONE, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_SCREAMER_LVL, x);
set_dist_option(DIST_SCREAMER_LVL, x);
set_dist_type(handle, DIST_TYPE_808);
set_dist_type(DIST_TYPE_808);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_808_OVERDRIVE, x);
set_dist_option(DIST_808_OVERDRIVE, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_808_TONE, x);
set_dist_option(DIST_808_TONE, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_808_LVL, x);
set_dist_option(DIST_808_LVL, x);
set_dist_type(handle, DIST_TYPE_GUYOD);
set_dist_type(DIST_TYPE_GUYOD);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_GUYOD_DRIVE, x);
set_dist_option(DIST_GUYOD_DRIVE, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_GUYOD_LVL, x);
set_dist_option(DIST_GUYOD_LVL, x);
set_dist_type(handle, DIST_TYPE_DOD250);
set_dist_type(DIST_TYPE_DOD250);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_DOD250_GAIN, x);
set_dist_option(DIST_DOD250_GAIN, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_DOD250_LVL, x);
set_dist_option(DIST_DOD250_LVL, x);
set_dist_type(handle, DIST_TYPE_RODENT);
set_dist_type(DIST_TYPE_RODENT);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_RODENT_DIST, x);
set_dist_option(DIST_RODENT_DIST, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_RODENT_FILTER, x);
set_dist_option(DIST_RODENT_FILTER, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_RODENT_LVL, x);
set_dist_option(DIST_RODENT_LVL, x);
set_dist_type(handle, DIST_TYPE_MX);
set_dist_type(DIST_TYPE_MX);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_MX_DIST, x);
set_dist_option(DIST_MX_DIST, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_MX_OUTPUT, x);
set_dist_option(DIST_MX_OUTPUT, x);
set_dist_type(handle, DIST_TYPE_DS);
set_dist_type(DIST_TYPE_DS);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_DS_GAIN, x);
set_dist_option(DIST_DS_GAIN, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_DS_TONE, x);
set_dist_option(DIST_DS_TONE, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_DS_LVL, x);
set_dist_option(DIST_DS_LVL, x);
set_dist_type(handle, DIST_TYPE_GRUNGE);
set_dist_type(DIST_TYPE_GRUNGE);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_GRUNGE_GRUNGE, x);
set_dist_option(DIST_GRUNGE_GRUNGE, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_GRUNGE_FACE, x);
set_dist_option(DIST_GRUNGE_FACE, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_GRUNGE_LOUD, x);
set_dist_option(DIST_GRUNGE_LOUD, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_GRUNGE_BUTT, x);
set_dist_option(DIST_GRUNGE_BUTT, x);
set_dist_type(handle, DIST_TYPE_ZONE);
set_dist_type(DIST_TYPE_ZONE);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_ZONE_GAIN, x);
set_dist_option(DIST_ZONE_GAIN, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_ZONE_LOW, x);
set_dist_option(DIST_ZONE_LOW, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_ZONE_MID_LVL, x);
set_dist_option(DIST_ZONE_MID_LVL, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_ZONE_MID_FREQ, x);
set_dist_option(DIST_ZONE_MID_FREQ, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_ZONE_HIGH, x);
set_dist_option(DIST_ZONE_HIGH, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_ZONE_LEVEL, x);
set_dist_option(DIST_ZONE_LEVEL, x);
set_dist_type(handle, DIST_TYPE_DEATH);
set_dist_type(DIST_TYPE_DEATH);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_DEATH_LOW, x);
set_dist_option(DIST_DEATH_LOW, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_DEATH_MID, x);
set_dist_option(DIST_DEATH_MID, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_DEATH_HIGH, x);
set_dist_option(DIST_DEATH_HIGH, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_DEATH_LVL, x);
set_dist_option(DIST_DEATH_LVL, x);
set_dist_type(handle, DIST_TYPE_GONK);
set_dist_type(DIST_TYPE_GONK);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_GONK_GONK, x);
set_dist_option(DIST_GONK_GONK, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_GONK_SMEAR, x);
set_dist_option(DIST_GONK_SMEAR, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_GONK_SUCK, x);
set_dist_option(DIST_GONK_SUCK, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_GONK_HEAVE, x);
set_dist_option(DIST_GONK_HEAVE, x);
set_dist_type(handle, DIST_TYPE_FUZZY);
set_dist_type(DIST_TYPE_FUZZY);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_FUZZY_FUZZ, x);
set_dist_option(DIST_FUZZY_FUZZ, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_FUZZY_VOLUME, x);
set_dist_option(DIST_FUZZY_VOLUME, x);
set_dist_type(handle, DIST_TYPE_MP);
set_dist_type(DIST_TYPE_MP);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_MP_SUSTAIN, x);
set_dist_option(DIST_MP_SUSTAIN, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_MP_TONE, x);
set_dist_option(DIST_MP_TONE, x);
for (x=0; x<=99; x++)
set_dist_option(handle, DIST_MP_VOLUME, x);
set_dist_option(DIST_MP_VOLUME, x);
set_dist_on_off(handle, TRUE);
set_dist_on_off(handle, FALSE);
set_dist_on_off(TRUE);
set_dist_on_off(FALSE);
}
void test_presets(struct usb_dev_handle *handle)
void test_presets()
{
int x;
for (x=0; x<=60; x++)
switch_user_preset(handle, x);
switch_user_preset(x);
for (x=0; x<=60; x++)
switch_system_preset(handle, x);
switch_system_preset(x);
for (x=0; x<=99; x++)
set_preset_level(handle, x);
set_preset_level(x);
}
void test_pickups(struct usb_dev_handle *handle)
void test_pickups()
{
set_pickup_type(handle, PICKUP_TYPE_HB_SC);
set_pickup_type(handle, PICKUP_TYPE_SC_HB);
set_pickup_type(PICKUP_TYPE_HB_SC);
set_pickup_type(PICKUP_TYPE_SC_HB);
set_pickup_on_off(handle, TRUE);
set_pickup_on_off(handle, FALSE);
set_pickup_on_off(TRUE);
set_pickup_on_off(FALSE);
}
void test_eq(struct usb_dev_handle *handle)
void test_eq()
{
int x;
set_eq_type(handle, EQ_TYPE_BRIGHT);
set_eq_type(handle, EQ_TYPE_MIDBOOST);
set_eq_type(handle, EQ_TYPE_SCOOP);
set_eq_type(handle, EQ_TYPE_WARM);
set_eq_type(EQ_TYPE_BRIGHT);
set_eq_type(EQ_TYPE_MIDBOOST);
set_eq_type(EQ_TYPE_SCOOP);
set_eq_type(EQ_TYPE_WARM);
for (x=0; x<=99; x++)
set_eq_gain(handle, x);
set_eq_gain(x);
for (x=0; x<=99; x++)
set_eq_level(handle, x);
set_eq_level(x);
for (x=0; x<=0x18; x++)
set_eq_bass(handle, x);
set_eq_bass(x);
for (x=0; x<=0x18; x++)
set_eq_mid(handle, x);
set_eq_mid(x);
for (x=0; x<=4700; x++)
set_eq_mid_hz(handle, x);
set_eq_mid_hz(x);
for (x=0; x<=0x18; x++)
set_eq_treble(handle, x);
set_eq_treble(x);
for (x=0; x<=7500; x++)
set_eq_treb_hz(handle, x);
set_eq_treb_hz(x);
set_eq_on_off(handle, TRUE);
set_eq_on_off(handle, FALSE);
set_eq_on_off(TRUE);
set_eq_on_off(FALSE);
}
void test_noisegate(struct usb_dev_handle *handle)
void test_noisegate()
{
int x;
set_noisegate_type(handle, NOISEGATE_GATE);
set_noisegate_type(NOISEGATE_GATE);
for (x=0; x<=99; x++)
set_gate_option(handle, NOISEGATE_GATE_TRESHOLD, x);
set_gate_option(NOISEGATE_GATE_TRESHOLD, x);
for (x=0; x<=99; x++)
set_gate_option(handle, NOISEGATE_ATTACK, x);
set_gate_option(NOISEGATE_ATTACK, x);
for (x=0; x<=99; x++)
set_gate_option(handle, NOISEGATE_RELEASE, x);
set_gate_option(NOISEGATE_RELEASE, x);
for (x=0; x<=99; x++)
set_gate_option(handle, NOISEGATE_ATTN, x);
set_gate_option(NOISEGATE_ATTN, x);
set_noisegate_type(handle, NOISEGATE_SWELL);
set_noisegate_type(NOISEGATE_SWELL);
for (x=0; x<=99; x++)
set_gate_option(handle, NOISEGATE_SWELL_SENS, x);
set_gate_option(NOISEGATE_SWELL_SENS, x);
for (x=0; x<=99; x++)
set_gate_option(handle, NOISEGATE_ATTACK, x);
set_gate_option(NOISEGATE_ATTACK, x);
for (x=0; x<=99; x++)
set_gate_option(handle, NOISEGATE_RELEASE, x);
set_gate_option(NOISEGATE_RELEASE, x);
for (x=0; x<=99; x++)
set_gate_option(handle, NOISEGATE_ATTN, x);
set_gate_option(NOISEGATE_ATTN, x);
set_noisegate_on_off(handle, TRUE);
set_noisegate_on_off(handle, FALSE);
set_noisegate_on_off(TRUE);
set_noisegate_on_off(FALSE);
}
void test_chorusfx(struct usb_dev_handle *handle)
void test_chorusfx()
{
int x;
set_chorusfx_type(handle, CHORUS_TYPE_CE);
set_chorusfx_type(CHORUS_TYPE_CE);
for (x=0; x<=99; x++)
set_chorusfx_option(handle, CE_CHORUS_SPEED, x);
set_chorusfx_option(CE_CHORUS_SPEED, x);
for (x=0; x<=99; x++)
set_chorusfx_option(handle, CE_CHORUS_DEPTH, x);
set_chorusfx_option(CE_CHORUS_DEPTH, x);
set_chorusfx_type(handle, CHORUS_TYPE_DUAL);
set_chorusfx_type(CHORUS_TYPE_DUAL);
for (x=0; x<=99; x++)
set_chorusfx_option(handle, DUAL_CHORUS_SPEED, x);
set_chorusfx_option(DUAL_CHORUS_SPEED, x);
for (x=0; x<=99; x++)
set_chorusfx_option(handle, DUAL_CHORUS_DEPTH, x);
set_chorusfx_option(DUAL_CHORUS_DEPTH, x);
for (x=0; x<=99; x++)
set_chorusfx_option(handle, DUAL_CHORUS_LEVEL, x);
set_chorusfx_option(handle, DUAL_CHORUS_WAVE, WAVE_TRI);
set_chorusfx_option(handle, DUAL_CHORUS_WAVE, WAVE_SINE);
set_chorusfx_option(handle, DUAL_CHORUS_WAVE, WAVE_SQUARE);
set_chorusfx_option(DUAL_CHORUS_LEVEL, x);
set_chorusfx_option(DUAL_CHORUS_WAVE, WAVE_TRI);
set_chorusfx_option(DUAL_CHORUS_WAVE, WAVE_SINE);
set_chorusfx_option(DUAL_CHORUS_WAVE, WAVE_SQUARE);
set_chorusfx_type(handle, CHORUS_TYPE_MULTI);
set_chorusfx_type(CHORUS_TYPE_MULTI);
for (x=0; x<=99; x++)
set_chorusfx_option(handle, MULTI_CHORUS_SPEED, x);
set_chorusfx_option(MULTI_CHORUS_SPEED, x);
for (x=0; x<=99; x++)
set_chorusfx_option(handle, MULTI_CHORUS_DEPTH, x);
set_chorusfx_option(MULTI_CHORUS_DEPTH, x);
for (x=0; x<=99; x++)
set_chorusfx_option(handle, MULTI_CHORUS_LEVEL, x);
set_chorusfx_option(handle, MULTI_CHORUS_WAVE, WAVE_TRI);
set_chorusfx_option(handle, MULTI_CHORUS_WAVE, WAVE_SINE);
set_chorusfx_option(handle, MULTI_CHORUS_WAVE, WAVE_SQUARE);
set_chorusfx_option(MULTI_CHORUS_LEVEL, x);
set_chorusfx_option(MULTI_CHORUS_WAVE, WAVE_TRI);
set_chorusfx_option(MULTI_CHORUS_WAVE, WAVE_SINE);
set_chorusfx_option(MULTI_CHORUS_WAVE, WAVE_SQUARE);
set_chorusfx_type(handle, CHORUS_TYPE_FLANGER);
set_chorusfx_type(CHORUS_TYPE_FLANGER);
for (x=0; x<=99; x++)
set_flanger_option(handle, FLANGER_SPEED, x);
set_flanger_option(FLANGER_SPEED, x);
for (x=0; x<=99; x++)
set_flanger_option(handle, FLANGER_DEPTH, x);
set_flanger_option(FLANGER_DEPTH, x);
for (x=0; x<=99; x++)
set_flanger_option(handle, FLANGER_REGEN, x);
set_flanger_option(FLANGER_REGEN, x);
for (x=0; x<=99; x++)
set_flanger_option(handle, FLANGER_LEVEL, x);
set_flanger_option(handle, FLANGER_WAVE, WAVE_TRI);
set_flanger_option(handle, FLANGER_WAVE, WAVE_SINE);
set_flanger_option(handle, FLANGER_WAVE, WAVE_SQUARE);
set_flanger_option(FLANGER_LEVEL, x);
set_flanger_option(FLANGER_WAVE, WAVE_TRI);
set_flanger_option(FLANGER_WAVE, WAVE_SINE);
set_flanger_option(FLANGER_WAVE, WAVE_SQUARE);
set_chorusfx_type(handle, CHORUS_TYPE_MXR_FLANGER);
set_chorusfx_type(CHORUS_TYPE_MXR_FLANGER);
for (x=0; x<=99; x++)
set_flanger_option(handle, MXR_FLANGER_SPEED, x);
set_flanger_option(MXR_FLANGER_SPEED, x);
for (x=0; x<=99; x++)
set_flanger_option(handle, MXR_FLANGER_WIDTH, x);
set_flanger_option(MXR_FLANGER_WIDTH, x);
for (x=0; x<=99; x++)
set_flanger_option(handle, MXR_FLANGER_REGEN, x);
set_flanger_option(MXR_FLANGER_REGEN, x);
for (x=0; x<=99; x++)
set_flanger_option(handle, MXR_FLANGER_MANUAL, x);
set_flanger_option(MXR_FLANGER_MANUAL, x);
set_chorusfx_type(handle, CHORUS_TYPE_PHASER);
set_chorusfx_type(CHORUS_TYPE_PHASER);
for (x=0; x<=99; x++)
set_flanger_option(handle, PHASER_SPEED, x);
set_flanger_option(PHASER_SPEED, x);
for (x=0; x<=99; x++)
set_flanger_option(handle, PHASER_DEPTH, x);
set_flanger_option(PHASER_DEPTH, x);
for (x=0; x<=99; x++)
set_flanger_option(handle, PHASER_REGEN, x);
set_flanger_option(PHASER_REGEN, x);
for (x=0; x<=99; x++)
set_flanger_option(handle, PHASER_LEVEL, x);
set_flanger_option(handle, PHASER_WAVE, WAVE_TRI);
set_flanger_option(handle, PHASER_WAVE, WAVE_SINE);
set_flanger_option(handle, PHASER_WAVE, WAVE_SQUARE);
set_flanger_option(PHASER_LEVEL, x);
set_flanger_option(PHASER_WAVE, WAVE_TRI);
set_flanger_option(PHASER_WAVE, WAVE_SINE);
set_flanger_option(PHASER_WAVE, WAVE_SQUARE);
set_chorusfx_type(handle, CHORUS_TYPE_VIBRATO);
set_chorusfx_type(CHORUS_TYPE_VIBRATO);
for (x=0; x<=99; x++)
set_vibrato_option(handle, VIBRATO_SPEED, x);
set_vibrato_option(VIBRATO_SPEED, x);
for (x=0; x<=99; x++)
set_vibrato_option(handle, VIBRATO_DEPTH, x);
set_vibrato_option(VIBRATO_DEPTH, x);
set_chorusfx_type(handle, CHORUS_TYPE_ROTARY);
set_chorusfx_type(CHORUS_TYPE_ROTARY);
for (x=0; x<=99; x++)
set_vibrato_option(handle, ROTARY_SPEED, x);
set_vibrato_option(ROTARY_SPEED, x);
for (x=0; x<=99; x++)
set_vibrato_option(handle, ROTARY_INTENSITY, x);
set_vibrato_option(ROTARY_INTENSITY, x);
for (x=0; x<=99; x++)
set_vibrato_option(handle, ROTARY_DOPPLER, x);
set_vibrato_option(ROTARY_DOPPLER, x);
for (x=0; x<=99; x++)
set_vibrato_option(handle, ROTARY_CROSSOVER, x);
set_vibrato_option(ROTARY_CROSSOVER, x);
set_chorusfx_type(handle, CHORUS_TYPE_VIBROPAN);
set_chorusfx_type(CHORUS_TYPE_VIBROPAN);
for (x=0; x<=99; x++)
set_vibrato_option(handle, VIBROPAN_SPEED, x);
set_vibrato_option(VIBROPAN_SPEED, x);
for (x=0; x<=99; x++)
set_vibrato_option(handle, VIBROPAN_DEPTH, x);
set_vibrato_option(VIBROPAN_DEPTH, x);
for (x=0; x<=99; x++)
set_vibrato_option(handle, VIBROPAN_VIBRA, x);
set_vibrato_option(handle, VIBROPAN_WAVE, WAVE_TRI);
set_vibrato_option(handle, VIBROPAN_WAVE, WAVE_SINE);
set_vibrato_option(handle, VIBROPAN_WAVE, WAVE_SQUARE);
set_vibrato_option(VIBROPAN_VIBRA, x);
set_vibrato_option(VIBROPAN_WAVE, WAVE_TRI);
set_vibrato_option(VIBROPAN_WAVE, WAVE_SINE);
set_vibrato_option(VIBROPAN_WAVE, WAVE_SQUARE);
set_chorusfx_type(handle, CHORUS_TYPE_TREMOLO);
set_chorusfx_type(CHORUS_TYPE_TREMOLO);
for (x=0; x<=99; x++)
set_tremolo_option(handle, TREMOLO_SPEED, x);
set_tremolo_option(TREMOLO_SPEED, x);
for (x=0; x<=99; x++)
set_tremolo_option(handle, TREMOLO_DEPTH, x);
set_tremolo_option(handle, TREMOLO_WAVE, WAVE_TRI);
set_tremolo_option(handle, TREMOLO_WAVE, WAVE_SINE);
set_tremolo_option(handle, TREMOLO_WAVE, WAVE_SQUARE);
set_tremolo_option(TREMOLO_DEPTH, x);
set_tremolo_option(TREMOLO_WAVE, WAVE_TRI);
set_tremolo_option(TREMOLO_WAVE, WAVE_SINE);
set_tremolo_option(TREMOLO_WAVE, WAVE_SQUARE);
set_chorusfx_type(handle, CHORUS_TYPE_PANNER);
set_chorusfx_type(CHORUS_TYPE_PANNER);
for (x=0; x<=99; x++)
set_tremolo_option(handle, PANNER_SPEED, x);
set_tremolo_option(PANNER_SPEED, x);
for (x=0; x<=99; x++)
set_tremolo_option(handle, PANNER_DEPTH, x);
set_tremolo_option(handle, PANNER_WAVE, WAVE_TRI);
set_tremolo_option(handle, PANNER_WAVE, WAVE_SINE);
set_tremolo_option(handle, PANNER_WAVE, WAVE_SQUARE);
set_tremolo_option(PANNER_DEPTH, x);
set_tremolo_option(PANNER_WAVE, WAVE_TRI);
set_tremolo_option(PANNER_WAVE, WAVE_SINE);
set_tremolo_option(PANNER_WAVE, WAVE_SQUARE);
set_chorusfx_type(handle, CHORUS_TYPE_ENVELOPE);
set_chorusfx_type(CHORUS_TYPE_ENVELOPE);
for (x=0; x<=99; x++)
set_envelope_option(handle, ENVELOPE_SENSITIVITY, x);
set_envelope_option(ENVELOPE_SENSITIVITY, x);
for (x=0; x<=99; x++)
set_envelope_option(handle, ENVELOPE_RANGE, x);
set_envelope_option(ENVELOPE_RANGE, x);
set_chorusfx_type(handle, CHORUS_TYPE_AUTOYA);
set_chorusfx_type(CHORUS_TYPE_AUTOYA);
for (x=0; x<=99; x++)
set_ya_option(handle, AUTOYA_SPEED, x);
set_ya_option(AUTOYA_SPEED, x);
for (x=0; x<=99; x++)
set_ya_option(handle, AUTOYA_INTENSITY, x);
set_ya_option(AUTOYA_INTENSITY, x);
for (x=0; x<=0x31; x++)
set_ya_option(handle, AUTOYA_RANGE, x);
set_ya_option(AUTOYA_RANGE, x);
set_chorusfx_type(handle, CHORUS_TYPE_YAYA);
set_chorusfx_type(CHORUS_TYPE_YAYA);
for (x=0; x<=99; x++)
set_ya_option(handle, YAYA_PEDAL, x);
set_ya_option(YAYA_PEDAL, x);
for (x=0; x<=99; x++)
set_ya_option(handle, YAYA_INTENSITY, x);
set_ya_option(YAYA_INTENSITY, x);
for (x=0; x<=0x31; x++)
set_ya_option(handle, YAYA_RANGE, x);
set_ya_option(YAYA_RANGE, x);
set_chorusfx_type(handle, CHORUS_TYPE_STEP_FILTER);
set_chorusfx_type(CHORUS_TYPE_STEP_FILTER);
for (x=0; x<=99; x++)
set_filter_option(handle, STEP_FILTER_SPEED, x);
set_filter_option(STEP_FILTER_SPEED, x);
for (x=0; x<=99; x++)
set_filter_option(handle, STEP_FILTER_INTENSITY, x);
set_filter_option(STEP_FILTER_INTENSITY, x);
set_chorusfx_type(handle, CHORUS_TYPE_WHAMMY);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_OCT_UP);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_2OCT_UP);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_2ND_DN);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_RV_2ND);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_4TH_DN);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_OCT_DN);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_2OCT_DN);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_DIV_BMB);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_M3_MA);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_2ND_MA3);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_3RD_4TH);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_4TH_5TH);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_5TH_OCT);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_HOCT_UP);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_HOCT_DN);
set_whammy_option(handle, WHAMMY_AMOUNT, WHAMMY_OCT_UD);
set_chorusfx_type(CHORUS_TYPE_WHAMMY);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_OCT_UP);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_2OCT_UP);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_2ND_DN);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_RV_2ND);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_4TH_DN);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_OCT_DN);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_2OCT_DN);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_DIV_BMB);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_M3_MA);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_2ND_MA3);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_3RD_4TH);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_4TH_5TH);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_5TH_OCT);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_HOCT_UP);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_HOCT_DN);
set_whammy_option(WHAMMY_AMOUNT, WHAMMY_OCT_UD);
for (x=0; x<=99; x++)
set_whammy_option(handle, WHAMMY_PEDAL, x);
set_whammy_option(WHAMMY_PEDAL, x);
for (x=0; x<=99; x++)
set_whammy_option(handle, WHAMMY_MIX, x);
set_whammy_option(WHAMMY_MIX, x);
set_chorusfx_type(handle, CHORUS_TYPE_PITCH_SHIFT);
set_chorusfx_type(CHORUS_TYPE_PITCH_SHIFT);
for (x=0; x<=0x30; x++)
set_pitch_option(handle, PITCH_AMOUNT, x);
set_pitch_option(PITCH_AMOUNT, x);
for (x=0; x<=99; x++)
set_pitch_option(handle, PITCH_MIX, x);
set_pitch_option(PITCH_MIX, x);
set_chorusfx_type(handle, CHORUS_TYPE_DETUNE);
set_chorusfx_type(CHORUS_TYPE_DETUNE);
for (x=0; x<=0x30; x++)
set_pitch_option(handle, DETUNE_AMOUNT, x);
set_pitch_option(DETUNE_AMOUNT, x);
for (x=0; x<=99; x++)
set_pitch_option(handle, DETUNE_LEVEL, x);
set_pitch_option(DETUNE_LEVEL, x);
set_chorusfx_type(handle, CHORUS_TYPE_IPS);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_OCT_D);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_7TH_DN);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_6TH_DN);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_5TH_DN);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_4TH_DN);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_3RD_DN);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_2ND_DN);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_2ND_UP);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_3RD_UP);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_4TH_UP);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_5TH_UP);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_6TH_UP);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_7TH_UP);
set_ips_option(handle, IPS_SHIFT_AMOUNT, IPS_OCT_U);
set_ips_option(handle, IPS_KEY, IPS_E);
set_ips_option(handle, IPS_KEY, IPS_F);
set_ips_option(handle, IPS_KEY, IPS_GB);
set_ips_option(handle, IPS_KEY, IPS_G);
set_ips_option(handle, IPS_KEY, IPS_AB);
set_ips_option(handle, IPS_KEY, IPS_A);
set_ips_option(handle, IPS_KEY, IPS_BB);
set_ips_option(handle, IPS_KEY, IPS_B);
set_ips_option(handle, IPS_KEY, IPS_C);
set_ips_option(handle, IPS_KEY, IPS_DD);
set_ips_option(handle, IPS_KEY, IPS_D);
set_ips_option(handle, IPS_KEY, IPS_EB);
set_ips_option(handle, IPS_SCALE, IPS_MAJOR);
set_ips_option(handle, IPS_SCALE, IPS_MINOR);
set_ips_option(handle, IPS_SCALE, IPS_DORIA);
set_ips_option(handle, IPS_SCALE, IPS_MIXLYD);
set_ips_option(handle, IPS_SCALE, IPS_LYDIAN);
set_ips_option(handle, IPS_SCALE, IPS_HMINO);
set_chorusfx_type(CHORUS_TYPE_IPS);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_OCT_D);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_7TH_DN);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_6TH_DN);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_5TH_DN);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_4TH_DN);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_3RD_DN);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_2ND_DN);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_2ND_UP);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_3RD_UP);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_4TH_UP);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_5TH_UP);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_6TH_UP);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_7TH_UP);
set_ips_option(IPS_SHIFT_AMOUNT, IPS_OCT_U);
set_ips_option(IPS_KEY, IPS_E);
set_ips_option(IPS_KEY, IPS_F);
set_ips_option(IPS_KEY, IPS_GB);
set_ips_option(IPS_KEY, IPS_G);
set_ips_option(IPS_KEY, IPS_AB);
set_ips_option(IPS_KEY, IPS_A);
set_ips_option(IPS_KEY, IPS_BB);
set_ips_option(IPS_KEY, IPS_B);
set_ips_option(IPS_KEY, IPS_C);
set_ips_option(IPS_KEY, IPS_DD);
set_ips_option(IPS_KEY, IPS_D);
set_ips_option(IPS_KEY, IPS_EB);
set_ips_option(IPS_SCALE, IPS_MAJOR);
set_ips_option(IPS_SCALE, IPS_MINOR);
set_ips_option(IPS_SCALE, IPS_DORIA);
set_ips_option(IPS_SCALE, IPS_MIXLYD);
set_ips_option(IPS_SCALE, IPS_LYDIAN);
set_ips_option(IPS_SCALE, IPS_HMINO);
for (x=0; x<=99; x++)
set_ips_option(handle, IPS_LEVEL, x);
set_ips_option(IPS_LEVEL, x);
set_chorusfx_on_off(handle, TRUE);
set_chorusfx_on_off(handle, FALSE);
set_chorusfx_on_off(TRUE);
set_chorusfx_on_off(FALSE);
}
void test_delay(struct usb_dev_handle *handle)
void test_delay()
{
int x;
set_delay_type(handle, DELAY_TYPE_ANALOG);
set_delay_type(DELAY_TYPE_ANALOG);
for (x=0; x<=139; x++)
set_delay_time(handle, x);
set_delay_time(x);
for (x=0; x<=99; x++)
set_delay_option(handle, ANALOG_LEVEL, x);
set_delay_option(ANALOG_LEVEL, x);
for (x=0; x<=100; x++)
set_delay_option(handle, ANALOG_REPEATS, x);
set_delay_option(ANALOG_REPEATS, x);
set_delay_type(handle, DELAY_TYPE_DIGITAL);
set_delay_type(DELAY_TYPE_DIGITAL);
for (x=0; x<=139; x++)
set_delay_time(handle, x);
set_delay_time(x);
for (x=0; x<=99; x++)
set_delay_option(handle, DIGITAL_LEVEL, x);
set_delay_option(DIGITAL_LEVEL, x);
for (x=0; x<=100; x++)
set_delay_option(handle, DIGITAL_REPEATS, x);
set_delay_option(DIGITAL_REPEATS, x);
for (x=0; x<=99; x++)
set_delay_option(handle, DIGITAL_DUCKER_THRESH, x);
set_delay_option(DIGITAL_DUCKER_THRESH, x);
for (x=0; x<=99; x++)
set_delay_option(handle, DIGITAL_DUCKER_LEVEL, x);
set_delay_option(DIGITAL_DUCKER_LEVEL, x);
set_delay_type(handle, DELAY_TYPE_MODULATED);
set_delay_type(DELAY_TYPE_MODULATED);
for (x=0; x<=139; x++)
set_delay_time(handle, x);
set_delay_time(x);
for (x=0; x<=99; x++)
set_delay_option(handle, MODULATED_LEVEL, x);
set_delay_option(MODULATED_LEVEL, x);
for (x=0; x<=100; x++)
set_delay_option(handle, MODULATED_REPEATS, x);
set_delay_option(MODULATED_REPEATS, x);
for (x=0; x<=99; x++)
set_delay_option(handle, MODULATED_DEPTH, x);
set_delay_option(MODULATED_DEPTH, x);
set_delay_type(handle, DELAY_TYPE_PONG);
set_delay_type(DELAY_TYPE_PONG);
for (x=0; x<=139; x++)
set_delay_time(handle, x);
set_delay_time(x);
for (x=0; x<=99; x++)
set_delay_option(handle, PONG_LEVEL, x);
set_delay_option(PONG_LEVEL, x);
for (x=0; x<=100; x++)
set_delay_option(handle, PONG_REPEATS, x);
set_delay_option(PONG_REPEATS, x);
for (x=0; x<=99; x++)
set_delay_option(handle, PONG_DUCKER_THRESH, x);
set_delay_option(PONG_DUCKER_THRESH, x);
for (x=0; x<=99; x++)
set_delay_option(handle, PONG_DUCKER_LEVEL, x);
set_delay_option(PONG_DUCKER_LEVEL, x);
set_delay_type(handle, DELAY_TYPE_TAPE);
set_delay_type(DELAY_TYPE_TAPE);
for (x=0; x<=139; x++)
set_delay_time(handle, x);
set_delay_time(x);
for (x=0; x<=99; x++)
set_delay_option(handle, TAPE_LEVEL, x);
set_delay_option(TAPE_LEVEL, x);
for (x=0; x<=100; x++)
set_delay_option(handle, TAPE_REPEATS, x);
set_delay_option(TAPE_REPEATS, x);
for (x=0; x<=99; x++)
set_delay_option(handle, TAPE_WOW, x);
set_delay_option(TAPE_WOW, x);
for (x=0; x<=99; x++)
set_delay_option(handle, TAPE_FLUTTER, x);
set_delay_option(TAPE_FLUTTER, x);
set_delay_on_off(handle, TRUE);
set_delay_on_off(handle, FALSE);
set_delay_on_off(TRUE);
set_delay_on_off(FALSE);
}
void test_reverb(struct usb_dev_handle *handle)
void test_reverb()
{
int x;
set_reverb_type(handle, REVERB_TYPE_TWIN);
set_reverb_type(REVERB_TYPE_TWIN);
for (x=0; x<=99; x++)
set_reverb_option(handle, TWIN_REVERB, x);
set_reverb_option(TWIN_REVERB, x);
set_reverb_type(handle, REVERB_TYPE_LEX_AMBIENCE);
set_reverb_type(REVERB_TYPE_LEX_AMBIENCE);
for (x=0; x<=15; x++)
set_reverb_option(handle, LEX_AMBIENCE_PREDELAY, x);
set_reverb_option(LEX_AMBIENCE_PREDELAY, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, LEX_AMBIENCE_DECAY, x);
set_reverb_option(LEX_AMBIENCE_DECAY, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, LEX_AMBIENCE_LIVELINESS, x);
set_reverb_option(LEX_AMBIENCE_LIVELINESS, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, LEX_AMBIENCE_LEVEL, x);
set_reverb_option(LEX_AMBIENCE_LEVEL, x);
set_reverb_type(handle, REVERB_TYPE_LEX_STUDIO);
set_reverb_type(REVERB_TYPE_LEX_STUDIO);
for (x=0; x<=15; x++)
set_reverb_option(handle, LEX_STUDIO_PREDELAY, x);
set_reverb_option(LEX_STUDIO_PREDELAY, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, LEX_STUDIO_DECAY, x);
set_reverb_option(LEX_STUDIO_DECAY, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, LEX_STUDIO_LIVELINESS, x);
set_reverb_option(LEX_STUDIO_LIVELINESS, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, LEX_STUDIO_LEVEL, x);
set_reverb_option(LEX_STUDIO_LEVEL, x);
set_reverb_type(handle, REVERB_TYPE_LEX_ROOM);
set_reverb_type(REVERB_TYPE_LEX_ROOM);
for (x=0; x<=15; x++)
set_reverb_option(handle, LEX_ROOM_PREDELAY, x);
set_reverb_option(LEX_ROOM_PREDELAY, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, LEX_ROOM_DECAY, x);
set_reverb_option(LEX_ROOM_DECAY, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, LEX_ROOM_LIVELINESS, x);
set_reverb_option(LEX_ROOM_LIVELINESS, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, LEX_ROOM_LEVEL, x);
set_reverb_option(LEX_ROOM_LEVEL, x);
set_reverb_type(handle, REVERB_TYPE_LEX_HALL);
set_reverb_type(REVERB_TYPE_LEX_HALL);
for (x=0; x<=15; x++)
set_reverb_option(handle, LEX_HALL_PREDELAY, x);
set_reverb_option(LEX_HALL_PREDELAY, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, LEX_HALL_DECAY, x);
set_reverb_option(LEX_HALL_DECAY, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, LEX_HALL_LIVELINESS, x);
set_reverb_option(LEX_HALL_LIVELINESS, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, LEX_HALL_LEVEL, x);
set_reverb_option(LEX_HALL_LEVEL, x);
set_reverb_type(handle, REVERB_TYPE_EMT240_PLATE);
set_reverb_type(REVERB_TYPE_EMT240_PLATE);
for (x=0; x<=15; x++)
set_reverb_option(handle, EMT240_PLATE_PREDELAY, x);
set_reverb_option(EMT240_PLATE_PREDELAY, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, EMT240_PLATE_DECAY, x);
set_reverb_option(EMT240_PLATE_DECAY, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, EMT240_PLATE_LIVELINESS, x);
set_reverb_option(EMT240_PLATE_LIVELINESS, x);
for (x=0; x<=99; x++)
set_reverb_option(handle, EMT240_PLATE_LEVEL, x);
set_reverb_option(EMT240_PLATE_LEVEL, x);
set_reverb_on_off(handle, TRUE);
set_reverb_on_off(handle, FALSE);
set_reverb_on_off(TRUE);
set_reverb_on_off(FALSE);
}
void test_all(struct usb_dev_handle *handle)
void test_all()
{
test_wah(handle);
test_compressor(handle);
test_dist(handle);
test_presets(handle);
test_pickups(handle);
test_eq(handle);
test_noisegate(handle);
test_chorusfx(handle);
test_delay(handle);
test_reverb(handle);
test_wah();
test_compressor();
test_dist();
test_presets();
test_pickups();
test_eq();
test_noisegate();
test_chorusfx();
test_delay();
test_reverb();
}

22
tests.h
View File

@@ -16,14 +16,14 @@
#include "gdigi.h"
void test_wah(struct usb_dev_handle *handle);
void test_compressor(struct usb_dev_handle *handle);
void test_dist(struct usb_dev_handle *handle);
void test_presets(struct usb_dev_handle *handle);
void test_pickups(struct usb_dev_handle *handle);
void test_eq(struct usb_dev_handle *handle);
void test_noisegate(struct usb_dev_handle *handle);
void test_chorusfx(struct usb_dev_handle *handle);
void test_delay(struct usb_dev_handle *handle);
void test_reverb(struct usb_dev_handle *handle);
void test_all(struct usb_dev_handle *handle);
void test_wah();
void test_compressor();
void test_dist();
void test_presets();
void test_pickups();
void test_eq();
void test_noisegate();
void test_chorusfx();
void test_delay();
void test_reverb();
void test_all();