diff -Nru calf-0.0.19+git20140527+e79ddef54/configure.ac calf-0.0.19+git20140915+5de5da28/configure.ac --- calf-0.0.19+git20140527+e79ddef54/configure.ac 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/configure.ac 2014-09-13 19:46:25.000000000 +0000 @@ -37,6 +37,10 @@ AC_SUBST(JACK_DEPS_LIBS) AC_SUBST(FLUIDSYNTH_DEPS_CFLAGS) AC_SUBST(FLUIDSYNTH_DEPS_LIBS) +AC_SUBST(LV2_DEPS_CFLAGS) +AC_SUBST(LV2_DEPS_LIBS) +AC_SUBST(FFTW3_DEPS_CFLAGS) +AC_SUBST(FFTW3_DEPS_LIBS) ############################################################################################ # Detect dependencies @@ -53,6 +57,7 @@ AC_CHECK_HEADER(fftw3.h, true, AC_MSG_ERROR([FFTW3 header (fftw3.h) not found])) AC_CHECK_LIB(fftw3, true, AC_MSG_ERROR([FFTW3 library (libfftw3) not found])) AC_CHECK_LIB(fftw3f, true, AC_MSG_ERROR([Single-precision FFTW3 library (libfftw3f) not found])) +PKG_CHECK_MODULES(FFTW3_DEPS, fftw3, true, AC_MSG_ERROR([FFTW3 library (libfftw3) not found])) # JACK AC_CHECK_HEADERS([jack/jack.h], have_jack_header=yes, have_jack_header=no) @@ -153,6 +158,7 @@ if test "$set_enable_debug" = "yes"; then CXXFLAGS="$CXXFLAGS -O0 -g -Wall" else + # TODO: remove -finline options if clang is used CXXFLAGS="$CXXFLAGS -O3 -finline-functions -finline-functions-called-once -Wall" fi diff -Nru calf-0.0.19+git20140527+e79ddef54/debian/changelog calf-0.0.19+git20140915+5de5da28/debian/changelog --- calf-0.0.19+git20140527+e79ddef54/debian/changelog 2014-05-27 20:49:02.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/debian/changelog 2014-09-15 20:20:41.000000000 +0000 @@ -1,3 +1,9 @@ +calf (0.0.19+git20140915+5de5da28-1) unstable; urgency=medium + + * Imported Upstream version 0.0.19+git20140915+5de5da28 (Closes: #759833) + + -- Adrian Knoth Mon, 15 Sep 2014 22:19:42 +0200 + calf (0.0.19+git20140527+e79ddef54-1) unstable; urgency=medium [ Adrian Knoth ] diff -Nru calf-0.0.19+git20140527+e79ddef54/gui/gui-bassenhancer.xml calf-0.0.19+git20140915+5de5da28/gui/gui-bassenhancer.xml --- calf-0.0.19+git20140527+e79ddef54/gui/gui-bassenhancer.xml 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/gui/gui-bassenhancer.xml 2014-09-13 19:46:25.000000000 +0000 @@ -40,8 +40,8 @@ - - + + diff -Nru calf-0.0.19+git20140527+e79ddef54/gui/gui-enhancer.xml calf-0.0.19+git20140915+5de5da28/gui/gui-enhancer.xml --- calf-0.0.19+git20140527+e79ddef54/gui/gui-enhancer.xml 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/gui/gui-enhancer.xml 1970-01-01 00:00:00.000000000 +0000 @@ -1,61 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff -Nru calf-0.0.19+git20140527+e79ddef54/gui/gui-eq30.xml calf-0.0.19+git20140915+5de5da28/gui/gui-eq30.xml --- calf-0.0.19+git20140527+e79ddef54/gui/gui-eq30.xml 1970-01-01 00:00:00.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/gui/gui-eq30.xml 2014-09-13 19:46:25.000000000 +0000 @@ -0,0 +1,254 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + + + + + + + + + + + + + + diff -Nru calf-0.0.19+git20140527+e79ddef54/gui/gui-exciter.xml calf-0.0.19+git20140915+5de5da28/gui/gui-exciter.xml --- calf-0.0.19+git20140527+e79ddef54/gui/gui-exciter.xml 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/gui/gui-exciter.xml 2014-09-13 19:46:25.000000000 +0000 @@ -40,8 +40,8 @@ - - + + diff -Nru calf-0.0.19+git20140527+e79ddef54/gui/gui-reversedelay.xml calf-0.0.19+git20140915+5de5da28/gui/gui-reversedelay.xml --- calf-0.0.19+git20140527+e79ddef54/gui/gui-reversedelay.xml 1970-01-01 00:00:00.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/gui/gui-reversedelay.xml 2014-09-13 19:46:25.000000000 +0000 @@ -0,0 +1,76 @@ + + + + + + + + + + + + + + + + + + + + + + + + +

+ + + + + + + + + + + + + + + + + +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + + diff -Nru calf-0.0.19+git20140527+e79ddef54/src/calf/audio_fx.h calf-0.0.19+git20140915+5de5da28/src/calf/audio_fx.h --- calf-0.0.19+git20140527+e79ddef54/src/calf/audio_fx.h 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/calf/audio_fx.h 2014-09-13 19:46:25.000000000 +0000 @@ -723,6 +723,69 @@ } }; +/* + Class for warping clicks avoiding between chunks + Used in reverse delay +*/ +class overlap_window +{ +private: + float val; + float step; + float acc; + unsigned int active_samples; + unsigned int full_samples; + unsigned int counter; + +public: + overlap_window() { + val = 0; + step = 0; + acc = 0; + active_samples = 0; + full_samples = 0; + counter = 0; + } + void set_coef(float t /* 0..1 */, unsigned int full_samples) { + set_full(0, full_samples, t*full_samples); + } + bool set_full(float min_val, unsigned int full_samples, unsigned int active_samples) { + if(active_samples >= full_samples) return false; + + acc = min_val; + val = min_val; + this->full_samples = full_samples; + this->active_samples = active_samples; + counter = 0; + step = (1 - min_val)/(active_samples/2); + + return true; + } + float get() { + if(counter >= 0 && counter < active_samples/2) { + acc += step; + counter++; + return acc; + } + else if(counter >= active_samples/2 && counter <= full_samples - active_samples/2) { + counter++; + return 1; + } + else if(counter > full_samples - active_samples/2 && counter < full_samples) { + acc -= step; + counter++; + return acc; + } + else if(counter >= full_samples) { + float ret_val = acc; + acc = val; + counter = 0; + return ret_val; + } + return 1; + } +}; + #if 0 { to keep editor happy #endif diff -Nru calf-0.0.19+git20140527+e79ddef54/src/calf/buffer.h calf-0.0.19+git20140915+5de5da28/src/calf/buffer.h --- calf-0.0.19+git20140527+e79ddef54/src/calf/buffer.h 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/calf/buffer.h 2014-09-13 19:46:25.000000000 +0000 @@ -153,7 +153,7 @@ typedef typename T::data_type data_type; data_type *dest = dest_buf.data(); const data_type *src = src_buf.data(); - int size = src.size(); + int size = src->size(); for (int i=0; i #include +#include G_BEGIN_DECLS diff -Nru calf-0.0.19+git20140527+e79ddef54/src/calf/ctl_vumeter.h calf-0.0.19+git20140915+5de5da28/src/calf/ctl_vumeter.h --- calf-0.0.19+git20140527+e79ddef54/src/calf/ctl_vumeter.h 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/calf/ctl_vumeter.h 2014-09-13 19:46:25.000000000 +0000 @@ -62,7 +62,7 @@ float disp_value; int vumeter_position; cairo_surface_t *cache_surface; - cairo_pattern_t *pat; + cairo_surface_t *cache_overlay; }; struct CalfVUMeterClass diff -Nru calf-0.0.19+git20140527+e79ddef54/src/calf/fixed_point.h calf-0.0.19+git20140915+5de5da28/src/calf/fixed_point.h --- calf-0.0.19+git20140527+e79ddef54/src/calf/fixed_point.h 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/calf/fixed_point.h 2014-09-13 19:46:25.000000000 +0000 @@ -37,7 +37,7 @@ template class fixed_point { T value; - enum { IntBits = (sizeof(T)/8) - FracBits }; + enum { IntBits = (sizeof(T)*8) - FracBits }; public: /// default constructor, does not initialize the value, just like - say - float doesn't @@ -210,13 +210,13 @@ template inline U lerp_by_fract_int(U v1, U v2) const { int fp = fpart(); - assert ( fp >=0 && fp <= (1<=0 && fp <= (1ULL< - inline U lerp_table_lookup_int(U data[(1<(data[pos], data[pos+1]); } @@ -224,19 +224,19 @@ /// Untested... I've started it to get a sin/cos readout for rotaryorgan, but decided to use table-less solution instead /// Do not assume it works, because it most probably doesn't template - inline U lerp_table_lookup_int_shift(U data[(1<(data[pos], data[pos+1]); } template - inline U lerp_table_lookup_float(U data[(1< - inline U lerp_table_lookup_float_mask(U data[(1< params; std::vector read_serials; + /* For optional lv2ui:show interface. */ + bool optclosed; + GtkWidget* optwidget; + GtkWidget* optwindow; + const char* opttitle; + plugin_gui(plugin_gui_window *_window); GtkWidget *create_from_xml(plugin_ctl_iface *_plugin, const char *xml); param_control *create_control_from_xml(const char *element, const char *attributes[]); @@ -335,6 +341,39 @@ void activate_command(GtkAction *action, activate_command_params *params); +class cairo_impl: public calf_plugins::cairo_iface +{ +public: + cairo_t *context; + virtual void set_source_rgba(float r, float g, float b, float a = 1.f) { cairo_set_source_rgba(context, r, g, b, a); } + virtual void set_line_width(float width) { cairo_set_line_width(context, width); } + virtual void set_dash(const double *dash, int length) { cairo_set_dash(context, dash, length, 0); } + virtual void draw_label(const char *label, float x, float y, int pos, float margin, float align) { + cairo_text_extents_t extents; + cairo_text_extents(context, label, &extents); + switch(pos) { + case 0: + default: + // top + cairo_move_to(context, x - extents.width / 2, y - margin); + break; + case 1: + // right + cairo_move_to(context, x + margin, y + 2); + break; + case 2: + // bottom + cairo_move_to(context, x - extents.width / 2, y + margin + extents.height); + break; + case 3: + // left + cairo_move_to(context, x - margin - extents.width, y + 2); + break; + } + cairo_show_text(context, label); + } +}; + }; #endif diff -Nru calf-0.0.19+git20140527+e79ddef54/src/calf/inertia.h calf-0.0.19+git20140915+5de5da28/src/calf/inertia.h --- calf-0.0.19+git20140527+e79ddef54/src/calf/inertia.h 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/calf/inertia.h 2014-09-13 19:46:25.000000000 +0000 @@ -253,6 +253,67 @@ // to read param, use get() }; +template < typename T > +class switcher +{ +private: + T cont_val_cur; + T cont_val_prev; + bool is_active; + double step; + double acc; +public: + switcher(unsigned int samples) : cont_val_cur(), cont_val_prev() + { + step = 1.0/samples; + acc = 0; + is_active = false; + } + + void set(T ctr) + { + cont_val_cur = ctr; + is_active = true; + } + + void set_previous(T ctr) + { + cont_val_prev = ctr; + } + + T get_state() + { + return cont_val_prev; + } + + double get_ramp() + { + if(is_active) { + if(acc < 0.5) { + /// Decrease value to zero + acc+= step; + return 1 - 2*acc; + } + else if(acc >= 0.5 && acc <= 1.0) { + /// Switch and increase value to one + cont_val_prev = cont_val_cur; + acc+= step; + return (acc - 0.5)*2; + } + else if(acc > 1) { + /// Switching finished + acc = 0; + is_active = false; + return 1; + } + else + return 1; + } + else + return 1; + } +}; + } #endif diff -Nru calf-0.0.19+git20140527+e79ddef54/src/calf/lv2_options.h calf-0.0.19+git20140915+5de5da28/src/calf/lv2_options.h --- calf-0.0.19+git20140527+e79ddef54/src/calf/lv2_options.h 1970-01-01 00:00:00.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/calf/lv2_options.h 2014-09-13 19:46:25.000000000 +0000 @@ -0,0 +1,132 @@ +/* + Copyright 2012 David Robillard + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef LV2_OPTIONS_H +#define LV2_OPTIONS_H + +#include + +#include "lv2_uri_map.h" +#include "lv2.h" + +#define LV2_OPTIONS_URI "http://lv2plug.in/ns/ext/options" +#define LV2_OPTIONS_PREFIX LV2_OPTIONS_URI "#" + +#define LV2_OPTIONS__Option LV2_OPTIONS_PREFIX "Option" +#define LV2_OPTIONS__interface LV2_OPTIONS_PREFIX "interface" +#define LV2_OPTIONS__options LV2_OPTIONS_PREFIX "options" +#define LV2_OPTIONS__requiredOption LV2_OPTIONS_PREFIX "requiredOption" +#define LV2_OPTIONS__supportedOption LV2_OPTIONS_PREFIX "supportedOption" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + The context of an Option, which defines the subject it applies to. +*/ +typedef enum { + /** + This option applies to the instance itself. The subject must be + ignored. + */ + LV2_OPTIONS_INSTANCE, + + /** + This option applies to some named resource. The subject is a URI mapped + to an integer (a LV2_URID, like the key) + */ + LV2_OPTIONS_RESOURCE, + + /** + This option applies to some blank node. The subject is a blank node + identifier, which is valid only within the current local scope. + */ + LV2_OPTIONS_BLANK, + + /** + This option applies to a port on the instance. The subject is the + port's index. + */ + LV2_OPTIONS_PORT +} LV2_Options_Context; + +/** + An option. + + This is a property with a subject, also known as a triple or statement. + + This struct is useful anywhere a statement needs to be passed where no + memory ownership issues are present (since the value is a const pointer). + + Options can be passed to an instance via the feature LV2_OPTIONS__options + with data pointed to an array of options terminated by a zeroed option, or + accessed/manipulated using LV2_Options_Interface. +*/ +typedef struct _LV2_Options_Option { + LV2_Options_Context context; /**< Context (type of subject). */ + uint32_t subject; /**< Subject. */ + uint32_t key; /**< Key (property). */ + uint32_t size; /**< Size of value in bytes. */ + uint32_t type; /**< Type of value (datatype). */ + const void* value; /**< Pointer to value (object). */ +} LV2_Options_Option; + +/** A status code for option functions. */ +typedef enum { + LV2_OPTIONS_SUCCESS = 0, /**< Completed successfully. */ + LV2_OPTIONS_ERR_UNKNOWN = 1, /**< Unknown error. */ + LV2_OPTIONS_ERR_BAD_SUBJECT = 1 << 1, /**< Invalid/unsupported subject. */ + LV2_OPTIONS_ERR_BAD_KEY = 1 << 2, /**< Invalid/unsupported key. */ + LV2_OPTIONS_ERR_BAD_VALUE = 1 << 3 /**< Invalid/unsupported value. */ +} LV2_Options_Status; + +/** + Interface for dynamically setting options (LV2_OPTIONS__interface). +*/ +typedef struct _LV2_Options_Interface { + /** + Get the given options. + + Each element of the passed options array MUST have type, subject, and + key set. All other fields (size, type, value) MUST be initialised to + zero, and are set to the option value if such an option is found. + + This function is in the "instantiation" LV2 threading class, so no other + instance functions may be called concurrently. + + @return Bitwise OR of LV2_Options_Status values. + */ + uint32_t (*get)(LV2_Handle instance, + LV2_Options_Option* options); + + /** + Set the given options. + + This function is in the "instantiation" LV2 threading class, so no other + instance functions may be called concurrently. + + @return Bitwise OR of LV2_Options_Status values. + */ + uint32_t (*set)(LV2_Handle instance, + const LV2_Options_Option* options); +} LV2_Options_Interface; + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* LV2_OPTIONS_H */ diff -Nru calf-0.0.19+git20140527+e79ddef54/src/calf/lv2_ui.h calf-0.0.19+git20140915+5de5da28/src/calf/lv2_ui.h --- calf-0.0.19+git20140527+e79ddef54/src/calf/lv2_ui.h 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/calf/lv2_ui.h 2014-09-13 19:46:25.000000000 +0000 @@ -1,253 +1,159 @@ -/************************************************************************ - * - * In-process UI extension for LV2 - * - * Copyright (C) 2006-2008 Lars Luthman - * - * Based on lv2.h, which was - * - * Copyright (C) 2000-2002 Richard W.E. Furse, Paul Barton-Davis, - * Stefan Westerfeld - * Copyright (C) 2006 Steve Harris, Dave Robillard. - * - * This header is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 2.1 of the License, - * or (at your option) any later version. - * - * This header 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 - * USA. - * - ***********************************************************************/ - -/** @file - This extension defines an interface that can be used in LV2 plugins and - hosts to create UIs for plugins. The UIs are plugins that reside in - shared object files in an LV2 bundle and are referenced in the RDF data - using the triples (Turtle shown) -

    
-    @@prefix uiext:  .
-        uiext:ui      .
-        a            uiext:GtkUI .
-      uiext:binary  .
-

