#include <cassert>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <wx/types.h>

Include dependency graph for Reverb_libSoX.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	fifo_t

struct	filter_t

struct	one_pole_t

struct	filter_array_t

struct	reverb_t

Macros
#define	M_LN10 2.30258509299404568402 /* log_e 10 */

#define	array_length(a) (sizeof(a)/sizeof(a[0]))

#define	dB_to_linear(x) exp((x) * M_LN10 * 0.05)

#define	midi_to_freq(n) (440 * pow(2,((n)-69)/12.))

#define	FIFO_SIZE_T size_t

#define	FIFO_MIN 0x4000

#define	fifo_read_ptr(f) fifo_read(f, (FIFO_SIZE_T)0, NULL)

#define	lsx_zalloc(var, n) var = (float )calloc(n, sizeof(var))

#define	filter_advance(p) if (--(p)->ptr < (p)->buffer) (p)->ptr += (p)->size

#define	filter_delete(p) free((p)->buffer)

Functions
static void	fifo_clear (fifo_t *f)

static void	fifo_clear_and_zero (fifo_t *f)

static void *	fifo_reserve (fifo_t *f, FIFO_SIZE_T n)

static void *	fifo_write (fifo_t f, FIFO_SIZE_T n, void const data)

static void *	fifo_read (fifo_t f, FIFO_SIZE_T n, void data)

static void	fifo_delete (fifo_t *f)

static void	fifo_create (fifo_t *f, FIFO_SIZE_T item_size)

static float	comb_process (filter_t p, float const input, float const feedback, float const hf_damping)

static float	allpass_process (filter_t p, float const input)

static float	one_pole_process (one_pole_t *p, float i0)

static void	one_pole_init (filter_array_t *p, double rate, double fc_highpass, double fc_lowpass)

static void	filter_array_allocate (filter_array_t *p, double rate, double scale, double offset)

static void	filter_t_resize (filter_t *p, size_t newSize)

static void	filter_array_init (filter_array_t *p, double rate, double scale, double offset)

static void	filter_array_create (filter_array_t *p, double rate, double scale, double offset)

static void	filter_array_process (filter_array_t p, size_t length, float const input, float output, float const feedback, float const hf_damping, float const gain)

static void	filter_array_delete (filter_array_t *p)

static void	filter_t_resize_resetting (filter_t *p, size_t newSize)

static void	filter_t_resize_preserving (filter_t *p, size_t newSize)

static void	reverb_allocate (reverb_t p, double sample_rate_Hz, size_t buffer_size, float *out)

static void	reverb_set_simple_params (reverb_t *p, double sample_rate_Hz, double wet_gain_dB, double reverberance, double hf_damping, double tone_low, double tone_high)

static void	reverb_init (reverb_t *p, double sample_rate_Hz, double wet_gain_dB, double room_scale, double reverberance, double hf_damping, double pre_delay_ms, double stereo_depth, double tone_low, double tone_high)

static void	reverb_create (reverb_t p, double sample_rate_Hz, double wet_gain_dB, double room_scale, double reverberance, double hf_damping, double pre_delay_ms, double stereo_depth, double tone_low, double tone_high, size_t buffer_size, float *out)

static void	reverb_process (reverb_t *p, size_t length)

static void	reverb_delete (reverb_t *p)

static void	reverb_clear (reverb_t *p)

Variables
static const size_t	comb_lengths [] = {1116, 1188, 1277, 1356, 1422, 1491, 1557, 1617}

static const size_t	allpass_lengths [] = {225, 341, 441, 556}

static const size_t	stereo_adjust = 12

Macro Definition Documentation

◆ array_length

#define array_length ( a ) (sizeof(a)/sizeof(a[0]))

Definition at line 28 of file Reverb_libSoX.h.

◆ dB_to_linear

#define dB_to_linear ( x ) exp((x) * M_LN10 * 0.05)

Definition at line 29 of file Reverb_libSoX.h.

◆ FIFO_MIN

#define FIFO_MIN 0x4000

Definition at line 32 of file Reverb_libSoX.h.

◆ fifo_read_ptr

#define fifo_read_ptr ( f ) fifo_read(f, (FIFO_SIZE_T)0, NULL)

Definition at line 33 of file Reverb_libSoX.h.

◆ FIFO_SIZE_T

#define FIFO_SIZE_T size_t

