Kalman Filter Noise Reduction in Java not working

Question

I have been trying to create a Voice Communication program using Java. So far it has been great but I need a way to reduce the background noise, and after researching I found out that the Kalman Filter seems to be the best option for this task. I'm using the org.apache.commons.math3 library and after reading some papers I came up with a Class that should help me reduce the noise coming from the audio that is recorded from the microphone and transferred as byte arrays of dimension 1024 bytes. Right now using the filter the output audio is not what I was expecting, I can only hear a faint scratching noise when someone talks. I'm aware of my limits when it comes to matrix and vectors and right now I'm stuck. I would appreciate any kind of tips you can give me. I tired changing the values of the R matrix but it didn't seem to make any difference.

import org.apache.commons.math3.filter.DefaultMeasurementModel;
import org.apache.commons.math3.filter.DefaultProcessModel;
import org.apache.commons.math3.filter.KalmanFilter;
import org.apache.commons.math3.linear.Array2DRowRealMatrix;
import org.apache.commons.math3.linear.ArrayRealVector;
import org.apache.commons.math3.linear.RealMatrix;
import org.apache.commons.math3.linear.RealVector;

public class KalmanFilterNoiseReduction {


    private static final int STATE_DIMENSION = 2;
    private static final int MEASUREMENT_DIMENSION = 1024;

    private KalmanFilter kalmanFilter;

    public KalmanFilterNoiseReduction() {
        initializeKalmanFilter();
    }

    private void initializeKalmanFilter() {
        // State transition matrix A
        RealMatrix A = new Array2DRowRealMatrix(new double[][]{{1, 1}, {0, 1}});

        // Control input matrix B
        RealMatrix B = new Array2DRowRealMatrix(new double[][]{{0}, {0}});

        // Measurement matrix H
        RealMatrix H = new Array2DRowRealMatrix(new double[MEASUREMENT_DIMENSION][STATE_DIMENSION]);
        for (int i = 0; i < MEASUREMENT_DIMENSION; i++) {
            for (int j = 0; j < STATE_DIMENSION; j++) {
                H.setEntry(i, j, (i == j) ? 1.0 : 0.0);
            }
        }

        // Process noise covariance matrix Q
        RealMatrix Q = new Array2DRowRealMatrix(new double[][]{{1, 0}, {0, 1}});

        // Measurement noise covariance matrix R
        RealMatrix R = new Array2DRowRealMatrix(new double[MEASUREMENT_DIMENSION][MEASUREMENT_DIMENSION]);
        for (int i = 0; i < MEASUREMENT_DIMENSION; i++) {
            R.setEntry(i, i, 0.1); 
        }


        // Initial state estimate x
        RealVector initialStateEstimate = new ArrayRealVector(new double[]{0, 0});

        // Initial error covariance matrix P
        RealMatrix initialErrorCovariance = new Array2DRowRealMatrix(STATE_DIMENSION, STATE_DIMENSION);

        // Create Kalman Filter
        kalmanFilter = new KalmanFilter(
                new DefaultProcessModel(A, B, Q, initialStateEstimate, initialErrorCovariance),
                new DefaultMeasurementModel(H, R));
    }

    public byte[] filterAudio(byte[] audioData) {
        double[] input = convertByteArrayToDoubleArray(audioData);

        // Predict the next state
        kalmanFilter.predict();

        // Update the state based on the measurement
        kalmanFilter.correct(input);

        // Get the filtered output
        double[] output = kalmanFilter.getStateEstimation();

        // Convert the double array to a byte array
        byte[] filteredAudio = convertDoubleArrayToByteArray(output);

        return filteredAudio;
    }

    private double[] convertByteArrayToDoubleArray(byte[] byteArray) {
        double[] doubleArray = new double[byteArray.length];
        for (int i = 0; i < byteArray.length; i++) {
            doubleArray[i] = byteArray[i];
        }
        return doubleArray;
    }

    private byte[] convertDoubleArrayToByteArray(double[] doubleArray) {
        byte[] byteArray = new byte[doubleArray.length];
        for (int i = 0; i < doubleArray.length; i++) {
            byteArray[i] = (byte) doubleArray[i];
        }
        return byteArray;
    }
}

This is the part where I send the audio to my server to be broadcasted:

this.filter=new KalmanFilterNoiseReduction();

    private void captureAndSendAudio() {
        try {
            byte[] audioData = new byte[1024];
            targetDataLine.start();

            while (!Thread.currentThread().isInterrupted()) {
                int bytesRead = targetDataLine.read(audioData, 0, audioData.length);
                if (bytesRead > 0) {
                    if(vad.start(audioData)==false) {
                        byte[] filteredAudio = filter.filterAudio(audioData);
                        outputStream.write(filteredAudio, 0, filteredAudio.length);
                    }else {
                        Arrays.fill(audioData, (byte) 0);
                        outputStream.write(audioData, 0, bytesRead);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }