Question

我正在用c ++编写VST DSP插件。

我在'filterbank'中创建了一系列带通滤波器。我已在头文件（包括函数）中实现了一个过滤器类，并在.cpp中正确构建了构造函数/析构函数。

我可以将值传递给方法并返回它们。但是，问题在于将函数中的数据存储在缓冲区中。似乎每次调用函数方法时，存储在缓冲区中的值都会被重置（或者，首先不能正确存储）。因此，传回的内容并非“完整”。

非常感谢任何建议！

n.b。此帖子已使用新代码进行更新：

以下是课程：

class aFilterL

{

朋友班Beat_to_Midi;

公共： aFilterL（）; 〜aFilterL（）;

float fOut1_l;
float filterOut1_l;
float Out_1_l;
float Out_2_l;
float* buffer_Out_1_l;
float* buffer_Out_2_l;

虚拟浮动aFilterMethodL（浮动a0，浮动a1，浮动a2，浮动b1，浮动b2，浮动输入L，浮动prevInput1L，浮动prevInput2L） {

Out_1_l = buffer_Out_1_l[0];
Out_2_l = buffer_Out_2_l[0];

filterOut1_l = (a0 * inputL) + (a1 * prevInput1L) + (a2 * prevInput2L) - (b1 * Out_1_l) - (b2 * Out_2_l) + 1.0E-25;

fOut1_l = filterOut1_l;
buffer_Out_2_l[0] = buffer_Out_1_l[0];
buffer_Out_1_l[0] = fOut1_l;  
return fOut1_l;

}

};

类aFilterR {

朋友班Beat_to_Midi;

公共： aFilterR（）; 〜aFilterR（）;

float fOut1_r;
float filterOut1_r;
float Out_1_r;
float Out_2_r;
float* buffer_Out_1_r;
float* buffer_Out_2_r;

虚拟浮动aFilterMethodR（浮动a0，浮动a1，浮动a2，浮动b1，浮动b2，浮动输入R，浮动prevInput1R，浮动prevInput2R） {

Out_1_r = buffer_Out_1_r[0];
Out_2_r = buffer_Out_2_r[0];

filterOut1_r = (a0 * inputR) + (a1 * prevInput1R) + (a2 * prevInput2R) - (b1 * Out_1_r) - (b2 * Out_2_r) + 1.0E-25;

fOut1_r = filterOut1_r;
buffer_Out_2_r[0] = buffer_Out_1_r[0];
buffer_Out_1_r[0] = fOut1_r;
return fOut1_r;

} };

然后在cpp中构建/销毁它，如下所示：

aFilterL::aFilterL()

{ fOut1_l = 0.f; filterOut1_l = 0.f;

Out_1_l = 0.f;
Out_2_l = 0.f;

buffer_Out_1_l = new float [1];
buffer_Out_2_l = new float [1];

buffer_Out_1_l[0] = 0.f;
buffer_Out_2_l[0] = 0.f;

}

aFilterL ::〜aFilterL（） {

if (buffer_Out_1_l)
    delete[] buffer_Out_1_l;
if (buffer_Out_2_l)
    delete[] buffer_Out_2_l;

}

aFilterR :: aFilterR（） { fOut1_r = 0.f;

filterOut1_r = 0.f;

Out_1_r = 0.f;
Out_2_r = 0.f;

buffer_Out_1_r = new float [1];
buffer_Out_2_r = new float [1];

buffer_Out_1_r[0] = 0.f;
buffer_Out_2_r[0] = 0.f;

}

aFilterR ::〜aFilterR（） {

if (buffer_Out_1_r)
    delete[] buffer_Out_1_r;
if (buffer_Out_2_r)
    delete [] buffer_Out_2_r;

}

最后，它在processReplacing函数中实现为：

void myPlugin :: processReplacing（float ** inputs，float ** outputs，VstInt32 sampleFrames） {

float* in1  =  inputs[0]; 
float* in2  =  inputs[1]; 
float* out1 = outputs[0]; 
float* out2 = outputs[1]; 

    aFilterL *my_aFilter1L = new aFilterL;
aFilterR *my_aFilter1R = new aFilterR;

while（--sampleFrames＆gt; = 0） {

//过滤输入

In_1_l = buffer_In_1_l [0];

In_1_r = buffer_In_1_r [0];

In_2_l = buffer_In_2_l [0];

In_2_r = buffer_In_2_r [0];

//在管理中过滤

buffer_In_2_l [0] = buffer_In_1_l [0];

buffer_In_2_r [0] = buffer_In_1_r [0];

buffer_In_1_l [0] = * in1;

buffer_In_1_r [0] = * in2;

//发送到函数进行处理

returnedL = my_aFilter1L-＆gt; aFilterMethodL（0.000171f，0.0f，-0.000171f，-1.999911f，0.999943f，* in1，In_1_l，In_2_l）;

returnedR = my_aFilter1R-＆gt; aFilterMethodR（0.000171f，0.0f，-0.000171f，-1.999911f，0.999943f，* in2，In_1_r，In_2_r）;

//将过滤器输出发送到输出

* out1 = returnL;

* out2 = returnR;

* IN1 ++;

* IN2 ++;

* OUT1 ++;

* OUT2 ++; }}

Answer 1

您是否意识到return立即退出该功能的事实？因此，永远不会执行将值存储到缓冲区之后的代码。

相反，您应该将返回调用放在函数的末尾。

其他一些说明：

我不清楚为什么如果你只使用第一个元素，你需要指向缓冲区的指针。
-L和-R函数中有重复的代码。相反，使用“mono”类的两个实例，因此每个类只存储一个通道的数据。
您（几乎）永远不需要使用this->。把它留下来吧。

Answer 2

在找到here找到的嵌套类的新问题之后，找到了解决方案。

过滤器类在myPlugin类中声明。

从这里构造函数和析构函数构建为：

myPlugin::aFilterL::aFilterL()
myPlugin::aFilterL::~aFilterL()

在myPlugin构造函数中创建了新实例：

aFilterL *my_aFilter1L = new aFilterL();

然后拼图中的最后一部分是确保它们作为实例添加到myPlugin效果中：

aFilterL my_aFilter1L;
aFilterR my_aFilter1R;

my_aFilter1L等现在可以通过processReplacing访问，并且似乎正常运行。

非常感谢大家对此事的所有帮助。

在类函数方法中将值存储在缓冲区中

2 个答案: