AudioResampler fixes for more than one channel

Author: devopvoid

webrtc-jni/src/main/cpp/include/JNI_AudioResampler.h

@@ -16,20 +16,16 @@
 
 #include "JNI_AudioResampler.h"
 #include "Exception.h"
-#include "JavaArrayList.h"
-#include "JavaEnums.h"
-#include "JavaError.h"
 #include "JavaObject.h"
 #include "JavaRef.h"
-#include "JavaString.h"
 #include "JavaUtils.h"
 
-#include "common_audio/resampler/push_sinc_resampler.h"
+#include "common_audio/resampler/include/push_resampler.h"
 
 JNIEXPORT void JNICALL Java_dev_onvoid_webrtc_media_audio_AudioResampler_dispose
 (JNIEnv * env, jobject caller)
 {
-	webrtc::PushSincResampler * resampler = GetHandle<webrtc::PushSincResampler>(env, caller);
+	webrtc::PushResampler<int16_t> * resampler = GetHandle<webrtc::PushResampler<int16_t>>(env, caller);
 	CHECK_HANDLE(resampler);
 
 	delete resampler;
@@ -38,17 +34,26 @@ JNIEXPORT void JNICALL Java_dev_onvoid_webrtc_media_audio_AudioResampler_dispose
 }
 
 JNIEXPORT void JNICALL Java_dev_onvoid_webrtc_media_audio_AudioResampler_initialize
-(JNIEnv * env, jobject caller, jint sourceFrames, jint targetFrames)
+(JNIEnv * env, jobject caller)
 {
-	webrtc::PushSincResampler * resampler = new webrtc::PushSincResampler(sourceFrames, targetFrames);
+	webrtc::PushResampler<int16_t> * resampler = new webrtc::PushResampler<int16_t>();
 
 	SetHandle(env, caller, resampler);
 }
 
