Initial commit

COPYING

@@ -0,0 +1,28 @@
+Copyright (c) 2023, Yann Weber
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- Neither the name of the Xiph.Org Foundation nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,38 @@
+# pyrnnoise
+
+Python wrapper for [Xiph.org rnnoise](https://gitlab.xiph.org/xiph/rnnoise)
+
+## Dependencies
+
+### librnnoise
+
+```
+git clone 'https://gitlab.xiph.org/xiph/rnnoise/-/tree/master'
+cd rnnoise
+./autogen.sh
+./configure
+make
+sudo make install
+```
+
+### Build dependencies
+
+- setuptools
+- build
+- wheel
+
+## Building
+
+`python3 -m build`
+
+## Run tests
+
+`bash test.sh`
+
+## Installing
+
+`pip install dist/pyrnnoise*.whl`
+
+## Examples
+
+See `demo_iter.py` and `demo.py` or run `python3 -c 'import rnnoise; help(rnnoise)'`.

demo.py

@@ -0,0 +1,22 @@
+import rnnoise
+
+import sys
+import wave
+
+rnn = rnnoise.RNNoise()
+
+with wave.open(sys.argv[1], 'rb') as infp:
+    with wave.open(sys.argv[2], 'wb') as outfp:
+        outfp.setparams(infp.getparams())
+        buf = b''
+        for i in range(infp.getnframes()):
+            dataframe = infp.readframes(10)
+            buf += dataframe
+            while len(buf) >= (rnn.frame_size*2):
+                res = rnn.process_frame(buf[:rnn.frame_size*2])
+                outfp.writeframes(res)
+                buf = buf[rnn.frame_size*2:]
+        if len(buf):
+            lenbuf = len(buf)
+            buf += bytes(rnn.frame_size*2 - lenbuf)
+            outfp.writeframes(rnn.process_frame(buf)[:lenbuf])

demo_iter.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+import sys
+import wave
+
+import rnnoise
+
+def in_iter(fname, chunk_sz=4096):
+    with wave.open(fname, 'rb') as infp:
+        while True:
+            data = infp.readframes(chunk_sz)
+            if len(data) == 0:
+                return
+            yield data
+
+rnn = rnnoise.RNNoise()
+
+with wave.open(sys.argv[1], 'rb') as infp:
+    params = infp.getparams()
+
+with wave.open(sys.argv[2], 'wb') as outfp:
+    outfp.setparams(params)
+
+    for frames in rnn.iter_on(in_iter(sys.argv[1])):
+        outfp.writeframes(frames)

demo_orig.py

@@ -0,0 +1,30 @@
+import os
+import sys
+import tempfile
+import wave
+
+wavein=sys.argv[1]
+waveout=sys.argv[2]
+
+datain=tempfile.NamedTemporaryFile()
+dataout=tempfile.NamedTemporaryFile()
+
+with tempfile.NamedTemporaryFile() as dataoutfp:
+    with tempfile.NamedTemporaryFile()as datainfp:
+        datain_name = datainfp.name
+        dataout_name = dataoutfp.name
+        with wave.open(wavein, 'rb') as infp:
+            params=infp.getparams()
+            while True:
+                data = infp.readframes(2048)
+                if not len(data):
+                    break
+                datainfp.write(data)
+        datainfp.flush()
+        cmd = "./rnnoise_demo %r %r" % (datain_name, dataout_name)
+        os.system(cmd)
+
+        with wave.open(waveout, 'wb') as outfp:
+            params=outfp.setparams(params)
+            outfp.writeframes(dataoutfp.read())
+

pyrnnoise.c

@@ -0,0 +1,394 @@
+/* Copyright (c) 2023 Yann Weber */
+/*
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   - Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+   - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <errno.h>
+#include <limits.h>
+#include <poll.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include <rnnoise.h>
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include "structmember.h"
+
+/**The number of samples processed by RNNoise.process_frame()
+ * @note There is two samples per frame
+ * @note Initialized by PyInit_rnnoise module initialization function
+ */
+static int frame_size;
+
+/**@brief Represent a RNNoise python object */
+typedef struct
+{
+	PyObject_VAR_HEAD;
+	/** The RNNoise structure */
+	DenoiseState *st;
+	/** Read only attribute on rnnoise frame size
+	 * @note The frame size is in sample (2 bytes per sample)
+	 */
+	int frame_size;
+
+	/** When iterating use this iterator as source */
+	PyObject *in_iter;
+	/** Previous partially processed buffer */
+	PyObject *prev_buf_obj;
+	/** Pointer on the part of the buffer left to copy */
+	char *prev_buf;
+	/** Size in bytes of the buffer left to copy */
+	Py_ssize_t left_in_buf;
+} PyRNNoise_t;
+
+/**@brief RNNoise.__new__ */
+PyObject* pyrnnoise_new(PyTypeObject *subtype, PyObject *args, PyObject* kwds)
+{
+	PyObject *ret = PyType_GenericNew(subtype, args, kwds);
+	if(PyErr_Occurred())
+	{
+		return NULL;
+	}
+	return ret;
+}
+
+/**@brief RNNoise.__init__
+ * @todo implement model support in argument
+ */
+int pyrnnoise_init(PyObject *_self, PyObject *args, PyObject *kwds)
+{
+	PyRNNoise_t *self = (PyRNNoise_t*)_self;
+	self->st = rnnoise_create(NULL); // TODO implement model instead of NULL
+	self->frame_size = frame_size;
+	self->in_iter = NULL;
+	self->prev_buf_obj = NULL;
+	return 0;
+}
+
+/** @brief RNNoise.__del__ */
+void pyrnnoise_del(PyObject *_self)
+{
+	PyRNNoise_t *self = (PyRNNoise_t*)_self;
+	rnnoise_destroy(self->st);
+	if(self->prev_buf_obj) { Py_DECREF(self->prev_buf_obj); }
+	if(self->in_iter) { Py_DECREF(self->in_iter); }
+	return;
+}
+
+/**@brief RNNoise.process_frame(frame:bytes) -> bytes method
+ * @param PyObject* Current RNNoise instance
+ * @param PyObject** List of arguments (1 expected)
+ * @param Py_ssize_t Number of arguments given
+ * @return A PyObject* with processed frame (bytes) or NULL (on error)
+ */
+PyObject *pyrnnoise_process_frame(PyObject *_self, PyObject *const *args, Py_ssize_t nargs)
+{
+	PyRNNoise_t *self = (PyRNNoise_t*)_self;
+	if(nargs != 1)
+	{
+		PyErr_SetString(PyExc_ValueError, "Expected one bytes argument");
+		return NULL;
+	}
+	if(!PyBytes_Check(args[0]))
+	{
+		PyErr_SetString(PyExc_TypeError, "Excpected argument to be bytes");
+		return NULL;
+	}
+	Py_ssize_t sz = PyBytes_Size(args[0]);
+	if(sz != 2*self->frame_size)
+	{
+		PyErr_Format(PyExc_ValueError,
+				"Expected %ld bytes but got %ld",
+				self->frame_size*2, sz);
+		return NULL;
+	}
+
+	short *data = (short*)PyBytes_AsString(args[0]);
+	short out[self->frame_size];
+	float frame[self->frame_size];
+
+	for(int i=0; i<self->frame_size; i++) { frame[i] = data[i]; }
+	rnnoise_process_frame(self->st, frame, frame);
+
+	for(int i=0; i<self->frame_size; i++) { out[i] = frame[i]; }
+	PyObject *ret = PyBytes_FromStringAndSize((char*)out, self->frame_size*2);
+	return ret;
+}
+
+/**@brief pyrnnoise_iternext() utility function
+ *
+ * Fill the short buffer given in argument with previous buffer if set
+ * or with next buffer(s) in iterator.
+ *
+ * @param PyRNNoise_t self
+ * @param short* The buffer (with @ref frame_size samples)
+ * @return The number of bytes read. Should be @ref frame_size * 2,
+ * may be less than this value a last time before falling to 0 on
+ * iterator exhauste
+ */
+static ssize_t _iter_frame(PyRNNoise_t *self, short *buf)
+{
+	const ssize_t to_read = frame_size * 2;
+
+	PyObject *inbuf;
+	ssize_t readed;
+
+	if(self->prev_buf_obj)
+	{
+		Py_ssize_t from_buf = self->left_in_buf > to_read?\
+				      to_read:self->left_in_buf;
+		memcpy(buf, self->prev_buf, from_buf);
+		readed = from_buf;
+		if(from_buf == self->left_in_buf)
+		{
+			Py_DECREF(self->prev_buf_obj);
+			self->prev_buf_obj = NULL;
+			self->prev_buf = NULL;
+		}
+		else
+		{
+			self->left_in_buf -= from_buf;
+			self->prev_buf = &self->prev_buf[from_buf];
+		}
+	}
+	else
+	{
+		readed = 0;
+	}
+
+	while(readed < to_read)
+	{
+		const ssize_t left = to_read - readed;
+		if(!(inbuf = PyIter_Next(self->in_iter)))
+		{
+			break;
+		}
+		if(!PyBytes_Check(inbuf))
+		{
+			PyErr_SetString(PyExc_TypeError, "Expected input iterator to return bytes");
+			return -1;
+		}
+		Py_ssize_t inbuf_sz = PyBytes_Size(inbuf);
+		char *inbuf_ptr = PyBytes_AsString(inbuf);
+
+		memcpy((char*)buf+readed, inbuf_ptr,
+				inbuf_sz > left?left:inbuf_sz);
+		readed += inbuf_sz > left?left:inbuf_sz;
+		if(inbuf_sz > left)
+		{
+			self->prev_buf = &inbuf_ptr[left];
+			self->prev_buf_obj = inbuf;
+			self->left_in_buf = inbuf_sz - left;
+		}
+		else
+		{
+			Py_DECREF(inbuf);
+		}
+	}
+
+	return readed;
+}
+
+/**@brief The tp_iternext method of RNNoise
+ * @return Next processed frame from input_iterator (bytes instance)
+ */
+PyObject *pyrnnoise_iternext(PyObject *_self)
+{
+	PyRNNoise_t *self = (PyRNNoise_t*)_self;
+	if(!self->in_iter)
+	{
+		PyErr_SetString(PyExc_StopIteration, "No input use the iter_on class method");
+		return NULL;
+	}
+
+	float frame[frame_size];
+	short res[frame_size];
+
+	ssize_t readed = _iter_frame(self, res);
+	if(readed < 0)
+	{
+		return NULL;
+	}
+	else if(!readed)
+	{
+		Py_DECREF(self->in_iter);
+		self->in_iter = NULL;
+		PyErr_SetString(PyExc_StopIteration, "Input exhausted");
+		return NULL;
+	}
+	else if(readed  % 2)
+	{
+		PyErr_SetString(PyExc_ValueError,
+			"Iterator exhausted on invalid odd bytes count for as single channel 16bits PCM input");
+		return NULL;
+	}
+
+	for(int i=0; i<readed/2; i++) { frame[i] = res[i]; }
+	for(int i=readed/2; i<frame_size; i++) { frame[i] = 0; }
+
+	rnnoise_process_frame(self->st, frame, frame);
+
+	for(int i=0; i<frame_size; i++) { res[i] = frame[i]; }
+	return PyBytes_FromStringAndSize((char*)res, readed);
+}
+
+/**@brief RNNoise.iter_on(iterator) method
+ * @return A new reference on self iterator
+ */
+PyObject* pyrnnoise_iter_on(PyObject *_self, PyObject *iterator)
+{
+	PyRNNoise_t *self = (PyRNNoise_t*)_self;
+	if(!PyIter_Check(iterator))
+	{
+		PyErr_SetString(PyExc_TypeError, "Expected an iterator");
+		return NULL;
+	}
+	if(self->in_iter)
+	{
+		Py_DECREF(self->in_iter);
+	}
+	Py_INCREF(iterator);
+	self->in_iter = iterator;
+	return PyObject_GetIter(_self);
+}
+
+
+/*
+ *	RNNoise class definition
+ */
+
+/**@brief RNNoise methods list */
+PyMethodDef RNNoise_methods[] = {
+	{"process_frame", (PyCFunction)pyrnnoise_process_frame, METH_FASTCALL,
+		"Process a frame of data\n\
+Arguments :\n\
+    - frame : bytes representing a 16bit PCM audio signal (len must be \n\
+              rnnoise.frame_size() * rnnoise.bytes_per_sample())\n\
+Returns : The processed frame bytes"},
+	{"iter_on", (PyCFunction)pyrnnoise_iter_on, METH_O,
+		"Consume an iterator and iterate on processed frames\n\
+Arguments :\n\
+    - iterator : an iterator on PCM 16bit bytes\n\
+Returns : an iterator on processed frames"},
+	{ NULL } // Sentinel
+};
+
+/**@brief RNNoise attributes list */
+PyMemberDef RNNoise_members[] = {
+	{"frame_size", T_INT, offsetof(PyRNNoise_t, frame_size), READONLY,
+	 "The number of sample processed by RNNoise.process_frame()"},
+	{NULL} // Sentinel
+};
+
+/**@brief RNNoise type object */
+PyTypeObject RNNoiseType = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	.tp_name = "rnnoise.RNNoise",
+	.tp_doc= "Xiph RNNoise voice noise reduction wrapper",
+	.tp_basicsize = sizeof(PyRNNoise_t),
+	.tp_del = pyrnnoise_del,
+	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+	.tp_methods = RNNoise_methods,
+	.tp_members = RNNoise_members,
+	.tp_iter = PyObject_SelfIter,
+	.tp_iternext = pyrnnoise_iternext,
+	.tp_init = pyrnnoise_init,
+	.tp_new = pyrnnoise_new,
+};
+
+
+/*
+ *	rnnoise module definition
+ */
+
+/**@brief Module's method without argument, returning the number
+ * of samples processed by RNNoise.process_frame()
+ */
+PyObject* pyrnnoise_frame_size(PyObject *mod, PyObject *nullval)
+{
+	return PyLong_FromLong(frame_size);
+}
+
+
+/**@brief Module's method without argument, returning the number of
+ * bytes per sample
+ */
+PyObject* pyrnnoise_bytes_per_sample(PyObject *mod, PyObject *nullval)
+{
+	return PyLong_FromLong(2);
+}
+
+/**@brief rnnoise module's methods */
+PyMethodDef pyrnnoise_methods[] = {
+	{"frame_size", (PyCFunction)pyrnnoise_frame_size, METH_NOARGS,
+		"Return the number of samples processed by RNNoise.process_frame() method"},
+	{"bytes_per_sample", (PyCFunction)pyrnnoise_bytes_per_sample, METH_NOARGS,
+		"Return the number of bytes per sample"},
+	{NULL}
+};
+
+/**@brief rnnoise module object */
+PyModuleDef pyrnnoise_module = {
+	PyModuleDef_HEAD_INIT,
+	.m_name = "rnnoise",
+	.m_doc = "Python bindings to xiph rnnoise",
+	.m_size = -1,
+	.m_methods = pyrnnoise_methods,
+	.m_slots = NULL,
+	.m_traverse = NULL,
+	.m_clear = NULL,
+	.m_free = NULL,
+};
+
+/**@brief Module initialisation function (kind of main or __init__) */
+PyMODINIT_FUNC
+PyInit_rnnoise(void)
+{
+	PyObject *mod;
+
+	mod = PyModule_Create(&pyrnnoise_module);
+	if(mod == NULL) { return NULL; }
+
+	if(PyType_Ready(&RNNoiseType) < 0)
+	{
+		goto fail_rnnoisetype_ready;
+	}
+	Py_INCREF(&RNNoiseType);
+	if(PyModule_AddObject(mod, "RNNoise", (PyObject*)&RNNoiseType) < 0)
+	{
+		goto fail_rnnoisetype_add;
+	}
+
+	frame_size = rnnoise_get_frame_size();
+
+	return mod;
+
+fail_rnnoisetype_add:
+	Py_DECREF(&RNNoiseType);
+fail_rnnoisetype_ready:
+	Py_DECREF(mod);
+	return NULL;
+}
+

