AudioResampler utility class which can be used for sampling rate conversion

Author: devopvoid

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

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2021 Alex Andres
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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"
+
+JNIEXPORT void JNICALL Java_dev_onvoid_webrtc_media_audio_AudioResampler_dispose
+(JNIEnv * env, jobject caller)
+{
+	webrtc::PushSincResampler * resampler = GetHandle<webrtc::PushSincResampler>(env, caller);
+	CHECK_HANDLE(resampler);
+
+	delete resampler;
+
+	SetHandle<std::nullptr_t>(env, caller, nullptr);
+}
+
+JNIEXPORT void JNICALL Java_dev_onvoid_webrtc_media_audio_AudioResampler_initialize
+(JNIEnv * env, jobject caller, jint sourceFrames, jint targetFrames)
+{
+	webrtc::PushSincResampler * resampler = new webrtc::PushSincResampler(sourceFrames, targetFrames);
+
+	SetHandle(env, caller, resampler);
+}
+
+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);
+	CHECK_HANDLEV(resampler, -1);
+
+	jboolean isDstCopy = JNI_FALSE;
+
+	jbyte * srcPtr = env->GetByteArrayElements(samplesIn, nullptr);
+	jbyte * dstPtr = env->GetByteArrayElements(samplesOut, &isDstCopy);
+
+	size_t result = resampler->Resample(reinterpret_cast<int16_t *>(srcPtr), nSamplesIn, reinterpret_cast<int16_t *>(dstPtr), maxSamplesOut);
+
+	if (isDstCopy == JNI_TRUE) {
+		jsize dstLength = env->GetArrayLength(samplesOut);
+
+		env->SetByteArrayRegion(samplesOut, 0, dstLength, dstPtr);
+	}
+
+	env->ReleaseByteArrayElements(samplesIn, srcPtr, JNI_ABORT);
+	env->ReleaseByteArrayElements(samplesOut, dstPtr, JNI_ABORT);
+
+	return static_cast<jint>(result);
+}

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

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2021 Alex Andres
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dev.onvoid.webrtc.media.audio;
+
+import static java.util.Objects.requireNonNull;
+
+import dev.onvoid.webrtc.internal.DisposableNativeObject;
+
+/**
+ * Audio sampling rate converter. This resampler operates on audio frames of 10
+ * milliseconds.
+ *
+ * @author Alex Andres
+ */
+public class AudioResampler extends DisposableNativeObject {
+
+	private final int sourceFrames;
+
+	private final int targetFrames;
+
+
+	/**
+	 * 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.
+	 */
+	public AudioResampler(int sourceSampleRate, int targetSampleRate) {
+		// 10 ms frames
+		sourceFrames = sourceSampleRate / 100;
+		targetFrames = targetSampleRate / 100;
+
+		initialize(sourceFrames, targetFrames);
+	}
+
+	/**
+	 * Converts the input samples into the output samples with the sampling
+	 * frequency specified in the constructor. The audio input must be of the
+	 * length of 10 milliseconds. Accordingly, the output has the length of 10
+	 * milliseconds.
+	 *
+	 * @param samplesIn  The audio samples to convert.
+	 * @param nSamplesIn The number of audio samples to consider from {@code
+	 *                   samplesIn}.
+	 * @param samplesOut The converted audio samples.
+	 *
+	 * @return The number of converted audio samples.
+	 */
+	public int resample(byte[] samplesIn, int nSamplesIn, byte[] samplesOut) {
+		requireNonNull(samplesIn);
+		requireNonNull(samplesOut);
+
+		final int arraySamplesIn = samplesIn.length / 2;
+		final int maxSamplesOut = samplesOut.length / 2;
+
+		nSamplesIn = Math.min(arraySamplesIn, Math.max(0, nSamplesIn));
+
+		if (targetFrames > maxSamplesOut) {
+			throw new IllegalArgumentException("Insufficient samples output length");
+		}
+
+		return resampleInternal(samplesIn, nSamplesIn, samplesOut, maxSamplesOut);
+	}
+
+	@Override
+	public native void dispose();
+
+	private native void initialize(int sourceFrames, int targetFrames);
+
+	private native int resampleInternal(byte[] samplesIn, int nSamplesIn,
+			byte[] samplesOut, int maxSamplesOut);
+
+}

webrtc/src/test/java/dev/onvoid/webrtc/media/audio/AudioResamplerTest.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2019 Alex Andres
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dev.onvoid.webrtc.media.audio;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import dev.onvoid.webrtc.TestBase;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+class AudioResamplerTest extends TestBase {
+
+	private AudioResampler resampler;
+
+
+	@AfterEach
+	void dispose() {
+		resampler.dispose();
+	}
+
+	@Test
+	void targetBufferUnderflow() {
+		resampler = new AudioResampler(48000, 24000);
+
+		SampleBuffer buffer = new SampleBuffer(48000, 24000);
+		buffer.setTargetBufferSize(buffer.frameSizeOut / 2);
+
+		assertThrows(IllegalArgumentException.class, () -> {
+			resample(resampler, buffer);
+		});
+	}
+
+	@Test
+	void downSample() {
+		resampler = new AudioResampler(48000, 44100);
+
+		SampleBuffer buffer = new SampleBuffer(48000, 44100);
+
+		int result = resample(resampler, buffer);
+
+		assertEquals(buffer.nSamplesOut, result);
+	}
+
+	@Test
+	void upSample() {
+		resampler = new AudioResampler(32000, 48000);
+
+		SampleBuffer buffer = new SampleBuffer(32000, 48000);
+
+		int result = resample(resampler, buffer);
+
+		assertEquals(buffer.nSamplesOut, result);
+	}
+
+	private static int resample(AudioResampler resampler, SampleBuffer buffer) {
+		return resampler.resample(buffer.src, buffer.nSamplesIn, buffer.dst);
+	}
+
+
+
+	private static class SampleBuffer {
+
+		final int bytesPerFrame = 2;
+
+		final int sampleRateIn;
+		final int sampleRateOut;
+
+		final int nSamplesIn;
+		final int nSamplesOut;
+
+		final int frameSizeIn;
+		final int frameSizeOut;
+
+		byte[] src;
+		byte[] dst;
+
+
+		SampleBuffer(int sampleRateIn, int sampleRateOut) {
+			this.sampleRateIn = sampleRateIn;
+			this.sampleRateOut = sampleRateOut;
+
+			nSamplesIn = sampleRateIn / 100; // 10 ms frame
+			nSamplesOut = sampleRateOut / 100;
+			frameSizeIn = nSamplesIn * bytesPerFrame;
+			frameSizeOut = nSamplesOut * bytesPerFrame;
+
+			src = new byte[frameSizeIn];
+			dst = new byte[frameSizeOut];
+		}
+
+		void setTargetBufferSize(int size) {
+			dst = new byte[size];
+		}
+	}
+}