C++ 两个信号（DI和麦克风）的互相关

我想知道是否有人能给我一些建议，如何在我设置的两条简单延迟线内实现互相关函数。我的问题是，我有两条硬编码的延迟线，我可以手动更改以对齐两个进入的信号。我使用的是来自低音放大器的DI信号和麦克风信号。如果我在当前状态下使用此代码，它将延迟DI信号，但我希望它做的是，将两个信号在DSP内对齐，以便它以一个信号和另一个信号的相位输出它们。我当前的代码如下所示：

#include <Bela.h>
#define DELAY_BUFFER_SIZE 44100
// Buffer holding previous samples per channel
float gDelayBuffer_l[DELAY_BUFFER_SIZE] = {0};
float gDelayBuffer_r[DELAY_BUFFER_SIZE] = {0};
// Write pointer
int gDelayBufWritePtr = 0;
// Amount of delay
float gDelayAmount = 1;
// Amount of feedback
float gDelayFeedbackAmount = 0;
// Level of pre-delay input
float gDelayAmountPre = 1;
// Amount of delay in samples 
int gDelayInSamples = 22050;

// Buffer holding previous samples per channel
float hDelayBuffer_l[DELAY_BUFFER_SIZE] = {0};
float hDelayBuffer_r[DELAY_BUFFER_SIZE] = {0};
// Write pointer
int hDelayBufWritePtr = 0;
// Amount of delay
float hDelayAmount = 1;
// Amount of feedback
float hDelayFeedbackAmount = 0;
// Level of pre-delay input
float hDelayAmountPre = 1;
// Amount of delay in samples 
int hDelayInSamples = 44100;

bool setup(BelaContext *context, void *userData)
{

    return true;
}

void render(BelaContext *context, void *userData)
{

    for(unsigned int n = 0; n < context->analogFrames; n++) {

        float out_l = 0;
        float out_r = 0;

        // Read audio inputs
        out_l = analogRead(context,n,0);
        out_r = analogRead(context,n,1);

        // Increment delay buffer write pointer
        if(++gDelayBufWritePtr>DELAY_BUFFER_SIZE)
            gDelayBufWritePtr = 0;


               // Increment delay buffer write pointer

        // Calculate the sample that will be written into the delay buffer...
        // 1. Multiply the current (dry) sample by the pre-delay gain level (set above)
        // 2. Get the previously delayed sample from the buffer, multiply it by the feedback gain and add it to the current sample
        float del_input_l = (gDelayAmountPre * out_l + gDelayBuffer_l[(gDelayBufWritePtr-gDelayInSamples+DELAY_BUFFER_SIZE)%DELAY_BUFFER_SIZE] * gDelayFeedbackAmount);
        float del_input_r = (gDelayAmountPre * out_r + gDelayBuffer_r[(gDelayBufWritePtr-gDelayInSamples+DELAY_BUFFER_SIZE)%DELAY_BUFFER_SIZE] * gDelayFeedbackAmount);


        //  Now we can write it into the delay buffer
        gDelayBuffer_l[gDelayBufWritePtr] = del_input_l;
        gDelayBuffer_r[gDelayBufWritePtr] = del_input_r;



        // Get the delayed sample (by reading `gDelayInSamples` many samples behind our current write pointer) and add it to our output sample
        out_l = gDelayBuffer_l[(gDelayBufWritePtr-gDelayInSamples+DELAY_BUFFER_SIZE)%DELAY_BUFFER_SIZE] * gDelayAmount;
        out_r = gDelayBuffer_r[(gDelayBufWritePtr-gDelayInSamples+DELAY_BUFFER_SIZE)%DELAY_BUFFER_SIZE] * gDelayAmount;

       // Write the sample into the output buffer
        analogWrite(context, n, 0, out_l);
        analogWrite(context, n, 1, out_r);

    }
    for(unsigned int n = 0; n < context->analogFrames; n++) {

        float out_l = 0;
        float out_r = 0;

        // Read audio inputs
       out_l = analogRead(context,n,2);
        out_r = analogRead(context,n,3);
        // Increment delay buffer write pointer
        if(++hDelayBufWritePtr>DELAY_BUFFER_SIZE)
            hDelayBufWritePtr = 0;

               // Increment delay buffer write pointer
        if(++hDelayBufWritePtr>DELAY_BUFFER_SIZE)
            hDelayBufWritePtr = 0;

        // Calculate the sample that will be written into the delay buffer...
        // 1. Multiply the current (dry) sample by the pre-delay gain level (set above)
        // 2. Get the previously delayed sample from the buffer, multiply it by the feedback gain and add it to the current sample
        float del_input_l = (hDelayAmountPre * out_l + hDelayBuffer_l[(hDelayBufWritePtr-hDelayInSamples+DELAY_BUFFER_SIZE)%DELAY_BUFFER_SIZE] * hDelayFeedbackAmount);
        float del_input_r = (hDelayAmountPre * out_r + hDelayBuffer_r[(hDelayBufWritePtr-hDelayInSamples+DELAY_BUFFER_SIZE)%DELAY_BUFFER_SIZE] * hDelayFeedbackAmount);



        //  Now we can write it into the delay buffer
        hDelayBuffer_l[hDelayBufWritePtr] = del_input_l;
        hDelayBuffer_r[hDelayBufWritePtr] = del_input_r;

        // Get the delayed sample (by reading `gDelayInSamples` many samples behind our current write pointer) and add it to our output sample
        out_l = hDelayBuffer_l[(hDelayBufWritePtr-hDelayInSamples+DELAY_BUFFER_SIZE)%DELAY_BUFFER_SIZE] * hDelayAmount;
        out_r = hDelayBuffer_r[(hDelayBufWritePtr-hDelayInSamples+DELAY_BUFFER_SIZE)%DELAY_BUFFER_SIZE] * hDelayAmount;

        // Write the sample into the output buffer

        analogWrite(context, n, 2, out_l);
        analogWrite(context, n, 3, out_r);



}
}
void cleanup(BelaContext *context, void *userData)
{
}

