有一个信号采样率为61.44MHz的原始信号文件，该文件内容为IQ,IQ....IQ形式的时域数据，其中I、Q的大小均为2字节，完整的一组IQ即4字节，它们共表示一个频域数据点。请用C++实现一个Farrow滤波器模块，该模块可以根据不同的插值倍数把原始信号进行插值滤波为122.88MHz的信号

非常感谢您的问题。

以下是一个简单的 Farrow 滤波器模块的代码实现，该模块可以将采样率为61.44MHz的原始信号插值到122.88MHz。

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

#define FILENAME "raw_data.bin"
#define INT16_MAX_VALUE 32767

int main() {
    char* input_data = NULL;
    int input_data_size = 0;
    FILE* fp_input = fopen(FILENAME, "rb");
    if (fp_input == NULL) {
        printf("Error: Cannot open input file %s.\n", FILENAME);
        return 1;
    }

    fseek(fp_input, 0, SEEK_END);
    input_data_size = ftell(fp_input);
    fseek(fp_input, 0, SEEK_SET);

    input_data = (char*)malloc(sizeof(char) * input_data_size);
    if (input_data == NULL) {
        printf("Error: Cannot allocate memory for input data.\n");
        return 1;
    }

    fread(input_data, sizeof(char), input_data_size, fp_input);
    fclose(fp_input);

    printf("Read data from file %s, Size: %d bytes.\n", FILENAME, input_data_size);

    int n_interpolation = 2; // 插值倍数
    int n_group_points = n_interpolation + 1;
    int n_iq_points = input_data_size / 4;
    int n_i_points = n_iq_points * n_group_points;
    int n_q_points = n_iq_points * n_group_points;
    float* output_i = (float*)malloc(sizeof(float) * n_i_points);
    float* output_q = (float*)malloc(sizeof(float) * n_q_points);
    float* group_x = (float*)malloc(sizeof(float) * n_group_points);
    float* group_y = (float*)malloc(sizeof(float) * n_group_points);
    float* group_h = (float*)malloc(sizeof(float) * n_group_points);

    if (output_i == NULL || output_q == NULL || group_x == NULL || group_y == NULL || group_h == NULL) {
        printf("Error: Cannot allocate memory for output data.\n");
        return 1;
    }

    memset(output_i, 0, sizeof(float) * n_i_points);
    memset(output_q, 0, sizeof(float) * n_q_points);
    memset(group_x, 0, sizeof(float) * n_group_points);
    memset(group_y, 0, sizeof(float) * n_group_points);
    memset(group_h, 0, sizeof(float) * n_group_points);

    float k = (float)(n_interpolation + 1) / 2.0;
    float c = (float)n_interpolation / 2.0;
    int offset = 0;
    for (int i = 0; i < n_iq_points; i++) {
        group_x[0] = (float)(input_data[offset] + (input_data[offset + 1] << 8)) / (float)INT16_MAX_VALUE;
        group_x[1] = (float)(input_data[offset + 2] + (input_data[offset + 3] << 8)) / (float)INT16_MAX_VALUE;
        int output_offset = i * n_group_points;
        for (int j = 0; j < n_group_points; j++) {
            float n = k * (j - c) + i;
            if (n < 0 || n > n_iq_points - 1) {
                continue;
            }
            group_y[j] = (float)(input_data[(int)n * 4] + (input_data[(int)n * 4 + 1] << 8)) / (float)INT16_MAX_VALUE;
            group_h[j] = 1.0;
        }
        for (int j = 0; j < n_group_points; j++) {
            float p = 1.0;
            for (int k = 0; k < n_group_points; k++) {
                if (j == k) continue;
                p *= (group_x[j] - group_x[k]) / (group_x[j] - group_x[k]);
            }
            output_i[output_offset + j] = group_y[j] * p * group_h[j];
        }
        group_x[0] = (float)(input_data[offset + 2] + (input_data[offset + 3] << 8)) / (float)INT16_MAX_VALUE;
        group_x[1] = (float)(input_data[offset + 4] + (input_data[offset + 5] << 8)) / (float)INT16_MAX_VALUE;
        output_offset = i * n_group_points;
        for (int j = 0; j < n_group_points; j++) {
            float n = k * (j - c) + i;
            if (n < 0 || n > n_iq_points - 1) {
                continue;
            }
            group_y[j] = (float)(input_data[(int)n * 4 + 2] + (input_data[(int)n * 4 + 3] << 8)) / (float)INT16_MAX_VALUE;
            group_h[j] = 1.0;
        }
        for (int j = 0; j < n_group_points; j++) {
            float p = 1.0;
            for (int k = 0; k < n_group_points; k++) {
                if (j == k) continue;
                p *= (group_x[j] - group_x[k]) / (group_x[j] - group_x[k]);
            }
            output_q[output_offset + j] = group_y[j] * p * group_h[j];
        }
        offset += 4;
    }

    free(group_x);
    free(group_y);
    free(group_h);

    FILE* fp_output = fopen("interpolated_data.bin", "wb");
    if (fp_output == NULL) {
        printf("Error: Cannot open output file interpolated_data.bin.\n");
        return 1;
    }

    fwrite(output_i, sizeof(float), n_i_points, fp_output);
    fwrite(output_q, sizeof(float), n_q_points, fp_output);
    fclose(fp_output);

    printf("Interpolated data saved to file interpolated_data.bin.\n");

    free(input_data);
    free(output_i);
    free(output_q);

    return 0;
}

我希望这可以回答您的问题。如果您有任何其他问题，欢迎再次联系。