A templated Chamberlin filter

A Chamberlin filter is a IIR (Infinite Impulse Response) filter, and it is possible to make it output high-, band- or low-pass signals. It has only two parameters that are independent.

The equations are very simple:

Each of the series is either the low-pass, the band-pass or the high-pass output.

There are some factors that are pre-computed:

The first is a function of the Cut frequency and the Sampling frequency, a “numerical frequency”. The second one is the numerical attenuation, between 0 and 2.

This is an excerpt of the actual code, I’ve only displayed the relevant code.

template<class Data_Type>
class VariableFilter
{
public:
  typedef Data_Type DataType;
 
  void process(const DataType* in, DataType* out, unsigned long nb_samples)
  {
    for(unsigned long i = 0; i < nb_samples; ++i)
    {
      yh = in[i] - yl - numerical_attenuation * yb;
      yb = numerical_frequency * yh + yb;
      yl = numerical_frequency * yb + yl;
      if(selected == 0)
      {
        out[i] = yl;
      }
      else if(selected == 1)
      {
        out[i] = yb;
      }
      else
      {
        out[i] = yh;
      }
    }
  } 
 
protected:
  void compute_factors()
  {
    numerical_frequency = 2 * std::sin(M_PI * cutoff_frequency / sampling_frequency);
    numerical_attenuation = 2 * attenuation;
  }
};

Now, I’ve written a simple GUI for this plugin.

GUI with Qt

I’ve used the QtAgain skeletton to wrap the filter and to make it available to PyVST. It’s really easy to add other parameters to the skeletton, so I will not write everything here again. There are three parameters, 2 numerical ones, and one three-state variable.

Results

I’ve recorded the filter’s outputs for 6kHz as central frequency, and an attenuation factor of .3. The output signal was generated from a random signal, and then an FFT was performed on the inputs and the outputs and displayed.

Note: I didn’t convert the scale to dB.

As you may have noted, the filter amplifies the signal near the central frequency for each output for the attenuation I’ve selected. The issue is that selecting a higher one has also an impact on the stability of the filter at higher frequencies. The sum of the numerical attenuation and the numerical frequency should always be inferior to 2.

Conclusion

This numerical is really simple to implement, and it has few parameters. The dark side of this filter is that is not always stable and the central frequency seems to be always amplified. Other filters can be better balanced.

The code is available on Launchpad.

Version 0.1 provides basic access to the VST interface, as well as a script to analyze and display the audio process of a plugin. It can be easy-installed or downloaded on its Launchpad page.

Changelog for 0.1:

• Uses the VST dispatcher for several functions:
  • processReplacing
  • processDoubleReplacing
  • open/close the plugin
  • open/close the GUI editor
  • returns the GUI rectangle
  • set the sample rate
  • set the block size
  • get name/vendor/product
  • handle programs
  • handle parameters
  • suspend/resume
• set/get a parameter
• get number of programs
• get number of inputs
• get number of outputs
• display.py script
  • can load any plugin
  • displays the editor, if it exists
  • uses a stereo sine-sweep
  • displays a spectrogram of the process of the stereo sine-sweep
  • dumps properties information

When developing pyvst, I has to implement the retrieval of the size of the plugin, and I’ve decided to add this to QtAGain. I was surprised to see that it actually work with just giving back the UI size (so fixing this was less than 5 lines).

So now, I know that to impelment an UI for a VST plugin, I have to implement:

• open()
• close()
• but also getRect()

Don’t make the same mistake as I did, do implement all three of them, even if your favorite VST host can live without getRect().

P.S.: Mixing Qt for VST UIs and wxPython for pyvst works really fine!

I’ve searched if someone has already used this new version to create a VST plugin. The only blog post I’ve found does not use the Qt Solution and is not perfect. According to the documentation what is missing in this solution is precisely what the Solution should do. So let’s try it.

So I’ve download the 2.4 VST SDK as well as Qt 4.5 and the WinMigrate Solution. As I’ll be using Qt with signals and slots, I used SCons to build my small plugin.

Designing the interface and testing it

The interface is really simple: a label with a name, the value of the gain and a slider. Here is what it looks like in Tracktion 3:

The slider takes values from 0 to 99, value that will be displayed in a label. This will be the gain factor in percentage.

Nothing fancy here with the class header:

class QVstPanel : public QWinWidget
{
  HWND h_parent;
  AudioEffectX *again;
 
  QLabel *valueLabel;
  QSlider *slider;
public:
  QVstPanel(AudioEffectX *again, HWND h_parent = NULL);
};

The panel is created with a link to the actual audio effect (needed in the future) and the parent HWND given by the host.

The actual code is even simplier:

