Mirrors/overte-thingvellir
3
0
Fork 0
mirror of https://thingvellir.net/git/overte synced 2025-03-27 23:52:03 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove Gverb source code

Browse source
This commit is contained in:
Atlante45 2014-10-21 17:45:21 -07:00
parent 9a7ca8b132
commit d81158f941
7 changed files with 0 additions and 1284 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
interface/external/gverb/CMakeLists.txt vendored
View file

@ -1,2 +0,0 @@
cmake_minimum_required(VERSION 2.8)
add_library(gverb include/ladspa-util.h include/lv2.h src/gverb.h src/gverb.c src/gverbdsp.h src/gverbdsp.c)

234
interface/external/gverb/include/ladspa-util.h vendored
View file

@ -1,234 +0,0 @@
/* Some misc util functions for audio DSP work, written by Steve Harris,
* December 2000
*
* steve@plugin.org.uk
*/
#ifndef LADSPA_UTIL_H
#define LADSPA_UTIL_H
#include <math.h>
#include <stdint.h>
#include <string.h>
#define buffer_write(a, b) a=(b)
// 16.16 fixpoint
typedef union {
int32_t all;
struct {
#ifdef WORDS_BIGENDIAN
int16_t in;
uint16_t fr;
#else
uint16_t fr;
int16_t in;
#endif
} part;
} fixp16;
// 32.32 fixpoint
typedef union {
int64_t all;
struct {
#ifdef WORDS_BIGENDIAN
int32_t in;
uint32_t fr;
#else
uint32_t fr;
int32_t in;
#endif
} part;
} fixp32;
/* 32 bit "pointer cast" union */
typedef union {
float f;
int32_t i;
} ls_pcast32;
// Sometimes it doesn't get defined, even though it eists and C99 is declared
long int lrintf (float x);
// 1.0 / ln(2)
#define LN2R 1.442695041f
/* detet floating point denormal numbers by comparing them to the smallest
* normal, crap, but reliable */
#define DN_CHECK(x, l) if (fabs(x) < 1e-38) printf("DN: "l"\n")
// Denormalise floats, only actually needed for PIII and recent PowerPC
//#define FLUSH_TO_ZERO(fv) (((*(unsigned int*)&(fv))&0x7f800000)==0)?0.0f:(fv)
static inline float flush_to_zero(float f)
{
ls_pcast32 v;
v.f = f;
// original: return (v.i & 0x7f800000) == 0 ? 0.0f : f;
// version from Tim Blechmann
return (v.i & 0x7f800000) < 0x08000000 ? 0.0f : f;
}
static inline void round_to_zero(volatile float *f)
{
*f += 1e-18;
*f -= 1e-18;
}
/* A set of branchless clipping operations from Laurent de Soras */
static inline float f_max(float x, float a)
{
x -= a;
x += fabs(x);
x *= 0.5;
x += a;
return x;
}
static inline float f_min(float x, float b)
{
x = b - x;
x += fabs(x);
x *= 0.5;
x = b - x;
return x;
}
static inline float f_clamp(float x, float a, float b)
{
const float x1 = fabs(x - a);
const float x2 = fabs(x - b);
x = x1 + a + b;
x -= x2;
x *= 0.5;
return x;
}
// Limit a value to be l<=v<=u
#define LIMIT(v,l,u) ((v)<(l)?(l):((v)>(u)?(u):(v)))
// Truncate-to-zero modulo (ANSI C doesn't specify) will only work
// if -m < v < 2m
#define MOD(v,m) (v<0?v+m:(v>=m?v-m:v))
// Truncate-to-zero modulo (ANSI C doesn't specify) will only work
// if v > -m and v < m
#define NEG_MOD(v,m) ((v)<0?((v)+(m)):(v))
// Convert a value in dB's to a coefficent
#define DB_CO(g) ((g) > -90.0f ? powf(10.0f, (g) * 0.05f) : 0.0f)
#define CO_DB(v) (20.0f * log10f(v))
// Linearly interpolate [ = a * (1 - f) + b * f]
#define LIN_INTERP(f,a,b) ((a) + (f) * ((b) - (a)))
// Cubic interpolation function
static inline float cube_interp(const float fr, const float inm1, const float
in, const float inp1, const float inp2)
{
return in + 0.5f * fr * (inp1 - inm1 +
fr * (4.0f * inp1 + 2.0f * inm1 - 5.0f * in - inp2 +
fr * (3.0f * (in - inp1) - inm1 + inp2)));
}
/* fast sin^2 aproxiamtion, adapted from jan AT rpgfan's posting to the
* music-dsp list */
static inline float f_sin_sq(float angle)
{
const float asqr = angle * angle;
float result = -2.39e-08f;
result *= asqr;
result += 2.7526e-06f;
result *= asqr;
result -= 1.98409e-04f;
result *= asqr;
result += 8.3333315e-03f;
result *= asqr;
result -= 1.666666664e-01f;
result *= asqr;
result += 1.0f;
result *= angle;
return result * result;
}
#ifdef HAVE_LRINTF
#define f_round(f) lrintf(f)
#else
// Round float to int using IEEE int* hack
static inline int f_round(float f)
{
ls_pcast32 p;
p.f = f;
p.f += (3<<22);
return p.i - 0x4b400000;
}
#endif
// Truncate float to int
static inline int f_trunc(float f)
{
return f_round(floorf(f));
}
/* Andrew Simper's pow(2, x) aproximation from the music-dsp list */
#if 0
/* original */
static inline float f_pow2(float x)
{
long *px = (long*)(&x); // store address of float as long pointer
const float tx = (x-0.5f) + (3<<22); // temporary value for truncation
const long lx = *((long*)&tx) - 0x4b400000; // integer power of 2
const float dx = x-(float)(lx); // float remainder of power of 2
x = 1.0f + dx*(0.6960656421638072f + // cubic apporoximation of 2^x
dx*(0.224494337302845f + // for x in the range [0, 1]
dx*(0.07944023841053369f)));
*px += (lx<<23); // add integer power of 2 to exponent
return x;
}
#else
/* union version */
static inline float f_pow2(float x)
{
ls_pcast32 *px, tx, lx;
float dx;
px = (ls_pcast32 *)&x; // store address of float as long pointer
tx.f = (x-0.5f) + (3<<22); // temporary value for truncation
lx.i = tx.i - 0x4b400000; // integer power of 2
dx = x - (float)lx.i; // float remainder of power of 2
x = 1.0f + dx * (0.6960656421638072f + // cubic apporoximation of 2^x
dx * (0.224494337302845f + // for x in the range [0, 1]
dx * (0.07944023841053369f)));
(*px).i += (lx.i << 23); // add integer power of 2 to exponent
return (*px).f;
}
#endif
/* Fast exponentiation function, y = e^x */
#define f_exp(x) f_pow2(x * LN2R)
#endif

392
interface/external/gverb/include/lv2.h vendored
View file

@ -1,392 +0,0 @@
/* LV2 - LADSPA (Linux Audio Developer's Simple Plugin API) Version 2
* Revision 1
*
* Copyright (C) 2000-2002 Richard W.E. Furse, Paul Barton-Davis,
* Stefan Westerfeld.
* Copyright (C) 2006-2008 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.
*/
#ifndef LV2_H_INCLUDED
#define LV2_H_INCLUDED
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/* ************************************************************************* */
/** @file lv2.h
*
* Revision: 1
*
* == Overview ==
*
* There are a large number of open source and free software synthesis
* packages in use or development at this time. This API ('LV2')
* attempts to give programmers the ability to write simple 'plugin'
* audio processors in C/C++ and link them dynamically ('plug') into
* a range of these packages ('hosts'). It should be possible for any
* host and any plugin to communicate completely through this interface.
*
* This API is deliberately as short and simple as possible.
* The information required to use a plugin is in a companion data
* (RDF) file. The shared library portion of the API (defined in this
* header) does not contain enough information to make use of the plugin
* possible - the data file is mandatory.
*
* Plugins are expected to distinguish between control rate and audio
* rate data (or other types of data defined by extensions). Plugins have
* 'ports' that are inputs or outputs and each plugin is 'run' for a 'block'
* corresponding to a short time interval measured in samples. Audio rate
* data is communicated using arrays with one element per sample processed,
* allowing a block of audio to be processed by the plugin in a single
* pass. Control rate data is communicated using single values. Control
* rate data has a single value at the start of a call to the 'run()'
* function, and may be considered to remain this value for its duration.
* Thus the 'control rate' is determined by the block size, controlled by
* the host. The plugin may assume that all its input and output ports have
* been connected to the relevant data location (see the 'connect_port()'
* function below) before it is asked to run, unless the port has been set
* 'connection optional' in the plugin's data file.
*
* Plugins will reside in shared object files suitable for dynamic linking
* by dlopen() and family. The file will provide a number of 'plugin
* types' that can be used to instantiate actual plugins (sometimes known
* as 'plugin instances') that can be connected together to perform tasks.
* The host can access these plugin types using the lv2_descriptor()
* function.
*
* This API contains very limited error-handling.
*
* == Threading rules ==
*
* Certain hosts may need to call the functions provided by a plugin from
* multiple threads. For this to be safe, the plugin must be written so that
* those functions can be executed simultaneously without problems.
* To facilitate this, the functions provided by a plugin are divided into
* classes:
*
* - Discovery class: lv2_descriptor(), extension_data()
* - Instantiation class: instantiate(), cleanup(), activate(), deactivate()
* - Audio class: run(), connect_port()
*
* Extensions to this specification which add new functions MUST declare in
* which of these classes the functions belong, or define new classes for them.
* The rules that hosts must follow are these:
*
* - When a function from the Discovery class is running, no other
* functions in the same shared object file may run.
* - When a function from the Instantiation class is running for a plugin
* instance, no other functions for that instance may run.
* - When a function is running for a plugin instance, no other
* function in the same class may run for that instance.
*
* Any simultaneous calls that are not explicitly forbidden by these rules
* are allowed. For example, a host may call run() for two different plugin
* instances simultaneously.
*/
/* ************************************************************************* */
/** Plugin Handle.
*
* This plugin handle indicates a particular instance of the plugin
* concerned. It is valid to compare this to NULL (0 for C++) but
* otherwise the host MUST NOT attempt to interpret it. The plugin
* may use it to reference internal instance data. */
typedef void * LV2_Handle;
/* ************************************************************************* */
/** Feature data.
*
* These are passed to a plugin's instantiate method to represent a special
* feature the host has which the plugin may depend on. This is to allow
* extensions to the LV2 specification without causing any breakage.
* Extensions may specify what data needs to be passed here. The base
* LV2 specification does not define any features; hosts are not required
* to use this facility. */
typedef struct _LV2_Feature {
/** A globally unique, case-sensitive identifier for this feature.
*
* This MUST be defined in the specification of any LV2 extension which
* defines a host feature. */
const char * URI;
/** Pointer to arbitrary data.
*
* This is to allow hosts to pass data to a plugin (simple values, data
* structures, function pointers, etc) as part of a 'feature'. The LV2
* specification makes no restrictions on the contents of this data.
* The data here MUST be cleary defined by the LV2 extension which defines
* this feature.
* If no data is required, this may be set to NULL. */
void * data;
} LV2_Feature;
/* ************************************************************************* */
/** Descriptor for a Type of Plugin.
*
* This structure is used to describe a plugin type. It provides a number
* of functions to instantiate it, link it to buffers and run it. */
typedef struct _LV2_Descriptor {
/** A globally unique, case-sensitive identifier for this plugin type.
*
* All plugins with the same URI MUST be compatible in terms of 'port
* signature', meaning they have the same number of ports, same port
* shortnames, and roughly the same functionality. URIs should
* probably contain a version number (or similar) for this reason.
*
* Rationale: When serializing session/patch/etc files, hosts MUST
* refer to a loaded plugin by the plugin URI only. In the future
* loading a plugin with this URI MUST yield a plugin with the
* same ports (etc) which is 100% compatible. */
const char * URI;
/** Function pointer that instantiates a plugin.
*
* A handle is returned indicating the new plugin instance. The
* instantiation function accepts a sample rate as a parameter as well
* as the plugin descriptor from which this instantiate function was
* found. This function must return NULL if instantiation fails.
*
* bundle_path is a string of the path to the LV2 bundle which contains
* this plugin binary. It MUST include the trailing directory separator
* (e.g. '/') so that BundlePath + filename gives the path to a file
* in the bundle.
*
* features is a NULL terminated array of LV2_Feature structs which
* represent the features the host supports. Plugins may refuse to
* instantiate if required features are not found here (however hosts
* SHOULD NOT use this as a discovery mechanism, instead reading the
* data file before attempting to instantiate the plugin). This array
* must always exist; if a host has no features, it MUST pass a single
* element array containing NULL (to simplify plugins).
*
* Note that instance initialisation should generally occur in
* activate() rather than here. If a host calls instantiate, it MUST
* call cleanup() at some point in the future. */
LV2_Handle (*instantiate)(const struct _LV2_Descriptor * descriptor,
double sample_rate,
const char * bundle_path,
const LV2_Feature *const * features);
/** Function pointer that connects a port on a plugin instance to a memory
* location where the block of data for the port will be read/written.
*
* The data location is expected to be of the type defined in the
* plugin's data file (e.g. an array of float for an lv2:AudioPort).
* Memory issues are managed by the host. The plugin must read/write
* the data at these locations every time run() is called, data
* present at the time of this connection call MUST NOT be
* considered meaningful.
*
* The host MUST NOT try to connect a data buffer to a port index
* that is not defined in the RDF data for the plugin. If it does,
* the plugin's behaviour is undefined.
*
* connect_port() may be called more than once for a plugin instance
* to allow the host to change the buffers that the plugin is reading
* or writing. These calls may be made before or after activate()
* or deactivate() calls. Note that there may be realtime constraints
* on connect_port (see lv2:hardRTCapable in lv2.ttl).
*
* connect_port() MUST be called at least once for each port before
* run() is called. The plugin must pay careful attention to the block
* size passed to the run function as the block allocated may only just
* be large enough to contain the block of data (typically samples), and
* is not guaranteed to be constant.
*
* Plugin writers should be aware that the host may elect to use the
* same buffer for more than one port and even use the same buffer for
* both input and output (see lv2:inPlaceBroken in lv2.ttl).
* However, overlapped buffers or use of a single buffer for both
* audio and control data may result in unexpected behaviour.
*
* If the plugin has the feature lv2:hardRTCapable then there are
* various things that the plugin MUST NOT do within the connect_port()
* function (see lv2.ttl). */
void (*connect_port)(LV2_Handle instance,
uint32_t port,
void * data_location);
/** Function pointer that initialises a plugin instance and activates
* it for use.
*
* This is separated from instantiate() to aid real-time support and so
* that hosts can reinitialise a plugin instance by calling deactivate()
* and then activate(). In this case the plugin instance must reset all
* state information dependent on the history of the plugin instance
* except for any data locations provided by connect_port(). If there
* is nothing for activate() to do then the plugin writer may provide
* a NULL rather than an empty function.
*
* When present, hosts MUST call this function once before run()
* is called for the first time. This call SHOULD be made as close
* to the run() call as possible and indicates to real-time plugins
* that they are now live, however plugins MUST NOT rely on a prompt
* call to run() after activate(). activate() may not be called again
* unless deactivate() is called first (after which activate() may be
* called again, followed by deactivate, etc. etc.). If a host calls
* activate, it MUST call deactivate at some point in the future.
*
* Note that connect_port() may be called before or after a call to
* activate(). */
void (*activate)(LV2_Handle instance);
/** Function pointer that runs a plugin instance for a block.
*
* Two parameters are required: the first is a handle to the particular
* instance to be run and the second indicates the block size (in
* samples) for which the plugin instance may run.
*
* Note that if an activate() function exists then it must be called
* before run(). If deactivate() is called for a plugin instance then
* the plugin instance may not be reused until activate() has been
* called again.
*
* If the plugin has the feature lv2:hardRTCapable then there are
* various things that the plugin MUST NOT do within the run()
* function (see lv2.ttl). */
void (*run)(LV2_Handle instance,
uint32_t sample_count);
/** This is the counterpart to activate() (see above). If there is
* nothing for deactivate() to do then the plugin writer may provide
* a NULL rather than an empty function.
*
* Hosts must deactivate all activated units after they have been run()
* for the last time. This call SHOULD be made as close to the last
* run() call as possible and indicates to real-time plugins that
* they are no longer live, however plugins MUST NOT rely on prompt
* deactivation. Note that connect_port() may be called before or
* after a call to deactivate().
*
* Note that deactivation is not similar to pausing as the plugin
* instance will be reinitialised when activate() is called to reuse it.
* Hosts MUST NOT call deactivate() unless activate() was previously
* called. */
void (*deactivate)(LV2_Handle instance);
/** This is the counterpart to instantiate() (see above). Once an instance
* of a plugin has been finished with it can be deleted using this
* function. The instance handle passed ceases to be valid after
* this call.
*
* If activate() was called for a plugin instance then a corresponding
* call to deactivate() MUST be made before cleanup() is called.
* Hosts MUST NOT call cleanup() unless instantiate() was previously
* called. */
void (*cleanup)(LV2_Handle instance);
/** Function pointer that can be used to return additional instance data for
* a plugin defined by some extenion (e.g. a struct containing additional
* function pointers).
*
* The actual type and meaning of the returned object MUST be specified
* precisely by the extension if it defines any extra data. If a particular
* extension does not define extra instance data, this function MUST return
* NULL for that extension's URI. If a plugin does not support any
* extensions that define extra instance data, this function pointer may be
* set to NULL rather than providing an empty function.
*
* The only parameter is the URI of the extension. The plugin MUST return
* NULL if it does not support the extension, but hosts SHOULD NOT use this
* as a discovery method (e.g. hosts should only call this function for
* extensions known to be supported by the plugin from the data file).
*
* The host is never responsible for freeing the returned value.
*
* NOTE: This function should return a struct (likely containing function
* pointers) and NOT a direct function pointer. Standard C and C++ do not
* allow type casts from void* to a function pointer type. To provide
* additional functions a struct should be returned containing the extra
* function pointers (which is valid standard code, and a much better idea
* for extensibility anyway). */
const void* (*extension_data)(const char * uri);
} LV2_Descriptor;
/* ****************************************************************** */
/** Accessing Plugin Types.
*
* The exact mechanism by which plugins are loaded is host-dependent,
* however all most hosts will need to know is the URI of the plugin they
* wish to load. The environment variable LV2_PATH, if present, should
* contain a colon-separated path indicating directories (containing
* plugin bundle subdirectories) that should be searched (in order)
* for plugins. It is expected that hosts will use a library to provide
* this functionality.
*
* A plugin programmer must include a function called "lv2_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).
*
* A host will find the plugin shared object file by one means or another,
* find the lv2_descriptor() function, call it, and proceed from there.
*
* Plugin types are accessed by index (not ID) using values from 0
* upwards. Out of range indexes must result in this function returning
* NULL, so the plugin count can be determined by checking for the least
* index that results in NULL being returned. Index has no meaning,
* hosts MUST NOT depend on it remaining constant (ie when serialising)
* in any way. */
const LV2_Descriptor * lv2_descriptor(uint32_t index);
/** Datatype corresponding to the lv2_descriptor() function. */
typedef const LV2_Descriptor *
(*LV2_Descriptor_Function)(uint32_t index);
/* ******************************************************************** */
/* Put this (LV2_SYMBOL_EXPORT) before any functions that are to be loaded
* by the host as a symbol from the dynamic library.
*/
#ifdef WIN32
#define LV2_SYMBOL_EXPORT __declspec(dllexport)
#else
#define LV2_SYMBOL_EXPORT
#endif
#ifdef __cplusplus
}
#endif
#endif /* LV2_H_INCLUDED */