#包括
#定义延迟缓冲区大小44100
//每个通道保存先前采样的缓冲区
float gDelayBuffer_l[延迟缓冲区大小]={0}；
float gDelayBuffer_r[延迟缓冲区大小]={0}；
//写指针
int-gDelayBufWritePtr=0；
//延迟量
float gDelayAmount=1；
//反馈的数量
浮动gDelayFeedbackAmount=0；
//预延迟输入电平
float gDelayAmountPre=1；
//样本延迟量
int gDelayInSamples=22050；
//每个通道保存先前采样的缓冲区
float hDelayBuffer_l[延迟缓冲区大小]={0}；
float hDelayBuffer_r[延迟缓冲区大小]={0}；
//写指针
int hDelayBufWritePtr=0；
//延迟量
浮点hDelayAmount=1；
//反馈的数量
浮动hDelayFeedbackAmount=0；
//预延迟输入电平
浮点hDelayAmountPre=1；
//样本延迟量
int hDelayInSamples=44100；
bool设置（BelaContext*上下文，void*用户数据）
{
返回true；
}
void呈现（上下文*上下文，void*用户数据）
{
对于（无符号整数n=0；nanalogFrames；n++）{
浮出=0；
浮出\u r=0；
//读取音频输入
out_l=模拟读取（上下文，n，0）；
out_r=模拟读取（上下文，n，1）；
//增量延迟缓冲区写入指针
if（++gDelayBufWritePtr>延迟缓冲区大小）
gDelayBufWritePtr=0；
//增量延迟缓冲区写入指针
//计算将写入延迟缓冲区的样本。。。
//1.将当前（干）样本乘以延迟前增益水平（如上所述）
//2.从缓冲器中获取先前延迟的样本，将其乘以反馈增益，并将其添加到当前样本中
float del_input_l=（gDelayAmountPre*out_l+gDelayBuffer_l[（gdelaybufferwriteptr gDelayInSamples+DELAY_BUFFER_SIZE）%DELAY_BUFFER_SIZE]*gDelayFeedbackAmount）；
float del_input_r=（gDelayAmountPre*out_r+gDelayBuffer_r[（gdelaybufferwriteptr gDelayInSamples+DELAY_BUFFER_SIZE）%DELAY_BUFFER_SIZE]*gDelayFeedbackAmount）；
//现在我们可以将其写入延迟缓冲区
gDelayBuffer_l[gDelayBufWritePtr]=del_input_l；
gDelayBuffer_r[gDelayBufWritePtr]=del_input_r；
//获取延迟样本（通过读取当前写入指针后面的`gDelayInSamples`多个样本），并将其添加到输出样本中
out_l=gDelayBuffer_l[（gdelaybufferwriteptr gDelayInSamples+DELAY_BUFFER_SIZE）%DELAY_BUFFER_SIZE]*gDelayAmount；
out_r=gDelayBuffer_r[（gdelaybufferwriteptr gDelayInSamples+DELAY_BUFFER_SIZE）%DELAY_BUFFER_SIZE]*gDelayAmount；
//将样本写入输出缓冲区
类比写入（上下文，n，0，out_l）；
类比写入（上下文，n，1，out\r）；
}
对于（无符号整数n=0；nanalogFrames；n++）{
浮出=0；
浮出\u r=0；
//读取音频输入
out_l=模拟读取（上下文，n，2）；
out_r=模拟读取（上下文，n，3）；
//增量延迟缓冲区写入指针
如果（++hDelayBufWritePtr>DELAY\u BUFFER\u SIZE）
hDelayBufWritePtr=0；
//增量延迟缓冲区写入指针
如果（++hDelayBufWritePtr>DELAY\u BUFFER\u SIZE）
hDelayBufWritePtr=0；
//计算将写入延迟缓冲区的样本。。。
//1.将当前（干）样本乘以延迟前增益水平（如上所述）
//2.从缓冲器中获取先前延迟的样本，将其乘以反馈增益，并将其添加到当前样本中
浮点del_input_l=（hDelayAmountPre*out_l+hDelayBuffer_l[（hdelaybufferwriteptr hDelayInSamples+DELAY_BUFFER_SIZE）%DELAY_BUFFER_SIZE]*hDelayFeedbackAmount）；
浮点del_input_r=（hDelayAmountPre*out_r+hDelayBuffer_r[（hdelaybufferwriteptr hDelayInSamples+DELAY_BUFFER_SIZE）%DELAY_BUFFER_SIZE]*hDelayFeedbackAmount）；
//现在我们可以将其写入延迟缓冲区
hDelayBuffer\u l[hDelayBufWritePtr]=del\u输入；
hDelayBuffer\u r[hDelayBufWritePtr]=del\u输入；
//获取延迟样本（通过读取当前写入指针后面的`gDelayInSamples`多个样本），并将其添加到输出样本中
out_l=hDelayBuffer_l[（hdelaybufferwriteptr hDelayInSamples+延迟缓冲大小）%DELAY缓冲大小]*hDelayAmount；
out_r=hDelayBuffer_r[（hdelaybufferwriteptr hDelayInSamples+DELAY_BUFFER_SIZE）%DELAY_BUFFER_SIZE]*hDelayAmount；
//将样本写入输出缓冲区
类比书写（上下文，n，2，out_l）；
类比写入（上下文，n，3，out\r）；
}
}
无效清除（上下文*上下文，无效*用户数据）
{
}

HI，欢迎来到StackOverflow。请您在问题中添加更具体的信息-当前结果、预期结果、您的确切问题是什么等。在当前状态下，此问题太广泛，可能很快就会结束。谢谢您的回复。我的问题是，我有两条硬编码的延迟线，我可以手动更改以对齐两个进入的信号。我使用的是来自低音放大器的DI信号和麦克风信号。如果我在当前状态下使用此代码，它将延迟DI信号，但我希望它做的是，将两个信号在DSP内对齐，以便它与一个和另一个信号同相输出。这会更好-如果您可以编辑原始问题以包含这些信息，因为在评论中查找关键问题是非常重要的