Definition at line 31 of file Reverb_libSoX.h.

◆ filter_advance

#define filter_advance ( p ) if (--(p)->ptr < (p)->buffer) (p)->ptr += (p)->size

Definition at line 35 of file Reverb_libSoX.h.

◆ filter_delete

#define filter_delete ( p ) free((p)->buffer)

Definition at line 36 of file Reverb_libSoX.h.

◆ lsx_zalloc

#define lsx_zalloc	(	var,
		n
	)	var = (float )calloc(n, sizeof(var))

Definition at line 34 of file Reverb_libSoX.h.

◆ M_LN10

#define M_LN10 2.30258509299404568402 /* log_e 10 */

Definition at line 19 of file Reverb_libSoX.h.

◆ midi_to_freq

#define midi_to_freq ( n ) (440 * pow(2,((n)-69)/12.))

Definition at line 30 of file Reverb_libSoX.h.

Function Documentation

◆ allpass_process()

static float allpass_process	(	filter_t *	p,
		float const *	input
	)

static

Definition at line 132 of file Reverb_libSoX.h.

{
   float output = *p->ptr;
   *p->ptr = *input + output * .5;
   filter_advance(p);
   return output - *input;
}

References filter_advance, and filter_t::ptr.

Referenced by filter_array_process().

Here is the caller graph for this function:

◆ comb_process()

static float comb_process	(	filter_t *	p,
		float const *	input,
		float const *	feedback,
		float const *	hf_damping
	)

static

Definition at line 122 of file Reverb_libSoX.h.

{
   float output = *p->ptr;
   p->store = output + (p->store - output) * *hf_damping;
   *p->ptr = *input + p->store * *feedback;
   filter_advance(p);
   return output;
}

References filter_advance, filter_t::ptr, and filter_t::store.

Referenced by filter_array_process().

Here is the caller graph for this function:

◆ fifo_clear()

static void fifo_clear ( fifo_t * f )

static

Definition at line 46 of file Reverb_libSoX.h.

{
   f->end = f->begin = 0;
}

References fifo_t::begin, and fifo_t::end.

Referenced by fifo_create(), fifo_reserve(), and reverb_clear().

Here is the caller graph for this function:

◆ fifo_clear_and_zero()

static void fifo_clear_and_zero ( fifo_t * f )

static

Definition at line 51 of file Reverb_libSoX.h.

{
   f->end = f->begin = 0;
   memset(f->data, 0, f->allocation);
}

References fifo_t::allocation, fifo_t::begin, fifo_t::data, and fifo_t::end.

Referenced by reverb_init().

Here is the caller graph for this function:

◆ fifo_create()

static void fifo_create	(	fifo_t *	f,
		FIFO_SIZE_T	item_size
	)

static

Definition at line 108 of file Reverb_libSoX.h.

{
   f->item_size = item_size;
   f->allocation = FIFO_MIN;
   f->data = (char *)malloc(f->allocation);
   fifo_clear(f);
}

References fifo_t::allocation, fifo_t::data, fifo_clear(), FIFO_MIN, and fifo_t::item_size.

Referenced by reverb_allocate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fifo_delete()

static void fifo_delete ( fifo_t * f )

static

Definition at line 103 of file Reverb_libSoX.h.

{
   free(f->data);
}

References fifo_t::data, and staffpad::vo::free().

Referenced by reverb_delete().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fifo_read()

static void * fifo_read	(	fifo_t *	f,
		FIFO_SIZE_T	n,
		void *	data
	)

static

Definition at line 91 of file Reverb_libSoX.h.

{
   char * ret = f->data + f->begin;
   n *= f->item_size;
   if (n > (FIFO_SIZE_T)(f->end - f->begin))
      return NULL;
   if (data)
      memcpy(data, ret, (size_t)n);
   f->begin += n;
   return ret;
}

References fifo_t::begin, fifo_t::data, fifo_t::end, FIFO_SIZE_T, and fifo_t::item_size.

Referenced by reverb_process().

Here is the caller graph for this function:

◆ fifo_reserve()

static void * fifo_reserve	(	fifo_t *	f,
		FIFO_SIZE_T	n
	)

static

Definition at line 58 of file Reverb_libSoX.h.