QVstPanel::QVstPanel(AudioEffectX *again, HWND h_parent)
:QWinWidget(h_parent, NULL), again(again), h_parent(h_parent)
{
  setAttribute(Qt::WA_DeleteOnClose);
 
  QLabel *label = new QLabel("Gain", this);
  valueLabel = new QLabel("0", this);
  slider = new QSlider(Qt::Horizontal, this);
  QHBoxLayout *layout = new QHBoxLayout(this);
  layout->addWidget(label);
  layout->addWidget(valueLabel);
  layout->addWidget(slider);
  setLayout(layout);
}

Now this is the class that will be opened by the VST editor this way:

class QtAGain : public AEffEditor
{
  QWinWidget* widget;
  AudioEffectX* effect;
 
public:
  QtAGain(AudioEffectX* effect)
    :widget(NULL), effect(effect)
  {
  }
 
  ~QtAGain()
  {
  }
 
  bool open(void* ptr);
  void close();
};

bool QtAGain::open(void* ptr)
{
  AEffEditor::open (ptr);
  widget = new QVstPanel(effect, static_cast<HWND>(ptr));
  widget->move( 0, 0 );
  widget->adjustSize();
  widget->setMinimumSize(widget->size());
  widget->show();
 
  return true;
}
 
void QtAGain::close()
{
  delete widget;
}

Now, in AGain’s constructor, I can add my custom editor:

  QtAGain* again = new QtAGain(this);
  setEditor(again);

So there isn’t anything really fancy, it kind of works out of the box. Unfortunately, it doesn’t work as well as in T3 in every host. I cannot resize the window VSTHost gives to the open() method, even if I tested it with almost all solutions I’ve found on MSDN.

Adding interactivity

Now, I will eventually use the power of Qt. The QtAGain class will be a QObject, as will be the AGain effect. This way, I can connect signals from the GUI to the effect when a parameter is modified by the user, and vice-versa, the UI will be updated when the effect sees a parameter change (indicated by the host for instance).

So I add a connection inside the QVstPanel constructor to a new slot that will update the underlying effect:

connect(slider, SIGNAL(sliderMoved(int)), this, SLOT(update(int)));
 
void QVstPanel::update(int value)
{
  valueLabel->setText(QString::number(value));
  again->setParameter(0, value / 100.);
}

The trouble arises from the effect: what should I do if the effect gets a setParameter that didn’t come from the UI? If there is no UI, everything is fine though. So I will add a signal inside QtAgain, the editor, that will forward a signal emitted by AGain only if the UI is up.

void AGain::setParameter (VstInt32 index, float value)
{
  fGain = value;
  emit update(value);
}

So now, the signal that the UI will get is a float, so I can reuse the name update() for my slot:

void QVstPanel::update(float value)
{
  int intValue = value * 100;
  valueLabel->setText(QString::number(intValue));
  slider->setValue(intValue);  
}

Of course, you will have several parameters inside your VST plugin, I suggest you use the editor instance to the mapping between the effect and the different slots you may have inside your UI.

Conclusion

Although I couldn’t get it to work with VSTHost (the host widget is not resized), I think the QWinWidget is a good class to help developing Qt VST plugins. I may want to use this skeletton to test some digital effects with a cool UI.

If you have a solution to make VSTHost work, I’m all ears.

The code is available on Launchpad.

Changes

First, I had to widen two pot holes in the bass body. Indeed, the GB-74 balance and master volume pots are smaller than the EQ one, contrary to the STC where they all have the same size.

Then, I’ve copied the GB-74 bypass switch. When off, the output of the balance pot is the input of the master pot, without any amplification. On the on position, the usual path is kept, from the balance to the tone circuit and from the tone circuit to the volume pot.

Modified wiring diagram

I’ve also kept the Cort humbucker switch, which can either use one of the two micro lines or both in parallel.

On the original Cort wiring diagram, the bypass switch is located on the main volume pot, and the EQ switch is alone. With the STC, the EQ switch is located ont he volume pot. It is possible to change this, but it means unsoldering the switch and as the wires are thinner than the Cort ones, I didn’t do it.

Comments

I have some comments on my new tone circuit:

• The wires are thinner than the original tone circuit. Compared to the price of the STC-2, using correct, stronger wires would be expected.
• The STC is based on a similar design than the GB74 tone circuit but it is made with “real” components, not SOC. The sound color should be better.
• The EQ switch is awkward: to activate it, the main volume pot must be pulled, so the default position is without tone control.
• I think the global volume is lower than before. I will change the pickups in the future for stronger ones

I’m satisfied with my new bass electronics. It wasn’t complicated to install it, so even someone who did not have much experience with soldering may be able to install it inside one’s bass.