- where is the URI of the plugin, is - the URI of the plugin UI and is the relative URI to the shared - object file. While it is possible to have the plugin UI and the plugin in - the same shared object file it is probably a good idea to keep them - separate so that hosts that don't want UIs don't have to load the UI code. - A UI MUST specify its class in the RDF data. In this case the class is - uiext:GtkUI, which is the only class defined by this extension. +/* + LV2 UI Extension + Copyright 2009-2014 David Robillard + Copyright 2006-2011 Lars Luthman + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ - (Note: the prefix above is used throughout this file for the same URI) +/** + @file ui.h User Interface API. - It's entirely possible to have multiple UIs for the same plugin, or to have - the UI for a plugin in a different bundle from the actual plugin - this - way people other than the plugin author can write plugin UIs independently - without editing the original plugin bundle. - - Note that the process that loads the shared object file containing the UI - code and the process that loads the shared object file containing the - actual plugin implementation does not have to be the same. There are many - valid reasons for having the plugin and the UI in different processes, or - even on different machines. This means that you can _not_ use singletons - and global variables and expect them to refer to the same objects in the - UI and the actual plugin. The function callback interface defined in this - header is all you can expect to work. - - Since the LV2 specification itself allows for extensions that may add - new types of data and configuration parameters that plugin authors may - want to control with a UI, this extension allows for meta-extensions that - can extend the interface between the UI and the host. These extensions - mirror the extensions used for plugins - there are required and optional - "features" that you declare in the RDF data for the UI as -

    
-     uiext:requiredFeature  .
-     uiext:optionalFeature  .
-

- These predicates have the same semantics as lv2:requiredFeature and - lv2:optionalFeature - if a UI is declaring a feature as required, the - host is NOT allowed to load it unless it supports that feature, and if it - does support a feature (required or optional) it MUST pass that feature's - URI and any additional data (specified by the meta-extension that defines - the feature) to the UI's instantiate() function. - - These features may be used to specify how to pass data between the UI - and the plugin port buffers - see LV2UI_Write_Function for details. - - There are two features defined in this extension that hosts may want to - implement: -

-    uiext:makeResident
-    uiext:makeSONameResident
-

- If the first feature, @c uiext:makeResident, is required by a UI the host - MUST never unload the shared library containing the UI implementation - during the lifetime of the host process (e.g. never calling dlclose() on - Linux). This feature may be needed by e.g. a uiext:GtkUI that registers - its own Glib types using g_type_register_static() - if it gets unloaded - and then loaded again the type registration will break, since there is no - way to unregister the types when the library is unloaded. - - The second feature, @c uiext:makeSONameResident, is ELF specific - and if it is required by an UI the UI should also list a number of - SO names (shared object names) for libraries that the UI shared object - depends on and that may not be unloaded during the lifetime of the host - process, using the predicate @c uiext:residentSONames, like this: -

-     uiext:residentSONames "libgtkmm-2.4.so.1", "libfoo.so.0"
-

- The host MUST then make sure that the shared libraries with the given ELF - SO names are not unloaded when the plugin UI is, but stay loaded during - the entire lifetime of the host process. On Linux this can be accomplished - by calling dlopen() on the shared library file with that SO name and never - calling a matching dlclose(). However, if a plugin UI requires the - @c uiext:makeSONameResident feature, it MUST always be safe for the host to - just never unload the shared object containing the UI implementation, i.e. - act as if the UI required the @c uiext:makeResident feature instead. Thus - the host only needs to find the shared library files corresponding to the - given SO names if it wants to save RAM by unloading the UI shared object - file when it is no longer needed. - - UIs written to this specification do not need to be threadsafe - the - functions defined below may only be called in the same thread as the UI - main loop is running in. - - Note that this UI extension is NOT a lv2:Feature. There is no way for a - plugin to know whether the host that loads it supports UIs or not, and - the plugin must ALWAYS work without the UI (although it may be rather - useless unless it has been configured using the UI in a previous session). - - A UI does not have to be a graphical widget, it could just as well be a - server listening for OSC input or an interface to some sort of hardware - device, depending on the RDF class of the UI. + For high-level documentation, see . */ #ifndef LV2_UI_H #define LV2_UI_H -#include +#include + +#include "lv2.h" #define LV2_UI_URI "http://lv2plug.in/ns/extensions/ui" - +#define LV2_UI_PREFIX LV2_UI_URI "#" + +#define LV2_UI__CocoaUI LV2_UI_PREFIX "CocoaUI" +#define LV2_UI__Gtk3UI LV2_UI_PREFIX "Gtk3UI" +#define LV2_UI__GtkUI LV2_UI_PREFIX "GtkUI" +#define LV2_UI__PortNotification LV2_UI_PREFIX "PortNotification" +#define LV2_UI__Qt4UI LV2_UI_PREFIX "Qt4UI" +#define LV2_UI__UI LV2_UI_PREFIX "UI" +#define LV2_UI__WindowsUI LV2_UI_PREFIX "WindowsUI" +#define LV2_UI__X11UI LV2_UI_PREFIX "X11UI" +#define LV2_UI__binary LV2_UI_PREFIX "binary" +#define LV2_UI__fixedSize LV2_UI_PREFIX "fixedSize" +#define LV2_UI__idleInterface LV2_UI_PREFIX "idleInterface" +#define LV2_UI__noUserResize LV2_UI_PREFIX "noUserResize" +#define LV2_UI__notifyType LV2_UI_PREFIX "notifyType" +#define LV2_UI__parent LV2_UI_PREFIX "parent" +#define LV2_UI__plugin LV2_UI_PREFIX "plugin" +#define LV2_UI__portIndex LV2_UI_PREFIX "portIndex" +#define LV2_UI__portMap LV2_UI_PREFIX "portMap" +#define LV2_UI__portNotification LV2_UI_PREFIX "portNotification" +#define LV2_UI__portSubscribe LV2_UI_PREFIX "portSubscribe" +#define LV2_UI__resize LV2_UI_PREFIX "resize" +#define LV2_UI__showInterface LV2_UI_PREFIX "showInterface" +#define LV2_UI__touch LV2_UI_PREFIX "touch" +#define LV2_UI__ui LV2_UI_PREFIX "ui" +#define LV2_UI__updateRate LV2_UI_PREFIX "updateRate" +#define LV2_UI__windowTitle LV2_UI_PREFIX "windowTitle" + +/** + The index returned by LV2_UI_Port_Port::port_index() for unknown ports. +*/ +#define LV2UI_INVALID_PORT_INDEX ((uint32_t)-1) #ifdef __cplusplus extern "C" { +#else +# include #endif +/** + A pointer to some widget or other type of UI handle. -/** A pointer to some widget or other type of UI handle. - The actual type is defined by the type URI of the UI, e.g. if - " a uiext:GtkUI", this is a pointer - to a GtkWidget compatible with GTK+ 2.0 and the UI can expect the GTK+ - main loop to be running during the entire lifetime of all instances of that - UI. All the functionality provided by this extension is toolkit - independent, the host only needs to pass the necessary callbacks and - display the widget, if possible. Plugins may have several UIs, in various - toolkits, but uiext:GtkUI is the only type that is defined in this - extension. */ + The actual type is defined by the type of the UI. +*/ typedef void* LV2UI_Widget; +/** + A pointer to UI instance internals. -/** A pointer to some host data required to instantiate a UI. - Like the type of the widget, the actual type of this pointer is defined by - the type URI of the UI. Hosts can use this to pass toolkit specific data - to a UI it needs to instantiate (type map, drawing context, etc). For the - uiext:GtkUI type this should be NULL. */ -typedef void* LV2UI_Host_Data; - - -/** This handle indicates a particular instance of a UI. - It is valid to compare this to NULL (0 for C++) but otherwise the - host MUST not attempt to interpret it. The UI plugin may use it to - reference internal instance data. */ + The host may compare this to NULL, but otherwise MUST NOT interpret it. +*/ typedef void* LV2UI_Handle; +/** + A pointer to a controller provided by the host. -/** This handle indicates a particular plugin instance, provided by the host. - It is valid to compare this to NULL (0 for C++) but otherwise the - UI plugin MUST not attempt to interpret it. The host may use it to - reference internal plugin instance data. */ + The UI may compare this to NULL, but otherwise MUST NOT interpret it. +*/ typedef void* LV2UI_Controller; - -/** This is the type of the host-provided function that the UI can use to - send data to a plugin's input ports. The @c buffer parameter must point - to a block of data, @c buffer_size bytes large. The contents of this buffer - will depend on the class of the port it's being sent to, and the transfer - mechanism specified for that port class. +/** + A pointer to opaque data for a feature. +*/ +typedef void* LV2UI_Feature_Handle; + +/** + A host-provided function that sends data to a plugin's input ports. + + The @p buffer parameter must point to a block of data, @p buffer_size bytes + large. The format of this data and how the host should use it is defined by + the @p port_protocol. This buffer is owned by the UI and is only valid for + the duration of this call. + + The @p port_protocol parameter should either be 0 or the URID for a + ui:PortProtocol. If it is 0, the protocol is implicitly ui:floatProtocol, + the port MUST be an lv2:ControlPort input, @p buffer MUST point to a single + float value, and @p buffer_size MUST be sizeof(float). - Transfer mechanisms are Features and may be defined in meta-extensions. - They specify how to translate the data buffers passed to this function - to input data for the plugin ports. If a UI wishes to write data to an - input port, it must list a transfer mechanism Feature for that port's - class as an optional or required feature (depending on whether the UI - will work without being able to write to that port or not). The only - exception is ports of the class lv2:ControlPort, for which @c buffer_size - should always be 4 and the buffer should always contain a single IEEE-754 - float. - - The UI MUST NOT try to write to a port for which there is no specified - transfer mechanism, or to an output port. The UI is responsible for - allocating the buffer and deallocating it after the call. A function - pointer of this type will be provided to the UI by the host in the - instantiate() function. - - An UI may list multiple transfer mechanisms for the same port type. - To tell the host which mechanism is to be used, it passes an integer ID - for the mechanism in the @c format parameter. This ID is retrieved from - a URI-to-integer mapping function provided by the host, using the URI Map - feature with the map URI - "http://lv2plug.in/ns/extensions/ui". Thus a UI that requires transfer - mechanism features MUST also require the URI Map feature. A @c format - value of 0 is a special case that always means that the buffer should - be interpreted as a single IEEE-754 float, and may only be written to - a control port. - - An UI MUST NOT pass a @c format parameter value (except 0) that has not - been returned by the host-provided URI mapping function for a - host-supported transfer mechanism feature URI. + The UI SHOULD NOT use a protocol not supported by the host, but the host + MUST gracefully ignore any protocol it does not understand. */ typedef void (*LV2UI_Write_Function)(LV2UI_Controller controller, uint32_t port_index, uint32_t buffer_size, - uint32_t format, + uint32_t port_protocol, const void* buffer); +/** + A plugin UI. -/** */ + A pointer to an object of this type is returned by the lv2ui_descriptor() + function. +*/ typedef struct _LV2UI_Descriptor { - - /** The URI for this UI (not for the plugin it controls). */ + /** + The URI for this UI (not for the plugin it controls). + */ const char* URI; - /** Create a new UI object and return a handle to it. This function works - similarly to the instantiate() member in LV2_Descriptor. + /** + Create a new UI and return a handle to it. This function works + similarly to LV2_Descriptor::instantiate(). + + @param descriptor The descriptor for the UI to instantiate. - @param descriptor The descriptor for the UI that you want to instantiate. @param plugin_uri The URI of the plugin that this UI will control. - @param bundle_path The path to the bundle containing the RDF data file - that references this shared object file, including the - trailing '/'. - @param write_function A function provided by the host that the UI can - use to send data to the plugin's input ports. - @param controller A handle for the plugin instance that should be passed - as the first parameter of @c write_function. - @param widget A pointer to an LV2UI_Widget. The UI will write a - widget pointer to this location (what type of widget - depends on the RDF class of the UI) that will be the - main UI widget. + + @param bundle_path The path to the bundle containing this UI, including + the trailing directory separator. + + @param write_function A function that the UI can use to send data to the + plugin's input ports. + + @param controller A handle for the plugin instance to be passed as the + first parameter of UI methods. + + @param widget (output) widget pointer. The UI points this at its main + widget, which has the type defined by the UI type in the data file. + @param features An array of LV2_Feature pointers. The host must pass - all feature URIs that it and the plugin supports and any - additional data, just like in the LV2 plugin - instantiate() function. + all feature URIs that it and the UI supports and any additional data, as + in LV2_Descriptor::instantiate(). Note that UI features and plugin + features are not necessarily the same. + */ LV2UI_Handle (*instantiate)(const struct _LV2UI_Descriptor* descriptor, const char* plugin_uri, @@ -258,55 +164,30 @@ const LV2_Feature* const* features); - /** Destroy the UI object and the associated widget. The host must not try - to access the widget after calling this function. + /** + Destroy the UI. The host must not try to access the widget after + calling this function. */ void (*cleanup)(LV2UI_Handle ui); - /** Tell the UI that something interesting has happened at a plugin port. - What is interesting and how it is written to the buffer passed to this - function is defined by transfer mechanism extensions (see - LV2UI_Write_Function). The only exception is ports of the class - lv2:ControlPort, for which this function should be called - when the port value changes (it does not have to be called for every - single change if the host's UI thread has problems keeping up with - the thread the plugin is running in), @c buffer_size should be 4 and the - buffer should contain a single IEEE-754 float. In this case the @c format - parameter should be 0. + /** + Tell the UI that something interesting has happened at a plugin port. - By default, the host should only call this function for input ports of - the lv2:ControlPort class. However, the default setting can be modified - by using the following URIs in the UI's RDF data: -

-      uiext:portNotification
-      uiext:noPortNotification
-      uiext:plugin
-      uiext:portIndex
-

- For example, if you want the UI with uri - for the plugin with URI - to get notified when the value of the - output control port with index 4 changes, you would use the following - in the RDF for your UI: -

-       uiext:portNotification [ uiext:plugin  ;
-                                                      uiext:portIndex 4 ] .
-