{
   n *= f->item_size;
 
   if (f->begin == f->end)
      fifo_clear(f);
 
   while (1) {
      if (f->end + n <= f->allocation) {
         void *p = f->data + f->end;
 
         f->end += n;
         return p;
      }
      if (f->begin > FIFO_MIN) {
         memmove(f->data, f->data + f->begin, f->end - f->begin);
         f->end -= f->begin;
         f->begin = 0;
         continue;
      }
      f->allocation += n;
      f->data = (char *)realloc(f->data, f->allocation);
   }
}

References fifo_t::allocation, fifo_t::begin, fifo_t::data, fifo_t::end, fifo_clear(), FIFO_MIN, and fifo_t::item_size.

Referenced by fifo_write().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fifo_write()

static void * fifo_write	(	fifo_t *	f,
		FIFO_SIZE_T	n,
		void const *	data
	)

static

Definition at line 83 of file Reverb_libSoX.h.

{
   void * s = fifo_reserve(f, n);
   if (data)
      memcpy(s, data, n * f->item_size);
   return s;
}

References fifo_reserve(), and fifo_t::item_size.

Referenced by ReverbBase::Instance::InstanceProcess(), and reverb_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ filter_array_allocate()

static void filter_array_allocate	(	filter_array_t *	p,
		double	rate,
		double	scale,
		double	offset
	)

static

Definition at line 176 of file Reverb_libSoX.h.

{
   size_t i;
   double r = rate * (1 / 44100.); /* Compensate for actual sample-rate */
 
   for (i = 0; i < array_length(comb_lengths); ++i)
   {
      filter_t* pcomb = &p->comb[i];
      pcomb->size = (size_t)(scale * r * (comb_lengths[i] + stereo_adjust * offset) + .5);
      pcomb->ptr = lsx_zalloc(pcomb->buffer, pcomb->size);
   }
   for (i = 0; i < array_length(allpass_lengths); ++i)
   {
      filter_t* pallpass = &p->allpass[i];
      pallpass->size = (size_t)(r * (allpass_lengths[i] + stereo_adjust * offset) + .5);
      pallpass->ptr = lsx_zalloc(pallpass->buffer, pallpass->size);
   }
}

References filter_array_t::allpass, allpass_lengths, array_length, filter_t::buffer, filter_array_t::comb, comb_lengths, lsx_zalloc, filter_t::ptr, filter_t::size, and stereo_adjust.

Referenced by reverb_allocate().

Here is the caller graph for this function:

◆ filter_array_create()

static void filter_array_create	(	filter_array_t *	p,
		double	rate,
		double	scale,
		double	offset
	)

static

Definition at line 220 of file Reverb_libSoX.h.

{
   size_t i;
   double r = rate * (1 / 44100.); /* Compensate for actual sample-rate */
 
   for (i = 0; i < array_length(comb_lengths); ++i, offset = -offset)
   {
      filter_t * pcomb = &p->comb[i];
      pcomb->size = (size_t)(scale * r * (comb_lengths[i] + stereo_adjust * offset) + .5);
      pcomb->ptr = lsx_zalloc(pcomb->buffer, pcomb->size);
   }
   for (i = 0; i < array_length(allpass_lengths); ++i, offset = -offset)
   {
      filter_t * pallpass = &p->allpass[i];
      pallpass->size = (size_t)(r * (allpass_lengths[i] + stereo_adjust * offset) + .5);
      pallpass->ptr = lsx_zalloc(pallpass->buffer, pallpass->size);
   }
}

References filter_array_t::allpass, allpass_lengths, array_length, filter_t::buffer, filter_array_t::comb, comb_lengths, lsx_zalloc, filter_t::ptr, filter_t::size, and stereo_adjust.

◆ filter_array_delete()

static void filter_array_delete ( filter_array_t * p )

static

Definition at line 261 of file Reverb_libSoX.h.

{
   size_t i;
 
   for (i = 0; i < array_length(allpass_lengths); ++i)
      filter_delete(&p->allpass[i]);
   for (i = 0; i < array_length(comb_lengths); ++i)
      filter_delete(&p->comb[i]);
}

References filter_array_t::allpass, allpass_lengths, array_length, filter_array_t::comb, comb_lengths, and filter_delete.

Referenced by reverb_delete().

Here is the caller graph for this function:

◆ filter_array_init()

static void filter_array_init	(	filter_array_t *	p,
		double	rate,
		double	scale,
		double	offset
	)

static

Definition at line 198 of file Reverb_libSoX.h.

