как создать простой фильтр нижних частот iir с некруглыми ошибками? (16-битные данные PCM)

Предполагая, что результат функции filter_freq может быть записан в виде дроби m/n, ваш расчет фильтра в основном

y_new = y_old + (m/n) * (x - y_old);

который может быть преобразован в

y_new = ((n * y_old) + m * (x - y_old)) / n;

Целочисленное деление / n усекает результат до 0. Если вам нужно округление вместо усечения, вы можете реализовать его как

y_tmp = ((n * y_old) + m * (x - y_old));
if(y_tmp < 0) y_tmp -= (n / 2);
else y_tmp += (n / 2);
y_new = y_tmp / n

Чтобы избежать потери точности при делении результата на n в одном шаге и умножении его на n в следующем шаге, вы можете сохранить значение y_tmp перед делением и использовать его в следующем цикле.

y_tmp = (y_tmp + m * (x - y_old));
if(y_tmp < 0) y_new = y_tmp - (n / 2);
else y_new = y_tmp + (n / 2);
y_new /= n;

Если ваши входные данные int16_t, я предлагаю реализовать расчет с использованием int32_t, чтобы избежать переполнения.

Я попытался преобразовать фильтр в ваш код, не проверяя другие части на наличие возможных проблем.

    INT32  left_id  = 0;
    INT32  right_id = 1;
    int32_t filtered_l_out = 0; // output value after division
    int32_t filtered_r_out = 0;
    int32_t  filtered_l_tmp = 0; // used to keep the output value before division
    int32_t  filtered_r_tmp = 0;  
    int32_t  l_in = 0; // input value
    int32_t  r_in = 0; 

    DOUBLE  low_filter  =  filter_freq(core->audio->low_pass_cut);
    // define denominator and calculate numerator
    // use power of 2 to allow bit-shift instead of division
    const uint32_t filter_shift = 16U;
    const int32_t filter_n = 1U << filter_shift;
    int32_t filter_m = (int32_t)(low_filter * filter_n)

    for(UINT32 a = 0; a < (buffer_size/2);++a)  
    {    
  
        l_in = input_buffer[left_id]);
        r_in = input_buffer[right_id];

        ///////////////LOW PASS
        filtered_l_tmp = filtered_l_tmp + filter_m * (l_in - filtered_l_out);
        if(last_filtered_left < 0) {
            filtered_l_out = last_filtered_left - filter_n/2;
        } else {
            filtered_l_out = last_filtered_left + filter_n/2;
        }
        //filtered_l_out /= filter_n;
        filtered_l_out >>= filter_shift;

        /* same calculation for right */
  
        INT16 l = (INT16)(filtered_l_out);
        INT16 r = (INT16)(filtered_r_out);

        output_buffer[left_id]  =  (output_buffer[left_id]  + l);
        output_buffer[right_id] =  (output_buffer[right_id] + r);     

        left_id +=2;
        right_id +=2;
    }

Поскольку ваш фильтр инициализирован 0, может потребоваться несколько выборок, чтобы выполнить возможный шаг до первого входного значения. В зависимости от ваших данных может быть лучше инициализировать фильтр на основе первого входного значения.