207
interface/external/gverb/src/gverb.c vendored
View file

@ -1,207 +0,0 @@
/*
Copyright (C) 1999 Juhana Sadeharju
kouhia at nic.funet.fi
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include "gverbdsp.h"
#include "gverb.h"
#include "../include/ladspa-util.h"
ty_gverb *gverb_new(int srate, float maxroomsize, float roomsize,
float revtime,
float damping, float spread,
float inputbandwidth, float earlylevel,
float taillevel)
{
ty_gverb *p;
float ga,gb,gt;
int i,n;
float r;
float diffscale;
int a,b,c,cc,d,dd,e;
float spread1,spread2;
p = (ty_gverb *)malloc(sizeof(ty_gverb));
p->rate = srate;
p->fdndamping = damping;
p->maxroomsize = maxroomsize;
p->roomsize = roomsize;
p->revtime = revtime;
p->earlylevel = earlylevel;
p->taillevel = taillevel;
p->maxdelay = p->rate*p->maxroomsize/340.0;
p->largestdelay = p->rate*p->roomsize/340.0;
/* Input damper */
p->inputbandwidth = inputbandwidth;
p->inputdamper = damper_make(1.0 - p->inputbandwidth);
/* FDN section */
p->fdndels = (ty_fixeddelay **)calloc(FDNORDER, sizeof(ty_fixeddelay *));
for(i = 0; i < FDNORDER; i++) {
p->fdndels[i] = fixeddelay_make((int)p->maxdelay+1000);
}
p->fdngains = (float *)calloc(FDNORDER, sizeof(float));
p->fdnlens = (int *)calloc(FDNORDER, sizeof(int));
p->fdndamps = (ty_damper **)calloc(FDNORDER, sizeof(ty_damper *));
for(i = 0; i < FDNORDER; i++) {
p->fdndamps[i] = damper_make(p->fdndamping);
}
ga = 60.0;
gt = p->revtime;
ga = powf(10.0f,-ga/20.0f);
n = p->rate*gt;
p->alpha = pow((double)ga, 1.0/(double)n);
gb = 0.0;
for(i = 0; i < FDNORDER; i++) {
if (i == 0) gb = 1.000000*p->largestdelay;
if (i == 1) gb = 0.816490*p->largestdelay;
if (i == 2) gb = 0.707100*p->largestdelay;
if (i == 3) gb = 0.632450*p->largestdelay;
#if 0
p->fdnlens[i] = nearest_prime((int)gb, 0.5);
#else
p->fdnlens[i] = f_round(gb);
#endif
p->fdngains[i] = -powf((float)p->alpha,p->fdnlens[i]);
}
p->d = (float *)calloc(FDNORDER, sizeof(float));
p->u = (float *)calloc(FDNORDER, sizeof(float));
p->f = (float *)calloc(FDNORDER, sizeof(float));
/* Diffuser section */
diffscale = (float)p->fdnlens[3]/(210+159+562+410);
spread1 = spread;
spread2 = 3.0*spread;
b = 210;
r = 0.125541;
a = spread1*r;
c = 210+159+a;
cc = c-b;
r = 0.854046;
a = spread2*r;
d = 210+159+562+a;
dd = d-c;
e = 1341-d;
p->ldifs = (ty_diffuser **)calloc(4, sizeof(ty_diffuser *));
p->ldifs[0] = diffuser_make((int)(diffscale*b),0.75);
p->ldifs[1] = diffuser_make((int)(diffscale*cc),0.75);
p->ldifs[2] = diffuser_make((int)(diffscale*dd),0.625);
p->ldifs[3] = diffuser_make((int)(diffscale*e),0.625);
b = 210;
r = -0.568366;
a = spread1*r;
c = 210+159+a;
cc = c-b;
r = -0.126815;
a = spread2*r;
d = 210+159+562+a;
dd = d-c;
e = 1341-d;
p->rdifs = (ty_diffuser **)calloc(4, sizeof(ty_diffuser *));
p->rdifs[0] = diffuser_make((int)(diffscale*b),0.75);
p->rdifs[1] = diffuser_make((int)(diffscale*cc),0.75);
p->rdifs[2] = diffuser_make((int)(diffscale*dd),0.625);
p->rdifs[3] = diffuser_make((int)(diffscale*e),0.625);
/* Tapped delay section */
p->tapdelay = fixeddelay_make(44000);
p->taps = (int *)calloc(FDNORDER, sizeof(int));
p->tapgains = (float *)calloc(FDNORDER, sizeof(float));
p->taps[0] = 5+0.410*p->largestdelay;
p->taps[1] = 5+0.300*p->largestdelay;
p->taps[2] = 5+0.155*p->largestdelay;
p->taps[3] = 5+0.000*p->largestdelay;
for(i = 0; i < FDNORDER; i++) {
p->tapgains[i] = pow(p->alpha,(double)p->taps[i]);
}
return(p);
}
void gverb_free(ty_gverb *p)
{
int i;
damper_free(p->inputdamper);
for(i = 0; i < FDNORDER; i++) {
fixeddelay_free(p->fdndels[i]);
damper_free(p->fdndamps[i]);
diffuser_free(p->ldifs[i]);
diffuser_free(p->rdifs[i]);
}
free(p->fdndels);
free(p->fdngains);
free(p->fdnlens);
free(p->fdndamps);
free(p->d);
free(p->u);
free(p->f);
free(p->ldifs);
free(p->rdifs);
free(p->taps);
free(p->tapgains);
fixeddelay_free(p->tapdelay);
free(p);
}
void gverb_flush(ty_gverb *p)
{
int i;
damper_flush(p->inputdamper);
for(i = 0; i < FDNORDER; i++) {
fixeddelay_flush(p->fdndels[i]);
damper_flush(p->fdndamps[i]);
diffuser_flush(p->ldifs[i]);
diffuser_flush(p->rdifs[i]);
}
memset(p->d, 0, FDNORDER * sizeof(float));
memset(p->u, 0, FDNORDER * sizeof(float));
memset(p->f, 0, FDNORDER * sizeof(float));
fixeddelay_flush(p->tapdelay);
}
/* swh: other functions are now in the .h file for inlining */