+JNIEXPORT void JNICALL Java_dev_onvoid_webrtc_media_audio_AudioResampler_resetInternal
+(JNIEnv* env, jobject caller, jint sourceRate, jint targetRate, jint channels)
+{
+	webrtc::PushResampler<int16_t> * resampler = GetHandle<webrtc::PushResampler<int16_t>>(env, caller);
+	CHECK_HANDLE(resampler);
+
+	resampler->InitializeIfNeeded(sourceRate, targetRate, channels);
+}
+
 JNIEXPORT jint JNICALL Java_dev_onvoid_webrtc_media_audio_AudioResampler_resampleInternal
 (JNIEnv * env, jobject caller, jbyteArray samplesIn, jint nSamplesIn, jbyteArray samplesOut, jint maxSamplesOut)
 {
-	webrtc::PushSincResampler * resampler = GetHandle<webrtc::PushSincResampler>(env, caller);
+	webrtc::PushResampler<int16_t> * resampler = GetHandle<webrtc::PushResampler<int16_t>>(env, caller);
 	CHECK_HANDLEV(resampler, -1);
 
 	jboolean isDstCopy = JNI_FALSE;

webrtc-jni/src/main/cpp/src/JNI_AudioResampler.cpp

@@ -22,30 +22,55 @@
 
 /**
  * Audio sampling rate converter. This resampler operates on audio frames of 10
- * milliseconds.
+ * milliseconds. Each sample is assumed to be a 16-bit PCM sample.
  *
  * @author Alex Andres
  */
 public class AudioResampler extends DisposableNativeObject {
 
-	private final int sourceFrames;
+	private int targetFrames;
 
-	private final int targetFrames;
+	private boolean initialized;
 
 
+	/**
+	 * Creates a new {@code AudioResampler} without sampling parameters. Make
+	 * sure to call {@link #reset(int, int, int)} afterwards.
+	 */
+	public AudioResampler() {
+		initialize();
+	}
+
 	/**
 	 * Creates a new {@code AudioResampler} with specified sampling frequency
 	 * parameters.
 	 *
 	 * @param sourceSampleRate The sampling frequency of the input signal.
 	 * @param targetSampleRate The sampling frequency of the output signal.
+	 * @param channels         The number of audio channels to resample.
+	 */
+	public AudioResampler(int sourceSampleRate, int targetSampleRate, int channels) {
+		initialize();
+		reset(sourceSampleRate, targetSampleRate, channels);
+	}
+
+	/**
+	 * Must be called when created with default constructor or whenever the
+	 * sampling parameters change. Can be called at any time as it is a no-op if
+	 * parameters have not changed since the last call.
+	 *
+	 * @param sourceSampleRate The sampling frequency of the input signal.
+	 * @param targetSampleRate The sampling frequency of the output signal.
+	 * @param channels         The number of audio channels to resample.
 	 */
-	public AudioResampler(int sourceSampleRate, int targetSampleRate) {
-		// 10 ms frames
-		sourceFrames = sourceSampleRate / 100;
-		targetFrames = targetSampleRate / 100;
+	public void reset(int sourceSampleRate, int targetSampleRate, int channels) {
+		initialized = false;
+
+		resetInternal(sourceSampleRate, targetSampleRate, channels);
 
-		initialize(sourceFrames, targetFrames);
+		targetFrames = targetSampleRate / 100 * channels; // 10 ms frame
+
+		initialized = true;
 	}
 
 	/**
@@ -65,7 +90,11 @@ public int resample(byte[] samplesIn, int nSamplesIn, byte[] samplesOut) {
 		requireNonNull(samplesIn);
 		requireNonNull(samplesOut);
 
-		final int arraySamplesIn = samplesIn.length / 2;
+		if (!initialized) {
+			throw new IllegalStateException("Not initialized: Use reset() to set parameters");
+		}
+
+		final int arraySamplesIn = samplesIn.length / 2; // 16-bit PCM sample
 		final int maxSamplesOut = samplesOut.length / 2;
 
 		nSamplesIn = Math.min(arraySamplesIn, Math.max(0, nSamplesIn));
@@ -80,7 +109,10 @@ public int resample(byte[] samplesIn, int nSamplesIn, byte[] samplesOut) {
 	@Override
 	public native void dispose();
 
-	private native void initialize(int sourceFrames, int targetFrames);
+	private native void initialize();
+
+	private native void resetInternal(int sourceSampleRate, int targetSampleRate,
+			int channels);
 
 	private native int resampleInternal(byte[] samplesIn, int nSamplesIn,
 			byte[] samplesOut, int maxSamplesOut);

webrtc/src/main/java/dev/onvoid/webrtc/media/audio/AudioResampler.java

@@ -22,35 +22,63 @@
 import dev.onvoid.webrtc.TestBase;
 
 import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 class AudioResamplerTest extends TestBase {
 
 	private AudioResampler resampler;
 
 
+	@BeforeEach
+	void init() {
+		resampler = new AudioResampler();
+	}
+
 	@AfterEach
 	void dispose() {
 		resampler.dispose();
 	}
 
 	@Test
-	void targetBufferUnderflow() {
-		resampler = new AudioResampler(48000, 24000);
+	void notInitialized() {
+		SampleBuffer buffer = new SampleBuffer(48000, 24000, 1);
+
+		assertThrows(IllegalStateException.class, () -> {
+			resampler.resample(buffer.src, buffer.nSamplesIn, buffer.dst);
+		});
+	}
 
-		SampleBuffer buffer = new SampleBuffer(48000, 24000);
+	@Test
+	void targetBufferUnderflow() {
+		SampleBuffer buffer = new SampleBuffer(48000, 24000, 1);
 		buffer.setTargetBufferSize(buffer.frameSizeOut / 2);
 
+		reset(resampler, buffer);
+
 		assertThrows(IllegalArgumentException.class, () -> {
 			resample(resampler, buffer);
 		});
 	}
 
+	@Test
+	void constructorParameters() {
+		SampleBuffer buffer = new SampleBuffer(48000, 44100, 2);
+
+		AudioResampler resampler = new AudioResampler(48000, 44100, 2);
+
+		int result = resample(resampler, buffer);
+
+		resampler.dispose();
+
+		assertEquals(buffer.nSamplesOut, result);
+	}
+
 	@Test
 	void downSample() {
-		resampler = new AudioResampler(48000, 44100);
+		SampleBuffer buffer = new SampleBuffer(48000, 44100, 1);
 
-		SampleBuffer buffer = new SampleBuffer(48000, 44100);
+		reset(resampler, buffer);
 
 		int result = resample(resampler, buffer);
 
@@ -59,15 +87,19 @@ void downSample() {
 
 	@Test
 	void upSample() {
-		resampler = new AudioResampler(32000, 48000);
+		SampleBuffer buffer = new SampleBuffer(32000, 48000, 1);
 
-		SampleBuffer buffer = new SampleBuffer(32000, 48000);
+		reset(resampler, buffer);
 
 		int result = resample(resampler, buffer);
 
 		assertEquals(buffer.nSamplesOut, result);
 	}
 
+	private static void reset(AudioResampler resampler, SampleBuffer buffer) {
+		resampler.reset(buffer.sampleRateIn, buffer.sampleRateOut, 1);
+	}
+
 	private static int resample(AudioResampler resampler, SampleBuffer buffer) {
 		return resampler.resample(buffer.src, buffer.nSamplesIn, buffer.dst);
 	}
@@ -78,6 +110,8 @@ private static class SampleBuffer {
 
 		final int bytesPerFrame = 2;
 
+		final int channels;
+
 		final int sampleRateIn;
 		final int sampleRateOut;
 
@@ -91,12 +125,13 @@ private static class SampleBuffer {
 		byte[] dst;
 
 
-		SampleBuffer(int sampleRateIn, int sampleRateOut) {
+		SampleBuffer(int sampleRateIn, int sampleRateOut, int channels) {
+			this.channels = channels;
 			this.sampleRateIn = sampleRateIn;
 			this.sampleRateOut = sampleRateOut;
 
-			nSamplesIn = sampleRateIn / 100; // 10 ms frame
-			nSamplesOut = sampleRateOut / 100;
+			nSamplesIn = sampleRateIn / 100 * channels; // 10 ms frame
+			nSamplesOut = sampleRateOut / 100 * channels;
 			frameSizeIn = nSamplesIn * bytesPerFrame;
 			frameSizeOut = nSamplesOut * bytesPerFrame;