{
   size_t i;
   double r = rate * (1 / 44100.); /* Compensate for actual sample-rate */
 
   for (i = 0; i < array_length(comb_lengths); ++i, offset = -offset)
   {
      filter_t* pcomb = &p->comb[i];
      size_t newSize = (size_t)(scale * r * (comb_lengths[i] + stereo_adjust * offset) + .5);
      filter_t_resize(pcomb, newSize);
   }
   for (i = 0; i < array_length(allpass_lengths); ++i, offset = -offset)
   {
      filter_t* pallpass = &p->allpass[i];
      size_t newSize = (size_t)(r * (allpass_lengths[i] + stereo_adjust * offset) + .5);
      filter_t_resize(pallpass, newSize);
   }
}

References filter_array_t::allpass, allpass_lengths, array_length, filter_array_t::comb, comb_lengths, filter_t_resize(), and stereo_adjust.

Referenced by reverb_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ filter_array_process()

static void filter_array_process	(	filter_array_t *	p,
		size_t	length,
		float const *	input,
		float *	output,
		float const *	feedback,
		float const *	hf_damping,
		float const *	gain
	)

static

Definition at line 240 of file Reverb_libSoX.h.

{
   while (length--) {
      float out = 0, in = *input++;
 
      size_t i = array_length(comb_lengths) - 1;
      do out += comb_process(p->comb + i, &in, feedback, hf_damping);
      while (i--);
 
      i = array_length(allpass_lengths) - 1;
      do out = allpass_process(p->allpass + i, &out);
      while (i--);
 
      out = one_pole_process(&p->one_pole[0], out);
      out = one_pole_process(&p->one_pole[1], out);
      *output++ = out * *gain;
   }
}

References filter_array_t::allpass, allpass_lengths, allpass_process(), array_length, filter_array_t::comb, comb_lengths, comb_process(), filter_array_t::one_pole, and one_pole_process().

Referenced by reverb_process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ filter_t_resize()

static void filter_t_resize	(	filter_t *	p,
		size_t	newSize
	)

static

Definition at line 369 of file Reverb_libSoX.h.

{
   // Choose your resize method.
   //
   // When moving the Room Size slider:
   //
   // - using resize_resetting, you will not hear previous reverberations,
   //   but at the same time you will not hear sound artifacts
   //
   // - using resize_preserving, you will hear previous reverberations,
   //   but sometimes you might hear sound artifacts
 
#if 1
   filter_t_resize_resetting(p, newSize);
#else
   filter_t_resize_preserving(p, newSize);
#endif
 
}

References filter_t_resize_preserving(), and filter_t_resize_resetting().

Referenced by filter_array_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ filter_t_resize_preserving()

static void filter_t_resize_preserving	(	filter_t *	p,
		size_t	newSize
	)

static

Definition at line 293 of file Reverb_libSoX.h.

{
   // Imagine we have this filter_t as input:
   //
   //                  ptr goes from right to left and when falling off the left side, it wraps back to the right;
   //    <--ptr--      it reads the most distant sample in the past, and after reading it will write a new sample.
   //        |         Imagine someone just recorded "A B C D E", and now we are going to read "A", but a resize request comes.
   //        v
   //  | C B A E D |
   //
 
   // Depending on the new requested size and where ptr is, we can have these cases:
   //
   //        v
   //  | C B A 0 E D |  bigger size: right-shift what is right of ptr,
   //                   and fill the resulting gap with zeros.
   //
   //                   (with variant: ptr is already at the old right edge - then shift nothing, just append zeros)
   //        v
   //  | C B A D |      smaller size, and ptr is within it (but not at the edge): left-shift what is to the right of ptr,
   //                   discarding samples.
   //
   //        V
   //  | C B A |        smaller size, and ptr would be at the new right edge; do nothing.
   //
   //      v
   //  | B A |          smaller size, and ptr would be beyond the new right edge: left-shift what is ahead of ptr,
   //                   AND move ptr to size-1
 
   assert(newSize > 0);
 
   const int    sizeDiff = ((ssize_t)newSize - (ssize_t)p->size);
   const size_t ptrPos   = (p->ptr  - p->buffer);
 
   const size_t numSamplesBehindPtr = (p->size - 1) - ptrPos;
 
   if (sizeDiff > 0)
   {
      // case: bigger size
 
      if (numSamplesBehindPtr > 0)
      {
         // right-shift what is right of ptr
         memcpy(p->ptr + 1 + sizeDiff, p->ptr + 1, numSamplesBehindPtr * sizeof(float));
      }
 
      // fill the created gap with zeros
      memset(p->ptr + 1, 0, sizeDiff * sizeof(float));
   }
   else if (sizeDiff < 0)
   {
      // case: smaller size
 
      if (ptrPos < newSize-1)
      {
         size_t lenOfBlockToShift = newSize - 1 - ptrPos;
         float* ptrToBlockToShift = p->buffer + p->size - lenOfBlockToShift;
         memcpy(p->ptr + 1, ptrToBlockToShift, lenOfBlockToShift * sizeof(float));
      }
      else if (ptrPos == newSize - 1)
      {
         // sub-case: ptr is at the new edge - no shifting to do, and ptr can stay where it is
      }
      else
      {
         // sub-case: ptr would be beyond the new edge
         // left-shift what is ahead of ptr and make ptr point to the new edge
         memcpy(p->buffer, p->ptr - newSize + 1, newSize * sizeof(float));
         p->ptr = p->buffer + newSize - 1;
      }
   }
 
   p->size = newSize;
}