234
interface/external/gverb/src/gverb.h vendored
View file

@ -1,234 +0,0 @@
/*
Copyright (C) 1999 Juhana Sadeharju
kouhia at nic.funet.fi
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef GVERB_H
#define GVERB_H
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include "gverbdsp.h"
#include "gverb.h"
#include "../include/ladspa-util.h"
#define FDNORDER 4
typedef struct {
int rate;
float inputbandwidth;
float taillevel;
float earlylevel;
ty_damper *inputdamper;
float maxroomsize;
float roomsize;
float revtime;
float maxdelay;
float largestdelay;
ty_fixeddelay **fdndels;
float *fdngains;
int *fdnlens;
ty_damper **fdndamps;
float fdndamping;
ty_diffuser **ldifs;
ty_diffuser **rdifs;
ty_fixeddelay *tapdelay;
int *taps;
float *tapgains;
float *d;
float *u;
float *f;
double alpha;
} ty_gverb;
ty_gverb *gverb_new(int, float, float, float, float, float, float, float, float);
void gverb_free(ty_gverb *);
void gverb_flush(ty_gverb *);
static void gverb_do(ty_gverb *, float, float *, float *);
static void gverb_set_roomsize(ty_gverb *, float);
static void gverb_set_revtime(ty_gverb *, float);
static void gverb_set_damping(ty_gverb *, float);
static void gverb_set_inputbandwidth(ty_gverb *, float);
static void gverb_set_earlylevel(ty_gverb *, float);
static void gverb_set_taillevel(ty_gverb *, float);
/*
* This FDN reverb can be made smoother by setting matrix elements at the
* diagonal and near of it to zero or nearly zero. By setting diagonals to zero
* means we remove the effect of the parallel comb structure from the
* reverberation. A comb generates uniform impulse stream to the reverberation
* impulse response, and thus it is not good. By setting near diagonal elements
* to zero means we remove delay sequences having consequtive delays of the
* similar lenths, when the delays are in sorted in length with respect to
* matrix element index. The matrix described here could be generated by
* differencing Rocchesso's circulant matrix at max diffuse value and at low
* diffuse value (approaching parallel combs).
*
* Example 1:
* Set a(k,k), for all k, equal to 0.
*
* Example 2:
* Set a(k,k), a(k,k-1) and a(k,k+1) equal to 0.
*
* Example 3: The transition to zero gains could be smooth as well.
* a(k,k-1) and a(k,k+1) could be 0.3, and a(k,k-2) and a(k,k+2) could
* be 0.5, say.
*/
static inline void gverb_fdnmatrix(float *a, float *b)
{
const float dl0 = a[0], dl1 = a[1], dl2 = a[2], dl3 = a[3];
b[0] = 0.5f*(+dl0 + dl1 - dl2 - dl3);
b[1] = 0.5f*(+dl0 - dl1 - dl2 + dl3);
b[2] = 0.5f*(-dl0 + dl1 - dl2 + dl3);
b[3] = 0.5f*(+dl0 + dl1 + dl2 + dl3);
}
static inline void gverb_do(ty_gverb *p, float x, float *yl, float *yr)
{
float z;
unsigned int i;
float lsum,rsum,sum,sign;
if ((x != x) || fabsf(x) > 100000.0f) {
x = 0.0f;
}
z = damper_do(p->inputdamper, x);
z = diffuser_do(p->ldifs[0],z);
for(i = 0; i < FDNORDER; i++) {
p->u[i] = p->tapgains[i]*fixeddelay_read(p->tapdelay,p->taps[i]);
}
fixeddelay_write(p->tapdelay,z);
for(i = 0; i < FDNORDER; i++) {
p->d[i] = damper_do(p->fdndamps[i],
p->fdngains[i]*fixeddelay_read(p->fdndels[i],
p->fdnlens[i]));
}
sum = 0.0f;
sign = 1.0f;
for(i = 0; i < FDNORDER; i++) {
sum += sign*(p->taillevel*p->d[i] + p->earlylevel*p->u[i]);
sign = -sign;
}
sum += x*p->earlylevel;
lsum = sum;
rsum = sum;
gverb_fdnmatrix(p->d,p->f);
for(i = 0; i < FDNORDER; i++) {
fixeddelay_write(p->fdndels[i],p->u[i]+p->f[i]);
}
lsum = diffuser_do(p->ldifs[1],lsum);
lsum = diffuser_do(p->ldifs[2],lsum);
lsum = diffuser_do(p->ldifs[3],lsum);
rsum = diffuser_do(p->rdifs[1],rsum);
rsum = diffuser_do(p->rdifs[2],rsum);
rsum = diffuser_do(p->rdifs[3],rsum);
*yl = lsum;
*yr = rsum;
}
static inline void gverb_set_roomsize(ty_gverb *p, const float a)
{
unsigned int i;
if (a <= 1.0 || (a != a)) {
p->roomsize = 1.0;
} else {
p->roomsize = a;
}
p->largestdelay = p->rate * p->roomsize * 0.00294f;
p->fdnlens[0] = f_round(1.000000f*p->largestdelay);
p->fdnlens[1] = f_round(0.816490f*p->largestdelay);
p->fdnlens[2] = f_round(0.707100f*p->largestdelay);
p->fdnlens[3] = f_round(0.632450f*p->largestdelay);
for(i = 0; i < FDNORDER; i++) {
p->fdngains[i] = -powf((float)p->alpha, p->fdnlens[i]);
}
p->taps[0] = 5+f_round(0.410f*p->largestdelay);
p->taps[1] = 5+f_round(0.300f*p->largestdelay);
p->taps[2] = 5+f_round(0.155f*p->largestdelay);
p->taps[3] = 5+f_round(0.000f*p->largestdelay);
for(i = 0; i < FDNORDER; i++) {
p->tapgains[i] = powf((float)p->alpha, p->taps[i]);
}
}
static inline void gverb_set_revtime(ty_gverb *p,float a)
{
float ga,gt;
double n;
unsigned int i;
p->revtime = a;
ga = 60.0;
gt = p->revtime;
ga = powf(10.0f,-ga/20.0f);
n = p->rate*gt;
p->alpha = (double)powf(ga,1.0f/n);
for(i = 0; i < FDNORDER; i++) {
p->fdngains[i] = -powf((float)p->alpha, p->fdnlens[i]);
}
}
static inline void gverb_set_damping(ty_gverb *p,float a)
{
unsigned int i;
p->fdndamping = a;
for(i = 0; i < FDNORDER; i++) {
damper_set(p->fdndamps[i],p->fdndamping);
}
}
static inline void gverb_set_inputbandwidth(ty_gverb *p,float a)
{
p->inputbandwidth = a;
damper_set(p->inputdamper,1.0 - p->inputbandwidth);
}
static inline void gverb_set_earlylevel(ty_gverb *p,float a)
{
p->earlylevel = a;
}
static inline void gverb_set_taillevel(ty_gverb *p,float a)
{
p->taillevel = a;
}
#endif

