c - 如何将音频事件前后 50 毫秒存储在循环缓冲区中？

Question

我正在处理 17 小时音频 .wav(16 位 PCM，192khz)的数据集，以模拟将嵌入 ESP32、Arduino DUE 或 RASP 中的“实时”处理，具体取决于结果。

我现在该如何处理？

首先，我用 C 语言创建了一个程序，将该文件转换为 .CSV(跳过 .wav 的整个头部并仅获取日期字段)，然后将 17 小时的文件剪切为 1 分钟的样本。

PS:我选择 CSV 是为了更好地处理数据，以便在 Scilab 中执行测试来验证算法。

使用生成的 .CSV 文件，我在第二个程序中运行它，该程序打开该文件并用 130ms(24900 个值)填充循环缓冲区，当缓冲区已满时，代码开始计算 RMS(均方根) ) 在 10ms 重叠的移动窗口中，窗口大小为 30ms 。当我得到的值大于 1000 时，它被视为一个事件。

下面您可以看到问题的说明:

这里显示了事件前后 50 毫秒的窗口，我的意思是:

PS:Inicio、Fim 和 Janela 分别表示开始、结束、窗口。

我的问题是:

由于事件可能发生在缓冲区中的任何位置，因此我应该如何保存事件前后的这 50 毫秒？如果事件持续超过一个窗口我该怎么办？

一些有助于理解的数据:

130ms = 24900 values ​​from my .csv file
50ms = 9600   values
30ms = 5700   values
10ms = 1920   values

我搜索了多个来源，但大多数 DSP 引用书目和数据结构对这些主题的处理都很肤浅，只是说明什么是循环缓冲区，而不是如何以有用的方式处理它。

这是我的代码草图，它似乎对问题采取了错误的方法，但我真的不知道如何继续，在这种情况下，我创建了一个从 1 到 100 的数据集以方便调试:

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<math.h>

    // Define the size of window 50ms
    #define window_size 3 // 30ms
    #define buffer_size 13 // 130ms = 50ms + 30ms + 50ms

    int main()
    {
        //define variables.
        int buffer[buffer_size]={0}; // create the buffer with 150ms;
        int write = 0;
        int i = 0, j = 0;
        int read = 0;
        int read1 =0;
        int write1 = 0;
        int counter_elements = 0;
        int number_lines = 0;
        int save_line = 0;
        char c;
        char str[1024];     // array to hold characters in a conversion of char to int.
        int inicio = 0, fim = 0;
        //RMS
        int soma_quadrado = 0;
        int rms = 0;
        int pre_amostragem[5] = {0};

        //Define variaveis referentes a leitura do arquivo e manipulacoes do mesmo.
        FILE * fp;
        FILE * LOG;
        FILE * log_rms_final;

        // Open the file and verify is NULL.
        if((fp = fopen("generator.txt","r")) == NULL)
        { // Define o nome do csv para abrir
            printf("Error! Can't open the file.\n");
            exit(1);
        }
        // store rms values
         LOG = fopen("RMSValues.csv", "a");
        // store the 50ms after and before a event.
        log_rms_final = fopen("Log_RMS.csv","a");

        int lines = 0;
        while(!feof(fp))
        {
            fgets(str,1024,fp); //reads 1024 characters and store in str.
            buffer[write] = atoi(str);
            write = (write + 1) % buffer_size; // circular
            counter_elements++; // sum 

        c = fgetc(fp);
        if(c == '\n')
        {
            lines++;
        }
        printf("%d\n", lines);
            //if buffer is full
            if(counter_elements == buffer_size)
            {
                // window
                read1 = read; 
                for(i = 0; i < window_size; i++)
                {
                    //square and sum.
                    soma_quadrado += buffer[read1]*buffer[read1];
                    read1 = (read1 + 1) % buffer_size;
                }

                // RMS 
                rms = sqrt(soma_quadrado/window_size);

                fprintf(LOG, "\n %d", rms); // store

                if(rms > 1000)
                {
                    printf("rms: %d\n",rms);

                    // store the 50ms befor a event and the window.
                    write1 = write;
                    for(j = 0 ; j < 5; j++)
                    {

                        write1 = (write1 + (buffer_size - 1)) % buffer_size;
                        pre_amostragem[j] = buffer[write1];
                    }

                    fprintf(log_rms_final,"%s","\n");

                    for(j = 4; j >= 0; j--)
                    {
                        fprintf(log_rms_final,"%d - pre \n",pre_amostragem[j]);
                    }

                    fprintf(log_rms_final,"%s","\n");
    /*
                    for(j = 0; j < window_size; j++)
                    {

                        fprintf(log_rms_final,"%d - janela\n",buffer[read1]);
                        read1 = (read1 + 1) % buffer_size;
                    }
    */
                    fprintf(log_rms_final,"%s","\n");

                    //store the 50ms after a event.

                    /*
                    fseek(log_rms_final,save_line - 3,save_line);

                    for(j = 0; j < 5; j++){

                        fgets(str,1024,fp);
                        fprintf(log_rms_final,"%d - pós \n",atoi(str));

                    }
                    */
                }

                soma_quadrado = 0;
                rms = 0;


                read = (read + 1) % buffer_size;
                counter_elements = counter_elements - 2;

            }
            soma_quadrado = 0;
            rms = 0;

        }

    fclose(fp);
    fclose(LOG);
    fclose(log_rms_final);
    return 0;
    }

一些评论是葡萄牙语，但与理解问题无关。

Answer 1

我在这里为您提供解决方案的算法。

1. 始终在循环缓冲区中记录 50 毫秒(甚至 60 毫秒)的数据。
2. 如果您检测到启动事件，
   • 将前 50 毫秒从循环缓冲区复制到最终缓冲区
   • 继续将接收到的数据写入最终缓冲区的 50ms 位置。
3. 如果您检测到结束事件。
   • 继续写入最终缓冲区 50 毫秒。
   • 再次开始写入循环缓冲区。
4. 如果您有多个事件，则需要有多个最终缓冲区并且可以重复该过程。

正如下面评论中提到的，该解决方案也适用于窗口大小 > 50 毫秒。您需要相应地选择最终缓冲区的大小。