References filter_t::buffer, filter_t::ptr, and filter_t::size.

Referenced by filter_t_resize().

Here is the caller graph for this function:

◆ filter_t_resize_resetting()

static void filter_t_resize_resetting	(	filter_t *	p,
		size_t	newSize
	)

static

Definition at line 283 of file Reverb_libSoX.h.

{
   memset(p->buffer, 0, newSize * sizeof(float));
   p->ptr = p->buffer;
   p->store = 0;
   p->size = newSize;
}

References filter_t::buffer, filter_t::ptr, filter_t::size, and filter_t::store.

Referenced by filter_t_resize().

Here is the caller graph for this function:

◆ one_pole_init()

static void one_pole_init	(	filter_array_t *	p,
		double	rate,
		double	fc_highpass,
		double	fc_lowpass
	)

static

Definition at line 160 of file Reverb_libSoX.h.

{
   { /* EQ: highpass */
      one_pole_t* q = &p->one_pole[0];
      q->a1 = -exp(-2 * M_PI * fc_highpass / rate);
      q->b0 = (1 - q->a1) / 2, q->b1 = -q->b0;
   }
   { /* EQ: lowpass */
      one_pole_t* q = &p->one_pole[1];
      q->a1 = -exp(-2 * M_PI * fc_lowpass / rate);
      q->b0 = 1 + q->a1, q->b1 = 0;
   }
}

References one_pole_t::a1, one_pole_t::b0, one_pole_t::b1, M_PI, and filter_array_t::one_pole.

Referenced by reverb_set_simple_params().

Here is the caller graph for this function:

◆ one_pole_process()

static float one_pole_process	(	one_pole_t *	p,
		float	i0
	)

static

Definition at line 143 of file Reverb_libSoX.h.

{
   float o0 = i0*p->b0 + p->i1*p->b1 - p->o1*p->a1;
   p->i1 = i0;
   return p->o1 = o0;
}

References one_pole_t::a1, one_pole_t::b0, one_pole_t::b1, one_pole_t::i1, and one_pole_t::o1.

Referenced by filter_array_process().

Here is the caller graph for this function:

◆ reverb_allocate()

static void reverb_allocate	(	reverb_t *	p,
		double	sample_rate_Hz,
		size_t	buffer_size,
		float **	out
	)

static

Definition at line 390 of file Reverb_libSoX.h.

{
   memset(p, 0, sizeof(*p));
 
   // Input queue
   fifo_create(&p->input_fifo, sizeof(float));
 
   // Outputs
   out[0] = lsx_zalloc(p->out[0], buffer_size);
   out[1] = lsx_zalloc(p->out[1], buffer_size);
 
   // Allpass & Comb filters
   // pass the numbers that will cause the maximum possible allocation of the
   // buffer just once, even if it is in excess of what is required by the
   // settings passed in initialization after the allocation
   filter_array_allocate(p->chan + 0, sample_rate_Hz, 1.0, 0.0);
   filter_array_allocate(p->chan + 1, sample_rate_Hz, 1.0, 1.0);
}

References reverb_t::chan, fifo_create(), filter_array_allocate(), reverb_t::input_fifo, lsx_zalloc, and reverb_t::out.