130
interface/external/gverb/src/gverbdsp.c vendored
View file

@ -1,130 +0,0 @@
/*
Copyright (C) 1999 Juhana Sadeharju
kouhia at nic.funet.fi
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "gverbdsp.h"
#define TRUE 1
#define FALSE 0
ty_diffuser *diffuser_make(int size, float coeff)
{
ty_diffuser *p;
int i;
p = (ty_diffuser *)malloc(sizeof(ty_diffuser));
p->size = size;
p->coeff = coeff;
p->idx = 0;
p->buf = (float *)malloc(size*sizeof(float));
for (i = 0; i < size; i++) p->buf[i] = 0.0;
return(p);
}
void diffuser_free(ty_diffuser *p)
{
free(p->buf);
free(p);
}
void diffuser_flush(ty_diffuser *p)
{
memset(p->buf, 0, p->size * sizeof(float));
}
ty_damper *damper_make(float damping)
{
ty_damper *p;
p = (ty_damper *)malloc(sizeof(ty_damper));
p->damping = damping;
p->delay = 0.0f;
return(p);
}
void damper_free(ty_damper *p)
{
free(p);
}
void damper_flush(ty_damper *p)
{
p->delay = 0.0f;
}
ty_fixeddelay *fixeddelay_make(int size)
{
ty_fixeddelay *p;
int i;
p = (ty_fixeddelay *)malloc(sizeof(ty_fixeddelay));
p->size = size;
p->idx = 0;
p->buf = (float *)malloc(size*sizeof(float));
for (i = 0; i < size; i++) p->buf[i] = 0.0;
return(p);
}
void fixeddelay_free(ty_fixeddelay *p)
{
free(p->buf);
free(p);
}
void fixeddelay_flush(ty_fixeddelay *p)
{
memset(p->buf, 0, p->size * sizeof(float));
}
int isprime(int n)
{
unsigned int i;
const unsigned int lim = (int)sqrtf((float)n);
if (n == 2) return(TRUE);
if ((n & 1) == 0) return(FALSE);
for(i = 3; i <= lim; i += 2)
if ((n % i) == 0) return(FALSE);
return(TRUE);
}
int nearest_prime(int n, float rerror)
/* relative error; new prime will be in range
* [n-n*rerror, n+n*rerror];
*/
{
int bound,k;
if (isprime(n)) return(n);
/* assume n is large enough and n*rerror enough smaller than n */
bound = n*rerror;
for(k = 1; k <= bound; k++) {
if (isprime(n+k)) return(n+k);
if (isprime(n-k)) return(n-k);
}
return(-1);
}

