Issues when attempting to resample 32Khz sample to 22.05khz

[Ewan-Stacey-BTO-IS]

I am trying to use the Resample class to resample audio data in a double array to 22.05Khz, the resampling code seems to work on 32khz files that are under two minutes long but seemingly fails on all other 32khz files but seems to work fine with 44.1kHz, 48kHz and 84kHz files of any size, here is the stack trace:
Exception stacktrace:
-647115
com.github.psambit9791.jdsp.signal.Resample$_UpFIRDown.apply_filter(Resample.java:372)
com.github.psambit9791.jdsp.signal.Resample$_UpFIRDown.access$100(Resample.java:312)
com.github.psambit9791.jdsp.signal.Resample.resample_poly(Resample.java:282)
com.github.psambit9791.jdsp.signal.Resample.resampleSignal(Resample.java:301)
org.bto.acousticpipeline.services.WavFileImporter.importWavToFloatArray(WavFileImporter.java:138)

The code from my program:

if (originalFormat.getSampleRate() != desiredSampleRate) {
                Resample resampler = new Resample(desiredSampleRate.intValue(), (int) originalFormat.getSampleRate(), "constant");
                double[] preResamplingArray = convertFloatArrayToDouble(trimmedValues);
                ArrayList<double[]> splitResampledArrays = new ArrayList<>();
                int outerArraySize = (int) Math.ceil((double) preResamplingArray.length / (double) MAX_ARRAY_RESAMPLE_SIZE);
                for (int x = 0; x < outerArraySize; x++) {
                    int endOfRange;
                    if (x == (outerArraySize - 1)) {
                        endOfRange = preResamplingArray.length;
                    } else {
                        endOfRange = ((x + 1) * MAX_ARRAY_RESAMPLE_SIZE);
                    }
                    double[] splitArray = Arrays.copyOfRange(preResamplingArray, x * MAX_ARRAY_RESAMPLE_SIZE, endOfRange);
                    double[] resampledDoubleArray = resampler.resampleSignal(splitArray); //error occurs here
                    splitResampledArrays.add(resampledDoubleArray);
                }
                double[] recombinedDoubleArray = recombineDoubleArray(splitResampledArrays);
                resampledValues = convertDoubleArrayToFloat(recombinedDoubleArray);
            } else {
                resampledValues = trimmedValues;
            }

for reference:
MAX_ARRAY_RESAMPLE_SIZE = 10000000 This is an arbitrary size, it's just that running whole files through the resampling process seems break the resampler so I break them into smaller arrays
trimmedValues is a float array that contains samples

Relevant methods

public static double[] convertFloatArrayToDouble (float[] floatArray) {
        double[] doubleArray = new double[floatArray.length];
        
        int index = 0;
        
        for(float floatValue : floatArray) {
            doubleArray[index] = (double) floatValue;
            index++;
        }
        
        return doubleArray;
    }

The error occurs on resampler.resampleSignal(splitArray); so anything afterwards shouldn't effect it

We are specifically using this library because of the anti-aliasing unlike the default java resampling when using AudioInputStream

We know about the decimate function but since we are trying to convert to 22.05khz we do not think it will work for our purposes, additionally we sometime would need to up sample

I'm not really familiar with the mathematics of resampling, so I'm not really sure what could be going wrong

[psambit9791]

1. The usage of Resample is incorrect here. The utility reflects the method used in scipy.resample_poly.
   The first two parameters in the function invocation Resample resampler = new Resample(desiredSampleRate.intValue(), (int) originalFormat.getSampleRate(), "constant") should not be the target frequency and source frequency - instead they need to be the upscaling and downscaling ratio as integers. These can be computed using the GCD between the target and source frequencies.
   Please refer to the hyperlink for how it works in scipy and please use the documentation for Resample in case you want details on the parameters to be used.

2. Can you please share a sample file I can use to recreate the issue? This file needs to be the subsample (the smaller array from the original data) which I can read using the WAV class.

[Ewan-Stacey-BTO-IS]

I cannot as WAV files are not allowed to be uploaded by Github on the discussion threads

I could upload the file in a public repo and then send it to you that way I guess?

[psambit9791]

You can zip the file and upload it here itself. If that doesn't work, you can send it to me at [email protected]

[Ewan-Stacey-BTO-IS]

Oh sorry
audio_file.zip
There we go

[Ewan-Stacey-BTO-IS]

Hey Sorry to bother you, we went back to using the polyphase resample since the mono-phase takes a very long time to convert even quite small files which does admittedly make a lot of sense. I have implemented the changes you suggested (see first response), however it still does not seem to accept 32khz files and was wondering if you have been able to find anything wrong with the library, though I would be more than willing to suspect it was a failure on my end causing the issue.

Thanks

Ewan Stacey BTO

[psambit9791]

Hey,

Sorry I have not had a chance to look into this yet. I'll get to it as soon as I can.

[psambit9791]

Hi @Ewan-Stacey-BTO-IS ,

I have used the file that you had shared and Polyphase Resampling is working as expected.

Sharing the properties here:

Source Signal Properties: 
Sample Rate: 32000
Channels: 1
Number of Points: 128000

Desired Signal Properties: 
Sample Rate: 22050
Channels: 1
Number of Points: 88200