Referenced by reverb_create().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reverb_clear()

static void reverb_clear ( reverb_t * p )

static

Definition at line 511 of file Reverb_libSoX.h.

{
   for (size_t c = 0; c < 2; c++)
   {
      auto& chn = p->chan[c];
 
      chn.one_pole[0].i1 = 0.0;
      chn.one_pole[0].o1 = 0.0;
 
      chn.one_pole[1].i1 = 0.0;
      chn.one_pole[1].o1 = 0.0;
 
      for (size_t combIndex = 0; combIndex < array_length(comb_lengths); combIndex++)
      {
         auto& comb = chn.comb[combIndex];
 
         memset(comb.buffer, 0, comb.size * sizeof(float));
 
         comb.store = 0.0f;
      }
 
      for (size_t allpassIndex = 0; allpassIndex < array_length(allpass_lengths); allpassIndex++)
      {
         auto& allpass = chn.allpass[allpassIndex];
 
         memset(allpass.buffer, 0, allpass.size * sizeof(float));
 
         allpass.store = 0.0f;
      }
   } // loop on channels
 
   fifo_clear( &(p->input_fifo) );
}

References allpass_lengths, array_length, reverb_t::chan, comb_lengths, fifo_clear(), one_pole_t::i1, reverb_t::input_fifo, and filter_array_t::one_pole.

Referenced by ReverbBase::Instance::RealtimeSuspend().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reverb_create()

static void reverb_create	(	reverb_t *	p,
		double	sample_rate_Hz,
		double	wet_gain_dB,
		double	room_scale,
		double	reverberance,
		double	hf_damping,
		double	pre_delay_ms,
		double	stereo_depth,
		double	tone_low,
		double	tone_high,
		size_t	buffer_size,
		float **	out
	)

static

Definition at line 474 of file Reverb_libSoX.h.

{
   reverb_allocate(p, sample_rate_Hz, buffer_size, out);
 
   reverb_init(p, sample_rate_Hz, wet_gain_dB, room_scale, reverberance, hf_damping, pre_delay_ms, stereo_depth, tone_low, tone_high);
}

References reverb_allocate(), and reverb_init().

Referenced by ReverbBase::Instance::InstanceInit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reverb_delete()

static void reverb_delete ( reverb_t * p )

static

Definition at line 501 of file Reverb_libSoX.h.

{
   size_t i;
   for (i = 0; i < 2 && p->out[i]; ++i) {
      free(p->out[i]);
      filter_array_delete(p->chan + i);
   }
   fifo_delete(&p->input_fifo);
}

References reverb_t::chan, fifo_delete(), filter_array_delete(), staffpad::vo::free(), reverb_t::input_fifo, and reverb_t::out.

Referenced by Reverb_priv_ex::~Reverb_priv_ex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reverb_init()

static void reverb_init	(	reverb_t *	p,
		double	sample_rate_Hz,
		double	wet_gain_dB,
		double	room_scale,
		double	reverberance,
		double	hf_damping,
		double	pre_delay_ms,
		double	stereo_depth,
		double	tone_low,
		double	tone_high
	)

static

Definition at line 439 of file Reverb_libSoX.h.

{
   // Input queue
   fifo_clear_and_zero(&p->input_fifo);
   size_t delay = pre_delay_ms / 1000 * sample_rate_Hz + .5;
   memset(fifo_write(&p->input_fifo, delay, 0), 0, delay * sizeof(float));
 
   reverb_set_simple_params(p, sample_rate_Hz, wet_gain_dB, reverberance, hf_damping, tone_low, tone_high);
 
   // Allpass & Comb filters
   double scale = room_scale / 100 * .9 + .1;
   double depth = stereo_depth / 100;
   for (size_t i = 0; i <= ceil(depth); ++i)
   {
      filter_array_init(p->chan + i, sample_rate_Hz, scale, i * depth);
   }
 
   // Remember if stereo depth was set to 0, so we do not have to process twice
   p->initializedWithZeroDepth = (stereo_depth == 0.0);
 
}

References reverb_t::chan, fifo_clear_and_zero(), fifo_write(), filter_array_init(), reverb_t::initializedWithZeroDepth, reverb_t::input_fifo, and reverb_set_simple_params().

Referenced by ReverbBase::Instance::RealtimeProcess(), and reverb_create().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reverb_process()

static void reverb_process	(	reverb_t *	p,
		size_t	length
	)

static

Definition at line 491 of file Reverb_libSoX.h.

{
   filter_array_process(p->chan, length, (float *) fifo_read_ptr(&p->input_fifo), p->out[0], &p->feedback, &p->hf_damping, &p->gain);
 
   if (!p->initializedWithZeroDepth)
      filter_array_process(p->chan + 1, length, (float*)fifo_read_ptr(&p->input_fifo), p->out[1], &p->feedback, &p->hf_damping, &p->gain);
 
   fifo_read(&p->input_fifo, length, NULL);
}

References reverb_t::chan, reverb_t::feedback, fifo_read(), fifo_read_ptr, filter_array_process(), reverb_t::gain, reverb_t::hf_damping, reverb_t::initializedWithZeroDepth, reverb_t::input_fifo, and reverb_t::out.

Referenced by ReverbBase::Instance::InstanceProcess().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reverb_set_simple_params()

static void reverb_set_simple_params	(	reverb_t *	p,
		double	sample_rate_Hz,
		double	wet_gain_dB,
		double	reverberance,
		double	hf_damping,
		double	tone_low,
		double	tone_high
	)

static

Definition at line 411 of file Reverb_libSoX.h.

{
   // Feedback, Damping, Gain
   double a = -1 / log(1 - .3 );           /* Set minimum feedback */
   double b = 100 / (log(1 - .98) * a + 1);  /* Set maximum feedback */
 
   p->feedback = 1 - exp((reverberance - b) / (a * b));
   p->hf_damping = hf_damping / 100 * .3 + .2;
   p->gain = dB_to_linear(wet_gain_dB) * .015;
 
 
   // LP-HP Filters
   double fc_highpass = midi_to_freq(72 - tone_low / 100 * 48);
   double fc_lowpass = midi_to_freq(72 + tone_high / 100 * 48);
   one_pole_init(&p->chan[0], sample_rate_Hz, fc_highpass, fc_lowpass);
   one_pole_init(&p->chan[1], sample_rate_Hz, fc_highpass, fc_lowpass);
}

References reverb_t::chan, dB_to_linear, reverb_t::feedback, reverb_t::gain, reverb_t::hf_damping, midi_to_freq, and one_pole_init().

Referenced by ReverbBase::Instance::RealtimeProcess(), and reverb_init().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ allpass_lengths

const size_t allpass_lengths[] = {225, 341, 441, 556}

static

Definition at line 152 of file Reverb_libSoX.h.

Referenced by filter_array_allocate(), filter_array_create(), filter_array_delete(), filter_array_init(), filter_array_process(), and reverb_clear().

◆ comb_lengths

const size_t comb_lengths[] = {1116, 1188, 1277, 1356, 1422, 1491, 1557, 1617}

static

Definition at line 151 of file Reverb_libSoX.h.

Referenced by filter_array_allocate(), filter_array_create(), filter_array_delete(), filter_array_init(), filter_array_process(), and reverb_clear().

◆ stereo_adjust

const size_t stereo_adjust = 12

static

Definition at line 152 of file Reverb_libSoX.h.

Referenced by filter_array_allocate(), filter_array_create(), and filter_array_init().

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ array_length

◆ dB_to_linear

◆ FIFO_MIN

◆ fifo_read_ptr

◆ FIFO_SIZE_T

◆ filter_advance

◆ filter_delete

◆ lsx_zalloc

◆ M_LN10

◆ midi_to_freq

Function Documentation

◆ allpass_process()

◆ comb_process()

◆ fifo_clear()

◆ fifo_clear_and_zero()

◆ fifo_create()

◆ fifo_delete()

◆ fifo_read()

◆ fifo_reserve()

◆ fifo_write()

◆ filter_array_allocate()

◆ filter_array_create()

◆ filter_array_delete()

◆ filter_array_init()

◆ filter_array_process()

◆ filter_t_resize()

◆ filter_t_resize_preserving()

◆ filter_t_resize_resetting()

◆ one_pole_init()

◆ one_pole_process()

◆ reverb_allocate()

◆ reverb_clear()

◆ reverb_create()

◆ reverb_delete()

◆ reverb_init()

◆ reverb_process()

◆ reverb_set_simple_params()

Variable Documentation

◆ allpass_lengths

◆ comb_lengths

◆ stereo_adjust