85
interface/external/gverb/src/gverbdsp.h vendored
View file

@ -1,85 +0,0 @@
#ifndef GVERBDSP_H
#define GVERBDSP_H
#include "../include/ladspa-util.h"
typedef struct {
int size;
int idx;
float *buf;
} ty_fixeddelay;
typedef struct {
int size;
float coeff;
int idx;
float *buf;
} ty_diffuser;
typedef struct {
float damping;
float delay;
} ty_damper;
ty_diffuser *diffuser_make(int, float);
void diffuser_free(ty_diffuser *);
void diffuser_flush(ty_diffuser *);
//float diffuser_do(ty_diffuser *, float);
ty_damper *damper_make(float);
void damper_free(ty_damper *);
void damper_flush(ty_damper *);
//void damper_set(ty_damper *, float);
//float damper_do(ty_damper *, float);
ty_fixeddelay *fixeddelay_make(int);
void fixeddelay_free(ty_fixeddelay *);
void fixeddelay_flush(ty_fixeddelay *);
//float fixeddelay_read(ty_fixeddelay *, int);
//void fixeddelay_write(ty_fixeddelay *, float);
int isprime(int);
int nearest_prime(int, float);
static inline float diffuser_do(ty_diffuser *p, float x)
{
float y,w;
w = x - p->buf[p->idx]*p->coeff;
w = flush_to_zero(w);
y = p->buf[p->idx] + w*p->coeff;
p->buf[p->idx] = w;
p->idx = (p->idx + 1) % p->size;
return(y);
}
static inline float fixeddelay_read(ty_fixeddelay *p, int n)
{
int i;
i = (p->idx - n + p->size) % p->size;
return(p->buf[i]);
}
static inline void fixeddelay_write(ty_fixeddelay *p, float x)
{
p->buf[p->idx] = x;
p->idx = (p->idx + 1) % p->size;
}
static inline void damper_set(ty_damper *p, float damping)
{
p->damping = damping;
}
static inline float damper_do(ty_damper *p, float x)
{
float y;
y = x*(1.0-p->damping) + p->delay*p->damping;
p->delay = y;
return(y);
}
#endif