Which if you calculate: (22050/32000) * 128000 is 88200

Also attaching the data (input and output) as a ZIP file here.
data.zip

Finally, the sample code I used is here:

package org.example;

import com.github.psambit9791.jdsp.io.WAV;
import com.github.psambit9791.jdsp.misc.UtilMethods;
import com.github.psambit9791.jdsp.signal.Resample;
import com.github.psambit9791.wavfile.WavFileException;
import org.apache.commons.math3.util.ArithmeticUtils;

import java.io.IOException;
import java.util.Hashtable;

public class Main {
    public static void printProps(Hashtable h1, double[] signal, String signalType) {
        System.out.println(signalType + " Properties: ");
        System.out.println("Sample Rate: " + h1.get("SampleRate"));
        System.out.println("Channels: " + h1.get("Channels"));
        System.out.println("Number of Points: " + signal.length);
        System.out.println("\n\n");
    }

    public static void main(String[] args) throws IOException, WavFileException {

        // Reading the Source Audio File and getting the properties
        WAV objReadSource = new WAV();
        objReadSource.readWAV("data/audio_32000.wav");
        double[][] signal = objReadSource.getData("int");
        double[] signalFlat = UtilMethods.flattenMatrix(signal);
        Hashtable<String, Long> propsOut = objReadSource.getProperties();
        printProps(propsOut, signalFlat, "Source Signal");

        // This is where the key operation happens
        long desiredSampleRate = 22050;
        long sourceSampleRate = propsOut.get("SampleRate");
        long maxFrequency = ArithmeticUtils.lcm(sourceSampleRate, desiredSampleRate);
        int upScaler = (int)(maxFrequency/sourceSampleRate);
        int downScaler = (int)(maxFrequency/desiredSampleRate);

        Resample pr = new Resample(upScaler, downScaler, "constant");
        double[] newSignalFlat = pr.resampleSignal(signalFlat);
        double[][] newSignal = new double[newSignalFlat.length][1];
        for (int i=0; i<newSignalFlat.length; i++) {
            newSignal[i][0] = newSignalFlat[i];
        }

        // Writing the resampled signal into a new WAV file
        WAV objWrite = new WAV();
        String outputFilename = "data/audio_22050.wav";
        objWrite.putData(newSignal, (long)desiredSampleRate, "int", outputFilename);

        // Reading the new WAV file and getting its properties for comparison
        WAV objReadDesired = new WAV();
        objReadDesired.readWAV("data/audio_22050.wav");
        double[][] signalDesired = objReadDesired.getData("int");
        double[] signalDesiredFlat = UtilMethods.flattenMatrix(signalDesired);
        Hashtable<String, Long> propsOutDesired = objReadDesired.getProperties();
        printProps(propsOutDesired, signalDesiredFlat, "Desired Signal");
    }
}

I have also run the same code on a WAV file with a duration of 02:48 (which is where the key issue had been encountered according to your first post) and that has worked fine as well. Sharing the input and output files for your reference as a zip attachment.
two_minutes_plus_test.zip

Can you please check this out and let me know if you are still encountering the issue?
And if this works, please highlight what had caused the issue for posterity and please mark this as the answer.

[Ewan-Stacey-BTO-IS]

Hey, after some testing this does seem to work though you will need to split up larger files since this only seems to work for smaller files.

1. From what I can tell the issue was being caused by the number of samples being entered into the resampler, causing issues specifically when asked to resample 8800000 samples at 32khz I don't have any idea why since it could do 10000000 samples from 32khz to 22.05khz and I haven't been able to test if any other sample sizes fail
2. I implemented a new system using your solution which goes by the sample rate instead which looks like this

long desiredSampleRateLong = desiredSampleRate.longValue();
long sourceSampleRate = (long) originalFormat.getSampleRate();
long maxFrequency = ArithmeticUtils.lcm(sourceSampleRate, desiredSampleRateLong);
int upScaler = (int)(maxFrequency/sourceSampleRate);
int downScaler = (int)(maxFrequency/desiredSampleRateLong);
                
Resample resampler = new Resample(upScaler, downScaler, "constant");
double[] preResamplingArray = convertFloatArrayToDouble(trimmedValues);
trimmedValues = new float[0];
int maxArrayResampleSize = (int)sourceSampleRate * 4;
ArrayList<double[]> splitResampledArrays = new ArrayList<>();
int outerArraySize = (int) Math.ceil((double) preResamplingArray.length / (double) maxArrayResampleSize);

for (int x = 0; x < outerArraySize; x++) {
    int endOfRange;
                    
     if (x == (outerArraySize - 1)) {
         endOfRange = preResamplingArray.length;
      } else {
          endOfRange = ((x + 1) * maxArrayResampleSize);
      }

    double[] splitArray = Arrays.copyOfRange(preResamplingArray, x * maxArrayResampleSize, endOfRange);
    double[] resampledDoubleArray = resampler.resampleSignal(splitArray);
    splitResampledArrays.add(resampledDoubleArray);
}
                
double[] recombinedDoubleArray = recombineDoubleArray(splitResampledArrays);
resampledValues = convertDoubleArrayToFloat(recombinedDoubleArray);