- and similarly with uiext:noPortNotification if you wanted - to prevent notifications for a port for which it would be on by default - otherwise. The UI is not allowed to request notifications for ports - for which no transfer mechanism is specified, if it does it should be - considered broken and the host should not load it. + What is "interesting" and how it is written to @p buffer is defined by + @p format, which has the same meaning as in LV2UI_Write_Function(). + Format 0 is a special case for lv2:ControlPort, where this function + should be called when the port value changes (but not necessarily for + every change), @p buffer_size must be sizeof(float), and @p buffer + points to a single IEEE-754 float. - The @c buffer is only valid during the time of this function call, so if - the UI wants to keep it for later use it has to copy the contents to an - internal buffer. + By default, the host should only call this function for lv2:ControlPort + inputs. However, the UI can request updates for other ports statically + with ui:portNotification or dynamicaly with ui:portSubscribe. - This member may be set to NULL if the UI is not interested in any - port events. + The UI MUST NOT retain any reference to @p buffer after this function + returns, it is only valid for the duration of the call. - The @c format parameter is used to specify the format of the buffer - contents, with the same restrictions as in LV2_Write_Function. + This member may be NULL if the UI is not interested in any port events. */ void (*port_event)(LV2UI_Handle ui, uint32_t port_index, @@ -314,44 +195,236 @@ uint32_t format, const void* buffer); - /** Returns a data structure associated with an extension URI, for example - a struct containing additional function pointers. Avoid returning - function pointers directly since standard C++ has no valid way of - casting a void* to a function pointer. This member may be set to NULL - if the UI is not interested in supporting any extensions. This is similar - to the extension_data() member in LV2_Descriptor. + /** + Return a data structure associated with an extension URI, typically an + interface struct with additional function pointers + + This member may be set to NULL if the UI is not interested in supporting + any extensions. This is similar to LV2_Descriptor::extension_data(). + */ const void* (*extension_data)(const char* uri); - } LV2UI_Descriptor; +/** + Feature/interface for resizable UIs (LV2_UI__resize). - -/** A plugin UI programmer must include a function called "lv2ui_descriptor" - with the following function prototype within the shared object - file. This function will have C-style linkage (if you are using - C++ this is taken care of by the 'extern "C"' clause at the top of - the file). This function will be accessed by the UI host using the - @c dlsym() function and called to get a LV2UI_UIDescriptor for the - wanted plugin. - - Just like lv2_descriptor(), this function takes an index parameter. The - index should only be used for enumeration and not as any sort of ID number - - the host should just iterate from 0 and upwards until the function returns - NULL, or a descriptor with an URI matching the one the host is looking for - is returned. + This structure is used in two ways: as a feature passed by the host via + LV2UI_Descriptor::instantiate(), or as an interface provided by a UI via + LV2UI_Descriptor::extension_data()). +*/ +typedef struct _LV2UI_Resize { + /** + Pointer to opaque data which must be passed to ui_resize(). + */ + LV2UI_Feature_Handle handle; + + /** + Request/advertise a size change. + + When provided by the host, the UI may call this function to inform the + host about the size of the UI. + + When provided by the UI, the host may call this function to notify the + UI that it should change its size accordingly. + + @return 0 on success. */ -const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index); - - -/** This is the type of the lv2ui_descriptor() function. */ -typedef const LV2UI_Descriptor* (*LV2UI_DescriptorFunction)(uint32_t index); + int (*ui_resize)(LV2UI_Feature_Handle handle, int width, int height); +} LV2UI_Resize; +/** + Feature to map port symbols to UIs. + This can be used by the UI to get the index for a port with the given + symbol. This makes it possible to implement and distribute a UI separately + from the plugin (since symbol, unlike index, is a stable port identifier). +*/ +typedef struct _LV2UI_Port_Map { + /** + Pointer to opaque data which must be passed to port_index(). + */ + LV2UI_Feature_Handle handle; + + /** + Get the index for the port with the given @p symbol. + + @return The index of the port, or LV2UI_INVALID_PORT_INDEX if no such + port is found. + */ + uint32_t (*port_index)(LV2UI_Feature_Handle handle, const char* symbol); +} LV2UI_Port_Map; + +/** + Feature to subscribe to port updates (LV2_UI__portSubscribe). +*/ +typedef struct _LV2UI_Port_Subscribe { + /** + Pointer to opaque data which must be passed to subscribe() and + unsubscribe(). + */ + LV2UI_Feature_Handle handle; + + /** + Subscribe to updates for a port. + + This means that the host will call the UI's port_event() function when + the port value changes (as defined by protocol). + + Calling this function with the same @p port_index and @p port_protocol + as an already active subscription has no effect. + + @param handle The handle field of this struct. + @param port_index The index of the port. + @param port_protocol The URID of the ui:PortProtocol. + @param features Features for this subscription. + @return 0 on success. + */ + uint32_t (*subscribe)(LV2UI_Feature_Handle handle, + uint32_t port_index, + uint32_t port_protocol, + const LV2_Feature* const* features); + + /** + Unsubscribe from updates for a port. + + This means that the host will cease calling calling port_event() when + the port value changes. + + Calling this function with a @p port_index and @p port_protocol that + does not refer to an active port subscription has no effect. + + @param handle The handle field of this struct. + @param port_index The index of the port. + @param port_protocol The URID of the ui:PortProtocol. + @param features Features for this subscription. + @return 0 on success. + */ + uint32_t (*unsubscribe)(LV2UI_Feature_Handle handle, + uint32_t port_index, + uint32_t port_protocol, + const LV2_Feature* const* features); +} LV2UI_Port_Subscribe; + +/** + A feature to notify the host that the user has grabbed a UI control. +*/ +typedef struct _LV2UI_Touch { + /** + Pointer to opaque data which must be passed to ui_resize(). + */ + LV2UI_Feature_Handle handle; + + /** + Notify the host that a control has been grabbed or released. + + The host should cease automating the port or otherwise manipulating the + port value until the control has been ungrabbed. + + @param handle The handle field of this struct. + @param port_index The index of the port associated with the control. + @param grabbed If true, the control has been grabbed, otherwise the + control has been released. + */ + void (*touch)(LV2UI_Feature_Handle handle, + uint32_t port_index, + bool grabbed); +} LV2UI_Touch; + +/** + UI Idle Interface (LV2_UI__idleInterface) + + UIs can provide this interface to have an idle() callback called by the host + rapidly to update the UI. +*/ +typedef struct _LV2UI_Idle_Interface { + /** + Run a single iteration of the UI's idle loop. + + This will be called rapidly in the UI thread at a rate appropriate + for a toolkit main loop. There are no precise timing guarantees, but + the host should attempt to call idle() at a high enough rate for smooth + animation, at least 30Hz. + + @return non-zero if the UI has been closed, in which case the host + should stop calling idle(), and can either completely destroy the UI, or + re-show it and resume calling idle(). + */ + int (*idle)(LV2UI_Handle ui); +} LV2UI_Idle_Interface; + +/** + UI Show Interface (LV2_UI__showInterface) + + UIs can provide this interface to show and hide a window, which allows them + to function in hosts unable to embed their widget. This allows any UI to + provide a fallback for embedding that works in any host. + + If used: + - The host MUST use LV2UI_Idle_Interface to drive the UI. + - The UI MUST return non-zero from LV2UI_Idle_Interface::idle() when it has been closed. + - If idle() returns non-zero, the host MUST call hide() and stop calling + idle(). It MAY later call show() then resume calling idle(). +*/ +typedef struct _LV2UI_Show_Interface { + /** + Show a window for this UI. + + The window title MAY have been passed by the host to + LV2UI_Descriptor::instantiate() as an LV2_Options_Option with key + LV2_UI__windowTitle. + + @return 0 on success, or anything else to stop being called. + */ + int (*show)(LV2UI_Handle ui); + + /** + Hide the window for this UI. + + @return 0 on success, or anything else to stop being called. + */ + int (*hide)(LV2UI_Handle ui); +} LV2UI_Show_Interface; + +/** + Peak data for a slice of time, the update format for ui:peakProtocol. +*/ +typedef struct _LV2UI_Peak_Data { + /** + The start of the measurement period. This is just a running counter + that is only meaningful in comparison to previous values and must not be + interpreted as an absolute time. + */ + uint32_t period_start; + + /** + The size of the measurement period, in the same units as period_start. + */ + uint32_t period_size; + + /** + The peak value for the measurement period. This should be the maximal + value for abs(sample) over all the samples in the period. + */ + float peak; +} LV2UI_Peak_Data; + +/** + Prototype for UI accessor function. + + This is the entry point to a UI library, which works in the same way as + lv2_descriptor() but for UIs rather than plugins. +*/ +LV2_SYMBOL_EXPORT +const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index); + +/** + The type of the lv2ui_descriptor() function. +*/ +typedef const LV2UI_Descriptor* (*LV2UI_DescriptorFunction)(uint32_t index); #ifdef __cplusplus } #endif - -#endif +#endif /* LV2_UI_H */ diff -Nru calf-0.0.19+git20140527+e79ddef54/src/calf/metadata.h calf-0.0.19+git20140915+5de5da28/src/calf/metadata.h --- calf-0.0.19+git20140527+e79ddef54/src/calf/metadata.h 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/calf/metadata.h 2014-09-13 19:46:25.000000000 +0000 @@ -101,6 +101,13 @@ PLUGIN_NAME_ID_LABEL("haasenhancer", "haasenhancer", "Haas Stereo Enhancer") }; +struct reverse_delay_metadata: public plugin_metadata +{ + enum { par_bpm, par_bpm_host, par_divide, par_time_l, par_time_r, par_feedback, par_amount, par_width, par_sync, par_sync_led_l, par_sync_led_r, par_reset, par_window, param_count }; + enum { in_count = 2, out_count = 2, ins_optional = 0, outs_optional = 0, rt_capable = true, support_midi = false, require_midi = false }; + PLUGIN_NAME_ID_LABEL("reversedelay", "reversedelay", "Reverse Delay") +}; + struct rotary_speaker_metadata: public plugin_metadata { public: @@ -415,6 +422,88 @@ enum { PeakBands = 8, first_graph_param = param_hp_active, last_graph_param = param_p8_q }; PLUGIN_NAME_ID_LABEL("equalizer12band", "eq12", "Equalizer 12 Band") }; +/// 30-band EQ - metadata +struct equalizer30band_metadata: public plugin_metadata +{ + enum { in_count = 2, out_count = 2, ins_optional = 0, outs_optional = 0, support_midi = false, require_midi = false, rt_capable = true }; + enum { + param_level_in, param_level_in_vuL, param_level_in_vuR, param_level_in_clipL, param_level_in_clipR, + param_bypass, param_filters, + param_gainscale1, param_gainscale2, + param_level_out, param_level_out_vuL, param_level_out_vuR, param_level_out_clipL, param_level_out_clipR, + + //1 - 30 Bands + param_gain10, param_gain_scale10, + param_gain11, param_freq11, param_gain_scale11, + param_gain12, param_freq12, param_gain_scale12, + param_gain13, param_freq13, param_gain_scale13, + param_gain14, param_freq14, param_gain_scale14, + param_gain15, param_freq15, param_gain_scale15, + param_gain16, param_freq16, param_gain_scale16, + param_gain17, param_freq17, param_gain_scale17, + param_gain18, param_freq18, param_gain_scale18, + param_gain19, param_freq19, param_gain_scale19, + param_gain110, param_freq110, param_gain_scale110, + param_gain111, param_freq111, param_gain_scale111, + param_gain112, param_freq112, param_gain_scale112, + param_gain113, param_freq113, param_gain_scale113, + param_gain114, param_freq114, param_gain_scale114, + param_gain115, param_freq115, param_gain_scale115, + param_gain116, param_freq116, param_gain_scale116, + param_gain117, param_freq117, param_gain_scale117, + param_gain118, param_freq118, param_gain_scale118, + param_gain119, param_freq119, param_gain_scale119, + param_gain120, param_freq120, param_gain_scale120, + param_gain121, param_freq121, param_gain_scale121, + param_gain122, param_freq122, param_gain_scale122, + param_gain123, param_freq123, param_gain_scale123, + param_gain124, param_freq124, param_gain_scale124, + param_gain125, param_freq125, param_gain_scale125, + param_gain126, param_freq126, param_gain_scale126, + param_gain127, param_freq127, param_gain_scale127, + param_gain128, param_freq128, param_gain_scale128, + param_gain129, param_freq129, param_gain_scale129, + param_gain130, param_freq130, param_gain_scale130, + + //2 - 30 Bands + param_gain20, param_gain_scale20, + param_gain21, param_freq21, param_gain_scale21, + param_gain22, param_freq22, param_gain_scale22, + param_gain23, param_freq23, param_gain_scale23, + param_gain24, param_freq24, param_gain_scale24, + param_gain25, param_freq25, param_gain_scale25, + param_gain26, param_freq26, param_gain_scale26, + param_gain27, param_freq27, param_gain_scale27, + param_gain28, param_freq28, param_gain_scale28, + param_gain29, param_freq29, param_gain_scale29, + param_gain210, param_freq210, param_gain_scale210, + param_gain211, param_freq211, param_gain_scale211, + param_gain212, param_freq212, param_gain_scale212, + param_gain213, param_freq213, param_gain_scale213, + param_gain214, param_freq214, param_gain_scale214, + param_gain215, param_freq215, param_gain_scale215, + param_gain216, param_freq216, param_gain_scale216, + param_gain217, param_freq217, param_gain_scale217, + param_gain218, param_freq218, param_gain_scale218, + param_gain219, param_freq219, param_gain_scale219, + param_gain220, param_freq220, param_gain_scale220, + param_gain221, param_freq221, param_gain_scale221, + param_gain222, param_freq222, param_gain_scale222, + param_gain223, param_freq223, param_gain_scale223, + param_gain224, param_freq224, param_gain_scale224, + param_gain225, param_freq225, param_gain_scale225, + param_gain226, param_freq226, param_gain_scale226, + param_gain227, param_freq227, param_gain_scale227, + param_gain228, param_freq228, param_gain_scale228, + param_gain229, param_freq229, param_gain_scale229, + param_gain230, param_freq230, param_gain_scale230, + + param_count }; + enum { band_params = 3 }; + enum { gain_step = 6 }; + + PLUGIN_NAME_ID_LABEL("equalizer30band", "eq30", "Equalizer 30 Band") +}; /// Markus's X-Overs struct xover2_metadata: public plugin_metadata { diff -Nru calf-0.0.19+git20140527+e79ddef54/src/calf/modulelist.h calf-0.0.19+git20140915+5de5da28/src/calf/modulelist.h --- calf-0.0.19+git20140527+e79ddef54/src/calf/modulelist.h 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/calf/modulelist.h 2014-09-13 19:46:25.000000000 +0000 @@ -22,6 +22,7 @@ // Delay PER_MODULE_ITEM(vintage_delay, false, "vintagedelay") PER_MODULE_ITEM(comp_delay, false, "compdelay") + PER_MODULE_ITEM(reverse_delay, false, "reversedelay") // Compressor PER_MODULE_ITEM(compressor, false, "compressor") @@ -54,6 +55,7 @@ PER_MODULE_ITEM(equalizer5band, false, "eq5") PER_MODULE_ITEM(equalizer8band, false, "eq8") PER_MODULE_ITEM(equalizer12band, false, "eq12") + PER_MODULE_ITEM(equalizer30band, false, "eq30") // Distrotion PER_MODULE_ITEM(saturator, false, "saturator") diff -Nru calf-0.0.19+git20140527+e79ddef54/src/calf/modules_delay.h calf-0.0.19+git20140915+5de5da28/src/calf/modules_delay.h --- calf-0.0.19+git20140527+e79ddef54/src/calf/modules_delay.h 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/calf/modules_delay.h 2014-09-13 19:46:25.000000000 +0000 @@ -158,5 +158,35 @@ uint32_t process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask); }; +/********************************************************************** + * REVERSE DELAY +**********************************************************************/ + +class reverse_delay_audio_module: public audio_module +{ +public: + enum { MAX_DELAY = 6144000, ADDR_MASK = MAX_DELAY - 1 }; + float buffers[2][MAX_DELAY]; + int counters[2]; + dsp::overlap_window ow[2]; + int deltime_l, deltime_r; + + dsp::gain_smoothing fb_val, dry, width; + + float feedback_buf[2]; + + uint32_t srate; + + uint32_t line_state_old; + + reverse_delay_audio_module(); + + void params_changed(); + void activate(); + void deactivate(); + void set_sample_rate(uint32_t sr); + uint32_t process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask); +}; + }; #endif diff -Nru calf-0.0.19+git20140527+e79ddef54/src/calf/modules_filter.h calf-0.0.19+git20140915+5de5da28/src/calf/modules_filter.h --- calf-0.0.19+git20140527+e79ddef54/src/calf/modules_filter.h 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/calf/modules_filter.h 2014-09-13 19:46:25.000000000 +0000 @@ -32,6 +32,7 @@ #include "loudness.h" #include "analyzer.h" #include "bypass.h" +#include "orfanidis_eq.h" namespace calf_plugins { @@ -100,6 +101,41 @@ typedef equalizerNband_audio_module equalizer12band_audio_module; /********************************************************************** + * EQUALIZER 30 BAND +**********************************************************************/ + +class equalizer30band_audio_module: public audio_module { + orfanidis_eq::conversions conv; + orfanidis_eq::freq_grid fg; + std::vector eq_arrL; + std::vector eq_arrR; + + orfanidis_eq::filter_type flt_type; + orfanidis_eq::filter_type flt_type_old; + + dsp::switcher swL; + dsp::switcher swR; + + bool is_freq_grid_init; + void set_freq_grid(); + +public: + uint32_t srate; + bool is_active; + dsp::bypass bypass; + dsp::bypass eq_switch; + vumeters meters; + equalizer30band_audio_module(); + ~equalizer30band_audio_module(); + + void activate(); + void deactivate(); + void params_changed(); + void set_sample_rate(uint32_t sr); + uint32_t process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask); +}; + +/********************************************************************** * FILTER MODULE by Krzysztof Foltman **********************************************************************/ diff -Nru calf-0.0.19+git20140527+e79ddef54/src/calf/orfanidis_eq.h calf-0.0.19+git20140915+5de5da28/src/calf/orfanidis_eq.h --- calf-0.0.19+git20140527+e79ddef54/src/calf/orfanidis_eq.h 1970-01-01 00:00:00.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/calf/orfanidis_eq.h 2014-09-13 19:46:25.000000000 +0000 @@ -0,0 +1,1161 @@ +#ifndef ORFANIDIS_EQ_H_ +#define ORFANIDIS_EQ_H_ + +#include +#include + +using namespace std; + +namespace orfanidis_eq { + +//Eq data types. +typedef double eq_single_t; +typedef double eq_double_t; +//NOTE: the default float type usage +//can have shortage of precision + +//Eq types +typedef enum { + none, + butterworth, + chebyshev1, + chebyshev2 +} filter_type; + +static const char *get_eq_text(filter_type type) { + switch(type) { + case none: + return "not initialized"; + case butterworth: + return "butterworth"; + case chebyshev1: + return "chebyshev1"; + case chebyshev2: + return "chebyshev2"; + default: + return "none"; + } +} + +//Eq errors +typedef enum { + no_error, + invalid_input_data_error, + processing_error +} eq_error_t; + +//Constants +static const eq_double_t pi = 3.1415926535897932384626433832795; +static const unsigned int fo_section_order = 4; + +//Default gains +static const int max_base_gain_db = 0; +static const int min_base_gain_db = -60; +static const int butterworth_band_gain_db = -3; +static const int chebyshev1_band_base_gain_db = -6; +static const int chebyshev2_band_base_gain_db = -40; +static const int eq_min_max_gain_db = 46; + +//Default freq's +static const eq_double_t lowest_grid_center_freq_hz = 31.25; +static const eq_double_t bands_grid_center_freq_hz = 1000; +static const eq_double_t lowest_audio_freq_hz = 20; +static const eq_double_t highest_audio_freq_hz = 20000; + +//Eq config constants +static const unsigned int default_eq_band_filters_order = 4; //>2 +static const eq_double_t default_sample_freq_hz = 48000; + +//Precomputed Eq (eq2) config constants +static const eq_double_t p_eq_min_max_gain_db = 40; +static const eq_double_t p_eq_gain_step_db = 1; +static const eq_double_t common_base_gain_db = 3; +static const eq_double_t p_eq_default_gain_db = 0; + +//Version +static const char* eq_version = "0.01"; + + +//------------ Conversion functions class ------------ +class conversions +{ + int db_min_max; + std::vector lin_gains; + + int lin_gains_index(eq_double_t x) { + int int_x = (int)x; + if((x >= -db_min_max) && (x < db_min_max - 1)) + return db_min_max + int_x; + + return db_min_max; + } + + conversions(){} + +public: + conversions(int min_max) { + db_min_max = min_max; + //Update table (vector elements) for fast conversions + int step = -min_max; + while(step <= min_max) + lin_gains.push_back(db_2_lin(step++)); + } + + inline eq_double_t fast_db_2_lin(eq_double_t x) { + int int_part = (int)x; + eq_double_t frac_part = x - int_part; + return lin_gains[lin_gains_index(int_part)]*(1-frac_part) + + (lin_gains[lin_gains_index(int_part + 1)])*frac_part; + } + + inline eq_double_t fast_lin_2_db(eq_double_t x) { + if((x >= lin_gains[0]) && (x < lin_gains[lin_gains.size() - 1])) { + for (unsigned int i = 0; i < lin_gains.size() - 2; i++) + if((x >= lin_gains[i]) && (x < lin_gains[i + 1])) { + int int_part = i - db_min_max; + eq_double_t frac_part = x - (int)(x); + return int_part + frac_part; + } + } + return 0; + } + + inline static eq_double_t db_2_lin(eq_double_t x) { + return pow(10, x/20); + } + + inline static eq_double_t lin_2_db(eq_double_t x) { + return 20*log10(x); + } + + inline static eq_double_t rad_2_hz(eq_double_t x, eq_double_t fs) { + return 2*pi/x*fs; + } + + inline static eq_double_t hz_2_rad(eq_double_t x, eq_double_t fs) { + return 2*pi*x/fs; + } +}; + +//------------ Band freq's structure ------------ +struct band_freqs { +private: + band_freqs(); + +public: + eq_double_t min_freq; + eq_double_t center_freq; + eq_double_t max_freq; + + band_freqs(eq_double_t f1, eq_double_t f0, eq_double_t f2): + min_freq(f1), center_freq(f0), max_freq(f2){} + + ~band_freqs(){} +}; + +//------------ Frequency grid class ------------ +class freq_grid { +private: + std::vector freqs_; + +public: + freq_grid(){} + freq_grid(const freq_grid& fg){this->freqs_ = fg.freqs_;} + ~freq_grid(){} + + eq_error_t set_band(eq_double_t fmin, eq_double_t f0, eq_double_t fmax) { + freqs_.clear(); + return add_band(fmin, f0, fmax); + } + + //fc, fmin, fmax + eq_error_t add_band(eq_double_t fmin, eq_double_t f0, eq_double_t fmax) { + if(fmin < f0 && f0 < fmax) + freqs_.push_back(band_freqs(fmin, f0, fmax)); + else + return invalid_input_data_error; + return no_error; + } + + //f0, deltaf = fmax - fmin + eq_error_t add_band(eq_double_t f0, eq_double_t df) { + if(f0 >= df/2) + { + eq_double_t fmin = f0 - df/2; + eq_double_t fmax = f0 + df/2; + freqs_.push_back(band_freqs(fmin, f0, fmax)); + } + else + return invalid_input_data_error; + return no_error; + } + + eq_error_t set_5_bands(eq_double_t center_freq = bands_grid_center_freq_hz) { + freqs_.clear(); + if(lowest_audio_freq_hz < center_freq && + center_freq < highest_audio_freq_hz) { + + //Find lowest center frequency in band + eq_double_t lowest_center_freq = center_freq; + while(lowest_center_freq > lowest_grid_center_freq_hz) + lowest_center_freq/=4.0; + if(lowest_center_freq < lowest_grid_center_freq_hz) + lowest_center_freq*=4.0; + + //Calculate freq's + eq_double_t f0 = lowest_center_freq; + for(unsigned int i = 0; i < 5 ; i++) { + freqs_.push_back(band_freqs(f0/2, f0, f0*2)); + f0 *= 4; + } + } + else + return invalid_input_data_error; + return no_error; + } + + eq_error_t set_10_bands(eq_double_t center_freq = bands_grid_center_freq_hz) { + freqs_.clear(); + if(lowest_audio_freq_hz < center_freq && + center_freq < highest_audio_freq_hz) { + + //Find lowest center frequency in band + eq_double_t lowest_center_freq = center_freq; + while(lowest_center_freq > lowest_grid_center_freq_hz) + lowest_center_freq/=2; + if(lowest_center_freq < lowest_grid_center_freq_hz) + lowest_center_freq*=2; + + //Calculate freq's + eq_double_t f0 = lowest_center_freq; + for(unsigned int i = 0; i < 10; i++) { + freqs_.push_back(band_freqs(f0/pow(2,0.5), f0, f0*pow(2,0.5))); + f0 *= 2; + } + } + else + return invalid_input_data_error; + return no_error; + } + + eq_error_t set_20_bands(eq_double_t center_freq = bands_grid_center_freq_hz) { + freqs_.clear(); + if(lowest_audio_freq_hz < center_freq && + center_freq < highest_audio_freq_hz) { + + //Find lowest center frequency in band + eq_double_t lowest_center_freq = center_freq; + while(lowest_center_freq > lowest_audio_freq_hz) + lowest_center_freq/=pow(2,0.5); + if(lowest_center_freq < lowest_audio_freq_hz) + lowest_center_freq*=pow(2,0.5); + + //Calculate freq's + eq_double_t f0 = lowest_center_freq; + for(unsigned int i = 0; i < 20; i++) { + freqs_.push_back(band_freqs(f0/pow(2,0.25), + f0, f0*pow(2,0.25))); + f0 *= pow(2,0.5); + } + } + else + return invalid_input_data_error; + return no_error; + } + + eq_error_t set_30_bands(eq_double_t center_freq = bands_grid_center_freq_hz) { + freqs_.clear(); + if(lowest_audio_freq_hz < center_freq && + center_freq < highest_audio_freq_hz) { + + //Find lowest center frequency in band + eq_double_t lowest_center_freq = center_freq; + while(lowest_center_freq > lowest_audio_freq_hz) + lowest_center_freq/=pow(2.0,1.0/3.0); + if(lowest_center_freq < lowest_audio_freq_hz) + lowest_center_freq*=pow(2.0,1.0/3.0); + + //Calculate freq's + eq_double_t f0 = lowest_center_freq; + for(unsigned int i = 0; i < 30; i++) { + freqs_.push_back(band_freqs(f0/pow(2.0,1.0/6.0), + f0, f0*pow(2.0,1.0/6.0))); + f0 *= pow(2,1.0/3.0); + } + } + else + return invalid_input_data_error; + return no_error; + } + + unsigned int get_number_of_bands(){return freqs_.size();} + + std::vector get_freqs(){return freqs_;} + + unsigned int get_freq(unsigned int number) { + if(number < freqs_.size()) + return freqs_[number].center_freq; + else + return 0; + } + + unsigned int get_rounded_freq(unsigned int number) { + if(number < freqs_.size()) { + unsigned int freq = freqs_[number].center_freq; + if (freq < 100) + return freq; + else if(freq >= 100 && freq < 1000) { + unsigned int rest = freq%10; + if(rest < 5) + return freq - rest; + else + return freq - rest + 10; + } + else if(freq >= 1000 && freq < 10000) { + unsigned int rest = freq%100; + if(rest < 50) + return freq - rest; + else + return freq - rest + 100; + } + else if(freq >= 10000) { + unsigned int rest = freq%1000; + if(rest < 500) + return freq - rest; + else + return freq - rest + 1000; + } + } + return 0; + } +}; + +//------------ Forth order sections ------------ +class fo_section { +protected: +eq_single_t b0; eq_single_t b1; eq_single_t b2; eq_single_t b3; eq_single_t b4; +eq_single_t a0; eq_single_t a1; eq_single_t a2; eq_single_t a3; eq_single_t a4; + +eq_single_t numBuf[fo_section_order]; +eq_single_t denumBuf[fo_section_order]; + +inline eq_single_t df1_fo_process(eq_single_t in) { + eq_single_t out = 0; + out+= b0*in; + out+= (b1*numBuf[0] - denumBuf[0]*a1); + out+= (b2*numBuf[1] - denumBuf[1]*a2); + out+= (b3*numBuf[2] - denumBuf[2]*a3); + out+= (b4*numBuf[3] - denumBuf[3]*a4); + + numBuf[3] = numBuf[2]; + numBuf[2] = numBuf[1]; + numBuf[1] = numBuf[0]; + *numBuf = in; + + denumBuf[3] = denumBuf[2]; + denumBuf[2] = denumBuf[1]; + denumBuf[1] = denumBuf[0]; + *denumBuf = out; + + return(out); + } + +public: + fo_section() { + b0 = 1; b1 = 0; b2 = 0; b3 = 0; b4 = 0; + a0 = 1; a1 = 0; a2 = 0; a3 = 0; a4 = 0; + + for(unsigned int i = 0; i < fo_section_order; i++) { + numBuf[i] = 0; + denumBuf[i] = 0; + } + } + + virtual ~fo_section(){} + + eq_single_t process(eq_single_t in) { + return df1_fo_process(in); + } + + virtual fo_section get() { + return *this; + } +}; + +class butterworth_fo_section : public fo_section { + butterworth_fo_section(){} + butterworth_fo_section(butterworth_fo_section&){} +public: + butterworth_fo_section(eq_double_t beta, + eq_double_t s, eq_double_t g, eq_double_t g0, + eq_double_t D, eq_double_t c0) { + b0 = (g*g*beta*beta + 2*g*g0*s*beta + g0*g0)/D; + b1 = -4*c0*(g0*g0 + g*g0*s*beta)/D; + b2 = 2*(g0*g0*(1 + 2*c0*c0) - g*g*beta*beta)/D; + b3 = -4*c0*(g0*g0 - g*g0*s*beta)/D; + b4 = (g*g*beta*beta - 2*g*g0*s*beta + g0*g0)/D; + + a0 = 1; + a1 = -4*c0*(1 + s*beta)/D; + a2 = 2*(1 + 2*c0*c0 - beta*beta)/D; + a3 = -4*c0*(1 - s*beta)/D; + a4 = (beta*beta - 2*s*beta + 1)/D; + } + + fo_section get() {return *this;} +}; + +class chebyshev_type1_fo_section : public fo_section { + chebyshev_type1_fo_section(){} + chebyshev_type1_fo_section(chebyshev_type1_fo_section&){} +public: + chebyshev_type1_fo_section(eq_double_t a, + eq_double_t c, eq_double_t tetta_b, + eq_double_t g0, eq_double_t s, eq_double_t b, + eq_double_t D, eq_double_t c0) { + b0 = ((b*b + g0*g0*c*c)*tetta_b*tetta_b + 2*g0*b*s*tetta_b + g0*g0)/D; + b1 = -4*c0*(g0*g0 + g0*b*s*tetta_b)/D; + b2 = 2*(g0*g0*(1 + 2*c0*c0) - (b*b + g0*g0*c*c)*tetta_b*tetta_b)/D; + b3 = -4*c0*(g0*g0 - g0*b*s*tetta_b)/D; + b4 = ((b*b + g0*g0*c*c)*tetta_b*tetta_b - 2*g0*b*s*tetta_b + g0*g0)/D; + + a0 = 1; + a1 = -4*c0*(1 + a*s*tetta_b)/D; + a2 = 2*(1 + 2*c0*c0 - (a*a + c*c)*tetta_b*tetta_b)/D; + a3 = -4*c0*(1 - a*s*tetta_b)/D; + a4 = ((a*a + c*c)*tetta_b*tetta_b - 2*a*s*tetta_b + 1)/D; + } + + fo_section get() {return *this;} +}; + +class chebyshev_type2_fo_section : public fo_section { + chebyshev_type2_fo_section(){} + chebyshev_type2_fo_section(chebyshev_type2_fo_section&){} +public: + chebyshev_type2_fo_section(eq_double_t a, + eq_double_t c, eq_double_t tetta_b, + eq_double_t g, eq_double_t s, eq_double_t b, + eq_double_t D, eq_double_t c0) { + b0 = (g*g*tetta_b*tetta_b + 2*g*b*s*tetta_b + b*b + g*g*c*c)/D; + b1 = -4*c0*(b*b + g*g*c*c + g*b*s*tetta_b)/D; + b2 = 2*((b*b + g*g*c*c)*(1 + 2*c0*c0) - g*g*tetta_b*tetta_b)/D; + b3 = -4*c0*(b*b + g*g*c*c - g*b*s*tetta_b)/D; + b4 = (g*g*tetta_b*tetta_b - 2*g*b*s*tetta_b + b*b + g*g*c*c)/D; + + a0 = 1; + a1 = -4*c0*(a*a + c*c + a*s*tetta_b)/D; + a2 = 2*((a*a + c*c)*(1 + 2*c0*c0) - tetta_b*tetta_b)/D; + a3 = -4*c0*(a*a + c*c - a*s*tetta_b)/D; + a4 = (tetta_b*tetta_b - 2*a*s*tetta_b + a*a + c*c)/D; + } + + fo_section get() {return *this;} +}; + +//------------ Bandpass filters ------------ +class bp_filter { +public: + bp_filter(){} + virtual ~bp_filter(){} + + virtual eq_single_t process(eq_single_t in) = 0; +}; + +class butterworth_bp_filter : public bp_filter { +private: + std::vector sections_; + + butterworth_bp_filter(){} +public: + butterworth_bp_filter(butterworth_bp_filter& f) { + this->sections_ = f.sections_; + } + + butterworth_bp_filter(unsigned int N, + eq_double_t w0, eq_double_t wb, + eq_double_t G, eq_double_t Gb, eq_double_t G0) { + //Case if G == 0 : allpass + if(G == 0 && G0 == 0) { + sections_.push_back(fo_section()); + return; + } + + //Get number of analog sections + unsigned int r = N%2; + unsigned int L = (N - r)/2; + + //Convert gains to linear scale + G = conversions::db_2_lin(G); + Gb = conversions::db_2_lin(Gb); + G0 = conversions::db_2_lin(G0); + + eq_double_t epsilon = pow(((eq_double_t)(G*G - Gb*Gb))/ + (Gb*Gb - G0*G0),0.5); + eq_double_t g = pow(((eq_double_t)G),1.0/((eq_double_t)N)); + eq_double_t g0 = pow(((eq_double_t)G0),1.0/((eq_double_t)N)); + eq_double_t beta = pow(((eq_double_t)epsilon), -1.0/((eq_double_t)N))* + tan(wb/2.0); + + eq_double_t c0 = cos(w0); + if (w0 == 0) c0 = 1; + if (w0 == pi/2) c0=0; + if (w0 == pi) c0 =- 1; + + //Calculate every section + for(unsigned int i = 1; i <= L; i++) { + eq_double_t ui = (2.0*i-1)/N; + eq_double_t si = sin(pi*ui/2.0); + + eq_double_t Di = beta*beta + 2*si*beta + 1; + + sections_.push_back + (butterworth_fo_section(beta, si, g, g0, Di, c0)); + } + } + + ~butterworth_bp_filter(){} + + static eq_single_t compute_bw_gain_db(eq_single_t gain) { + eq_single_t bw_gain = 0; + if(gain <= -6) + bw_gain = gain + common_base_gain_db; + else if(gain > -6 && gain < 6) + bw_gain = gain*0.5; + else if(gain >= 6) + bw_gain = gain - common_base_gain_db; + + return bw_gain; + } + + virtual eq_single_t process(eq_single_t in) { + eq_single_t p0 = in; + eq_single_t p1 = 0; + //Process FO sections in serial connection + for(unsigned int i = 0; i < sections_.size(); i++) { + p1 = sections_[i].process(p0); + p0 = p1; + } + + return p1; + } +}; + +class chebyshev_type1_bp_filter : public bp_filter { +private: + std::vector sections_; + + chebyshev_type1_bp_filter(){} +public: + chebyshev_type1_bp_filter(unsigned int N, + eq_double_t w0, eq_double_t wb, + eq_double_t G, eq_double_t Gb, eq_double_t G0) { + //Case if G == 0 : allpass + if(G == 0 && G0 == 0) { + sections_.push_back(fo_section()); + return; + } + + //Get number of analog sections + unsigned int r = N%2; + unsigned int L = (N - r)/2; + + //Convert gains to linear scale + G = conversions::db_2_lin(G); + Gb = conversions::db_2_lin(Gb); + G0 = conversions::db_2_lin(G0); + + eq_double_t epsilon = pow((eq_double_t)(G*G - Gb*Gb)/ + (Gb*Gb - G0*G0),0.5); + eq_double_t g0 = pow((eq_double_t)(G0),1.0/N); + eq_double_t alfa = + pow(1.0/epsilon + pow(1 + pow(epsilon,-2.0),0.5),1.0/N); + eq_double_t beta = + pow(G/epsilon + Gb*pow(1 + pow(epsilon,-2.0),0.5),1.0/N); + eq_double_t a = 0.5*(alfa - 1.0/alfa); + eq_double_t b = 0.5*(beta - g0*g0*(1/beta)); + eq_double_t tetta_b = tan(wb/2); + + eq_double_t c0 = cos(w0); + if (w0 == 0) c0 = 1; + if (w0 == pi/2) c0=0; + if (w0 == pi) c0 =- 1; + + //Calculate every section + for(unsigned int i = 1; i <= L; i++) { + eq_double_t ui = (2.0*i-1.0)/N; + eq_double_t ci = cos(pi*ui/2.0); + eq_double_t si = sin(pi*ui/2.0); + + eq_double_t Di = (a*a + ci*ci)*tetta_b*tetta_b + + 2.0*a*si*tetta_b + 1; + sections_.push_back( + chebyshev_type1_fo_section(a, ci, tetta_b, g0, si, b, Di, c0)); + } + } + + + ~chebyshev_type1_bp_filter(){} + + static eq_single_t compute_bw_gain_db(eq_single_t gain) { + eq_single_t bw_gain = 0; + if(gain <= -6) + bw_gain = gain + 1; + else if(gain > -6 && gain < 6) + bw_gain = gain*0.9; + else if(gain >= 6) + bw_gain = gain - 1; + + return bw_gain; + } + + eq_single_t process(eq_single_t in) { + eq_single_t p0 = in; + eq_single_t p1 = 0; + //Process FO sections in serial connection + for(unsigned int i = 0; i < sections_.size(); i++) { + p1 = sections_[i].process(p0); + p0 = p1; + } + + return p1; + } +}; + +class chebyshev_type2_bp_filter : public bp_filter { +private: + std::vector sections_; + + chebyshev_type2_bp_filter(){} +public: + chebyshev_type2_bp_filter(unsigned int N, + eq_double_t w0, eq_double_t wb, + eq_double_t G, eq_double_t Gb, eq_double_t G0) { + //Case if G == 0 : allpass + if(G == 0 && G0 == 0) { + sections_.push_back(fo_section()); + return; + } + + //Get number of analog sections + unsigned int r = N%2; + unsigned int L = (N - r)/2; + + //Convert gains to linear scale + G = conversions::db_2_lin(G); + Gb = conversions::db_2_lin(Gb); + G0 = conversions::db_2_lin(G0); + + eq_double_t epsilon = pow((eq_double_t)((G*G - Gb*Gb)/ + (Gb*Gb - G0*G0)),0.5); + eq_double_t g = pow((eq_double_t)(G),1.0/N); + eq_double_t eu = pow(epsilon + sqrt(1 + epsilon*epsilon), 1.0/N); + eq_double_t ew = pow(G0*epsilon + Gb*sqrt(1 + epsilon*epsilon), 1.0/N); + eq_double_t a = (eu - 1.0/eu)/2.0; + eq_double_t b = (ew - g*g/ew)/2.0; + eq_double_t tetta_b = tan(wb/2); + + eq_double_t c0 = cos(w0); + if (w0 == 0) c0 = 1; + if (w0 == pi/2) c0=0; + if (w0 == pi) c0 =- 1; + + //Calculate every section + for(unsigned int i = 1; i <= L; i++) { + eq_double_t ui = (2.0*i-1.0)/N; + eq_double_t ci = cos(pi*ui/2.0); + eq_double_t si = sin(pi*ui/2.0); + eq_double_t Di = tetta_b*tetta_b + 2*a*si*tetta_b + a*a + ci*ci; + + sections_.push_back( + chebyshev_type2_fo_section(a, ci, tetta_b, g, si, b, Di, c0)); + } + } + + ~chebyshev_type2_bp_filter(){} + + static eq_single_t compute_bw_gain_db(eq_single_t gain) { + eq_single_t bw_gain = 0; + if(gain <= -6) + bw_gain = -common_base_gain_db; + else if(gain > -6 && gain < 6) + bw_gain = gain*0.3; + else if(gain >= 6) + bw_gain = common_base_gain_db; + + return bw_gain; + } + + eq_single_t process(eq_single_t in) { + eq_single_t p0 = in; + eq_single_t p1 = 0; + + //Process FO sections in serial connection + for(unsigned int i = 0; i < sections_.size(); i++) { + p1 = sections_[i].process(p0); + p0 = p1; + } + + return p1; + } +}; + +// ------------ eq1 ------------ +// Equalizer with single precomputed filter for every band +class eq1 { +private: + conversions conv_; + eq_double_t sampling_frequency_; + freq_grid freq_grid_; + std::vector band_gains_; + std::vector filters_; + filter_type current_eq_type_; + + eq1():conv_(eq_min_max_gain_db){} + eq1(const eq1&):conv_(eq_min_max_gain_db){} + + void cleanup_filters_array() { + for(unsigned int j = 0; j < filters_.size(); j++) + delete filters_[j]; + } + +public: + eq1(const freq_grid &fg, filter_type eq_t) : conv_(eq_min_max_gain_db) { + sampling_frequency_ = default_sample_freq_hz; + freq_grid_ = fg; + current_eq_type_ = eq_t; + set_eq(freq_grid_, eq_t); + } + ~eq1(){cleanup_filters_array();} + + eq_error_t set_eq(freq_grid& fg, filter_type eqt) { + band_gains_.clear(); + cleanup_filters_array(); + filters_.clear(); + freq_grid_ = fg; + + for(unsigned int i = 0; i < freq_grid_.get_number_of_bands(); i++) { + + eq_double_t wb = conversions::hz_2_rad( + freq_grid_.get_freqs()[i].max_freq - + freq_grid_.get_freqs()[i].min_freq, + sampling_frequency_); + + eq_double_t w0 = conversions::hz_2_rad( + freq_grid_.get_freqs()[i].center_freq, + sampling_frequency_); + + switch(eqt) { + case (butterworth): { + butterworth_bp_filter* bf = + new butterworth_bp_filter( + default_eq_band_filters_order, + w0, + wb, + max_base_gain_db, + butterworth_band_gain_db, + min_base_gain_db + ); + + filters_.push_back(bf); + break; + } + + case (chebyshev1): { + chebyshev_type1_bp_filter* cf1 = + new chebyshev_type1_bp_filter( + default_eq_band_filters_order, + w0, + wb, + max_base_gain_db, + chebyshev1_band_base_gain_db, + min_base_gain_db + ); + + filters_.push_back(cf1); + break; + } + + case (chebyshev2): { + chebyshev_type2_bp_filter* cf2 = + new chebyshev_type2_bp_filter( + default_eq_band_filters_order, + w0, + wb, + max_base_gain_db, + chebyshev2_band_base_gain_db, + min_base_gain_db + ); + + filters_.push_back(cf2); + break; + } + + default: + current_eq_type_ = none; + return invalid_input_data_error; + + } + band_gains_.push_back(max_base_gain_db); + } + + current_eq_type_ = eqt; + return no_error; + } + + eq_error_t set_eq(filter_type eqt) + { + return set_eq(freq_grid_, eqt); + } + + eq_error_t set_sample_rate(eq_double_t sr) { + eq_error_t err = no_error; + sampling_frequency_ = sr; + err = set_eq(freq_grid_, current_eq_type_); + + return err; + } + + eq_error_t change_gains(std::vector band_gains) { + if(band_gains_.size() == band_gains.size()) + band_gains_ = band_gains; + else + return invalid_input_data_error; + + return no_error; + } + + eq_error_t change_gains_db(std::vector band_gains) { + if(band_gains_.size() == band_gains.size()) + for(unsigned int j = 0; j < get_number_of_bands(); j++) + band_gains_[j] = conv_.fast_db_2_lin(band_gains[j]); + else + return invalid_input_data_error; + + return no_error; + } + + eq_error_t change_band_gain(unsigned int band_number, + eq_single_t band_gain) { + if(band_number < get_number_of_bands()) + band_gains_[band_number] = band_gain; + else + return invalid_input_data_error; + + return no_error; + } + + eq_error_t change_band_gain_db(unsigned int band_number, + eq_single_t band_gain) { + if(band_number < get_number_of_bands()) + band_gains_[band_number] = conv_.fast_db_2_lin(band_gain); + else + return invalid_input_data_error; + + return no_error; + } + + eq_error_t sbs_process_band(unsigned int band_number, + eq_single_t *in, eq_single_t *out) { + if(band_number < get_number_of_bands()) + *out = band_gains_[band_number]* + filters_[band_number]->process(*in); + else + return invalid_input_data_error; + + return no_error; + } + + eq_error_t sbs_process(eq_single_t *in, eq_single_t *out) { + eq_error_t err = no_error; + eq_single_t acc_out = 0; + for(unsigned int j = 0; j < get_number_of_bands(); j++) { + eq_single_t band_out = 0; + err = sbs_process_band(j, in, &band_out); + acc_out += band_out; + } + *out = acc_out; + + return err; + } + + filter_type get_eq_type(){return current_eq_type_;} + const char* get_string_eq_type(){return get_eq_text(current_eq_type_);} + unsigned int get_number_of_bands() { + return freq_grid_.get_number_of_bands(); + } + const char* get_version(){return eq_version;} +}; + +//!!! New functionality + +// ------------ eq_channel ------------ +// Precomputed equalizer channel, +// consists of vector of filters for every gain value +class eq_channel +{ + eq_single_t f0_; + eq_single_t fb_; + eq_single_t sampling_frequency_; + eq_single_t min_max_gain_db_; + eq_single_t gain_step_db_; + + unsigned int current_filter_index_; + eq_single_t current_gain_db_; + + std::vector filters_; + filter_type current_channel_type_; + + eq_channel(){} + + unsigned int get_flt_index(eq_single_t gain_db) { + unsigned int number_of_filters = filters_.size(); + eq_single_t scale_coef = gain_db/min_max_gain_db_; + return (number_of_filters/2) + (number_of_filters/2)*scale_coef; + } + + void cleanup_filters_array() { + for(unsigned int j = 0; j < filters_.size(); j++) + delete filters_[j]; + } + +public: + eq_channel(filter_type ft, + eq_single_t fs, eq_single_t f0, eq_single_t fb, + eq_single_t min_max_gain_db = p_eq_min_max_gain_db, + eq_single_t step_db = p_eq_gain_step_db) { + + //Init data fields + sampling_frequency_ = fs; + f0_ = f0; + fb_ = fb; + min_max_gain_db_ = min_max_gain_db; + gain_step_db_ = step_db; + + current_gain_db_ = 0; + current_filter_index_ = 0; + + current_channel_type_ = ft; + + set_channel(current_channel_type_, sampling_frequency_); + } + + ~eq_channel(){cleanup_filters_array();} + + eq_error_t set_channel(filter_type ft, eq_single_t fs) { + + eq_double_t wb = conversions::hz_2_rad(fb_, sampling_frequency_); + eq_double_t w0 = conversions::hz_2_rad(f0_, sampling_frequency_); + + for(eq_single_t gain = -min_max_gain_db_; gain <= min_max_gain_db_; + gain+= gain_step_db_) { + + switch(ft) { + case (butterworth): { + eq_single_t bw_gain = + butterworth_bp_filter::compute_bw_gain_db(gain); + + butterworth_bp_filter* bf = + new butterworth_bp_filter( + default_eq_band_filters_order, + w0, + wb, + gain, + bw_gain, + p_eq_default_gain_db + ); + + filters_.push_back(bf); + break; + } + case (chebyshev1): { + eq_single_t bw_gain = + chebyshev_type1_bp_filter::compute_bw_gain_db(gain); + + chebyshev_type1_bp_filter* cf1 = + new chebyshev_type1_bp_filter( + default_eq_band_filters_order, + w0, + wb, + gain, + bw_gain, + p_eq_default_gain_db + ); + + filters_.push_back(cf1); + break; + } + case (chebyshev2): { + eq_single_t bw_gain = + chebyshev_type2_bp_filter::compute_bw_gain_db(gain); + + chebyshev_type2_bp_filter* cf2 = + new chebyshev_type2_bp_filter( + default_eq_band_filters_order, + w0, + wb, + gain, + bw_gain, + p_eq_default_gain_db + ); + + filters_.push_back(cf2); + break; + } + default: { + current_channel_type_ = none; + return invalid_input_data_error; + } + } + } + + //Get current filter index + current_gain_db_ = 0; + current_filter_index_ = get_flt_index(current_gain_db_); + + return no_error; + } + + eq_error_t set_gain_db(eq_single_t db) { + if (db > -min_max_gain_db_ && db < min_max_gain_db_) { + current_gain_db_ = db; + current_filter_index_ = get_flt_index(db); + } + else + return invalid_input_data_error; + + return no_error; + } + + eq_error_t sbs_process(eq_single_t *in, eq_single_t *out) { + *out = filters_[current_filter_index_]->process(*in); + return no_error; + } +}; + +// ------------ eq2 ------------ +// Precomputed equalizer + +class eq2 +{ + conversions conv_; + eq_double_t sampling_frequency_; + freq_grid freq_grid_; + std::vector channels_; + filter_type current_eq_type_; + + void cleanup_channels_array() { + for(unsigned int j = 0; j < channels_.size(); j++) + delete channels_[j]; + } + +public: + eq2(freq_grid &fg, filter_type eq_t) : conv_(eq_min_max_gain_db) { + sampling_frequency_ = default_sample_freq_hz; + freq_grid_ = fg; + current_eq_type_ = eq_t; + set_eq(freq_grid_, eq_t); + } + ~eq2(){cleanup_channels_array();} + + eq_error_t set_eq(const freq_grid& fg, filter_type ft) { + cleanup_channels_array(); + channels_.clear(); + freq_grid_ = fg; + + for(unsigned int i = 0; i < freq_grid_.get_number_of_bands(); i++) { + band_freqs b_fres = freq_grid_.get_freqs()[i]; + + eq_channel* eq_ch = new eq_channel(ft, sampling_frequency_, + b_fres.center_freq, b_fres.max_freq - b_fres.min_freq); + + channels_.push_back(eq_ch); + channels_[i]->set_gain_db(p_eq_default_gain_db); + } + + current_eq_type_ = ft; + return no_error; + } + + eq_error_t set_eq(filter_type ft) { + eq_error_t err = set_eq(freq_grid_, ft); + return err; + } + + eq_error_t set_sample_rate(eq_double_t sr) { + sampling_frequency_ = sr; + eq_error_t err = set_eq(current_eq_type_); + return err; + } + + eq_error_t change_gains(std::vector band_gains) { + if(channels_.size() == band_gains.size()) + for(unsigned int j = 0; j < channels_.size(); j++) + channels_[j]->set_gain_db(conv_.fast_lin_2_db(band_gains[j])); + else + return invalid_input_data_error; + + return no_error; + } + + eq_error_t change_gains_db(std::vector band_gains) { + if(channels_.size() == band_gains.size()) + for(unsigned int j = 0; j < channels_.size(); j++) + channels_[j]->set_gain_db(band_gains[j]); + else + return invalid_input_data_error; + + return no_error; + } + + eq_error_t change_band_gain(unsigned int band_number, + eq_single_t band_gain) { + if(band_number < channels_.size()) + channels_[band_number]->set_gain_db(conv_.fast_lin_2_db(band_gain)); + else + return invalid_input_data_error; + + return no_error; + } + + eq_error_t change_band_gain_db(unsigned int band_number, + eq_single_t band_gain) { + if(band_number < channels_.size()) + channels_[band_number]->set_gain_db(band_gain); + else + return invalid_input_data_error; + + return no_error; + } + + eq_error_t sbs_process_band(unsigned int band_number, + eq_single_t *in, eq_single_t *out) { + if(band_number < get_number_of_bands()) + channels_[band_number]->sbs_process(in, out); + else + return invalid_input_data_error; + + return no_error; + } + + eq_error_t sbs_process(eq_single_t *in, eq_single_t *out) { + eq_error_t err = no_error; + eq_single_t in_out = *in; + for(unsigned int i = 0; i < get_number_of_bands(); i++) + err = sbs_process_band(i,&in_out,&in_out); + + *out = in_out; + + return err; + } + + filter_type get_eq_type(){return current_eq_type_;} + const char* get_string_eq_type(){return get_eq_text(current_eq_type_);} + unsigned int get_number_of_bands() { + return freq_grid_.get_number_of_bands(); + } + const char* get_version(){return eq_version;} +}; + +} //namespace orfanidis_eq +#endif //ORFANIDIS_EQ_H_ diff -Nru calf-0.0.19+git20140527+e79ddef54/src/ctl_knob.cpp calf-0.0.19+git20140915+5de5da28/src/ctl_knob.cpp --- calf-0.0.19+git20140527+e79ddef54/src/ctl_knob.cpp 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/ctl_knob.cpp 2014-09-13 19:46:25.000000000 +0000 @@ -22,7 +22,9 @@ #include #include #include +#if !defined(__APPLE__) #include +#endif #include #include #include diff -Nru calf-0.0.19+git20140527+e79ddef54/src/ctl_tube.cpp calf-0.0.19+git20140915+5de5da28/src/ctl_tube.cpp --- calf-0.0.19+git20140527+e79ddef54/src/ctl_tube.cpp 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/ctl_tube.cpp 2014-09-13 19:46:25.000000000 +0000 @@ -21,7 +21,9 @@ #include "config.h" #include #include +#if !defined(__APPLE__) #include +#endif #include #include #include diff -Nru calf-0.0.19+git20140527+e79ddef54/src/ctl_vumeter.cpp calf-0.0.19+git20140915+5de5da28/src/ctl_vumeter.cpp --- calf-0.0.19+git20140527+e79ddef54/src/ctl_vumeter.cpp 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/ctl_vumeter.cpp 2014-09-13 19:46:25.000000000 +0000 @@ -207,27 +207,47 @@ cairo_stroke(cache_cr); } // create blinder pattern - vu->pat = cairo_pattern_create_linear (led_x, led_y, led_x, led_y + led_h); - cairo_pattern_add_color_stop_rgba (vu->pat, 0, 1, 1, 1, 0.25); - cairo_pattern_add_color_stop_rgba (vu->pat, 0.5, 0.5, 0.5, 0.5, 0.0); - cairo_pattern_add_color_stop_rgba (vu->pat, 1, 0.0, 0.0, 0.0, 0.25); - cairo_rectangle( cache_cr, led_x, led_y, led_w, led_h); - cairo_set_source( cache_cr, vu->pat ); + cairo_pattern_t *pat = cairo_pattern_create_linear (led_x, led_y, led_x, led_y + led_h); + cairo_pattern_add_color_stop_rgba (pat, 0, 1, 1, 1, 0.25); + cairo_pattern_add_color_stop_rgba (pat, 0.5, 0.5, 0.5, 0.5, 0.0); + cairo_pattern_add_color_stop_rgba (pat, 1, 0.0, 0.0, 0.0, 0.25); + cairo_rectangle(cache_cr, led_x, led_y, led_w, led_h); + cairo_set_source(cache_cr, pat); cairo_fill(cache_cr); + // create overlay + vu->cache_overlay = cairo_surface_create_similar(window_surface, + CAIRO_CONTENT_COLOR, + widget->allocation.width, + widget->allocation.height); + cairo_t *over_cr = cairo_create(vu->cache_overlay); + + // copy surface to overlay + cairo_set_source_surface(over_cr, vu->cache_surface, 0, 0); + cairo_rectangle(over_cr, 0, 0, width, height); + cairo_fill(over_cr); + // create blinder pattern - vu->pat = cairo_pattern_create_linear (led_x, led_y, led_x, led_y + led_h); - cairo_pattern_add_color_stop_rgba (vu->pat, 0, 0.2, 0.2, 0.2, 0.7); - cairo_pattern_add_color_stop_rgba (vu->pat, 0.4, 0.05, 0.05, 0.05, 0.7); - cairo_pattern_add_color_stop_rgba (vu->pat, 0.401, 0.05, 0.05, 0.05, 0.9); - cairo_pattern_add_color_stop_rgba (vu->pat, 1, 0.05, 0.05, 0.05, 0.75); - cairo_destroy( cache_cr ); + pat = cairo_pattern_create_linear (led_x, led_y, led_x, led_y + led_h); + cairo_pattern_add_color_stop_rgba (pat, 0, 0.2, 0.2, 0.2, 0.7); + cairo_pattern_add_color_stop_rgba (pat, 0.4, 0.05, 0.05, 0.05, 0.7); + cairo_pattern_add_color_stop_rgba (pat, 0.401, 0.05, 0.05, 0.05, 0.9); + cairo_pattern_add_color_stop_rgba (pat, 1, 0.05, 0.05, 0.05, 0.75); + + // draw on top of overlay + cairo_set_source(over_cr, pat); + cairo_rectangle(over_cr, 0, 0, width, height); + cairo_paint(over_cr); + + // clean up + cairo_destroy(cache_cr); + cairo_destroy(over_cr); } // draw LED blinder cairo_set_source_surface( c, vu->cache_surface, 0,0 ); cairo_paint( c ); - cairo_set_source( c, vu->pat ); + cairo_set_source_surface( c, vu->cache_overlay, 0, 0 ); // get microseconds timeval tv; @@ -376,6 +396,17 @@ } static void +calf_vumeter_unrealize (GtkWidget *widget, CalfVUMeter *vu) +{ + if( vu->cache_surface ) + cairo_surface_destroy( vu->cache_surface ); + vu->cache_surface = NULL; + if( vu->cache_overlay ) + cairo_surface_destroy( vu->cache_overlay ); + vu->cache_overlay = NULL; +} + +static void calf_vumeter_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { @@ -386,9 +417,7 @@ parent_class->size_allocate( widget, allocation ); - if( vu->cache_surface ) - cairo_surface_destroy( vu->cache_surface ); - vu->cache_surface = NULL; + calf_vumeter_unrealize(widget, vu); } static void @@ -413,6 +442,7 @@ self->meter_width = 0; self->disp_value = 0.f; self->value = 0.f; + g_signal_connect(GTK_OBJECT(widget), "unrealize", G_CALLBACK(calf_vumeter_unrealize), (gpointer)self); } GtkWidget * diff -Nru calf-0.0.19+git20140527+e79ddef54/src/giface.cpp calf-0.0.19+git20140915+5de5da28/src/giface.cpp --- calf-0.0.19+git20140527+e79ddef54/src/giface.cpp 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/giface.cpp 2014-09-13 19:46:25.000000000 +0000 @@ -20,6 +20,8 @@ */ #include #include +#include +#include #include #include @@ -159,6 +161,22 @@ increment = 1.0 / (max - min); return increment; } +std::string human_readable(float value, uint32_t base, char *format) +{ + // format is something like "%.2f%sB" for e.g. "1.23kB" + // base is something like 1000 or 1024 + char buf[32]; + const char *suf[] = { "", "k", "m", "g", "t", "p", "e" }; + if (value == 0) { + sprintf(buf, format, 0.f, ""); + return string(buf); + } + double val = abs(value); + int place = (int)(log(val) / log(base)); + double num = val / pow(base, place); + sprintf(buf, format, (float)((value > 0) - (value < 0)) * num, suf[place]); + return string(buf); +} int parameter_properties::get_char_count() const { @@ -173,14 +191,17 @@ len = std::max(len, strlen(buf)) + 2; return (int)len; } - return std::max(to_string(min).length(), std::max(to_string(max).length(), to_string(min + (max-min) * 0.987654).length())); + std::string min_ = human_readable(min, 1000, (char*)"%g%s"); + std::string max_ = human_readable(max, 1000, (char*)"%g%s"); + return std::max((int)min_.length(), std::max((int)max_.length(), 1)); } + std::string parameter_properties::to_string(float value) const { char buf[32]; if ((flags & PF_SCALEMASK) == PF_SCALE_PERC) { - snprintf(buf, sizeof(buf), "%0.f%%", 100.0 * value); + snprintf(buf, sizeof(buf), "%0.2f%%", 100.0 * value); return string(buf); } if ((flags & PF_SCALEMASK) == PF_SCALE_GAIN) { @@ -189,6 +210,7 @@ snprintf(buf, sizeof(buf), "%0.1f dB", dsp::amp2dB(value)); return string(buf); } + std::string s_; switch(flags & PF_TYPEMASK) { case PF_INT: @@ -196,13 +218,38 @@ case PF_ENUM: case PF_ENUM_MULTI: value = (int)value; + s_ = human_readable(value, 1000, (char*)"%g%s"); + snprintf(buf, sizeof(buf), "%s", s_.c_str()); + //printf("%.2f %s\n", value, buf); + break; + case PF_FLOAT: + switch (flags & PF_DIGITMASK) { + case PF_DIGIT_0: + snprintf(buf, sizeof(buf), "%.0f", value); + break; + case PF_DIGIT_1: + snprintf(buf, sizeof(buf), "%.1f", value); + break; + case PF_DIGIT_2: + snprintf(buf, sizeof(buf), "%.2f", value); + break; + case PF_DIGIT_3: + snprintf(buf, sizeof(buf), "%.3f", value); + break; + case PF_DIGIT_ALL: + default: + snprintf(buf, sizeof(buf), "%g", value); + break; + } + break; + default: + snprintf(buf, sizeof(buf), "%g", value); break; } if ((flags & PF_SCALEMASK) == PF_SCALE_LOG_INF && IS_FAKE_INFINITY(value)) - snprintf(buf, sizeof(buf), "+inf"); // XXXKF change to utf-8 infinity - else - snprintf(buf, sizeof(buf), "%g", value); + snprintf(buf, sizeof(buf), "∞"); // XXXKF change to utf-8 infinity + switch(flags & PF_UNITMASK) { case PF_UNIT_DB: return string(buf) + " dB"; case PF_UNIT_HZ: return string(buf) + " Hz"; diff -Nru calf-0.0.19+git20140527+e79ddef54/src/gui_controls.cpp calf-0.0.19+git20140915+5de5da28/src/gui_controls.cpp --- calf-0.0.19+git20140527+e79ddef54/src/gui_controls.cpp 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/gui_controls.cpp 2014-09-13 19:46:25.000000000 +0000 @@ -531,14 +531,16 @@ if (param_no != -1) { const parameter_properties &props = get_props(); - gtk_label_set_width_chars (GTK_LABEL (widget), props.get_char_count()); + int width = get_int("width", 0); + gtk_label_set_width_chars (GTK_LABEL (widget), + width ? width : props.get_char_count()); } else { require_attribute("key"); require_int_attribute("width"); param_variable = attribs["key"]; - gtk_label_set_width_chars (GTK_LABEL (widget), get_int("width")); + gtk_label_set_width_chars (GTK_LABEL (widget), get_int("width")); } gtk_misc_set_alignment (GTK_MISC (widget), get_float("align-x", 0.5), get_float("align-y", 0.5)); gtk_widget_set_name(GTK_WIDGET(widget), "Calf-Value"); diff -Nru calf-0.0.19+git20140527+e79ddef54/src/gui.cpp calf-0.0.19+git20140915+5de5da28/src/gui.cpp --- calf-0.0.19+git20140527+e79ddef54/src/gui.cpp 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/gui.cpp 2014-09-13 19:46:25.000000000 +0000 @@ -42,6 +42,10 @@ container = NULL; effect_name = NULL; preset_access = new gui_preset_access(this); + optclosed = false; + optwidget = NULL; + optwindow = NULL; + opttitle = NULL; } param_control *plugin_gui::create_control_from_xml(const char *element, const char *attributes[]) diff -Nru calf-0.0.19+git20140527+e79ddef54/src/lv2gui.cpp calf-0.0.19+git20140915+5de5da28/src/lv2gui.cpp --- calf-0.0.19+git20140527+e79ddef54/src/lv2gui.cpp 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/lv2gui.cpp 2014-09-13 19:46:25.000000000 +0000 @@ -22,6 +22,7 @@ #include #include #include +#include #include #include #include @@ -279,6 +280,9 @@ LV2UI_Widget* widget, const LV2_Feature* const* features) { + static int argc = 0; + gtk_init(&argc, NULL); + const plugin_metadata_iface *md = plugin_registry::instance().get_by_uri(plugin_uri); if (!md) return NULL; @@ -292,13 +296,45 @@ plugin_gui *gui = new plugin_gui(window); const char *xml = proxy->plugin_metadata->get_gui_xml(); assert(xml); - *(GtkWidget **)(widget) = gui->create_from_xml(proxy, xml); + gui->optwidget = gui->create_from_xml(proxy, xml); proxy->enable_all_sends(); proxy->send_configures(gui); - if (*(GtkWidget **)(widget)) + if (gui->optwidget) proxy->source_id = g_timeout_add_full(G_PRIORITY_LOW, 1000/30, plugin_on_idle, gui, NULL); // 30 fps should be enough for everybody gui->show_rack_ears(proxy->get_config()->rack_ears); + *(GtkWidget **)(widget) = gui->optwidget; + + // find window title + const LV2_Options_Option* options = NULL; + const LV2_URI_Map_Feature* uriMap = NULL; + + for (int i=0; features[i]; i++) + { + if (!strcmp(features[i]->URI, LV2_OPTIONS__options)) + options = (const LV2_Options_Option*)features[i]->data; + else if (!strcmp(features[i]->URI, LV2_URI_MAP_URI)) + uriMap = (const LV2_URI_Map_Feature*)features[i]->data; + } + + if (!options || !uriMap) + return (LV2UI_Handle)gui; + + const uint32_t uridWindowTitle = uriMap->uri_to_id(uriMap->callback_data, NULL, LV2_UI__windowTitle); + + if (!uridWindowTitle) + return (LV2UI_Handle)gui; + + for (int i=0; options[i].key; i++) + { + if (options[i].key == uridWindowTitle) + { + const char* windowTitle = (const char*)options[i].value; + gui->opttitle = strdup(windowTitle); + break; + } + } + return (LV2UI_Handle)gui; } @@ -308,6 +344,10 @@ lv2_plugin_proxy *proxy = dynamic_cast(gui->plugin); if (proxy->source_id) g_source_remove(proxy->source_id); + if (gui->optwindow) + gtk_widget_destroy(gui->optwindow); + if (gui->opttitle) + free((void*)gui->opttitle); delete gui; } @@ -330,8 +370,69 @@ } } +void gui_destroy(GtkWidget*, gpointer data) +{ + plugin_gui *gui = (plugin_gui *)data; + + gui->optclosed = true; + gui->optwindow = NULL; +} + +int gui_show(LV2UI_Handle handle) +{ + plugin_gui *gui = (plugin_gui *)handle; + + if (! gui->optwindow) + { + gui->optwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); + g_signal_connect(G_OBJECT(gui->optwindow), "destroy", G_CALLBACK(gui_destroy), (gpointer)gui); + + if (gui->optwidget) + gtk_container_add(GTK_CONTAINER(gui->optwindow), gui->optwidget); + + if (gui->opttitle) + gtk_window_set_title(GTK_WINDOW(gui->optwindow), gui->opttitle); + + gtk_window_set_resizable(GTK_WINDOW(gui->optwindow), false); + } + + gtk_widget_show_all(gui->optwindow); + gtk_window_present(GTK_WINDOW(gui->optwindow)); + + return 0; +} + +int gui_hide(LV2UI_Handle handle) +{ + plugin_gui *gui = (plugin_gui *)handle; + + if (gui->optwindow) + gtk_widget_hide_all(gui->optwindow); + + return 0; +} + +int gui_idle(LV2UI_Handle handle) +{ + plugin_gui *gui = (plugin_gui *)handle; + + if (gui->optclosed) + return 1; + + if (gui->optwindow) + gtk_main_iteration(); + + return 0; +} + const void *gui_extension(const char *uri) { + static const LV2UI_Show_Interface show = { gui_show, gui_hide }; + static const LV2UI_Idle_Interface idle = { gui_idle }; + if (!strcmp(uri, LV2_UI__showInterface)) + return &show; + if (!strcmp(uri, LV2_UI__idleInterface)) + return &idle; return NULL; } diff -Nru calf-0.0.19+git20140527+e79ddef54/src/Makefile.am calf-0.0.19+git20140915+5de5da28/src/Makefile.am --- calf-0.0.19+git20140527+e79ddef54/src/Makefile.am 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/Makefile.am 2014-09-13 19:46:25.000000000 +0000 @@ -11,7 +11,8 @@ pkglib_LTLIBRARIES = calf.la AM_CPPFLAGS = -I$(top_srcdir) -I$(srcdir) -AM_CXXFLAGS = -ffast-math -finline-limit=80 $(FLUIDSYNTH_DEPS_CFLAGS) +# TODO: Remove -finline flags is clang is used +AM_CXXFLAGS = -ffast-math -finline-limit=80 $(FLUIDSYNTH_DEPS_CFLAGS) $(LV2_DEPS_CFLAGS) if USE_GUI AM_CXXFLAGS += $(GUI_DEPS_CFLAGS) @@ -21,7 +22,7 @@ noinst_LTLIBRARIES += libcalfgui.la bin_PROGRAMS += calfjackhost calfjackhost_SOURCES = gtk_session_env.cpp host_session.cpp jack_client.cpp jackhost.cpp gtk_main_win.cpp connector.cpp session_mgr.cpp -calfjackhost_LDADD = libcalfgui.la calf.la $(JACK_DEPS_LIBS) $(GUI_DEPS_LIBS) $(FLUIDSYNTH_DEPS_LIBS) -lfftw3f +calfjackhost_LDADD = libcalfgui.la calf.la $(JACK_DEPS_LIBS) $(GUI_DEPS_LIBS) $(FLUIDSYNTH_DEPS_LIBS) $(FFTW3_DEPS_LIBS) -lfftw3f if USE_LASH AM_CXXFLAGS += $(LASH_DEPS_CFLAGS) calfjackhost_LDADD += $(LASH_DEPS_LIBS) @@ -30,14 +31,14 @@ AM_CXXFLAGS += $(GLIB_DEPS_CFLAGS) noinst_PROGRAMS += calfmakerdf -calfmakerdf_SOURCES = makerdf.cpp -calfmakerdf_LDADD = calf.la +calfmakerdf_SOURCES = makerdf.cpp +calfmakerdf_LDADD = calf.la calfbenchmark_SOURCES = benchmark.cpp calfbenchmark_LDADD = calf.la -calf_la_SOURCES = audio_fx.cpp analyzer.cpp metadata.cpp modules_tools.cpp modules_delay.cpp modules_comp.cpp modules_limit.cpp modules_dist.cpp modules_filter.cpp modules_mod.cpp fluidsynth.cpp giface.cpp monosynth.cpp organ.cpp osctl.cpp plugin.cpp preset.cpp synth.cpp utils.cpp wavetable.cpp modmatrix.cpp -calf_la_LIBADD = $(FLUIDSYNTH_DEPS_LIBS) $(GLIB_DEPS_LIBS) -lfftw3f +calf_la_SOURCES = audio_fx.cpp analyzer.cpp metadata.cpp modules_tools.cpp modules_delay.cpp modules_comp.cpp modules_limit.cpp modules_dist.cpp modules_filter.cpp modules_mod.cpp fluidsynth.cpp giface.cpp monosynth.cpp organ.cpp osctl.cpp plugin.cpp preset.cpp synth.cpp utils.cpp wavetable.cpp modmatrix.cpp +calf_la_LIBADD = $(FLUIDSYNTH_DEPS_LIBS) $(GLIB_DEPS_LIBS) $(FFTW3_DEPS_LIBS) -lfftw3f if USE_DEBUG calf_la_LDFLAGS = -rpath $(pkglibdir) -avoid-version -module -lexpat -disable-static else diff -Nru calf-0.0.19+git20140527+e79ddef54/src/makerdf.cpp calf-0.0.19+git20140915+5de5da28/src/makerdf.cpp --- calf-0.0.19+git20140527+e79ddef54/src/makerdf.cpp 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/makerdf.cpp 2014-09-13 19:46:25.000000000 +0000 @@ -237,8 +237,9 @@ string gtkgui_uri = ""; gui_header = gtkgui_uri + "\n" " a uiext:GtkUI ;\n" - " uiext:binary ;\n" - " uiext:requiredFeature uiext:makeResident .\n" + " lv2:extensionData uiext:showInterface ;\n" + " lv2:requiredFeature uiext:makeResident ;\n" + " uiext:binary .\n" "\n" ; #endif diff -Nru calf-0.0.19+git20140527+e79ddef54/src/metadata.cpp calf-0.0.19+git20140915+5de5da28/src/metadata.cpp --- calf-0.0.19+git20140527+e79ddef54/src/metadata.cpp 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/metadata.cpp 2014-09-13 19:46:25.000000000 +0000 @@ -243,6 +243,29 @@ //////////////////////////////////////////////////////////////////////////// +CALF_PORT_NAMES(reverse_delay) = {"In L", "In R", "Out L", "Out R"}; + +CALF_PORT_PROPS(reverse_delay) = { + { 120, 30, 300, 1, PF_FLOAT | PF_SCALE_LINEAR | PF_CTL_KNOB | PF_UNIT_BPM, NULL, "bpm", "Tempo" }, + { 120, 1, 300, 1, PF_FLOAT | PF_SCALE_LINEAR | PF_CTL_KNOB | PF_UNIT_BPM | PF_SYNC_BPM, NULL, "bpm_host", "Host BPM" }, + { 4, 1, 16, 1, PF_INT | PF_SCALE_LINEAR | PF_CTL_FADER, NULL, "subdiv", "Subdivide"}, + { 5, 1, 16, 1, PF_INT | PF_SCALE_LINEAR | PF_CTL_FADER, NULL, "time_l", "Time L"}, + { 5, 1, 16, 1, PF_INT | PF_SCALE_LINEAR | PF_CTL_FADER, NULL, "time_r", "Time R"}, + { 0.5, 0, 1, 0, PF_FLOAT | PF_SCALE_PERC | PF_CTL_KNOB, NULL, "feedback", "Feedback" }, + { 0, -1, 1, 0, PF_FLOAT | PF_SCALE_PERC | PF_CTL_KNOB | PF_UNIT_COEF | PF_PROP_NOBOUNDS, NULL, "amount", "Dry/Wet" }, + { 0, 0, 1, 0, PF_FLOAT | PF_SCALE_PERC | PF_CTL_KNOB , NULL, "width", "Stereo Width" }, + { 0, 0, 1, 0, PF_BOOL | PF_CTL_TOGGLE, NULL, "sync", "Sync BPM" }, + { 0, 0, 1, 0, PF_INT | PF_CTL_LED | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "sync_led_l", "Left" }, + { 0, 0, 1, 0, PF_INT | PF_CTL_LED | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "sync_led_r", "Right" }, + { 0, 0, 1, 2, PF_BOOL | PF_CTL_BUTTON , NULL, "reset", "Reset" }, + { 0.5, 0, 1, 0, PF_FLOAT | PF_SCALE_PERC | PF_CTL_KNOB, NULL, "window", "Window" }, + {} +}; + +CALF_PLUGIN_INFO(reverse_delay) = { 0x8482, "ReverseDelay", "Calf Reverse Delay", "drgreenthumb", calf_plugins::calf_copyright_info, "DelayPlugin" }; + +//////////////////////////////////////////////////////////////////////////// + CALF_PORT_NAMES(rotary_speaker) = {"In L", "In R", "Out L", "Out R"}; const char *rotary_speaker_speed_names[] = { "Off", "Chorale", "Tremolo", "HoldPedal", "ModWheel", "Manual" }; @@ -802,6 +825,114 @@ //////////////////////////////////////////////////////////////////////////// +#define GRAPHICEQ_BAND_PARAMS(band) \ + { 0, -1, 1, 0, PF_FLOAT | PF_SCALE_LINEAR | PF_CTL_KNOB | PF_UNIT_COEF | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "gain" #band, "Gain " #band },\ + { 33, 10, 25000, 0, PF_INT | PF_SCALE_LINEAR | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "freq" #band, "Freq " #band },\ + { 0, -32, 32, 0, PF_FLOAT | PF_DIGIT_1 | PF_SCALE_LINEAR | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "gain_scale" #band, "Gain Scale " #band }, + +#define GRAPHICEQ_GAIN_PARAMS(band) \ + { 0, -1, 1, 0, PF_FLOAT | PF_SCALE_LINEAR | PF_CTL_KNOB | PF_UNIT_COEF | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "gain" #band, "Gain " #band },\ + { 0, -32, 32, 0, PF_FLOAT | PF_UNIT_DB | PF_SCALE_LINEAR | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "gain_scale" #band, "Gain Scale " #band }, + +const char *equalizer30band_filters_modes[] = {"Butterworth", "Chebyshev 1", "Chebyshev 2"}; + +const char *equalizer30band_gainscale_modes1[] = {"6 dB", "12 dB", "18 dB", "24 dB", "30 dB"}; + +CALF_PORT_NAMES(equalizer30band) = {"In L", "In R", "Out L", "Out R"}; + +CALF_PORT_PROPS(equalizer30band) = { + + { 1, 0.015625, 64, 0, PF_FLOAT | PF_SCALE_GAIN | PF_CTL_KNOB | PF_UNIT_DB, NULL, "level_in", "In Level" }, + { 0, 0, 1, 0, PF_FLOAT | PF_SCALE_GAIN | PF_CTL_METER | PF_CTLO_LABEL | PF_UNIT_DB | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "level_in_vuL", "Level In L" }, + { 0, 0, 1, 0, PF_FLOAT | PF_SCALE_GAIN | PF_CTL_METER | PF_CTLO_LABEL | PF_UNIT_DB | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "level_in_vuR", "Level In R" }, + { 0, 0, 1, 0, PF_FLOAT | PF_CTL_LED | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "level_in_clipL", "Level Clip In L" }, + { 0, 0, 1, 0, PF_FLOAT | PF_CTL_LED | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "level_in_clipR", "Level Clip In R" }, + + { 0, 0, 1, 0, PF_BOOL | PF_CTL_TOGGLE, NULL, "bypass", "Bypass" }, + { 0, 0, 2, 0, PF_ENUM | PF_CTL_COMBO, equalizer30band_filters_modes, "filters", "Filters Type" }, + + { 18, 6, 30, 0, PF_FLOAT | PF_SCALE_LINEAR | PF_CTL_KNOB | PF_UNIT_DB, NULL, "gainscale1", "Gain scale 1" }, + { 18, 6, 30, 0, PF_FLOAT | PF_SCALE_LINEAR | PF_CTL_KNOB | PF_UNIT_DB, NULL, "gainscale2", "Gain scale 2" }, + + { 1, 0.015625, 64, 0, PF_FLOAT | PF_SCALE_GAIN | PF_CTL_KNOB | PF_UNIT_DB, NULL, "level_out", "Out Level" }, + { 0, 0, 1, 0, PF_FLOAT | PF_SCALE_GAIN | PF_CTL_METER | PF_CTLO_LABEL | PF_UNIT_DB | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "level_out_vuL", "Level Out L" }, + { 0, 0, 1, 0, PF_FLOAT | PF_SCALE_GAIN | PF_CTL_METER | PF_CTLO_LABEL | PF_UNIT_DB | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "level_out_vuR", "Level Out R" }, + { 0, 0, 1, 0, PF_FLOAT | PF_CTL_LED | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "level_out_clipL", "Level Clip Out L" }, + { 0, 0, 1, 0, PF_FLOAT | PF_CTL_LED | PF_PROP_OUTPUT | PF_PROP_OPTIONAL, NULL, "level_out_clipR", "Level Clip Out R" }, + + //1 - 30 Bands + GRAPHICEQ_GAIN_PARAMS(10) + GRAPHICEQ_BAND_PARAMS(11) + GRAPHICEQ_BAND_PARAMS(12) + GRAPHICEQ_BAND_PARAMS(13) + GRAPHICEQ_BAND_PARAMS(14) + GRAPHICEQ_BAND_PARAMS(15) + GRAPHICEQ_BAND_PARAMS(16) + GRAPHICEQ_BAND_PARAMS(17) + GRAPHICEQ_BAND_PARAMS(18) + GRAPHICEQ_BAND_PARAMS(19) + GRAPHICEQ_BAND_PARAMS(110) + GRAPHICEQ_BAND_PARAMS(111) + GRAPHICEQ_BAND_PARAMS(112) + GRAPHICEQ_BAND_PARAMS(113) + GRAPHICEQ_BAND_PARAMS(114) + GRAPHICEQ_BAND_PARAMS(115) + GRAPHICEQ_BAND_PARAMS(116) + GRAPHICEQ_BAND_PARAMS(117) + GRAPHICEQ_BAND_PARAMS(118) + GRAPHICEQ_BAND_PARAMS(119) + GRAPHICEQ_BAND_PARAMS(120) + GRAPHICEQ_BAND_PARAMS(121) + GRAPHICEQ_BAND_PARAMS(122) + GRAPHICEQ_BAND_PARAMS(123) + GRAPHICEQ_BAND_PARAMS(124) + GRAPHICEQ_BAND_PARAMS(125) + GRAPHICEQ_BAND_PARAMS(126) + GRAPHICEQ_BAND_PARAMS(127) + GRAPHICEQ_BAND_PARAMS(128) + GRAPHICEQ_BAND_PARAMS(129) + GRAPHICEQ_BAND_PARAMS(130) + + //2 - 30 Bands + GRAPHICEQ_GAIN_PARAMS(20) + GRAPHICEQ_BAND_PARAMS(21) + GRAPHICEQ_BAND_PARAMS(22) + GRAPHICEQ_BAND_PARAMS(23) + GRAPHICEQ_BAND_PARAMS(24) + GRAPHICEQ_BAND_PARAMS(25) + GRAPHICEQ_BAND_PARAMS(26) + GRAPHICEQ_BAND_PARAMS(27) + GRAPHICEQ_BAND_PARAMS(28) + GRAPHICEQ_BAND_PARAMS(29) + GRAPHICEQ_BAND_PARAMS(210) + GRAPHICEQ_BAND_PARAMS(211) + GRAPHICEQ_BAND_PARAMS(212) + GRAPHICEQ_BAND_PARAMS(213) + GRAPHICEQ_BAND_PARAMS(214) + GRAPHICEQ_BAND_PARAMS(215) + GRAPHICEQ_BAND_PARAMS(216) + GRAPHICEQ_BAND_PARAMS(217) + GRAPHICEQ_BAND_PARAMS(218) + GRAPHICEQ_BAND_PARAMS(219) + GRAPHICEQ_BAND_PARAMS(220) + GRAPHICEQ_BAND_PARAMS(221) + GRAPHICEQ_BAND_PARAMS(222) + GRAPHICEQ_BAND_PARAMS(223) + GRAPHICEQ_BAND_PARAMS(224) + GRAPHICEQ_BAND_PARAMS(225) + GRAPHICEQ_BAND_PARAMS(226) + GRAPHICEQ_BAND_PARAMS(227) + GRAPHICEQ_BAND_PARAMS(228) + GRAPHICEQ_BAND_PARAMS(229) + GRAPHICEQ_BAND_PARAMS(230) + + {} +}; + +CALF_PLUGIN_INFO(equalizer30band) = { 0x8514, "Equalizer30Band", "Calf Equalizer 30 Band", "drgreenthumb", calf_plugins::calf_copyright_info, "EQPlugin" }; + +//////////////////////////////////////////////////////////////////////////// + #define XOVER_BAND_PARAMS(band) \ { 1, 0.015625, 64, 0, PF_FLOAT | PF_SCALE_GAIN | PF_CTL_KNOB | PF_UNIT_DB, NULL, "level" #band, "Gain " #band }, \ { 1, 0, 1, 0, PF_BOOL | PF_CTL_TOGGLE, NULL, "active" #band, "Active " #band }, \ diff -Nru calf-0.0.19+git20140527+e79ddef54/src/modules_delay.cpp calf-0.0.19+git20140915+5de5da28/src/modules_delay.cpp --- calf-0.0.19+git20140527+e79ddef54/src/modules_delay.cpp 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/modules_delay.cpp 2014-09-13 19:46:25.000000000 +0000 @@ -565,3 +565,143 @@ meters.fall(numsamples); return outputs_mask; } + +/********************************************************************** + * REVERSE DELAY +**********************************************************************/ + +reverse_delay_audio_module::reverse_delay_audio_module() +{ + for (int i = 0; i < MAX_DELAY; i++) { + buffers[0][i] = 0.f; + buffers[1][i] = 0.f; + } + + counters[0] = 0; + counters[1] = 0; + + feedback_buf[0] = 0; + feedback_buf[1] = 0; +} + +void reverse_delay_audio_module::params_changed() +{ + if (*params[par_sync] > 0.5f) + *params[par_bpm] = *params[par_bpm_host]; + + //Max delay line length: (60*192000/30)*16 = 6144000, see buffers declaration + float unit = 60.0 * srate / (*params[par_bpm] * *params[par_divide]); + deltime_l = dsp::fastf2i_drm(unit * *params[par_time_l]); + deltime_r = dsp::fastf2i_drm(unit * *params[par_time_r]); + + fb_val.set_inertia(*params[par_feedback]); + dry.set_inertia(*params[par_amount]); + + counters[0] = 0; + counters[1] = 0; + + ow[0].set_coef((*params[par_window] + 0.005), deltime_l/2); + ow[1].set_coef((*params[par_window] + 0.005), deltime_r/2); + + width.set_inertia(*params[par_width]); + + //Cleanup delay line buffers if reset + if(*params[par_reset]) + { + for (int i = 0; i < MAX_DELAY; i++) { + buffers[0][i] = 0.f; + buffers[1][i] = 0.f; + } + + feedback_buf[0] = 0; + feedback_buf[1] = 0; + } +} + +void reverse_delay_audio_module::activate() +{ +} + +void reverse_delay_audio_module::deactivate() +{ +} + +void reverse_delay_audio_module::set_sample_rate(uint32_t sr) +{ + srate = sr; + fb_val.set_sample_rate(sr); + dry.set_sample_rate(sr); + width.set_sample_rate(sr); +} + +static float reverse_delay_line_impl(float in, float* buf, int* counter, int length) +{ + float out = 0; + + //Read data + if(*counter < length - 1) + { + unsigned int read_counter = length - 1 - (*counter); + out = buf[read_counter]; + } + + //Write data + *(buf + (*counter)) = in; + (*counter)++; + if ((*counter) > length-1) + (*counter) = 0; + + return (out); +} + +uint32_t reverse_delay_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask) +{ + + uint32_t ostate = 3; // XXXKF optimize! + uint32_t end = offset + numsamples; + + //Loop + for(uint32_t i = offset; i < end; i++) + { + //Update sync led's + if(counters[0] < deltime_l/4) + *params[par_sync_led_l] = true; + else + *params[par_sync_led_l] = false; + + if(counters[1] < deltime_r/4) + *params[par_sync_led_r] = true; + else + *params[par_sync_led_r] = false; + + //Process + float feedback_val = fb_val.get(); + float st_width_val = width.get(); + + float inL = ins[0][i] + st_width_val*ins[1][i]; + float inR = ins[1][i]*(1 - st_width_val); + float outL = 0; + float outR = 0; + + + inL = inL + feedback_buf[0]* feedback_val*(1 - st_width_val) + feedback_buf[1]* st_width_val*feedback_val; + inR = inR + feedback_buf[1]* feedback_val*(1 - st_width_val) + feedback_buf[0]* st_width_val*feedback_val; + + outL = reverse_delay_line_impl(inL, &buffers[0][0], &counters[0], deltime_l); + outR = reverse_delay_line_impl(inR, &buffers[1][0], &counters[1], deltime_r); + feedback_buf[0] = outL; + feedback_buf[1] = outR; + + outL*= ow[0].get(); + outR*= ow[1].get(); + + outL = outL*(1 + dry.get()) + inL*(1 - dry.get()); + outR = outR*(1 + dry.get()) + inR*(1 - dry.get()); + + outs[0][i] = outL; + outs[1][i] = outR; + + } + + return ostate; +} diff -Nru calf-0.0.19+git20140527+e79ddef54/src/modules_filter.cpp calf-0.0.19+git20140915+5de5da28/src/modules_filter.cpp --- calf-0.0.19+git20140527+e79ddef54/src/modules_filter.cpp 2014-05-26 23:54:01.000000000 +0000 +++ calf-0.0.19+git20140915+5de5da28/src/modules_filter.cpp 2014-09-13 19:46:25.000000000 +0000 @@ -495,6 +495,192 @@ template class equalizerNband_audio_module; template class equalizerNband_audio_module; +/********************************************************************** + * EQUALIZER 30 BAND +**********************************************************************/ + +void equalizer30band_audio_module::set_freq_grid() +{ + //Initialize freq indicators + unsigned int param_ptr = 0; + for(unsigned j = 0; j < fg.get_number_of_bands(); j++) + { + *params[param_freq11 + param_ptr] = fg.get_rounded_freq(j); + *params[param_freq21 + param_ptr] = fg.get_rounded_freq(j); + param_ptr += 3; + } + + is_freq_grid_init = true; +} + +equalizer30band_audio_module::equalizer30band_audio_module() : + conv(orfanidis_eq::eq_min_max_gain_db), + swL(10000), swR(10000) +{ + is_active = false; + srate = 0; + + is_freq_grid_init = false; + + //Construct equalizers + using namespace orfanidis_eq; + + fg.set_30_bands(); + + eq2* ptr30L = new eq2(fg, butterworth); + eq2* ptr30R = new eq2(fg, butterworth); + eq_arrL.push_back(ptr30L); + eq_arrR.push_back(ptr30R); + + ptr30L = new eq2(fg, chebyshev1); + ptr30R = new eq2(fg, chebyshev1); + eq_arrL.push_back(ptr30L); + eq_arrR.push_back(ptr30R); + + ptr30L = new eq2(fg, chebyshev2); + ptr30R = new eq2(fg, chebyshev2); + eq_arrL.push_back(ptr30L); + eq_arrR.push_back(ptr30R); + + flt_type = butterworth; + flt_type_old = none; + + //Set switcher + swL.set_previous(butterworth); + swL.set(butterworth); + + swR.set_previous(butterworth); + swR.set(butterworth); +} + +equalizer30band_audio_module::~equalizer30band_audio_module() +{ + for (unsigned int i = 0; i < eq_arrL.size(); i++) + delete eq_arrL[i]; + + for (unsigned int i = 0; i < eq_arrR.size(); i++) + delete eq_arrR[i]; +} + +void equalizer30band_audio_module::activate() +{ + is_active = true; + + //Update freq grid + if(is_freq_grid_init == false) + set_freq_grid(); +} + +void equalizer30band_audio_module::deactivate() +{ + is_active = false; +} + +void equalizer30band_audio_module::params_changed() +{ + using namespace orfanidis_eq; + + //Change gain indicators + *params[param_gain_scale10] = *params[param_gain10] * *params[param_gainscale1]; + *params[param_gain_scale20] = *params[param_gain20] * *params[param_gainscale2]; + + for(unsigned int i = 0; i < fg.get_number_of_bands(); i++) + *params[param_gain_scale11 + band_params*i] = (*params[param_gain11 + band_params*i])* + *params[param_gainscale1]; + + for(unsigned int i = 0; i < fg.get_number_of_bands(); i++) + *params[param_gain_scale21 + band_params*i] = (*params[param_gain21 + band_params*i])* + *params[param_gainscale2]; + + //Pass gains to eq's + for (unsigned int i = 0; i < fg.get_number_of_bands(); i++) + eq_arrL[*params[param_filters]]->change_band_gain_db(i,*params[param_gain_scale11 + band_params*i]); + + for (unsigned int i = 0; i < fg.get_number_of_bands(); i++) + eq_arrR[*params[param_filters]]->change_band_gain_db(i,*params[param_gain_scale21 + band_params*i]); + + //Upadte filter type + flt_type = (filter_type)(*params[param_filters] + 1); +} + +void equalizer30band_audio_module::set_sample_rate(uint32_t sr) +{ + srate = sr; + + //Change sample rate for eq's + for(unsigned int i = 0; i < eq_arrL.size(); i++) + { + eq_arrL[i]->set_sample_rate(srate); + eq_arrL[i]->set_sample_rate(srate); + } + + int meter[] = {param_level_in_vuL, param_level_in_vuR, param_level_out_vuL, param_level_out_vuR}; + int clip[] = {param_level_in_clipL, param_level_in_clipR, param_level_out_clipL, param_level_out_clipR}; + meters.init(params, meter, clip, 4, sr); +} + +uint32_t equalizer30band_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask) +{ + uint32_t orig_numsamples = numsamples; + uint32_t orig_offset = offset; + bool bypassed = bypass.update(*params[param_bypass] > 0.5f, numsamples); + numsamples += offset; + if(bypassed) { + // everything bypassed + while(offset < numsamples) { + outs[0][offset] = ins[0][offset]; + outs[1][offset] = ins[1][offset]; + float values[] = {0, 0, 0, 0}; + meters.process(values); + ++offset; + } + } else { + // process + while(offset < numsamples) { + + double inL = ins[0][offset] * *params[param_level_in]; + double inR = ins[1][offset] * *params[param_level_in]; + + double outL = inL; + double outR = inR; + + unsigned int eq_index = swL.get_state() - 1; + eq_arrL[eq_index]->sbs_process(&inL, &outL); + eq_arrR[eq_index]->sbs_process(&inR, &outR); + + //If filter type switched + if(flt_type_old != flt_type) + { + swL.set(flt_type); + swR.set(flt_type); + flt_type_old = flt_type; + } + + outL *= swL.get_ramp(); + outR *= swR.get_ramp(); + + outL = outL* conv.fast_db_2_lin(*params[param_gain_scale10]); + outR = outR* conv.fast_db_2_lin(*params[param_gain_scale20]); + + outL = outL* *params[param_level_out]; + outR = outR* *params[param_level_out]; + + outs[0][offset] = outL; + outs[1][offset] = outR; + + // meters + float values[] = {(float)inL, (float)inR, (float)outL, (float)outR}; + meters.process(values); + + // next sample + ++offset; + } // cycle trough samples + bypass.crossfade(ins, outs, 2, orig_offset, numsamples); + } + + meters.fall(orig_numsamples); + return outputs_mask; +} /********************************************************************** * FILTERKLAVIER by Hans Baier