rnnoise_demo.c

@@ -0,0 +1,63 @@
+/* Copyright (c) 2018 Gregor Richards
+ * Copyright (c) 2017 Mozilla
+ * Copyright (c) 2023 Yann Weber */
+/*
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   - Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+   - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <rnnoise.h>
+
+#define FRAME_SIZE 480
+
+int main(int argc, char **argv) {
+  int i;
+  int first = 1;
+  float x[FRAME_SIZE];
+  FILE *f1, *fout;
+  DenoiseState *st;
+  st = rnnoise_create(NULL);
+  if (argc!=3) {
+    fprintf(stderr, "usage: %s <noisy speech> <output denoised>\n", argv[0]);
+    return 1;
+  }
+  f1 = fopen(argv[1], "rb");
+  fout = fopen(argv[2], "wb");
+  while (1) {
+    short tmp[FRAME_SIZE];
+    size_t readed = fread(tmp, sizeof(short), FRAME_SIZE, f1);
+    bzero(x, sizeof(x));
+    for (i=0;i<readed;i++) x[i] = tmp[i];
+    rnnoise_process_frame(st, x, x);
+    for (i=0;i<readed;i++) tmp[i] = x[i];
+    fwrite(tmp, sizeof(short), readed, fout);
+    if (feof(f1)) break;
+    first = 0;
+  }
+  rnnoise_destroy(st);
+  fclose(f1);
+  fclose(fout);
+  return 0;
+}

samples/LICENCE

@@ -0,0 +1,24 @@
+Base Audio Libre De Mots Français
+-----------------------------------
+
+La "Base Audio Libre De Mots Français" est une base de données 
+d'enregistrements sonores d'une liste d'environ 12000 mots ou 
+expressions en langue française. 
+
+Le contenu de cette base de données est distribué librement sous 
+licence "Creative Commons Paternité 2.0". Vous trouverez
+plus d'informations sur cette licence sur :
+
+	http://creativecommons.org/licenses/by/2.0/fr/
+
+L'ensemble de cette base audio est disponible à l'adresse suivante :
+
+ 	http://shtooka.net/audio-base/fra/
+
+L'enregistrement audio a été réalisé à l'aide du programme "Shtooka
+Recorder" distribué sous licence GPL et disponible à l'adresse 
+suivante :
+
+	http://shtooka.net/soft/shtooka_recorder/
+
+"Base Audio Libre De Mots Français" - Copyright (c) 2006-2007 Vion Nicolas

samples/README

@@ -0,0 +1,3 @@
+Sample generated from shootka.net (see LICENCE file) words using :
+
+ffmpeg -i input.flac -f wav -acodec pcm_s16le -ac 1 -ar 16000 output.wav

setup.py

@@ -0,0 +1,21 @@
+from setuptools import setup, Extension
+
+setup(name = 'pyrnnoise',
+	version = '0.1',
+        test_suite='test_pyrnnoise',
+        description="Python wrapper for Xiph.org rnnoise algorithm implementation",
+        long_description="file: README.md",
+        author = "Yann Weber",
+        author_email = "pyrnnoise@yannweb.net",
+        url = "https://git.yannweb.net/yannweb/pyrnnoise",
+        license = "BSD-3-Clause",
+        keywords = ["rnnoise", "noise reduction", "audio processing"],
+	ext_modules = [
+		Extension(
+                        name="rnnoise",
+			libraries=['rnnoise'],
+                        sources=["pyrnnoise.c"],
+                        extra_compile_args=["-Wall", "-Werror"],
+		)
+	]
+);

test.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+
+INFILE=samples/bonjour.wav
+
+hr() {
+ echo "$(printf "%0.s+" $(seq 80))"
+}
+
+hr
+echo "Running test_pyrnnoise.py"
+hr
+/usr/bin/env python3 test_pyrnnoise.py -vv || exit 1
+
+out_orig=$(mktemp -t out_XXXXXXXX.wav)
+out_1=$(mktemp -t out_XXXXXXXX.wav)
+out_2=$(mktemp -t out_XXXXXXXX.wav)
+
+clean_exit() {
+	rm $out_orig $out_1 $out_2
+	exit $1
+}
+
+
+hr
+echo "Functionnal test of rnnoise module against Xiph demo program"
+hr
+
+if [ ! -f 'rnnoise_demo' ]
+then
+	echo "Compiling rnnoise_demo"
+	gcc -o rnnoise_demo rnnoise_demo.c -lrnnoise || clean_exit 12
+fi
+echo "Running Xiph demo programm"
+python3 demo_orig.py "$INFILE" "$out_orig" || clean_exit 2
+
+echo "Running demo.py"
+python3 demo.py "$INFILE" "$out_2" || clean_exit 3
+if diff -rupN "$out_orig" "$out_2"
+then
+	echo "demo.py [OK]"
+else
+	echo "demo.py  [fail]"
+fi
+
+
+echo "Running demo_iter.py"
+python3 demo_iter.py "$INFILE" "$out_1" || clean_exit 4
+if diff -rupN "$out_orig" "$out_1"
+then
+	echo "demo_iter.py [OK]"
+else
+	echo "demo_iter.py  [fail]"
+fi
+
+clean_exit 0

test_pyrnnoise.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+
+import unittest
+import wave
+
+import rnnoise
+
+INPUT="samples/bonjour.wav"
+
+class TestRNNoiseModule(unittest.TestCase):
+
+    def test_frame_info(self):
+        """ Check rnnoise module's methods """
+        fsize = rnnoise.frame_size()
+        bps = rnnoise.bytes_per_sample()
+        self.assertTrue(isinstance(fsize, int))
+        self.assertTrue(isinstance(bps, int))
+        self.assertTrue(fsize > 0)
+        self.assertTrue(bps > 0)
+
+class TestRNNoise(unittest.TestCase):
+
+    def test_process_frame(self):
+        rnn = rnnoise.RNNoise()
+        with wave.open(INPUT, 'rb') as fp:
+            frame = fp.readframes(rnn.frame_size)
+            res = rnn.process_frame(frame)
+            self.assertTrue(isinstance(res, bytes))
+            self.assertEqual(len(res), rnn.frame_size*rnnoise.bytes_per_sample())
+
+    def test_process_frame_invalid(self):
+        rnn = rnnoise.RNNoise()
+        bad_frames = (
+                bytes(rnn.frame_size),
+                bytes((rnn.frame_size-1)*rnnoise.bytes_per_sample()),
+                bytes((rnn.frame_size+1)*rnnoise.bytes_per_sample()),
+                bytes((rnn.frame_size*rnnoise.bytes_per_sample())-1),
+                bytes((rnn.frame_size*rnnoise.bytes_per_sample())+1),
+        )
+        for bad_frame in bad_frames:
+            msg = "Testing with a bad frame"
+            with self.subTest(msg, frame_len=len(bad_frame)) as st:
+                with self.assertRaises(ValueError):
+                    rnn.process_frame(bad_frame)
+
+class TestRNNoiseIterator(unittest.TestCase):
+    """ Testing RNNoise.iter_on() method """
+
+    def setUp(self):
+        rnn = rnnoise.RNNoise()
+        self.orig = bytes()
+        with wave.open(INPUT, 'rb') as fp:
+            needed = rnn.frame_size * rnnoise.bytes_per_sample()
+            while True:
+                frame = fp.readframes(rnn.frame_size)
+                if len(frame) == 0:
+                    break
+                if len(frame) < needed:
+                    frame += bytes(needed-len(frame))
+                newframe = rnn.process_frame(frame)
+                newframe =  newframe[:len(frame)]
+                self.orig += newframe
+
+    @staticmethod
+    def in_iter(fsize):
+        """ fsize is a callable returning expected frame size """
+        with wave.open(INPUT, 'rb') as fp:
+            while True:
+                frame = fp.readframes(fsize())
+                if len(frame):
+                    yield frame
+                else:
+                    raise StopIteration()
+
+    def test_iter_big_samples(self):
+        """ Testing with iterator on 4096 samples """
+        rnn = rnnoise.RNNoise()
+        result = bytes()
+        for frame in rnn.iter_on(self.in_iter(lambda: 4096)):
+            result += frame
+        self.assertEqual(result, self.orig)
+
+    def test_byte_sample(self):
+        """ Testing with iterator on 1 byte """
+        rnn = rnnoise.RNNoise()
+        def _cust_iter():
+            for sample in self.in_iter(lambda: 1):
+                yield sample[:1]
+                yield sample[1:]
+
+        result = bytes()
+        for frame in rnn.iter_on(_cust_iter()):
+            result += frame
+        self.assertEqual(result, self.orig)
+
+    def test_invalid(self):
+        """ Testing with invalid iterator on odd number of bytes """
+        rnn = rnnoise.RNNoise()
+        def _cust_iter():
+            data = self.in_iter(lambda: 4096)
+            yield next(data)[:-1]
+            for sample in data:
+                yield sample
+
+        with self.assertRaises(ValueError):
+            result = bytes()
+            for frame in rnn.iter_on(_cust_iter()):
+                result += frame
+
+if __name__ == '__main__':
+    unittest.main()